ccdchat/public/traceur/BrowserSystem.js

(function(global) {
  'use strict';
  if (global.$traceurRuntime) {
    return;
  }
  function setupGlobals(global) {
    global.Reflect = global.Reflect || {};
    global.Reflect.global = global.Reflect.global || global;
  }
  setupGlobals(global);
  var typeOf = function(x) {
    return typeof x;
  };
  global.$traceurRuntime = {
    options: {},
    setupGlobals: setupGlobals,
    typeof: typeOf
  };
})(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this);
(function() {
  function buildFromEncodedParts(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {
    var out = [];
    if (opt_scheme) {
      out.push(opt_scheme, ':');
    }
    if (opt_domain) {
      out.push('//');
      if (opt_userInfo) {
        out.push(opt_userInfo, '@');
      }
      out.push(opt_domain);
      if (opt_port) {
        out.push(':', opt_port);
      }
    }
    if (opt_path) {
      out.push(opt_path);
    }
    if (opt_queryData) {
      out.push('?', opt_queryData);
    }
    if (opt_fragment) {
      out.push('#', opt_fragment);
    }
    return out.join('');
  }
  var splitRe = new RegExp('^' + '(?:' + '([^:/?#.]+)' + ':)?' + '(?://' + '(?:([^/?#]*)@)?' + '([\\w\\d\\-\\u0100-\\uffff.%]*)' + '(?::([0-9]+))?' + ')?' + '([^?#]+)?' + '(?:\\?([^#]*))?' + '(?:#(.*))?' + '$');
  var ComponentIndex = {
    SCHEME: 1,
    USER_INFO: 2,
    DOMAIN: 3,
    PORT: 4,
    PATH: 5,
    QUERY_DATA: 6,
    FRAGMENT: 7
  };
  function split(uri) {
    return (uri.match(splitRe));
  }
  function removeDotSegments(path) {
    if (path === '/')
      return '/';
    var leadingSlash = path[0] === '/' ? '/' : '';
    var trailingSlash = path.slice(-1) === '/' ? '/' : '';
    var segments = path.split('/');
    var out = [];
    var up = 0;
    for (var pos = 0; pos < segments.length; pos++) {
      var segment = segments[pos];
      switch (segment) {
        case '':
        case '.':
          break;
        case '..':
          if (out.length)
            out.pop();
          else
            up++;
          break;
        default:
          out.push(segment);
      }
    }
    if (!leadingSlash) {
      while (up-- > 0) {
        out.unshift('..');
      }
      if (out.length === 0)
        out.push('.');
    }
    return leadingSlash + out.join('/') + trailingSlash;
  }
  function joinAndCanonicalizePath(parts) {
    var path = parts[ComponentIndex.PATH] || '';
    path = removeDotSegments(path);
    parts[ComponentIndex.PATH] = path;
    return buildFromEncodedParts(parts[ComponentIndex.SCHEME], parts[ComponentIndex.USER_INFO], parts[ComponentIndex.DOMAIN], parts[ComponentIndex.PORT], parts[ComponentIndex.PATH], parts[ComponentIndex.QUERY_DATA], parts[ComponentIndex.FRAGMENT]);
  }
  function canonicalizeUrl(url) {
    var parts = split(url);
    return joinAndCanonicalizePath(parts);
  }
  function resolveUrl(base, url) {
    var parts = split(url);
    var baseParts = split(base);
    if (parts[ComponentIndex.SCHEME]) {
      return joinAndCanonicalizePath(parts);
    } else {
      parts[ComponentIndex.SCHEME] = baseParts[ComponentIndex.SCHEME];
    }
    for (var i = ComponentIndex.SCHEME; i <= ComponentIndex.PORT; i++) {
      if (!parts[i]) {
        parts[i] = baseParts[i];
      }
    }
    if (parts[ComponentIndex.PATH][0] == '/') {
      return joinAndCanonicalizePath(parts);
    }
    var path = baseParts[ComponentIndex.PATH];
    var index = path.lastIndexOf('/');
    path = path.slice(0, index + 1) + parts[ComponentIndex.PATH];
    parts[ComponentIndex.PATH] = path;
    return joinAndCanonicalizePath(parts);
  }
  function isAbsolute(name) {
    if (!name)
      return false;
    if (name[0] === '/')
      return true;
    var parts = split(name);
    if (parts[ComponentIndex.SCHEME])
      return true;
    return false;
  }
  $traceurRuntime.canonicalizeUrl = canonicalizeUrl;
  $traceurRuntime.isAbsolute = isAbsolute;
  $traceurRuntime.removeDotSegments = removeDotSegments;
  $traceurRuntime.resolveUrl = resolveUrl;
})();
(function(global) {
  'use strict';
  var $__3 = $traceurRuntime,
      canonicalizeUrl = $__3.canonicalizeUrl,
      resolveUrl = $__3.resolveUrl,
      isAbsolute = $__3.isAbsolute;
  var moduleInstantiators = Object.create(null);
  var baseURL;
  if (global.location && global.location.href)
    baseURL = resolveUrl(global.location.href, './');
  else
    baseURL = '';
  function UncoatedModuleEntry(url, uncoatedModule) {
    this.url = url;
    this.value_ = uncoatedModule;
  }
  function ModuleEvaluationError(erroneousModuleName, cause) {
    this.message = this.constructor.name + ': ' + this.stripCause(cause) + ' in ' + erroneousModuleName;
    if (!(cause instanceof ModuleEvaluationError) && cause.stack)
      this.stack = this.stripStack(cause.stack);
    else
      this.stack = '';
  }
  ModuleEvaluationError.prototype = Object.create(Error.prototype);
  ModuleEvaluationError.prototype.constructor = ModuleEvaluationError;
  ModuleEvaluationError.prototype.stripError = function(message) {
    return message.replace(/.*Error:/, this.constructor.name + ':');
  };
  ModuleEvaluationError.prototype.stripCause = function(cause) {
    if (!cause)
      return '';
    if (!cause.message)
      return cause + '';
    return this.stripError(cause.message);
  };
  ModuleEvaluationError.prototype.loadedBy = function(moduleName) {
    this.stack += '\n loaded by ' + moduleName;
  };
  ModuleEvaluationError.prototype.stripStack = function(causeStack) {
    var stack = [];
    causeStack.split('\n').some(function(frame) {
      if (/UncoatedModuleInstantiator/.test(frame))
        return true;
      stack.push(frame);
    });
    stack[0] = this.stripError(stack[0]);
    return stack.join('\n');
  };
  function beforeLines(lines, number) {
    var result = [];
    var first = number - 3;
    if (first < 0)
      first = 0;
    for (var i = first; i < number; i++) {
      result.push(lines[i]);
    }
    return result;
  }
  function afterLines(lines, number) {
    var last = number + 1;
    if (last > lines.length - 1)
      last = lines.length - 1;
    var result = [];
    for (var i = number; i <= last; i++) {
      result.push(lines[i]);
    }
    return result;
  }
  function columnSpacing(columns) {
    var result = '';
    for (var i = 0; i < columns - 1; i++) {
      result += '-';
    }
    return result;
  }
  function UncoatedModuleInstantiator(url, func) {
    UncoatedModuleEntry.call(this, url, null);
    this.func = func;
  }
  UncoatedModuleInstantiator.prototype = Object.create(UncoatedModuleEntry.prototype);
  UncoatedModuleInstantiator.prototype.getUncoatedModule = function() {
    var $__2 = this;
    if (this.value_)
      return this.value_;
    try {
      var relativeRequire;
      if (typeof $traceurRuntime !== undefined && $traceurRuntime.require) {
        relativeRequire = $traceurRuntime.require.bind(null, this.url);
      }
      return this.value_ = this.func.call(global, relativeRequire);
    } catch (ex) {
      if (ex instanceof ModuleEvaluationError) {
        ex.loadedBy(this.url);
        throw ex;
      }
      if (ex.stack) {
        var lines = this.func.toString().split('\n');
        var evaled = [];
        ex.stack.split('\n').some(function(frame, index) {
          if (frame.indexOf('UncoatedModuleInstantiator.getUncoatedModule') > 0)
            return true;
          var m = /(at\s[^\s]*\s).*>:(\d*):(\d*)\)/.exec(frame);
          if (m) {
            var line = parseInt(m[2], 10);
            evaled = evaled.concat(beforeLines(lines, line));
            if (index === 1) {
              evaled.push(columnSpacing(m[3]) + '^ ' + $__2.url);
            } else {
              evaled.push(columnSpacing(m[3]) + '^');
            }
            evaled = evaled.concat(afterLines(lines, line));
            evaled.push('= = = = = = = = =');
          } else {
            evaled.push(frame);
          }
        });
        ex.stack = evaled.join('\n');
      }
      throw new ModuleEvaluationError(this.url, ex);
    }
  };
  function getUncoatedModuleInstantiator(name) {
    if (!name)
      return;
    var url = ModuleStore.normalize(name);
    return moduleInstantiators[url];
  }
  ;
  var moduleInstances = Object.create(null);
  var liveModuleSentinel = {};
  function Module(uncoatedModule) {
    var isLive = arguments[1];
    var coatedModule = Object.create(null);
    Object.getOwnPropertyNames(uncoatedModule).forEach(function(name) {
      var getter,
          value;
      if (isLive === liveModuleSentinel) {
        var descr = Object.getOwnPropertyDescriptor(uncoatedModule, name);
        if (descr.get)
          getter = descr.get;
      }
      if (!getter) {
        value = uncoatedModule[name];
        getter = function() {
          return value;
        };
      }
      Object.defineProperty(coatedModule, name, {
        get: getter,
        enumerable: true
      });
    });
    Object.preventExtensions(coatedModule);
    return coatedModule;
  }
  var ModuleStore = {
    normalize: function(name, refererName, refererAddress) {
      if (typeof name !== 'string')
        throw new TypeError('module name must be a string, not ' + typeof name);
      if (isAbsolute(name))
        return canonicalizeUrl(name);
      if (/[^\.]\/\.\.\//.test(name)) {
        throw new Error('module name embeds /../: ' + name);
      }
      if (name[0] === '.' && refererName)
        return resolveUrl(refererName, name);
      return canonicalizeUrl(name);
    },
    get: function(normalizedName) {
      var m = getUncoatedModuleInstantiator(normalizedName);
      if (!m)
        return undefined;
      var moduleInstance = moduleInstances[m.url];
      if (moduleInstance)
        return moduleInstance;
      moduleInstance = Module(m.getUncoatedModule(), liveModuleSentinel);
      return moduleInstances[m.url] = moduleInstance;
    },
    set: function(normalizedName, module) {
      normalizedName = String(normalizedName);
      moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, function() {
        return module;
      });
      moduleInstances[normalizedName] = module;
    },
    get baseURL() {
      return baseURL;
    },
    set baseURL(v) {
      baseURL = String(v);
    },
    registerModule: function(name, deps, func) {
      var normalizedName = ModuleStore.normalize(name);
      if (moduleInstantiators[normalizedName])
        throw new Error('duplicate module named ' + normalizedName);
      moduleInstantiators[normalizedName] = new UncoatedModuleInstantiator(normalizedName, func);
    },
    bundleStore: Object.create(null),
    register: function(name, deps, func) {
      if (!deps || !deps.length && !func.length) {
        this.registerModule(name, deps, func);
      } else {
        this.bundleStore[name] = {
          deps: deps,
          execute: function() {
            var $__2 = arguments;
            var depMap = {};
            deps.forEach(function(dep, index) {
              return depMap[dep] = $__2[index];
            });
            var registryEntry = func.call(this, depMap);
            registryEntry.execute.call(this);
            return registryEntry.exports;
          }
        };
      }
    },
    getAnonymousModule: function(func) {
      return new Module(func(), liveModuleSentinel);
    }
  };
  var moduleStoreModule = new Module({ModuleStore: ModuleStore});
  ModuleStore.set('@traceur/src/runtime/ModuleStore.js', moduleStoreModule);
  var setupGlobals = $traceurRuntime.setupGlobals;
  $traceurRuntime.setupGlobals = function(global) {
    setupGlobals(global);
  };
  $traceurRuntime.ModuleStore = ModuleStore;
  $traceurRuntime.registerModule = ModuleStore.registerModule.bind(ModuleStore);
  $traceurRuntime.getModule = ModuleStore.get;
  $traceurRuntime.setModule = ModuleStore.set;
  $traceurRuntime.normalizeModuleName = ModuleStore.normalize;
})(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this);
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/new-unique-string.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/new-unique-string.js";
  var random = Math.random;
  var counter = Date.now() % 1e9;
  function newUniqueString() {
    return '__$' + (random() * 1e9 >>> 1) + '$' + ++counter + '$__';
  }
  return {get default() {
      return newUniqueString;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/has-native-symbols.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/has-native-symbols.js";
  var v = !!Object.getOwnPropertySymbols && typeof Symbol === 'function';
  function hasNativeSymbol() {
    return v;
  }
  return {get default() {
      return hasNativeSymbol;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/symbols.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/symbols.js";
  var newUniqueString = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../new-unique-string.js", "traceur@0.0.112/src/runtime/modules/symbols.js")).default;
  var hasNativeSymbol = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../has-native-symbols.js", "traceur@0.0.112/src/runtime/modules/symbols.js")).default;
  var $create = Object.create;
  var $defineProperty = Object.defineProperty;
  var $freeze = Object.freeze;
  var $getOwnPropertyNames = Object.getOwnPropertyNames;
  var $keys = Object.keys;
  var $TypeError = TypeError;
  function nonEnum(value) {
    return {
      configurable: true,
      enumerable: false,
      value: value,
      writable: true
    };
  }
  var symbolInternalProperty = newUniqueString();
  var symbolDescriptionProperty = newUniqueString();
  var symbolDataProperty = newUniqueString();
  var symbolValues = $create(null);
  var SymbolImpl = function Symbol(description) {
    var value = new SymbolValue(description);
    if (!(this instanceof SymbolImpl))
      return value;
    throw new $TypeError('Symbol cannot be new\'ed');
  };
  $defineProperty(SymbolImpl.prototype, 'constructor', nonEnum(SymbolImpl));
  $defineProperty(SymbolImpl.prototype, 'toString', nonEnum(function() {
    var symbolValue = this[symbolDataProperty];
    return symbolValue[symbolInternalProperty];
  }));
  $defineProperty(SymbolImpl.prototype, 'valueOf', nonEnum(function() {
    var symbolValue = this[symbolDataProperty];
    if (!symbolValue)
      throw $TypeError('Conversion from symbol to string');
    return symbolValue[symbolInternalProperty];
  }));
  function SymbolValue(description) {
    var key = newUniqueString();
    $defineProperty(this, symbolDataProperty, {value: this});
    $defineProperty(this, symbolInternalProperty, {value: key});
    $defineProperty(this, symbolDescriptionProperty, {value: description});
    $freeze(this);
    symbolValues[key] = this;
  }
  $defineProperty(SymbolValue.prototype, 'constructor', nonEnum(SymbolImpl));
  $defineProperty(SymbolValue.prototype, 'toString', {
    value: SymbolImpl.prototype.toString,
    enumerable: false
  });
  $defineProperty(SymbolValue.prototype, 'valueOf', {
    value: SymbolImpl.prototype.valueOf,
    enumerable: false
  });
  $freeze(SymbolValue.prototype);
  function isSymbolString(s) {
    return symbolValues[s];
  }
  function removeSymbolKeys(array) {
    var rv = [];
    for (var i = 0; i < array.length; i++) {
      if (!isSymbolString(array[i])) {
        rv.push(array[i]);
      }
    }
    return rv;
  }
  function getOwnPropertyNames(object) {
    return removeSymbolKeys($getOwnPropertyNames(object));
  }
  function keys(object) {
    return removeSymbolKeys($keys(object));
  }
  function getOwnPropertySymbols(object) {
    var rv = [];
    var names = $getOwnPropertyNames(object);
    for (var i = 0; i < names.length; i++) {
      var symbol = symbolValues[names[i]];
      if (symbol) {
        rv.push(symbol);
      }
    }
    return rv;
  }
  function polyfillSymbol(global) {
    var Object = global.Object;
    if (!hasNativeSymbol()) {
      global.Symbol = SymbolImpl;
      Object.getOwnPropertyNames = getOwnPropertyNames;
      Object.keys = keys;
      $defineProperty(Object, 'getOwnPropertySymbols', nonEnum(getOwnPropertySymbols));
    }
    if (!global.Symbol.iterator) {
      global.Symbol.iterator = global.Symbol('Symbol.iterator');
    }
    if (!global.Symbol.observer) {
      global.Symbol.observer = global.Symbol('Symbol.observer');
    }
  }
  var g = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : (void 0);
  polyfillSymbol(g);
  var typeOf = hasNativeSymbol() ? function(x) {
    return typeof x;
  } : function(x) {
    return x instanceof SymbolValue ? 'symbol' : typeof x;
  };
  return {get typeof() {
      return typeOf;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/typeof.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/typeof.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_symbols_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./symbols.js", "traceur@0.0.112/src/runtime/modules/typeof.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_symbols_46_js__.typeof;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/symbols.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/symbols.js";
  var t = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/typeof.js", "traceur@0.0.112/src/runtime/symbols.js")).default;
  $traceurRuntime.typeof = t;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/createClass.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/createClass.js";
  var $Object = Object;
  var $TypeError = TypeError;
  var $__1 = Object,
      create = $__1.create,
      defineProperties = $__1.defineProperties,
      defineProperty = $__1.defineProperty,
      getOwnPropertyDescriptor = $__1.getOwnPropertyDescriptor,
      getOwnPropertyNames = $__1.getOwnPropertyNames,
      getOwnPropertySymbols = $__1.getOwnPropertySymbols;
  function forEachPropertyKey(object, f) {
    getOwnPropertyNames(object).forEach(f);
    if (getOwnPropertySymbols) {
      getOwnPropertySymbols(object).forEach(f);
    }
  }
  function getDescriptors(object) {
    var descriptors = {};
    forEachPropertyKey(object, function(key) {
      descriptors[key] = getOwnPropertyDescriptor(object, key);
      descriptors[key].enumerable = false;
    });
    return descriptors;
  }
  var nonEnum = {enumerable: false};
  function makePropertiesNonEnumerable(object) {
    forEachPropertyKey(object, function(key) {
      defineProperty(object, key, nonEnum);
    });
  }
  function createClass(ctor, object, staticObject, superClass) {
    defineProperty(object, 'constructor', {
      value: ctor,
      configurable: true,
      enumerable: false,
      writable: true
    });
    if (arguments.length > 3) {
      if (typeof superClass === 'function')
        ctor.__proto__ = superClass;
      ctor.prototype = create(getProtoParent(superClass), getDescriptors(object));
    } else {
      makePropertiesNonEnumerable(object);
      ctor.prototype = object;
    }
    defineProperty(ctor, 'prototype', {
      configurable: false,
      writable: false
    });
    return defineProperties(ctor, getDescriptors(staticObject));
  }
  function getProtoParent(superClass) {
    if (typeof superClass === 'function') {
      var prototype = superClass.prototype;
      if ($Object(prototype) === prototype || prototype === null)
        return superClass.prototype;
      throw new $TypeError('super prototype must be an Object or null');
    }
    if (superClass === null)
      return null;
    throw new $TypeError(("Super expression must either be null or a function, not " + typeof superClass + "."));
  }
  return {get default() {
      return createClass;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/superConstructor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/superConstructor.js";
  function superConstructor(ctor) {
    return ctor.__proto__;
  }
  return {get default() {
      return superConstructor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/superDescriptor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/superDescriptor.js";
  var $__0 = Object,
      getOwnPropertyDescriptor = $__0.getOwnPropertyDescriptor,
      getPrototypeOf = $__0.getPrototypeOf;
  function superDescriptor(homeObject, name) {
    var proto = getPrototypeOf(homeObject);
    do {
      var result = getOwnPropertyDescriptor(proto, name);
      if (result)
        return result;
      proto = getPrototypeOf(proto);
    } while (proto);
    return undefined;
  }
  return {get default() {
      return superDescriptor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/superGet.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/superGet.js";
  var superDescriptor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./superDescriptor.js", "traceur@0.0.112/src/runtime/modules/superGet.js")).default;
  function superGet(self, homeObject, name) {
    var descriptor = superDescriptor(homeObject, name);
    if (descriptor) {
      var value = descriptor.value;
      if (value)
        return value;
      if (!descriptor.get)
        return value;
      return descriptor.get.call(self);
    }
    return undefined;
  }
  return {get default() {
      return superGet;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/superSet.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/superSet.js";
  var superDescriptor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./superDescriptor.js", "traceur@0.0.112/src/runtime/modules/superSet.js")).default;
  var $TypeError = TypeError;
  function superSet(self, homeObject, name, value) {
    var descriptor = superDescriptor(homeObject, name);
    if (descriptor && descriptor.set) {
      descriptor.set.call(self, value);
      return value;
    }
    throw $TypeError(("super has no setter '" + name + "'."));
  }
  return {get default() {
      return superSet;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/classes.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/classes.js";
  var createClass = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/createClass.js", "traceur@0.0.112/src/runtime/classes.js")).default;
  var superConstructor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/superConstructor.js", "traceur@0.0.112/src/runtime/classes.js")).default;
  var superGet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/superGet.js", "traceur@0.0.112/src/runtime/classes.js")).default;
  var superSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/superSet.js", "traceur@0.0.112/src/runtime/classes.js")).default;
  $traceurRuntime.createClass = createClass;
  $traceurRuntime.superConstructor = superConstructor;
  $traceurRuntime.superGet = superGet;
  $traceurRuntime.superSet = superSet;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/exportStar.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/exportStar.js";
  var $__1 = Object,
      defineProperty = $__1.defineProperty,
      getOwnPropertyNames = $__1.getOwnPropertyNames;
  function exportStar(object) {
    var $__2 = arguments,
        $__3 = function(i) {
          var mod = $__2[i];
          var names = getOwnPropertyNames(mod);
          var $__5 = function(j) {
            var name = names[j];
            if (name === '__esModule' || name === 'default') {
              return 0;
            }
            defineProperty(object, name, {
              get: function() {
                return mod[name];
              },
              enumerable: true
            });
          },
              $__6;
          $__4: for (var j = 0; j < names.length; j++) {
            $__6 = $__5(j);
            switch ($__6) {
              case 0:
                continue $__4;
            }
          }
        };
    for (var i = 1; i < arguments.length; i++) {
      $__3(i);
    }
    return object;
  }
  return {get default() {
      return exportStar;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/exportStar.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/exportStar.js";
  var exportStar = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/exportStar.js", "traceur@0.0.112/src/runtime/exportStar.js")).default;
  $traceurRuntime.exportStar = exportStar;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/private-symbol.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/private-symbol.js";
  var newUniqueString = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./new-unique-string.js", "traceur@0.0.112/src/runtime/private-symbol.js")).default;
  var $Symbol = typeof Symbol === 'function' ? Symbol : undefined;
  var $getOwnPropertySymbols = Object.getOwnPropertySymbols;
  var $create = Object.create;
  var privateNames = $create(null);
  function isPrivateSymbol(s) {
    return privateNames[s];
  }
  ;
  function createPrivateSymbol() {
    var s = ($Symbol || newUniqueString)();
    privateNames[s] = true;
    return s;
  }
  ;
  function hasPrivate(obj, sym) {
    return hasOwnProperty.call(obj, sym);
  }
  ;
  function deletePrivate(obj, sym) {
    if (!hasPrivate(obj, sym)) {
      return false;
    }
    delete obj[sym];
    return true;
  }
  ;
  function setPrivate(obj, sym, val) {
    obj[sym] = val;
  }
  ;
  function getPrivate(obj, sym) {
    var val = obj[sym];
    if (val === undefined)
      return undefined;
    return hasOwnProperty.call(obj, sym) ? val : undefined;
  }
  ;
  function init() {
    if ($getOwnPropertySymbols) {
      Object.getOwnPropertySymbols = function getOwnPropertySymbols(object) {
        var rv = [];
        var symbols = $getOwnPropertySymbols(object);
        for (var i = 0; i < symbols.length; i++) {
          var symbol = symbols[i];
          if (!isPrivateSymbol(symbol)) {
            rv.push(symbol);
          }
        }
        return rv;
      };
    }
  }
  return {
    get isPrivateSymbol() {
      return isPrivateSymbol;
    },
    get createPrivateSymbol() {
      return createPrivateSymbol;
    },
    get hasPrivate() {
      return hasPrivate;
    },
    get deletePrivate() {
      return deletePrivate;
    },
    get setPrivate() {
      return setPrivate;
    },
    get getPrivate() {
      return getPrivate;
    },
    get init() {
      return init;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/private-weak-map.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/private-weak-map.js";
  var $WeakMap = typeof WeakMap === 'function' ? WeakMap : undefined;
  function isPrivateSymbol(s) {
    return false;
  }
  function createPrivateSymbol() {
    return new $WeakMap();
  }
  function hasPrivate(obj, sym) {
    return sym.has(obj);
  }
  function deletePrivate(obj, sym) {
    return sym.delete(obj);
  }
  function setPrivate(obj, sym, val) {
    sym.set(obj, val);
  }
  function getPrivate(obj, sym) {
    return sym.get(obj);
  }
  function init() {}
  return {
    get isPrivateSymbol() {
      return isPrivateSymbol;
    },
    get createPrivateSymbol() {
      return createPrivateSymbol;
    },
    get hasPrivate() {
      return hasPrivate;
    },
    get deletePrivate() {
      return deletePrivate;
    },
    get setPrivate() {
      return setPrivate;
    },
    get getPrivate() {
      return getPrivate;
    },
    get init() {
      return init;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/private.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/private.js";
  var sym = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./private-symbol.js", "traceur@0.0.112/src/runtime/private.js"));
  var weak = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./private-weak-map.js", "traceur@0.0.112/src/runtime/private.js"));
  var hasWeakMap = typeof WeakMap === 'function';
  var m = hasWeakMap ? weak : sym;
  var isPrivateSymbol = m.isPrivateSymbol;
  var createPrivateSymbol = m.createPrivateSymbol;
  var hasPrivate = m.hasPrivate;
  var deletePrivate = m.deletePrivate;
  var setPrivate = m.setPrivate;
  var getPrivate = m.getPrivate;
  m.init();
  return {
    get isPrivateSymbol() {
      return isPrivateSymbol;
    },
    get createPrivateSymbol() {
      return createPrivateSymbol;
    },
    get hasPrivate() {
      return hasPrivate;
    },
    get deletePrivate() {
      return deletePrivate;
    },
    get setPrivate() {
      return setPrivate;
    },
    get getPrivate() {
      return getPrivate;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/properTailCalls.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/properTailCalls.js";
  var $__0 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../private.js", "traceur@0.0.112/src/runtime/modules/properTailCalls.js")),
      getPrivate = $__0.getPrivate,
      setPrivate = $__0.setPrivate,
      createPrivateSymbol = $__0.createPrivateSymbol;
  var $apply = Function.prototype.call.bind(Function.prototype.apply);
  var CONTINUATION_TYPE = Object.create(null);
  var isTailRecursiveName = null;
  function createContinuation(operand, thisArg, argsArray) {
    return [CONTINUATION_TYPE, operand, thisArg, argsArray];
  }
  function isContinuation(object) {
    return object && object[0] === CONTINUATION_TYPE;
  }
  function $bind(operand, thisArg, args) {
    var argArray = [thisArg];
    for (var i = 0; i < args.length; i++) {
      argArray[i + 1] = args[i];
    }
    var func = $apply(Function.prototype.bind, operand, argArray);
    return func;
  }
  function $construct(func, argArray) {
    var object = new ($bind(func, null, argArray));
    return object;
  }
  function isTailRecursive(func) {
    return !!getPrivate(func, isTailRecursiveName);
  }
  function tailCall(func, thisArg, argArray) {
    var continuation = argArray[0];
    if (isContinuation(continuation)) {
      continuation = $apply(func, thisArg, continuation[3]);
      return continuation;
    }
    continuation = createContinuation(func, thisArg, argArray);
    while (true) {
      if (isTailRecursive(func)) {
        continuation = $apply(func, continuation[2], [continuation]);
      } else {
        continuation = $apply(func, continuation[2], continuation[3]);
      }
      if (!isContinuation(continuation)) {
        return continuation;
      }
      func = continuation[1];
    }
  }
  function construct() {
    var object;
    if (isTailRecursive(this)) {
      object = $construct(this, [createContinuation(null, null, arguments)]);
    } else {
      object = $construct(this, arguments);
    }
    return object;
  }
  function setupProperTailCalls() {
    isTailRecursiveName = createPrivateSymbol();
    Function.prototype.call = initTailRecursiveFunction(function call(thisArg) {
      var result = tailCall(function(thisArg) {
        var argArray = [];
        for (var i = 1; i < arguments.length; ++i) {
          argArray[i - 1] = arguments[i];
        }
        var continuation = createContinuation(this, thisArg, argArray);
        return continuation;
      }, this, arguments);
      return result;
    });
    Function.prototype.apply = initTailRecursiveFunction(function apply(thisArg, argArray) {
      var result = tailCall(function(thisArg, argArray) {
        var continuation = createContinuation(this, thisArg, argArray);
        return continuation;
      }, this, arguments);
      return result;
    });
  }
  function initTailRecursiveFunction(func) {
    if (isTailRecursiveName === null) {
      setupProperTailCalls();
    }
    setPrivate(func, isTailRecursiveName, true);
    return func;
  }
  return {
    get createContinuation() {
      return createContinuation;
    },
    get tailCall() {
      return tailCall;
    },
    get construct() {
      return construct;
    },
    get initTailRecursiveFunction() {
      return initTailRecursiveFunction;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/initTailRecursiveFunction.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/initTailRecursiveFunction.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./properTailCalls.js", "traceur@0.0.112/src/runtime/modules/initTailRecursiveFunction.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__.initTailRecursiveFunction;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/call.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/call.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./properTailCalls.js", "traceur@0.0.112/src/runtime/modules/call.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__.tailCall;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/continuation.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/continuation.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./properTailCalls.js", "traceur@0.0.112/src/runtime/modules/continuation.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__.createContinuation;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/construct.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/construct.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./properTailCalls.js", "traceur@0.0.112/src/runtime/modules/construct.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_properTailCalls_46_js__.construct;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/properTailCalls.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/properTailCalls.js";
  var initTailRecursiveFunction = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/initTailRecursiveFunction.js", "traceur@0.0.112/src/runtime/properTailCalls.js")).default;
  var call = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/call.js", "traceur@0.0.112/src/runtime/properTailCalls.js")).default;
  var continuation = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/continuation.js", "traceur@0.0.112/src/runtime/properTailCalls.js")).default;
  var construct = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/construct.js", "traceur@0.0.112/src/runtime/properTailCalls.js")).default;
  $traceurRuntime.initTailRecursiveFunction = initTailRecursiveFunction;
  $traceurRuntime.call = call;
  $traceurRuntime.continuation = continuation;
  $traceurRuntime.construct = construct;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/relativeRequire.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/relativeRequire.js";
  var path;
  function relativeRequire(callerPath, requiredPath) {
    path = path || typeof require !== 'undefined' && require('path');
    function isDirectory(path) {
      return path.slice(-1) === '/';
    }
    function isAbsolute(path) {
      return path[0] === '/';
    }
    function isRelative(path) {
      return path[0] === '.';
    }
    if (isDirectory(requiredPath) || isAbsolute(requiredPath))
      return;
    return isRelative(requiredPath) ? require(path.resolve(path.dirname(callerPath), requiredPath)) : require(requiredPath);
  }
  $traceurRuntime.require = relativeRequire;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/checkObjectCoercible.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/checkObjectCoercible.js";
  var $TypeError = TypeError;
  function checkObjectCoercible(v) {
    if (v === null || v === undefined) {
      throw new $TypeError('Value cannot be converted to an Object');
    }
    return v;
  }
  return {get default() {
      return checkObjectCoercible;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/spread.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/spread.js";
  var checkObjectCoercible = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../checkObjectCoercible.js", "traceur@0.0.112/src/runtime/modules/spread.js")).default;
  function spread() {
    var rv = [],
        j = 0,
        iterResult;
    for (var i = 0; i < arguments.length; i++) {
      var valueToSpread = checkObjectCoercible(arguments[i]);
      if (typeof valueToSpread[Symbol.iterator] !== 'function') {
        throw new TypeError('Cannot spread non-iterable object.');
      }
      var iter = valueToSpread[Symbol.iterator]();
      while (!(iterResult = iter.next()).done) {
        rv[j++] = iterResult.value;
      }
    }
    return rv;
  }
  return {get default() {
      return spread;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/spread.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/spread.js";
  var spread = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/spread.js", "traceur@0.0.112/src/runtime/spread.js")).default;
  $traceurRuntime.spread = spread;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/iteratorToArray.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/iteratorToArray.js";
  function iteratorToArray(iter) {
    var rv = [];
    var i = 0;
    var tmp;
    while (!(tmp = iter.next()).done) {
      rv[i++] = tmp.value;
    }
    return rv;
  }
  return {get default() {
      return iteratorToArray;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/destructuring.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/destructuring.js";
  var iteratorToArray = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/iteratorToArray.js", "traceur@0.0.112/src/runtime/destructuring.js")).default;
  $traceurRuntime.iteratorToArray = iteratorToArray;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/async.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/async.js";
  var $__12 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../private.js", "traceur@0.0.112/src/runtime/modules/async.js")),
      createPrivateSymbol = $__12.createPrivateSymbol,
      getPrivate = $__12.getPrivate,
      setPrivate = $__12.setPrivate;
  var $__11 = Object,
      create = $__11.create,
      defineProperty = $__11.defineProperty;
  var observeName = createPrivateSymbol();
  function AsyncGeneratorFunction() {}
  function AsyncGeneratorFunctionPrototype() {}
  AsyncGeneratorFunction.prototype = AsyncGeneratorFunctionPrototype;
  AsyncGeneratorFunctionPrototype.constructor = AsyncGeneratorFunction;
  defineProperty(AsyncGeneratorFunctionPrototype, 'constructor', {enumerable: false});
  var AsyncGeneratorContext = function() {
    function AsyncGeneratorContext(observer) {
      var $__2 = this;
      this.decoratedObserver = createDecoratedGenerator(observer, function() {
        $__2.done = true;
      });
      this.done = false;
      this.inReturn = false;
    }
    return ($traceurRuntime.createClass)(AsyncGeneratorContext, {
      throw: function(error) {
        if (!this.inReturn) {
          throw error;
        }
      },
      yield: function(value) {
        if (this.done) {
          this.inReturn = true;
          throw undefined;
        }
        var result;
        try {
          result = this.decoratedObserver.next(value);
        } catch (e) {
          this.done = true;
          throw e;
        }
        if (result === undefined) {
          return;
        }
        if (result.done) {
          this.done = true;
          this.inReturn = true;
          throw undefined;
        }
        return result.value;
      },
      yieldFor: function(observable) {
        var ctx = this;
        return observeForEach(observable[Symbol.observer].bind(observable), function(value) {
          if (ctx.done) {
            this.return();
            return;
          }
          var result;
          try {
            result = ctx.decoratedObserver.next(value);
          } catch (e) {
            ctx.done = true;
            throw e;
          }
          if (result === undefined) {
            return;
          }
          if (result.done) {
            ctx.done = true;
          }
          return result;
        });
      }
    }, {});
  }();
  AsyncGeneratorFunctionPrototype.prototype[Symbol.observer] = function(observer) {
    var observe = getPrivate(this, observeName);
    var ctx = new AsyncGeneratorContext(observer);
    schedule(function() {
      return observe(ctx);
    }).then(function(value) {
      if (!ctx.done) {
        ctx.decoratedObserver.return(value);
      }
    }).catch(function(error) {
      if (!ctx.done) {
        ctx.decoratedObserver.throw(error);
      }
    });
    return ctx.decoratedObserver;
  };
  defineProperty(AsyncGeneratorFunctionPrototype.prototype, Symbol.observer, {enumerable: false});
  function initAsyncGeneratorFunction(functionObject) {
    functionObject.prototype = create(AsyncGeneratorFunctionPrototype.prototype);
    functionObject.__proto__ = AsyncGeneratorFunctionPrototype;
    return functionObject;
  }
  function createAsyncGeneratorInstance(observe, functionObject) {
    for (var args = [],
        $__10 = 2; $__10 < arguments.length; $__10++)
      args[$__10 - 2] = arguments[$__10];
    var object = create(functionObject.prototype);
    setPrivate(object, observeName, observe);
    return object;
  }
  function observeForEach(observe, next) {
    return new Promise(function(resolve, reject) {
      var generator = observe({
        next: function(value) {
          return next.call(generator, value);
        },
        throw: function(error) {
          reject(error);
        },
        return: function(value) {
          resolve(value);
        }
      });
    });
  }
  function schedule(asyncF) {
    return Promise.resolve().then(asyncF);
  }
  var generator = Symbol();
  var onDone = Symbol();
  var DecoratedGenerator = function() {
    function DecoratedGenerator(_generator, _onDone) {
      this[generator] = _generator;
      this[onDone] = _onDone;
    }
    return ($traceurRuntime.createClass)(DecoratedGenerator, {
      next: function(value) {
        var result = this[generator].next(value);
        if (result !== undefined && result.done) {
          this[onDone].call(this);
        }
        return result;
      },
      throw: function(error) {
        this[onDone].call(this);
        return this[generator].throw(error);
      },
      return: function(value) {
        this[onDone].call(this);
        return this[generator].return(value);
      }
    }, {});
  }();
  function createDecoratedGenerator(generator, onDone) {
    return new DecoratedGenerator(generator, onDone);
  }
  Array.prototype[Symbol.observer] = function(observer) {
    var done = false;
    var decoratedObserver = createDecoratedGenerator(observer, function() {
      return done = true;
    });
    var $__6 = true;
    var $__7 = false;
    var $__8 = undefined;
    try {
      for (var $__4 = void 0,
          $__3 = (this)[Symbol.iterator](); !($__6 = ($__4 = $__3.next()).done); $__6 = true) {
        var value = $__4.value;
        {
          decoratedObserver.next(value);
          if (done) {
            return;
          }
        }
      }
    } catch ($__9) {
      $__7 = true;
      $__8 = $__9;
    } finally {
      try {
        if (!$__6 && $__3.return != null) {
          $__3.return();
        }
      } finally {
        if ($__7) {
          throw $__8;
        }
      }
    }
    decoratedObserver.return();
    return decoratedObserver;
  };
  defineProperty(Array.prototype, Symbol.observer, {enumerable: false});
  return {
    get initAsyncGeneratorFunction() {
      return initAsyncGeneratorFunction;
    },
    get createAsyncGeneratorInstance() {
      return createAsyncGeneratorInstance;
    },
    get observeForEach() {
      return observeForEach;
    },
    get schedule() {
      return schedule;
    },
    get createDecoratedGenerator() {
      return createDecoratedGenerator;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/initAsyncGeneratorFunction.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/initAsyncGeneratorFunction.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./async.js", "traceur@0.0.112/src/runtime/modules/initAsyncGeneratorFunction.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__.initAsyncGeneratorFunction;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/createAsyncGeneratorInstance.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/createAsyncGeneratorInstance.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./async.js", "traceur@0.0.112/src/runtime/modules/createAsyncGeneratorInstance.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__.createAsyncGeneratorInstance;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/observeForEach.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/observeForEach.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./async.js", "traceur@0.0.112/src/runtime/modules/observeForEach.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__.observeForEach;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/schedule.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/schedule.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./async.js", "traceur@0.0.112/src/runtime/modules/schedule.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__.schedule;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/createDecoratedGenerator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/createDecoratedGenerator.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./async.js", "traceur@0.0.112/src/runtime/modules/createDecoratedGenerator.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_async_46_js__.createDecoratedGenerator;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/async.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/async.js";
  var initAsyncGeneratorFunction = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/initAsyncGeneratorFunction.js", "traceur@0.0.112/src/runtime/async.js")).default;
  var createAsyncGeneratorInstance = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/createAsyncGeneratorInstance.js", "traceur@0.0.112/src/runtime/async.js")).default;
  var observeForEach = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/observeForEach.js", "traceur@0.0.112/src/runtime/async.js")).default;
  var schedule = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/schedule.js", "traceur@0.0.112/src/runtime/async.js")).default;
  var createDecoratedGenerator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/createDecoratedGenerator.js", "traceur@0.0.112/src/runtime/async.js")).default;
  $traceurRuntime.initAsyncGeneratorFunction = initAsyncGeneratorFunction;
  $traceurRuntime.createAsyncGeneratorInstance = createAsyncGeneratorInstance;
  $traceurRuntime.observeForEach = observeForEach;
  $traceurRuntime.schedule = schedule;
  $traceurRuntime.createDecoratedGenerator = createDecoratedGenerator;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/generators.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/generators.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../private.js", "traceur@0.0.112/src/runtime/modules/generators.js")),
      createPrivateSymbol = $__2.createPrivateSymbol,
      getPrivate = $__2.getPrivate,
      setPrivate = $__2.setPrivate;
  var $TypeError = TypeError;
  var $__1 = Object,
      create = $__1.create,
      defineProperties = $__1.defineProperties,
      defineProperty = $__1.defineProperty;
  function nonEnum(value) {
    return {
      configurable: true,
      enumerable: false,
      value: value,
      writable: true
    };
  }
  var ST_NEWBORN = 0;
  var ST_EXECUTING = 1;
  var ST_SUSPENDED = 2;
  var ST_CLOSED = 3;
  var END_STATE = -2;
  var RETHROW_STATE = -3;
  function getInternalError(state) {
    return new Error('Traceur compiler bug: invalid state in state machine: ' + state);
  }
  var RETURN_SENTINEL = {};
  function GeneratorContext() {
    this.state = 0;
    this.GState = ST_NEWBORN;
    this.storedException = undefined;
    this.finallyFallThrough = undefined;
    this.sent_ = undefined;
    this.returnValue = undefined;
    this.oldReturnValue = undefined;
    this.tryStack_ = [];
  }
  GeneratorContext.prototype = {
    pushTry: function(catchState, finallyState) {
      if (finallyState !== null) {
        var finallyFallThrough = null;
        for (var i = this.tryStack_.length - 1; i >= 0; i--) {
          if (this.tryStack_[i].catch !== undefined) {
            finallyFallThrough = this.tryStack_[i].catch;
            break;
          }
        }
        if (finallyFallThrough === null)
          finallyFallThrough = RETHROW_STATE;
        this.tryStack_.push({
          finally: finallyState,
          finallyFallThrough: finallyFallThrough
        });
      }
      if (catchState !== null) {
        this.tryStack_.push({catch: catchState});
      }
    },
    popTry: function() {
      this.tryStack_.pop();
    },
    maybeUncatchable: function() {
      if (this.storedException === RETURN_SENTINEL) {
        throw RETURN_SENTINEL;
      }
    },
    get sent() {
      this.maybeThrow();
      return this.sent_;
    },
    set sent(v) {
      this.sent_ = v;
    },
    get sentIgnoreThrow() {
      return this.sent_;
    },
    maybeThrow: function() {
      if (this.action === 'throw') {
        this.action = 'next';
        throw this.sent_;
      }
    },
    end: function() {
      switch (this.state) {
        case END_STATE:
          return this;
        case RETHROW_STATE:
          throw this.storedException;
        default:
          throw getInternalError(this.state);
      }
    },
    handleException: function(ex) {
      this.GState = ST_CLOSED;
      this.state = END_STATE;
      throw ex;
    },
    wrapYieldStar: function(iterator) {
      var ctx = this;
      return {
        next: function(v) {
          return iterator.next(v);
        },
        throw: function(e) {
          var result;
          if (e === RETURN_SENTINEL) {
            if (iterator.return) {
              result = iterator.return(ctx.returnValue);
              if (!result.done) {
                ctx.returnValue = ctx.oldReturnValue;
                return result;
              }
              ctx.returnValue = result.value;
            }
            throw e;
          }
          if (iterator.throw) {
            return iterator.throw(e);
          }
          iterator.return && iterator.return();
          throw $TypeError('Inner iterator does not have a throw method');
        }
      };
    }
  };
  function nextOrThrow(ctx, moveNext, action, x) {
    switch (ctx.GState) {
      case ST_EXECUTING:
        throw new Error(("\"" + action + "\" on executing generator"));
      case ST_CLOSED:
        if (action == 'next') {
          return {
            value: undefined,
            done: true
          };
        }
        if (x === RETURN_SENTINEL) {
          return {
            value: ctx.returnValue,
            done: true
          };
        }
        throw x;
      case ST_NEWBORN:
        if (action === 'throw') {
          ctx.GState = ST_CLOSED;
          if (x === RETURN_SENTINEL) {
            return {
              value: ctx.returnValue,
              done: true
            };
          }
          throw x;
        }
        if (x !== undefined)
          throw $TypeError('Sent value to newborn generator');
      case ST_SUSPENDED:
        ctx.GState = ST_EXECUTING;
        ctx.action = action;
        ctx.sent = x;
        var value;
        try {
          value = moveNext(ctx);
        } catch (ex) {
          if (ex === RETURN_SENTINEL) {
            value = ctx;
          } else {
            throw ex;
          }
        }
        var done = value === ctx;
        if (done)
          value = ctx.returnValue;
        ctx.GState = done ? ST_CLOSED : ST_SUSPENDED;
        return {
          value: value,
          done: done
        };
    }
  }
  var ctxName = createPrivateSymbol();
  var moveNextName = createPrivateSymbol();
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}
  GeneratorFunction.prototype = GeneratorFunctionPrototype;
  defineProperty(GeneratorFunctionPrototype, 'constructor', nonEnum(GeneratorFunction));
  GeneratorFunctionPrototype.prototype = {
    constructor: GeneratorFunctionPrototype,
    next: function(v) {
      return nextOrThrow(getPrivate(this, ctxName), getPrivate(this, moveNextName), 'next', v);
    },
    throw: function(v) {
      return nextOrThrow(getPrivate(this, ctxName), getPrivate(this, moveNextName), 'throw', v);
    },
    return: function(v) {
      var ctx = getPrivate(this, ctxName);
      ctx.oldReturnValue = ctx.returnValue;
      ctx.returnValue = v;
      return nextOrThrow(ctx, getPrivate(this, moveNextName), 'throw', RETURN_SENTINEL);
    }
  };
  defineProperties(GeneratorFunctionPrototype.prototype, {
    constructor: {enumerable: false},
    next: {enumerable: false},
    throw: {enumerable: false},
    return: {enumerable: false}
  });
  Object.defineProperty(GeneratorFunctionPrototype.prototype, Symbol.iterator, nonEnum(function() {
    return this;
  }));
  function createGeneratorInstance(innerFunction, functionObject, self) {
    var moveNext = getMoveNext(innerFunction, self);
    var ctx = new GeneratorContext();
    var object = create(functionObject.prototype);
    setPrivate(object, ctxName, ctx);
    setPrivate(object, moveNextName, moveNext);
    return object;
  }
  function initGeneratorFunction(functionObject) {
    functionObject.prototype = create(GeneratorFunctionPrototype.prototype);
    functionObject.__proto__ = GeneratorFunctionPrototype;
    return functionObject;
  }
  function AsyncFunctionContext() {
    GeneratorContext.call(this);
    this.err = undefined;
    var ctx = this;
    ctx.result = new Promise(function(resolve, reject) {
      ctx.resolve = resolve;
      ctx.reject = reject;
    });
  }
  AsyncFunctionContext.prototype = create(GeneratorContext.prototype);
  AsyncFunctionContext.prototype.end = function() {
    switch (this.state) {
      case END_STATE:
        this.resolve(this.returnValue);
        break;
      case RETHROW_STATE:
        this.reject(this.storedException);
        break;
      default:
        this.reject(getInternalError(this.state));
    }
  };
  AsyncFunctionContext.prototype.handleException = function() {
    this.state = RETHROW_STATE;
  };
  function asyncWrap(innerFunction, self) {
    var moveNext = getMoveNext(innerFunction, self);
    var ctx = new AsyncFunctionContext();
    ctx.createCallback = function(newState) {
      return function(value) {
        ctx.state = newState;
        ctx.value = value;
        moveNext(ctx);
      };
    };
    ctx.errback = function(err) {
      handleCatch(ctx, err);
      moveNext(ctx);
    };
    moveNext(ctx);
    return ctx.result;
  }
  function getMoveNext(innerFunction, self) {
    return function(ctx) {
      while (true) {
        try {
          return innerFunction.call(self, ctx);
        } catch (ex) {
          handleCatch(ctx, ex);
        }
      }
    };
  }
  function handleCatch(ctx, ex) {
    ctx.storedException = ex;
    var last = ctx.tryStack_[ctx.tryStack_.length - 1];
    if (!last) {
      ctx.handleException(ex);
      return;
    }
    ctx.state = last.catch !== undefined ? last.catch : last.finally;
    if (last.finallyFallThrough !== undefined)
      ctx.finallyFallThrough = last.finallyFallThrough;
  }
  return {
    get createGeneratorInstance() {
      return createGeneratorInstance;
    },
    get initGeneratorFunction() {
      return initGeneratorFunction;
    },
    get asyncWrap() {
      return asyncWrap;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/asyncWrap.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/asyncWrap.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_generators_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./generators.js", "traceur@0.0.112/src/runtime/modules/asyncWrap.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_generators_46_js__.asyncWrap;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/initGeneratorFunction.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/initGeneratorFunction.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_generators_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./generators.js", "traceur@0.0.112/src/runtime/modules/initGeneratorFunction.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_generators_46_js__.initGeneratorFunction;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/createGeneratorInstance.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/createGeneratorInstance.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_generators_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./generators.js", "traceur@0.0.112/src/runtime/modules/createGeneratorInstance.js"));
  return {get default() {
      return $__traceur_64_0_46_0_46_112_47_src_47_runtime_47_modules_47_generators_46_js__.createGeneratorInstance;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/generators.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/generators.js";
  var asyncWrap = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/asyncWrap.js", "traceur@0.0.112/src/runtime/generators.js")).default;
  var initGeneratorFunction = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/initGeneratorFunction.js", "traceur@0.0.112/src/runtime/generators.js")).default;
  var createGeneratorInstance = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/createGeneratorInstance.js", "traceur@0.0.112/src/runtime/generators.js")).default;
  $traceurRuntime.asyncWrap = asyncWrap;
  $traceurRuntime.initGeneratorFunction = initGeneratorFunction;
  $traceurRuntime.createGeneratorInstance = createGeneratorInstance;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/spawn.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/spawn.js";
  function spawn(self, args, gen) {
    return new Promise(function(resolve, reject) {
      function fulfill(v) {
        try {
          step(gen.next(v));
        } catch (e) {
          reject(e);
        }
      }
      function rejected(v) {
        try {
          step(gen.throw(v));
        } catch (e) {
          reject(e);
        }
      }
      function step(res) {
        if (res.done) {
          resolve(res.value);
        } else {
          Promise.resolve(res.value).then(fulfill, rejected);
        }
      }
      step((gen = gen.apply(self, args)).next());
    });
  }
  return {get default() {
      return spawn;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/spawn.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/spawn.js";
  var spawn = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/spawn.js", "traceur@0.0.112/src/runtime/spawn.js")).default;
  $traceurRuntime.spawn = spawn;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/getTemplateObject.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/getTemplateObject.js";
  var $__1 = Object,
      defineProperty = $__1.defineProperty,
      freeze = $__1.freeze;
  var slice = Array.prototype.slice;
  var map = Object.create(null);
  function getTemplateObject(raw) {
    var cooked = arguments[1];
    var key = raw.join('${}');
    var templateObject = map[key];
    if (templateObject)
      return templateObject;
    if (!cooked) {
      cooked = slice.call(raw);
    }
    return map[key] = freeze(defineProperty(cooked, 'raw', {value: freeze(raw)}));
  }
  return {get default() {
      return getTemplateObject;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/template.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/template.js";
  var getTemplateObject = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/getTemplateObject.js", "traceur@0.0.112/src/runtime/template.js")).default;
  $traceurRuntime.getTemplateObject = getTemplateObject;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/modules/spreadProperties.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/modules/spreadProperties.js";
  var $__1 = Object,
      defineProperty = $__1.defineProperty,
      getOwnPropertyNames = $__1.getOwnPropertyNames,
      getOwnPropertySymbols = $__1.getOwnPropertySymbols,
      propertyIsEnumerable = $__1.propertyIsEnumerable;
  function createDataProperty(o, p, v) {
    defineProperty(o, p, {
      configurable: true,
      enumerable: true,
      value: v,
      writable: true
    });
  }
  function copyDataProperties(target, source) {
    if (source == null) {
      return;
    }
    var copy = function(keys) {
      for (var i = 0; i < keys.length; i++) {
        var nextKey = keys[i];
        if (propertyIsEnumerable.call(source, nextKey)) {
          var propValue = source[nextKey];
          createDataProperty(target, nextKey, propValue);
        }
      }
    };
    copy(getOwnPropertyNames(source));
    copy(getOwnPropertySymbols(source));
  }
  var $__default = function() {
    var target = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
      copyDataProperties(target, arguments[i]);
    }
    return target;
  };
  return {get default() {
      return $__default;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/jsx.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/jsx.js";
  var spreadProperties = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./modules/spreadProperties.js", "traceur@0.0.112/src/runtime/jsx.js")).default;
  $traceurRuntime.spreadProperties = spreadProperties;
  return {};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/runtime-modules.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/runtime-modules.js";
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./symbols.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./classes.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./exportStar.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./properTailCalls.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./relativeRequire.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./spread.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./destructuring.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./async.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./generators.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./spawn.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./template.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./jsx.js", "traceur@0.0.112/src/runtime/runtime-modules.js"));
  return {};
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/runtime-modules.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/frozen-data.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/frozen-data.js";
  function findIndex(arr, key) {
    for (var i = 0; i < arr.length; i += 2) {
      if (arr[i] === key) {
        return i;
      }
    }
    return -1;
  }
  function setFrozen(arr, key, val) {
    var i = findIndex(arr, key);
    if (i === -1) {
      arr.push(key, val);
    }
  }
  function getFrozen(arr, key) {
    var i = findIndex(arr, key);
    if (i !== -1) {
      return arr[i + 1];
    }
    return undefined;
  }
  function hasFrozen(arr, key) {
    return findIndex(arr, key) !== -1;
  }
  function deleteFrozen(arr, key) {
    var i = findIndex(arr, key);
    if (i !== -1) {
      arr.splice(i, 2);
      return true;
    }
    return false;
  }
  return {
    get setFrozen() {
      return setFrozen;
    },
    get getFrozen() {
      return getFrozen;
    },
    get hasFrozen() {
      return hasFrozen;
    },
    get deleteFrozen() {
      return deleteFrozen;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/utils.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/utils.js";
  var $ceil = Math.ceil;
  var $floor = Math.floor;
  var $isFinite = isFinite;
  var $isNaN = isNaN;
  var $pow = Math.pow;
  var $min = Math.min;
  var $TypeError = TypeError;
  var $Object = Object;
  function toObject(x) {
    if (x == null) {
      throw $TypeError();
    }
    return $Object(x);
  }
  function toUint32(x) {
    return x >>> 0;
  }
  function isObject(x) {
    return x && (typeof x === 'object' || typeof x === 'function');
  }
  function isCallable(x) {
    return typeof x === 'function';
  }
  function isNumber(x) {
    return typeof x === 'number';
  }
  function toInteger(x) {
    x = +x;
    if ($isNaN(x))
      return 0;
    if (x === 0 || !$isFinite(x))
      return x;
    return x > 0 ? $floor(x) : $ceil(x);
  }
  var MAX_SAFE_LENGTH = $pow(2, 53) - 1;
  function toLength(x) {
    var len = toInteger(x);
    return len < 0 ? 0 : $min(len, MAX_SAFE_LENGTH);
  }
  function checkIterable(x) {
    return !isObject(x) ? undefined : x[Symbol.iterator];
  }
  function isConstructor(x) {
    return isCallable(x);
  }
  function createIteratorResultObject(value, done) {
    return {
      value: value,
      done: done
    };
  }
  function maybeDefine(object, name, descr) {
    if (!(name in object)) {
      Object.defineProperty(object, name, descr);
    }
  }
  function maybeDefineMethod(object, name, value) {
    maybeDefine(object, name, {
      value: value,
      configurable: true,
      enumerable: false,
      writable: true
    });
  }
  function maybeDefineConst(object, name, value) {
    maybeDefine(object, name, {
      value: value,
      configurable: false,
      enumerable: false,
      writable: false
    });
  }
  function maybeAddFunctions(object, functions) {
    for (var i = 0; i < functions.length; i += 2) {
      var name = functions[i];
      var value = functions[i + 1];
      maybeDefineMethod(object, name, value);
    }
  }
  function maybeAddConsts(object, consts) {
    for (var i = 0; i < consts.length; i += 2) {
      var name = consts[i];
      var value = consts[i + 1];
      maybeDefineConst(object, name, value);
    }
  }
  function maybeAddIterator(object, func, Symbol) {
    if (!Symbol || !Symbol.iterator || object[Symbol.iterator])
      return;
    if (object['@@iterator'])
      func = object['@@iterator'];
    Object.defineProperty(object, Symbol.iterator, {
      value: func,
      configurable: true,
      enumerable: false,
      writable: true
    });
  }
  var polyfills = [];
  function registerPolyfill(func) {
    polyfills.push(func);
  }
  function polyfillAll(global) {
    polyfills.forEach(function(f) {
      return f(global);
    });
  }
  return {
    get toObject() {
      return toObject;
    },
    get toUint32() {
      return toUint32;
    },
    get isObject() {
      return isObject;
    },
    get isCallable() {
      return isCallable;
    },
    get isNumber() {
      return isNumber;
    },
    get toInteger() {
      return toInteger;
    },
    get toLength() {
      return toLength;
    },
    get checkIterable() {
      return checkIterable;
    },
    get isConstructor() {
      return isConstructor;
    },
    get createIteratorResultObject() {
      return createIteratorResultObject;
    },
    get maybeDefine() {
      return maybeDefine;
    },
    get maybeDefineMethod() {
      return maybeDefineMethod;
    },
    get maybeDefineConst() {
      return maybeDefineConst;
    },
    get maybeAddFunctions() {
      return maybeAddFunctions;
    },
    get maybeAddConsts() {
      return maybeAddConsts;
    },
    get maybeAddIterator() {
      return maybeAddIterator;
    },
    get registerPolyfill() {
      return registerPolyfill;
    },
    get polyfillAll() {
      return polyfillAll;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/Map.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/Map.js";
  var $__16 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../private.js", "traceur@0.0.112/src/runtime/polyfills/Map.js")),
      createPrivateSymbol = $__16.createPrivateSymbol,
      getPrivate = $__16.getPrivate,
      setPrivate = $__16.setPrivate;
  var $__17 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../frozen-data.js", "traceur@0.0.112/src/runtime/polyfills/Map.js")),
      deleteFrozen = $__17.deleteFrozen,
      getFrozen = $__17.getFrozen,
      setFrozen = $__17.setFrozen;
  var $__18 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/Map.js")),
      isObject = $__18.isObject,
      registerPolyfill = $__18.registerPolyfill;
  var hasNativeSymbol = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../has-native-symbols.js", "traceur@0.0.112/src/runtime/polyfills/Map.js")).default;
  var $__9 = Object,
      defineProperty = $__9.defineProperty,
      getOwnPropertyDescriptor = $__9.getOwnPropertyDescriptor,
      hasOwnProperty = $__9.hasOwnProperty,
      isExtensible = $__9.isExtensible;
  var deletedSentinel = {};
  var counter = 1;
  var hashCodeName = createPrivateSymbol();
  function getHashCodeForObject(obj) {
    return getPrivate(obj, hashCodeName);
  }
  function getOrSetHashCodeForObject(obj) {
    var hash = getHashCodeForObject(obj);
    if (!hash) {
      hash = counter++;
      setPrivate(obj, hashCodeName, hash);
    }
    return hash;
  }
  function lookupIndex(map, key) {
    if (typeof key === 'string') {
      return map.stringIndex_[key];
    }
    if (isObject(key)) {
      if (!isExtensible(key)) {
        return getFrozen(map.frozenData_, key);
      }
      var hc = getHashCodeForObject(key);
      if (hc === undefined) {
        return undefined;
      }
      return map.objectIndex_[hc];
    }
    return map.primitiveIndex_[key];
  }
  function initMap(map) {
    map.entries_ = [];
    map.objectIndex_ = Object.create(null);
    map.stringIndex_ = Object.create(null);
    map.primitiveIndex_ = Object.create(null);
    map.frozenData_ = [];
    map.deletedCount_ = 0;
  }
  var Map = function() {
    function Map() {
      var $__11,
          $__12;
      var iterable = arguments[0];
      if (!isObject(this))
        throw new TypeError('Map called on incompatible type');
      if (hasOwnProperty.call(this, 'entries_')) {
        throw new TypeError('Map can not be reentrantly initialised');
      }
      initMap(this);
      if (iterable !== null && iterable !== undefined) {
        var $__5 = true;
        var $__6 = false;
        var $__7 = undefined;
        try {
          for (var $__3 = void 0,
              $__2 = (iterable)[Symbol.iterator](); !($__5 = ($__3 = $__2.next()).done); $__5 = true) {
            var $__10 = $__3.value,
                key = ($__11 = $__10[Symbol.iterator](), ($__12 = $__11.next()).done ? void 0 : $__12.value),
                value = ($__12 = $__11.next()).done ? void 0 : $__12.value;
            {
              this.set(key, value);
            }
          }
        } catch ($__8) {
          $__6 = true;
          $__7 = $__8;
        } finally {
          try {
            if (!$__5 && $__2.return != null) {
              $__2.return();
            }
          } finally {
            if ($__6) {
              throw $__7;
            }
          }
        }
      }
    }
    return ($traceurRuntime.createClass)(Map, {
      get size() {
        return this.entries_.length / 2 - this.deletedCount_;
      },
      get: function(key) {
        var index = lookupIndex(this, key);
        if (index !== undefined) {
          return this.entries_[index + 1];
        }
      },
      set: function(key, value) {
        var index = lookupIndex(this, key);
        if (index !== undefined) {
          this.entries_[index + 1] = value;
        } else {
          index = this.entries_.length;
          this.entries_[index] = key;
          this.entries_[index + 1] = value;
          if (isObject(key)) {
            if (!isExtensible(key)) {
              setFrozen(this.frozenData_, key, index);
            } else {
              var hash = getOrSetHashCodeForObject(key);
              this.objectIndex_[hash] = index;
            }
          } else if (typeof key === 'string') {
            this.stringIndex_[key] = index;
          } else {
            this.primitiveIndex_[key] = index;
          }
        }
        return this;
      },
      has: function(key) {
        return lookupIndex(this, key) !== undefined;
      },
      delete: function(key) {
        var index = lookupIndex(this, key);
        if (index === undefined) {
          return false;
        }
        this.entries_[index] = deletedSentinel;
        this.entries_[index + 1] = undefined;
        this.deletedCount_++;
        if (isObject(key)) {
          if (!isExtensible(key)) {
            deleteFrozen(this.frozenData_, key);
          } else {
            var hash = getHashCodeForObject(key);
            delete this.objectIndex_[hash];
          }
        } else if (typeof key === 'string') {
          delete this.stringIndex_[key];
        } else {
          delete this.primitiveIndex_[key];
        }
        return true;
      },
      clear: function() {
        initMap(this);
      },
      forEach: function(callbackFn) {
        var thisArg = arguments[1];
        for (var i = 0; i < this.entries_.length; i += 2) {
          var key = this.entries_[i];
          var value = this.entries_[i + 1];
          if (key === deletedSentinel)
            continue;
          callbackFn.call(thisArg, value, key, this);
        }
      },
      entries: $traceurRuntime.initGeneratorFunction(function $__13() {
        var i,
            key,
            value;
        return $traceurRuntime.createGeneratorInstance(function($ctx) {
          while (true)
            switch ($ctx.state) {
              case 0:
                i = 0;
                $ctx.state = 12;
                break;
              case 12:
                $ctx.state = (i < this.entries_.length) ? 8 : -2;
                break;
              case 4:
                i += 2;
                $ctx.state = 12;
                break;
              case 8:
                key = this.entries_[i];
                value = this.entries_[i + 1];
                $ctx.state = 9;
                break;
              case 9:
                $ctx.state = (key === deletedSentinel) ? 4 : 6;
                break;
              case 6:
                $ctx.state = 2;
                return [key, value];
              case 2:
                $ctx.maybeThrow();
                $ctx.state = 4;
                break;
              default:
                return $ctx.end();
            }
        }, $__13, this);
      }),
      keys: $traceurRuntime.initGeneratorFunction(function $__14() {
        var i,
            key,
            value;
        return $traceurRuntime.createGeneratorInstance(function($ctx) {
          while (true)
            switch ($ctx.state) {
              case 0:
                i = 0;
                $ctx.state = 12;
                break;
              case 12:
                $ctx.state = (i < this.entries_.length) ? 8 : -2;
                break;
              case 4:
                i += 2;
                $ctx.state = 12;
                break;
              case 8:
                key = this.entries_[i];
                value = this.entries_[i + 1];
                $ctx.state = 9;
                break;
              case 9:
                $ctx.state = (key === deletedSentinel) ? 4 : 6;
                break;
              case 6:
                $ctx.state = 2;
                return key;
              case 2:
                $ctx.maybeThrow();
                $ctx.state = 4;
                break;
              default:
                return $ctx.end();
            }
        }, $__14, this);
      }),
      values: $traceurRuntime.initGeneratorFunction(function $__15() {
        var i,
            key,
            value;
        return $traceurRuntime.createGeneratorInstance(function($ctx) {
          while (true)
            switch ($ctx.state) {
              case 0:
                i = 0;
                $ctx.state = 12;
                break;
              case 12:
                $ctx.state = (i < this.entries_.length) ? 8 : -2;
                break;
              case 4:
                i += 2;
                $ctx.state = 12;
                break;
              case 8:
                key = this.entries_[i];
                value = this.entries_[i + 1];
                $ctx.state = 9;
                break;
              case 9:
                $ctx.state = (key === deletedSentinel) ? 4 : 6;
                break;
              case 6:
                $ctx.state = 2;
                return value;
              case 2:
                $ctx.maybeThrow();
                $ctx.state = 4;
                break;
              default:
                return $ctx.end();
            }
        }, $__15, this);
      })
    }, {});
  }();
  defineProperty(Map.prototype, Symbol.iterator, {
    configurable: true,
    writable: true,
    value: Map.prototype.entries
  });
  function needsPolyfill(global) {
    var $__10 = global,
        Map = $__10.Map,
        Symbol = $__10.Symbol;
    if (!Map || !hasNativeSymbol() || !Map.prototype[Symbol.iterator] || !Map.prototype.entries) {
      return true;
    }
    try {
      return new Map([[]]).size !== 1;
    } catch (e) {
      return false;
    }
  }
  function polyfillMap(global) {
    if (needsPolyfill(global)) {
      global.Map = Map;
    }
  }
  registerPolyfill(polyfillMap);
  return {
    get Map() {
      return Map;
    },
    get polyfillMap() {
      return polyfillMap;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/Map.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/Set.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/Set.js";
  var $__18 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/Set.js")),
      isObject = $__18.isObject,
      registerPolyfill = $__18.registerPolyfill;
  var Map = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Map.js", "traceur@0.0.112/src/runtime/polyfills/Set.js")).Map;
  var hasNativeSymbol = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../has-native-symbols.js", "traceur@0.0.112/src/runtime/polyfills/Set.js")).default;
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  var Set = function() {
    function Set() {
      var iterable = arguments[0];
      if (!isObject(this))
        throw new TypeError('Set called on incompatible type');
      if (hasOwnProperty.call(this, 'map_')) {
        throw new TypeError('Set can not be reentrantly initialised');
      }
      this.map_ = new Map();
      if (iterable !== null && iterable !== undefined) {
        var $__6 = true;
        var $__7 = false;
        var $__8 = undefined;
        try {
          for (var $__4 = void 0,
              $__3 = (iterable)[Symbol.iterator](); !($__6 = ($__4 = $__3.next()).done); $__6 = true) {
            var item = $__4.value;
            {
              this.add(item);
            }
          }
        } catch ($__9) {
          $__7 = true;
          $__8 = $__9;
        } finally {
          try {
            if (!$__6 && $__3.return != null) {
              $__3.return();
            }
          } finally {
            if ($__7) {
              throw $__8;
            }
          }
        }
      }
    }
    return ($traceurRuntime.createClass)(Set, {
      get size() {
        return this.map_.size;
      },
      has: function(key) {
        return this.map_.has(key);
      },
      add: function(key) {
        this.map_.set(key, key);
        return this;
      },
      delete: function(key) {
        return this.map_.delete(key);
      },
      clear: function() {
        return this.map_.clear();
      },
      forEach: function(callbackFn) {
        var thisArg = arguments[1];
        var $__2 = this;
        return this.map_.forEach(function(value, key) {
          callbackFn.call(thisArg, key, key, $__2);
        });
      },
      values: $traceurRuntime.initGeneratorFunction(function $__12() {
        var $__13,
            $__14;
        return $traceurRuntime.createGeneratorInstance(function($ctx) {
          while (true)
            switch ($ctx.state) {
              case 0:
                $__13 = $ctx.wrapYieldStar(this.map_.keys()[Symbol.iterator]());
                $ctx.sent = void 0;
                $ctx.action = 'next';
                $ctx.state = 12;
                break;
              case 12:
                $__14 = $__13[$ctx.action]($ctx.sentIgnoreThrow);
                $ctx.state = 9;
                break;
              case 9:
                $ctx.state = ($__14.done) ? 3 : 2;
                break;
              case 3:
                $ctx.sent = $__14.value;
                $ctx.state = -2;
                break;
              case 2:
                $ctx.state = 12;
                return $__14.value;
              default:
                return $ctx.end();
            }
        }, $__12, this);
      }),
      entries: $traceurRuntime.initGeneratorFunction(function $__15() {
        var $__16,
            $__17;
        return $traceurRuntime.createGeneratorInstance(function($ctx) {
          while (true)
            switch ($ctx.state) {
              case 0:
                $__16 = $ctx.wrapYieldStar(this.map_.entries()[Symbol.iterator]());
                $ctx.sent = void 0;
                $ctx.action = 'next';
                $ctx.state = 12;
                break;
              case 12:
                $__17 = $__16[$ctx.action]($ctx.sentIgnoreThrow);
                $ctx.state = 9;
                break;
              case 9:
                $ctx.state = ($__17.done) ? 3 : 2;
                break;
              case 3:
                $ctx.sent = $__17.value;
                $ctx.state = -2;
                break;
              case 2:
                $ctx.state = 12;
                return $__17.value;
              default:
                return $ctx.end();
            }
        }, $__15, this);
      })
    }, {});
  }();
  Object.defineProperty(Set.prototype, Symbol.iterator, {
    configurable: true,
    writable: true,
    value: Set.prototype.values
  });
  Object.defineProperty(Set.prototype, 'keys', {
    configurable: true,
    writable: true,
    value: Set.prototype.values
  });
  function needsPolyfill(global) {
    var $__11 = global,
        Set = $__11.Set,
        Symbol = $__11.Symbol;
    if (!Set || !hasNativeSymbol() || !Set.prototype[Symbol.iterator] || !Set.prototype.values) {
      return true;
    }
    try {
      return new Set([1]).size !== 1;
    } catch (e) {
      return false;
    }
  }
  function polyfillSet(global) {
    if (needsPolyfill(global)) {
      global.Set = Set;
    }
  }
  registerPolyfill(polyfillSet);
  return {
    get Set() {
      return Set;
    },
    get polyfillSet() {
      return polyfillSet;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/Set.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/node_modules/rsvp/lib/rsvp/asap.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/node_modules/rsvp/lib/rsvp/asap.js";
  var len = 0;
  var toString = {}.toString;
  var vertxNext;
  function asap(callback, arg) {
    queue[len] = callback;
    queue[len + 1] = arg;
    len += 2;
    if (len === 2) {
      scheduleFlush();
    }
  }
  var browserWindow = (typeof window !== 'undefined') ? window : undefined;
  var browserGlobal = browserWindow || {};
  var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
  var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
  var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
  function useNextTick() {
    var nextTick = process.nextTick;
    var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/);
    if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {
      nextTick = setImmediate;
    }
    return function() {
      nextTick(flush);
    };
  }
  function useVertxTimer() {
    return function() {
      vertxNext(flush);
    };
  }
  function useMutationObserver() {
    var iterations = 0;
    var observer = new BrowserMutationObserver(flush);
    var node = document.createTextNode('');
    observer.observe(node, {characterData: true});
    return function() {
      node.data = (iterations = ++iterations % 2);
    };
  }
  function useMessageChannel() {
    var channel = new MessageChannel();
    channel.port1.onmessage = flush;
    return function() {
      channel.port2.postMessage(0);
    };
  }
  function useSetTimeout() {
    return function() {
      setTimeout(flush, 1);
    };
  }
  var queue = new Array(1000);
  function flush() {
    for (var i = 0; i < len; i += 2) {
      var callback = queue[i];
      var arg = queue[i + 1];
      callback(arg);
      queue[i] = undefined;
      queue[i + 1] = undefined;
    }
    len = 0;
  }
  function attemptVertex() {
    try {
      var r = require;
      var vertx = r('vertx');
      vertxNext = vertx.runOnLoop || vertx.runOnContext;
      return useVertxTimer();
    } catch (e) {
      return useSetTimeout();
    }
  }
  var scheduleFlush;
  if (isNode) {
    scheduleFlush = useNextTick();
  } else if (BrowserMutationObserver) {
    scheduleFlush = useMutationObserver();
  } else if (isWorker) {
    scheduleFlush = useMessageChannel();
  } else if (browserWindow === undefined && typeof require === 'function') {
    scheduleFlush = attemptVertex();
  } else {
    scheduleFlush = useSetTimeout();
  }
  return {get default() {
      return asap;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/Promise.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/Promise.js";
  var async = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../../node_modules/rsvp/lib/rsvp/asap.js", "traceur@0.0.112/src/runtime/polyfills/Promise.js")).default;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/Promise.js")),
      isObject = $__9.isObject,
      registerPolyfill = $__9.registerPolyfill;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../private.js", "traceur@0.0.112/src/runtime/polyfills/Promise.js")),
      createPrivateSymbol = $__10.createPrivateSymbol,
      getPrivate = $__10.getPrivate,
      setPrivate = $__10.setPrivate;
  var promiseRaw = {};
  function isPromise(x) {
    return x && typeof x === 'object' && x.status_ !== undefined;
  }
  function idResolveHandler(x) {
    return x;
  }
  function idRejectHandler(x) {
    throw x;
  }
  function chain(promise) {
    var onResolve = arguments[1] !== (void 0) ? arguments[1] : idResolveHandler;
    var onReject = arguments[2] !== (void 0) ? arguments[2] : idRejectHandler;
    var deferred = getDeferred(promise.constructor);
    switch (promise.status_) {
      case undefined:
        throw TypeError;
      case 0:
        promise.onResolve_.push(onResolve, deferred);
        promise.onReject_.push(onReject, deferred);
        break;
      case +1:
        promiseEnqueue(promise.value_, [onResolve, deferred]);
        break;
      case -1:
        promiseEnqueue(promise.value_, [onReject, deferred]);
        break;
    }
    return deferred.promise;
  }
  function getDeferred(C) {
    if (this === $Promise) {
      var promise = promiseInit(new $Promise(promiseRaw));
      return {
        promise: promise,
        resolve: function(x) {
          promiseResolve(promise, x);
        },
        reject: function(r) {
          promiseReject(promise, r);
        }
      };
    } else {
      var result = {};
      result.promise = new C(function(resolve, reject) {
        result.resolve = resolve;
        result.reject = reject;
      });
      return result;
    }
  }
  function promiseSet(promise, status, value, onResolve, onReject) {
    promise.status_ = status;
    promise.value_ = value;
    promise.onResolve_ = onResolve;
    promise.onReject_ = onReject;
    return promise;
  }
  function promiseInit(promise) {
    return promiseSet(promise, 0, undefined, [], []);
  }
  var Promise = function() {
    function Promise(resolver) {
      if (resolver === promiseRaw)
        return;
      if (typeof resolver !== 'function')
        throw new TypeError;
      var promise = promiseInit(this);
      try {
        resolver(function(x) {
          promiseResolve(promise, x);
        }, function(r) {
          promiseReject(promise, r);
        });
      } catch (e) {
        promiseReject(promise, e);
      }
    }
    return ($traceurRuntime.createClass)(Promise, {
      catch: function(onReject) {
        return this.then(undefined, onReject);
      },
      then: function(onResolve, onReject) {
        if (typeof onResolve !== 'function')
          onResolve = idResolveHandler;
        if (typeof onReject !== 'function')
          onReject = idRejectHandler;
        var that = this;
        var constructor = this.constructor;
        return chain(this, function(x) {
          x = promiseCoerce(constructor, x);
          return x === that ? onReject(new TypeError) : isPromise(x) ? x.then(onResolve, onReject) : onResolve(x);
        }, onReject);
      }
    }, {
      resolve: function(x) {
        if (this === $Promise) {
          if (isPromise(x)) {
            return x;
          }
          return promiseSet(new $Promise(promiseRaw), +1, x);
        } else {
          return new this(function(resolve, reject) {
            resolve(x);
          });
        }
      },
      reject: function(r) {
        if (this === $Promise) {
          return promiseSet(new $Promise(promiseRaw), -1, r);
        } else {
          return new this(function(resolve, reject) {
            reject(r);
          });
        }
      },
      all: function(values) {
        var deferred = getDeferred(this);
        var resolutions = [];
        try {
          var makeCountdownFunction = function(i) {
            return function(x) {
              resolutions[i] = x;
              if (--count === 0)
                deferred.resolve(resolutions);
            };
          };
          var count = 0;
          var i = 0;
          var $__4 = true;
          var $__5 = false;
          var $__6 = undefined;
          try {
            for (var $__2 = void 0,
                $__1 = (values)[Symbol.iterator](); !($__4 = ($__2 = $__1.next()).done); $__4 = true) {
              var value = $__2.value;
              {
                var countdownFunction = makeCountdownFunction(i);
                this.resolve(value).then(countdownFunction, function(r) {
                  deferred.reject(r);
                });
                ++i;
                ++count;
              }
            }
          } catch ($__7) {
            $__5 = true;
            $__6 = $__7;
          } finally {
            try {
              if (!$__4 && $__1.return != null) {
                $__1.return();
              }
            } finally {
              if ($__5) {
                throw $__6;
              }
            }
          }
          if (count === 0) {
            deferred.resolve(resolutions);
          }
        } catch (e) {
          deferred.reject(e);
        }
        return deferred.promise;
      },
      race: function(values) {
        var deferred = getDeferred(this);
        try {
          for (var i = 0; i < values.length; i++) {
            this.resolve(values[i]).then(function(x) {
              deferred.resolve(x);
            }, function(r) {
              deferred.reject(r);
            });
          }
        } catch (e) {
          deferred.reject(e);
        }
        return deferred.promise;
      }
    });
  }();
  var $Promise = Promise;
  var $PromiseReject = $Promise.reject;
  function promiseResolve(promise, x) {
    promiseDone(promise, +1, x, promise.onResolve_);
  }
  function promiseReject(promise, r) {
    promiseDone(promise, -1, r, promise.onReject_);
  }
  function promiseDone(promise, status, value, reactions) {
    if (promise.status_ !== 0)
      return;
    promiseEnqueue(value, reactions);
    promiseSet(promise, status, value);
  }
  function promiseEnqueue(value, tasks) {
    async(function() {
      for (var i = 0; i < tasks.length; i += 2) {
        promiseHandle(value, tasks[i], tasks[i + 1]);
      }
    });
  }
  function promiseHandle(value, handler, deferred) {
    try {
      var result = handler(value);
      if (result === deferred.promise)
        throw new TypeError;
      else if (isPromise(result))
        chain(result, deferred.resolve, deferred.reject);
      else
        deferred.resolve(result);
    } catch (e) {
      try {
        deferred.reject(e);
      } catch (e) {}
    }
  }
  var thenableSymbol = createPrivateSymbol();
  function promiseCoerce(constructor, x) {
    if (!isPromise(x) && isObject(x)) {
      var then;
      try {
        then = x.then;
      } catch (r) {
        var promise = $PromiseReject.call(constructor, r);
        setPrivate(x, thenableSymbol, promise);
        return promise;
      }
      if (typeof then === 'function') {
        var p = getPrivate(x, thenableSymbol);
        if (p) {
          return p;
        } else {
          var deferred = getDeferred(constructor);
          setPrivate(x, thenableSymbol, deferred.promise);
          try {
            then.call(x, deferred.resolve, deferred.reject);
          } catch (r) {
            deferred.reject(r);
          }
          return deferred.promise;
        }
      }
    }
    return x;
  }
  function polyfillPromise(global) {
    if (!global.Promise)
      global.Promise = Promise;
  }
  registerPolyfill(polyfillPromise);
  return {
    get Promise() {
      return Promise;
    },
    get polyfillPromise() {
      return polyfillPromise;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/Promise.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/StringIterator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/StringIterator.js";
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/StringIterator.js")),
      createIteratorResultObject = $__3.createIteratorResultObject,
      isObject = $__3.isObject;
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  var iteratedString = Symbol('iteratedString');
  var stringIteratorNextIndex = Symbol('stringIteratorNextIndex');
  var StringIterator = function() {
    var $__1;
    function StringIterator() {}
    return ($traceurRuntime.createClass)(StringIterator, ($__1 = {}, Object.defineProperty($__1, "next", {
      value: function() {
        var o = this;
        if (!isObject(o) || !hasOwnProperty.call(o, iteratedString)) {
          throw new TypeError('this must be a StringIterator object');
        }
        var s = o[iteratedString];
        if (s === undefined) {
          return createIteratorResultObject(undefined, true);
        }
        var position = o[stringIteratorNextIndex];
        var len = s.length;
        if (position >= len) {
          o[iteratedString] = undefined;
          return createIteratorResultObject(undefined, true);
        }
        var first = s.charCodeAt(position);
        var resultString;
        if (first < 0xD800 || first > 0xDBFF || position + 1 === len) {
          resultString = String.fromCharCode(first);
        } else {
          var second = s.charCodeAt(position + 1);
          if (second < 0xDC00 || second > 0xDFFF) {
            resultString = String.fromCharCode(first);
          } else {
            resultString = String.fromCharCode(first) + String.fromCharCode(second);
          }
        }
        o[stringIteratorNextIndex] = position + resultString.length;
        return createIteratorResultObject(resultString, false);
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), Object.defineProperty($__1, Symbol.iterator, {
      value: function() {
        return this;
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), $__1), {});
  }();
  function createStringIterator(string) {
    var s = String(string);
    var iterator = Object.create(StringIterator.prototype);
    iterator[iteratedString] = s;
    iterator[stringIteratorNextIndex] = 0;
    return iterator;
  }
  return {get createStringIterator() {
      return createStringIterator;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/String.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/String.js";
  var checkObjectCoercible = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../checkObjectCoercible.js", "traceur@0.0.112/src/runtime/polyfills/String.js")).default;
  var createStringIterator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./StringIterator.js", "traceur@0.0.112/src/runtime/polyfills/String.js")).createStringIterator;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/String.js")),
      maybeAddFunctions = $__3.maybeAddFunctions,
      maybeAddIterator = $__3.maybeAddIterator,
      registerPolyfill = $__3.registerPolyfill;
  var $toString = Object.prototype.toString;
  var $indexOf = String.prototype.indexOf;
  var $lastIndexOf = String.prototype.lastIndexOf;
  function startsWith(search) {
    var string = String(this);
    if (this == null || $toString.call(search) == '[object RegExp]') {
      throw TypeError();
    }
    var stringLength = string.length;
    var searchString = String(search);
    var searchLength = searchString.length;
    var position = arguments.length > 1 ? arguments[1] : undefined;
    var pos = position ? Number(position) : 0;
    if (isNaN(pos)) {
      pos = 0;
    }
    var start = Math.min(Math.max(pos, 0), stringLength);
    return $indexOf.call(string, searchString, pos) == start;
  }
  function endsWith(search) {
    var string = String(this);
    if (this == null || $toString.call(search) == '[object RegExp]') {
      throw TypeError();
    }
    var stringLength = string.length;
    var searchString = String(search);
    var searchLength = searchString.length;
    var pos = stringLength;
    if (arguments.length > 1) {
      var position = arguments[1];
      if (position !== undefined) {
        pos = position ? Number(position) : 0;
        if (isNaN(pos)) {
          pos = 0;
        }
      }
    }
    var end = Math.min(Math.max(pos, 0), stringLength);
    var start = end - searchLength;
    if (start < 0) {
      return false;
    }
    return $lastIndexOf.call(string, searchString, start) == start;
  }
  function includes(search) {
    if (this == null) {
      throw TypeError();
    }
    var string = String(this);
    if (search && $toString.call(search) == '[object RegExp]') {
      throw TypeError();
    }
    var stringLength = string.length;
    var searchString = String(search);
    var searchLength = searchString.length;
    var position = arguments.length > 1 ? arguments[1] : undefined;
    var pos = position ? Number(position) : 0;
    if (pos != pos) {
      pos = 0;
    }
    var start = Math.min(Math.max(pos, 0), stringLength);
    if (searchLength + start > stringLength) {
      return false;
    }
    return $indexOf.call(string, searchString, pos) != -1;
  }
  function repeat(count) {
    if (this == null) {
      throw TypeError();
    }
    var string = String(this);
    var n = count ? Number(count) : 0;
    if (isNaN(n)) {
      n = 0;
    }
    if (n < 0 || n == Infinity) {
      throw RangeError();
    }
    if (n == 0) {
      return '';
    }
    var result = '';
    while (n--) {
      result += string;
    }
    return result;
  }
  function codePointAt(position) {
    if (this == null) {
      throw TypeError();
    }
    var string = String(this);
    var size = string.length;
    var index = position ? Number(position) : 0;
    if (isNaN(index)) {
      index = 0;
    }
    if (index < 0 || index >= size) {
      return undefined;
    }
    var first = string.charCodeAt(index);
    var second;
    if (first >= 0xD800 && first <= 0xDBFF && size > index + 1) {
      second = string.charCodeAt(index + 1);
      if (second >= 0xDC00 && second <= 0xDFFF) {
        return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
      }
    }
    return first;
  }
  function raw(callsite) {
    var raw = callsite.raw;
    var len = raw.length >>> 0;
    if (len === 0)
      return '';
    var s = '';
    var i = 0;
    while (true) {
      s += raw[i];
      if (i + 1 === len)
        return s;
      s += arguments[++i];
    }
  }
  function fromCodePoint(_) {
    var codeUnits = [];
    var floor = Math.floor;
    var highSurrogate;
    var lowSurrogate;
    var index = -1;
    var length = arguments.length;
    if (!length) {
      return '';
    }
    while (++index < length) {
      var codePoint = Number(arguments[index]);
      if (!isFinite(codePoint) || codePoint < 0 || codePoint > 0x10FFFF || floor(codePoint) != codePoint) {
        throw RangeError('Invalid code point: ' + codePoint);
      }
      if (codePoint <= 0xFFFF) {
        codeUnits.push(codePoint);
      } else {
        codePoint -= 0x10000;
        highSurrogate = (codePoint >> 10) + 0xD800;
        lowSurrogate = (codePoint % 0x400) + 0xDC00;
        codeUnits.push(highSurrogate, lowSurrogate);
      }
    }
    return String.fromCharCode.apply(null, codeUnits);
  }
  function stringPrototypeIterator() {
    var o = checkObjectCoercible(this);
    var s = String(o);
    return createStringIterator(s);
  }
  function polyfillString(global) {
    var String = global.String;
    maybeAddFunctions(String.prototype, ['codePointAt', codePointAt, 'endsWith', endsWith, 'includes', includes, 'repeat', repeat, 'startsWith', startsWith]);
    maybeAddFunctions(String, ['fromCodePoint', fromCodePoint, 'raw', raw]);
    maybeAddIterator(String.prototype, stringPrototypeIterator, Symbol);
  }
  registerPolyfill(polyfillString);
  return {
    get startsWith() {
      return startsWith;
    },
    get endsWith() {
      return endsWith;
    },
    get includes() {
      return includes;
    },
    get repeat() {
      return repeat;
    },
    get codePointAt() {
      return codePointAt;
    },
    get raw() {
      return raw;
    },
    get fromCodePoint() {
      return fromCodePoint;
    },
    get stringPrototypeIterator() {
      return stringPrototypeIterator;
    },
    get polyfillString() {
      return polyfillString;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/String.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/ArrayIterator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/ArrayIterator.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/ArrayIterator.js")),
      toObject = $__2.toObject,
      toUint32 = $__2.toUint32,
      createIteratorResultObject = $__2.createIteratorResultObject;
  var ARRAY_ITERATOR_KIND_KEYS = 1;
  var ARRAY_ITERATOR_KIND_VALUES = 2;
  var ARRAY_ITERATOR_KIND_ENTRIES = 3;
  var ArrayIterator = function() {
    var $__1;
    function ArrayIterator() {}
    return ($traceurRuntime.createClass)(ArrayIterator, ($__1 = {}, Object.defineProperty($__1, "next", {
      value: function() {
        var iterator = toObject(this);
        var array = iterator.iteratorObject_;
        if (!array) {
          throw new TypeError('Object is not an ArrayIterator');
        }
        var index = iterator.arrayIteratorNextIndex_;
        var itemKind = iterator.arrayIterationKind_;
        var length = toUint32(array.length);
        if (index >= length) {
          iterator.arrayIteratorNextIndex_ = Infinity;
          return createIteratorResultObject(undefined, true);
        }
        iterator.arrayIteratorNextIndex_ = index + 1;
        if (itemKind == ARRAY_ITERATOR_KIND_VALUES)
          return createIteratorResultObject(array[index], false);
        if (itemKind == ARRAY_ITERATOR_KIND_ENTRIES)
          return createIteratorResultObject([index, array[index]], false);
        return createIteratorResultObject(index, false);
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), Object.defineProperty($__1, Symbol.iterator, {
      value: function() {
        return this;
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), $__1), {});
  }();
  function createArrayIterator(array, kind) {
    var object = toObject(array);
    var iterator = new ArrayIterator;
    iterator.iteratorObject_ = object;
    iterator.arrayIteratorNextIndex_ = 0;
    iterator.arrayIterationKind_ = kind;
    return iterator;
  }
  function entries() {
    return createArrayIterator(this, ARRAY_ITERATOR_KIND_ENTRIES);
  }
  function keys() {
    return createArrayIterator(this, ARRAY_ITERATOR_KIND_KEYS);
  }
  function values() {
    return createArrayIterator(this, ARRAY_ITERATOR_KIND_VALUES);
  }
  return {
    get entries() {
      return entries;
    },
    get keys() {
      return keys;
    },
    get values() {
      return values;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/Array.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/Array.js";
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ArrayIterator.js", "traceur@0.0.112/src/runtime/polyfills/Array.js")),
      entries = $__9.entries,
      keys = $__9.keys,
      jsValues = $__9.values;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/Array.js")),
      checkIterable = $__10.checkIterable,
      isCallable = $__10.isCallable,
      isConstructor = $__10.isConstructor,
      maybeAddFunctions = $__10.maybeAddFunctions,
      maybeAddIterator = $__10.maybeAddIterator,
      registerPolyfill = $__10.registerPolyfill,
      toInteger = $__10.toInteger,
      toLength = $__10.toLength,
      toObject = $__10.toObject;
  function from(arrLike) {
    var mapFn = arguments[1];
    var thisArg = arguments[2];
    var C = this;
    var items = toObject(arrLike);
    var mapping = mapFn !== undefined;
    var k = 0;
    var arr,
        len;
    if (mapping && !isCallable(mapFn)) {
      throw TypeError();
    }
    if (checkIterable(items)) {
      arr = isConstructor(C) ? new C() : [];
      var $__3 = true;
      var $__4 = false;
      var $__5 = undefined;
      try {
        for (var $__1 = void 0,
            $__0 = (items)[Symbol.iterator](); !($__3 = ($__1 = $__0.next()).done); $__3 = true) {
          var item = $__1.value;
          {
            if (mapping) {
              arr[k] = mapFn.call(thisArg, item, k);
            } else {
              arr[k] = item;
            }
            k++;
          }
        }
      } catch ($__6) {
        $__4 = true;
        $__5 = $__6;
      } finally {
        try {
          if (!$__3 && $__0.return != null) {
            $__0.return();
          }
        } finally {
          if ($__4) {
            throw $__5;
          }
        }
      }
      arr.length = k;
      return arr;
    }
    len = toLength(items.length);
    arr = isConstructor(C) ? new C(len) : new Array(len);
    for (; k < len; k++) {
      if (mapping) {
        arr[k] = typeof thisArg === 'undefined' ? mapFn(items[k], k) : mapFn.call(thisArg, items[k], k);
      } else {
        arr[k] = items[k];
      }
    }
    arr.length = len;
    return arr;
  }
  function of() {
    for (var items = [],
        $__7 = 0; $__7 < arguments.length; $__7++)
      items[$__7] = arguments[$__7];
    var C = this;
    var len = items.length;
    var arr = isConstructor(C) ? new C(len) : new Array(len);
    for (var k = 0; k < len; k++) {
      arr[k] = items[k];
    }
    arr.length = len;
    return arr;
  }
  function fill(value) {
    var start = arguments[1] !== (void 0) ? arguments[1] : 0;
    var end = arguments[2];
    var object = toObject(this);
    var len = toLength(object.length);
    var fillStart = toInteger(start);
    var fillEnd = end !== undefined ? toInteger(end) : len;
    fillStart = fillStart < 0 ? Math.max(len + fillStart, 0) : Math.min(fillStart, len);
    fillEnd = fillEnd < 0 ? Math.max(len + fillEnd, 0) : Math.min(fillEnd, len);
    while (fillStart < fillEnd) {
      object[fillStart] = value;
      fillStart++;
    }
    return object;
  }
  function find(predicate) {
    var thisArg = arguments[1];
    return findHelper(this, predicate, thisArg);
  }
  function findIndex(predicate) {
    var thisArg = arguments[1];
    return findHelper(this, predicate, thisArg, true);
  }
  function findHelper(self, predicate) {
    var thisArg = arguments[2];
    var returnIndex = arguments[3] !== (void 0) ? arguments[3] : false;
    var object = toObject(self);
    var len = toLength(object.length);
    if (!isCallable(predicate)) {
      throw TypeError();
    }
    for (var i = 0; i < len; i++) {
      var value = object[i];
      if (predicate.call(thisArg, value, i, object)) {
        return returnIndex ? i : value;
      }
    }
    return returnIndex ? -1 : undefined;
  }
  function polyfillArray(global) {
    var $__8 = global,
        Array = $__8.Array,
        Object = $__8.Object,
        Symbol = $__8.Symbol;
    var values = jsValues;
    if (Symbol && Symbol.iterator && Array.prototype[Symbol.iterator]) {
      values = Array.prototype[Symbol.iterator];
    }
    maybeAddFunctions(Array.prototype, ['entries', entries, 'keys', keys, 'values', values, 'fill', fill, 'find', find, 'findIndex', findIndex]);
    maybeAddFunctions(Array, ['from', from, 'of', of]);
    maybeAddIterator(Array.prototype, values, Symbol);
    maybeAddIterator(Object.getPrototypeOf([].values()), function() {
      return this;
    }, Symbol);
  }
  registerPolyfill(polyfillArray);
  return {
    get from() {
      return from;
    },
    get of() {
      return of;
    },
    get fill() {
      return fill;
    },
    get find() {
      return find;
    },
    get findIndex() {
      return findIndex;
    },
    get polyfillArray() {
      return polyfillArray;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/Array.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/assign.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/assign.js";
  var keys = Object.keys;
  function assign(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
      var props = source == null ? [] : keys(source);
      var p = void 0,
          length = props.length;
      for (p = 0; p < length; p++) {
        var name = props[p];
        target[name] = source[name];
      }
    }
    return target;
  }
  return {get default() {
      return assign;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/Object.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/Object.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/Object.js")),
      maybeAddFunctions = $__2.maybeAddFunctions,
      registerPolyfill = $__2.registerPolyfill;
  var assign = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./assign.js", "traceur@0.0.112/src/runtime/polyfills/Object.js")).default;
  var $__0 = Object,
      defineProperty = $__0.defineProperty,
      getOwnPropertyDescriptor = $__0.getOwnPropertyDescriptor,
      getOwnPropertyNames = $__0.getOwnPropertyNames;
  function is(left, right) {
    if (left === right)
      return left !== 0 || 1 / left === 1 / right;
    return left !== left && right !== right;
  }
  function mixin(target, source) {
    var props = getOwnPropertyNames(source);
    var p,
        descriptor,
        length = props.length;
    for (p = 0; p < length; p++) {
      var name = props[p];
      descriptor = getOwnPropertyDescriptor(source, props[p]);
      defineProperty(target, props[p], descriptor);
    }
    return target;
  }
  function polyfillObject(global) {
    var Object = global.Object;
    maybeAddFunctions(Object, ['assign', assign, 'is', is, 'mixin', mixin]);
  }
  registerPolyfill(polyfillObject);
  return {
    get assign() {
      return assign;
    },
    get is() {
      return is;
    },
    get mixin() {
      return mixin;
    },
    get polyfillObject() {
      return polyfillObject;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/Object.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/Number.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/Number.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/Number.js")),
      isNumber = $__1.isNumber,
      maybeAddConsts = $__1.maybeAddConsts,
      maybeAddFunctions = $__1.maybeAddFunctions,
      registerPolyfill = $__1.registerPolyfill,
      toInteger = $__1.toInteger;
  var $abs = Math.abs;
  var $isFinite = isFinite;
  var $isNaN = isNaN;
  var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
  var MIN_SAFE_INTEGER = -Math.pow(2, 53) + 1;
  var EPSILON = Math.pow(2, -52);
  function NumberIsFinite(number) {
    return isNumber(number) && $isFinite(number);
  }
  function isInteger(number) {
    return NumberIsFinite(number) && toInteger(number) === number;
  }
  function NumberIsNaN(number) {
    return isNumber(number) && $isNaN(number);
  }
  function isSafeInteger(number) {
    if (NumberIsFinite(number)) {
      var integral = toInteger(number);
      if (integral === number)
        return $abs(integral) <= MAX_SAFE_INTEGER;
    }
    return false;
  }
  function polyfillNumber(global) {
    var Number = global.Number;
    maybeAddConsts(Number, ['MAX_SAFE_INTEGER', MAX_SAFE_INTEGER, 'MIN_SAFE_INTEGER', MIN_SAFE_INTEGER, 'EPSILON', EPSILON]);
    maybeAddFunctions(Number, ['isFinite', NumberIsFinite, 'isInteger', isInteger, 'isNaN', NumberIsNaN, 'isSafeInteger', isSafeInteger]);
  }
  registerPolyfill(polyfillNumber);
  return {
    get MAX_SAFE_INTEGER() {
      return MAX_SAFE_INTEGER;
    },
    get MIN_SAFE_INTEGER() {
      return MIN_SAFE_INTEGER;
    },
    get EPSILON() {
      return EPSILON;
    },
    get isFinite() {
      return NumberIsFinite;
    },
    get isInteger() {
      return isInteger;
    },
    get isNaN() {
      return NumberIsNaN;
    },
    get isSafeInteger() {
      return isSafeInteger;
    },
    get polyfillNumber() {
      return polyfillNumber;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/Number.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/fround.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/fround.js";
  var $isFinite = isFinite;
  var $isNaN = isNaN;
  var $__0 = Math,
      LN2 = $__0.LN2,
      abs = $__0.abs,
      floor = $__0.floor,
      log = $__0.log,
      min = $__0.min,
      pow = $__0.pow;
  function packIEEE754(v, ebits, fbits) {
    var bias = (1 << (ebits - 1)) - 1,
        s,
        e,
        f,
        ln,
        i,
        bits,
        str,
        bytes;
    function roundToEven(n) {
      var w = floor(n),
          f = n - w;
      if (f < 0.5)
        return w;
      if (f > 0.5)
        return w + 1;
      return w % 2 ? w + 1 : w;
    }
    if (v !== v) {
      e = (1 << ebits) - 1;
      f = pow(2, fbits - 1);
      s = 0;
    } else if (v === Infinity || v === -Infinity) {
      e = (1 << ebits) - 1;
      f = 0;
      s = (v < 0) ? 1 : 0;
    } else if (v === 0) {
      e = 0;
      f = 0;
      s = (1 / v === -Infinity) ? 1 : 0;
    } else {
      s = v < 0;
      v = abs(v);
      if (v >= pow(2, 1 - bias)) {
        e = min(floor(log(v) / LN2), 1023);
        f = roundToEven(v / pow(2, e) * pow(2, fbits));
        if (f / pow(2, fbits) >= 2) {
          e = e + 1;
          f = 1;
        }
        if (e > bias) {
          e = (1 << ebits) - 1;
          f = 0;
        } else {
          e = e + bias;
          f = f - pow(2, fbits);
        }
      } else {
        e = 0;
        f = roundToEven(v / pow(2, 1 - bias - fbits));
      }
    }
    bits = [];
    for (i = fbits; i; i -= 1) {
      bits.push(f % 2 ? 1 : 0);
      f = floor(f / 2);
    }
    for (i = ebits; i; i -= 1) {
      bits.push(e % 2 ? 1 : 0);
      e = floor(e / 2);
    }
    bits.push(s ? 1 : 0);
    bits.reverse();
    str = bits.join('');
    bytes = [];
    while (str.length) {
      bytes.push(parseInt(str.substring(0, 8), 2));
      str = str.substring(8);
    }
    return bytes;
  }
  function unpackIEEE754(bytes, ebits, fbits) {
    var bits = [],
        i,
        j,
        b,
        str,
        bias,
        s,
        e,
        f;
    for (i = bytes.length; i; i -= 1) {
      b = bytes[i - 1];
      for (j = 8; j; j -= 1) {
        bits.push(b % 2 ? 1 : 0);
        b = b >> 1;
      }
    }
    bits.reverse();
    str = bits.join('');
    bias = (1 << (ebits - 1)) - 1;
    s = parseInt(str.substring(0, 1), 2) ? -1 : 1;
    e = parseInt(str.substring(1, 1 + ebits), 2);
    f = parseInt(str.substring(1 + ebits), 2);
    if (e === (1 << ebits) - 1) {
      return f !== 0 ? NaN : s * Infinity;
    } else if (e > 0) {
      return s * pow(2, e - bias) * (1 + f / pow(2, fbits));
    } else if (f !== 0) {
      return s * pow(2, -(bias - 1)) * (f / pow(2, fbits));
    } else {
      return s < 0 ? -0 : 0;
    }
  }
  function unpackF32(b) {
    return unpackIEEE754(b, 8, 23);
  }
  function packF32(v) {
    return packIEEE754(v, 8, 23);
  }
  function fround(x) {
    if (x === 0 || !$isFinite(x) || $isNaN(x)) {
      return x;
    }
    return unpackF32(packF32(Number(x)));
  }
  return {get fround() {
      return fround;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/Math.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/Math.js";
  var jsFround = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./fround.js", "traceur@0.0.112/src/runtime/polyfills/Math.js")).fround;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/Math.js")),
      maybeAddFunctions = $__3.maybeAddFunctions,
      registerPolyfill = $__3.registerPolyfill,
      toUint32 = $__3.toUint32;
  var $isFinite = isFinite;
  var $isNaN = isNaN;
  var $__0 = Math,
      abs = $__0.abs,
      ceil = $__0.ceil,
      exp = $__0.exp,
      floor = $__0.floor,
      log = $__0.log,
      pow = $__0.pow,
      sqrt = $__0.sqrt;
  function clz32(x) {
    x = toUint32(+x);
    if (x == 0)
      return 32;
    var result = 0;
    if ((x & 0xFFFF0000) === 0) {
      x <<= 16;
      result += 16;
    }
    ;
    if ((x & 0xFF000000) === 0) {
      x <<= 8;
      result += 8;
    }
    ;
    if ((x & 0xF0000000) === 0) {
      x <<= 4;
      result += 4;
    }
    ;
    if ((x & 0xC0000000) === 0) {
      x <<= 2;
      result += 2;
    }
    ;
    if ((x & 0x80000000) === 0) {
      x <<= 1;
      result += 1;
    }
    ;
    return result;
  }
  function imul(x, y) {
    x = toUint32(+x);
    y = toUint32(+y);
    var xh = (x >>> 16) & 0xffff;
    var xl = x & 0xffff;
    var yh = (y >>> 16) & 0xffff;
    var yl = y & 0xffff;
    return xl * yl + (((xh * yl + xl * yh) << 16) >>> 0) | 0;
  }
  function sign(x) {
    x = +x;
    if (x > 0)
      return 1;
    if (x < 0)
      return -1;
    return x;
  }
  function log10(x) {
    return log(x) * 0.434294481903251828;
  }
  function log2(x) {
    return log(x) * 1.442695040888963407;
  }
  function log1p(x) {
    x = +x;
    if (x < -1 || $isNaN(x)) {
      return NaN;
    }
    if (x === 0 || x === Infinity) {
      return x;
    }
    if (x === -1) {
      return -Infinity;
    }
    var result = 0;
    var n = 50;
    if (x < 0 || x > 1) {
      return log(1 + x);
    }
    for (var i = 1; i < n; i++) {
      if ((i % 2) === 0) {
        result -= pow(x, i) / i;
      } else {
        result += pow(x, i) / i;
      }
    }
    return result;
  }
  function expm1(x) {
    x = +x;
    if (x === -Infinity) {
      return -1;
    }
    if (!$isFinite(x) || x === 0) {
      return x;
    }
    return exp(x) - 1;
  }
  function cosh(x) {
    x = +x;
    if (x === 0) {
      return 1;
    }
    if ($isNaN(x)) {
      return NaN;
    }
    if (!$isFinite(x)) {
      return Infinity;
    }
    if (x < 0) {
      x = -x;
    }
    if (x > 21) {
      return exp(x) / 2;
    }
    return (exp(x) + exp(-x)) / 2;
  }
  function sinh(x) {
    x = +x;
    if (!$isFinite(x) || x === 0) {
      return x;
    }
    return (exp(x) - exp(-x)) / 2;
  }
  function tanh(x) {
    x = +x;
    if (x === 0)
      return x;
    if (!$isFinite(x))
      return sign(x);
    var exp1 = exp(x);
    var exp2 = exp(-x);
    return (exp1 - exp2) / (exp1 + exp2);
  }
  function acosh(x) {
    x = +x;
    if (x < 1)
      return NaN;
    if (!$isFinite(x))
      return x;
    return log(x + sqrt(x + 1) * sqrt(x - 1));
  }
  function asinh(x) {
    x = +x;
    if (x === 0 || !$isFinite(x))
      return x;
    if (x > 0)
      return log(x + sqrt(x * x + 1));
    return -log(-x + sqrt(x * x + 1));
  }
  function atanh(x) {
    x = +x;
    if (x === -1) {
      return -Infinity;
    }
    if (x === 1) {
      return Infinity;
    }
    if (x === 0) {
      return x;
    }
    if ($isNaN(x) || x < -1 || x > 1) {
      return NaN;
    }
    return 0.5 * log((1 + x) / (1 - x));
  }
  function hypot(x, y) {
    var length = arguments.length;
    var args = new Array(length);
    var max = 0;
    for (var i = 0; i < length; i++) {
      var n = arguments[i];
      n = +n;
      if (n === Infinity || n === -Infinity)
        return Infinity;
      n = abs(n);
      if (n > max)
        max = n;
      args[i] = n;
    }
    if (max === 0)
      max = 1;
    var sum = 0;
    var compensation = 0;
    for (var i = 0; i < length; i++) {
      var n = args[i] / max;
      var summand = n * n - compensation;
      var preliminary = sum + summand;
      compensation = (preliminary - sum) - summand;
      sum = preliminary;
    }
    return sqrt(sum) * max;
  }
  function trunc(x) {
    x = +x;
    if (x > 0)
      return floor(x);
    if (x < 0)
      return ceil(x);
    return x;
  }
  var fround,
      f32;
  if (typeof Float32Array === 'function') {
    f32 = new Float32Array(1);
    fround = function(x) {
      f32[0] = Number(x);
      return f32[0];
    };
  } else {
    fround = jsFround;
  }
  function cbrt(x) {
    x = +x;
    if (x === 0)
      return x;
    var negate = x < 0;
    if (negate)
      x = -x;
    var result = pow(x, 1 / 3);
    return negate ? -result : result;
  }
  function polyfillMath(global) {
    var Math = global.Math;
    maybeAddFunctions(Math, ['acosh', acosh, 'asinh', asinh, 'atanh', atanh, 'cbrt', cbrt, 'clz32', clz32, 'cosh', cosh, 'expm1', expm1, 'fround', fround, 'hypot', hypot, 'imul', imul, 'log10', log10, 'log1p', log1p, 'log2', log2, 'sign', sign, 'sinh', sinh, 'tanh', tanh, 'trunc', trunc]);
  }
  registerPolyfill(polyfillMath);
  return {
    get clz32() {
      return clz32;
    },
    get imul() {
      return imul;
    },
    get sign() {
      return sign;
    },
    get log10() {
      return log10;
    },
    get log2() {
      return log2;
    },
    get log1p() {
      return log1p;
    },
    get expm1() {
      return expm1;
    },
    get cosh() {
      return cosh;
    },
    get sinh() {
      return sinh;
    },
    get tanh() {
      return tanh;
    },
    get acosh() {
      return acosh;
    },
    get asinh() {
      return asinh;
    },
    get atanh() {
      return atanh;
    },
    get hypot() {
      return hypot;
    },
    get trunc() {
      return trunc;
    },
    get fround() {
      return fround;
    },
    get cbrt() {
      return cbrt;
    },
    get polyfillMath() {
      return polyfillMath;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/Math.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/WeakMap.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/WeakMap.js";
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../private.js", "traceur@0.0.112/src/runtime/polyfills/WeakMap.js")),
      createPrivateSymbol = $__5.createPrivateSymbol,
      deletePrivate = $__5.deletePrivate,
      getPrivate = $__5.getPrivate,
      hasPrivate = $__5.hasPrivate,
      setPrivate = $__5.setPrivate;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../frozen-data.js", "traceur@0.0.112/src/runtime/polyfills/WeakMap.js")),
      deleteFrozen = $__6.deleteFrozen,
      getFrozen = $__6.getFrozen,
      hasFrozen = $__6.hasFrozen,
      setFrozen = $__6.setFrozen;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/WeakMap.js")),
      isObject = $__7.isObject,
      registerPolyfill = $__7.registerPolyfill;
  var hasNativeSymbol = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../has-native-symbols.js", "traceur@0.0.112/src/runtime/polyfills/WeakMap.js")).default;
  var $__2 = Object,
      defineProperty = $__2.defineProperty,
      getOwnPropertyDescriptor = $__2.getOwnPropertyDescriptor,
      isExtensible = $__2.isExtensible;
  var $TypeError = TypeError;
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  var sentinel = {};
  var WeakMap = function() {
    function WeakMap() {
      this.name_ = createPrivateSymbol();
      this.frozenData_ = [];
    }
    return ($traceurRuntime.createClass)(WeakMap, {
      set: function(key, value) {
        if (!isObject(key))
          throw new $TypeError('key must be an object');
        if (!isExtensible(key)) {
          setFrozen(this.frozenData_, key, value);
        } else {
          setPrivate(key, this.name_, value);
        }
        return this;
      },
      get: function(key) {
        if (!isObject(key))
          return undefined;
        if (!isExtensible(key)) {
          return getFrozen(this.frozenData_, key);
        }
        return getPrivate(key, this.name_);
      },
      delete: function(key) {
        if (!isObject(key))
          return false;
        if (!isExtensible(key)) {
          return deleteFrozen(this.frozenData_, key);
        }
        return deletePrivate(key, this.name_);
      },
      has: function(key) {
        if (!isObject(key))
          return false;
        if (!isExtensible(key)) {
          return hasFrozen(this.frozenData_, key);
        }
        return hasPrivate(key, this.name_);
      }
    }, {});
  }();
  function needsPolyfill(global) {
    var $__4 = global,
        WeakMap = $__4.WeakMap,
        Symbol = $__4.Symbol;
    if (!WeakMap || !hasNativeSymbol()) {
      return true;
    }
    try {
      var o = {};
      var wm = new WeakMap([[o, false]]);
      return wm.get(o);
    } catch (e) {
      return false;
    }
  }
  function polyfillWeakMap(global) {
    if (needsPolyfill(global)) {
      global.WeakMap = WeakMap;
    }
  }
  registerPolyfill(polyfillWeakMap);
  return {
    get WeakMap() {
      return WeakMap;
    },
    get polyfillWeakMap() {
      return polyfillWeakMap;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/WeakMap.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/WeakSet.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/WeakSet.js";
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../private.js", "traceur@0.0.112/src/runtime/polyfills/WeakSet.js")),
      createPrivateSymbol = $__5.createPrivateSymbol,
      deletePrivate = $__5.deletePrivate,
      getPrivate = $__5.getPrivate,
      hasPrivate = $__5.hasPrivate,
      setPrivate = $__5.setPrivate;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../frozen-data.js", "traceur@0.0.112/src/runtime/polyfills/WeakSet.js")),
      deleteFrozen = $__6.deleteFrozen,
      getFrozen = $__6.getFrozen,
      setFrozen = $__6.setFrozen;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/WeakSet.js")),
      isObject = $__7.isObject,
      registerPolyfill = $__7.registerPolyfill;
  var hasNativeSymbol = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../has-native-symbols.js", "traceur@0.0.112/src/runtime/polyfills/WeakSet.js")).default;
  var $__2 = Object,
      defineProperty = $__2.defineProperty,
      isExtensible = $__2.isExtensible;
  var $TypeError = TypeError;
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  var WeakSet = function() {
    function WeakSet() {
      this.name_ = createPrivateSymbol();
      this.frozenData_ = [];
    }
    return ($traceurRuntime.createClass)(WeakSet, {
      add: function(value) {
        if (!isObject(value))
          throw new $TypeError('value must be an object');
        if (!isExtensible(value)) {
          setFrozen(this.frozenData_, value, value);
        } else {
          setPrivate(value, this.name_, true);
        }
        return this;
      },
      delete: function(value) {
        if (!isObject(value))
          return false;
        if (!isExtensible(value)) {
          return deleteFrozen(this.frozenData_, value);
        }
        return deletePrivate(value, this.name_);
      },
      has: function(value) {
        if (!isObject(value))
          return false;
        if (!isExtensible(value)) {
          return getFrozen(this.frozenData_, value) === value;
        }
        return hasPrivate(value, this.name_);
      }
    }, {});
  }();
  function needsPolyfill(global) {
    var $__4 = global,
        WeakSet = $__4.WeakSet,
        Symbol = $__4.Symbol;
    if (!WeakSet || !hasNativeSymbol()) {
      return true;
    }
    try {
      var o = {};
      var wm = new WeakSet([[o]]);
      return !wm.has(o);
    } catch (e) {
      return false;
    }
  }
  function polyfillWeakSet(global) {
    if (needsPolyfill(global)) {
      global.WeakSet = WeakSet;
    }
  }
  registerPolyfill(polyfillWeakSet);
  return {
    get WeakSet() {
      return WeakSet;
    },
    get polyfillWeakSet() {
      return polyfillWeakSet;
    }
  };
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/WeakSet.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/runtime/polyfills/polyfills.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/runtime/polyfills/polyfills.js";
  var polyfillAll = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./utils.js", "traceur@0.0.112/src/runtime/polyfills/polyfills.js")).polyfillAll;
  polyfillAll(Reflect.global);
  var setupGlobals = $traceurRuntime.setupGlobals;
  $traceurRuntime.setupGlobals = function(global) {
    setupGlobals(global);
    polyfillAll(global);
  };
  return {};
});
$traceurRuntime.getModule("traceur@0.0.112/src/runtime/polyfills/polyfills.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/util/SourceRange.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/SourceRange.js";
  var SourceRange = function() {
    function SourceRange(start, end) {
      this.start = start;
      this.end = end;
    }
    return ($traceurRuntime.createClass)(SourceRange, {toString: function() {
        var str = this.start.source.contents;
        return str.slice(this.start.offset, this.end.offset);
      }}, {});
  }();
  return {get SourceRange() {
      return SourceRange;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/ErrorReporter.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/ErrorReporter.js";
  var SourceRange = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SourceRange.js", "traceur@0.0.112/src/util/ErrorReporter.js")).SourceRange;
  var ErrorReporter = function() {
    function ErrorReporter() {
      this.hadError_ = false;
    }
    return ($traceurRuntime.createClass)(ErrorReporter, {
      reportError: function(location, message) {
        this.hadError_ = true;
        this.reportMessageInternal(location, message);
      },
      reportMessageInternal: function(location, message) {
        if (location)
          message = (location.start + ": " + message);
        console.error(message);
      },
      hadError: function() {
        return this.hadError_;
      },
      clearError: function() {
        this.hadError_ = false;
      }
    }, {});
  }();
  function format(location, text) {
    var args = arguments[2];
    var i = 0;
    text = text.replace(/%./g, function(s) {
      switch (s) {
        case '%s':
          return args && args[i++];
        case '%%':
          return '%';
      }
      return s;
    });
    if (location)
      text = (location + ": " + text);
    return text;
  }
  ;
  ErrorReporter.format = format;
  return {
    get ErrorReporter() {
      return ErrorReporter;
    },
    get format() {
      return format;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/MutedErrorReporter.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/MutedErrorReporter.js";
  var ErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ErrorReporter.js", "traceur@0.0.112/src/util/MutedErrorReporter.js")).ErrorReporter;
  var MutedErrorReporter = function($__super) {
    function MutedErrorReporter() {
      $traceurRuntime.superConstructor(MutedErrorReporter).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(MutedErrorReporter, {reportMessageInternal: function(location, format, args) {}}, {}, $__super);
  }(ErrorReporter);
  return {get MutedErrorReporter() {
      return MutedErrorReporter;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/Options.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/Options.js";
  function enumerableOnlyObject(obj) {
    var result = Object.create(null);
    Object.keys(obj).forEach(function(key) {
      Object.defineProperty(result, key, {
        enumerable: true,
        value: obj[key]
      });
    });
    return result;
  }
  var optionsV01 = enumerableOnlyObject({
    annotations: false,
    arrayComprehension: false,
    arrowFunctions: true,
    asyncFunctions: false,
    asyncGenerators: false,
    blockBinding: true,
    classes: true,
    commentCallback: false,
    computedPropertyNames: true,
    debug: false,
    debugNames: false,
    defaultParameters: true,
    destructuring: true,
    exponentiation: false,
    exportFromExtended: false,
    forOf: true,
    forOn: false,
    freeVariableChecker: false,
    generatorComprehension: false,
    generators: true,
    importRuntime: false,
    inputSourceMap: false,
    jsx: false,
    lowResolutionSourceMap: false,
    memberVariables: false,
    moduleName: 'default',
    modules: 'bootstrap',
    numericLiterals: true,
    outputLanguage: 'es5',
    properTailCalls: false,
    propertyMethods: true,
    propertyNameShorthand: true,
    referrer: '',
    require: false,
    restParameters: true,
    script: false,
    sourceMaps: false,
    sourceRoot: false,
    spread: true,
    spreadProperties: false,
    symbols: true,
    templateLiterals: true,
    types: false,
    unicodeEscapeSequences: true,
    unicodeExpressions: true,
    validate: false
  });
  var versionLockedOptions = optionsV01;
  var defaultValues = Object.create(null);
  var featureOptions = Object.create(null);
  var experimentalOptions = Object.create(null);
  var moduleOptions = ['amd', 'commonjs', 'closure', 'instantiate', 'inline', 'bootstrap', 'parse'];
  var EXPERIMENTAL = 0;
  var ON_BY_DEFAULT = 1;
  function addFeatureOption(name, kind) {
    featureOptions[name] = true;
    if (kind === EXPERIMENTAL)
      experimentalOptions[name] = true;
    var defaultValue = kind === ON_BY_DEFAULT;
    defaultValues[name] = defaultValue;
  }
  function addBoolOption(name) {
    defaultValues[name] = false;
  }
  addFeatureOption('arrowFunctions', ON_BY_DEFAULT);
  addFeatureOption('blockBinding', ON_BY_DEFAULT);
  addFeatureOption('classes', ON_BY_DEFAULT);
  addFeatureOption('computedPropertyNames', ON_BY_DEFAULT);
  addFeatureOption('defaultParameters', ON_BY_DEFAULT);
  addFeatureOption('destructuring', ON_BY_DEFAULT);
  addFeatureOption('forOf', ON_BY_DEFAULT);
  addFeatureOption('generators', ON_BY_DEFAULT);
  addFeatureOption('modules', 'SPECIAL');
  addFeatureOption('numericLiterals', ON_BY_DEFAULT);
  addFeatureOption('propertyMethods', ON_BY_DEFAULT);
  addFeatureOption('propertyNameShorthand', ON_BY_DEFAULT);
  addFeatureOption('restParameters', ON_BY_DEFAULT);
  addFeatureOption('sourceMaps', 'SPECIAL');
  addFeatureOption('spread', ON_BY_DEFAULT);
  addFeatureOption('symbols', ON_BY_DEFAULT);
  addFeatureOption('templateLiterals', ON_BY_DEFAULT);
  addFeatureOption('unicodeEscapeSequences', ON_BY_DEFAULT);
  addFeatureOption('unicodeExpressions', ON_BY_DEFAULT);
  addFeatureOption('properTailCalls', EXPERIMENTAL);
  addFeatureOption('annotations', EXPERIMENTAL);
  addFeatureOption('arrayComprehension', EXPERIMENTAL);
  addFeatureOption('asyncFunctions', EXPERIMENTAL);
  addFeatureOption('asyncGenerators', EXPERIMENTAL);
  addFeatureOption('exponentiation', EXPERIMENTAL);
  addFeatureOption('exportFromExtended', EXPERIMENTAL);
  addFeatureOption('forOn', EXPERIMENTAL);
  addFeatureOption('generatorComprehension', EXPERIMENTAL);
  addFeatureOption('importRuntime', EXPERIMENTAL);
  addFeatureOption('jsx', EXPERIMENTAL);
  addFeatureOption('memberVariables', EXPERIMENTAL);
  addFeatureOption('require', EXPERIMENTAL);
  addFeatureOption('spreadProperties', EXPERIMENTAL);
  addFeatureOption('types', EXPERIMENTAL);
  var transformOptionsPrototype = {};
  Object.keys(featureOptions).forEach(function(name) {
    Object.defineProperty(transformOptionsPrototype, name, {
      get: function() {
        var v = this.proxiedOptions_[name];
        if (v === 'parse')
          return false;
        return v;
      },
      enumerable: true
    });
  });
  var parseOptionsPrototype = {};
  Object.keys(featureOptions).forEach(function(name) {
    Object.defineProperty(parseOptionsPrototype, name, {
      get: function() {
        return !!this.proxiedOptions_[name];
      },
      enumerable: true
    });
  });
  addBoolOption('commentCallback');
  addBoolOption('debug');
  addBoolOption('debugNames');
  addBoolOption('freeVariableChecker');
  addBoolOption('script');
  addBoolOption('validate');
  var Options = function() {
    function Options() {
      var options = arguments[0] !== (void 0) ? arguments[0] : Object.create(null);
      this.reset();
      Object.defineProperties(this, {
        modules_: {
          value: versionLockedOptions.modules,
          writable: true,
          enumerable: false
        },
        sourceMaps_: {
          value: versionLockedOptions.sourceMaps,
          writable: true,
          enumerable: false
        },
        sourceRoot_: {
          value: versionLockedOptions.sourceRoot,
          writable: true,
          enumerable: false
        },
        transformOptions: {
          value: Object.create(transformOptionsPrototype, {proxiedOptions_: {
              value: this,
              enumerable: false
            }}),
          enumerable: false
        },
        parseOptions: {
          value: Object.create(parseOptionsPrototype, {proxiedOptions_: {
              value: this,
              enumerable: false
            }}),
          enumerable: false
        }
      });
      this.setFromObject(options);
    }
    return ($traceurRuntime.createClass)(Options, {
      set experimental(v) {
        var $__2 = this;
        v = coerceOptionValue(v);
        Object.keys(experimentalOptions).forEach(function(name) {
          $__2[name] = v;
        });
      },
      get experimental() {
        var $__2 = this;
        var value;
        Object.keys(experimentalOptions).every(function(name) {
          var currentValue = $__2[name];
          if (value === undefined) {
            value = currentValue;
            return true;
          }
          if (currentValue !== value) {
            value = null;
            return false;
          }
          return true;
        });
        return value;
      },
      get atscript() {
        return this.types && this.annotations && this.memberVariables;
      },
      set atscript(value) {
        this.types = value;
        this.annotations = value;
        this.memberVariables = value;
      },
      get modules() {
        return this.modules_;
      },
      set modules(value) {
        if (typeof value === 'boolean' && !value)
          value = 'bootstrap';
        if (moduleOptions.indexOf(value) === -1) {
          throw new Error('Invalid \'modules\' option \'' + value + '\', not in ' + moduleOptions.join(', '));
        }
        this.modules_ = value;
      },
      get sourceMaps() {
        return this.sourceMaps_;
      },
      set sourceMaps(value) {
        if (value === null || typeof value === 'boolean') {
          this.sourceMaps_ = value ? 'file' : false;
          return;
        }
        if (value === 'file' || value === 'inline' || value === 'memory') {
          this.sourceMaps_ = value;
        } else {
          throw new Error('Option sourceMaps should be ' + '[false|inline|file|memory], not ' + value);
        }
      },
      reset: function() {
        var allOff = arguments[0];
        var $__2 = this;
        var useDefault = allOff === undefined;
        Object.keys(defaultValues).forEach(function(name) {
          $__2[name] = useDefault && defaultValues[name];
        });
        this.setDefaults();
      },
      setDefaults: function() {
        this.modules = 'bootstrap';
        this.moduleName = 'default';
        this.outputLanguage = 'es5';
        this.referrer = '';
        this.sourceMaps = false;
        this.sourceRoot = false;
        this.lowResolutionSourceMap = false;
        this.inputSourceMap = false;
      },
      setFromObject: function(object) {
        var $__2 = this;
        Object.keys(this).forEach(function(name) {
          if (name in object)
            $__2.setOption(name, object[name]);
        });
        this.modules = object.modules || this.modules;
        if (typeof object.sourceMaps === 'boolean' || typeof object.sourceMaps === 'string') {
          this.sourceMaps = object.sourceMaps;
        }
        if (object.sourceRoot !== undefined)
          this.sourceRoot = object.sourceRoot;
        return this;
      },
      setOption: function(name, value) {
        name = toCamelCase(name);
        if (name in this) {
          this[name] = value;
        } else {
          throw Error('Unknown option: ' + name);
        }
      },
      diff: function(ref) {
        var $__2 = this;
        var mismatches = [];
        Object.keys(this).forEach(function(key) {
          if ($__2[key] !== ref[key]) {
            mismatches.push({
              key: key,
              now: $traceurRuntime.options[key],
              v01: ref[key]
            });
          }
        });
        return mismatches;
      }
    }, {
      experimental: function() {
        return new Options(experimentalOptions);
      },
      atscript: function() {
        return new Options({
          types: true,
          annotations: true,
          memberVariables: true
        });
      },
      listUnknownOptions: function(obj) {
        var unknowns = [];
        Object.keys(obj).forEach(function(propName) {
          if (!(propName in optionsV01)) {
            unknowns.push(propName);
          }
        });
        return unknowns;
      }
    });
  }();
  ;
  var descriptions = {
    experimental: 'Turns on all experimental features',
    require: 'Generate require function argument for node when modules=register',
    sourceMaps: 'Generate source map and (\'file\') write to .map' + ' or (\'inline\') append data URL'
  };
  var CommandOptions = function($__super) {
    function CommandOptions() {
      $traceurRuntime.superConstructor(CommandOptions).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(CommandOptions, {
      parseCommand: function(s) {
        var re = /--([^=]+)(?:=(.+))?/;
        var m = re.exec(s);
        if (m)
          this.setOptionCoerced(m[1], m[2]);
      },
      setOptionCoerced: function(name, value) {
        if (typeof value !== 'undefined' && value !== null)
          value = coerceOptionValue(value);
        else
          value = true;
        this.setOption(name, value);
      }
    }, {
      fromString: function(s) {
        return CommandOptions.fromArgv(s.split(/\s+/));
      },
      fromArgv: function(args) {
        var options = new CommandOptions();
        args.forEach(function(arg) {
          return options.parseCommand(arg);
        });
        return options;
      }
    }, $__super);
  }(Options);
  function coerceOptionValue(v) {
    switch (v) {
      case 'false':
        return false;
      case 'true':
      case true:
        return true;
      default:
        return !!v && String(v);
    }
  }
  function toCamelCase(s) {
    return s.replace(/-\w/g, function(ch) {
      return ch[1].toUpperCase();
    });
  }
  function toDashCase(s) {
    return s.replace(/[A-Z]/g, function(ch) {
      return '-' + ch.toLowerCase();
    });
  }
  function addOptions(flags, commandOptions) {
    flags.option('--referrer <name>', 'Bracket output code with System.referrerName=<name>', function(name) {
      commandOptions.setOption('referrer', name);
      System.map = System.semverMap(name);
      return name;
    });
    flags.option('--modules <' + moduleOptions.join(', ') + '>', 'select the output format for modules', function(moduleFormat) {
      commandOptions.modules = moduleFormat;
    });
    flags.option('--moduleName [true|false|default]', 'true for named, false for anonymous modules; default depends on --modules', function(moduleName) {
      if (moduleName === 'true')
        moduleName = true;
      else if (moduleName === 'false')
        moduleName = false;
      else
        moduleName = 'default';
      commandOptions.moduleName = moduleName;
    });
    flags.option('--outputLanguage <es6|es5>', 'compilation target language', function(outputLanguage) {
      if (outputLanguage === 'es6' || outputLanguage === 'es5')
        commandOptions.outputLanguage = outputLanguage;
      else
        throw new Error('outputLanguage must be one of es5, es6');
    });
    flags.option('--source-maps [file|inline|memory]', 'sourceMaps generated to file or inline with data: URL', function(to) {
      return commandOptions.sourceMaps = to;
    });
    flags.option('--source-root <true|false|string>', 'sourcemap sourceRoot value. false to omit, ' + 'true for directory of output file.', function(to) {
      if (to === 'false')
        to = false;
      else if (to === 'true')
        to = true;
      return commandOptions.sourceRoot = to;
    });
    flags.option('--low-resolution-source-maps', 'Lower sourceMaps granularity to one mapping per output line', function() {
      return commandOptions.lowResolutionSourceMap = true;
    });
    flags.option('--experimental', 'Turns on all experimental features', function() {
      commandOptions.experimental = true;
    });
    flags.option('--atscript', 'Turns on all AtScript features', function() {
      commandOptions.atscript = true;
    });
    Object.keys(commandOptions).forEach(function(name) {
      var dashedName = toDashCase(name);
      if (flags.optionFor('--' + name) || flags.optionFor('--' + dashedName)) {
        return;
      } else if (name in featureOptions) {
        flags.option('--' + dashedName + ' [true|false|parse]', descriptions[name]);
        flags.on(dashedName, function(value) {
          return commandOptions.setOptionCoerced(dashedName, value);
        });
      } else if (commandOptions[name] !== null) {
        flags.option('--' + dashedName, descriptions[name]);
        flags.on(dashedName, function() {
          return commandOptions.setOption(dashedName, true);
        });
      } else {
        throw new Error('Unexpected null commandOption ' + name);
      }
    });
    commandOptions.setDefaults();
  }
  return {
    get optionsV01() {
      return optionsV01;
    },
    get versionLockedOptions() {
      return versionLockedOptions;
    },
    get Options() {
      return Options;
    },
    get CommandOptions() {
      return CommandOptions;
    },
    get toDashCase() {
      return toDashCase;
    },
    get addOptions() {
      return addOptions;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/webLoader.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/webLoader.js";
  var webLoader = {load: function(url, callback, errback) {
      var xhr = new XMLHttpRequest();
      xhr.onload = function() {
        if (xhr.status == 200 || xhr.status == 0) {
          callback(xhr.responseText);
        } else {
          var err;
          if (xhr.status === 404)
            err = 'File not found \'' + url + '\'';
          else
            err = xhr.status + xhr.statusText;
          errback(err);
        }
        xhr = null;
      };
      xhr.onerror = function(err) {
        errback(err);
      };
      xhr.open('GET', url, true);
      xhr.send();
      return function() {
        xhr && xhr.abort();
      };
    }};
  return {get webLoader() {
      return webLoader;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/WebPageTranscoder.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/WebPageTranscoder.js";
  var ErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util/ErrorReporter.js", "traceur@0.0.112/src/WebPageTranscoder.js")).ErrorReporter;
  var CommandOptions = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Options.js", "traceur@0.0.112/src/WebPageTranscoder.js")).CommandOptions;
  var webLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./loader/webLoader.js", "traceur@0.0.112/src/WebPageTranscoder.js")).webLoader;
  var scriptSelector = 'script[type="module"],script[type="text/traceur"]';
  var WebPageTranscoder = function() {
    function WebPageTranscoder() {
      var url = arguments[0] !== (void 0) ? arguments[0] : document.location.href;
      var traceurOptions = arguments[1] !== (void 0) ? arguments[1] : new Options();
      this.url = url;
      this.numPending_ = 0;
      this.numberInlined_ = 0;
      this.traceurOptions_ = traceurOptions;
    }
    return ($traceurRuntime.createClass)(WebPageTranscoder, {
      asyncLoad_: function(url, fncOfContent, onScriptsReady) {
        var $__3 = this;
        this.numPending_++;
        webLoader.load(url, function(content) {
          if (content)
            fncOfContent(content);
          else
            console.warn('Failed to load', url);
          if (--$__3.numPending_ <= 0)
            onScriptsReady();
        }, function(error) {
          console.error('WebPageTranscoder FAILED to load ' + url, error.stack || error);
        });
      },
      addFileFromScriptElement: function(scriptElement, name, content) {
        var options = this.traceurOptions_;
        var elementOptionString = scriptElement.getAttribute('traceurOptions');
        if (elementOptionString) {
          options = CommandOptions.fromString(elementOptionString);
        }
        var nameInfo = {
          address: name,
          referrerName: window.location.href,
          name: name,
          metadata: {traceurOptions: options}
        };
        var loadingResult;
        if (scriptElement.type === 'module')
          loadingResult = System.module(content, nameInfo);
        else
          loadingResult = System.script(content, nameInfo);
        loadingResult.catch(function(error) {
          console.error(error.stack || error);
        });
      },
      nextInlineScriptName_: function() {
        this.numberInlined_ += 1;
        if (!this.inlineScriptNameBase_) {
          var segments = this.url.split('.');
          segments.pop();
          this.inlineScriptNameBase_ = segments.join('.');
        }
        return this.inlineScriptNameBase_ + '_inline_script_' + this.numberInlined_ + '.js';
      },
      addFilesFromScriptElements: function(scriptElements, onScriptsReady) {
        for (var i = 0,
            length = scriptElements.length; i < length; i++) {
          var scriptElement = scriptElements[i];
          if (!scriptElement.src) {
            var name = this.nextInlineScriptName_();
            var content = scriptElement.textContent;
            this.addFileFromScriptElement(scriptElement, name, content);
          } else {
            var name$__4 = scriptElement.src;
            this.asyncLoad_(name$__4, this.addFileFromScriptElement.bind(this, scriptElement, name$__4), onScriptsReady);
          }
        }
        if (this.numPending_ <= 0)
          onScriptsReady();
      },
      get reporter() {
        if (!this.reporter_) {
          this.reporter_ = new ErrorReporter();
        }
        return this.reporter_;
      },
      putFile: function(file) {
        var scriptElement = document.createElement('script');
        scriptElement.setAttribute('data-traceur-src-url', file.name);
        scriptElement.textContent = file.generatedSource;
        var parent = file.scriptElement.parentNode;
        parent.insertBefore(scriptElement, file.scriptElement || null);
      },
      selectAndProcessScripts: function(done) {
        var selector = scriptSelector;
        var scripts = document.querySelectorAll(selector);
        if (!scripts.length) {
          done();
          return;
        }
        this.addFilesFromScriptElements(scripts, function() {
          done();
        });
      },
      run: function() {
        var done = arguments[0] !== (void 0) ? arguments[0] : function() {};
        var $__3 = this;
        var ready = document.readyState;
        if (ready === 'complete' || ready === 'loaded') {
          this.selectAndProcessScripts(done);
        } else {
          document.addEventListener('DOMContentLoaded', function() {
            return $__3.selectAndProcessScripts(done);
          }, false);
        }
      }
    }, {});
  }();
  return {
    get scriptSelector() {
      return scriptSelector;
    },
    get WebPageTranscoder() {
      return WebPageTranscoder;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/StringSet.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/StringSet.js";
  function assertString(value) {
    if (typeof value !== 'string')
      throw new TypeError();
  }
  var StringSet = function() {
    function StringSet() {
      this.storage_ = Object.create(null);
    }
    return ($traceurRuntime.createClass)(StringSet, {
      add: function(value) {
        assertString(value);
        this.storage_[value] = true;
      },
      has: function(value) {
        assertString(value);
        return this.storage_[value] !== undefined;
      },
      delete: function(value) {
        assertString(value);
        delete this.storage_[value];
      },
      isEmpty: function() {
        for (var _ in this.storage_) {
          return false;
        }
        return true;
      },
      valuesAsArray: function() {
        return Object.keys(this.storage_);
      },
      forEach: function(func) {
        for (var value in this.storage_) {
          func(value);
        }
      }
    }, {});
  }();
  return {get StringSet() {
      return StringSet;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/StringMap.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/StringMap.js";
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./StringSet.js", "traceur@0.0.112/src/util/StringMap.js")).StringSet;
  function assertString(value) {
    if (typeof value !== 'string')
      throw new TypeError();
  }
  var StringMap = function() {
    function StringMap() {
      this.storage_ = Object.create(null);
    }
    return ($traceurRuntime.createClass)(StringMap, {
      set: function(key, value) {
        assertString(key);
        this.storage_[key] = value;
      },
      get: function(key) {
        assertString(key);
        return this.storage_[key];
      },
      delete: function(key) {
        assertString(key);
        delete this.storage_[key];
      },
      has: function(key) {
        assertString(key);
        return this.storage_[key] !== undefined;
      },
      keysAsArray: function() {
        return Object.keys(this.storage_);
      },
      keysAsSet: function() {
        var set = new StringSet();
        this.forEach(function(key) {
          return set.add(key);
        });
        return set;
      },
      forEach: function(func) {
        for (var key in this.storage_) {
          func(key, this.storage_[key]);
        }
      }
    }, {});
  }();
  return {get StringMap() {
      return StringMap;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/HTMLImportTranscoder.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/HTMLImportTranscoder.js";
  var StringMap = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util/StringMap.js", "traceur@0.0.112/src/HTMLImportTranscoder.js")).StringMap;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./WebPageTranscoder.js", "traceur@0.0.112/src/HTMLImportTranscoder.js")),
      WebPageTranscoder = $__4.WebPageTranscoder,
      scriptSelector = $__4.scriptSelector;
  var importSelector = 'link[rel=import][href]';
  var HTMLImportTranscoder = function() {
    function HTMLImportTranscoder() {
      this.importsToProcess_ = [];
    }
    return ($traceurRuntime.createClass)(HTMLImportTranscoder, {
      findAllChildrenHTMLImports_: function(parentImportNodes) {
        var foundImportNodes = [];
        for (var parentIndex = 0; parentIndex < parentImportNodes.length; parentIndex++) {
          var parentLink = parentImportNodes[parentIndex];
          var childImportNodes = parentLink.import.querySelectorAll(importSelector);
          if (childImportNodes.length > 0)
            this.findAllChildrenHTMLImports_(childImportNodes);
          this.importsToProcess_.push(parentLink);
        }
      },
      filterHTMLImports_: function(importNodes) {
        this.findAllChildrenHTMLImports_(importNodes);
        var importsToParse = [];
        var dupFilterMap = new StringMap();
        for (var index = 0; index < this.importsToProcess_.length; index++) {
          var processLink = this.importsToProcess_[index];
          if (!dupFilterMap.has(processLink.href)) {
            dupFilterMap.set(processLink.href, 0);
            var scripts = processLink.import.querySelectorAll(scriptSelector);
            if (scripts.length > 0)
              importsToParse.push({
                href: processLink.href,
                scripts: scripts
              });
          }
        }
        this.importsToProcess_ = [];
        return importsToParse;
      },
      selectAndProcessHTMLImports: function(importNodes, done) {
        var importInfoList = this.filterHTMLImports_(importNodes);
        if (importInfoList.length === 0)
          done();
        var processCount = importInfoList.length;
        importInfoList.forEach(function(importInfo) {
          var transcoder = new WebPageTranscoder(importInfo.href);
          transcoder.addFilesFromScriptElements(importInfo.scripts, function() {
            processCount--;
            if (processCount === 0 && done)
              done();
          });
        });
      },
      run: function() {
        var done = arguments[0] !== (void 0) ? arguments[0] : function() {};
        var $__2 = this;
        var ready = document.readyState;
        if (ready === 'complete' || ready === 'loaded') {
          var importNodes = document.querySelectorAll(importSelector);
          if (importNodes.length > 0)
            this.selectAndProcessHTMLImports(importNodes, done);
        } else {
          document.addEventListener('HTMLImportsLoaded', function(event) {
            var importNodes = event.detail && event.detail.allImports ? event.detail.allImports : document.querySelectorAll(importSelector);
            if (importNodes.length > 0)
              $__2.selectAndProcessHTMLImports(importNodes, done);
          });
        }
      }
    }, {});
  }();
  return {get HTMLImportTranscoder() {
      return HTMLImportTranscoder;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/CollectingErrorReporter.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/CollectingErrorReporter.js";
  var ErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/ErrorReporter.js", "traceur@0.0.112/src/util/CollectingErrorReporter.js")).ErrorReporter;
  var MultipleErrors = function($__super) {
    function MultipleErrors(errors) {
      $traceurRuntime.superConstructor(MultipleErrors).call(this);
      this.message = errors ? errors.join('\n') : '';
      this.name = 'MultipleErrors';
      this.errors = errors;
    }
    return ($traceurRuntime.createClass)(MultipleErrors, {}, {}, $__super);
  }(Error);
  var CollectingErrorReporter = function($__super) {
    function CollectingErrorReporter() {
      $traceurRuntime.superConstructor(CollectingErrorReporter).call(this);
      this.errors = [];
    }
    return ($traceurRuntime.createClass)(CollectingErrorReporter, {
      reportMessageInternal: function(location, message) {
        this.errors.push((location.start + ": " + message));
      },
      errorsAsString: function() {
        return this.toError().message;
      },
      toError: function() {
        return new MultipleErrors(this.errors);
      }
    }, {}, $__super);
  }(ErrorReporter);
  return {
    get MultipleErrors() {
      return MultipleErrors;
    },
    get CollectingErrorReporter() {
      return CollectingErrorReporter;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util-imports.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util-imports.js";
  $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util/MutedErrorReporter.js", "traceur@0.0.112/src/util-imports.js"));
  var $__traceur_64_0_46_0_46_112_47_src_47_WebPageTranscoder_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./WebPageTranscoder.js", "traceur@0.0.112/src/util-imports.js"));
  var $__traceur_64_0_46_0_46_112_47_src_47_HTMLImportTranscoder_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./HTMLImportTranscoder.js", "traceur@0.0.112/src/util-imports.js"));
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Options.js", "traceur@0.0.112/src/util-imports.js")),
      addOptions = $__1.addOptions,
      CommandOptions = $__1.CommandOptions,
      Options = $__1.Options;
  var ErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util/ErrorReporter.js", "traceur@0.0.112/src/util-imports.js")).ErrorReporter;
  var CollectingErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util/CollectingErrorReporter.js", "traceur@0.0.112/src/util-imports.js")).CollectingErrorReporter;
  var util = {
    addOptions: addOptions,
    CommandOptions: CommandOptions,
    CollectingErrorReporter: CollectingErrorReporter,
    ErrorReporter: ErrorReporter,
    Options: Options
  };
  return {
    get WebPageTranscoder() {
      return $__traceur_64_0_46_0_46_112_47_src_47_WebPageTranscoder_46_js__.WebPageTranscoder;
    },
    get HTMLImportTranscoder() {
      return $__traceur_64_0_46_0_46_112_47_src_47_HTMLImportTranscoder_46_js__.HTMLImportTranscoder;
    },
    get util() {
      return util;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/trees/ParseTreeType.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/trees/ParseTreeType.js";
  var ANNOTATION = 'ANNOTATION';
  var ANON_BLOCK = 'ANON_BLOCK';
  var ARGUMENT_LIST = 'ARGUMENT_LIST';
  var ARRAY_COMPREHENSION = 'ARRAY_COMPREHENSION';
  var ARRAY_LITERAL = 'ARRAY_LITERAL';
  var ARRAY_PATTERN = 'ARRAY_PATTERN';
  var ARRAY_TYPE = 'ARRAY_TYPE';
  var ARROW_FUNCTION = 'ARROW_FUNCTION';
  var ASSIGNMENT_ELEMENT = 'ASSIGNMENT_ELEMENT';
  var AWAIT_EXPRESSION = 'AWAIT_EXPRESSION';
  var BINARY_EXPRESSION = 'BINARY_EXPRESSION';
  var BINDING_ELEMENT = 'BINDING_ELEMENT';
  var BINDING_IDENTIFIER = 'BINDING_IDENTIFIER';
  var BLOCK = 'BLOCK';
  var BREAK_STATEMENT = 'BREAK_STATEMENT';
  var CALL_EXPRESSION = 'CALL_EXPRESSION';
  var CALL_SIGNATURE = 'CALL_SIGNATURE';
  var CASE_CLAUSE = 'CASE_CLAUSE';
  var CATCH = 'CATCH';
  var CLASS_DECLARATION = 'CLASS_DECLARATION';
  var CLASS_EXPRESSION = 'CLASS_EXPRESSION';
  var COMMA_EXPRESSION = 'COMMA_EXPRESSION';
  var COMPREHENSION_FOR = 'COMPREHENSION_FOR';
  var COMPREHENSION_IF = 'COMPREHENSION_IF';
  var COMPUTED_PROPERTY_NAME = 'COMPUTED_PROPERTY_NAME';
  var CONDITIONAL_EXPRESSION = 'CONDITIONAL_EXPRESSION';
  var CONSTRUCT_SIGNATURE = 'CONSTRUCT_SIGNATURE';
  var CONSTRUCTOR_TYPE = 'CONSTRUCTOR_TYPE';
  var CONTINUE_STATEMENT = 'CONTINUE_STATEMENT';
  var COVER_FORMALS = 'COVER_FORMALS';
  var COVER_INITIALIZED_NAME = 'COVER_INITIALIZED_NAME';
  var DEBUGGER_STATEMENT = 'DEBUGGER_STATEMENT';
  var DEFAULT_CLAUSE = 'DEFAULT_CLAUSE';
  var DO_WHILE_STATEMENT = 'DO_WHILE_STATEMENT';
  var EMPTY_STATEMENT = 'EMPTY_STATEMENT';
  var EXPORT_DECLARATION = 'EXPORT_DECLARATION';
  var EXPORT_DEFAULT = 'EXPORT_DEFAULT';
  var EXPORT_SPECIFIER = 'EXPORT_SPECIFIER';
  var EXPORT_SPECIFIER_SET = 'EXPORT_SPECIFIER_SET';
  var EXPORT_STAR = 'EXPORT_STAR';
  var EXPRESSION_STATEMENT = 'EXPRESSION_STATEMENT';
  var FINALLY = 'FINALLY';
  var FOR_IN_STATEMENT = 'FOR_IN_STATEMENT';
  var FOR_OF_STATEMENT = 'FOR_OF_STATEMENT';
  var FOR_ON_STATEMENT = 'FOR_ON_STATEMENT';
  var FOR_STATEMENT = 'FOR_STATEMENT';
  var FORMAL_PARAMETER = 'FORMAL_PARAMETER';
  var FORMAL_PARAMETER_LIST = 'FORMAL_PARAMETER_LIST';
  var FORWARD_DEFAULT_EXPORT = 'FORWARD_DEFAULT_EXPORT';
  var FUNCTION_BODY = 'FUNCTION_BODY';
  var FUNCTION_DECLARATION = 'FUNCTION_DECLARATION';
  var FUNCTION_EXPRESSION = 'FUNCTION_EXPRESSION';
  var FUNCTION_TYPE = 'FUNCTION_TYPE';
  var GENERATOR_COMPREHENSION = 'GENERATOR_COMPREHENSION';
  var GET_ACCESSOR = 'GET_ACCESSOR';
  var IDENTIFIER_EXPRESSION = 'IDENTIFIER_EXPRESSION';
  var IF_STATEMENT = 'IF_STATEMENT';
  var IMPORT_CLAUSE_PAIR = 'IMPORT_CLAUSE_PAIR';
  var IMPORT_DECLARATION = 'IMPORT_DECLARATION';
  var IMPORT_SPECIFIER = 'IMPORT_SPECIFIER';
  var IMPORT_SPECIFIER_SET = 'IMPORT_SPECIFIER_SET';
  var IMPORT_TYPE_CLAUSE = 'IMPORT_TYPE_CLAUSE';
  var IMPORTED_BINDING = 'IMPORTED_BINDING';
  var INDEX_SIGNATURE = 'INDEX_SIGNATURE';
  var INTERFACE_DECLARATION = 'INTERFACE_DECLARATION';
  var JSX_ATTRIBUTE = 'JSX_ATTRIBUTE';
  var JSX_ELEMENT = 'JSX_ELEMENT';
  var JSX_ELEMENT_NAME = 'JSX_ELEMENT_NAME';
  var JSX_PLACEHOLDER = 'JSX_PLACEHOLDER';
  var JSX_SPREAD_ATTRIBUTE = 'JSX_SPREAD_ATTRIBUTE';
  var JSX_TEXT = 'JSX_TEXT';
  var LABELLED_STATEMENT = 'LABELLED_STATEMENT';
  var LITERAL_EXPRESSION = 'LITERAL_EXPRESSION';
  var LITERAL_PROPERTY_NAME = 'LITERAL_PROPERTY_NAME';
  var MEMBER_EXPRESSION = 'MEMBER_EXPRESSION';
  var MEMBER_LOOKUP_EXPRESSION = 'MEMBER_LOOKUP_EXPRESSION';
  var METHOD = 'METHOD';
  var METHOD_SIGNATURE = 'METHOD_SIGNATURE';
  var MODULE = 'MODULE';
  var MODULE_SPECIFIER = 'MODULE_SPECIFIER';
  var NAME_SPACE_EXPORT = 'NAME_SPACE_EXPORT';
  var NAME_SPACE_IMPORT = 'NAME_SPACE_IMPORT';
  var NAMED_EXPORT = 'NAMED_EXPORT';
  var NEW_EXPRESSION = 'NEW_EXPRESSION';
  var OBJECT_LITERAL = 'OBJECT_LITERAL';
  var OBJECT_PATTERN = 'OBJECT_PATTERN';
  var OBJECT_PATTERN_FIELD = 'OBJECT_PATTERN_FIELD';
  var OBJECT_TYPE = 'OBJECT_TYPE';
  var PAREN_EXPRESSION = 'PAREN_EXPRESSION';
  var POSTFIX_EXPRESSION = 'POSTFIX_EXPRESSION';
  var PREDEFINED_TYPE = 'PREDEFINED_TYPE';
  var PROPERTY_NAME_ASSIGNMENT = 'PROPERTY_NAME_ASSIGNMENT';
  var PROPERTY_NAME_SHORTHAND = 'PROPERTY_NAME_SHORTHAND';
  var PROPERTY_SIGNATURE = 'PROPERTY_SIGNATURE';
  var PROPERTY_VARIABLE_DECLARATION = 'PROPERTY_VARIABLE_DECLARATION';
  var REST_PARAMETER = 'REST_PARAMETER';
  var RETURN_STATEMENT = 'RETURN_STATEMENT';
  var SCRIPT = 'SCRIPT';
  var SET_ACCESSOR = 'SET_ACCESSOR';
  var SPREAD_EXPRESSION = 'SPREAD_EXPRESSION';
  var SPREAD_PATTERN_ELEMENT = 'SPREAD_PATTERN_ELEMENT';
  var STATE_MACHINE = 'STATE_MACHINE';
  var SUPER_EXPRESSION = 'SUPER_EXPRESSION';
  var SWITCH_STATEMENT = 'SWITCH_STATEMENT';
  var SYNTAX_ERROR_TREE = 'SYNTAX_ERROR_TREE';
  var TEMPLATE_LITERAL_EXPRESSION = 'TEMPLATE_LITERAL_EXPRESSION';
  var TEMPLATE_LITERAL_PORTION = 'TEMPLATE_LITERAL_PORTION';
  var TEMPLATE_SUBSTITUTION = 'TEMPLATE_SUBSTITUTION';
  var THIS_EXPRESSION = 'THIS_EXPRESSION';
  var THROW_STATEMENT = 'THROW_STATEMENT';
  var TRY_STATEMENT = 'TRY_STATEMENT';
  var TYPE_ALIAS_DECLARATION = 'TYPE_ALIAS_DECLARATION';
  var TYPE_ARGUMENTS = 'TYPE_ARGUMENTS';
  var TYPE_NAME = 'TYPE_NAME';
  var TYPE_PARAMETER = 'TYPE_PARAMETER';
  var TYPE_PARAMETERS = 'TYPE_PARAMETERS';
  var TYPE_REFERENCE = 'TYPE_REFERENCE';
  var UNARY_EXPRESSION = 'UNARY_EXPRESSION';
  var UNION_TYPE = 'UNION_TYPE';
  var VARIABLE_DECLARATION = 'VARIABLE_DECLARATION';
  var VARIABLE_DECLARATION_LIST = 'VARIABLE_DECLARATION_LIST';
  var VARIABLE_STATEMENT = 'VARIABLE_STATEMENT';
  var WHILE_STATEMENT = 'WHILE_STATEMENT';
  var WITH_STATEMENT = 'WITH_STATEMENT';
  var YIELD_EXPRESSION = 'YIELD_EXPRESSION';
  return {
    get ANNOTATION() {
      return ANNOTATION;
    },
    get ANON_BLOCK() {
      return ANON_BLOCK;
    },
    get ARGUMENT_LIST() {
      return ARGUMENT_LIST;
    },
    get ARRAY_COMPREHENSION() {
      return ARRAY_COMPREHENSION;
    },
    get ARRAY_LITERAL() {
      return ARRAY_LITERAL;
    },
    get ARRAY_PATTERN() {
      return ARRAY_PATTERN;
    },
    get ARRAY_TYPE() {
      return ARRAY_TYPE;
    },
    get ARROW_FUNCTION() {
      return ARROW_FUNCTION;
    },
    get ASSIGNMENT_ELEMENT() {
      return ASSIGNMENT_ELEMENT;
    },
    get AWAIT_EXPRESSION() {
      return AWAIT_EXPRESSION;
    },
    get BINARY_EXPRESSION() {
      return BINARY_EXPRESSION;
    },
    get BINDING_ELEMENT() {
      return BINDING_ELEMENT;
    },
    get BINDING_IDENTIFIER() {
      return BINDING_IDENTIFIER;
    },
    get BLOCK() {
      return BLOCK;
    },
    get BREAK_STATEMENT() {
      return BREAK_STATEMENT;
    },
    get CALL_EXPRESSION() {
      return CALL_EXPRESSION;
    },
    get CALL_SIGNATURE() {
      return CALL_SIGNATURE;
    },
    get CASE_CLAUSE() {
      return CASE_CLAUSE;
    },
    get CATCH() {
      return CATCH;
    },
    get CLASS_DECLARATION() {
      return CLASS_DECLARATION;
    },
    get CLASS_EXPRESSION() {
      return CLASS_EXPRESSION;
    },
    get COMMA_EXPRESSION() {
      return COMMA_EXPRESSION;
    },
    get COMPREHENSION_FOR() {
      return COMPREHENSION_FOR;
    },
    get COMPREHENSION_IF() {
      return COMPREHENSION_IF;
    },
    get COMPUTED_PROPERTY_NAME() {
      return COMPUTED_PROPERTY_NAME;
    },
    get CONDITIONAL_EXPRESSION() {
      return CONDITIONAL_EXPRESSION;
    },
    get CONSTRUCT_SIGNATURE() {
      return CONSTRUCT_SIGNATURE;
    },
    get CONSTRUCTOR_TYPE() {
      return CONSTRUCTOR_TYPE;
    },
    get CONTINUE_STATEMENT() {
      return CONTINUE_STATEMENT;
    },
    get COVER_FORMALS() {
      return COVER_FORMALS;
    },
    get COVER_INITIALIZED_NAME() {
      return COVER_INITIALIZED_NAME;
    },
    get DEBUGGER_STATEMENT() {
      return DEBUGGER_STATEMENT;
    },
    get DEFAULT_CLAUSE() {
      return DEFAULT_CLAUSE;
    },
    get DO_WHILE_STATEMENT() {
      return DO_WHILE_STATEMENT;
    },
    get EMPTY_STATEMENT() {
      return EMPTY_STATEMENT;
    },
    get EXPORT_DECLARATION() {
      return EXPORT_DECLARATION;
    },
    get EXPORT_DEFAULT() {
      return EXPORT_DEFAULT;
    },
    get EXPORT_SPECIFIER() {
      return EXPORT_SPECIFIER;
    },
    get EXPORT_SPECIFIER_SET() {
      return EXPORT_SPECIFIER_SET;
    },
    get EXPORT_STAR() {
      return EXPORT_STAR;
    },
    get EXPRESSION_STATEMENT() {
      return EXPRESSION_STATEMENT;
    },
    get FINALLY() {
      return FINALLY;
    },
    get FOR_IN_STATEMENT() {
      return FOR_IN_STATEMENT;
    },
    get FOR_OF_STATEMENT() {
      return FOR_OF_STATEMENT;
    },
    get FOR_ON_STATEMENT() {
      return FOR_ON_STATEMENT;
    },
    get FOR_STATEMENT() {
      return FOR_STATEMENT;
    },
    get FORMAL_PARAMETER() {
      return FORMAL_PARAMETER;
    },
    get FORMAL_PARAMETER_LIST() {
      return FORMAL_PARAMETER_LIST;
    },
    get FORWARD_DEFAULT_EXPORT() {
      return FORWARD_DEFAULT_EXPORT;
    },
    get FUNCTION_BODY() {
      return FUNCTION_BODY;
    },
    get FUNCTION_DECLARATION() {
      return FUNCTION_DECLARATION;
    },
    get FUNCTION_EXPRESSION() {
      return FUNCTION_EXPRESSION;
    },
    get FUNCTION_TYPE() {
      return FUNCTION_TYPE;
    },
    get GENERATOR_COMPREHENSION() {
      return GENERATOR_COMPREHENSION;
    },
    get GET_ACCESSOR() {
      return GET_ACCESSOR;
    },
    get IDENTIFIER_EXPRESSION() {
      return IDENTIFIER_EXPRESSION;
    },
    get IF_STATEMENT() {
      return IF_STATEMENT;
    },
    get IMPORT_CLAUSE_PAIR() {
      return IMPORT_CLAUSE_PAIR;
    },
    get IMPORT_DECLARATION() {
      return IMPORT_DECLARATION;
    },
    get IMPORT_SPECIFIER() {
      return IMPORT_SPECIFIER;
    },
    get IMPORT_SPECIFIER_SET() {
      return IMPORT_SPECIFIER_SET;
    },
    get IMPORT_TYPE_CLAUSE() {
      return IMPORT_TYPE_CLAUSE;
    },
    get IMPORTED_BINDING() {
      return IMPORTED_BINDING;
    },
    get INDEX_SIGNATURE() {
      return INDEX_SIGNATURE;
    },
    get INTERFACE_DECLARATION() {
      return INTERFACE_DECLARATION;
    },
    get JSX_ATTRIBUTE() {
      return JSX_ATTRIBUTE;
    },
    get JSX_ELEMENT() {
      return JSX_ELEMENT;
    },
    get JSX_ELEMENT_NAME() {
      return JSX_ELEMENT_NAME;
    },
    get JSX_PLACEHOLDER() {
      return JSX_PLACEHOLDER;
    },
    get JSX_SPREAD_ATTRIBUTE() {
      return JSX_SPREAD_ATTRIBUTE;
    },
    get JSX_TEXT() {
      return JSX_TEXT;
    },
    get LABELLED_STATEMENT() {
      return LABELLED_STATEMENT;
    },
    get LITERAL_EXPRESSION() {
      return LITERAL_EXPRESSION;
    },
    get LITERAL_PROPERTY_NAME() {
      return LITERAL_PROPERTY_NAME;
    },
    get MEMBER_EXPRESSION() {
      return MEMBER_EXPRESSION;
    },
    get MEMBER_LOOKUP_EXPRESSION() {
      return MEMBER_LOOKUP_EXPRESSION;
    },
    get METHOD() {
      return METHOD;
    },
    get METHOD_SIGNATURE() {
      return METHOD_SIGNATURE;
    },
    get MODULE() {
      return MODULE;
    },
    get MODULE_SPECIFIER() {
      return MODULE_SPECIFIER;
    },
    get NAME_SPACE_EXPORT() {
      return NAME_SPACE_EXPORT;
    },
    get NAME_SPACE_IMPORT() {
      return NAME_SPACE_IMPORT;
    },
    get NAMED_EXPORT() {
      return NAMED_EXPORT;
    },
    get NEW_EXPRESSION() {
      return NEW_EXPRESSION;
    },
    get OBJECT_LITERAL() {
      return OBJECT_LITERAL;
    },
    get OBJECT_PATTERN() {
      return OBJECT_PATTERN;
    },
    get OBJECT_PATTERN_FIELD() {
      return OBJECT_PATTERN_FIELD;
    },
    get OBJECT_TYPE() {
      return OBJECT_TYPE;
    },
    get PAREN_EXPRESSION() {
      return PAREN_EXPRESSION;
    },
    get POSTFIX_EXPRESSION() {
      return POSTFIX_EXPRESSION;
    },
    get PREDEFINED_TYPE() {
      return PREDEFINED_TYPE;
    },
    get PROPERTY_NAME_ASSIGNMENT() {
      return PROPERTY_NAME_ASSIGNMENT;
    },
    get PROPERTY_NAME_SHORTHAND() {
      return PROPERTY_NAME_SHORTHAND;
    },
    get PROPERTY_SIGNATURE() {
      return PROPERTY_SIGNATURE;
    },
    get PROPERTY_VARIABLE_DECLARATION() {
      return PROPERTY_VARIABLE_DECLARATION;
    },
    get REST_PARAMETER() {
      return REST_PARAMETER;
    },
    get RETURN_STATEMENT() {
      return RETURN_STATEMENT;
    },
    get SCRIPT() {
      return SCRIPT;
    },
    get SET_ACCESSOR() {
      return SET_ACCESSOR;
    },
    get SPREAD_EXPRESSION() {
      return SPREAD_EXPRESSION;
    },
    get SPREAD_PATTERN_ELEMENT() {
      return SPREAD_PATTERN_ELEMENT;
    },
    get STATE_MACHINE() {
      return STATE_MACHINE;
    },
    get SUPER_EXPRESSION() {
      return SUPER_EXPRESSION;
    },
    get SWITCH_STATEMENT() {
      return SWITCH_STATEMENT;
    },
    get SYNTAX_ERROR_TREE() {
      return SYNTAX_ERROR_TREE;
    },
    get TEMPLATE_LITERAL_EXPRESSION() {
      return TEMPLATE_LITERAL_EXPRESSION;
    },
    get TEMPLATE_LITERAL_PORTION() {
      return TEMPLATE_LITERAL_PORTION;
    },
    get TEMPLATE_SUBSTITUTION() {
      return TEMPLATE_SUBSTITUTION;
    },
    get THIS_EXPRESSION() {
      return THIS_EXPRESSION;
    },
    get THROW_STATEMENT() {
      return THROW_STATEMENT;
    },
    get TRY_STATEMENT() {
      return TRY_STATEMENT;
    },
    get TYPE_ALIAS_DECLARATION() {
      return TYPE_ALIAS_DECLARATION;
    },
    get TYPE_ARGUMENTS() {
      return TYPE_ARGUMENTS;
    },
    get TYPE_NAME() {
      return TYPE_NAME;
    },
    get TYPE_PARAMETER() {
      return TYPE_PARAMETER;
    },
    get TYPE_PARAMETERS() {
      return TYPE_PARAMETERS;
    },
    get TYPE_REFERENCE() {
      return TYPE_REFERENCE;
    },
    get UNARY_EXPRESSION() {
      return UNARY_EXPRESSION;
    },
    get UNION_TYPE() {
      return UNION_TYPE;
    },
    get VARIABLE_DECLARATION() {
      return VARIABLE_DECLARATION;
    },
    get VARIABLE_DECLARATION_LIST() {
      return VARIABLE_DECLARATION_LIST;
    },
    get VARIABLE_STATEMENT() {
      return VARIABLE_STATEMENT;
    },
    get WHILE_STATEMENT() {
      return WHILE_STATEMENT;
    },
    get WITH_STATEMENT() {
      return WITH_STATEMENT;
    },
    get YIELD_EXPRESSION() {
      return YIELD_EXPRESSION;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/TokenType.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/TokenType.js";
  var AMPERSAND = '&';
  var AMPERSAND_EQUAL = '&=';
  var AND = '&&';
  var ARROW = '=>';
  var AT = '@';
  var BACK_QUOTE = '`';
  var BANG = '!';
  var BAR = '|';
  var BAR_EQUAL = '|=';
  var BREAK = 'break';
  var CARET = '^';
  var CARET_EQUAL = '^=';
  var CASE = 'case';
  var CATCH = 'catch';
  var CLASS = 'class';
  var CLOSE_ANGLE = '>';
  var CLOSE_CURLY = '}';
  var CLOSE_PAREN = ')';
  var CLOSE_SQUARE = ']';
  var COLON = ':';
  var COMMA = ',';
  var CONST = 'const';
  var CONTINUE = 'continue';
  var DEBUGGER = 'debugger';
  var DEFAULT = 'default';
  var DELETE = 'delete';
  var DO = 'do';
  var DOT_DOT_DOT = '...';
  var ELSE = 'else';
  var END_OF_FILE = 'End of File';
  var ENUM = 'enum';
  var EQUAL = '=';
  var EQUAL_EQUAL = '==';
  var EQUAL_EQUAL_EQUAL = '===';
  var ERROR = 'error';
  var EXPORT = 'export';
  var EXTENDS = 'extends';
  var FALSE = 'false';
  var FINALLY = 'finally';
  var FOR = 'for';
  var FUNCTION = 'function';
  var GREATER_EQUAL = '>=';
  var IDENTIFIER = 'identifier';
  var IF = 'if';
  var IMPLEMENTS = 'implements';
  var IMPORT = 'import';
  var IN = 'in';
  var INSTANCEOF = 'instanceof';
  var INTERFACE = 'interface';
  var JSX_IDENTIFIER = 'jsx identifier';
  var LEFT_SHIFT = '<<';
  var LEFT_SHIFT_EQUAL = '<<=';
  var LESS_EQUAL = '<=';
  var LET = 'let';
  var MINUS = '-';
  var MINUS_EQUAL = '-=';
  var MINUS_MINUS = '--';
  var NEW = 'new';
  var NO_SUBSTITUTION_TEMPLATE = 'no substitution template';
  var NOT_EQUAL = '!=';
  var NOT_EQUAL_EQUAL = '!==';
  var NULL = 'null';
  var NUMBER = 'number literal';
  var OPEN_ANGLE = '<';
  var OPEN_CURLY = '{';
  var OPEN_PAREN = '(';
  var OPEN_SQUARE = '[';
  var OR = '||';
  var PACKAGE = 'package';
  var PERCENT = '%';
  var PERCENT_EQUAL = '%=';
  var PERIOD = '.';
  var PLUS = '+';
  var PLUS_EQUAL = '+=';
  var PLUS_PLUS = '++';
  var PRIVATE = 'private';
  var PROTECTED = 'protected';
  var PUBLIC = 'public';
  var QUESTION = '?';
  var REGULAR_EXPRESSION = 'regular expression literal';
  var RETURN = 'return';
  var RIGHT_SHIFT = '>>';
  var RIGHT_SHIFT_EQUAL = '>>=';
  var SEMI_COLON = ';';
  var SLASH = '/';
  var SLASH_EQUAL = '/=';
  var STAR = '*';
  var STAR_EQUAL = '*=';
  var STAR_STAR = '**';
  var STAR_STAR_EQUAL = '**=';
  var STATIC = 'static';
  var STRING = 'string literal';
  var SUPER = 'super';
  var SWITCH = 'switch';
  var TEMPLATE_HEAD = 'template head';
  var TEMPLATE_MIDDLE = 'template middle';
  var TEMPLATE_TAIL = 'template tail';
  var THIS = 'this';
  var THROW = 'throw';
  var TILDE = '~';
  var TRUE = 'true';
  var TRY = 'try';
  var TYPEOF = 'typeof';
  var UNSIGNED_RIGHT_SHIFT = '>>>';
  var UNSIGNED_RIGHT_SHIFT_EQUAL = '>>>=';
  var VAR = 'var';
  var VOID = 'void';
  var WHILE = 'while';
  var WITH = 'with';
  var YIELD = 'yield';
  return {
    get AMPERSAND() {
      return AMPERSAND;
    },
    get AMPERSAND_EQUAL() {
      return AMPERSAND_EQUAL;
    },
    get AND() {
      return AND;
    },
    get ARROW() {
      return ARROW;
    },
    get AT() {
      return AT;
    },
    get BACK_QUOTE() {
      return BACK_QUOTE;
    },
    get BANG() {
      return BANG;
    },
    get BAR() {
      return BAR;
    },
    get BAR_EQUAL() {
      return BAR_EQUAL;
    },
    get BREAK() {
      return BREAK;
    },
    get CARET() {
      return CARET;
    },
    get CARET_EQUAL() {
      return CARET_EQUAL;
    },
    get CASE() {
      return CASE;
    },
    get CATCH() {
      return CATCH;
    },
    get CLASS() {
      return CLASS;
    },
    get CLOSE_ANGLE() {
      return CLOSE_ANGLE;
    },
    get CLOSE_CURLY() {
      return CLOSE_CURLY;
    },
    get CLOSE_PAREN() {
      return CLOSE_PAREN;
    },
    get CLOSE_SQUARE() {
      return CLOSE_SQUARE;
    },
    get COLON() {
      return COLON;
    },
    get COMMA() {
      return COMMA;
    },
    get CONST() {
      return CONST;
    },
    get CONTINUE() {
      return CONTINUE;
    },
    get DEBUGGER() {
      return DEBUGGER;
    },
    get DEFAULT() {
      return DEFAULT;
    },
    get DELETE() {
      return DELETE;
    },
    get DO() {
      return DO;
    },
    get DOT_DOT_DOT() {
      return DOT_DOT_DOT;
    },
    get ELSE() {
      return ELSE;
    },
    get END_OF_FILE() {
      return END_OF_FILE;
    },
    get ENUM() {
      return ENUM;
    },
    get EQUAL() {
      return EQUAL;
    },
    get EQUAL_EQUAL() {
      return EQUAL_EQUAL;
    },
    get EQUAL_EQUAL_EQUAL() {
      return EQUAL_EQUAL_EQUAL;
    },
    get ERROR() {
      return ERROR;
    },
    get EXPORT() {
      return EXPORT;
    },
    get EXTENDS() {
      return EXTENDS;
    },
    get FALSE() {
      return FALSE;
    },
    get FINALLY() {
      return FINALLY;
    },
    get FOR() {
      return FOR;
    },
    get FUNCTION() {
      return FUNCTION;
    },
    get GREATER_EQUAL() {
      return GREATER_EQUAL;
    },
    get IDENTIFIER() {
      return IDENTIFIER;
    },
    get IF() {
      return IF;
    },
    get IMPLEMENTS() {
      return IMPLEMENTS;
    },
    get IMPORT() {
      return IMPORT;
    },
    get IN() {
      return IN;
    },
    get INSTANCEOF() {
      return INSTANCEOF;
    },
    get INTERFACE() {
      return INTERFACE;
    },
    get JSX_IDENTIFIER() {
      return JSX_IDENTIFIER;
    },
    get LEFT_SHIFT() {
      return LEFT_SHIFT;
    },
    get LEFT_SHIFT_EQUAL() {
      return LEFT_SHIFT_EQUAL;
    },
    get LESS_EQUAL() {
      return LESS_EQUAL;
    },
    get LET() {
      return LET;
    },
    get MINUS() {
      return MINUS;
    },
    get MINUS_EQUAL() {
      return MINUS_EQUAL;
    },
    get MINUS_MINUS() {
      return MINUS_MINUS;
    },
    get NEW() {
      return NEW;
    },
    get NO_SUBSTITUTION_TEMPLATE() {
      return NO_SUBSTITUTION_TEMPLATE;
    },
    get NOT_EQUAL() {
      return NOT_EQUAL;
    },
    get NOT_EQUAL_EQUAL() {
      return NOT_EQUAL_EQUAL;
    },
    get NULL() {
      return NULL;
    },
    get NUMBER() {
      return NUMBER;
    },
    get OPEN_ANGLE() {
      return OPEN_ANGLE;
    },
    get OPEN_CURLY() {
      return OPEN_CURLY;
    },
    get OPEN_PAREN() {
      return OPEN_PAREN;
    },
    get OPEN_SQUARE() {
      return OPEN_SQUARE;
    },
    get OR() {
      return OR;
    },
    get PACKAGE() {
      return PACKAGE;
    },
    get PERCENT() {
      return PERCENT;
    },
    get PERCENT_EQUAL() {
      return PERCENT_EQUAL;
    },
    get PERIOD() {
      return PERIOD;
    },
    get PLUS() {
      return PLUS;
    },
    get PLUS_EQUAL() {
      return PLUS_EQUAL;
    },
    get PLUS_PLUS() {
      return PLUS_PLUS;
    },
    get PRIVATE() {
      return PRIVATE;
    },
    get PROTECTED() {
      return PROTECTED;
    },
    get PUBLIC() {
      return PUBLIC;
    },
    get QUESTION() {
      return QUESTION;
    },
    get REGULAR_EXPRESSION() {
      return REGULAR_EXPRESSION;
    },
    get RETURN() {
      return RETURN;
    },
    get RIGHT_SHIFT() {
      return RIGHT_SHIFT;
    },
    get RIGHT_SHIFT_EQUAL() {
      return RIGHT_SHIFT_EQUAL;
    },
    get SEMI_COLON() {
      return SEMI_COLON;
    },
    get SLASH() {
      return SLASH;
    },
    get SLASH_EQUAL() {
      return SLASH_EQUAL;
    },
    get STAR() {
      return STAR;
    },
    get STAR_EQUAL() {
      return STAR_EQUAL;
    },
    get STAR_STAR() {
      return STAR_STAR;
    },
    get STAR_STAR_EQUAL() {
      return STAR_STAR_EQUAL;
    },
    get STATIC() {
      return STATIC;
    },
    get STRING() {
      return STRING;
    },
    get SUPER() {
      return SUPER;
    },
    get SWITCH() {
      return SWITCH;
    },
    get TEMPLATE_HEAD() {
      return TEMPLATE_HEAD;
    },
    get TEMPLATE_MIDDLE() {
      return TEMPLATE_MIDDLE;
    },
    get TEMPLATE_TAIL() {
      return TEMPLATE_TAIL;
    },
    get THIS() {
      return THIS;
    },
    get THROW() {
      return THROW;
    },
    get TILDE() {
      return TILDE;
    },
    get TRUE() {
      return TRUE;
    },
    get TRY() {
      return TRY;
    },
    get TYPEOF() {
      return TYPEOF;
    },
    get UNSIGNED_RIGHT_SHIFT() {
      return UNSIGNED_RIGHT_SHIFT;
    },
    get UNSIGNED_RIGHT_SHIFT_EQUAL() {
      return UNSIGNED_RIGHT_SHIFT_EQUAL;
    },
    get VAR() {
      return VAR;
    },
    get VOID() {
      return VOID;
    },
    get WHILE() {
      return WHILE;
    },
    get WITH() {
      return WITH;
    },
    get YIELD() {
      return YIELD;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/Token.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/Token.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TokenType.js", "traceur@0.0.112/src/syntax/Token.js")),
      AMPERSAND_EQUAL = $__1.AMPERSAND_EQUAL,
      BAR_EQUAL = $__1.BAR_EQUAL,
      CARET_EQUAL = $__1.CARET_EQUAL,
      EQUAL = $__1.EQUAL,
      LEFT_SHIFT_EQUAL = $__1.LEFT_SHIFT_EQUAL,
      MINUS_EQUAL = $__1.MINUS_EQUAL,
      PERCENT_EQUAL = $__1.PERCENT_EQUAL,
      PLUS_EQUAL = $__1.PLUS_EQUAL,
      RIGHT_SHIFT_EQUAL = $__1.RIGHT_SHIFT_EQUAL,
      SLASH_EQUAL = $__1.SLASH_EQUAL,
      STAR_EQUAL = $__1.STAR_EQUAL,
      STAR_STAR_EQUAL = $__1.STAR_STAR_EQUAL,
      UNSIGNED_RIGHT_SHIFT_EQUAL = $__1.UNSIGNED_RIGHT_SHIFT_EQUAL;
  var Token = function() {
    function Token(type, location) {
      this.type = type;
      this.location = location;
    }
    return ($traceurRuntime.createClass)(Token, {
      toString: function() {
        return this.type;
      },
      isAssignmentOperator: function() {
        return isAssignmentOperator(this.type);
      },
      isKeyword: function() {
        return false;
      },
      isStrictKeyword: function() {
        return false;
      }
    }, {});
  }();
  function isAssignmentOperator(type) {
    switch (type) {
      case AMPERSAND_EQUAL:
      case BAR_EQUAL:
      case CARET_EQUAL:
      case EQUAL:
      case LEFT_SHIFT_EQUAL:
      case MINUS_EQUAL:
      case PERCENT_EQUAL:
      case PLUS_EQUAL:
      case RIGHT_SHIFT_EQUAL:
      case SLASH_EQUAL:
      case STAR_EQUAL:
      case STAR_STAR_EQUAL:
      case UNSIGNED_RIGHT_SHIFT_EQUAL:
        return true;
    }
    return false;
  }
  return {
    get Token() {
      return Token;
    },
    get isAssignmentOperator() {
      return isAssignmentOperator;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/JSON.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/JSON.js";
  function transform(v) {
    var replacer = arguments[1] !== (void 0) ? arguments[1] : function(k, v) {
      return v;
    };
    return transform_(replacer('', v), replacer);
  }
  function transform_(v, replacer) {
    var rv,
        tv;
    if (Array.isArray(v)) {
      var len = v.length;
      rv = Array(len);
      for (var i = 0; i < len; i++) {
        tv = transform_(replacer(String(i), v[i]), replacer);
        rv[i] = tv === undefined ? null : tv;
      }
      return rv;
    }
    if (v instanceof Object) {
      rv = {};
      Object.keys(v).forEach(function(k) {
        tv = transform_(replacer(k, v[k]), replacer);
        if (tv !== undefined) {
          rv[k] = tv;
        }
      });
      return rv;
    }
    return v;
  }
  return {get transform() {
      return transform;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/PredefinedName.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/PredefinedName.js";
  var $ARGUMENTS = '$arguments';
  var ANY = 'any';
  var APPLY = 'apply';
  var ARGUMENTS = 'arguments';
  var ARRAY = 'Array';
  var AS = 'as';
  var ASYNC = 'async';
  var ASYNC_STAR = 'async star';
  var AWAIT = 'await';
  var BIND = 'bind';
  var CALL = 'call';
  var CONFIGURABLE = 'configurable';
  var CONSTRUCTOR = 'constructor';
  var CREATE = 'create';
  var CURRENT = 'current';
  var DEFINE_PROPERTY = 'defineProperty';
  var ENUMERABLE = 'enumerable';
  var FREEZE = 'freeze';
  var FROM = 'from';
  var FUNCTION = 'Function';
  var GET = 'get';
  var HAS = 'has';
  var LENGTH = 'length';
  var MODULE = 'module';
  var NEW = 'new';
  var OBJECT = 'Object';
  var OBJECT_NAME = 'Object';
  var OF = 'of';
  var ON = 'on';
  var PREVENT_EXTENSIONS = 'preventExtensions';
  var PROTOTYPE = 'prototype';
  var PUSH = 'push';
  var SET = 'set';
  var SLICE = 'slice';
  var THIS = 'this';
  var TRACEUR_RUNTIME = '$traceurRuntime';
  var TYPE = 'type';
  var UNDEFINED = 'undefined';
  var WRITABLE = 'writable';
  return {
    get $ARGUMENTS() {
      return $ARGUMENTS;
    },
    get ANY() {
      return ANY;
    },
    get APPLY() {
      return APPLY;
    },
    get ARGUMENTS() {
      return ARGUMENTS;
    },
    get ARRAY() {
      return ARRAY;
    },
    get AS() {
      return AS;
    },
    get ASYNC() {
      return ASYNC;
    },
    get ASYNC_STAR() {
      return ASYNC_STAR;
    },
    get AWAIT() {
      return AWAIT;
    },
    get BIND() {
      return BIND;
    },
    get CALL() {
      return CALL;
    },
    get CONFIGURABLE() {
      return CONFIGURABLE;
    },
    get CONSTRUCTOR() {
      return CONSTRUCTOR;
    },
    get CREATE() {
      return CREATE;
    },
    get CURRENT() {
      return CURRENT;
    },
    get DEFINE_PROPERTY() {
      return DEFINE_PROPERTY;
    },
    get ENUMERABLE() {
      return ENUMERABLE;
    },
    get FREEZE() {
      return FREEZE;
    },
    get FROM() {
      return FROM;
    },
    get FUNCTION() {
      return FUNCTION;
    },
    get GET() {
      return GET;
    },
    get HAS() {
      return HAS;
    },
    get LENGTH() {
      return LENGTH;
    },
    get MODULE() {
      return MODULE;
    },
    get NEW() {
      return NEW;
    },
    get OBJECT() {
      return OBJECT;
    },
    get OBJECT_NAME() {
      return OBJECT_NAME;
    },
    get OF() {
      return OF;
    },
    get ON() {
      return ON;
    },
    get PREVENT_EXTENSIONS() {
      return PREVENT_EXTENSIONS;
    },
    get PROTOTYPE() {
      return PROTOTYPE;
    },
    get PUSH() {
      return PUSH;
    },
    get SET() {
      return SET;
    },
    get SLICE() {
      return SLICE;
    },
    get THIS() {
      return THIS;
    },
    get TRACEUR_RUNTIME() {
      return TRACEUR_RUNTIME;
    },
    get TYPE() {
      return TYPE;
    },
    get UNDEFINED() {
      return UNDEFINED;
    },
    get WRITABLE() {
      return WRITABLE;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/trees/ParseTree.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/trees/ParseTree.js";
  var ParseTreeType = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeType.js", "traceur@0.0.112/src/syntax/trees/ParseTree.js"));
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../TokenType.js", "traceur@0.0.112/src/syntax/trees/ParseTree.js")),
      IDENTIFIER = $__2.IDENTIFIER,
      STAR = $__2.STAR,
      STRING = $__2.STRING,
      VAR = $__2.VAR;
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../Token.js", "traceur@0.0.112/src/syntax/trees/ParseTree.js")).Token;
  var utilJSON = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../util/JSON.js", "traceur@0.0.112/src/syntax/trees/ParseTree.js"));
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PredefinedName.js", "traceur@0.0.112/src/syntax/trees/ParseTree.js")),
      ASYNC = $__4.ASYNC,
      ASYNC_STAR = $__4.ASYNC_STAR;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeType.js", "traceur@0.0.112/src/syntax/trees/ParseTree.js")),
      ARRAY_COMPREHENSION = $__5.ARRAY_COMPREHENSION,
      ARRAY_LITERAL = $__5.ARRAY_LITERAL,
      ARRAY_PATTERN = $__5.ARRAY_PATTERN,
      ARROW_FUNCTION = $__5.ARROW_FUNCTION,
      AWAIT_EXPRESSION = $__5.AWAIT_EXPRESSION,
      BINARY_EXPRESSION = $__5.BINARY_EXPRESSION,
      BINDING_IDENTIFIER = $__5.BINDING_IDENTIFIER,
      BLOCK = $__5.BLOCK,
      BREAK_STATEMENT = $__5.BREAK_STATEMENT,
      CALL_EXPRESSION = $__5.CALL_EXPRESSION,
      CLASS_DECLARATION = $__5.CLASS_DECLARATION,
      CLASS_EXPRESSION = $__5.CLASS_EXPRESSION,
      COMMA_EXPRESSION = $__5.COMMA_EXPRESSION,
      CONDITIONAL_EXPRESSION = $__5.CONDITIONAL_EXPRESSION,
      CONSTRUCTOR_TYPE = $__5.CONSTRUCTOR_TYPE,
      CONTINUE_STATEMENT = $__5.CONTINUE_STATEMENT,
      DEBUGGER_STATEMENT = $__5.DEBUGGER_STATEMENT,
      DO_WHILE_STATEMENT = $__5.DO_WHILE_STATEMENT,
      EMPTY_STATEMENT = $__5.EMPTY_STATEMENT,
      EXPORT_DECLARATION = $__5.EXPORT_DECLARATION,
      EXPRESSION_STATEMENT = $__5.EXPRESSION_STATEMENT,
      FOR_IN_STATEMENT = $__5.FOR_IN_STATEMENT,
      FOR_OF_STATEMENT = $__5.FOR_OF_STATEMENT,
      FOR_ON_STATEMENT = $__5.FOR_ON_STATEMENT,
      FOR_STATEMENT = $__5.FOR_STATEMENT,
      FORMAL_PARAMETER = $__5.FORMAL_PARAMETER,
      FUNCTION_DECLARATION = $__5.FUNCTION_DECLARATION,
      FUNCTION_EXPRESSION = $__5.FUNCTION_EXPRESSION,
      FUNCTION_TYPE = $__5.FUNCTION_TYPE,
      GENERATOR_COMPREHENSION = $__5.GENERATOR_COMPREHENSION,
      IDENTIFIER_EXPRESSION = $__5.IDENTIFIER_EXPRESSION,
      IF_STATEMENT = $__5.IF_STATEMENT,
      IMPORT_DECLARATION = $__5.IMPORT_DECLARATION,
      IMPORTED_BINDING = $__5.IMPORTED_BINDING,
      INTERFACE_DECLARATION = $__5.INTERFACE_DECLARATION,
      JSX_ELEMENT = $__5.JSX_ELEMENT,
      LABELLED_STATEMENT = $__5.LABELLED_STATEMENT,
      LITERAL_EXPRESSION = $__5.LITERAL_EXPRESSION,
      LITERAL_PROPERTY_NAME = $__5.LITERAL_PROPERTY_NAME,
      MEMBER_EXPRESSION = $__5.MEMBER_EXPRESSION,
      MEMBER_LOOKUP_EXPRESSION = $__5.MEMBER_LOOKUP_EXPRESSION,
      NEW_EXPRESSION = $__5.NEW_EXPRESSION,
      OBJECT_LITERAL = $__5.OBJECT_LITERAL,
      OBJECT_PATTERN = $__5.OBJECT_PATTERN,
      OBJECT_TYPE = $__5.OBJECT_TYPE,
      PAREN_EXPRESSION = $__5.PAREN_EXPRESSION,
      POSTFIX_EXPRESSION = $__5.POSTFIX_EXPRESSION,
      PREDEFINED_TYPE = $__5.PREDEFINED_TYPE,
      PROPERTY_NAME_SHORTHAND = $__5.PROPERTY_NAME_SHORTHAND,
      REST_PARAMETER = $__5.REST_PARAMETER,
      RETURN_STATEMENT = $__5.RETURN_STATEMENT,
      SPREAD_EXPRESSION = $__5.SPREAD_EXPRESSION,
      SPREAD_PATTERN_ELEMENT = $__5.SPREAD_PATTERN_ELEMENT,
      SUPER_EXPRESSION = $__5.SUPER_EXPRESSION,
      SWITCH_STATEMENT = $__5.SWITCH_STATEMENT,
      TEMPLATE_LITERAL_EXPRESSION = $__5.TEMPLATE_LITERAL_EXPRESSION,
      THIS_EXPRESSION = $__5.THIS_EXPRESSION,
      THROW_STATEMENT = $__5.THROW_STATEMENT,
      TRY_STATEMENT = $__5.TRY_STATEMENT,
      TYPE_ALIAS_DECLARATION = $__5.TYPE_ALIAS_DECLARATION,
      TYPE_NAME = $__5.TYPE_NAME,
      TYPE_REFERENCE = $__5.TYPE_REFERENCE,
      UNARY_EXPRESSION = $__5.UNARY_EXPRESSION,
      VARIABLE_DECLARATION = $__5.VARIABLE_DECLARATION,
      VARIABLE_STATEMENT = $__5.VARIABLE_STATEMENT,
      WHILE_STATEMENT = $__5.WHILE_STATEMENT,
      WITH_STATEMENT = $__5.WITH_STATEMENT,
      YIELD_EXPRESSION = $__5.YIELD_EXPRESSION;
  var ParseTree = function() {
    function ParseTree(location) {
      this.location = location;
    }
    return ($traceurRuntime.createClass)(ParseTree, {
      isPattern: function() {
        switch (this.type) {
          case ARRAY_PATTERN:
          case OBJECT_PATTERN:
            return true;
          default:
            return false;
        }
      },
      isLeftHandSideExpression: function() {
        switch (this.type) {
          case ARRAY_PATTERN:
          case IDENTIFIER_EXPRESSION:
          case MEMBER_EXPRESSION:
          case MEMBER_LOOKUP_EXPRESSION:
          case OBJECT_PATTERN:
            return true;
          case PAREN_EXPRESSION:
            return this.expression.isLeftHandSideExpression();
          default:
            return false;
        }
      },
      isAssignmentExpression: function() {
        switch (this.type) {
          case ARRAY_COMPREHENSION:
          case ARRAY_LITERAL:
          case ARROW_FUNCTION:
          case AWAIT_EXPRESSION:
          case BINARY_EXPRESSION:
          case CALL_EXPRESSION:
          case CLASS_EXPRESSION:
          case CONDITIONAL_EXPRESSION:
          case FUNCTION_EXPRESSION:
          case GENERATOR_COMPREHENSION:
          case IDENTIFIER_EXPRESSION:
          case JSX_ELEMENT:
          case LITERAL_EXPRESSION:
          case MEMBER_EXPRESSION:
          case MEMBER_LOOKUP_EXPRESSION:
          case NEW_EXPRESSION:
          case OBJECT_LITERAL:
          case PAREN_EXPRESSION:
          case POSTFIX_EXPRESSION:
          case TEMPLATE_LITERAL_EXPRESSION:
          case SUPER_EXPRESSION:
          case THIS_EXPRESSION:
          case UNARY_EXPRESSION:
          case YIELD_EXPRESSION:
            return true;
          default:
            return false;
        }
      },
      isMemberExpression: function() {
        switch (this.type) {
          case THIS_EXPRESSION:
          case CLASS_EXPRESSION:
          case SUPER_EXPRESSION:
          case IDENTIFIER_EXPRESSION:
          case JSX_ELEMENT:
          case LITERAL_EXPRESSION:
          case ARRAY_LITERAL:
          case OBJECT_LITERAL:
          case PAREN_EXPRESSION:
          case TEMPLATE_LITERAL_EXPRESSION:
          case FUNCTION_EXPRESSION:
          case MEMBER_LOOKUP_EXPRESSION:
          case MEMBER_EXPRESSION:
          case CALL_EXPRESSION:
            return true;
          case NEW_EXPRESSION:
            return this.args !== null;
        }
        return false;
      },
      isExpression: function() {
        return this.isAssignmentExpression() || this.type === COMMA_EXPRESSION;
      },
      isAssignmentOrSpread: function() {
        return this.isAssignmentExpression() || this.type === SPREAD_EXPRESSION;
      },
      isRestParameter: function() {
        return this.type === REST_PARAMETER || (this.type === FORMAL_PARAMETER && this.parameter.isRestParameter());
      },
      isSpreadPatternElement: function() {
        return this.type === SPREAD_PATTERN_ELEMENT;
      },
      isStatementListItem: function() {
        return this.isStatement() || this.isDeclaration() || this.type === TYPE_ALIAS_DECLARATION;
      },
      isStatement: function() {
        switch (this.type) {
          case BLOCK:
          case VARIABLE_STATEMENT:
          case EMPTY_STATEMENT:
          case EXPRESSION_STATEMENT:
          case IF_STATEMENT:
          case CONTINUE_STATEMENT:
          case BREAK_STATEMENT:
          case RETURN_STATEMENT:
          case WITH_STATEMENT:
          case LABELLED_STATEMENT:
          case THROW_STATEMENT:
          case TRY_STATEMENT:
          case DEBUGGER_STATEMENT:
            return true;
        }
        return this.isBreakableStatement();
      },
      isDeclaration: function() {
        switch (this.type) {
          case FUNCTION_DECLARATION:
          case CLASS_DECLARATION:
            return true;
        }
        return this.isLexicalDeclaration();
      },
      isLexicalDeclaration: function() {
        switch (this.type) {
          case VARIABLE_STATEMENT:
            return this.declarations.declarationType !== VAR;
        }
        return false;
      },
      isBreakableStatement: function() {
        switch (this.type) {
          case SWITCH_STATEMENT:
            return true;
        }
        return this.isIterationStatement();
      },
      isIterationStatement: function() {
        switch (this.type) {
          case DO_WHILE_STATEMENT:
          case FOR_IN_STATEMENT:
          case FOR_OF_STATEMENT:
          case FOR_ON_STATEMENT:
          case FOR_STATEMENT:
          case WHILE_STATEMENT:
            return true;
        }
        return false;
      },
      isScriptElement: function() {
        switch (this.type) {
          case CLASS_DECLARATION:
          case EXPORT_DECLARATION:
          case FUNCTION_DECLARATION:
          case IMPORT_DECLARATION:
          case INTERFACE_DECLARATION:
          case VARIABLE_DECLARATION:
          case TYPE_ALIAS_DECLARATION:
            return true;
        }
        return this.isStatement();
      },
      isGenerator: function() {
        return this.functionKind !== null && this.functionKind.type === STAR;
      },
      isAsyncFunction: function() {
        return this.functionKind !== null && this.functionKind.type === IDENTIFIER && this.functionKind.value === ASYNC;
      },
      isAsyncGenerator: function() {
        return this.functionKind !== null && this.functionKind.type === IDENTIFIER && this.functionKind.value === ASYNC_STAR;
      },
      isType: function() {
        switch (this.type) {
          case CONSTRUCTOR_TYPE:
          case FUNCTION_TYPE:
          case OBJECT_TYPE:
          case PREDEFINED_TYPE:
          case TYPE_NAME:
          case TYPE_REFERENCE:
            return true;
        }
        return false;
      },
      getDirectivePrologueStringToken_: function() {
        var tree = this;
        if (tree.type !== EXPRESSION_STATEMENT || !(tree = tree.expression))
          return null;
        if (tree.type !== LITERAL_EXPRESSION || !(tree = tree.literalToken))
          return null;
        if (tree.type !== STRING)
          return null;
        return tree;
      },
      isDirectivePrologue: function() {
        return this.getDirectivePrologueStringToken_() !== null;
      },
      isUseStrictDirective: function() {
        var token = this.getDirectivePrologueStringToken_();
        if (!token)
          return false;
        var v = token.value;
        return v === '"use strict"' || v === "'use strict'";
      },
      toJSON: function() {
        return utilJSON.transform(this, ParseTree.replacer);
      },
      stringify: function() {
        var indent = arguments[0] !== (void 0) ? arguments[0] : 2;
        return JSON.stringify(this, ParseTree.replacer, indent);
      },
      getStringValue: function() {
        switch (this.type) {
          case IDENTIFIER_EXPRESSION:
          case BINDING_IDENTIFIER:
            return this.identifierToken.toString();
          case IMPORTED_BINDING:
            return this.binding.getStringValue();
          case PROPERTY_NAME_SHORTHAND:
            return this.name.toString();
          case LITERAL_PROPERTY_NAME:
            return this.literalToken.toString();
        }
        throw new Error('Not yet implemented');
      }
    }, {
      stripLocation: function(key, value) {
        if (key === 'location') {
          return undefined;
        }
        return value;
      },
      replacer: function(k, v) {
        if (v instanceof ParseTree || v instanceof Token) {
          var rv = {type: v.type};
          Object.keys(v).forEach(function(name) {
            if (name !== 'location')
              rv[name] = v[name];
          });
          return rv;
        }
        return v;
      }
    });
  }();
  return {
    get ParseTreeType() {
      return ParseTreeType;
    },
    get ParseTree() {
      return ParseTree;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/trees/ParseTrees.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/trees/ParseTrees.js";
  var ParseTree = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTree.js", "traceur@0.0.112/src/syntax/trees/ParseTrees.js")).ParseTree;
  var ParseTreeType = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeType.js", "traceur@0.0.112/src/syntax/trees/ParseTrees.js"));
  var ANNOTATION = ParseTreeType.ANNOTATION;
  var Annotation = function($__super) {
    function Annotation(location, name, args) {
      $traceurRuntime.superConstructor(Annotation).call(this, location);
      this.name = name;
      this.args = args;
    }
    return ($traceurRuntime.createClass)(Annotation, {
      transform: function(transformer) {
        return transformer.transformAnnotation(this);
      },
      visit: function(visitor) {
        visitor.visitAnnotation(this);
      },
      get type() {
        return ANNOTATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var ANON_BLOCK = ParseTreeType.ANON_BLOCK;
  var AnonBlock = function($__super) {
    function AnonBlock(location, statements) {
      $traceurRuntime.superConstructor(AnonBlock).call(this, location);
      this.statements = statements;
    }
    return ($traceurRuntime.createClass)(AnonBlock, {
      transform: function(transformer) {
        return transformer.transformAnonBlock(this);
      },
      visit: function(visitor) {
        visitor.visitAnonBlock(this);
      },
      get type() {
        return ANON_BLOCK;
      }
    }, {}, $__super);
  }(ParseTree);
  var ARGUMENT_LIST = ParseTreeType.ARGUMENT_LIST;
  var ArgumentList = function($__super) {
    function ArgumentList(location, args) {
      $traceurRuntime.superConstructor(ArgumentList).call(this, location);
      this.args = args;
    }
    return ($traceurRuntime.createClass)(ArgumentList, {
      transform: function(transformer) {
        return transformer.transformArgumentList(this);
      },
      visit: function(visitor) {
        visitor.visitArgumentList(this);
      },
      get type() {
        return ARGUMENT_LIST;
      }
    }, {}, $__super);
  }(ParseTree);
  var ARRAY_COMPREHENSION = ParseTreeType.ARRAY_COMPREHENSION;
  var ArrayComprehension = function($__super) {
    function ArrayComprehension(location, comprehensionList, expression) {
      $traceurRuntime.superConstructor(ArrayComprehension).call(this, location);
      this.comprehensionList = comprehensionList;
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(ArrayComprehension, {
      transform: function(transformer) {
        return transformer.transformArrayComprehension(this);
      },
      visit: function(visitor) {
        visitor.visitArrayComprehension(this);
      },
      get type() {
        return ARRAY_COMPREHENSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var ARRAY_LITERAL = ParseTreeType.ARRAY_LITERAL;
  var ArrayLiteral = function($__super) {
    function ArrayLiteral(location, elements) {
      $traceurRuntime.superConstructor(ArrayLiteral).call(this, location);
      this.elements = elements;
    }
    return ($traceurRuntime.createClass)(ArrayLiteral, {
      transform: function(transformer) {
        return transformer.transformArrayLiteral(this);
      },
      visit: function(visitor) {
        visitor.visitArrayLiteral(this);
      },
      get type() {
        return ARRAY_LITERAL;
      }
    }, {}, $__super);
  }(ParseTree);
  var ARRAY_PATTERN = ParseTreeType.ARRAY_PATTERN;
  var ArrayPattern = function($__super) {
    function ArrayPattern(location, elements) {
      $traceurRuntime.superConstructor(ArrayPattern).call(this, location);
      this.elements = elements;
    }
    return ($traceurRuntime.createClass)(ArrayPattern, {
      transform: function(transformer) {
        return transformer.transformArrayPattern(this);
      },
      visit: function(visitor) {
        visitor.visitArrayPattern(this);
      },
      get type() {
        return ARRAY_PATTERN;
      }
    }, {}, $__super);
  }(ParseTree);
  var ARRAY_TYPE = ParseTreeType.ARRAY_TYPE;
  var ArrayType = function($__super) {
    function ArrayType(location, elementType) {
      $traceurRuntime.superConstructor(ArrayType).call(this, location);
      this.elementType = elementType;
    }
    return ($traceurRuntime.createClass)(ArrayType, {
      transform: function(transformer) {
        return transformer.transformArrayType(this);
      },
      visit: function(visitor) {
        visitor.visitArrayType(this);
      },
      get type() {
        return ARRAY_TYPE;
      }
    }, {}, $__super);
  }(ParseTree);
  var ARROW_FUNCTION = ParseTreeType.ARROW_FUNCTION;
  var ArrowFunction = function($__super) {
    function ArrowFunction(location, functionKind, parameterList, body) {
      $traceurRuntime.superConstructor(ArrowFunction).call(this, location);
      this.functionKind = functionKind;
      this.parameterList = parameterList;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(ArrowFunction, {
      transform: function(transformer) {
        return transformer.transformArrowFunction(this);
      },
      visit: function(visitor) {
        visitor.visitArrowFunction(this);
      },
      get type() {
        return ARROW_FUNCTION;
      }
    }, {}, $__super);
  }(ParseTree);
  var ASSIGNMENT_ELEMENT = ParseTreeType.ASSIGNMENT_ELEMENT;
  var AssignmentElement = function($__super) {
    function AssignmentElement(location, assignment, initializer) {
      $traceurRuntime.superConstructor(AssignmentElement).call(this, location);
      this.assignment = assignment;
      this.initializer = initializer;
    }
    return ($traceurRuntime.createClass)(AssignmentElement, {
      transform: function(transformer) {
        return transformer.transformAssignmentElement(this);
      },
      visit: function(visitor) {
        visitor.visitAssignmentElement(this);
      },
      get type() {
        return ASSIGNMENT_ELEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var AWAIT_EXPRESSION = ParseTreeType.AWAIT_EXPRESSION;
  var AwaitExpression = function($__super) {
    function AwaitExpression(location, expression) {
      $traceurRuntime.superConstructor(AwaitExpression).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(AwaitExpression, {
      transform: function(transformer) {
        return transformer.transformAwaitExpression(this);
      },
      visit: function(visitor) {
        visitor.visitAwaitExpression(this);
      },
      get type() {
        return AWAIT_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var BINARY_EXPRESSION = ParseTreeType.BINARY_EXPRESSION;
  var BinaryExpression = function($__super) {
    function BinaryExpression(location, left, operator, right) {
      $traceurRuntime.superConstructor(BinaryExpression).call(this, location);
      this.left = left;
      this.operator = operator;
      this.right = right;
    }
    return ($traceurRuntime.createClass)(BinaryExpression, {
      transform: function(transformer) {
        return transformer.transformBinaryExpression(this);
      },
      visit: function(visitor) {
        visitor.visitBinaryExpression(this);
      },
      get type() {
        return BINARY_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var BINDING_ELEMENT = ParseTreeType.BINDING_ELEMENT;
  var BindingElement = function($__super) {
    function BindingElement(location, binding, initializer) {
      $traceurRuntime.superConstructor(BindingElement).call(this, location);
      this.binding = binding;
      this.initializer = initializer;
    }
    return ($traceurRuntime.createClass)(BindingElement, {
      transform: function(transformer) {
        return transformer.transformBindingElement(this);
      },
      visit: function(visitor) {
        visitor.visitBindingElement(this);
      },
      get type() {
        return BINDING_ELEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var BINDING_IDENTIFIER = ParseTreeType.BINDING_IDENTIFIER;
  var BindingIdentifier = function($__super) {
    function BindingIdentifier(location, identifierToken) {
      $traceurRuntime.superConstructor(BindingIdentifier).call(this, location);
      this.identifierToken = identifierToken;
    }
    return ($traceurRuntime.createClass)(BindingIdentifier, {
      transform: function(transformer) {
        return transformer.transformBindingIdentifier(this);
      },
      visit: function(visitor) {
        visitor.visitBindingIdentifier(this);
      },
      get type() {
        return BINDING_IDENTIFIER;
      }
    }, {}, $__super);
  }(ParseTree);
  var BLOCK = ParseTreeType.BLOCK;
  var Block = function($__super) {
    function Block(location, statements) {
      $traceurRuntime.superConstructor(Block).call(this, location);
      this.statements = statements;
    }
    return ($traceurRuntime.createClass)(Block, {
      transform: function(transformer) {
        return transformer.transformBlock(this);
      },
      visit: function(visitor) {
        visitor.visitBlock(this);
      },
      get type() {
        return BLOCK;
      }
    }, {}, $__super);
  }(ParseTree);
  var BREAK_STATEMENT = ParseTreeType.BREAK_STATEMENT;
  var BreakStatement = function($__super) {
    function BreakStatement(location, name) {
      $traceurRuntime.superConstructor(BreakStatement).call(this, location);
      this.name = name;
    }
    return ($traceurRuntime.createClass)(BreakStatement, {
      transform: function(transformer) {
        return transformer.transformBreakStatement(this);
      },
      visit: function(visitor) {
        visitor.visitBreakStatement(this);
      },
      get type() {
        return BREAK_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var CALL_EXPRESSION = ParseTreeType.CALL_EXPRESSION;
  var CallExpression = function($__super) {
    function CallExpression(location, operand, args) {
      $traceurRuntime.superConstructor(CallExpression).call(this, location);
      this.operand = operand;
      this.args = args;
    }
    return ($traceurRuntime.createClass)(CallExpression, {
      transform: function(transformer) {
        return transformer.transformCallExpression(this);
      },
      visit: function(visitor) {
        visitor.visitCallExpression(this);
      },
      get type() {
        return CALL_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var CALL_SIGNATURE = ParseTreeType.CALL_SIGNATURE;
  var CallSignature = function($__super) {
    function CallSignature(location, typeParameters, parameterList, returnType) {
      $traceurRuntime.superConstructor(CallSignature).call(this, location);
      this.typeParameters = typeParameters;
      this.parameterList = parameterList;
      this.returnType = returnType;
    }
    return ($traceurRuntime.createClass)(CallSignature, {
      transform: function(transformer) {
        return transformer.transformCallSignature(this);
      },
      visit: function(visitor) {
        visitor.visitCallSignature(this);
      },
      get type() {
        return CALL_SIGNATURE;
      }
    }, {}, $__super);
  }(ParseTree);
  var CASE_CLAUSE = ParseTreeType.CASE_CLAUSE;
  var CaseClause = function($__super) {
    function CaseClause(location, expression, statements) {
      $traceurRuntime.superConstructor(CaseClause).call(this, location);
      this.expression = expression;
      this.statements = statements;
    }
    return ($traceurRuntime.createClass)(CaseClause, {
      transform: function(transformer) {
        return transformer.transformCaseClause(this);
      },
      visit: function(visitor) {
        visitor.visitCaseClause(this);
      },
      get type() {
        return CASE_CLAUSE;
      }
    }, {}, $__super);
  }(ParseTree);
  var CATCH = ParseTreeType.CATCH;
  var Catch = function($__super) {
    function Catch(location, binding, catchBody) {
      $traceurRuntime.superConstructor(Catch).call(this, location);
      this.binding = binding;
      this.catchBody = catchBody;
    }
    return ($traceurRuntime.createClass)(Catch, {
      transform: function(transformer) {
        return transformer.transformCatch(this);
      },
      visit: function(visitor) {
        visitor.visitCatch(this);
      },
      get type() {
        return CATCH;
      }
    }, {}, $__super);
  }(ParseTree);
  var CLASS_DECLARATION = ParseTreeType.CLASS_DECLARATION;
  var ClassDeclaration = function($__super) {
    function ClassDeclaration(location, name, superClass, elements, annotations, typeParameters) {
      $traceurRuntime.superConstructor(ClassDeclaration).call(this, location);
      this.name = name;
      this.superClass = superClass;
      this.elements = elements;
      this.annotations = annotations;
      this.typeParameters = typeParameters;
    }
    return ($traceurRuntime.createClass)(ClassDeclaration, {
      transform: function(transformer) {
        return transformer.transformClassDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitClassDeclaration(this);
      },
      get type() {
        return CLASS_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var CLASS_EXPRESSION = ParseTreeType.CLASS_EXPRESSION;
  var ClassExpression = function($__super) {
    function ClassExpression(location, name, superClass, elements, annotations, typeParameters) {
      $traceurRuntime.superConstructor(ClassExpression).call(this, location);
      this.name = name;
      this.superClass = superClass;
      this.elements = elements;
      this.annotations = annotations;
      this.typeParameters = typeParameters;
    }
    return ($traceurRuntime.createClass)(ClassExpression, {
      transform: function(transformer) {
        return transformer.transformClassExpression(this);
      },
      visit: function(visitor) {
        visitor.visitClassExpression(this);
      },
      get type() {
        return CLASS_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var COMMA_EXPRESSION = ParseTreeType.COMMA_EXPRESSION;
  var CommaExpression = function($__super) {
    function CommaExpression(location, expressions) {
      $traceurRuntime.superConstructor(CommaExpression).call(this, location);
      this.expressions = expressions;
    }
    return ($traceurRuntime.createClass)(CommaExpression, {
      transform: function(transformer) {
        return transformer.transformCommaExpression(this);
      },
      visit: function(visitor) {
        visitor.visitCommaExpression(this);
      },
      get type() {
        return COMMA_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var COMPREHENSION_FOR = ParseTreeType.COMPREHENSION_FOR;
  var ComprehensionFor = function($__super) {
    function ComprehensionFor(location, left, iterator) {
      $traceurRuntime.superConstructor(ComprehensionFor).call(this, location);
      this.left = left;
      this.iterator = iterator;
    }
    return ($traceurRuntime.createClass)(ComprehensionFor, {
      transform: function(transformer) {
        return transformer.transformComprehensionFor(this);
      },
      visit: function(visitor) {
        visitor.visitComprehensionFor(this);
      },
      get type() {
        return COMPREHENSION_FOR;
      }
    }, {}, $__super);
  }(ParseTree);
  var COMPREHENSION_IF = ParseTreeType.COMPREHENSION_IF;
  var ComprehensionIf = function($__super) {
    function ComprehensionIf(location, expression) {
      $traceurRuntime.superConstructor(ComprehensionIf).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(ComprehensionIf, {
      transform: function(transformer) {
        return transformer.transformComprehensionIf(this);
      },
      visit: function(visitor) {
        visitor.visitComprehensionIf(this);
      },
      get type() {
        return COMPREHENSION_IF;
      }
    }, {}, $__super);
  }(ParseTree);
  var COMPUTED_PROPERTY_NAME = ParseTreeType.COMPUTED_PROPERTY_NAME;
  var ComputedPropertyName = function($__super) {
    function ComputedPropertyName(location, expression) {
      $traceurRuntime.superConstructor(ComputedPropertyName).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(ComputedPropertyName, {
      transform: function(transformer) {
        return transformer.transformComputedPropertyName(this);
      },
      visit: function(visitor) {
        visitor.visitComputedPropertyName(this);
      },
      get type() {
        return COMPUTED_PROPERTY_NAME;
      }
    }, {}, $__super);
  }(ParseTree);
  var CONDITIONAL_EXPRESSION = ParseTreeType.CONDITIONAL_EXPRESSION;
  var ConditionalExpression = function($__super) {
    function ConditionalExpression(location, condition, left, right) {
      $traceurRuntime.superConstructor(ConditionalExpression).call(this, location);
      this.condition = condition;
      this.left = left;
      this.right = right;
    }
    return ($traceurRuntime.createClass)(ConditionalExpression, {
      transform: function(transformer) {
        return transformer.transformConditionalExpression(this);
      },
      visit: function(visitor) {
        visitor.visitConditionalExpression(this);
      },
      get type() {
        return CONDITIONAL_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var CONSTRUCT_SIGNATURE = ParseTreeType.CONSTRUCT_SIGNATURE;
  var ConstructSignature = function($__super) {
    function ConstructSignature(location, typeParameters, parameterList, returnType) {
      $traceurRuntime.superConstructor(ConstructSignature).call(this, location);
      this.typeParameters = typeParameters;
      this.parameterList = parameterList;
      this.returnType = returnType;
    }
    return ($traceurRuntime.createClass)(ConstructSignature, {
      transform: function(transformer) {
        return transformer.transformConstructSignature(this);
      },
      visit: function(visitor) {
        visitor.visitConstructSignature(this);
      },
      get type() {
        return CONSTRUCT_SIGNATURE;
      }
    }, {}, $__super);
  }(ParseTree);
  var CONSTRUCTOR_TYPE = ParseTreeType.CONSTRUCTOR_TYPE;
  var ConstructorType = function($__super) {
    function ConstructorType(location, typeParameters, parameterList, returnType) {
      $traceurRuntime.superConstructor(ConstructorType).call(this, location);
      this.typeParameters = typeParameters;
      this.parameterList = parameterList;
      this.returnType = returnType;
    }
    return ($traceurRuntime.createClass)(ConstructorType, {
      transform: function(transformer) {
        return transformer.transformConstructorType(this);
      },
      visit: function(visitor) {
        visitor.visitConstructorType(this);
      },
      get type() {
        return CONSTRUCTOR_TYPE;
      }
    }, {}, $__super);
  }(ParseTree);
  var CONTINUE_STATEMENT = ParseTreeType.CONTINUE_STATEMENT;
  var ContinueStatement = function($__super) {
    function ContinueStatement(location, name) {
      $traceurRuntime.superConstructor(ContinueStatement).call(this, location);
      this.name = name;
    }
    return ($traceurRuntime.createClass)(ContinueStatement, {
      transform: function(transformer) {
        return transformer.transformContinueStatement(this);
      },
      visit: function(visitor) {
        visitor.visitContinueStatement(this);
      },
      get type() {
        return CONTINUE_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var COVER_FORMALS = ParseTreeType.COVER_FORMALS;
  var CoverFormals = function($__super) {
    function CoverFormals(location, expressions) {
      $traceurRuntime.superConstructor(CoverFormals).call(this, location);
      this.expressions = expressions;
    }
    return ($traceurRuntime.createClass)(CoverFormals, {
      transform: function(transformer) {
        return transformer.transformCoverFormals(this);
      },
      visit: function(visitor) {
        visitor.visitCoverFormals(this);
      },
      get type() {
        return COVER_FORMALS;
      }
    }, {}, $__super);
  }(ParseTree);
  var COVER_INITIALIZED_NAME = ParseTreeType.COVER_INITIALIZED_NAME;
  var CoverInitializedName = function($__super) {
    function CoverInitializedName(location, name, equalToken, initializer) {
      $traceurRuntime.superConstructor(CoverInitializedName).call(this, location);
      this.name = name;
      this.equalToken = equalToken;
      this.initializer = initializer;
    }
    return ($traceurRuntime.createClass)(CoverInitializedName, {
      transform: function(transformer) {
        return transformer.transformCoverInitializedName(this);
      },
      visit: function(visitor) {
        visitor.visitCoverInitializedName(this);
      },
      get type() {
        return COVER_INITIALIZED_NAME;
      }
    }, {}, $__super);
  }(ParseTree);
  var DEBUGGER_STATEMENT = ParseTreeType.DEBUGGER_STATEMENT;
  var DebuggerStatement = function($__super) {
    function DebuggerStatement(location) {
      $traceurRuntime.superConstructor(DebuggerStatement).call(this, location);
    }
    return ($traceurRuntime.createClass)(DebuggerStatement, {
      transform: function(transformer) {
        return transformer.transformDebuggerStatement(this);
      },
      visit: function(visitor) {
        visitor.visitDebuggerStatement(this);
      },
      get type() {
        return DEBUGGER_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var DEFAULT_CLAUSE = ParseTreeType.DEFAULT_CLAUSE;
  var DefaultClause = function($__super) {
    function DefaultClause(location, statements) {
      $traceurRuntime.superConstructor(DefaultClause).call(this, location);
      this.statements = statements;
    }
    return ($traceurRuntime.createClass)(DefaultClause, {
      transform: function(transformer) {
        return transformer.transformDefaultClause(this);
      },
      visit: function(visitor) {
        visitor.visitDefaultClause(this);
      },
      get type() {
        return DEFAULT_CLAUSE;
      }
    }, {}, $__super);
  }(ParseTree);
  var DO_WHILE_STATEMENT = ParseTreeType.DO_WHILE_STATEMENT;
  var DoWhileStatement = function($__super) {
    function DoWhileStatement(location, body, condition) {
      $traceurRuntime.superConstructor(DoWhileStatement).call(this, location);
      this.body = body;
      this.condition = condition;
    }
    return ($traceurRuntime.createClass)(DoWhileStatement, {
      transform: function(transformer) {
        return transformer.transformDoWhileStatement(this);
      },
      visit: function(visitor) {
        visitor.visitDoWhileStatement(this);
      },
      get type() {
        return DO_WHILE_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var EMPTY_STATEMENT = ParseTreeType.EMPTY_STATEMENT;
  var EmptyStatement = function($__super) {
    function EmptyStatement(location) {
      $traceurRuntime.superConstructor(EmptyStatement).call(this, location);
    }
    return ($traceurRuntime.createClass)(EmptyStatement, {
      transform: function(transformer) {
        return transformer.transformEmptyStatement(this);
      },
      visit: function(visitor) {
        visitor.visitEmptyStatement(this);
      },
      get type() {
        return EMPTY_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var EXPORT_DECLARATION = ParseTreeType.EXPORT_DECLARATION;
  var ExportDeclaration = function($__super) {
    function ExportDeclaration(location, declaration, annotations) {
      $traceurRuntime.superConstructor(ExportDeclaration).call(this, location);
      this.declaration = declaration;
      this.annotations = annotations;
    }
    return ($traceurRuntime.createClass)(ExportDeclaration, {
      transform: function(transformer) {
        return transformer.transformExportDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitExportDeclaration(this);
      },
      get type() {
        return EXPORT_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var EXPORT_DEFAULT = ParseTreeType.EXPORT_DEFAULT;
  var ExportDefault = function($__super) {
    function ExportDefault(location, expression) {
      $traceurRuntime.superConstructor(ExportDefault).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(ExportDefault, {
      transform: function(transformer) {
        return transformer.transformExportDefault(this);
      },
      visit: function(visitor) {
        visitor.visitExportDefault(this);
      },
      get type() {
        return EXPORT_DEFAULT;
      }
    }, {}, $__super);
  }(ParseTree);
  var EXPORT_SPECIFIER = ParseTreeType.EXPORT_SPECIFIER;
  var ExportSpecifier = function($__super) {
    function ExportSpecifier(location, lhs, rhs) {
      $traceurRuntime.superConstructor(ExportSpecifier).call(this, location);
      this.lhs = lhs;
      this.rhs = rhs;
    }
    return ($traceurRuntime.createClass)(ExportSpecifier, {
      transform: function(transformer) {
        return transformer.transformExportSpecifier(this);
      },
      visit: function(visitor) {
        visitor.visitExportSpecifier(this);
      },
      get type() {
        return EXPORT_SPECIFIER;
      }
    }, {}, $__super);
  }(ParseTree);
  var EXPORT_SPECIFIER_SET = ParseTreeType.EXPORT_SPECIFIER_SET;
  var ExportSpecifierSet = function($__super) {
    function ExportSpecifierSet(location, specifiers) {
      $traceurRuntime.superConstructor(ExportSpecifierSet).call(this, location);
      this.specifiers = specifiers;
    }
    return ($traceurRuntime.createClass)(ExportSpecifierSet, {
      transform: function(transformer) {
        return transformer.transformExportSpecifierSet(this);
      },
      visit: function(visitor) {
        visitor.visitExportSpecifierSet(this);
      },
      get type() {
        return EXPORT_SPECIFIER_SET;
      }
    }, {}, $__super);
  }(ParseTree);
  var EXPORT_STAR = ParseTreeType.EXPORT_STAR;
  var ExportStar = function($__super) {
    function ExportStar(location) {
      $traceurRuntime.superConstructor(ExportStar).call(this, location);
    }
    return ($traceurRuntime.createClass)(ExportStar, {
      transform: function(transformer) {
        return transformer.transformExportStar(this);
      },
      visit: function(visitor) {
        visitor.visitExportStar(this);
      },
      get type() {
        return EXPORT_STAR;
      }
    }, {}, $__super);
  }(ParseTree);
  var EXPRESSION_STATEMENT = ParseTreeType.EXPRESSION_STATEMENT;
  var ExpressionStatement = function($__super) {
    function ExpressionStatement(location, expression) {
      $traceurRuntime.superConstructor(ExpressionStatement).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(ExpressionStatement, {
      transform: function(transformer) {
        return transformer.transformExpressionStatement(this);
      },
      visit: function(visitor) {
        visitor.visitExpressionStatement(this);
      },
      get type() {
        return EXPRESSION_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var FINALLY = ParseTreeType.FINALLY;
  var Finally = function($__super) {
    function Finally(location, block) {
      $traceurRuntime.superConstructor(Finally).call(this, location);
      this.block = block;
    }
    return ($traceurRuntime.createClass)(Finally, {
      transform: function(transformer) {
        return transformer.transformFinally(this);
      },
      visit: function(visitor) {
        visitor.visitFinally(this);
      },
      get type() {
        return FINALLY;
      }
    }, {}, $__super);
  }(ParseTree);
  var FOR_IN_STATEMENT = ParseTreeType.FOR_IN_STATEMENT;
  var ForInStatement = function($__super) {
    function ForInStatement(location, initializer, collection, body) {
      $traceurRuntime.superConstructor(ForInStatement).call(this, location);
      this.initializer = initializer;
      this.collection = collection;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(ForInStatement, {
      transform: function(transformer) {
        return transformer.transformForInStatement(this);
      },
      visit: function(visitor) {
        visitor.visitForInStatement(this);
      },
      get type() {
        return FOR_IN_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var FOR_OF_STATEMENT = ParseTreeType.FOR_OF_STATEMENT;
  var ForOfStatement = function($__super) {
    function ForOfStatement(location, initializer, collection, body) {
      $traceurRuntime.superConstructor(ForOfStatement).call(this, location);
      this.initializer = initializer;
      this.collection = collection;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(ForOfStatement, {
      transform: function(transformer) {
        return transformer.transformForOfStatement(this);
      },
      visit: function(visitor) {
        visitor.visitForOfStatement(this);
      },
      get type() {
        return FOR_OF_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var FOR_ON_STATEMENT = ParseTreeType.FOR_ON_STATEMENT;
  var ForOnStatement = function($__super) {
    function ForOnStatement(location, initializer, observable, body) {
      $traceurRuntime.superConstructor(ForOnStatement).call(this, location);
      this.initializer = initializer;
      this.observable = observable;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(ForOnStatement, {
      transform: function(transformer) {
        return transformer.transformForOnStatement(this);
      },
      visit: function(visitor) {
        visitor.visitForOnStatement(this);
      },
      get type() {
        return FOR_ON_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var FOR_STATEMENT = ParseTreeType.FOR_STATEMENT;
  var ForStatement = function($__super) {
    function ForStatement(location, initializer, condition, increment, body) {
      $traceurRuntime.superConstructor(ForStatement).call(this, location);
      this.initializer = initializer;
      this.condition = condition;
      this.increment = increment;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(ForStatement, {
      transform: function(transformer) {
        return transformer.transformForStatement(this);
      },
      visit: function(visitor) {
        visitor.visitForStatement(this);
      },
      get type() {
        return FOR_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var FORMAL_PARAMETER = ParseTreeType.FORMAL_PARAMETER;
  var FormalParameter = function($__super) {
    function FormalParameter(location, parameter, typeAnnotation, annotations) {
      $traceurRuntime.superConstructor(FormalParameter).call(this, location);
      this.parameter = parameter;
      this.typeAnnotation = typeAnnotation;
      this.annotations = annotations;
    }
    return ($traceurRuntime.createClass)(FormalParameter, {
      transform: function(transformer) {
        return transformer.transformFormalParameter(this);
      },
      visit: function(visitor) {
        visitor.visitFormalParameter(this);
      },
      get type() {
        return FORMAL_PARAMETER;
      }
    }, {}, $__super);
  }(ParseTree);
  var FORMAL_PARAMETER_LIST = ParseTreeType.FORMAL_PARAMETER_LIST;
  var FormalParameterList = function($__super) {
    function FormalParameterList(location, parameters) {
      $traceurRuntime.superConstructor(FormalParameterList).call(this, location);
      this.parameters = parameters;
    }
    return ($traceurRuntime.createClass)(FormalParameterList, {
      transform: function(transformer) {
        return transformer.transformFormalParameterList(this);
      },
      visit: function(visitor) {
        visitor.visitFormalParameterList(this);
      },
      get type() {
        return FORMAL_PARAMETER_LIST;
      }
    }, {}, $__super);
  }(ParseTree);
  var FORWARD_DEFAULT_EXPORT = ParseTreeType.FORWARD_DEFAULT_EXPORT;
  var ForwardDefaultExport = function($__super) {
    function ForwardDefaultExport(location, name) {
      $traceurRuntime.superConstructor(ForwardDefaultExport).call(this, location);
      this.name = name;
    }
    return ($traceurRuntime.createClass)(ForwardDefaultExport, {
      transform: function(transformer) {
        return transformer.transformForwardDefaultExport(this);
      },
      visit: function(visitor) {
        visitor.visitForwardDefaultExport(this);
      },
      get type() {
        return FORWARD_DEFAULT_EXPORT;
      }
    }, {}, $__super);
  }(ParseTree);
  var FUNCTION_BODY = ParseTreeType.FUNCTION_BODY;
  var FunctionBody = function($__super) {
    function FunctionBody(location, statements) {
      $traceurRuntime.superConstructor(FunctionBody).call(this, location);
      this.statements = statements;
    }
    return ($traceurRuntime.createClass)(FunctionBody, {
      transform: function(transformer) {
        return transformer.transformFunctionBody(this);
      },
      visit: function(visitor) {
        visitor.visitFunctionBody(this);
      },
      get type() {
        return FUNCTION_BODY;
      }
    }, {}, $__super);
  }(ParseTree);
  var FUNCTION_DECLARATION = ParseTreeType.FUNCTION_DECLARATION;
  var FunctionDeclaration = function($__super) {
    function FunctionDeclaration(location, name, functionKind, parameterList, typeAnnotation, annotations, body) {
      $traceurRuntime.superConstructor(FunctionDeclaration).call(this, location);
      this.name = name;
      this.functionKind = functionKind;
      this.parameterList = parameterList;
      this.typeAnnotation = typeAnnotation;
      this.annotations = annotations;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(FunctionDeclaration, {
      transform: function(transformer) {
        return transformer.transformFunctionDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitFunctionDeclaration(this);
      },
      get type() {
        return FUNCTION_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var FUNCTION_EXPRESSION = ParseTreeType.FUNCTION_EXPRESSION;
  var FunctionExpression = function($__super) {
    function FunctionExpression(location, name, functionKind, parameterList, typeAnnotation, annotations, body) {
      $traceurRuntime.superConstructor(FunctionExpression).call(this, location);
      this.name = name;
      this.functionKind = functionKind;
      this.parameterList = parameterList;
      this.typeAnnotation = typeAnnotation;
      this.annotations = annotations;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(FunctionExpression, {
      transform: function(transformer) {
        return transformer.transformFunctionExpression(this);
      },
      visit: function(visitor) {
        visitor.visitFunctionExpression(this);
      },
      get type() {
        return FUNCTION_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var FUNCTION_TYPE = ParseTreeType.FUNCTION_TYPE;
  var FunctionType = function($__super) {
    function FunctionType(location, typeParameters, parameterList, returnType) {
      $traceurRuntime.superConstructor(FunctionType).call(this, location);
      this.typeParameters = typeParameters;
      this.parameterList = parameterList;
      this.returnType = returnType;
    }
    return ($traceurRuntime.createClass)(FunctionType, {
      transform: function(transformer) {
        return transformer.transformFunctionType(this);
      },
      visit: function(visitor) {
        visitor.visitFunctionType(this);
      },
      get type() {
        return FUNCTION_TYPE;
      }
    }, {}, $__super);
  }(ParseTree);
  var GENERATOR_COMPREHENSION = ParseTreeType.GENERATOR_COMPREHENSION;
  var GeneratorComprehension = function($__super) {
    function GeneratorComprehension(location, comprehensionList, expression) {
      $traceurRuntime.superConstructor(GeneratorComprehension).call(this, location);
      this.comprehensionList = comprehensionList;
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(GeneratorComprehension, {
      transform: function(transformer) {
        return transformer.transformGeneratorComprehension(this);
      },
      visit: function(visitor) {
        visitor.visitGeneratorComprehension(this);
      },
      get type() {
        return GENERATOR_COMPREHENSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var GET_ACCESSOR = ParseTreeType.GET_ACCESSOR;
  var GetAccessor = function($__super) {
    function GetAccessor(location, isStatic, name, typeAnnotation, annotations, body) {
      $traceurRuntime.superConstructor(GetAccessor).call(this, location);
      this.isStatic = isStatic;
      this.name = name;
      this.typeAnnotation = typeAnnotation;
      this.annotations = annotations;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(GetAccessor, {
      transform: function(transformer) {
        return transformer.transformGetAccessor(this);
      },
      visit: function(visitor) {
        visitor.visitGetAccessor(this);
      },
      get type() {
        return GET_ACCESSOR;
      }
    }, {}, $__super);
  }(ParseTree);
  var IDENTIFIER_EXPRESSION = ParseTreeType.IDENTIFIER_EXPRESSION;
  var IdentifierExpression = function($__super) {
    function IdentifierExpression(location, identifierToken) {
      $traceurRuntime.superConstructor(IdentifierExpression).call(this, location);
      this.identifierToken = identifierToken;
    }
    return ($traceurRuntime.createClass)(IdentifierExpression, {
      transform: function(transformer) {
        return transformer.transformIdentifierExpression(this);
      },
      visit: function(visitor) {
        visitor.visitIdentifierExpression(this);
      },
      get type() {
        return IDENTIFIER_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var IF_STATEMENT = ParseTreeType.IF_STATEMENT;
  var IfStatement = function($__super) {
    function IfStatement(location, condition, ifClause, elseClause) {
      $traceurRuntime.superConstructor(IfStatement).call(this, location);
      this.condition = condition;
      this.ifClause = ifClause;
      this.elseClause = elseClause;
    }
    return ($traceurRuntime.createClass)(IfStatement, {
      transform: function(transformer) {
        return transformer.transformIfStatement(this);
      },
      visit: function(visitor) {
        visitor.visitIfStatement(this);
      },
      get type() {
        return IF_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var IMPORTED_BINDING = ParseTreeType.IMPORTED_BINDING;
  var ImportedBinding = function($__super) {
    function ImportedBinding(location, binding) {
      $traceurRuntime.superConstructor(ImportedBinding).call(this, location);
      this.binding = binding;
    }
    return ($traceurRuntime.createClass)(ImportedBinding, {
      transform: function(transformer) {
        return transformer.transformImportedBinding(this);
      },
      visit: function(visitor) {
        visitor.visitImportedBinding(this);
      },
      get type() {
        return IMPORTED_BINDING;
      }
    }, {}, $__super);
  }(ParseTree);
  var IMPORT_CLAUSE_PAIR = ParseTreeType.IMPORT_CLAUSE_PAIR;
  var ImportClausePair = function($__super) {
    function ImportClausePair(location, first, second) {
      $traceurRuntime.superConstructor(ImportClausePair).call(this, location);
      this.first = first;
      this.second = second;
    }
    return ($traceurRuntime.createClass)(ImportClausePair, {
      transform: function(transformer) {
        return transformer.transformImportClausePair(this);
      },
      visit: function(visitor) {
        visitor.visitImportClausePair(this);
      },
      get type() {
        return IMPORT_CLAUSE_PAIR;
      }
    }, {}, $__super);
  }(ParseTree);
  var IMPORT_DECLARATION = ParseTreeType.IMPORT_DECLARATION;
  var ImportDeclaration = function($__super) {
    function ImportDeclaration(location, importClause, moduleSpecifier) {
      $traceurRuntime.superConstructor(ImportDeclaration).call(this, location);
      this.importClause = importClause;
      this.moduleSpecifier = moduleSpecifier;
    }
    return ($traceurRuntime.createClass)(ImportDeclaration, {
      transform: function(transformer) {
        return transformer.transformImportDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitImportDeclaration(this);
      },
      get type() {
        return IMPORT_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var IMPORT_SPECIFIER = ParseTreeType.IMPORT_SPECIFIER;
  var ImportSpecifier = function($__super) {
    function ImportSpecifier(location, binding, name) {
      $traceurRuntime.superConstructor(ImportSpecifier).call(this, location);
      this.binding = binding;
      this.name = name;
    }
    return ($traceurRuntime.createClass)(ImportSpecifier, {
      transform: function(transformer) {
        return transformer.transformImportSpecifier(this);
      },
      visit: function(visitor) {
        visitor.visitImportSpecifier(this);
      },
      get type() {
        return IMPORT_SPECIFIER;
      }
    }, {}, $__super);
  }(ParseTree);
  var IMPORT_SPECIFIER_SET = ParseTreeType.IMPORT_SPECIFIER_SET;
  var ImportSpecifierSet = function($__super) {
    function ImportSpecifierSet(location, specifiers) {
      $traceurRuntime.superConstructor(ImportSpecifierSet).call(this, location);
      this.specifiers = specifiers;
    }
    return ($traceurRuntime.createClass)(ImportSpecifierSet, {
      transform: function(transformer) {
        return transformer.transformImportSpecifierSet(this);
      },
      visit: function(visitor) {
        visitor.visitImportSpecifierSet(this);
      },
      get type() {
        return IMPORT_SPECIFIER_SET;
      }
    }, {}, $__super);
  }(ParseTree);
  var IMPORT_TYPE_CLAUSE = ParseTreeType.IMPORT_TYPE_CLAUSE;
  var ImportTypeClause = function($__super) {
    function ImportTypeClause(location, clause) {
      $traceurRuntime.superConstructor(ImportTypeClause).call(this, location);
      this.clause = clause;
    }
    return ($traceurRuntime.createClass)(ImportTypeClause, {
      transform: function(transformer) {
        return transformer.transformImportTypeClause(this);
      },
      visit: function(visitor) {
        visitor.visitImportTypeClause(this);
      },
      get type() {
        return IMPORT_TYPE_CLAUSE;
      }
    }, {}, $__super);
  }(ParseTree);
  var INDEX_SIGNATURE = ParseTreeType.INDEX_SIGNATURE;
  var IndexSignature = function($__super) {
    function IndexSignature(location, name, indexType, typeAnnotation) {
      $traceurRuntime.superConstructor(IndexSignature).call(this, location);
      this.name = name;
      this.indexType = indexType;
      this.typeAnnotation = typeAnnotation;
    }
    return ($traceurRuntime.createClass)(IndexSignature, {
      transform: function(transformer) {
        return transformer.transformIndexSignature(this);
      },
      visit: function(visitor) {
        visitor.visitIndexSignature(this);
      },
      get type() {
        return INDEX_SIGNATURE;
      }
    }, {}, $__super);
  }(ParseTree);
  var INTERFACE_DECLARATION = ParseTreeType.INTERFACE_DECLARATION;
  var InterfaceDeclaration = function($__super) {
    function InterfaceDeclaration(location, name, typeParameters, extendsClause, objectType) {
      $traceurRuntime.superConstructor(InterfaceDeclaration).call(this, location);
      this.name = name;
      this.typeParameters = typeParameters;
      this.extendsClause = extendsClause;
      this.objectType = objectType;
    }
    return ($traceurRuntime.createClass)(InterfaceDeclaration, {
      transform: function(transformer) {
        return transformer.transformInterfaceDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitInterfaceDeclaration(this);
      },
      get type() {
        return INTERFACE_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var JSX_ATTRIBUTE = ParseTreeType.JSX_ATTRIBUTE;
  var JsxAttribute = function($__super) {
    function JsxAttribute(location, name, value) {
      $traceurRuntime.superConstructor(JsxAttribute).call(this, location);
      this.name = name;
      this.value = value;
    }
    return ($traceurRuntime.createClass)(JsxAttribute, {
      transform: function(transformer) {
        return transformer.transformJsxAttribute(this);
      },
      visit: function(visitor) {
        visitor.visitJsxAttribute(this);
      },
      get type() {
        return JSX_ATTRIBUTE;
      }
    }, {}, $__super);
  }(ParseTree);
  var JSX_ELEMENT = ParseTreeType.JSX_ELEMENT;
  var JsxElement = function($__super) {
    function JsxElement(location, name, attributes, children) {
      $traceurRuntime.superConstructor(JsxElement).call(this, location);
      this.name = name;
      this.attributes = attributes;
      this.children = children;
    }
    return ($traceurRuntime.createClass)(JsxElement, {
      transform: function(transformer) {
        return transformer.transformJsxElement(this);
      },
      visit: function(visitor) {
        visitor.visitJsxElement(this);
      },
      get type() {
        return JSX_ELEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var JSX_ELEMENT_NAME = ParseTreeType.JSX_ELEMENT_NAME;
  var JsxElementName = function($__super) {
    function JsxElementName(location, names) {
      $traceurRuntime.superConstructor(JsxElementName).call(this, location);
      this.names = names;
    }
    return ($traceurRuntime.createClass)(JsxElementName, {
      transform: function(transformer) {
        return transformer.transformJsxElementName(this);
      },
      visit: function(visitor) {
        visitor.visitJsxElementName(this);
      },
      get type() {
        return JSX_ELEMENT_NAME;
      }
    }, {}, $__super);
  }(ParseTree);
  var JSX_PLACEHOLDER = ParseTreeType.JSX_PLACEHOLDER;
  var JsxPlaceholder = function($__super) {
    function JsxPlaceholder(location, expression) {
      $traceurRuntime.superConstructor(JsxPlaceholder).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(JsxPlaceholder, {
      transform: function(transformer) {
        return transformer.transformJsxPlaceholder(this);
      },
      visit: function(visitor) {
        visitor.visitJsxPlaceholder(this);
      },
      get type() {
        return JSX_PLACEHOLDER;
      }
    }, {}, $__super);
  }(ParseTree);
  var JSX_SPREAD_ATTRIBUTE = ParseTreeType.JSX_SPREAD_ATTRIBUTE;
  var JsxSpreadAttribute = function($__super) {
    function JsxSpreadAttribute(location, expression) {
      $traceurRuntime.superConstructor(JsxSpreadAttribute).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(JsxSpreadAttribute, {
      transform: function(transformer) {
        return transformer.transformJsxSpreadAttribute(this);
      },
      visit: function(visitor) {
        visitor.visitJsxSpreadAttribute(this);
      },
      get type() {
        return JSX_SPREAD_ATTRIBUTE;
      }
    }, {}, $__super);
  }(ParseTree);
  var JSX_TEXT = ParseTreeType.JSX_TEXT;
  var JsxText = function($__super) {
    function JsxText(location, value) {
      $traceurRuntime.superConstructor(JsxText).call(this, location);
      this.value = value;
    }
    return ($traceurRuntime.createClass)(JsxText, {
      transform: function(transformer) {
        return transformer.transformJsxText(this);
      },
      visit: function(visitor) {
        visitor.visitJsxText(this);
      },
      get type() {
        return JSX_TEXT;
      }
    }, {}, $__super);
  }(ParseTree);
  var LABELLED_STATEMENT = ParseTreeType.LABELLED_STATEMENT;
  var LabelledStatement = function($__super) {
    function LabelledStatement(location, name, statement) {
      $traceurRuntime.superConstructor(LabelledStatement).call(this, location);
      this.name = name;
      this.statement = statement;
    }
    return ($traceurRuntime.createClass)(LabelledStatement, {
      transform: function(transformer) {
        return transformer.transformLabelledStatement(this);
      },
      visit: function(visitor) {
        visitor.visitLabelledStatement(this);
      },
      get type() {
        return LABELLED_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var LITERAL_EXPRESSION = ParseTreeType.LITERAL_EXPRESSION;
  var LiteralExpression = function($__super) {
    function LiteralExpression(location, literalToken) {
      $traceurRuntime.superConstructor(LiteralExpression).call(this, location);
      this.literalToken = literalToken;
    }
    return ($traceurRuntime.createClass)(LiteralExpression, {
      transform: function(transformer) {
        return transformer.transformLiteralExpression(this);
      },
      visit: function(visitor) {
        visitor.visitLiteralExpression(this);
      },
      get type() {
        return LITERAL_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var LITERAL_PROPERTY_NAME = ParseTreeType.LITERAL_PROPERTY_NAME;
  var LiteralPropertyName = function($__super) {
    function LiteralPropertyName(location, literalToken) {
      $traceurRuntime.superConstructor(LiteralPropertyName).call(this, location);
      this.literalToken = literalToken;
    }
    return ($traceurRuntime.createClass)(LiteralPropertyName, {
      transform: function(transformer) {
        return transformer.transformLiteralPropertyName(this);
      },
      visit: function(visitor) {
        visitor.visitLiteralPropertyName(this);
      },
      get type() {
        return LITERAL_PROPERTY_NAME;
      }
    }, {}, $__super);
  }(ParseTree);
  var MEMBER_EXPRESSION = ParseTreeType.MEMBER_EXPRESSION;
  var MemberExpression = function($__super) {
    function MemberExpression(location, operand, memberName) {
      $traceurRuntime.superConstructor(MemberExpression).call(this, location);
      this.operand = operand;
      this.memberName = memberName;
    }
    return ($traceurRuntime.createClass)(MemberExpression, {
      transform: function(transformer) {
        return transformer.transformMemberExpression(this);
      },
      visit: function(visitor) {
        visitor.visitMemberExpression(this);
      },
      get type() {
        return MEMBER_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var MEMBER_LOOKUP_EXPRESSION = ParseTreeType.MEMBER_LOOKUP_EXPRESSION;
  var MemberLookupExpression = function($__super) {
    function MemberLookupExpression(location, operand, memberExpression) {
      $traceurRuntime.superConstructor(MemberLookupExpression).call(this, location);
      this.operand = operand;
      this.memberExpression = memberExpression;
    }
    return ($traceurRuntime.createClass)(MemberLookupExpression, {
      transform: function(transformer) {
        return transformer.transformMemberLookupExpression(this);
      },
      visit: function(visitor) {
        visitor.visitMemberLookupExpression(this);
      },
      get type() {
        return MEMBER_LOOKUP_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var METHOD = ParseTreeType.METHOD;
  var Method = function($__super) {
    function Method(location, isStatic, functionKind, name, parameterList, typeAnnotation, annotations, body, debugName) {
      $traceurRuntime.superConstructor(Method).call(this, location);
      this.isStatic = isStatic;
      this.functionKind = functionKind;
      this.name = name;
      this.parameterList = parameterList;
      this.typeAnnotation = typeAnnotation;
      this.annotations = annotations;
      this.body = body;
      this.debugName = debugName;
    }
    return ($traceurRuntime.createClass)(Method, {
      transform: function(transformer) {
        return transformer.transformMethod(this);
      },
      visit: function(visitor) {
        visitor.visitMethod(this);
      },
      get type() {
        return METHOD;
      }
    }, {}, $__super);
  }(ParseTree);
  var METHOD_SIGNATURE = ParseTreeType.METHOD_SIGNATURE;
  var MethodSignature = function($__super) {
    function MethodSignature(location, name, optional, callSignature) {
      $traceurRuntime.superConstructor(MethodSignature).call(this, location);
      this.name = name;
      this.optional = optional;
      this.callSignature = callSignature;
    }
    return ($traceurRuntime.createClass)(MethodSignature, {
      transform: function(transformer) {
        return transformer.transformMethodSignature(this);
      },
      visit: function(visitor) {
        visitor.visitMethodSignature(this);
      },
      get type() {
        return METHOD_SIGNATURE;
      }
    }, {}, $__super);
  }(ParseTree);
  var MODULE = ParseTreeType.MODULE;
  var Module = function($__super) {
    function Module(location, scriptItemList, moduleName) {
      $traceurRuntime.superConstructor(Module).call(this, location);
      this.scriptItemList = scriptItemList;
      this.moduleName = moduleName;
    }
    return ($traceurRuntime.createClass)(Module, {
      transform: function(transformer) {
        return transformer.transformModule(this);
      },
      visit: function(visitor) {
        visitor.visitModule(this);
      },
      get type() {
        return MODULE;
      }
    }, {}, $__super);
  }(ParseTree);
  var MODULE_SPECIFIER = ParseTreeType.MODULE_SPECIFIER;
  var ModuleSpecifier = function($__super) {
    function ModuleSpecifier(location, token) {
      $traceurRuntime.superConstructor(ModuleSpecifier).call(this, location);
      this.token = token;
    }
    return ($traceurRuntime.createClass)(ModuleSpecifier, {
      transform: function(transformer) {
        return transformer.transformModuleSpecifier(this);
      },
      visit: function(visitor) {
        visitor.visitModuleSpecifier(this);
      },
      get type() {
        return MODULE_SPECIFIER;
      }
    }, {}, $__super);
  }(ParseTree);
  var NAME_SPACE_EXPORT = ParseTreeType.NAME_SPACE_EXPORT;
  var NameSpaceExport = function($__super) {
    function NameSpaceExport(location, name) {
      $traceurRuntime.superConstructor(NameSpaceExport).call(this, location);
      this.name = name;
    }
    return ($traceurRuntime.createClass)(NameSpaceExport, {
      transform: function(transformer) {
        return transformer.transformNameSpaceExport(this);
      },
      visit: function(visitor) {
        visitor.visitNameSpaceExport(this);
      },
      get type() {
        return NAME_SPACE_EXPORT;
      }
    }, {}, $__super);
  }(ParseTree);
  var NAME_SPACE_IMPORT = ParseTreeType.NAME_SPACE_IMPORT;
  var NameSpaceImport = function($__super) {
    function NameSpaceImport(location, binding) {
      $traceurRuntime.superConstructor(NameSpaceImport).call(this, location);
      this.binding = binding;
    }
    return ($traceurRuntime.createClass)(NameSpaceImport, {
      transform: function(transformer) {
        return transformer.transformNameSpaceImport(this);
      },
      visit: function(visitor) {
        visitor.visitNameSpaceImport(this);
      },
      get type() {
        return NAME_SPACE_IMPORT;
      }
    }, {}, $__super);
  }(ParseTree);
  var NAMED_EXPORT = ParseTreeType.NAMED_EXPORT;
  var NamedExport = function($__super) {
    function NamedExport(location, exportClause, moduleSpecifier) {
      $traceurRuntime.superConstructor(NamedExport).call(this, location);
      this.exportClause = exportClause;
      this.moduleSpecifier = moduleSpecifier;
    }
    return ($traceurRuntime.createClass)(NamedExport, {
      transform: function(transformer) {
        return transformer.transformNamedExport(this);
      },
      visit: function(visitor) {
        visitor.visitNamedExport(this);
      },
      get type() {
        return NAMED_EXPORT;
      }
    }, {}, $__super);
  }(ParseTree);
  var NEW_EXPRESSION = ParseTreeType.NEW_EXPRESSION;
  var NewExpression = function($__super) {
    function NewExpression(location, operand, args) {
      $traceurRuntime.superConstructor(NewExpression).call(this, location);
      this.operand = operand;
      this.args = args;
    }
    return ($traceurRuntime.createClass)(NewExpression, {
      transform: function(transformer) {
        return transformer.transformNewExpression(this);
      },
      visit: function(visitor) {
        visitor.visitNewExpression(this);
      },
      get type() {
        return NEW_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var OBJECT_LITERAL = ParseTreeType.OBJECT_LITERAL;
  var ObjectLiteral = function($__super) {
    function ObjectLiteral(location, propertyNameAndValues) {
      $traceurRuntime.superConstructor(ObjectLiteral).call(this, location);
      this.propertyNameAndValues = propertyNameAndValues;
    }
    return ($traceurRuntime.createClass)(ObjectLiteral, {
      transform: function(transformer) {
        return transformer.transformObjectLiteral(this);
      },
      visit: function(visitor) {
        visitor.visitObjectLiteral(this);
      },
      get type() {
        return OBJECT_LITERAL;
      }
    }, {}, $__super);
  }(ParseTree);
  var OBJECT_PATTERN = ParseTreeType.OBJECT_PATTERN;
  var ObjectPattern = function($__super) {
    function ObjectPattern(location, fields) {
      $traceurRuntime.superConstructor(ObjectPattern).call(this, location);
      this.fields = fields;
    }
    return ($traceurRuntime.createClass)(ObjectPattern, {
      transform: function(transformer) {
        return transformer.transformObjectPattern(this);
      },
      visit: function(visitor) {
        visitor.visitObjectPattern(this);
      },
      get type() {
        return OBJECT_PATTERN;
      }
    }, {}, $__super);
  }(ParseTree);
  var OBJECT_PATTERN_FIELD = ParseTreeType.OBJECT_PATTERN_FIELD;
  var ObjectPatternField = function($__super) {
    function ObjectPatternField(location, name, element) {
      $traceurRuntime.superConstructor(ObjectPatternField).call(this, location);
      this.name = name;
      this.element = element;
    }
    return ($traceurRuntime.createClass)(ObjectPatternField, {
      transform: function(transformer) {
        return transformer.transformObjectPatternField(this);
      },
      visit: function(visitor) {
        visitor.visitObjectPatternField(this);
      },
      get type() {
        return OBJECT_PATTERN_FIELD;
      }
    }, {}, $__super);
  }(ParseTree);
  var OBJECT_TYPE = ParseTreeType.OBJECT_TYPE;
  var ObjectType = function($__super) {
    function ObjectType(location, typeMembers) {
      $traceurRuntime.superConstructor(ObjectType).call(this, location);
      this.typeMembers = typeMembers;
    }
    return ($traceurRuntime.createClass)(ObjectType, {
      transform: function(transformer) {
        return transformer.transformObjectType(this);
      },
      visit: function(visitor) {
        visitor.visitObjectType(this);
      },
      get type() {
        return OBJECT_TYPE;
      }
    }, {}, $__super);
  }(ParseTree);
  var PAREN_EXPRESSION = ParseTreeType.PAREN_EXPRESSION;
  var ParenExpression = function($__super) {
    function ParenExpression(location, expression) {
      $traceurRuntime.superConstructor(ParenExpression).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(ParenExpression, {
      transform: function(transformer) {
        return transformer.transformParenExpression(this);
      },
      visit: function(visitor) {
        visitor.visitParenExpression(this);
      },
      get type() {
        return PAREN_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var POSTFIX_EXPRESSION = ParseTreeType.POSTFIX_EXPRESSION;
  var PostfixExpression = function($__super) {
    function PostfixExpression(location, operand, operator) {
      $traceurRuntime.superConstructor(PostfixExpression).call(this, location);
      this.operand = operand;
      this.operator = operator;
    }
    return ($traceurRuntime.createClass)(PostfixExpression, {
      transform: function(transformer) {
        return transformer.transformPostfixExpression(this);
      },
      visit: function(visitor) {
        visitor.visitPostfixExpression(this);
      },
      get type() {
        return POSTFIX_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var PREDEFINED_TYPE = ParseTreeType.PREDEFINED_TYPE;
  var PredefinedType = function($__super) {
    function PredefinedType(location, typeToken) {
      $traceurRuntime.superConstructor(PredefinedType).call(this, location);
      this.typeToken = typeToken;
    }
    return ($traceurRuntime.createClass)(PredefinedType, {
      transform: function(transformer) {
        return transformer.transformPredefinedType(this);
      },
      visit: function(visitor) {
        visitor.visitPredefinedType(this);
      },
      get type() {
        return PREDEFINED_TYPE;
      }
    }, {}, $__super);
  }(ParseTree);
  var SCRIPT = ParseTreeType.SCRIPT;
  var Script = function($__super) {
    function Script(location, scriptItemList, moduleName) {
      $traceurRuntime.superConstructor(Script).call(this, location);
      this.scriptItemList = scriptItemList;
      this.moduleName = moduleName;
    }
    return ($traceurRuntime.createClass)(Script, {
      transform: function(transformer) {
        return transformer.transformScript(this);
      },
      visit: function(visitor) {
        visitor.visitScript(this);
      },
      get type() {
        return SCRIPT;
      }
    }, {}, $__super);
  }(ParseTree);
  var PROPERTY_NAME_ASSIGNMENT = ParseTreeType.PROPERTY_NAME_ASSIGNMENT;
  var PropertyNameAssignment = function($__super) {
    function PropertyNameAssignment(location, name, value) {
      $traceurRuntime.superConstructor(PropertyNameAssignment).call(this, location);
      this.name = name;
      this.value = value;
    }
    return ($traceurRuntime.createClass)(PropertyNameAssignment, {
      transform: function(transformer) {
        return transformer.transformPropertyNameAssignment(this);
      },
      visit: function(visitor) {
        visitor.visitPropertyNameAssignment(this);
      },
      get type() {
        return PROPERTY_NAME_ASSIGNMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var PROPERTY_NAME_SHORTHAND = ParseTreeType.PROPERTY_NAME_SHORTHAND;
  var PropertyNameShorthand = function($__super) {
    function PropertyNameShorthand(location, name) {
      $traceurRuntime.superConstructor(PropertyNameShorthand).call(this, location);
      this.name = name;
    }
    return ($traceurRuntime.createClass)(PropertyNameShorthand, {
      transform: function(transformer) {
        return transformer.transformPropertyNameShorthand(this);
      },
      visit: function(visitor) {
        visitor.visitPropertyNameShorthand(this);
      },
      get type() {
        return PROPERTY_NAME_SHORTHAND;
      }
    }, {}, $__super);
  }(ParseTree);
  var PROPERTY_VARIABLE_DECLARATION = ParseTreeType.PROPERTY_VARIABLE_DECLARATION;
  var PropertyVariableDeclaration = function($__super) {
    function PropertyVariableDeclaration(location, isStatic, name, typeAnnotation, annotations, initializer) {
      $traceurRuntime.superConstructor(PropertyVariableDeclaration).call(this, location);
      this.isStatic = isStatic;
      this.name = name;
      this.typeAnnotation = typeAnnotation;
      this.annotations = annotations;
      this.initializer = initializer;
    }
    return ($traceurRuntime.createClass)(PropertyVariableDeclaration, {
      transform: function(transformer) {
        return transformer.transformPropertyVariableDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitPropertyVariableDeclaration(this);
      },
      get type() {
        return PROPERTY_VARIABLE_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var PROPERTY_SIGNATURE = ParseTreeType.PROPERTY_SIGNATURE;
  var PropertySignature = function($__super) {
    function PropertySignature(location, name, optional, typeAnnotation) {
      $traceurRuntime.superConstructor(PropertySignature).call(this, location);
      this.name = name;
      this.optional = optional;
      this.typeAnnotation = typeAnnotation;
    }
    return ($traceurRuntime.createClass)(PropertySignature, {
      transform: function(transformer) {
        return transformer.transformPropertySignature(this);
      },
      visit: function(visitor) {
        visitor.visitPropertySignature(this);
      },
      get type() {
        return PROPERTY_SIGNATURE;
      }
    }, {}, $__super);
  }(ParseTree);
  var REST_PARAMETER = ParseTreeType.REST_PARAMETER;
  var RestParameter = function($__super) {
    function RestParameter(location, identifier) {
      $traceurRuntime.superConstructor(RestParameter).call(this, location);
      this.identifier = identifier;
    }
    return ($traceurRuntime.createClass)(RestParameter, {
      transform: function(transformer) {
        return transformer.transformRestParameter(this);
      },
      visit: function(visitor) {
        visitor.visitRestParameter(this);
      },
      get type() {
        return REST_PARAMETER;
      }
    }, {}, $__super);
  }(ParseTree);
  var RETURN_STATEMENT = ParseTreeType.RETURN_STATEMENT;
  var ReturnStatement = function($__super) {
    function ReturnStatement(location, expression) {
      $traceurRuntime.superConstructor(ReturnStatement).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(ReturnStatement, {
      transform: function(transformer) {
        return transformer.transformReturnStatement(this);
      },
      visit: function(visitor) {
        visitor.visitReturnStatement(this);
      },
      get type() {
        return RETURN_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var SET_ACCESSOR = ParseTreeType.SET_ACCESSOR;
  var SetAccessor = function($__super) {
    function SetAccessor(location, isStatic, name, parameterList, annotations, body) {
      $traceurRuntime.superConstructor(SetAccessor).call(this, location);
      this.isStatic = isStatic;
      this.name = name;
      this.parameterList = parameterList;
      this.annotations = annotations;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(SetAccessor, {
      transform: function(transformer) {
        return transformer.transformSetAccessor(this);
      },
      visit: function(visitor) {
        visitor.visitSetAccessor(this);
      },
      get type() {
        return SET_ACCESSOR;
      }
    }, {}, $__super);
  }(ParseTree);
  var SPREAD_EXPRESSION = ParseTreeType.SPREAD_EXPRESSION;
  var SpreadExpression = function($__super) {
    function SpreadExpression(location, expression) {
      $traceurRuntime.superConstructor(SpreadExpression).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(SpreadExpression, {
      transform: function(transformer) {
        return transformer.transformSpreadExpression(this);
      },
      visit: function(visitor) {
        visitor.visitSpreadExpression(this);
      },
      get type() {
        return SPREAD_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var SPREAD_PATTERN_ELEMENT = ParseTreeType.SPREAD_PATTERN_ELEMENT;
  var SpreadPatternElement = function($__super) {
    function SpreadPatternElement(location, lvalue) {
      $traceurRuntime.superConstructor(SpreadPatternElement).call(this, location);
      this.lvalue = lvalue;
    }
    return ($traceurRuntime.createClass)(SpreadPatternElement, {
      transform: function(transformer) {
        return transformer.transformSpreadPatternElement(this);
      },
      visit: function(visitor) {
        visitor.visitSpreadPatternElement(this);
      },
      get type() {
        return SPREAD_PATTERN_ELEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var SUPER_EXPRESSION = ParseTreeType.SUPER_EXPRESSION;
  var SuperExpression = function($__super) {
    function SuperExpression(location) {
      $traceurRuntime.superConstructor(SuperExpression).call(this, location);
    }
    return ($traceurRuntime.createClass)(SuperExpression, {
      transform: function(transformer) {
        return transformer.transformSuperExpression(this);
      },
      visit: function(visitor) {
        visitor.visitSuperExpression(this);
      },
      get type() {
        return SUPER_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var SWITCH_STATEMENT = ParseTreeType.SWITCH_STATEMENT;
  var SwitchStatement = function($__super) {
    function SwitchStatement(location, expression, caseClauses) {
      $traceurRuntime.superConstructor(SwitchStatement).call(this, location);
      this.expression = expression;
      this.caseClauses = caseClauses;
    }
    return ($traceurRuntime.createClass)(SwitchStatement, {
      transform: function(transformer) {
        return transformer.transformSwitchStatement(this);
      },
      visit: function(visitor) {
        visitor.visitSwitchStatement(this);
      },
      get type() {
        return SWITCH_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var SYNTAX_ERROR_TREE = ParseTreeType.SYNTAX_ERROR_TREE;
  var SyntaxErrorTree = function($__super) {
    function SyntaxErrorTree(location, nextToken, message) {
      $traceurRuntime.superConstructor(SyntaxErrorTree).call(this, location);
      this.nextToken = nextToken;
      this.message = message;
    }
    return ($traceurRuntime.createClass)(SyntaxErrorTree, {
      transform: function(transformer) {
        return transformer.transformSyntaxErrorTree(this);
      },
      visit: function(visitor) {
        visitor.visitSyntaxErrorTree(this);
      },
      get type() {
        return SYNTAX_ERROR_TREE;
      }
    }, {}, $__super);
  }(ParseTree);
  var TEMPLATE_LITERAL_EXPRESSION = ParseTreeType.TEMPLATE_LITERAL_EXPRESSION;
  var TemplateLiteralExpression = function($__super) {
    function TemplateLiteralExpression(location, operand, elements) {
      $traceurRuntime.superConstructor(TemplateLiteralExpression).call(this, location);
      this.operand = operand;
      this.elements = elements;
    }
    return ($traceurRuntime.createClass)(TemplateLiteralExpression, {
      transform: function(transformer) {
        return transformer.transformTemplateLiteralExpression(this);
      },
      visit: function(visitor) {
        visitor.visitTemplateLiteralExpression(this);
      },
      get type() {
        return TEMPLATE_LITERAL_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var TEMPLATE_LITERAL_PORTION = ParseTreeType.TEMPLATE_LITERAL_PORTION;
  var TemplateLiteralPortion = function($__super) {
    function TemplateLiteralPortion(location, value) {
      $traceurRuntime.superConstructor(TemplateLiteralPortion).call(this, location);
      this.value = value;
    }
    return ($traceurRuntime.createClass)(TemplateLiteralPortion, {
      transform: function(transformer) {
        return transformer.transformTemplateLiteralPortion(this);
      },
      visit: function(visitor) {
        visitor.visitTemplateLiteralPortion(this);
      },
      get type() {
        return TEMPLATE_LITERAL_PORTION;
      }
    }, {}, $__super);
  }(ParseTree);
  var TEMPLATE_SUBSTITUTION = ParseTreeType.TEMPLATE_SUBSTITUTION;
  var TemplateSubstitution = function($__super) {
    function TemplateSubstitution(location, expression) {
      $traceurRuntime.superConstructor(TemplateSubstitution).call(this, location);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(TemplateSubstitution, {
      transform: function(transformer) {
        return transformer.transformTemplateSubstitution(this);
      },
      visit: function(visitor) {
        visitor.visitTemplateSubstitution(this);
      },
      get type() {
        return TEMPLATE_SUBSTITUTION;
      }
    }, {}, $__super);
  }(ParseTree);
  var THIS_EXPRESSION = ParseTreeType.THIS_EXPRESSION;
  var ThisExpression = function($__super) {
    function ThisExpression(location) {
      $traceurRuntime.superConstructor(ThisExpression).call(this, location);
    }
    return ($traceurRuntime.createClass)(ThisExpression, {
      transform: function(transformer) {
        return transformer.transformThisExpression(this);
      },
      visit: function(visitor) {
        visitor.visitThisExpression(this);
      },
      get type() {
        return THIS_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var THROW_STATEMENT = ParseTreeType.THROW_STATEMENT;
  var ThrowStatement = function($__super) {
    function ThrowStatement(location, value) {
      $traceurRuntime.superConstructor(ThrowStatement).call(this, location);
      this.value = value;
    }
    return ($traceurRuntime.createClass)(ThrowStatement, {
      transform: function(transformer) {
        return transformer.transformThrowStatement(this);
      },
      visit: function(visitor) {
        visitor.visitThrowStatement(this);
      },
      get type() {
        return THROW_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var TRY_STATEMENT = ParseTreeType.TRY_STATEMENT;
  var TryStatement = function($__super) {
    function TryStatement(location, body, catchBlock, finallyBlock) {
      $traceurRuntime.superConstructor(TryStatement).call(this, location);
      this.body = body;
      this.catchBlock = catchBlock;
      this.finallyBlock = finallyBlock;
    }
    return ($traceurRuntime.createClass)(TryStatement, {
      transform: function(transformer) {
        return transformer.transformTryStatement(this);
      },
      visit: function(visitor) {
        visitor.visitTryStatement(this);
      },
      get type() {
        return TRY_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var TYPE_ALIAS_DECLARATION = ParseTreeType.TYPE_ALIAS_DECLARATION;
  var TypeAliasDeclaration = function($__super) {
    function TypeAliasDeclaration(location, name, value) {
      $traceurRuntime.superConstructor(TypeAliasDeclaration).call(this, location);
      this.name = name;
      this.value = value;
    }
    return ($traceurRuntime.createClass)(TypeAliasDeclaration, {
      transform: function(transformer) {
        return transformer.transformTypeAliasDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitTypeAliasDeclaration(this);
      },
      get type() {
        return TYPE_ALIAS_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var TYPE_ARGUMENTS = ParseTreeType.TYPE_ARGUMENTS;
  var TypeArguments = function($__super) {
    function TypeArguments(location, args) {
      $traceurRuntime.superConstructor(TypeArguments).call(this, location);
      this.args = args;
    }
    return ($traceurRuntime.createClass)(TypeArguments, {
      transform: function(transformer) {
        return transformer.transformTypeArguments(this);
      },
      visit: function(visitor) {
        visitor.visitTypeArguments(this);
      },
      get type() {
        return TYPE_ARGUMENTS;
      }
    }, {}, $__super);
  }(ParseTree);
  var TYPE_NAME = ParseTreeType.TYPE_NAME;
  var TypeName = function($__super) {
    function TypeName(location, moduleName, name) {
      $traceurRuntime.superConstructor(TypeName).call(this, location);
      this.moduleName = moduleName;
      this.name = name;
    }
    return ($traceurRuntime.createClass)(TypeName, {
      transform: function(transformer) {
        return transformer.transformTypeName(this);
      },
      visit: function(visitor) {
        visitor.visitTypeName(this);
      },
      get type() {
        return TYPE_NAME;
      }
    }, {}, $__super);
  }(ParseTree);
  var TYPE_PARAMETER = ParseTreeType.TYPE_PARAMETER;
  var TypeParameter = function($__super) {
    function TypeParameter(location, identifierToken, extendsType) {
      $traceurRuntime.superConstructor(TypeParameter).call(this, location);
      this.identifierToken = identifierToken;
      this.extendsType = extendsType;
    }
    return ($traceurRuntime.createClass)(TypeParameter, {
      transform: function(transformer) {
        return transformer.transformTypeParameter(this);
      },
      visit: function(visitor) {
        visitor.visitTypeParameter(this);
      },
      get type() {
        return TYPE_PARAMETER;
      }
    }, {}, $__super);
  }(ParseTree);
  var TYPE_PARAMETERS = ParseTreeType.TYPE_PARAMETERS;
  var TypeParameters = function($__super) {
    function TypeParameters(location, parameters) {
      $traceurRuntime.superConstructor(TypeParameters).call(this, location);
      this.parameters = parameters;
    }
    return ($traceurRuntime.createClass)(TypeParameters, {
      transform: function(transformer) {
        return transformer.transformTypeParameters(this);
      },
      visit: function(visitor) {
        visitor.visitTypeParameters(this);
      },
      get type() {
        return TYPE_PARAMETERS;
      }
    }, {}, $__super);
  }(ParseTree);
  var TYPE_REFERENCE = ParseTreeType.TYPE_REFERENCE;
  var TypeReference = function($__super) {
    function TypeReference(location, typeName, args) {
      $traceurRuntime.superConstructor(TypeReference).call(this, location);
      this.typeName = typeName;
      this.args = args;
    }
    return ($traceurRuntime.createClass)(TypeReference, {
      transform: function(transformer) {
        return transformer.transformTypeReference(this);
      },
      visit: function(visitor) {
        visitor.visitTypeReference(this);
      },
      get type() {
        return TYPE_REFERENCE;
      }
    }, {}, $__super);
  }(ParseTree);
  var UNARY_EXPRESSION = ParseTreeType.UNARY_EXPRESSION;
  var UnaryExpression = function($__super) {
    function UnaryExpression(location, operator, operand) {
      $traceurRuntime.superConstructor(UnaryExpression).call(this, location);
      this.operator = operator;
      this.operand = operand;
    }
    return ($traceurRuntime.createClass)(UnaryExpression, {
      transform: function(transformer) {
        return transformer.transformUnaryExpression(this);
      },
      visit: function(visitor) {
        visitor.visitUnaryExpression(this);
      },
      get type() {
        return UNARY_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  var UNION_TYPE = ParseTreeType.UNION_TYPE;
  var UnionType = function($__super) {
    function UnionType(location, types) {
      $traceurRuntime.superConstructor(UnionType).call(this, location);
      this.types = types;
    }
    return ($traceurRuntime.createClass)(UnionType, {
      transform: function(transformer) {
        return transformer.transformUnionType(this);
      },
      visit: function(visitor) {
        visitor.visitUnionType(this);
      },
      get type() {
        return UNION_TYPE;
      }
    }, {}, $__super);
  }(ParseTree);
  var VARIABLE_DECLARATION = ParseTreeType.VARIABLE_DECLARATION;
  var VariableDeclaration = function($__super) {
    function VariableDeclaration(location, lvalue, typeAnnotation, initializer) {
      $traceurRuntime.superConstructor(VariableDeclaration).call(this, location);
      this.lvalue = lvalue;
      this.typeAnnotation = typeAnnotation;
      this.initializer = initializer;
    }
    return ($traceurRuntime.createClass)(VariableDeclaration, {
      transform: function(transformer) {
        return transformer.transformVariableDeclaration(this);
      },
      visit: function(visitor) {
        visitor.visitVariableDeclaration(this);
      },
      get type() {
        return VARIABLE_DECLARATION;
      }
    }, {}, $__super);
  }(ParseTree);
  var VARIABLE_DECLARATION_LIST = ParseTreeType.VARIABLE_DECLARATION_LIST;
  var VariableDeclarationList = function($__super) {
    function VariableDeclarationList(location, declarationType, declarations) {
      $traceurRuntime.superConstructor(VariableDeclarationList).call(this, location);
      this.declarationType = declarationType;
      this.declarations = declarations;
    }
    return ($traceurRuntime.createClass)(VariableDeclarationList, {
      transform: function(transformer) {
        return transformer.transformVariableDeclarationList(this);
      },
      visit: function(visitor) {
        visitor.visitVariableDeclarationList(this);
      },
      get type() {
        return VARIABLE_DECLARATION_LIST;
      }
    }, {}, $__super);
  }(ParseTree);
  var VARIABLE_STATEMENT = ParseTreeType.VARIABLE_STATEMENT;
  var VariableStatement = function($__super) {
    function VariableStatement(location, declarations) {
      $traceurRuntime.superConstructor(VariableStatement).call(this, location);
      this.declarations = declarations;
    }
    return ($traceurRuntime.createClass)(VariableStatement, {
      transform: function(transformer) {
        return transformer.transformVariableStatement(this);
      },
      visit: function(visitor) {
        visitor.visitVariableStatement(this);
      },
      get type() {
        return VARIABLE_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var WHILE_STATEMENT = ParseTreeType.WHILE_STATEMENT;
  var WhileStatement = function($__super) {
    function WhileStatement(location, condition, body) {
      $traceurRuntime.superConstructor(WhileStatement).call(this, location);
      this.condition = condition;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(WhileStatement, {
      transform: function(transformer) {
        return transformer.transformWhileStatement(this);
      },
      visit: function(visitor) {
        visitor.visitWhileStatement(this);
      },
      get type() {
        return WHILE_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var WITH_STATEMENT = ParseTreeType.WITH_STATEMENT;
  var WithStatement = function($__super) {
    function WithStatement(location, expression, body) {
      $traceurRuntime.superConstructor(WithStatement).call(this, location);
      this.expression = expression;
      this.body = body;
    }
    return ($traceurRuntime.createClass)(WithStatement, {
      transform: function(transformer) {
        return transformer.transformWithStatement(this);
      },
      visit: function(visitor) {
        visitor.visitWithStatement(this);
      },
      get type() {
        return WITH_STATEMENT;
      }
    }, {}, $__super);
  }(ParseTree);
  var YIELD_EXPRESSION = ParseTreeType.YIELD_EXPRESSION;
  var YieldExpression = function($__super) {
    function YieldExpression(location, expression, isYieldFor) {
      $traceurRuntime.superConstructor(YieldExpression).call(this, location);
      this.expression = expression;
      this.isYieldFor = isYieldFor;
    }
    return ($traceurRuntime.createClass)(YieldExpression, {
      transform: function(transformer) {
        return transformer.transformYieldExpression(this);
      },
      visit: function(visitor) {
        visitor.visitYieldExpression(this);
      },
      get type() {
        return YIELD_EXPRESSION;
      }
    }, {}, $__super);
  }(ParseTree);
  return {
    get Annotation() {
      return Annotation;
    },
    get AnonBlock() {
      return AnonBlock;
    },
    get ArgumentList() {
      return ArgumentList;
    },
    get ArrayComprehension() {
      return ArrayComprehension;
    },
    get ArrayLiteral() {
      return ArrayLiteral;
    },
    get ArrayPattern() {
      return ArrayPattern;
    },
    get ArrayType() {
      return ArrayType;
    },
    get ArrowFunction() {
      return ArrowFunction;
    },
    get AssignmentElement() {
      return AssignmentElement;
    },
    get AwaitExpression() {
      return AwaitExpression;
    },
    get BinaryExpression() {
      return BinaryExpression;
    },
    get BindingElement() {
      return BindingElement;
    },
    get BindingIdentifier() {
      return BindingIdentifier;
    },
    get Block() {
      return Block;
    },
    get BreakStatement() {
      return BreakStatement;
    },
    get CallExpression() {
      return CallExpression;
    },
    get CallSignature() {
      return CallSignature;
    },
    get CaseClause() {
      return CaseClause;
    },
    get Catch() {
      return Catch;
    },
    get ClassDeclaration() {
      return ClassDeclaration;
    },
    get ClassExpression() {
      return ClassExpression;
    },
    get CommaExpression() {
      return CommaExpression;
    },
    get ComprehensionFor() {
      return ComprehensionFor;
    },
    get ComprehensionIf() {
      return ComprehensionIf;
    },
    get ComputedPropertyName() {
      return ComputedPropertyName;
    },
    get ConditionalExpression() {
      return ConditionalExpression;
    },
    get ConstructSignature() {
      return ConstructSignature;
    },
    get ConstructorType() {
      return ConstructorType;
    },
    get ContinueStatement() {
      return ContinueStatement;
    },
    get CoverFormals() {
      return CoverFormals;
    },
    get CoverInitializedName() {
      return CoverInitializedName;
    },
    get DebuggerStatement() {
      return DebuggerStatement;
    },
    get DefaultClause() {
      return DefaultClause;
    },
    get DoWhileStatement() {
      return DoWhileStatement;
    },
    get EmptyStatement() {
      return EmptyStatement;
    },
    get ExportDeclaration() {
      return ExportDeclaration;
    },
    get ExportDefault() {
      return ExportDefault;
    },
    get ExportSpecifier() {
      return ExportSpecifier;
    },
    get ExportSpecifierSet() {
      return ExportSpecifierSet;
    },
    get ExportStar() {
      return ExportStar;
    },
    get ExpressionStatement() {
      return ExpressionStatement;
    },
    get Finally() {
      return Finally;
    },
    get ForInStatement() {
      return ForInStatement;
    },
    get ForOfStatement() {
      return ForOfStatement;
    },
    get ForOnStatement() {
      return ForOnStatement;
    },
    get ForStatement() {
      return ForStatement;
    },
    get FormalParameter() {
      return FormalParameter;
    },
    get FormalParameterList() {
      return FormalParameterList;
    },
    get ForwardDefaultExport() {
      return ForwardDefaultExport;
    },
    get FunctionBody() {
      return FunctionBody;
    },
    get FunctionDeclaration() {
      return FunctionDeclaration;
    },
    get FunctionExpression() {
      return FunctionExpression;
    },
    get FunctionType() {
      return FunctionType;
    },
    get GeneratorComprehension() {
      return GeneratorComprehension;
    },
    get GetAccessor() {
      return GetAccessor;
    },
    get IdentifierExpression() {
      return IdentifierExpression;
    },
    get IfStatement() {
      return IfStatement;
    },
    get ImportedBinding() {
      return ImportedBinding;
    },
    get ImportClausePair() {
      return ImportClausePair;
    },
    get ImportDeclaration() {
      return ImportDeclaration;
    },
    get ImportSpecifier() {
      return ImportSpecifier;
    },
    get ImportSpecifierSet() {
      return ImportSpecifierSet;
    },
    get ImportTypeClause() {
      return ImportTypeClause;
    },
    get IndexSignature() {
      return IndexSignature;
    },
    get InterfaceDeclaration() {
      return InterfaceDeclaration;
    },
    get JsxAttribute() {
      return JsxAttribute;
    },
    get JsxElement() {
      return JsxElement;
    },
    get JsxElementName() {
      return JsxElementName;
    },
    get JsxPlaceholder() {
      return JsxPlaceholder;
    },
    get JsxSpreadAttribute() {
      return JsxSpreadAttribute;
    },
    get JsxText() {
      return JsxText;
    },
    get LabelledStatement() {
      return LabelledStatement;
    },
    get LiteralExpression() {
      return LiteralExpression;
    },
    get LiteralPropertyName() {
      return LiteralPropertyName;
    },
    get MemberExpression() {
      return MemberExpression;
    },
    get MemberLookupExpression() {
      return MemberLookupExpression;
    },
    get Method() {
      return Method;
    },
    get MethodSignature() {
      return MethodSignature;
    },
    get Module() {
      return Module;
    },
    get ModuleSpecifier() {
      return ModuleSpecifier;
    },
    get NameSpaceExport() {
      return NameSpaceExport;
    },
    get NameSpaceImport() {
      return NameSpaceImport;
    },
    get NamedExport() {
      return NamedExport;
    },
    get NewExpression() {
      return NewExpression;
    },
    get ObjectLiteral() {
      return ObjectLiteral;
    },
    get ObjectPattern() {
      return ObjectPattern;
    },
    get ObjectPatternField() {
      return ObjectPatternField;
    },
    get ObjectType() {
      return ObjectType;
    },
    get ParenExpression() {
      return ParenExpression;
    },
    get PostfixExpression() {
      return PostfixExpression;
    },
    get PredefinedType() {
      return PredefinedType;
    },
    get Script() {
      return Script;
    },
    get PropertyNameAssignment() {
      return PropertyNameAssignment;
    },
    get PropertyNameShorthand() {
      return PropertyNameShorthand;
    },
    get PropertyVariableDeclaration() {
      return PropertyVariableDeclaration;
    },
    get PropertySignature() {
      return PropertySignature;
    },
    get RestParameter() {
      return RestParameter;
    },
    get ReturnStatement() {
      return ReturnStatement;
    },
    get SetAccessor() {
      return SetAccessor;
    },
    get SpreadExpression() {
      return SpreadExpression;
    },
    get SpreadPatternElement() {
      return SpreadPatternElement;
    },
    get SuperExpression() {
      return SuperExpression;
    },
    get SwitchStatement() {
      return SwitchStatement;
    },
    get SyntaxErrorTree() {
      return SyntaxErrorTree;
    },
    get TemplateLiteralExpression() {
      return TemplateLiteralExpression;
    },
    get TemplateLiteralPortion() {
      return TemplateLiteralPortion;
    },
    get TemplateSubstitution() {
      return TemplateSubstitution;
    },
    get ThisExpression() {
      return ThisExpression;
    },
    get ThrowStatement() {
      return ThrowStatement;
    },
    get TryStatement() {
      return TryStatement;
    },
    get TypeAliasDeclaration() {
      return TypeAliasDeclaration;
    },
    get TypeArguments() {
      return TypeArguments;
    },
    get TypeName() {
      return TypeName;
    },
    get TypeParameter() {
      return TypeParameter;
    },
    get TypeParameters() {
      return TypeParameters;
    },
    get TypeReference() {
      return TypeReference;
    },
    get UnaryExpression() {
      return UnaryExpression;
    },
    get UnionType() {
      return UnionType;
    },
    get VariableDeclaration() {
      return VariableDeclaration;
    },
    get VariableDeclarationList() {
      return VariableDeclarationList;
    },
    get VariableStatement() {
      return VariableStatement;
    },
    get WhileStatement() {
      return WhileStatement;
    },
    get WithStatement() {
      return WithStatement;
    },
    get YieldExpression() {
      return YieldExpression;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ParseTreeTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ParseTreeTransformer.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ParseTreeTransformer.js")),
      Annotation = $__2.Annotation,
      AnonBlock = $__2.AnonBlock,
      ArgumentList = $__2.ArgumentList,
      ArrayComprehension = $__2.ArrayComprehension,
      ArrayLiteral = $__2.ArrayLiteral,
      ArrayPattern = $__2.ArrayPattern,
      ArrayType = $__2.ArrayType,
      ArrowFunction = $__2.ArrowFunction,
      AssignmentElement = $__2.AssignmentElement,
      AwaitExpression = $__2.AwaitExpression,
      BinaryExpression = $__2.BinaryExpression,
      BindingElement = $__2.BindingElement,
      BindingIdentifier = $__2.BindingIdentifier,
      Block = $__2.Block,
      BreakStatement = $__2.BreakStatement,
      CallExpression = $__2.CallExpression,
      CallSignature = $__2.CallSignature,
      CaseClause = $__2.CaseClause,
      Catch = $__2.Catch,
      ClassDeclaration = $__2.ClassDeclaration,
      ClassExpression = $__2.ClassExpression,
      CommaExpression = $__2.CommaExpression,
      ComprehensionFor = $__2.ComprehensionFor,
      ComprehensionIf = $__2.ComprehensionIf,
      ComputedPropertyName = $__2.ComputedPropertyName,
      ConditionalExpression = $__2.ConditionalExpression,
      ConstructSignature = $__2.ConstructSignature,
      ConstructorType = $__2.ConstructorType,
      ContinueStatement = $__2.ContinueStatement,
      CoverFormals = $__2.CoverFormals,
      CoverInitializedName = $__2.CoverInitializedName,
      DebuggerStatement = $__2.DebuggerStatement,
      DefaultClause = $__2.DefaultClause,
      DoWhileStatement = $__2.DoWhileStatement,
      EmptyStatement = $__2.EmptyStatement,
      ExportDeclaration = $__2.ExportDeclaration,
      ExportDefault = $__2.ExportDefault,
      ExportSpecifier = $__2.ExportSpecifier,
      ExportSpecifierSet = $__2.ExportSpecifierSet,
      ExportStar = $__2.ExportStar,
      ExpressionStatement = $__2.ExpressionStatement,
      Finally = $__2.Finally,
      ForInStatement = $__2.ForInStatement,
      ForOfStatement = $__2.ForOfStatement,
      ForOnStatement = $__2.ForOnStatement,
      ForStatement = $__2.ForStatement,
      FormalParameter = $__2.FormalParameter,
      FormalParameterList = $__2.FormalParameterList,
      ForwardDefaultExport = $__2.ForwardDefaultExport,
      FunctionBody = $__2.FunctionBody,
      FunctionDeclaration = $__2.FunctionDeclaration,
      FunctionExpression = $__2.FunctionExpression,
      FunctionType = $__2.FunctionType,
      GeneratorComprehension = $__2.GeneratorComprehension,
      GetAccessor = $__2.GetAccessor,
      IdentifierExpression = $__2.IdentifierExpression,
      IfStatement = $__2.IfStatement,
      ImportedBinding = $__2.ImportedBinding,
      ImportClausePair = $__2.ImportClausePair,
      ImportDeclaration = $__2.ImportDeclaration,
      ImportSpecifier = $__2.ImportSpecifier,
      ImportSpecifierSet = $__2.ImportSpecifierSet,
      ImportTypeClause = $__2.ImportTypeClause,
      IndexSignature = $__2.IndexSignature,
      InterfaceDeclaration = $__2.InterfaceDeclaration,
      JsxAttribute = $__2.JsxAttribute,
      JsxElement = $__2.JsxElement,
      JsxElementName = $__2.JsxElementName,
      JsxPlaceholder = $__2.JsxPlaceholder,
      JsxSpreadAttribute = $__2.JsxSpreadAttribute,
      JsxText = $__2.JsxText,
      LabelledStatement = $__2.LabelledStatement,
      LiteralExpression = $__2.LiteralExpression,
      LiteralPropertyName = $__2.LiteralPropertyName,
      MemberExpression = $__2.MemberExpression,
      MemberLookupExpression = $__2.MemberLookupExpression,
      Method = $__2.Method,
      MethodSignature = $__2.MethodSignature,
      Module = $__2.Module,
      ModuleSpecifier = $__2.ModuleSpecifier,
      NameSpaceExport = $__2.NameSpaceExport,
      NameSpaceImport = $__2.NameSpaceImport,
      NamedExport = $__2.NamedExport,
      NewExpression = $__2.NewExpression,
      ObjectLiteral = $__2.ObjectLiteral,
      ObjectPattern = $__2.ObjectPattern,
      ObjectPatternField = $__2.ObjectPatternField,
      ObjectType = $__2.ObjectType,
      ParenExpression = $__2.ParenExpression,
      PostfixExpression = $__2.PostfixExpression,
      PredefinedType = $__2.PredefinedType,
      Script = $__2.Script,
      PropertyNameAssignment = $__2.PropertyNameAssignment,
      PropertyNameShorthand = $__2.PropertyNameShorthand,
      PropertyVariableDeclaration = $__2.PropertyVariableDeclaration,
      PropertySignature = $__2.PropertySignature,
      RestParameter = $__2.RestParameter,
      ReturnStatement = $__2.ReturnStatement,
      SetAccessor = $__2.SetAccessor,
      SpreadExpression = $__2.SpreadExpression,
      SpreadPatternElement = $__2.SpreadPatternElement,
      SuperExpression = $__2.SuperExpression,
      SwitchStatement = $__2.SwitchStatement,
      SyntaxErrorTree = $__2.SyntaxErrorTree,
      TemplateLiteralExpression = $__2.TemplateLiteralExpression,
      TemplateLiteralPortion = $__2.TemplateLiteralPortion,
      TemplateSubstitution = $__2.TemplateSubstitution,
      ThisExpression = $__2.ThisExpression,
      ThrowStatement = $__2.ThrowStatement,
      TryStatement = $__2.TryStatement,
      TypeAliasDeclaration = $__2.TypeAliasDeclaration,
      TypeArguments = $__2.TypeArguments,
      TypeName = $__2.TypeName,
      TypeParameter = $__2.TypeParameter,
      TypeParameters = $__2.TypeParameters,
      TypeReference = $__2.TypeReference,
      UnaryExpression = $__2.UnaryExpression,
      UnionType = $__2.UnionType,
      VariableDeclaration = $__2.VariableDeclaration,
      VariableDeclarationList = $__2.VariableDeclarationList,
      VariableStatement = $__2.VariableStatement,
      WhileStatement = $__2.WhileStatement,
      WithStatement = $__2.WithStatement,
      YieldExpression = $__2.YieldExpression;
  var ParseTreeTransformer = function() {
    function ParseTreeTransformer() {}
    return ($traceurRuntime.createClass)(ParseTreeTransformer, {
      transformAny: function(tree) {
        return tree === null ? null : tree.transform(this);
      },
      transformList: function(list) {
        var $__1;
        var builder = null;
        for (var index = 0; index < list.length; index++) {
          var element = list[index];
          var transformed = this.transformAny(element);
          if (builder != null || element != transformed) {
            if (builder === null) {
              builder = list.slice(0, index);
            }
            if (transformed instanceof AnonBlock)
              ($__1 = builder).push.apply($__1, $traceurRuntime.spread(transformed.statements));
            else
              builder.push(transformed);
          }
        }
        return builder || list;
      },
      transformStateMachine: function(tree) {
        throw Error('State machines should not live outside of the GeneratorTransformer.');
      },
      transformToBlockOrStatement: function(tree) {
        var transformed = this.transformAny(tree);
        if (transformed instanceof AnonBlock) {
          return new Block(transformed.location, transformed.statements);
        }
        return transformed;
      },
      transformAnnotation: function(tree) {
        var name = this.transformAny(tree.name);
        var args = this.transformAny(tree.args);
        if (name === tree.name && args === tree.args) {
          return tree;
        }
        return new Annotation(tree.location, name, args);
      },
      transformAnonBlock: function(tree) {
        var statements = this.transformList(tree.statements);
        if (statements === tree.statements) {
          return tree;
        }
        return new AnonBlock(tree.location, statements);
      },
      transformArgumentList: function(tree) {
        var args = this.transformList(tree.args);
        if (args === tree.args) {
          return tree;
        }
        return new ArgumentList(tree.location, args);
      },
      transformArrayComprehension: function(tree) {
        var comprehensionList = this.transformList(tree.comprehensionList);
        var expression = this.transformAny(tree.expression);
        if (comprehensionList === tree.comprehensionList && expression === tree.expression) {
          return tree;
        }
        return new ArrayComprehension(tree.location, comprehensionList, expression);
      },
      transformArrayLiteral: function(tree) {
        var elements = this.transformList(tree.elements);
        if (elements === tree.elements) {
          return tree;
        }
        return new ArrayLiteral(tree.location, elements);
      },
      transformArrayPattern: function(tree) {
        var elements = this.transformList(tree.elements);
        if (elements === tree.elements) {
          return tree;
        }
        return new ArrayPattern(tree.location, elements);
      },
      transformArrayType: function(tree) {
        var elementType = this.transformAny(tree.elementType);
        if (elementType === tree.elementType) {
          return tree;
        }
        return new ArrayType(tree.location, elementType);
      },
      transformArrowFunction: function(tree) {
        var parameterList = this.transformAny(tree.parameterList);
        var body = this.transformAny(tree.body);
        if (parameterList === tree.parameterList && body === tree.body) {
          return tree;
        }
        return new ArrowFunction(tree.location, tree.functionKind, parameterList, body);
      },
      transformAssignmentElement: function(tree) {
        var assignment = this.transformAny(tree.assignment);
        var initializer = this.transformAny(tree.initializer);
        if (assignment === tree.assignment && initializer === tree.initializer) {
          return tree;
        }
        return new AssignmentElement(tree.location, assignment, initializer);
      },
      transformAwaitExpression: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new AwaitExpression(tree.location, expression);
      },
      transformBinaryExpression: function(tree) {
        var left = this.transformAny(tree.left);
        var right = this.transformAny(tree.right);
        if (left === tree.left && right === tree.right) {
          return tree;
        }
        return new BinaryExpression(tree.location, left, tree.operator, right);
      },
      transformBindingElement: function(tree) {
        var binding = this.transformAny(tree.binding);
        var initializer = this.transformAny(tree.initializer);
        if (binding === tree.binding && initializer === tree.initializer) {
          return tree;
        }
        return new BindingElement(tree.location, binding, initializer);
      },
      transformBindingIdentifier: function(tree) {
        return tree;
      },
      transformBlock: function(tree) {
        var statements = this.transformList(tree.statements);
        if (statements === tree.statements) {
          return tree;
        }
        return new Block(tree.location, statements);
      },
      transformBreakStatement: function(tree) {
        return tree;
      },
      transformCallExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        var args = this.transformAny(tree.args);
        if (operand === tree.operand && args === tree.args) {
          return tree;
        }
        return new CallExpression(tree.location, operand, args);
      },
      transformCallSignature: function(tree) {
        var typeParameters = this.transformAny(tree.typeParameters);
        var parameterList = this.transformAny(tree.parameterList);
        var returnType = this.transformAny(tree.returnType);
        if (typeParameters === tree.typeParameters && parameterList === tree.parameterList && returnType === tree.returnType) {
          return tree;
        }
        return new CallSignature(tree.location, typeParameters, parameterList, returnType);
      },
      transformCaseClause: function(tree) {
        var expression = this.transformAny(tree.expression);
        var statements = this.transformList(tree.statements);
        if (expression === tree.expression && statements === tree.statements) {
          return tree;
        }
        return new CaseClause(tree.location, expression, statements);
      },
      transformCatch: function(tree) {
        var binding = this.transformAny(tree.binding);
        var catchBody = this.transformAny(tree.catchBody);
        if (binding === tree.binding && catchBody === tree.catchBody) {
          return tree;
        }
        return new Catch(tree.location, binding, catchBody);
      },
      transformClassDeclaration: function(tree) {
        var name = this.transformAny(tree.name);
        var superClass = this.transformAny(tree.superClass);
        var elements = this.transformList(tree.elements);
        var annotations = this.transformList(tree.annotations);
        var typeParameters = this.transformAny(tree.typeParameters);
        if (name === tree.name && superClass === tree.superClass && elements === tree.elements && annotations === tree.annotations && typeParameters === tree.typeParameters) {
          return tree;
        }
        return new ClassDeclaration(tree.location, name, superClass, elements, annotations, typeParameters);
      },
      transformClassExpression: function(tree) {
        var name = this.transformAny(tree.name);
        var superClass = this.transformAny(tree.superClass);
        var elements = this.transformList(tree.elements);
        var annotations = this.transformList(tree.annotations);
        var typeParameters = this.transformAny(tree.typeParameters);
        if (name === tree.name && superClass === tree.superClass && elements === tree.elements && annotations === tree.annotations && typeParameters === tree.typeParameters) {
          return tree;
        }
        return new ClassExpression(tree.location, name, superClass, elements, annotations, typeParameters);
      },
      transformCommaExpression: function(tree) {
        var expressions = this.transformList(tree.expressions);
        if (expressions === tree.expressions) {
          return tree;
        }
        return new CommaExpression(tree.location, expressions);
      },
      transformComprehensionFor: function(tree) {
        var left = this.transformAny(tree.left);
        var iterator = this.transformAny(tree.iterator);
        if (left === tree.left && iterator === tree.iterator) {
          return tree;
        }
        return new ComprehensionFor(tree.location, left, iterator);
      },
      transformComprehensionIf: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new ComprehensionIf(tree.location, expression);
      },
      transformComputedPropertyName: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new ComputedPropertyName(tree.location, expression);
      },
      transformConditionalExpression: function(tree) {
        var condition = this.transformAny(tree.condition);
        var left = this.transformAny(tree.left);
        var right = this.transformAny(tree.right);
        if (condition === tree.condition && left === tree.left && right === tree.right) {
          return tree;
        }
        return new ConditionalExpression(tree.location, condition, left, right);
      },
      transformConstructSignature: function(tree) {
        var typeParameters = this.transformAny(tree.typeParameters);
        var parameterList = this.transformAny(tree.parameterList);
        var returnType = this.transformAny(tree.returnType);
        if (typeParameters === tree.typeParameters && parameterList === tree.parameterList && returnType === tree.returnType) {
          return tree;
        }
        return new ConstructSignature(tree.location, typeParameters, parameterList, returnType);
      },
      transformConstructorType: function(tree) {
        var typeParameters = this.transformAny(tree.typeParameters);
        var parameterList = this.transformAny(tree.parameterList);
        var returnType = this.transformAny(tree.returnType);
        if (typeParameters === tree.typeParameters && parameterList === tree.parameterList && returnType === tree.returnType) {
          return tree;
        }
        return new ConstructorType(tree.location, typeParameters, parameterList, returnType);
      },
      transformContinueStatement: function(tree) {
        return tree;
      },
      transformCoverFormals: function(tree) {
        var expressions = this.transformList(tree.expressions);
        if (expressions === tree.expressions) {
          return tree;
        }
        return new CoverFormals(tree.location, expressions);
      },
      transformCoverInitializedName: function(tree) {
        var initializer = this.transformAny(tree.initializer);
        if (initializer === tree.initializer) {
          return tree;
        }
        return new CoverInitializedName(tree.location, tree.name, tree.equalToken, initializer);
      },
      transformDebuggerStatement: function(tree) {
        return tree;
      },
      transformDefaultClause: function(tree) {
        var statements = this.transformList(tree.statements);
        if (statements === tree.statements) {
          return tree;
        }
        return new DefaultClause(tree.location, statements);
      },
      transformDoWhileStatement: function(tree) {
        var body = this.transformToBlockOrStatement(tree.body);
        var condition = this.transformAny(tree.condition);
        if (body === tree.body && condition === tree.condition) {
          return tree;
        }
        return new DoWhileStatement(tree.location, body, condition);
      },
      transformEmptyStatement: function(tree) {
        return tree;
      },
      transformExportDeclaration: function(tree) {
        var declaration = this.transformAny(tree.declaration);
        var annotations = this.transformList(tree.annotations);
        if (declaration === tree.declaration && annotations === tree.annotations) {
          return tree;
        }
        return new ExportDeclaration(tree.location, declaration, annotations);
      },
      transformExportDefault: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new ExportDefault(tree.location, expression);
      },
      transformExportSpecifier: function(tree) {
        return tree;
      },
      transformExportSpecifierSet: function(tree) {
        var specifiers = this.transformList(tree.specifiers);
        if (specifiers === tree.specifiers) {
          return tree;
        }
        return new ExportSpecifierSet(tree.location, specifiers);
      },
      transformExportStar: function(tree) {
        return tree;
      },
      transformExpressionStatement: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new ExpressionStatement(tree.location, expression);
      },
      transformFinally: function(tree) {
        var block = this.transformAny(tree.block);
        if (block === tree.block) {
          return tree;
        }
        return new Finally(tree.location, block);
      },
      transformForInStatement: function(tree) {
        var initializer = this.transformAny(tree.initializer);
        var collection = this.transformAny(tree.collection);
        var body = this.transformToBlockOrStatement(tree.body);
        if (initializer === tree.initializer && collection === tree.collection && body === tree.body) {
          return tree;
        }
        return new ForInStatement(tree.location, initializer, collection, body);
      },
      transformForOfStatement: function(tree) {
        var initializer = this.transformAny(tree.initializer);
        var collection = this.transformAny(tree.collection);
        var body = this.transformToBlockOrStatement(tree.body);
        if (initializer === tree.initializer && collection === tree.collection && body === tree.body) {
          return tree;
        }
        return new ForOfStatement(tree.location, initializer, collection, body);
      },
      transformForOnStatement: function(tree) {
        var initializer = this.transformAny(tree.initializer);
        var observable = this.transformAny(tree.observable);
        var body = this.transformToBlockOrStatement(tree.body);
        if (initializer === tree.initializer && observable === tree.observable && body === tree.body) {
          return tree;
        }
        return new ForOnStatement(tree.location, initializer, observable, body);
      },
      transformForStatement: function(tree) {
        var initializer = this.transformAny(tree.initializer);
        var condition = this.transformAny(tree.condition);
        var increment = this.transformAny(tree.increment);
        var body = this.transformToBlockOrStatement(tree.body);
        if (initializer === tree.initializer && condition === tree.condition && increment === tree.increment && body === tree.body) {
          return tree;
        }
        return new ForStatement(tree.location, initializer, condition, increment, body);
      },
      transformFormalParameter: function(tree) {
        var parameter = this.transformAny(tree.parameter);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        if (parameter === tree.parameter && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations) {
          return tree;
        }
        return new FormalParameter(tree.location, parameter, typeAnnotation, annotations);
      },
      transformFormalParameterList: function(tree) {
        var parameters = this.transformList(tree.parameters);
        if (parameters === tree.parameters) {
          return tree;
        }
        return new FormalParameterList(tree.location, parameters);
      },
      transformForwardDefaultExport: function(tree) {
        return tree;
      },
      transformFunctionBody: function(tree) {
        var statements = this.transformList(tree.statements);
        if (statements === tree.statements) {
          return tree;
        }
        return new FunctionBody(tree.location, statements);
      },
      transformFunctionDeclaration: function(tree) {
        var name = this.transformAny(tree.name);
        var parameterList = this.transformAny(tree.parameterList);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var body = this.transformAny(tree.body);
        if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) {
          return tree;
        }
        return new FunctionDeclaration(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, body);
      },
      transformFunctionExpression: function(tree) {
        var name = this.transformAny(tree.name);
        var parameterList = this.transformAny(tree.parameterList);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var body = this.transformAny(tree.body);
        if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) {
          return tree;
        }
        return new FunctionExpression(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, body);
      },
      transformFunctionType: function(tree) {
        var typeParameters = this.transformAny(tree.typeParameters);
        var parameterList = this.transformAny(tree.parameterList);
        var returnType = this.transformAny(tree.returnType);
        if (typeParameters === tree.typeParameters && parameterList === tree.parameterList && returnType === tree.returnType) {
          return tree;
        }
        return new FunctionType(tree.location, typeParameters, parameterList, returnType);
      },
      transformGeneratorComprehension: function(tree) {
        var comprehensionList = this.transformList(tree.comprehensionList);
        var expression = this.transformAny(tree.expression);
        if (comprehensionList === tree.comprehensionList && expression === tree.expression) {
          return tree;
        }
        return new GeneratorComprehension(tree.location, comprehensionList, expression);
      },
      transformGetAccessor: function(tree) {
        var name = this.transformAny(tree.name);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var body = this.transformAny(tree.body);
        if (name === tree.name && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) {
          return tree;
        }
        return new GetAccessor(tree.location, tree.isStatic, name, typeAnnotation, annotations, body);
      },
      transformIdentifierExpression: function(tree) {
        return tree;
      },
      transformIfStatement: function(tree) {
        var condition = this.transformAny(tree.condition);
        var ifClause = this.transformToBlockOrStatement(tree.ifClause);
        var elseClause = this.transformToBlockOrStatement(tree.elseClause);
        if (condition === tree.condition && ifClause === tree.ifClause && elseClause === tree.elseClause) {
          return tree;
        }
        return new IfStatement(tree.location, condition, ifClause, elseClause);
      },
      transformImportedBinding: function(tree) {
        var binding = this.transformAny(tree.binding);
        if (binding === tree.binding) {
          return tree;
        }
        return new ImportedBinding(tree.location, binding);
      },
      transformImportClausePair: function(tree) {
        var first = this.transformAny(tree.first);
        var second = this.transformAny(tree.second);
        if (first === tree.first && second === tree.second) {
          return tree;
        }
        return new ImportClausePair(tree.location, first, second);
      },
      transformImportDeclaration: function(tree) {
        var importClause = this.transformAny(tree.importClause);
        var moduleSpecifier = this.transformAny(tree.moduleSpecifier);
        if (importClause === tree.importClause && moduleSpecifier === tree.moduleSpecifier) {
          return tree;
        }
        return new ImportDeclaration(tree.location, importClause, moduleSpecifier);
      },
      transformImportSpecifier: function(tree) {
        var binding = this.transformAny(tree.binding);
        if (binding === tree.binding) {
          return tree;
        }
        return new ImportSpecifier(tree.location, binding, tree.name);
      },
      transformImportSpecifierSet: function(tree) {
        var specifiers = this.transformList(tree.specifiers);
        if (specifiers === tree.specifiers) {
          return tree;
        }
        return new ImportSpecifierSet(tree.location, specifiers);
      },
      transformImportTypeClause: function(tree) {
        var clause = this.transformAny(tree.clause);
        if (clause === tree.clause) {
          return tree;
        }
        return new ImportTypeClause(tree.location, clause);
      },
      transformIndexSignature: function(tree) {
        var indexType = this.transformAny(tree.indexType);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        if (indexType === tree.indexType && typeAnnotation === tree.typeAnnotation) {
          return tree;
        }
        return new IndexSignature(tree.location, tree.name, indexType, typeAnnotation);
      },
      transformInterfaceDeclaration: function(tree) {
        var typeParameters = this.transformAny(tree.typeParameters);
        var objectType = this.transformAny(tree.objectType);
        if (typeParameters === tree.typeParameters && objectType === tree.objectType) {
          return tree;
        }
        return new InterfaceDeclaration(tree.location, tree.name, typeParameters, tree.extendsClause, objectType);
      },
      transformJsxAttribute: function(tree) {
        var value = this.transformAny(tree.value);
        if (value === tree.value) {
          return tree;
        }
        return new JsxAttribute(tree.location, tree.name, value);
      },
      transformJsxElement: function(tree) {
        var name = this.transformAny(tree.name);
        var attributes = this.transformList(tree.attributes);
        var children = this.transformList(tree.children);
        if (name === tree.name && attributes === tree.attributes && children === tree.children) {
          return tree;
        }
        return new JsxElement(tree.location, name, attributes, children);
      },
      transformJsxElementName: function(tree) {
        return tree;
      },
      transformJsxPlaceholder: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new JsxPlaceholder(tree.location, expression);
      },
      transformJsxSpreadAttribute: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new JsxSpreadAttribute(tree.location, expression);
      },
      transformJsxText: function(tree) {
        return tree;
      },
      transformLabelledStatement: function(tree) {
        var statement = this.transformAny(tree.statement);
        if (statement === tree.statement) {
          return tree;
        }
        return new LabelledStatement(tree.location, tree.name, statement);
      },
      transformLiteralExpression: function(tree) {
        return tree;
      },
      transformLiteralPropertyName: function(tree) {
        return tree;
      },
      transformMemberExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        if (operand === tree.operand) {
          return tree;
        }
        return new MemberExpression(tree.location, operand, tree.memberName);
      },
      transformMemberLookupExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        var memberExpression = this.transformAny(tree.memberExpression);
        if (operand === tree.operand && memberExpression === tree.memberExpression) {
          return tree;
        }
        return new MemberLookupExpression(tree.location, operand, memberExpression);
      },
      transformMethod: function(tree) {
        var name = this.transformAny(tree.name);
        var parameterList = this.transformAny(tree.parameterList);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var body = this.transformAny(tree.body);
        var debugName = this.transformAny(tree.debugName);
        if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body && debugName === tree.debugName) {
          return tree;
        }
        return new Method(tree.location, tree.isStatic, tree.functionKind, name, parameterList, typeAnnotation, annotations, body, debugName);
      },
      transformMethodSignature: function(tree) {
        var name = this.transformAny(tree.name);
        var callSignature = this.transformAny(tree.callSignature);
        if (name === tree.name && callSignature === tree.callSignature) {
          return tree;
        }
        return new MethodSignature(tree.location, name, tree.optional, callSignature);
      },
      transformModule: function(tree) {
        var scriptItemList = this.transformList(tree.scriptItemList);
        if (scriptItemList === tree.scriptItemList) {
          return tree;
        }
        return new Module(tree.location, scriptItemList, tree.moduleName);
      },
      transformModuleSpecifier: function(tree) {
        return tree;
      },
      transformNameSpaceExport: function(tree) {
        return tree;
      },
      transformNameSpaceImport: function(tree) {
        var binding = this.transformAny(tree.binding);
        if (binding === tree.binding) {
          return tree;
        }
        return new NameSpaceImport(tree.location, binding);
      },
      transformNamedExport: function(tree) {
        var exportClause = this.transformAny(tree.exportClause);
        var moduleSpecifier = this.transformAny(tree.moduleSpecifier);
        if (exportClause === tree.exportClause && moduleSpecifier === tree.moduleSpecifier) {
          return tree;
        }
        return new NamedExport(tree.location, exportClause, moduleSpecifier);
      },
      transformNewExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        var args = this.transformAny(tree.args);
        if (operand === tree.operand && args === tree.args) {
          return tree;
        }
        return new NewExpression(tree.location, operand, args);
      },
      transformObjectLiteral: function(tree) {
        var propertyNameAndValues = this.transformList(tree.propertyNameAndValues);
        if (propertyNameAndValues === tree.propertyNameAndValues) {
          return tree;
        }
        return new ObjectLiteral(tree.location, propertyNameAndValues);
      },
      transformObjectPattern: function(tree) {
        var fields = this.transformList(tree.fields);
        if (fields === tree.fields) {
          return tree;
        }
        return new ObjectPattern(tree.location, fields);
      },
      transformObjectPatternField: function(tree) {
        var name = this.transformAny(tree.name);
        var element = this.transformAny(tree.element);
        if (name === tree.name && element === tree.element) {
          return tree;
        }
        return new ObjectPatternField(tree.location, name, element);
      },
      transformObjectType: function(tree) {
        var typeMembers = this.transformList(tree.typeMembers);
        if (typeMembers === tree.typeMembers) {
          return tree;
        }
        return new ObjectType(tree.location, typeMembers);
      },
      transformParenExpression: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new ParenExpression(tree.location, expression);
      },
      transformPostfixExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        if (operand === tree.operand) {
          return tree;
        }
        return new PostfixExpression(tree.location, operand, tree.operator);
      },
      transformPredefinedType: function(tree) {
        return tree;
      },
      transformScript: function(tree) {
        var scriptItemList = this.transformList(tree.scriptItemList);
        if (scriptItemList === tree.scriptItemList) {
          return tree;
        }
        return new Script(tree.location, scriptItemList, tree.moduleName);
      },
      transformPropertyNameAssignment: function(tree) {
        var name = this.transformAny(tree.name);
        var value = this.transformAny(tree.value);
        if (name === tree.name && value === tree.value) {
          return tree;
        }
        return new PropertyNameAssignment(tree.location, name, value);
      },
      transformPropertyNameShorthand: function(tree) {
        return tree;
      },
      transformPropertyVariableDeclaration: function(tree) {
        var name = this.transformAny(tree.name);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var initializer = this.transformAny(tree.initializer);
        if (name === tree.name && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && initializer === tree.initializer) {
          return tree;
        }
        return new PropertyVariableDeclaration(tree.location, tree.isStatic, name, typeAnnotation, annotations, initializer);
      },
      transformPropertySignature: function(tree) {
        var name = this.transformAny(tree.name);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        if (name === tree.name && typeAnnotation === tree.typeAnnotation) {
          return tree;
        }
        return new PropertySignature(tree.location, name, tree.optional, typeAnnotation);
      },
      transformRestParameter: function(tree) {
        var identifier = this.transformAny(tree.identifier);
        if (identifier === tree.identifier) {
          return tree;
        }
        return new RestParameter(tree.location, identifier);
      },
      transformReturnStatement: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new ReturnStatement(tree.location, expression);
      },
      transformSetAccessor: function(tree) {
        var name = this.transformAny(tree.name);
        var parameterList = this.transformAny(tree.parameterList);
        var annotations = this.transformList(tree.annotations);
        var body = this.transformAny(tree.body);
        if (name === tree.name && parameterList === tree.parameterList && annotations === tree.annotations && body === tree.body) {
          return tree;
        }
        return new SetAccessor(tree.location, tree.isStatic, name, parameterList, annotations, body);
      },
      transformSpreadExpression: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new SpreadExpression(tree.location, expression);
      },
      transformSpreadPatternElement: function(tree) {
        var lvalue = this.transformAny(tree.lvalue);
        if (lvalue === tree.lvalue) {
          return tree;
        }
        return new SpreadPatternElement(tree.location, lvalue);
      },
      transformSuperExpression: function(tree) {
        return tree;
      },
      transformSwitchStatement: function(tree) {
        var expression = this.transformAny(tree.expression);
        var caseClauses = this.transformList(tree.caseClauses);
        if (expression === tree.expression && caseClauses === tree.caseClauses) {
          return tree;
        }
        return new SwitchStatement(tree.location, expression, caseClauses);
      },
      transformSyntaxErrorTree: function(tree) {
        return tree;
      },
      transformTemplateLiteralExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        var elements = this.transformList(tree.elements);
        if (operand === tree.operand && elements === tree.elements) {
          return tree;
        }
        return new TemplateLiteralExpression(tree.location, operand, elements);
      },
      transformTemplateLiteralPortion: function(tree) {
        return tree;
      },
      transformTemplateSubstitution: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new TemplateSubstitution(tree.location, expression);
      },
      transformThisExpression: function(tree) {
        return tree;
      },
      transformThrowStatement: function(tree) {
        var value = this.transformAny(tree.value);
        if (value === tree.value) {
          return tree;
        }
        return new ThrowStatement(tree.location, value);
      },
      transformTryStatement: function(tree) {
        var body = this.transformAny(tree.body);
        var catchBlock = this.transformAny(tree.catchBlock);
        var finallyBlock = this.transformAny(tree.finallyBlock);
        if (body === tree.body && catchBlock === tree.catchBlock && finallyBlock === tree.finallyBlock) {
          return tree;
        }
        return new TryStatement(tree.location, body, catchBlock, finallyBlock);
      },
      transformTypeAliasDeclaration: function(tree) {
        var value = this.transformAny(tree.value);
        if (value === tree.value) {
          return tree;
        }
        return new TypeAliasDeclaration(tree.location, tree.name, value);
      },
      transformTypeArguments: function(tree) {
        var args = this.transformList(tree.args);
        if (args === tree.args) {
          return tree;
        }
        return new TypeArguments(tree.location, args);
      },
      transformTypeName: function(tree) {
        var moduleName = this.transformAny(tree.moduleName);
        if (moduleName === tree.moduleName) {
          return tree;
        }
        return new TypeName(tree.location, moduleName, tree.name);
      },
      transformTypeParameter: function(tree) {
        var extendsType = this.transformAny(tree.extendsType);
        if (extendsType === tree.extendsType) {
          return tree;
        }
        return new TypeParameter(tree.location, tree.identifierToken, extendsType);
      },
      transformTypeParameters: function(tree) {
        var parameters = this.transformList(tree.parameters);
        if (parameters === tree.parameters) {
          return tree;
        }
        return new TypeParameters(tree.location, parameters);
      },
      transformTypeReference: function(tree) {
        var typeName = this.transformAny(tree.typeName);
        var args = this.transformAny(tree.args);
        if (typeName === tree.typeName && args === tree.args) {
          return tree;
        }
        return new TypeReference(tree.location, typeName, args);
      },
      transformUnaryExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        if (operand === tree.operand) {
          return tree;
        }
        return new UnaryExpression(tree.location, tree.operator, operand);
      },
      transformUnionType: function(tree) {
        var types = this.transformList(tree.types);
        if (types === tree.types) {
          return tree;
        }
        return new UnionType(tree.location, types);
      },
      transformVariableDeclaration: function(tree) {
        var lvalue = this.transformAny(tree.lvalue);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var initializer = this.transformAny(tree.initializer);
        if (lvalue === tree.lvalue && typeAnnotation === tree.typeAnnotation && initializer === tree.initializer) {
          return tree;
        }
        return new VariableDeclaration(tree.location, lvalue, typeAnnotation, initializer);
      },
      transformVariableDeclarationList: function(tree) {
        var declarations = this.transformList(tree.declarations);
        if (declarations === tree.declarations) {
          return tree;
        }
        return new VariableDeclarationList(tree.location, tree.declarationType, declarations);
      },
      transformVariableStatement: function(tree) {
        var declarations = this.transformAny(tree.declarations);
        if (declarations === tree.declarations) {
          return tree;
        }
        return new VariableStatement(tree.location, declarations);
      },
      transformWhileStatement: function(tree) {
        var condition = this.transformAny(tree.condition);
        var body = this.transformToBlockOrStatement(tree.body);
        if (condition === tree.condition && body === tree.body) {
          return tree;
        }
        return new WhileStatement(tree.location, condition, body);
      },
      transformWithStatement: function(tree) {
        var expression = this.transformAny(tree.expression);
        var body = this.transformToBlockOrStatement(tree.body);
        if (expression === tree.expression && body === tree.body) {
          return tree;
        }
        return new WithStatement(tree.location, expression, body);
      },
      transformYieldExpression: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression) {
          return tree;
        }
        return new YieldExpression(tree.location, expression, tree.isYieldFor);
      }
    }, {});
  }();
  return {get ParseTreeTransformer() {
      return ParseTreeTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/AttachModuleNameTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/AttachModuleNameTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/module/AttachModuleNameTransformer.js")).ParseTreeTransformer;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/module/AttachModuleNameTransformer.js")),
      Module = $__2.Module,
      Script = $__2.Script;
  var AttachModuleNameTransformer = function($__super) {
    function AttachModuleNameTransformer(moduleName) {
      $traceurRuntime.superConstructor(AttachModuleNameTransformer).call(this);
      this.moduleName_ = moduleName;
    }
    return ($traceurRuntime.createClass)(AttachModuleNameTransformer, {
      transformModule: function(tree) {
        return new Module(tree.location, tree.scriptItemList, this.moduleName_);
      },
      transformScript: function(tree) {
        return new Script(tree.location, tree.scriptItemList, this.moduleName_);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get AttachModuleNameTransformer() {
      return AttachModuleNameTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/IdentifierToken.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/IdentifierToken.js";
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Token.js", "traceur@0.0.112/src/syntax/IdentifierToken.js")).Token;
  var IDENTIFIER = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TokenType.js", "traceur@0.0.112/src/syntax/IdentifierToken.js")).IDENTIFIER;
  var IdentifierToken = function($__super) {
    function IdentifierToken(location, value) {
      $traceurRuntime.superConstructor(IdentifierToken).call(this, IDENTIFIER, location);
      this.value = value;
    }
    return ($traceurRuntime.createClass)(IdentifierToken, {toString: function() {
        return this.value;
      }}, {}, $__super);
  }(Token);
  return {get IdentifierToken() {
      return IdentifierToken;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/LiteralToken.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/LiteralToken.js";
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Token.js", "traceur@0.0.112/src/syntax/LiteralToken.js")).Token;
  var $__11 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TokenType.js", "traceur@0.0.112/src/syntax/LiteralToken.js")),
      NULL = $__11.NULL,
      NUMBER = $__11.NUMBER,
      STRING = $__11.STRING;
  var StringParser = function() {
    var $__2;
    function StringParser(value) {
      this.value = value;
      this.index = 0;
    }
    return ($traceurRuntime.createClass)(StringParser, ($__2 = {}, Object.defineProperty($__2, Symbol.iterator, {
      value: function() {
        return this;
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), Object.defineProperty($__2, "next", {
      value: function() {
        if (++this.index >= this.value.length - 1)
          return {
            value: undefined,
            done: true
          };
        return {
          value: this.value[this.index],
          done: false
        };
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), Object.defineProperty($__2, "parse", {
      value: function() {
        if (this.value.indexOf('\\') === -1)
          return this.value.slice(1, -1);
        var result = '';
        var $__6 = true;
        var $__7 = false;
        var $__8 = undefined;
        try {
          for (var $__4 = void 0,
              $__3 = (this)[Symbol.iterator](); !($__6 = ($__4 = $__3.next()).done); $__6 = true) {
            var ch = $__4.value;
            {
              result += ch === '\\' ? this.parseEscapeSequence() : ch;
            }
          }
        } catch ($__9) {
          $__7 = true;
          $__8 = $__9;
        } finally {
          try {
            if (!$__6 && $__3.return != null) {
              $__3.return();
            }
          } finally {
            if ($__7) {
              throw $__8;
            }
          }
        }
        return result;
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), Object.defineProperty($__2, "parseEscapeSequence", {
      value: function() {
        var ch = this.next().value;
        switch (ch) {
          case '\n':
          case '\r':
          case '\u2028':
          case '\u2029':
            return '';
          case '0':
            return '\0';
          case 'b':
            return '\b';
          case 'f':
            return '\f';
          case 'n':
            return '\n';
          case 'r':
            return '\r';
          case 't':
            return '\t';
          case 'v':
            return '\v';
          case 'x':
            return String.fromCharCode(parseInt(this.next().value + this.next().value, 16));
          case 'u':
            {
              var nextValue = this.next().value;
              if (nextValue === '{') {
                var hexDigits = '';
                while ((nextValue = this.next().value) !== '}') {
                  hexDigits += nextValue;
                }
                var codePoint = parseInt(hexDigits, 16);
                if (codePoint <= 0xFFFF) {
                  return String.fromCharCode(codePoint);
                }
                var high = Math.floor((codePoint - 0x10000) / 0x400) + 0xD800;
                var low = (codePoint - 0x10000) % 0x400 + 0xDC00;
                return String.fromCharCode(high, low);
              }
              return String.fromCharCode(parseInt(nextValue + this.next().value + this.next().value + this.next().value, 16));
            }
          default:
            if (Number(ch) < 8)
              throw new Error('Octal literals are not supported');
            return ch;
        }
      },
      configurable: true,
      enumerable: true,
      writable: true
    }), $__2), {});
  }();
  var LiteralToken = function($__super) {
    function LiteralToken(type, value, location) {
      $traceurRuntime.superConstructor(LiteralToken).call(this, type, location);
      this.value = value;
    }
    return ($traceurRuntime.createClass)(LiteralToken, {
      toString: function() {
        return this.value;
      },
      get processedValue() {
        switch (this.type) {
          case NULL:
            return null;
          case NUMBER:
            {
              var value = this.value;
              if (value.charCodeAt(0) === 48) {
                switch (value.charCodeAt(1)) {
                  case 66:
                  case 98:
                    return parseInt(this.value.slice(2), 2);
                  case 79:
                  case 111:
                    return parseInt(this.value.slice(2), 8);
                }
              }
              return Number(this.value);
            }
          case STRING:
            {
              var parser = new StringParser(this.value);
              return parser.parse();
            }
          default:
            throw new Error('Not implemented');
        }
      }
    }, {}, $__super);
  }(Token);
  return {get LiteralToken() {
      return LiteralToken;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/assert.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/assert.js";
  function assert(b) {
    if (!b && $traceurRuntime.options.debug)
      throw Error('Assertion failed');
  }
  return {get assert() {
      return assert;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ParseTreeFactory.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js";
  var IdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/IdentifierToken.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")).IdentifierToken;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/LiteralToken.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")).LiteralToken;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTree.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")),
      ParseTree = $__3.ParseTree,
      ParseTreeType = $__3.ParseTreeType;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")),
      CALL = $__4.CALL,
      CREATE = $__4.CREATE,
      DEFINE_PROPERTY = $__4.DEFINE_PROPERTY,
      FREEZE = $__4.FREEZE,
      OBJECT = $__4.OBJECT,
      UNDEFINED = $__4.UNDEFINED;
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/Token.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")).Token;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")),
      EQUAL = $__6.EQUAL,
      FALSE = $__6.FALSE,
      NULL = $__6.NULL,
      NUMBER = $__6.NUMBER,
      STRING = $__6.STRING,
      TRUE = $__6.TRUE,
      VOID = $__6.VOID;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/assert.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")).assert;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ParseTreeFactory.js")),
      ArgumentList = $__8.ArgumentList,
      ArrayLiteral = $__8.ArrayLiteral,
      BindingElement = $__8.BindingElement,
      BinaryExpression = $__8.BinaryExpression,
      BindingIdentifier = $__8.BindingIdentifier,
      Block = $__8.Block,
      BreakStatement = $__8.BreakStatement,
      CallExpression = $__8.CallExpression,
      CaseClause = $__8.CaseClause,
      Catch = $__8.Catch,
      ClassDeclaration = $__8.ClassDeclaration,
      CommaExpression = $__8.CommaExpression,
      ConditionalExpression = $__8.ConditionalExpression,
      ContinueStatement = $__8.ContinueStatement,
      DefaultClause = $__8.DefaultClause,
      DoWhileStatement = $__8.DoWhileStatement,
      EmptyStatement = $__8.EmptyStatement,
      ExpressionStatement = $__8.ExpressionStatement,
      Finally = $__8.Finally,
      ForInStatement = $__8.ForInStatement,
      ForOfStatement = $__8.ForOfStatement,
      ForStatement = $__8.ForStatement,
      FormalParameter = $__8.FormalParameter,
      FormalParameterList = $__8.FormalParameterList,
      FunctionBody = $__8.FunctionBody,
      FunctionExpression = $__8.FunctionExpression,
      IdentifierExpression = $__8.IdentifierExpression,
      IfStatement = $__8.IfStatement,
      ImportedBinding = $__8.ImportedBinding,
      LiteralExpression = $__8.LiteralExpression,
      LiteralPropertyName = $__8.LiteralPropertyName,
      MemberExpression = $__8.MemberExpression,
      MemberLookupExpression = $__8.MemberLookupExpression,
      NewExpression = $__8.NewExpression,
      ObjectLiteral = $__8.ObjectLiteral,
      ParenExpression = $__8.ParenExpression,
      PostfixExpression = $__8.PostfixExpression,
      Script = $__8.Script,
      PropertyNameAssignment = $__8.PropertyNameAssignment,
      RestParameter = $__8.RestParameter,
      ReturnStatement = $__8.ReturnStatement,
      SpreadExpression = $__8.SpreadExpression,
      SwitchStatement = $__8.SwitchStatement,
      ThisExpression = $__8.ThisExpression,
      ThrowStatement = $__8.ThrowStatement,
      TryStatement = $__8.TryStatement,
      UnaryExpression = $__8.UnaryExpression,
      VariableDeclaration = $__8.VariableDeclaration,
      VariableDeclarationList = $__8.VariableDeclarationList,
      VariableStatement = $__8.VariableStatement,
      WhileStatement = $__8.WhileStatement,
      WithStatement = $__8.WithStatement;
  var slice = Array.prototype.slice.call.bind(Array.prototype.slice);
  var map = Array.prototype.map.call.bind(Array.prototype.map);
  function createOperatorToken(operator) {
    return new Token(operator, null);
  }
  function createIdentifierToken(identifier) {
    return new IdentifierToken(null, identifier);
  }
  function createStringLiteralToken(value) {
    return new LiteralToken(STRING, JSON.stringify(value), null);
  }
  function createBooleanLiteralToken(value) {
    return new Token(value ? TRUE : FALSE, null);
  }
  function createNullLiteralToken() {
    return new LiteralToken(NULL, 'null', null);
  }
  function createNumberLiteralToken(value) {
    return new LiteralToken(NUMBER, String(value), null);
  }
  function createEmptyParameterList() {
    return new FormalParameterList(null, []);
  }
  function createFormalParameter(name) {
    var bindingIdentifier = createBindingIdentifier(name);
    return new FormalParameter(null, new BindingElement(null, bindingIdentifier, null), null, []);
  }
  function createArgumentList(list) {
    return new ArgumentList(null, list);
  }
  function createEmptyArgumentList() {
    return createArgumentList([]);
  }
  function createArrayLiteral(list) {
    return new ArrayLiteral(null, list);
  }
  function createEmptyArrayLiteral() {
    return createArrayLiteral([]);
  }
  function createAssignmentExpression(lhs, rhs) {
    return new BinaryExpression(null, lhs, createOperatorToken(EQUAL), rhs);
  }
  function createBinaryExpression(left, operator, right) {
    return new BinaryExpression(null, left, operator, right);
  }
  function createBindingIdentifier(identifier) {
    if (typeof identifier === 'string')
      identifier = createIdentifierToken(identifier);
    else if (identifier.type === ParseTreeType.BINDING_IDENTIFIER)
      return identifier;
    else if (identifier.type === ParseTreeType.IDENTIFIER_EXPRESSION)
      return new BindingIdentifier(identifier.location, identifier.identifierToken);
    return new BindingIdentifier(null, identifier);
  }
  function createImportedBinding(name) {
    var bindingIdentifier = createBindingIdentifier(name);
    return new ImportedBinding(bindingIdentifier.location, bindingIdentifier);
  }
  function createEmptyStatement() {
    return new EmptyStatement(null);
  }
  function createEmptyBlock() {
    return createBlock([]);
  }
  function createBlock(statements) {
    return new Block(null, statements);
  }
  function createFunctionBody(statements) {
    return new FunctionBody(null, statements);
  }
  function createScopedExpression(body, scope) {
    assert(body.type === 'FUNCTION_BODY');
    return createCallCall(createParenExpression(createFunctionExpression(createEmptyParameterList(), body)), scope);
  }
  function createImmediatelyInvokedFunctionExpression(body) {
    assert(body.type === 'FUNCTION_BODY');
    return createCallExpression(createParenExpression(createFunctionExpression(createEmptyParameterList(), body)));
  }
  function createCallExpression(operand) {
    var args = arguments[1] !== (void 0) ? arguments[1] : createEmptyArgumentList();
    return new CallExpression(null, operand, args);
  }
  function createBreakStatement() {
    var name = arguments[0] !== (void 0) ? arguments[0] : null;
    return new BreakStatement(null, name);
  }
  function createCallCall(func, thisExpression) {
    return createCallExpression(createMemberExpression(func, CALL), createArgumentList([thisExpression]));
  }
  function createCaseClause(expression, statements) {
    return new CaseClause(null, expression, statements);
  }
  function createCatch(identifier, catchBody) {
    identifier = createBindingIdentifier(identifier);
    return new Catch(null, identifier, catchBody);
  }
  function createClassDeclaration(name, superClass, elements) {
    return new ClassDeclaration(null, name, superClass, elements, []);
  }
  function createCommaExpression(expressions) {
    return new CommaExpression(null, expressions);
  }
  function createConditionalExpression(condition, left, right) {
    return new ConditionalExpression(null, condition, left, right);
  }
  function createContinueStatement() {
    var name = arguments[0] !== (void 0) ? arguments[0] : null;
    return new ContinueStatement(null, name);
  }
  function createDefaultClause(statements) {
    return new DefaultClause(null, statements);
  }
  function createDoWhileStatement(body, condition) {
    return new DoWhileStatement(null, body, condition);
  }
  function createAssignmentStatement(lhs, rhs) {
    return createExpressionStatement(createAssignmentExpression(lhs, rhs));
  }
  function createCallStatement(operand) {
    var args = arguments[1];
    return createExpressionStatement(createCallExpression(operand, args));
  }
  function createExpressionStatement(expression) {
    return new ExpressionStatement(null, expression);
  }
  function createFinally(block) {
    return new Finally(null, block);
  }
  function createForOfStatement(initializer, collection, body) {
    return new ForOfStatement(null, initializer, collection, body);
  }
  function createForInStatement(initializer, collection, body) {
    return new ForInStatement(null, initializer, collection, body);
  }
  function createForStatement(variables, condition, increment, body) {
    return new ForStatement(null, variables, condition, increment, body);
  }
  function createFunctionExpression(parameterList, body) {
    assert(body.type === 'FUNCTION_BODY');
    return new FunctionExpression(null, null, false, parameterList, null, [], body);
  }
  function createIdentifierExpression(identifier) {
    if (typeof identifier === 'string')
      identifier = createIdentifierToken(identifier);
    else if (identifier instanceof BindingIdentifier)
      identifier = identifier.identifierToken;
    return new IdentifierExpression(null, identifier);
  }
  function createUndefinedExpression() {
    return createIdentifierExpression(UNDEFINED);
  }
  function createIfStatement(condition, ifClause) {
    var elseClause = arguments[2] !== (void 0) ? arguments[2] : null;
    return new IfStatement(null, condition, ifClause, elseClause);
  }
  function createStringLiteral(value) {
    return new LiteralExpression(null, createStringLiteralToken(value));
  }
  function createBooleanLiteral(value) {
    return new LiteralExpression(null, createBooleanLiteralToken(value));
  }
  function createTrueLiteral() {
    return createBooleanLiteral(true);
  }
  function createFalseLiteral() {
    return createBooleanLiteral(false);
  }
  function createNullLiteral() {
    return new LiteralExpression(null, createNullLiteralToken());
  }
  function createNumberLiteral(value) {
    return new LiteralExpression(null, createNumberLiteralToken(value));
  }
  function createMemberExpression(operand, memberName) {
    for (var memberNames = [],
        $__0 = 2; $__0 < arguments.length; $__0++)
      memberNames[$__0 - 2] = arguments[$__0];
    if (typeof operand === 'string' || operand instanceof IdentifierToken)
      operand = createIdentifierExpression(operand);
    if (typeof memberName === 'string')
      memberName = createIdentifierToken(memberName);
    if (memberName instanceof LiteralToken)
      memberName = new LiteralExpression(null, memberName);
    var tree = memberName instanceof LiteralExpression ? new MemberLookupExpression(null, operand, memberName) : new MemberExpression(null, operand, memberName);
    for (var i = 0; i < memberNames.length; i++) {
      tree = createMemberExpression(tree, memberNames[i]);
    }
    return tree;
  }
  function createMemberLookupExpression(operand, memberExpression) {
    return new MemberLookupExpression(null, operand, memberExpression);
  }
  function createThisExpression() {
    return new ThisExpression(null);
  }
  function createNewExpression(operand, args) {
    return new NewExpression(null, operand, args);
  }
  function createObjectFreeze(value) {
    return createCallExpression(createMemberExpression(OBJECT, FREEZE), createArgumentList([value]));
  }
  function createObjectCreate(protoExpression) {
    var descriptors = arguments[1];
    var argumentList = [protoExpression];
    if (descriptors)
      argumentList.push(descriptors);
    return createCallExpression(createMemberExpression(OBJECT, CREATE), createArgumentList(argumentList));
  }
  function createObjectLiteralForDescriptor(descr) {
    var propertyNameAndValues = Object.keys(descr).map(function(name) {
      var value = descr[name];
      if (!(value instanceof ParseTree))
        value = createBooleanLiteral(!!value);
      return createPropertyNameAssignment(name, value);
    });
    return createObjectLiteral(propertyNameAndValues);
  }
  function createDefineProperty(tree, name, descr) {
    if (typeof name === 'string')
      name = createStringLiteral(name);
    return createCallExpression(createMemberExpression(OBJECT, DEFINE_PROPERTY), createArgumentList([tree, name, createObjectLiteralForDescriptor(descr)]));
  }
  function createObjectLiteral(propertyNameAndValues) {
    return new ObjectLiteral(null, propertyNameAndValues);
  }
  function createParenExpression(expression) {
    return new ParenExpression(null, expression);
  }
  function createPostfixExpression(operand, operator) {
    return new PostfixExpression(null, operand, operator);
  }
  function createScript(scriptItemList) {
    return new Script(null, scriptItemList, null);
  }
  function createPropertyNameAssignment(identifier, value) {
    if (typeof identifier === 'string')
      identifier = createLiteralPropertyName(identifier);
    return new PropertyNameAssignment(null, identifier, value);
  }
  function createLiteralPropertyName(name) {
    return new LiteralPropertyName(null, createIdentifierToken(name));
  }
  function createRestParameter(identifier) {
    var rest = new RestParameter(null, createBindingIdentifier(identifier));
    return new FormalParameter(null, rest, null, []);
  }
  function createReturnStatement(expression) {
    return new ReturnStatement(null, expression);
  }
  function createSpreadExpression(expression) {
    return new SpreadExpression(null, expression);
  }
  function createSwitchStatement(expression, caseClauses) {
    return new SwitchStatement(null, expression, caseClauses);
  }
  function createThrowStatement(value) {
    return new ThrowStatement(null, value);
  }
  function createTryStatement(body, catchBlock) {
    var finallyBlock = arguments[2] !== (void 0) ? arguments[2] : null;
    return new TryStatement(null, body, catchBlock, finallyBlock);
  }
  function createUnaryExpression(operator, operand) {
    return new UnaryExpression(null, operator, operand);
  }
  function createUseStrictDirective() {
    return createExpressionStatement(createStringLiteral('use strict'));
  }
  function createVariableDeclarationList(binding, identifierOrDeclarations) {
    var initializer = arguments[2];
    if (identifierOrDeclarations instanceof Array) {
      var declarations = identifierOrDeclarations;
      return new VariableDeclarationList(null, binding, declarations);
    }
    var identifier = identifierOrDeclarations;
    return createVariableDeclarationList(binding, [createVariableDeclaration(identifier, initializer)]);
  }
  function createVariableDeclaration(identifier, initializer) {
    if (!(identifier instanceof ParseTree) || identifier.type !== ParseTreeType.BINDING_IDENTIFIER && identifier.type !== ParseTreeType.OBJECT_PATTERN && identifier.type !== ParseTreeType.ARRAY_PATTERN) {
      identifier = createBindingIdentifier(identifier);
    }
    return new VariableDeclaration(null, identifier, null, initializer);
  }
  function createVariableStatement(listOrBinding) {
    var identifier = arguments[1];
    var initializer = arguments[2];
    if (listOrBinding instanceof VariableDeclarationList)
      return new VariableStatement(null, listOrBinding);
    var binding = listOrBinding;
    var list = createVariableDeclarationList(binding, identifier, initializer);
    return createVariableStatement(list);
  }
  function createVoid0() {
    return createParenExpression(createUnaryExpression(createOperatorToken(VOID), createNumberLiteral(0)));
  }
  function createWhileStatement(condition, body) {
    return new WhileStatement(null, condition, body);
  }
  function createWithStatement(expression, body) {
    return new WithStatement(null, expression, body);
  }
  function createAssignStateStatement(state) {
    return createAssignmentStatement(createMemberExpression('$ctx', 'state'), createNumberLiteral(state));
  }
  return {
    get createOperatorToken() {
      return createOperatorToken;
    },
    get createIdentifierToken() {
      return createIdentifierToken;
    },
    get createStringLiteralToken() {
      return createStringLiteralToken;
    },
    get createBooleanLiteralToken() {
      return createBooleanLiteralToken;
    },
    get createNullLiteralToken() {
      return createNullLiteralToken;
    },
    get createNumberLiteralToken() {
      return createNumberLiteralToken;
    },
    get createEmptyParameterList() {
      return createEmptyParameterList;
    },
    get createFormalParameter() {
      return createFormalParameter;
    },
    get createArgumentList() {
      return createArgumentList;
    },
    get createEmptyArgumentList() {
      return createEmptyArgumentList;
    },
    get createArrayLiteral() {
      return createArrayLiteral;
    },
    get createEmptyArrayLiteral() {
      return createEmptyArrayLiteral;
    },
    get createAssignmentExpression() {
      return createAssignmentExpression;
    },
    get createBinaryExpression() {
      return createBinaryExpression;
    },
    get createBindingIdentifier() {
      return createBindingIdentifier;
    },
    get createImportedBinding() {
      return createImportedBinding;
    },
    get createEmptyStatement() {
      return createEmptyStatement;
    },
    get createEmptyBlock() {
      return createEmptyBlock;
    },
    get createBlock() {
      return createBlock;
    },
    get createFunctionBody() {
      return createFunctionBody;
    },
    get createScopedExpression() {
      return createScopedExpression;
    },
    get createImmediatelyInvokedFunctionExpression() {
      return createImmediatelyInvokedFunctionExpression;
    },
    get createCallExpression() {
      return createCallExpression;
    },
    get createBreakStatement() {
      return createBreakStatement;
    },
    get createCaseClause() {
      return createCaseClause;
    },
    get createCatch() {
      return createCatch;
    },
    get createClassDeclaration() {
      return createClassDeclaration;
    },
    get createCommaExpression() {
      return createCommaExpression;
    },
    get createConditionalExpression() {
      return createConditionalExpression;
    },
    get createContinueStatement() {
      return createContinueStatement;
    },
    get createDefaultClause() {
      return createDefaultClause;
    },
    get createDoWhileStatement() {
      return createDoWhileStatement;
    },
    get createAssignmentStatement() {
      return createAssignmentStatement;
    },
    get createCallStatement() {
      return createCallStatement;
    },
    get createExpressionStatement() {
      return createExpressionStatement;
    },
    get createFinally() {
      return createFinally;
    },
    get createForOfStatement() {
      return createForOfStatement;
    },
    get createForInStatement() {
      return createForInStatement;
    },
    get createForStatement() {
      return createForStatement;
    },
    get createFunctionExpression() {
      return createFunctionExpression;
    },
    get createIdentifierExpression() {
      return createIdentifierExpression;
    },
    get createUndefinedExpression() {
      return createUndefinedExpression;
    },
    get createIfStatement() {
      return createIfStatement;
    },
    get createStringLiteral() {
      return createStringLiteral;
    },
    get createBooleanLiteral() {
      return createBooleanLiteral;
    },
    get createTrueLiteral() {
      return createTrueLiteral;
    },
    get createFalseLiteral() {
      return createFalseLiteral;
    },
    get createNullLiteral() {
      return createNullLiteral;
    },
    get createNumberLiteral() {
      return createNumberLiteral;
    },
    get createMemberExpression() {
      return createMemberExpression;
    },
    get createMemberLookupExpression() {
      return createMemberLookupExpression;
    },
    get createThisExpression() {
      return createThisExpression;
    },
    get createNewExpression() {
      return createNewExpression;
    },
    get createObjectFreeze() {
      return createObjectFreeze;
    },
    get createObjectCreate() {
      return createObjectCreate;
    },
    get createObjectLiteralForDescriptor() {
      return createObjectLiteralForDescriptor;
    },
    get createDefineProperty() {
      return createDefineProperty;
    },
    get createObjectLiteral() {
      return createObjectLiteral;
    },
    get createParenExpression() {
      return createParenExpression;
    },
    get createPostfixExpression() {
      return createPostfixExpression;
    },
    get createScript() {
      return createScript;
    },
    get createPropertyNameAssignment() {
      return createPropertyNameAssignment;
    },
    get createLiteralPropertyName() {
      return createLiteralPropertyName;
    },
    get createRestParameter() {
      return createRestParameter;
    },
    get createReturnStatement() {
      return createReturnStatement;
    },
    get createSwitchStatement() {
      return createSwitchStatement;
    },
    get createThrowStatement() {
      return createThrowStatement;
    },
    get createTryStatement() {
      return createTryStatement;
    },
    get createUnaryExpression() {
      return createUnaryExpression;
    },
    get createUseStrictDirective() {
      return createUseStrictDirective;
    },
    get createVariableDeclarationList() {
      return createVariableDeclarationList;
    },
    get createVariableDeclaration() {
      return createVariableDeclaration;
    },
    get createVariableStatement() {
      return createVariableStatement;
    },
    get createVoid0() {
      return createVoid0;
    },
    get createWhileStatement() {
      return createWhileStatement;
    },
    get createWithStatement() {
      return createWithStatement;
    },
    get createAssignStateStatement() {
      return createAssignStateStatement;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/ParseTreeVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/ParseTreeVisitor.js";
  var ParseTreeVisitor = function() {
    function ParseTreeVisitor() {}
    return ($traceurRuntime.createClass)(ParseTreeVisitor, {
      visitAny: function(tree) {
        tree !== null && tree.visit(this);
      },
      visit: function(tree) {
        this.visitAny(tree);
      },
      visitList: function(list) {
        if (list) {
          for (var i = 0; i < list.length; i++) {
            this.visitAny(list[i]);
          }
        }
      },
      visitStateMachine: function(tree) {
        throw Error('State machines should not live outside of the GeneratorTransformer.');
      },
      visitAnnotation: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.args);
      },
      visitAnonBlock: function(tree) {
        this.visitList(tree.statements);
      },
      visitArgumentList: function(tree) {
        this.visitList(tree.args);
      },
      visitArrayComprehension: function(tree) {
        this.visitList(tree.comprehensionList);
        this.visitAny(tree.expression);
      },
      visitArrayLiteral: function(tree) {
        this.visitList(tree.elements);
      },
      visitArrayPattern: function(tree) {
        this.visitList(tree.elements);
      },
      visitArrayType: function(tree) {
        this.visitAny(tree.elementType);
      },
      visitArrowFunction: function(tree) {
        this.visitAny(tree.parameterList);
        this.visitAny(tree.body);
      },
      visitAssignmentElement: function(tree) {
        this.visitAny(tree.assignment);
        this.visitAny(tree.initializer);
      },
      visitAwaitExpression: function(tree) {
        this.visitAny(tree.expression);
      },
      visitBinaryExpression: function(tree) {
        this.visitAny(tree.left);
        this.visitAny(tree.right);
      },
      visitBindingElement: function(tree) {
        this.visitAny(tree.binding);
        this.visitAny(tree.initializer);
      },
      visitBindingIdentifier: function(tree) {},
      visitBlock: function(tree) {
        this.visitList(tree.statements);
      },
      visitBreakStatement: function(tree) {},
      visitCallExpression: function(tree) {
        this.visitAny(tree.operand);
        this.visitAny(tree.args);
      },
      visitCallSignature: function(tree) {
        this.visitAny(tree.typeParameters);
        this.visitAny(tree.parameterList);
        this.visitAny(tree.returnType);
      },
      visitCaseClause: function(tree) {
        this.visitAny(tree.expression);
        this.visitList(tree.statements);
      },
      visitCatch: function(tree) {
        this.visitAny(tree.binding);
        this.visitAny(tree.catchBody);
      },
      visitClassDeclaration: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.superClass);
        this.visitList(tree.elements);
        this.visitList(tree.annotations);
        this.visitAny(tree.typeParameters);
      },
      visitClassExpression: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.superClass);
        this.visitList(tree.elements);
        this.visitList(tree.annotations);
        this.visitAny(tree.typeParameters);
      },
      visitCommaExpression: function(tree) {
        this.visitList(tree.expressions);
      },
      visitComprehensionFor: function(tree) {
        this.visitAny(tree.left);
        this.visitAny(tree.iterator);
      },
      visitComprehensionIf: function(tree) {
        this.visitAny(tree.expression);
      },
      visitComputedPropertyName: function(tree) {
        this.visitAny(tree.expression);
      },
      visitConditionalExpression: function(tree) {
        this.visitAny(tree.condition);
        this.visitAny(tree.left);
        this.visitAny(tree.right);
      },
      visitConstructSignature: function(tree) {
        this.visitAny(tree.typeParameters);
        this.visitAny(tree.parameterList);
        this.visitAny(tree.returnType);
      },
      visitConstructorType: function(tree) {
        this.visitAny(tree.typeParameters);
        this.visitAny(tree.parameterList);
        this.visitAny(tree.returnType);
      },
      visitContinueStatement: function(tree) {},
      visitCoverFormals: function(tree) {
        this.visitList(tree.expressions);
      },
      visitCoverInitializedName: function(tree) {
        this.visitAny(tree.initializer);
      },
      visitDebuggerStatement: function(tree) {},
      visitDefaultClause: function(tree) {
        this.visitList(tree.statements);
      },
      visitDoWhileStatement: function(tree) {
        this.visitAny(tree.body);
        this.visitAny(tree.condition);
      },
      visitEmptyStatement: function(tree) {},
      visitExportDeclaration: function(tree) {
        this.visitAny(tree.declaration);
        this.visitList(tree.annotations);
      },
      visitExportDefault: function(tree) {
        this.visitAny(tree.expression);
      },
      visitExportSpecifier: function(tree) {},
      visitExportSpecifierSet: function(tree) {
        this.visitList(tree.specifiers);
      },
      visitExportStar: function(tree) {},
      visitExpressionStatement: function(tree) {
        this.visitAny(tree.expression);
      },
      visitFinally: function(tree) {
        this.visitAny(tree.block);
      },
      visitForInStatement: function(tree) {
        this.visitAny(tree.initializer);
        this.visitAny(tree.collection);
        this.visitAny(tree.body);
      },
      visitForOfStatement: function(tree) {
        this.visitAny(tree.initializer);
        this.visitAny(tree.collection);
        this.visitAny(tree.body);
      },
      visitForOnStatement: function(tree) {
        this.visitAny(tree.initializer);
        this.visitAny(tree.observable);
        this.visitAny(tree.body);
      },
      visitForStatement: function(tree) {
        this.visitAny(tree.initializer);
        this.visitAny(tree.condition);
        this.visitAny(tree.increment);
        this.visitAny(tree.body);
      },
      visitFormalParameter: function(tree) {
        this.visitAny(tree.parameter);
        this.visitAny(tree.typeAnnotation);
        this.visitList(tree.annotations);
      },
      visitFormalParameterList: function(tree) {
        this.visitList(tree.parameters);
      },
      visitForwardDefaultExport: function(tree) {},
      visitFunctionBody: function(tree) {
        this.visitList(tree.statements);
      },
      visitFunctionDeclaration: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.parameterList);
        this.visitAny(tree.typeAnnotation);
        this.visitList(tree.annotations);
        this.visitAny(tree.body);
      },
      visitFunctionExpression: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.parameterList);
        this.visitAny(tree.typeAnnotation);
        this.visitList(tree.annotations);
        this.visitAny(tree.body);
      },
      visitFunctionType: function(tree) {
        this.visitAny(tree.typeParameters);
        this.visitAny(tree.parameterList);
        this.visitAny(tree.returnType);
      },
      visitGeneratorComprehension: function(tree) {
        this.visitList(tree.comprehensionList);
        this.visitAny(tree.expression);
      },
      visitGetAccessor: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.typeAnnotation);
        this.visitList(tree.annotations);
        this.visitAny(tree.body);
      },
      visitIdentifierExpression: function(tree) {},
      visitIfStatement: function(tree) {
        this.visitAny(tree.condition);
        this.visitAny(tree.ifClause);
        this.visitAny(tree.elseClause);
      },
      visitImportedBinding: function(tree) {
        this.visitAny(tree.binding);
      },
      visitImportClausePair: function(tree) {
        this.visitAny(tree.first);
        this.visitAny(tree.second);
      },
      visitImportDeclaration: function(tree) {
        this.visitAny(tree.importClause);
        this.visitAny(tree.moduleSpecifier);
      },
      visitImportSpecifier: function(tree) {
        this.visitAny(tree.binding);
      },
      visitImportSpecifierSet: function(tree) {
        this.visitList(tree.specifiers);
      },
      visitImportTypeClause: function(tree) {
        this.visitAny(tree.clause);
      },
      visitIndexSignature: function(tree) {
        this.visitAny(tree.indexType);
        this.visitAny(tree.typeAnnotation);
      },
      visitInterfaceDeclaration: function(tree) {
        this.visitAny(tree.typeParameters);
        this.visitAny(tree.objectType);
      },
      visitJsxAttribute: function(tree) {
        this.visitAny(tree.value);
      },
      visitJsxElement: function(tree) {
        this.visitAny(tree.name);
        this.visitList(tree.attributes);
        this.visitList(tree.children);
      },
      visitJsxElementName: function(tree) {},
      visitJsxPlaceholder: function(tree) {
        this.visitAny(tree.expression);
      },
      visitJsxSpreadAttribute: function(tree) {
        this.visitAny(tree.expression);
      },
      visitJsxText: function(tree) {},
      visitLabelledStatement: function(tree) {
        this.visitAny(tree.statement);
      },
      visitLiteralExpression: function(tree) {},
      visitLiteralPropertyName: function(tree) {},
      visitMemberExpression: function(tree) {
        this.visitAny(tree.operand);
      },
      visitMemberLookupExpression: function(tree) {
        this.visitAny(tree.operand);
        this.visitAny(tree.memberExpression);
      },
      visitMethod: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.parameterList);
        this.visitAny(tree.typeAnnotation);
        this.visitList(tree.annotations);
        this.visitAny(tree.body);
        this.visitAny(tree.debugName);
      },
      visitMethodSignature: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.callSignature);
      },
      visitModule: function(tree) {
        this.visitList(tree.scriptItemList);
      },
      visitModuleSpecifier: function(tree) {},
      visitNameSpaceExport: function(tree) {},
      visitNameSpaceImport: function(tree) {
        this.visitAny(tree.binding);
      },
      visitNamedExport: function(tree) {
        this.visitAny(tree.exportClause);
        this.visitAny(tree.moduleSpecifier);
      },
      visitNewExpression: function(tree) {
        this.visitAny(tree.operand);
        this.visitAny(tree.args);
      },
      visitObjectLiteral: function(tree) {
        this.visitList(tree.propertyNameAndValues);
      },
      visitObjectPattern: function(tree) {
        this.visitList(tree.fields);
      },
      visitObjectPatternField: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.element);
      },
      visitObjectType: function(tree) {
        this.visitList(tree.typeMembers);
      },
      visitParenExpression: function(tree) {
        this.visitAny(tree.expression);
      },
      visitPostfixExpression: function(tree) {
        this.visitAny(tree.operand);
      },
      visitPredefinedType: function(tree) {},
      visitScript: function(tree) {
        this.visitList(tree.scriptItemList);
      },
      visitPropertyNameAssignment: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.value);
      },
      visitPropertyNameShorthand: function(tree) {},
      visitPropertyVariableDeclaration: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.typeAnnotation);
        this.visitList(tree.annotations);
        this.visitAny(tree.initializer);
      },
      visitPropertySignature: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.typeAnnotation);
      },
      visitRestParameter: function(tree) {
        this.visitAny(tree.identifier);
      },
      visitReturnStatement: function(tree) {
        this.visitAny(tree.expression);
      },
      visitSetAccessor: function(tree) {
        this.visitAny(tree.name);
        this.visitAny(tree.parameterList);
        this.visitList(tree.annotations);
        this.visitAny(tree.body);
      },
      visitSpreadExpression: function(tree) {
        this.visitAny(tree.expression);
      },
      visitSpreadPatternElement: function(tree) {
        this.visitAny(tree.lvalue);
      },
      visitSuperExpression: function(tree) {},
      visitSwitchStatement: function(tree) {
        this.visitAny(tree.expression);
        this.visitList(tree.caseClauses);
      },
      visitSyntaxErrorTree: function(tree) {},
      visitTemplateLiteralExpression: function(tree) {
        this.visitAny(tree.operand);
        this.visitList(tree.elements);
      },
      visitTemplateLiteralPortion: function(tree) {},
      visitTemplateSubstitution: function(tree) {
        this.visitAny(tree.expression);
      },
      visitThisExpression: function(tree) {},
      visitThrowStatement: function(tree) {
        this.visitAny(tree.value);
      },
      visitTryStatement: function(tree) {
        this.visitAny(tree.body);
        this.visitAny(tree.catchBlock);
        this.visitAny(tree.finallyBlock);
      },
      visitTypeAliasDeclaration: function(tree) {
        this.visitAny(tree.value);
      },
      visitTypeArguments: function(tree) {
        this.visitList(tree.args);
      },
      visitTypeName: function(tree) {
        this.visitAny(tree.moduleName);
      },
      visitTypeParameter: function(tree) {
        this.visitAny(tree.extendsType);
      },
      visitTypeParameters: function(tree) {
        this.visitList(tree.parameters);
      },
      visitTypeReference: function(tree) {
        this.visitAny(tree.typeName);
        this.visitAny(tree.args);
      },
      visitUnaryExpression: function(tree) {
        this.visitAny(tree.operand);
      },
      visitUnionType: function(tree) {
        this.visitList(tree.types);
      },
      visitVariableDeclaration: function(tree) {
        this.visitAny(tree.lvalue);
        this.visitAny(tree.typeAnnotation);
        this.visitAny(tree.initializer);
      },
      visitVariableDeclarationList: function(tree) {
        this.visitList(tree.declarations);
      },
      visitVariableStatement: function(tree) {
        this.visitAny(tree.declarations);
      },
      visitWhileStatement: function(tree) {
        this.visitAny(tree.condition);
        this.visitAny(tree.body);
      },
      visitWithStatement: function(tree) {
        this.visitAny(tree.expression);
        this.visitAny(tree.body);
      },
      visitYieldExpression: function(tree) {
        this.visitAny(tree.expression);
      }
    }, {});
  }();
  return {get ParseTreeVisitor() {
      return ParseTreeVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/FindVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/FindVisitor.js";
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/codegeneration/FindVisitor.js")).ParseTreeVisitor;
  var FindVisitor = function($__super) {
    function FindVisitor() {
      var keepOnGoing = arguments[0];
      $traceurRuntime.superConstructor(FindVisitor).call(this);
      this.found_ = false;
      this.shouldContinue_ = true;
      this.keepOnGoing_ = keepOnGoing;
    }
    return ($traceurRuntime.createClass)(FindVisitor, {
      get found() {
        return this.found_;
      },
      set found(v) {
        if (v) {
          this.found_ = true;
          if (!this.keepOnGoing_)
            this.shouldContinue_ = false;
        }
      },
      visitAny: function(tree) {
        this.shouldContinue_ && tree && tree.visit(this);
      },
      visitList: function(list) {
        if (list) {
          for (var i = 0; this.shouldContinue_ && i < list.length; i++) {
            this.visitAny(list[i]);
          }
        }
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  return {get FindVisitor() {
      return FindVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/SyntaxErrorReporter.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/SyntaxErrorReporter.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ErrorReporter.js", "traceur@0.0.112/src/util/SyntaxErrorReporter.js")),
      ErrorReporter = $__1.ErrorReporter,
      format = $__1.format;
  var SyntaxErrorReporter = function($__super) {
    function SyntaxErrorReporter() {
      $traceurRuntime.superConstructor(SyntaxErrorReporter).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(SyntaxErrorReporter, {reportMessageInternal: function(location, message) {
        var s = format(location, message);
        throw new SyntaxError(s);
      }}, {}, $__super);
  }(ErrorReporter);
  return {get SyntaxErrorReporter() {
      return SyntaxErrorReporter;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/JsxIdentifierToken.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/JsxIdentifierToken.js";
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Token.js", "traceur@0.0.112/src/syntax/JsxIdentifierToken.js")).Token;
  var JSX_IDENTIFIER = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TokenType.js", "traceur@0.0.112/src/syntax/JsxIdentifierToken.js")).JSX_IDENTIFIER;
  var JsxIdentifierToken = function($__super) {
    function JsxIdentifierToken(location, value) {
      $traceurRuntime.superConstructor(JsxIdentifierToken).call(this, JSX_IDENTIFIER, location);
      this.value = value;
    }
    return ($traceurRuntime.createClass)(JsxIdentifierToken, {toString: function() {
        return this.value;
      }}, {}, $__super);
  }(Token);
  return {get JsxIdentifierToken() {
      return JsxIdentifierToken;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/Keywords.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/Keywords.js";
  var keywords = ['break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'export', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'return', 'super', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'enum', 'extends', 'null', 'true', 'false'];
  var strictKeywords = ['implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield'];
  var keywordsByName = Object.create(null);
  var NORMAL_KEYWORD = 1;
  var STRICT_KEYWORD = 2;
  keywords.forEach(function(value) {
    keywordsByName[value] = NORMAL_KEYWORD;
  });
  strictKeywords.forEach(function(value) {
    keywordsByName[value] = STRICT_KEYWORD;
  });
  function getKeywordType(value) {
    return keywordsByName[value];
  }
  function isStrictKeyword(value) {
    return getKeywordType(value) === STRICT_KEYWORD;
  }
  return {
    get NORMAL_KEYWORD() {
      return NORMAL_KEYWORD;
    },
    get STRICT_KEYWORD() {
      return STRICT_KEYWORD;
    },
    get getKeywordType() {
      return getKeywordType;
    },
    get isStrictKeyword() {
      return isStrictKeyword;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/KeywordToken.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/KeywordToken.js";
  var STRICT_KEYWORD = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Keywords.js", "traceur@0.0.112/src/syntax/KeywordToken.js")).STRICT_KEYWORD;
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Token.js", "traceur@0.0.112/src/syntax/KeywordToken.js")).Token;
  var KeywordToken = function($__super) {
    function KeywordToken(type, keywordType, location) {
      $traceurRuntime.superConstructor(KeywordToken).call(this, type, location);
      this.isStrictKeyword_ = keywordType === STRICT_KEYWORD;
    }
    return ($traceurRuntime.createClass)(KeywordToken, {
      isKeyword: function() {
        return true;
      },
      isStrictKeyword: function() {
        return this.isStrictKeyword_;
      }
    }, {}, $__super);
  }(Token);
  return {get KeywordToken() {
      return KeywordToken;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/unicode-tables.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/unicode-tables.js";
  var idStartTable = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 442, 443, 443, 444, 447, 448, 451, 452, 659, 660, 660, 661, 687, 688, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 883, 884, 884, 886, 887, 890, 890, 891, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1599, 1600, 1600, 1601, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2226, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2417, 2418, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3653, 3654, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4348, 4349, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5873, 5880, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6210, 6211, 6211, 6212, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7287, 7288, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7467, 7468, 7530, 7531, 7543, 7544, 7544, 7545, 7578, 7579, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8472, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8494, 8494, 8495, 8500, 8501, 8504, 8505, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8578, 8579, 8580, 8581, 8584, 11264, 11310, 11312, 11358, 11360, 11387, 11388, 11389, 11390, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12293, 12294, 12294, 12295, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12347, 12347, 12348, 12348, 12353, 12438, 12443, 12444, 12445, 12446, 12447, 12447, 12449, 12538, 12540, 12542, 12543, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 40980, 40981, 40981, 40982, 42124, 42192, 42231, 42232, 42237, 42240, 42507, 42508, 42508, 42512, 42527, 42538, 42539, 42560, 42605, 42606, 42606, 42623, 42623, 42624, 42651, 42652, 42653, 42656, 42725, 42726, 42735, 42775, 42783, 42786, 42863, 42864, 42864, 42865, 42887, 42888, 42888, 42891, 42894, 42896, 42925, 42928, 42929, 42999, 42999, 43000, 43001, 43002, 43002, 43003, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43494, 43495, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43631, 43632, 43632, 43633, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43740, 43741, 43741, 43744, 43754, 43762, 43762, 43763, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43871, 43876, 43877, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65391, 65392, 65392, 65393, 65437, 65438, 65439, 65440, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66352, 66368, 66369, 66369, 66370, 66377, 66378, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66639, 66640, 66717, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68147, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 69635, 69687, 69763, 69807, 69840, 69864, 69891, 69926, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70144, 70161, 70163, 70187, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70493, 70497, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71168, 71215, 71236, 71236, 71296, 71338, 71840, 71903, 71935, 71935, 72384, 72440, 73728, 74648, 74752, 74862, 77824, 78894, 92160, 92728, 92736, 92766, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93952, 94020, 94032, 94032, 94099, 94111, 110592, 110593, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 124928, 125124, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 194560, 195101];
  var idContinueTable = [183, 183, 768, 879, 903, 903, 1155, 1159, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1552, 1562, 1611, 1631, 1632, 1641, 1648, 1648, 1750, 1756, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1809, 1809, 1840, 1866, 1958, 1968, 1984, 1993, 2027, 2035, 2070, 2073, 2075, 2083, 2085, 2087, 2089, 2093, 2137, 2139, 2276, 2306, 2307, 2307, 2362, 2362, 2363, 2363, 2364, 2364, 2366, 2368, 2369, 2376, 2377, 2380, 2381, 2381, 2382, 2383, 2385, 2391, 2402, 2403, 2406, 2415, 2433, 2433, 2434, 2435, 2492, 2492, 2494, 2496, 2497, 2500, 2503, 2504, 2507, 2508, 2509, 2509, 2519, 2519, 2530, 2531, 2534, 2543, 2561, 2562, 2563, 2563, 2620, 2620, 2622, 2624, 2625, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2662, 2671, 2672, 2673, 2677, 2677, 2689, 2690, 2691, 2691, 2748, 2748, 2750, 2752, 2753, 2757, 2759, 2760, 2761, 2761, 2763, 2764, 2765, 2765, 2786, 2787, 2790, 2799, 2817, 2817, 2818, 2819, 2876, 2876, 2878, 2878, 2879, 2879, 2880, 2880, 2881, 2884, 2887, 2888, 2891, 2892, 2893, 2893, 2902, 2902, 2903, 2903, 2914, 2915, 2918, 2927, 2946, 2946, 3006, 3007, 3008, 3008, 3009, 3010, 3014, 3016, 3018, 3020, 3021, 3021, 3031, 3031, 3046, 3055, 3072, 3072, 3073, 3075, 3134, 3136, 3137, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3201, 3201, 3202, 3203, 3260, 3260, 3262, 3262, 3263, 3263, 3264, 3268, 3270, 3270, 3271, 3272, 3274, 3275, 3276, 3277, 3285, 3286, 3298, 3299, 3302, 3311, 3329, 3329, 3330, 3331, 3390, 3392, 3393, 3396, 3398, 3400, 3402, 3404, 3405, 3405, 3415, 3415, 3426, 3427, 3430, 3439, 3458, 3459, 3530, 3530, 3535, 3537, 3538, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3633, 3633, 3636, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3764, 3769, 3771, 3772, 3784, 3789, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3903, 3953, 3966, 3967, 3967, 3968, 3972, 3974, 3975, 3981, 3991, 3993, 4028, 4038, 4038, 4139, 4140, 4141, 4144, 4145, 4145, 4146, 4151, 4152, 4152, 4153, 4154, 4155, 4156, 4157, 4158, 4160, 4169, 4182, 4183, 4184, 4185, 4190, 4192, 4194, 4196, 4199, 4205, 4209, 4212, 4226, 4226, 4227, 4228, 4229, 4230, 4231, 4236, 4237, 4237, 4239, 4239, 4240, 4249, 4250, 4252, 4253, 4253, 4957, 4959, 4969, 4977, 5906, 5908, 5938, 5940, 5970, 5971, 6002, 6003, 6068, 6069, 6070, 6070, 6071, 6077, 6078, 6085, 6086, 6086, 6087, 6088, 6089, 6099, 6109, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6313, 6313, 6432, 6434, 6435, 6438, 6439, 6440, 6441, 6443, 6448, 6449, 6450, 6450, 6451, 6456, 6457, 6459, 6470, 6479, 6576, 6592, 6600, 6601, 6608, 6617, 6618, 6618, 6679, 6680, 6681, 6682, 6683, 6683, 6741, 6741, 6742, 6742, 6743, 6743, 6744, 6750, 6752, 6752, 6753, 6753, 6754, 6754, 6755, 6756, 6757, 6764, 6765, 6770, 6771, 6780, 6783, 6783, 6784, 6793, 6800, 6809, 6832, 6845, 6912, 6915, 6916, 6916, 6964, 6964, 6965, 6965, 6966, 6970, 6971, 6971, 6972, 6972, 6973, 6977, 6978, 6978, 6979, 6980, 6992, 7001, 7019, 7027, 7040, 7041, 7042, 7042, 7073, 7073, 7074, 7077, 7078, 7079, 7080, 7081, 7082, 7082, 7083, 7085, 7088, 7097, 7142, 7142, 7143, 7143, 7144, 7145, 7146, 7148, 7149, 7149, 7150, 7150, 7151, 7153, 7154, 7155, 7204, 7211, 7212, 7219, 7220, 7221, 7222, 7223, 7232, 7241, 7248, 7257, 7376, 7378, 7380, 7392, 7393, 7393, 7394, 7400, 7405, 7405, 7410, 7411, 7412, 7412, 7416, 7417, 7616, 7669, 7676, 7679, 8255, 8256, 8276, 8276, 8400, 8412, 8417, 8417, 8421, 8432, 11503, 11505, 11647, 11647, 11744, 11775, 12330, 12333, 12334, 12335, 12441, 12442, 42528, 42537, 42607, 42607, 42612, 42621, 42655, 42655, 42736, 42737, 43010, 43010, 43014, 43014, 43019, 43019, 43043, 43044, 43045, 43046, 43047, 43047, 43136, 43137, 43188, 43203, 43204, 43204, 43216, 43225, 43232, 43249, 43264, 43273, 43302, 43309, 43335, 43345, 43346, 43347, 43392, 43394, 43395, 43395, 43443, 43443, 43444, 43445, 43446, 43449, 43450, 43451, 43452, 43452, 43453, 43456, 43472, 43481, 43493, 43493, 43504, 43513, 43561, 43566, 43567, 43568, 43569, 43570, 43571, 43572, 43573, 43574, 43587, 43587, 43596, 43596, 43597, 43597, 43600, 43609, 43643, 43643, 43644, 43644, 43645, 43645, 43696, 43696, 43698, 43700, 43703, 43704, 43710, 43711, 43713, 43713, 43755, 43755, 43756, 43757, 43758, 43759, 43765, 43765, 43766, 43766, 44003, 44004, 44005, 44005, 44006, 44007, 44008, 44008, 44009, 44010, 44012, 44012, 44013, 44013, 44016, 44025, 64286, 64286, 65024, 65039, 65056, 65069, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343, 66045, 66045, 66272, 66272, 66422, 66426, 66720, 66729, 68097, 68099, 68101, 68102, 68108, 68111, 68152, 68154, 68159, 68159, 68325, 68326, 69632, 69632, 69633, 69633, 69634, 69634, 69688, 69702, 69734, 69743, 69759, 69761, 69762, 69762, 69808, 69810, 69811, 69814, 69815, 69816, 69817, 69818, 69872, 69881, 69888, 69890, 69927, 69931, 69932, 69932, 69933, 69940, 69942, 69951, 70003, 70003, 70016, 70017, 70018, 70018, 70067, 70069, 70070, 70078, 70079, 70080, 70096, 70105, 70188, 70190, 70191, 70193, 70194, 70195, 70196, 70196, 70197, 70197, 70198, 70199, 70367, 70367, 70368, 70370, 70371, 70378, 70384, 70393, 70401, 70401, 70402, 70403, 70460, 70460, 70462, 70463, 70464, 70464, 70465, 70468, 70471, 70472, 70475, 70477, 70487, 70487, 70498, 70499, 70502, 70508, 70512, 70516, 70832, 70834, 70835, 70840, 70841, 70841, 70842, 70842, 70843, 70846, 70847, 70848, 70849, 70849, 70850, 70851, 70864, 70873, 71087, 71089, 71090, 71093, 71096, 71099, 71100, 71101, 71102, 71102, 71103, 71104, 71216, 71218, 71219, 71226, 71227, 71228, 71229, 71229, 71230, 71230, 71231, 71232, 71248, 71257, 71339, 71339, 71340, 71340, 71341, 71341, 71342, 71343, 71344, 71349, 71350, 71350, 71351, 71351, 71360, 71369, 71904, 71913, 92768, 92777, 92912, 92916, 92976, 92982, 93008, 93017, 94033, 94078, 94095, 94098, 113821, 113822, 119141, 119142, 119143, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 120782, 120831, 125136, 125142, 917760, 917999];
  return {
    get idStartTable() {
      return idStartTable;
    },
    get idContinueTable() {
      return idContinueTable;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/Scanner.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/Scanner.js";
  var IdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./IdentifierToken.js", "traceur@0.0.112/src/syntax/Scanner.js")).IdentifierToken;
  var JsxIdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./JsxIdentifierToken.js", "traceur@0.0.112/src/syntax/Scanner.js")).JsxIdentifierToken;
  var KeywordToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./KeywordToken.js", "traceur@0.0.112/src/syntax/Scanner.js")).KeywordToken;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./LiteralToken.js", "traceur@0.0.112/src/syntax/Scanner.js")).LiteralToken;
  var SourceRange = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/SourceRange.js", "traceur@0.0.112/src/syntax/Scanner.js")).SourceRange;
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Token.js", "traceur@0.0.112/src/syntax/Scanner.js")).Token;
  var getKeywordType = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Keywords.js", "traceur@0.0.112/src/syntax/Scanner.js")).getKeywordType;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./unicode-tables.js", "traceur@0.0.112/src/syntax/Scanner.js")),
      idContinueTable = $__10.idContinueTable,
      idStartTable = $__10.idStartTable;
  var $__11 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TokenType.js", "traceur@0.0.112/src/syntax/Scanner.js")),
      AMPERSAND = $__11.AMPERSAND,
      AMPERSAND_EQUAL = $__11.AMPERSAND_EQUAL,
      AND = $__11.AND,
      ARROW = $__11.ARROW,
      AT = $__11.AT,
      BANG = $__11.BANG,
      BAR = $__11.BAR,
      BAR_EQUAL = $__11.BAR_EQUAL,
      CARET = $__11.CARET,
      CARET_EQUAL = $__11.CARET_EQUAL,
      CLOSE_ANGLE = $__11.CLOSE_ANGLE,
      CLOSE_CURLY = $__11.CLOSE_CURLY,
      CLOSE_PAREN = $__11.CLOSE_PAREN,
      CLOSE_SQUARE = $__11.CLOSE_SQUARE,
      COLON = $__11.COLON,
      COMMA = $__11.COMMA,
      DOT_DOT_DOT = $__11.DOT_DOT_DOT,
      END_OF_FILE = $__11.END_OF_FILE,
      EQUAL = $__11.EQUAL,
      EQUAL_EQUAL = $__11.EQUAL_EQUAL,
      EQUAL_EQUAL_EQUAL = $__11.EQUAL_EQUAL_EQUAL,
      ERROR = $__11.ERROR,
      GREATER_EQUAL = $__11.GREATER_EQUAL,
      LEFT_SHIFT = $__11.LEFT_SHIFT,
      LEFT_SHIFT_EQUAL = $__11.LEFT_SHIFT_EQUAL,
      LESS_EQUAL = $__11.LESS_EQUAL,
      MINUS = $__11.MINUS,
      MINUS_EQUAL = $__11.MINUS_EQUAL,
      MINUS_MINUS = $__11.MINUS_MINUS,
      NO_SUBSTITUTION_TEMPLATE = $__11.NO_SUBSTITUTION_TEMPLATE,
      NOT_EQUAL = $__11.NOT_EQUAL,
      NOT_EQUAL_EQUAL = $__11.NOT_EQUAL_EQUAL,
      NUMBER = $__11.NUMBER,
      OPEN_ANGLE = $__11.OPEN_ANGLE,
      OPEN_CURLY = $__11.OPEN_CURLY,
      OPEN_PAREN = $__11.OPEN_PAREN,
      OPEN_SQUARE = $__11.OPEN_SQUARE,
      OR = $__11.OR,
      PERCENT = $__11.PERCENT,
      PERCENT_EQUAL = $__11.PERCENT_EQUAL,
      PERIOD = $__11.PERIOD,
      PLUS = $__11.PLUS,
      PLUS_EQUAL = $__11.PLUS_EQUAL,
      PLUS_PLUS = $__11.PLUS_PLUS,
      QUESTION = $__11.QUESTION,
      REGULAR_EXPRESSION = $__11.REGULAR_EXPRESSION,
      RIGHT_SHIFT = $__11.RIGHT_SHIFT,
      RIGHT_SHIFT_EQUAL = $__11.RIGHT_SHIFT_EQUAL,
      SEMI_COLON = $__11.SEMI_COLON,
      SLASH = $__11.SLASH,
      SLASH_EQUAL = $__11.SLASH_EQUAL,
      STAR = $__11.STAR,
      STAR_EQUAL = $__11.STAR_EQUAL,
      STAR_STAR = $__11.STAR_STAR,
      STAR_STAR_EQUAL = $__11.STAR_STAR_EQUAL,
      STRING = $__11.STRING,
      TEMPLATE_HEAD = $__11.TEMPLATE_HEAD,
      TEMPLATE_MIDDLE = $__11.TEMPLATE_MIDDLE,
      TEMPLATE_TAIL = $__11.TEMPLATE_TAIL,
      TILDE = $__11.TILDE,
      UNSIGNED_RIGHT_SHIFT = $__11.UNSIGNED_RIGHT_SHIFT,
      UNSIGNED_RIGHT_SHIFT_EQUAL = $__11.UNSIGNED_RIGHT_SHIFT_EQUAL;
  var isWhitespaceArray = [];
  for (var i = 0; i < 128; i++) {
    isWhitespaceArray[i] = i >= 9 && i <= 13 || i === 0x20;
  }
  function isWhitespace(code) {
    if (code < 128)
      return isWhitespaceArray[code];
    switch (code) {
      case 0xA0:
      case 0xFEFF:
      case 0x2028:
      case 0x2029:
        return true;
    }
    return false;
  }
  function isLineTerminator(code) {
    switch (code) {
      case 10:
      case 13:
      case 0x2028:
      case 0x2029:
        return true;
    }
    return false;
  }
  function isDecimalDigit(code) {
    return code >= 48 && code <= 57;
  }
  var isHexDigitArray = [];
  for (var i$__0 = 0; i$__0 < 128; i$__0++) {
    isHexDigitArray[i$__0] = i$__0 >= 48 && i$__0 <= 57 || i$__0 >= 65 && i$__0 <= 70 || i$__0 >= 97 && i$__0 <= 102;
  }
  function isHexDigit(code) {
    return code < 128 && isHexDigitArray[code];
  }
  function isBinaryDigit(code) {
    return code === 48 || code === 49;
  }
  function isOctalDigit(code) {
    return code >= 48 && code <= 55;
  }
  var isIdentifierStartArray = [];
  for (var i$__1 = 0; i$__1 < 128; i$__1++) {
    isIdentifierStartArray[i$__1] = i$__1 === 36 || i$__1 >= 65 && i$__1 <= 90 || i$__1 === 95 || i$__1 >= 97 && i$__1 <= 122;
  }
  function isIdentifierStart(code) {
    return code < 128 ? isIdentifierStartArray[code] : inTable(idStartTable, code);
  }
  var isIdentifierPartArray = [];
  for (var i$__2 = 0; i$__2 < 128; i$__2++) {
    isIdentifierPartArray[i$__2] = isIdentifierStart(i$__2) || isDecimalDigit(i$__2);
  }
  function isIdentifierPart(code) {
    return code < 128 ? isIdentifierPartArray[code] : inTable(idStartTable, code) || inTable(idContinueTable, code) || code === 8204 || code === 8205;
  }
  function inTable(table, code) {
    for (var i = 0; i < table.length; ) {
      if (code < table[i++])
        return false;
      if (code <= table[i++])
        return true;
    }
    return false;
  }
  function isRegularExpressionChar(code) {
    switch (code) {
      case 47:
        return false;
      case 91:
      case 92:
        return true;
    }
    return !isLineTerminator(code);
  }
  function isRegularExpressionFirstChar(code) {
    return isRegularExpressionChar(code) && code !== 42;
  }
  var index,
      input,
      length,
      token,
      lastToken,
      lookaheadToken,
      currentCharCode,
      lineNumberTable,
      errorReporter,
      currentParser,
      options;
  function init(reporter, file, parser, traceurOptions) {
    errorReporter = reporter;
    lineNumberTable = file.lineNumberTable;
    input = file.contents;
    length = file.contents.length;
    setIndex(0);
    currentParser = parser;
    options = traceurOptions;
  }
  function getLastToken() {
    return lastToken;
  }
  function nextRegularExpressionLiteralToken() {
    lastToken = nextRegularExpressionLiteralToken2();
    token = scanToken();
    return lastToken;
  }
  function nextTemplateLiteralToken() {
    var t = nextTemplateLiteralToken2();
    token = scanToken();
    return t;
  }
  function setIndex(i) {
    index = i;
    lastToken = null;
    token = null;
    lookaheadToken = null;
    updateCurrentCharCode();
  }
  function getPosition() {
    return getPositionByOffset(getOffset());
  }
  function getPositionByOffset(offset) {
    return lineNumberTable.getSourcePosition(offset);
  }
  function nextCloseAngle() {
    switch (token.type) {
      case GREATER_EQUAL:
      case RIGHT_SHIFT:
      case RIGHT_SHIFT_EQUAL:
      case UNSIGNED_RIGHT_SHIFT:
      case UNSIGNED_RIGHT_SHIFT_EQUAL:
        setIndex(index - token.type.length + 1);
        lastToken = createToken(CLOSE_ANGLE, index);
        token = scanToken();
        return lastToken;
    }
    return nextToken();
  }
  function getTokenRange(startOffset) {
    return lineNumberTable.getSourceRange(startOffset, index);
  }
  function getOffset() {
    return token ? token.location.start.offset : index;
  }
  function nextRegularExpressionLiteralToken2() {
    var beginIndex = index - token.toString().length;
    if (token.type === SLASH_EQUAL) {
      skipRegularExpressionBodyContinuation();
    } else {
      skipRegularExpressionBody(beginIndex);
    }
    if (currentCharCode !== 47) {
      reportError('Expected \'/\' in regular expression literal', beginIndex);
      return new LiteralToken(REGULAR_EXPRESSION, getTokenString(beginIndex), getTokenRange(beginIndex));
    }
    next();
    while (isIdentifierPart(currentCharCode)) {
      next();
    }
    return new LiteralToken(REGULAR_EXPRESSION, getTokenString(beginIndex), getTokenRange(beginIndex));
  }
  function skipRegularExpressionBody(beginIndex) {
    if (!isRegularExpressionFirstChar(currentCharCode)) {
      reportError('Expected regular expression first char', beginIndex);
      return;
    }
    skipRegularExpressionBodyContinuation();
  }
  function skipRegularExpressionBodyContinuation() {
    while (!isAtEnd() && isRegularExpressionChar(currentCharCode)) {
      if (!skipRegularExpressionChar()) {
        return;
      }
    }
  }
  function skipRegularExpressionChar() {
    switch (currentCharCode) {
      case 92:
        return skipRegularExpressionBackslashSequence();
      case 91:
        return skipRegularExpressionClass();
      default:
        next();
        return true;
    }
  }
  function skipRegularExpressionBackslashSequence() {
    var beginIndex = index;
    next();
    if (isLineTerminator(currentCharCode) || isAtEnd()) {
      reportError('New line not allowed in regular expression literal', beginIndex, index);
      return false;
    }
    next();
    return true;
  }
  function skipRegularExpressionClass() {
    var beginIndex = index;
    next();
    while (!isAtEnd() && peekRegularExpressionClassChar()) {
      if (!skipRegularExpressionClassChar()) {
        return false;
      }
    }
    if (currentCharCode !== 93) {
      reportError('\']\' expected', beginIndex, index);
      return false;
    }
    next();
    return true;
  }
  function peekRegularExpressionClassChar() {
    return currentCharCode !== 93 && !isLineTerminator(currentCharCode);
  }
  function skipRegularExpressionClassChar() {
    if (currentCharCode === 92) {
      return skipRegularExpressionBackslashSequence();
    }
    next();
    return true;
  }
  function skipTemplateCharacter() {
    while (!isAtEnd()) {
      switch (currentCharCode) {
        case 96:
          return;
        case 92:
          skipStringLiteralEscapeSequence();
          break;
        case 36:
          {
            var code = input.charCodeAt(index + 1);
            if (code === 123)
              return;
            next();
            break;
          }
        default:
          next();
      }
    }
  }
  function scanTemplateStart(beginIndex) {
    if (isAtEnd()) {
      reportError('Unterminated template literal', beginIndex, index);
      return lastToken = createToken(END_OF_FILE, beginIndex);
    }
    return nextTemplateLiteralTokenShared(NO_SUBSTITUTION_TEMPLATE, TEMPLATE_HEAD);
  }
  function nextTemplateLiteralToken2() {
    if (isAtEnd()) {
      reportError('Expected \'}\' after expression in template literal', index, index);
      return createToken(END_OF_FILE, index);
    }
    if (token.type !== CLOSE_CURLY) {
      reportError('Expected \'}\' after expression in template literal', index, index);
      return createToken(ERROR, index);
    }
    return nextTemplateLiteralTokenShared(TEMPLATE_TAIL, TEMPLATE_MIDDLE);
  }
  function nextTemplateLiteralTokenShared(endType, middleType) {
    var beginIndex = index;
    skipTemplateCharacter();
    if (isAtEnd()) {
      reportError('Unterminated template literal');
      return createToken(ERROR, beginIndex);
    }
    var value = getTokenString(beginIndex);
    switch (currentCharCode) {
      case 96:
        next();
        return lastToken = new LiteralToken(endType, value, getTokenRange(beginIndex - 1));
      case 36:
        next();
        next();
        return lastToken = new LiteralToken(middleType, value, getTokenRange(beginIndex - 1));
    }
  }
  function peekJsxToken() {
    return token || (token = scanJsxToken());
  }
  function nextJsxToken() {
    lastToken = peekJsxToken();
    token = null;
    return lastToken;
  }
  function scanJsxToken() {
    skipComments();
    var beginIndex = index;
    switch (currentCharCode) {
      case 34:
      case 39:
        return scanJsxStringLiteral(beginIndex, currentCharCode);
      case 62:
        next();
        return createToken(CLOSE_ANGLE, beginIndex);
    }
    if (!isIdentifierStart(currentCharCode)) {
      return scanToken();
    }
    next();
    while (isIdentifierPart(currentCharCode) || currentCharCode === 45) {
      next();
    }
    var value = input.slice(beginIndex, index);
    return new JsxIdentifierToken(getTokenRange(beginIndex), value);
  }
  function scanJsxStringLiteral(beginIndex, terminator) {
    next();
    while (!isAtEnd() && currentCharCode !== terminator) {
      next();
    }
    if (currentCharCode !== terminator) {
      reportError('Unterminated String Literal', beginIndex);
    } else {
      next();
    }
    return new LiteralToken(STRING, getTokenString(beginIndex), getTokenRange(beginIndex));
  }
  function nextJsxTextToken() {
    lastToken = token || scanJsxTextToken();
    token = null;
    return lastToken;
  }
  function skipJsxText() {
    while (!isAtEnd() && peekJsxText()) {
      next();
    }
  }
  function isJsxTextChar(code) {
    switch (code) {
      case 60:
      case 123:
        return false;
    }
    return true;
  }
  function skipJsxText() {
    while (!isAtEnd() && isJsxTextChar(currentCharCode)) {
      next();
    }
  }
  function scanJsxTextToken() {
    var beginIndex = index;
    if (isAtEnd()) {
      return createToken(END_OF_FILE, beginIndex);
    }
    skipJsxText();
    if (beginIndex === index) {
      switch (currentCharCode) {
        case 60:
          next();
          return createToken(OPEN_ANGLE, beginIndex);
        case 123:
          next();
          return createToken(OPEN_CURLY, beginIndex);
      }
    }
    return new LiteralToken(STRING, getTokenString(beginIndex), getTokenRange(beginIndex));
  }
  function nextToken() {
    var t = peekToken();
    token = lookaheadToken || scanToken();
    lookaheadToken = null;
    lastToken = t;
    return t;
  }
  function peekTokenNoLineTerminator() {
    var t = peekToken();
    var start = lastToken.location.end.offset;
    var end = t.location.start.offset;
    for (var i = start; i < end; i++) {
      if (isLineTerminator(input.charCodeAt(i))) {
        return null;
      }
    }
    return t;
  }
  function peek(expectedType) {
    return peekToken().type === expectedType;
  }
  function peekLookahead(expectedType) {
    return peekTokenLookahead().type === expectedType;
  }
  function peekToken() {
    return token || (token = scanToken());
  }
  function peekType() {
    return peekToken().type;
  }
  function peekLocation() {
    return peekToken().location;
  }
  function peekTokenLookahead() {
    if (!token)
      token = scanToken();
    if (!lookaheadToken)
      lookaheadToken = scanToken();
    return lookaheadToken;
  }
  function skipWhitespace() {
    while (!isAtEnd() && peekWhitespace()) {
      next();
    }
  }
  function peekWhitespace() {
    return isWhitespace(currentCharCode);
  }
  function skipComments() {
    while (skipComment()) {}
  }
  function skipComment() {
    skipWhitespace();
    var code = currentCharCode;
    if (code === 47) {
      code = input.charCodeAt(index + 1);
      switch (code) {
        case 47:
          skipSingleLineComment();
          return true;
        case 42:
          skipMultiLineComment();
          return true;
      }
    }
    return false;
  }
  function commentCallback(start, index) {
    if (options.commentCallback)
      currentParser.handleComment(lineNumberTable.getSourceRange(start, index));
  }
  function skipSingleLineComment() {
    var start = index;
    index += 2;
    while (!isAtEnd() && !isLineTerminator(input.charCodeAt(index++))) {}
    updateCurrentCharCode();
    commentCallback(start, index);
  }
  function skipMultiLineComment() {
    var start = index;
    var i = input.indexOf('*/', index + 2);
    if (i !== -1)
      index = i + 2;
    else
      index = length;
    updateCurrentCharCode();
    commentCallback(start, index);
  }
  function scanToken() {
    skipComments();
    var beginIndex = index;
    if (isAtEnd())
      return createToken(END_OF_FILE, beginIndex);
    var code = currentCharCode;
    next();
    switch (code) {
      case 123:
        return createToken(OPEN_CURLY, beginIndex);
      case 125:
        return createToken(CLOSE_CURLY, beginIndex);
      case 40:
        return createToken(OPEN_PAREN, beginIndex);
      case 41:
        return createToken(CLOSE_PAREN, beginIndex);
      case 91:
        return createToken(OPEN_SQUARE, beginIndex);
      case 93:
        return createToken(CLOSE_SQUARE, beginIndex);
      case 46:
        switch (currentCharCode) {
          case 46:
            if (input.charCodeAt(index + 1) === 46) {
              next();
              next();
              return createToken(DOT_DOT_DOT, beginIndex);
            }
            break;
          default:
            if (isDecimalDigit(currentCharCode))
              return scanNumberPostPeriod(beginIndex);
        }
        return createToken(PERIOD, beginIndex);
      case 59:
        return createToken(SEMI_COLON, beginIndex);
      case 44:
        return createToken(COMMA, beginIndex);
      case 126:
        return createToken(TILDE, beginIndex);
      case 63:
        return createToken(QUESTION, beginIndex);
      case 58:
        return createToken(COLON, beginIndex);
      case 60:
        switch (currentCharCode) {
          case 60:
            next();
            if (currentCharCode === 61) {
              next();
              return createToken(LEFT_SHIFT_EQUAL, beginIndex);
            }
            return createToken(LEFT_SHIFT, beginIndex);
          case 61:
            next();
            return createToken(LESS_EQUAL, beginIndex);
          default:
            return createToken(OPEN_ANGLE, beginIndex);
        }
      case 62:
        switch (currentCharCode) {
          case 62:
            next();
            switch (currentCharCode) {
              case 61:
                next();
                return createToken(RIGHT_SHIFT_EQUAL, beginIndex);
              case 62:
                next();
                if (currentCharCode === 61) {
                  next();
                  return createToken(UNSIGNED_RIGHT_SHIFT_EQUAL, beginIndex);
                }
                return createToken(UNSIGNED_RIGHT_SHIFT, beginIndex);
              default:
                return createToken(RIGHT_SHIFT, beginIndex);
            }
          case 61:
            next();
            return createToken(GREATER_EQUAL, beginIndex);
          default:
            return createToken(CLOSE_ANGLE, beginIndex);
        }
      case 61:
        if (currentCharCode === 61) {
          next();
          if (currentCharCode === 61) {
            next();
            return createToken(EQUAL_EQUAL_EQUAL, beginIndex);
          }
          return createToken(EQUAL_EQUAL, beginIndex);
        }
        if (currentCharCode === 62 && options.arrowFunctions) {
          next();
          return createToken(ARROW, beginIndex);
        }
        return createToken(EQUAL, beginIndex);
      case 33:
        if (currentCharCode === 61) {
          next();
          if (currentCharCode === 61) {
            next();
            return createToken(NOT_EQUAL_EQUAL, beginIndex);
          }
          return createToken(NOT_EQUAL, beginIndex);
        }
        return createToken(BANG, beginIndex);
      case 42:
        if (currentCharCode === 61) {
          next();
          return createToken(STAR_EQUAL, beginIndex);
        }
        if (currentCharCode === 42 && options.exponentiation) {
          next();
          if (currentCharCode === 61) {
            next();
            return createToken(STAR_STAR_EQUAL, beginIndex);
          }
          return createToken(STAR_STAR, beginIndex);
        }
        return createToken(STAR, beginIndex);
      case 37:
        if (currentCharCode === 61) {
          next();
          return createToken(PERCENT_EQUAL, beginIndex);
        }
        return createToken(PERCENT, beginIndex);
      case 94:
        if (currentCharCode === 61) {
          next();
          return createToken(CARET_EQUAL, beginIndex);
        }
        return createToken(CARET, beginIndex);
      case 47:
        if (currentCharCode === 61) {
          next();
          return createToken(SLASH_EQUAL, beginIndex);
        }
        return createToken(SLASH, beginIndex);
      case 43:
        switch (currentCharCode) {
          case 43:
            next();
            return createToken(PLUS_PLUS, beginIndex);
          case 61:
            next();
            return createToken(PLUS_EQUAL, beginIndex);
          default:
            return createToken(PLUS, beginIndex);
        }
      case 45:
        switch (currentCharCode) {
          case 45:
            next();
            return createToken(MINUS_MINUS, beginIndex);
          case 61:
            next();
            return createToken(MINUS_EQUAL, beginIndex);
          default:
            return createToken(MINUS, beginIndex);
        }
      case 38:
        switch (currentCharCode) {
          case 38:
            next();
            return createToken(AND, beginIndex);
          case 61:
            next();
            return createToken(AMPERSAND_EQUAL, beginIndex);
          default:
            return createToken(AMPERSAND, beginIndex);
        }
      case 124:
        switch (currentCharCode) {
          case 124:
            next();
            return createToken(OR, beginIndex);
          case 61:
            next();
            return createToken(BAR_EQUAL, beginIndex);
          default:
            return createToken(BAR, beginIndex);
        }
      case 96:
        return scanTemplateStart(beginIndex);
      case 64:
        return createToken(AT, beginIndex);
      case 48:
        return scanPostZero(beginIndex);
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
        return scanPostDigit(beginIndex);
      case 34:
      case 39:
        return scanStringLiteral(beginIndex, code);
      default:
        return scanIdentifierOrKeyword(beginIndex, code);
    }
  }
  function scanNumberPostPeriod(beginIndex) {
    skipDecimalDigits();
    return scanExponentOfNumericLiteral(beginIndex);
  }
  function scanPostDigit(beginIndex) {
    skipDecimalDigits();
    return scanFractionalNumericLiteral(beginIndex);
  }
  function scanPostZero(beginIndex) {
    switch (currentCharCode) {
      case 46:
        return scanFractionalNumericLiteral(beginIndex);
      case 88:
      case 120:
        next();
        if (!isHexDigit(currentCharCode)) {
          reportError('Hex Integer Literal must contain at least one digit', beginIndex);
        }
        skipHexDigits();
        return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex));
      case 66:
      case 98:
        if (!options.numericLiterals)
          break;
        next();
        if (!isBinaryDigit(currentCharCode)) {
          reportError('Binary Integer Literal must contain at least one digit', beginIndex);
        }
        skipBinaryDigits();
        return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex));
      case 79:
      case 111:
        if (!options.numericLiterals)
          break;
        next();
        if (!isOctalDigit(currentCharCode)) {
          reportError('Octal Integer Literal must contain at least one digit', beginIndex);
        }
        skipOctalDigits();
        return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex));
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
        return scanPostDigit(beginIndex);
    }
    return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex));
  }
  function createToken(type, beginIndex) {
    return new Token(type, getTokenRange(beginIndex));
  }
  function readUnicodeEscapeSequence() {
    var beginIndex = index;
    if (currentCharCode === 117) {
      next();
      if (skipHexDigit() && skipHexDigit() && skipHexDigit() && skipHexDigit()) {
        return parseInt(getTokenString(beginIndex + 1), 16);
      }
    }
    reportError('Invalid unicode escape sequence in identifier', beginIndex - 1);
    return 0;
  }
  function scanIdentifierOrKeyword(beginIndex, code) {
    var escapedCharCodes;
    if (code === 92) {
      code = readUnicodeEscapeSequence();
      escapedCharCodes = [code];
    }
    if (!isIdentifierStart(code)) {
      reportError(("Character code '" + code + "' is not a valid identifier start char"), beginIndex);
      return createToken(ERROR, beginIndex);
    }
    for (; ; ) {
      code = currentCharCode;
      if (isIdentifierPart(code)) {
        next();
      } else if (code === 92) {
        next();
        code = readUnicodeEscapeSequence();
        if (!escapedCharCodes)
          escapedCharCodes = [];
        escapedCharCodes.push(code);
        if (!isIdentifierPart(code))
          return createToken(ERROR, beginIndex);
      } else {
        break;
      }
    }
    var value = input.slice(beginIndex, index);
    var keywordType = getKeywordType(value);
    if (keywordType)
      return new KeywordToken(value, keywordType, getTokenRange(beginIndex));
    if (escapedCharCodes) {
      var i = 0;
      value = value.replace(/\\u..../g, function(s) {
        return String.fromCharCode(escapedCharCodes[i++]);
      });
    }
    return new IdentifierToken(getTokenRange(beginIndex), value);
  }
  function scanStringLiteral(beginIndex, terminator) {
    while (peekStringLiteralChar(terminator)) {
      if (!skipStringLiteralChar()) {
        return new LiteralToken(STRING, getTokenString(beginIndex), getTokenRange(beginIndex));
      }
    }
    if (currentCharCode !== terminator) {
      reportError('Unterminated String Literal', beginIndex);
    } else {
      next();
    }
    return new LiteralToken(STRING, getTokenString(beginIndex), getTokenRange(beginIndex));
  }
  function getTokenString(beginIndex) {
    return input.substring(beginIndex, index);
  }
  function peekStringLiteralChar(terminator) {
    return !isAtEnd() && currentCharCode !== terminator && !isLineTerminator(currentCharCode);
  }
  function skipStringLiteralChar() {
    if (currentCharCode === 92) {
      return skipStringLiteralEscapeSequence();
    }
    next();
    return true;
  }
  function skipStringLiteralEscapeSequence() {
    next();
    if (isAtEnd()) {
      reportError('Unterminated string literal escape sequence');
      return false;
    }
    if (isLineTerminator(currentCharCode)) {
      skipLineTerminator();
      return true;
    }
    var code = currentCharCode;
    next();
    switch (code) {
      case 39:
      case 34:
      case 92:
      case 98:
      case 102:
      case 110:
      case 114:
      case 116:
      case 118:
      case 48:
        return true;
      case 120:
        return skipHexDigit() && skipHexDigit();
      case 117:
        return skipUnicodeEscapeSequence();
      default:
        return true;
    }
  }
  function skipUnicodeEscapeSequence() {
    if (currentCharCode === 123 && options.unicodeEscapeSequences) {
      next();
      var beginIndex = index;
      if (!isHexDigit(currentCharCode)) {
        reportError('Hex digit expected', beginIndex);
        return false;
      }
      skipHexDigits();
      if (currentCharCode !== 125) {
        reportError('Hex digit expected', beginIndex);
        return false;
      }
      var codePoint = getTokenString(beginIndex, index);
      if (parseInt(codePoint, 16) > 0x10FFFF) {
        reportError('The code point in a Unicode escape sequence cannot exceed 10FFFF', beginIndex);
        return false;
      }
      next();
      return true;
    }
    return skipHexDigit() && skipHexDigit() && skipHexDigit() && skipHexDigit();
  }
  function skipHexDigit() {
    if (!isHexDigit(currentCharCode)) {
      reportError('Hex digit expected');
      return false;
    }
    next();
    return true;
  }
  function skipLineTerminator() {
    var first = currentCharCode;
    next();
    if (first === 13 && currentCharCode === 10) {
      next();
    }
  }
  function scanFractionalNumericLiteral(beginIndex) {
    if (currentCharCode === 46) {
      next();
      skipDecimalDigits();
    }
    return scanExponentOfNumericLiteral(beginIndex);
  }
  function scanExponentOfNumericLiteral(beginIndex) {
    switch (currentCharCode) {
      case 101:
      case 69:
        next();
        switch (currentCharCode) {
          case 43:
          case 45:
            next();
            break;
        }
        if (!isDecimalDigit(currentCharCode)) {
          reportError('Exponent part must contain at least one digit', beginIndex);
        }
        skipDecimalDigits();
        break;
      default:
        break;
    }
    return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex));
  }
  function skipDecimalDigits() {
    while (isDecimalDigit(currentCharCode)) {
      next();
    }
  }
  function skipHexDigits() {
    while (isHexDigit(currentCharCode)) {
      next();
    }
  }
  function skipBinaryDigits() {
    while (isBinaryDigit(currentCharCode)) {
      next();
    }
  }
  function skipOctalDigits() {
    while (isOctalDigit(currentCharCode)) {
      next();
    }
  }
  function isAtEnd() {
    return index === length;
  }
  function next() {
    index++;
    updateCurrentCharCode();
  }
  function updateCurrentCharCode() {
    currentCharCode = input.charCodeAt(index);
  }
  function reportError(message) {
    var startIndex = arguments[1] !== (void 0) ? arguments[1] : index;
    var endIndex = arguments[2] !== (void 0) ? arguments[2] : index;
    var start = getPositionByOffset(startIndex);
    var end = getPositionByOffset(endIndex);
    var location = new SourceRange(start, end);
    errorReporter.reportError(location, message);
  }
  return {
    get isWhitespace() {
      return isWhitespace;
    },
    get isLineTerminator() {
      return isLineTerminator;
    },
    get isIdentifierPart() {
      return isIdentifierPart;
    },
    get init() {
      return init;
    },
    get getLastToken() {
      return getLastToken;
    },
    get nextRegularExpressionLiteralToken() {
      return nextRegularExpressionLiteralToken;
    },
    get nextTemplateLiteralToken() {
      return nextTemplateLiteralToken;
    },
    get setIndex() {
      return setIndex;
    },
    get getPosition() {
      return getPosition;
    },
    get nextCloseAngle() {
      return nextCloseAngle;
    },
    get peekJsxToken() {
      return peekJsxToken;
    },
    get nextJsxToken() {
      return nextJsxToken;
    },
    get nextJsxTextToken() {
      return nextJsxTextToken;
    },
    get nextToken() {
      return nextToken;
    },
    get peekTokenNoLineTerminator() {
      return peekTokenNoLineTerminator;
    },
    get peek() {
      return peek;
    },
    get peekLookahead() {
      return peekLookahead;
    },
    get peekToken() {
      return peekToken;
    },
    get peekType() {
      return peekType;
    },
    get peekLocation() {
      return peekLocation;
    },
    get peekTokenLookahead() {
      return peekTokenLookahead;
    },
    get isAtEnd() {
      return isAtEnd;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/ConstructorValidator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/ConstructorValidator.js";
  var SUPER_EXPRESSION = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/semantics/ConstructorValidator.js")).SUPER_EXPRESSION;
  var FindVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../codegeneration/FindVisitor.js", "traceur@0.0.112/src/semantics/ConstructorValidator.js")).FindVisitor;
  var ConstructorValidator = function($__super) {
    function ConstructorValidator(reporter) {
      $traceurRuntime.superConstructor(ConstructorValidator).call(this);
      this.reporter_ = reporter;
      this.hasError = false;
    }
    return ($traceurRuntime.createClass)(ConstructorValidator, {
      visitClassExpression: function(tree) {
        this.visitAny(tree.superClass);
      },
      visitClassDeclaration: function(tree) {
        this.visitAny(tree.superClass);
      },
      visitThisExpression: function(tree) {
        this.reportError_(tree.location, 'this');
      },
      visitCallExpression: function(tree) {
        if (tree.operand.type === SUPER_EXPRESSION) {
          this.visitAny(tree.args);
          this.found = true;
          return;
        }
        $traceurRuntime.superGet(this, ConstructorValidator.prototype, "visitCallExpression").call(this, tree);
      },
      visitSuperExpression: function(tree) {
        this.reportError_(tree.location, 'super property');
      },
      reportError_: function(location, kind) {
        this.reporter_.reportError(location, ("'" + kind + "' is not allowed before super()"));
        this.hasError = true;
        this.found = true;
      }
    }, {}, $__super);
  }(FindVisitor);
  function validateConstructor(tree, reporter) {
    var visitor = new ConstructorValidator(reporter);
    visitor.visitAny(tree);
    if (visitor.hasError)
      return false;
    if (visitor.found)
      return true;
    reporter.reportError(tree.location, 'Derived constructor must call super()');
    return false;
  }
  return {get validateConstructor() {
      return validateConstructor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/staticsemantics/validateParameters.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/staticsemantics/validateParameters.js";
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/staticsemantics/validateParameters.js")).ParseTreeVisitor;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/staticsemantics/validateParameters.js")).StringSet;
  var isStrictKeyword = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/Keywords.js", "traceur@0.0.112/src/staticsemantics/validateParameters.js")).isStrictKeyword;
  var ParameterValidationVisitor = function($__super) {
    function ParameterValidationVisitor(isStrict, reporter) {
      $traceurRuntime.superConstructor(ParameterValidationVisitor).call(this);
      this.reporter_ = reporter;
      this.names_ = new StringSet();
      this.errors_ = [];
      this.reportStrictKeywords_ = isStrict;
      this.reportDuplicates_ = isStrict;
    }
    return ($traceurRuntime.createClass)(ParameterValidationVisitor, {
      visitBindingIdentifier: function(tree) {
        var name = tree.identifierToken.toString();
        if (this.reportStrictKeywords_ && (isStrictKeyword(name) || name === 'eval' || name === 'arguments')) {
          this.reporter_.reportError(tree.location, (name + " is a reserved identifier"));
        }
        if (this.names_.has(name)) {
          this.maybeReportDuplicateError_(name, tree.location);
        }
        this.names_.add(name);
      },
      visitBindingElement: function(tree) {
        if (tree.initializer !== null) {
          this.reportEarlierErrors_();
        }
        this.visitAny(tree.binding);
      },
      visitRestParameter: function(tree) {
        this.reportEarlierErrors_();
        this.visitAny(tree.identifier);
      },
      visitFormalParameter: function(tree) {
        this.visitAny(tree.parameter);
      },
      visitArrayPattern: function(tree) {
        this.reportEarlierErrors_();
        $traceurRuntime.superGet(this, ParameterValidationVisitor.prototype, "visitArrayPattern").call(this, tree);
      },
      visitObjectPattern: function(tree) {
        this.reportEarlierErrors_();
        $traceurRuntime.superGet(this, ParameterValidationVisitor.prototype, "visitObjectPattern").call(this, tree);
      },
      reportDuplicateError_: function(name, location) {
        this.reporter_.reportError(location, ("Duplicate parameter name " + name));
      },
      maybeReportDuplicateError_: function(name, location) {
        if (this.reportDuplicates_) {
          this.reportDuplicateError_(name, location);
        } else {
          this.errors_.push(name, location);
        }
      },
      reportEarlierErrors_: function() {
        if (!this.reportDuplicates_) {
          this.reportDuplicates_ = true;
          for (var i = 0; i < this.errors_.length; i += 2) {
            var name = this.errors_[i];
            var location = this.errors_[i + 1];
            this.reportDuplicateError_(name, location);
          }
        }
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  var $__default = function(tree, isStrict, reporter) {
    new ParameterValidationVisitor(isStrict, reporter).visitAny(tree);
  };
  return {get default() {
      return $__default;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/staticsemantics/isValidSimpleAssignmentTarget.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/staticsemantics/isValidSimpleAssignmentTarget.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/staticsemantics/isValidSimpleAssignmentTarget.js")),
      IDENTIFIER_EXPRESSION = $__1.IDENTIFIER_EXPRESSION,
      MEMBER_EXPRESSION = $__1.MEMBER_EXPRESSION,
      MEMBER_LOOKUP_EXPRESSION = $__1.MEMBER_LOOKUP_EXPRESSION,
      PAREN_EXPRESSION = $__1.PAREN_EXPRESSION;
  function isValidSimpleAssignmentTarget(tree, isStrict) {
    switch (tree.type) {
      case IDENTIFIER_EXPRESSION:
        {
          if (!isStrict)
            return true;
          var value = tree.identifierToken.value;
          return value !== 'arguments' && value !== 'eval';
        }
      case PAREN_EXPRESSION:
        return isValidSimpleAssignmentTarget(tree.expression, isStrict);
      case MEMBER_EXPRESSION:
      case MEMBER_LOOKUP_EXPRESSION:
        return true;
      default:
        return false;
    }
  }
  return {get default() {
      return isValidSimpleAssignmentTarget;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/Parser.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/Parser.js";
  var FindVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../codegeneration/FindVisitor.js", "traceur@0.0.112/src/syntax/Parser.js")).FindVisitor;
  var IdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./IdentifierToken.js", "traceur@0.0.112/src/syntax/Parser.js")).IdentifierToken;
  var $__25 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./trees/ParseTreeType.js", "traceur@0.0.112/src/syntax/Parser.js")),
      ARRAY_LITERAL = $__25.ARRAY_LITERAL,
      BINDING_IDENTIFIER = $__25.BINDING_IDENTIFIER,
      CALL_EXPRESSION = $__25.CALL_EXPRESSION,
      COMPUTED_PROPERTY_NAME = $__25.COMPUTED_PROPERTY_NAME,
      COVER_FORMALS = $__25.COVER_FORMALS,
      FORMAL_PARAMETER_LIST = $__25.FORMAL_PARAMETER_LIST,
      IDENTIFIER_EXPRESSION = $__25.IDENTIFIER_EXPRESSION,
      LITERAL_PROPERTY_NAME = $__25.LITERAL_PROPERTY_NAME,
      OBJECT_LITERAL = $__25.OBJECT_LITERAL,
      REST_PARAMETER = $__25.REST_PARAMETER,
      SYNTAX_ERROR_TREE = $__25.SYNTAX_ERROR_TREE;
  var Options = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../Options.js", "traceur@0.0.112/src/syntax/Parser.js")).Options;
  var $__27 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PredefinedName.js", "traceur@0.0.112/src/syntax/Parser.js")),
      AS = $__27.AS,
      ASYNC = $__27.ASYNC,
      ASYNC_STAR = $__27.ASYNC_STAR,
      AWAIT = $__27.AWAIT,
      CONSTRUCTOR = $__27.CONSTRUCTOR,
      FROM = $__27.FROM,
      GET = $__27.GET,
      OF = $__27.OF,
      ON = $__27.ON,
      SET = $__27.SET,
      TYPE = $__27.TYPE;
  var SyntaxErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/SyntaxErrorReporter.js", "traceur@0.0.112/src/syntax/Parser.js")).SyntaxErrorReporter;
  var $__29 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Scanner.js", "traceur@0.0.112/src/syntax/Parser.js")),
      getLastToken = $__29.getLastToken,
      getPosition = $__29.getPosition,
      initScanner = $__29.init,
      isAtEnd = $__29.isAtEnd,
      nextCloseAngle = $__29.nextCloseAngle,
      nextJsxTextToken = $__29.nextJsxTextToken,
      nextJsxToken = $__29.nextJsxToken,
      nextRegularExpressionLiteralToken = $__29.nextRegularExpressionLiteralToken,
      nextTemplateLiteralToken = $__29.nextTemplateLiteralToken,
      nextToken = $__29.nextToken,
      peek = $__29.peek,
      peekJsxToken = $__29.peekJsxToken,
      peekLocation = $__29.peekLocation,
      peekLookahead = $__29.peekLookahead,
      peekToken = $__29.peekToken,
      peekTokenLookahead = $__29.peekTokenLookahead,
      peekTokenNoLineTerminator = $__29.peekTokenNoLineTerminator,
      peekType = $__29.peekType,
      resetScanner = $__29.setIndex;
  var SourceRange = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/SourceRange.js", "traceur@0.0.112/src/syntax/Parser.js")).SourceRange;
  var $__31 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Token.js", "traceur@0.0.112/src/syntax/Parser.js")),
      Token = $__31.Token,
      isAssignmentOperator = $__31.isAssignmentOperator;
  var getKeywordType = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Keywords.js", "traceur@0.0.112/src/syntax/Parser.js")).getKeywordType;
  var validateConstructor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/ConstructorValidator.js", "traceur@0.0.112/src/syntax/Parser.js")).validateConstructor;
  var validateParameters = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../staticsemantics/validateParameters.js", "traceur@0.0.112/src/syntax/Parser.js")).default;
  var isValidSimpleAssignmentTarget = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../staticsemantics/isValidSimpleAssignmentTarget.js", "traceur@0.0.112/src/syntax/Parser.js")).default;
  var $__36 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TokenType.js", "traceur@0.0.112/src/syntax/Parser.js")),
      AMPERSAND = $__36.AMPERSAND,
      AND = $__36.AND,
      ARROW = $__36.ARROW,
      AT = $__36.AT,
      BANG = $__36.BANG,
      BAR = $__36.BAR,
      BREAK = $__36.BREAK,
      CARET = $__36.CARET,
      CASE = $__36.CASE,
      CATCH = $__36.CATCH,
      CLASS = $__36.CLASS,
      CLOSE_ANGLE = $__36.CLOSE_ANGLE,
      CLOSE_CURLY = $__36.CLOSE_CURLY,
      CLOSE_PAREN = $__36.CLOSE_PAREN,
      CLOSE_SQUARE = $__36.CLOSE_SQUARE,
      COLON = $__36.COLON,
      COMMA = $__36.COMMA,
      CONST = $__36.CONST,
      CONTINUE = $__36.CONTINUE,
      DEBUGGER = $__36.DEBUGGER,
      DEFAULT = $__36.DEFAULT,
      DELETE = $__36.DELETE,
      DO = $__36.DO,
      DOT_DOT_DOT = $__36.DOT_DOT_DOT,
      ELSE = $__36.ELSE,
      END_OF_FILE = $__36.END_OF_FILE,
      EQUAL = $__36.EQUAL,
      EQUAL_EQUAL = $__36.EQUAL_EQUAL,
      EQUAL_EQUAL_EQUAL = $__36.EQUAL_EQUAL_EQUAL,
      ERROR = $__36.ERROR,
      EXPORT = $__36.EXPORT,
      EXTENDS = $__36.EXTENDS,
      FALSE = $__36.FALSE,
      FINALLY = $__36.FINALLY,
      FOR = $__36.FOR,
      FUNCTION = $__36.FUNCTION,
      GREATER_EQUAL = $__36.GREATER_EQUAL,
      IDENTIFIER = $__36.IDENTIFIER,
      IF = $__36.IF,
      IMPLEMENTS = $__36.IMPLEMENTS,
      IMPORT = $__36.IMPORT,
      IN = $__36.IN,
      INSTANCEOF = $__36.INSTANCEOF,
      INTERFACE = $__36.INTERFACE,
      JSX_IDENTIFIER = $__36.JSX_IDENTIFIER,
      LEFT_SHIFT = $__36.LEFT_SHIFT,
      LESS_EQUAL = $__36.LESS_EQUAL,
      LET = $__36.LET,
      MINUS = $__36.MINUS,
      MINUS_MINUS = $__36.MINUS_MINUS,
      NEW = $__36.NEW,
      NO_SUBSTITUTION_TEMPLATE = $__36.NO_SUBSTITUTION_TEMPLATE,
      NOT_EQUAL = $__36.NOT_EQUAL,
      NOT_EQUAL_EQUAL = $__36.NOT_EQUAL_EQUAL,
      NULL = $__36.NULL,
      NUMBER = $__36.NUMBER,
      OPEN_ANGLE = $__36.OPEN_ANGLE,
      OPEN_CURLY = $__36.OPEN_CURLY,
      OPEN_PAREN = $__36.OPEN_PAREN,
      OPEN_SQUARE = $__36.OPEN_SQUARE,
      OR = $__36.OR,
      PACKAGE = $__36.PACKAGE,
      PERCENT = $__36.PERCENT,
      PERIOD = $__36.PERIOD,
      PLUS = $__36.PLUS,
      PLUS_PLUS = $__36.PLUS_PLUS,
      PRIVATE = $__36.PRIVATE,
      PROTECTED = $__36.PROTECTED,
      PUBLIC = $__36.PUBLIC,
      QUESTION = $__36.QUESTION,
      RETURN = $__36.RETURN,
      RIGHT_SHIFT = $__36.RIGHT_SHIFT,
      SEMI_COLON = $__36.SEMI_COLON,
      SLASH = $__36.SLASH,
      SLASH_EQUAL = $__36.SLASH_EQUAL,
      STAR = $__36.STAR,
      STAR_STAR = $__36.STAR_STAR,
      STATIC = $__36.STATIC,
      STRING = $__36.STRING,
      SUPER = $__36.SUPER,
      SWITCH = $__36.SWITCH,
      TEMPLATE_HEAD = $__36.TEMPLATE_HEAD,
      TEMPLATE_TAIL = $__36.TEMPLATE_TAIL,
      THIS = $__36.THIS,
      THROW = $__36.THROW,
      TILDE = $__36.TILDE,
      TRUE = $__36.TRUE,
      TRY = $__36.TRY,
      TYPEOF = $__36.TYPEOF,
      UNSIGNED_RIGHT_SHIFT = $__36.UNSIGNED_RIGHT_SHIFT,
      VAR = $__36.VAR,
      VOID = $__36.VOID,
      WHILE = $__36.WHILE,
      WITH = $__36.WITH,
      YIELD = $__36.YIELD;
  var $__37 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./trees/ParseTrees.js", "traceur@0.0.112/src/syntax/Parser.js")),
      ArgumentList = $__37.ArgumentList,
      ArrayComprehension = $__37.ArrayComprehension,
      ArrayLiteral = $__37.ArrayLiteral,
      ArrayPattern = $__37.ArrayPattern,
      ArrayType = $__37.ArrayType,
      ArrowFunction = $__37.ArrowFunction,
      AssignmentElement = $__37.AssignmentElement,
      AwaitExpression = $__37.AwaitExpression,
      BinaryExpression = $__37.BinaryExpression,
      BindingElement = $__37.BindingElement,
      BindingIdentifier = $__37.BindingIdentifier,
      Block = $__37.Block,
      BreakStatement = $__37.BreakStatement,
      CallExpression = $__37.CallExpression,
      CallSignature = $__37.CallSignature,
      CaseClause = $__37.CaseClause,
      Catch = $__37.Catch,
      ClassDeclaration = $__37.ClassDeclaration,
      ClassExpression = $__37.ClassExpression,
      CommaExpression = $__37.CommaExpression,
      ComprehensionFor = $__37.ComprehensionFor,
      ComprehensionIf = $__37.ComprehensionIf,
      ComputedPropertyName = $__37.ComputedPropertyName,
      ConditionalExpression = $__37.ConditionalExpression,
      ConstructSignature = $__37.ConstructSignature,
      ConstructorType = $__37.ConstructorType,
      ContinueStatement = $__37.ContinueStatement,
      CoverFormals = $__37.CoverFormals,
      CoverInitializedName = $__37.CoverInitializedName,
      DebuggerStatement = $__37.DebuggerStatement,
      Annotation = $__37.Annotation,
      DefaultClause = $__37.DefaultClause,
      DoWhileStatement = $__37.DoWhileStatement,
      EmptyStatement = $__37.EmptyStatement,
      ExportDeclaration = $__37.ExportDeclaration,
      ExportDefault = $__37.ExportDefault,
      ExportSpecifier = $__37.ExportSpecifier,
      ExportSpecifierSet = $__37.ExportSpecifierSet,
      ExportStar = $__37.ExportStar,
      ExpressionStatement = $__37.ExpressionStatement,
      Finally = $__37.Finally,
      ForInStatement = $__37.ForInStatement,
      ForOfStatement = $__37.ForOfStatement,
      ForOnStatement = $__37.ForOnStatement,
      ForStatement = $__37.ForStatement,
      FormalParameter = $__37.FormalParameter,
      FormalParameterList = $__37.FormalParameterList,
      ForwardDefaultExport = $__37.ForwardDefaultExport,
      FunctionBody = $__37.FunctionBody,
      FunctionDeclaration = $__37.FunctionDeclaration,
      FunctionExpression = $__37.FunctionExpression,
      FunctionType = $__37.FunctionType,
      GeneratorComprehension = $__37.GeneratorComprehension,
      GetAccessor = $__37.GetAccessor,
      IdentifierExpression = $__37.IdentifierExpression,
      IfStatement = $__37.IfStatement,
      ImportClausePair = $__37.ImportClausePair,
      ImportDeclaration = $__37.ImportDeclaration,
      ImportSpecifier = $__37.ImportSpecifier,
      ImportSpecifierSet = $__37.ImportSpecifierSet,
      ImportedBinding = $__37.ImportedBinding,
      ImportTypeClause = $__37.ImportTypeClause,
      IndexSignature = $__37.IndexSignature,
      InterfaceDeclaration = $__37.InterfaceDeclaration,
      JsxAttribute = $__37.JsxAttribute,
      JsxElement = $__37.JsxElement,
      JsxElementName = $__37.JsxElementName,
      JsxPlaceholder = $__37.JsxPlaceholder,
      JsxSpreadAttribute = $__37.JsxSpreadAttribute,
      JsxText = $__37.JsxText,
      LabelledStatement = $__37.LabelledStatement,
      LiteralExpression = $__37.LiteralExpression,
      LiteralPropertyName = $__37.LiteralPropertyName,
      MemberExpression = $__37.MemberExpression,
      MemberLookupExpression = $__37.MemberLookupExpression,
      Method = $__37.Method,
      MethodSignature = $__37.MethodSignature,
      Module = $__37.Module,
      ModuleSpecifier = $__37.ModuleSpecifier,
      NameSpaceExport = $__37.NameSpaceExport,
      NameSpaceImport = $__37.NameSpaceImport,
      NamedExport = $__37.NamedExport,
      NewExpression = $__37.NewExpression,
      ObjectLiteral = $__37.ObjectLiteral,
      ObjectPattern = $__37.ObjectPattern,
      ObjectPatternField = $__37.ObjectPatternField,
      ObjectType = $__37.ObjectType,
      ParenExpression = $__37.ParenExpression,
      PostfixExpression = $__37.PostfixExpression,
      PredefinedType = $__37.PredefinedType,
      PropertyNameAssignment = $__37.PropertyNameAssignment,
      PropertyNameShorthand = $__37.PropertyNameShorthand,
      PropertySignature = $__37.PropertySignature,
      PropertyVariableDeclaration = $__37.PropertyVariableDeclaration,
      RestParameter = $__37.RestParameter,
      ReturnStatement = $__37.ReturnStatement,
      Script = $__37.Script,
      SetAccessor = $__37.SetAccessor,
      SpreadExpression = $__37.SpreadExpression,
      SpreadPatternElement = $__37.SpreadPatternElement,
      SuperExpression = $__37.SuperExpression,
      SwitchStatement = $__37.SwitchStatement,
      SyntaxErrorTree = $__37.SyntaxErrorTree,
      TemplateLiteralExpression = $__37.TemplateLiteralExpression,
      TemplateLiteralPortion = $__37.TemplateLiteralPortion,
      TemplateSubstitution = $__37.TemplateSubstitution,
      ThisExpression = $__37.ThisExpression,
      ThrowStatement = $__37.ThrowStatement,
      TryStatement = $__37.TryStatement,
      TypeAliasDeclaration = $__37.TypeAliasDeclaration,
      TypeArguments = $__37.TypeArguments,
      TypeName = $__37.TypeName,
      TypeParameter = $__37.TypeParameter,
      TypeParameters = $__37.TypeParameters,
      TypeReference = $__37.TypeReference,
      UnaryExpression = $__37.UnaryExpression,
      UnionType = $__37.UnionType,
      VariableDeclaration = $__37.VariableDeclaration,
      VariableDeclarationList = $__37.VariableDeclarationList,
      VariableStatement = $__37.VariableStatement,
      WhileStatement = $__37.WhileStatement,
      WithStatement = $__37.WithStatement,
      YieldExpression = $__37.YieldExpression;
  var ALLOW_IN = true;
  var NO_IN = false;
  var INITIALIZER_REQUIRED = true;
  var INITIALIZER_OPTIONAL = false;
  var ValidateObjectLiteral = function($__super) {
    function ValidateObjectLiteral() {
      $traceurRuntime.superConstructor(ValidateObjectLiteral).call(this);
      this.errorToken = null;
    }
    return ($traceurRuntime.createClass)(ValidateObjectLiteral, {visitCoverInitializedName: function(tree) {
        this.errorToken = tree.equalToken;
        this.found = true;
      }}, {}, $__super);
  }(FindVisitor);
  function containsInitializer(declarations) {
    return declarations.some(function(v) {
      return v.initializer;
    });
  }
  var FUNCTION_STATE_SCRIPT = 1;
  var FUNCTION_STATE_MODULE = 1 << 1;
  var FUNCTION_STATE_FUNCTION = 1 << 2;
  var FUNCTION_STATE_ARROW = 1 << 3;
  var FUNCTION_STATE_METHOD = 1 << 4;
  var FUNCTION_STATE_DERIVED_CONSTRUCTOR = 1 << 5;
  var FUNCTION_STATE_GENERATOR = 1 << 6;
  var FUNCTION_STATE_ASYNC = 1 << 7;
  var FUNCTION_STATE_LENIENT = FUNCTION_STATE_METHOD | FUNCTION_STATE_GENERATOR | FUNCTION_STATE_ASYNC | FUNCTION_STATE_DERIVED_CONSTRUCTOR;
  var FunctionState = function() {
    function FunctionState(outer, kind) {
      this.outer = outer;
      this.kind = kind;
    }
    return ($traceurRuntime.createClass)(FunctionState, {
      isTopMost: function() {
        return this.kind & (FUNCTION_STATE_SCRIPT | FUNCTION_STATE_MODULE);
      },
      isMethod: function() {
        return this.kind & FUNCTION_STATE_METHOD;
      },
      isDerivedConstructor: function() {
        return this.kind & FUNCTION_STATE_DERIVED_CONSTRUCTOR;
      },
      isArrowFunction: function() {
        return this.kind & FUNCTION_STATE_ARROW;
      },
      isGenerator: function() {
        return this.kind & FUNCTION_STATE_GENERATOR;
      },
      isAsyncFunction: function() {
        return this.kind & FUNCTION_STATE_ASYNC;
      },
      isAsyncGenerator: function() {
        return this.isGenerator() && this.isAsyncFunction();
      }
    }, {});
  }();
  var Parser = function() {
    function Parser(file) {
      var errorReporter = arguments[1] !== (void 0) ? arguments[1] : new SyntaxErrorReporter();
      var options = arguments[2] !== (void 0) ? arguments[2] : new Options();
      this.errorReporter_ = errorReporter;
      initScanner(errorReporter, file, this, options);
      this.options_ = options;
      this.coverInitializedNameCount_ = 0;
      this.strictMode_ = false;
      this.annotations_ = [];
      this.functionState_ = null;
    }
    return ($traceurRuntime.createClass)(Parser, {
      get allowYield_() {
        return this.functionState_.isGenerator();
      },
      get allowAwait_() {
        return this.functionState_.isAsyncFunction();
      },
      get allowForOn_() {
        return this.functionState_.isAsyncFunction();
      },
      parseScript: function() {
        this.strictMode_ = false;
        var start = this.getTreeStartLocation_();
        var fs = this.pushFunctionState_(FUNCTION_STATE_SCRIPT);
        var scriptItemList = this.parseStatementList_(true);
        this.eat_(END_OF_FILE);
        this.popFunctionState_(fs);
        return new Script(this.getTreeLocation_(start), scriptItemList, null);
      },
      pushFunctionState_: function(kind) {
        return this.functionState_ = new FunctionState(this.functionState_, kind);
      },
      popFunctionState_: function(fs) {
        if (fs != this.functionState_) {
          throw new Error('Internal error');
        }
        this.functionState_ = this.functionState_.outer;
      },
      parseStatementList_: function(checkUseStrictDirective) {
        var result = [];
        var type;
        while ((type = peekType()) !== CLOSE_CURLY && type !== END_OF_FILE) {
          var statement = this.parseStatementListItem_(type);
          if (checkUseStrictDirective) {
            if (!statement.isDirectivePrologue()) {
              checkUseStrictDirective = false;
            } else if (statement.isUseStrictDirective()) {
              this.strictMode_ = true;
              checkUseStrictDirective = false;
            }
          }
          result.push(statement);
        }
        return result;
      },
      parseStatementListItem_: function(type) {
        switch (type) {
          case LET:
          case CONST:
            if (this.options_.blockBinding) {
              return this.parseVariableStatement_();
            }
            break;
          case CLASS:
            if (this.options_.classes) {
              return this.parseClassDeclaration_();
            }
            break;
          case FUNCTION:
            return this.parseFunctionDeclaration_();
          case IDENTIFIER:
            if (this.options_.types && this.peekPredefinedString_(TYPE) && peekLookahead(IDENTIFIER)) {
              return this.parseTypeAliasDeclaration_();
            }
            break;
        }
        return this.parseStatementWithType_(type);
      },
      parseModule: function() {
        var start = this.getTreeStartLocation_();
        var fs = this.pushFunctionState_(FUNCTION_STATE_MODULE);
        var scriptItemList = this.parseModuleItemList_();
        this.eat_(END_OF_FILE);
        this.popFunctionState_(fs);
        return new Module(this.getTreeLocation_(start), scriptItemList, null);
      },
      parseModuleItemList_: function() {
        this.strictMode_ = true;
        var result = [];
        var type;
        while ((type = peekType()) !== END_OF_FILE) {
          var statement = this.parseModuleItem_(type);
          result.push(statement);
        }
        return result;
      },
      parseModuleItem_: function(type) {
        switch (type) {
          case IMPORT:
            return this.parseImportDeclaration_();
          case EXPORT:
            return this.parseExportDeclaration_();
          case AT:
            if (this.options_.annotations)
              return this.parseAnnotatedDeclarations_(true);
            break;
        }
        return this.parseStatementListItem_(type);
      },
      parseModuleSpecifier_: function() {
        var start = this.getTreeStartLocation_();
        var token = this.eat_(STRING);
        return new ModuleSpecifier(this.getTreeLocation_(start), token);
      },
      parseNameSpaceImport_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(STAR);
        this.eatId_(AS);
        var binding = this.parseImportedBinding_();
        return new NameSpaceImport(this.getTreeLocation_(start), binding);
      },
      parseImportDeclaration_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(IMPORT);
        var importClause = null;
        if (!peek(STRING)) {
          importClause = this.parseImportClause_(true, this.options_.types);
          this.eatId_(FROM);
        }
        var moduleSpecifier = this.parseModuleSpecifier_();
        this.eatPossibleImplicitSemiColon_();
        return new ImportDeclaration(this.getTreeLocation_(start), importClause, moduleSpecifier);
      },
      parseImportClause_: function(allowImportedDefaultBinding, allowType) {
        switch (peekType()) {
          case STAR:
            return this.parseNameSpaceImport_();
          case OPEN_CURLY:
            return this.parseImportSpecifierSet_();
          case IDENTIFIER:
            if (allowType && this.peekPredefinedString_(TYPE)) {
              var start = this.getTreeStartLocation_();
              var t = peekTokenLookahead();
              if (t.type === OPEN_CURLY || t.type === IDENTIFIER && t.value !== FROM) {
                this.eatId_(TYPE);
                var clause = this.parseImportClause_(allowImportedDefaultBinding, false);
                return new ImportTypeClause(this.getTreeLocation_(start), clause);
              }
            }
            if (allowImportedDefaultBinding) {
              var start$__4 = this.getTreeStartLocation_();
              var importedBinding = this.parseImportedBinding_();
              if (this.eatIf_(COMMA)) {
                var second = this.parseImportClause_(false, false);
                return new ImportClausePair(this.getTreeLocation_(start$__4), importedBinding, second);
              }
              return importedBinding;
            }
            break;
        }
        return this.parseUnexpectedToken_();
      },
      parseImportSpecifierSet_: function() {
        var start = this.getTreeStartLocation_();
        var specifiers = [];
        this.eat_(OPEN_CURLY);
        while (!peek(CLOSE_CURLY) && !isAtEnd()) {
          specifiers.push(this.parseImportSpecifier_());
          if (!this.eatIf_(COMMA))
            break;
        }
        this.eat_(CLOSE_CURLY);
        return new ImportSpecifierSet(this.getTreeLocation_(start), specifiers);
      },
      parseImportedBinding_: function() {
        var start = this.getTreeStartLocation_();
        var binding = this.parseBindingIdentifier_();
        return new ImportedBinding(this.getTreeLocation_(start), binding);
      },
      parseImportSpecifier_: function() {
        var start = this.getTreeStartLocation_();
        var token = peekToken();
        var isKeyword = token.isKeyword();
        var binding;
        var name = this.eatIdName_();
        if (isKeyword || this.peekPredefinedString_(AS)) {
          this.eatId_(AS);
          binding = this.parseImportedBinding_();
        } else {
          binding = new ImportedBinding(name.location, new BindingIdentifier(name.location, name));
          name = null;
        }
        return new ImportSpecifier(this.getTreeLocation_(start), binding, name);
      },
      parseExportDeclaration_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(EXPORT);
        var exportTree;
        var annotations = this.popAnnotations_();
        var type = peekType();
        switch (type) {
          case CONST:
          case LET:
            if (this.options_.blockBinding) {
              exportTree = this.parseVariableStatement_();
              break;
            }
            return this.parseUnexpectedToken_();
          case VAR:
            exportTree = this.parseVariableStatement_();
            break;
          case FUNCTION:
            exportTree = this.parseFunctionDeclaration_();
            break;
          case CLASS:
            exportTree = this.parseClassDeclaration_();
            break;
          case DEFAULT:
            exportTree = this.parseExportDefault_();
            break;
          case OPEN_CURLY:
          case STAR:
            exportTree = this.parseNamedExport_();
            break;
          case IDENTIFIER:
            if (this.options_.asyncFunctions && this.peekPredefinedString_(ASYNC)) {
              var asyncToken = this.eatId_();
              exportTree = this.parseAsyncFunctionDeclaration_(asyncToken);
            } else if (this.options_.types && this.peekPredefinedString_(TYPE) && peekLookahead(IDENTIFIER)) {
              exportTree = this.parseTypeAliasDeclaration_();
            } else if (this.options_.exportFromExtended) {
              exportTree = this.parseNamedExport_();
            } else {
              return this.parseUnexpectedToken_();
            }
            break;
          default:
            {
              var token = peekToken();
              if (!token.isKeyword()) {
                return this.parseUnexpectedToken_();
              }
              exportTree = this.parseNamedExport_();
            }
        }
        return new ExportDeclaration(this.getTreeLocation_(start), exportTree, annotations);
      },
      parseExportDefault_: function() {
        var start = this.getTreeStartLocation_();
        var defaultToken = this.eat_(DEFAULT);
        if (this.options_.exportFromExtended && this.peekPredefinedString_(FROM)) {
          var idName = new IdentifierToken(defaultToken.location, DEFAULT);
          var namedExport = new ForwardDefaultExport(this.getTreeLocation_(start), idName);
          this.eatId_(FROM);
          var moduleSpecifier = this.parseModuleSpecifier_();
          return new NamedExport(this.getTreeLocation_(start), namedExport, moduleSpecifier);
        }
        var exportValue;
        switch (peekType()) {
          case FUNCTION:
            {
              var tree = this.parseFunctionExpression_();
              if (tree.name) {
                tree = new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body);
              }
              exportValue = tree;
              break;
            }
          case CLASS:
            {
              if (!this.options_.classes) {
                return this.parseSyntaxError_('Unexpected reserved word');
              }
              var tree$__5 = this.parseClassExpression_();
              if (tree$__5.name) {
                tree$__5 = new ClassDeclaration(tree$__5.location, tree$__5.name, tree$__5.superClass, tree$__5.elements, tree$__5.annotations, tree$__5.typeParameters);
              }
              exportValue = tree$__5;
              break;
            }
          default:
            exportValue = this.parseAssignmentExpression_(ALLOW_IN);
            this.eatPossibleImplicitSemiColon_();
        }
        return new ExportDefault(this.getTreeLocation_(start), exportValue);
      },
      parseNamedExport_: function() {
        var start = this.getTreeStartLocation_();
        var exportClause,
            moduleSpecifier = null;
        switch (peekType()) {
          case OPEN_CURLY:
            exportClause = this.parseExportSpecifierSet_();
            if (this.peekPredefinedString_(FROM)) {
              this.eatId_(FROM);
              moduleSpecifier = this.parseModuleSpecifier_();
            } else {
              this.validateExportSpecifierSet_(exportClause);
            }
            break;
          case STAR:
            exportClause = this.parseExportStar_();
            this.eatId_(FROM);
            moduleSpecifier = this.parseModuleSpecifier_();
            break;
          default:
            exportClause = this.parseForwardDefaultExport_();
            this.eatId_(FROM);
            moduleSpecifier = this.parseModuleSpecifier_();
            break;
        }
        this.eatPossibleImplicitSemiColon_();
        return new NamedExport(this.getTreeLocation_(start), exportClause, moduleSpecifier);
      },
      parseExportStar_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(STAR);
        if (this.peekPredefinedString_(AS)) {
          this.eatId_(AS);
          var name = this.eatIdName_();
          return new NameSpaceExport(this.getTreeLocation_(start), name);
        }
        return new ExportStar(this.getTreeLocation_(start));
      },
      parseExportSpecifierSet_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_CURLY);
        var specifiers = [this.parseExportSpecifier_()];
        while (this.eatIf_(COMMA)) {
          if (peek(CLOSE_CURLY))
            break;
          specifiers.push(this.parseExportSpecifier_());
        }
        this.eat_(CLOSE_CURLY);
        return new ExportSpecifierSet(this.getTreeLocation_(start), specifiers);
      },
      parseExportSpecifier_: function() {
        var start = this.getTreeStartLocation_();
        var lhs = this.eatIdName_();
        var rhs = null;
        if (this.peekPredefinedString_(AS)) {
          this.eatId_();
          rhs = this.eatIdName_();
        }
        return new ExportSpecifier(this.getTreeLocation_(start), lhs, rhs);
      },
      parseForwardDefaultExport_: function() {
        var start = this.getTreeStartLocation_();
        var idName = this.eatIdName_();
        return new ForwardDefaultExport(this.getTreeLocation_(start), idName);
      },
      validateExportSpecifierSet_: function(tree) {
        for (var i = 0; i < tree.specifiers.length; i++) {
          var specifier = tree.specifiers[i];
          if (getKeywordType(specifier.lhs.value)) {
            this.reportError_(specifier.lhs.location, ("Unexpected token " + specifier.lhs.value));
          }
        }
      },
      peekId_: function(type) {
        if (type === IDENTIFIER)
          return true;
        if (this.strictMode_)
          return false;
        return peekToken().isStrictKeyword();
      },
      peekIdName_: function(token) {
        return token.type === IDENTIFIER || token.isKeyword();
      },
      parseClassShared_: function(constr) {
        var start = this.getTreeStartLocation_();
        var strictMode = this.strictMode_;
        this.strictMode_ = true;
        this.eat_(CLASS);
        var name = null;
        var typeParameters = null;
        var annotations = [];
        if (constr === ClassDeclaration || !peek(EXTENDS) && !peek(OPEN_CURLY)) {
          name = this.parseBindingIdentifier_();
          if (this.options_.types) {
            typeParameters = this.parseTypeParametersOpt_();
          }
          annotations = this.popAnnotations_();
        }
        var superClass = null;
        if (this.eatIf_(EXTENDS)) {
          superClass = this.parseLeftHandSideExpression_();
          superClass = this.coverFormalsToParenExpression_(superClass);
        }
        this.eat_(OPEN_CURLY);
        var elements = this.parseClassElements_(superClass);
        this.eat_(CLOSE_CURLY);
        this.strictMode_ = strictMode;
        return new constr(this.getTreeLocation_(start), name, superClass, elements, annotations, typeParameters);
      },
      parseClassDeclaration_: function() {
        return this.parseClassShared_(ClassDeclaration);
      },
      parseClassExpression_: function() {
        return this.parseClassShared_(ClassExpression);
      },
      parseClassElements_: function(derivedClass) {
        var result = [];
        while (true) {
          var type = peekType();
          if (type === SEMI_COLON) {
            nextToken();
          } else if (this.peekClassElement_(peekType())) {
            result.push(this.parseClassElement_(derivedClass));
          } else {
            break;
          }
        }
        return result;
      },
      peekClassElement_: function(type) {
        return this.peekPropertyName_(type) || type === STAR && this.options_.generators || type === AT && this.options_.annotations;
      },
      parsePropertyName_: function() {
        if (peek(OPEN_SQUARE))
          return this.parseComputedPropertyName_();
        return this.parseLiteralPropertyName_();
      },
      parseLiteralPropertyName_: function() {
        var start = this.getTreeStartLocation_();
        var token = nextToken();
        return new LiteralPropertyName(this.getTreeLocation_(start), token);
      },
      parseComputedPropertyName_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_SQUARE);
        var expression = this.parseAssignmentExpression_(ALLOW_IN);
        this.eat_(CLOSE_SQUARE);
        return new ComputedPropertyName(this.getTreeLocation_(start), expression);
      },
      parseStatement: function() {
        var fs = this.pushFunctionState_(FUNCTION_STATE_LENIENT);
        var result = this.parseModuleItem_(peekType());
        this.popFunctionState_(fs);
        return result;
      },
      parseStatements: function() {
        var fs = this.pushFunctionState_(FUNCTION_STATE_LENIENT);
        var result = this.parseModuleItemList_();
        this.popFunctionState_(fs);
        return result;
      },
      parseStatement_: function() {
        return this.parseStatementWithType_(peekType());
      },
      parseStatementWithType_: function(type) {
        switch (type) {
          case RETURN:
            return this.parseReturnStatement_();
          case VAR:
            return this.parseVariableStatement_();
          case IF:
            return this.parseIfStatement_();
          case FOR:
            return this.parseForStatement_();
          case BREAK:
            return this.parseBreakStatement_();
          case SWITCH:
            return this.parseSwitchStatement_();
          case THROW:
            return this.parseThrowStatement_();
          case WHILE:
            return this.parseWhileStatement_();
          case AT:
            if (this.options_.annotations)
              return this.parseAnnotatedDeclarations_(false);
            break;
          case CONTINUE:
            return this.parseContinueStatement_();
          case DEBUGGER:
            return this.parseDebuggerStatement_();
          case DO:
            return this.parseDoWhileStatement_();
          case OPEN_CURLY:
            return this.parseBlock_();
          case SEMI_COLON:
            return this.parseEmptyStatement_();
          case TRY:
            return this.parseTryStatement_();
          case WITH:
            return this.parseWithStatement_();
          case INTERFACE:
            if (this.options_.types) {
              return this.parseInterfaceDeclaration_();
            }
        }
        return this.parseFallThroughStatement_();
      },
      parseFunctionDeclaration_: function() {
        return this.parseFunction_(FunctionDeclaration);
      },
      parseFunctionExpression_: function() {
        return this.parseFunction_(FunctionExpression);
      },
      parseAsyncFunctionDeclaration_: function(asyncToken) {
        return this.parseAsyncFunction_(asyncToken, FunctionDeclaration);
      },
      parseAsyncFunctionExpression_: function(asyncToken) {
        return this.parseAsyncFunction_(asyncToken, FunctionExpression);
      },
      peekAsyncStar_: function() {
        return this.options_.asyncGenerators && peek(STAR);
      },
      parseAsyncFunction_: function(asyncToken, ctor) {
        var start = asyncToken.location.start;
        this.eat_(FUNCTION);
        var kind = FUNCTION_STATE_FUNCTION | FUNCTION_STATE_ASYNC;
        if (this.peekAsyncStar_()) {
          kind |= FUNCTION_STATE_GENERATOR;
          this.eat_(STAR);
          asyncToken = new IdentifierToken(asyncToken.location, ASYNC_STAR);
        }
        var fs = this.pushFunctionState_(kind);
        var f = this.parseFunction2_(start, asyncToken, ctor);
        this.popFunctionState_(fs);
        return f;
      },
      parseFunction_: function(ctor) {
        var start = this.getTreeStartLocation_();
        this.eat_(FUNCTION);
        var functionKind = null;
        var kind = FUNCTION_STATE_FUNCTION;
        if (this.options_.generators && peek(STAR)) {
          functionKind = this.eat_(STAR);
          kind |= FUNCTION_STATE_GENERATOR;
        }
        var fs = this.pushFunctionState_(kind);
        var f = this.parseFunction2_(start, functionKind, ctor);
        this.popFunctionState_(fs);
        return f;
      },
      parseFunction2_: function(start, functionKind, ctor) {
        var name = null;
        var annotations = [];
        if (ctor === FunctionDeclaration || this.peekBindingIdentifier_(peekType())) {
          name = this.parseBindingIdentifier_();
          annotations = this.popAnnotations_();
        }
        this.eat_(OPEN_PAREN);
        var parameters = this.parseFormalParameters_();
        this.eat_(CLOSE_PAREN);
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        var body = this.parseFunctionBody_(parameters);
        return new ctor(this.getTreeLocation_(start), name, functionKind, parameters, typeAnnotation, annotations, body);
      },
      peekRest_: function(type) {
        return type === DOT_DOT_DOT && this.options_.restParameters;
      },
      parseFormalParameters_: function() {
        var start = this.getTreeStartLocation_();
        var formals = [];
        this.pushAnnotations_();
        var type = peekType();
        if (this.peekRest_(type)) {
          formals.push(this.parseFormalRestParameter_());
        } else {
          if (this.peekFormalParameter_(peekType()))
            formals.push(this.parseFormalParameter_(INITIALIZER_OPTIONAL));
          while (this.eatIf_(COMMA)) {
            this.pushAnnotations_();
            if (this.peekRest_(peekType())) {
              formals.push(this.parseFormalRestParameter_());
              break;
            }
            formals.push(this.parseFormalParameter_(INITIALIZER_OPTIONAL));
          }
        }
        return new FormalParameterList(this.getTreeLocation_(start), formals);
      },
      peekFormalParameter_: function(type) {
        return this.peekBindingElement_(type);
      },
      parseFormalParameter_: function(initializerAllowed) {
        var start = this.getTreeStartLocation_();
        var binding = this.parseBindingElementBinding_();
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        var initializer = this.parseBindingElementInitializer_(initializerAllowed);
        return new FormalParameter(this.getTreeLocation_(start), new BindingElement(this.getTreeLocation_(start), binding, initializer), typeAnnotation, this.popAnnotations_());
      },
      parseFormalRestParameter_: function() {
        var start = this.getTreeStartLocation_();
        var restParameter = this.parseRestParameter_();
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        return new FormalParameter(this.getTreeLocation_(start), restParameter, typeAnnotation, this.popAnnotations_());
      },
      parseRestParameter_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(DOT_DOT_DOT);
        var id = this.parseBindingIdentifier_();
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        return new RestParameter(this.getTreeLocation_(start), id, typeAnnotation);
      },
      parseFunctionBody_: function(params) {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_CURLY);
        var strictMode = this.strictMode_;
        var result = this.parseStatementList_(!strictMode);
        validateParameters(params, this.strictMode_, this.errorReporter_);
        this.strictMode_ = strictMode;
        this.eat_(CLOSE_CURLY);
        return new FunctionBody(this.getTreeLocation_(start), result);
      },
      parseSpreadExpression_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(DOT_DOT_DOT);
        var operand = this.parseAssignmentExpression_(ALLOW_IN);
        return new SpreadExpression(this.getTreeLocation_(start), operand);
      },
      parseBlock_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_CURLY);
        var result = this.parseStatementList_(false);
        this.eat_(CLOSE_CURLY);
        return new Block(this.getTreeLocation_(start), result);
      },
      parseVariableStatement_: function() {
        var start = this.getTreeStartLocation_();
        var declarations = this.parseVariableDeclarationList_(ALLOW_IN, INITIALIZER_REQUIRED);
        this.checkInitializers_(declarations);
        this.eatPossibleImplicitSemiColon_();
        return new VariableStatement(this.getTreeLocation_(start), declarations);
      },
      parseVariableDeclarationList_: function(allowIn, initializerRequired) {
        var type = peekType();
        switch (type) {
          case CONST:
          case LET:
          case VAR:
            nextToken();
            break;
          default:
            throw Error('unreachable');
        }
        var start = this.getTreeStartLocation_();
        var declarations = [];
        declarations.push(this.parseVariableDeclaration_(type, allowIn, initializerRequired));
        while (this.eatIf_(COMMA)) {
          declarations.push(this.parseVariableDeclaration_(type, allowIn, initializerRequired));
        }
        return new VariableDeclarationList(this.getTreeLocation_(start), type, declarations);
      },
      parseVariableDeclaration_: function(binding, noIn, initializerRequired) {
        var initRequired = initializerRequired !== INITIALIZER_OPTIONAL;
        var start = this.getTreeStartLocation_();
        var lvalue;
        var typeAnnotation;
        if (this.peekPattern_(peekType())) {
          lvalue = this.parseBindingPattern_();
          typeAnnotation = null;
        } else {
          lvalue = this.parseBindingIdentifier_();
          typeAnnotation = this.parseTypeAnnotationOpt_();
        }
        var init = null;
        if (peek(EQUAL)) {
          init = this.parseInitializer_(noIn);
        } else if (lvalue.isPattern() && initRequired) {
          this.reportError_(lvalue.location, 'destructuring must have an initializer');
        }
        return new VariableDeclaration(this.getTreeLocation_(start), lvalue, typeAnnotation, init);
      },
      parseInitializer_: function(allowIn) {
        this.eat_(EQUAL);
        return this.parseAssignmentExpression_(allowIn);
      },
      parseInitializerOpt_: function(allowIn) {
        if (this.eatIf_(EQUAL))
          return this.parseAssignmentExpression_(allowIn);
        return null;
      },
      parseEmptyStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(SEMI_COLON);
        return new EmptyStatement(this.getTreeLocation_(start));
      },
      parseFallThroughStatement_: function() {
        var start = this.getTreeStartLocation_();
        var expression;
        switch (peekType()) {
          case OPEN_CURLY:
            return this.parseUnexpectedToken_();
          case FUNCTION:
          case CLASS:
            return this.parseUnexpectedReservedWord_(peekToken());
          case LET:
            {
              var token = peekLookahead(OPEN_SQUARE);
              if (token) {
                return this.parseSyntaxError_("A statement cannot start with 'let ['");
              }
            }
        }
        if (this.options_.asyncFunctions && this.peekPredefinedString_(ASYNC) && peekLookahead(FUNCTION)) {
          var asyncToken = this.eatId_();
          var functionToken = peekTokenNoLineTerminator();
          if (functionToken !== null)
            return this.parseAsyncFunctionDeclaration_(asyncToken);
          expression = new IdentifierExpression(this.getTreeLocation_(start), asyncToken);
        } else {
          expression = this.parseExpression_(ALLOW_IN);
        }
        if (expression.type === IDENTIFIER_EXPRESSION) {
          if (this.eatIf_(COLON)) {
            var nameToken = expression.identifierToken;
            var statement = this.parseStatement_();
            return new LabelledStatement(this.getTreeLocation_(start), nameToken, statement);
          }
        }
        this.eatPossibleImplicitSemiColon_();
        return new ExpressionStatement(this.getTreeLocation_(start), expression);
      },
      parseIfStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(IF);
        this.eat_(OPEN_PAREN);
        var condition = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        var ifClause = this.parseStatement_();
        var elseClause = null;
        if (this.eatIf_(ELSE)) {
          elseClause = this.parseStatement_();
        }
        return new IfStatement(this.getTreeLocation_(start), condition, ifClause, elseClause);
      },
      parseDoWhileStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(DO);
        var body = this.parseStatement_();
        this.eat_(WHILE);
        this.eat_(OPEN_PAREN);
        var condition = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        this.eatPossibleImplicitSemiColon_();
        return new DoWhileStatement(this.getTreeLocation_(start), body, condition);
      },
      parseWhileStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(WHILE);
        this.eat_(OPEN_PAREN);
        var condition = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        var body = this.parseStatement_();
        return new WhileStatement(this.getTreeLocation_(start), condition, body);
      },
      parseForStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(FOR);
        this.eat_(OPEN_PAREN);
        var type = peekType();
        if (this.peekVariableDeclarationList_(type)) {
          var variables = this.parseVariableDeclarationList_(NO_IN, INITIALIZER_OPTIONAL);
          var declarations = variables.declarations;
          if (declarations.length > 1 || containsInitializer(declarations)) {
            return this.parseForStatement2_(start, variables);
          }
          type = peekType();
          if (type === IN) {
            return this.parseForInStatement_(start, variables);
          } else if (this.peekOf_()) {
            return this.parseForOfStatement_(start, variables);
          } else if (this.allowForOn_ && this.peekOn_()) {
            return this.parseForOnStatement_(start, variables);
          } else {
            this.checkInitializers_(variables);
            return this.parseForStatement2_(start, variables);
          }
        }
        if (type === SEMI_COLON) {
          return this.parseForStatement2_(start, null);
        }
        var coverInitializedNameCount = this.coverInitializedNameCount_;
        var initializer = this.parseExpressionAllowPattern_(NO_IN);
        type = peekType();
        if ((type === IN || this.peekOf_() || this.allowForOn_ && this.peekOn_())) {
          initializer = this.transformLeftHandSideExpression_(initializer);
          this.validateAssignmentTarget_(initializer, 'assignment');
          if (this.peekOf_()) {
            return this.parseForOfStatement_(start, initializer);
          } else if (this.allowForOn_ && this.peekOn_()) {
            return this.parseForOnStatement_(start, initializer);
          }
          return this.parseForInStatement_(start, initializer);
        }
        this.ensureNoCoverInitializedNames_(initializer, coverInitializedNameCount);
        return this.parseForStatement2_(start, initializer);
      },
      peekOf_: function() {
        return this.options_.forOf && this.peekPredefinedString_(OF);
      },
      peekOn_: function() {
        return this.options_.forOn && this.peekPredefinedString_(ON);
      },
      parseForOfStatement_: function(start, initializer) {
        this.eatId_();
        var collection = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        var body = this.parseStatement_();
        return new ForOfStatement(this.getTreeLocation_(start), initializer, collection, body);
      },
      parseForOnStatement_: function(start, initializer) {
        this.eatId_();
        var observable = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        var body = this.parseStatement_();
        return new ForOnStatement(this.getTreeLocation_(start), initializer, observable, body);
      },
      checkInitializers_: function(variables) {
        if (this.options_.blockBinding && variables.declarationType === CONST) {
          var type = variables.declarationType;
          for (var i = 0; i < variables.declarations.length; i++) {
            if (!this.checkInitializer_(type, variables.declarations[i])) {
              break;
            }
          }
        }
      },
      checkInitializer_: function(type, declaration) {
        if (this.options_.blockBinding && type === CONST && declaration.initializer === null) {
          this.reportError_(declaration.location, 'const variables must have an initializer');
          return false;
        }
        return true;
      },
      peekVariableDeclarationList_: function(type) {
        switch (type) {
          case VAR:
            return true;
          case CONST:
          case LET:
            return this.options_.blockBinding;
          default:
            return false;
        }
      },
      parseForStatement2_: function(start, initializer) {
        this.eat_(SEMI_COLON);
        var condition = null;
        if (!peek(SEMI_COLON)) {
          condition = this.parseExpression_(ALLOW_IN);
        }
        this.eat_(SEMI_COLON);
        var increment = null;
        if (!peek(CLOSE_PAREN)) {
          increment = this.parseExpression_(ALLOW_IN);
        }
        this.eat_(CLOSE_PAREN);
        var body = this.parseStatement_();
        return new ForStatement(this.getTreeLocation_(start), initializer, condition, increment, body);
      },
      parseForInStatement_: function(start, initializer) {
        this.eat_(IN);
        var collection = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        var body = this.parseStatement_();
        return new ForInStatement(this.getTreeLocation_(start), initializer, collection, body);
      },
      parseContinueStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(CONTINUE);
        var name = null;
        if (!this.peekImplicitSemiColon_()) {
          name = this.eatIdOpt_();
        }
        this.eatPossibleImplicitSemiColon_();
        return new ContinueStatement(this.getTreeLocation_(start), name);
      },
      parseBreakStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(BREAK);
        var name = null;
        if (!this.peekImplicitSemiColon_()) {
          name = this.eatIdOpt_();
        }
        this.eatPossibleImplicitSemiColon_();
        return new BreakStatement(this.getTreeLocation_(start), name);
      },
      parseReturnStatement_: function() {
        var start = this.getTreeStartLocation_();
        var returnToken = this.eat_(RETURN);
        if (this.functionState_.isTopMost()) {
          this.reportError_(returnToken.location, 'Illegal return statement');
        }
        var expression = null;
        if (!this.peekImplicitSemiColon_()) {
          expression = this.parseExpression_(ALLOW_IN);
        }
        this.eatPossibleImplicitSemiColon_();
        return new ReturnStatement(this.getTreeLocation_(start), expression);
      },
      parseYieldExpression_: function(allowIn) {
        var start = this.getTreeStartLocation_();
        this.eat_(YIELD);
        var expression = null;
        var isYieldFor = false;
        var token = peekTokenNoLineTerminator();
        if (token !== null) {
          switch (token.type) {
            case CLOSE_CURLY:
            case CLOSE_PAREN:
            case CLOSE_SQUARE:
            case COLON:
            case COMMA:
            case END_OF_FILE:
            case SEMI_COLON:
              break;
            default:
              isYieldFor = this.eatIf_(STAR);
              expression = this.parseAssignmentExpression_(allowIn);
          }
        }
        return new YieldExpression(this.getTreeLocation_(start), expression, isYieldFor);
      },
      parseWithStatement_: function() {
        var start = this.getTreeStartLocation_();
        var withToken = this.eat_(WITH);
        if (this.strictMode_) {
          this.reportError_(withToken.location, 'Strict mode code may not include a with statement');
        }
        this.eat_(OPEN_PAREN);
        var expression = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        var body = this.parseStatement_();
        return new WithStatement(this.getTreeLocation_(start), expression, body);
      },
      parseSwitchStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(SWITCH);
        this.eat_(OPEN_PAREN);
        var expression = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        this.eat_(OPEN_CURLY);
        var caseClauses = this.parseCaseClauses_();
        this.eat_(CLOSE_CURLY);
        return new SwitchStatement(this.getTreeLocation_(start), expression, caseClauses);
      },
      parseCaseClauses_: function() {
        var foundDefaultClause = false;
        var result = [];
        while (true) {
          var start = this.getTreeStartLocation_();
          switch (peekType()) {
            case CASE:
              {
                nextToken();
                var expression = this.parseExpression_(ALLOW_IN);
                this.eat_(COLON);
                var statements = this.parseCaseStatementsOpt_();
                result.push(new CaseClause(this.getTreeLocation_(start), expression, statements));
                break;
              }
            case DEFAULT:
              {
                var defaultToken = nextToken();
                if (foundDefaultClause) {
                  this.reportError_(defaultToken.location, 'Switch statements may have at most one \'default\' clause');
                } else {
                  foundDefaultClause = true;
                }
                this.eat_(COLON);
                result.push(new DefaultClause(this.getTreeLocation_(start), this.parseCaseStatementsOpt_()));
                break;
              }
            default:
              return result;
          }
        }
      },
      parseCaseStatementsOpt_: function() {
        var result = [];
        var type;
        while (true) {
          switch (type = peekType()) {
            case CASE:
            case DEFAULT:
            case CLOSE_CURLY:
            case END_OF_FILE:
              return result;
          }
          result.push(this.parseStatementListItem_(type));
        }
      },
      parseThrowStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(THROW);
        var value = null;
        if (!this.peekImplicitSemiColon_()) {
          value = this.parseExpression_(ALLOW_IN);
        }
        this.eatPossibleImplicitSemiColon_();
        return new ThrowStatement(this.getTreeLocation_(start), value);
      },
      parseTryStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(TRY);
        var body = this.parseBlock_();
        var catchBlock = null;
        if (peek(CATCH)) {
          catchBlock = this.parseCatch_();
        }
        var finallyBlock = null;
        if (peek(FINALLY)) {
          finallyBlock = this.parseFinallyBlock_();
        }
        if (catchBlock === null && finallyBlock === null) {
          var token = peekToken();
          this.reportError_(token.location, "'catch' or 'finally' expected.");
        }
        return new TryStatement(this.getTreeLocation_(start), body, catchBlock, finallyBlock);
      },
      parseCatch_: function() {
        var start = this.getTreeStartLocation_();
        var catchBlock;
        this.eat_(CATCH);
        this.eat_(OPEN_PAREN);
        var binding;
        if (this.peekPattern_(peekType()))
          binding = this.parseBindingPattern_();
        else
          binding = this.parseBindingIdentifier_();
        this.eat_(CLOSE_PAREN);
        var catchBody = this.parseBlock_();
        catchBlock = new Catch(this.getTreeLocation_(start), binding, catchBody);
        return catchBlock;
      },
      parseFinallyBlock_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(FINALLY);
        var finallyBlock = this.parseBlock_();
        return new Finally(this.getTreeLocation_(start), finallyBlock);
      },
      parseDebuggerStatement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(DEBUGGER);
        this.eatPossibleImplicitSemiColon_();
        return new DebuggerStatement(this.getTreeLocation_(start));
      },
      parsePrimaryExpression_: function() {
        switch (peekType()) {
          case CLASS:
            return this.options_.classes ? this.parseClassExpression_() : this.parseUnexpectedReservedWord_(peekToken());
          case THIS:
            return this.parseThisExpression_();
          case IDENTIFIER:
            {
              var identifier = this.parseIdentifierExpression_();
              if (this.options_.asyncFunctions && identifier.identifierToken.value === ASYNC) {
                var token$__6 = peekTokenNoLineTerminator();
                if (token$__6 && token$__6.type === FUNCTION) {
                  var asyncToken = identifier.identifierToken;
                  return this.parseAsyncFunctionExpression_(asyncToken);
                }
              }
              return identifier;
            }
          case NUMBER:
          case STRING:
          case TRUE:
          case FALSE:
          case NULL:
            return this.parseLiteralExpression_();
          case OPEN_SQUARE:
            return this.parseArrayLiteral_();
          case OPEN_CURLY:
            return this.parseObjectLiteral_();
          case OPEN_PAREN:
            return this.parsePrimaryExpressionStartingWithParen_();
          case SLASH:
          case SLASH_EQUAL:
            return this.parseRegularExpressionLiteral_();
          case NO_SUBSTITUTION_TEMPLATE:
          case TEMPLATE_HEAD:
            if (this.options_.templateLiterals) {
              return this.parseTemplateLiteral_(null);
            }
            break;
          case IMPLEMENTS:
          case INTERFACE:
          case PACKAGE:
          case PRIVATE:
          case PROTECTED:
          case PUBLIC:
          case STATIC:
          case YIELD:
            if (this.strictMode_) {
              this.reportReservedIdentifier_(nextToken());
            }
            return this.parseIdentifierExpression_();
          case OPEN_ANGLE:
            if (this.options_.jsx) {
              return this.parseJsxElement_();
            }
            break;
          case END_OF_FILE:
            return this.parseSyntaxError_('Unexpected end of input');
        }
        var token = peekToken();
        if (token.isKeyword()) {
          return this.parseUnexpectedReservedWord_(token);
        }
        return this.parseUnexpectedToken_(token);
      },
      parseSuperExpression_: function(isNew) {
        var start = this.getTreeStartLocation_();
        var fs = this.functionState_;
        while (fs && fs.isArrowFunction()) {
          fs = fs.outer;
        }
        var superToken = this.eat_(SUPER);
        if (!fs || !fs.isMethod()) {
          this.reportError_(superToken.location, 'super is only allowed in methods');
        }
        var operand = new SuperExpression(this.getTreeLocation_(start));
        var type = peekType();
        if (isNew) {
          if (type === OPEN_SQUARE) {
            return this.parseMemberLookupExpression_(start, operand);
          }
          return this.parseMemberExpression_(start, operand);
        }
        switch (type) {
          case OPEN_SQUARE:
            return this.parseMemberLookupExpression_(start, operand);
          case PERIOD:
            return this.parseMemberExpression_(start, operand);
          case OPEN_PAREN:
            {
              var superCall = this.parseCallExpression_(start, operand);
              if (!fs.isDerivedConstructor()) {
                this.reportError_(superToken.location, 'super call is only allowed in derived constructor');
              }
              return superCall;
            }
        }
        return this.parseUnexpectedToken_();
      },
      parseThisExpression_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(THIS);
        return new ThisExpression(this.getTreeLocation_(start));
      },
      peekBindingIdentifier_: function(type) {
        return this.peekId_(type);
      },
      parseBindingIdentifier_: function() {
        var start = this.getTreeStartLocation_();
        var identifier = this.eatId_();
        return new BindingIdentifier(this.getTreeLocation_(start), identifier);
      },
      parseIdentifierExpression_: function() {
        var start = this.getTreeStartLocation_();
        var identifier = this.eatId_();
        return new IdentifierExpression(this.getTreeLocation_(start), identifier);
      },
      parseIdentifierNameExpression_: function() {
        var start = this.getTreeStartLocation_();
        var identifier = this.eatIdName_();
        return new IdentifierExpression(this.getTreeLocation_(start), identifier);
      },
      parseLiteralExpression_: function() {
        var start = this.getTreeStartLocation_();
        var literal = this.nextLiteralToken_();
        return new LiteralExpression(this.getTreeLocation_(start), literal);
      },
      nextLiteralToken_: function() {
        return nextToken();
      },
      parseRegularExpressionLiteral_: function() {
        var start = this.getTreeStartLocation_();
        var literal = nextRegularExpressionLiteralToken();
        return new LiteralExpression(this.getTreeLocation_(start), literal);
      },
      peekSpread_: function(type) {
        return type === DOT_DOT_DOT && this.options_.spread;
      },
      parseArrayLiteral_: function() {
        var start = this.getTreeStartLocation_();
        var expression;
        var elements = [];
        this.eat_(OPEN_SQUARE);
        var type = peekType();
        if (type === FOR && this.options_.arrayComprehension)
          return this.parseArrayComprehension_(start);
        while (true) {
          type = peekType();
          if (type === COMMA) {
            expression = null;
          } else if (this.peekSpread_(type)) {
            expression = this.parseSpreadExpression_();
          } else if (type === CLOSE_SQUARE || type === END_OF_FILE) {
            break;
          } else {
            expression = this.parseAssignmentExpression_(ALLOW_IN);
          }
          elements.push(expression);
          type = peekType();
          if (type !== CLOSE_SQUARE)
            this.eat_(COMMA);
        }
        this.eat_(CLOSE_SQUARE);
        return new ArrayLiteral(this.getTreeLocation_(start), elements);
      },
      parseArrayComprehension_: function(start) {
        var list = this.parseComprehensionList_();
        var expression = this.parseAssignmentExpression_(ALLOW_IN);
        this.eat_(CLOSE_SQUARE);
        return new ArrayComprehension(this.getTreeLocation_(start), list, expression);
      },
      parseComprehensionList_: function() {
        var list = [this.parseComprehensionFor_()];
        while (true) {
          var type = peekType();
          switch (type) {
            case FOR:
              list.push(this.parseComprehensionFor_());
              break;
            case IF:
              list.push(this.parseComprehensionIf_());
              break;
            default:
              return list;
          }
        }
      },
      parseComprehensionFor_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(FOR);
        this.eat_(OPEN_PAREN);
        var left = this.parseForBinding_();
        this.eatId_(OF);
        var iterator = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        return new ComprehensionFor(this.getTreeLocation_(start), left, iterator);
      },
      parseComprehensionIf_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(IF);
        this.eat_(OPEN_PAREN);
        var expression = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        return new ComprehensionIf(this.getTreeLocation_(start), expression);
      },
      parseObjectLiteral_: function() {
        var start = this.getTreeStartLocation_();
        var result = [];
        this.eat_(OPEN_CURLY);
        while (this.peekPropertyDefinition_(peekType())) {
          var propertyDefinition = this.parsePropertyDefinition_();
          result.push(propertyDefinition);
          if (!this.eatIf_(COMMA))
            break;
        }
        this.eat_(CLOSE_CURLY);
        return new ObjectLiteral(this.getTreeLocation_(start), result);
      },
      parsePropertyDefinition: function() {
        var fs = this.pushFunctionState_(FUNCTION_STATE_SCRIPT);
        var result = this.parsePropertyDefinition_();
        this.popFunctionState_(fs);
        return result;
      },
      parsePropertyDefinition_: function() {
        var start = this.getTreeStartLocation_();
        var functionKind = null;
        var isStatic = false;
        if (this.options_.generators && this.options_.propertyMethods && peek(STAR)) {
          var fs = this.pushFunctionState_(FUNCTION_STATE_METHOD | FUNCTION_STATE_GENERATOR);
          var m = this.parseGeneratorMethod_(start, isStatic, []);
          this.popFunctionState_(fs);
          return m;
        }
        if (this.options_.spreadProperties && peek(DOT_DOT_DOT)) {
          return this.parseSpreadExpression_();
        }
        var token = peekToken();
        var name = this.parsePropertyName_();
        if (this.options_.propertyMethods && peek(OPEN_PAREN)) {
          var fs$__7 = this.pushFunctionState_(FUNCTION_STATE_METHOD);
          var m$__8 = this.parseMethod_(start, isStatic, functionKind, name, []);
          this.popFunctionState_(fs$__7);
          return m$__8;
        }
        if (this.eatIf_(COLON)) {
          var value = this.parseAssignmentExpression_(ALLOW_IN);
          return new PropertyNameAssignment(this.getTreeLocation_(start), name, value);
        }
        var type = peekType();
        if (name.type === LITERAL_PROPERTY_NAME) {
          var nameLiteral = name.literalToken;
          if (nameLiteral.value === GET && this.peekPropertyName_(type)) {
            return this.parseGetAccessor_(start, isStatic, []);
          }
          if (nameLiteral.value === SET && this.peekPropertyName_(type)) {
            return this.parseSetAccessor_(start, isStatic, []);
          }
          if (this.options_.asyncFunctions && nameLiteral.value === ASYNC && (this.peekPropertyName_(type) || this.peekAsyncStar_())) {
            var async = nameLiteral;
            var kind = FUNCTION_STATE_METHOD | FUNCTION_STATE_ASYNC;
            if (this.peekAsyncStar_()) {
              kind |= FUNCTION_STATE_GENERATOR;
              this.eat_(STAR);
              async = new IdentifierToken(async.location, ASYNC_STAR);
            }
            var name$__9 = this.parsePropertyName_();
            var fs$__10 = this.pushFunctionState_(kind);
            var m$__11 = this.parseMethod_(start, isStatic, async, name$__9, []);
            this.popFunctionState_(fs$__10);
            return m$__11;
          }
          if (this.options_.propertyNameShorthand && (nameLiteral.type === IDENTIFIER || nameLiteral.isStrictKeyword() && !this.strictMode_ || nameLiteral.type === YIELD && this.allowYield_)) {
            if (peek(EQUAL)) {
              token = nextToken();
              var coverInitializedNameCount = this.coverInitializedNameCount_;
              var expr = this.parseAssignmentExpression_(ALLOW_IN);
              this.ensureNoCoverInitializedNames_(expr, coverInitializedNameCount);
              this.coverInitializedNameCount_++;
              return new CoverInitializedName(this.getTreeLocation_(start), nameLiteral, token, expr);
            }
            return new PropertyNameShorthand(this.getTreeLocation_(start), nameLiteral);
          }
          if (this.strictMode_ && nameLiteral.isStrictKeyword())
            this.reportReservedIdentifier_(nameLiteral);
        }
        if (name.type === COMPUTED_PROPERTY_NAME)
          token = peekToken();
        return this.parseUnexpectedToken_(token);
      },
      parseClassElement_: function(derivedClass) {
        var start = this.getTreeStartLocation_();
        var annotations = this.parseAnnotations_();
        var type = peekType();
        var isStatic = false,
            functionKind = null;
        switch (type) {
          case STATIC:
            {
              var staticToken = nextToken();
              type = peekType();
              switch (type) {
                case OPEN_PAREN:
                  {
                    var location = this.getTreeLocation_(start);
                    var name = new LiteralPropertyName(location, staticToken);
                    var fs = this.pushFunctionState_(FUNCTION_STATE_METHOD);
                    var m = this.parseMethod_(start, isStatic, functionKind, name, annotations);
                    this.popFunctionState_(fs);
                    return m;
                  }
                default:
                  isStatic = true;
                  if (type === STAR && this.options_.generators)
                    return this.parseGeneratorMethod_(start, true, annotations);
                  return this.parseClassElement2_(start, isStatic, annotations, derivedClass);
              }
              break;
            }
          case STAR:
            return this.parseGeneratorMethod_(start, isStatic, annotations);
          default:
            return this.parseClassElement2_(start, isStatic, annotations, derivedClass);
        }
      },
      parseGeneratorMethod_: function(start, isStatic, annotations) {
        var functionKind = this.eat_(STAR);
        var name = this.parsePropertyName_();
        var fs = this.pushFunctionState_(FUNCTION_STATE_METHOD | FUNCTION_STATE_GENERATOR);
        var m = this.parseMethod_(start, isStatic, functionKind, name, annotations);
        this.popFunctionState_(fs);
        return m;
      },
      parseMethod_: function(start, isStatic, functionKind, name, annotations) {
        this.eat_(OPEN_PAREN);
        var parameterList = this.parseFormalParameters_();
        this.eat_(CLOSE_PAREN);
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        var body = this.parseFunctionBody_(parameterList);
        return new Method(this.getTreeLocation_(start), isStatic, functionKind, name, parameterList, typeAnnotation, annotations, body, null);
      },
      parsePropertyVariableDeclaration_: function(start, isStatic, name, annotations) {
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        var initializer = this.parseInitializerOpt_(ALLOW_IN);
        this.eat_(SEMI_COLON);
        return new PropertyVariableDeclaration(this.getTreeLocation_(start), isStatic, name, typeAnnotation, annotations, initializer);
      },
      parseClassElement2_: function(start, isStatic, annotations, derivedClass) {
        var functionKind = null;
        var name = this.parsePropertyName_();
        var type = peekType();
        if (name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === GET && this.peekPropertyName_(type)) {
          return this.parseGetAccessor_(start, isStatic, annotations);
        }
        if (name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === SET && this.peekPropertyName_(type)) {
          return this.parseSetAccessor_(start, isStatic, annotations);
        }
        if (this.options_.asyncFunctions && name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === ASYNC && (this.peekPropertyName_(type) || this.peekAsyncStar_())) {
          var async = name.literalToken;
          var kind = FUNCTION_STATE_METHOD | FUNCTION_STATE_ASYNC;
          if (this.peekAsyncStar_()) {
            kind |= FUNCTION_STATE_GENERATOR;
            this.eat_(STAR);
            async = new IdentifierToken(async.location, ASYNC_STAR);
          }
          name = this.parsePropertyName_();
          var fs = this.pushFunctionState_(kind);
          var m = this.parseMethod_(start, isStatic, async, name, annotations);
          this.popFunctionState_(fs);
          return m;
        }
        if (!this.options_.memberVariables || type === OPEN_PAREN) {
          var kind$__12 = FUNCTION_STATE_METHOD;
          var isDerivedConstructor = derivedClass && !isStatic && functionKind === null && name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === CONSTRUCTOR;
          if (isDerivedConstructor) {
            kind$__12 |= FUNCTION_STATE_DERIVED_CONSTRUCTOR;
          }
          var fs$__13 = this.pushFunctionState_(kind$__12);
          var m$__14 = this.parseMethod_(start, isStatic, functionKind, name, annotations);
          this.popFunctionState_(fs$__13);
          if (isDerivedConstructor) {
            validateConstructor(m$__14, this.errorReporter_);
          }
          return m$__14;
        }
        return this.parsePropertyVariableDeclaration_(start, isStatic, name, annotations);
      },
      parseGetAccessor_: function(start, isStatic, annotations) {
        var name = this.parsePropertyName_();
        var fs = this.pushFunctionState_(FUNCTION_STATE_METHOD);
        this.eat_(OPEN_PAREN);
        this.eat_(CLOSE_PAREN);
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        var body = this.parseFunctionBody_(null);
        this.popFunctionState_(fs);
        return new GetAccessor(this.getTreeLocation_(start), isStatic, name, typeAnnotation, annotations, body);
      },
      parseSetAccessor_: function(start, isStatic, annotations) {
        var name = this.parsePropertyName_();
        var fs = this.pushFunctionState_(FUNCTION_STATE_METHOD);
        this.eat_(OPEN_PAREN);
        var parameterList = this.parsePropertySetParameterList_();
        this.eat_(CLOSE_PAREN);
        var body = this.parseFunctionBody_(parameterList);
        this.popFunctionState_(fs);
        return new SetAccessor(this.getTreeLocation_(start), isStatic, name, parameterList, annotations, body);
      },
      peekPropertyDefinition_: function(type) {
        return this.peekPropertyName_(type) || type === STAR && this.options_.propertyMethods && this.options_.generators || type === DOT_DOT_DOT && this.options_.spreadProperties;
      },
      peekPropertyName_: function(type) {
        switch (type) {
          case IDENTIFIER:
          case STRING:
          case NUMBER:
            return true;
          case OPEN_SQUARE:
            return this.options_.computedPropertyNames;
          default:
            return peekToken().isKeyword();
        }
      },
      peekPredefinedString_: function(string) {
        var token = peekToken();
        return token.type === IDENTIFIER && token.value === string;
      },
      parsePropertySetParameterList_: function() {
        var start = this.getTreeStartLocation_();
        var binding;
        this.pushAnnotations_();
        if (this.peekPattern_(peekType()))
          binding = this.parseBindingPattern_();
        else
          binding = this.parseBindingIdentifier_();
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        var parameter = new FormalParameter(this.getTreeLocation_(start), new BindingElement(this.getTreeLocation_(start), binding, null), typeAnnotation, this.popAnnotations_());
        return new FormalParameterList(parameter.location, [parameter]);
      },
      parsePrimaryExpressionStartingWithParen_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_PAREN);
        if (peek(FOR) && this.options_.generatorComprehension)
          return this.parseGeneratorComprehension_(start);
        return this.parseCoverFormals_(start);
      },
      parseSyntaxError_: function(message) {
        var token = nextToken();
        this.reportError_(token.location, message);
        return new SyntaxErrorTree(token.location, token, message);
      },
      parseUnexpectedToken_: function() {
        var token = arguments[0] !== (void 0) ? arguments[0] : peekToken();
        if (token.type === NO_SUBSTITUTION_TEMPLATE) {
          return this.parseSyntaxError_('Unexpected token `');
        }
        return this.parseSyntaxError_(("Unexpected token " + token));
      },
      parseUnexpectedReservedWord_: function(token) {
        return this.parseSyntaxError_(("Unexpected reserved word " + token));
      },
      parseExpression_: function(allowIn) {
        var coverInitializedNameCount = this.coverInitializedNameCount_;
        var expression = this.parseExpressionAllowPattern_(allowIn);
        this.ensureNoCoverInitializedNames_(expression, coverInitializedNameCount);
        return expression;
      },
      parseExpression: function() {
        var fs = this.pushFunctionState_(FUNCTION_STATE_LENIENT);
        var expression = this.parseExpression_(ALLOW_IN);
        this.popFunctionState_(fs);
        return expression;
      },
      parseExpressionAllowPattern_: function(allowIn) {
        var start = this.getTreeStartLocation_();
        var expression = this.parseAssignmentExpression_(allowIn);
        if (peek(COMMA)) {
          var expressions = [expression];
          while (this.eatIf_(COMMA)) {
            expressions.push(this.parseAssignmentExpression_(allowIn));
          }
          return new CommaExpression(this.getTreeLocation_(start), expressions);
        }
        return expression;
      },
      parseAssignmentExpression_: function(allowIn) {
        if (this.allowYield_ && peek(YIELD))
          return this.parseYieldExpression_(allowIn);
        var start = this.getTreeStartLocation_();
        var validAsyncParen = false;
        if (this.options_.asyncFunctions && this.peekPredefinedString_(ASYNC)) {
          var asyncToken = peekToken();
          var maybeOpenParenToken = peekTokenLookahead();
          validAsyncParen = maybeOpenParenToken.type === OPEN_PAREN && asyncToken.location.end.line === maybeOpenParenToken.location.start.line;
        }
        var left = this.parseConditional_(allowIn);
        var type = peekType();
        if (this.options_.asyncFunctions && left.type === IDENTIFIER_EXPRESSION && left.identifierToken.value === ASYNC && type === IDENTIFIER) {
          if (peekTokenNoLineTerminator() !== null) {
            var bindingIdentifier = this.parseBindingIdentifier_();
            var asyncToken$__15 = left.identifierToken;
            return this.parseArrowFunction_(start, bindingIdentifier, asyncToken$__15);
          }
        }
        if (type === ARROW && peekTokenNoLineTerminator() !== null) {
          if (left.type === COVER_FORMALS || left.type === IDENTIFIER_EXPRESSION)
            return this.parseArrowFunction_(start, left, null);
          if (validAsyncParen && left.type === CALL_EXPRESSION) {
            var asyncToken$__16 = left.operand.identifierToken;
            return this.parseArrowFunction_(start, left.args, asyncToken$__16);
          }
        }
        left = this.coverFormalsToParenExpression_(left);
        if (this.peekAssignmentOperator_(type)) {
          if (type === EQUAL)
            left = this.transformLeftHandSideExpression_(left);
          this.validateAssignmentTarget_(left, 'assignment');
          var operator = nextToken();
          var right = this.parseAssignmentExpression_(allowIn);
          return new BinaryExpression(this.getTreeLocation_(start), left, operator, right);
        }
        return left;
      },
      transformLeftHandSideExpression_: function(tree) {
        switch (tree.type) {
          case ARRAY_LITERAL:
          case OBJECT_LITERAL:
            resetScanner(tree.location.start.offset);
            return this.parseAssignmentPattern_();
        }
        return tree;
      },
      peekAssignmentOperator_: function(type) {
        return isAssignmentOperator(type);
      },
      parseConditional_: function(allowIn) {
        var start = this.getTreeStartLocation_();
        var condition = this.parseBinaryExpression_(allowIn);
        if (this.eatIf_(QUESTION)) {
          condition = this.toPrimaryExpression_(condition);
          var left = this.parseAssignmentExpression_(ALLOW_IN);
          this.eat_(COLON);
          var right = this.parseAssignmentExpression_(allowIn);
          return new ConditionalExpression(this.getTreeLocation_(start), condition, left, right);
        }
        return condition;
      },
      getPrecedence_: function(type, allowIn) {
        switch (type) {
          case OR:
            return 1;
          case AND:
            return 2;
          case BAR:
            return 3;
          case CARET:
            return 4;
          case AMPERSAND:
            return 5;
          case EQUAL_EQUAL:
          case EQUAL_EQUAL_EQUAL:
          case NOT_EQUAL:
          case NOT_EQUAL_EQUAL:
            return 6;
          case CLOSE_ANGLE:
          case GREATER_EQUAL:
          case INSTANCEOF:
          case LESS_EQUAL:
          case OPEN_ANGLE:
            return 7;
          case IN:
            return allowIn ? 7 : 0;
          case LEFT_SHIFT:
          case RIGHT_SHIFT:
          case UNSIGNED_RIGHT_SHIFT:
            return 8;
          case MINUS:
          case PLUS:
            return 9;
          case SLASH:
          case STAR:
          case PERCENT:
            return 10;
          case STAR_STAR:
            return this.options_.exponentiation ? 11 : 0;
          default:
            return 0;
        }
      },
      parseBinaryExpression_: function(allowIn) {
        var start = this.getTreeStartLocation_();
        var left = this.parseUnaryExpression_();
        return this.parseBinaryExpressionHelper_(start, left, -1, allowIn);
      },
      parseBinaryExpressionHelper_: function(start, left, minPrec, allowIn) {
        var type = peekType();
        var prec = this.getPrecedence_(type, allowIn);
        if (prec === 0) {
          return left;
        }
        var leftToRight = type !== STAR_STAR;
        if (leftToRight ? prec > minPrec : prec >= minPrec) {
          var token = nextToken();
          var rightStart = this.getTreeStartLocation_();
          var rightUnary = this.parseUnaryExpression_();
          var right = this.parseBinaryExpressionHelper_(rightStart, rightUnary, prec, allowIn);
          left = this.toPrimaryExpression_(left);
          right = this.toPrimaryExpression_(right);
          var node = new BinaryExpression(this.getTreeLocation_(start), left, token, right);
          return this.parseBinaryExpressionHelper_(start, node, minPrec, allowIn);
        }
        return left;
      },
      parseUnaryExpression_: function() {
        var start = this.getTreeStartLocation_();
        if (this.allowAwait_ && this.peekPredefinedString_(AWAIT)) {
          this.eatId_();
          var operand;
          if (this.allowYield_ && peek(YIELD)) {
            operand = this.parseYieldExpression_(ALLOW_IN);
          } else {
            operand = this.parseUnaryExpression_();
            operand = this.toPrimaryExpression_(operand);
          }
          return new AwaitExpression(this.getTreeLocation_(start), operand);
        }
        if (this.peekUnaryOperator_(peekType())) {
          var operator = nextToken();
          var operand$__17 = this.parseUnaryExpression_();
          operand$__17 = this.toPrimaryExpression_(operand$__17);
          if (operand$__17.type !== SYNTAX_ERROR_TREE) {
            switch (operator.type) {
              case PLUS_PLUS:
              case MINUS_MINUS:
                this.validateAssignmentTarget_(operand$__17, 'prefix operation');
            }
          }
          return new UnaryExpression(this.getTreeLocation_(start), operator, operand$__17);
        }
        return this.parsePostfixExpression_();
      },
      peekUnaryOperator_: function(type) {
        switch (type) {
          case DELETE:
          case VOID:
          case TYPEOF:
          case PLUS_PLUS:
          case MINUS_MINUS:
          case PLUS:
          case MINUS:
          case TILDE:
          case BANG:
            return true;
          default:
            return false;
        }
      },
      parsePostfixExpression_: function() {
        var start = this.getTreeStartLocation_();
        var operand = this.parseLeftHandSideExpression_();
        while (this.peekPostfixOperator_(peekType())) {
          operand = this.toPrimaryExpression_(operand);
          var operator = nextToken();
          this.validateAssignmentTarget_(operand, 'postfix operation');
          operand = new PostfixExpression(this.getTreeLocation_(start), operand, operator);
        }
        return operand;
      },
      peekPostfixOperator_: function(type) {
        switch (type) {
          case PLUS_PLUS:
          case MINUS_MINUS:
            {
              var token = peekTokenNoLineTerminator();
              return token !== null;
            }
        }
        return false;
      },
      parseLeftHandSideExpression_: function() {
        var start = this.getTreeStartLocation_();
        var operand = this.parseNewExpression_();
        if (!(operand instanceof NewExpression) || operand.args !== null) {
          loop: while (true) {
            switch (peekType()) {
              case OPEN_PAREN:
                operand = this.toPrimaryExpression_(operand);
                operand = this.parseCallExpression_(start, operand);
                break;
              case OPEN_SQUARE:
                operand = this.toPrimaryExpression_(operand);
                operand = this.parseMemberLookupExpression_(start, operand);
                break;
              case PERIOD:
                operand = this.toPrimaryExpression_(operand);
                operand = this.parseMemberExpression_(start, operand);
                break;
              case NO_SUBSTITUTION_TEMPLATE:
              case TEMPLATE_HEAD:
                if (!this.options_.templateLiterals)
                  break loop;
                operand = this.toPrimaryExpression_(operand);
                if (this.options_.templateLiterals) {
                  operand = this.parseTemplateLiteral_(operand);
                }
                break;
              default:
                break loop;
            }
          }
        }
        return operand;
      },
      parseMemberExpressionNoNew_: function() {
        var start = this.getTreeStartLocation_();
        var operand;
        if (peekType() === FUNCTION) {
          operand = this.parseFunctionExpression_();
        } else {
          operand = this.parsePrimaryExpression_();
        }
        loop: while (true) {
          switch (peekType()) {
            case OPEN_SQUARE:
              operand = this.toPrimaryExpression_(operand);
              operand = this.parseMemberLookupExpression_(start, operand);
              break;
            case PERIOD:
              operand = this.toPrimaryExpression_(operand);
              operand = this.parseMemberExpression_(start, operand);
              break;
            case NO_SUBSTITUTION_TEMPLATE:
            case TEMPLATE_HEAD:
              if (!this.options_.templateLiterals)
                break loop;
              operand = this.toPrimaryExpression_(operand);
              operand = this.parseTemplateLiteral_(operand);
              break;
            default:
              break loop;
          }
        }
        return operand;
      },
      parseMemberExpression_: function(start, operand) {
        this.eat_(PERIOD);
        var name = this.eatIdName_();
        return new MemberExpression(this.getTreeLocation_(start), operand, name);
      },
      parseMemberLookupExpression_: function(start, operand) {
        this.eat_(OPEN_SQUARE);
        var member = this.parseExpression_(ALLOW_IN);
        this.eat_(CLOSE_SQUARE);
        return new MemberLookupExpression(this.getTreeLocation_(start), operand, member);
      },
      parseCallExpression_: function(start, operand) {
        var args = this.parseArguments_();
        return new CallExpression(this.getTreeLocation_(start), operand, args);
      },
      parseNewExpression_: function() {
        var operand,
            start;
        switch (peekType()) {
          case NEW:
            {
              start = this.getTreeStartLocation_();
              this.eat_(NEW);
              if (peek(SUPER)) {
                operand = this.parseSuperExpression_(true);
              } else {
                operand = this.toPrimaryExpression_(this.parseNewExpression_());
              }
              var args = null;
              if (peek(OPEN_PAREN)) {
                args = this.parseArguments_();
              }
              return new NewExpression(this.getTreeLocation_(start), operand, args);
            }
          case SUPER:
            return this.parseSuperExpression_(false);
          default:
            return this.parseMemberExpressionNoNew_();
        }
      },
      parseArguments_: function() {
        var start = this.getTreeStartLocation_();
        var args = [];
        this.eat_(OPEN_PAREN);
        if (!peek(CLOSE_PAREN)) {
          args.push(this.parseArgument_());
          while (this.eatIf_(COMMA)) {
            args.push(this.parseArgument_());
          }
        }
        this.eat_(CLOSE_PAREN);
        return new ArgumentList(this.getTreeLocation_(start), args);
      },
      parseArgument_: function() {
        if (this.peekSpread_(peekType()))
          return this.parseSpreadExpression_();
        return this.parseAssignmentExpression_(ALLOW_IN);
      },
      parseArrowFunction_: function(start, tree, asyncToken) {
        var $__3 = this;
        var formals;
        var kind = FUNCTION_STATE_ARROW;
        if (asyncToken && asyncToken.value === ASYNC) {
          kind |= FUNCTION_STATE_ASYNC;
        }
        var fs = this.pushFunctionState_(kind);
        var makeFormals = function(tree) {
          return new FormalParameterList($__3.getTreeLocation_(start), [new FormalParameter(tree.location, new BindingElement(tree.location, tree, null), null, [])]);
        };
        switch (tree.type) {
          case IDENTIFIER_EXPRESSION:
            formals = makeFormals(new BindingIdentifier(tree.location, tree.identifierToken));
            break;
          case BINDING_IDENTIFIER:
            formals = makeFormals(tree);
            break;
          case FORMAL_PARAMETER_LIST:
            formals = tree;
            break;
          default:
            formals = this.toFormalParameters_(start, tree, asyncToken);
        }
        this.eat_(ARROW);
        var body = this.parseConciseBody_(formals);
        this.popFunctionState_(fs);
        return new ArrowFunction(this.getTreeLocation_(start), asyncToken, formals, body);
      },
      parseCoverFormals_: function(start) {
        var expressions = [];
        if (!peek(CLOSE_PAREN)) {
          do {
            var type = peekType();
            if (this.peekRest_(type)) {
              expressions.push(this.parseRestParameter_());
              break;
            } else {
              expressions.push(this.parseAssignmentExpression_(ALLOW_IN));
            }
            if (this.eatIf_(COMMA))
              continue;
          } while (!peek(CLOSE_PAREN) && !isAtEnd());
        }
        this.eat_(CLOSE_PAREN);
        return new CoverFormals(this.getTreeLocation_(start), expressions);
      },
      ensureNoCoverInitializedNames_: function(tree, coverInitializedNameCount) {
        if (coverInitializedNameCount === this.coverInitializedNameCount_)
          return;
        var finder = new ValidateObjectLiteral();
        finder.visitAny(tree);
        if (finder.found) {
          var token = finder.errorToken;
          this.reportError_(token.location, ("Unexpected token " + token));
        }
      },
      toPrimaryExpression_: function(tree) {
        if (tree.type === COVER_FORMALS)
          return this.coverFormalsToParenExpression_(tree);
        return tree;
      },
      validateCoverFormalsAsParenExpression_: function(tree) {
        for (var i = 0; i < tree.expressions.length; i++) {
          if (tree.expressions[i].type === REST_PARAMETER) {
            var token = new Token(DOT_DOT_DOT, tree.expressions[i].location);
            this.reportError_(token.location, ("Unexpected token " + token));
            return;
          }
        }
      },
      coverFormalsToParenExpression_: function(tree) {
        if (tree.type === COVER_FORMALS) {
          var expressions = tree.expressions;
          if (expressions.length === 0) {
            var message = 'Unexpected token )';
            this.reportError_(tree.location, message);
          } else {
            this.validateCoverFormalsAsParenExpression_(tree);
            var expression;
            if (expressions.length > 1)
              expression = new CommaExpression(expressions[0].location, expressions);
            else
              expression = expressions[0];
            return new ParenExpression(tree.location, expression);
          }
        }
        return tree;
      },
      toFormalParameters_: function(start, tree, asyncToken) {
        resetScanner(start.offset);
        return this.parseArrowFormalParameters_(asyncToken);
      },
      parseArrowFormalParameters_: function(asyncToken) {
        if (asyncToken)
          this.eat_(IDENTIFIER);
        this.eat_(OPEN_PAREN);
        var parameters = this.parseFormalParameters_();
        this.eat_(CLOSE_PAREN);
        return parameters;
      },
      peekArrow_: function(type) {
        return type === ARROW && this.options_.arrowFunctions;
      },
      parseConciseBody_: function(params) {
        if (peek(OPEN_CURLY))
          return this.parseFunctionBody_(params);
        validateParameters(params, this.strictMode_, this.errorReporter_);
        return this.parseAssignmentExpression_(ALLOW_IN);
      },
      parseGeneratorComprehension_: function(start) {
        var comprehensionList = this.parseComprehensionList_();
        var expression = this.parseAssignmentExpression_(ALLOW_IN);
        this.eat_(CLOSE_PAREN);
        return new GeneratorComprehension(this.getTreeLocation_(start), comprehensionList, expression);
      },
      parseForBinding_: function() {
        if (this.peekPattern_(peekType()))
          return this.parseBindingPattern_();
        return this.parseBindingIdentifier_();
      },
      peekPattern_: function(type) {
        return this.options_.destructuring && (this.peekObjectPattern_(type) || this.peekArrayPattern_(type));
      },
      peekArrayPattern_: function(type) {
        return type === OPEN_SQUARE;
      },
      peekObjectPattern_: function(type) {
        return type === OPEN_CURLY;
      },
      parseBindingPattern_: function() {
        return this.parsePattern_(true);
      },
      parsePattern_: function(useBinding) {
        if (this.peekArrayPattern_(peekType()))
          return this.parseArrayPattern_(useBinding);
        return this.parseObjectPattern_(useBinding);
      },
      parseArrayBindingPattern_: function() {
        return this.parseArrayPattern_(true);
      },
      parsePatternElement_: function(useBinding) {
        return useBinding ? this.parseBindingElement_() : this.parseAssignmentElement_();
      },
      parsePatternRestElement_: function(useBinding) {
        return useBinding ? this.parseBindingRestElement_() : this.parseAssignmentRestElement_();
      },
      parseArrayPattern_: function(useBinding) {
        var start = this.getTreeStartLocation_();
        var elements = [];
        this.eat_(OPEN_SQUARE);
        while (true) {
          var type = peekType();
          if (type === COMMA) {
            elements.push(null);
          } else if (this.peekSpread_(type)) {
            elements.push(this.parsePatternRestElement_(useBinding));
            break;
          } else if (type === CLOSE_SQUARE || type === END_OF_FILE) {
            break;
          } else {
            elements.push(this.parsePatternElement_(useBinding));
          }
          type = peekType();
          if (type !== CLOSE_SQUARE) {
            this.eat_(COMMA);
          }
        }
        this.eat_(CLOSE_SQUARE);
        return new ArrayPattern(this.getTreeLocation_(start), elements);
      },
      parseBindingElementList_: function(elements) {
        this.parseElisionOpt_(elements);
        elements.push(this.parseBindingElement_());
        while (this.eatIf_(COMMA)) {
          this.parseElisionOpt_(elements);
          elements.push(this.parseBindingElement_());
        }
      },
      parseElisionOpt_: function(elements) {
        while (this.eatIf_(COMMA)) {
          elements.push(null);
        }
      },
      peekBindingElement_: function(type) {
        return this.peekBindingIdentifier_(type) || this.peekPattern_(type);
      },
      parseBindingElement_: function() {
        var start = this.getTreeStartLocation_();
        var binding = this.parseBindingElementBinding_();
        var initializer = this.parseBindingElementInitializer_(INITIALIZER_OPTIONAL);
        return new BindingElement(this.getTreeLocation_(start), binding, initializer);
      },
      parseBindingElementBinding_: function() {
        if (this.peekPattern_(peekType()))
          return this.parseBindingPattern_();
        return this.parseBindingIdentifier_();
      },
      parseBindingElementInitializer_: function(initializerRequired) {
        if (peek(EQUAL) || initializerRequired) {
          return this.parseInitializer_(ALLOW_IN);
        }
        return null;
      },
      parseBindingRestElement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(DOT_DOT_DOT);
        var identifier = this.parseBindingIdentifier_();
        return new SpreadPatternElement(this.getTreeLocation_(start), identifier);
      },
      parseObjectPattern_: function(useBinding) {
        var start = this.getTreeStartLocation_();
        var elements = [];
        this.eat_(OPEN_CURLY);
        var type;
        while ((type = peekType()) !== CLOSE_CURLY && type !== END_OF_FILE) {
          elements.push(this.parsePatternProperty_(useBinding));
          if (!this.eatIf_(COMMA))
            break;
        }
        this.eat_(CLOSE_CURLY);
        return new ObjectPattern(this.getTreeLocation_(start), elements);
      },
      parsePatternProperty_: function(useBinding) {
        var start = this.getTreeStartLocation_();
        var name = this.parsePropertyName_();
        var requireColon = name.type !== LITERAL_PROPERTY_NAME || !name.literalToken.isStrictKeyword() && name.literalToken.type !== IDENTIFIER;
        if (requireColon || peek(COLON)) {
          this.eat_(COLON);
          var element = this.parsePatternElement_(useBinding);
          return new ObjectPatternField(this.getTreeLocation_(start), name, element);
        }
        var token = name.literalToken;
        if (this.strictMode_ && token.isStrictKeyword())
          this.reportReservedIdentifier_(token);
        if (useBinding) {
          var binding = new BindingIdentifier(name.location, token);
          var initializer$__18 = this.parseInitializerOpt_(ALLOW_IN);
          return new BindingElement(this.getTreeLocation_(start), binding, initializer$__18);
        }
        var assignment = new IdentifierExpression(name.location, token);
        var initializer = this.parseInitializerOpt_(ALLOW_IN);
        return new AssignmentElement(this.getTreeLocation_(start), assignment, initializer);
      },
      parseAssignmentPattern_: function() {
        return this.parsePattern_(false);
      },
      parseArrayAssignmentPattern_: function() {
        return this.parseArrayPattern_(false);
      },
      parseAssignmentElement_: function() {
        var start = this.getTreeStartLocation_();
        var assignment = this.parseDestructuringAssignmentTarget_();
        var initializer = this.parseInitializerOpt_(ALLOW_IN);
        return new AssignmentElement(this.getTreeLocation_(start), assignment, initializer);
      },
      parseDestructuringAssignmentTarget_: function() {
        switch (peekType()) {
          case OPEN_SQUARE:
            return this.parseArrayAssignmentPattern_();
          case OPEN_CURLY:
            return this.parseObjectAssignmentPattern_();
        }
        var expression = this.parseLeftHandSideExpression_();
        expression = this.coverFormalsToParenExpression_(expression);
        this.validateAssignmentTarget_(expression, 'assignment');
        return expression;
      },
      parseAssignmentRestElement_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(DOT_DOT_DOT);
        var id = this.parseDestructuringAssignmentTarget_();
        return new SpreadPatternElement(this.getTreeLocation_(start), id);
      },
      parseObjectAssignmentPattern_: function() {
        return this.parseObjectPattern_(false);
      },
      parseAssignmentProperty_: function() {
        return this.parsePatternProperty_(false);
      },
      parseTemplateLiteral_: function(operand) {
        var start = operand ? operand.location.start : this.getTreeStartLocation_();
        var token = nextToken();
        var elements = [new TemplateLiteralPortion(token.location, token)];
        if (token.type === NO_SUBSTITUTION_TEMPLATE) {
          return new TemplateLiteralExpression(this.getTreeLocation_(start), operand, elements);
        }
        var expression = this.parseExpression_(ALLOW_IN);
        elements.push(new TemplateSubstitution(expression.location, expression));
        while (expression.type !== SYNTAX_ERROR_TREE) {
          token = nextTemplateLiteralToken();
          if (token.type === ERROR || token.type === END_OF_FILE)
            break;
          elements.push(new TemplateLiteralPortion(token.location, token));
          if (token.type === TEMPLATE_TAIL)
            break;
          expression = this.parseExpression_(ALLOW_IN);
          elements.push(new TemplateSubstitution(expression.location, expression));
        }
        return new TemplateLiteralExpression(this.getTreeLocation_(start), operand, elements);
      },
      parseTypeAnnotationOpt_: function() {
        if (this.options_.types && this.eatOpt_(COLON)) {
          return this.parseType_();
        }
        return null;
      },
      parseType_: function() {
        switch (peekType()) {
          case NEW:
            return this.parseConstructorType_();
          case OPEN_PAREN:
          case OPEN_ANGLE:
            return this.parseFunctionType_();
        }
        var start = this.getTreeStartLocation_();
        var elementType = this.parsePrimaryType_();
        return this.parseUnionTypeSuffix_(start, elementType);
      },
      parsePrimaryType_: function() {
        var start = this.getTreeStartLocation_();
        var elementType,
            token;
        switch (peekType()) {
          case VOID:
            token = nextToken();
            elementType = new PredefinedType(this.getTreeLocation_(start), token);
            break;
          case IDENTIFIER:
            switch (peekToken().value) {
              case 'any':
              case 'boolean':
              case 'number':
              case 'string':
              case 'symbol':
                token = nextToken();
                elementType = new PredefinedType(this.getTreeLocation_(start), token);
                break;
              default:
                elementType = this.parseTypeReference_();
            }
            break;
          case TYPEOF:
            elementType = this.parseTypeQuery_(start);
            break;
          case OPEN_CURLY:
            elementType = this.parseObjectType_();
            break;
          default:
            return this.parseUnexpectedToken_();
        }
        return this.parseArrayTypeSuffix_(start, elementType);
      },
      parseTypeReference_: function() {
        var start = this.getTreeStartLocation_();
        var typeName = this.parseTypeName_();
        var args = null;
        if (peek(OPEN_ANGLE)) {
          var args$__19 = this.parseTypeArguments_();
          return new TypeReference(this.getTreeLocation_(start), typeName, args$__19);
        }
        return typeName;
      },
      parseUnionTypeSuffix_: function(start, elementType) {
        if (peek(BAR)) {
          var types = [elementType];
          this.eat_(BAR);
          while (true) {
            types.push(this.parsePrimaryType_());
            if (!this.eatIf_(BAR)) {
              break;
            }
          }
          return new UnionType(this.getTreeLocation_(start), types);
        }
        return elementType;
      },
      parseArrayTypeSuffix_: function(start, elementType) {
        var token = peekTokenNoLineTerminator();
        if (token && token.type === OPEN_SQUARE) {
          this.eat_(OPEN_SQUARE);
          this.eat_(CLOSE_SQUARE);
          elementType = new ArrayType(this.getTreeLocation_(start), elementType);
          return this.parseArrayTypeSuffix_(start, elementType);
        }
        return elementType;
      },
      parseTypeArguments_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_ANGLE);
        var args = [this.parseType_()];
        while (peek(COMMA)) {
          this.eat_(COMMA);
          args.push(this.parseType_());
        }
        var token = nextCloseAngle();
        if (token.type !== CLOSE_ANGLE) {
          return this.parseUnexpectedToken_(token);
        }
        return new TypeArguments(this.getTreeLocation_(start), args);
      },
      parseConstructorType_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(NEW);
        var typeParameters = this.parseTypeParametersOpt_();
        this.eat_(OPEN_PAREN);
        var parameterList = this.parseFormalParameters_();
        this.eat_(CLOSE_PAREN);
        this.eat_(ARROW);
        var returnType = this.parseType_();
        return new ConstructorType(this.getTreeLocation_(start), typeParameters, parameterList, returnType);
      },
      parseObjectType_: function() {
        var start = this.getTreeStartLocation_();
        var typeMembers = [];
        this.eat_(OPEN_CURLY);
        var type;
        while (this.peekTypeMember_(type = peekType())) {
          typeMembers.push(this.parseTypeMember_(type));
          if (!this.eatIf_(SEMI_COLON)) {
            break;
          }
        }
        this.eat_(CLOSE_CURLY);
        return new ObjectType(this.getTreeLocation_(start), typeMembers);
      },
      peekTypeMember_: function(type) {
        switch (type) {
          case NEW:
          case OPEN_PAREN:
          case OPEN_ANGLE:
          case OPEN_SQUARE:
          case IDENTIFIER:
          case STRING:
          case NUMBER:
            return true;
          default:
            return peekToken().isKeyword();
        }
      },
      parseTypeMember_: function(type) {
        switch (type) {
          case NEW:
            return this.parseConstructSignature_();
          case OPEN_PAREN:
          case OPEN_ANGLE:
            return this.parseCallSignature_();
          case OPEN_SQUARE:
            return this.parseIndexSignature_();
        }
        var start = this.getTreeStartLocation_();
        var propertyName = this.parseLiteralPropertyName_();
        var isOpt = this.eatIf_(QUESTION);
        type = peekType();
        if (type === OPEN_ANGLE || type === OPEN_PAREN) {
          var callSignature = this.parseCallSignature_();
          return new MethodSignature(this.getTreeLocation_(start), propertyName, isOpt, callSignature);
        }
        var typeAnnotation = this.parseTypeAnnotationOpt_();
        return new PropertySignature(this.getTreeLocation_(start), propertyName, isOpt, typeAnnotation);
      },
      parseCallSignature_: function() {
        var start = this.getTreeStartLocation_();
        var typeParameters = this.parseTypeParametersOpt_();
        this.eat_(OPEN_PAREN);
        var parameterList = this.parseFormalParameters_();
        this.eat_(CLOSE_PAREN);
        var returnType = this.parseTypeAnnotationOpt_();
        return new CallSignature(this.getTreeLocation_(start), typeParameters, parameterList, returnType);
      },
      parseConstructSignature_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(NEW);
        var typeParameters = this.parseTypeParametersOpt_();
        this.eat_(OPEN_PAREN);
        var parameterList = this.parseFormalParameters_();
        this.eat_(CLOSE_PAREN);
        var returnType = this.parseTypeAnnotationOpt_();
        return new ConstructSignature(this.getTreeLocation_(start), typeParameters, parameterList, returnType);
      },
      parseIndexSignature_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_SQUARE);
        var id = this.eatId_();
        this.eat_(COLON);
        var typeName;
        var typeStart = this.getTreeStartLocation_();
        if (this.peekPredefinedString_('string')) {
          typeName = this.eatId_('string');
        } else {
          typeName = this.eatId_('number');
        }
        var indexType = new PredefinedType(this.getTreeLocation_(typeStart), typeName);
        this.eat_(CLOSE_SQUARE);
        this.eat_(COLON);
        var typeAnnotation = this.parseType_();
        return new IndexSignature(this.getTreeLocation_(start), id, indexType, typeAnnotation);
      },
      parseFunctionType_: function() {
        var start = this.getTreeStartLocation_();
        var typeParameters = this.parseTypeParametersOpt_();
        this.eat_(OPEN_PAREN);
        var parameterList = this.parseFormalParameters_();
        this.eat_(CLOSE_PAREN);
        this.eat_(ARROW);
        var returnType = this.parseType_();
        return new FunctionType(this.getTreeLocation_(start), typeParameters, parameterList, returnType);
      },
      parseTypeQuery_: function(start) {
        throw 'NYI';
      },
      peekTypeParameters_: function() {
        return peek(OPEN_ANGLE);
      },
      parseTypeParametersOpt_: function() {
        if (peek(OPEN_ANGLE)) {
          return this.parseTypeParameters_();
        }
        return null;
      },
      parseTypeParameters_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(OPEN_ANGLE);
        var parameters = [this.parseTypeParameter_()];
        while (peek(COMMA)) {
          this.eat_(COMMA);
          parameters.push(this.parseTypeParameter_());
        }
        this.eat_(CLOSE_ANGLE);
        return new TypeParameters(this.getTreeLocation_(start), parameters);
      },
      parseTypeParameter_: function() {
        var start = this.getTreeStartLocation_();
        var id = this.eatId_();
        var extendsType = null;
        if (this.eatIf_(EXTENDS)) {
          extendsType = this.parseType_();
        }
        return new TypeParameter(this.getTreeLocation_(start), id, extendsType);
      },
      parseNamedOrPredefinedType_: function() {
        var start = this.getTreeStartLocation_();
        switch (peekToken().value) {
          case 'any':
          case 'number':
          case 'boolean':
          case 'string':
            {
              var token = nextToken();
              return new PredefinedType(this.getTreeLocation_(start), token);
            }
          default:
            return this.parseTypeName_();
        }
      },
      parseTypeName_: function() {
        var start = this.getTreeStartLocation_();
        var id = this.eatId_();
        var typeName = new TypeName(this.getTreeLocation_(start), null, id);
        while (this.eatIf_(PERIOD)) {
          var memberName = this.eatIdName_();
          typeName = new TypeName(this.getTreeLocation_(start), typeName, memberName);
        }
        return typeName;
      },
      parseInterfaceDeclaration_: function() {
        var start = this.getTreeStartLocation_();
        this.eat_(INTERFACE);
        var name = this.eatId_();
        var typeParameters = this.parseTypeParametersOpt_();
        var extendsClause;
        if (this.eatIf_(EXTENDS)) {
          extendsClause = this.parseInterfaceExtendsClause_();
        } else {
          extendsClause = [];
        }
        var objectType = this.parseObjectType_();
        return new InterfaceDeclaration(this.getTreeLocation_(start), name, typeParameters, extendsClause, objectType);
      },
      parseInterfaceExtendsClause_: function() {
        var result = [this.parseTypeReference_()];
        while (this.eatIf_(COMMA)) {
          result.push(this.parseTypeReference_());
        }
        return result;
      },
      parseAnnotatedDeclarations_: function(parsingModuleItem) {
        this.pushAnnotations_();
        var declaration;
        var type = peekType();
        if (parsingModuleItem) {
          declaration = this.parseModuleItem_(type);
        } else {
          declaration = this.parseStatementListItem_(type);
        }
        if (this.annotations_.length > 0) {
          this.reportError_(this.annotations_[0].location, 'Unsupported annotated expression');
        }
        return declaration;
      },
      parseAnnotations_: function() {
        var annotations = [];
        while (this.eatIf_(AT)) {
          annotations.push(this.parseAnnotation_());
        }
        return annotations;
      },
      pushAnnotations_: function() {
        this.annotations_ = this.parseAnnotations_();
      },
      popAnnotations_: function() {
        var annotations = this.annotations_;
        this.annotations_ = [];
        return annotations;
      },
      parseAnnotation_: function() {
        var start = this.getTreeStartLocation_();
        var expression = this.parseMemberExpressionNoNew_();
        var args = null;
        if (peek(OPEN_PAREN))
          args = this.parseArguments_();
        return new Annotation(this.getTreeLocation_(start), expression, args);
      },
      parseTypeAliasDeclaration_: function() {
        var start = this.getTreeStartLocation_();
        this.eatId_(TYPE);
        var name = this.eatId_();
        this.eat_(EQUAL);
        var type = this.parseType_();
        this.eatPossibleImplicitSemiColon_();
        return new TypeAliasDeclaration(this.getTreeLocation_(start), name, type);
      },
      parseJsxElement_: function() {
        var token = this.eatJsx_(OPEN_ANGLE);
        return this.parseJsxElementContinuation_(token.location.start);
      },
      parseJsxElementContinuation_: function(start) {
        var name = this.parseJsxElementName_();
        var attrs = this.parseJsxAttributes_();
        var children = [];
        switch (peekJsxToken().type) {
          case SLASH:
            nextJsxToken();
            this.eat_(CLOSE_ANGLE);
            break;
          case CLOSE_ANGLE:
            {
              nextJsxTextToken();
              loop: while (true) {
                var token = nextJsxTextToken();
                switch (token.type) {
                  case STRING:
                    {
                      children.push(new JsxText(token.location, token));
                      continue;
                    }
                  case OPEN_CURLY:
                    {
                      var start$__20 = token.location.start;
                      var expression = null;
                      if (!peek(CLOSE_CURLY)) {
                        expression = this.parseAssignmentExpression_(ALLOW_IN);
                      }
                      this.eatJsx_(CLOSE_CURLY);
                      var placeHolder = new JsxPlaceholder(this.getTreeLocation_(start$__20), expression);
                      children.push(placeHolder);
                      continue;
                    }
                  case OPEN_ANGLE:
                    {
                      var start$__21 = token.location.start;
                      if (peekJsxToken().type === SLASH) {
                        nextJsxToken();
                        break loop;
                      }
                      var subElement = this.parseJsxElementContinuation_(start$__21);
                      children.push(subElement);
                      resetScanner(subElement.location.end.offset);
                      continue;
                    }
                  default:
                    return this.parseSyntaxError_('Unexpected token');
                }
              }
              var closeName = this.parseJsxElementName_();
              if (!jsxNamesEqual(name, closeName)) {
                this.reportError_(closeName.location, ("Non matching JSX closing tag. Expected " + jsxNameToString(name) + ", found " + jsxNameToString(closeName)));
              }
              this.eat_(CLOSE_ANGLE);
              break;
            }
          default:
            return this.parseSyntaxError_('Unexpected token');
        }
        var element = new JsxElement(this.getTreeLocation_(start), name, attrs, children);
        return element;
      },
      parseJsxElementName_: function() {
        var tokens = [];
        var id = this.eatJsx_(JSX_IDENTIFIER);
        var start = id.location.start;
        tokens.push(id);
        while (peekJsxToken().type === PERIOD) {
          nextJsxToken();
          var id$__22 = this.eatJsx_(JSX_IDENTIFIER);
          tokens.push(id$__22);
        }
        return new JsxElementName(this.getTreeLocation_(start), tokens);
      },
      parseJsxAttributes_: function() {
        var attributes = [];
        loop: while (true) {
          switch (peekJsxToken().type) {
            case JSX_IDENTIFIER:
              attributes.push(this.parseJsxAttribute_());
              break;
            case OPEN_CURLY:
              attributes.push(this.parseJsxSpreadAttribute_());
              break;
            default:
              break loop;
          }
        }
        return attributes;
      },
      parseJsxAttribute_: function() {
        var name = this.eatJsx_(JSX_IDENTIFIER);
        var start = name.location.start;
        var value = null;
        if (peekJsxToken().type === EQUAL) {
          this.eatJsx_(EQUAL);
          value = this.parseJsxAttributeValue_();
        }
        return new JsxAttribute(this.getTreeLocation_(start), name, value);
      },
      parseJsxAttributeValue_: function() {
        var token = peekJsxToken();
        var start = token.location.start;
        switch (token.type) {
          case STRING:
            nextJsxToken();
            return new LiteralExpression(this.getTreeLocation_(start), token);
          case OPEN_CURLY:
            {
              nextJsxToken();
              var expr = this.parseAssignmentExpression_(ALLOW_IN);
              this.eatJsx_(CLOSE_CURLY);
              return new JsxPlaceholder(this.getTreeLocation_(start), expr);
            }
          case OPEN_ANGLE:
            return this.parseJsxElement_();
        }
        return this.parseSyntaxError_('Unexpected token');
      },
      parseJsxSpreadAttribute_: function() {
        var token = peekJsxToken();
        var start = token.location.start;
        nextJsxToken();
        this.eatJsx_(DOT_DOT_DOT);
        var expr = this.parseAssignmentExpression_(ALLOW_IN);
        this.eatJsx_(CLOSE_CURLY);
        return new JsxSpreadAttribute(this.getTreeLocation_(start), expr);
      },
      eatPossibleImplicitSemiColon_: function() {
        var token = peekTokenNoLineTerminator();
        if (!token)
          return;
        switch (token.type) {
          case SEMI_COLON:
            nextToken();
            return;
          case END_OF_FILE:
          case CLOSE_CURLY:
            return;
        }
        this.reportError_(token.location, 'Semi-colon expected');
      },
      peekImplicitSemiColon_: function() {
        switch (peekType()) {
          case SEMI_COLON:
          case CLOSE_CURLY:
          case END_OF_FILE:
            return true;
        }
        var token = peekTokenNoLineTerminator();
        return token === null;
      },
      eatOpt_: function(expectedTokenType) {
        if (peek(expectedTokenType))
          return nextToken();
        return null;
      },
      eatIdOpt_: function() {
        return peek(IDENTIFIER) ? this.eatId_() : null;
      },
      eatId_: function() {
        var expected = arguments[0];
        var token = nextToken();
        if (token.type === IDENTIFIER) {
          if (expected && token.value !== expected)
            this.reportExpectedError_(token, expected);
          return token;
        }
        if (token.isStrictKeyword()) {
          if (this.strictMode_) {
            this.reportReservedIdentifier_(token);
          } else {
            return new IdentifierToken(token.location, token.type);
          }
        } else {
          this.reportExpectedError_(token, expected || 'identifier');
        }
        return token;
      },
      eatIdName_: function() {
        var t = nextToken();
        if (t.type !== IDENTIFIER) {
          if (!t.isKeyword()) {
            this.reportExpectedError_(t, 'identifier');
            return null;
          }
          return new IdentifierToken(t.location, t.type);
        }
        return t;
      },
      eat_: function(expectedTokenType) {
        return this.isExpectedToken_(nextToken(), expectedTokenType);
      },
      eatIf_: function(expectedTokenType) {
        if (peek(expectedTokenType)) {
          nextToken();
          return true;
        }
        return false;
      },
      eatJsx_: function(expectedTokenType) {
        return this.isExpectedToken_(nextJsxToken(), expectedTokenType);
      },
      isExpectedToken_: function(token, expectedTokenType) {
        if (token.type !== expectedTokenType) {
          this.reportExpectedError_(token, expectedTokenType);
        }
        return token;
      },
      reportExpectedError_: function(token, expected) {
        this.reportError_(token.location, ("Unexpected token " + token));
      },
      getTreeStartLocation_: function() {
        return peekLocation().start;
      },
      getTreeEndLocation_: function() {
        return getLastToken().location.end;
      },
      getTreeLocation_: function(start) {
        return new SourceRange(start, this.getTreeEndLocation_());
      },
      handleComment: function(range) {},
      isAtEnd: function() {
        return isAtEnd();
      },
      reportError_: function(location, message) {
        this.errorReporter_.reportError(location, message);
      },
      reportReservedIdentifier_: function(token) {
        this.reportError_(token.location, (token.type + " is a reserved identifier"));
      },
      validateAssignmentTarget_: function(tree, operation) {
        if (!tree.isPattern() && !isValidSimpleAssignmentTarget(tree, this.strictMode_)) {
          this.reportError_(tree.location, ("Invalid left-hand side expression in " + operation));
        }
      }
    }, {});
  }();
  function jsxNamesEqual(name, other) {
    if (name.names.length !== other.names.length) {
      return false;
    }
    for (var i = 0; i < name.names.length; i++) {
      if (name.names[i].value !== other.names[i].value) {
        return false;
      }
    }
    return true;
  }
  function jsxNameToString(name) {
    return name.names.join('.');
  }
  return {get Parser() {
      return Parser;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/SourcePosition.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/SourcePosition.js";
  var SourcePosition = function() {
    function SourcePosition(source, offset) {
      this.source = source;
      this.offset = offset;
      this.line_ = -1;
      this.column_ = -1;
    }
    return ($traceurRuntime.createClass)(SourcePosition, {
      get line() {
        if (this.line_ === -1)
          this.line_ = this.source.lineNumberTable.getLine(this.offset);
        return this.line_;
      },
      get column() {
        if (this.column_ === -1)
          this.column_ = this.source.lineNumberTable.getColumn(this.offset);
        return this.column_;
      },
      toString: function() {
        var name = this.source ? this.source.name : '';
        return (name + ":" + (this.line + 1) + ":" + (this.column + 1));
      }
    }, {});
  }();
  return {get SourcePosition() {
      return SourcePosition;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/LineNumberTable.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/LineNumberTable.js";
  var SourcePosition = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/SourcePosition.js", "traceur@0.0.112/src/syntax/LineNumberTable.js")).SourcePosition;
  var SourceRange = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/SourceRange.js", "traceur@0.0.112/src/syntax/LineNumberTable.js")).SourceRange;
  var isLineTerminator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Scanner.js", "traceur@0.0.112/src/syntax/LineNumberTable.js")).isLineTerminator;
  var MAX_INT_REPRESENTATION = 9007199254740992;
  function computeLineStartOffsets(source) {
    var lineStartOffsets = [0];
    var k = 1;
    for (var index = 0; index < source.length; index++) {
      var code = source.charCodeAt(index);
      if (isLineTerminator(code)) {
        if (code === 13 && source.charCodeAt(index + 1) === 10) {
          index++;
        }
        lineStartOffsets[k++] = index + 1;
      }
    }
    lineStartOffsets[k++] = MAX_INT_REPRESENTATION;
    return lineStartOffsets;
  }
  var LineNumberTable = function() {
    function LineNumberTable(sourceFile) {
      this.sourceFile_ = sourceFile;
      this.lineStartOffsets_ = null;
      this.lastLine_ = 0;
      this.lastOffset_ = -1;
    }
    return ($traceurRuntime.createClass)(LineNumberTable, {
      ensureLineStartOffsets_: function() {
        if (!this.lineStartOffsets_) {
          this.lineStartOffsets_ = computeLineStartOffsets(this.sourceFile_.contents);
        }
      },
      getSourcePosition: function(offset) {
        return new SourcePosition(this.sourceFile_, offset);
      },
      getLine: function(offset) {
        if (offset === this.lastOffset_)
          return this.lastLine_;
        this.ensureLineStartOffsets_();
        if (offset < 0)
          return 0;
        var line;
        if (offset < this.lastOffset_) {
          for (var i = this.lastLine_; i >= 0; i--) {
            if (this.lineStartOffsets_[i] <= offset) {
              line = i;
              break;
            }
          }
        } else {
          for (var i$__1 = this.lastLine_; true; i$__1++) {
            if (this.lineStartOffsets_[i$__1] > offset) {
              line = i$__1 - 1;
              break;
            }
          }
        }
        this.lastLine_ = line;
        this.lastOffset_ = offset;
        return line;
      },
      offsetOfLine: function(line) {
        this.ensureLineStartOffsets_();
        return this.lineStartOffsets_[line];
      },
      getColumn: function(offset) {
        var line = this.getLine(offset);
        return offset - this.lineStartOffsets_[line];
      },
      getSourceRange: function(startOffset, endOffset) {
        return new SourceRange(this.getSourcePosition(startOffset), this.getSourcePosition(endOffset));
      }
    }, {});
  }();
  return {get LineNumberTable() {
      return LineNumberTable;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/SourceFile.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/SourceFile.js";
  var LineNumberTable = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./LineNumberTable.js", "traceur@0.0.112/src/syntax/SourceFile.js")).LineNumberTable;
  var SourceFile = function() {
    function SourceFile(name, contents) {
      this.name = name;
      this.contents = contents;
      this.lineNumberTable = new LineNumberTable(this);
    }
    return ($traceurRuntime.createClass)(SourceFile, {}, {});
  }();
  return {get SourceFile() {
      return SourceFile;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/PlaceholderParser.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/PlaceholderParser.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")),
      ARGUMENT_LIST = $__2.ARGUMENT_LIST,
      BLOCK = $__2.BLOCK,
      EXPRESSION_STATEMENT = $__2.EXPRESSION_STATEMENT,
      FUNCTION_BODY = $__2.FUNCTION_BODY,
      IDENTIFIER_EXPRESSION = $__2.IDENTIFIER_EXPRESSION;
  var IdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/IdentifierToken.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).IdentifierToken;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/LiteralToken.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).LiteralToken;
  var CollectingErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/CollectingErrorReporter.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).CollectingErrorReporter;
  var Options = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../Options.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).Options;
  var ParseTree = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTree.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).ParseTree;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).ParseTreeTransformer;
  var Parser = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/Parser.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).Parser;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")),
      LiteralExpression = $__10.LiteralExpression,
      LiteralPropertyName = $__10.LiteralPropertyName,
      TypeName = $__10.TypeName;
  var SourceFile = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/SourceFile.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).SourceFile;
  var IDENTIFIER = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")).IDENTIFIER;
  var $__13 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/PlaceholderParser.js")),
      createArrayLiteral = $__13.createArrayLiteral,
      createBindingIdentifier = $__13.createBindingIdentifier,
      createBlock = $__13.createBlock,
      createBooleanLiteral = $__13.createBooleanLiteral,
      createCommaExpression = $__13.createCommaExpression,
      createExpressionStatement = $__13.createExpressionStatement,
      createFunctionBody = $__13.createFunctionBody,
      createIdentifierExpression = $__13.createIdentifierExpression,
      createIdentifierToken = $__13.createIdentifierToken,
      createMemberExpression = $__13.createMemberExpression,
      createNullLiteral = $__13.createNullLiteral,
      createNumberLiteral = $__13.createNumberLiteral,
      createParenExpression = $__13.createParenExpression,
      createStringLiteral = $__13.createStringLiteral,
      createVoid0 = $__13.createVoid0;
  var NOT_FOUND = {};
  function makeParseFunction(doParse) {
    var cache = new Map();
    return function(sourceLiterals) {
      for (var values = [],
          $__1 = 1; $__1 < arguments.length; $__1++)
        values[$__1 - 1] = arguments[$__1];
      return parse(sourceLiterals, values, doParse, cache);
    };
  }
  var parseExpression = makeParseFunction(function(p) {
    return p.parseExpression();
  });
  var parseStatement = makeParseFunction(function(p) {
    return p.parseStatement();
  });
  var parseModule = makeParseFunction(function(p) {
    return p.parseModule();
  });
  var parseScript = makeParseFunction(function(p) {
    return p.parseScript();
  });
  var parseStatements = makeParseFunction(function(p) {
    return p.parseStatements();
  });
  var parsePropertyDefinition = makeParseFunction(function(p) {
    return p.parsePropertyDefinition();
  });
  function parse(sourceLiterals, values, doParse, cache) {
    var tree = cache.get(sourceLiterals);
    if (!tree) {
      var source = insertPlaceholderIdentifiers(sourceLiterals);
      var errorReporter = new CollectingErrorReporter();
      var parser = getParser(source, errorReporter);
      tree = doParse(parser);
      if (errorReporter.hadError() || !tree || !parser.isAtEnd()) {
        throw new Error(("Internal error trying to parse:\n\n" + source + "\n\n" + errorReporter.errorsAsString()));
      }
      cache.set(sourceLiterals, tree);
    }
    if (!values.length)
      return tree;
    if (tree instanceof ParseTree)
      return new PlaceholderTransformer(values).transformAny(tree);
    return new PlaceholderTransformer(values).transformList(tree);
  }
  var PREFIX = '$__placeholder__';
  function insertPlaceholderIdentifiers(sourceLiterals) {
    var source = sourceLiterals[0];
    for (var i = 1; i < sourceLiterals.length; i++) {
      source += PREFIX + String(i - 1) + sourceLiterals[i];
    }
    return source;
  }
  var counter = 0;
  function getParser(source, errorReporter) {
    var file = new SourceFile(null, source);
    var options = new Options();
    options.experimental = true;
    return new Parser(file, errorReporter, options);
  }
  function convertValueToExpression(value) {
    if (value instanceof ParseTree)
      return value;
    if (value instanceof IdentifierToken)
      return createIdentifierExpression(value);
    if (value instanceof LiteralToken)
      return new LiteralExpression(value.location, value);
    if (Array.isArray(value)) {
      if (value[0] instanceof ParseTree) {
        if (value.length === 1)
          return value[0];
        if (value[0].isStatement())
          return createBlock(value);
        else
          return createParenExpression(createCommaExpression(value));
      }
      return createArrayLiteral(value.map(convertValueToExpression));
    }
    if (value === null)
      return createNullLiteral();
    if (value === undefined)
      return createVoid0();
    switch (typeof value) {
      case 'string':
        return createStringLiteral(value);
      case 'boolean':
        return createBooleanLiteral(value);
      case 'number':
        return createNumberLiteral(value);
    }
    throw new Error('Not implemented');
  }
  function convertValueToIdentifierToken(value) {
    if (value instanceof IdentifierToken)
      return value;
    return createIdentifierToken(value);
  }
  function convertValueToType(value) {
    if (value === null)
      return null;
    if (value instanceof ParseTree)
      return value;
    if (typeof value === 'string') {
      return new TypeName(null, null, convertValueToIdentifierToken(value));
    }
    if (value instanceof IdentifierToken) {
      return new TypeName(null, null, value);
    }
    throw new Error('Not implemented');
  }
  var PlaceholderTransformer = function($__super) {
    function PlaceholderTransformer(values) {
      $traceurRuntime.superConstructor(PlaceholderTransformer).call(this);
      this.values = values;
    }
    return ($traceurRuntime.createClass)(PlaceholderTransformer, {
      getValueAt: function(index) {
        return this.values[index];
      },
      getValue_: function(str) {
        if (str.indexOf(PREFIX) !== 0)
          return NOT_FOUND;
        return this.getValueAt(Number(str.slice(PREFIX.length)));
      },
      transformIdentifierExpression: function(tree) {
        var value = this.getValue_(tree.identifierToken.value);
        if (value === NOT_FOUND)
          return tree;
        return convertValueToExpression(value);
      },
      transformBindingIdentifier: function(tree) {
        var value = this.getValue_(tree.identifierToken.value);
        if (value === NOT_FOUND)
          return tree;
        return createBindingIdentifier(value);
      },
      transformExpressionStatement: function(tree) {
        if (tree.expression.type === IDENTIFIER_EXPRESSION) {
          var transformedExpression = this.transformIdentifierExpression(tree.expression);
          if (transformedExpression === tree.expression)
            return tree;
          if (transformedExpression.isStatementListItem() || transformedExpression.type === FUNCTION_BODY) {
            return transformedExpression;
          }
          return createExpressionStatement(transformedExpression);
        }
        return $traceurRuntime.superGet(this, PlaceholderTransformer.prototype, "transformExpressionStatement").call(this, tree);
      },
      transformBlock: function(tree) {
        if (tree.statements.length === 1 && tree.statements[0].type === EXPRESSION_STATEMENT) {
          var transformedStatement = this.transformExpressionStatement(tree.statements[0]);
          if (transformedStatement === tree.statements[0])
            return tree;
          if (transformedStatement.type === BLOCK)
            return transformedStatement;
        }
        return $traceurRuntime.superGet(this, PlaceholderTransformer.prototype, "transformBlock").call(this, tree);
      },
      transformFunctionBody: function(tree) {
        if (tree.statements.length === 1 && tree.statements[0].type === EXPRESSION_STATEMENT) {
          var transformedStatement = this.transformExpressionStatement(tree.statements[0]);
          if (transformedStatement.type === FUNCTION_BODY)
            return transformedStatement;
          if (transformedStatement === tree.statements[0])
            return tree;
          if (transformedStatement.type === BLOCK)
            return createFunctionBody(transformedStatement.statements);
        }
        return $traceurRuntime.superGet(this, PlaceholderTransformer.prototype, "transformFunctionBody").call(this, tree);
      },
      transformMemberExpression: function(tree) {
        var value = this.getValue_(tree.memberName.value);
        if (value === NOT_FOUND)
          return $traceurRuntime.superGet(this, PlaceholderTransformer.prototype, "transformMemberExpression").call(this, tree);
        var operand = this.transformAny(tree.operand);
        return createMemberExpression(operand, value);
      },
      transformLiteralPropertyName: function(tree) {
        if (tree.literalToken.type === IDENTIFIER) {
          var value = this.getValue_(tree.literalToken.value);
          if (value !== NOT_FOUND) {
            return new LiteralPropertyName(null, convertValueToIdentifierToken(value));
          }
        }
        return $traceurRuntime.superGet(this, PlaceholderTransformer.prototype, "transformLiteralPropertyName").call(this, tree);
      },
      transformArgumentList: function(tree) {
        if (tree.args.length === 1 && tree.args[0].type === IDENTIFIER_EXPRESSION) {
          var arg0 = this.transformAny(tree.args[0]);
          if (arg0 === tree.args[0])
            return tree;
          if (arg0.type === ARGUMENT_LIST)
            return arg0;
        }
        return $traceurRuntime.superGet(this, PlaceholderTransformer.prototype, "transformArgumentList").call(this, tree);
      },
      transformTypeName: function(tree) {
        var value = this.getValue_(tree.name.value);
        if (value === NOT_FOUND)
          return $traceurRuntime.superGet(this, PlaceholderTransformer.prototype, "transformTypeName").call(this, tree);
        var moduleName = this.transformAny(tree.moduleName);
        if (moduleName !== null) {
          return new TypeName(null, moduleName, convertValueToIdentifierToken(value));
        }
        return convertValueToType(value);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {
    get parseExpression() {
      return parseExpression;
    },
    get parseStatement() {
      return parseStatement;
    },
    get parseModule() {
      return parseModule;
    },
    get parseScript() {
      return parseScript;
    },
    get parseStatements() {
      return parseStatements;
    },
    get parsePropertyDefinition() {
      return parsePropertyDefinition;
    },
    get PlaceholderTransformer() {
      return PlaceholderTransformer;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/PrependStatements.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/PrependStatements.js";
  function prependStatements(statements) {
    var $__1;
    for (var statementsToPrepend = [],
        $__0 = 1; $__0 < arguments.length; $__0++)
      statementsToPrepend[$__0 - 1] = arguments[$__0];
    if (!statements.length)
      return statementsToPrepend;
    if (!statementsToPrepend.length)
      return statements;
    var transformed = [];
    var inProlog = true;
    statements.forEach(function(statement) {
      var $__1;
      if (inProlog && !statement.isDirectivePrologue()) {
        ($__1 = transformed).push.apply($__1, $traceurRuntime.spread(statementsToPrepend));
        inProlog = false;
      }
      transformed.push(statement);
    });
    if (inProlog) {
      ($__1 = transformed).push.apply($__1, $traceurRuntime.spread(statementsToPrepend));
    }
    return transformed;
  }
  return {get prependStatements() {
      return prependStatements;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js";
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js")),
      CONST = $__5.CONST,
      VAR = $__5.VAR;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js")),
      ImportDeclaration = $__6.ImportDeclaration,
      ImportedBinding = $__6.ImportedBinding,
      ImportSpecifier = $__6.ImportSpecifier,
      ImportSpecifierSet = $__6.ImportSpecifierSet,
      Module = $__6.Module,
      ModuleSpecifier = $__6.ModuleSpecifier,
      Script = $__6.Script;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js")).StringSet;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js")),
      createBindingIdentifier = $__8.createBindingIdentifier,
      createIdentifierToken = $__8.createIdentifierToken,
      createIdentifierExpression = $__8.createIdentifierExpression,
      createMemberExpression = $__8.createMemberExpression,
      createStringLiteral = $__8.createStringLiteral,
      createStringLiteralToken = $__8.createStringLiteralToken,
      createVariableStatement = $__8.createVariableStatement;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js")).parseExpression;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/ImportRuntimeTrait.js")).prependStatements;
  function toTempName(name) {
    return ("$__" + name);
  }
  function getDeclarationType(options) {
    return options.parseOptions.blockBinding && !options.transformOptions.blockBinding ? CONST : VAR;
  }
  function ImportRuntimeTrait(ParseTreeTransformerClass) {
    return function($__super) {
      function $__0() {
        var $__4;
        for (var args = [],
            $__3 = 0; $__3 < arguments.length; $__3++)
          args[$__3] = arguments[$__3];
        ($__4 = $traceurRuntime.superConstructor($__0)).call.apply($__4, $traceurRuntime.spread([this], args));
        this.importedNames = new StringSet();
        this._existingImports = new StringSet();
      }
      return ($traceurRuntime.createClass)($__0, {
        getRuntimeExpression: function(name) {
          if (this.options.importRuntime) {
            this.addImportedName(name);
            return createIdentifierExpression(toTempName(name));
          }
          return createMemberExpression('$traceurRuntime', name);
        },
        get requiredNames() {
          return this.importedNames;
        },
        addImportedName: function(name) {
          this.importedNames.add(name);
        },
        transformScript: function(tree) {
          var transformed = $traceurRuntime.superGet(this, $__0.prototype, "transformScript").call(this, tree);
          if (tree === transformed) {
            return tree;
          }
          if (!this.options.importRuntime) {
            return transformed;
          }
          var scriptItemList = this.addRuntimeImports(transformed.scriptItemList);
          return new Script(tree.location, scriptItemList, tree.moduleName);
        },
        transformModule: function(tree) {
          var transformed = $traceurRuntime.superGet(this, $__0.prototype, "transformModule").call(this, tree);
          if (tree === transformed) {
            return tree;
          }
          if (!this.options.importRuntime) {
            return transformed;
          }
          var scriptItemList = this.addRuntimeImports(transformed.scriptItemList);
          return new Module(tree.location, scriptItemList, tree.moduleName);
        },
        transformImportedBinding: function(tree) {
          this._existingImports.add(tree.binding.getStringValue());
          return $traceurRuntime.superGet(this, $__0.prototype, "transformImportedBinding").call(this, tree);
        },
        _getModuleSpecifier: function(name) {
          var base = 'traceur/dist/commonjs';
          if (this.options.modules === 'parse') {
            base = 'traceur/src';
          }
          var moduleId = createStringLiteralToken((base + "/runtime/modules/" + name + ".js"));
          return new ModuleSpecifier(null, moduleId);
        },
        getRuntimeImports: function() {
          var $__2 = this;
          return this.importedNames.valuesAsArray().filter(function(name) {
            return !$__2._existingImports.has(toTempName(name));
          }).map(function(name) {
            var def = createIdentifierToken('default');
            var binding = new ImportedBinding(null, createBindingIdentifier(toTempName(name)));
            var specifier = new ImportSpecifier(null, binding, def);
            return new ImportDeclaration(null, new ImportSpecifierSet(null, [specifier]), $__2._getModuleSpecifier(name));
          });
        },
        addRuntimeImports: function(scriptItemList) {
          var runtimeImports = this.getRuntimeImports();
          return prependStatements.apply((void 0), $traceurRuntime.spread([scriptItemList], runtimeImports));
        }
      }, {}, $__super);
    }(ParseTreeTransformerClass);
  }
  return {get default() {
      return ImportRuntimeTrait;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/TempVarTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/TempVarTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/TempVarTransformer.js")).ParseTreeTransformer;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/TempVarTransformer.js")),
      Module = $__6.Module,
      Script = $__6.Script;
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/TempVarTransformer.js")).ARGUMENTS;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/codegeneration/TempVarTransformer.js")).StringSet;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/TempVarTransformer.js")),
      LET = $__9.LET,
      VAR = $__9.VAR;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/TempVarTransformer.js")),
      createFunctionBody = $__10.createFunctionBody,
      createThisExpression = $__10.createThisExpression,
      createIdentifierExpression = $__10.createIdentifierExpression,
      createVariableDeclaration = $__10.createVariableDeclaration,
      createVariableDeclarationList = $__10.createVariableDeclarationList,
      createVariableStatement = $__10.createVariableStatement;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/TempVarTransformer.js")).prependStatements;
  var TempVarStatement = function() {
    function TempVarStatement(name, initializer) {
      this.name = name;
      this.initializer = initializer;
    }
    return ($traceurRuntime.createClass)(TempVarStatement, {}, {});
  }();
  var TempScope = function() {
    function TempScope() {
      this.identifiers = [];
    }
    return ($traceurRuntime.createClass)(TempScope, {
      push: function(identifier) {
        this.identifiers.push(identifier);
      },
      pop: function() {
        return this.identifiers.pop();
      },
      release: function(obj) {
        for (var i = this.identifiers.length - 1; i >= 0; i--) {
          obj.releaseTempName(this.identifiers[i]);
        }
      }
    }, {});
  }();
  var VarScope = function() {
    function VarScope(options) {
      this.thisName = null;
      this.argumentName = null;
      this.tempVarStatements = [];
      this.declarationType_ = options.blockBinding && !options.transformOptions.blockBinding ? LET : VAR;
    }
    return ($traceurRuntime.createClass)(VarScope, {
      push: function(tempVarStatement) {
        this.tempVarStatements.push(tempVarStatement);
      },
      pop: function() {
        return this.tempVarStatements.pop();
      },
      release: function(obj) {
        for (var i = this.tempVarStatements.length - 1; i >= 0; i--) {
          obj.releaseTempName(this.tempVarStatements[i].name);
        }
      },
      isEmpty: function() {
        return !this.tempVarStatements.length;
      },
      createVariableStatement: function() {
        var declarations = [];
        var seenNames = new StringSet();
        for (var i = 0; i < this.tempVarStatements.length; i++) {
          var $__4 = this.tempVarStatements[i],
              name = $__4.name,
              initializer = $__4.initializer;
          if (seenNames.has(name)) {
            if (initializer)
              throw new Error('Invalid use of TempVarTransformer');
            continue;
          }
          seenNames.add(name);
          declarations.push(createVariableDeclaration(name, initializer));
        }
        return createVariableStatement(createVariableDeclarationList(this.declarationType_, declarations));
      }
    }, {});
  }();
  var TempVarTransformer = function($__super) {
    function TempVarTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(TempVarTransformer).call(this);
      this.identifierGenerator = identifierGenerator;
      this.reporter = reporter;
      this.options = options;
      this.tempVarStack_ = [new VarScope(this.options)];
      this.tempScopeStack_ = [new TempScope()];
      this.namePool_ = [];
    }
    return ($traceurRuntime.createClass)(TempVarTransformer, {
      transformStatements_: function(statements) {
        this.tempVarStack_.push(new VarScope(this.options));
        var transformedStatements = this.transformList(statements);
        var vars = this.tempVarStack_.pop();
        if (vars.isEmpty())
          return transformedStatements;
        var variableStatement = vars.createVariableStatement();
        vars.release(this);
        return prependStatements(transformedStatements, variableStatement);
      },
      transformScript: function(tree) {
        var scriptItemList = this.transformStatements_(tree.scriptItemList);
        if (scriptItemList === tree.scriptItemList) {
          return tree;
        }
        return new Script(tree.location, scriptItemList, tree.moduleName);
      },
      transformModule: function(tree) {
        var scriptItemList = this.transformStatements_(tree.scriptItemList);
        if (scriptItemList === tree.scriptItemList) {
          return tree;
        }
        return new Module(tree.location, scriptItemList, tree.moduleName);
      },
      transformFunctionBody: function(tree) {
        this.pushTempScope();
        var statements = this.transformStatements_(tree.statements);
        this.popTempScope();
        if (statements === tree.statements)
          return tree;
        return createFunctionBody(statements);
      },
      getTempIdentifier: function() {
        var name = this.getName_();
        this.tempScopeStack_[this.tempScopeStack_.length - 1].push(name);
        return name;
      },
      getName_: function() {
        return this.namePool_.length ? this.namePool_.pop() : this.identifierGenerator.generateUniqueIdentifier();
      },
      addTempVar: function() {
        var initializer = arguments[0] !== (void 0) ? arguments[0] : null;
        var vars = this.tempVarStack_[this.tempVarStack_.length - 1];
        var name = this.getName_();
        vars.push(new TempVarStatement(name, initializer));
        return name;
      },
      registerTempVarName: function(name) {
        var vars = this.tempVarStack_[this.tempVarStack_.length - 1];
        vars.push(new TempVarStatement(name, null));
      },
      addTempVarForThis: function() {
        var varScope = this.tempVarStack_[this.tempVarStack_.length - 1];
        return varScope.thisName || (varScope.thisName = this.addTempVar(createThisExpression()));
      },
      addTempVarForArguments: function() {
        var varScope = this.tempVarStack_[this.tempVarStack_.length - 1];
        return varScope.argumentName || (varScope.argumentName = this.addTempVar(createIdentifierExpression(ARGUMENTS)));
      },
      pushTempScope: function() {
        this.tempScopeStack_.push(new TempScope());
      },
      popTempScope: function() {
        this.tempScopeStack_.pop().release(this);
      },
      releaseTempName: function(name) {
        this.namePool_.push(name);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get TempVarTransformer() {
      return TempVarTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/bindingsInDestructuringPattern.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/bindingsInDestructuringPattern.js";
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/semantics/bindingsInDestructuringPattern.js")).ParseTreeVisitor;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/semantics/bindingsInDestructuringPattern.js")).StringSet;
  var BindingsInDestructuringPatternVisitor = function($__super) {
    function BindingsInDestructuringPatternVisitor() {
      $traceurRuntime.superConstructor(BindingsInDestructuringPatternVisitor).call(this);
      this.bindings = new StringSet();
    }
    return ($traceurRuntime.createClass)(BindingsInDestructuringPatternVisitor, {
      visitBindingIdentifier: function(tree) {
        this.bindings.add(tree.getStringValue());
      },
      visitBindingElement: function(tree) {
        this.visitAny(tree.binding);
      },
      visitVariableDeclaration: function(tree) {
        this.visitAny(tree.lvalue);
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  function bindingsInDestructuringPattern(tree) {
    var v = new BindingsInDestructuringPatternVisitor();
    v.visitAny(tree);
    return v.bindings;
  }
  return {get default() {
      return bindingsInDestructuringPattern;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/DestructuringTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js";
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")),
      ARRAY_LITERAL = $__8.ARRAY_LITERAL,
      ARRAY_PATTERN = $__8.ARRAY_PATTERN,
      ASSIGNMENT_ELEMENT = $__8.ASSIGNMENT_ELEMENT,
      BINDING_ELEMENT = $__8.BINDING_ELEMENT,
      BINDING_IDENTIFIER = $__8.BINDING_IDENTIFIER,
      BLOCK = $__8.BLOCK,
      CALL_EXPRESSION = $__8.CALL_EXPRESSION,
      COMPUTED_PROPERTY_NAME = $__8.COMPUTED_PROPERTY_NAME,
      IDENTIFIER_EXPRESSION = $__8.IDENTIFIER_EXPRESSION,
      LITERAL_EXPRESSION = $__8.LITERAL_EXPRESSION,
      MEMBER_EXPRESSION = $__8.MEMBER_EXPRESSION,
      MEMBER_LOOKUP_EXPRESSION = $__8.MEMBER_LOOKUP_EXPRESSION,
      OBJECT_LITERAL = $__8.OBJECT_LITERAL,
      OBJECT_PATTERN_FIELD = $__8.OBJECT_PATTERN_FIELD,
      OBJECT_PATTERN = $__8.OBJECT_PATTERN,
      PAREN_EXPRESSION = $__8.PAREN_EXPRESSION,
      VARIABLE_DECLARATION_LIST = $__8.VARIABLE_DECLARATION_LIST,
      VARIABLE_STATEMENT = $__8.VARIABLE_STATEMENT;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")),
      AnonBlock = $__9.AnonBlock,
      AssignmentElement = $__9.AssignmentElement,
      BindingElement = $__9.BindingElement,
      Catch = $__9.Catch,
      ExportDeclaration = $__9.ExportDeclaration,
      ForInStatement = $__9.ForInStatement,
      ForOfStatement = $__9.ForOfStatement,
      ForOnStatement = $__9.ForOnStatement,
      VariableDeclarationList = $__9.VariableDeclarationList,
      VariableStatement = $__9.VariableStatement;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")).default;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")).TempVarTransformer;
  var $__12 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")),
      EQUAL = $__12.EQUAL,
      LET = $__12.LET,
      VAR = $__12.VAR;
  var bindingsInDestructuringPattern = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/bindingsInDestructuringPattern.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")).default;
  var $__14 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")),
      createAssignmentExpression = $__14.createAssignmentExpression,
      createBindingIdentifier = $__14.createBindingIdentifier,
      createBlock = $__14.createBlock,
      createCommaExpression = $__14.createCommaExpression,
      createExpressionStatement = $__14.createExpressionStatement,
      createFunctionBody = $__14.createFunctionBody,
      createIdentifierExpression = $__14.createIdentifierExpression,
      createMemberExpression = $__14.createMemberExpression,
      createMemberLookupExpression = $__14.createMemberLookupExpression,
      createParenExpression = $__14.createParenExpression,
      createVariableDeclaration = $__14.createVariableDeclaration,
      createVariableDeclarationList = $__14.createVariableDeclarationList,
      createVariableStatement = $__14.createVariableStatement;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")).parseExpression;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/DestructuringTransformer.js")).prependStatements;
  var Desugaring = function() {
    function Desugaring(rvalue) {
      this.rvalue = rvalue;
      this.expressions = [];
      this.pendingExpressions = [];
    }
    return ($traceurRuntime.createClass)(Desugaring, {
      createIterator: function(iterId) {
        this.pendingExpressions.push(parseExpression($traceurRuntime.getTemplateObject(["", " = ", "[Symbol.iterator]()"]), iterId, this.rvalue));
      },
      createInitializer: function(expression) {
        if (this.pendingExpressions.length === 0)
          return expression;
        var expressions = this.pendingExpressions;
        this.pendingExpressions = [];
        expressions.push(expression);
        return createParenExpression(createCommaExpression(expressions));
      },
      skipHole: function(iterId) {
        this.pendingExpressions.push(parseExpression($traceurRuntime.getTemplateObject(["", ".next()"]), iterId));
      }
    }, {});
  }();
  var AssignmentExpressionDesugaring = function($__super) {
    function AssignmentExpressionDesugaring(rvalue) {
      $traceurRuntime.superConstructor(AssignmentExpressionDesugaring).call(this, rvalue);
    }
    return ($traceurRuntime.createClass)(AssignmentExpressionDesugaring, {
      assign: function(lvalue, rvalue) {
        lvalue = lvalue instanceof AssignmentElement ? lvalue.assignment : lvalue;
        rvalue = this.createInitializer(rvalue);
        this.expressions.push(createAssignmentExpression(lvalue, rvalue));
      },
      createAssignmentExpression: function(tempId, rvalue) {
        var $__6;
        var expressions = this.expressions;
        expressions.unshift(createAssignmentExpression(tempId, rvalue));
        ($__6 = expressions).push.apply($__6, $traceurRuntime.spread(this.pendingExpressions, [tempId]));
        return createParenExpression(createCommaExpression(expressions));
      }
    }, {}, $__super);
  }(Desugaring);
  var VariableDeclarationDesugaring = function($__super) {
    function VariableDeclarationDesugaring(rvalue) {
      $traceurRuntime.superConstructor(VariableDeclarationDesugaring).call(this, rvalue);
    }
    return ($traceurRuntime.createClass)(VariableDeclarationDesugaring, {
      assign: function(lvalue, rvalue) {
        var binding = lvalue instanceof BindingElement ? lvalue.binding : createBindingIdentifier(lvalue);
        rvalue = this.createInitializer(rvalue);
        this.expressions.push(createVariableDeclaration(binding, rvalue));
      },
      get declarations() {
        return this.expressions;
      }
    }, {}, $__super);
  }(Desugaring);
  var DestructuringTransformer = function($__super) {
    function DestructuringTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(DestructuringTransformer).call(this, identifierGenerator, reporter, options);
      this.parameterDeclarations = null;
    }
    return ($traceurRuntime.createClass)(DestructuringTransformer, {
      transformArrayPattern: function(tree) {
        throw new Error('unreachable');
      },
      transformObjectPattern: function(tree) {
        throw new Error('unreachable');
      },
      transformBinaryExpression: function(tree) {
        this.pushTempScope();
        var rv;
        if (tree.operator.type === EQUAL && tree.left.isPattern()) {
          rv = this.transformAny(this.desugarAssignment_(tree.left, tree.right));
        } else {
          rv = $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformBinaryExpression").call(this, tree);
        }
        this.popTempScope();
        return rv;
      },
      desugarAssignment_: function(lvalue, rvalue) {
        var tempId = createIdentifierExpression(this.addTempVar());
        var desugaring = new AssignmentExpressionDesugaring(tempId);
        this.desugarPattern_(desugaring, lvalue);
        return desugaring.createAssignmentExpression(tempId, rvalue);
      },
      transformVariableDeclarationList: function(tree) {
        var $__4 = this;
        if (!hasDestructuring(tree)) {
          return $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformVariableDeclarationList").call(this, tree);
        }
        var desugaredDeclarations = [];
        tree.declarations.forEach(function(declaration) {
          var $__6;
          if (declaration.lvalue.isPattern()) {
            ($__6 = desugaredDeclarations).push.apply($__6, $traceurRuntime.spread($__4.desugarVariableDeclaration_(declaration)));
          } else {
            desugaredDeclarations.push(declaration);
          }
        });
        var transformedTree = this.transformVariableDeclarationList(createVariableDeclarationList(tree.declarationType, desugaredDeclarations));
        return transformedTree;
      },
      transformForInStatement: function(tree) {
        return this.transformForInOrOfOrOn_(tree, $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformForInStatement"), ForInStatement);
      },
      transformForOfStatement: function(tree) {
        return this.transformForInOrOfOrOn_(tree, $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformForOfStatement"), ForOfStatement);
      },
      transformForOnStatement: function(tree) {
        return this.transformForInOrOfOrOn_(tree, $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformForOnStatement"), ForOnStatement);
      },
      transformForInOrOfOrOn_: function(tree, superMethod, constr) {
        var $__6;
        if (!tree.initializer.isPattern() && (tree.initializer.type !== VARIABLE_DECLARATION_LIST || !hasDestructuring(tree.initializer))) {
          return superMethod.call(this, tree);
        }
        this.pushTempScope();
        var declarationType,
            lvalue;
        if (tree.initializer.isPattern()) {
          declarationType = null;
          lvalue = tree.initializer;
        } else {
          declarationType = tree.initializer.declarationType;
          lvalue = tree.initializer.declarations[0].lvalue;
        }
        var statements = [];
        var binding = this.desugarBinding_(lvalue, statements, declarationType);
        var initializer = createVariableDeclarationList(VAR, binding, null);
        var collection = this.transformAny(tree.collection);
        var body = this.transformAny(tree.body);
        if (body.type === BLOCK)
          ($__6 = statements).push.apply($__6, $traceurRuntime.spread(body.statements));
        else
          statements.push(body);
        body = createBlock(statements);
        this.popTempScope();
        return new constr(tree.location, initializer, collection, body);
      },
      transformAssignmentElement: function(tree) {
        throw new Error('unreachable');
      },
      transformBindingElement: function(tree) {
        if (!tree.binding.isPattern() || tree.initializer)
          return tree;
        if (this.parameterDeclarations === null) {
          this.parameterDeclarations = [];
          this.pushTempScope();
        }
        var varName = this.getTempIdentifier();
        var binding = createBindingIdentifier(varName);
        var initializer = createIdentifierExpression(varName);
        var decl = createVariableDeclaration(tree.binding, initializer);
        this.parameterDeclarations.push(decl);
        return new BindingElement(null, binding, null);
      },
      transformFunctionBody: function(tree) {
        if (this.parameterDeclarations === null)
          return $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformFunctionBody").call(this, tree);
        var list = createVariableDeclarationList(VAR, this.parameterDeclarations);
        var statement = createVariableStatement(list);
        var statements = prependStatements(tree.statements, statement);
        var newBody = createFunctionBody(statements);
        this.parameterDeclarations = null;
        var result = $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformFunctionBody").call(this, newBody);
        this.popTempScope();
        return result;
      },
      transformCatch: function(tree) {
        var $__6;
        if (!tree.binding.isPattern())
          return $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformCatch").call(this, tree);
        var body = this.transformAny(tree.catchBody);
        var statements = [];
        var kind = this.options.blockBinding ? LET : VAR;
        var binding = this.desugarBinding_(tree.binding, statements, kind);
        ($__6 = statements).push.apply($__6, $traceurRuntime.spread(body.statements));
        return new Catch(tree.location, binding, createBlock(statements));
      },
      transformExportDeclaration: function(tree) {
        if (tree.declaration.type === VARIABLE_STATEMENT && hasDestructuring(tree.declaration.declarations)) {
          var names = bindingsInDestructuringPattern(tree.declaration.declarations);
          var declaration = this.transformAny(tree.declaration);
          var statements = [];
          var $__5 = declaration.declarations,
              declarations = $__5.declarations,
              declarationType = $__5.declarationType;
          for (var i = 0; i < declarations.length; i++) {
            var declaration$__7 = declarations[i];
            var statement = new VariableStatement(declaration$__7.location, new VariableDeclarationList(declaration$__7.location, declarationType, [declaration$__7]));
            if (names.has(declarations[i].lvalue.getStringValue())) {
              statement = new ExportDeclaration(statement.location, statement, []);
            }
            statements.push(statement);
          }
          return new AnonBlock(null, statements);
        }
        return $traceurRuntime.superGet(this, DestructuringTransformer.prototype, "transformExportDeclaration").call(this, tree);
      },
      desugarBinding_: function(bindingTree, statements, declarationType) {
        var varName = this.getTempIdentifier();
        var binding = createBindingIdentifier(varName);
        var idExpr = createIdentifierExpression(varName);
        var desugaring;
        if (declarationType === null)
          desugaring = new AssignmentExpressionDesugaring(idExpr);
        else
          desugaring = new VariableDeclarationDesugaring(idExpr);
        this.desugarPattern_(desugaring, bindingTree);
        if (declarationType === null) {
          statements.push(createExpressionStatement(createCommaExpression(desugaring.expressions)));
        } else {
          statements.push(createVariableStatement(this.transformVariableDeclarationList(createVariableDeclarationList(declarationType, desugaring.declarations))));
        }
        return binding;
      },
      desugarVariableDeclaration_: function(tree) {
        var tempRValueName = this.getTempIdentifier();
        var tempRValueIdent = createIdentifierExpression(tempRValueName);
        var desugaring;
        var initializer;
        switch (tree.initializer.type) {
          case ARRAY_LITERAL:
          case CALL_EXPRESSION:
          case IDENTIFIER_EXPRESSION:
          case LITERAL_EXPRESSION:
          case MEMBER_EXPRESSION:
          case MEMBER_LOOKUP_EXPRESSION:
          case OBJECT_LITERAL:
          case PAREN_EXPRESSION:
            initializer = tree.initializer;
        }
        desugaring = new VariableDeclarationDesugaring(tempRValueIdent);
        desugaring.assign(desugaring.rvalue, tree.initializer);
        var initializerFound = this.desugarPattern_(desugaring, tree.lvalue);
        if (initializerFound || desugaring.declarations.length > 2) {
          return desugaring.declarations;
        }
        if (!initializer) {
          initializer = createParenExpression(tree.initializer);
        }
        desugaring = new VariableDeclarationDesugaring(initializer);
        this.desugarPattern_(desugaring, tree.lvalue);
        return desugaring.declarations;
      },
      desugarPattern_: function(desugaring, tree) {
        var $__4 = this;
        var initializerFound = false;
        var pattern;
        switch (tree.type) {
          case ARRAY_PATTERN:
            {
              pattern = tree;
              this.pushTempScope();
              var iterId = createIdentifierExpression(this.addTempVar());
              var iterObjectId = createIdentifierExpression(this.addTempVar());
              desugaring.createIterator(iterId);
              for (var i = 0; i < pattern.elements.length; i++) {
                var lvalue = pattern.elements[i];
                if (lvalue === null) {
                  desugaring.skipHole(iterId);
                  continue;
                } else if (lvalue.isSpreadPatternElement()) {
                  var iteratorToArray = this.getRuntimeExpression('iteratorToArray');
                  desugaring.assign(lvalue.lvalue, parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), iteratorToArray, iterId));
                } else {
                  if (lvalue.initializer) {
                    initializerFound = true;
                  }
                  desugaring.assign(lvalue, this.createConditionalIterExpression(iterObjectId, iterId, lvalue.initializer));
                }
              }
              this.popTempScope();
              break;
            }
          case OBJECT_PATTERN:
            {
              pattern = tree;
              var elementHelper = function(lvalue, initializer) {
                if (initializer)
                  initializerFound = true;
                var lookup = $__4.createConditionalMemberExpression(desugaring.rvalue, lvalue, initializer);
                desugaring.assign(lvalue, lookup);
              };
              pattern.fields.forEach(function(field) {
                var lookup;
                switch (field.type) {
                  case ASSIGNMENT_ELEMENT:
                    elementHelper(field.assignment, field.initializer);
                    break;
                  case BINDING_ELEMENT:
                    elementHelper(field.binding, field.initializer);
                    break;
                  case OBJECT_PATTERN_FIELD:
                    {
                      if (field.element.initializer)
                        initializerFound = true;
                      var name = field.name;
                      lookup = $__4.createConditionalMemberExpression(desugaring.rvalue, name, field.element.initializer);
                      desugaring.assign(field.element, lookup);
                      break;
                    }
                  default:
                    throw Error('unreachable');
                }
              });
              break;
            }
          case PAREN_EXPRESSION:
            return this.desugarPattern_(desugaring, tree.expression);
          default:
            throw new Error('unreachable');
        }
        if (desugaring instanceof VariableDeclarationDesugaring && desugaring.declarations.length === 0) {
          desugaring.assign(createBindingIdentifier(this.getTempIdentifier()), desugaring.rvalue);
        }
        return initializerFound;
      },
      createConditionalMemberExpression: function(rvalue, name, initializer) {
        if (name.type === COMPUTED_PROPERTY_NAME) {
          return this.createConditionalMemberLookupExpression(rvalue, name.expression, initializer);
        }
        var token;
        switch (name.type) {
          case BINDING_IDENTIFIER:
          case IDENTIFIER_EXPRESSION:
            token = name.identifierToken;
            break;
          default:
            token = name.literalToken;
        }
        if (!initializer)
          return createMemberExpression(rvalue, token);
        var tempIdent = createIdentifierExpression(this.addTempVar());
        return parseExpression($traceurRuntime.getTemplateObject(["(", " = ", ".", ") === void 0 ?\n        ", " : ", ""]), tempIdent, rvalue, token, initializer, tempIdent);
      },
      createConditionalMemberLookupExpression: function(rvalue, index, initializer) {
        if (!initializer)
          return createMemberLookupExpression(rvalue, index);
        var tempIdent = createIdentifierExpression(this.addTempVar());
        return parseExpression($traceurRuntime.getTemplateObject(["(", " = ", "[", "]) === void 0 ?\n        ", " : ", ""]), tempIdent, rvalue, index, initializer, tempIdent);
      },
      createConditionalIterExpression: function(iterObjectId, iterId, initializer) {
        var expr = parseExpression($traceurRuntime.getTemplateObject(["(", " =\n        ", ".next()).done ? void 0 : ", ".value"]), iterObjectId, iterId, iterObjectId);
        if (!initializer) {
          return expr;
        }
        var tempIdent = createIdentifierExpression(this.addTempVar());
        return parseExpression($traceurRuntime.getTemplateObject(["(", " = ", ") === void 0 ?\n        ", " : ", ""]), tempIdent, expr, initializer, tempIdent);
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  function hasDestructuring(tree) {
    return tree.declarations.some(function(declaration) {
      return declaration.lvalue.isPattern();
    });
  }
  return {get DestructuringTransformer() {
      return DestructuringTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/ModuleSymbol.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/ModuleSymbol.js";
  var StringMap = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../util/StringMap.js", "traceur@0.0.112/src/codegeneration/module/ModuleSymbol.js")).StringMap;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../util/assert.js", "traceur@0.0.112/src/codegeneration/module/ModuleSymbol.js")).assert;
  var ExportsList = function() {
    function ExportsList(normalizedName) {
      this.exports_ = new StringMap();
      if (normalizedName !== null)
        this.normalizedName = normalizedName.replace(/\\/g, '/');
      else
        this.normalizedName = null;
    }
    return ($traceurRuntime.createClass)(ExportsList, {
      addExport: function(name, tree) {
        assert(!this.exports_.has(name));
        this.exports_.set(name, tree);
      },
      getExport: function(name) {
        return this.exports_.get(name);
      },
      getExports: function() {
        return this.exports_.keysAsArray();
      },
      addExportsFromModule: function(module) {
        var $__2 = this;
        Object.getOwnPropertyNames(module).forEach(function(name) {
          $__2.addExport(name, true);
        });
      }
    }, {});
  }();
  var ModuleSymbol = function($__super) {
    function ModuleSymbol(tree, normalizedName) {
      $traceurRuntime.superConstructor(ModuleSymbol).call(this, normalizedName);
      this.tree = tree;
      this.imports_ = new StringMap();
    }
    return ($traceurRuntime.createClass)(ModuleSymbol, {
      addImport: function(name, tree) {
        assert(!this.imports_.has(name));
        this.imports_.set(name, tree);
      },
      getImport: function(name) {
        return this.imports_.get(name);
      }
    }, {}, $__super);
  }(ExportsList);
  return {
    get ExportsList() {
      return ExportsList;
    },
    get ModuleSymbol() {
      return ModuleSymbol;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/ModuleVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/ModuleVisitor.js";
  var ExportsList = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleSymbol.js", "traceur@0.0.112/src/codegeneration/module/ModuleVisitor.js")).ExportsList;
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/codegeneration/module/ModuleVisitor.js")).ParseTreeVisitor;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/module/ModuleVisitor.js")),
      EXPORT_DECLARATION = $__3.EXPORT_DECLARATION,
      IMPORT_DECLARATION = $__3.IMPORT_DECLARATION;
  var ModuleVisitor = function($__super) {
    function ModuleVisitor(reporter, loader, moduleSymbol) {
      $traceurRuntime.superConstructor(ModuleVisitor).call(this);
      this.reporter = reporter;
      this.loader_ = loader;
      this.moduleSymbol = moduleSymbol;
    }
    return ($traceurRuntime.createClass)(ModuleVisitor, {
      getExportsListForModuleSpecifier: function(name) {
        var referrer = this.moduleSymbol.normalizedName;
        return this.loader_.getExportsListForModuleSpecifier(name, referrer);
      },
      visitFunctionDeclaration: function(tree) {},
      visitFunctionExpression: function(tree) {},
      visitFunctionBody: function(tree) {},
      visitBlock: function(tree) {},
      visitClassDeclaration: function(tree) {},
      visitClassExpression: function(tree) {},
      visitModuleElement_: function(element) {
        switch (element.type) {
          case EXPORT_DECLARATION:
          case IMPORT_DECLARATION:
            this.visitAny(element);
        }
      },
      visitScript: function(tree) {
        tree.scriptItemList.forEach(this.visitModuleElement_, this);
      },
      visitModule: function(tree) {
        tree.scriptItemList.forEach(this.visitModuleElement_, this);
      },
      reportError: function(tree, message) {
        this.reporter.reportError(tree.location, message);
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  return {get ModuleVisitor() {
      return ModuleVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/ExportVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/ExportVisitor.js";
  var ModuleVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleVisitor.js", "traceur@0.0.112/src/codegeneration/module/ExportVisitor.js")).ModuleVisitor;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../util/assert.js", "traceur@0.0.112/src/codegeneration/module/ExportVisitor.js")).assert;
  var ExportVisitor = function($__super) {
    function ExportVisitor(reporter, loader, moduleSymbol) {
      $traceurRuntime.superConstructor(ExportVisitor).call(this, reporter, loader, moduleSymbol);
      this.inExport_ = false;
      this.moduleSpecifier = null;
    }
    return ($traceurRuntime.createClass)(ExportVisitor, {
      addExport_: function(name, tree) {
        assert(typeof name === 'string');
        if (this.inExport_)
          this.addExport(name, tree);
      },
      addExport: function(name, tree) {
        var moduleSymbol = this.moduleSymbol;
        var existingExport = moduleSymbol.getExport(name);
        if (existingExport) {
          this.reportError(tree, ("Duplicate export. '" + name + "' was previously ") + ("exported at " + existingExport.location.start));
        } else {
          moduleSymbol.addExport(name, tree);
        }
      },
      visitClassDeclaration: function(tree) {
        this.addExport_(tree.name.identifierToken.value, tree);
      },
      visitExportDeclaration: function(tree) {
        this.inExport_ = true;
        this.visitAny(tree.declaration);
        this.inExport_ = false;
      },
      visitNamedExport: function(tree) {
        this.moduleSpecifier = tree.moduleSpecifier;
        this.visitAny(tree.exportClause);
        this.moduleSpecifier = null;
      },
      visitExportDefault: function(tree) {
        this.addExport_('default', tree);
      },
      visitExportSpecifier: function(tree) {
        this.addExport_((tree.rhs || tree.lhs).value, tree);
      },
      visitExportStar: function(tree) {
        var $__1 = this;
        var name = this.moduleSpecifier.token.processedValue;
        var exportList = this.getExportsListForModuleSpecifier(name);
        if (exportList) {
          exportList.getExports().forEach(function(name) {
            return $__1.addExport(name, tree);
          });
        }
      },
      visitNameSpaceExport: function(tree) {
        this.addExport_(tree.name.value, tree);
      },
      visitForwardDefaultExport: function(tree) {
        this.addExport_(tree.name.value, tree);
      },
      visitFunctionDeclaration: function(tree) {
        this.addExport_(tree.name.getStringValue(), tree);
      },
      visitVariableDeclaration: function(tree) {
        this.visitAny(tree.lvalue);
      },
      visitBindingIdentifier: function(tree) {
        this.addExport_(tree.getStringValue(), tree);
      },
      visitBindingElement: function(tree) {
        this.visitAny(tree.binding);
      },
      visitTypeAliasDeclaration: function(tree) {
        this.addExport(tree.name.value, tree);
      }
    }, {}, $__super);
  }(ModuleVisitor);
  return {get ExportVisitor() {
      return ExportVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/DirectExportVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/DirectExportVisitor.js";
  var ExportVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ExportVisitor.js", "traceur@0.0.112/src/codegeneration/module/DirectExportVisitor.js")).ExportVisitor;
  var TYPE_ALIAS_DECLARATION = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/module/DirectExportVisitor.js")).TYPE_ALIAS_DECLARATION;
  var DirectExportVisitor = function($__super) {
    function DirectExportVisitor() {
      $traceurRuntime.superConstructor(DirectExportVisitor).call(this, null, null, null);
      this.namedExports = [];
      this.starExports = [];
    }
    return ($traceurRuntime.createClass)(DirectExportVisitor, {
      addExport: function(name, tree) {
        this.namedExports.push({
          name: name,
          tree: tree,
          moduleSpecifier: this.moduleSpecifier
        });
      },
      visitExportStar: function(tree) {
        this.starExports.push(this.moduleSpecifier);
      },
      hasExports: function() {
        return this.namedExports.length !== 0 || this.starExports.length !== 0;
      },
      getNonTypeNamedExports: function() {
        return this.namedExports.filter(function(exp) {
          return exp.tree.type !== TYPE_ALIAS_DECLARATION;
        });
      }
    }, {}, $__super);
  }(ExportVisitor);
  return {get DirectExportVisitor() {
      return DirectExportVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ImportSimplifyingTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ImportSimplifyingTransformer.js";
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ImportSimplifyingTransformer.js")),
      AnonBlock = $__5.AnonBlock,
      ImportDeclaration = $__5.ImportDeclaration,
      ImportSpecifier = $__5.ImportSpecifier,
      ImportSpecifierSet = $__5.ImportSpecifierSet,
      Module = $__5.Module;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/ImportSimplifyingTransformer.js")).ParseTreeTransformer;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ImportSimplifyingTransformer.js")),
      ANON_BLOCK = $__7.ANON_BLOCK,
      IMPORT_CLAUSE_PAIR = $__7.IMPORT_CLAUSE_PAIR,
      IMPORT_DECLARATION = $__7.IMPORT_DECLARATION,
      IMPORT_SPECIFIER_SET = $__7.IMPORT_SPECIFIER_SET,
      IMPORTED_BINDING = $__7.IMPORTED_BINDING,
      NAME_SPACE_IMPORT = $__7.NAME_SPACE_IMPORT;
  var createIdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ImportSimplifyingTransformer.js")).createIdentifierToken;
  var ImportSimplifyingTransformer = function($__super) {
    function ImportSimplifyingTransformer() {
      $traceurRuntime.superConstructor(ImportSimplifyingTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ImportSimplifyingTransformer, {
      transformModule: function(tree) {
        var $__2;
        var statements = [];
        for (var i = 0; i < tree.scriptItemList.length; i++) {
          var item = tree.scriptItemList[i];
          switch (item.type) {
            case IMPORT_DECLARATION:
              {
                var transformed = this.transformAny(item);
                if (transformed.type === ANON_BLOCK) {
                  ($__2 = statements).push.apply($__2, $traceurRuntime.spread(transformed.statements));
                } else {
                  statements.push(transformed);
                }
                break;
              }
            default:
              statements.push(item);
          }
        }
        return new Module(tree.location, statements, tree.moduleName);
      },
      transformImportDeclaration: function(tree) {
        var importClause = tree.importClause;
        if (importClause === null) {
          var set = new ImportSpecifierSet(null, []);
          return new ImportDeclaration(tree.location, set, tree.moduleSpecifier);
        }
        if (importClause.type === NAME_SPACE_IMPORT) {
          return tree;
        }
        if (importClause.type === IMPORTED_BINDING) {
          var specifier = this.transformAny(importClause);
          var set$__3 = new ImportSpecifierSet(null, [specifier]);
          return new ImportDeclaration(tree.location, set$__3, tree.moduleSpecifier);
        }
        if (importClause.type === IMPORT_CLAUSE_PAIR) {
          var $__1 = importClause,
              first = $__1.first,
              second = $__1.second;
          if (second.type === IMPORT_SPECIFIER_SET) {
            var defaultSpecifier = this.transformAny(first);
            var specifiers = $traceurRuntime.spread([defaultSpecifier], second.specifiers);
            var set$__4 = new ImportSpecifierSet(first.location, specifiers);
            return new ImportDeclaration(tree.location, set$__4, tree.moduleSpecifier);
          }
          var firstImport = new ImportDeclaration(tree.location, first, tree.moduleSpecifier);
          firstImport = this.transformAny(firstImport);
          var secondImport = new ImportDeclaration(tree.location, second, tree.moduleSpecifier);
          return new AnonBlock(null, [firstImport, secondImport]);
        }
        return $traceurRuntime.superGet(this, ImportSimplifyingTransformer.prototype, "transformImportDeclaration").call(this, tree);
      },
      transformImportSpecifier: function(tree) {
        return tree;
      },
      transformImportedBinding: function(tree) {
        var name = createIdentifierToken('default');
        return new ImportSpecifier(tree.location, tree, name);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get ImportSimplifyingTransformer() {
      return ImportSimplifyingTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/util/url.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/util/url.js";
  var canonicalizeUrl = $traceurRuntime.canonicalizeUrl;
  var isAbsolute = $traceurRuntime.isAbsolute;
  var removeDotSegments = $traceurRuntime.removeDotSegments;
  var resolveUrl = $traceurRuntime.resolveUrl;
  return {
    get canonicalizeUrl() {
      return canonicalizeUrl;
    },
    get isAbsolute() {
      return isAbsolute;
    },
    get removeDotSegments() {
      return removeDotSegments;
    },
    get resolveUrl() {
      return resolveUrl;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/SkipFunctionsTransformerTrait.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/SkipFunctionsTransformerTrait.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/SkipFunctionsTransformerTrait.js")),
      ArrowFunction = $__1.ArrowFunction,
      FunctionDeclaration = $__1.FunctionDeclaration,
      FunctionExpression = $__1.FunctionExpression,
      GetAccessor = $__1.GetAccessor,
      Method = $__1.Method,
      SetAccessor = $__1.SetAccessor;
  function SkipFunctionsTransformerTrait(ParseTreeTransformer) {
    return function($__super) {
      function SkipFunctionsTransformer() {
        $traceurRuntime.superConstructor(SkipFunctionsTransformer).apply(this, arguments);
      }
      return ($traceurRuntime.createClass)(SkipFunctionsTransformer, {
        transformFunctionDeclaration: function(tree) {
          var annotations = this.transformList(tree.annotations);
          if (annotations === tree.annotations) {
            return tree;
          }
          return new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, tree.typeAnnotation, annotations, tree.body);
        },
        transformFunctionExpression: function(tree) {
          var annotations = this.transformList(tree.annotations);
          if (annotations === tree.annotations) {
            return tree;
          }
          return new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, tree.typeAnnotation, annotations, tree.body);
        },
        transformSetAccessor: function(tree) {
          var name = this.transformAny(tree.name);
          var annotations = this.transformList(tree.annotations);
          if (name === tree.name && annotations === tree.annotations) {
            return tree;
          }
          return new SetAccessor(tree.location, tree.isStatic, name, tree.parameterList, annotations, tree.body);
        },
        transformGetAccessor: function(tree) {
          var name = this.transformAny(tree.name);
          var annotations = this.transformList(tree.annotations);
          if (name === tree.name && annotations === tree.annotations) {
            return tree;
          }
          return new GetAccessor(tree.location, tree.isStatic, name, annotations, tree.body);
        },
        transformMethod: function(tree) {
          var name = this.transformAny(tree.name);
          var annotations = this.transformList(tree.annotations);
          if (name === tree.name && annotations === tree.annotations) {
            return tree;
          }
          return new Method(tree.location, tree.isStatic, tree.functionKind, name, tree.parameterList, tree.typeAnnotation, annotations, tree.body, tree.debugName);
        },
        transformArrowFunction: function(tree) {
          return tree;
        }
      }, {}, $__super);
    }(ParseTreeTransformer);
  }
  return {get default() {
      return SkipFunctionsTransformerTrait;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ModuleTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ModuleTransformer.js";
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")),
      AnonBlock = $__8.AnonBlock,
      BindingElement = $__8.BindingElement,
      EmptyStatement = $__8.EmptyStatement,
      LiteralPropertyName = $__8.LiteralPropertyName,
      Module = $__8.Module,
      ObjectPattern = $__8.ObjectPattern,
      ObjectPatternField = $__8.ObjectPatternField,
      Script = $__8.Script;
  var DestructuringTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./DestructuringTransformer.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).DestructuringTransformer;
  var DirectExportVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./module/DirectExportVisitor.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).DirectExportVisitor;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).default;
  var ImportSimplifyingTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportSimplifyingTransformer.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).ImportSimplifyingTransformer;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).TempVarTransformer;
  var $__14 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")),
      CLASS_DECLARATION = $__14.CLASS_DECLARATION,
      EXPORT_DEFAULT = $__14.EXPORT_DEFAULT,
      EXPORT_SPECIFIER = $__14.EXPORT_SPECIFIER,
      FORWARD_DEFAULT_EXPORT = $__14.FORWARD_DEFAULT_EXPORT,
      FUNCTION_DECLARATION = $__14.FUNCTION_DECLARATION,
      IMPORT_SPECIFIER_SET = $__14.IMPORT_SPECIFIER_SET,
      IMPORT_TYPE_CLAUSE = $__14.IMPORT_TYPE_CLAUSE,
      NAME_SPACE_EXPORT = $__14.NAME_SPACE_EXPORT;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).VAR;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/assert.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).assert;
  var $__17 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/url.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")),
      resolveUrl = $__17.resolveUrl,
      canonicalizeUrl = $__17.canonicalizeUrl;
  var $__18 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")),
      createArgumentList = $__18.createArgumentList,
      createExpressionStatement = $__18.createExpressionStatement,
      createIdentifierExpression = $__18.createIdentifierExpression,
      createIdentifierToken = $__18.createIdentifierToken,
      createMemberExpression = $__18.createMemberExpression,
      createObjectLiteral = $__18.createObjectLiteral,
      createUseStrictDirective = $__18.createUseStrictDirective,
      createVariableStatement = $__18.createVariableStatement,
      createVoid0 = $__18.createVoid0;
  var $__19 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")),
      parseExpression = $__19.parseExpression,
      parsePropertyDefinition = $__19.parsePropertyDefinition,
      parseStatement = $__19.parseStatement,
      parseStatements = $__19.parseStatements;
  var SkipFunctionsTransformerTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SkipFunctionsTransformerTrait.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).default;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).ParseTreeTransformer;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/ModuleTransformer.js")).prependStatements;
  function removeUseStrictDirectives(tree) {
    var result = tree.scriptItemList.filter(function(tree) {
      return !tree.isUseStrictDirective();
    });
    return new Module(tree.location, result, tree.moduleName);
  }
  var DestructImportVarStatement = function($__super) {
    function DestructImportVarStatement() {
      $traceurRuntime.superConstructor(DestructImportVarStatement).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(DestructImportVarStatement, {createGuardedExpression: function(tree) {
        return tree;
      }}, {}, $__super);
  }(DestructuringTransformer);
  var ModuleTransformer = function($__super) {
    function ModuleTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(ModuleTransformer).call(this, identifierGenerator, reporter, options);
      this.exportVisitor = new DirectExportVisitor();
      this.importSimplifier_ = new ImportSimplifyingTransformer();
      this.moduleName = null;
    }
    return ($traceurRuntime.createClass)(ModuleTransformer, {
      getTempVarNameForModuleName: function(moduleName) {
        return '$__' + moduleName.replace(/[^a-zA-Z0-9$]/g, function(c) {
          return '_' + String(c.charCodeAt(0)) + '_';
        }) + '__';
      },
      getModuleName: function(tree) {
        return tree.moduleName;
      },
      getTempVarNameForModuleSpecifier: function(moduleSpecifier) {
        var name = moduleSpecifier.token.processedValue;
        if (name[0] === '.' && this.moduleName) {
          name = resolveUrl(this.moduleName, name);
        } else {
          name = canonicalizeUrl(name);
        }
        return this.getTempVarNameForModuleName(name);
      },
      transformScript: function(tree) {
        this.moduleName = tree.moduleName;
        return $traceurRuntime.superGet(this, ModuleTransformer.prototype, "transformScript").call(this, tree);
      },
      transformModule: function(tree) {
        tree = removeUseStrictDirectives(tree);
        tree = this.importSimplifier_.transformModule(tree);
        var replaceThis = new ReplaceThis();
        tree = replaceThis.transformAny(tree);
        this.moduleName = this.getModuleName(tree);
        this.pushTempScope();
        var statements = this.transformList(tree.scriptItemList);
        statements = this.addExportStatement(statements);
        var runtimeImports = this.transformList(this.getRuntimeImports());
        statements = prependStatements.apply((void 0), $traceurRuntime.spread([statements], runtimeImports));
        this.popTempScope();
        statements = this.wrapModule(this.moduleProlog().concat(statements));
        return new Script(tree.location, statements, null);
      },
      moduleProlog: function() {
        var statements = [createUseStrictDirective()];
        if (this.moduleName) {
          statements.push(parseStatement($traceurRuntime.getTemplateObject(["var __moduleName = ", ";"]), this.moduleName));
        }
        return statements;
      },
      wrapModule: function(statements) {
        var functionExpression;
        if (this.options.transformOptions.require) {
          functionExpression = parseExpression($traceurRuntime.getTemplateObject(["function(require) {\n        ", "\n      }"]), statements);
        } else {
          functionExpression = parseExpression($traceurRuntime.getTemplateObject(["function() {\n        ", "\n      }"]), statements);
        }
        if (this.moduleName === null) {
          return parseStatements($traceurRuntime.getTemplateObject(["$traceurRuntime.ModuleStore.getAnonymousModule(\n              ", ");"]), functionExpression);
        }
        return parseStatements($traceurRuntime.getTemplateObject(["$traceurRuntime.registerModule(", ", [], ", ");"]), this.moduleName, functionExpression);
      },
      getGetterExport: function(exp) {
        var returnExpression = this.getGetterExportReturnExpression(exp);
        return parsePropertyDefinition($traceurRuntime.getTemplateObject(["get ", "() { return ", "; }"]), exp.name, returnExpression);
      },
      getGetterExportReturnExpression: function($__4) {
        var $__5 = $__4,
            name = $__5.name,
            tree = $__5.tree,
            moduleSpecifier = $__5.moduleSpecifier;
        var returnExpression;
        switch (tree.type) {
          case EXPORT_DEFAULT:
            switch (tree.expression.type) {
              case CLASS_DECLARATION:
              case FUNCTION_DECLARATION:
                return createIdentifierExpression(tree.expression.name);
              default:
                return createIdentifierExpression('$__default');
            }
            break;
          case EXPORT_SPECIFIER:
            if (moduleSpecifier) {
              var idName = this.getTempVarNameForModuleSpecifier(moduleSpecifier);
              return createMemberExpression(idName, tree.lhs);
            }
            return createIdentifierExpression(tree.lhs);
          case NAME_SPACE_EXPORT:
            {
              var idName$__6 = this.getTempVarNameForModuleSpecifier(moduleSpecifier);
              return createIdentifierExpression(idName$__6);
            }
          case FORWARD_DEFAULT_EXPORT:
            {
              var idName$__7 = this.getTempVarNameForModuleSpecifier(moduleSpecifier);
              return createMemberExpression(idName$__7, 'default');
            }
          default:
            return createIdentifierExpression(name);
        }
      },
      getExportProperties: function() {
        var $__3 = this;
        return this.exportVisitor.getNonTypeNamedExports().map(function(exp) {
          return $__3.getGetterExport(exp);
        }).concat(this.exportVisitor.namedExports.map(function(exp) {
          return $__3.getSetterExport(exp);
        })).filter(function(e) {
          return e;
        });
      },
      getSetterExport: function($__4) {
        var $__5 = $__4,
            name = $__5.name,
            tree = $__5.tree,
            moduleSpecifier = $__5.moduleSpecifier;
        return null;
      },
      getExportObject: function() {
        var exportObject = createObjectLiteral(this.getExportProperties());
        if (this.hasStarExports()) {
          return this.getExportStar(exportObject);
        }
        return exportObject;
      },
      getExportStar: function(exportObject) {
        var $__3 = this;
        var starExports = this.exportVisitor.starExports;
        var starIdents = starExports.map(function(moduleSpecifier) {
          return createIdentifierExpression($__3.getTempVarNameForModuleSpecifier(moduleSpecifier));
        });
        var args = createArgumentList($traceurRuntime.spread([exportObject], starIdents));
        var runtime = this.getRuntimeExpression('exportStar');
        return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), runtime, args);
      },
      addExportStatement: function(statements) {
        var exportObject = this.getExportObject();
        statements.push(parseStatement($traceurRuntime.getTemplateObject(["return ", ""]), exportObject));
        return statements;
      },
      hasExports: function() {
        return this.exportVisitor.hasExports();
      },
      hasStarExports: function() {
        return this.exportVisitor.starExports.length > 0;
      },
      transformExportDeclaration: function(tree) {
        this.exportVisitor.visitAny(tree);
        return this.transformAny(tree.declaration);
      },
      transformExportDefault: function(tree) {
        switch (tree.expression.type) {
          case CLASS_DECLARATION:
          case FUNCTION_DECLARATION:
            return tree.expression;
        }
        return parseStatement($traceurRuntime.getTemplateObject(["var $__default = ", ""]), tree.expression);
      },
      transformNamedExport: function(tree) {
        var moduleSpecifier = tree.moduleSpecifier;
        if (moduleSpecifier) {
          var expression = this.transformAny(moduleSpecifier);
          var idName = this.getTempVarNameForModuleSpecifier(moduleSpecifier);
          return createVariableStatement(VAR, idName, expression);
        }
        return new AnonBlock(null, []);
      },
      transformModuleSpecifier: function(tree) {
        assert(this.moduleName);
        var name = tree.token.processedValue;
        return parseExpression($traceurRuntime.getTemplateObject(["$traceurRuntime.getModule(\n      $traceurRuntime.normalizeModuleName(", ", ", "));"]), name, this.moduleName);
      },
      transformImportDeclaration: function(tree) {
        if (tree.importClause.type === IMPORT_TYPE_CLAUSE) {
          return new AnonBlock(null, []);
        }
        if (tree.importClause.type === IMPORT_SPECIFIER_SET && tree.importClause.specifiers.length === 0) {
          return createExpressionStatement(this.transformAny(tree.moduleSpecifier));
        }
        var binding = this.transformAny(tree.importClause);
        var initializer = this.transformAny(tree.moduleSpecifier);
        var varStatement = createVariableStatement(VAR, binding, initializer);
        if (this.options.transformOptions.destructuring || !this.options.parseOptions.destructuring) {
          var destructuringTransformer = new DestructImportVarStatement(this.identifierGenerator, this.reporter, this.options);
          varStatement = varStatement.transform(destructuringTransformer);
        }
        return varStatement;
      },
      transformImportSpecifierSet: function(tree) {
        var fields = this.transformList(tree.specifiers);
        return new ObjectPattern(null, fields);
      },
      transformNameSpaceImport: function(tree) {
        return tree.binding.binding;
      },
      transformImportSpecifier: function(tree) {
        var binding = tree.binding.binding;
        var bindingElement = new BindingElement(binding.location, binding, null);
        if (tree.name) {
          var name = new LiteralPropertyName(tree.name.location, tree.name);
          return new ObjectPatternField(tree.location, name, bindingElement);
        }
        return bindingElement;
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  var ReplaceThis = function($__super) {
    function ReplaceThis() {
      $traceurRuntime.superConstructor(ReplaceThis).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ReplaceThis, {transformThisExpression: function(tree) {
        return createVoid0();
      }}, {}, $__super);
  }(SkipFunctionsTransformerTrait(ParseTreeTransformer));
  return {get ModuleTransformer() {
      return ModuleTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/globalThis.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/globalThis.js";
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/globalThis.js")).parseExpression;
  var expr;
  function globalThis() {
    if (!expr)
      expr = parseExpression($traceurRuntime.getTemplateObject(["Reflect.global"]));
    return expr;
  }
  var $__default = globalThis;
  return {get default() {
      return $__default;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/AmdTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/AmdTransformer.js";
  var ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/AmdTransformer.js")).ModuleTransformer;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/AmdTransformer.js")),
      createIdentifierExpression = $__3.createIdentifierExpression,
      createFormalParameter = $__3.createFormalParameter,
      createStringLiteralToken = $__3.createStringLiteralToken;
  var globalThis = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./globalThis.js", "traceur@0.0.112/src/codegeneration/AmdTransformer.js")).default;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/AmdTransformer.js")),
      parseExpression = $__5.parseExpression,
      parseStatement = $__5.parseStatement,
      parseStatements = $__5.parseStatements,
      parsePropertyDefinition = $__5.parsePropertyDefinition;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/AmdTransformer.js")),
      FormalParameterList = $__6.FormalParameterList,
      FunctionBody = $__6.FunctionBody,
      FunctionExpression = $__6.FunctionExpression;
  var AmdTransformer = function($__super) {
    function AmdTransformer(identifierGenerator, reporter) {
      var options = arguments[2];
      $traceurRuntime.superConstructor(AmdTransformer).call(this, identifierGenerator, reporter, options);
      this.dependencies = [];
      this.anonymousModule = options && !options.bundle && options.moduleName !== true;
    }
    return ($traceurRuntime.createClass)(AmdTransformer, {
      getModuleName: function(tree) {
        if (this.anonymousModule)
          return null;
        return tree.moduleName;
      },
      getExportProperties: function() {
        var properties = $traceurRuntime.superGet(this, AmdTransformer.prototype, "getExportProperties").call(this);
        if (this.exportVisitor.hasExports())
          properties.push(parsePropertyDefinition($traceurRuntime.getTemplateObject(["__esModule: true"])));
        return properties;
      },
      moduleProlog: function() {
        var locals = this.dependencies.map(function(dep) {
          var local = createIdentifierExpression(dep.local);
          return parseStatement($traceurRuntime.getTemplateObject(["if (!", " || !", ".__esModule)\n            ", " = {default: ", "}"]), local, local, local, local);
        });
        return $traceurRuntime.superGet(this, AmdTransformer.prototype, "moduleProlog").call(this).concat(locals);
      },
      wrapModule: function(statements) {
        var depPaths = this.dependencies.map(function(dep) {
          return dep.path;
        });
        var formals = this.dependencies.map(function(dep) {
          return createFormalParameter(dep.local);
        });
        var parameterList = new FormalParameterList(null, formals);
        var body = new FunctionBody(null, statements);
        var func = new FunctionExpression(null, null, null, parameterList, null, [], body);
        if (this.moduleName) {
          return parseStatements($traceurRuntime.getTemplateObject(["define(", ", ", ", ", ");"]), this.moduleName, depPaths, func);
        } else {
          return parseStatements($traceurRuntime.getTemplateObject(["define(", ", ", ");"]), depPaths, func);
        }
      },
      transformModuleSpecifier: function(tree) {
        var localName = this.getTempIdentifier();
        var value = tree.token.processedValue;
        var stringLiteral = createStringLiteralToken(value.replace(/\.js$/, ''));
        this.dependencies.push({
          path: stringLiteral,
          local: localName
        });
        return createIdentifierExpression(localName);
      }
    }, {}, $__super);
  }(ModuleTransformer);
  return {get AmdTransformer() {
      return AmdTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/staticsemantics/PropName.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/staticsemantics/PropName.js";
  var $__0 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/staticsemantics/PropName.js")),
      COMPUTED_PROPERTY_NAME = $__0.COMPUTED_PROPERTY_NAME,
      GET_ACCESSOR = $__0.GET_ACCESSOR,
      LITERAL_PROPERTY_NAME = $__0.LITERAL_PROPERTY_NAME,
      METHOD = $__0.METHOD,
      PROPERTY_NAME_ASSIGNMENT = $__0.PROPERTY_NAME_ASSIGNMENT,
      PROPERTY_NAME_SHORTHAND = $__0.PROPERTY_NAME_SHORTHAND,
      SET_ACCESSOR = $__0.SET_ACCESSOR;
  var IDENTIFIER = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/staticsemantics/PropName.js")).IDENTIFIER;
  function propName(tree) {
    switch (tree.type) {
      case LITERAL_PROPERTY_NAME:
        {
          var token = tree.literalToken;
          if (token.isKeyword() || token.type === IDENTIFIER)
            return token.toString();
          return String(tree.literalToken.processedValue);
        }
      case COMPUTED_PROPERTY_NAME:
        return '';
      case PROPERTY_NAME_SHORTHAND:
        return tree.name.toString();
      case METHOD:
      case PROPERTY_NAME_ASSIGNMENT:
      case GET_ACCESSOR:
      case SET_ACCESSOR:
        return propName(tree.name);
    }
  }
  return {get propName() {
      return propName;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js")).ParseTreeTransformer;
  var CONSTRUCTOR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js")).CONSTRUCTOR;
  var STRING = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js")).STRING;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js")),
      AnonBlock = $__8.AnonBlock,
      ClassDeclaration = $__8.ClassDeclaration,
      ExportDeclaration = $__8.ExportDeclaration,
      FormalParameter = $__8.FormalParameter,
      FunctionDeclaration = $__8.FunctionDeclaration,
      GetAccessor = $__8.GetAccessor,
      LiteralExpression = $__8.LiteralExpression,
      Method = $__8.Method,
      SetAccessor = $__8.SetAccessor;
  var propName = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../staticsemantics/PropName.js", "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js")).propName;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js")),
      createArgumentList = $__10.createArgumentList,
      createArrayLiteral = $__10.createArrayLiteral,
      createAssignmentStatement = $__10.createAssignmentStatement,
      createIdentifierExpression = $__10.createIdentifierExpression,
      createMemberExpression = $__10.createMemberExpression,
      createNewExpression = $__10.createNewExpression,
      createStringLiteralToken = $__10.createStringLiteralToken;
  var $__11 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/AnnotationsTransformer.js")),
      parseExpression = $__11.parseExpression,
      parseStatement = $__11.parseStatement;
  var AnnotationsScope = function() {
    function AnnotationsScope() {
      this.className = null;
      this.isExport = false;
      this.constructorParameters = [];
      this.annotations = [];
      this.metadata = [];
    }
    return ($traceurRuntime.createClass)(AnnotationsScope, {get inClassScope() {
        return this.className !== null;
      }}, {});
  }();
  var AnnotationsTransformer = function($__super) {
    function AnnotationsTransformer() {
      $traceurRuntime.superConstructor(AnnotationsTransformer).call(this);
      this.stack_ = [new AnnotationsScope()];
    }
    return ($traceurRuntime.createClass)(AnnotationsTransformer, {
      transformExportDeclaration: function(tree) {
        var $__3;
        var scope = this.pushAnnotationScope_();
        scope.isExport = true;
        ($__3 = scope.annotations).push.apply($__3, $traceurRuntime.spread(tree.annotations));
        var declaration = this.transformAny(tree.declaration);
        if (declaration !== tree.declaration || tree.annotations.length > 0)
          tree = new ExportDeclaration(tree.location, declaration, []);
        return this.appendMetadata_(tree);
      },
      transformClassDeclaration: function(tree) {
        var $__3,
            $__4;
        var elementsChanged = false;
        var exportAnnotations = this.scope.isExport ? this.scope.annotations : [];
        var scope = this.pushAnnotationScope_();
        scope.className = tree.name;
        ($__3 = scope.annotations).push.apply($__3, $traceurRuntime.spread(exportAnnotations, tree.annotations));
        tree = $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformClassDeclaration").call(this, tree);
        ($__4 = scope.metadata).unshift.apply($__4, $traceurRuntime.spread(this.transformMetadata_(createIdentifierExpression(tree.name), scope.annotations, scope.constructorParameters)));
        if (tree.annotations.length > 0) {
          tree = new ClassDeclaration(tree.location, tree.name, tree.superClass, tree.elements, [], null);
        }
        return this.appendMetadata_(tree);
      },
      transformFunctionDeclaration: function(tree) {
        var $__3,
            $__4;
        var exportAnnotations = this.scope.isExport ? this.scope.annotations : [];
        var scope = this.pushAnnotationScope_();
        ($__3 = scope.annotations).push.apply($__3, $traceurRuntime.spread(exportAnnotations, tree.annotations));
        ($__4 = scope.metadata).push.apply($__4, $traceurRuntime.spread(this.transformMetadata_(createIdentifierExpression(tree.name), scope.annotations, tree.parameterList.parameters)));
        tree = $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformFunctionDeclaration").call(this, tree);
        if (tree.annotations.length > 0) {
          tree = new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, tree.typeAnnotation, [], tree.body);
        }
        return this.appendMetadata_(tree);
      },
      transformFormalParameter: function(tree) {
        if (tree.annotations.length > 0) {
          tree = new FormalParameter(tree.location, tree.parameter, tree.typeAnnotation, []);
        }
        return $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformFormalParameter").call(this, tree);
      },
      transformGetAccessor: function(tree) {
        var $__3;
        if (!this.scope.inClassScope)
          return $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformGetAccessor").call(this, tree);
        ($__3 = this.scope.metadata).push.apply($__3, $traceurRuntime.spread(this.transformMetadata_(this.transformAccessor_(tree, this.scope.className, 'get'), tree.annotations, [])));
        if (tree.annotations.length > 0) {
          tree = new GetAccessor(tree.location, tree.isStatic, tree.name, tree.typeAnnotation, [], tree.body);
        }
        return $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformGetAccessor").call(this, tree);
      },
      transformSetAccessor: function(tree) {
        var $__3;
        if (!this.scope.inClassScope)
          return $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformSetAccessor").call(this, tree);
        ($__3 = this.scope.metadata).push.apply($__3, $traceurRuntime.spread(this.transformMetadata_(this.transformAccessor_(tree, this.scope.className, 'set'), tree.annotations, tree.parameterList.parameters)));
        var parameterList = this.transformAny(tree.parameterList);
        if (parameterList !== tree.parameterList || tree.annotations.length > 0) {
          tree = new SetAccessor(tree.location, tree.isStatic, tree.name, parameterList, [], tree.body);
        }
        return $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformSetAccessor").call(this, tree);
      },
      transformMethod: function(tree) {
        var $__3,
            $__4;
        if (!this.scope.inClassScope)
          return $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformMethod").call(this, tree);
        if (!tree.isStatic && propName(tree) === CONSTRUCTOR) {
          ($__3 = this.scope.annotations).push.apply($__3, $traceurRuntime.spread(tree.annotations));
          this.scope.constructorParameters = tree.parameterList.parameters;
        } else {
          ($__4 = this.scope.metadata).push.apply($__4, $traceurRuntime.spread(this.transformMetadata_(this.transformPropertyMethod_(tree, this.scope.className), tree.annotations, tree.parameterList.parameters)));
        }
        var parameterList = this.transformAny(tree.parameterList);
        if (parameterList !== tree.parameterList || tree.annotations.length > 0) {
          tree = new Method(tree.location, tree.isStatic, tree.functionKind, tree.name, parameterList, tree.typeAnnotation, [], tree.body, tree.debugName);
        }
        return $traceurRuntime.superGet(this, AnnotationsTransformer.prototype, "transformMethod").call(this, tree);
      },
      appendMetadata_: function(tree) {
        var $__3;
        var metadata = this.stack_.pop().metadata;
        if (metadata.length > 0) {
          if (this.scope.isExport) {
            ($__3 = this.scope.metadata).push.apply($__3, $traceurRuntime.spread(metadata));
          } else {
            tree = new AnonBlock(null, $traceurRuntime.spread([tree], metadata));
          }
        }
        return tree;
      },
      transformClassReference_: function(tree, className) {
        var parent = createIdentifierExpression(className);
        if (!tree.isStatic)
          parent = createMemberExpression(parent, 'prototype');
        return parent;
      },
      transformPropertyMethod_: function(tree, className) {
        return createMemberExpression(this.transformClassReference_(tree, className), tree.name.literalToken);
      },
      transformAccessor_: function(tree, className, accessor) {
        var args = createArgumentList([this.transformClassReference_(tree, className), this.createLiteralStringExpression_(tree.name)]);
        var descriptor = parseExpression($traceurRuntime.getTemplateObject(["Object.getOwnPropertyDescriptor(", ")"]), args);
        return createMemberExpression(descriptor, accessor);
      },
      transformParameters_: function(parameters) {
        var $__2 = this;
        var hasParameterMetadata = false;
        parameters = parameters.map(function(param) {
          var $__3;
          var metadata = [];
          if (param.typeAnnotation)
            metadata.push($__2.transformAny(param.typeAnnotation));
          if (param.annotations && param.annotations.length > 0)
            ($__3 = metadata).push.apply($__3, $traceurRuntime.spread($__2.transformAnnotations_(param.annotations)));
          if (metadata.length > 0) {
            hasParameterMetadata = true;
            return createArrayLiteral(metadata);
          }
          return createArrayLiteral([]);
        });
        return hasParameterMetadata ? parameters : [];
      },
      transformAnnotations_: function(annotations) {
        return annotations.map(function(annotation) {
          return createNewExpression(annotation.name, annotation.args);
        });
      },
      transformMetadata_: function(target, annotations, parameters) {
        var metadataStatements = [];
        if (annotations !== null) {
          annotations = this.transformAnnotations_(annotations);
          if (annotations.length > 0) {
            metadataStatements.push(this.createDefinePropertyStatement_(target, 'annotations', createArrayLiteral(annotations)));
          }
        }
        if (parameters !== null) {
          parameters = this.transformParameters_(parameters);
          if (parameters.length > 0) {
            metadataStatements.push(this.createDefinePropertyStatement_(target, 'parameters', createArrayLiteral(parameters)));
          }
        }
        return metadataStatements;
      },
      createDefinePropertyStatement_: function(target, property, value) {
        return parseStatement($traceurRuntime.getTemplateObject(["Object.defineProperty(", ", ", ",\n        {get: function() {return ", "}});"]), target, property, value);
      },
      createLiteralStringExpression_: function(tree) {
        var token = tree.literalToken;
        if (tree.literalToken.type !== STRING)
          token = createStringLiteralToken(tree.literalToken.value);
        return new LiteralExpression(null, token);
      },
      get scope() {
        return this.stack_[this.stack_.length - 1];
      },
      pushAnnotationScope_: function() {
        var scope = new AnnotationsScope();
        this.stack_.push(scope);
        return scope;
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get AnnotationsTransformer() {
      return AnnotationsTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/FindInFunctionScope.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/FindInFunctionScope.js";
  var FindVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindVisitor.js", "traceur@0.0.112/src/codegeneration/FindInFunctionScope.js")).FindVisitor;
  var FindInFunctionScope = function($__super) {
    function FindInFunctionScope() {
      $traceurRuntime.superConstructor(FindInFunctionScope).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(FindInFunctionScope, {
      visitFunctionDeclaration: function(tree) {
        this.visitList(tree.annotations);
      },
      visitFunctionExpression: function(tree) {
        this.visitList(tree.annotations);
      },
      visitSetAccessor: function(tree) {
        this.visitAny(tree.name);
        this.visitList(tree.annotations);
      },
      visitGetAccessor: function(tree) {
        this.visitAny(tree.name);
        this.visitList(tree.annotations);
      },
      visitMethod: function(tree) {
        this.visitAny(tree.name);
        this.visitList(tree.annotations);
      }
    }, {}, $__super);
  }(FindVisitor);
  return {get FindInFunctionScope() {
      return FindInFunctionScope;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/util.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/util.js";
  var $__0 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/semantics/util.js")),
      IDENTIFIER_EXPRESSION = $__0.IDENTIFIER_EXPRESSION,
      LITERAL_EXPRESSION = $__0.LITERAL_EXPRESSION,
      PAREN_EXPRESSION = $__0.PAREN_EXPRESSION,
      UNARY_EXPRESSION = $__0.UNARY_EXPRESSION;
  var UNDEFINED = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/semantics/util.js")).UNDEFINED;
  var VOID = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/semantics/util.js")).VOID;
  function hasUseStrict(list) {
    for (var i = 0; i < list.length; i++) {
      if (!list[i].isDirectivePrologue())
        return false;
      if (list[i].isUseStrictDirective())
        return true;
    }
    return false;
  }
  function isUndefined(tree) {
    if (tree.type === PAREN_EXPRESSION)
      return isUndefined(tree.expression);
    return tree.type === IDENTIFIER_EXPRESSION && tree.identifierToken.value === UNDEFINED;
  }
  function isVoidExpression(tree) {
    if (tree.type === PAREN_EXPRESSION)
      return isVoidExpression(tree.expression);
    return tree.type === UNARY_EXPRESSION && tree.operator.type === VOID && isLiteralExpression(tree.operand);
  }
  function isLiteralExpression(tree) {
    if (tree.type === PAREN_EXPRESSION)
      return isLiteralExpression(tree.expression);
    return tree.type === LITERAL_EXPRESSION;
  }
  return {
    get hasUseStrict() {
      return hasUseStrict;
    },
    get isUndefined() {
      return isUndefined;
    },
    get isVoidExpression() {
      return isVoidExpression;
    },
    get isLiteralExpression() {
      return isLiteralExpression;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/isTreeStrict.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/isTreeStrict.js";
  var $__0 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/semantics/isTreeStrict.js")),
      ARROW_FUNCTION = $__0.ARROW_FUNCTION,
      CLASS_DECLARATION = $__0.CLASS_DECLARATION,
      CLASS_EXPRESSION = $__0.CLASS_EXPRESSION,
      FUNCTION_BODY = $__0.FUNCTION_BODY,
      FUNCTION_DECLARATION = $__0.FUNCTION_DECLARATION,
      FUNCTION_EXPRESSION = $__0.FUNCTION_EXPRESSION,
      GET_ACCESSOR = $__0.GET_ACCESSOR,
      METHOD = $__0.METHOD,
      MODULE = $__0.MODULE,
      SCRIPT = $__0.SCRIPT,
      SET_ACCESSOR = $__0.SET_ACCESSOR;
  var hasUseStrict = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util.js", "traceur@0.0.112/src/semantics/isTreeStrict.js")).hasUseStrict;
  function isTreeStrict(tree) {
    switch (tree.type) {
      case CLASS_DECLARATION:
      case CLASS_EXPRESSION:
      case MODULE:
        return true;
      case FUNCTION_BODY:
        return hasUseStrict(tree.statements);
      case FUNCTION_EXPRESSION:
      case FUNCTION_DECLARATION:
      case METHOD:
        return isTreeStrict(tree.body);
      case ARROW_FUNCTION:
        if (tree.body.type === FUNCTION_BODY) {
          return isTreeStrict(tree.body);
        }
        return false;
      case GET_ACCESSOR:
      case SET_ACCESSOR:
        return isTreeStrict(tree.body);
      case SCRIPT:
        return hasUseStrict(tree.scriptItemList);
      default:
        return false;
    }
  }
  return {get isTreeStrict() {
      return isTreeStrict;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/Scope.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/Scope.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/semantics/Scope.js")),
      BLOCK = $__2.BLOCK,
      CATCH = $__2.CATCH,
      FUNCTION_EXPRESSION = $__2.FUNCTION_EXPRESSION;
  var StringMap = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringMap.js", "traceur@0.0.112/src/semantics/Scope.js")).StringMap;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/semantics/Scope.js")).VAR;
  var isTreeStrict = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./isTreeStrict.js", "traceur@0.0.112/src/semantics/Scope.js")).isTreeStrict;
  function reportDuplicateVar(reporter, tree, name) {
    reporter.reportError(tree.location, ("Duplicate declaration, " + name));
  }
  var Scope = function() {
    function Scope(parent, tree) {
      this.parent = parent;
      this.tree = tree;
      this.variableDeclarations_ = new StringMap();
      this.lexicalDeclarations_ = new StringMap();
      this.strictMode = parent && parent.strictMode || isTreeStrict(tree);
      this.inGenerator = parent ? parent.inGenerator || false : false;
    }
    return ($traceurRuntime.createClass)(Scope, {
      addBinding: function(tree, type, reporter) {
        if (type === VAR) {
          this.addVar(tree, reporter);
        } else {
          this.addDeclaration(tree, type, reporter);
        }
      },
      addVar: function(tree, reporter) {
        var name = tree.getStringValue();
        if (this.lexicalDeclarations_.has(name) && !this.isFunctionExpressionName(name)) {
          reportDuplicateVar(reporter, tree, name);
          return;
        }
        this.variableDeclarations_.set(name, {
          type: VAR,
          tree: tree,
          scope: this
        });
        if (!this.isVarScope && this.parent) {
          this.parent.addVar(tree, reporter);
        }
      },
      addDeclaration: function(tree, type, reporter) {
        var name = tree.getStringValue();
        if ((this.lexicalDeclarations_.has(name) || this.variableDeclarations_.has(name)) && !this.isFunctionExpressionName(name)) {
          reportDuplicateVar(reporter, tree, name);
          return;
        }
        this.lexicalDeclarations_.set(name, {
          type: type,
          tree: tree,
          scope: this
        });
      },
      renameBinding: function(oldName, newTree, newType, reporter) {
        var name = newTree.getStringValue();
        if (newType === VAR) {
          if (this.lexicalDeclarations_.has(oldName)) {
            this.lexicalDeclarations_.delete(oldName);
            this.addVar(newTree, reporter);
          }
        } else if (this.variableDeclarations_.has(oldName)) {
          this.variableDeclarations_.delete(oldName);
          this.addDeclaration(newTree, newType, reporter);
          if (!this.isVarScope && this.parent) {
            this.parent.renameBinding(oldName, newTree, newType);
          }
        }
      },
      get isVarScope() {
        switch (this.tree.type) {
          case BLOCK:
          case CATCH:
            return false;
        }
        return true;
      },
      getVarScope: function() {
        if (this.isVarScope) {
          return this;
        }
        if (this.parent) {
          return this.parent.getVarScope();
        }
        return null;
      },
      isFunctionExpressionName: function(name) {
        var b = this.getBindingByName(name);
        return b && b.scope.tree.type === FUNCTION_EXPRESSION && b.scope.tree.name === b.tree;
      },
      getBinding: function(tree) {
        var name = tree.getStringValue();
        return this.getBindingByName(name);
      },
      getBindingByName: function(name) {
        var b = this.variableDeclarations_.get(name);
        if (b && this.isVarScope) {
          return b;
        }
        b = this.lexicalDeclarations_.get(name);
        if (b) {
          return b;
        }
        if (this.parent) {
          return this.parent.getBindingByName(name);
        }
        return null;
      },
      getAllBindingNames: function() {
        var names = this.variableDeclarations_.keysAsSet();
        this.lexicalDeclarations_.forEach(function(name) {
          return names.add(name);
        });
        return names;
      },
      getVariableBindingNames: function() {
        return this.variableDeclarations_.keysAsSet();
      },
      getLexicalBindingNames: function() {
        return this.lexicalDeclarations_.keysAsSet();
      },
      hasBindingName: function(name) {
        return this.lexicalDeclarations_.has(name) || this.variableDeclarations_.has(name);
      },
      hasLexicalBindingName: function(name) {
        return this.lexicalDeclarations_.has(name);
      },
      hasVariableBindingName: function(name) {
        return this.variableDeclarations_.has(name);
      }
    }, {});
  }();
  return {get Scope() {
      return Scope;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/ScopeVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/ScopeVisitor.js";
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/semantics/ScopeVisitor.js")).ParseTreeVisitor;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/semantics/ScopeVisitor.js")).VAR;
  var Scope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Scope.js", "traceur@0.0.112/src/semantics/ScopeVisitor.js")).Scope;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/semantics/ScopeVisitor.js")),
      COMPREHENSION_FOR = $__6.COMPREHENSION_FOR,
      VARIABLE_DECLARATION_LIST = $__6.VARIABLE_DECLARATION_LIST;
  var ScopeVisitor = function($__super) {
    function ScopeVisitor() {
      $traceurRuntime.superConstructor(ScopeVisitor).call(this);
      this.map_ = new Map();
      this.scope = null;
      this.withBlockCounter_ = 0;
    }
    return ($traceurRuntime.createClass)(ScopeVisitor, {
      getScopeForTree: function(tree) {
        return this.map_.get(tree);
      },
      createScope: function(tree) {
        return new Scope(this.scope, tree);
      },
      pushScope: function(tree) {
        var scope = this.createScope(tree);
        this.map_.set(tree, scope);
        return this.scope = scope;
      },
      popScope: function(scope) {
        if (this.scope !== scope) {
          throw new Error('ScopeVisitor scope mismatch');
        }
        this.scope = scope.parent;
      },
      visitScript: function(tree) {
        var scope = this.pushScope(tree);
        $traceurRuntime.superGet(this, ScopeVisitor.prototype, "visitScript").call(this, tree);
        this.popScope(scope);
      },
      visitModule: function(tree) {
        var scope = this.pushScope(tree);
        $traceurRuntime.superGet(this, ScopeVisitor.prototype, "visitModule").call(this, tree);
        this.popScope(scope);
      },
      visitBlock: function(tree) {
        var scope = this.pushScope(tree);
        $traceurRuntime.superGet(this, ScopeVisitor.prototype, "visitBlock").call(this, tree);
        this.popScope(scope);
      },
      visitCatch: function(tree) {
        var scope = this.pushScope(tree);
        this.visitAny(tree.binding);
        this.visitList(tree.catchBody.statements);
        this.popScope(scope);
      },
      visitFunctionBodyForScope: function(tree) {
        var parameterList = arguments[1] !== (void 0) ? arguments[1] : tree.parameterList;
        var scope = this.pushScope(tree);
        this.visitAny(parameterList);
        scope.inGenerator = tree.functionKind && tree.isGenerator();
        this.visitAny(tree.body);
        this.popScope(scope);
      },
      visitFunctionExpression: function(tree) {
        this.visitFunctionBodyForScope(tree);
      },
      visitFunctionDeclaration: function(tree) {
        this.visitAny(tree.name);
        this.visitFunctionBodyForScope(tree);
      },
      visitArrowFunction: function(tree) {
        this.visitFunctionBodyForScope(tree);
      },
      visitGetAccessor: function(tree) {
        this.visitFunctionBodyForScope(tree, null);
      },
      visitSetAccessor: function(tree) {
        this.visitFunctionBodyForScope(tree);
      },
      visitMethod: function(tree) {
        this.visitFunctionBodyForScope(tree);
      },
      visitClassDeclaration: function(tree) {
        this.visitAny(tree.superClass);
        var scope = this.pushScope(tree);
        this.visitAny(tree.name);
        this.visitList(tree.elements);
        this.popScope(scope);
      },
      visitClassExpression: function(tree) {
        this.visitAny(tree.superClass);
        var scope;
        if (tree.name) {
          scope = this.pushScope(tree);
          this.visitAny(tree.name);
        }
        this.visitList(tree.elements);
        if (tree.name) {
          this.popScope(scope);
        }
      },
      visitWithStatement: function(tree) {
        this.visitAny(tree.expression);
        this.withBlockCounter_++;
        this.visitAny(tree.body);
        this.withBlockCounter_--;
      },
      get inWithBlock() {
        return this.withBlockCounter_ > 0;
      },
      visitLoop_: function(tree, func) {
        if (tree.initializer.type !== VARIABLE_DECLARATION_LIST || tree.initializer.declarationType === VAR) {
          func();
          return;
        }
        var scope = this.pushScope(tree);
        func();
        this.popScope(scope);
      },
      visitForInStatement: function(tree) {
        var $__1 = this;
        this.visitLoop_(tree, function() {
          return $traceurRuntime.superGet($__1, ScopeVisitor.prototype, "visitForInStatement").call($__1, tree);
        });
      },
      visitForOfStatement: function(tree) {
        var $__1 = this;
        this.visitLoop_(tree, function() {
          return $traceurRuntime.superGet($__1, ScopeVisitor.prototype, "visitForOfStatement").call($__1, tree);
        });
      },
      visitForStatement: function(tree) {
        var $__1 = this;
        if (!tree.initializer) {
          $traceurRuntime.superGet(this, ScopeVisitor.prototype, "visitForStatement").call(this, tree);
        } else {
          this.visitLoop_(tree, function() {
            return $traceurRuntime.superGet($__1, ScopeVisitor.prototype, "visitForStatement").call($__1, tree);
          });
        }
      },
      visitComprehension_: function(tree) {
        var scopes = [];
        for (var i = 0; i < tree.comprehensionList.length; i++) {
          var scope = null;
          if (tree.comprehensionList[i].type === COMPREHENSION_FOR) {
            scope = this.pushScope(tree.comprehensionList[i]);
          }
          scopes.push(scope);
          this.visitAny(tree.comprehensionList[i]);
        }
        this.visitAny(tree.expression);
        for (var i$__2 = scopes.length - 1; i$__2 >= 0; i$__2--) {
          if (scopes[i$__2]) {
            this.popScope(scopes[i$__2]);
          }
        }
      },
      visitArrayComprehension: function(tree) {
        this.visitComprehension_(tree);
      },
      visitGeneratorComprehension: function(tree) {
        this.visitComprehension_(tree);
      },
      visitPredefinedType: function(tree) {},
      visitTypeArguments: function(tree) {},
      visitFunctionType: function(tree) {}
    }, {}, $__super);
  }(ParseTreeVisitor);
  return {get ScopeVisitor() {
      return ScopeVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/ScopeChainBuilder.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/ScopeChainBuilder.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/semantics/ScopeChainBuilder.js")),
      CONST = $__1.CONST,
      LET = $__1.LET,
      VAR = $__1.VAR;
  var ScopeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeVisitor.js", "traceur@0.0.112/src/semantics/ScopeChainBuilder.js")).ScopeVisitor;
  var ScopeChainBuilder = function($__super) {
    function ScopeChainBuilder(reporter) {
      $traceurRuntime.superConstructor(ScopeChainBuilder).call(this);
      this.reporter = reporter;
      this.declarationType_ = null;
    }
    return ($traceurRuntime.createClass)(ScopeChainBuilder, {
      visitCatch: function(tree) {
        var scope = this.pushScope(tree);
        this.declarationType_ = LET;
        this.visitAny(tree.binding);
        this.visitList(tree.catchBody.statements);
        this.popScope(scope);
      },
      visitImportedBinding: function(tree) {
        this.declarationType_ = CONST;
        $traceurRuntime.superGet(this, ScopeChainBuilder.prototype, "visitImportedBinding").call(this, tree);
      },
      visitVariableDeclarationList: function(tree) {
        this.declarationType_ = tree.declarationType;
        $traceurRuntime.superGet(this, ScopeChainBuilder.prototype, "visitVariableDeclarationList").call(this, tree);
      },
      visitBindingIdentifier: function(tree) {
        this.declareVariable(tree);
      },
      visitFunctionExpression: function(tree) {
        var scope = this.pushScope(tree);
        if (tree.name) {
          this.declarationType_ = CONST;
          this.visitAny(tree.name);
        }
        this.visitAny(tree.parameterList);
        scope.inGenerator = tree.isGenerator();
        this.visitAny(tree.body);
        this.popScope(scope);
      },
      visitFormalParameter: function(tree) {
        this.declarationType_ = VAR;
        $traceurRuntime.superGet(this, ScopeChainBuilder.prototype, "visitFormalParameter").call(this, tree);
      },
      visitFunctionDeclaration: function(tree) {
        if (this.scope) {
          if (this.scope.isVarScope) {
            this.declarationType_ = VAR;
            this.visitAny(tree.name);
          } else {
            if (!this.scope.strictMode) {
              var varScope = this.scope.getVarScope();
              if (varScope) {
                varScope.addVar(tree.name, this.reporter);
              }
            }
            this.declarationType_ = LET;
            this.visitAny(tree.name);
          }
        }
        this.visitFunctionBodyForScope(tree, tree.parameterList, tree.body);
      },
      visitClassDeclaration: function(tree) {
        this.visitAny(tree.superClass);
        this.declarationType_ = LET;
        this.visitAny(tree.name);
        var scope = this.pushScope(tree);
        this.declarationType_ = CONST;
        this.visitAny(tree.name);
        this.visitList(tree.elements);
        this.popScope(scope);
      },
      visitClassExpression: function(tree) {
        this.visitAny(tree.superClass);
        var scope;
        if (tree.name) {
          scope = this.pushScope(tree);
          this.declarationType_ = CONST;
          this.visitAny(tree.name);
        }
        this.visitList(tree.elements);
        if (tree.name) {
          this.popScope(scope);
        }
      },
      visitComprehensionFor: function(tree) {
        this.declarationType_ = LET;
        $traceurRuntime.superGet(this, ScopeChainBuilder.prototype, "visitComprehensionFor").call(this, tree);
      },
      declareVariable: function(tree) {
        this.scope.addBinding(tree, this.declarationType_, this.reporter);
      }
    }, {}, $__super);
  }(ScopeVisitor);
  return {get ScopeChainBuilder() {
      return ScopeChainBuilder;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/VariableBinder.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/VariableBinder.js";
  var ScopeChainBuilder = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeChainBuilder.js", "traceur@0.0.112/src/semantics/VariableBinder.js")).ScopeChainBuilder;
  function variablesInBlock(tree) {
    var includeFunctionScope = arguments[1];
    var builder = new ScopeChainBuilder(null);
    builder.visitAny(tree);
    var scope = builder.getScopeForTree(tree);
    var names = scope.getLexicalBindingNames();
    if (!includeFunctionScope) {
      return names;
    }
    var variableBindingNames = scope.getVariableBindingNames();
    variableBindingNames.forEach(function(name) {
      return names.add(name);
    });
    return names;
  }
  function variablesInFunction(tree) {
    var builder = new ScopeChainBuilder(null);
    builder.visitAny(tree);
    var scope = builder.getScopeForTree(tree);
    return scope.getAllBindingNames();
  }
  return {
    get variablesInBlock() {
      return variablesInBlock;
    },
    get variablesInFunction() {
      return variablesInFunction;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ScopeTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ScopeTransformer.js";
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")),
      ARGUMENTS = $__4.ARGUMENTS,
      THIS = $__4.THIS;
  var FindInFunctionScope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindInFunctionScope.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")).FindInFunctionScope;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")).ParseTreeTransformer;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")),
      FunctionDeclaration = $__7.FunctionDeclaration,
      FunctionExpression = $__7.FunctionExpression,
      GetAccessor = $__7.GetAccessor,
      Method = $__7.Method,
      SetAccessor = $__7.SetAccessor;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")).StringSet;
  var VARIABLE_DECLARATION_LIST = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")).VARIABLE_DECLARATION_LIST;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")).VAR;
  var $__11 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/VariableBinder.js", "traceur@0.0.112/src/codegeneration/ScopeTransformer.js")),
      variablesInBlock = $__11.variablesInBlock,
      variablesInFunction = $__11.variablesInFunction;
  var FindNames = function($__super) {
    function FindNames(names) {
      $traceurRuntime.superConstructor(FindNames).call(this);
      this.names = names;
    }
    return ($traceurRuntime.createClass)(FindNames, {visitBindingIdentifier: function(tree) {
        this.names.add(tree.getStringValue());
      }}, {}, $__super);
  }(FindInFunctionScope);
  function getLexicalBindingNames(tree) {
    var names = new StringSet();
    if (tree !== null && tree.type === VARIABLE_DECLARATION_LIST && tree.declarationType !== VAR) {
      var visitor = new FindNames(names);
      for (var i = 0; i < tree.declarations.length; i++) {
        visitor.visitAny(tree.declarations[i].lvalue);
      }
    }
    return names;
  }
  var ScopeTransformer = function($__super) {
    function ScopeTransformer(varName) {
      $traceurRuntime.superConstructor(ScopeTransformer).call(this);
      this.varName_ = varName;
    }
    return ($traceurRuntime.createClass)(ScopeTransformer, {
      transformBlock: function(tree) {
        if (variablesInBlock(tree).has(this.varName_)) {
          return tree;
        }
        return $traceurRuntime.superGet(this, ScopeTransformer.prototype, "transformBlock").call(this, tree);
      },
      sameTreeIfNameInLoopInitializer_: function(tree) {
        var names = getLexicalBindingNames(tree.initializer);
        if (names.has(this.varName_)) {
          return tree;
        }
        return null;
      },
      transformForStatement: function(tree) {
        return this.sameTreeIfNameInLoopInitializer_(tree) || $traceurRuntime.superGet(this, ScopeTransformer.prototype, "transformForStatement").call(this, tree);
      },
      transformForInStatement: function(tree) {
        return this.sameTreeIfNameInLoopInitializer_(tree) || $traceurRuntime.superGet(this, ScopeTransformer.prototype, "transformForInStatement").call(this, tree);
      },
      transformForOfStatement: function(tree) {
        return this.sameTreeIfNameInLoopInitializer_(tree) || $traceurRuntime.superGet(this, ScopeTransformer.prototype, "transformForOfStatement").call(this, tree);
      },
      transformForOnStatement: function(tree) {
        return this.sameTreeIfNameInLoopInitializer_(tree) || $traceurRuntime.superGet(this, ScopeTransformer.prototype, "transformForOnStatement").call(this, tree);
      },
      transformThisExpression: function(tree) {
        if (this.varName_ !== THIS)
          return tree;
        return $traceurRuntime.superGet(this, ScopeTransformer.prototype, "transformThisExpression").call(this, tree);
      },
      transformParameterListAndBody_: function(tree) {
        if (this.getDoNotRecurse(tree))
          return tree;
        return {
          parameterList: this.transformAny(tree.parameterList),
          body: this.transformAny(tree.body)
        };
      },
      transformFunctionDeclaration: function(tree) {
        var name = this.transformAny(tree.name);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var $__3 = this.transformParameterListAndBody_(tree),
            parameterList = $__3.parameterList,
            body = $__3.body;
        if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) {
          return tree;
        }
        return new FunctionDeclaration(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, body);
      },
      transformFunctionExpression: function(tree) {
        var name = this.transformAny(tree.name);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var $__3 = this.transformParameterListAndBody_(tree),
            parameterList = $__3.parameterList,
            body = $__3.body;
        if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) {
          return tree;
        }
        return new FunctionExpression(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, body);
      },
      transformMethod: function(tree) {
        var name = this.transformAny(tree.name);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var $__3 = this.transformParameterListAndBody_(tree),
            parameterList = $__3.parameterList,
            body = $__3.body;
        if (name === tree.name && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && parameterList === tree.parameterList && body === tree.body) {
          return tree;
        }
        return new Method(tree.location, tree.isStatic, tree.functionKind, name, parameterList, typeAnnotation, annotations, body, tree.debugName);
      },
      transformGetAccessor: function(tree) {
        var name = this.transformAny(tree.name);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var body = this.getDoNotRecurse(tree) ? tree.body : this.transformAny(tree.body);
        if (name === tree.name && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && body === tree.body) {
          return tree;
        }
        return new GetAccessor(tree.location, tree.isStatic, name, typeAnnotation, annotations, body);
      },
      transformSetAccessor: function(tree) {
        var name = this.transformAny(tree.name);
        var annotations = this.transformList(tree.annotations);
        var $__3 = this.transformParameterListAndBody_(tree),
            parameterList = $__3.parameterList,
            body = $__3.body;
        if (name === tree.name && annotations === tree.annotations && parameterList === tree.parameterList && body === tree.body) {
          return tree;
        }
        return new SetAccessor(tree.location, tree.isStatic, name, parameterList, annotations, body);
      },
      getDoNotRecurse: function(tree) {
        return this.varName_ === ARGUMENTS || this.varName_ === THIS || variablesInFunction(tree).has(this.varName_);
      },
      transformCatch: function(tree) {
        if (!tree.binding.isPattern() && this.varName_ === tree.binding.identifierToken.value) {
          return tree;
        }
        return $traceurRuntime.superGet(this, ScopeTransformer.prototype, "transformCatch").call(this, tree);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get ScopeTransformer() {
      return ScopeTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/AlphaRenamer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/AlphaRenamer.js";
  var ScopeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeTransformer.js", "traceur@0.0.112/src/codegeneration/AlphaRenamer.js")).ScopeTransformer;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/AlphaRenamer.js")),
      FunctionDeclaration = $__2.FunctionDeclaration,
      FunctionExpression = $__2.FunctionExpression;
  var THIS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/AlphaRenamer.js")).THIS;
  var createIdentifierExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/AlphaRenamer.js")).createIdentifierExpression;
  var AlphaRenamer = function($__super) {
    function AlphaRenamer(varName, newName) {
      $traceurRuntime.superConstructor(AlphaRenamer).call(this, varName);
      this.newName_ = newName;
    }
    return ($traceurRuntime.createClass)(AlphaRenamer, {
      transformIdentifierExpression: function(tree) {
        if (this.varName_ === tree.identifierToken.value) {
          return createIdentifierExpression(this.newName_);
        } else {
          return tree;
        }
      },
      transformThisExpression: function(tree) {
        if (this.varName_ !== THIS)
          return tree;
        return createIdentifierExpression(this.newName_);
      },
      transformFunctionDeclaration: function(tree) {
        if (this.varName_ === tree.name) {
          tree = new FunctionDeclaration(tree.location, this.newName_, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body);
        }
        return $traceurRuntime.superGet(this, AlphaRenamer.prototype, "transformFunctionDeclaration").call(this, tree);
      },
      transformFunctionExpression: function(tree) {
        if (this.varName_ === tree.name) {
          tree = new FunctionExpression(tree.location, this.newName_, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body);
        }
        return $traceurRuntime.superGet(this, AlphaRenamer.prototype, "transformFunctionExpression").call(this, tree);
      }
    }, {rename: function(tree, varName, newName) {
        return new AlphaRenamer(varName, newName).transformAny(tree);
      }}, $__super);
  }(ScopeTransformer);
  return {get AlphaRenamer() {
      return AlphaRenamer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/FindThisOrArguments.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/FindThisOrArguments.js";
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/FindThisOrArguments.js")).ARGUMENTS;
  var FindInFunctionScope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindInFunctionScope.js", "traceur@0.0.112/src/codegeneration/FindThisOrArguments.js")).FindInFunctionScope;
  var FindThisOrArguments = function($__super) {
    function FindThisOrArguments() {
      $traceurRuntime.superConstructor(FindThisOrArguments).call(this);
      this.foundThis = false;
      this.foundArguments = false;
    }
    return ($traceurRuntime.createClass)(FindThisOrArguments, {
      visitThisExpression: function(tree) {
        this.foundThis = true;
        this.found = this.foundArguments;
      },
      visitIdentifierExpression: function(tree) {
        if (tree.identifierToken.value === ARGUMENTS) {
          this.foundArguments = true;
          this.found = this.foundThis;
        }
      }
    }, {}, $__super);
  }(FindInFunctionScope);
  return {get FindThisOrArguments() {
      return FindThisOrArguments;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/alphaRenameThisAndArguments.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/alphaRenameThisAndArguments.js";
  var $__0 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/alphaRenameThisAndArguments.js")),
      ARGUMENTS = $__0.ARGUMENTS,
      THIS = $__0.THIS;
  var AlphaRenamer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AlphaRenamer.js", "traceur@0.0.112/src/codegeneration/alphaRenameThisAndArguments.js")).AlphaRenamer;
  var FindThisOrArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindThisOrArguments.js", "traceur@0.0.112/src/codegeneration/alphaRenameThisAndArguments.js")).FindThisOrArguments;
  function alphaRenameThisAndArguments(tempVarTransformer, tree) {
    var finder = new FindThisOrArguments();
    finder.visitAny(tree);
    if (finder.foundArguments) {
      var argumentsTempName = tempVarTransformer.addTempVarForArguments();
      tree = AlphaRenamer.rename(tree, ARGUMENTS, argumentsTempName);
    }
    if (finder.foundThis) {
      var thisTempName = tempVarTransformer.addTempVarForThis();
      tree = AlphaRenamer.rename(tree, THIS, thisTempName);
    }
    return tree;
  }
  return {get default() {
      return alphaRenameThisAndArguments;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js";
  var alphaRenameThisAndArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./alphaRenameThisAndArguments.js", "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js")).default;
  var FunctionExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js")).FunctionExpression;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js")).TempVarTransformer;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js")),
      LET = $__4.LET,
      STAR = $__4.STAR,
      VAR = $__4.VAR;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js")),
      COMPREHENSION_FOR = $__5.COMPREHENSION_FOR,
      COMPREHENSION_IF = $__5.COMPREHENSION_IF;
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/Token.js", "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js")).Token;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ComprehensionTransformer.js")),
      createCallExpression = $__7.createCallExpression,
      createEmptyParameterList = $__7.createEmptyParameterList,
      createForOfStatement = $__7.createForOfStatement,
      createFunctionBody = $__7.createFunctionBody,
      createIfStatement = $__7.createIfStatement,
      createParenExpression = $__7.createParenExpression,
      createVariableDeclarationList = $__7.createVariableDeclarationList;
  var ComprehensionTransformer = function($__super) {
    function ComprehensionTransformer() {
      $traceurRuntime.superConstructor(ComprehensionTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ComprehensionTransformer, {transformComprehension: function(tree, statement, isGenerator) {
        var prefix = arguments[3];
        var suffix = arguments[4];
        var bindingKind = isGenerator || !this.options.blockBinding ? VAR : LET;
        var statements = prefix ? [prefix] : [];
        for (var i = tree.comprehensionList.length - 1; i >= 0; i--) {
          var item = tree.comprehensionList[i];
          switch (item.type) {
            case COMPREHENSION_IF:
              {
                var expression = this.transformAny(item.expression);
                statement = createIfStatement(expression, statement);
                break;
              }
            case COMPREHENSION_FOR:
              {
                var left = this.transformAny(item.left);
                var iterator = this.transformAny(item.iterator);
                var initializer = createVariableDeclarationList(bindingKind, left, null);
                statement = createForOfStatement(initializer, iterator, statement);
                break;
              }
            default:
              throw new Error('Unreachable.');
          }
        }
        statement = alphaRenameThisAndArguments(this, statement);
        statements.push(statement);
        if (suffix)
          statements.push(suffix);
        var functionKind = isGenerator ? new Token(STAR, null) : null;
        var func = new FunctionExpression(null, null, functionKind, createEmptyParameterList(), null, [], createFunctionBody(statements));
        return createParenExpression(createCallExpression(func));
      }}, {}, $__super);
  }(TempVarTransformer);
  return {get ComprehensionTransformer() {
      return ComprehensionTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ArrayComprehensionTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ArrayComprehensionTransformer.js";
  var ComprehensionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ComprehensionTransformer.js", "traceur@0.0.112/src/codegeneration/ArrayComprehensionTransformer.js")).ComprehensionTransformer;
  var createIdentifierExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ArrayComprehensionTransformer.js")).createIdentifierExpression;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ArrayComprehensionTransformer.js")).parseStatement;
  var ArrayComprehensionTransformer = function($__super) {
    function ArrayComprehensionTransformer() {
      $traceurRuntime.superConstructor(ArrayComprehensionTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ArrayComprehensionTransformer, {transformArrayComprehension: function(tree) {
        this.pushTempScope();
        var expression = this.transformAny(tree.expression);
        var index = createIdentifierExpression(this.getTempIdentifier());
        var result = createIdentifierExpression(this.getTempIdentifier());
        var tempVarsStatatement = parseStatement($traceurRuntime.getTemplateObject(["var ", " = 0, ", " = [];"]), index, result);
        var statement = parseStatement($traceurRuntime.getTemplateObject(["", "[", "++] = ", ";"]), result, index, expression);
        var returnStatement = parseStatement($traceurRuntime.getTemplateObject(["return ", ";"]), result);
        var functionKind = null;
        result = this.transformComprehension(tree, statement, functionKind, tempVarsStatatement, returnStatement);
        this.popTempScope();
        return result;
      }}, {}, $__super);
  }(ComprehensionTransformer);
  return {get ArrayComprehensionTransformer() {
      return ArrayComprehensionTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ParenTrait.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ParenTrait.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ParenTrait.js")),
      ArgumentList = $__2.ArgumentList,
      ArrayLiteral = $__2.ArrayLiteral,
      BinaryExpression = $__2.BinaryExpression,
      ConditionalExpression = $__2.ConditionalExpression,
      ExpressionStatement = $__2.ExpressionStatement,
      NewExpression = $__2.NewExpression,
      ParenExpression = $__2.ParenExpression,
      PropertyNameAssignment = $__2.PropertyNameAssignment,
      VariableDeclaration = $__2.VariableDeclaration;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ParenTrait.js")),
      CALL_EXPRESSION = $__3.CALL_EXPRESSION,
      COMMA_EXPRESSION = $__3.COMMA_EXPRESSION,
      FUNCTION_EXPRESSION = $__3.FUNCTION_EXPRESSION,
      OBJECT_LITERAL = $__3.OBJECT_LITERAL,
      OBJECT_PATTERN = $__3.OBJECT_PATTERN,
      TEMPLATE_LITERAL_EXPRESSION = $__3.TEMPLATE_LITERAL_EXPRESSION,
      YIELD_EXPRESSION = $__3.YIELD_EXPRESSION;
  function wrap(tree) {
    return new ParenExpression(tree.location, tree);
  }
  function ParenTrait(ParseTreeTransformerClass) {
    return function($__super) {
      function $__0() {
        $traceurRuntime.superConstructor($__0).apply(this, arguments);
      }
      return ($traceurRuntime.createClass)($__0, {
        transformVariableDeclaration: function(tree) {
          var lvalue = this.transformAny(tree.lvalue);
          var typeAnnotation = this.transformAny(tree.typeAnnotation);
          var initializer = this.transformAny(tree.initializer);
          if (initializer !== null && initializer.type === COMMA_EXPRESSION) {
            initializer = wrap(initializer);
          } else if (tree.lvalue === lvalue && tree.typeAnnotation === typeAnnotation && tree.initializer === initializer) {
            return tree;
          }
          return new VariableDeclaration(tree.location, lvalue, typeAnnotation, initializer);
        },
        transformExpressionStatement: function(tree) {
          var expression = this.transformAny(tree.expression);
          switch (expression.type) {
            case OBJECT_LITERAL:
            case OBJECT_PATTERN:
            case FUNCTION_EXPRESSION:
              expression = wrap(expression);
              break;
          }
          if (tree.expression === expression) {
            return tree;
          }
          return new ExpressionStatement(tree.location, expression);
        },
        transformNewExpression: function(tree) {
          var operand = this.transformAny(tree.operand);
          var args = this.transformAny(tree.args);
          switch (operand.type) {
            case CALL_EXPRESSION:
            case TEMPLATE_LITERAL_EXPRESSION:
              operand = wrap(operand);
          }
          if (operand === tree.operand && args === tree.args) {
            return tree;
          }
          return new NewExpression(tree.location, operand, args);
        },
        transformExpressionList_: function(list) {
          var expressions = this.transformList(list);
          var newList = null;
          for (var i = 0; i < list.length; i++) {
            var expression = expressions[i];
            if (expression !== null && expression.type === COMMA_EXPRESSION) {
              expression = wrap(expression);
              if (newList === null) {
                newList = expressions.slice(0, i);
              }
              newList.push(expression);
            } else if (newList !== null) {
              newList.push(expression);
            }
          }
          if (newList !== null) {
            return newList;
          }
          return expressions;
        },
        transformArgumentList: function(tree) {
          var args = this.transformExpressionList_(tree.args);
          if (tree.args === args) {
            return tree;
          }
          return new ArgumentList(tree.location, args);
        },
        transformArrayLiteral: function(tree) {
          var elements = this.transformExpressionList_(tree.elements);
          if (tree.elements === elements) {
            return tree;
          }
          return new ArrayLiteral(tree.location, elements);
        },
        transformPropertyNameAssignment: function(tree) {
          var name = this.transformAny(tree.name);
          var value = this.transformAny(tree.value);
          if (value.type === COMMA_EXPRESSION) {
            value = wrap(value);
          } else if (name === tree.name && value === tree.value) {
            return tree;
          }
          return new PropertyNameAssignment(tree.location, name, value);
        },
        transformBinaryExpression: function(tree) {
          var left = this.transformAny(tree.left);
          var right = this.transformAny(tree.right);
          if (commaOrYield(left.type)) {
            left = wrap(left);
          }
          if (commaOrYield(right.type)) {
            right = wrap(right);
          }
          if (left === tree.left && right === tree.right) {
            return tree;
          }
          return new BinaryExpression(tree.location, left, tree.operator, right);
        },
        transformConditionalExpression: function(tree) {
          var condition = this.transformAny(tree.condition);
          var left = this.transformAny(tree.left);
          var right = this.transformAny(tree.right);
          if (commaOrYield(condition.type)) {
            condition = wrap(condition);
          }
          if (left.type == COMMA_EXPRESSION) {
            left = wrap(left);
          }
          if (right.type == COMMA_EXPRESSION) {
            right = wrap(right);
          }
          if (condition === tree.condition && left === tree.left && right === tree.right) {
            return tree;
          }
          return new ConditionalExpression(tree.location, condition, left, right);
        }
      }, {}, $__super);
    }(ParseTreeTransformerClass);
  }
  function commaOrYield(type) {
    return type === COMMA_EXPRESSION || type == YIELD_EXPRESSION;
  }
  return {get ParenTrait() {
      return ParenTrait;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")),
      ARGUMENTS = $__1.ARGUMENTS,
      CONSTRUCTOR = $__1.CONSTRUCTOR,
      THIS = $__1.THIS;
  var AlphaRenamer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AlphaRenamer.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")).AlphaRenamer;
  var FunctionExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")).FunctionExpression;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")).TempVarTransformer;
  var ParenTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParenTrait.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")).ParenTrait;
  var alphaRenameThisAndArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./alphaRenameThisAndArguments.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")).default;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")),
      FUNCTION_BODY = $__7.FUNCTION_BODY,
      LITERAL_PROPERTY_NAME = $__7.LITERAL_PROPERTY_NAME;
  var FindThisOrArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindThisOrArguments.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")).FindThisOrArguments;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ArrowFunctionTransformer.js")),
      createAssignmentExpression = $__9.createAssignmentExpression,
      createCommaExpression = $__9.createCommaExpression,
      createFunctionBody = $__9.createFunctionBody,
      createIdentifierExpression = $__9.createIdentifierExpression,
      createReturnStatement = $__9.createReturnStatement,
      createThisExpression = $__9.createThisExpression;
  function convertConciseBody(tree) {
    if (tree.type !== FUNCTION_BODY)
      return createFunctionBody([createReturnStatement(tree)]);
    return tree;
  }
  var ArrowFunctionTransformer = function($__super) {
    function ArrowFunctionTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(ArrowFunctionTransformer).call(this, identifierGenerator, reporter, options);
      this.inDerivedClass_ = false;
      this.inConstructor_ = false;
    }
    return ($traceurRuntime.createClass)(ArrowFunctionTransformer, {
      transformArrowFunction: function(tree) {
        if (this.inDerivedClass_ && this.inConstructor_) {
          return this.transformUsingCommaExpression_(tree);
        }
        return this.transformUsingTempVar_(tree);
      },
      transformUsingCommaExpression_: function(tree) {
        var finder = new FindThisOrArguments();
        var argumentsTempName,
            thisTempName;
        finder.visitAny(tree);
        if (finder.foundArguments) {
          argumentsTempName = this.addTempVar();
          tree = AlphaRenamer.rename(tree, ARGUMENTS, argumentsTempName);
        }
        if (finder.foundThis) {
          thisTempName = this.addTempVar();
          tree = AlphaRenamer.rename(tree, THIS, thisTempName);
        }
        var parameterList = this.transformAny(tree.parameterList);
        var body = this.transformAny(tree.body);
        body = convertConciseBody(body);
        var functionExpression = new FunctionExpression(tree.location, null, tree.functionKind, parameterList, null, [], body);
        var expressions = [];
        if (argumentsTempName) {
          expressions.push(createAssignmentExpression(createIdentifierExpression(argumentsTempName), createIdentifierExpression(ARGUMENTS)));
        }
        if (thisTempName) {
          expressions.push(createAssignmentExpression(createIdentifierExpression(thisTempName), createThisExpression()));
        }
        if (expressions.length === 0) {
          return functionExpression;
        }
        expressions.push(functionExpression);
        return createCommaExpression(expressions);
      },
      transformUsingTempVar_: function(tree) {
        var alphaRenamed = alphaRenameThisAndArguments(this, tree);
        var parameterList = this.transformAny(alphaRenamed.parameterList);
        var body = this.transformAny(alphaRenamed.body);
        body = convertConciseBody(body);
        var functionExpression = new FunctionExpression(tree.location, null, tree.functionKind, parameterList, null, [], body);
        return functionExpression;
      },
      transformClassExpression: function(tree) {
        var inDerivedClass = this.inDerivedClass_;
        this.inDerivedClass_ = tree.superClass !== null;
        var result = $traceurRuntime.superGet(this, ArrowFunctionTransformer.prototype, "transformClassExpression").call(this, tree);
        this.inDerivedClass_ = inDerivedClass;
        return result;
      },
      transformClassDeclaration: function(tree) {
        var inDerivedClass = this.inDerivedClass_;
        this.inDerivedClass_ = tree.superClass !== null;
        var result = $traceurRuntime.superGet(this, ArrowFunctionTransformer.prototype, "transformClassDeclaration").call(this, tree);
        this.inDerivedClass_ = inDerivedClass;
        return result;
      },
      transformMethod: function(tree) {
        var inConstructor = this.inConstructor_;
        this.inConstructor_ = !tree.isStatic && tree.functionKind === null && tree.name.type === LITERAL_PROPERTY_NAME && tree.name.literalToken.value === CONSTRUCTOR;
        var result = $traceurRuntime.superGet(this, ArrowFunctionTransformer.prototype, "transformMethod").call(this, tree);
        this.inConstructor_ = inConstructor;
        return result;
      }
    }, {transform: function(tempVarTransformer, tree) {
        tree = alphaRenameThisAndArguments(tempVarTransformer, tree);
        var body = convertConciseBody(tree.body);
        return new FunctionExpression(tree.location, null, tree.functionKind, tree.parameterList, null, [], body);
      }}, $__super);
  }(ParenTrait(TempVarTransformer));
  return {get ArrowFunctionTransformer() {
      return ArrowFunctionTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js";
  var alphaRenameThisAndArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./alphaRenameThisAndArguments.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")).default;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")),
      createArgumentList = $__2.createArgumentList,
      createBlock = $__2.createBlock,
      createFunctionBody = $__2.createFunctionBody,
      id = $__2.createIdentifierExpression,
      createMemberExpression = $__2.createMemberExpression,
      createThisExpression = $__2.createThisExpression,
      createVariableDeclaration = $__2.createVariableDeclaration,
      createVariableDeclarationList = $__2.createVariableDeclarationList,
      createVariableStatement = $__2.createVariableStatement;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")).parseStatement;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")).default;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")).TempVarTransformer;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")),
      AwaitExpression = $__6.AwaitExpression,
      Block = $__6.Block,
      CallExpression = $__6.CallExpression,
      Catch = $__6.Catch;
  var SkipFunctionsTransformerTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SkipFunctionsTransformerTrait.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")).default;
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")).ARGUMENTS;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformer.js")).VAR;
  var AsyncGeneratorTransformer = function($__super) {
    function AsyncGeneratorTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(AsyncGeneratorTransformer).call(this, identifierGenerator, reporter, options);
      this.variableDeclarations_ = [];
      this.ctx_ = id(this.getTempIdentifier());
    }
    return ($traceurRuntime.createClass)(AsyncGeneratorTransformer, {
      transformYieldExpression: function(tree) {
        var argList = createArgumentList([tree.expression]);
        if (tree.isYieldFor) {
          return new AwaitExpression(tree.location, new CallExpression(null, createMemberExpression(this.ctx_, 'yieldFor'), argList));
        }
        return new CallExpression(tree.location, createMemberExpression(this.ctx_, 'yield'), argList);
      },
      transformCatch: function(tree) {
        var body = tree.catchBody;
        body = new Block(body.location, $traceurRuntime.spread([parseStatement($traceurRuntime.getTemplateObject(["\n        if (", ".inReturn) {\n          throw undefined;\n        }"]), this.ctx_)], body.statements));
        return new Catch(tree.location, tree.binding, body);
      },
      transformAsyncGeneratorBody_: function(tree, name) {
        tree = this.transformAny(tree);
        tree = alphaRenameThisAndArguments(this, tree);
        var statements = [];
        if (this.variableDeclarations_.length > 0) {
          statements.push(createVariableStatement(createVariableDeclarationList(VAR, this.variableDeclarations_)));
        }
        var body = createBlock(tree.statements);
        var createAsyncGeneratorInstance = this.getRuntimeExpression('createAsyncGeneratorInstance');
        statements.push(parseStatement($traceurRuntime.getTemplateObject(["\n        return ", "(\n            async function (", ") {\n                ", "\n            }, ", ");"]), createAsyncGeneratorInstance, this.ctx_, body, name));
        return createFunctionBody(statements);
      },
      addTempVarForArguments: function() {
        var tmpVarName = this.getTempIdentifier();
        this.variableDeclarations_.push(createVariableDeclaration(tmpVarName, id(ARGUMENTS)));
        return tmpVarName;
      },
      addTempVarForThis: function() {
        var tmpVarName = this.getTempIdentifier();
        this.variableDeclarations_.push(createVariableDeclaration(tmpVarName, createThisExpression()));
        return tmpVarName;
      }
    }, {transformAsyncGeneratorBody: function(identifierGenerator, reporter, options, body, name) {
        return new AsyncGeneratorTransformer(identifierGenerator, reporter, options).transformAsyncGeneratorBody_(body, name);
      }}, $__super);
  }(SkipFunctionsTransformerTrait(ImportRuntimeTrait(TempVarTransformer)));
  return {get AsyncGeneratorTransformer() {
      return AsyncGeneratorTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js";
  var AsyncGeneratorTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AsyncGeneratorTransformer.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js")).AsyncGeneratorTransformer;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js")).TempVarTransformer;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js")),
      AnonBlock = $__3.AnonBlock,
      FunctionDeclaration = $__3.FunctionDeclaration,
      FunctionExpression = $__3.FunctionExpression;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js")).default;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js")),
      createBindingIdentifier = $__5.createBindingIdentifier,
      id = $__5.createIdentifierExpression,
      createIdentifierToken = $__5.createIdentifierToken;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/AsyncGeneratorTransformPass.js")),
      parseExpression = $__6.parseExpression,
      parseStatement = $__6.parseStatement;
  var AsyncGeneratorTransformPass = function($__super) {
    function AsyncGeneratorTransformPass(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(AsyncGeneratorTransformPass).call(this, identifierGenerator, reporter, options);
      this.transformOptions_ = options.transformOptions;
      this.inBlock_ = false;
    }
    return ($traceurRuntime.createClass)(AsyncGeneratorTransformPass, {
      needsTransform_: function(tree) {
        return this.transformOptions_.asyncGenerators && tree.isAsyncGenerator();
      },
      transformFunctionDeclaration: function(tree) {
        if (!this.needsTransform_(tree))
          return $traceurRuntime.superGet(this, AsyncGeneratorTransformPass.prototype, "transformFunctionDeclaration").call(this, tree);
        var nameIdExpression = id(tree.name.identifierToken);
        var initAsyncGeneratorFunction = this.getRuntimeExpression('initAsyncGeneratorFunction');
        var setupPrototypeExpression = parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), initAsyncGeneratorFunction, nameIdExpression);
        var tmpVar = id(this.inBlock_ ? this.getTempIdentifier() : this.addTempVar(setupPrototypeExpression));
        var funcDecl = this.transformFunction_(tree, FunctionDeclaration, tmpVar);
        if (!this.inBlock_)
          return funcDecl;
        return new AnonBlock(null, [funcDecl, parseStatement($traceurRuntime.getTemplateObject(["var ", " = ", ""]), tmpVar, setupPrototypeExpression)]);
      },
      transformFunctionExpression: function(tree) {
        if (!this.needsTransform_(tree)) {
          return $traceurRuntime.superGet(this, AsyncGeneratorTransformPass.prototype, "transformFunctionExpression").call(this, tree);
        }
        var name;
        if (!tree.name) {
          name = createIdentifierToken(this.getTempIdentifier());
          tree = new FunctionExpression(tree.location, createBindingIdentifier(name), tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body);
        } else {
          name = tree.name.identifierToken;
        }
        var functionExpression = this.transformFunction_(tree, FunctionExpression, id(name));
        var initAsyncGeneratorFunction = this.getRuntimeExpression('initAsyncGeneratorFunction');
        return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), initAsyncGeneratorFunction, functionExpression);
      },
      transformFunction_: function(tree, constructor, nameExpression) {
        var body = $traceurRuntime.superGet(this, AsyncGeneratorTransformPass.prototype, "transformAny").call(this, tree.body);
        body = AsyncGeneratorTransformer.transformAsyncGeneratorBody(this.identifierGenerator, this.reporter, this.options, body, nameExpression);
        var functionKind = null;
        return new constructor(tree.location, tree.name, functionKind, tree.parameterList, tree.typeAnnotation || null, tree.annotations || null, body);
      },
      transformBlock: function(tree) {
        var inBlock = this.inBlock_;
        this.inBlock_ = true;
        var rv = $traceurRuntime.superGet(this, AsyncGeneratorTransformPass.prototype, "transformBlock").call(this, tree);
        this.inBlock_ = inBlock;
        return rv;
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  return {get AsyncGeneratorTransformPass() {
      return AsyncGeneratorTransformPass;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/FindArguments.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/FindArguments.js";
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/FindArguments.js")).ARGUMENTS;
  var FindInFunctionScope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindInFunctionScope.js", "traceur@0.0.112/src/codegeneration/FindArguments.js")).FindInFunctionScope;
  var FindArguments = function($__super) {
    function FindArguments() {
      $traceurRuntime.superConstructor(FindArguments).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(FindArguments, {visitIdentifierExpression: function(tree) {
        if (tree.identifierToken.value === ARGUMENTS) {
          this.found = true;
        }
      }}, {}, $__super);
  }(FindInFunctionScope);
  return {get default() {
      return FindArguments;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js";
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")).ARGUMENTS;
  var FindArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindArguments.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")).default;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")),
      FunctionBody = $__3.FunctionBody,
      FunctionDeclaration = $__3.FunctionDeclaration,
      FunctionExpression = $__3.FunctionExpression,
      Method = $__3.Method,
      YieldExpression = $__3.YieldExpression;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")).default;
  var ParenTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParenTrait.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")).ParenTrait;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")).parseStatement;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")).TempVarTransformer;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/AsyncToGeneratorTransformer.js")),
      createIdentifierExpression = $__8.createIdentifierExpression,
      createNullLiteral = $__8.createNullLiteral;
  var AsyncToGeneratorTransformer = function($__super) {
    function AsyncToGeneratorTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(AsyncToGeneratorTransformer).call(this, identifierGenerator, reporter, options);
      this.inAsyncFunction_ = false;
    }
    return ($traceurRuntime.createClass)(AsyncToGeneratorTransformer, {
      transformFunctionDeclaration: function(tree) {
        if (tree.isAsyncFunction()) {
          return this.transformFunctionShared_(tree, FunctionDeclaration);
        }
        return $traceurRuntime.superGet(this, AsyncToGeneratorTransformer.prototype, "transformFunctionDeclaration").call(this, tree);
      },
      transformFunctionExpression: function(tree) {
        if (tree.isAsyncFunction()) {
          return this.transformFunctionShared_(tree, FunctionExpression);
        }
        return $traceurRuntime.superGet(this, AsyncToGeneratorTransformer.prototype, "transformFunctionExpression").call(this, tree);
      },
      transformFunctionShared_: function(tree, ctor) {
        var parameterList = this.transformAny(tree.parameterList);
        var typeAnnotation = this.transformAny(tree.typeAnnotation);
        var annotations = this.transformList(tree.annotations);
        var body = this.transformAsyncBody_(tree.body);
        return new ctor(tree.location, tree.name, null, parameterList, typeAnnotation, annotations, body);
      },
      transformAsyncBody_: function(body) {
        var inAsyncFunction = this.inAsyncFunction_;
        this.inAsyncFunction_ = true;
        body = this.transformFunctionBody(body);
        var spawn = this.getRuntimeExpression('spawn');
        body = wrapBodyInSpawn(body, spawn);
        this.inAsyncFunction_ = inAsyncFunction;
        return body;
      },
      transformMethod: function(tree) {
        if (tree.isAsyncFunction()) {
          var name = this.transformAny(tree.name);
          var parameterList = this.transformAny(tree.parameterList);
          var typeAnnotation = this.transformAny(tree.typeAnnotation);
          var annotations = this.transformList(tree.annotations);
          var body = this.transformAsyncBody_(tree.body);
          return new Method(tree.location, tree.isStatic, null, name, parameterList, typeAnnotation, annotations, body, tree.debugName);
        }
        return $traceurRuntime.superGet(this, AsyncToGeneratorTransformer.prototype, "transformMethod").call(this, tree);
      },
      transformAwaitExpression: function(tree) {
        if (this.inAsyncFunction_) {
          var expression = this.transformAny(tree.expression);
          return new YieldExpression(tree.location, expression, false);
        }
        return $traceurRuntime.superGet(this, AsyncToGeneratorTransformer.prototype, "transformAwaitExpression").call(this, tree);
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(ParenTrait(TempVarTransformer)));
  function wrapBodyInSpawn(body, spawn) {
    var visitor = new FindArguments();
    visitor.visitAny(body);
    var argExpr = visitor.found ? createIdentifierExpression(ARGUMENTS) : createNullLiteral();
    var statement = parseStatement($traceurRuntime.getTemplateObject(["return ", "(this, ", ", function*() { ", " });"]), spawn, argExpr, body);
    return new FunctionBody(body.location, [statement]);
  }
  return {get AsyncToGeneratorTransformer() {
      return AsyncToGeneratorTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/FindIdentifiers.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/FindIdentifiers.js";
  var ScopeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/ScopeVisitor.js", "traceur@0.0.112/src/codegeneration/FindIdentifiers.js")).ScopeVisitor;
  var FindIdentifiers = function($__super) {
    function FindIdentifiers(tree, filterFunction) {
      $traceurRuntime.superConstructor(FindIdentifiers).call(this);
      this.filterFunction_ = filterFunction;
      this.found_ = false;
      this.visitAny(tree);
    }
    return ($traceurRuntime.createClass)(FindIdentifiers, {
      visitIdentifierExpression: function(tree) {
        if (this.filterFunction_(tree.identifierToken.value, this.scope.tree)) {
          this.found = true;
        }
      },
      get found() {
        return this.found_;
      },
      set found(v) {
        if (v) {
          this.found_ = true;
        }
      },
      visitAny: function(tree) {
        !this.found_ && tree && tree.visit(this);
      },
      visitList: function(list) {
        if (list) {
          for (var i = 0; !this.found_ && i < list.length; i++) {
            this.visitAny(list[i]);
          }
        }
      }
    }, {}, $__super);
  }(ScopeVisitor);
  return {get FindIdentifiers() {
      return FindIdentifiers;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")).ParseTreeTransformer;
  var alphaRenameThisAndArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./alphaRenameThisAndArguments.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")).default;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")).parseStatement;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")),
      AnonBlock = $__6.AnonBlock,
      BreakStatement = $__6.BreakStatement,
      ContinueStatement = $__6.ContinueStatement,
      FormalParameterList = $__6.FormalParameterList,
      FunctionExpression = $__6.FunctionExpression,
      ReturnStatement = $__6.ReturnStatement,
      YieldExpression = $__6.YieldExpression;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")),
      createArgumentList = $__7.createArgumentList,
      createAssignmentStatement = $__7.createAssignmentStatement,
      createAssignmentExpression = $__7.createAssignmentExpression,
      createBlock = $__7.createBlock,
      createCallExpression = $__7.createCallExpression,
      createCaseClause = $__7.createCaseClause,
      createDefaultClause = $__7.createDefaultClause,
      createExpressionStatement = $__7.createExpressionStatement,
      createFunctionBody = $__7.createFunctionBody,
      createFunctionExpression = $__7.createFunctionExpression,
      createIdentifierExpression = $__7.createIdentifierExpression,
      createNumberLiteral = $__7.createNumberLiteral,
      createObjectLiteralForDescriptor = $__7.createObjectLiteralForDescriptor,
      createSwitchStatement = $__7.createSwitchStatement,
      createThisExpression = $__7.createThisExpression,
      createVariableDeclaration = $__7.createVariableDeclaration,
      createVariableDeclarationList = $__7.createVariableDeclarationList,
      createVariableStatement = $__7.createVariableStatement,
      createVoid0 = $__7.createVoid0;
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")).ARGUMENTS;
  var SkipFunctionsTransformerTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SkipFunctionsTransformerTrait.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")).default;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")).StringSet;
  var Token = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/Token.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")).Token;
  var $__12 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/FnExtractAbruptCompletions.js")),
      STAR = $__12.STAR,
      VAR = $__12.VAR;
  var FnExtractAbruptCompletions = function($__super) {
    function FnExtractAbruptCompletions(idGenerator, requestParentLabel) {
      $traceurRuntime.superConstructor(FnExtractAbruptCompletions).call(this);
      this.idGenerator_ = idGenerator;
      this.inLoop_ = 0;
      this.inBreakble_ = 0;
      this.variableDeclarations_ = [];
      this.extractedStatements_ = [];
      this.requestParentLabel_ = requestParentLabel;
      this.labelledStatements_ = new StringSet();
    }
    return ($traceurRuntime.createClass)(FnExtractAbruptCompletions, {
      createIIFE: function(body, paramList, argsList, inGenerator) {
        body = this.transformAny(body);
        body = alphaRenameThisAndArguments(this, body);
        var tmpFnName = this.idGenerator_.generateUniqueIdentifier();
        var functionKind = inGenerator ? new Token(STAR, null) : null;
        var functionExpression = new FunctionExpression(null, null, functionKind, new FormalParameterList(null, paramList), null, [], createFunctionBody(body.statements || [body]));
        this.variableDeclarations_.push(createVariableDeclaration(tmpFnName, functionExpression));
        var functionCall = createCallExpression(createIdentifierExpression(tmpFnName), createArgumentList(argsList));
        if (inGenerator) {
          functionCall = new YieldExpression(null, functionCall, true);
        }
        var loopBody = null;
        if (this.extractedStatements_.length || this.hasReturns) {
          var tmpVarName = createIdentifierExpression(this.idGenerator_.generateUniqueIdentifier());
          this.variableDeclarations_.push(createVariableDeclaration(tmpVarName, null));
          var maybeReturn;
          if (this.hasReturns) {
            maybeReturn = parseStatement($traceurRuntime.getTemplateObject(["if (typeof ", " === \"object\")\n            return ", ".v;"]), tmpVarName, tmpVarName);
          }
          if (this.extractedStatements_.length) {
            var caseClauses = this.extractedStatements_.map(function(statement, index) {
              return createCaseClause(createNumberLiteral(index), [statement]);
            });
            if (maybeReturn) {
              caseClauses.push(createDefaultClause([maybeReturn]));
            }
            loopBody = createBlock([createExpressionStatement(createAssignmentExpression(tmpVarName, functionCall)), createSwitchStatement(tmpVarName, caseClauses)]);
          } else {
            loopBody = createBlock([createExpressionStatement(createAssignmentExpression(tmpVarName, functionCall)), maybeReturn]);
          }
        } else {
          loopBody = createBlock([createExpressionStatement(functionCall)]);
        }
        return {
          variableStatements: createVariableStatement(createVariableDeclarationList(VAR, this.variableDeclarations_)),
          loopBody: loopBody
        };
      },
      addTempVarForArguments: function() {
        var tmpVarName = this.idGenerator_.generateUniqueIdentifier();
        this.variableDeclarations_.push(createVariableDeclaration(tmpVarName, createIdentifierExpression(ARGUMENTS)));
        return tmpVarName;
      },
      addTempVarForThis: function() {
        var tmpVarName = this.idGenerator_.generateUniqueIdentifier();
        this.variableDeclarations_.push(createVariableDeclaration(tmpVarName, createThisExpression()));
        return tmpVarName;
      },
      transformAny: function(tree) {
        if (tree) {
          if (tree.isBreakableStatement())
            this.inBreakble_++;
          if (tree.isIterationStatement())
            this.inLoop_++;
          tree = $traceurRuntime.superGet(this, FnExtractAbruptCompletions.prototype, "transformAny").call(this, tree);
          if (tree.isBreakableStatement())
            this.inBreakble_--;
          if (tree.isIterationStatement())
            this.inLoop_--;
        }
        return tree;
      },
      transformReturnStatement: function(tree) {
        this.hasReturns = true;
        return new ReturnStatement(tree.location, createObjectLiteralForDescriptor({v: tree.expression || createVoid0()}));
      },
      transformAbruptCompletion_: function(tree) {
        this.extractedStatements_.push(tree);
        var index = this.extractedStatements_.length - 1;
        return parseStatement($traceurRuntime.getTemplateObject(["return ", ";"]), index);
      },
      transformBreakStatement: function(tree) {
        if (!tree.name) {
          if (this.inBreakble_) {
            return $traceurRuntime.superGet(this, FnExtractAbruptCompletions.prototype, "transformBreakStatement").call(this, tree);
          } else {
            tree = new BreakStatement(tree.location, this.requestParentLabel_());
          }
        } else if (this.labelledStatements_.has(tree.name.value)) {
          return $traceurRuntime.superGet(this, FnExtractAbruptCompletions.prototype, "transformBreakStatement").call(this, tree);
        }
        return this.transformAbruptCompletion_(tree);
      },
      transformContinueStatement: function(tree) {
        if (!tree.name) {
          if (this.inLoop_) {
            return $traceurRuntime.superGet(this, FnExtractAbruptCompletions.prototype, "transformContinueStatement").call(this, tree);
          } else {
            tree = new ContinueStatement(tree.location, this.requestParentLabel_());
          }
        } else if (this.labelledStatements_.has(tree.name.value)) {
          return $traceurRuntime.superGet(this, FnExtractAbruptCompletions.prototype, "transformContinueStatement").call(this, tree);
        }
        return this.transformAbruptCompletion_(tree);
      },
      transformLabelledStatement: function(tree) {
        this.labelledStatements_.add(tree.name.value);
        return $traceurRuntime.superGet(this, FnExtractAbruptCompletions.prototype, "transformLabelledStatement").call(this, tree);
      },
      transformVariableStatement: function(tree) {
        var $__2 = this;
        if (tree.declarations.declarationType === VAR) {
          var assignments = [];
          tree.declarations.declarations.forEach(function(variableDeclaration) {
            var variableName = variableDeclaration.lvalue.getStringValue();
            var initializer = $traceurRuntime.superGet($__2, FnExtractAbruptCompletions.prototype, "transformAny").call($__2, variableDeclaration.initializer);
            $__2.variableDeclarations_.push(createVariableDeclaration(variableName, null));
            assignments.push(createAssignmentStatement(createIdentifierExpression(variableName), initializer));
          });
          return new AnonBlock(null, assignments);
        }
        return $traceurRuntime.superGet(this, FnExtractAbruptCompletions.prototype, "transformVariableStatement").call(this, tree);
      }
    }, {createIIFE: function(idGenerator, body, paramList, argsList, requestParentLabel, inGenerator) {
        return new FnExtractAbruptCompletions(idGenerator, requestParentLabel).createIIFE(body, paramList, argsList, inGenerator);
      }}, $__super);
  }(SkipFunctionsTransformerTrait(ParseTreeTransformer));
  return {get FnExtractAbruptCompletions() {
      return FnExtractAbruptCompletions;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/ScopeReferences.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/ScopeReferences.js";
  var Scope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Scope.js", "traceur@0.0.112/src/semantics/ScopeReferences.js")).Scope;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/semantics/ScopeReferences.js")).StringSet;
  var ScopeReferences = function($__super) {
    function ScopeReferences(parent, tree) {
      $traceurRuntime.superConstructor(ScopeReferences).call(this, parent, tree);
      this.freeVars_ = new StringSet();
    }
    return ($traceurRuntime.createClass)(ScopeReferences, {
      addReference: function(name) {
        this.freeVars_.add(name);
      },
      hasFreeVariable: function(name) {
        return this.freeVars_.has(name);
      }
    }, {}, $__super);
  }(Scope);
  return {get ScopeReferences() {
      return ScopeReferences;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/ScopeChainBuilderWithReferences.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/ScopeChainBuilderWithReferences.js";
  var ScopeChainBuilder = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeChainBuilder.js", "traceur@0.0.112/src/semantics/ScopeChainBuilderWithReferences.js")).ScopeChainBuilder;
  var ScopeReferences = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeReferences.js", "traceur@0.0.112/src/semantics/ScopeChainBuilderWithReferences.js")).ScopeReferences;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/semantics/ScopeChainBuilderWithReferences.js")),
      FUNCTION_DECLARATION = $__3.FUNCTION_DECLARATION,
      FUNCTION_EXPRESSION = $__3.FUNCTION_EXPRESSION,
      GET_ACCESSOR = $__3.GET_ACCESSOR,
      IDENTIFIER_EXPRESSION = $__3.IDENTIFIER_EXPRESSION,
      METHOD = $__3.METHOD,
      MODULE = $__3.MODULE,
      SET_ACCESSOR = $__3.SET_ACCESSOR;
  var TYPEOF = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/semantics/ScopeChainBuilderWithReferences.js")).TYPEOF;
  function hasArgumentsInScope(scope) {
    for (; scope; scope = scope.parent) {
      switch (scope.tree.type) {
        case FUNCTION_DECLARATION:
        case FUNCTION_EXPRESSION:
        case GET_ACCESSOR:
        case METHOD:
        case SET_ACCESSOR:
          return true;
      }
    }
    return false;
  }
  function inModuleScope(scope) {
    for (; scope; scope = scope.parent) {
      if (scope.tree.type === MODULE) {
        return true;
      }
    }
    return false;
  }
  var ScopeChainBuilderWithReferences = function($__super) {
    function ScopeChainBuilderWithReferences() {
      $traceurRuntime.superConstructor(ScopeChainBuilderWithReferences).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ScopeChainBuilderWithReferences, {
      createScope: function(tree) {
        return new ScopeReferences(this.scope, tree);
      },
      visitIdentifierExpression: function(tree) {
        if (this.inWithBlock) {
          return;
        }
        var scope = this.scope;
        var name = tree.getStringValue();
        if (name === 'arguments' && hasArgumentsInScope(scope)) {
          return;
        }
        if (name === '__moduleName' && inModuleScope(scope)) {
          return;
        }
        this.referenceFound(tree, name);
      },
      visitUnaryExpression: function(tree) {
        if (tree.operator.type === TYPEOF && tree.operand.type === IDENTIFIER_EXPRESSION) {
          var scope = this.scope;
          var binding = scope.getBinding(tree.operand);
          if (!binding) {
            scope.addVar(tree.operand, this.reporter);
          }
        } else {
          $traceurRuntime.superGet(this, ScopeChainBuilderWithReferences.prototype, "visitUnaryExpression").call(this, tree);
        }
      },
      referenceFound: function(tree, name) {
        this.scope.addReference(name);
      }
    }, {}, $__super);
  }(ScopeChainBuilder);
  return {get ScopeChainBuilderWithReferences() {
      return ScopeChainBuilderWithReferences;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js";
  var AlphaRenamer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AlphaRenamer.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).AlphaRenamer;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")),
      ANON_BLOCK = $__7.ANON_BLOCK,
      BINDING_IDENTIFIER = $__7.BINDING_IDENTIFIER,
      FOR_IN_STATEMENT = $__7.FOR_IN_STATEMENT,
      FOR_OF_STATEMENT = $__7.FOR_OF_STATEMENT,
      VARIABLE_DECLARATION_LIST = $__7.VARIABLE_DECLARATION_LIST;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")),
      AnonBlock = $__8.AnonBlock,
      BindingElement = $__8.BindingElement,
      BindingIdentifier = $__8.BindingIdentifier,
      Block = $__8.Block,
      Catch = $__8.Catch,
      DoWhileStatement = $__8.DoWhileStatement,
      ForInStatement = $__8.ForInStatement,
      ForStatement = $__8.ForStatement,
      FormalParameter = $__8.FormalParameter,
      FunctionBody = $__8.FunctionBody,
      FunctionExpression = $__8.FunctionExpression,
      LabelledStatement = $__8.LabelledStatement,
      LiteralPropertyName = $__8.LiteralPropertyName,
      Module = $__8.Module,
      ObjectPatternField = $__8.ObjectPatternField,
      Script = $__8.Script,
      VariableDeclaration = $__8.VariableDeclaration,
      VariableDeclarationList = $__8.VariableDeclarationList,
      VariableStatement = $__8.VariableStatement,
      WhileStatement = $__8.WhileStatement;
  var IdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/IdentifierToken.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).IdentifierToken;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).ParseTreeTransformer;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).VAR;
  var $__12 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")),
      createBindingIdentifier = $__12.createBindingIdentifier,
      createIdentifierExpression = $__12.createIdentifierExpression,
      createIdentifierToken = $__12.createIdentifierToken;
  var FindIdentifiers = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindIdentifiers.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).FindIdentifiers;
  var FindVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindVisitor.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).FindVisitor;
  var FnExtractAbruptCompletions = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FnExtractAbruptCompletions.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).FnExtractAbruptCompletions;
  var ScopeChainBuilderWithReferences = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/ScopeChainBuilderWithReferences.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).ScopeChainBuilderWithReferences;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).parseExpression;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/BlockBindingTransformer.js")).prependStatements;
  function varNeedsInitializer(tree, loopTree) {
    if (loopTree === null)
      return false;
    var type = loopTree.type;
    if (type !== FOR_IN_STATEMENT && type !== FOR_OF_STATEMENT)
      return true;
    return loopTree.initializer.declarations[0] !== tree;
  }
  var BlockBindingTransformer = function($__super) {
    function BlockBindingTransformer(idGenerator, reporter, tree) {
      var scopeBuilder = arguments[3];
      var latestScope = arguments[4];
      $traceurRuntime.superConstructor(BlockBindingTransformer).call(this);
      this.idGenerator_ = idGenerator;
      this.reporter_ = reporter;
      if (!scopeBuilder) {
        scopeBuilder = new ScopeChainBuilderWithReferences(reporter);
        scopeBuilder.visitAny(tree);
      }
      this.scopeBuilder_ = scopeBuilder;
      this.labelledLoops_ = new Map();
      this.prependStatement_ = [];
      this.prependBlockStatement_ = [];
      this.blockRenames_ = [];
      this.rootTree_ = tree;
      if (latestScope) {
        this.scope_ = latestScope;
      } else {
        this.pushScope(tree);
      }
      this.usedVars_ = this.scope_.getAllBindingNames();
      this.maybeRename_ = false;
      this.inObjectPattern_ = false;
      this.currentLoopTree_ = null;
    }
    return ($traceurRuntime.createClass)(BlockBindingTransformer, {
      getVariableName_: function(variable) {
        var lvalue = variable.lvalue;
        if (lvalue.type === BINDING_IDENTIFIER) {
          return lvalue.getStringValue();
        }
        throw new Error('Unexpected destructuring declaration found.');
      },
      flushRenames: function(tree) {
        tree = renameAll(this.blockRenames_, tree);
        this.blockRenames_.length = 0;
        return tree;
      },
      pushScope: function(tree) {
        var scope = this.scopeBuilder_.getScopeForTree(tree);
        if (!scope)
          throw new Error('BlockBindingTransformer tree with no scope');
        if (this.scope_)
          this.scope_.blockBindingRenames = this.blockRenames_;
        this.scope_ = scope;
        this.blockRenames_ = [];
        return scope;
      },
      popScope: function(scope) {
        if (this.scope_ !== scope) {
          throw new Error('BlockBindingTransformer scope mismatch');
        }
        this.scope_ = scope.parent;
        this.blockRenames_ = this.scope_ && this.scope_.blockBindingRenames || [];
      },
      revisitTreeForScopes: function(tree) {
        this.scopeBuilder_.scope = this.scope_;
        this.scopeBuilder_.visitAny(tree);
        this.scopeBuilder_.scope = null;
      },
      needsRename_: function(name) {
        if (this.usedVars_.has(name))
          return true;
        var scope = this.scope_;
        var parent = scope.parent;
        if (!parent || scope.isVarScope)
          return false;
        var varScope = scope.getVarScope();
        if (varScope && varScope.hasFreeVariable(name)) {
          return true;
        }
        var parentBinding = parent.getBindingByName(name);
        if (!parentBinding)
          return false;
        var currentBinding = scope.getBindingByName(name);
        if (currentBinding.tree === parentBinding.tree)
          return false;
        return true;
      },
      newNameFromOrig: function(origName, renames) {
        var newName;
        if (this.needsRename_(origName)) {
          newName = origName + this.idGenerator_.generateUniqueIdentifier();
          renames.push(new Rename(origName, newName));
        } else {
          this.usedVars_.add(origName);
          newName = origName;
        }
        return newName;
      },
      transformFunctionBody: function(tree) {
        if (tree === this.rootTree_ || !this.rootTree_) {
          tree = $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformFunctionBody").call(this, tree);
          if (this.prependStatement_.length || this.blockRenames_.length) {
            var statements = prependStatements.apply((void 0), $traceurRuntime.spread([tree.statements], this.prependStatement_));
            tree = new FunctionBody(tree.location, statements);
            tree = this.flushRenames(tree);
          }
        } else {
          var functionTransform = new BlockBindingTransformer(this.idGenerator_, this.reporter_, tree, this.scopeBuilder_, this.scope_);
          var functionBodyTree = functionTransform.transformAny(tree);
          if (functionBodyTree === tree) {
            return tree;
          }
          tree = new FunctionBody(tree.location, functionBodyTree.statements);
        }
        return tree;
      },
      transformScript: function(tree) {
        if (tree === this.rootTree_ || !this.rootTree_) {
          tree = $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformScript").call(this, tree);
          if (this.prependStatement_.length || this.blockRenames_.length) {
            var scriptItemList = prependStatements.apply((void 0), $traceurRuntime.spread([tree.scriptItemList], this.prependStatement_));
            tree = new Script(tree.location, scriptItemList, tree.moduleName);
            tree = this.flushRenames(tree);
          }
        } else {
          var functionTransform = new BlockBindingTransformer(this.idGenerator_, this.reporter_, tree, this.scopeBuilder_);
          var newTree = functionTransform.transformAny(tree);
          if (newTree === tree) {
            return tree;
          }
          tree = new Script(tree.location, newTree.scriptItemList, tree.moduleName);
        }
        return tree;
      },
      transformModule: function(tree) {
        if (tree === this.rootTree_ || !this.rootTree_) {
          tree = $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformModule").call(this, tree);
          if (this.prependStatement_.length || this.blockRenames_.length) {
            var scriptItemList = prependStatements.apply((void 0), $traceurRuntime.spread([tree.scriptItemList], this.prependStatement_));
            tree = new Module(tree.location, scriptItemList, tree.moduleName);
            tree = this.flushRenames(tree);
          }
        } else {
          var functionTransform = new BlockBindingTransformer(this.idGenerator_, this.reporter_, tree, this.scopeBuilder_);
          var newTree = functionTransform.transformAny(tree);
          if (newTree === tree) {
            return tree;
          }
          tree = new Module(tree.location, newTree.scriptItemList, tree.moduleName);
        }
        return tree;
      },
      transformVariableStatement: function(tree) {
        var declarations = this.transformAny(tree.declarations);
        if (declarations.type === ANON_BLOCK) {
          return declarations;
        }
        if (declarations === tree.declarations) {
          return tree;
        }
        return new VariableStatement(tree.location, declarations);
      },
      transformVariableDeclarationList: function(tree) {
        if (tree.declarationType === VAR) {
          return $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformVariableDeclarationList").call(this, tree);
        }
        this.maybeRename_ = !this.scope_.isVarScope;
        var declarations = this.transformList(tree.declarations);
        this.maybeRename_ = false;
        return new VariableDeclarationList(tree.location, VAR, declarations);
      },
      transformVariableDeclaration: function(tree) {
        var maybeRename = this.maybeRename_;
        var lvalue = this.transformAny(tree.lvalue);
        this.maybeRename_ = false;
        var initializer = null;
        if (tree.initializer) {
          initializer = this.transformAny(tree.initializer);
        } else if (varNeedsInitializer(tree, this.currentLoopTree_)) {
          initializer = parseExpression($traceurRuntime.getTemplateObject(["void 0"]));
        }
        this.maybeRename_ = maybeRename;
        if (tree.lvalue === lvalue && tree.initializer === initializer) {
          return tree;
        }
        return new VariableDeclaration(tree.location, lvalue, tree.typeAnnotation, initializer);
      },
      transformBindingIdentifier: function(tree) {
        if (this.maybeRename_) {
          var origName = tree.getStringValue();
          var newName = this.newNameFromOrig(origName, this.blockRenames_);
          if (origName === newName) {
            return tree;
          }
          var newToken = new IdentifierToken(tree.location, newName);
          var bindingIdentifier = new BindingIdentifier(tree.location, newToken);
          this.scope_.renameBinding(origName, bindingIdentifier, VAR, this.reporter_);
          return bindingIdentifier;
        }
        return $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformBindingIdentifier").call(this, tree);
      },
      transformBindingElement: function(tree) {
        var maybeRename = this.maybeRename_;
        var inObjectPattern = this.inObjectPattern_;
        var binding = this.transformAny(tree.binding);
        this.maybeRename_ = false;
        this.inObjectPattern_ = false;
        var initializer = this.transformAny(tree.initializer);
        this.maybeRename_ = maybeRename;
        this.inObjectPattern_ = inObjectPattern;
        if (tree.binding === binding && tree.initializer === initializer) {
          return tree;
        }
        var bindingElement = new BindingElement(tree.location, binding, initializer);
        if (this.inObjectPattern_ && tree.binding !== binding && tree.binding.type === BINDING_IDENTIFIER) {
          return new ObjectPatternField(tree.location, new LiteralPropertyName(tree.location, tree.binding.identifierToken), bindingElement);
        }
        return bindingElement;
      },
      transformObjectPattern: function(tree) {
        var inObjectPattern = this.inObjectPattern_;
        this.inObjectPattern_ = true;
        var transformed = $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformObjectPattern").call(this, tree);
        this.inObjectPattern_ = inObjectPattern;
        return transformed;
      },
      transformObjectPatternField: function(tree) {
        var name = this.transformAny(tree.name);
        this.inObjectPattern_ = false;
        var element = this.transformAny(tree.element);
        this.inObjectPattern_ = true;
        if (tree.name === name && tree.element === element) {
          return tree;
        }
        return new ObjectPatternField(tree.location, name, element);
      },
      transformBlock: function(tree) {
        var scope = this.pushScope(tree);
        var outerPrepends = this.prependBlockStatement_;
        this.prependBlockStatement_ = [];
        tree = $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformBlock").call(this, tree);
        if (this.prependBlockStatement_.length) {
          tree = new Block(tree.location, prependStatements.apply((void 0), $traceurRuntime.spread([tree.statements], this.prependBlockStatement_)));
        }
        this.prependBlockStatement_ = outerPrepends;
        tree = this.flushRenames(tree);
        this.popScope(scope);
        return tree;
      },
      transformCatch: function(tree) {
        var scope = this.pushScope(tree);
        var binding = this.transformAny(tree.binding);
        var statements = this.transformList(tree.catchBody.statements);
        if (binding !== tree.binding || statements !== tree.catchBody.statements) {
          tree = new Catch(tree.location, binding, new Block(tree.catchBody.location, statements));
        }
        tree = this.flushRenames(tree);
        this.popScope(scope);
        return tree;
      },
      transformFunctionForScope_: function(func, tree) {
        var scope = this.pushScope(tree);
        tree = func();
        tree = this.flushRenames(tree);
        this.popScope(scope);
        return tree;
      },
      transformGetAccessor: function(tree) {
        var $__3 = this;
        return this.transformFunctionForScope_(function() {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformGetAccessor").call($__3, tree);
        }, tree);
      },
      transformSetAccessor: function(tree) {
        var $__3 = this;
        return this.transformFunctionForScope_(function() {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformSetAccessor").call($__3, tree);
        }, tree);
      },
      transformFunctionExpression: function(tree) {
        var $__3 = this;
        return this.transformFunctionForScope_(function() {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformFunctionExpression").call($__3, tree);
        }, tree);
      },
      transformFunctionDeclaration: function(tree) {
        var $__3 = this;
        if (!this.scope_.isVarScope) {
          var origName = tree.name.getStringValue();
          var newName = this.newNameFromOrig(origName, this.blockRenames_);
          var functionExpression = new FunctionExpression(tree.location, null, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body);
          this.revisitTreeForScopes(functionExpression);
          functionExpression = this.transformAny(functionExpression);
          var bindingIdentifier = createBindingIdentifier(newName);
          var statement = new VariableStatement(tree.location, new VariableDeclarationList(tree.location, VAR, [new VariableDeclaration(tree.location, bindingIdentifier, null, functionExpression)]));
          this.scope_.renameBinding(origName, bindingIdentifier, VAR, this.reporter_);
          this.prependBlockStatement_.push(statement);
          return new AnonBlock(null, []);
        }
        return this.transformFunctionForScope_(function() {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformFunctionDeclaration").call($__3, tree);
        }, tree);
      },
      transformLoop_: function(func, tree, loopFactory) {
        var $__3 = this;
        var scope,
            initializerIsBlockBinding;
        if (tree.initializer && tree.initializer.type === VARIABLE_DECLARATION_LIST && tree.initializer.declarationType !== VAR) {
          initializerIsBlockBinding = true;
        }
        if (initializerIsBlockBinding) {
          scope = this.pushScope(tree);
        }
        var finder = new FindBlockBindingInLoop(tree, this.scopeBuilder_);
        finder.visitAny(tree);
        if (!finder.found) {
          var callFunc = function() {
            var currentLoopTree = $__3.currentLoopTree_;
            $__3.currentLoopTree_ = tree;
            var rv = func(tree);
            $__3.currentLoopTree_ = currentLoopTree;
            return rv;
          };
          if (!initializerIsBlockBinding) {
            return callFunc();
          }
          var renames = [];
          var initializer = new VariableDeclarationList(null, VAR, tree.initializer.declarations.map(function(declaration) {
            var origName = $__3.getVariableName_(declaration);
            var newName = $__3.newNameFromOrig(origName, renames);
            var bindingIdentifier = createBindingIdentifier(newName);
            $__3.scope_.renameBinding(origName, bindingIdentifier, VAR, $__3.reporter_);
            return new VariableDeclaration(null, bindingIdentifier, null, declaration.initializer);
          }));
          initializer = renameAll(renames, initializer);
          tree = loopFactory(initializer, renames, renameAll(renames, tree.body));
          this.revisitTreeForScopes(tree);
          tree = callFunc();
        } else {
          var iifeParameterList = [];
          var iifeArgumentList = [];
          var renames$__4 = [];
          var initializer$__5 = null;
          if (tree.initializer) {
            if (tree.initializer.type === VARIABLE_DECLARATION_LIST && tree.initializer.declarationType !== VAR) {
              initializer$__5 = new VariableDeclarationList(null, VAR, tree.initializer.declarations.map(function(declaration) {
                var origName = $__3.getVariableName_(declaration);
                var newName = $__3.newNameFromOrig(origName, renames$__4);
                iifeArgumentList.push(createIdentifierExpression(newName));
                iifeParameterList.push(new FormalParameter(null, new BindingElement(null, createBindingIdentifier(origName), null), null, []));
                var bindingIdentifier = createBindingIdentifier(newName);
                $__3.scope_.renameBinding(origName, bindingIdentifier, VAR, $__3.reporter_);
                return new VariableDeclaration(null, bindingIdentifier, null, declaration.initializer);
              }));
              initializer$__5 = renameAll(renames$__4, initializer$__5);
            } else {
              initializer$__5 = this.transformAny(tree.initializer);
            }
          }
          var loopLabel = this.labelledLoops_.get(tree);
          var iifeInfo = FnExtractAbruptCompletions.createIIFE(this.idGenerator_, tree.body, iifeParameterList, iifeArgumentList, function() {
            return loopLabel = loopLabel || createIdentifierToken($__3.idGenerator_.generateUniqueIdentifier());
          }, this.scope_.inGenerator);
          tree = loopFactory(initializer$__5, renames$__4, iifeInfo.loopBody);
          if (loopLabel) {
            tree = new LabelledStatement(tree.location, loopLabel, tree);
          }
          tree = new AnonBlock(tree.location, [iifeInfo.variableStatements, tree]);
          this.revisitTreeForScopes(tree);
          tree = this.transformAny(tree);
        }
        if (initializerIsBlockBinding) {
          tree = this.flushRenames(tree);
          this.popScope(scope);
        }
        return tree;
      },
      transformForInStatement: function(tree) {
        var $__3 = this;
        return this.transformLoop_(function(t) {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformForInStatement").call($__3, t);
        }, tree, function(initializer, renames, body) {
          return new ForInStatement(tree.location, initializer, renameAll(renames, tree.collection), body);
        });
      },
      transformForStatement: function(tree) {
        var $__3 = this;
        return this.transformLoop_(function(t) {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformForStatement").call($__3, t);
        }, tree, function(initializer, renames, body) {
          return new ForStatement(tree.location, initializer, renameAll(renames, tree.condition), renameAll(renames, tree.increment), body);
        });
      },
      transformWhileStatement: function(tree) {
        var $__3 = this;
        return this.transformLoop_(function(t) {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformWhileStatement").call($__3, t);
        }, tree, function(initializer, renames, body) {
          return new WhileStatement(tree.location, renameAll(renames, tree.condition), body);
        });
      },
      transformDoWhileStatement: function(tree) {
        var $__3 = this;
        return this.transformLoop_(function(t) {
          return $traceurRuntime.superGet($__3, BlockBindingTransformer.prototype, "transformDoWhileStatement").call($__3, t);
        }, tree, function(initializer, renames, body) {
          return new DoWhileStatement(tree.location, body, renameAll(renames, tree.condition));
        });
      },
      transformLabelledStatement: function(tree) {
        if (tree.statement.isIterationStatement()) {
          this.labelledLoops_.set(tree.statement, tree.name.value);
          var statement = this.transformAny(tree.statement);
          if (!statement.isStatement()) {
            return statement;
          }
          if (statement === tree.statement) {
            return tree;
          }
          return new LabelledStatement(tree.location, tree.name, statement);
        }
        return $traceurRuntime.superGet(this, BlockBindingTransformer.prototype, "transformLabelledStatement").call(this, tree);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  var Rename = function() {
    function Rename(oldName, newName) {
      this.oldName = oldName;
      this.newName = newName;
    }
    return ($traceurRuntime.createClass)(Rename, {}, {});
  }();
  function renameAll(renames, tree) {
    renames.forEach(function(rename) {
      tree = AlphaRenamer.rename(tree, rename.oldName, rename.newName);
    });
    return tree;
  }
  var FindBlockBindingInLoop = function($__super) {
    function FindBlockBindingInLoop(tree, scopeBuilder) {
      $traceurRuntime.superConstructor(FindBlockBindingInLoop).call(this);
      this.scopeBuilder_ = scopeBuilder;
      this.topScope_ = scopeBuilder.getScopeForTree(tree) || scopeBuilder.getScopeForTree(tree.body);
      this.outOfScope_ = null;
      this.acceptLoop_ = tree.isIterationStatement();
    }
    return ($traceurRuntime.createClass)(FindBlockBindingInLoop, {
      visitForInStatement: function(tree) {
        var $__3 = this;
        this.visitLoop_(tree, function() {
          return $traceurRuntime.superGet($__3, FindBlockBindingInLoop.prototype, "visitForInStatement").call($__3, tree);
        });
      },
      visitForStatement: function(tree) {
        var $__3 = this;
        this.visitLoop_(tree, function() {
          return $traceurRuntime.superGet($__3, FindBlockBindingInLoop.prototype, "visitForStatement").call($__3, tree);
        });
      },
      visitWhileStatement: function(tree) {
        var $__3 = this;
        this.visitLoop_(tree, function() {
          return $traceurRuntime.superGet($__3, FindBlockBindingInLoop.prototype, "visitWhileStatement").call($__3, tree);
        });
      },
      visitDoWhileStatement: function(tree) {
        var $__3 = this;
        this.visitLoop_(tree, function() {
          return $traceurRuntime.superGet($__3, FindBlockBindingInLoop.prototype, "visitDoWhileStatement").call($__3, tree);
        });
      },
      visitLoop_: function(tree, func) {
        if (this.acceptLoop_) {
          this.acceptLoop_ = false;
        } else if (!this.outOfScope_) {
          this.outOfScope_ = this.scopeBuilder_.getScopeForTree(tree) || this.scopeBuilder_.getScopeForTree(tree.body);
        }
        func();
      },
      visitArrowFunction: function(tree) {
        this.visitFunction_(tree);
      },
      visitFunctionDeclaration: function(tree) {
        this.visitFunction_(tree);
      },
      visitFunctionExpression: function(tree) {
        this.visitFunction_(tree);
      },
      visitGetAccessor: function(tree) {
        this.visitFunction_(tree);
      },
      visitMethod: function(tree) {
        this.visitFunction_(tree);
      },
      visitSetAccessor: function(tree) {
        this.visitFunction_(tree);
      },
      visitFunction_: function(tree) {
        var $__3 = this;
        this.found = new FindIdentifiers(tree, function(identifierToken, identScope) {
          identScope = $__3.scopeBuilder_.getScopeForTree(identScope);
          var fnScope = $__3.outOfScope_ || $__3.scopeBuilder_.getScopeForTree(tree);
          if (identScope.hasLexicalBindingName(identifierToken)) {
            return false;
          }
          while (identScope !== fnScope && (identScope = identScope.parent)) {
            if (identScope.hasLexicalBindingName(identifierToken)) {
              return false;
            }
          }
          while (fnScope = fnScope.parent) {
            if (fnScope.hasLexicalBindingName(identifierToken)) {
              return true;
            }
            if (fnScope.hasVariableBindingName(identifierToken)) {
              return false;
            }
            if (fnScope === $__3.topScope_)
              break;
          }
          return false;
        }).found;
      }
    }, {}, $__super);
  }(FindVisitor);
  return {get BlockBindingTransformer() {
      return BlockBindingTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/MakeStrictTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/MakeStrictTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/MakeStrictTransformer.js")),
      FunctionBody = $__1.FunctionBody,
      Script = $__1.Script;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/MakeStrictTransformer.js")).ParseTreeTransformer;
  var createUseStrictDirective = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/MakeStrictTransformer.js")).createUseStrictDirective;
  var hasUseStrict = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/util.js", "traceur@0.0.112/src/codegeneration/MakeStrictTransformer.js")).hasUseStrict;
  function prepend(statements) {
    return $traceurRuntime.spread([createUseStrictDirective()], statements);
  }
  var MakeStrictTransformer = function($__super) {
    function MakeStrictTransformer() {
      $traceurRuntime.superConstructor(MakeStrictTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(MakeStrictTransformer, {
      transformScript: function(tree) {
        if (hasUseStrict(tree.scriptItemList))
          return tree;
        return new Script(tree.location, prepend(tree.scriptItemList), tree.moduleName);
      },
      transformFunctionBody: function(tree) {
        if (hasUseStrict(tree.statements))
          return tree;
        return new FunctionBody(tree.location, prepend(tree.statements));
      }
    }, {transformTree: function(tree) {
        return new MakeStrictTransformer().transformAny(tree);
      }}, $__super);
  }(ParseTreeTransformer);
  return {get MakeStrictTransformer() {
      return MakeStrictTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ClassTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ClassTransformer.js";
  var CONSTRUCTOR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")).CONSTRUCTOR;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")),
      AnonBlock = $__3.AnonBlock,
      ClassExpression = $__3.ClassExpression,
      ExportDeclaration = $__3.ExportDeclaration,
      ExportSpecifier = $__3.ExportSpecifier,
      ExportSpecifierSet = $__3.ExportSpecifierSet,
      FunctionDeclaration = $__3.FunctionDeclaration,
      FunctionExpression = $__3.FunctionExpression,
      GetAccessor = $__3.GetAccessor,
      Method = $__3.Method,
      NamedExport = $__3.NamedExport,
      SetAccessor = $__3.SetAccessor;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")),
      CLASS_DECLARATION = $__4.CLASS_DECLARATION,
      COMPUTED_PROPERTY_NAME = $__4.COMPUTED_PROPERTY_NAME,
      EXPORT_DEFAULT = $__4.EXPORT_DEFAULT,
      GET_ACCESSOR = $__4.GET_ACCESSOR,
      LITERAL_PROPERTY_NAME = $__4.LITERAL_PROPERTY_NAME,
      METHOD = $__4.METHOD,
      SET_ACCESSOR = $__4.SET_ACCESSOR;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")).TempVarTransformer;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")),
      CONST = $__6.CONST,
      LET = $__6.LET,
      VAR = $__6.VAR,
      STRING = $__6.STRING;
  var MakeStrictTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./MakeStrictTransformer.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")).MakeStrictTransformer;
  var ParenTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParenTrait.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")).ParenTrait;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")).default;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")),
      createBindingIdentifier = $__10.createBindingIdentifier,
      id = $__10.createIdentifierExpression,
      createIdentifierToken = $__10.createIdentifierToken,
      createObjectLiteral = $__10.createObjectLiteral,
      createVariableStatement = $__10.createVariableStatement;
  var hasUseStrict = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/util.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")).hasUseStrict;
  var $__12 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ClassTransformer.js")),
      parseExpression = $__12.parseExpression,
      parsePropertyDefinition = $__12.parsePropertyDefinition,
      parseStatement = $__12.parseStatement;
  function methodNameFromTree(tree) {
    if (tree.type === COMPUTED_PROPERTY_NAME) {
      return '';
    }
    if (tree.literalToken && tree.literalToken.type === STRING) {
      return tree.getStringValue().substr(1, -1);
    }
    return tree.getStringValue();
  }
  function classMethodDebugName(className, methodName, isStatic) {
    if (isStatic) {
      return createBindingIdentifier('$__' + className + '_' + methodName);
    }
    return createBindingIdentifier('$__' + className + '_prototype_' + methodName);
  }
  function functionExpressionToDeclaration(tree, name) {
    if (tree.name === null) {
      name = createBindingIdentifier(name);
    } else {
      name = tree.name;
    }
    return new FunctionDeclaration(tree.location, name, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body);
  }
  function removeStaticModifier(tree) {
    switch (tree.type) {
      case GET_ACCESSOR:
        return new GetAccessor(tree.location, false, tree.name, tree.typeAnnotation, tree.annotations, tree.body);
      case SET_ACCESSOR:
        return new SetAccessor(tree.location, false, tree.name, tree.parameterList, tree.annotations, tree.body);
      case METHOD:
        return new Method(tree.location, false, tree.functionKind, tree.name, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body, tree.debugName);
      default:
        throw new Error('unreachable');
    }
  }
  function isConstructor(tree) {
    if (tree.type !== METHOD || tree.isStatic || tree.functionKind !== null) {
      return false;
    }
    var name = tree.name;
    return name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === CONSTRUCTOR;
  }
  var ClassTransformer = function($__super) {
    function ClassTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(ClassTransformer).call(this, identifierGenerator, reporter, options);
      this.strictCount_ = 0;
      this.state_ = null;
    }
    return ($traceurRuntime.createClass)(ClassTransformer, {
      transformModule: function(tree) {
        this.strictCount_ = 1;
        return $traceurRuntime.superGet(this, ClassTransformer.prototype, "transformModule").call(this, tree);
      },
      transformScript: function(tree) {
        this.strictCount_ = hasUseStrict(tree.scriptItemList) ? 1 : 0;
        return $traceurRuntime.superGet(this, ClassTransformer.prototype, "transformScript").call(this, tree);
      },
      transformFunctionBody: function(tree) {
        var useStrict = hasUseStrict(tree.statements) ? 1 : 0;
        this.strictCount_ += useStrict;
        var result = $traceurRuntime.superGet(this, ClassTransformer.prototype, "transformFunctionBody").call(this, tree);
        this.strictCount_ -= useStrict;
        return result;
      },
      makeStrict_: function(tree) {
        if (this.strictCount_)
          return tree;
        return MakeStrictTransformer.transformTree(tree);
      },
      transformClassDeclaration: function(tree) {
        var classExpression = new ClassExpression(tree.location, tree.name, tree.superClass, tree.elements, tree.annotations, tree.typeParameters);
        var transformed = this.transformClassExpression(classExpression);
        var useLet = !this.options.transformOptions.blockBinding && this.options.parseOptions.blockBinding;
        return createVariableStatement(useLet ? LET : VAR, tree.name, transformed);
      },
      transformClassExpression: function(tree) {
        var superClass = this.transformAny(tree.superClass);
        var elements = this.transformList(tree.elements);
        var annotations = this.transformList(tree.annotations);
        var constructor = null;
        var protoElements = elements.filter(function(tree) {
          if (tree.isStatic)
            return false;
          if (isConstructor(tree)) {
            constructor = tree;
            return false;
          }
          return true;
        });
        var staticElements = elements.filter(function(tree) {
          return tree.isStatic;
        }).map(removeStaticModifier);
        var protoObject = createObjectLiteral(protoElements);
        var staticObject = createObjectLiteral(staticElements);
        if (!constructor) {
          constructor = this.getDefaultConstructor_(tree);
        }
        var func = new FunctionExpression(tree.location, tree.name, null, constructor.parameterList, null, annotations, constructor.body);
        var expression;
        var createClass = this.getRuntimeExpression('createClass');
        if (tree.name) {
          var functionStatement;
          var name = tree.name.identifierToken;
          var nameId = id(("" + name));
          if (!this.options.transformOptions.blockBinding && this.options.parseOptions.blockBinding) {
            functionStatement = createVariableStatement(CONST, tree.name, func);
          } else {
            functionStatement = functionExpressionToDeclaration(func, name);
          }
          if (superClass) {
            expression = parseExpression($traceurRuntime.getTemplateObject(["function($__super) {\n          ", ";\n          return (", ")(", ", ", ",\n                                  ", ", $__super);\n        }(", ")"]), functionStatement, createClass, nameId, protoObject, staticObject, superClass);
          } else {
            expression = parseExpression($traceurRuntime.getTemplateObject(["function() {\n          ", ";\n          return (", ")(", ", ", ", ", ");\n        }()"]), functionStatement, createClass, nameId, protoObject, staticObject);
          }
        } else {
          if (superClass) {
            expression = parseExpression($traceurRuntime.getTemplateObject(["(", ")(", ", ", ", ", ", ", ")"]), createClass, func, protoObject, staticObject, superClass);
          } else {
            expression = parseExpression($traceurRuntime.getTemplateObject(["(", ")(", ", ", ", ", ")"]), createClass, func, protoObject, staticObject);
          }
        }
        return this.makeStrict_(expression);
      },
      transformExportDeclaration: function(tree) {
        if (tree.declaration.type === EXPORT_DEFAULT && tree.declaration.expression.type === CLASS_DECLARATION) {
          return this.transformExportDefaultClass_(tree.declaration);
        }
        return $traceurRuntime.superGet(this, ClassTransformer.prototype, "transformExportDeclaration").call(this, tree);
      },
      transformExportDefaultClass_: function(tree) {
        var name = tree.expression.name.identifierToken;
        var specifier = new ExportSpecifier(name.location, name, createIdentifierToken('default'));
        var exportTree = new ExportSpecifierSet(name.location, [specifier]);
        var named = new NamedExport(name.location, exportTree, null);
        var exp = new ExportDeclaration(name.location, named, []);
        var classTree = this.transformAny(tree.expression);
        return new AnonBlock(null, [classTree, exp]);
      },
      getDefaultConstructor_: function(tree) {
        if (tree.superClass) {
          var name = id(tree.name.identifierToken);
          var superConstructor = this.getRuntimeExpression('superConstructor');
          return parsePropertyDefinition($traceurRuntime.getTemplateObject(["constructor() {\n        ", "(", ").apply(this, arguments)\n      }"]), superConstructor, name);
        }
        return parsePropertyDefinition($traceurRuntime.getTemplateObject(["constructor() {}"]));
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(ParenTrait(TempVarTransformer)));
  return {get ClassTransformer() {
      return ClassTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ClosureModuleTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ClosureModuleTransformer.js";
  var ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/ClosureModuleTransformer.js")).ModuleTransformer;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ClosureModuleTransformer.js")),
      createIdentifierExpression = $__4.createIdentifierExpression,
      createMemberExpression = $__4.createMemberExpression,
      createPropertyNameAssignment = $__4.createPropertyNameAssignment;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ClosureModuleTransformer.js")),
      EXPORT_DEFAULT = $__5.EXPORT_DEFAULT,
      EXPORT_SPECIFIER = $__5.EXPORT_SPECIFIER;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ClosureModuleTransformer.js")),
      parseExpression = $__6.parseExpression,
      parseStatement = $__6.parseStatement,
      parseStatements = $__6.parseStatements;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/ClosureModuleTransformer.js")).prependStatements;
  var ClosureModuleTransformer = function($__super) {
    function ClosureModuleTransformer() {
      $traceurRuntime.superConstructor(ClosureModuleTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ClosureModuleTransformer, {
      moduleProlog: function() {
        if (!this.moduleName) {
          throw new Error('Closure modules (goog.module) require a moduleName');
        }
        return parseStatements($traceurRuntime.getTemplateObject(["goog.module(", ");"]), this.moduleName);
      },
      wrapModule: function(statements) {
        if (this.hasStarExports()) {
          throw new Error('Closure modules (goog.module) do not support "export *"');
        }
        return statements;
      },
      addExportStatement: function(statements) {
        if (!this.hasExports())
          return statements;
        var exportObject = this.getExportObject();
        statements.push(parseStatement($traceurRuntime.getTemplateObject(["exports = ", ""]), exportObject));
        return statements;
      },
      getGetterExport: function($__1) {
        var $__2 = $__1,
            name = $__2.name,
            tree = $__2.tree,
            moduleSpecifier = $__2.moduleSpecifier;
        var expression;
        switch (tree.type) {
          case EXPORT_DEFAULT:
            expression = createIdentifierExpression('$__default');
            break;
          case EXPORT_SPECIFIER:
            if (moduleSpecifier) {
              var idName = this.getTempVarNameForModuleSpecifier(moduleSpecifier);
              expression = createMemberExpression(idName, tree.lhs);
            } else {
              expression = createPropertyNameAssignment(name, tree.lhs);
            }
            break;
          default:
            expression = createIdentifierExpression(name);
            break;
        }
        return createPropertyNameAssignment(name, expression);
      },
      transformModuleSpecifier: function(tree) {
        var moduleName = tree.token.processedValue;
        return parseExpression($traceurRuntime.getTemplateObject(["goog.require(", ")"]), moduleName);
      }
    }, {}, $__super);
  }(ModuleTransformer);
  return {get ClosureModuleTransformer() {
      return ClosureModuleTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js";
  var ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js")).ModuleTransformer;
  var NAMED_EXPORT = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js")).NAMED_EXPORT;
  var AnonBlock = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js")).AnonBlock;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js")),
      parseExpression = $__6.parseExpression,
      parsePropertyDefinition = $__6.parsePropertyDefinition,
      parseStatement = $__6.parseStatement;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js")),
      createExpressionStatement = $__7.createExpressionStatement,
      createObjectLiteral = $__7.createObjectLiteral,
      createObjectLiteralForDescriptor = $__7.createObjectLiteralForDescriptor,
      createPropertyNameAssignment = $__7.createPropertyNameAssignment;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js")).prependStatements;
  var FindVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindVisitor.js", "traceur@0.0.112/src/codegeneration/CommonJsModuleTransformer.js")).FindVisitor;
  var CommonJsModuleTransformer = function($__super) {
    function CommonJsModuleTransformer(identifierGenerator, reporter) {
      var options = arguments[2];
      $traceurRuntime.superConstructor(CommonJsModuleTransformer).call(this, identifierGenerator, reporter, options);
      this.anonymousModule = options && !options.bundle && options.moduleName !== true;
      this.namedExportsWithModuleSpecifiers_ = [];
      this.isImportingDefault_ = false;
      this.needsInteropRequire_ = false;
    }
    return ($traceurRuntime.createClass)(CommonJsModuleTransformer, {
      getModuleName: function(tree) {
        if (this.anonymousModule)
          return null;
        return tree.moduleName;
      },
      wrapModule: function(statements) {
        if (this.needsInteropRequire_) {
          var req = parseStatement($traceurRuntime.getTemplateObject(["function $__interopRequire(id) {\n        id = require(id);\n        return id && id.__esModule && id || {default: id};\n      }"]));
          return prependStatements(statements, req);
        }
        return statements;
      },
      addExportStatement: function(statements) {
        if (!this.hasExports()) {
          return statements;
        }
        var descr = this.getExportDescriptors();
        var exportObject = parseExpression($traceurRuntime.getTemplateObject(["Object.defineProperties(module.exports, ", ")"]), descr);
        if (this.hasStarExports()) {
          exportObject = this.getExportStar(exportObject);
        }
        return prependStatements.apply((void 0), $traceurRuntime.spread([statements], this.namedExportsWithModuleSpecifiers_, [createExpressionStatement(exportObject)]));
      },
      getExportDescriptors: function() {
        var $__2 = this;
        var properties = this.exportVisitor.getNonTypeNamedExports().map(function(exp) {
          var f = parseExpression($traceurRuntime.getTemplateObject(["function() { return ", "; }"]), $__2.getGetterExportReturnExpression(exp));
          return createPropertyNameAssignment(exp.name, createObjectLiteralForDescriptor({
            enumerable: true,
            get: f
          }));
        });
        properties.unshift(parsePropertyDefinition($traceurRuntime.getTemplateObject(["__esModule: {value: true}"])));
        return createObjectLiteral(properties);
      },
      transformExportDeclaration: function(tree) {
        this.checkForDefaultImport_(tree);
        this.exportVisitor.visitAny(tree);
        var transformed = this.transformAny(tree.declaration);
        if (tree.declaration.type == NAMED_EXPORT && tree.declaration.moduleSpecifier !== null) {
          this.namedExportsWithModuleSpecifiers_.push(transformed);
          return new AnonBlock(null, []);
        }
        return transformed;
      },
      transformImportDeclaration: function(tree) {
        this.checkForDefaultImport_(tree);
        return $traceurRuntime.superGet(this, CommonJsModuleTransformer.prototype, "transformImportDeclaration").call(this, tree);
      },
      checkForDefaultImport_: function(tree) {
        var finder = new FindDefault();
        finder.visitAny(tree);
        this.isImportingDefault_ = finder.found;
      },
      transformModuleSpecifier: function(tree) {
        var moduleName = tree.token.processedValue;
        if (this.isImportingDefault_) {
          this.needsInteropRequire_ = true;
          return parseExpression($traceurRuntime.getTemplateObject(["$__interopRequire(", ")"]), moduleName);
        }
        return parseExpression($traceurRuntime.getTemplateObject(["require(", ")"]), moduleName);
      }
    }, {}, $__super);
  }(ModuleTransformer);
  var FindDefault = function($__super) {
    function FindDefault() {
      $traceurRuntime.superConstructor(FindDefault).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(FindDefault, {
      visitImportSpecifier: function(tree) {
        this.found = tree.name !== null && tree.name.value === 'default';
      },
      visitNameSpaceImport: function(tree) {
        this.found = true;
      },
      visitNameSpaceExport: function(tree) {
        this.found = true;
      },
      visitExportSpecifier: function(tree) {
        this.found = tree.lhs !== null && tree.lhs.value === 'default';
      }
    }, {}, $__super);
  }(FindVisitor);
  return {get CommonJsModuleTransformer() {
      return CommonJsModuleTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ParameterTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ParameterTransformer.js";
  var FunctionBody = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ParameterTransformer.js")).FunctionBody;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ParameterTransformer.js")).TempVarTransformer;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/ParameterTransformer.js")).prependStatements;
  var stack = [];
  var ParameterTransformer = function($__super) {
    function ParameterTransformer() {
      $traceurRuntime.superConstructor(ParameterTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ParameterTransformer, {
      transformArrowFunction: function(tree) {
        stack.push([]);
        return $traceurRuntime.superGet(this, ParameterTransformer.prototype, "transformArrowFunction").call(this, tree);
      },
      transformFunctionDeclaration: function(tree) {
        stack.push([]);
        return $traceurRuntime.superGet(this, ParameterTransformer.prototype, "transformFunctionDeclaration").call(this, tree);
      },
      transformFunctionExpression: function(tree) {
        stack.push([]);
        return $traceurRuntime.superGet(this, ParameterTransformer.prototype, "transformFunctionExpression").call(this, tree);
      },
      transformGetAccessor: function(tree) {
        stack.push([]);
        return $traceurRuntime.superGet(this, ParameterTransformer.prototype, "transformGetAccessor").call(this, tree);
      },
      transformSetAccessor: function(tree) {
        stack.push([]);
        return $traceurRuntime.superGet(this, ParameterTransformer.prototype, "transformSetAccessor").call(this, tree);
      },
      transformMethod: function(tree) {
        stack.push([]);
        return $traceurRuntime.superGet(this, ParameterTransformer.prototype, "transformMethod").call(this, tree);
      },
      transformFunctionBody: function(tree) {
        var transformedTree = $traceurRuntime.superGet(this, ParameterTransformer.prototype, "transformFunctionBody").call(this, tree);
        var statements = stack.pop();
        if (!statements.length)
          return transformedTree;
        statements = prependStatements.apply((void 0), $traceurRuntime.spread([transformedTree.statements], statements));
        return new FunctionBody(transformedTree.location, statements);
      },
      get parameterStatements() {
        return stack[stack.length - 1];
      },
      transformConstructorType: function(tree) {
        return tree;
      },
      transformFunctionType: function(tree) {
        return tree;
      }
    }, {}, $__super);
  }(TempVarTransformer);
  return {get ParameterTransformer() {
      return ParameterTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/util.js", "traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js")),
      isUndefined = $__1.isUndefined,
      isVoidExpression = $__1.isVoidExpression;
  var FormalParameterList = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js")).FormalParameterList;
  var ParameterTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParameterTransformer.js", "traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js")).ParameterTransformer;
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js")).ARGUMENTS;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js")),
      NOT_EQUAL_EQUAL = $__5.NOT_EQUAL_EQUAL,
      VAR = $__5.VAR;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/DefaultParametersTransformer.js")),
      createBinaryExpression = $__6.createBinaryExpression,
      createConditionalExpression = $__6.createConditionalExpression,
      createIdentifierExpression = $__6.createIdentifierExpression,
      createMemberLookupExpression = $__6.createMemberLookupExpression,
      createNumberLiteral = $__6.createNumberLiteral,
      createOperatorToken = $__6.createOperatorToken,
      createVariableStatement = $__6.createVariableStatement,
      createVoid0 = $__6.createVoid0;
  function createDefaultAssignment(index, binding, initializer) {
    var argumentsExpression = createMemberLookupExpression(createIdentifierExpression(ARGUMENTS), createNumberLiteral(index));
    var assignmentExpression;
    if (initializer === null || isUndefined(initializer) || isVoidExpression(initializer)) {
      assignmentExpression = argumentsExpression;
    } else {
      assignmentExpression = createConditionalExpression(createBinaryExpression(argumentsExpression, createOperatorToken(NOT_EQUAL_EQUAL), createVoid0()), argumentsExpression, initializer);
    }
    return createVariableStatement(VAR, binding, assignmentExpression);
  }
  var DefaultParametersTransformer = function($__super) {
    function DefaultParametersTransformer() {
      $traceurRuntime.superConstructor(DefaultParametersTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(DefaultParametersTransformer, {transformFormalParameterList: function(tree) {
        var parameters = [];
        var changed = false;
        var defaultToUndefined = false;
        for (var i = 0; i < tree.parameters.length; i++) {
          var param = this.transformAny(tree.parameters[i]);
          if (param !== tree.parameters[i])
            changed = true;
          if (param.isRestParameter() || !param.parameter.initializer && !defaultToUndefined) {
            parameters.push(param);
          } else {
            defaultToUndefined = true;
            changed = true;
            this.parameterStatements.push(createDefaultAssignment(i, param.parameter.binding, param.parameter.initializer));
          }
        }
        if (!changed)
          return tree;
        return new FormalParameterList(tree.location, parameters);
      }}, {}, $__super);
  }(ParameterTransformer);
  return {get DefaultParametersTransformer() {
      return DefaultParametersTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/assignmentOperatorToBinaryOperator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/assignmentOperatorToBinaryOperator.js";
  var $__0 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/assignmentOperatorToBinaryOperator.js")),
      AMPERSAND = $__0.AMPERSAND,
      AMPERSAND_EQUAL = $__0.AMPERSAND_EQUAL,
      BAR = $__0.BAR,
      BAR_EQUAL = $__0.BAR_EQUAL,
      CARET = $__0.CARET,
      CARET_EQUAL = $__0.CARET_EQUAL,
      LEFT_SHIFT = $__0.LEFT_SHIFT,
      LEFT_SHIFT_EQUAL = $__0.LEFT_SHIFT_EQUAL,
      MINUS = $__0.MINUS,
      MINUS_EQUAL = $__0.MINUS_EQUAL,
      PERCENT = $__0.PERCENT,
      PERCENT_EQUAL = $__0.PERCENT_EQUAL,
      PLUS = $__0.PLUS,
      PLUS_EQUAL = $__0.PLUS_EQUAL,
      RIGHT_SHIFT = $__0.RIGHT_SHIFT,
      RIGHT_SHIFT_EQUAL = $__0.RIGHT_SHIFT_EQUAL,
      SLASH = $__0.SLASH,
      SLASH_EQUAL = $__0.SLASH_EQUAL,
      STAR = $__0.STAR,
      STAR_EQUAL = $__0.STAR_EQUAL,
      STAR_STAR = $__0.STAR_STAR,
      STAR_STAR_EQUAL = $__0.STAR_STAR_EQUAL,
      UNSIGNED_RIGHT_SHIFT = $__0.UNSIGNED_RIGHT_SHIFT,
      UNSIGNED_RIGHT_SHIFT_EQUAL = $__0.UNSIGNED_RIGHT_SHIFT_EQUAL;
  function assignmentOperatorToBinaryOperator(type) {
    switch (type) {
      case STAR_EQUAL:
        return STAR;
      case STAR_STAR_EQUAL:
        return STAR_STAR;
      case SLASH_EQUAL:
        return SLASH;
      case PERCENT_EQUAL:
        return PERCENT;
      case PLUS_EQUAL:
        return PLUS;
      case MINUS_EQUAL:
        return MINUS;
      case LEFT_SHIFT_EQUAL:
        return LEFT_SHIFT;
      case RIGHT_SHIFT_EQUAL:
        return RIGHT_SHIFT;
      case UNSIGNED_RIGHT_SHIFT_EQUAL:
        return UNSIGNED_RIGHT_SHIFT;
      case AMPERSAND_EQUAL:
        return AMPERSAND;
      case CARET_EQUAL:
        return CARET;
      case BAR_EQUAL:
        return BAR;
      default:
        throw Error('unreachable');
    }
  }
  var $__default = assignmentOperatorToBinaryOperator;
  return {get default() {
      return $__default;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js")).ParseTreeTransformer;
  var $__13 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js")),
      createAssignmentExpression = $__13.createAssignmentExpression,
      createCommaExpression = $__13.createCommaExpression,
      id = $__13.createIdentifierExpression,
      createMemberExpression = $__13.createMemberExpression,
      createNumberLiteral = $__13.createNumberLiteral,
      createOperatorToken = $__13.createOperatorToken,
      createParenExpression = $__13.createParenExpression;
  var $__14 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js")),
      AND = $__14.AND,
      EQUAL = $__14.EQUAL,
      MINUS = $__14.MINUS,
      MINUS_EQUAL = $__14.MINUS_EQUAL,
      MINUS_MINUS = $__14.MINUS_MINUS,
      OR = $__14.OR,
      PLUS = $__14.PLUS,
      PLUS_EQUAL = $__14.PLUS_EQUAL,
      PLUS_PLUS = $__14.PLUS_PLUS;
  var $__15 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js")),
      COMMA_EXPRESSION = $__15.COMMA_EXPRESSION,
      IDENTIFIER_EXPRESSION = $__15.IDENTIFIER_EXPRESSION,
      MEMBER_EXPRESSION = $__15.MEMBER_EXPRESSION,
      MEMBER_LOOKUP_EXPRESSION = $__15.MEMBER_LOOKUP_EXPRESSION,
      PROPERTY_NAME_ASSIGNMENT = $__15.PROPERTY_NAME_ASSIGNMENT,
      SPREAD_EXPRESSION = $__15.SPREAD_EXPRESSION,
      TEMPLATE_LITERAL_PORTION = $__15.TEMPLATE_LITERAL_PORTION;
  var $__16 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js")),
      ArgumentList = $__16.ArgumentList,
      ArrayLiteral = $__16.ArrayLiteral,
      AwaitExpression = $__16.AwaitExpression,
      BinaryExpression = $__16.BinaryExpression,
      CallExpression = $__16.CallExpression,
      ClassExpression = $__16.ClassExpression,
      ConditionalExpression = $__16.ConditionalExpression,
      MemberExpression = $__16.MemberExpression,
      MemberLookupExpression = $__16.MemberLookupExpression,
      NewExpression = $__16.NewExpression,
      ObjectLiteral = $__16.ObjectLiteral,
      PropertyNameAssignment = $__16.PropertyNameAssignment,
      SpreadExpression = $__16.SpreadExpression,
      TemplateLiteralExpression = $__16.TemplateLiteralExpression,
      TemplateSubstitution = $__16.TemplateSubstitution,
      UnaryExpression = $__16.UnaryExpression,
      YieldExpression = $__16.YieldExpression;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/assert.js", "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js")).assert;
  var assignmentOperatorToBinaryOperator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./assignmentOperatorToBinaryOperator.js", "traceur@0.0.112/src/codegeneration/ExplodeExpressionTransformer.js")).default;
  var CommaExpressionBuilder = function() {
    function CommaExpressionBuilder(tempVar) {
      this.tempVar = tempVar;
      this.expressions = [];
    }
    return ($traceurRuntime.createClass)(CommaExpressionBuilder, {
      add: function(tree) {
        var $__2;
        if (tree.type === COMMA_EXPRESSION)
          ($__2 = this.expressions).push.apply($__2, $traceurRuntime.spread(getExpressions(tree)));
        return this;
      },
      build: function(tree) {
        var tempVar = this.tempVar;
        this.expressions.push(createAssignmentExpression(tempVar, tree), tempVar);
        return createCommaExpression(this.expressions);
      }
    }, {});
  }();
  function getResult(tree) {
    if (tree.type === COMMA_EXPRESSION)
      return tree.expressions[tree.expressions.length - 1];
    return tree;
  }
  function getExpressions(tree) {
    if (tree.type === COMMA_EXPRESSION)
      return tree.expressions.slice(0, -1);
    return [];
  }
  var ExplodeExpressionTransformer = function($__super) {
    function ExplodeExpressionTransformer(tempVarTransformer) {
      $traceurRuntime.superConstructor(ExplodeExpressionTransformer).call(this);
      this.tempVarTransformer_ = tempVarTransformer;
    }
    return ($traceurRuntime.createClass)(ExplodeExpressionTransformer, {
      addTempVar: function() {
        var tmpId = this.tempVarTransformer_.addTempVar();
        return id(tmpId);
      },
      transformUnaryExpression: function(tree) {
        if (tree.operator.type === PLUS_PLUS)
          return this.transformUnaryNumeric_(tree, PLUS_EQUAL);
        if (tree.operator.type === MINUS_MINUS)
          return this.transformUnaryNumeric_(tree, MINUS_EQUAL);
        var operand = this.transformAny(tree.operand);
        if (operand === tree.operand)
          return tree;
        var expressions = $traceurRuntime.spread(getExpressions(operand), [new UnaryExpression(tree.location, tree.operator, getResult(operand))]);
        return createCommaExpression(expressions);
      },
      transformUnaryNumeric_: function(tree, operator) {
        return this.transformAny(new BinaryExpression(tree.location, tree.operand, createOperatorToken(operator), createNumberLiteral(1)));
      },
      transformPostfixExpression: function(tree) {
        if (tree.operand.type === MEMBER_EXPRESSION)
          return this.transformPostfixMemberExpression_(tree);
        if (tree.operand.type === MEMBER_LOOKUP_EXPRESSION)
          return this.transformPostfixMemberLookupExpression_(tree);
        assert(tree.operand.type === IDENTIFIER_EXPRESSION);
        var operand = tree.operand;
        var tmp = this.addTempVar();
        var operator = tree.operator.type === PLUS_PLUS ? PLUS : MINUS;
        var expressions = [createAssignmentExpression(tmp, operand), createAssignmentExpression(operand, new BinaryExpression(tree.location, tmp, createOperatorToken(operator), createNumberLiteral(1))), tmp];
        return createCommaExpression(expressions);
      },
      transformPostfixMemberExpression_: function(tree) {
        var memberName = tree.operand.memberName;
        var operand = this.transformAny(tree.operand.operand);
        var tmp = this.addTempVar();
        var memberExpression = new MemberExpression(tree.operand.location, getResult(operand), memberName);
        var operator = tree.operator.type === PLUS_PLUS ? PLUS : MINUS;
        var expressions = $traceurRuntime.spread(getExpressions(operand), [createAssignmentExpression(tmp, memberExpression), createAssignmentExpression(memberExpression, new BinaryExpression(tree.location, tmp, createOperatorToken(operator), createNumberLiteral(1))), tmp]);
        return createCommaExpression(expressions);
      },
      transformPostfixMemberLookupExpression_: function(tree) {
        var memberExpression = this.transformAny(tree.operand.memberExpression);
        var operand = this.transformAny(tree.operand.operand);
        var tmp = this.addTempVar();
        var memberLookupExpression = new MemberLookupExpression(null, getResult(operand), getResult(memberExpression));
        var operator = tree.operator.type === PLUS_PLUS ? PLUS : MINUS;
        var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), [createAssignmentExpression(tmp, memberLookupExpression), createAssignmentExpression(memberLookupExpression, new BinaryExpression(tree.location, tmp, createOperatorToken(operator), createNumberLiteral(1))), tmp]);
        return createCommaExpression(expressions);
      },
      transformYieldExpression: function(tree) {
        if (tree.expression === null) {
          return this.createCommaExpressionBuilder_().build(new YieldExpression(tree.location, null, false));
        }
        var expression = this.transformAny(tree.expression);
        return this.createCommaExpressionBuilder_().add(expression).build(new YieldExpression(tree.location, getResult(expression), tree.isYieldFor));
      },
      transformAwaitExpression: function(tree) {
        var expression = this.transformAny(tree.expression);
        return this.createCommaExpressionBuilder_().add(expression).build(new AwaitExpression(tree.location, getResult(expression)));
      },
      transformParenExpression: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression)
          return tree;
        var result = getResult(expression);
        if (result.type === IDENTIFIER_EXPRESSION)
          return expression;
        return this.createCommaExpressionBuilder_().add(expression).build(result);
      },
      transformCommaExpression: function(tree) {
        var expressions = this.transformList(tree.expressions);
        if (expressions === tree.expressions)
          return tree;
        var builder = new CommaExpressionBuilder(null);
        for (var i = 0; i < expressions.length; i++) {
          builder.add(expressions[i]);
        }
        return createCommaExpression($traceurRuntime.spread(builder.expressions, [getResult(expressions[expressions.length - 1])]));
      },
      transformMemberExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        return this.createCommaExpressionBuilder_().add(operand).build(new MemberExpression(tree.location, getResult(operand), tree.memberName));
      },
      transformMemberLookupExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        var memberExpression = this.transformAny(tree.memberExpression);
        return this.createCommaExpressionBuilder_().add(operand).add(memberExpression).build(new MemberLookupExpression(tree.location, getResult(operand), getResult(memberExpression)));
      },
      transformBinaryExpression: function(tree) {
        if (tree.operator.isAssignmentOperator())
          return this.transformAssignmentExpression_(tree);
        var left = this.transformAny(tree.left);
        var right = this.transformAny(tree.right);
        if (left === tree.left && right === tree.right)
          return tree;
        if (tree.operator.type === OR)
          return this.transformOr_(left, right);
        if (tree.operator.type === AND)
          return this.transformAnd_(left, right);
        var expressions = $traceurRuntime.spread(getExpressions(left), getExpressions(right), [new BinaryExpression(tree.location, getResult(left), tree.operator, getResult(right))]);
        return createCommaExpression(expressions);
      },
      transformAssignmentExpression_: function(tree) {
        var left = tree.left;
        if (left.type === MEMBER_EXPRESSION)
          return this.transformAssignMemberExpression_(tree);
        if (left.type === MEMBER_LOOKUP_EXPRESSION)
          return this.transformAssignMemberLookupExpression_(tree);
        assert(tree.left.type === IDENTIFIER_EXPRESSION);
        if (tree.operator.type === EQUAL) {
          left = this.transformAny(left);
          var right$__3 = this.transformAny(tree.right);
          var expressions$__4 = $traceurRuntime.spread(getExpressions(right$__3), [createAssignmentExpression(left, getResult(right$__3)), getResult(right$__3)]);
          return createCommaExpression(expressions$__4);
        }
        var right = this.transformAny(tree.right);
        var tmp = this.addTempVar();
        var binop = createOperatorToken(assignmentOperatorToBinaryOperator(tree.operator.type));
        var expressions = $traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(tmp, new BinaryExpression(tree.location, left, binop, getResult(right))), createAssignmentExpression(left, tmp), tmp]);
        return createCommaExpression(expressions);
      },
      transformAssignMemberExpression_: function(tree) {
        var left = tree.left;
        if (tree.operator.type === EQUAL) {
          var operand$__5 = this.transformAny(left.operand);
          var right$__6 = this.transformAny(tree.right);
          var expressions$__7 = $traceurRuntime.spread(getExpressions(operand$__5), getExpressions(right$__6), [new BinaryExpression(tree.location, new MemberExpression(left.location, getResult(operand$__5), left.memberName), tree.operator, getResult(right$__6)), getResult(right$__6)]);
          return createCommaExpression(expressions$__7);
        }
        var operand = this.transformAny(left.operand);
        var right = this.transformAny(tree.right);
        var tmp = this.addTempVar();
        var memberExpression = new MemberExpression(left.location, getResult(operand), left.memberName);
        var tmp2 = this.addTempVar();
        var binop = createOperatorToken(assignmentOperatorToBinaryOperator(tree.operator.type));
        var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(right), [createAssignmentExpression(tmp, memberExpression), createAssignmentExpression(tmp2, new BinaryExpression(tree.location, tmp, binop, getResult(right))), createAssignmentExpression(memberExpression, tmp2), tmp2]);
        return createCommaExpression(expressions);
      },
      transformAssignMemberLookupExpression_: function(tree) {
        var left = tree.left;
        if (tree.operator.type === EQUAL) {
          var operand$__8 = this.transformAny(left.operand);
          var memberExpression$__9 = this.transformAny(left.memberExpression);
          var right$__10 = this.transformAny(tree.right);
          var expressions$__11 = $traceurRuntime.spread(getExpressions(operand$__8), getExpressions(memberExpression$__9), getExpressions(right$__10), [new BinaryExpression(tree.location, new MemberLookupExpression(left.location, getResult(operand$__8), getResult(memberExpression$__9)), tree.operator, getResult(right$__10)), getResult(right$__10)]);
          return createCommaExpression(expressions$__11);
        }
        var operand = this.transformAny(left.operand);
        var memberExpression = this.transformAny(left.memberExpression);
        var right = this.transformAny(tree.right);
        var tmp = this.addTempVar();
        var memberLookupExpression = new MemberLookupExpression(left.location, getResult(operand), getResult(memberExpression));
        var tmp2 = this.addTempVar();
        var binop = createOperatorToken(assignmentOperatorToBinaryOperator(tree.operator.type));
        var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), getExpressions(right), [createAssignmentExpression(tmp, memberLookupExpression), createAssignmentExpression(tmp2, new BinaryExpression(tree.location, tmp, binop, getResult(right))), createAssignmentExpression(memberLookupExpression, tmp2), tmp2]);
        return createCommaExpression(expressions);
      },
      transformArrayLiteral: function(tree) {
        var elements = this.transformList(tree.elements);
        if (elements === tree.elements)
          return tree;
        var builder = this.createCommaExpressionBuilder_();
        var results = [];
        for (var i = 0; i < elements.length; i++) {
          builder.add(elements[i]);
          results.push(getResult(elements[i]));
        }
        return builder.build(new ArrayLiteral(tree.location, results));
      },
      transformObjectLiteral: function(tree) {
        var propertyNameAndValues = this.transformList(tree.propertyNameAndValues);
        if (propertyNameAndValues === tree.propertyNameAndValues)
          return tree;
        var builder = this.createCommaExpressionBuilder_();
        var results = [];
        for (var i = 0; i < propertyNameAndValues.length; i++) {
          if (propertyNameAndValues[i].type === PROPERTY_NAME_ASSIGNMENT) {
            builder.add(propertyNameAndValues[i].value);
            results.push(new PropertyNameAssignment(propertyNameAndValues[i].location, propertyNameAndValues[i].name, getResult(propertyNameAndValues[i].value)));
          } else {
            results.push(propertyNameAndValues[i]);
          }
        }
        return builder.build(new ObjectLiteral(tree.location, results));
      },
      transformTemplateLiteralExpression: function(tree) {
        var operand = this.transformAny(tree.operand);
        var elements = this.transformList(tree.elements);
        if (!operand && operand === tree.operand && elements === tree.elements)
          return tree;
        var builder = this.createCommaExpressionBuilder_();
        if (operand)
          builder.add(operand);
        var results = [];
        for (var i = 0; i < elements.length; i++) {
          if (elements[i].type === TEMPLATE_LITERAL_PORTION) {
            results.push(elements[i]);
          } else {
            var expression = elements[i].expression;
            builder.add(expression);
            var result = getResult(expression);
            results.push(new TemplateSubstitution(expression.location, result));
          }
        }
        return builder.build(new TemplateLiteralExpression(tree.location, operand && getResult(operand), results));
      },
      transformCallExpression: function(tree) {
        if (tree.operand.type === MEMBER_EXPRESSION)
          return this.transformCallMemberExpression_(tree);
        if (tree.operand.type === MEMBER_LOOKUP_EXPRESSION)
          return this.transformCallMemberLookupExpression_(tree);
        return this.transformCallAndNew_(tree, CallExpression);
      },
      transformNewExpression: function(tree) {
        return this.transformCallAndNew_(tree, NewExpression);
      },
      transformCallAndNew_: function(tree, ctor) {
        var operand = this.transformAny(tree.operand);
        var args = this.transformAny(tree.args);
        var builder = this.createCommaExpressionBuilder_().add(operand);
        var argResults = [];
        args.args.forEach(function(arg) {
          builder.add(arg);
          argResults.push(getResult(arg));
        });
        return builder.build(new ctor(tree.location, getResult(operand), new ArgumentList(args.location, argResults)));
      },
      transformCallMemberExpression_: function(tree) {
        var memberName = tree.operand.memberName;
        var operand = this.transformAny(tree.operand.operand);
        var tmp = this.addTempVar();
        var memberExpresssion = new MemberExpression(tree.operand.location, getResult(operand), memberName);
        var args = this.transformAny(tree.args);
        var expressions = $traceurRuntime.spread(getExpressions(operand), [createAssignmentExpression(tmp, memberExpresssion)]);
        var argResults = [getResult(operand)];
        args.args.forEach(function(arg) {
          var $__2;
          ($__2 = expressions).push.apply($__2, $traceurRuntime.spread(getExpressions(arg)));
          argResults.push(getResult(arg));
        });
        var callExpression = new CallExpression(tree.location, createMemberExpression(tmp, 'call'), new ArgumentList(args.location, argResults));
        var tmp2 = this.addTempVar();
        expressions.push(createAssignmentExpression(tmp2, callExpression), tmp2);
        return createCommaExpression(expressions);
      },
      transformCallMemberLookupExpression_: function(tree) {
        var operand = this.transformAny(tree.operand.operand);
        var memberExpression = this.transformAny(tree.operand.memberExpression);
        var tmp = this.addTempVar();
        var lookupExpresssion = new MemberLookupExpression(tree.operand.location, getResult(operand), getResult(memberExpression));
        var args = this.transformAny(tree.args);
        var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), [createAssignmentExpression(tmp, lookupExpresssion)]);
        var argResults = [getResult(operand)];
        args.args.forEach(function(arg, i) {
          var $__2;
          ($__2 = expressions).push.apply($__2, $traceurRuntime.spread(getExpressions(arg)));
          var result = getResult(arg);
          if (tree.args.args[i].type === SPREAD_EXPRESSION)
            result = new SpreadExpression(arg.location, result);
          argResults.push(result);
        });
        var callExpression = new CallExpression(tree.location, createMemberExpression(tmp, 'call'), new ArgumentList(args.location, argResults));
        var tmp2 = this.addTempVar();
        expressions.push(createAssignmentExpression(tmp2, callExpression), tmp2);
        return createCommaExpression(expressions);
      },
      transformConditionalExpression: function(tree) {
        var condition = this.transformAny(tree.condition);
        var left = this.transformAny(tree.left);
        var right = this.transformAny(tree.right);
        if (condition === tree.condition && left === tree.left && right === tree.right)
          return tree;
        var res = this.addTempVar();
        var leftTree = createCommaExpression($traceurRuntime.spread(getExpressions(left), [createAssignmentExpression(res, getResult(left))]));
        var rightTree = createCommaExpression($traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(res, getResult(right))]));
        var expressions = $traceurRuntime.spread(getExpressions(condition), [new ConditionalExpression(tree.location, getResult(condition), createParenExpression(leftTree), createParenExpression(rightTree)), res]);
        return createCommaExpression(expressions);
      },
      transformOr_: function(left, right) {
        var res = this.addTempVar();
        var leftTree = createCommaExpression([createAssignmentExpression(res, getResult(left))]);
        var rightTree = createCommaExpression($traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(res, getResult(right))]));
        var expressions = $traceurRuntime.spread(getExpressions(left), [new ConditionalExpression(left.location, getResult(left), createParenExpression(leftTree), createParenExpression(rightTree)), res]);
        return createCommaExpression(expressions);
      },
      transformAnd_: function(left, right) {
        var res = this.addTempVar();
        var leftTree = createCommaExpression($traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(res, getResult(right))]));
        var rightTree = createCommaExpression([createAssignmentExpression(res, getResult(left))]);
        var expressions = $traceurRuntime.spread(getExpressions(left), [new ConditionalExpression(left.location, getResult(left), createParenExpression(leftTree), createParenExpression(rightTree)), res]);
        return createCommaExpression(expressions);
      },
      transformSpreadExpression: function(tree) {
        var expression = this.transformAny(tree.expression);
        if (expression === tree.expression)
          return tree;
        var result = getResult(expression);
        if (result.type !== SPREAD_EXPRESSION)
          result = new SpreadExpression(result.location, result);
        var expressions = $traceurRuntime.spread(getExpressions(expression), [result]);
        return createCommaExpression(expressions);
      },
      transformFunctionExpression: function(tree) {
        return this.createCommaExpressionBuilder_().build(tree);
      },
      transformArrowFunction: function(tree) {
        return this.createCommaExpressionBuilder_().build(tree);
      },
      transformClassExpression: function(tree) {
        var superClass = this.transformAny(tree.superClass);
        if (superClass === tree.superClass) {
          return this.createCommaExpressionBuilder_().build(tree);
        }
        var builder = this.createCommaExpressionBuilder_();
        builder.add(superClass);
        return builder.build(new ClassExpression(tree.location, tree.name, getResult(superClass), tree.elements, tree.annotations, tree.typeParameters));
      },
      transformFunctionBody: function(tree) {
        return tree;
      },
      createCommaExpressionBuilder_: function() {
        return new CommaExpressionBuilder(this.addTempVar());
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get ExplodeExpressionTransformer() {
      return ExplodeExpressionTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ExponentiationTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ExponentiationTransformer.js";
  var ExplodeExpressionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ExplodeExpressionTransformer.js", "traceur@0.0.112/src/codegeneration/ExponentiationTransformer.js")).ExplodeExpressionTransformer;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ExponentiationTransformer.js")).TempVarTransformer;
  var ParenTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParenTrait.js", "traceur@0.0.112/src/codegeneration/ExponentiationTransformer.js")).ParenTrait;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ExponentiationTransformer.js")),
      STAR_STAR = $__4.STAR_STAR,
      STAR_STAR_EQUAL = $__4.STAR_STAR_EQUAL;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ExponentiationTransformer.js")).parseExpression;
  var ExponentiationTransformer = function($__super) {
    function ExponentiationTransformer() {
      $traceurRuntime.superConstructor(ExponentiationTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ExponentiationTransformer, {transformBinaryExpression: function(tree) {
        switch (tree.operator.type) {
          case STAR_STAR:
            {
              var left = this.transformAny(tree.left);
              var right = this.transformAny(tree.right);
              return parseExpression($traceurRuntime.getTemplateObject(["Math.pow(", ", ", ")"]), left, right);
            }
          case STAR_STAR_EQUAL:
            {
              var exploded = new ExplodeExpressionTransformer(this).transformAny(tree);
              return this.transformAny(exploded);
            }
        }
        return $traceurRuntime.superGet(this, ExponentiationTransformer.prototype, "transformBinaryExpression").call(this, tree);
      }}, {}, $__super);
  }(ParenTrait(TempVarTransformer));
  return {get ExponentiationTransformer() {
      return ExponentiationTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ForOfTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ForOfTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ForOfTransformer.js")),
      FOR_OF_STATEMENT = $__1.FOR_OF_STATEMENT,
      VARIABLE_DECLARATION_LIST = $__1.VARIABLE_DECLARATION_LIST,
      LABELLED_STATEMENT = $__1.LABELLED_STATEMENT;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ForOfTransformer.js")).TempVarTransformer;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ForOfTransformer.js")),
      id = $__3.createIdentifierExpression,
      createMemberExpression = $__3.createMemberExpression,
      createVariableStatement = $__3.createVariableStatement;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ForOfTransformer.js")),
      parseStatement = $__4.parseStatement,
      parseStatements = $__4.parseStatements;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ForOfTransformer.js")),
      AnonBlock = $__5.AnonBlock,
      LabelledStatement = $__5.LabelledStatement;
  var ForOfTransformer = function($__super) {
    function ForOfTransformer() {
      $traceurRuntime.superConstructor(ForOfTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ForOfTransformer, {
      transformForOfStatement: function(original) {
        return this.transformForOfStatement_(original, []);
      },
      transformForOfStatement_: function(original, labelSet) {
        var tree = $traceurRuntime.superGet(this, ForOfTransformer.prototype, "transformForOfStatement").call(this, original);
        var iter = id(this.getTempIdentifier());
        var result = id(this.getTempIdentifier());
        var label = id(this.getTempIdentifier());
        var normalCompletion = id(this.getTempIdentifier());
        var throwCompletion = id(this.getTempIdentifier());
        var exception = id(this.getTempIdentifier());
        var ex = id(this.getTempIdentifier());
        var labelledStatement;
        var innerStatement;
        var assignment;
        if (tree.initializer.type === VARIABLE_DECLARATION_LIST) {
          assignment = createVariableStatement(tree.initializer.declarationType, tree.initializer.declarations[0].lvalue, createMemberExpression(result, 'value'));
        } else {
          assignment = parseStatement($traceurRuntime.getTemplateObject(["", " = ", ".value;"]), tree.initializer, result);
        }
        innerStatement = parseStatement($traceurRuntime.getTemplateObject(["\n        for (var ", ",\n                 ", " = (", ")[Symbol.iterator]();\n             !(", " = (", " = ", ".next()).done);\n             ", " = true) {\n          ", "\n          ", "\n        }"]), result, iter, tree.collection, normalCompletion, result, iter, normalCompletion, assignment, tree.body);
        while (labelledStatement = labelSet.pop()) {
          innerStatement = new LabelledStatement(labelledStatement.location, labelledStatement.name, innerStatement);
        }
        return new AnonBlock(null, parseStatements($traceurRuntime.getTemplateObject(["\n        var ", " = true;\n        var ", " = false;\n        var ", " = undefined;\n        try {\n          ", "\n        } catch (", ") {\n          ", " = true;\n          ", " = ", ";\n        } finally {\n          try {\n            if (!", " && ", ".return != null) {\n              ", ".return();\n            }\n          } finally {\n            if (", ") {\n              throw ", ";\n            }\n          }\n        }"]), normalCompletion, throwCompletion, exception, innerStatement, ex, throwCompletion, exception, ex, normalCompletion, iter, iter, throwCompletion, exception));
      },
      transformLabelledStatement: function(tree) {
        var labelSet = [tree];
        var statement = tree.statement;
        while (statement.type === LABELLED_STATEMENT) {
          labelSet.push(statement);
          statement = statement.statement;
        }
        if (statement.type !== FOR_OF_STATEMENT) {
          return $traceurRuntime.superGet(this, ForOfTransformer.prototype, "transformLabelledStatement").call(this, tree);
        }
        return this.transformForOfStatement_(statement, labelSet);
      }
    }, {}, $__super);
  }(TempVarTransformer);
  return {get ForOfTransformer() {
      return ForOfTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")).ParseTreeTransformer;
  var alphaRenameThisAndArguments = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./alphaRenameThisAndArguments.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")).default;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")),
      parseStatement = $__4.parseStatement,
      parseStatements = $__4.parseStatements;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")),
      AnonBlock = $__5.AnonBlock,
      Block = $__5.Block,
      ContinueStatement = $__5.ContinueStatement,
      LabelledStatement = $__5.LabelledStatement,
      ReturnStatement = $__5.ReturnStatement;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")).StringSet;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")),
      createAssignmentStatement = $__7.createAssignmentStatement,
      createCaseClause = $__7.createCaseClause,
      createDefaultClause = $__7.createDefaultClause,
      id = $__7.createIdentifierExpression,
      createNumberLiteral = $__7.createNumberLiteral,
      createSwitchStatement = $__7.createSwitchStatement,
      createThisExpression = $__7.createThisExpression,
      createVariableStatement = $__7.createVariableStatement,
      createVariableDeclaration = $__7.createVariableDeclaration,
      createVariableDeclarationList = $__7.createVariableDeclarationList,
      createVoid0 = $__7.createVoid0;
  var SkipFunctionsTransformerTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SkipFunctionsTransformerTrait.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")).default;
  var ARGUMENTS = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")).ARGUMENTS;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")).VAR;
  var $__11 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/InnerForOnTransformer.js")),
      VARIABLE_DECLARATION_LIST = $__11.VARIABLE_DECLARATION_LIST,
      BLOCK = $__11.BLOCK;
  var InnerForOnTransformer = function($__super) {
    function InnerForOnTransformer(tempIdGenerator, labelSet, options) {
      var $__1;
      $traceurRuntime.superConstructor(InnerForOnTransformer).call(this);
      this.idGenerator_ = tempIdGenerator;
      this.inLoop_ = 0;
      this.inBreakble_ = 0;
      this.variableDeclarations_ = [];
      this.extractedStatements_ = [];
      this.labelSet_ = labelSet;
      this.labelledStatements_ = new StringSet();
      this.observer_ = id(this.idGenerator_.getTempIdentifier());
      this.result_ = id(this.idGenerator_.getTempIdentifier());
      this.parentLabels_ = new StringSet();
      this.labelSet_.forEach(($__1 = this, function(tree) {
        $__1.parentLabels_.add(tree.name.value);
      }));
      this.options = options;
    }
    return ($traceurRuntime.createClass)(InnerForOnTransformer, {
      transform: function(tree) {
        var value = id(this.idGenerator_.getTempIdentifier());
        var assignment;
        if (tree.initializer.type === VARIABLE_DECLARATION_LIST) {
          assignment = createVariableStatement(tree.initializer.declarationType, tree.initializer.declarations[0].lvalue, value);
        } else {
          assignment = parseStatement($traceurRuntime.getTemplateObject(["\n          ", " = ", ";"]), tree.initializer, value);
        }
        var body;
        if (tree.body.type === BLOCK) {
          body = new Block(tree.body.location, $traceurRuntime.spread([assignment], tree.body.statements));
        } else {
          body = new Block(null, [assignment, tree.body]);
        }
        body = this.transformAny(body);
        body = alphaRenameThisAndArguments(this, body);
        this.variableDeclarations_.push(createVariableDeclaration(this.result_, createVoid0()));
        var caseClauses = this.extractedStatements_.map(function(statement, index) {
          return createCaseClause(createNumberLiteral(index), [statement]);
        });
        caseClauses.push(createCaseClause(createVoid0(), [new ContinueStatement(null, null)]));
        caseClauses.push(createDefaultClause(parseStatements($traceurRuntime.getTemplateObject(["\n        return ", ".v;"]), this.result_)));
        var switchStatement = createSwitchStatement(this.result_, caseClauses);
        var observeForEach = this.idGenerator_.getRuntimeExpression('observeForEach');
        var statement = parseStatement($traceurRuntime.getTemplateObject(["\n        do {\n          ", "\n            await ", "(\n              ", "[Symbol.observer].bind(", "),\n              async function (", ") {\n                var ", " = this;\n                try {\n                  ", "\n                } catch (e) {\n                  ", ".throw(e);\n                }\n              });\n          ", "\n        } while (false);"]), createVariableStatement(createVariableDeclarationList(VAR, this.variableDeclarations_)), observeForEach, tree.observable, tree.observable, value, this.observer_, body, this.observer_, switchStatement);
        var labelledStatement;
        while (labelledStatement = this.labelSet_.pop()) {
          statement = new LabelledStatement(labelledStatement.location, labelledStatement.name, statement);
        }
        return statement;
      },
      addTempVarForArguments: function() {
        var tmpVarName = this.idGenerator_.generateUniqueIdentifier();
        this.variableDeclarations_.push(createVariableDeclaration(tmpVarName, id(ARGUMENTS)));
        return tmpVarName;
      },
      addTempVarForThis: function() {
        var tmpVarName = this.idGenerator_.generateUniqueIdentifier();
        this.variableDeclarations_.push(createVariableDeclaration(tmpVarName, createThisExpression()));
        return tmpVarName;
      },
      transformAny: function(tree) {
        if (tree) {
          if (tree.isBreakableStatement())
            this.inBreakble_++;
          if (tree.isIterationStatement())
            this.inLoop_++;
          tree = $traceurRuntime.superGet(this, InnerForOnTransformer.prototype, "transformAny").call(this, tree);
          if (tree.isBreakableStatement())
            this.inBreakble_--;
          if (tree.isIterationStatement())
            this.inLoop_--;
        }
        return tree;
      },
      transformReturnStatement: function(tree) {
        return new AnonBlock(tree.location, parseStatements($traceurRuntime.getTemplateObject(["\n        ", ".return();\n        ", " = {v: ", "};\n        return;"]), this.observer_, this.result_, (tree.expression || createVoid0())));
      },
      transformAbruptCompletion_: function(tree) {
        this.extractedStatements_.push(tree);
        var index = this.extractedStatements_.length - 1;
        return new AnonBlock(null, parseStatements($traceurRuntime.getTemplateObject(["\n        ", ".return();\n        ", " = ", ";\n        return;"]), this.observer_, this.result_, index));
      },
      transformBreakStatement: function(tree) {
        if (!tree.name) {
          if (this.inBreakble_) {
            return $traceurRuntime.superGet(this, InnerForOnTransformer.prototype, "transformBreakStatement").call(this, tree);
          }
          return this.transformAbruptCompletion_(new ContinueStatement(tree.location, null));
        }
        if (this.labelledStatements_.has(tree.name.value)) {
          return $traceurRuntime.superGet(this, InnerForOnTransformer.prototype, "transformBreakStatement").call(this, tree);
        }
        return this.transformAbruptCompletion_(tree);
      },
      transformContinueStatement: function(tree) {
        if (!tree.name) {
          if (this.inLoop_) {
            return $traceurRuntime.superGet(this, InnerForOnTransformer.prototype, "transformContinueStatement").call(this, tree);
          }
          return new ReturnStatement(tree.location, null);
        }
        if (this.labelledStatements_.has(tree.name.value)) {
          return $traceurRuntime.superGet(this, InnerForOnTransformer.prototype, "transformContinueStatement").call(this, tree);
        }
        if (this.parentLabels_.has(tree.name.value)) {
          return new ReturnStatement(tree.location, null);
        }
        return this.transformAbruptCompletion_(tree);
      },
      transformLabelledStatement: function(tree) {
        this.labelledStatements_.add(tree.name.value);
        return $traceurRuntime.superGet(this, InnerForOnTransformer.prototype, "transformLabelledStatement").call(this, tree);
      },
      transformVariableStatement: function(tree) {
        var $__1 = this;
        if (tree.declarations.declarationType === VAR) {
          var assignments = [];
          tree.declarations.declarations.forEach(function(variableDeclaration) {
            var variableName = variableDeclaration.lvalue.getStringValue();
            var initializer = $traceurRuntime.superGet($__1, InnerForOnTransformer.prototype, "transformAny").call($__1, variableDeclaration.initializer);
            $__1.variableDeclarations_.push(createVariableDeclaration(variableName, null));
            assignments.push(createAssignmentStatement(id(variableName), initializer));
          });
          return new AnonBlock(null, assignments);
        }
        return $traceurRuntime.superGet(this, InnerForOnTransformer.prototype, "transformVariableStatement").call(this, tree);
      }
    }, {transform: function(tempIdGenerator, tree, labelSet) {
        return new InnerForOnTransformer(tempIdGenerator, labelSet).transform(tree);
      }}, $__super);
  }(SkipFunctionsTransformerTrait(ParseTreeTransformer));
  return {get InnerForOnTransformer() {
      return InnerForOnTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ForOnTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ForOnTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ForOnTransformer.js")),
      FOR_ON_STATEMENT = $__1.FOR_ON_STATEMENT,
      LABELLED_STATEMENT = $__1.LABELLED_STATEMENT;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/ForOnTransformer.js")).default;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ForOnTransformer.js")).TempVarTransformer;
  var InnerForOnTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./InnerForOnTransformer.js", "traceur@0.0.112/src/codegeneration/ForOnTransformer.js")).InnerForOnTransformer;
  var ForOnTransformer = function($__super) {
    function ForOnTransformer() {
      $traceurRuntime.superConstructor(ForOnTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ForOnTransformer, {
      transformForOnStatement: function(original) {
        return this.transformForOnStatement_(original, []);
      },
      transformForOnStatement_: function(original, labelSet) {
        return InnerForOnTransformer.transform(this, $traceurRuntime.superGet(this, ForOnTransformer.prototype, "transformForOnStatement").call(this, original), labelSet);
      },
      transformLabelledStatement: function(tree) {
        var labelSet = [tree];
        var statement;
        for (statement = tree.statement; statement.type === LABELLED_STATEMENT; statement = statement.statement) {
          labelSet.push(statement);
        }
        if (statement.type !== FOR_ON_STATEMENT) {
          return $traceurRuntime.superGet(this, ForOnTransformer.prototype, "transformLabelledStatement").call(this, tree);
        }
        return this.transformForOnStatement_(statement, labelSet);
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  return {get ForOnTransformer() {
      return ForOnTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/GeneratorComprehensionTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/GeneratorComprehensionTransformer.js";
  var ComprehensionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ComprehensionTransformer.js", "traceur@0.0.112/src/codegeneration/GeneratorComprehensionTransformer.js")).ComprehensionTransformer;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/GeneratorComprehensionTransformer.js")).parseStatement;
  var GeneratorComprehensionTransformer = function($__super) {
    function GeneratorComprehensionTransformer() {
      $traceurRuntime.superConstructor(GeneratorComprehensionTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(GeneratorComprehensionTransformer, {transformGeneratorComprehension: function(tree) {
        var expression = this.transformAny(tree.expression);
        var statement = parseStatement($traceurRuntime.getTemplateObject(["yield ", ""]), expression);
        var isGenerator = true;
        return this.transformComprehension(tree, statement, isGenerator);
      }}, {}, $__super);
  }(ComprehensionTransformer);
  return {get GeneratorComprehensionTransformer() {
      return GeneratorComprehensionTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/State.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/State.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/State.js")),
      createAssignStateStatement = $__1.createAssignStateStatement,
      createBreakStatement = $__1.createBreakStatement,
      createCaseClause = $__1.createCaseClause,
      createNumberLiteral = $__1.createNumberLiteral;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/generator/State.js")).parseStatement;
  var State = function() {
    function State(id) {
      this.id = id;
    }
    return ($traceurRuntime.createClass)(State, {
      transformMachineState: function(enclosingFinally, machineEndState, reporter) {
        return createCaseClause(createNumberLiteral(this.id), this.transform(enclosingFinally, machineEndState, reporter));
      },
      transformBreak: function(labelSet, breakState) {
        return this;
      },
      transformBreakOrContinue: function(labelSet) {
        var breakState = arguments[1];
        var continueState = arguments[2];
        return this;
      }
    }, {});
  }();
  State.START_STATE = 0;
  State.INVALID_STATE = -1;
  State.END_STATE = -2;
  State.RETHROW_STATE = -3;
  State.generateJump = function(enclosingFinally, fallThroughState) {
    return $traceurRuntime.spread(State.generateAssignState(enclosingFinally, fallThroughState), [createBreakStatement()]);
  };
  State.generateAssignState = function(enclosingFinally, fallThroughState) {
    var assignState;
    if (State.isFinallyExit(enclosingFinally, fallThroughState)) {
      assignState = generateAssignStateOutOfFinally(enclosingFinally, fallThroughState);
    } else {
      assignState = [createAssignStateStatement(fallThroughState)];
    }
    return assignState;
  };
  State.isFinallyExit = function(enclosingFinally, destination) {
    return !!enclosingFinally && enclosingFinally.tryStates.indexOf(destination) < 0;
  };
  function generateAssignStateOutOfFinally(enclosingFinally, destination) {
    var finallyState = enclosingFinally.finallyState;
    return [createAssignStateStatement(finallyState), parseStatement($traceurRuntime.getTemplateObject(["$ctx.finallyFallThrough = ", ""]), destination)];
  }
  State.replaceStateList = function(oldStates, oldState, newState) {
    var states = [];
    for (var i = 0; i < oldStates.length; i++) {
      states.push(State.replaceStateId(oldStates[i], oldState, newState));
    }
    return states;
  };
  State.replaceStateId = function(current, oldState, newState) {
    return current === oldState ? newState : current;
  };
  State.replaceAllStates = function(exceptionBlocks, oldState, newState) {
    var result = [];
    for (var i = 0; i < exceptionBlocks.length; i++) {
      result.push(exceptionBlocks[i].replaceState(oldState, newState));
    }
    return result;
  };
  return {get State() {
      return State;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/AwaitState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/AwaitState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/AwaitState.js")).State;
  var parseStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/generator/AwaitState.js")).parseStatements;
  var AwaitState = function($__super) {
    function AwaitState(id, callbackState, expression) {
      $traceurRuntime.superConstructor(AwaitState).call(this, id), this.callbackState = callbackState;
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(AwaitState, {
      replaceState: function(oldState, newState) {
        return new AwaitState(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.callbackState, oldState, newState), this.expression);
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        var $__1;
        var stateId,
            statements;
        if (State.isFinallyExit(enclosingFinally, this.callbackState)) {
          stateId = enclosingFinally.finallyState;
          statements = parseStatements($traceurRuntime.getTemplateObject(["$ctx.finallyFallThrough = ", ""]), this.callbackState);
        } else {
          stateId = this.callbackState;
          statements = [];
        }
        ($__1 = statements).push.apply($__1, $traceurRuntime.spread(parseStatements($traceurRuntime.getTemplateObject(["Promise.resolve(", ").then(\n          $ctx.createCallback(", "), $ctx.errback);\n          return;"]), this.expression, stateId)));
        return statements;
      }
    }, {}, $__super);
  }(State);
  return {get AwaitState() {
      return AwaitState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/FallThroughState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/FallThroughState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/FallThroughState.js")).State;
  var FallThroughState = function($__super) {
    function FallThroughState(id, fallThroughState, statements) {
      $traceurRuntime.superConstructor(FallThroughState).call(this, id);
      this.fallThroughState = fallThroughState;
      this.statements = statements;
    }
    return ($traceurRuntime.createClass)(FallThroughState, {
      replaceState: function(oldState, newState) {
        return new FallThroughState(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.statements);
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        return $traceurRuntime.spread(this.statements, State.generateJump(enclosingFinally, this.fallThroughState));
      }
    }, {}, $__super);
  }(State);
  return {get FallThroughState() {
      return FallThroughState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/BreakState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/BreakState.js";
  var FallThroughState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FallThroughState.js", "traceur@0.0.112/src/codegeneration/generator/BreakState.js")).FallThroughState;
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/BreakState.js")).State;
  var BreakState = function($__super) {
    function BreakState(id, label) {
      $traceurRuntime.superConstructor(BreakState).call(this, id);
      this.label = label;
    }
    return ($traceurRuntime.createClass)(BreakState, {
      replaceState: function(oldState, newState) {
        return new BreakState(State.replaceStateId(this.id, oldState, newState), this.label);
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        throw new Error('These should be removed before the transform step');
      },
      transformBreak: function(labelSet) {
        var breakState = arguments[1];
        if (this.label === null)
          return new FallThroughState(this.id, breakState, []);
        if (labelSet.has(this.label)) {
          return new FallThroughState(this.id, labelSet.get(this.label).fallThroughState, []);
        }
        return this;
      },
      transformBreakOrContinue: function(labelSet) {
        var breakState = arguments[1];
        var continueState = arguments[2];
        return this.transformBreak(labelSet, breakState);
      }
    }, {}, $__super);
  }(State);
  return {get BreakState() {
      return BreakState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/ContinueState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/ContinueState.js";
  var FallThroughState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FallThroughState.js", "traceur@0.0.112/src/codegeneration/generator/ContinueState.js")).FallThroughState;
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/ContinueState.js")).State;
  var ContinueState = function($__super) {
    function ContinueState(id, label) {
      $traceurRuntime.superConstructor(ContinueState).call(this, id);
      this.label = label;
    }
    return ($traceurRuntime.createClass)(ContinueState, {
      replaceState: function(oldState, newState) {
        return new ContinueState(State.replaceStateId(this.id, oldState, newState), this.label);
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        throw new Error('These should be removed before the transform step');
      },
      transformBreakOrContinue: function(labelSet) {
        var breakState = arguments[1];
        var continueState = arguments[2];
        if (this.label === null)
          return new FallThroughState(this.id, continueState, []);
        if (labelSet.has(this.label)) {
          return new FallThroughState(this.id, labelSet.get(this.label).continueState, []);
        }
        return this;
      }
    }, {}, $__super);
  }(State);
  return {get ContinueState() {
      return ContinueState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/TryState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/TryState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/TryState.js")).State;
  var Kind = {
    CATCH: 'catch',
    FINALLY: 'finally'
  };
  var TryState = function() {
    function TryState(kind, tryStates, nestedTrys) {
      this.kind = kind;
      this.tryStates = tryStates;
      this.nestedTrys = nestedTrys;
    }
    return ($traceurRuntime.createClass)(TryState, {
      replaceAllStates: function(oldState, newState) {
        return State.replaceStateList(this.tryStates, oldState, newState);
      },
      replaceNestedTrys: function(oldState, newState) {
        var states = [];
        for (var i = 0; i < this.nestedTrys.length; i++) {
          states.push(this.nestedTrys[i].replaceState(oldState, newState));
        }
        return states;
      }
    }, {});
  }();
  TryState.Kind = Kind;
  return {get TryState() {
      return TryState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/trees/StateMachine.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/trees/StateMachine.js";
  var ParseTree = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTree.js", "traceur@0.0.112/src/syntax/trees/StateMachine.js")).ParseTree;
  var STATE_MACHINE = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeType.js", "traceur@0.0.112/src/syntax/trees/StateMachine.js")).STATE_MACHINE;
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../codegeneration/generator/State.js", "traceur@0.0.112/src/syntax/trees/StateMachine.js")).State;
  var TryState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../codegeneration/generator/TryState.js", "traceur@0.0.112/src/syntax/trees/StateMachine.js")).TryState;
  function addCatchOrFinallyStates(kind, enclosingMap, tryStates) {
    for (var i = 0; i < tryStates.length; i++) {
      var tryState = tryStates[i];
      if (tryState.kind === kind) {
        for (var j = 0; j < tryState.tryStates.length; j++) {
          var id = tryState.tryStates[j];
          enclosingMap[id] = tryState;
        }
      }
      addCatchOrFinallyStates(kind, enclosingMap, tryState.nestedTrys);
    }
  }
  function addAllCatchStates(tryStates, catches) {
    for (var i = 0; i < tryStates.length; i++) {
      var tryState = tryStates[i];
      if (tryState.kind === TryState.Kind.CATCH) {
        catches.push(tryState);
      }
      addAllCatchStates(tryState.nestedTrys, catches);
    }
  }
  var StateMachine = function($__super) {
    function StateMachine(startState, fallThroughState, states, exceptionBlocks) {
      $traceurRuntime.superConstructor(StateMachine).call(this, null);
      this.startState = startState;
      this.fallThroughState = fallThroughState;
      this.states = states;
      this.exceptionBlocks = exceptionBlocks;
    }
    return ($traceurRuntime.createClass)(StateMachine, {
      get type() {
        return STATE_MACHINE;
      },
      transform: function(transformer) {
        return transformer.transformStateMachine(this);
      },
      visit: function(visitor) {
        visitor.visitStateMachine(this);
      },
      getAllStateIDs: function() {
        var result = [];
        for (var i = 0; i < this.states.length; i++) {
          result.push(this.states[i].id);
        }
        return result;
      },
      getEnclosingFinallyMap: function() {
        var enclosingMap = Object.create(null);
        addCatchOrFinallyStates(TryState.Kind.FINALLY, enclosingMap, this.exceptionBlocks);
        return enclosingMap;
      },
      allCatchStates: function() {
        var catches = [];
        addAllCatchStates(this.exceptionBlocks, catches);
        return catches;
      },
      replaceStateId: function(oldState, newState) {
        return new StateMachine(State.replaceStateId(this.startState, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), State.replaceAllStates(this.states, oldState, newState), State.replaceAllStates(this.exceptionBlocks, oldState, newState));
      },
      replaceStartState: function(newState) {
        return this.replaceStateId(this.startState, newState);
      },
      replaceFallThroughState: function(newState) {
        return this.replaceStateId(this.fallThroughState, newState);
      },
      append: function(nextMachine) {
        var states = $traceurRuntime.spread(this.states);
        for (var i = 0; i < nextMachine.states.length; i++) {
          var otherState = nextMachine.states[i];
          states.push(otherState.replaceState(nextMachine.startState, this.fallThroughState));
        }
        var exceptionBlocks = $traceurRuntime.spread(this.exceptionBlocks);
        for (var i$__1 = 0; i$__1 < nextMachine.exceptionBlocks.length; i$__1++) {
          var tryState = nextMachine.exceptionBlocks[i$__1];
          exceptionBlocks.push(tryState.replaceState(nextMachine.startState, this.fallThroughState));
        }
        return new StateMachine(this.startState, nextMachine.fallThroughState, states, exceptionBlocks);
      }
    }, {}, $__super);
  }(ParseTree);
  return {get StateMachine() {
      return StateMachine;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/BreakContinueTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/BreakContinueTransformer.js";
  var BreakState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./BreakState.js", "traceur@0.0.112/src/codegeneration/generator/BreakContinueTransformer.js")).BreakState;
  var ContinueState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ContinueState.js", "traceur@0.0.112/src/codegeneration/generator/BreakContinueTransformer.js")).ContinueState;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/generator/BreakContinueTransformer.js")).ParseTreeTransformer;
  var StateMachine = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/StateMachine.js", "traceur@0.0.112/src/codegeneration/generator/BreakContinueTransformer.js")).StateMachine;
  function safeGetLabel(tree) {
    return tree.name ? tree.name.value : null;
  }
  var BreakContinueTransformer = function($__super) {
    function BreakContinueTransformer(stateAllocator) {
      $traceurRuntime.superConstructor(BreakContinueTransformer).call(this);
      this.transformBreaks_ = true;
      this.stateAllocator_ = stateAllocator;
    }
    return ($traceurRuntime.createClass)(BreakContinueTransformer, {
      allocateState_: function() {
        return this.stateAllocator_.allocateState();
      },
      stateToStateMachine_: function(newState) {
        var fallThroughState = this.allocateState_();
        return new StateMachine(newState.id, fallThroughState, [newState], []);
      },
      transformBreakStatement: function(tree) {
        return this.transformBreaks_ || tree.name ? this.stateToStateMachine_(new BreakState(this.allocateState_(), safeGetLabel(tree))) : tree;
      },
      transformContinueStatement: function(tree) {
        return this.stateToStateMachine_(new ContinueState(this.allocateState_(), safeGetLabel(tree)));
      },
      transformDoWhileStatement: function(tree) {
        return tree;
      },
      transformForOfStatement: function(tree) {
        return tree;
      },
      transformForOnStatement: function(tree) {
        return tree;
      },
      transformForStatement: function(tree) {
        return tree;
      },
      transformFunctionDeclaration: function(tree) {
        return tree;
      },
      transformFunctionExpression: function(tree) {
        return tree;
      },
      transformStateMachine: function(tree) {
        return tree;
      },
      transformSwitchStatement: function(tree) {
        var oldState = this.transformBreaks_;
        this.transformBreaks_ = false;
        var result = $traceurRuntime.superGet(this, BreakContinueTransformer.prototype, "transformSwitchStatement").call(this, tree);
        this.transformBreaks_ = oldState;
        return result;
      },
      transformWhileStatement: function(tree) {
        return tree;
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get BreakContinueTransformer() {
      return BreakContinueTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/CatchState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/CatchState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/CatchState.js")).State;
  var TryState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TryState.js", "traceur@0.0.112/src/codegeneration/generator/CatchState.js")).TryState;
  var CatchState = function($__super) {
    function CatchState(identifier, catchState, fallThroughState, allStates, nestedTrys) {
      $traceurRuntime.superConstructor(CatchState).call(this, TryState.Kind.CATCH, allStates, nestedTrys);
      this.identifier = identifier;
      this.catchState = catchState;
      this.fallThroughState = fallThroughState;
    }
    return ($traceurRuntime.createClass)(CatchState, {replaceState: function(oldState, newState) {
        return new CatchState(this.identifier, State.replaceStateId(this.catchState, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.replaceAllStates(oldState, newState), this.replaceNestedTrys(oldState, newState));
      }}, {}, $__super);
  }(TryState);
  return {get CatchState() {
      return CatchState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/ConditionalState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/ConditionalState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/ConditionalState.js")).State;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/ConditionalState.js")),
      createBlock = $__2.createBlock,
      createIfStatement = $__2.createIfStatement;
  var parseStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/generator/ConditionalState.js")).parseStatements;
  var ConditionalState = function($__super) {
    function ConditionalState(id, ifState, elseState, condition) {
      $traceurRuntime.superConstructor(ConditionalState).call(this, id);
      this.ifState = ifState;
      this.elseState = elseState;
      this.condition = condition;
    }
    return ($traceurRuntime.createClass)(ConditionalState, {
      replaceState: function(oldState, newState) {
        return new ConditionalState(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.ifState, oldState, newState), State.replaceStateId(this.elseState, oldState, newState), this.condition);
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        if (State.isFinallyExit(enclosingFinally, this.ifState) || State.isFinallyExit(enclosingFinally, this.elseState)) {
          return [createIfStatement(this.condition, createBlock(State.generateJump(enclosingFinally, this.ifState)), createBlock(State.generateJump(enclosingFinally, this.elseState)))];
        }
        return parseStatements($traceurRuntime.getTemplateObject(["$ctx.state = (", ") ? ", " : ", ";\n        break"]), this.condition, this.ifState, this.elseState);
      }
    }, {}, $__super);
  }(State);
  return {get ConditionalState() {
      return ConditionalState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/FinallyFallThroughState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/FinallyFallThroughState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/FinallyFallThroughState.js")).State;
  var FinallyFallThroughState = function($__super) {
    function FinallyFallThroughState() {
      $traceurRuntime.superConstructor(FinallyFallThroughState).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(FinallyFallThroughState, {
      replaceState: function(oldState, newState) {
        return new FinallyFallThroughState(State.replaceStateId(this.id, oldState, newState));
      },
      transformMachineState: function(enclosingFinally, machineEndState, reporter) {
        return null;
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        throw new Error('these are generated in addFinallyFallThroughDispatches');
      }
    }, {}, $__super);
  }(State);
  return {get FinallyFallThroughState() {
      return FinallyFallThroughState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/FinallyState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/FinallyState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/FinallyState.js")).State;
  var TryState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TryState.js", "traceur@0.0.112/src/codegeneration/generator/FinallyState.js")).TryState;
  var FinallyState = function($__super) {
    function FinallyState(finallyState, fallThroughState, allStates, nestedTrys) {
      $traceurRuntime.superConstructor(FinallyState).call(this, TryState.Kind.FINALLY, allStates, nestedTrys);
      this.finallyState = finallyState;
      this.fallThroughState = fallThroughState;
    }
    return ($traceurRuntime.createClass)(FinallyState, {replaceState: function(oldState, newState) {
        return new FinallyState(State.replaceStateId(this.finallyState, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.replaceAllStates(oldState, newState), this.replaceNestedTrys(oldState, newState));
      }}, {}, $__super);
  }(TryState);
  return {get FinallyState() {
      return FinallyState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/StateAllocator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/StateAllocator.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/StateAllocator.js")).State;
  var StateAllocator = function() {
    function StateAllocator() {
      this.nextState_ = State.START_STATE + 1;
    }
    return ($traceurRuntime.createClass)(StateAllocator, {allocateState: function() {
        return this.nextState_++;
      }}, {});
  }();
  return {get StateAllocator() {
      return StateAllocator;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/SwitchState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/SwitchState.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/generator/SwitchState.js")),
      CaseClause = $__2.CaseClause,
      DefaultClause = $__2.DefaultClause,
      SwitchStatement = $__2.SwitchStatement;
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/SwitchState.js")).State;
  var createBreakStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/SwitchState.js")).createBreakStatement;
  var SwitchClause = function() {
    function SwitchClause(first, second) {
      this.first = first;
      this.second = second;
    }
    return ($traceurRuntime.createClass)(SwitchClause, {}, {});
  }();
  var SwitchState = function($__super) {
    function SwitchState(id, expression, clauses) {
      $traceurRuntime.superConstructor(SwitchState).call(this, id);
      this.expression = expression;
      this.clauses = clauses;
    }
    return ($traceurRuntime.createClass)(SwitchState, {
      replaceState: function(oldState, newState) {
        var clauses = this.clauses.map(function(clause) {
          return new SwitchClause(clause.first, State.replaceStateId(clause.second, oldState, newState));
        });
        return new SwitchState(State.replaceStateId(this.id, oldState, newState), this.expression, clauses);
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        var clauses = [];
        for (var i = 0; i < this.clauses.length; i++) {
          var clause = this.clauses[i];
          if (clause.first === null) {
            clauses.push(new DefaultClause(null, State.generateJump(enclosingFinally, clause.second)));
          } else {
            clauses.push(new CaseClause(null, clause.first, State.generateJump(enclosingFinally, clause.second)));
          }
        }
        return [new SwitchStatement(null, this.expression, clauses), createBreakStatement()];
      }
    }, {}, $__super);
  }(State);
  return {
    get SwitchClause() {
      return SwitchClause;
    },
    get SwitchState() {
      return SwitchState;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js")),
      AnonBlock = $__1.AnonBlock,
      Catch = $__1.Catch,
      FunctionBody = $__1.FunctionBody,
      ForInStatement = $__1.ForInStatement,
      ForOfStatement = $__1.ForOfStatement,
      ForStatement = $__1.ForStatement,
      VariableDeclarationList = $__1.VariableDeclarationList,
      VariableStatement = $__1.VariableStatement;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js")),
      OBJECT_PATTERN = $__2.OBJECT_PATTERN,
      VARIABLE_DECLARATION_LIST = $__2.VARIABLE_DECLARATION_LIST;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js")).ParseTreeTransformer;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js")).StringSet;
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js")).VAR;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js")),
      createAssignmentExpression = $__6.createAssignmentExpression,
      createCommaExpression = $__6.createCommaExpression,
      createExpressionStatement = $__6.createExpressionStatement,
      id = $__6.createIdentifierExpression,
      createParenExpression = $__6.createParenExpression,
      createVariableDeclaration = $__6.createVariableDeclaration;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/HoistVariablesTransformer.js")).prependStatements;
  var HoistVariablesTransformer = function($__super) {
    function HoistVariablesTransformer() {
      var shouldHoistFunctions = arguments[0] !== (void 0) ? arguments[0] : false;
      $traceurRuntime.superConstructor(HoistVariablesTransformer).call(this);
      this.hoistedFunctions_ = [];
      this.hoistedVariables_ = new StringSet();
      this.keepBindingIdentifiers_ = false;
      this.inBlockOrFor_ = false;
      this.shouldHoistFunctions_ = shouldHoistFunctions;
    }
    return ($traceurRuntime.createClass)(HoistVariablesTransformer, {
      transformFunctionBody: function(tree) {
        var statements = this.transformList(tree.statements);
        if (statements === tree.statements)
          return tree;
        statements = this.prependVariables(statements);
        statements = this.prependFunctions(statements);
        return new FunctionBody(tree.location, statements);
      },
      addVariable: function(name) {
        this.hoistedVariables_.add(name);
      },
      addFunctionDeclaration: function(tree) {
        this.hoistedFunctions_.push(tree);
      },
      hasVariables: function() {
        return !this.hoistedVariables_.isEmpty();
      },
      hasFunctions: function() {
        return this.hoistedFunctions_.length > 0;
      },
      getVariableNames: function() {
        return this.hoistedVariables_.valuesAsArray();
      },
      getVariableStatement: function() {
        if (!this.hasVariables())
          return new AnonBlock(null, []);
        var declarations = this.getVariableNames().map(function(name) {
          return createVariableDeclaration(name, null);
        });
        return new VariableStatement(null, new VariableDeclarationList(null, VAR, declarations));
      },
      getFunctions: function() {
        return this.hoistedFunctions_;
      },
      prependVariables: function(statements) {
        if (!this.hasVariables())
          return statements;
        return prependStatements(statements, this.getVariableStatement());
      },
      prependFunctions: function(statements) {
        if (!this.hasFunctions())
          return statements;
        return prependStatements(statements, this.getFunctionDeclarations());
      },
      transformVariableStatement: function(tree) {
        var declarations = this.transformAny(tree.declarations);
        if (declarations === tree.declarations)
          return tree;
        if (declarations === null)
          return new AnonBlock(null, []);
        if (declarations.type === VARIABLE_DECLARATION_LIST)
          return new VariableStatement(tree.location, declarations);
        return createExpressionStatement(declarations);
      },
      transformVariableDeclaration: function(tree) {
        var lvalue = this.transformAny(tree.lvalue);
        var initializer = this.transformAny(tree.initializer);
        if (initializer) {
          var expression = createAssignmentExpression(lvalue, initializer);
          if (lvalue.type === OBJECT_PATTERN)
            expression = createParenExpression(expression);
          return expression;
        }
        return null;
      },
      transformObjectPattern: function(tree) {
        var keepBindingIdentifiers = this.keepBindingIdentifiers_;
        this.keepBindingIdentifiers_ = true;
        var transformed = $traceurRuntime.superGet(this, HoistVariablesTransformer.prototype, "transformObjectPattern").call(this, tree);
        this.keepBindingIdentifiers_ = keepBindingIdentifiers;
        return transformed;
      },
      transformArrayPattern: function(tree) {
        var keepBindingIdentifiers = this.keepBindingIdentifiers_;
        this.keepBindingIdentifiers_ = true;
        var transformed = $traceurRuntime.superGet(this, HoistVariablesTransformer.prototype, "transformArrayPattern").call(this, tree);
        this.keepBindingIdentifiers_ = keepBindingIdentifiers;
        return transformed;
      },
      transformBindingIdentifier: function(tree) {
        var idToken = tree.identifierToken;
        this.addVariable(idToken.value);
        if (this.keepBindingIdentifiers_)
          return tree;
        return id(idToken);
      },
      transformVariableDeclarationList: function(tree) {
        if (tree.declarationType === VAR || !this.inBlockOrFor_) {
          var expressions = this.transformList(tree.declarations);
          expressions = expressions.filter(function(tree) {
            return tree;
          });
          if (expressions.length === 0)
            return null;
          if (expressions.length === 1)
            return expressions[0];
          return createCommaExpression(expressions);
        }
        return tree;
      },
      transformCatch: function(tree) {
        var catchBody = this.transformAny(tree.catchBody);
        if (catchBody === tree.catchBody)
          return tree;
        return new Catch(tree.location, tree.binding, catchBody);
      },
      transformForInStatement: function(tree) {
        return this.transformLoop_(tree, ForInStatement);
      },
      transformForOfStatement: function(tree) {
        return this.transformLoop_(tree, ForOfStatement);
      },
      transformForOnStatement: function(tree) {
        return this.transformLoop_(tree, ForOfStatement);
      },
      transformLoop_: function(tree, ctor) {
        var initializer = this.transformLoopIninitaliser_(tree.initializer);
        var collection = this.transformAny(tree.collection);
        var body = this.transformAny(tree.body);
        if (initializer === tree.initializer && collection === tree.collection && body === tree.body) {
          return tree;
        }
        return new ctor(tree.location, initializer, collection, body);
      },
      transformLoopIninitaliser_: function(tree) {
        if (tree.type !== VARIABLE_DECLARATION_LIST || tree.declarationType !== VAR)
          return tree;
        return this.transformAny(tree.declarations[0].lvalue);
      },
      transformForStatement: function(tree) {
        var inBlockOrFor = this.inBlockOrFor_;
        this.inBlockOrFor_ = true;
        var initializer = this.transformAny(tree.initializer);
        this.inBlockOrFor_ = inBlockOrFor;
        var condition = this.transformAny(tree.condition);
        var increment = this.transformAny(tree.increment);
        var body = this.transformAny(tree.body);
        if (initializer === tree.initializer && condition === tree.condition && increment === tree.increment && body === tree.body) {
          return tree;
        }
        return new ForStatement(tree.location, initializer, condition, increment, body);
      },
      transformBlock: function(tree) {
        var inBlockOrFor = this.inBlockOrFor_;
        this.inBlockOrFor_ = true;
        tree = $traceurRuntime.superGet(this, HoistVariablesTransformer.prototype, "transformBlock").call(this, tree);
        this.inBlockOrFor_ = inBlockOrFor;
        return tree;
      },
      addMachineVariable: function(name) {
        this.machineVariables_[name] = true;
      },
      transformClassDeclaration: function(tree) {
        return tree;
      },
      transformClassExpression: function(tree) {
        return tree;
      },
      transformFunctionDeclaration: function(tree) {
        if (this.shouldHoistFunctions_) {
          this.addFunctionDeclaration(tree);
          return new AnonBlock(null, []);
        }
        return tree;
      },
      transformFunctionExpression: function(tree) {
        return tree;
      },
      transformGetAccessor: function(tree) {
        return tree;
      },
      transformSetAccessor: function(tree) {
        return tree;
      },
      transformMethod: function(tree) {
        return tree;
      },
      transformArrowFunction: function(tree) {
        return tree;
      },
      transformComprehensionFor: function(tree) {
        return tree;
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  var $__default = HoistVariablesTransformer;
  return {get default() {
      return $__default;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js";
  var AlphaRenamer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../AlphaRenamer.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).AlphaRenamer;
  var BreakContinueTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./BreakContinueTransformer.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).BreakContinueTransformer;
  var $__19 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")),
      BLOCK = $__19.BLOCK,
      CASE_CLAUSE = $__19.CASE_CLAUSE,
      CONDITIONAL_EXPRESSION = $__19.CONDITIONAL_EXPRESSION,
      EXPRESSION_STATEMENT = $__19.EXPRESSION_STATEMENT,
      PAREN_EXPRESSION = $__19.PAREN_EXPRESSION,
      STATE_MACHINE = $__19.STATE_MACHINE;
  var $__20 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")),
      AnonBlock = $__20.AnonBlock,
      Block = $__20.Block,
      CaseClause = $__20.CaseClause,
      IfStatement = $__20.IfStatement,
      SwitchStatement = $__20.SwitchStatement;
  var CatchState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./CatchState.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).CatchState;
  var ConditionalState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ConditionalState.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).ConditionalState;
  var ExplodeExpressionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ExplodeExpressionTransformer.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).ExplodeExpressionTransformer;
  var FallThroughState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FallThroughState.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).FallThroughState;
  var FinallyFallThroughState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FinallyFallThroughState.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).FinallyFallThroughState;
  var FinallyState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FinallyState.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).FinallyState;
  var FindInFunctionScope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../FindInFunctionScope.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).FindInFunctionScope;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).ParseTreeTransformer;
  var StringMap = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../util/StringMap.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).StringMap;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).TempVarTransformer;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../util/assert.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).assert;
  var $__32 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")),
      parseExpression = $__32.parseExpression,
      parseStatement = $__32.parseStatement,
      parseStatements = $__32.parseStatements;
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).State;
  var StateAllocator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./StateAllocator.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).StateAllocator;
  var StateMachine = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/StateMachine.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).StateMachine;
  var $__36 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SwitchState.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")),
      SwitchClause = $__36.SwitchClause,
      SwitchState = $__36.SwitchState;
  var TryState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TryState.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).TryState;
  var $__38 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")),
      createAssignStateStatement = $__38.createAssignStateStatement,
      createBreakStatement = $__38.createBreakStatement,
      createCaseClause = $__38.createCaseClause,
      createDefaultClause = $__38.createDefaultClause,
      createExpressionStatement = $__38.createExpressionStatement,
      createFunctionBody = $__38.createFunctionBody,
      id = $__38.createIdentifierExpression,
      createMemberExpression = $__38.createMemberExpression,
      createNumberLiteral = $__38.createNumberLiteral,
      createSwitchStatement = $__38.createSwitchStatement;
  var HoistVariablesTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../HoistVariablesTransformer.js", "traceur@0.0.112/src/codegeneration/generator/CPSTransformer.js")).default;
  var LabelState = function() {
    function LabelState(name, continueState, fallThroughState) {
      this.name = name;
      this.continueState = continueState;
      this.fallThroughState = fallThroughState;
    }
    return ($traceurRuntime.createClass)(LabelState, {}, {});
  }();
  var NeedsStateMachine = function($__super) {
    function NeedsStateMachine() {
      $traceurRuntime.superConstructor(NeedsStateMachine).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(NeedsStateMachine, {
      visitBreakStatement: function(tree) {
        this.found = true;
      },
      visitContinueStatement: function(tree) {
        this.found = true;
      },
      visitStateMachine: function(tree) {
        this.found = true;
      },
      visitYieldExpression: function(tee) {
        this.found = true;
      }
    }, {}, $__super);
  }(FindInFunctionScope);
  function needsStateMachine(tree) {
    var visitor = new NeedsStateMachine();
    visitor.visitAny(tree);
    return visitor.found;
  }
  var HoistVariables = function($__super) {
    function HoistVariables() {
      $traceurRuntime.superConstructor(HoistVariables).call(this, true);
    }
    return ($traceurRuntime.createClass)(HoistVariables, {
      prependVariables: function(statements) {
        return statements;
      },
      prependFunctions: function(statements) {
        return statements;
      }
    }, {}, $__super);
  }(HoistVariablesTransformer);
  var CPSTransformer = function($__super) {
    function CPSTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(CPSTransformer).call(this, identifierGenerator, reporter, options);
      this.stateAllocator_ = new StateAllocator();
      this.labelSet_ = new StringMap();
      this.currentLabel_ = null;
      this.hoistVariablesTransformer_ = new HoistVariables();
    }
    return ($traceurRuntime.createClass)(CPSTransformer, {
      expressionNeedsStateMachine: function(tree) {
        return false;
      },
      allocateState: function() {
        return this.stateAllocator_.allocateState();
      },
      transformBlock: function(tree) {
        var labels = this.getLabels_();
        var label = this.clearCurrentLabel_();
        var transformedTree = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformBlock").call(this, tree);
        var machine = this.transformStatementList_(transformedTree.statements);
        if (machine === null)
          return transformedTree;
        if (label) {
          var states = [];
          for (var i = 0; i < machine.states.length; i++) {
            var state = machine.states[i];
            states.push(state.transformBreakOrContinue(labels));
          }
          machine = new StateMachine(machine.startState, machine.fallThroughState, states, machine.exceptionBlocks);
        }
        return machine;
      },
      transformFunctionBody: function(tree) {
        this.pushTempScope();
        var oldLabels = this.clearLabels_();
        var transformedTree = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformFunctionBody").call(this, tree);
        var machine = this.transformStatementList_(transformedTree.statements);
        this.restoreLabels_(oldLabels);
        this.popTempScope();
        return machine === null ? transformedTree : machine;
      },
      transformStatementList_: function(trees) {
        var groups = [];
        var newMachine;
        for (var i = 0; i < trees.length; i++) {
          if (trees[i].type === STATE_MACHINE) {
            groups.push(trees[i]);
          } else if (needsStateMachine(trees[i])) {
            newMachine = this.ensureTransformed_(trees[i]);
            groups.push(newMachine);
          } else {
            var last = groups[groups.length - 1];
            if (!(last instanceof Array))
              groups.push(last = []);
            last.push(trees[i]);
          }
        }
        if (groups.length === 1 && groups[0] instanceof Array)
          return null;
        var machine = null;
        for (var i$__11 = 0; i$__11 < groups.length; i$__11++) {
          if (groups[i$__11] instanceof Array) {
            newMachine = this.statementsToStateMachine_(groups[i$__11]);
          } else {
            newMachine = groups[i$__11];
          }
          if (i$__11 === 0)
            machine = newMachine;
          else
            machine = machine.append(newMachine);
        }
        return machine;
      },
      needsStateMachine_: function(statements) {
        if (statements instanceof Array) {
          for (var i = 0; i < statements.length; i++) {
            if (needsStateMachine(statements[i]))
              return true;
          }
          return false;
        }
        assert(statements instanceof SwitchStatement);
        return needsStateMachine(statements);
      },
      transformCaseClause: function(tree) {
        var result = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformCaseClause").call(this, tree);
        var machine = this.transformStatementList_(result.statements);
        return machine === null ? result : new CaseClause(null, result.expression, [machine]);
      },
      transformDoWhileStatement: function(tree) {
        var $__8;
        var $__6,
            $__7;
        var labels = this.getLabels_();
        var label = this.clearCurrentLabel_();
        var machine,
            condition,
            body;
        if (this.expressionNeedsStateMachine(tree.condition)) {
          (($__6 = this.expressionToStateMachine(tree.condition), machine = $__6.machine, condition = $__6.expression, $__6));
          body = this.transformAny(tree.body);
        } else {
          var result = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformDoWhileStatement").call(this, tree);
          (($__7 = result, condition = $__7.condition, body = $__7.body, $__7));
          if (body.type !== STATE_MACHINE)
            return result;
        }
        var loopBodyMachine = this.ensureTransformed_(body);
        var startState = loopBodyMachine.startState;
        var conditionState = loopBodyMachine.fallThroughState;
        var fallThroughState = this.allocateState();
        var states = [];
        this.addLoopBodyStates_(loopBodyMachine, conditionState, fallThroughState, labels, states);
        if (machine) {
          machine = machine.replaceStartState(conditionState);
          conditionState = machine.fallThroughState;
          ($__8 = states).push.apply($__8, $traceurRuntime.spread(machine.states));
        }
        states.push(new ConditionalState(conditionState, startState, fallThroughState, condition));
        machine = new StateMachine(startState, fallThroughState, states, loopBodyMachine.exceptionBlocks);
        if (label)
          machine = machine.replaceStateId(conditionState, label.continueState);
        return machine;
      },
      addLoopBodyStates_: function(loopBodyMachine, continueState, breakState, labels, states) {
        for (var i = 0; i < loopBodyMachine.states.length; i++) {
          var state = loopBodyMachine.states[i];
          states.push(state.transformBreakOrContinue(labels, breakState, continueState));
        }
      },
      transformForStatement: function(tree) {
        var $__8,
            $__9,
            $__10;
        var labels = this.getLabels_();
        var label = this.clearCurrentLabel_();
        var tmp;
        var initializer = null,
            initializerMachine;
        if (tree.initializer) {
          if (this.expressionNeedsStateMachine(tree.initializer)) {
            tmp = this.expressionToStateMachine(tree.initializer);
            initializer = tmp.expression;
            initializerMachine = tmp.machine;
          } else {
            initializer = this.transformAny(tree.initializer);
          }
        }
        var condition = null,
            conditionMachine;
        if (tree.condition) {
          if (this.expressionNeedsStateMachine(tree.condition)) {
            tmp = this.expressionToStateMachine(tree.condition);
            condition = tmp.expression;
            conditionMachine = tmp.machine;
          } else {
            condition = this.transformAny(tree.condition);
          }
        }
        var increment = null,
            incrementMachine;
        if (tree.increment) {
          if (this.expressionNeedsStateMachine(tree.increment)) {
            tmp = this.expressionToStateMachine(tree.increment);
            increment = tmp.expression;
            incrementMachine = tmp.machine;
          } else {
            increment = this.transformAny(tree.increment);
          }
        }
        var body = this.transformAny(tree.body);
        if (initializer === tree.initializer && condition === tree.condition && increment === tree.increment && body === tree.body) {
          return tree;
        }
        if (!initializerMachine && !conditionMachine && !incrementMachine && body.type !== STATE_MACHINE) {
          return new ForStatement(tree.location, initializer, condition, increment, body);
        }
        var loopBodyMachine = this.ensureTransformed_(body);
        var bodyFallThroughId = loopBodyMachine.fallThroughState;
        var fallThroughId = this.allocateState();
        var startId;
        var initializerStartId = initializer ? this.allocateState() : State.INVALID_STATE;
        var conditionStartId = increment ? this.allocateState() : bodyFallThroughId;
        var loopStartId = loopBodyMachine.startState;
        var incrementStartId = bodyFallThroughId;
        var states = [];
        if (initializer) {
          startId = initializerStartId;
          var initialiserFallThroughId;
          if (condition)
            initialiserFallThroughId = conditionStartId;
          else
            initialiserFallThroughId = loopStartId;
          var tmpId = initializerStartId;
          if (initializerMachine) {
            initializerMachine = initializerMachine.replaceStartState(initializerStartId);
            tmpId = initializerMachine.fallThroughState;
            ($__8 = states).push.apply($__8, $traceurRuntime.spread(initializerMachine.states));
          }
          states.push(new FallThroughState(tmpId, initialiserFallThroughId, [createExpressionStatement(initializer)]));
        }
        if (condition) {
          if (!initializer)
            startId = conditionStartId;
          var tmpId$__12 = conditionStartId;
          if (conditionMachine) {
            conditionMachine = conditionMachine.replaceStartState(conditionStartId);
            tmpId$__12 = conditionMachine.fallThroughState;
            ($__9 = states).push.apply($__9, $traceurRuntime.spread(conditionMachine.states));
          }
          states.push(new ConditionalState(tmpId$__12, loopStartId, fallThroughId, condition));
        }
        if (increment) {
          var incrementFallThroughId;
          if (condition)
            incrementFallThroughId = conditionStartId;
          else
            incrementFallThroughId = loopStartId;
          var tmpId$__13 = incrementStartId;
          if (incrementMachine) {
            incrementMachine = incrementMachine.replaceStartState(incrementStartId);
            tmpId$__13 = incrementMachine.fallThroughState;
            ($__10 = states).push.apply($__10, $traceurRuntime.spread(incrementMachine.states));
          }
          states.push(new FallThroughState(tmpId$__13, incrementFallThroughId, [createExpressionStatement(increment)]));
        }
        if (!initializer && !condition)
          startId = loopStartId;
        var continueId;
        if (increment)
          continueId = incrementStartId;
        else if (condition)
          continueId = conditionStartId;
        else
          continueId = loopStartId;
        if (!increment && !condition) {
          loopBodyMachine = loopBodyMachine.replaceFallThroughState(loopBodyMachine.startState);
        }
        this.addLoopBodyStates_(loopBodyMachine, continueId, fallThroughId, labels, states);
        var machine = new StateMachine(startId, fallThroughId, states, loopBodyMachine.exceptionBlocks);
        if (label)
          machine = machine.replaceStateId(continueId, label.continueState);
        return machine;
      },
      transformForInStatement: function(tree) {
        return tree;
      },
      transformForOfStatement: function(tree) {
        throw new Error('for of statements should be transformed before this pass');
      },
      transformIfStatement: function(tree) {
        var $__8,
            $__9,
            $__10;
        var $__6,
            $__7;
        var machine,
            condition,
            ifClause,
            elseClause;
        if (this.expressionNeedsStateMachine(tree.condition)) {
          (($__6 = this.expressionToStateMachine(tree.condition), machine = $__6.machine, condition = $__6.expression, $__6));
          ifClause = this.transformAny(tree.ifClause);
          elseClause = this.transformAny(tree.elseClause);
        } else {
          var result = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformIfStatement").call(this, tree);
          (($__7 = result, condition = $__7.condition, ifClause = $__7.ifClause, elseClause = $__7.elseClause, $__7));
          if (ifClause.type !== STATE_MACHINE && (elseClause === null || elseClause.type !== STATE_MACHINE)) {
            return result;
          }
        }
        ifClause = this.ensureTransformed_(ifClause);
        elseClause = this.ensureTransformed_(elseClause);
        var startState = this.allocateState();
        var fallThroughState = ifClause.fallThroughState;
        var ifState = ifClause.startState;
        var elseState = elseClause === null ? fallThroughState : elseClause.startState;
        var states = [];
        var exceptionBlocks = [];
        states.push(new ConditionalState(startState, ifState, elseState, condition));
        ($__8 = states).push.apply($__8, $traceurRuntime.spread(ifClause.states));
        ($__9 = exceptionBlocks).push.apply($__9, $traceurRuntime.spread(ifClause.exceptionBlocks));
        if (elseClause !== null) {
          this.replaceAndAddStates_(elseClause.states, elseClause.fallThroughState, fallThroughState, states);
          ($__10 = exceptionBlocks).push.apply($__10, $traceurRuntime.spread(State.replaceAllStates(elseClause.exceptionBlocks, elseClause.fallThroughState, fallThroughState)));
        }
        var ifMachine = new StateMachine(startState, fallThroughState, states, exceptionBlocks);
        if (machine)
          ifMachine = machine.append(ifMachine);
        return ifMachine;
      },
      removeEmptyStates: function(oldStates) {
        var emptyStates = [],
            newStates = [];
        for (var i = 0; i < oldStates.length; i++) {
          if (oldStates[i] instanceof FallThroughState && oldStates[i].statements.length === 0) {
            emptyStates.push(oldStates[i]);
          } else {
            newStates.push(oldStates[i]);
          }
        }
        for (var i$__14 = 0; i$__14 < newStates.length; i$__14++) {
          newStates[i$__14] = emptyStates.reduce(function(state, $__6) {
            var $__7 = $__6,
                id = $__7.id,
                fallThroughState = $__7.fallThroughState;
            return state.replaceState(id, fallThroughState);
          }, newStates[i$__14]);
        }
        return newStates;
      },
      replaceAndAddStates_: function(oldStates, oldState, newState, newStates) {
        for (var i = 0; i < oldStates.length; i++) {
          newStates.push(oldStates[i].replaceState(oldState, newState));
        }
      },
      transformLabelledStatement: function(tree) {
        var startState = this.allocateState();
        var continueState = this.allocateState();
        var fallThroughState = this.allocateState();
        var label = new LabelState(tree.name.value, continueState, fallThroughState);
        var oldLabels = this.addLabel_(label);
        this.currentLabel_ = label;
        var result = this.transformAny(tree.statement);
        if (result === tree.statement) {
          result = tree;
        } else if (result.type === STATE_MACHINE) {
          result = result.replaceStartState(startState);
          result = result.replaceFallThroughState(fallThroughState);
        }
        this.restoreLabels_(oldLabels);
        return result;
      },
      getLabels_: function() {
        return this.labelSet_;
      },
      restoreLabels_: function(oldLabels) {
        this.labelSet_ = oldLabels;
      },
      addLabel_: function(label) {
        var $__5 = this;
        var oldLabels = this.labelSet_;
        var labelSet = new StringMap();
        this.labelSet_.forEach(function(k) {
          return labelSet[k] = $__5.labelSet_[k];
        });
        labelSet.set(label.name, label);
        this.labelSet_ = labelSet;
        return oldLabels;
      },
      clearLabels_: function() {
        var result = this.labelSet_;
        this.labelSet_ = new StringMap();
        return result;
      },
      clearCurrentLabel_: function() {
        var result = this.currentLabel_;
        this.currentLabel_ = null;
        return result;
      },
      transformSwitchStatement: function(tree) {
        var $__6,
            $__7;
        var labels = this.getLabels_();
        var expression,
            machine,
            caseClauses;
        if (this.expressionNeedsStateMachine(tree.expression)) {
          (($__6 = this.expressionToStateMachine(tree.expression), expression = $__6.expression, machine = $__6.machine, $__6));
          caseClauses = this.transformList(tree.caseClauses);
        } else {
          var result = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformSwitchStatement").call(this, tree);
          if (!needsStateMachine(result))
            return result;
          (($__7 = result, expression = $__7.expression, caseClauses = $__7.caseClauses, $__7));
        }
        var startState = this.allocateState();
        var fallThroughState = this.allocateState();
        var nextState = fallThroughState;
        var states = [];
        var clauses = [];
        var tryStates = [];
        var hasDefault = false;
        for (var index = caseClauses.length - 1; index >= 0; index--) {
          var clause = caseClauses[index];
          if (clause.type === CASE_CLAUSE) {
            var caseClause = clause;
            nextState = this.addSwitchClauseStates_(nextState, fallThroughState, labels, caseClause.statements, states, tryStates);
            clauses.push(new SwitchClause(caseClause.expression, nextState));
          } else {
            hasDefault = true;
            var defaultClause = clause;
            nextState = this.addSwitchClauseStates_(nextState, fallThroughState, labels, defaultClause.statements, states, tryStates);
            clauses.push(new SwitchClause(null, nextState));
          }
        }
        if (!hasDefault) {
          clauses.push(new SwitchClause(null, fallThroughState));
        }
        states.push(new SwitchState(startState, expression, clauses.reverse()));
        var switchMachine = new StateMachine(startState, fallThroughState, states.reverse(), tryStates);
        if (machine)
          switchMachine = machine.append(switchMachine);
        return switchMachine;
      },
      addSwitchClauseStates_: function(nextState, fallThroughState, labels, statements, states, tryStates) {
        var $__8;
        var machine = this.ensureTransformedList_(statements);
        for (var i = 0; i < machine.states.length; i++) {
          var state = machine.states[i];
          var transformedState = state.transformBreak(labels, fallThroughState);
          states.push(transformedState.replaceState(machine.fallThroughState, nextState));
        }
        ($__8 = tryStates).push.apply($__8, $traceurRuntime.spread(machine.exceptionBlocks));
        return machine.startState;
      },
      transformTryStatement: function(tree) {
        var result = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformTryStatement").call(this, tree);
        var $__6 = result,
            body = $__6.body,
            catchBlock = $__6.catchBlock,
            finallyBlock = $__6.finallyBlock;
        if (body.type !== STATE_MACHINE && (catchBlock === null || catchBlock.catchBody.type !== STATE_MACHINE) && (finallyBlock === null || finallyBlock.block.type !== STATE_MACHINE)) {
          return result;
        }
        var outerCatchState = this.allocateState();
        var outerFinallyState = this.allocateState();
        var pushTryState = this.statementToStateMachine_(parseStatement($traceurRuntime.getTemplateObject(["$ctx.pushTry(\n            ", ",\n            ", ");"]), (catchBlock && outerCatchState), (finallyBlock && outerFinallyState)));
        var tryMachine = this.ensureTransformed_(body);
        tryMachine = pushTryState.append(tryMachine);
        if (catchBlock !== null) {
          var popTry = this.statementToStateMachine_(parseStatement($traceurRuntime.getTemplateObject(["$ctx.popTry();"])));
          tryMachine = tryMachine.append(popTry);
          var exceptionName = catchBlock.binding.identifierToken.value;
          var catchMachine = this.ensureTransformed_(catchBlock.catchBody);
          var catchStart = this.allocateState();
          this.addMachineVariable(exceptionName);
          var states = $traceurRuntime.spread(tryMachine.states, [new FallThroughState(catchStart, catchMachine.startState, parseStatements($traceurRuntime.getTemplateObject(["\n              $ctx.popTry();\n              $ctx.maybeUncatchable(); // see RETURN_SENTINEL in runtime\n              ", " = $ctx.storedException;"]), id(exceptionName)))]);
          this.replaceAndAddStates_(catchMachine.states, catchMachine.fallThroughState, tryMachine.fallThroughState, states);
          tryMachine = new StateMachine(tryMachine.startState, tryMachine.fallThroughState, states, [new CatchState(exceptionName, catchStart, tryMachine.fallThroughState, tryMachine.getAllStateIDs(), tryMachine.exceptionBlocks)]);
          tryMachine = tryMachine.replaceStateId(catchStart, outerCatchState);
        }
        if (finallyBlock !== null) {
          var finallyMachine = this.ensureTransformed_(finallyBlock.block);
          var popTry$__15 = this.statementToStateMachine_(parseStatement($traceurRuntime.getTemplateObject(["$ctx.popTry();"])));
          finallyMachine = popTry$__15.append(finallyMachine);
          var states$__16 = $traceurRuntime.spread(tryMachine.states, finallyMachine.states, [new FinallyFallThroughState(finallyMachine.fallThroughState)]);
          tryMachine = new StateMachine(tryMachine.startState, tryMachine.fallThroughState, states$__16, [new FinallyState(finallyMachine.startState, finallyMachine.fallThroughState, tryMachine.getAllStateIDs(), tryMachine.exceptionBlocks)]);
          tryMachine = tryMachine.replaceStateId(finallyMachine.startState, outerFinallyState);
        }
        return tryMachine;
      },
      transformWhileStatement: function(tree) {
        var $__8;
        var $__6,
            $__7;
        var labels = this.getLabels_();
        var label = this.clearCurrentLabel_();
        var condition,
            machine,
            body;
        if (this.expressionNeedsStateMachine(tree.condition)) {
          (($__6 = this.expressionToStateMachine(tree.condition), machine = $__6.machine, condition = $__6.expression, $__6));
          body = this.transformAny(tree.body);
        } else {
          var result = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformWhileStatement").call(this, tree);
          (($__7 = result, condition = $__7.condition, body = $__7.body, $__7));
          if (body.type !== STATE_MACHINE)
            return result;
        }
        var loopBodyMachine = this.ensureTransformed_(body);
        var startState = loopBodyMachine.fallThroughState;
        var fallThroughState = this.allocateState();
        var states = [];
        var conditionStart = startState;
        if (machine) {
          machine = machine.replaceStartState(startState);
          conditionStart = machine.fallThroughState;
          ($__8 = states).push.apply($__8, $traceurRuntime.spread(machine.states));
        }
        states.push(new ConditionalState(conditionStart, loopBodyMachine.startState, fallThroughState, condition));
        this.addLoopBodyStates_(loopBodyMachine, startState, fallThroughState, labels, states);
        machine = new StateMachine(startState, fallThroughState, states, loopBodyMachine.exceptionBlocks);
        if (label)
          machine = machine.replaceStateId(startState, label.continueState);
        return machine;
      },
      transformWithStatement: function(tree) {
        var result = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformWithStatement").call(this, tree);
        if (result.body.type !== STATE_MACHINE) {
          return result;
        }
        throw new Error('Unreachable - with statement not allowed in strict mode/harmony');
      },
      generateMachineInnerFunction: function(machine) {
        var enclosingFinallyState = machine.getEnclosingFinallyMap();
        var SwitchStatement = createSwitchStatement(createMemberExpression('$ctx', 'state'), this.transformMachineStates(machine, State.END_STATE, State.RETHROW_STATE, enclosingFinallyState));
        return parseExpression($traceurRuntime.getTemplateObject(["function($ctx) {\n      while (true) ", "\n    }"]), SwitchStatement);
      },
      addTempVar: function() {
        var name = this.getTempIdentifier();
        this.addMachineVariable(name);
        return name;
      },
      addMachineVariable: function(name) {
        this.hoistVariablesTransformer_.addVariable(name);
      },
      transformCpsFunctionBody: function(tree, runtimeMethod) {
        var $__8;
        var functionRef = arguments[2];
        var alphaRenamedTree = AlphaRenamer.rename(tree, 'arguments', '$arguments');
        var hasArguments = alphaRenamedTree !== tree;
        var hoistedTree = this.hoistVariablesTransformer_.transformAny(alphaRenamedTree);
        var maybeMachine = this.transformAny(hoistedTree);
        if (this.reporter.hadError())
          return tree;
        var machine;
        if (maybeMachine.type !== STATE_MACHINE) {
          machine = this.statementsToStateMachine_(maybeMachine.statements);
        } else {
          machine = new StateMachine(maybeMachine.startState, maybeMachine.fallThroughState, this.removeEmptyStates(maybeMachine.states), maybeMachine.exceptionBlocks);
        }
        machine = machine.replaceFallThroughState(State.END_STATE).replaceStartState(State.START_STATE);
        var statements = [];
        if (this.hoistVariablesTransformer_.hasFunctions())
          ($__8 = statements).push.apply($__8, $traceurRuntime.spread(this.hoistVariablesTransformer_.getFunctions()));
        if (this.hoistVariablesTransformer_.hasVariables())
          statements.push(this.hoistVariablesTransformer_.getVariableStatement());
        if (hasArguments)
          statements.push(parseStatement($traceurRuntime.getTemplateObject(["var $arguments = arguments;"])));
        if (functionRef) {
          statements.push(parseStatement($traceurRuntime.getTemplateObject(["return ", "(\n              ", ",\n              ", ", this);"]), runtimeMethod, this.generateMachineInnerFunction(machine), functionRef));
        } else {
          statements.push(parseStatement($traceurRuntime.getTemplateObject(["return ", "(\n              ", ", this);"]), runtimeMethod, this.generateMachineInnerFunction(machine)));
        }
        return createFunctionBody(statements);
      },
      transformFunctionDeclaration: function(tree) {
        return tree;
      },
      transformFunctionExpression: function(tree) {
        return tree;
      },
      transformGetAccessor: function(tree) {
        return tree;
      },
      transformSetAccessor: function(tree) {
        return tree;
      },
      transformArrowFunction: function(tree) {
        return tree;
      },
      transformStateMachine: function(tree) {
        return tree;
      },
      statementToStateMachine_: function(statement) {
        var statements;
        if (statement.type === BLOCK)
          statements = statement.statements;
        else
          statements = [statement];
        return this.statementsToStateMachine_(statements);
      },
      statementsToStateMachine_: function(statements) {
        var startState = this.allocateState();
        var fallThroughState = this.allocateState();
        return this.stateToStateMachine_(new FallThroughState(startState, fallThroughState, statements), fallThroughState);
      },
      stateToStateMachine_: function(newState, fallThroughState) {
        return new StateMachine(newState.id, fallThroughState, [newState], []);
      },
      transformMachineStates: function(machine, machineEndState, rethrowState, enclosingFinallyState) {
        var cases = [];
        for (var i = 0; i < machine.states.length; i++) {
          var state = machine.states[i];
          var stateCase = state.transformMachineState(enclosingFinallyState[state.id], machineEndState, this.reporter);
          if (stateCase !== null) {
            cases.push(stateCase);
          }
        }
        this.addFinallyFallThroughDispatches(null, machine.exceptionBlocks, cases);
        cases.push(createDefaultClause(parseStatements($traceurRuntime.getTemplateObject(["return $ctx.end()"]))));
        return cases;
      },
      addFinallyFallThroughDispatches: function(enclosingFinallyState, tryStates, cases) {
        for (var i = 0; i < tryStates.length; i++) {
          var tryState = tryStates[i];
          if (tryState.kind === TryState.Kind.FINALLY) {
            var finallyState = tryState;
            if (enclosingFinallyState !== null) {
              var caseClauses = [];
              var index = 0;
              for (var j = 0; j < enclosingFinallyState.tryStates.length; j++) {
                var destination = enclosingFinallyState.tryStates[j];
                index++;
                var statements = void 0;
                if (index < enclosingFinallyState.tryStates.length) {
                  statements = [];
                } else {
                  statements = parseStatements($traceurRuntime.getTemplateObject(["\n                  $ctx.state = $ctx.finallyFallThrough;\n                  $ctx.finallyFallThrough = ", ";\n                  break;"]), State.INVALID_STATE);
                }
                caseClauses.push(createCaseClause(createNumberLiteral(destination), statements));
              }
              caseClauses.push(createDefaultClause([createAssignStateStatement(enclosingFinallyState.finallyState), createBreakStatement()]));
              cases.push(createCaseClause(createNumberLiteral(finallyState.fallThroughState), [createSwitchStatement(createMemberExpression('$ctx', 'finallyFallThrough'), caseClauses), createBreakStatement()]));
            } else {
              cases.push(createCaseClause(createNumberLiteral(finallyState.fallThroughState), parseStatements($traceurRuntime.getTemplateObject(["\n                      $ctx.state = $ctx.finallyFallThrough;\n                      break;"]))));
            }
            this.addFinallyFallThroughDispatches(finallyState, finallyState.nestedTrys, cases);
          } else {
            this.addFinallyFallThroughDispatches(enclosingFinallyState, tryState.nestedTrys, cases);
          }
        }
      },
      transformVariableDeclarationList: function(tree) {
        this.reporter.reportError(tree.location, 'Traceur: const/let declarations in a block containing a yield are ' + 'not yet implemented');
        return tree;
      },
      maybeTransformStatement_: function(maybeTransformedStatement) {
        var breakContinueTransformed = new BreakContinueTransformer(this.stateAllocator_).transformAny(maybeTransformedStatement);
        if (breakContinueTransformed !== maybeTransformedStatement) {
          breakContinueTransformed = this.transformAny(breakContinueTransformed);
        }
        return breakContinueTransformed;
      },
      ensureTransformed_: function(statement) {
        if (statement === null) {
          return null;
        }
        var maybeTransformed = this.maybeTransformStatement_(statement);
        return maybeTransformed.type === STATE_MACHINE ? maybeTransformed : this.statementToStateMachine_(maybeTransformed);
      },
      ensureTransformedList_: function(statements) {
        var maybeTransformedStatements = [];
        var foundMachine = false;
        for (var i = 0; i < statements.length; i++) {
          var statement = statements[i];
          var maybeTransformedStatement = this.maybeTransformStatement_(statement);
          maybeTransformedStatements.push(maybeTransformedStatement);
          if (maybeTransformedStatement.type === STATE_MACHINE) {
            foundMachine = true;
          }
        }
        if (!foundMachine) {
          return this.statementsToStateMachine_(statements);
        }
        return this.transformStatementList_(maybeTransformedStatements);
      },
      expressionToStateMachine: function(tree) {
        var commaExpression = new ExplodeExpressionTransformer(this).transformAny(tree);
        var statements = new NormalizeCommaExpressionToStatementTransformer().transformAny(commaExpression).statements;
        var lastStatement = statements.pop();
        assert(lastStatement.type === EXPRESSION_STATEMENT);
        var expression = lastStatement.expression;
        statements = $traceurRuntime.superGet(this, CPSTransformer.prototype, "transformList").call(this, statements);
        var machine = this.transformStatementList_(statements);
        return {
          expression: expression,
          machine: machine
        };
      }
    }, {}, $__super);
  }(TempVarTransformer);
  var NormalizeCommaExpressionToStatementTransformer = function($__super) {
    function NormalizeCommaExpressionToStatementTransformer() {
      $traceurRuntime.superConstructor(NormalizeCommaExpressionToStatementTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(NormalizeCommaExpressionToStatementTransformer, {
      transformCommaExpression: function(tree) {
        var $__5 = this;
        var statements = tree.expressions.map(function(expr) {
          if (expr.type === CONDITIONAL_EXPRESSION)
            return $__5.transformAny(expr);
          return createExpressionStatement(expr);
        });
        return new AnonBlock(tree.location, statements);
      },
      transformConditionalExpression: function(tree) {
        var ifBlock = this.transformAny(tree.left);
        var elseBlock = this.transformAny(tree.right);
        return new IfStatement(tree.location, tree.condition, anonBlockToBlock(ifBlock), anonBlockToBlock(elseBlock));
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  function anonBlockToBlock(tree) {
    if (tree.type === PAREN_EXPRESSION)
      return anonBlockToBlock(tree.expression);
    return new Block(tree.location, tree.statements);
  }
  return {get CPSTransformer() {
      return CPSTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/EndState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/EndState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/EndState.js")).State;
  var EndState = function($__super) {
    function EndState() {
      $traceurRuntime.superConstructor(EndState).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(EndState, {
      replaceState: function(oldState, newState) {
        return new EndState(State.replaceStateId(this.id, oldState, newState));
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        return State.generateJump(enclosingFinally, machineEndState);
      }
    }, {}, $__super);
  }(State);
  return {get EndState() {
      return EndState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js";
  var AwaitState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AwaitState.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).AwaitState;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")),
      BinaryExpression = $__4.BinaryExpression,
      ExpressionStatement = $__4.ExpressionStatement;
  var CPSTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./CPSTransformer.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).CPSTransformer;
  var EndState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./EndState.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).EndState;
  var FallThroughState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FallThroughState.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).FallThroughState;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).default;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")),
      AWAIT_EXPRESSION = $__9.AWAIT_EXPRESSION,
      BINARY_EXPRESSION = $__9.BINARY_EXPRESSION,
      STATE_MACHINE = $__9.STATE_MACHINE;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")),
      parseExpression = $__10.parseExpression,
      parseStatement = $__10.parseStatement,
      parseStatements = $__10.parseStatements;
  var StateMachine = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/StateMachine.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).StateMachine;
  var FindInFunctionScope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../FindInFunctionScope.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).FindInFunctionScope;
  var createUndefinedExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/AsyncTransformer.js")).createUndefinedExpression;
  function isAwaitAssign(tree) {
    return tree.type === BINARY_EXPRESSION && tree.operator.isAssignmentOperator() && tree.right.type === AWAIT_EXPRESSION && tree.left.isLeftHandSideExpression();
  }
  var AwaitFinder = function($__super) {
    function AwaitFinder() {
      $traceurRuntime.superConstructor(AwaitFinder).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(AwaitFinder, {visitAwaitExpression: function(tree) {
        this.found = true;
      }}, {}, $__super);
  }(FindInFunctionScope);
  function scopeContainsAwait(tree) {
    var visitor = new AwaitFinder();
    visitor.visitAny(tree);
    return visitor.found;
  }
  var AsyncTransformer = function($__super) {
    function AsyncTransformer() {
      $traceurRuntime.superConstructor(AsyncTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(AsyncTransformer, {
      expressionNeedsStateMachine: function(tree) {
        if (tree === null)
          return false;
        return scopeContainsAwait(tree);
      },
      transformExpressionStatement: function(tree) {
        var expression = tree.expression;
        if (expression.type === AWAIT_EXPRESSION)
          return this.transformAwaitExpression_(expression);
        if (isAwaitAssign(expression))
          return this.transformAwaitAssign_(expression);
        if (this.expressionNeedsStateMachine(expression)) {
          return this.expressionToStateMachine(expression).machine;
        }
        return $traceurRuntime.superGet(this, AsyncTransformer.prototype, "transformExpressionStatement").call(this, tree);
      },
      transformAwaitExpression: function(tree) {
        throw new Error('Internal error');
      },
      transformAwaitExpression_: function(tree) {
        return this.transformAwait_(tree, tree.expression, null, null);
      },
      transformAwaitAssign_: function(tree) {
        return this.transformAwait_(tree, tree.right.expression, tree.left, tree.operator);
      },
      transformAwait_: function(tree, inExpression, left, operator) {
        var $__2;
        var expression,
            machine;
        if (this.expressionNeedsStateMachine(inExpression)) {
          (($__2 = this.expressionToStateMachine(inExpression), expression = $__2.expression, machine = $__2.machine, $__2));
        } else {
          expression = this.transformAny(inExpression);
        }
        var createTaskState = this.allocateState();
        var fallThroughState = this.allocateState();
        var callbackState = left ? this.allocateState() : fallThroughState;
        var states = [];
        states.push(new AwaitState(createTaskState, callbackState, expression));
        if (left) {
          var statement = new ExpressionStatement(tree.location, new BinaryExpression(tree.location, left, operator, parseExpression($traceurRuntime.getTemplateObject(["$ctx.value"]))));
          states.push(new FallThroughState(callbackState, fallThroughState, [statement]));
        }
        var awaitMachine = new StateMachine(createTaskState, fallThroughState, states, []);
        if (machine) {
          awaitMachine = machine.append(awaitMachine);
        }
        return awaitMachine;
      },
      transformFinally: function(tree) {
        var result = $traceurRuntime.superGet(this, AsyncTransformer.prototype, "transformFinally").call(this, tree);
        if (result.block.type !== STATE_MACHINE) {
          return result;
        }
        this.reporter.reportError(tree.location, 'await not permitted within a finally block.');
        return result;
      },
      transformReturnStatement: function(tree) {
        var $__2;
        var expression,
            machine;
        if (this.expressionNeedsStateMachine(tree.expression)) {
          (($__2 = this.expressionToStateMachine(tree.expression), expression = $__2.expression, machine = $__2.machine, $__2));
        } else {
          expression = tree.expression || createUndefinedExpression();
        }
        var startState = this.allocateState();
        var endState = this.allocateState();
        var completeState = new FallThroughState(startState, endState, parseStatements($traceurRuntime.getTemplateObject(["$ctx.returnValue = ", ""]), expression));
        var end = new EndState(endState);
        var returnMachine = new StateMachine(startState, this.allocateState(), [completeState, end], []);
        if (machine)
          returnMachine = machine.append(returnMachine);
        return returnMachine;
      },
      createCompleteTask_: function(result) {
        return parseStatement($traceurRuntime.getTemplateObject(["$ctx.resolve(", ")"]), result);
      },
      transformAsyncBody: function(tree) {
        var asyncWrap = this.getRuntimeExpression('asyncWrap');
        return this.transformCpsFunctionBody(tree, asyncWrap);
      }
    }, {transformAsyncBody: function(identifierGenerator, reporter, options, body) {
        return new AsyncTransformer(identifierGenerator, reporter, options).transformAsyncBody(body);
      }}, $__super);
  }(ImportRuntimeTrait(CPSTransformer));
  ;
  return {get AsyncTransformer() {
      return AsyncTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/ForInTransformPass.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/ForInTransformPass.js";
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/generator/ForInTransformPass.js")),
      BLOCK = $__3.BLOCK,
      VARIABLE_DECLARATION_LIST = $__3.VARIABLE_DECLARATION_LIST,
      IDENTIFIER_EXPRESSION = $__3.IDENTIFIER_EXPRESSION;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/generator/ForInTransformPass.js")),
      LENGTH = $__4.LENGTH,
      PUSH = $__4.PUSH;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/generator/ForInTransformPass.js")).TempVarTransformer;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/generator/ForInTransformPass.js")),
      BANG = $__6.BANG,
      IN = $__6.IN,
      OPEN_ANGLE = $__6.OPEN_ANGLE,
      PLUS_PLUS = $__6.PLUS_PLUS,
      VAR = $__6.VAR;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/ForInTransformPass.js")),
      createArgumentList = $__7.createArgumentList,
      createAssignmentStatement = $__7.createAssignmentStatement,
      createBinaryExpression = $__7.createBinaryExpression,
      createBlock = $__7.createBlock,
      createCallStatement = $__7.createCallStatement,
      createContinueStatement = $__7.createContinueStatement,
      createEmptyArrayLiteral = $__7.createEmptyArrayLiteral,
      createForInStatement = $__7.createForInStatement,
      createForStatement = $__7.createForStatement,
      createIdentifierExpression = $__7.createIdentifierExpression,
      createIfStatement = $__7.createIfStatement,
      createMemberExpression = $__7.createMemberExpression,
      createMemberLookupExpression = $__7.createMemberLookupExpression,
      createNumberLiteral = $__7.createNumberLiteral,
      createOperatorToken = $__7.createOperatorToken,
      createParenExpression = $__7.createParenExpression,
      createPostfixExpression = $__7.createPostfixExpression,
      createUnaryExpression = $__7.createUnaryExpression,
      createVariableDeclarationList = $__7.createVariableDeclarationList,
      createVariableStatement = $__7.createVariableStatement;
  var ForInTransformPass = function($__super) {
    function ForInTransformPass() {
      $traceurRuntime.superConstructor(ForInTransformPass).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ForInTransformPass, {transformForInStatement: function(tree) {
        var $__1,
            $__2;
        var bodyStatements = [];
        var body = this.transformAny(tree.body);
        if (body.type === BLOCK) {
          ($__1 = bodyStatements).push.apply($__1, $traceurRuntime.spread(body.statements));
        } else {
          bodyStatements.push(body);
        }
        var elements = [];
        var keys = this.getTempIdentifier();
        elements.push(createVariableStatement(VAR, keys, createEmptyArrayLiteral()));
        var collection = this.getTempIdentifier();
        elements.push(createVariableStatement(VAR, collection, tree.collection));
        var p = this.getTempIdentifier();
        elements.push(createForInStatement(createVariableDeclarationList(VAR, p, null), createIdentifierExpression(collection), createCallStatement(createMemberExpression(keys, PUSH), createArgumentList([createIdentifierExpression(p)]))));
        var i = this.getTempIdentifier();
        var lookup = createMemberLookupExpression(createIdentifierExpression(keys), createIdentifierExpression(i));
        var originalKey,
            assignOriginalKey;
        if (tree.initializer.type === VARIABLE_DECLARATION_LIST) {
          var decList = tree.initializer;
          originalKey = createIdentifierExpression(decList.declarations[0].lvalue);
          assignOriginalKey = createVariableStatement(decList.declarationType, originalKey.identifierToken, lookup);
        } else if (tree.initializer.type === IDENTIFIER_EXPRESSION) {
          originalKey = tree.initializer;
          assignOriginalKey = createAssignmentStatement(tree.initializer, lookup);
        } else {
          throw new Error('Invalid left hand side of for in loop');
        }
        var innerBlock = [];
        innerBlock.push(assignOriginalKey);
        innerBlock.push(createIfStatement(createUnaryExpression(createOperatorToken(BANG), createParenExpression(createBinaryExpression(originalKey, createOperatorToken(IN), createIdentifierExpression(collection)))), createContinueStatement(), null));
        ($__2 = innerBlock).push.apply($__2, $traceurRuntime.spread(bodyStatements));
        elements.push(createForStatement(createVariableDeclarationList(VAR, i, createNumberLiteral(0)), createBinaryExpression(createIdentifierExpression(i), createOperatorToken(OPEN_ANGLE), createMemberExpression(keys, LENGTH)), createPostfixExpression(createIdentifierExpression(i), createOperatorToken(PLUS_PLUS)), createBlock(innerBlock)));
        return createBlock(elements);
      }}, {}, $__super);
  }(TempVarTransformer);
  return {get ForInTransformPass() {
      return ForInTransformPass;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/YieldState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/YieldState.js";
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/YieldState.js")).State;
  var createReturnStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/YieldState.js")).createReturnStatement;
  var YieldState = function($__super) {
    function YieldState(id, fallThroughState, expression) {
      $traceurRuntime.superConstructor(YieldState).call(this, id);
      this.fallThroughState = fallThroughState;
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(YieldState, {
      replaceState: function(oldState, newState) {
        return new this.constructor(State.replaceStateId(this.id, oldState, newState), State.replaceStateId(this.fallThroughState, oldState, newState), this.expression);
      },
      transform: function(enclosingFinally, machineEndState, reporter) {
        return $traceurRuntime.spread(State.generateAssignState(enclosingFinally, this.fallThroughState), [createReturnStatement(this.expression)]);
      }
    }, {}, $__super);
  }(State);
  return {get YieldState() {
      return YieldState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/ReturnState.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/ReturnState.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../semantics/util.js", "traceur@0.0.112/src/codegeneration/generator/ReturnState.js")),
      isUndefined = $__2.isUndefined,
      isVoidExpression = $__2.isVoidExpression;
  var YieldState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./YieldState.js", "traceur@0.0.112/src/codegeneration/generator/ReturnState.js")).YieldState;
  var State = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./State.js", "traceur@0.0.112/src/codegeneration/generator/ReturnState.js")).State;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/generator/ReturnState.js")).parseStatement;
  var ReturnState = function($__super) {
    function ReturnState() {
      $traceurRuntime.superConstructor(ReturnState).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ReturnState, {transform: function(enclosingFinally, machineEndState, reporter) {
        var $__1;
        var e = this.expression;
        var statements = [];
        if (e && !isUndefined(e) && !isVoidExpression(e))
          statements.push(parseStatement($traceurRuntime.getTemplateObject(["$ctx.returnValue = ", ""]), this.expression));
        ($__1 = statements).push.apply($__1, $traceurRuntime.spread(State.generateJump(enclosingFinally, machineEndState)));
        return statements;
      }}, {}, $__super);
  }(YieldState);
  return {get ReturnState() {
      return ReturnState;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js";
  var CPSTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./CPSTransformer.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")).CPSTransformer;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")),
      BINARY_EXPRESSION = $__4.BINARY_EXPRESSION,
      YIELD_EXPRESSION = $__4.YIELD_EXPRESSION;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")),
      BinaryExpression = $__5.BinaryExpression,
      ExpressionStatement = $__5.ExpressionStatement;
  var FindInFunctionScope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../FindInFunctionScope.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")).FindInFunctionScope;
  var ReturnState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ReturnState.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")).ReturnState;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")).default;
  var YieldState = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./YieldState.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")).YieldState;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")),
      id = $__10.createIdentifierExpression,
      createMemberExpression = $__10.createMemberExpression,
      createUndefinedExpression = $__10.createUndefinedExpression;
  var $__11 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/generator/GeneratorTransformer.js")),
      parseExpression = $__11.parseExpression,
      parseStatement = $__11.parseStatement,
      parseStatements = $__11.parseStatements;
  function isYieldAssign(tree) {
    return tree.type === BINARY_EXPRESSION && tree.operator.isAssignmentOperator() && tree.right.type === YIELD_EXPRESSION && tree.left.isLeftHandSideExpression();
  }
  var YieldFinder = function($__super) {
    function YieldFinder() {
      $traceurRuntime.superConstructor(YieldFinder).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(YieldFinder, {visitYieldExpression: function(tree) {
        this.found = true;
      }}, {}, $__super);
  }(FindInFunctionScope);
  function scopeContainsYield(tree) {
    var finder = new YieldFinder();
    finder.visitAny(tree);
    return finder.found;
  }
  var GeneratorTransformer = function($__super) {
    function GeneratorTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(GeneratorTransformer).call(this, identifierGenerator, reporter, options);
      this.shouldAppendThrowCloseState_ = true;
    }
    return ($traceurRuntime.createClass)(GeneratorTransformer, {
      expressionNeedsStateMachine: function(tree) {
        if (tree === null)
          return false;
        return scopeContainsYield(tree);
      },
      transformYieldExpression_: function(tree) {
        var $__2;
        var expression,
            machine;
        if (this.expressionNeedsStateMachine(tree.expression)) {
          (($__2 = this.expressionToStateMachine(tree.expression), expression = $__2.expression, machine = $__2.machine, $__2));
        } else {
          expression = this.transformAny(tree.expression);
        }
        if (tree.isYieldFor)
          return this.transformYieldForExpression_(expression, machine);
        var startState = this.allocateState();
        var fallThroughState = this.allocateState();
        var yieldMachine = this.stateToStateMachine_(new YieldState(startState, fallThroughState, expression), fallThroughState);
        if (machine)
          yieldMachine = machine.append(yieldMachine);
        if (this.shouldAppendThrowCloseState_)
          yieldMachine = yieldMachine.append(this.createThrowCloseState_());
        return yieldMachine;
      },
      transformYieldForExpression_: function(expression) {
        var machine = arguments[1];
        var gName = this.getTempIdentifier();
        this.addMachineVariable(gName);
        var g = id(gName);
        var nextName = this.getTempIdentifier();
        this.addMachineVariable(nextName);
        var next = id(nextName);
        var statements = parseStatements($traceurRuntime.getTemplateObject(["\n        ", " = $ctx.wrapYieldStar(", "[Symbol.iterator]());\n        // received = void 0;\n        $ctx.sent = void 0;\n        // send = true; // roughly equivalent\n        $ctx.action = 'next';\n\n        for (;;) {\n          ", " = ", "[$ctx.action]($ctx.sentIgnoreThrow);\n          if (", ".done) {\n            $ctx.sent = ", ".value;\n            break;\n          }\n          yield ", ".value;\n        }"]), g, expression, next, g, next, next, next);
        var shouldAppendThrowCloseState = this.shouldAppendThrowCloseState_;
        this.shouldAppendThrowCloseState_ = false;
        statements = this.transformList(statements);
        var yieldMachine = this.transformStatementList_(statements);
        this.shouldAppendThrowCloseState_ = shouldAppendThrowCloseState;
        if (machine)
          yieldMachine = machine.append(yieldMachine);
        return yieldMachine;
      },
      transformYieldExpression: function(tree) {
        this.reporter.reportError(tree.location, 'Only \'a = yield b\' and \'var a = yield b\' currently supported.');
        return tree;
      },
      transformYieldAssign_: function(tree) {
        var shouldAppendThrowCloseState = this.shouldAppendThrowCloseState_;
        this.shouldAppendThrowCloseState_ = false;
        var machine = this.transformYieldExpression_(tree.right);
        var left = this.transformAny(tree.left);
        var sentExpression = tree.right.isYieldFor ? parseExpression($traceurRuntime.getTemplateObject(["$ctx.sentIgnoreThrow"])) : parseExpression($traceurRuntime.getTemplateObject(["$ctx.sent"]));
        var statement = new ExpressionStatement(tree.location, new BinaryExpression(tree.location, left, tree.operator, sentExpression));
        var assignMachine = this.statementToStateMachine_(statement);
        this.shouldAppendThrowCloseState_ = shouldAppendThrowCloseState;
        return machine.append(assignMachine);
      },
      createThrowCloseState_: function() {
        return this.statementToStateMachine_(parseStatement($traceurRuntime.getTemplateObject(["$ctx.maybeThrow()"])));
      },
      transformExpressionStatement: function(tree) {
        var expression = tree.expression;
        if (expression.type === YIELD_EXPRESSION)
          return this.transformYieldExpression_(expression);
        if (isYieldAssign(expression))
          return this.transformYieldAssign_(expression);
        if (this.expressionNeedsStateMachine(expression)) {
          return this.expressionToStateMachine(expression).machine;
        }
        return $traceurRuntime.superGet(this, GeneratorTransformer.prototype, "transformExpressionStatement").call(this, tree);
      },
      transformAwaitStatement: function(tree) {
        this.reporter.reportError(tree.location, 'Generator function may not have an await statement.');
        return tree;
      },
      transformReturnStatement: function(tree) {
        var $__2;
        var expression,
            machine;
        if (this.expressionNeedsStateMachine(tree.expression))
          (($__2 = this.expressionToStateMachine(tree.expression), expression = $__2.expression, machine = $__2.machine, $__2));
        else
          expression = tree.expression;
        var startState = this.allocateState();
        var fallThroughState = this.allocateState();
        var returnMachine = this.stateToStateMachine_(new ReturnState(startState, fallThroughState, this.transformAny(expression)), fallThroughState);
        if (machine)
          return machine.append(returnMachine);
        return returnMachine;
      },
      transformGeneratorBody: function(tree, name) {
        var createGeneratorInstance = this.getRuntimeExpression('createGeneratorInstance');
        return this.transformCpsFunctionBody(tree, createGeneratorInstance, name);
      }
    }, {transformGeneratorBody: function(identifierGenerator, reporter, options, body, name) {
        return new GeneratorTransformer(identifierGenerator, reporter, options).transformGeneratorBody(body, name);
      }}, $__super);
  }(ImportRuntimeTrait(CPSTransformer));
  ;
  return {get GeneratorTransformer() {
      return GeneratorTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js";
  var ArrowFunctionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ArrowFunctionTransformer.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")).ArrowFunctionTransformer;
  var AsyncTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./generator/AsyncTransformer.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")).AsyncTransformer;
  var ForInTransformPass = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./generator/ForInTransformPass.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")).ForInTransformPass;
  var GeneratorTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./generator/GeneratorTransformer.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")).GeneratorTransformer;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")),
      parseExpression = $__8.parseExpression,
      parseStatement = $__8.parseStatement;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")).TempVarTransformer;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")).default;
  var FindInFunctionScope = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindInFunctionScope.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")).FindInFunctionScope;
  var $__12 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")),
      AnonBlock = $__12.AnonBlock,
      FunctionDeclaration = $__12.FunctionDeclaration,
      FunctionExpression = $__12.FunctionExpression;
  var $__13 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/GeneratorTransformPass.js")),
      createBindingIdentifier = $__13.createBindingIdentifier,
      id = $__13.createIdentifierExpression,
      createIdentifierToken = $__13.createIdentifierToken;
  var ForInFinder = function($__super) {
    function ForInFinder() {
      $traceurRuntime.superConstructor(ForInFinder).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ForInFinder, {visitForInStatement: function(tree) {
        this.found = true;
      }}, {}, $__super);
  }(FindInFunctionScope);
  function needsTransform(tree, transformOptions) {
    return transformOptions.generators && tree.isGenerator() || transformOptions.asyncFunctions && tree.isAsyncFunction();
  }
  var GeneratorTransformPass = function($__super) {
    function GeneratorTransformPass(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(GeneratorTransformPass).call(this, identifierGenerator, reporter, options);
      this.tranformOptions_ = options.transformOptions;
      this.inBlock_ = false;
    }
    return ($traceurRuntime.createClass)(GeneratorTransformPass, {
      transformFunctionDeclaration: function(tree) {
        if (!needsTransform(tree, this.tranformOptions_))
          return $traceurRuntime.superGet(this, GeneratorTransformPass.prototype, "transformFunctionDeclaration").call(this, tree);
        if (tree.isGenerator())
          return this.transformGeneratorDeclaration_(tree);
        return this.transformFunction_(tree, FunctionDeclaration, null);
      },
      transformGeneratorDeclaration_: function(tree) {
        var nameIdExpression = id(tree.name.identifierToken);
        var initGeneratorFunction = this.getRuntimeExpression('initGeneratorFunction');
        var setupPrototypeExpression = parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), initGeneratorFunction, nameIdExpression);
        var tmpVar = id(this.inBlock_ ? this.getTempIdentifier() : this.addTempVar(setupPrototypeExpression));
        var funcDecl = this.transformFunction_(tree, FunctionDeclaration, tmpVar);
        if (!this.inBlock_)
          return funcDecl;
        return new AnonBlock(null, [funcDecl, parseStatement($traceurRuntime.getTemplateObject(["var ", " = ", ""]), tmpVar, setupPrototypeExpression)]);
      },
      transformFunctionExpression: function(tree) {
        if (!needsTransform(tree, this.tranformOptions_))
          return $traceurRuntime.superGet(this, GeneratorTransformPass.prototype, "transformFunctionExpression").call(this, tree);
        if (tree.isGenerator())
          return this.transformGeneratorExpression_(tree);
        return this.transformFunction_(tree, FunctionExpression, null);
      },
      transformGeneratorExpression_: function(tree) {
        var name;
        if (!tree.name) {
          name = createIdentifierToken(this.getTempIdentifier());
          tree = new FunctionExpression(tree.location, createBindingIdentifier(name), tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.body);
        } else {
          name = tree.name.identifierToken;
        }
        var functionExpression = this.transformFunction_(tree, FunctionExpression, id(name));
        var initGeneratorFunction = this.getRuntimeExpression('initGeneratorFunction');
        return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), initGeneratorFunction, functionExpression);
      },
      transformFunction_: function(tree, constructor, nameExpression) {
        var $__2 = this;
        var body = $traceurRuntime.superGet(this, GeneratorTransformPass.prototype, "transformAny").call(this, tree.body);
        var finder = new ForInFinder();
        finder.visitAny(body);
        if (finder.found) {
          body = new ForInTransformPass(this.identifierGenerator, this.reporter, this.options).transformAny(body);
        }
        if (this.tranformOptions_.generators && tree.isGenerator()) {
          var transformer = new GeneratorTransformer(this.identifierGenerator, this.reporter, this.options);
          body = transformer.transformGeneratorBody(body, nameExpression);
          transformer.requiredNames.forEach(function(n) {
            $__2.addImportedName(n);
          });
        } else if (this.tranformOptions_.asyncFunctions && tree.isAsyncFunction()) {
          var transformer$__3 = new AsyncTransformer(this.identifierGenerator, this.reporter, this.options);
          body = transformer$__3.transformAsyncBody(body, nameExpression);
          transformer$__3.requiredNames.forEach(function(n) {
            $__2.addImportedName(n);
          });
        }
        var functionKind = null;
        return new constructor(tree.location, tree.name, functionKind, tree.parameterList, tree.typeAnnotation || null, tree.annotations || null, body);
      },
      transformArrowFunction: function(tree) {
        if (!tree.isAsyncFunction())
          return $traceurRuntime.superGet(this, GeneratorTransformPass.prototype, "transformArrowFunction").call(this, tree);
        return this.transformAny(ArrowFunctionTransformer.transform(this, tree));
      },
      transformBlock: function(tree) {
        var inBlock = this.inBlock_;
        this.inBlock_ = true;
        var rv = $traceurRuntime.superGet(this, GeneratorTransformPass.prototype, "transformBlock").call(this, tree);
        this.inBlock_ = inBlock;
        return rv;
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  return {get GeneratorTransformPass() {
      return GeneratorTransformPass;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/InlineModuleTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/InlineModuleTransformer.js";
  var VAR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/InlineModuleTransformer.js")).VAR;
  var ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/InlineModuleTransformer.js")).ModuleTransformer;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/InlineModuleTransformer.js")),
      createBindingIdentifier = $__3.createBindingIdentifier,
      createEmptyStatement = $__3.createEmptyStatement,
      createFunctionBody = $__3.createFunctionBody,
      createImmediatelyInvokedFunctionExpression = $__3.createImmediatelyInvokedFunctionExpression,
      createVariableStatement = $__3.createVariableStatement;
  var anonInlineModules = 0;
  var InlineModuleTransformer = function($__super) {
    function InlineModuleTransformer() {
      $traceurRuntime.superConstructor(InlineModuleTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(InlineModuleTransformer, {
      wrapModule: function(statements) {
        var seed = this.moduleName || 'anon_' + ++anonInlineModules;
        var idName = this.getTempVarNameForModuleName(seed);
        var body = createFunctionBody(statements);
        var moduleExpression = createImmediatelyInvokedFunctionExpression(body);
        return [createVariableStatement(VAR, idName, moduleExpression)];
      },
      transformNamedExport: function(tree) {
        return createEmptyStatement();
      },
      transformModuleSpecifier: function(tree) {
        return createBindingIdentifier(this.getTempVarNameForModuleSpecifier(tree));
      }
    }, {}, $__super);
  }(ModuleTransformer);
  return {get InlineModuleTransformer() {
      return InlineModuleTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js";
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")),
      AnonBlock = $__10.AnonBlock,
      ArrayLiteral = $__10.ArrayLiteral,
      ClassExpression = $__10.ClassExpression,
      CommaExpression = $__10.CommaExpression,
      ExpressionStatement = $__10.ExpressionStatement,
      VariableDeclaration = $__10.VariableDeclaration;
  var $__11 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")),
      ANON_BLOCK = $__11.ANON_BLOCK,
      CLASS_DECLARATION = $__11.CLASS_DECLARATION,
      FUNCTION_DECLARATION = $__11.FUNCTION_DECLARATION,
      IDENTIFIER_EXPRESSION = $__11.IDENTIFIER_EXPRESSION,
      IMPORT_SPECIFIER_SET = $__11.IMPORT_SPECIFIER_SET,
      NAME_SPACE_IMPORT = $__11.NAME_SPACE_IMPORT;
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")).ParseTreeVisitor;
  var ScopeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeTransformer.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")).ScopeTransformer;
  var $__14 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")),
      createEmptyParameterList = $__14.createEmptyParameterList,
      createFunctionBody = $__14.createFunctionBody,
      createFunctionExpression = $__14.createFunctionExpression,
      id = $__14.createIdentifierExpression,
      createObjectLiteralForDescriptor = $__14.createObjectLiteralForDescriptor,
      createUseStrictDirective = $__14.createUseStrictDirective,
      createVariableDeclarationList = $__14.createVariableDeclarationList,
      createVariableStatement = $__14.createVariableStatement;
  var ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")).ModuleTransformer;
  var $__16 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")),
      MINUS_MINUS = $__16.MINUS_MINUS,
      PLUS_PLUS = $__16.PLUS_PLUS,
      VAR = $__16.VAR;
  var $__17 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")),
      parseExpression = $__17.parseExpression,
      parseStatement = $__17.parseStatement,
      parseStatements = $__17.parseStatements;
  var HoistVariablesTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./HoistVariablesTransformer.js", "traceur@0.0.112/src/codegeneration/InstantiateModuleTransformer.js")).default;
  function flattenAnonBlocks(statements) {
    var $__9;
    var result = [];
    for (var i = 0; i < statements.length; i++) {
      var statement = statements[i];
      if (statement.type === ANON_BLOCK) {
        ($__9 = result).push.apply($__9, $traceurRuntime.spread(statement.statements));
      } else {
        result.push(statement);
      }
    }
    return result;
  }
  var ExportBindingsVisitor = function($__super) {
    function ExportBindingsVisitor() {
      $traceurRuntime.superConstructor(ExportBindingsVisitor).call(this);
      this.bindings = [];
    }
    return ($traceurRuntime.createClass)(ExportBindingsVisitor, {
      visitVariableDeclaration: function(tree) {
        this.visitAny(tree.lvalue);
      },
      visitBindingIdentifier: function(tree) {
        this.bindings.push(tree);
      },
      visitBindingElement: function(tree) {
        this.visitAny(tree.binding);
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  var DeclarationExtractionTransformer = function($__super) {
    function DeclarationExtractionTransformer() {
      $traceurRuntime.superConstructor(DeclarationExtractionTransformer).call(this);
      this.declarations_ = [];
    }
    return ($traceurRuntime.createClass)(DeclarationExtractionTransformer, {
      getDeclarationStatements: function() {
        return flattenAnonBlocks($traceurRuntime.spread([this.getVariableStatement()], this.declarations_));
      },
      addDeclaration: function(tree) {
        this.declarations_.push(tree);
      },
      transformFunctionDeclaration: function(tree) {
        this.addDeclaration(tree);
        return new AnonBlock(null, []);
      },
      transformClassDeclaration: function(tree) {
        this.addVariable(tree.name.identifierToken.value);
        tree = new ClassExpression(tree.location, tree.name, tree.superClass, tree.elements, tree.annotations, tree.typeParameters);
        return parseStatement($traceurRuntime.getTemplateObject(["", " = ", ""]), tree.name.identifierToken, tree);
      }
    }, {}, $__super);
  }(HoistVariablesTransformer);
  var ModuleNameIdentifierTransformer = function($__super) {
    function ModuleNameIdentifierTransformer() {
      $traceurRuntime.superConstructor(ModuleNameIdentifierTransformer).call(this, '__moduleName');
      this.usesModuleName = false;
    }
    return ($traceurRuntime.createClass)(ModuleNameIdentifierTransformer, {transformIdentifierExpression: function(tree) {
        if (tree.identifierToken.value === '__moduleName') {
          this.usesModuleName = true;
          return parseExpression($traceurRuntime.getTemplateObject(["$__moduleContext.id"]));
        }
        return $traceurRuntime.superGet(this, ModuleNameIdentifierTransformer.prototype, "transformIdentifierExpression").call(this, tree);
      }}, {}, $__super);
  }(ScopeTransformer);
  var InsertBindingAssignmentTransformer = function($__super) {
    function InsertBindingAssignmentTransformer(exportName, bindingName) {
      $traceurRuntime.superConstructor(InsertBindingAssignmentTransformer).call(this, bindingName);
      this.bindingName_ = bindingName;
      this.exportName_ = exportName;
    }
    return ($traceurRuntime.createClass)(InsertBindingAssignmentTransformer, {
      matchesBindingName_: function(binding) {
        return binding.type === IDENTIFIER_EXPRESSION && binding.identifierToken.value === this.bindingName_;
      },
      transformUnaryExpression: function(tree) {
        if (!this.matchesBindingName_(tree.operand))
          return $traceurRuntime.superGet(this, InsertBindingAssignmentTransformer.prototype, "transformUnaryExpression").call(this, tree);
        var operatorType = tree.operator.type;
        if (operatorType !== PLUS_PLUS && operatorType !== MINUS_MINUS)
          return $traceurRuntime.superGet(this, InsertBindingAssignmentTransformer.prototype, "transformUnaryExpression").call(this, tree);
        var operand = this.transformAny(tree.operand);
        if (operand !== tree.operand)
          tree = new UnaryExpression(tree.location, tree.operator, operand);
        return parseExpression($traceurRuntime.getTemplateObject(["$__export(", ", ", ")"]), this.exportName_, tree);
      },
      transformPostfixExpression: function(tree) {
        tree = $traceurRuntime.superGet(this, InsertBindingAssignmentTransformer.prototype, "transformPostfixExpression").call(this, tree);
        if (!this.matchesBindingName_(tree.operand))
          return tree;
        switch (tree.operator.type) {
          case PLUS_PLUS:
            return parseExpression($traceurRuntime.getTemplateObject(["($__export(", ", ", " + 1), ", ")"]), this.exportName_, tree.operand, tree);
          case MINUS_MINUS:
            return parseExpression($traceurRuntime.getTemplateObject(["($__export(", ", ", " - 1), ", ")"]), this.exportName_, tree.operand, tree);
        }
        return tree;
      },
      transformBinaryExpression: function(tree) {
        tree = $traceurRuntime.superGet(this, InsertBindingAssignmentTransformer.prototype, "transformBinaryExpression").call(this, tree);
        if (!tree.operator.isAssignmentOperator())
          return tree;
        if (!this.matchesBindingName_(tree.left))
          return tree;
        return parseExpression($traceurRuntime.getTemplateObject(["$__export(", ", ", ")}"]), this.exportName_, tree);
      }
    }, {}, $__super);
  }(ScopeTransformer);
  var InstantiateModuleTransformer = function($__super) {
    function InstantiateModuleTransformer(identifierGenerator, reporter) {
      var options = arguments[2];
      $traceurRuntime.superConstructor(InstantiateModuleTransformer).call(this, identifierGenerator, reporter, options);
      this.anonymousModule = options && !options.bundle && options.moduleName !== true;
      this.usesModuleName = false;
      this.inExport_ = false;
      this.curDepIndex_ = null;
      this.dependencies = [];
      this.externalExportBindings = [];
      this.importBindings = [];
      this.localExportBindings = [];
      this.functionDeclarations = [];
      this.moduleBindings = [];
      this.exportStarBindings = [];
    }
    return ($traceurRuntime.createClass)(InstantiateModuleTransformer, {
      getModuleName: function(tree) {
        if (this.anonymousModule)
          return null;
        return tree.moduleName;
      },
      moduleProlog: function() {
        return [];
      },
      wrapModule: function(statements) {
        var prolog = [createUseStrictDirective()];
        statements = prolog.concat(statements);
        if (this.usesModuleName) {
          if (this.moduleName) {
            return parseStatements($traceurRuntime.getTemplateObject(["System.register(", ",\n            ", ", function($__export, $__moduleContext) {\n              ", "\n            });"]), this.moduleName, this.dependencies, statements);
          }
          return parseStatements($traceurRuntime.getTemplateObject(["System.register(", ", function($__export, $__moduleContext) {\n            ", "\n          });"]), this.dependencies, statements);
        }
        if (this.moduleName) {
          return parseStatements($traceurRuntime.getTemplateObject(["System.register(", ",\n          ", ", function($__export) {\n            ", "\n          });"]), this.moduleName, this.dependencies, statements);
        }
        return parseStatements($traceurRuntime.getTemplateObject(["System.register(", ", function($__export) {\n          ", "\n        });"]), this.dependencies, statements);
      },
      addExportStatement: function(statements) {
        var $__6 = this;
        var declarationExtractionTransformer = new DeclarationExtractionTransformer();
        var moduleNameIdentifierTransformer = new ModuleNameIdentifierTransformer();
        statements = moduleNameIdentifierTransformer.transformList(statements);
        if (moduleNameIdentifierTransformer.usesModuleName)
          this.usesModuleName = true;
        this.localExportBindings.forEach(function(binding) {
          statements = new InsertBindingAssignmentTransformer(binding.exportName, binding.localName).transformList(statements);
        });
        var executionStatements = declarationExtractionTransformer.transformList(statements);
        var executionFunction = createFunctionExpression(createEmptyParameterList(), createFunctionBody(executionStatements));
        var declarationStatements = declarationExtractionTransformer.getDeclarationStatements();
        var setterFunctions = this.dependencies.map(function(dep, index) {
          var importBindings = $__6.importBindings[index];
          var externalExportBindings = $__6.externalExportBindings[index];
          var exportStarBinding = $__6.exportStarBindings[index];
          var moduleBinding = $__6.moduleBindings[index];
          var setterStatements = [];
          if (importBindings) {
            importBindings.forEach(function(binding) {
              setterStatements.push(parseStatement($traceurRuntime.getTemplateObject(["", " = $__m.", ";"]), id(binding.variableName), binding.exportName));
            });
          }
          if (externalExportBindings) {
            var reexports = Object.create(null);
            externalExportBindings.forEach(function($__7) {
              var $__8 = $__7,
                  exportName = $__8.exportName,
                  importName = $__8.importName;
              reexports[exportName] = importName === null ? parseExpression($traceurRuntime.getTemplateObject(["$__m"])) : parseExpression($traceurRuntime.getTemplateObject(["$__m.", ""]), importName);
            });
            setterStatements.push(parseStatement($traceurRuntime.getTemplateObject(["$__export(", ")"]), createObjectLiteralForDescriptor(reexports)));
          }
          if (moduleBinding) {
            setterStatements.push(parseStatement($traceurRuntime.getTemplateObject(["", " = $__m;"]), id(moduleBinding)));
          }
          if (exportStarBinding) {
            setterStatements = setterStatements.concat(parseStatements($traceurRuntime.getTemplateObject(["\n          var exportObj = Object.create(null);\n          Object.keys($__m).forEach(function(p) {\n            if (p !== 'default' && !$__exportNames[p])\n              exportObj[p] = $__m[p];\n          });\n          $__export(exportObj);\n        "])));
            var exportNames = {};
            $__6.localExportBindings.concat($__6.externalExportBindings).forEach(function(binding) {
              exportNames[binding.exportName] = true;
            });
            declarationStatements.push(parseStatement($traceurRuntime.getTemplateObject(["\n          var $__exportNames = ", ";\n        "]), createObjectLiteralForDescriptor(exportNames)));
          }
          if (setterStatements.length) {
            return parseExpression($traceurRuntime.getTemplateObject(["function($__m) {\n          ", "\n        }"]), setterStatements);
          }
          return parseExpression($traceurRuntime.getTemplateObject(["function($__m) {}"]));
        });
        declarationStatements = declarationStatements.concat(this.functionDeclarations.map(function(binding) {
          return parseStatement($traceurRuntime.getTemplateObject(["$__export(", ", ", ")"]), binding.exportName, id(binding.functionName));
        }));
        declarationStatements.push(parseStatement($traceurRuntime.getTemplateObject(["return {\n      setters: ", ",\n      execute: ", "\n    }"]), new ArrayLiteral(null, setterFunctions), executionFunction));
        return declarationStatements;
      },
      addLocalExportBinding: function(exportName) {
        var localName = arguments[1] !== (void 0) ? arguments[1] : exportName;
        this.localExportBindings.push({
          exportName: exportName,
          localName: localName
        });
      },
      addImportBinding: function(depIndex, variableName, exportName) {
        this.importBindings[depIndex] = this.importBindings[depIndex] || [];
        this.importBindings[depIndex].push({
          variableName: variableName,
          exportName: exportName
        });
      },
      addExternalExportBinding: function(depIndex, exportName, importName) {
        this.externalExportBindings[depIndex] = this.externalExportBindings[depIndex] || [];
        this.externalExportBindings[depIndex].push({
          exportName: exportName,
          importName: importName
        });
      },
      addExportStarBinding: function(depIndex) {
        this.exportStarBindings[depIndex] = true;
      },
      addModuleBinding: function(depIndex, variableName) {
        this.moduleBindings[depIndex] = variableName;
      },
      addExportFunction: function(exportName) {
        var functionName = arguments[1] !== (void 0) ? arguments[1] : exportName;
        this.functionDeclarations.push({
          exportName: exportName,
          functionName: functionName
        });
      },
      getOrCreateDependencyIndex: function(moduleSpecifier) {
        var name = moduleSpecifier.token.processedValue;
        var depIndex = this.dependencies.indexOf(name);
        if (depIndex === -1) {
          depIndex = this.dependencies.length;
          this.dependencies.push(name);
        }
        return depIndex;
      },
      transformExportDeclaration: function(tree) {
        this.inExport_ = true;
        if (tree.declaration.moduleSpecifier) {
          this.curDepIndex_ = this.getOrCreateDependencyIndex(tree.declaration.moduleSpecifier);
        } else {
          this.curDepIndex_ = null;
        }
        var transformed = this.transformAny(tree.declaration);
        this.inExport_ = false;
        return transformed;
      },
      transformVariableStatement: function(tree) {
        if (!this.inExport_)
          return $traceurRuntime.superGet(this, InstantiateModuleTransformer.prototype, "transformVariableStatement").call(this, tree);
        this.inExport_ = false;
        var bindingVisitor = new ExportBindingsVisitor();
        bindingVisitor.visitAny(tree);
        var statements = [];
        for (var i = 0; i < bindingVisitor.bindings.length; i++) {
          var identifierToken = bindingVisitor.bindings[i].identifierToken;
          var name = identifierToken.value;
          this.addLocalExportBinding(name);
          statements.push(parseStatement($traceurRuntime.getTemplateObject(["$__export(", ", ", ")"]), name, id(identifierToken)));
        }
        statements.unshift($traceurRuntime.superGet(this, InstantiateModuleTransformer.prototype, "transformAny").call(this, tree));
        return new AnonBlock(null, statements);
      },
      transformExportStar: function(tree) {
        this.inExport_ = false;
        this.addExportStarBinding(this.curDepIndex_);
        return new AnonBlock(null, []);
      },
      transformClassDeclaration: function(tree) {
        if (!this.inExport_)
          return $traceurRuntime.superGet(this, InstantiateModuleTransformer.prototype, "transformClassDeclaration").call(this, tree);
        this.inExport_ = false;
        var identifierToken = tree.name.identifierToken;
        var name = identifierToken.value;
        this.addLocalExportBinding(name);
        var statements = [$traceurRuntime.superGet(this, InstantiateModuleTransformer.prototype, "transformClassDeclaration").call(this, tree), parseStatement($traceurRuntime.getTemplateObject(["$__export(", ", ", ")"]), name, id(identifierToken))];
        return new AnonBlock(null, statements);
      },
      transformFunctionDeclaration: function(tree) {
        if (this.inExport_) {
          var name = tree.name.getStringValue();
          this.addLocalExportBinding(name);
          this.addExportFunction(name);
          this.inExport_ = false;
        }
        return $traceurRuntime.superGet(this, InstantiateModuleTransformer.prototype, "transformFunctionDeclaration").call(this, tree);
      },
      transformNamedExport: function(tree) {
        this.transformAny(tree.moduleSpecifier);
        var exportClause = this.transformAny(tree.exportClause);
        if (this.curDepIndex_ === null) {
          return exportClause;
        }
        return new AnonBlock(null, []);
      },
      transformImportDeclaration: function(tree) {
        this.curDepIndex_ = this.getOrCreateDependencyIndex(tree.moduleSpecifier);
        var initializer = this.transformAny(tree.moduleSpecifier);
        if (!tree.importClause) {
          return new AnonBlock(null, []);
        }
        var importClause = this.transformAny(tree.importClause);
        if (tree.importClause.type === NAME_SPACE_IMPORT) {
          var bindingIdentifier = tree.importClause.binding.binding;
          var name = bindingIdentifier.getStringValue();
          this.addModuleBinding(this.curDepIndex_, name);
          return parseStatement($traceurRuntime.getTemplateObject(["var ", ";"]), bindingIdentifier);
        }
        if (tree.importClause.type === IMPORT_SPECIFIER_SET) {
          return importClause;
        }
        var bindingName = tree.importClause.binding.getStringValue();
        this.addImportBinding(this.curDepIndex_, bindingName, 'default');
        return parseStatement($traceurRuntime.getTemplateObject(["var ", ";"]), bindingName);
      },
      transformImportSpecifierSet: function(tree) {
        return createVariableStatement(createVariableDeclarationList(VAR, this.transformList(tree.specifiers)));
      },
      transformExportDefault: function(tree) {
        this.inExport_ = false;
        var expression = this.transformAny(tree.expression);
        this.addLocalExportBinding('default');
        if (expression.type === CLASS_DECLARATION) {
          expression = new ClassExpression(expression.location, expression.name, expression.superClass, expression.elements, expression.annotations, expression.typeParameters);
        }
        if (expression.type === FUNCTION_DECLARATION) {
          this.addExportFunction('default', expression.name.identifierToken.value);
          return expression;
        } else {
          return parseStatement($traceurRuntime.getTemplateObject(["$__export('default', ", ");"]), expression);
        }
      },
      transformExportSpecifier: function(tree) {
        var exportName;
        var bindingName;
        if (tree.rhs) {
          exportName = tree.rhs.value;
          bindingName = tree.lhs.value;
        } else {
          exportName = tree.lhs.value;
          bindingName = exportName;
        }
        if (this.curDepIndex_ !== null) {
          this.addExternalExportBinding(this.curDepIndex_, exportName, bindingName);
        } else {
          this.addLocalExportBinding(exportName, bindingName);
          return parseExpression($traceurRuntime.getTemplateObject(["$__export(", ", ", ");"]), exportName, id(bindingName));
        }
      },
      transformExportSpecifierSet: function(tree) {
        var specifiers = this.transformList(tree.specifiers);
        return new ExpressionStatement(tree.location, new CommaExpression(tree.location, specifiers.filter(function(specifier) {
          return specifier;
        })));
      },
      transformNameSpaceExport: function(tree) {
        this.addExternalExportBinding(this.curDepIndex_, tree.name.value, null);
        return tree;
      },
      transformForwardDefaultExport: function(tree) {
        this.addExternalExportBinding(this.curDepIndex_, tree.name.value, 'default');
        return tree;
      },
      transformImportSpecifier: function(tree) {
        var localBinding = tree.binding.binding;
        var localBindingToken = localBinding.identifierToken;
        var importName = (tree.name || localBindingToken).value;
        this.addImportBinding(this.curDepIndex_, localBindingToken.value, importName);
        return new VariableDeclaration(tree.location, localBinding, null, null);
      },
      transformModuleSpecifier: function(tree) {
        this.curDepIndex_ = this.getOrCreateDependencyIndex(tree);
        return tree;
      }
    }, {}, $__super);
  }(ModuleTransformer);
  return {get InstantiateModuleTransformer() {
      return InstantiateModuleTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/SpreadPropertiesTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/SpreadPropertiesTransformer.js";
  var SPREAD_EXPRESSION = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/SpreadPropertiesTransformer.js")).SPREAD_EXPRESSION;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/SpreadPropertiesTransformer.js")),
      createObjectLiteral = $__2.createObjectLiteral,
      createArgumentList = $__2.createArgumentList;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/SpreadPropertiesTransformer.js")).parseExpression;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/SpreadPropertiesTransformer.js")).default;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/SpreadPropertiesTransformer.js")).ParseTreeTransformer;
  function hasSpread(trees) {
    return trees.some(function(tree) {
      return tree && tree.type === SPREAD_EXPRESSION;
    });
  }
  var SpreadPropertiesTransformer = function($__super) {
    function SpreadPropertiesTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(SpreadPropertiesTransformer).call(this, identifierGenerator, reporter, options);
      this.options = options;
    }
    return ($traceurRuntime.createClass)(SpreadPropertiesTransformer, {transformObjectLiteral: function(tree) {
        if (!hasSpread(tree.propertyNameAndValues)) {
          return $traceurRuntime.superGet(this, SpreadPropertiesTransformer.prototype, "transformObjectLiteral").call(this, tree);
        }
        var properties = this.transformList(tree.propertyNameAndValues);
        return spreadProperties(properties, this);
      }}, {}, $__super);
  }(ImportRuntimeTrait(ParseTreeTransformer));
  function spreadProperties(properties, self) {
    var args = [];
    var accummulatedProps = null;
    for (var i = 0; i < properties.length; i++) {
      var property = properties[i];
      if (property.type === SPREAD_EXPRESSION) {
        if (accummulatedProps) {
          args.push(createObjectLiteral(accummulatedProps));
          accummulatedProps = null;
        }
        args.push(property.expression);
      } else {
        if (!accummulatedProps) {
          accummulatedProps = [];
        }
        accummulatedProps.push(property);
      }
    }
    if (accummulatedProps) {
      args.push(createObjectLiteral(accummulatedProps));
    }
    var runtime = self.getRuntimeExpression('spreadProperties');
    return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), runtime, createArgumentList(args));
  }
  return {
    get SpreadPropertiesTransformer() {
      return SpreadPropertiesTransformer;
    },
    get spreadProperties() {
      return spreadProperties;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/JsxTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/JsxTransformer.js";
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")),
      JSX_ELEMENT = $__4.JSX_ELEMENT,
      JSX_PLACEHOLDER = $__4.JSX_PLACEHOLDER,
      JSX_SPREAD_ATTRIBUTE = $__4.JSX_SPREAD_ATTRIBUTE,
      JSX_TEXT = $__4.JSX_TEXT,
      LITERAL_EXPRESSION = $__4.LITERAL_EXPRESSION;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")),
      JsxText = $__5.JsxText,
      LiteralExpression = $__5.LiteralExpression,
      LiteralPropertyName = $__5.LiteralPropertyName,
      SpreadExpression = $__5.SpreadExpression;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/LiteralToken.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")).LiteralToken;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")).ParseTreeTransformer;
  var STRING = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")).STRING;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")),
      createArgumentList = $__9.createArgumentList,
      createIdentifierExpression = $__9.createIdentifierExpression,
      createIdentifierToken = $__9.createIdentifierToken,
      createMemberExpression = $__9.createMemberExpression,
      createNullLiteral = $__9.createNullLiteral,
      createObjectLiteral = $__9.createObjectLiteral,
      createPropertyNameAssignment = $__9.createPropertyNameAssignment,
      createStringLiteral = $__9.createStringLiteral,
      createStringLiteralToken = $__9.createStringLiteralToken,
      createTrueLiteral = $__9.createTrueLiteral;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")).parseExpression;
  var spreadProperties = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SpreadPropertiesTransformer.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")).spreadProperties;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/JsxTransformer.js")).default;
  var JsxTransformer = function($__super) {
    function JsxTransformer(idGen, reporter, options) {
      $traceurRuntime.superConstructor(JsxTransformer).call(this);
      this.options = options;
      this.jsxFunction_ = null;
    }
    return ($traceurRuntime.createClass)(JsxTransformer, {
      getJsxFunction_: function() {
        if (!this.jsxFunction_) {
          var jsx = this.options.jsx;
          if (typeof jsx === 'string') {
            this.jsxFunction_ = parseExpression([jsx]);
          } else {
            this.jsxFunction_ = parseExpression($traceurRuntime.getTemplateObject(["React.createElement"]));
          }
        }
        return this.jsxFunction_;
      },
      transformJsxElement: function(tree) {
        var name = this.transformAny(tree.name);
        var props = this.transformJsxAttributes_(tree);
        var children = this.transformJsxChildren_(tree.children);
        var args = createArgumentList($traceurRuntime.spread([name, props], children));
        return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), this.getJsxFunction_(), args);
      },
      transformJsxAttributes_: function(tree) {
        var attrs = this.transformList(tree.attributes);
        if (attrs.length === 0) {
          return createNullLiteral();
        }
        if (tree.attributes.some(function(a) {
          return a.type === JSX_SPREAD_ATTRIBUTE;
        })) {
          return spreadProperties(attrs, this);
        }
        return createObjectLiteral(attrs);
      },
      transformJsxElementName: function(tree) {
        if (tree.names.length === 1) {
          var value = tree.names[0].value;
          if (value[0] === value[0].toUpperCase()) {
            return createIdentifierExpression(value);
            ;
          }
          return createStringLiteral(value);
        }
        var names = tree.names.map(jsxIdentifierToToken);
        var operand = names[0];
        if (operand.type === STRING) {
          names[0] = new LiteralExpression(operand.location, operand);
        }
        return createMemberExpression.apply((void 0), $traceurRuntime.spread(names));
      },
      transformJsxAttribute: function(tree) {
        var name = new LiteralPropertyName(tree.name.location, jsxIdentifierToToken(tree.name));
        var value;
        if (tree.value === null) {
          value = createTrueLiteral();
        } else if (tree.value.type === LITERAL_EXPRESSION) {
          var literalToken = tree.value.literalToken;
          var v = literalToken.value;
          var location = literalToken.location;
          var lit = new LiteralToken(STRING, normalizeAttributeValue(v), location);
          value = new LiteralExpression(location, lit);
        } else {
          value = this.transformAny(tree.value);
        }
        return createPropertyNameAssignment(name, value);
      },
      transformJsxPlaceholder: function(tree) {
        return this.transformAny(tree.expression);
      },
      transformJsxSpreadAttribute: function(tree) {
        return new SpreadExpression(tree.location, this.transformAny(tree.expression));
      },
      transformJsxText: function(tree) {
        return createStringLiteral(tree.value.value);
      },
      transformJsxChildren_: function(trees) {
        var $__1 = this;
        var rv = [];
        trees.forEach(function(tree) {
          var newTree;
          switch (tree.type) {
            case JSX_ELEMENT:
              newTree = $__1.transformAny(tree);
              break;
            case JSX_PLACEHOLDER:
              if (tree.expression === null) {
                return;
              }
              newTree = $__1.transformAny(tree);
              break;
            case JSX_TEXT:
              {
                var s = tree.value.value;
                s = s.replace(/\t/g, ' ');
                if (!/[\n\r]/.test(s)) {
                  newTree = createStringLiteral(s);
                } else {
                  s = s.replace(/^[ \t]*[\n\r]\s*/, '');
                  s = s.replace(/[ \t]*[\n\r]\s*$/, '');
                  if (s === '') {
                    return;
                  }
                  newTree = createStringLiteral(s);
                }
                break;
              }
          }
          rv.push(newTree);
        });
        return rv;
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(ParseTreeTransformer));
  function jsxIdentifierToToken(token) {
    var value = token.value;
    if (value.indexOf('-') !== -1) {
      return createStringLiteralToken(value);
    }
    return createIdentifierToken(value);
  }
  function normalizeAttributeValue(s) {
    return JSON.stringify(s.slice(1, -1).replace(/\n\s+/g, ' '));
  }
  return {get JsxTransformer() {
      return JsxTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/MemberVariableConstructorTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/MemberVariableConstructorTransformer.js";
  var Method = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/MemberVariableConstructorTransformer.js")).Method;
  var SUPER_EXPRESSION = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/MemberVariableConstructorTransformer.js")).SUPER_EXPRESSION;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/MemberVariableConstructorTransformer.js")).ParseTreeTransformer;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/MemberVariableConstructorTransformer.js")),
      createCommaExpression = $__4.createCommaExpression,
      createExpressionStatement = $__4.createExpressionStatement,
      createFunctionBody = $__4.createFunctionBody,
      createParenExpression = $__4.createParenExpression,
      createThisExpression = $__4.createThisExpression;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/MemberVariableConstructorTransformer.js")).prependStatements;
  function transformConstructor(constructor, initExpression, superClass) {
    if (superClass) {
      var transformer = new SuperCallTransformer(initExpression);
      return transformer.transformAny(constructor);
    }
    var statements = constructor.body.statements;
    var initStatement = createExpressionStatement(initExpression);
    statements = prependStatements(statements, initStatement);
    return new Method(constructor.location, false, constructor.functionKind, constructor.name, constructor.parameterList, constructor.typeAnnotation, constructor.annotations, createFunctionBody(statements), constructor.debugName);
  }
  var SuperCallTransformer = function($__super) {
    function SuperCallTransformer(expression) {
      $traceurRuntime.superConstructor(SuperCallTransformer).call(this);
      this.expression = expression;
    }
    return ($traceurRuntime.createClass)(SuperCallTransformer, {
      transformCallExpression: function(tree) {
        if (tree.operand.type === SUPER_EXPRESSION) {
          var thisExpression = createThisExpression();
          return createParenExpression(createCommaExpression([tree, this.expression, thisExpression]));
        }
        return $traceurRuntime.superGet(this, SuperCallTransformer.prototype, "transformCallExpression").call(this, tree);
      },
      transformClassDeclaration: function(tree) {
        return tree;
      },
      transformClassExpression: function(tree) {
        return tree;
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get transformConstructor() {
      return transformConstructor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js";
  var CONSTRUCTOR = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")).CONSTRUCTOR;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")),
      AnonBlock = $__5.AnonBlock,
      ClassDeclaration = $__5.ClassDeclaration,
      ClassExpression = $__5.ClassExpression,
      FormalParameterList = $__5.FormalParameterList,
      IdentifierExpression = $__5.IdentifierExpression,
      Method = $__5.Method,
      ReturnStatement = $__5.ReturnStatement;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")),
      GET_ACCESSOR = $__6.GET_ACCESSOR,
      METHOD = $__6.METHOD,
      PROPERTY_VARIABLE_DECLARATION = $__6.PROPERTY_VARIABLE_DECLARATION,
      SET_ACCESSOR = $__6.SET_ACCESSOR;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")).TempVarTransformer;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")),
      createCommaExpression = $__8.createCommaExpression,
      createFunctionBody = $__8.createFunctionBody,
      createIdentifierToken = $__8.createIdentifierToken,
      createImmediatelyInvokedFunctionExpression = $__8.createImmediatelyInvokedFunctionExpression,
      createLiteralPropertyName = $__8.createLiteralPropertyName,
      createRestParameter = $__8.createRestParameter;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")),
      parsePropertyDefinition = $__9.parsePropertyDefinition,
      parseStatement = $__9.parseStatement;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")).parseExpression;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")).prependStatements;
  var propName = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../staticsemantics/PropName.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")).propName;
  var transformConstructor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./MemberVariableConstructorTransformer.js", "traceur@0.0.112/src/codegeneration/MemberVariableTransformer.js")).transformConstructor;
  var MemberVariableTransformer = function($__super) {
    function MemberVariableTransformer() {
      $traceurRuntime.superConstructor(MemberVariableTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(MemberVariableTransformer, {
      transformClassElements_: function(tree) {
        var $__2 = this;
        var elements = [];
        var initInstanceVars = [],
            initStaticVars = [];
        var constructor;
        var constructorIndex = 0;
        tree.elements.forEach(function(tree) {
          var initVars;
          if (tree.isStatic) {
            initVars = initStaticVars;
          } else {
            initVars = initInstanceVars;
          }
          switch (tree.type) {
            case GET_ACCESSOR:
            case SET_ACCESSOR:
              elements.push($__2.transformAny(tree));
              break;
            case METHOD:
              if (!tree.isStatic && propName(tree) === CONSTRUCTOR) {
                constructor = tree;
                constructorIndex = elements.length;
              } else {
                elements.push($__2.transformAny(tree));
              }
              break;
            case PROPERTY_VARIABLE_DECLARATION:
              tree = $__2.transformAny(tree);
              if (tree.initializer !== null) {
                initVars.push(tree);
              }
              break;
            default:
              throw new Error(("Unexpected class element: " + tree.type));
          }
        });
        if (initInstanceVars.length > 0) {
          var initExpression = getInstanceInitExpression(initInstanceVars);
          if (!constructor) {
            constructor = this.getDefaultConstructor_(tree);
          }
          constructor = transformConstructor(constructor, initExpression, tree.superClass);
        }
        if (constructor) {
          elements.splice(constructorIndex, 0, constructor);
        }
        return {
          elements: elements,
          initStaticVars: initStaticVars
        };
      },
      transformClassDeclaration: function(tree) {
        var $__3 = this.transformClassElements_(tree),
            elements = $__3.elements,
            initStaticVars = $__3.initStaticVars;
        var superClass = this.transformAny(tree.superClass);
        var classDecl = new ClassDeclaration(tree.location, tree.name, superClass, elements, tree.annotations, tree.typeParameters);
        if (initStaticVars.length === 0) {
          return classDecl;
        }
        var statements = createStaticInitializerStatements(tree.name.identifierToken, initStaticVars);
        statements = prependStatements(statements, classDecl);
        return new AnonBlock(null, statements);
      },
      transformClassExpression: function(tree) {
        var $__3 = this.transformClassElements_(tree),
            elements = $__3.elements,
            initStaticVars = $__3.initStaticVars;
        var superClass = this.transformAny(tree.superClass);
        var classExpression = new ClassExpression(tree.location, tree.name, superClass, elements, tree.annotations, tree.typeParameters);
        if (initStaticVars.length === 0) {
          return classExpression;
        }
        this.pushTempScope();
        var id = this.getTempIdentifier();
        var idToken = createIdentifierToken(id);
        var idExpression = new IdentifierExpression(idToken.location, idToken);
        var statements = $traceurRuntime.spread([parseStatement($traceurRuntime.getTemplateObject(["let ", " = ", ""]), id, classExpression)], createStaticInitializerStatements(idToken, initStaticVars), [new ReturnStatement(null, idExpression)]);
        var body = createFunctionBody(statements);
        this.popTempScope();
        return createImmediatelyInvokedFunctionExpression(body);
      },
      getDefaultConstructor_: function(tree) {
        if (tree.superClass) {
          var param = createRestParameter(createIdentifierToken('args'));
          var paramList = new FormalParameterList(null, [param]);
          var body = createFunctionBody([parseStatement($traceurRuntime.getTemplateObject(["super(...args)"]))]);
          var name = createLiteralPropertyName(CONSTRUCTOR);
          return new Method(tree.location, false, null, name, paramList, null, [], body, null);
        }
        return parsePropertyDefinition($traceurRuntime.getTemplateObject(["constructor() {}"]));
      }
    }, {}, $__super);
  }(TempVarTransformer);
  function createStaticInitializerStatements(idToken, initStaticMemberVars) {
    var className = new IdentifierExpression(idToken.location, idToken);
    return initStaticMemberVars.map(function(mv) {
      var propName = mv.name.literalToken.value;
      return parseStatement($traceurRuntime.getTemplateObject(["Object.defineProperty(", ", ", ", {enumerable: true,\n        configurable: true, value: ", ", writable: true})"]), className, propName, mv.initializer);
    });
  }
  function getInstanceInitExpression(initInstanceVars) {
    var expressions = initInstanceVars.map(function(mv) {
      var name = mv.name.literalToken;
      return parseExpression($traceurRuntime.getTemplateObject(["this.", " = ", ""]), name, mv.initializer);
    });
    return createCommaExpression(expressions);
  }
  return {get MemberVariableTransformer() {
      return MemberVariableTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/outputgeneration/ParseTreeWriter.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/outputgeneration/ParseTreeWriter.js";
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/outputgeneration/ParseTreeWriter.js")),
      BLOCK = $__4.BLOCK,
      CLASS_DECLARATION = $__4.CLASS_DECLARATION,
      FUNCTION_DECLARATION = $__4.FUNCTION_DECLARATION,
      IF_STATEMENT = $__4.IF_STATEMENT,
      LITERAL_EXPRESSION = $__4.LITERAL_EXPRESSION,
      POSTFIX_EXPRESSION = $__4.POSTFIX_EXPRESSION,
      UNARY_EXPRESSION = $__4.UNARY_EXPRESSION;
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/outputgeneration/ParseTreeWriter.js")).ParseTreeVisitor;
  var $__6 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/outputgeneration/ParseTreeWriter.js")),
      AS = $__6.AS,
      ASYNC = $__6.ASYNC,
      AWAIT = $__6.AWAIT,
      FROM = $__6.FROM,
      GET = $__6.GET,
      OF = $__6.OF,
      ON = $__6.ON,
      SET = $__6.SET,
      TYPE = $__6.TYPE;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/Scanner.js", "traceur@0.0.112/src/outputgeneration/ParseTreeWriter.js")),
      isIdentifierPart = $__7.isIdentifierPart,
      isWhitespace = $__7.isWhitespace;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/outputgeneration/ParseTreeWriter.js")),
      ARROW = $__8.ARROW,
      AT = $__8.AT,
      BACK_QUOTE = $__8.BACK_QUOTE,
      BAR = $__8.BAR,
      BREAK = $__8.BREAK,
      CASE = $__8.CASE,
      CATCH = $__8.CATCH,
      CLASS = $__8.CLASS,
      CLOSE_ANGLE = $__8.CLOSE_ANGLE,
      CLOSE_CURLY = $__8.CLOSE_CURLY,
      CLOSE_PAREN = $__8.CLOSE_PAREN,
      CLOSE_SQUARE = $__8.CLOSE_SQUARE,
      COLON = $__8.COLON,
      COMMA = $__8.COMMA,
      CONTINUE = $__8.CONTINUE,
      DEBUGGER = $__8.DEBUGGER,
      DEFAULT = $__8.DEFAULT,
      DO = $__8.DO,
      DOT_DOT_DOT = $__8.DOT_DOT_DOT,
      ELSE = $__8.ELSE,
      EQUAL = $__8.EQUAL,
      EXPORT = $__8.EXPORT,
      EXTENDS = $__8.EXTENDS,
      FINALLY = $__8.FINALLY,
      FOR = $__8.FOR,
      FUNCTION = $__8.FUNCTION,
      IF = $__8.IF,
      IMPORT = $__8.IMPORT,
      IN = $__8.IN,
      INTERFACE = $__8.INTERFACE,
      MINUS = $__8.MINUS,
      MINUS_MINUS = $__8.MINUS_MINUS,
      NEW = $__8.NEW,
      NUMBER = $__8.NUMBER,
      OPEN_ANGLE = $__8.OPEN_ANGLE,
      OPEN_CURLY = $__8.OPEN_CURLY,
      OPEN_PAREN = $__8.OPEN_PAREN,
      OPEN_SQUARE = $__8.OPEN_SQUARE,
      PERIOD = $__8.PERIOD,
      PLUS = $__8.PLUS,
      PLUS_PLUS = $__8.PLUS_PLUS,
      QUESTION = $__8.QUESTION,
      RETURN = $__8.RETURN,
      SEMI_COLON = $__8.SEMI_COLON,
      SLASH = $__8.SLASH,
      STAR = $__8.STAR,
      STATIC = $__8.STATIC,
      SUPER = $__8.SUPER,
      SWITCH = $__8.SWITCH,
      THIS = $__8.THIS,
      THROW = $__8.THROW,
      TRY = $__8.TRY,
      WHILE = $__8.WHILE,
      WITH = $__8.WITH,
      YIELD = $__8.YIELD;
  var NEW_LINE = '\n';
  var LINE_LENGTH = 80;
  var ParseTreeWriter = function($__super) {
    function ParseTreeWriter() {
      var $__3;
      var $__2 = arguments[0] !== (void 0) ? arguments[0] : {},
          prettyPrint = ($__3 = $__2.prettyPrint) === void 0 ? true : $__3;
      $traceurRuntime.superConstructor(ParseTreeWriter).call(this);
      this.prettyPrint_ = prettyPrint;
      this.result_ = '';
      this.currentLine_ = '';
      this.lastCode_ = -1;
      this.indentDepth_ = 0;
      this.currentParameterTypeAnnotation_ = null;
    }
    return ($traceurRuntime.createClass)(ParseTreeWriter, {
      toString: function() {
        if (this.currentLine_.length > 0) {
          this.result_ += this.currentLine_;
          this.currentLine_ = '';
          this.lastCode_ = -1;
        }
        return this.result_;
      },
      visitAnnotation: function(tree) {
        this.write_(AT);
        this.visitAny(tree.name);
        if (tree.args !== null) {
          this.write_(OPEN_PAREN);
          this.writeList_(tree.args.args, COMMA, false);
          this.write_(CLOSE_PAREN);
        }
      },
      visitArgumentList: function(tree) {
        this.write_(OPEN_PAREN);
        this.writeList_(tree.args, COMMA, false);
        this.write_(CLOSE_PAREN);
      },
      visitArrayComprehension: function(tree) {
        this.write_(OPEN_SQUARE);
        this.visitList(tree.comprehensionList);
        this.visitAny(tree.expression);
        this.write_(CLOSE_SQUARE);
      },
      visitArrayLiteral: function(tree) {
        this.write_(OPEN_SQUARE);
        this.writeList_(tree.elements, COMMA, false);
        if (tree.elements[tree.elements.length - 1] === null) {
          this.write_(COMMA);
          this.writeSpace_();
        }
        this.write_(CLOSE_SQUARE);
      },
      visitArrayPattern: function(tree) {
        this.write_(OPEN_SQUARE);
        this.writeList_(tree.elements, COMMA, false);
        if (tree.elements[tree.elements.length - 1] === null) {
          this.write_(COMMA);
          this.writeSpace_();
        }
        this.write_(CLOSE_SQUARE);
      },
      visitArrayType: function(tree) {
        this.visitAny(tree.elementType);
        this.write_(OPEN_SQUARE);
        this.write_(CLOSE_SQUARE);
      },
      visitArrowFunction: function(tree) {
        if (tree.functionKind) {
          this.writeToken_(tree.functionKind);
          this.writeSpace_();
        }
        this.write_(OPEN_PAREN);
        this.visitAny(tree.parameterList);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.write_(ARROW);
        this.writeSpace_();
        this.visitAny(tree.body);
      },
      visitAssignmentElement: function(tree) {
        this.visitAny(tree.assignment);
        if (tree.initializer) {
          this.writeSpace_();
          this.write_(EQUAL);
          this.writeSpace_();
          this.visitAny(tree.initializer);
        }
      },
      visitAwaitExpression: function(tree) {
        this.write_(AWAIT);
        this.writeSpace_();
        this.visitAny(tree.expression);
      },
      visitBinaryExpression: function(tree) {
        var left = tree.left;
        this.visitAny(left);
        var operator = tree.operator;
        if (left.type === POSTFIX_EXPRESSION && requiresSpaceBetween(left.operator.type, operator.type)) {
          this.writeRequiredSpace_();
        } else {
          this.writeSpace_();
        }
        this.writeToken_(operator);
        var right = tree.right;
        if (right.type === UNARY_EXPRESSION && requiresSpaceBetween(operator.type, right.operator.type)) {
          this.writeRequiredSpace_();
        } else {
          this.writeSpace_();
        }
        this.visitAny(right);
      },
      visitBindingElement: function(tree) {
        var typeAnnotation = this.currentParameterTypeAnnotation_;
        this.currentParameterTypeAnnotation_ = null;
        this.visitAny(tree.binding);
        this.writeTypeAnnotation_(typeAnnotation);
        if (tree.initializer) {
          this.writeSpace_();
          this.write_(EQUAL);
          this.writeSpace_();
          this.visitAny(tree.initializer);
        }
      },
      visitBindingIdentifier: function(tree) {
        this.writeToken_(tree.identifierToken);
      },
      visitBlock: function(tree) {
        this.writeOpenCurly_();
        this.writelnList_(tree.statements, null);
        this.writeCloseCurly_();
      },
      visitBreakStatement: function(tree) {
        this.write_(BREAK);
        if (tree.name !== null) {
          this.writeSpace_();
          this.writeToken_(tree.name);
        }
        this.write_(SEMI_COLON);
      },
      visitCallExpression: function(tree) {
        this.visitAny(tree.operand);
        this.visitAny(tree.args);
      },
      visitCallSignature: function(tree) {
        if (tree.typeParameters) {
          this.visitAny(tree.typeParameters);
        }
        this.write_(OPEN_PAREN);
        this.visitAny(tree.parameterList);
        this.write_(CLOSE_PAREN);
        this.writeTypeAnnotation_(tree.returnType);
      },
      visitCaseClause: function(tree) {
        this.write_(CASE);
        this.writeSpace_();
        this.visitAny(tree.expression);
        this.write_(COLON);
        this.indentDepth_++;
        this.writelnList_(tree.statements, null);
        this.indentDepth_--;
      },
      visitCatch: function(tree) {
        this.write_(CATCH);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.binding);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.visitAny(tree.catchBody);
      },
      visitClassShared_: function(tree) {
        this.writeAnnotations_(tree.annotations);
        this.write_(CLASS);
        this.writeSpace_();
        this.visitAny(tree.name);
        if (tree.typeParameters !== null) {
          this.visitAny(tree.typeParameters);
        }
        if (tree.superClass !== null) {
          this.writeSpace_();
          this.write_(EXTENDS);
          this.writeSpace_();
          this.visitAny(tree.superClass);
        }
        this.writeSpace_();
        this.writeOpenCurly_();
        this.writelnList_(tree.elements, null);
        this.writeCloseCurly_();
      },
      visitClassDeclaration: function(tree) {
        this.visitClassShared_(tree);
      },
      visitClassExpression: function(tree) {
        this.visitClassShared_(tree);
      },
      visitCommaExpression: function(tree) {
        this.writeList_(tree.expressions, COMMA, false);
      },
      visitComprehensionFor: function(tree) {
        this.write_(FOR);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.left);
        this.writeSpace_();
        this.write_(OF);
        this.writeSpace_();
        this.visitAny(tree.iterator);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
      },
      visitComprehensionIf: function(tree) {
        this.write_(IF);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.expression);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
      },
      visitComputedPropertyName: function(tree) {
        this.write_(OPEN_SQUARE);
        this.visitAny(tree.expression);
        this.write_(CLOSE_SQUARE);
      },
      visitConstructSignature: function(tree) {
        this.write_(NEW);
        this.writeSpace_();
        this.visitCallSignature(tree);
      },
      visitConstructorType: function(tree) {
        this.write_(NEW);
        this.writeSpace_();
        this.visitFunctionType(tree);
      },
      visitConditionalExpression: function(tree) {
        this.visitAny(tree.condition);
        this.writeSpace_();
        this.write_(QUESTION);
        this.writeSpace_();
        this.visitAny(tree.left);
        this.writeSpace_();
        this.write_(COLON);
        this.writeSpace_();
        this.visitAny(tree.right);
      },
      visitContinueStatement: function(tree) {
        this.write_(CONTINUE);
        if (tree.name !== null) {
          this.writeSpace_();
          this.writeToken_(tree.name);
        }
        this.write_(SEMI_COLON);
      },
      visitCoverInitializedName: function(tree) {
        this.writeToken_(tree.name);
        this.writeSpace_();
        this.writeToken_(tree.equalToken);
        this.writeSpace_();
        this.visitAny(tree.initializer);
      },
      visitDebuggerStatement: function(tree) {
        this.write_(DEBUGGER);
        this.write_(SEMI_COLON);
      },
      visitDefaultClause: function(tree) {
        this.write_(DEFAULT);
        this.write_(COLON);
        this.indentDepth_++;
        this.writelnList_(tree.statements, null);
        this.indentDepth_--;
      },
      visitDoWhileStatement: function(tree) {
        this.write_(DO);
        this.visitAnyBlockOrIndent_(tree.body);
        this.writeSpace_();
        this.write_(WHILE);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.condition);
        this.write_(CLOSE_PAREN);
        this.write_(SEMI_COLON);
      },
      visitEmptyStatement: function(tree) {
        this.write_(SEMI_COLON);
      },
      visitExportDeclaration: function(tree) {
        this.writeAnnotations_(tree.annotations);
        this.write_(EXPORT);
        this.writeSpace_();
        this.visitAny(tree.declaration);
      },
      visitExportDefault: function(tree) {
        this.write_(DEFAULT);
        this.writeSpace_();
        this.visitAny(tree.expression);
        switch (tree.expression.type) {
          case CLASS_DECLARATION:
          case FUNCTION_DECLARATION:
            break;
          default:
            this.write_(SEMI_COLON);
        }
      },
      visitNameSpaceExport: function(tree) {
        this.write_(STAR);
        this.writeSpace_();
        this.write_(AS);
        this.writeSpace_();
        this.writeToken_(tree.name);
      },
      visitNameSpaceImport: function(tree) {
        this.write_(STAR);
        this.writeSpace_();
        this.write_(AS);
        this.writeSpace_();
        this.visitAny(tree.binding);
      },
      visitNamedExport: function(tree) {
        this.visitAny(tree.exportClause);
        if (tree.moduleSpecifier) {
          this.writeSpace_();
          this.write_(FROM);
          this.writeSpace_();
          this.visitAny(tree.moduleSpecifier);
        }
        this.write_(SEMI_COLON);
      },
      visitExportSpecifier: function(tree) {
        this.writeToken_(tree.lhs);
        if (tree.rhs) {
          this.writeSpace_();
          this.write_(AS);
          this.writeSpace_();
          this.writeToken_(tree.rhs);
        }
      },
      visitExportSpecifierSet: function(tree) {
        this.writeOpenCurly_();
        this.writeList_(tree.specifiers, COMMA, false);
        this.writeCloseCurly_();
      },
      visitExportStar: function(tree) {
        this.write_(STAR);
      },
      visitExpressionStatement: function(tree) {
        this.visitAny(tree.expression);
        this.write_(SEMI_COLON);
      },
      visitFinally: function(tree) {
        this.write_(FINALLY);
        this.writeSpace_();
        this.visitAny(tree.block);
      },
      visitForOfStatement: function(tree) {
        this.write_(FOR);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.initializer);
        this.writeSpace_();
        this.write_(OF);
        this.writeSpace_();
        this.visitAny(tree.collection);
        this.write_(CLOSE_PAREN);
        this.visitAnyBlockOrIndent_(tree.body);
      },
      visitForOnStatement: function(tree) {
        this.write_(FOR);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.initializer);
        this.writeSpace_();
        this.write_(ON);
        this.writeSpace_();
        this.visitAny(tree.observable);
        this.write_(CLOSE_PAREN);
        this.visitAnyBlockOrIndent_(tree.body);
      },
      visitForInStatement: function(tree) {
        this.write_(FOR);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.initializer);
        this.writeSpace_();
        this.write_(IN);
        this.writeSpace_();
        this.visitAny(tree.collection);
        this.write_(CLOSE_PAREN);
        this.visitAnyBlockOrIndent_(tree.body);
      },
      visitForStatement: function(tree) {
        this.write_(FOR);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.initializer);
        this.write_(SEMI_COLON);
        this.writeSpace_();
        this.visitAny(tree.condition);
        this.write_(SEMI_COLON);
        this.writeSpace_();
        this.visitAny(tree.increment);
        this.write_(CLOSE_PAREN);
        this.visitAnyBlockOrIndent_(tree.body);
      },
      visitFormalParameterList: function(tree) {
        var first = true;
        for (var i = 0; i < tree.parameters.length; i++) {
          var parameter = tree.parameters[i];
          if (first) {
            first = false;
          } else {
            this.write_(COMMA);
            this.writeSpace_();
          }
          this.visitAny(parameter);
        }
      },
      visitFormalParameter: function(tree) {
        this.writeAnnotations_(tree.annotations, false);
        this.currentParameterTypeAnnotation_ = tree.typeAnnotation;
        this.visitAny(tree.parameter);
        this.currentParameterTypeAnnotation_ = null;
      },
      visitForwardDefaultExport: function(tree) {
        this.writeToken_(tree.name);
      },
      visitFunctionBody: function(tree) {
        this.writeOpenCurly_();
        this.writelnList_(tree.statements, null);
        this.writeCloseCurly_();
      },
      visitFunctionDeclaration: function(tree) {
        this.visitFunction_(tree);
      },
      visitFunctionExpression: function(tree) {
        this.visitFunction_(tree);
      },
      visitFunction_: function(tree) {
        this.writeAnnotations_(tree.annotations);
        if (tree.isAsyncGenerator()) {
          this.write_(ASYNC);
        }
        if (tree.isAsyncFunction())
          this.writeToken_(tree.functionKind);
        this.write_(FUNCTION);
        if (tree.isAsyncGenerator()) {
          this.write_(STAR);
        }
        if (tree.isGenerator())
          this.writeToken_(tree.functionKind);
        if (tree.name) {
          this.writeSpace_();
          this.visitAny(tree.name);
        }
        this.write_(OPEN_PAREN);
        this.visitAny(tree.parameterList);
        this.write_(CLOSE_PAREN);
        this.writeTypeAnnotation_(tree.typeAnnotation);
        this.writeSpace_();
        this.visitAny(tree.body);
      },
      visitFunctionType: function(tree) {
        if (tree.typeParameters !== null) {
          this.visitAny(tree.typeParameters);
        }
        this.write_(OPEN_PAREN);
        this.visitAny(tree.parameterList);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.write_(ARROW);
        this.writeSpace_();
        this.visitAny(tree.returnType);
      },
      visitGeneratorComprehension: function(tree) {
        this.write_(OPEN_PAREN);
        this.visitList(tree.comprehensionList);
        this.visitAny(tree.expression);
        this.write_(CLOSE_PAREN);
      },
      visitGetAccessor: function(tree) {
        this.writeAnnotations_(tree.annotations);
        if (tree.isStatic) {
          this.write_(STATIC);
          this.writeSpace_();
        }
        this.write_(GET);
        this.writeSpace_();
        this.visitAny(tree.name);
        this.write_(OPEN_PAREN);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.writeTypeAnnotation_(tree.typeAnnotation);
        this.visitAny(tree.body);
      },
      visitIdentifierExpression: function(tree) {
        this.writeToken_(tree.identifierToken);
      },
      visitIfStatement: function(tree) {
        this.write_(IF);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.condition);
        this.write_(CLOSE_PAREN);
        this.visitAnyBlockOrIndent_(tree.ifClause);
        if (tree.elseClause) {
          if (tree.ifClause.type === BLOCK)
            this.writeSpace_();
          this.write_(ELSE);
          if (tree.elseClause.type === IF_STATEMENT) {
            this.writeSpace_();
            this.visitAny(tree.elseClause);
          } else {
            this.visitAnyBlockOrIndent_(tree.elseClause);
          }
        }
      },
      visitIndexSignature: function(tree) {
        this.write_(OPEN_SQUARE);
        this.writeToken_(tree.name);
        this.write_(COLON);
        this.writeSpace_();
        this.visitAny(tree.indexType);
        this.write_(CLOSE_SQUARE);
        this.writeTypeAnnotation_(tree.typeAnnotation);
        this.write_(SEMI_COLON);
      },
      visitInterfaceDeclaration: function(tree) {
        this.write_(INTERFACE);
        this.writeSpace_();
        this.writeToken_(tree.name);
        if (tree.typeParameters) {
          this.visitAny(tree.typeParameters);
        }
        if (tree.extendsClause.length > 0) {
          this.writeSpace_();
          this.write_(EXTENDS);
          this.writeSpace_();
          this.writeList_(tree.extendsClause, COMMA, false);
        }
        this.writeSpace_();
        this.visitAny(tree.objectType);
      },
      visitAnyBlockOrIndent_: function(tree) {
        if (tree.type === BLOCK) {
          this.writeSpace_();
          this.visitAny(tree);
        } else {
          this.visitAnyIndented_(tree);
        }
      },
      visitAnyIndented_: function(tree) {
        var indent = arguments[1] !== (void 0) ? arguments[1] : 1;
        if (this.prettyPrint_) {
          this.indentDepth_ += indent;
          this.writeln_();
        }
        this.visitAny(tree);
        if (this.prettyPrint_) {
          this.indentDepth_ -= indent;
          this.writeln_();
        }
      },
      visitImportClausePair: function(tree) {
        this.visitAny(tree.first);
        this.write_(COMMA);
        this.writeSpace_();
        this.visitAny(tree.second);
      },
      visitImportDeclaration: function(tree) {
        this.write_(IMPORT);
        this.writeSpace_();
        if (tree.importClause) {
          this.visitAny(tree.importClause);
          this.writeSpace_();
          this.write_(FROM);
          this.writeSpace_();
        }
        this.visitAny(tree.moduleSpecifier);
        this.write_(SEMI_COLON);
      },
      visitImportSpecifier: function(tree) {
        if (tree.name) {
          this.writeToken_(tree.name);
          this.writeSpace_();
          this.write_(AS);
          this.writeSpace_();
        }
        this.visitAny(tree.binding);
      },
      visitImportSpecifierSet: function(tree) {
        if (tree.specifiers.type === STAR) {
          this.write_(STAR);
        } else {
          this.writeOpenCurly_();
          this.writelnList_(tree.specifiers, COMMA);
          this.writeCloseCurly_();
        }
      },
      visitImportTypeClause: function(tree) {
        this.write_(TYPE);
        this.writeSpace_();
        this.visitAny(tree.clause);
      },
      visitJsxAttribute: function(tree) {
        this.writeToken_(tree.name);
        if (tree.value !== null) {
          this.write_(EQUAL);
          this.visitAny(tree.value);
        }
      },
      visitJsxElement: function(tree) {
        this.write_(OPEN_ANGLE);
        this.visitAny(tree.name);
        for (var i = 0; i < tree.attributes.length; i++) {
          this.writeSpace_();
          this.visitAny(tree.attributes[i]);
        }
        if (tree.children.length === 0) {
          this.write_(SLASH);
          this.write_(CLOSE_ANGLE);
        } else {
          this.write_(CLOSE_ANGLE);
          this.visitList(tree.children);
          this.write_(OPEN_ANGLE);
          this.write_(SLASH);
          this.lastCode_ = -1;
          this.visitAny(tree.name);
          this.write_(CLOSE_ANGLE);
        }
      },
      visitJsxElementName: function(tree) {
        for (var i = 0; i < tree.names.length; i++) {
          if (i > 0) {
            this.write_(PERIOD);
          }
          this.writeToken_(tree.names[i]);
        }
      },
      visitJsxPlaceholder: function(tree) {
        this.write_(OPEN_CURLY);
        if (tree.expression !== null) {
          this.visitAny(tree.expression);
        }
        this.write_(CLOSE_CURLY);
      },
      visitJsxSpreadAttribute: function(tree) {
        this.write_(OPEN_CURLY);
        this.write_(DOT_DOT_DOT);
        this.visitAny(tree.expression);
        this.write_(CLOSE_CURLY);
      },
      visitJsxText: function(tree) {
        this.writeToken_(tree.value);
      },
      visitLabelledStatement: function(tree) {
        this.writeToken_(tree.name);
        this.write_(COLON);
        this.writeSpace_();
        this.visitAny(tree.statement);
      },
      visitLiteralExpression: function(tree) {
        this.writeToken_(tree.literalToken);
      },
      visitLiteralPropertyName: function(tree) {
        this.writeToken_(tree.literalToken);
      },
      visitMemberExpression: function(tree) {
        this.visitAny(tree.operand);
        if (tree.operand.type === LITERAL_EXPRESSION && tree.operand.literalToken.type === NUMBER) {
          if (!/\.|e|E/.test(tree.operand.literalToken.value))
            this.writeRequiredSpace_();
        }
        this.write_(PERIOD);
        this.writeToken_(tree.memberName);
      },
      visitMemberLookupExpression: function(tree) {
        this.visitAny(tree.operand);
        this.write_(OPEN_SQUARE);
        this.visitAny(tree.memberExpression);
        this.write_(CLOSE_SQUARE);
      },
      visitMethodSignature: function(tree) {
        this.visitAny(tree.name);
        if (tree.optional) {
          this.write_(QUESTION);
        }
        this.visitAny(tree.callSignature);
        this.write_(SEMI_COLON);
      },
      visitSyntaxErrorTree: function(tree) {
        this.write_('(function() {' + ("throw SyntaxError(" + JSON.stringify(tree.message) + ");") + '})()');
      },
      visitModule: function(tree) {
        this.writelnList_(tree.scriptItemList, null);
      },
      visitModuleSpecifier: function(tree) {
        this.writeToken_(tree.token);
      },
      visitNewExpression: function(tree) {
        this.write_(NEW);
        this.writeSpace_();
        this.visitAny(tree.operand);
        this.visitAny(tree.args);
      },
      visitObjectLiteral: function(tree) {
        this.writeOpenCurly_();
        if (tree.propertyNameAndValues.length > 1)
          this.writeln_();
        this.writelnList_(tree.propertyNameAndValues, COMMA);
        if (tree.propertyNameAndValues.length > 1)
          this.writeln_();
        this.writeCloseCurly_();
      },
      visitObjectPattern: function(tree) {
        this.writeOpenCurly_();
        this.writelnList_(tree.fields, COMMA);
        this.writeCloseCurly_();
      },
      visitObjectPatternField: function(tree) {
        this.visitAny(tree.name);
        if (tree.element !== null) {
          this.write_(COLON);
          this.writeSpace_();
          this.visitAny(tree.element);
        }
      },
      visitObjectType: function(tree) {
        this.writeOpenCurly_();
        this.writelnList_(tree.typeMembers, null);
        this.writeCloseCurly_();
      },
      visitParenExpression: function(tree) {
        this.write_(OPEN_PAREN);
        $traceurRuntime.superGet(this, ParseTreeWriter.prototype, "visitParenExpression").call(this, tree);
        this.write_(CLOSE_PAREN);
      },
      visitPostfixExpression: function(tree) {
        this.visitAny(tree.operand);
        if (tree.operand.type === POSTFIX_EXPRESSION && tree.operand.operator.type === tree.operator.type) {
          this.writeRequiredSpace_();
        }
        this.writeToken_(tree.operator);
      },
      visitPredefinedType: function(tree) {
        this.writeToken_(tree.typeToken);
      },
      visitScript: function(tree) {
        this.writelnList_(tree.scriptItemList, null);
      },
      visitMethod: function(tree) {
        this.writeAnnotations_(tree.annotations);
        if (tree.isStatic) {
          this.write_(STATIC);
          this.writeSpace_();
        }
        if (tree.isAsyncFunction() || tree.isAsyncGenerator())
          this.write_(ASYNC);
        if (tree.isGenerator() || tree.isAsyncGenerator())
          this.write_(STAR);
        if (tree.isAsyncGenerator())
          this.writeSpace_();
        this.visitAny(tree.name);
        this.write_(OPEN_PAREN);
        this.visitAny(tree.parameterList);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.writeTypeAnnotation_(tree.typeAnnotation);
        this.visitAny(tree.body);
      },
      visitPropertyNameAssignment: function(tree) {
        this.visitAny(tree.name);
        this.write_(COLON);
        this.writeSpace_();
        this.visitAny(tree.value);
      },
      visitPropertyNameShorthand: function(tree) {
        this.writeToken_(tree.name);
      },
      visitPropertyVariableDeclaration: function(tree) {
        this.writeAnnotations_(tree.annotations);
        if (tree.isStatic) {
          this.write_(STATIC);
          this.writeSpace_();
        }
        this.visitAny(tree.name);
        this.writeTypeAnnotation_(tree.typeAnnotation);
        if (tree.initalizer) {
          this.writeSpace_();
          this.write_(EQUAL);
          this.writeSpace_();
          this.visitAny(tree.initializer);
        }
        this.write_(SEMI_COLON);
      },
      visitPropertySignature: function(tree) {
        this.visitAny(tree.name);
        if (tree.optional) {
          this.write_(QUESTION);
        }
        this.writeTypeAnnotation_(tree.typeAnnotation);
        this.write_(SEMI_COLON);
      },
      visitTemplateLiteralExpression: function(tree) {
        if (tree.operand) {
          this.visitAny(tree.operand);
          this.writeSpace_();
        }
        this.writeRaw_(BACK_QUOTE);
        this.visitList(tree.elements);
        this.writeRaw_(BACK_QUOTE);
      },
      visitTemplateLiteralPortion: function(tree) {
        this.writeToken_(tree.value);
      },
      visitTemplateSubstitution: function(tree) {
        this.writeRaw_('$');
        this.writeRaw_(OPEN_CURLY);
        this.visitAny(tree.expression);
        this.writeRaw_(CLOSE_CURLY);
      },
      visitReturnStatement: function(tree) {
        this.write_(RETURN);
        if (tree.expression) {
          this.writeSpace_(tree.expression);
          this.visitAny(tree.expression);
        }
        this.write_(SEMI_COLON);
      },
      visitRestParameter: function(tree) {
        this.write_(DOT_DOT_DOT);
        this.visitAny(tree.identifier);
      },
      visitSetAccessor: function(tree) {
        this.writeAnnotations_(tree.annotations);
        if (tree.isStatic) {
          this.write_(STATIC);
          this.writeSpace_();
        }
        this.write_(SET);
        this.writeSpace_();
        this.visitAny(tree.name);
        this.write_(OPEN_PAREN);
        this.visitAny(tree.parameterList);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.visitAny(tree.body);
      },
      visitSpreadExpression: function(tree) {
        this.write_(DOT_DOT_DOT);
        this.visitAny(tree.expression);
      },
      visitSpreadPatternElement: function(tree) {
        this.write_(DOT_DOT_DOT);
        this.visitAny(tree.lvalue);
      },
      visitStateMachine: function(tree) {
        throw new Error('State machines cannot be converted to source');
      },
      visitSuperExpression: function(tree) {
        this.write_(SUPER);
      },
      visitSwitchStatement: function(tree) {
        this.write_(SWITCH);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.expression);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.writeOpenCurly_();
        this.writelnList_(tree.caseClauses, null);
        this.writeCloseCurly_();
      },
      visitThisExpression: function(tree) {
        this.write_(THIS);
      },
      visitThrowStatement: function(tree) {
        this.write_(THROW);
        this.writeSpace_();
        this.visitAny(tree.value);
        this.write_(SEMI_COLON);
      },
      visitTryStatement: function(tree) {
        this.write_(TRY);
        this.writeSpace_();
        this.visitAny(tree.body);
        if (tree.catchBlock) {
          this.writeSpace_();
          this.visitAny(tree.catchBlock);
        }
        if (tree.finallyBlock) {
          this.writeSpace_();
          this.visitAny(tree.finallyBlock);
        }
      },
      visitTypeAliasDeclaration: function(tree) {
        this.write_(TYPE);
        this.writeRequiredSpace_();
        this.writeToken_(tree.name);
        this.writeSpace_();
        this.write_(EQUAL);
        this.writeSpace_();
        this.visitAny(tree.value);
        this.write_(SEMI_COLON);
      },
      visitTypeArguments: function(tree) {
        this.write_(OPEN_ANGLE);
        var args = tree.args;
        this.visitAny(args[0]);
        for (var i = 1; i < args.length; i++) {
          this.write_(COMMA);
          this.writeSpace_();
          this.visitAny(args[i]);
        }
        this.write_(CLOSE_ANGLE);
      },
      visitTypeName: function(tree) {
        if (tree.moduleName) {
          this.visitAny(tree.moduleName);
          this.write_(PERIOD);
        }
        this.writeToken_(tree.name);
      },
      visitTypeParameter: function(tree) {
        this.writeToken_(tree.identifierToken);
        if (tree.extendsType) {
          this.writeSpace_();
          this.write_(EXTENDS);
          this.writeSpace_();
          this.visitAny(tree.extendsType);
        }
      },
      visitTypeParameters: function(tree) {
        this.write_(OPEN_ANGLE);
        this.writeList_(tree.parameters, COMMA, false);
        this.write_(CLOSE_ANGLE);
      },
      visitUnaryExpression: function(tree) {
        var op = tree.operator;
        this.writeToken_(op);
        var operand = tree.operand;
        if (operand.type === UNARY_EXPRESSION && requiresSpaceBetween(op.type, operand.operator.type)) {
          this.writeRequiredSpace_();
        }
        this.visitAny(operand);
      },
      visitUnionType: function(tree) {
        this.visitAny(tree.types[0]);
        for (var i = 1; i < tree.types.length; i++) {
          this.writeSpace_();
          this.write_(BAR);
          this.writeSpace_();
          this.visitAny(tree.types[i]);
        }
      },
      visitVariableDeclarationList: function(tree) {
        this.write_(tree.declarationType);
        this.writeSpace_();
        this.writeList_(tree.declarations, COMMA, true, 2);
      },
      visitVariableDeclaration: function(tree) {
        this.visitAny(tree.lvalue);
        this.writeTypeAnnotation_(tree.typeAnnotation);
        if (tree.initializer !== null) {
          this.writeSpace_();
          this.write_(EQUAL);
          this.writeSpace_();
          this.visitAny(tree.initializer);
        }
      },
      visitVariableStatement: function(tree) {
        $traceurRuntime.superGet(this, ParseTreeWriter.prototype, "visitVariableStatement").call(this, tree);
        this.write_(SEMI_COLON);
      },
      visitWhileStatement: function(tree) {
        this.write_(WHILE);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.condition);
        this.write_(CLOSE_PAREN);
        this.visitAnyBlockOrIndent_(tree.body);
      },
      visitWithStatement: function(tree) {
        this.write_(WITH);
        this.writeSpace_();
        this.write_(OPEN_PAREN);
        this.visitAny(tree.expression);
        this.write_(CLOSE_PAREN);
        this.writeSpace_();
        this.visitAny(tree.body);
      },
      visitYieldExpression: function(tree) {
        this.write_(YIELD);
        if (tree.isYieldFor)
          this.write_(STAR);
        if (tree.expression) {
          this.writeSpace_();
          this.visitAny(tree.expression);
        }
      },
      writeCurrentln_: function() {
        this.result_ += this.currentLine_ + NEW_LINE;
      },
      writeln_: function() {
        if (this.currentLine_)
          this.writeCurrentln_();
        this.currentLine_ = '';
        this.lastCode_ = -1;
      },
      writelnList_: function(list, delimiter) {
        if (delimiter !== null) {
          this.writeList_(list, delimiter, true);
        } else {
          if (list.length > 0)
            this.writeln_();
          this.writeList_(list, '', true);
          if (list.length > 0)
            this.writeln_();
        }
      },
      writeList_: function(list, delimiter, writeNewLine) {
        var indent = arguments[3] !== (void 0) ? arguments[3] : 0;
        var first = true;
        for (var i = 0; i < list.length; i++) {
          if (first) {
            first = false;
          } else {
            if (delimiter !== '') {
              this.write_(delimiter);
              if (!writeNewLine)
                this.writeSpace_();
            }
            if (writeNewLine) {
              if (i === 1)
                this.indentDepth_ += indent;
              this.writeln_();
            }
          }
          this.visitAny(list[i]);
        }
        if (writeNewLine && list.length > 1)
          this.indentDepth_ -= indent;
      },
      writeRaw_: function(value) {
        this.currentLine_ += value;
        this.lastCode_ = value.charCodeAt(value.length - 1);
      },
      writeToken_: function(token) {
        this.write_(token.toString());
      },
      write_: function(value) {
        if (this.prettyPrint_ && this.currentLine_.length === 0) {
          for (var i = 0,
              indent = this.indentDepth_; i < indent; i++) {
            this.writeRaw_('  ');
          }
        }
        if (this.needsSpace_(value)) {
          this.writeRaw_(' ');
        }
        this.writeRaw_(value);
      },
      writeCloseCurly_: function() {
        this.indentDepth_--;
        this.write_(CLOSE_CURLY);
      },
      writeOpenCurly_: function() {
        this.write_(OPEN_CURLY);
        this.indentDepth_++;
      },
      writeSpace_: function() {
        if (this.prettyPrint_ && !isWhitespace(this.lastCode_)) {
          this.writeRaw_(' ');
        }
      },
      writeRequiredSpace_: function() {
        if (!isWhitespace(this.lastCode_)) {
          this.writeRaw_(' ');
        }
      },
      writeTypeAnnotation_: function(typeAnnotation) {
        if (typeAnnotation !== null) {
          this.write_(COLON);
          this.writeSpace_();
          this.visitAny(typeAnnotation);
        }
      },
      writeAnnotations_: function(annotations) {
        var writeNewLine = arguments[1] !== (void 0) ? arguments[1] : this.prettyPrint_;
        if (annotations.length > 0) {
          this.writeList_(annotations, '', writeNewLine);
          if (writeNewLine)
            this.writeln_();
        }
      },
      needsSpace_: function(token) {
        var lastCode = this.lastCode_;
        if (isWhitespace(lastCode))
          return false;
        var firstCode = token.toString().charCodeAt(0);
        return isIdentifierPart(firstCode) && (isIdentifierPart(lastCode) || lastCode === 47);
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  function requiresSpaceBetween(first, second) {
    return (first === MINUS || first === MINUS_MINUS) && (second === MINUS || second === MINUS_MINUS) || (first === PLUS || first === PLUS_PLUS) && (second === PLUS || second === PLUS_PLUS);
  }
  return {get ParseTreeWriter() {
      return ParseTreeWriter;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/outputgeneration/ParseTreeMapWriter.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/outputgeneration/ParseTreeMapWriter.js";
  var ParseTreeWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeWriter.js", "traceur@0.0.112/src/outputgeneration/ParseTreeMapWriter.js")).ParseTreeWriter;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringSet.js", "traceur@0.0.112/src/outputgeneration/ParseTreeMapWriter.js")).StringSet;
  var ParseTreeMapWriter = function($__super) {
    function ParseTreeMapWriter(sourceMapConfiguration) {
      var options = arguments[1];
      $traceurRuntime.superConstructor(ParseTreeMapWriter).call(this, options);
      this.sourceMapGenerator_ = sourceMapConfiguration.sourceMapGenerator;
      this.lowResolution_ = sourceMapConfiguration.lowResolution;
      this.basepath_ = sourceMapConfiguration.basepath;
      this.outputLineCount_ = 1;
      this.isFirstMapping_ = true;
      this.sourcesInMap_ = new StringSet();
      this.relativeSourceName_ = '';
      this.generated_ = null;
      this.original_ = null;
      this.previousMapping_ = null;
    }
    return ($traceurRuntime.createClass)(ParseTreeMapWriter, {
      visitAny: function(tree) {
        if (tree === null) {
          return;
        }
        if (tree.location !== null)
          this.enterBranch(tree.location);
        $traceurRuntime.superGet(this, ParseTreeMapWriter.prototype, "visitAny").call(this, tree);
        if (tree.location !== null)
          this.exitBranch(tree.location);
      },
      writeCurrentln_: function() {
        $traceurRuntime.superGet(this, ParseTreeMapWriter.prototype, "writeCurrentln_").call(this);
        this.flushMappings();
        this.outputLineCount_++;
        this.generated_ = {
          line: this.outputLineCount_,
          column: 0
        };
        this.flushMappings();
      },
      write_: function(value) {
        this.generate();
        $traceurRuntime.superGet(this, ParseTreeMapWriter.prototype, "write_").call(this, value);
        this.generate();
      },
      generate: function() {
        var length = this.currentLine_.length;
        var column = length ? length - 1 : 0;
        this.generated_ = {
          line: this.outputLineCount_,
          column: column
        };
        this.flushMappings();
      },
      enterBranch: function(location) {
        var $__2 = location.start,
            line = $__2.line,
            column = $__2.column,
            source = $__2.source;
        this.originate(line, column, source);
      },
      exitBranch: function(location) {
        var $__2 = location.end,
            line = $__2.line,
            column = $__2.column,
            source = $__2.source;
        this.originate(line, column ? column - 1 : 0, source);
      },
      originate: function(line, column, source) {
        line++;
        if (this.original_ && this.original_.line !== line)
          this.flushMappings();
        this.original_ = {
          line: line,
          column: column
        };
        var name = source.name;
        if (name && !this.sourcesInMap_.has(name)) {
          this.sourcesInMap_.add(name);
          this.relativeSourceName_ = relativePath(name, this.basepath_);
          this.sourceMapGenerator_.setSourceContent(this.relativeSourceName_, source.contents);
        }
        this.flushMappings();
      },
      flushMappings: function() {
        if (this.original_ && this.generated_) {
          this.addMapping();
          this.original_ = null;
          this.generated_ = null;
        }
      },
      isSame: function(lhs, rhs) {
        return lhs.line === rhs.line && lhs.column === rhs.column;
      },
      skipMapping: function() {
        if (!this.previousMapping_)
          return false;
        if (this.lowResolution_ && this.previousMapping_.generated.line === this.generated_.line)
          return true;
        if (this.isSame(this.previousMapping_.generated, this.generated_) && this.isSame(this.previousMapping_.original, this.original_))
          return true;
      },
      addMapping: function() {
        if (this.skipMapping())
          return;
        var mapping = {
          generated: this.generated_,
          original: this.original_,
          source: this.relativeSourceName_
        };
        this.sourceMapGenerator_.addMapping(mapping);
        this.previousMapping_ = mapping;
      }
    }, {}, $__super);
  }(ParseTreeWriter);
  function relativePath(name, sourceRoot) {
    var $__3;
    if (!name || name[0] === '@')
      return name;
    if (!sourceRoot)
      return name;
    var nameSegments = name.split('/');
    var rootSegments = sourceRoot.split('/');
    if (rootSegments[rootSegments.length - 1]) {
      throw new Error('rootPath must end in /');
    }
    var commonSegmentsLength = 0;
    var uniqueSegments = [];
    var foundUnique = false;
    nameSegments.forEach(function(segment, index) {
      if (!foundUnique && segment === rootSegments[index]) {
        commonSegmentsLength++;
        return;
      }
      foundUnique = true;
      uniqueSegments.push(segment);
    });
    if (commonSegmentsLength < 1 || commonSegmentsLength === rootSegments.length)
      return name;
    var dotDotSegments = rootSegments.length - commonSegmentsLength - 1;
    var segments = [];
    while (dotDotSegments--) {
      segments.push('..');
    }
    ($__3 = segments).push.apply($__3, $traceurRuntime.spread(uniqueSegments));
    return segments.join('/');
  }
  return {
    get ParseTreeMapWriter() {
      return ParseTreeMapWriter;
    },
    get relativePath() {
      return relativePath;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/outputgeneration/SourceMapIntegration.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/outputgeneration/SourceMapIntegration.js";
  function makeDefine(mapping, id) {
    var require = function(id) {
      return mapping[id];
    };
    var exports = mapping[id] = {};
    var module = null;
    return function(factory) {
      factory(require, exports, module);
    };
  }
  var define,
      m = {};
  define = makeDefine(m, './util');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    function getArg(aArgs, aName, aDefaultValue) {
      if (aName in aArgs) {
        return aArgs[aName];
      } else if (arguments.length === 3) {
        return aDefaultValue;
      } else {
        throw new Error('"' + aName + '" is a required argument.');
      }
    }
    exports.getArg = getArg;
    var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
    var dataUrlRegexp = /^data:.+\,.+$/;
    function urlParse(aUrl) {
      var match = aUrl.match(urlRegexp);
      if (!match) {
        return null;
      }
      return {
        scheme: match[1],
        auth: match[2],
        host: match[3],
        port: match[4],
        path: match[5]
      };
    }
    exports.urlParse = urlParse;
    function urlGenerate(aParsedUrl) {
      var url = '';
      if (aParsedUrl.scheme) {
        url += aParsedUrl.scheme + ':';
      }
      url += '//';
      if (aParsedUrl.auth) {
        url += aParsedUrl.auth + '@';
      }
      if (aParsedUrl.host) {
        url += aParsedUrl.host;
      }
      if (aParsedUrl.port) {
        url += ":" + aParsedUrl.port;
      }
      if (aParsedUrl.path) {
        url += aParsedUrl.path;
      }
      return url;
    }
    exports.urlGenerate = urlGenerate;
    function normalize(aPath) {
      var path = aPath;
      var url = urlParse(aPath);
      if (url) {
        if (!url.path) {
          return aPath;
        }
        path = url.path;
      }
      var isAbsolute = (path.charAt(0) === '/');
      var parts = path.split(/\/+/);
      for (var part = void 0,
          up = 0,
          i = parts.length - 1; i >= 0; i--) {
        part = parts[i];
        if (part === '.') {
          parts.splice(i, 1);
        } else if (part === '..') {
          up++;
        } else if (up > 0) {
          if (part === '') {
            parts.splice(i + 1, up);
            up = 0;
          } else {
            parts.splice(i, 2);
            up--;
          }
        }
      }
      path = parts.join('/');
      if (path === '') {
        path = isAbsolute ? '/' : '.';
      }
      if (url) {
        url.path = path;
        return urlGenerate(url);
      }
      return path;
    }
    exports.normalize = normalize;
    function join(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      if (aPath === "") {
        aPath = ".";
      }
      var aPathUrl = urlParse(aPath);
      var aRootUrl = urlParse(aRoot);
      if (aRootUrl) {
        aRoot = aRootUrl.path || '/';
      }
      if (aPathUrl && !aPathUrl.scheme) {
        if (aRootUrl) {
          aPathUrl.scheme = aRootUrl.scheme;
        }
        return urlGenerate(aPathUrl);
      }
      if (aPathUrl || aPath.match(dataUrlRegexp)) {
        return aPath;
      }
      if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
        aRootUrl.host = aPath;
        return urlGenerate(aRootUrl);
      }
      var joined = aPath.charAt(0) === '/' ? aPath : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
      if (aRootUrl) {
        aRootUrl.path = joined;
        return urlGenerate(aRootUrl);
      }
      return joined;
    }
    exports.join = join;
    function relative(aRoot, aPath) {
      if (aRoot === "") {
        aRoot = ".";
      }
      aRoot = aRoot.replace(/\/$/, '');
      var url = urlParse(aRoot);
      if (aPath.charAt(0) == "/" && url && url.path == "/") {
        return aPath.slice(1);
      }
      return aPath.indexOf(aRoot + '/') === 0 ? aPath.substr(aRoot.length + 1) : aPath;
    }
    exports.relative = relative;
    function toSetString(aStr) {
      return '$' + aStr;
    }
    exports.toSetString = toSetString;
    function fromSetString(aStr) {
      return aStr.substr(1);
    }
    exports.fromSetString = fromSetString;
    function strcmp(aStr1, aStr2) {
      var s1 = aStr1 || "";
      var s2 = aStr2 || "";
      return (s1 > s2) - (s1 < s2);
    }
    function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
      var cmp;
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp || onlyCompareOriginal) {
        return cmp;
      }
      cmp = strcmp(mappingA.name, mappingB.name);
      if (cmp) {
        return cmp;
      }
      cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp) {
        return cmp;
      }
      return mappingA.generatedColumn - mappingB.generatedColumn;
    }
    ;
    exports.compareByOriginalPositions = compareByOriginalPositions;
    function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) {
      var cmp;
      cmp = mappingA.generatedLine - mappingB.generatedLine;
      if (cmp) {
        return cmp;
      }
      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
      if (cmp || onlyCompareGenerated) {
        return cmp;
      }
      cmp = strcmp(mappingA.source, mappingB.source);
      if (cmp) {
        return cmp;
      }
      cmp = mappingA.originalLine - mappingB.originalLine;
      if (cmp) {
        return cmp;
      }
      cmp = mappingA.originalColumn - mappingB.originalColumn;
      if (cmp) {
        return cmp;
      }
      return strcmp(mappingA.name, mappingB.name);
    }
    ;
    exports.compareByGeneratedPositions = compareByGeneratedPositions;
  });
  define = makeDefine(m, './array-set');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    var util = require('./util');
    function ArraySet() {
      this._array = [];
      this._set = {};
    }
    ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
      var set = new ArraySet();
      for (var i = 0,
          len = aArray.length; i < len; i++) {
        set.add(aArray[i], aAllowDuplicates);
      }
      return set;
    };
    ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
      var isDuplicate = this.has(aStr);
      var idx = this._array.length;
      if (!isDuplicate || aAllowDuplicates) {
        this._array.push(aStr);
      }
      if (!isDuplicate) {
        this._set[util.toSetString(aStr)] = idx;
      }
    };
    ArraySet.prototype.has = function ArraySet_has(aStr) {
      return Object.prototype.hasOwnProperty.call(this._set, util.toSetString(aStr));
    };
    ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
      if (this.has(aStr)) {
        return this._set[util.toSetString(aStr)];
      }
      throw new Error('"' + aStr + '" is not in the set.');
    };
    ArraySet.prototype.at = function ArraySet_at(aIdx) {
      if (aIdx >= 0 && aIdx < this._array.length) {
        return this._array[aIdx];
      }
      throw new Error('No element indexed by ' + aIdx);
    };
    ArraySet.prototype.toArray = function ArraySet_toArray() {
      return this._array.slice();
    };
    exports.ArraySet = ArraySet;
  });
  define = makeDefine(m, './base64');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    var charToIntMap = {};
    var intToCharMap = {};
    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('').forEach(function(ch, index) {
      charToIntMap[ch] = index;
      intToCharMap[index] = ch;
    });
    exports.encode = function base64_encode(aNumber) {
      if (aNumber in intToCharMap) {
        return intToCharMap[aNumber];
      }
      throw new TypeError("Must be between 0 and 63: " + aNumber);
    };
    exports.decode = function base64_decode(aChar) {
      if (aChar in charToIntMap) {
        return charToIntMap[aChar];
      }
      throw new TypeError("Not a valid base 64 digit: " + aChar);
    };
  });
  define = makeDefine(m, './base64-vlq');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    var base64 = require('./base64');
    var VLQ_BASE_SHIFT = 5;
    var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
    var VLQ_BASE_MASK = VLQ_BASE - 1;
    var VLQ_CONTINUATION_BIT = VLQ_BASE;
    function toVLQSigned(aValue) {
      return aValue < 0 ? ((-aValue) << 1) + 1 : (aValue << 1) + 0;
    }
    function fromVLQSigned(aValue) {
      var isNegative = (aValue & 1) === 1;
      var shifted = aValue >> 1;
      return isNegative ? -shifted : shifted;
    }
    exports.encode = function base64VLQ_encode(aValue) {
      var encoded = "";
      var digit;
      var vlq = toVLQSigned(aValue);
      do {
        digit = vlq & VLQ_BASE_MASK;
        vlq >>>= VLQ_BASE_SHIFT;
        if (vlq > 0) {
          digit |= VLQ_CONTINUATION_BIT;
        }
        encoded += base64.encode(digit);
      } while (vlq > 0);
      return encoded;
    };
    exports.decode = function base64VLQ_decode(aStr, aOutParam) {
      var i = 0;
      var strLen = aStr.length;
      var result = 0;
      var shift = 0;
      var continuation,
          digit;
      do {
        if (i >= strLen) {
          throw new Error("Expected more digits in base 64 VLQ value.");
        }
        digit = base64.decode(aStr.charAt(i++));
        continuation = !!(digit & VLQ_CONTINUATION_BIT);
        digit &= VLQ_BASE_MASK;
        result = result + (digit << shift);
        shift += VLQ_BASE_SHIFT;
      } while (continuation);
      aOutParam.value = fromVLQSigned(result);
      aOutParam.rest = aStr.slice(i);
    };
  });
  define = makeDefine(m, './binary-search');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
      var mid = Math.floor((aHigh - aLow) / 2) + aLow;
      var cmp = aCompare(aNeedle, aHaystack[mid], true);
      if (cmp === 0) {
        return mid;
      } else if (cmp > 0) {
        if (aHigh - mid > 1) {
          return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
        }
        return mid;
      } else {
        if (mid - aLow > 1) {
          return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
        }
        return aLow < 0 ? -1 : aLow;
      }
    }
    exports.search = function search(aNeedle, aHaystack, aCompare) {
      if (aHaystack.length === 0) {
        return -1;
      }
      return recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare);
    };
  });
  define = makeDefine(m, './mapping-list');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    var util = require('./util');
    function generatedPositionAfter(mappingA, mappingB) {
      var lineA = mappingA.generatedLine;
      var lineB = mappingB.generatedLine;
      var columnA = mappingA.generatedColumn;
      var columnB = mappingB.generatedColumn;
      return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositions(mappingA, mappingB) <= 0;
    }
    function MappingList() {
      this._array = [];
      this._sorted = true;
      this._last = {
        generatedLine: -1,
        generatedColumn: 0
      };
    }
    MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
      this._array.forEach(aCallback, aThisArg);
    };
    MappingList.prototype.add = function MappingList_add(aMapping) {
      var mapping;
      if (generatedPositionAfter(this._last, aMapping)) {
        this._last = aMapping;
        this._array.push(aMapping);
      } else {
        this._sorted = false;
        this._array.push(aMapping);
      }
    };
    MappingList.prototype.toArray = function MappingList_toArray() {
      if (!this._sorted) {
        this._array.sort(util.compareByGeneratedPositions);
        this._sorted = true;
      }
      return this._array;
    };
    exports.MappingList = MappingList;
  });
  define = makeDefine(m, './source-map-generator');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    var base64VLQ = require('./base64-vlq');
    var util = require('./util');
    var ArraySet = require('./array-set').ArraySet;
    var MappingList = require('./mapping-list').MappingList;
    function SourceMapGenerator(aArgs) {
      if (!aArgs) {
        aArgs = {};
      }
      this._file = util.getArg(aArgs, 'file', null);
      this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
      this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
      this._sources = new ArraySet();
      this._names = new ArraySet();
      this._mappings = new MappingList();
      this._sourcesContents = null;
    }
    SourceMapGenerator.prototype._version = 3;
    SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
      var sourceRoot = aSourceMapConsumer.sourceRoot;
      var generator = new SourceMapGenerator({
        file: aSourceMapConsumer.file,
        sourceRoot: sourceRoot
      });
      aSourceMapConsumer.eachMapping(function(mapping) {
        var newMapping = {generated: {
            line: mapping.generatedLine,
            column: mapping.generatedColumn
          }};
        if (mapping.source != null) {
          newMapping.source = mapping.source;
          if (sourceRoot != null) {
            newMapping.source = util.relative(sourceRoot, newMapping.source);
          }
          newMapping.original = {
            line: mapping.originalLine,
            column: mapping.originalColumn
          };
          if (mapping.name != null) {
            newMapping.name = mapping.name;
          }
        }
        generator.addMapping(newMapping);
      });
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          generator.setSourceContent(sourceFile, content);
        }
      });
      return generator;
    };
    SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
      var generated = util.getArg(aArgs, 'generated');
      var original = util.getArg(aArgs, 'original', null);
      var source = util.getArg(aArgs, 'source', null);
      var name = util.getArg(aArgs, 'name', null);
      if (!this._skipValidation) {
        this._validateMapping(generated, original, source, name);
      }
      if (source != null && !this._sources.has(source)) {
        this._sources.add(source);
      }
      if (name != null && !this._names.has(name)) {
        this._names.add(name);
      }
      this._mappings.add({
        generatedLine: generated.line,
        generatedColumn: generated.column,
        originalLine: original != null && original.line,
        originalColumn: original != null && original.column,
        source: source,
        name: name
      });
    };
    SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
      var source = aSourceFile;
      if (this._sourceRoot != null) {
        source = util.relative(this._sourceRoot, source);
      }
      if (aSourceContent != null) {
        if (!this._sourcesContents) {
          this._sourcesContents = {};
        }
        this._sourcesContents[util.toSetString(source)] = aSourceContent;
      } else if (this._sourcesContents) {
        delete this._sourcesContents[util.toSetString(source)];
        if (Object.keys(this._sourcesContents).length === 0) {
          this._sourcesContents = null;
        }
      }
    };
    SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
      var sourceFile = aSourceFile;
      if (aSourceFile == null) {
        if (aSourceMapConsumer.file == null) {
          throw new Error('SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' + 'or the source map\'s "file" property. Both were omitted.');
        }
        sourceFile = aSourceMapConsumer.file;
      }
      var sourceRoot = this._sourceRoot;
      if (sourceRoot != null) {
        sourceFile = util.relative(sourceRoot, sourceFile);
      }
      var newSources = new ArraySet();
      var newNames = new ArraySet();
      this._mappings.unsortedForEach(function(mapping) {
        if (mapping.source === sourceFile && mapping.originalLine != null) {
          var original = aSourceMapConsumer.originalPositionFor({
            line: mapping.originalLine,
            column: mapping.originalColumn
          });
          if (original.source != null) {
            mapping.source = original.source;
            if (aSourceMapPath != null) {
              mapping.source = util.join(aSourceMapPath, mapping.source);
            }
            if (sourceRoot != null) {
              mapping.source = util.relative(sourceRoot, mapping.source);
            }
            mapping.originalLine = original.line;
            mapping.originalColumn = original.column;
            if (original.name != null) {
              mapping.name = original.name;
            }
          }
        }
        var source = mapping.source;
        if (source != null && !newSources.has(source)) {
          newSources.add(source);
        }
        var name = mapping.name;
        if (name != null && !newNames.has(name)) {
          newNames.add(name);
        }
      }, this);
      this._sources = newSources;
      this._names = newNames;
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          if (aSourceMapPath != null) {
            sourceFile = util.join(aSourceMapPath, sourceFile);
          }
          if (sourceRoot != null) {
            sourceFile = util.relative(sourceRoot, sourceFile);
          }
          this.setSourceContent(sourceFile, content);
        }
      }, this);
    };
    SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
      if (aGenerated && 'line' in aGenerated && 'column' in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
        return;
      } else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated && aOriginal && 'line' in aOriginal && 'column' in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
        return;
      } else {
        throw new Error('Invalid mapping: ' + JSON.stringify({
          generated: aGenerated,
          source: aSource,
          original: aOriginal,
          name: aName
        }));
      }
    };
    SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
      var previousGeneratedColumn = 0;
      var previousGeneratedLine = 1;
      var previousOriginalColumn = 0;
      var previousOriginalLine = 0;
      var previousName = 0;
      var previousSource = 0;
      var result = '';
      var mapping;
      var mappings = this._mappings.toArray();
      for (var i = 0,
          len = mappings.length; i < len; i++) {
        mapping = mappings[i];
        if (mapping.generatedLine !== previousGeneratedLine) {
          previousGeneratedColumn = 0;
          while (mapping.generatedLine !== previousGeneratedLine) {
            result += ';';
            previousGeneratedLine++;
          }
        } else {
          if (i > 0) {
            if (!util.compareByGeneratedPositions(mapping, mappings[i - 1])) {
              continue;
            }
            result += ',';
          }
        }
        result += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
        previousGeneratedColumn = mapping.generatedColumn;
        if (mapping.source != null) {
          result += base64VLQ.encode(this._sources.indexOf(mapping.source) - previousSource);
          previousSource = this._sources.indexOf(mapping.source);
          result += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
          previousOriginalLine = mapping.originalLine - 1;
          result += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
          previousOriginalColumn = mapping.originalColumn;
          if (mapping.name != null) {
            result += base64VLQ.encode(this._names.indexOf(mapping.name) - previousName);
            previousName = this._names.indexOf(mapping.name);
          }
        }
      }
      return result;
    };
    SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
      return aSources.map(function(source) {
        if (!this._sourcesContents) {
          return null;
        }
        if (aSourceRoot != null) {
          source = util.relative(aSourceRoot, source);
        }
        var key = util.toSetString(source);
        return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
      }, this);
    };
    SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
      var map = {
        version: this._version,
        sources: this._sources.toArray(),
        names: this._names.toArray(),
        mappings: this._serializeMappings()
      };
      if (this._file != null) {
        map.file = this._file;
      }
      if (this._sourceRoot != null) {
        map.sourceRoot = this._sourceRoot;
      }
      if (this._sourcesContents) {
        map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
      }
      return map;
    };
    SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
      return JSON.stringify(this);
    };
    exports.SourceMapGenerator = SourceMapGenerator;
  });
  define = makeDefine(m, './source-map-consumer');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    var util = require('./util');
    var binarySearch = require('./binary-search');
    var ArraySet = require('./array-set').ArraySet;
    var base64VLQ = require('./base64-vlq');
    function SourceMapConsumer(aSourceMap) {
      var sourceMap = aSourceMap;
      if (typeof aSourceMap === 'string') {
        sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
      }
      var version = util.getArg(sourceMap, 'version');
      var sources = util.getArg(sourceMap, 'sources');
      var names = util.getArg(sourceMap, 'names', []);
      var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
      var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
      var mappings = util.getArg(sourceMap, 'mappings');
      var file = util.getArg(sourceMap, 'file', null);
      if (version != this._version) {
        throw new Error('Unsupported version: ' + version);
      }
      sources = sources.map(util.normalize);
      this._names = ArraySet.fromArray(names, true);
      this._sources = ArraySet.fromArray(sources, true);
      this.sourceRoot = sourceRoot;
      this.sourcesContent = sourcesContent;
      this._mappings = mappings;
      this.file = file;
    }
    SourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap) {
      var smc = Object.create(SourceMapConsumer.prototype);
      smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
      smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
      smc.sourceRoot = aSourceMap._sourceRoot;
      smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
      smc.file = aSourceMap._file;
      smc.__generatedMappings = aSourceMap._mappings.toArray().slice();
      smc.__originalMappings = aSourceMap._mappings.toArray().slice().sort(util.compareByOriginalPositions);
      return smc;
    };
    SourceMapConsumer.prototype._version = 3;
    Object.defineProperty(SourceMapConsumer.prototype, 'sources', {get: function() {
        return this._sources.toArray().map(function(s) {
          return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
        }, this);
      }});
    SourceMapConsumer.prototype.__generatedMappings = null;
    Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {get: function() {
        if (!this.__generatedMappings) {
          this.__generatedMappings = [];
          this.__originalMappings = [];
          this._parseMappings(this._mappings, this.sourceRoot);
        }
        return this.__generatedMappings;
      }});
    SourceMapConsumer.prototype.__originalMappings = null;
    Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {get: function() {
        if (!this.__originalMappings) {
          this.__generatedMappings = [];
          this.__originalMappings = [];
          this._parseMappings(this._mappings, this.sourceRoot);
        }
        return this.__originalMappings;
      }});
    SourceMapConsumer.prototype._nextCharIsMappingSeparator = function SourceMapConsumer_nextCharIsMappingSeparator(aStr) {
      var c = aStr.charAt(0);
      return c === ";" || c === ",";
    };
    SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      var generatedLine = 1;
      var previousGeneratedColumn = 0;
      var previousOriginalLine = 0;
      var previousOriginalColumn = 0;
      var previousSource = 0;
      var previousName = 0;
      var str = aStr;
      var temp = {};
      var mapping;
      while (str.length > 0) {
        if (str.charAt(0) === ';') {
          generatedLine++;
          str = str.slice(1);
          previousGeneratedColumn = 0;
        } else if (str.charAt(0) === ',') {
          str = str.slice(1);
        } else {
          mapping = {};
          mapping.generatedLine = generatedLine;
          base64VLQ.decode(str, temp);
          mapping.generatedColumn = previousGeneratedColumn + temp.value;
          previousGeneratedColumn = mapping.generatedColumn;
          str = temp.rest;
          if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
            base64VLQ.decode(str, temp);
            mapping.source = this._sources.at(previousSource + temp.value);
            previousSource += temp.value;
            str = temp.rest;
            if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
              throw new Error('Found a source, but no line and column');
            }
            base64VLQ.decode(str, temp);
            mapping.originalLine = previousOriginalLine + temp.value;
            previousOriginalLine = mapping.originalLine;
            mapping.originalLine += 1;
            str = temp.rest;
            if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
              throw new Error('Found a source and line, but no column');
            }
            base64VLQ.decode(str, temp);
            mapping.originalColumn = previousOriginalColumn + temp.value;
            previousOriginalColumn = mapping.originalColumn;
            str = temp.rest;
            if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
              base64VLQ.decode(str, temp);
              mapping.name = this._names.at(previousName + temp.value);
              previousName += temp.value;
              str = temp.rest;
            }
          }
          this.__generatedMappings.push(mapping);
          if (typeof mapping.originalLine === 'number') {
            this.__originalMappings.push(mapping);
          }
        }
      }
      this.__generatedMappings.sort(util.compareByGeneratedPositions);
      this.__originalMappings.sort(util.compareByOriginalPositions);
    };
    SourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator) {
      if (aNeedle[aLineName] <= 0) {
        throw new TypeError('Line must be greater than or equal to 1, got ' + aNeedle[aLineName]);
      }
      if (aNeedle[aColumnName] < 0) {
        throw new TypeError('Column must be greater than or equal to 0, got ' + aNeedle[aColumnName]);
      }
      return binarySearch.search(aNeedle, aMappings, aComparator);
    };
    SourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
      for (var index = 0; index < this._generatedMappings.length; ++index) {
        var mapping = this._generatedMappings[index];
        if (index + 1 < this._generatedMappings.length) {
          var nextMapping = this._generatedMappings[index + 1];
          if (mapping.generatedLine === nextMapping.generatedLine) {
            mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
            continue;
          }
        }
        mapping.lastGeneratedColumn = Infinity;
      }
    };
    SourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
      var needle = {
        generatedLine: util.getArg(aArgs, 'line'),
        generatedColumn: util.getArg(aArgs, 'column')
      };
      var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositions);
      if (index >= 0) {
        var mapping = this._generatedMappings[index];
        if (mapping.generatedLine === needle.generatedLine) {
          var source = util.getArg(mapping, 'source', null);
          if (source != null && this.sourceRoot != null) {
            source = util.join(this.sourceRoot, source);
          }
          return {
            source: source,
            line: util.getArg(mapping, 'originalLine', null),
            column: util.getArg(mapping, 'originalColumn', null),
            name: util.getArg(mapping, 'name', null)
          };
        }
      }
      return {
        source: null,
        line: null,
        column: null,
        name: null
      };
    };
    SourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource) {
      if (!this.sourcesContent) {
        return null;
      }
      if (this.sourceRoot != null) {
        aSource = util.relative(this.sourceRoot, aSource);
      }
      if (this._sources.has(aSource)) {
        return this.sourcesContent[this._sources.indexOf(aSource)];
      }
      var url;
      if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
        var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
        if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) {
          return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
        }
        if ((!url.path || url.path == "/") && this._sources.has("/" + aSource)) {
          return this.sourcesContent[this._sources.indexOf("/" + aSource)];
        }
      }
      throw new Error('"' + aSource + '" is not in the SourceMap.');
    };
    SourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
      var needle = {
        source: util.getArg(aArgs, 'source'),
        originalLine: util.getArg(aArgs, 'line'),
        originalColumn: util.getArg(aArgs, 'column')
      };
      if (this.sourceRoot != null) {
        needle.source = util.relative(this.sourceRoot, needle.source);
      }
      var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions);
      if (index >= 0) {
        var mapping = this._originalMappings[index];
        return {
          line: util.getArg(mapping, 'generatedLine', null),
          column: util.getArg(mapping, 'generatedColumn', null),
          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
        };
      }
      return {
        line: null,
        column: null,
        lastColumn: null
      };
    };
    SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
      var needle = {
        source: util.getArg(aArgs, 'source'),
        originalLine: util.getArg(aArgs, 'line'),
        originalColumn: Infinity
      };
      if (this.sourceRoot != null) {
        needle.source = util.relative(this.sourceRoot, needle.source);
      }
      var mappings = [];
      var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions);
      if (index >= 0) {
        var mapping = this._originalMappings[index];
        while (mapping && mapping.originalLine === needle.originalLine) {
          mappings.push({
            line: util.getArg(mapping, 'generatedLine', null),
            column: util.getArg(mapping, 'generatedColumn', null),
            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
          });
          mapping = this._originalMappings[--index];
        }
      }
      return mappings.reverse();
    };
    SourceMapConsumer.GENERATED_ORDER = 1;
    SourceMapConsumer.ORIGINAL_ORDER = 2;
    SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
      var context = aContext || null;
      var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
      var mappings;
      switch (order) {
        case SourceMapConsumer.GENERATED_ORDER:
          mappings = this._generatedMappings;
          break;
        case SourceMapConsumer.ORIGINAL_ORDER:
          mappings = this._originalMappings;
          break;
        default:
          throw new Error("Unknown order of iteration.");
      }
      var sourceRoot = this.sourceRoot;
      mappings.map(function(mapping) {
        var source = mapping.source;
        if (source != null && sourceRoot != null) {
          source = util.join(sourceRoot, source);
        }
        return {
          source: source,
          generatedLine: mapping.generatedLine,
          generatedColumn: mapping.generatedColumn,
          originalLine: mapping.originalLine,
          originalColumn: mapping.originalColumn,
          name: mapping.name
        };
      }).forEach(aCallback, context);
    };
    exports.SourceMapConsumer = SourceMapConsumer;
  });
  define = makeDefine(m, './source-node');
  if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
  }
  define(function(require, exports, module) {
    var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
    var util = require('./util');
    var REGEX_NEWLINE = /(\r?\n)/;
    var NEWLINE_CODE = 10;
    var isSourceNode = "$$$isSourceNode$$$";
    function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
      this.children = [];
      this.sourceContents = {};
      this.line = aLine == null ? null : aLine;
      this.column = aColumn == null ? null : aColumn;
      this.source = aSource == null ? null : aSource;
      this.name = aName == null ? null : aName;
      this[isSourceNode] = true;
      if (aChunks != null)
        this.add(aChunks);
    }
    SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
      var node = new SourceNode();
      var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
      var shiftNextLine = function() {
        var lineContents = remainingLines.shift();
        var newLine = remainingLines.shift() || "";
        return lineContents + newLine;
      };
      var lastGeneratedLine = 1,
          lastGeneratedColumn = 0;
      var lastMapping = null;
      aSourceMapConsumer.eachMapping(function(mapping) {
        if (lastMapping !== null) {
          if (lastGeneratedLine < mapping.generatedLine) {
            var code = "";
            addMappingWithCode(lastMapping, shiftNextLine());
            lastGeneratedLine++;
            lastGeneratedColumn = 0;
          } else {
            var nextLine = remainingLines[0];
            var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
            remainingLines[0] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
            lastGeneratedColumn = mapping.generatedColumn;
            addMappingWithCode(lastMapping, code);
            lastMapping = mapping;
            return;
          }
        }
        while (lastGeneratedLine < mapping.generatedLine) {
          node.add(shiftNextLine());
          lastGeneratedLine++;
        }
        if (lastGeneratedColumn < mapping.generatedColumn) {
          var nextLine = remainingLines[0];
          node.add(nextLine.substr(0, mapping.generatedColumn));
          remainingLines[0] = nextLine.substr(mapping.generatedColumn);
          lastGeneratedColumn = mapping.generatedColumn;
        }
        lastMapping = mapping;
      }, this);
      if (remainingLines.length > 0) {
        if (lastMapping) {
          addMappingWithCode(lastMapping, shiftNextLine());
        }
        node.add(remainingLines.join(""));
      }
      aSourceMapConsumer.sources.forEach(function(sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content != null) {
          if (aRelativePath != null) {
            sourceFile = util.join(aRelativePath, sourceFile);
          }
          node.setSourceContent(sourceFile, content);
        }
      });
      return node;
      function addMappingWithCode(mapping, code) {
        if (mapping === null || mapping.source === undefined) {
          node.add(code);
        } else {
          var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
          node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
        }
      }
    };
    SourceNode.prototype.add = function SourceNode_add(aChunk) {
      if (Array.isArray(aChunk)) {
        aChunk.forEach(function(chunk) {
          this.add(chunk);
        }, this);
      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
        if (aChunk) {
          this.children.push(aChunk);
        }
      } else {
        throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
      }
      return this;
    };
    SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
      if (Array.isArray(aChunk)) {
        for (var i = aChunk.length - 1; i >= 0; i--) {
          this.prepend(aChunk[i]);
        }
      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
        this.children.unshift(aChunk);
      } else {
        throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
      }
      return this;
    };
    SourceNode.prototype.walk = function SourceNode_walk(aFn) {
      var chunk;
      for (var i = 0,
          len = this.children.length; i < len; i++) {
        chunk = this.children[i];
        if (chunk[isSourceNode]) {
          chunk.walk(aFn);
        } else {
          if (chunk !== '') {
            aFn(chunk, {
              source: this.source,
              line: this.line,
              column: this.column,
              name: this.name
            });
          }
        }
      }
    };
    SourceNode.prototype.join = function SourceNode_join(aSep) {
      var newChildren;
      var i;
      var len = this.children.length;
      if (len > 0) {
        newChildren = [];
        for (i = 0; i < len - 1; i++) {
          newChildren.push(this.children[i]);
          newChildren.push(aSep);
        }
        newChildren.push(this.children[i]);
        this.children = newChildren;
      }
      return this;
    };
    SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
      var lastChild = this.children[this.children.length - 1];
      if (lastChild[isSourceNode]) {
        lastChild.replaceRight(aPattern, aReplacement);
      } else if (typeof lastChild === 'string') {
        this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
      } else {
        this.children.push(''.replace(aPattern, aReplacement));
      }
      return this;
    };
    SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
      this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
    };
    SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
      for (var i = 0,
          len = this.children.length; i < len; i++) {
        if (this.children[i][isSourceNode]) {
          this.children[i].walkSourceContents(aFn);
        }
      }
      var sources = Object.keys(this.sourceContents);
      for (var i = 0,
          len = sources.length; i < len; i++) {
        aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
      }
    };
    SourceNode.prototype.toString = function SourceNode_toString() {
      var str = "";
      this.walk(function(chunk) {
        str += chunk;
      });
      return str;
    };
    SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
      var generated = {
        code: "",
        line: 1,
        column: 0
      };
      var map = new SourceMapGenerator(aArgs);
      var sourceMappingActive = false;
      var lastOriginalSource = null;
      var lastOriginalLine = null;
      var lastOriginalColumn = null;
      var lastOriginalName = null;
      this.walk(function(chunk, original) {
        generated.code += chunk;
        if (original.source !== null && original.line !== null && original.column !== null) {
          if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
            map.addMapping({
              source: original.source,
              original: {
                line: original.line,
                column: original.column
              },
              generated: {
                line: generated.line,
                column: generated.column
              },
              name: original.name
            });
          }
          lastOriginalSource = original.source;
          lastOriginalLine = original.line;
          lastOriginalColumn = original.column;
          lastOriginalName = original.name;
          sourceMappingActive = true;
        } else if (sourceMappingActive) {
          map.addMapping({generated: {
              line: generated.line,
              column: generated.column
            }});
          lastOriginalSource = null;
          sourceMappingActive = false;
        }
        for (var idx = 0,
            length = chunk.length; idx < length; idx++) {
          if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
            generated.line++;
            generated.column = 0;
            if (idx + 1 === length) {
              lastOriginalSource = null;
              sourceMappingActive = false;
            } else if (sourceMappingActive) {
              map.addMapping({
                source: original.source,
                original: {
                  line: original.line,
                  column: original.column
                },
                generated: {
                  line: generated.line,
                  column: generated.column
                },
                name: original.name
              });
            }
          } else {
            generated.column++;
          }
        }
      });
      this.walkSourceContents(function(sourceFile, sourceContent) {
        map.setSourceContent(sourceFile, sourceContent);
      });
      return {
        code: generated.code,
        map: map
      };
    };
    exports.SourceNode = SourceNode;
  });
  var SourceMapGenerator = m['./source-map-generator'].SourceMapGenerator;
  var SourceMapConsumer = m['./source-map-consumer'].SourceMapConsumer;
  var SourceNode = m['./source-node'].SourceNode;
  var join = m['./util'].join;
  return {
    get SourceMapGenerator() {
      return SourceMapGenerator;
    },
    get SourceMapConsumer() {
      return SourceMapConsumer;
    },
    get SourceNode() {
      return SourceNode;
    },
    get join() {
      return join;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/outputgeneration/toSource.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/outputgeneration/toSource.js";
  var ParseTreeMapWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeMapWriter.js", "traceur@0.0.112/src/outputgeneration/toSource.js")).ParseTreeMapWriter;
  var ParseTreeWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeWriter.js", "traceur@0.0.112/src/outputgeneration/toSource.js")).ParseTreeWriter;
  var SourceMapGenerator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SourceMapIntegration.js", "traceur@0.0.112/src/outputgeneration/toSource.js")).SourceMapGenerator;
  function toSource(tree) {
    var options = arguments[1];
    var outputName = arguments[2] !== (void 0) ? arguments[2] : '<toSourceOutput>';
    var sourceRoot = arguments[3];
    var sourceMapGenerator = options && options.sourceMapGenerator;
    var sourcemaps = options && options.sourceMaps;
    if (!sourceMapGenerator && sourcemaps) {
      sourceMapGenerator = new SourceMapGenerator({
        file: outputName,
        sourceRoot: sourceRoot,
        skipValidation: true
      });
    }
    var sourceMapConfiguration = {
      sourceMapGenerator: sourceMapGenerator,
      sourceRoot: sourceRoot,
      lowResolution: options && options.lowResolutionSourceMap
    };
    var writer;
    if (sourceMapGenerator)
      writer = new ParseTreeMapWriter(sourceMapConfiguration, options);
    else
      writer = new ParseTreeWriter(options);
    writer.visitAny(tree);
    return [writer.toString(), sourceMapGenerator && sourceMapGenerator.toString()];
  }
  return {get toSource() {
      return toSource;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/outputgeneration/TreeWriter.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/outputgeneration/TreeWriter.js";
  var toSource = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./toSource.js", "traceur@0.0.112/src/outputgeneration/TreeWriter.js")).toSource;
  function write(tree) {
    var $__2,
        $__3;
    var options = arguments[1];
    var outputName = arguments[2] !== (void 0) ? arguments[2] : '<TreeWriter-output>';
    var sourceRoot = arguments[3];
    var $__1 = toSource(tree, options, outputName, sourceRoot),
        result = ($__2 = $__1[Symbol.iterator](), ($__3 = $__2.next()).done ? void 0 : $__3.value),
        sourceMap = ($__3 = $__2.next()).done ? void 0 : $__3.value;
    if (sourceMap)
      options.generatedSourceMap = sourceMap;
    return result;
  }
  var TreeWriter = function() {
    function TreeWriter() {}
    return ($traceurRuntime.createClass)(TreeWriter, {}, {});
  }();
  TreeWriter.write = write;
  return {
    get write() {
      return write;
    },
    get TreeWriter() {
      return TreeWriter;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/syntax/ParseTreeValidator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/syntax/ParseTreeValidator.js";
  var NewExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/syntax/ParseTreeValidator.js")).NewExpression;
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeVisitor.js", "traceur@0.0.112/src/syntax/ParseTreeValidator.js")).ParseTreeVisitor;
  var TreeWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../outputgeneration/TreeWriter.js", "traceur@0.0.112/src/syntax/ParseTreeValidator.js")).TreeWriter;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TokenType.js", "traceur@0.0.112/src/syntax/ParseTreeValidator.js")),
      AMPERSAND = $__7.AMPERSAND,
      AMPERSAND_EQUAL = $__7.AMPERSAND_EQUAL,
      AND = $__7.AND,
      BAR = $__7.BAR,
      BAR_EQUAL = $__7.BAR_EQUAL,
      CARET = $__7.CARET,
      CARET_EQUAL = $__7.CARET_EQUAL,
      CLOSE_ANGLE = $__7.CLOSE_ANGLE,
      EQUAL = $__7.EQUAL,
      EQUAL_EQUAL = $__7.EQUAL_EQUAL,
      EQUAL_EQUAL_EQUAL = $__7.EQUAL_EQUAL_EQUAL,
      GREATER_EQUAL = $__7.GREATER_EQUAL,
      IDENTIFIER = $__7.IDENTIFIER,
      IN = $__7.IN,
      INSTANCEOF = $__7.INSTANCEOF,
      LEFT_SHIFT = $__7.LEFT_SHIFT,
      LEFT_SHIFT_EQUAL = $__7.LEFT_SHIFT_EQUAL,
      LESS_EQUAL = $__7.LESS_EQUAL,
      MINUS = $__7.MINUS,
      MINUS_EQUAL = $__7.MINUS_EQUAL,
      NOT_EQUAL = $__7.NOT_EQUAL,
      NOT_EQUAL_EQUAL = $__7.NOT_EQUAL_EQUAL,
      NUMBER = $__7.NUMBER,
      OPEN_ANGLE = $__7.OPEN_ANGLE,
      OR = $__7.OR,
      PERCENT = $__7.PERCENT,
      PERCENT_EQUAL = $__7.PERCENT_EQUAL,
      PLUS = $__7.PLUS,
      PLUS_EQUAL = $__7.PLUS_EQUAL,
      RIGHT_SHIFT = $__7.RIGHT_SHIFT,
      RIGHT_SHIFT_EQUAL = $__7.RIGHT_SHIFT_EQUAL,
      SLASH = $__7.SLASH,
      SLASH_EQUAL = $__7.SLASH_EQUAL,
      STAR = $__7.STAR,
      STAR_EQUAL = $__7.STAR_EQUAL,
      STAR_STAR = $__7.STAR_STAR,
      STAR_STAR_EQUAL = $__7.STAR_STAR_EQUAL,
      STRING = $__7.STRING,
      UNSIGNED_RIGHT_SHIFT = $__7.UNSIGNED_RIGHT_SHIFT,
      UNSIGNED_RIGHT_SHIFT_EQUAL = $__7.UNSIGNED_RIGHT_SHIFT_EQUAL,
      YIELD = $__7.YIELD;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./trees/ParseTreeType.js", "traceur@0.0.112/src/syntax/ParseTreeValidator.js")),
      ARRAY_PATTERN = $__8.ARRAY_PATTERN,
      ASSIGNMENT_ELEMENT = $__8.ASSIGNMENT_ELEMENT,
      BINDING_ELEMENT = $__8.BINDING_ELEMENT,
      BINDING_IDENTIFIER = $__8.BINDING_IDENTIFIER,
      BLOCK = $__8.BLOCK,
      CASE_CLAUSE = $__8.CASE_CLAUSE,
      CATCH = $__8.CATCH,
      CLASS_DECLARATION = $__8.CLASS_DECLARATION,
      COMPUTED_PROPERTY_NAME = $__8.COMPUTED_PROPERTY_NAME,
      DEFAULT_CLAUSE = $__8.DEFAULT_CLAUSE,
      EXPORT_DEFAULT = $__8.EXPORT_DEFAULT,
      EXPORT_SPECIFIER = $__8.EXPORT_SPECIFIER,
      EXPORT_SPECIFIER_SET = $__8.EXPORT_SPECIFIER_SET,
      EXPORT_STAR = $__8.EXPORT_STAR,
      FINALLY = $__8.FINALLY,
      FORMAL_PARAMETER = $__8.FORMAL_PARAMETER,
      FORMAL_PARAMETER_LIST = $__8.FORMAL_PARAMETER_LIST,
      FORWARD_DEFAULT_EXPORT = $__8.FORWARD_DEFAULT_EXPORT,
      FUNCTION_BODY = $__8.FUNCTION_BODY,
      FUNCTION_DECLARATION = $__8.FUNCTION_DECLARATION,
      GET_ACCESSOR = $__8.GET_ACCESSOR,
      IDENTIFIER_EXPRESSION = $__8.IDENTIFIER_EXPRESSION,
      IMPORTED_BINDING = $__8.IMPORTED_BINDING,
      IMPORT_CLAUSE_PAIR = $__8.IMPORT_CLAUSE_PAIR,
      IMPORT_SPECIFIER_SET = $__8.IMPORT_SPECIFIER_SET,
      IMPORT_TYPE_CLAUSE = $__8.IMPORT_TYPE_CLAUSE,
      JSX_ATTRIBUTE = $__8.JSX_ATTRIBUTE,
      JSX_ELEMENT_NAME = $__8.JSX_ELEMENT_NAME,
      JSX_ELEMENT = $__8.JSX_ELEMENT,
      JSX_PLACEHOLDER = $__8.JSX_PLACEHOLDER,
      JSX_SPREAD_ATTRIBUTE = $__8.JSX_SPREAD_ATTRIBUTE,
      JSX_TEXT = $__8.JSX_TEXT,
      LITERAL_PROPERTY_NAME = $__8.LITERAL_PROPERTY_NAME,
      METHOD = $__8.METHOD,
      MODULE_SPECIFIER = $__8.MODULE_SPECIFIER,
      NAMED_EXPORT = $__8.NAMED_EXPORT,
      NAME_SPACE_EXPORT = $__8.NAME_SPACE_EXPORT,
      NAME_SPACE_IMPORT = $__8.NAME_SPACE_IMPORT,
      OBJECT_PATTERN = $__8.OBJECT_PATTERN,
      OBJECT_PATTERN_FIELD = $__8.OBJECT_PATTERN_FIELD,
      PROPERTY_NAME_ASSIGNMENT = $__8.PROPERTY_NAME_ASSIGNMENT,
      PROPERTY_NAME_SHORTHAND = $__8.PROPERTY_NAME_SHORTHAND,
      PROPERTY_VARIABLE_DECLARATION = $__8.PROPERTY_VARIABLE_DECLARATION,
      REST_PARAMETER = $__8.REST_PARAMETER,
      SET_ACCESSOR = $__8.SET_ACCESSOR,
      SPREAD_EXPRESSION = $__8.SPREAD_EXPRESSION,
      TEMPLATE_LITERAL_PORTION = $__8.TEMPLATE_LITERAL_PORTION,
      TEMPLATE_SUBSTITUTION = $__8.TEMPLATE_SUBSTITUTION,
      TYPE_ALIAS_DECLARATION = $__8.TYPE_ALIAS_DECLARATION,
      TYPE_ARGUMENTS = $__8.TYPE_ARGUMENTS,
      TYPE_NAME = $__8.TYPE_NAME,
      TYPE_PARAMETER = $__8.TYPE_PARAMETER,
      TYPE_PARAMETERS = $__8.TYPE_PARAMETERS,
      VARIABLE_DECLARATION_LIST = $__8.VARIABLE_DECLARATION_LIST,
      VARIABLE_STATEMENT = $__8.VARIABLE_STATEMENT;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/assert.js", "traceur@0.0.112/src/syntax/ParseTreeValidator.js")).assert;
  var ValidationError = function($__super) {
    function ValidationError(tree, message) {
      $traceurRuntime.superConstructor(ValidationError).call(this);
      this.tree = tree;
      this.message = message;
    }
    return ($traceurRuntime.createClass)(ValidationError, {}, {}, $__super);
  }(Error);
  var ParseTreeValidator = function($__super) {
    function ParseTreeValidator() {
      $traceurRuntime.superConstructor(ParseTreeValidator).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ParseTreeValidator, {
      fail_: function(tree, message) {
        throw new ValidationError(tree, message);
      },
      check_: function(condition, tree, message) {
        if (!condition) {
          this.fail_(tree, message);
        }
      },
      checkVisit_: function(condition, tree, message) {
        this.check_(condition, tree, message);
        this.visitAny(tree);
      },
      checkType_: function(type, tree, message) {
        this.checkVisit_(tree.type === type, tree, message);
      },
      visitArgumentList: function(tree) {
        for (var i = 0; i < tree.args.length; i++) {
          var argument = tree.args[i];
          this.checkVisit_(argument.isAssignmentOrSpread(), argument, 'assignment or spread expected');
        }
      },
      visitArrayLiteral: function(tree) {
        for (var i = 0; i < tree.elements.length; i++) {
          var element = tree.elements[i];
          this.checkVisit_(element === null || element.isAssignmentOrSpread(), element, 'assignment or spread expected');
        }
      },
      visitArrayPattern: function(tree) {
        for (var i = 0; i < tree.elements.length; i++) {
          var element = tree.elements[i];
          this.checkVisit_(element === null || element.type === BINDING_ELEMENT || element.type === ASSIGNMENT_ELEMENT || element.isLeftHandSideExpression() || element.isPattern() || element.isSpreadPatternElement(), element, 'null, sub pattern, left hand side expression or spread expected');
          if (element && element.isSpreadPatternElement()) {
            this.check_(i === (tree.elements.length - 1), element, 'spread in array patterns must be the last element');
          }
        }
      },
      visitBinaryExpression: function(tree) {
        switch (tree.operator.type) {
          case EQUAL:
          case STAR_EQUAL:
          case STAR_STAR_EQUAL:
          case SLASH_EQUAL:
          case PERCENT_EQUAL:
          case PLUS_EQUAL:
          case MINUS_EQUAL:
          case LEFT_SHIFT_EQUAL:
          case RIGHT_SHIFT_EQUAL:
          case UNSIGNED_RIGHT_SHIFT_EQUAL:
          case AMPERSAND_EQUAL:
          case CARET_EQUAL:
          case BAR_EQUAL:
            this.check_(tree.left.isLeftHandSideExpression() || tree.left.isPattern(), tree.left, 'left hand side expression or pattern expected');
            this.check_(tree.right.isAssignmentExpression(), tree.right, 'assignment expression expected');
            break;
          case AND:
          case OR:
          case BAR:
          case CARET:
          case AMPERSAND:
          case EQUAL_EQUAL:
          case NOT_EQUAL:
          case EQUAL_EQUAL_EQUAL:
          case NOT_EQUAL_EQUAL:
          case OPEN_ANGLE:
          case CLOSE_ANGLE:
          case GREATER_EQUAL:
          case LESS_EQUAL:
          case INSTANCEOF:
          case IN:
          case LEFT_SHIFT:
          case RIGHT_SHIFT:
          case UNSIGNED_RIGHT_SHIFT:
          case PLUS:
          case MINUS:
          case STAR:
          case SLASH:
          case PERCENT:
          case STAR_STAR:
            this.check_(tree.left.isAssignmentExpression(), tree.left, 'assignment expression expected');
            this.check_(tree.right.isAssignmentExpression(), tree.right, 'assignment expression expected');
            break;
          default:
            this.fail_(tree, 'unexpected binary operator');
        }
        this.visitAny(tree.left);
        this.visitAny(tree.right);
      },
      visitBindingElement: function(tree) {
        var binding = tree.binding;
        this.checkVisit_(binding.type === BINDING_IDENTIFIER || binding.type === OBJECT_PATTERN || binding.type === ARRAY_PATTERN, binding, 'expected valid binding element');
        this.visitAny(tree.initializer);
      },
      visitAssignmentElement: function(tree) {
        var assignment = tree.assignment;
        this.checkVisit_(assignment.type === OBJECT_PATTERN || assignment.type === ARRAY_PATTERN || assignment.isLeftHandSideExpression(), assignment, 'expected valid assignment element');
        this.visitAny(tree.initializer);
      },
      visitBlock: function(tree) {
        for (var i = 0; i < tree.statements.length; i++) {
          var statement = tree.statements[i];
          this.checkVisit_(statement.isStatementListItem(), statement, 'statement or function declaration expected');
        }
      },
      visitCallExpression: function(tree) {
        this.check_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected');
        if (tree.operand instanceof NewExpression) {
          this.check_(tree.operand.args !== null, tree.operand, 'new args expected');
        }
        this.visitAny(tree.operand);
        this.visitAny(tree.args);
      },
      visitCaseClause: function(tree) {
        this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected');
        for (var i = 0; i < tree.statements.length; i++) {
          var statement = tree.statements[i];
          this.checkVisit_(statement.isStatementListItem(), statement, 'statement expected');
        }
      },
      visitCatch: function(tree) {
        this.checkVisit_(tree.binding.isPattern() || tree.binding.type === BINDING_IDENTIFIER, tree.binding, 'binding identifier expected');
        this.checkVisit_(tree.catchBody.type === BLOCK, tree.catchBody, 'block expected');
      },
      visitClassDeclaration: function(tree) {
        this.visitClassShared_(tree);
      },
      visitClassExpression: function(tree) {
        this.visitClassShared_(tree);
      },
      visitClassShared_: function(tree) {
        if (tree.typeParameters) {
          this.checkVisit_(tree.typeParameters.type === TYPE_PARAMETERS, tree.typeParameters, 'type parameters expected');
        }
        for (var i = 0; i < tree.elements.length; i++) {
          var element = tree.elements[i];
          switch (element.type) {
            case GET_ACCESSOR:
            case SET_ACCESSOR:
            case METHOD:
            case PROPERTY_VARIABLE_DECLARATION:
              break;
            default:
              this.fail_(element, 'class element expected');
          }
          this.visitAny(element);
        }
      },
      visitCommaExpression: function(tree) {
        for (var i = 0; i < tree.expressions.length; i++) {
          var expression = tree.expressions[i];
          this.checkVisit_(expression.isExpression(), expression, 'expression expected');
        }
      },
      visitConditionalExpression: function(tree) {
        this.checkVisit_(tree.condition.isAssignmentExpression(), tree.condition, 'expression expected');
        this.checkVisit_(tree.left.isAssignmentExpression(), tree.left, 'expression expected');
        this.checkVisit_(tree.right.isAssignmentExpression(), tree.right, 'expression expected');
      },
      visitCoverFormals: function(tree) {
        this.fail_(tree, 'CoverFormals should have been removed');
      },
      visitCoverInitializedName: function(tree) {
        this.fail_(tree, 'CoverInitializedName should have been removed');
      },
      visitDefaultClause: function(tree) {
        for (var i = 0; i < tree.statements.length; i++) {
          var statement = tree.statements[i];
          this.checkVisit_(statement.isStatementListItem(), statement, 'statement expected');
        }
      },
      visitDoWhileStatement: function(tree) {
        this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected');
        this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected');
      },
      visitExportDeclaration: function(tree) {
        var declType = tree.declaration.type;
        this.checkVisit_(declType === VARIABLE_STATEMENT || declType === FUNCTION_DECLARATION || declType === CLASS_DECLARATION || declType === NAMED_EXPORT || declType === EXPORT_DEFAULT || declType === TYPE_ALIAS_DECLARATION, tree.declaration, 'expected valid export tree');
      },
      visitNamedExport: function(tree) {
        var specifierType = tree.exportClause.type;
        this.checkVisit_(specifierType === EXPORT_SPECIFIER || specifierType === EXPORT_SPECIFIER_SET || specifierType === EXPORT_STAR || specifierType === FORWARD_DEFAULT_EXPORT || specifierType === NAME_SPACE_EXPORT, tree.exportClause, 'Invalid export clause');
        if (tree.moduleSpecifier) {
          this.checkVisit_(tree.moduleSpecifier.type === MODULE_SPECIFIER, tree.moduleSpecifier, 'module expression expected');
        }
      },
      visitExportSpecifierSet: function(tree) {
        this.check_(tree.specifiers.length > 0, tree, 'expected at least one identifier');
        for (var i = 0; i < tree.specifiers.length; i++) {
          var specifier = tree.specifiers[i];
          this.checkVisit_(specifier.type === EXPORT_SPECIFIER || specifier.type === IDENTIFIER_EXPRESSION, specifier, 'expected valid export specifier');
        }
      },
      visitExpressionStatement: function(tree) {
        this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected');
      },
      visitFinally: function(tree) {
        this.checkVisit_(tree.block.type === BLOCK, tree.block, 'block expected');
      },
      visitForOfStatement: function(tree) {
        this.checkVisit_(tree.initializer.isPattern() || tree.initializer.type === IDENTIFIER_EXPRESSION || tree.initializer.type === VARIABLE_DECLARATION_LIST && tree.initializer.declarations.length === 1, tree.initializer, 'for-each statement may not have more than one variable declaration');
        this.checkVisit_(tree.collection.isExpression(), tree.collection, 'expression expected');
        this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected');
      },
      visitForInStatement: function(tree) {
        if (tree.initializer.type === VARIABLE_DECLARATION_LIST) {
          this.checkVisit_(tree.initializer.declarations.length <= 1, tree.initializer, 'for-in statement may not have more than one variable declaration');
        } else {
          this.checkVisit_(tree.initializer.isPattern() || tree.initializer.isExpression(), tree.initializer, 'variable declaration, expression or ' + 'pattern expected');
        }
        this.checkVisit_(tree.collection.isExpression(), tree.collection, 'expression expected');
        this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected');
      },
      visitFormalParameterList: function(tree) {
        for (var i = 0; i < tree.parameters.length; i++) {
          var parameter = tree.parameters[i];
          assert(parameter.type === FORMAL_PARAMETER);
          parameter = parameter.parameter;
          switch (parameter.type) {
            case BINDING_ELEMENT:
              break;
            case REST_PARAMETER:
              this.checkVisit_(i === tree.parameters.length - 1, parameter, 'rest parameters must be the last parameter in a parameter list');
              this.checkType_(BINDING_IDENTIFIER, parameter.identifier, 'binding identifier expected');
              break;
            default:
              this.fail_(parameter, 'parameters must be identifiers or rest' + (" parameters. Found: " + parameter.type));
              break;
          }
          this.visitAny(parameter);
        }
      },
      visitForStatement: function(tree) {
        if (tree.initializer !== null) {
          this.checkVisit_(tree.initializer.isExpression() || tree.initializer.type === VARIABLE_DECLARATION_LIST, tree.initializer, 'variable declaration list or expression expected');
        }
        if (tree.condition !== null) {
          this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected');
        }
        if (tree.increment !== null) {
          this.checkVisit_(tree.increment.isExpression(), tree.increment, 'expression expected');
        }
        this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected');
      },
      visitFunctionBody: function(tree) {
        for (var i = 0; i < tree.statements.length; i++) {
          var statement = tree.statements[i];
          this.checkVisit_(statement.isStatementListItem(), statement, 'statement expected');
        }
      },
      visitFunctionDeclaration: function(tree) {
        this.checkType_(BINDING_IDENTIFIER, tree.name, 'binding identifier expected');
        this.visitFunction_(tree);
      },
      visitFunctionExpression: function(tree) {
        if (tree.name !== null) {
          this.checkType_(BINDING_IDENTIFIER, tree.name, 'binding identifier expected');
        }
        this.visitFunction_(tree);
      },
      visitFunction_: function(tree) {
        this.checkType_(FORMAL_PARAMETER_LIST, tree.parameterList, 'formal parameters expected');
        this.checkType_(FUNCTION_BODY, tree.body, 'function body expected');
      },
      visitGetAccessor: function(tree) {
        this.checkPropertyName_(tree.name);
        this.checkType_(FUNCTION_BODY, tree.body, 'function body expected');
      },
      visitIfStatement: function(tree) {
        this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected');
        this.checkVisit_(tree.ifClause.isStatement(), tree.ifClause, 'statement expected');
        if (tree.elseClause !== null) {
          this.checkVisit_(tree.elseClause.isStatement(), tree.elseClause, 'statement expected');
        }
      },
      visitImportDeclaration: function(tree) {
        if (tree.importClause !== null) {
          this.check_(tree.importClause.type === NAME_SPACE_IMPORT || tree.importClause.type === IMPORTED_BINDING || tree.importClause.type === IMPORT_SPECIFIER_SET || tree.importClause.type === IMPORT_CLAUSE_PAIR || tree.importClause.type === IMPORT_TYPE_CLAUSE, tree.importClause, 'Invalid import clause');
        }
        this.checkType_(MODULE_SPECIFIER, tree.moduleSpecifier, 'module specifier expected');
      },
      visitImportSpecifier: function(tree) {
        this.checkType_(IMPORTED_BINDING, tree.binding, 'ImportedBinding expected');
      },
      visitImportedBinding: function(tree) {
        this.checkType_(BINDING_IDENTIFIER, tree.binding, 'binding identifier expected');
      },
      visitImportClausePair: function(tree) {
        this.checkType_(IMPORTED_BINDING, tree.first, 'ImportedBinding expected');
        this.check_(tree.second.type === NAME_SPACE_IMPORT || tree.second.type === IMPORT_SPECIFIER_SET, tree.second, 'Invalid import clause');
      },
      visitJsxElement: function(tree) {
        this.checkType_(JSX_ELEMENT_NAME, tree.name, 'JSX Element Name expected');
        for (var i = 0; i < tree.attributes.length; i++) {
          var attr = tree.attributes[i];
          this.checkVisit_(attr.type === JSX_ATTRIBUTE || attr.type === JSX_SPREAD_ATTRIBUTE, attr, 'JSX Attribute expected');
        }
        for (var i$__3 = 0; i$__3 < tree.children.length; i$__3++) {
          var child = tree.children[i$__3];
          this.checkVisit_(child.type === JSX_ELEMENT || child.type === JSX_PLACEHOLDER || child.type === JSX_TEXT, child, 'JSX child expected');
        }
      },
      visitLabelledStatement: function(tree) {
        this.checkVisit_(tree.statement.isStatement(), tree.statement, 'statement expected');
      },
      visitMemberExpression: function(tree) {
        this.check_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected');
        if (tree.operand instanceof NewExpression) {
          this.check_(tree.operand.args !== null, tree.operand, 'new args expected');
        }
        this.visitAny(tree.operand);
      },
      visitMemberLookupExpression: function(tree) {
        this.check_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected');
        if (tree.operand instanceof NewExpression) {
          this.check_(tree.operand.args !== null, tree.operand, 'new args expected');
        }
        this.visitAny(tree.operand);
      },
      visitSyntaxErrorTree: function(tree) {
        this.fail_(tree, ("parse tree contains SyntaxError: " + tree.message));
      },
      visitModuleSpecifier: function(tree) {
        this.check_(tree.token.type === STRING, tree, 'string or identifier expected');
      },
      visitNewExpression: function(tree) {
        this.checkVisit_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected');
        this.visitAny(tree.args);
      },
      visitObjectLiteral: function(tree) {
        for (var i = 0; i < tree.propertyNameAndValues.length; i++) {
          var propertyNameAndValue = tree.propertyNameAndValues[i];
          switch (propertyNameAndValue.type) {
            case GET_ACCESSOR:
            case SET_ACCESSOR:
            case METHOD:
              this.check_(!propertyNameAndValue.isStatic, propertyNameAndValue, 'static is not allowed in object literal expression');
              break;
            case PROPERTY_NAME_ASSIGNMENT:
            case PROPERTY_NAME_SHORTHAND:
            case SPREAD_EXPRESSION:
              break;
            default:
              this.fail_(propertyNameAndValue, 'accessor, property name ' + 'assignment or property method assigment expected');
          }
          this.visitAny(propertyNameAndValue);
        }
      },
      visitObjectPattern: function(tree) {
        for (var i = 0; i < tree.fields.length; i++) {
          var field = tree.fields[i];
          this.checkVisit_(field.type === OBJECT_PATTERN_FIELD || field.type === ASSIGNMENT_ELEMENT || field.type === BINDING_ELEMENT, field, 'object pattern field expected');
        }
      },
      visitObjectPatternField: function(tree) {
        this.checkPropertyName_(tree.name);
        this.checkVisit_(tree.element.type === ASSIGNMENT_ELEMENT || tree.element.type === BINDING_ELEMENT || tree.element.isPattern() || tree.element.isLeftHandSideExpression(), tree.element, 'binding element expected');
      },
      visitParenExpression: function(tree) {
        if (tree.expression.isPattern()) {
          this.visitAny(tree.expression);
        } else {
          this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected');
        }
      },
      visitPostfixExpression: function(tree) {
        this.checkVisit_(tree.operand.isAssignmentExpression(), tree.operand, 'assignment expression expected');
      },
      visitPredefinedType: function(tree) {},
      visitScript: function(tree) {
        for (var i = 0; i < tree.scriptItemList.length; i++) {
          var scriptItemList = tree.scriptItemList[i];
          this.checkVisit_(scriptItemList.isScriptElement(), scriptItemList, 'global script item expected');
        }
      },
      checkPropertyName_: function(tree) {
        this.checkVisit_(tree.type === LITERAL_PROPERTY_NAME || tree.type === COMPUTED_PROPERTY_NAME, tree, 'property name expected');
      },
      visitPropertyNameAssignment: function(tree) {
        this.checkPropertyName_(tree.name);
        this.checkVisit_(tree.value.isAssignmentExpression(), tree.value, 'assignment expression expected');
      },
      visitPropertyNameShorthand: function(tree) {
        this.check_(tree.name.type === IDENTIFIER || tree.name.type === YIELD || tree.name.isStrictKeyword(), tree, 'identifier token expected');
      },
      visitLiteralPropertyName: function(tree) {
        var type = tree.literalToken.type;
        this.check_(tree.literalToken.isKeyword() || type === IDENTIFIER || type === NUMBER || type === STRING, tree, 'Unexpected token in literal property name');
      },
      visitTemplateLiteralExpression: function(tree) {
        if (tree.operand) {
          this.checkVisit_(tree.operand.isMemberExpression(), tree.operand, 'member or call expression expected');
        }
        for (var i = 0; i < tree.elements.length; i++) {
          var element = tree.elements[i];
          if (i % 2) {
            this.checkType_(TEMPLATE_SUBSTITUTION, element, 'Template literal substitution expected');
          } else {
            this.checkType_(TEMPLATE_LITERAL_PORTION, element, 'Template literal portion expected');
          }
        }
      },
      visitReturnStatement: function(tree) {
        if (tree.expression !== null) {
          this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected');
        }
      },
      visitSetAccessor: function(tree) {
        this.checkPropertyName_(tree.name);
        this.checkType_(FUNCTION_BODY, tree.body, 'function body expected');
      },
      visitSpreadExpression: function(tree) {
        this.checkVisit_(tree.expression.isAssignmentExpression(), tree.expression, 'assignment expression expected');
      },
      visitStateMachine: function(tree) {
        this.fail_(tree, 'State machines are never valid outside of the ' + 'GeneratorTransformer pass.');
      },
      visitSwitchStatement: function(tree) {
        this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected');
        var defaultCount = 0;
        for (var i = 0; i < tree.caseClauses.length; i++) {
          var caseClause = tree.caseClauses[i];
          if (caseClause.type === DEFAULT_CLAUSE) {
            ++defaultCount;
            this.checkVisit_(defaultCount <= 1, caseClause, 'no more than one default clause allowed');
          } else {
            this.checkType_(CASE_CLAUSE, caseClause, 'case or default clause expected');
          }
        }
      },
      visitThrowStatement: function(tree) {
        if (tree.value === null) {
          return;
        }
        this.checkVisit_(tree.value.isExpression(), tree.value, 'expression expected');
      },
      visitTryStatement: function(tree) {
        this.checkType_(BLOCK, tree.body, 'block expected');
        if (tree.catchBlock !== null) {
          this.checkType_(CATCH, tree.catchBlock, 'catch block expected');
        }
        if (tree.finallyBlock !== null) {
          this.checkType_(FINALLY, tree.finallyBlock, 'finally block expected');
        }
        if (tree.catchBlock === null && tree.finallyBlock === null) {
          this.fail_(tree, 'either catch or finally must be present');
        }
      },
      visitTypeArguments: function(tree) {
        var args = tree.args;
        for (var i = 0; i < args.length; i++) {
          this.checkVisit_(args[i].isType(), args[i], 'Type arguments must be type expressions');
        }
      },
      visitTypeName: function(tree) {
        this.checkVisit_(tree.moduleName === null || tree.moduleName.type === TYPE_NAME, tree.moduleName, 'moduleName must be null or a TypeName');
        this.check_(tree.name.type === IDENTIFIER, tree, 'name must be an identifier');
      },
      visitTypeReference: function(tree) {
        this.checkType_(TYPE_NAME, tree.typeName, 'typeName must be a TypeName');
        this.checkType_(TYPE_ARGUMENTS, tree.args, 'args must be a TypeArguments');
      },
      visitTypeParameters: function(tree) {
        var parameters = tree.parameters;
        for (var i = 0; i < parameters.length; i++) {
          this.checkType_(TYPE_PARAMETER, parameters[i], 'Type parameters must all be type parameters');
        }
      },
      visitTypeParameter: function(tree) {
        this.check_(tree.identifierToken.type === IDENTIFIER, tree, 'Type parameter must be an identifier token');
        if (tree.extendsType) {
          this.checkVisit_(tree.extendsType.isType(), tree.extendsType, 'extends type must be a type expression');
        }
      },
      visitUnaryExpression: function(tree) {
        this.checkVisit_(tree.operand.isAssignmentExpression(), tree.operand, 'assignment expression expected');
      },
      visitVariableDeclaration: function(tree) {
        this.checkVisit_(tree.lvalue.isPattern() || tree.lvalue.type === BINDING_IDENTIFIER, tree.lvalue, 'binding identifier expected, found: ' + tree.lvalue.type);
        if (tree.initializer !== null) {
          this.checkVisit_(tree.initializer.isAssignmentExpression(), tree.initializer, 'assignment expression expected');
        }
      },
      visitWhileStatement: function(tree) {
        this.checkVisit_(tree.condition.isExpression(), tree.condition, 'expression expected');
        this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected');
      },
      visitWithStatement: function(tree) {
        this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected');
        this.checkVisit_(tree.body.isStatement(), tree.body, 'statement expected');
      },
      visitYieldExpression: function(tree) {
        if (tree.expression !== null) {
          this.checkVisit_(tree.expression.isExpression(), tree.expression, 'expression expected');
        }
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  ParseTreeValidator.validate = function(tree) {
    var validator = new ParseTreeValidator();
    try {
      validator.visitAny(tree);
    } catch (e) {
      if (!(e instanceof ValidationError)) {
        throw e;
      }
      var location = null;
      if (e.tree !== null) {
        location = e.tree.location;
      }
      if (location === null) {
        location = tree.location;
      }
      var locationString = location !== null ? location.start.toString() : '(unknown)';
      throw new Error(("Parse tree validation failure '" + e.message + "' at " + locationString + ":") + ("\n\n" + TreeWriter.write(tree) + "\n"));
    }
  };
  return {get ParseTreeValidator() {
      return ParseTreeValidator;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/MultiTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/MultiTransformer.js";
  var ParseTreeValidator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/ParseTreeValidator.js", "traceur@0.0.112/src/codegeneration/MultiTransformer.js")).ParseTreeValidator;
  var MultiTransformer = function() {
    function MultiTransformer(reporter, validate) {
      this.reporter_ = reporter;
      this.validate_ = validate;
      this.treeTransformers_ = [];
    }
    return ($traceurRuntime.createClass)(MultiTransformer, {
      append: function(treeTransformer) {
        this.treeTransformers_.push(treeTransformer);
      },
      transform: function(tree) {
        var reporter = this.reporter_;
        var validate = this.validate_;
        this.treeTransformers_.every(function(transformTree) {
          tree = transformTree(tree);
          if (reporter.hadError())
            return false;
          if (validate)
            ParseTreeValidator.validate(tree);
          return true;
        });
        return tree;
      }
    }, {});
  }();
  return {get MultiTransformer() {
      return MultiTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/NumericLiteralTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/NumericLiteralTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/NumericLiteralTransformer.js")).ParseTreeTransformer;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/NumericLiteralTransformer.js")),
      LiteralExpression = $__2.LiteralExpression,
      LiteralPropertyName = $__2.LiteralPropertyName;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/LiteralToken.js", "traceur@0.0.112/src/codegeneration/NumericLiteralTransformer.js")).LiteralToken;
  var NUMBER = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/NumericLiteralTransformer.js")).NUMBER;
  function needsTransform(token) {
    return token.type === NUMBER && /^0[bBoO]/.test(token.value);
  }
  function transformToken(token) {
    return new LiteralToken(NUMBER, String(token.processedValue), token.location);
  }
  var NumericLiteralTransformer = function($__super) {
    function NumericLiteralTransformer() {
      $traceurRuntime.superConstructor(NumericLiteralTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(NumericLiteralTransformer, {
      transformLiteralExpression: function(tree) {
        var token = tree.literalToken;
        if (needsTransform(token))
          return new LiteralExpression(tree.location, transformToken(token));
        return tree;
      },
      transformLiteralPropertyName: function(tree) {
        var token = tree.literalToken;
        if (needsTransform(token))
          return new LiteralPropertyName(tree.location, transformToken(token));
        return tree;
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get NumericLiteralTransformer() {
      return NumericLiteralTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js";
  var FindVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./FindVisitor.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")).FindVisitor;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")),
      FunctionExpression = $__4.FunctionExpression,
      IdentifierExpression = $__4.IdentifierExpression,
      LiteralExpression = $__4.LiteralExpression;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")).TempVarTransformer;
  var IDENTIFIER = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")).IDENTIFIER;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")),
      COMPUTED_PROPERTY_NAME = $__7.COMPUTED_PROPERTY_NAME,
      LITERAL_PROPERTY_NAME = $__7.LITERAL_PROPERTY_NAME;
  var StringMap = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/StringMap.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")).StringMap;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")),
      createAssignmentExpression = $__9.createAssignmentExpression,
      createCommaExpression = $__9.createCommaExpression,
      createDefineProperty = $__9.createDefineProperty,
      createEmptyParameterList = $__9.createEmptyParameterList,
      createFunctionExpression = $__9.createFunctionExpression,
      createIdentifierExpression = $__9.createIdentifierExpression,
      createObjectCreate = $__9.createObjectCreate,
      createObjectLiteral = $__9.createObjectLiteral,
      createParenExpression = $__9.createParenExpression,
      createPropertyNameAssignment = $__9.createPropertyNameAssignment,
      createStringLiteral = $__9.createStringLiteral;
  var propName = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../staticsemantics/PropName.js", "traceur@0.0.112/src/codegeneration/ObjectLiteralTransformer.js")).propName;
  var FindAdvancedProperty = function($__super) {
    function FindAdvancedProperty(transformOptions) {
      $traceurRuntime.superConstructor(FindAdvancedProperty).call(this, true);
      this.transformOptions_ = transformOptions;
      this.protoExpression = null;
    }
    return ($traceurRuntime.createClass)(FindAdvancedProperty, {
      visitPropertyNameAssignment: function(tree) {
        if (isProtoName(tree.name))
          this.protoExpression = tree.value;
        else
          this.visitAny(tree.name);
      },
      visitMethod: function(tree) {
        this.visitAny(tree.name);
      },
      visitGetAccessor: function(tree) {
        if (this.transformOptions_.properTailCalls) {
          this.found = true;
        } else {
          this.visitAny(tree.name);
        }
      },
      visitSetAccessor: function(tree) {
        if (this.transformOptions_.properTailCalls) {
          this.found = true;
        } else {
          this.visitAny(tree.name);
        }
      },
      visitComputedPropertyName: function(tree) {
        if (this.transformOptions_.computedPropertyNames)
          this.found = true;
      }
    }, {}, $__super);
  }(FindVisitor);
  function isProtoName(tree) {
    return propName(tree) === '__proto__';
  }
  var ObjectLiteralTransformer = function($__super) {
    function ObjectLiteralTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(ObjectLiteralTransformer).call(this, identifierGenerator, reporter, options);
      this.transformOptions_ = options.transformOptions;
      this.protoExpression = null;
      this.needsAdvancedTransform = false;
      this.seenAccessors = null;
    }
    return ($traceurRuntime.createClass)(ObjectLiteralTransformer, {
      findSeenAccessor_: function(name) {
        if (name.type === COMPUTED_PROPERTY_NAME)
          return null;
        var s = propName(name);
        return this.seenAccessors.get(s);
      },
      removeSeenAccessor_: function(name) {
        if (name.type === COMPUTED_PROPERTY_NAME)
          return;
        var s = propName(name);
        this.seenAccessors.delete(s);
      },
      addSeenAccessor_: function(name, descr) {
        if (name.type === COMPUTED_PROPERTY_NAME)
          return;
        var s = propName(name);
        this.seenAccessors.set(s, descr);
      },
      createProperty_: function(name, descr) {
        var expression;
        if (name.type === LITERAL_PROPERTY_NAME) {
          if (this.needsAdvancedTransform)
            expression = this.getPropertyName_(name);
          else
            expression = name;
        } else {
          expression = name.expression;
        }
        if (descr.get || descr.set) {
          var oldAccessor = this.findSeenAccessor_(name);
          if (oldAccessor) {
            oldAccessor.get = descr.get || oldAccessor.get;
            oldAccessor.set = descr.set || oldAccessor.set;
            this.removeSeenAccessor_(name);
            return null;
          } else {
            this.addSeenAccessor_(name, descr);
          }
        }
        return [expression, descr];
      },
      getPropertyName_: function(nameTree) {
        var token = nameTree.literalToken;
        switch (token.type) {
          case IDENTIFIER:
            return createStringLiteral(token.value);
          default:
            if (token.isKeyword())
              return createStringLiteral(token.type);
            return new LiteralExpression(token.location, token);
        }
      },
      transformClassDeclaration: function(tree) {
        return tree;
      },
      transformClassExpression: function(tree) {
        return tree;
      },
      transformObjectLiteral: function(tree) {
        var oldNeedsTransform = this.needsAdvancedTransform;
        var oldSeenAccessors = this.seenAccessors;
        var transformed = this.transformObjectLiteralInner_(tree);
        this.needsAdvancedTransform = oldNeedsTransform;
        this.seenAccessors = oldSeenAccessors;
        return transformed;
      },
      transformObjectLiteralInner_: function(tree) {
        var finder = new FindAdvancedProperty(this.transformOptions_);
        finder.visitAny(tree);
        if (!finder.found) {
          this.needsAdvancedTransform = false;
          return $traceurRuntime.superGet(this, ObjectLiteralTransformer.prototype, "transformObjectLiteral").call(this, tree);
        }
        this.needsAdvancedTransform = true;
        this.seenAccessors = new StringMap();
        var properties = this.transformList(tree.propertyNameAndValues);
        properties = properties.filter(function(tree) {
          return tree;
        });
        var tempVar = this.addTempVar();
        var tempVarIdentifierExpression = createIdentifierExpression(tempVar);
        var expressions = properties.map(function(property) {
          var expression = property[0];
          var descr = property[1];
          return createDefineProperty(tempVarIdentifierExpression, expression, descr);
        });
        var protoExpression = this.transformAny(finder.protoExpression);
        var objectExpression;
        if (protoExpression)
          objectExpression = createObjectCreate(protoExpression);
        else
          objectExpression = createObjectLiteral([]);
        expressions.unshift(createAssignmentExpression(tempVarIdentifierExpression, objectExpression));
        expressions.push(tempVarIdentifierExpression);
        return createParenExpression(createCommaExpression(expressions));
      },
      transformPropertyNameAssignment: function(tree) {
        if (!this.needsAdvancedTransform)
          return $traceurRuntime.superGet(this, ObjectLiteralTransformer.prototype, "transformPropertyNameAssignment").call(this, tree);
        if (isProtoName(tree.name))
          return null;
        return this.createProperty_(tree.name, {
          value: this.transformAny(tree.value),
          configurable: true,
          enumerable: true,
          writable: true
        });
      },
      transformGetAccessor: function(tree) {
        if (!this.needsAdvancedTransform)
          return $traceurRuntime.superGet(this, ObjectLiteralTransformer.prototype, "transformGetAccessor").call(this, tree);
        var body = this.transformAny(tree.body);
        var func = createFunctionExpression(createEmptyParameterList(), body);
        return this.createProperty_(tree.name, {
          get: func,
          configurable: true,
          enumerable: true
        });
      },
      transformSetAccessor: function(tree) {
        if (!this.needsAdvancedTransform)
          return $traceurRuntime.superGet(this, ObjectLiteralTransformer.prototype, "transformSetAccessor").call(this, tree);
        var body = this.transformAny(tree.body);
        var parameterList = this.transformAny(tree.parameterList);
        var func = createFunctionExpression(parameterList, body);
        return this.createProperty_(tree.name, {
          set: func,
          configurable: true,
          enumerable: true
        });
      },
      transformMethod: function(tree) {
        var func = new FunctionExpression(tree.location, tree.debugName, tree.functionKind, this.transformAny(tree.parameterList), tree.typeAnnotation, [], this.transformAny(tree.body));
        if (!this.needsAdvancedTransform) {
          return createPropertyNameAssignment(tree.name, func);
        }
        var expression = this.transformAny(tree.name);
        return this.createProperty_(tree.name, {
          value: func,
          configurable: true,
          enumerable: true,
          writable: true
        });
      },
      transformPropertyNameShorthand: function(tree) {
        if (!this.needsAdvancedTransform)
          return $traceurRuntime.superGet(this, ObjectLiteralTransformer.prototype, "transformPropertyNameShorthand").call(this, tree);
        var expression = this.transformAny(tree.name);
        return this.createProperty_(tree.name, {
          value: new IdentifierExpression(tree.location, tree.name.identifierToken),
          configurable: true,
          enumerable: false,
          writable: true
        });
      }
    }, {}, $__super);
  }(TempVarTransformer);
  return {get ObjectLiteralTransformer() {
      return ObjectLiteralTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/RewriteTailExpressionsTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/RewriteTailExpressionsTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/RewriteTailExpressionsTransformer.js")).ParseTreeTransformer;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/RewriteTailExpressionsTransformer.js")),
      ArgumentList = $__2.ArgumentList,
      BinaryExpression = $__2.BinaryExpression,
      CallExpression = $__2.CallExpression,
      ConditionalExpression = $__2.ConditionalExpression,
      MemberExpression = $__2.MemberExpression,
      MemberLookupExpression = $__2.MemberLookupExpression;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/RewriteTailExpressionsTransformer.js")),
      createArrayLiteral = $__3.createArrayLiteral,
      createAssignmentExpression = $__3.createAssignmentExpression,
      createCommaExpression = $__3.createCommaExpression,
      createMemberExpression = $__3.createMemberExpression,
      id = $__3.createIdentifierExpression,
      createNullLiteral = $__3.createNullLiteral,
      createParenExpression = $__3.createParenExpression;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/RewriteTailExpressionsTransformer.js")),
      COMMA_EXPRESSION = $__4.COMMA_EXPRESSION,
      MEMBER_EXPRESSION = $__4.MEMBER_EXPRESSION,
      MEMBER_LOOKUP_EXPRESSION = $__4.MEMBER_LOOKUP_EXPRESSION,
      IDENTIFIER_EXPRESSION = $__4.IDENTIFIER_EXPRESSION,
      PAREN_EXPRESSION = $__4.PAREN_EXPRESSION,
      THIS_EXPRESSION = $__4.THIS_EXPRESSION;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/RewriteTailExpressionsTransformer.js")),
      AND = $__5.AND,
      OR = $__5.OR;
  function createCall(tree, operand, thisArg, importRuntimeTransformer) {
    var argList = tree.args;
    var argArray = argList ? argList.args : [];
    argArray = argArray.map(function(arg) {
      if (arg.type === COMMA_EXPRESSION) {
        return createParenExpression(arg.type);
      }
      return arg;
    });
    var continuation = importRuntimeTransformer.getRuntimeExpression('continuation');
    return new CallExpression(tree.location, continuation, new ArgumentList(argList ? argList.location : null, [operand, thisArg, createArrayLiteral(argArray)]));
  }
  var RewriteTailExpressionsTransformer = function($__super) {
    function RewriteTailExpressionsTransformer(bodyTransformer) {
      $traceurRuntime.superConstructor(RewriteTailExpressionsTransformer).call(this);
      this.bodyTransformer_ = bodyTransformer;
    }
    return ($traceurRuntime.createClass)(RewriteTailExpressionsTransformer, {
      transformBinaryExpression: function(tree) {
        var operator = tree.operator;
        if (operator.type !== AND && operator.type !== OR) {
          return tree;
        }
        var right = this.transformAny(tree.right);
        if (right !== tree.right) {
          return new BinaryExpression(tree.location, tree.left, operator, right);
        }
        return tree;
      },
      transformCallExpression: function(tree) {
        var operand = tree.operand;
        while (operand.type === PAREN_EXPRESSION) {
          operand = operand.expression;
        }
        switch (operand.type) {
          case IDENTIFIER_EXPRESSION:
            return createCall(tree, operand, createNullLiteral(), this.bodyTransformer_);
          case MEMBER_EXPRESSION:
          case MEMBER_LOOKUP_EXPRESSION:
            return this.transformMemberExpressionCall_(tree, operand);
        }
        return tree;
      },
      transformMemberExpressionCall_: function(tree, operand) {
        var object = operand.operand;
        var thisArg;
        var assignment;
        if (object.type === IDENTIFIER_EXPRESSION || object.type === THIS_EXPRESSION) {
          thisArg = object;
        } else {
          thisArg = id(this.bodyTransformer_.addTempVar());
          assignment = createAssignmentExpression(thisArg, operand.operand);
        }
        if (operand.type === MEMBER_EXPRESSION) {
          operand = new MemberExpression(operand.location, thisArg, operand.memberName);
        } else {
          operand = new MemberLookupExpression(operand.location, thisArg, operand.memberExpression);
        }
        if (assignment) {
          return createParenExpression(createCommaExpression([assignment, createCall(tree, operand, thisArg, this.bodyTransformer_)]));
        } else {
          return createCall(tree, operand, thisArg, this.bodyTransformer_);
        }
      },
      transformCommaExpression: function(tree) {
        var expressions = tree.expressions;
        var expression = expressions[expressions.length - 1];
        var transformedExpression = this.transformAny(expression);
        if (expression !== transformedExpression) {
          expressions = expressions.slice(0, -1);
          expressions.push(transformedExpression);
          return new CommaExpression(tree.location, expressions);
        }
        return tree;
      },
      transformConditionalExpression: function(tree) {
        var left = this.transformAny(tree.left);
        var right = this.transformAny(tree.right);
        if (left !== tree.left || right !== tree.right) {
          return new ConditionalExpression(tree.location, tree.condition, left, right);
        }
        return tree;
      },
      transformNewExpression: function(tree) {
        var construct = this.bodyTransformer_.getRuntimeExpression('construct');
        return createCall(tree, construct, tree.operand, this.bodyTransformer_);
      },
      transformArrayLiteral: function(tree) {
        return tree;
      },
      transformArrowFunction: function(tree) {
        return tree;
      },
      transformFunctionExpression: function(tree) {
        return tree;
      },
      transformIdentifierExpression: function(tree) {
        return tree;
      },
      transformLiteralExpression: function(tree) {
        return tree;
      },
      transformMemberExpression: function(tree) {
        return tree;
      },
      transformMemberLookupExpression: function(tree) {
        return tree;
      },
      transformPostfixExpression: function(tree) {
        return tree;
      },
      transformObjectLiteral: function(tree) {
        return tree;
      },
      transformUnaryExpression: function(tree) {
        return tree;
      }
    }, {transform: function(bodyTransformer, tree) {
        return new RewriteTailExpressionsTransformer(bodyTransformer).transformAny(tree);
      }}, $__super);
  }(ParseTreeTransformer);
  return {get RewriteTailExpressionsTransformer() {
      return RewriteTailExpressionsTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/RewriteTailCallsTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/RewriteTailCallsTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/RewriteTailCallsTransformer.js")).ParseTreeTransformer;
  var RewriteTailExpressionsTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./RewriteTailExpressionsTransformer.js", "traceur@0.0.112/src/codegeneration/RewriteTailCallsTransformer.js")).RewriteTailExpressionsTransformer;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/RewriteTailCallsTransformer.js")),
      ReturnStatement = $__3.ReturnStatement,
      TryStatement = $__3.TryStatement;
  var SkipFunctionsTransformerTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SkipFunctionsTransformerTrait.js", "traceur@0.0.112/src/codegeneration/RewriteTailCallsTransformer.js")).default;
  var RewriteTailCallsTransformer = function($__super) {
    function RewriteTailCallsTransformer(bodyTransformer) {
      $traceurRuntime.superConstructor(RewriteTailCallsTransformer).call(this);
      this.bodyTransformer_ = bodyTransformer;
    }
    return ($traceurRuntime.createClass)(RewriteTailCallsTransformer, {
      transformReturnStatement: function(tree) {
        var expression = tree.expression;
        if (expression !== null) {
          expression = RewriteTailExpressionsTransformer.transform(this.bodyTransformer_, expression);
          if (expression !== tree.expression) {
            return new ReturnStatement(tree.location, expression);
          }
        }
        return tree;
      },
      transformTryStatement: function(tree) {
        var block;
        if (tree.finallyBlock !== null) {
          block = this.transformAny(tree.finallyBlock);
          if (block !== tree.finallyBlock) {
            return new TryStatement(tree.location, tree.body, tree.catchBlock, block);
          }
        } else {
          block = this.transformAny(tree.catchBlock);
          if (block !== tree.catchBlock) {
            return new TryStatement(tree.location, tree.body, block, tree.finallyBlock);
          }
        }
        return tree;
      },
      transformForInStatement: function(tree) {
        return tree;
      },
      transformForOfStatement: function(tree) {
        return tree;
      },
      transformForOnStatement: function(tree) {
        return tree;
      },
      transformClassDeclaration: function(tree) {
        return tree;
      },
      transformClassExpression: function(tree) {
        return tree;
      },
      transformExpressionStatement: function(tree) {
        return tree;
      },
      transformComprehensionFor: function(tree) {
        return tree;
      },
      transformVariableStatement: function(tree) {
        return tree;
      }
    }, {transform: function(bodyTransformer, tree) {
        return new RewriteTailCallsTransformer(bodyTransformer).transformAny(tree);
      }}, $__super);
  }(SkipFunctionsTransformerTrait(ParseTreeTransformer));
  return {get RewriteTailCallsTransformer() {
      return RewriteTailCallsTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js";
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js")).TempVarTransformer;
  var RewriteTailCallsTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./RewriteTailCallsTransformer.js", "traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js")).RewriteTailCallsTransformer;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js")),
      createFunctionBody = $__3.createFunctionBody,
      createFunctionExpression = $__3.createFunctionExpression,
      id = $__3.createIdentifierExpression;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js")),
      parseExpression = $__4.parseExpression,
      parseStatement = $__4.parseStatement,
      parseStatements = $__4.parseStatements;
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js")),
      AnonBlock = $__5.AnonBlock,
      FunctionDeclaration = $__5.FunctionDeclaration,
      FunctionExpression = $__5.FunctionExpression;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/ProperTailCallTransformer.js")).default;
  var ProperTailCallTransformer = function($__super) {
    function ProperTailCallTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(ProperTailCallTransformer).call(this, identifierGenerator, reporter, options);
      this.inBlock_ = false;
      this.options = options;
    }
    return ($traceurRuntime.createClass)(ProperTailCallTransformer, {
      transformFunctionDeclaration: function(tree) {
        tree = $traceurRuntime.superGet(this, ProperTailCallTransformer.prototype, "transformFunctionDeclaration").call(this, tree);
        if (tree.functionKind !== null) {
          return tree;
        }
        var nameIdExpression = id(tree.name.identifierToken);
        var initTailRecursiveFunction = this.getRuntimeExpression('initTailRecursiveFunction');
        var setupFlagExpression = parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), initTailRecursiveFunction, nameIdExpression);
        var funcDecl = this.transformFunction_(tree, FunctionDeclaration);
        if (funcDecl === tree) {
          return tree;
        }
        var tmpVar = id(this.inBlock_ ? this.getTempIdentifier() : this.addTempVar(setupFlagExpression));
        if (!this.inBlock_) {
          return funcDecl;
        }
        return new AnonBlock(null, [funcDecl, parseStatement($traceurRuntime.getTemplateObject(["var ", " = ", ";"]), tmpVar, setupFlagExpression)]);
      },
      transformFunctionExpression: function(tree) {
        tree = $traceurRuntime.superGet(this, ProperTailCallTransformer.prototype, "transformFunctionExpression").call(this, tree);
        if (tree.functionKind) {
          return tree;
        }
        var functionExpression = this.transformFunction_(tree, FunctionExpression);
        if (functionExpression === tree) {
          return tree;
        }
        var initTailRecursiveFunction = this.getRuntimeExpression('initTailRecursiveFunction');
        return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), initTailRecursiveFunction, functionExpression);
      },
      transformFunction_: function(tree, constructor) {
        var body = RewriteTailCallsTransformer.transform(this, tree.body);
        if (body === tree.body) {
          return tree;
        }
        var func = id(this.getTempIdentifier());
        var innerFunction = createFunctionExpression(tree.parameterList, body);
        var call = this.getRuntimeExpression('call');
        var outerBody = createFunctionBody(parseStatements($traceurRuntime.getTemplateObject(["\n        return ", "(", ", this, arguments);"]), call, innerFunction));
        return new constructor(tree.location, tree.name, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, outerBody);
      },
      transformBlock: function(tree) {
        var inBlock = this.inBlock_;
        this.inBlock_ = true;
        var rv = $traceurRuntime.superGet(this, ProperTailCallTransformer.prototype, "transformBlock").call(this, tree);
        this.inBlock_ = inBlock;
        return rv;
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  return {get ProperTailCallTransformer() {
      return ProperTailCallTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/PropertyNameShorthandTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/PropertyNameShorthandTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/PropertyNameShorthandTransformer.js")),
      IdentifierExpression = $__1.IdentifierExpression,
      LiteralPropertyName = $__1.LiteralPropertyName,
      PropertyNameAssignment = $__1.PropertyNameAssignment;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/PropertyNameShorthandTransformer.js")).ParseTreeTransformer;
  var PropertyNameShorthandTransformer = function($__super) {
    function PropertyNameShorthandTransformer() {
      $traceurRuntime.superConstructor(PropertyNameShorthandTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(PropertyNameShorthandTransformer, {transformPropertyNameShorthand: function(tree) {
        return new PropertyNameAssignment(tree.location, new LiteralPropertyName(tree.location, tree.name), new IdentifierExpression(tree.location, tree.name));
      }}, {}, $__super);
  }(ParseTreeTransformer);
  return {get PropertyNameShorthandTransformer() {
      return PropertyNameShorthandTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/outputgeneration/regexpuRewritePattern.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/outputgeneration/regexpuRewritePattern.js";
  var modules = {};
  var module = {};
  var exports = module.exports = {};
  var require = function(id) {
    return modules[id];
  };
  ;
  (function(root) {
    var freeExports = typeof exports == 'object' && exports;
    var freeModule = typeof module == 'object' && module && module.exports == freeExports && module;
    var freeGlobal = typeof global == 'object' && global;
    if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
      root = freeGlobal;
    }
    var ERRORS = {
      'rangeOrder': 'A range\u2019s `stop` value must be greater than or equal ' + 'to the `start` value.',
      'codePointRange': 'Invalid code point value. Code points range from ' + 'U+000000 to U+10FFFF.'
    };
    var HIGH_SURROGATE_MIN = 0xD800;
    var HIGH_SURROGATE_MAX = 0xDBFF;
    var LOW_SURROGATE_MIN = 0xDC00;
    var LOW_SURROGATE_MAX = 0xDFFF;
    var regexNull = /\\x00([^0123456789]|$)/g;
    var object = {};
    var hasOwnProperty = object.hasOwnProperty;
    var extend = function(destination, source) {
      var key;
      for (key in source) {
        if (hasOwnProperty.call(source, key)) {
          destination[key] = source[key];
        }
      }
      return destination;
    };
    var forEach = function(array, callback) {
      var index = -1;
      var length = array.length;
      while (++index < length) {
        callback(array[index], index);
      }
    };
    var toString = object.toString;
    var isArray = function(value) {
      return toString.call(value) == '[object Array]';
    };
    var isNumber = function(value) {
      return typeof value == 'number' || toString.call(value) == '[object Number]';
    };
    var zeroes = '0000';
    var pad = function(number, totalCharacters) {
      var string = String(number);
      return string.length < totalCharacters ? (zeroes + string).slice(-totalCharacters) : string;
    };
    var hex = function(number) {
      return Number(number).toString(16).toUpperCase();
    };
    var slice = [].slice;
    var dataFromCodePoints = function(codePoints) {
      var index = -1;
      var length = codePoints.length;
      var max = length - 1;
      var result = [];
      var isStart = true;
      var tmp;
      var previous = 0;
      while (++index < length) {
        tmp = codePoints[index];
        if (isStart) {
          result.push(tmp);
          previous = tmp;
          isStart = false;
        } else {
          if (tmp == previous + 1) {
            if (index != max) {
              previous = tmp;
              continue;
            } else {
              isStart = true;
              result.push(tmp + 1);
            }
          } else {
            result.push(previous + 1, tmp);
            previous = tmp;
          }
        }
      }
      if (!isStart) {
        result.push(tmp + 1);
      }
      return result;
    };
    var dataRemove = function(data, codePoint) {
      var index = 0;
      var start;
      var end;
      var length = data.length;
      while (index < length) {
        start = data[index];
        end = data[index + 1];
        if (codePoint >= start && codePoint < end) {
          if (codePoint == start) {
            if (end == start + 1) {
              data.splice(index, 2);
              return data;
            } else {
              data[index] = codePoint + 1;
              return data;
            }
          } else if (codePoint == end - 1) {
            data[index + 1] = codePoint;
            return data;
          } else {
            data.splice(index, 2, start, codePoint, codePoint + 1, end);
            return data;
          }
        }
        index += 2;
      }
      return data;
    };
    var dataRemoveRange = function(data, rangeStart, rangeEnd) {
      if (rangeEnd < rangeStart) {
        throw Error(ERRORS.rangeOrder);
      }
      var index = 0;
      var start;
      var end;
      while (index < data.length) {
        start = data[index];
        end = data[index + 1] - 1;
        if (start > rangeEnd) {
          return data;
        }
        if (rangeStart <= start && rangeEnd >= end) {
          data.splice(index, 2);
          continue;
        }
        if (rangeStart >= start && rangeEnd < end) {
          if (rangeStart == start) {
            data[index] = rangeEnd + 1;
            data[index + 1] = end + 1;
            return data;
          }
          data.splice(index, 2, start, rangeStart, rangeEnd + 1, end + 1);
          return data;
        }
        if (rangeStart >= start && rangeStart <= end) {
          data[index + 1] = rangeStart;
        } else if (rangeEnd >= start && rangeEnd <= end) {
          data[index] = rangeEnd + 1;
          return data;
        }
        index += 2;
      }
      return data;
    };
    var dataAdd = function(data, codePoint) {
      var index = 0;
      var start;
      var end;
      var lastIndex = null;
      var length = data.length;
      if (codePoint < 0x0 || codePoint > 0x10FFFF) {
        throw RangeError(ERRORS.codePointRange);
      }
      while (index < length) {
        start = data[index];
        end = data[index + 1];
        if (codePoint >= start && codePoint < end) {
          return data;
        }
        if (codePoint == start - 1) {
          data[index] = codePoint;
          return data;
        }
        if (start > codePoint) {
          data.splice(lastIndex != null ? lastIndex + 2 : 0, 0, codePoint, codePoint + 1);
          return data;
        }
        if (codePoint == end) {
          if (codePoint + 1 == data[index + 2]) {
            data.splice(index, 4, start, data[index + 3]);
            return data;
          }
          data[index + 1] = codePoint + 1;
          return data;
        }
        lastIndex = index;
        index += 2;
      }
      data.push(codePoint, codePoint + 1);
      return data;
    };
    var dataAddData = function(dataA, dataB) {
      var index = 0;
      var start;
      var end;
      var data = dataA.slice();
      var length = dataB.length;
      while (index < length) {
        start = dataB[index];
        end = dataB[index + 1] - 1;
        if (start == end) {
          data = dataAdd(data, start);
        } else {
          data = dataAddRange(data, start, end);
        }
        index += 2;
      }
      return data;
    };
    var dataRemoveData = function(dataA, dataB) {
      var index = 0;
      var start;
      var end;
      var data = dataA.slice();
      var length = dataB.length;
      while (index < length) {
        start = dataB[index];
        end = dataB[index + 1] - 1;
        if (start == end) {
          data = dataRemove(data, start);
        } else {
          data = dataRemoveRange(data, start, end);
        }
        index += 2;
      }
      return data;
    };
    var dataAddRange = function(data, rangeStart, rangeEnd) {
      if (rangeEnd < rangeStart) {
        throw Error(ERRORS.rangeOrder);
      }
      if (rangeStart < 0x0 || rangeStart > 0x10FFFF || rangeEnd < 0x0 || rangeEnd > 0x10FFFF) {
        throw RangeError(ERRORS.codePointRange);
      }
      var index = 0;
      var start;
      var end;
      var added = false;
      var length = data.length;
      while (index < length) {
        start = data[index];
        end = data[index + 1];
        if (added) {
          if (start == rangeEnd + 1) {
            data.splice(index - 1, 2);
            return data;
          }
          if (start > rangeEnd) {
            return data;
          }
          if (start >= rangeStart && start <= rangeEnd) {
            if (end > rangeStart && end - 1 <= rangeEnd) {
              data.splice(index, 2);
              index -= 2;
            } else {
              data.splice(index - 1, 2);
              index -= 2;
            }
          }
        } else if (start == rangeEnd + 1) {
          data[index] = rangeStart;
          return data;
        } else if (start > rangeEnd) {
          data.splice(index, 0, rangeStart, rangeEnd + 1);
          return data;
        } else if (rangeStart >= start && rangeStart < end && rangeEnd + 1 <= end) {
          return data;
        } else if ((rangeStart >= start && rangeStart < end) || end == rangeStart) {
          data[index + 1] = rangeEnd + 1;
          added = true;
        } else if (rangeStart <= start && rangeEnd + 1 >= end) {
          data[index] = rangeStart;
          data[index + 1] = rangeEnd + 1;
          added = true;
        }
        index += 2;
      }
      if (!added) {
        data.push(rangeStart, rangeEnd + 1);
      }
      return data;
    };
    var dataContains = function(data, codePoint) {
      var index = 0;
      var length = data.length;
      var start = data[index];
      var end = data[length - 1];
      if (length >= 2) {
        if (codePoint < start || codePoint > end) {
          return false;
        }
      }
      while (index < length) {
        start = data[index];
        end = data[index + 1];
        if (codePoint >= start && codePoint < end) {
          return true;
        }
        index += 2;
      }
      return false;
    };
    var dataIntersection = function(data, codePoints) {
      var index = 0;
      var length = codePoints.length;
      var codePoint;
      var result = [];
      while (index < length) {
        codePoint = codePoints[index];
        if (dataContains(data, codePoint)) {
          result.push(codePoint);
        }
        ++index;
      }
      return dataFromCodePoints(result);
    };
    var dataIsEmpty = function(data) {
      return !data.length;
    };
    var dataIsSingleton = function(data) {
      return data.length == 2 && data[0] + 1 == data[1];
    };
    var dataToArray = function(data) {
      var index = 0;
      var start;
      var end;
      var result = [];
      var length = data.length;
      while (index < length) {
        start = data[index];
        end = data[index + 1];
        while (start < end) {
          result.push(start);
          ++start;
        }
        index += 2;
      }
      return result;
    };
    var floor = Math.floor;
    var highSurrogate = function(codePoint) {
      return parseInt(floor((codePoint - 0x10000) / 0x400) + HIGH_SURROGATE_MIN, 10);
    };
    var lowSurrogate = function(codePoint) {
      return parseInt((codePoint - 0x10000) % 0x400 + LOW_SURROGATE_MIN, 10);
    };
    var stringFromCharCode = String.fromCharCode;
    var codePointToString = function(codePoint) {
      var string;
      if (codePoint == 0x09) {
        string = '\\t';
      } else if (codePoint == 0x0A) {
        string = '\\n';
      } else if (codePoint == 0x0C) {
        string = '\\f';
      } else if (codePoint == 0x0D) {
        string = '\\r';
      } else if (codePoint == 0x5C) {
        string = '\\\\';
      } else if (codePoint == 0x24 || (codePoint >= 0x28 && codePoint <= 0x2B) || codePoint == 0x2D || codePoint == 0x2E || codePoint == 0x3F || (codePoint >= 0x5B && codePoint <= 0x5E) || (codePoint >= 0x7B && codePoint <= 0x7D)) {
        string = '\\' + stringFromCharCode(codePoint);
      } else if (codePoint >= 0x20 && codePoint <= 0x7E) {
        string = stringFromCharCode(codePoint);
      } else if (codePoint <= 0xFF) {
        string = '\\x' + pad(hex(codePoint), 2);
      } else {
        string = '\\u' + pad(hex(codePoint), 4);
      }
      return string;
    };
    var symbolToCodePoint = function(symbol) {
      var length = symbol.length;
      var first = symbol.charCodeAt(0);
      var second;
      if (first >= HIGH_SURROGATE_MIN && first <= HIGH_SURROGATE_MAX && length > 1) {
        second = symbol.charCodeAt(1);
        return (first - HIGH_SURROGATE_MIN) * 0x400 + second - LOW_SURROGATE_MIN + 0x10000;
      }
      return first;
    };
    var createBMPCharacterClasses = function(data) {
      var result = '';
      var index = 0;
      var start;
      var end;
      var length = data.length;
      if (dataIsSingleton(data)) {
        return codePointToString(data[0]);
      }
      while (index < length) {
        start = data[index];
        end = data[index + 1] - 1;
        if (start == end) {
          result += codePointToString(start);
        } else if (start + 1 == end) {
          result += codePointToString(start) + codePointToString(end);
        } else {
          result += codePointToString(start) + '-' + codePointToString(end);
        }
        index += 2;
      }
      return '[' + result + ']';
    };
    var splitAtBMP = function(data) {
      var loneHighSurrogates = [];
      var loneLowSurrogates = [];
      var bmp = [];
      var astral = [];
      var index = 0;
      var start;
      var end;
      var length = data.length;
      while (index < length) {
        start = data[index];
        end = data[index + 1] - 1;
        if (start < HIGH_SURROGATE_MIN) {
          if (end < HIGH_SURROGATE_MIN) {
            bmp.push(start, end + 1);
          }
          if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {
            bmp.push(start, HIGH_SURROGATE_MIN);
            loneHighSurrogates.push(HIGH_SURROGATE_MIN, end + 1);
          }
          if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
            bmp.push(start, HIGH_SURROGATE_MIN);
            loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);
            loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);
          }
          if (end > LOW_SURROGATE_MAX) {
            bmp.push(start, HIGH_SURROGATE_MIN);
            loneHighSurrogates.push(HIGH_SURROGATE_MIN, HIGH_SURROGATE_MAX + 1);
            loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);
            if (end <= 0xFFFF) {
              bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
            } else {
              bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
              astral.push(0xFFFF + 1, end + 1);
            }
          }
        } else if (start >= HIGH_SURROGATE_MIN && start <= HIGH_SURROGATE_MAX) {
          if (end >= HIGH_SURROGATE_MIN && end <= HIGH_SURROGATE_MAX) {
            loneHighSurrogates.push(start, end + 1);
          }
          if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
            loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);
            loneLowSurrogates.push(LOW_SURROGATE_MIN, end + 1);
          }
          if (end > LOW_SURROGATE_MAX) {
            loneHighSurrogates.push(start, HIGH_SURROGATE_MAX + 1);
            loneLowSurrogates.push(LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1);
            if (end <= 0xFFFF) {
              bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
            } else {
              bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
              astral.push(0xFFFF + 1, end + 1);
            }
          }
        } else if (start >= LOW_SURROGATE_MIN && start <= LOW_SURROGATE_MAX) {
          if (end >= LOW_SURROGATE_MIN && end <= LOW_SURROGATE_MAX) {
            loneLowSurrogates.push(start, end + 1);
          }
          if (end > LOW_SURROGATE_MAX) {
            loneLowSurrogates.push(start, LOW_SURROGATE_MAX + 1);
            if (end <= 0xFFFF) {
              bmp.push(LOW_SURROGATE_MAX + 1, end + 1);
            } else {
              bmp.push(LOW_SURROGATE_MAX + 1, 0xFFFF + 1);
              astral.push(0xFFFF + 1, end + 1);
            }
          }
        } else if (start > LOW_SURROGATE_MAX && start <= 0xFFFF) {
          if (end <= 0xFFFF) {
            bmp.push(start, end + 1);
          } else {
            bmp.push(start, 0xFFFF + 1);
            astral.push(0xFFFF + 1, end + 1);
          }
        } else {
          astral.push(start, end + 1);
        }
        index += 2;
      }
      return {
        'loneHighSurrogates': loneHighSurrogates,
        'loneLowSurrogates': loneLowSurrogates,
        'bmp': bmp,
        'astral': astral
      };
    };
    var optimizeSurrogateMappings = function(surrogateMappings) {
      var result = [];
      var tmpLow = [];
      var addLow = false;
      var mapping;
      var nextMapping;
      var highSurrogates;
      var lowSurrogates;
      var nextHighSurrogates;
      var nextLowSurrogates;
      var index = -1;
      var length = surrogateMappings.length;
      while (++index < length) {
        mapping = surrogateMappings[index];
        nextMapping = surrogateMappings[index + 1];
        if (!nextMapping) {
          result.push(mapping);
          continue;
        }
        highSurrogates = mapping[0];
        lowSurrogates = mapping[1];
        nextHighSurrogates = nextMapping[0];
        nextLowSurrogates = nextMapping[1];
        tmpLow = lowSurrogates;
        while (nextHighSurrogates && highSurrogates[0] == nextHighSurrogates[0] && highSurrogates[1] == nextHighSurrogates[1]) {
          if (dataIsSingleton(nextLowSurrogates)) {
            tmpLow = dataAdd(tmpLow, nextLowSurrogates[0]);
          } else {
            tmpLow = dataAddRange(tmpLow, nextLowSurrogates[0], nextLowSurrogates[1] - 1);
          }
          ++index;
          mapping = surrogateMappings[index];
          highSurrogates = mapping[0];
          lowSurrogates = mapping[1];
          nextMapping = surrogateMappings[index + 1];
          nextHighSurrogates = nextMapping && nextMapping[0];
          nextLowSurrogates = nextMapping && nextMapping[1];
          addLow = true;
        }
        result.push([highSurrogates, addLow ? tmpLow : lowSurrogates]);
        addLow = false;
      }
      return optimizeByLowSurrogates(result);
    };
    var optimizeByLowSurrogates = function(surrogateMappings) {
      if (surrogateMappings.length == 1) {
        return surrogateMappings;
      }
      var index = -1;
      var innerIndex = -1;
      while (++index < surrogateMappings.length) {
        var mapping = surrogateMappings[index];
        var lowSurrogates = mapping[1];
        var lowSurrogateStart = lowSurrogates[0];
        var lowSurrogateEnd = lowSurrogates[1];
        innerIndex = index;
        while (++innerIndex < surrogateMappings.length) {
          var otherMapping = surrogateMappings[innerIndex];
          var otherLowSurrogates = otherMapping[1];
          var otherLowSurrogateStart = otherLowSurrogates[0];
          var otherLowSurrogateEnd = otherLowSurrogates[1];
          if (lowSurrogateStart == otherLowSurrogateStart && lowSurrogateEnd == otherLowSurrogateEnd) {
            if (dataIsSingleton(otherMapping[0])) {
              mapping[0] = dataAdd(mapping[0], otherMapping[0][0]);
            } else {
              mapping[0] = dataAddRange(mapping[0], otherMapping[0][0], otherMapping[0][1] - 1);
            }
            surrogateMappings.splice(innerIndex, 1);
            --innerIndex;
          }
        }
      }
      return surrogateMappings;
    };
    var surrogateSet = function(data) {
      if (!data.length) {
        return [];
      }
      var index = 0;
      var start;
      var end;
      var startHigh;
      var startLow;
      var prevStartHigh = 0;
      var prevEndHigh = 0;
      var tmpLow = [];
      var endHigh;
      var endLow;
      var surrogateMappings = [];
      var length = data.length;
      var dataHigh = [];
      while (index < length) {
        start = data[index];
        end = data[index + 1] - 1;
        startHigh = highSurrogate(start);
        startLow = lowSurrogate(start);
        endHigh = highSurrogate(end);
        endLow = lowSurrogate(end);
        var startsWithLowestLowSurrogate = startLow == LOW_SURROGATE_MIN;
        var endsWithHighestLowSurrogate = endLow == LOW_SURROGATE_MAX;
        var complete = false;
        if (startHigh == endHigh || startsWithLowestLowSurrogate && endsWithHighestLowSurrogate) {
          surrogateMappings.push([[startHigh, endHigh + 1], [startLow, endLow + 1]]);
          complete = true;
        } else {
          surrogateMappings.push([[startHigh, startHigh + 1], [startLow, LOW_SURROGATE_MAX + 1]]);
        }
        if (!complete && startHigh + 1 < endHigh) {
          if (endsWithHighestLowSurrogate) {
            surrogateMappings.push([[startHigh + 1, endHigh + 1], [LOW_SURROGATE_MIN, endLow + 1]]);
            complete = true;
          } else {
            surrogateMappings.push([[startHigh + 1, endHigh], [LOW_SURROGATE_MIN, LOW_SURROGATE_MAX + 1]]);
          }
        }
        if (!complete) {
          surrogateMappings.push([[endHigh, endHigh + 1], [LOW_SURROGATE_MIN, endLow + 1]]);
        }
        prevStartHigh = startHigh;
        prevEndHigh = endHigh;
        index += 2;
      }
      return optimizeSurrogateMappings(surrogateMappings);
    };
    var createSurrogateCharacterClasses = function(surrogateMappings) {
      var result = [];
      forEach(surrogateMappings, function(surrogateMapping) {
        var highSurrogates = surrogateMapping[0];
        var lowSurrogates = surrogateMapping[1];
        result.push(createBMPCharacterClasses(highSurrogates) + createBMPCharacterClasses(lowSurrogates));
      });
      return result.join('|');
    };
    var createCharacterClassesFromData = function(data, bmpOnly) {
      var result = [];
      var parts = splitAtBMP(data);
      var loneHighSurrogates = parts.loneHighSurrogates;
      var loneLowSurrogates = parts.loneLowSurrogates;
      var bmp = parts.bmp;
      var astral = parts.astral;
      var hasAstral = !dataIsEmpty(parts.astral);
      var hasLoneHighSurrogates = !dataIsEmpty(loneHighSurrogates);
      var hasLoneLowSurrogates = !dataIsEmpty(loneLowSurrogates);
      var surrogateMappings = surrogateSet(astral);
      if (bmpOnly) {
        bmp = dataAddData(bmp, loneHighSurrogates);
        hasLoneHighSurrogates = false;
        bmp = dataAddData(bmp, loneLowSurrogates);
        hasLoneLowSurrogates = false;
      }
      if (!dataIsEmpty(bmp)) {
        result.push(createBMPCharacterClasses(bmp));
      }
      if (surrogateMappings.length) {
        result.push(createSurrogateCharacterClasses(surrogateMappings));
      }
      if (hasLoneHighSurrogates) {
        result.push(createBMPCharacterClasses(loneHighSurrogates) + '(?![\\uDC00-\\uDFFF])');
      }
      if (hasLoneLowSurrogates) {
        result.push('(?:[^\\uD800-\\uDBFF]|^)' + createBMPCharacterClasses(loneLowSurrogates));
      }
      return result.join('|');
    };
    var regenerate = function(value) {
      if (arguments.length > 1) {
        value = slice.call(arguments);
      }
      if (this instanceof regenerate) {
        this.data = [];
        return value ? this.add(value) : this;
      }
      return (new regenerate).add(value);
    };
    regenerate.version = '1.2.0';
    var proto = regenerate.prototype;
    extend(proto, {
      'add': function(value) {
        var $this = this;
        if (value == null) {
          return $this;
        }
        if (value instanceof regenerate) {
          $this.data = dataAddData($this.data, value.data);
          return $this;
        }
        if (arguments.length > 1) {
          value = slice.call(arguments);
        }
        if (isArray(value)) {
          forEach(value, function(item) {
            $this.add(item);
          });
          return $this;
        }
        $this.data = dataAdd($this.data, isNumber(value) ? value : symbolToCodePoint(value));
        return $this;
      },
      'remove': function(value) {
        var $this = this;
        if (value == null) {
          return $this;
        }
        if (value instanceof regenerate) {
          $this.data = dataRemoveData($this.data, value.data);
          return $this;
        }
        if (arguments.length > 1) {
          value = slice.call(arguments);
        }
        if (isArray(value)) {
          forEach(value, function(item) {
            $this.remove(item);
          });
          return $this;
        }
        $this.data = dataRemove($this.data, isNumber(value) ? value : symbolToCodePoint(value));
        return $this;
      },
      'addRange': function(start, end) {
        var $this = this;
        $this.data = dataAddRange($this.data, isNumber(start) ? start : symbolToCodePoint(start), isNumber(end) ? end : symbolToCodePoint(end));
        return $this;
      },
      'removeRange': function(start, end) {
        var $this = this;
        var startCodePoint = isNumber(start) ? start : symbolToCodePoint(start);
        var endCodePoint = isNumber(end) ? end : symbolToCodePoint(end);
        $this.data = dataRemoveRange($this.data, startCodePoint, endCodePoint);
        return $this;
      },
      'intersection': function(argument) {
        var $this = this;
        var array = argument instanceof regenerate ? dataToArray(argument.data) : argument;
        $this.data = dataIntersection($this.data, array);
        return $this;
      },
      'contains': function(codePoint) {
        return dataContains(this.data, isNumber(codePoint) ? codePoint : symbolToCodePoint(codePoint));
      },
      'clone': function() {
        var set = new regenerate;
        set.data = this.data.slice(0);
        return set;
      },
      'toString': function(options) {
        var result = createCharacterClassesFromData(this.data, options ? options.bmpOnly : false);
        return result.replace(regexNull, '\\0$1');
      },
      'toRegExp': function(flags) {
        return RegExp(this.toString(), flags || '');
      },
      'valueOf': function() {
        return dataToArray(this.data);
      }
    });
    proto.toArray = proto.valueOf;
    if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
      define(function() {
        return regenerate;
      });
    } else if (freeExports && !freeExports.nodeType) {
      if (freeModule) {
        freeModule.exports = regenerate;
      } else {
        freeExports.regenerate = regenerate;
      }
    } else {
      root.regenerate = regenerate;
    }
  }((void 0)));
  modules['regenerate'] = module.exports || window.regenerate;
  ;
  (function() {
    'use strict';
    var objectTypes = {
      'function': true,
      'object': true
    };
    var root = (objectTypes[typeof window] && window) || this;
    var oldRoot = root;
    var freeExports = objectTypes[typeof exports] && exports;
    var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
    var freeGlobal = freeExports && freeModule && typeof global == 'object' && global;
    if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
      root = freeGlobal;
    }
    var stringFromCharCode = String.fromCharCode;
    var floor = Math.floor;
    function fromCodePoint() {
      var MAX_SIZE = 0x4000;
      var codeUnits = [];
      var highSurrogate;
      var lowSurrogate;
      var index = -1;
      var length = arguments.length;
      if (!length) {
        return '';
      }
      var result = '';
      while (++index < length) {
        var codePoint = Number(arguments[index]);
        if (!isFinite(codePoint) || codePoint < 0 || codePoint > 0x10FFFF || floor(codePoint) != codePoint) {
          throw RangeError('Invalid code point: ' + codePoint);
        }
        if (codePoint <= 0xFFFF) {
          codeUnits.push(codePoint);
        } else {
          codePoint -= 0x10000;
          highSurrogate = (codePoint >> 10) + 0xD800;
          lowSurrogate = (codePoint % 0x400) + 0xDC00;
          codeUnits.push(highSurrogate, lowSurrogate);
        }
        if (index + 1 == length || codeUnits.length > MAX_SIZE) {
          result += stringFromCharCode.apply(null, codeUnits);
          codeUnits.length = 0;
        }
      }
      return result;
    }
    function assertType(type, expected) {
      if (expected.indexOf('|') == -1) {
        if (type == expected) {
          return;
        }
        throw Error('Invalid node type: ' + type);
      }
      expected = assertType.hasOwnProperty(expected) ? assertType[expected] : (assertType[expected] = RegExp('^(?:' + expected + ')$'));
      if (expected.test(type)) {
        return;
      }
      throw Error('Invalid node type: ' + type);
    }
    function generate(node) {
      var type = node.type;
      if (generate.hasOwnProperty(type) && typeof generate[type] == 'function') {
        return generate[type](node);
      }
      throw Error('Invalid node type: ' + type);
    }
    function generateAlternative(node) {
      assertType(node.type, 'alternative');
      var terms = node.body,
          length = terms ? terms.length : 0;
      if (length == 1) {
        return generateTerm(terms[0]);
      } else {
        var i = -1,
            result = '';
        while (++i < length) {
          result += generateTerm(terms[i]);
        }
        return result;
      }
    }
    function generateAnchor(node) {
      assertType(node.type, 'anchor');
      switch (node.kind) {
        case 'start':
          return '^';
        case 'end':
          return '$';
        case 'boundary':
          return '\\b';
        case 'not-boundary':
          return '\\B';
        default:
          throw Error('Invalid assertion');
      }
    }
    function generateAtom(node) {
      assertType(node.type, 'anchor|characterClass|characterClassEscape|dot|group|reference|value');
      return generate(node);
    }
    function generateCharacterClass(node) {
      assertType(node.type, 'characterClass');
      var classRanges = node.body,
          length = classRanges ? classRanges.length : 0;
      var i = -1,
          result = '[';
      if (node.negative) {
        result += '^';
      }
      while (++i < length) {
        result += generateClassAtom(classRanges[i]);
      }
      result += ']';
      return result;
    }
    function generateCharacterClassEscape(node) {
      assertType(node.type, 'characterClassEscape');
      return '\\' + node.value;
    }
    function generateCharacterClassRange(node) {
      assertType(node.type, 'characterClassRange');
      var min = node.min,
          max = node.max;
      if (min.type == 'characterClassRange' || max.type == 'characterClassRange') {
        throw Error('Invalid character class range');
      }
      return generateClassAtom(min) + '-' + generateClassAtom(max);
    }
    function generateClassAtom(node) {
      assertType(node.type, 'anchor|characterClassEscape|characterClassRange|dot|value');
      return generate(node);
    }
    function generateDisjunction(node) {
      assertType(node.type, 'disjunction');
      var body = node.body,
          length = body ? body.length : 0;
      if (length == 0) {
        throw Error('No body');
      } else if (length == 1) {
        return generate(body[0]);
      } else {
        var i = -1,
            result = '';
        while (++i < length) {
          if (i != 0) {
            result += '|';
          }
          result += generate(body[i]);
        }
        return result;
      }
    }
    function generateDot(node) {
      assertType(node.type, 'dot');
      return '.';
    }
    function generateGroup(node) {
      assertType(node.type, 'group');
      var result = '(';
      switch (node.behavior) {
        case 'normal':
          break;
        case 'ignore':
          result += '?:';
          break;
        case 'lookahead':
          result += '?=';
          break;
        case 'negativeLookahead':
          result += '?!';
          break;
        default:
          throw Error('Invalid behaviour: ' + node.behaviour);
      }
      var body = node.body,
          length = body ? body.length : 0;
      if (length == 1) {
        result += generate(body[0]);
      } else {
        var i = -1;
        while (++i < length) {
          result += generate(body[i]);
        }
      }
      result += ')';
      return result;
    }
    function generateQuantifier(node) {
      assertType(node.type, 'quantifier');
      var quantifier = '',
          min = node.min,
          max = node.max;
      switch (max) {
        case undefined:
        case null:
          switch (min) {
            case 0:
              quantifier = '*';
              break;
            case 1:
              quantifier = '+';
              break;
            default:
              quantifier = '{' + min + ',}';
              break;
          }
          break;
        default:
          if (min == max) {
            quantifier = '{' + min + '}';
          } else if (min == 0 && max == 1) {
            quantifier = '?';
          } else {
            quantifier = '{' + min + ',' + max + '}';
          }
          break;
      }
      if (!node.greedy) {
        quantifier += '?';
      }
      return generateAtom(node.body[0]) + quantifier;
    }
    function generateReference(node) {
      assertType(node.type, 'reference');
      return '\\' + node.matchIndex;
    }
    function generateTerm(node) {
      assertType(node.type, 'anchor|characterClass|characterClassEscape|empty|group|quantifier|reference|value');
      return generate(node);
    }
    function generateValue(node) {
      assertType(node.type, 'value');
      var kind = node.kind,
          codePoint = node.codePoint;
      switch (kind) {
        case 'controlLetter':
          return '\\c' + fromCodePoint(codePoint + 64);
        case 'hexadecimalEscape':
          return '\\x' + ('00' + codePoint.toString(16).toUpperCase()).slice(-2);
        case 'identifier':
          return '\\' + fromCodePoint(codePoint);
        case 'null':
          return '\\' + codePoint;
        case 'octal':
          return '\\' + codePoint.toString(8);
        case 'singleEscape':
          switch (codePoint) {
            case 0x0008:
              return '\\b';
            case 0x009:
              return '\\t';
            case 0x00A:
              return '\\n';
            case 0x00B:
              return '\\v';
            case 0x00C:
              return '\\f';
            case 0x00D:
              return '\\r';
            default:
              throw Error('Invalid codepoint: ' + codePoint);
          }
        case 'symbol':
          return fromCodePoint(codePoint);
        case 'unicodeEscape':
          return '\\u' + ('0000' + codePoint.toString(16).toUpperCase()).slice(-4);
        case 'unicodeCodePointEscape':
          return '\\u{' + codePoint.toString(16).toUpperCase() + '}';
        default:
          throw Error('Unsupported node kind: ' + kind);
      }
    }
    generate.alternative = generateAlternative;
    generate.anchor = generateAnchor;
    generate.characterClass = generateCharacterClass;
    generate.characterClassEscape = generateCharacterClassEscape;
    generate.characterClassRange = generateCharacterClassRange;
    generate.disjunction = generateDisjunction;
    generate.dot = generateDot;
    generate.group = generateGroup;
    generate.quantifier = generateQuantifier;
    generate.reference = generateReference;
    generate.value = generateValue;
    if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
      define(function() {
        return {'generate': generate};
      });
    } else if (freeExports && freeModule) {
      freeExports.generate = generate;
    } else {
      root.regjsgen = {'generate': generate};
    }
  }.call((void 0)));
  modules['regjsgen'] = {generate: exports.generate || window.regjsgen};
  (function() {
    function parse(str, flags) {
      function addRaw(node) {
        node.raw = str.substring(node.range[0], node.range[1]);
        return node;
      }
      function updateRawStart(node, start) {
        node.range[0] = start;
        return addRaw(node);
      }
      function createAnchor(kind, rawLength) {
        return addRaw({
          type: 'anchor',
          kind: kind,
          range: [pos - rawLength, pos]
        });
      }
      function createValue(kind, codePoint, from, to) {
        return addRaw({
          type: 'value',
          kind: kind,
          codePoint: codePoint,
          range: [from, to]
        });
      }
      function createEscaped(kind, codePoint, value, fromOffset) {
        fromOffset = fromOffset || 0;
        return createValue(kind, codePoint, pos - (value.length + fromOffset), pos);
      }
      function createCharacter(matches) {
        var _char = matches[0];
        var first = _char.charCodeAt(0);
        if (hasUnicodeFlag) {
          var second;
          if (_char.length === 1 && first >= 0xD800 && first <= 0xDBFF) {
            second = lookahead().charCodeAt(0);
            if (second >= 0xDC00 && second <= 0xDFFF) {
              pos++;
              return createValue('symbol', (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000, pos - 2, pos);
            }
          }
        }
        return createValue('symbol', first, pos - 1, pos);
      }
      function createDisjunction(alternatives, from, to) {
        return addRaw({
          type: 'disjunction',
          body: alternatives,
          range: [from, to]
        });
      }
      function createDot() {
        return addRaw({
          type: 'dot',
          range: [pos - 1, pos]
        });
      }
      function createCharacterClassEscape(value) {
        return addRaw({
          type: 'characterClassEscape',
          value: value,
          range: [pos - 2, pos]
        });
      }
      function createReference(matchIndex) {
        return addRaw({
          type: 'reference',
          matchIndex: parseInt(matchIndex, 10),
          range: [pos - 1 - matchIndex.length, pos]
        });
      }
      function createGroup(behavior, disjunction, from, to) {
        return addRaw({
          type: 'group',
          behavior: behavior,
          body: disjunction,
          range: [from, to]
        });
      }
      function createQuantifier(min, max, from, to) {
        if (to == null) {
          from = pos - 1;
          to = pos;
        }
        return addRaw({
          type: 'quantifier',
          min: min,
          max: max,
          greedy: true,
          body: null,
          range: [from, to]
        });
      }
      function createAlternative(terms, from, to) {
        return addRaw({
          type: 'alternative',
          body: terms,
          range: [from, to]
        });
      }
      function createCharacterClass(classRanges, negative, from, to) {
        return addRaw({
          type: 'characterClass',
          body: classRanges,
          negative: negative,
          range: [from, to]
        });
      }
      function createClassRange(min, max, from, to) {
        if (min.codePoint > max.codePoint) {
          bail('invalid range in character class', min.raw + '-' + max.raw, from, to);
        }
        return addRaw({
          type: 'characterClassRange',
          min: min,
          max: max,
          range: [from, to]
        });
      }
      function flattenBody(body) {
        if (body.type === 'alternative') {
          return body.body;
        } else {
          return [body];
        }
      }
      function isEmpty(obj) {
        return obj.type === 'empty';
      }
      function incr(amount) {
        amount = (amount || 1);
        var res = str.substring(pos, pos + amount);
        pos += (amount || 1);
        return res;
      }
      function skip(value) {
        if (!match(value)) {
          bail('character', value);
        }
      }
      function match(value) {
        if (str.indexOf(value, pos) === pos) {
          return incr(value.length);
        }
      }
      function lookahead() {
        return str[pos];
      }
      function current(value) {
        return str.indexOf(value, pos) === pos;
      }
      function next(value) {
        return str[pos + 1] === value;
      }
      function matchReg(regExp) {
        var subStr = str.substring(pos);
        var res = subStr.match(regExp);
        if (res) {
          res.range = [];
          res.range[0] = pos;
          incr(res[0].length);
          res.range[1] = pos;
        }
        return res;
      }
      function parseDisjunction() {
        var res = [],
            from = pos;
        res.push(parseAlternative());
        while (match('|')) {
          res.push(parseAlternative());
        }
        if (res.length === 1) {
          return res[0];
        }
        return createDisjunction(res, from, pos);
      }
      function parseAlternative() {
        var res = [],
            from = pos;
        var term;
        while (term = parseTerm()) {
          res.push(term);
        }
        if (res.length === 1) {
          return res[0];
        }
        return createAlternative(res, from, pos);
      }
      function parseTerm() {
        if (pos >= str.length || current('|') || current(')')) {
          return null;
        }
        var anchor = parseAnchor();
        if (anchor) {
          return anchor;
        }
        var atom = parseAtom();
        if (!atom) {
          bail('Expected atom');
        }
        var quantifier = parseQuantifier() || false;
        if (quantifier) {
          quantifier.body = flattenBody(atom);
          updateRawStart(quantifier, atom.range[0]);
          return quantifier;
        }
        return atom;
      }
      function parseGroup(matchA, typeA, matchB, typeB) {
        var type = null,
            from = pos;
        if (match(matchA)) {
          type = typeA;
        } else if (match(matchB)) {
          type = typeB;
        } else {
          return false;
        }
        var body = parseDisjunction();
        if (!body) {
          bail('Expected disjunction');
        }
        skip(')');
        var group = createGroup(type, flattenBody(body), from, pos);
        if (type == 'normal') {
          if (firstIteration) {
            closedCaptureCounter++;
          }
        }
        return group;
      }
      function parseAnchor() {
        var res,
            from = pos;
        if (match('^')) {
          return createAnchor('start', 1);
        } else if (match('$')) {
          return createAnchor('end', 1);
        } else if (match('\\b')) {
          return createAnchor('boundary', 2);
        } else if (match('\\B')) {
          return createAnchor('not-boundary', 2);
        } else {
          return parseGroup('(?=', 'lookahead', '(?!', 'negativeLookahead');
        }
      }
      function parseQuantifier() {
        var res,
            from = pos;
        var quantifier;
        var min,
            max;
        if (match('*')) {
          quantifier = createQuantifier(0);
        } else if (match('+')) {
          quantifier = createQuantifier(1);
        } else if (match('?')) {
          quantifier = createQuantifier(0, 1);
        } else if (res = matchReg(/^\{([0-9]+)\}/)) {
          min = parseInt(res[1], 10);
          quantifier = createQuantifier(min, min, res.range[0], res.range[1]);
        } else if (res = matchReg(/^\{([0-9]+),\}/)) {
          min = parseInt(res[1], 10);
          quantifier = createQuantifier(min, undefined, res.range[0], res.range[1]);
        } else if (res = matchReg(/^\{([0-9]+),([0-9]+)\}/)) {
          min = parseInt(res[1], 10);
          max = parseInt(res[2], 10);
          if (min > max) {
            bail('numbers out of order in {} quantifier', '', from, pos);
          }
          quantifier = createQuantifier(min, max, res.range[0], res.range[1]);
        }
        if (quantifier) {
          if (match('?')) {
            quantifier.greedy = false;
            quantifier.range[1] += 1;
          }
        }
        return quantifier;
      }
      function parseAtom() {
        var res;
        if (res = matchReg(/^[^^$\\.*+?(){[|]/)) {
          return createCharacter(res);
        } else if (match('.')) {
          return createDot();
        } else if (match('\\')) {
          res = parseAtomEscape();
          if (!res) {
            bail('atomEscape');
          }
          return res;
        } else if (res = parseCharacterClass()) {
          return res;
        } else {
          return parseGroup('(?:', 'ignore', '(', 'normal');
        }
      }
      function parseUnicodeSurrogatePairEscape(firstEscape) {
        if (hasUnicodeFlag) {
          var first,
              second;
          if (firstEscape.kind == 'unicodeEscape' && (first = firstEscape.codePoint) >= 0xD800 && first <= 0xDBFF && current('\\') && next('u')) {
            var prevPos = pos;
            pos++;
            var secondEscape = parseClassEscape();
            if (secondEscape.kind == 'unicodeEscape' && (second = secondEscape.codePoint) >= 0xDC00 && second <= 0xDFFF) {
              firstEscape.range[1] = secondEscape.range[1];
              firstEscape.codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
              firstEscape.type = 'value';
              firstEscape.kind = 'unicodeCodePointEscape';
              addRaw(firstEscape);
            } else {
              pos = prevPos;
            }
          }
        }
        return firstEscape;
      }
      function parseClassEscape() {
        return parseAtomEscape(true);
      }
      function parseAtomEscape(insideCharacterClass) {
        var res,
            from = pos;
        res = parseDecimalEscape();
        if (res) {
          return res;
        }
        if (insideCharacterClass) {
          if (match('b')) {
            return createEscaped('singleEscape', 0x0008, '\\b');
          } else if (match('B')) {
            bail('\\B not possible inside of CharacterClass', '', from);
          }
        }
        res = parseCharacterEscape();
        return res;
      }
      function parseDecimalEscape() {
        var res,
            match;
        if (res = matchReg(/^(?!0)\d+/)) {
          match = res[0];
          var refIdx = parseInt(res[0], 10);
          if (refIdx <= closedCaptureCounter) {
            return createReference(res[0]);
          } else {
            backrefDenied.push(refIdx);
            incr(-res[0].length);
            if (res = matchReg(/^[0-7]{1,3}/)) {
              return createEscaped('octal', parseInt(res[0], 8), res[0], 1);
            } else {
              res = createCharacter(matchReg(/^[89]/));
              return updateRawStart(res, res.range[0] - 1);
            }
          }
        } else if (res = matchReg(/^[0-7]{1,3}/)) {
          match = res[0];
          if (/^0{1,3}$/.test(match)) {
            return createEscaped('null', 0x0000, '0', match.length + 1);
          } else {
            return createEscaped('octal', parseInt(match, 8), match, 1);
          }
        } else if (res = matchReg(/^[dDsSwW]/)) {
          return createCharacterClassEscape(res[0]);
        }
        return false;
      }
      function parseCharacterEscape() {
        var res;
        if (res = matchReg(/^[fnrtv]/)) {
          var codePoint = 0;
          switch (res[0]) {
            case 't':
              codePoint = 0x009;
              break;
            case 'n':
              codePoint = 0x00A;
              break;
            case 'v':
              codePoint = 0x00B;
              break;
            case 'f':
              codePoint = 0x00C;
              break;
            case 'r':
              codePoint = 0x00D;
              break;
          }
          return createEscaped('singleEscape', codePoint, '\\' + res[0]);
        } else if (res = matchReg(/^c([a-zA-Z])/)) {
          return createEscaped('controlLetter', res[1].charCodeAt(0) % 32, res[1], 2);
        } else if (res = matchReg(/^x([0-9a-fA-F]{2})/)) {
          return createEscaped('hexadecimalEscape', parseInt(res[1], 16), res[1], 2);
        } else if (res = matchReg(/^u([0-9a-fA-F]{4})/)) {
          return parseUnicodeSurrogatePairEscape(createEscaped('unicodeEscape', parseInt(res[1], 16), res[1], 2));
        } else if (hasUnicodeFlag && (res = matchReg(/^u\{([0-9a-fA-F]+)\}/))) {
          return createEscaped('unicodeCodePointEscape', parseInt(res[1], 16), res[1], 4);
        } else {
          return parseIdentityEscape();
        }
      }
      function isIdentifierPart(ch) {
        var NonAsciiIdentifierPart = new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]');
        return (ch === 36) || (ch === 95) || (ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122) || (ch >= 48 && ch <= 57) || (ch === 92) || ((ch >= 0x80) && NonAsciiIdentifierPart.test(String.fromCharCode(ch)));
      }
      function parseIdentityEscape() {
        var ZWJ = '\u200C';
        var ZWNJ = '\u200D';
        var tmp;
        if (!isIdentifierPart(lookahead())) {
          tmp = incr();
          return createEscaped('identifier', tmp.charCodeAt(0), tmp, 1);
        }
        if (match(ZWJ)) {
          return createEscaped('identifier', 0x200C, ZWJ);
        } else if (match(ZWNJ)) {
          return createEscaped('identifier', 0x200D, ZWNJ);
        }
        return null;
      }
      function parseCharacterClass() {
        var res,
            from = pos;
        if (res = matchReg(/^\[\^/)) {
          res = parseClassRanges();
          skip(']');
          return createCharacterClass(res, true, from, pos);
        } else if (match('[')) {
          res = parseClassRanges();
          skip(']');
          return createCharacterClass(res, false, from, pos);
        }
        return null;
      }
      function parseClassRanges() {
        var res;
        if (current(']')) {
          return [];
        } else {
          res = parseNonemptyClassRanges();
          if (!res) {
            bail('nonEmptyClassRanges');
          }
          return res;
        }
      }
      function parseHelperClassRanges(atom) {
        var from,
            to,
            res;
        if (current('-') && !next(']')) {
          skip('-');
          res = parseClassAtom();
          if (!res) {
            bail('classAtom');
          }
          to = pos;
          var classRanges = parseClassRanges();
          if (!classRanges) {
            bail('classRanges');
          }
          from = atom.range[0];
          if (classRanges.type === 'empty') {
            return [createClassRange(atom, res, from, to)];
          }
          return [createClassRange(atom, res, from, to)].concat(classRanges);
        }
        res = parseNonemptyClassRangesNoDash();
        if (!res) {
          bail('nonEmptyClassRangesNoDash');
        }
        return [atom].concat(res);
      }
      function parseNonemptyClassRanges() {
        var atom = parseClassAtom();
        if (!atom) {
          bail('classAtom');
        }
        if (current(']')) {
          return [atom];
        }
        return parseHelperClassRanges(atom);
      }
      function parseNonemptyClassRangesNoDash() {
        var res = parseClassAtom();
        if (!res) {
          bail('classAtom');
        }
        if (current(']')) {
          return res;
        }
        return parseHelperClassRanges(res);
      }
      function parseClassAtom() {
        if (match('-')) {
          return createCharacter('-');
        } else {
          return parseClassAtomNoDash();
        }
      }
      function parseClassAtomNoDash() {
        var res;
        if (res = matchReg(/^[^\\\]-]/)) {
          return createCharacter(res[0]);
        } else if (match('\\')) {
          res = parseClassEscape();
          if (!res) {
            bail('classEscape');
          }
          return parseUnicodeSurrogatePairEscape(res);
        }
      }
      function bail(message, details, from, to) {
        from = from == null ? pos : from;
        to = to == null ? from : to;
        var contextStart = Math.max(0, from - 10);
        var contextEnd = Math.min(to + 10, str.length);
        var context = '    ' + str.substring(contextStart, contextEnd);
        var pointer = '    ' + new Array(from - contextStart + 1).join(' ') + '^';
        throw SyntaxError(message + ' at position ' + from + (details ? ': ' + details : '') + '\n' + context + '\n' + pointer);
      }
      var backrefDenied = [];
      var closedCaptureCounter = 0;
      var firstIteration = true;
      var hasUnicodeFlag = (flags || "").indexOf("u") !== -1;
      var pos = 0;
      str = String(str);
      if (str === '') {
        str = '(?:)';
      }
      var result = parseDisjunction();
      if (result.range[1] !== str.length) {
        bail('Could not parse entire input - got stuck', '', result.range[1]);
      }
      for (var i = 0; i < backrefDenied.length; i++) {
        if (backrefDenied[i] <= closedCaptureCounter) {
          pos = 0;
          firstIteration = false;
          return parseDisjunction();
        }
      }
      return result;
    }
    var regjsparser = {parse: parse};
    if (typeof module !== 'undefined' && module.exports) {
      module.exports = regjsparser;
    } else {
      window.regjsparser = regjsparser;
    }
  }());
  modules['regjsparser'] = module.exports || window.regjsparser;
  modules['./data/iu-mappings.json'] = ({
    "75": 8490,
    "83": 383,
    "107": 8490,
    "115": 383,
    "181": 924,
    "197": 8491,
    "383": 83,
    "452": 453,
    "453": 452,
    "455": 456,
    "456": 455,
    "458": 459,
    "459": 458,
    "497": 498,
    "498": 497,
    "837": 8126,
    "914": 976,
    "917": 1013,
    "920": 1012,
    "921": 8126,
    "922": 1008,
    "924": 181,
    "928": 982,
    "929": 1009,
    "931": 962,
    "934": 981,
    "937": 8486,
    "962": 931,
    "976": 914,
    "977": 1012,
    "981": 934,
    "982": 928,
    "1008": 922,
    "1009": 929,
    "1012": [920, 977],
    "1013": 917,
    "7776": 7835,
    "7835": 7776,
    "8126": [837, 921],
    "8486": 937,
    "8490": 75,
    "8491": 197,
    "66560": 66600,
    "66561": 66601,
    "66562": 66602,
    "66563": 66603,
    "66564": 66604,
    "66565": 66605,
    "66566": 66606,
    "66567": 66607,
    "66568": 66608,
    "66569": 66609,
    "66570": 66610,
    "66571": 66611,
    "66572": 66612,
    "66573": 66613,
    "66574": 66614,
    "66575": 66615,
    "66576": 66616,
    "66577": 66617,
    "66578": 66618,
    "66579": 66619,
    "66580": 66620,
    "66581": 66621,
    "66582": 66622,
    "66583": 66623,
    "66584": 66624,
    "66585": 66625,
    "66586": 66626,
    "66587": 66627,
    "66588": 66628,
    "66589": 66629,
    "66590": 66630,
    "66591": 66631,
    "66592": 66632,
    "66593": 66633,
    "66594": 66634,
    "66595": 66635,
    "66596": 66636,
    "66597": 66637,
    "66598": 66638,
    "66599": 66639,
    "66600": 66560,
    "66601": 66561,
    "66602": 66562,
    "66603": 66563,
    "66604": 66564,
    "66605": 66565,
    "66606": 66566,
    "66607": 66567,
    "66608": 66568,
    "66609": 66569,
    "66610": 66570,
    "66611": 66571,
    "66612": 66572,
    "66613": 66573,
    "66614": 66574,
    "66615": 66575,
    "66616": 66576,
    "66617": 66577,
    "66618": 66578,
    "66619": 66579,
    "66620": 66580,
    "66621": 66581,
    "66622": 66582,
    "66623": 66583,
    "66624": 66584,
    "66625": 66585,
    "66626": 66586,
    "66627": 66587,
    "66628": 66588,
    "66629": 66589,
    "66630": 66590,
    "66631": 66591,
    "66632": 66592,
    "66633": 66593,
    "66634": 66594,
    "66635": 66595,
    "66636": 66596,
    "66637": 66597,
    "66638": 66598,
    "66639": 66599,
    "71840": 71872,
    "71841": 71873,
    "71842": 71874,
    "71843": 71875,
    "71844": 71876,
    "71845": 71877,
    "71846": 71878,
    "71847": 71879,
    "71848": 71880,
    "71849": 71881,
    "71850": 71882,
    "71851": 71883,
    "71852": 71884,
    "71853": 71885,
    "71854": 71886,
    "71855": 71887,
    "71856": 71888,
    "71857": 71889,
    "71858": 71890,
    "71859": 71891,
    "71860": 71892,
    "71861": 71893,
    "71862": 71894,
    "71863": 71895,
    "71864": 71896,
    "71865": 71897,
    "71866": 71898,
    "71867": 71899,
    "71868": 71900,
    "71869": 71901,
    "71870": 71902,
    "71871": 71903,
    "71872": 71840,
    "71873": 71841,
    "71874": 71842,
    "71875": 71843,
    "71876": 71844,
    "71877": 71845,
    "71878": 71846,
    "71879": 71847,
    "71880": 71848,
    "71881": 71849,
    "71882": 71850,
    "71883": 71851,
    "71884": 71852,
    "71885": 71853,
    "71886": 71854,
    "71887": 71855,
    "71888": 71856,
    "71889": 71857,
    "71890": 71858,
    "71891": 71859,
    "71892": 71860,
    "71893": 71861,
    "71894": 71862,
    "71895": 71863,
    "71896": 71864,
    "71897": 71865,
    "71898": 71866,
    "71899": 71867,
    "71900": 71868,
    "71901": 71869,
    "71902": 71870,
    "71903": 71871
  });
  var regenerate = require('regenerate');
  exports.REGULAR = {
    'd': regenerate().addRange(0x30, 0x39),
    'D': regenerate().addRange(0x0, 0x2F).addRange(0x3A, 0xFFFF),
    's': regenerate(0x20, 0xA0, 0x1680, 0x180E, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029),
    'S': regenerate().addRange(0x0, 0x8).addRange(0xE, 0x1F).addRange(0x21, 0x9F).addRange(0xA1, 0x167F).addRange(0x1681, 0x180D).addRange(0x180F, 0x1FFF).addRange(0x200B, 0x2027).addRange(0x202A, 0x202E).addRange(0x2030, 0x205E).addRange(0x2060, 0x2FFF).addRange(0x3001, 0xFEFE).addRange(0xFF00, 0xFFFF),
    'w': regenerate(0x5F).addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A),
    'W': regenerate(0x60).addRange(0x0, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0xFFFF)
  };
  exports.UNICODE = {
    'd': regenerate().addRange(0x30, 0x39),
    'D': regenerate().addRange(0x0, 0x2F).addRange(0x3A, 0x10FFFF),
    's': regenerate(0x20, 0xA0, 0x1680, 0x180E, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029),
    'S': regenerate().addRange(0x0, 0x8).addRange(0xE, 0x1F).addRange(0x21, 0x9F).addRange(0xA1, 0x167F).addRange(0x1681, 0x180D).addRange(0x180F, 0x1FFF).addRange(0x200B, 0x2027).addRange(0x202A, 0x202E).addRange(0x2030, 0x205E).addRange(0x2060, 0x2FFF).addRange(0x3001, 0xFEFE).addRange(0xFF00, 0x10FFFF),
    'w': regenerate(0x5F).addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A),
    'W': regenerate(0x60).addRange(0x0, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0x10FFFF)
  };
  exports.UNICODE_IGNORE_CASE = {
    'd': regenerate().addRange(0x30, 0x39),
    'D': regenerate().addRange(0x0, 0x2F).addRange(0x3A, 0x10FFFF),
    's': regenerate(0x20, 0xA0, 0x1680, 0x180E, 0x202F, 0x205F, 0x3000, 0xFEFF).addRange(0x9, 0xD).addRange(0x2000, 0x200A).addRange(0x2028, 0x2029),
    'S': regenerate().addRange(0x0, 0x8).addRange(0xE, 0x1F).addRange(0x21, 0x9F).addRange(0xA1, 0x167F).addRange(0x1681, 0x180D).addRange(0x180F, 0x1FFF).addRange(0x200B, 0x2027).addRange(0x202A, 0x202E).addRange(0x2030, 0x205E).addRange(0x2060, 0x2FFF).addRange(0x3001, 0xFEFE).addRange(0xFF00, 0x10FFFF),
    'w': regenerate(0x5F, 0x17F, 0x212A).addRange(0x30, 0x39).addRange(0x41, 0x5A).addRange(0x61, 0x7A),
    'W': regenerate(0x4B, 0x53, 0x60).addRange(0x0, 0x2F).addRange(0x3A, 0x40).addRange(0x5B, 0x5E).addRange(0x7B, 0x10FFFF)
  };
  modules['./data/character-class-escape-sets.js'] = {
    REGULAR: exports.REGULAR,
    UNICODE: exports.UNICODE,
    UNICODE_IGNORE_CASE: exports.UNICODE_IGNORE_CASE
  };
  var generate = require('regjsgen').generate;
  var parse = require('regjsparser').parse;
  var regenerate = require('regenerate');
  var iuMappings = require('./data/iu-mappings.json');
  var ESCAPE_SETS = require('./data/character-class-escape-sets.js');
  function getCharacterClassEscapeSet(character) {
    if (unicode) {
      if (ignoreCase) {
        return ESCAPE_SETS.UNICODE_IGNORE_CASE[character];
      }
      return ESCAPE_SETS.UNICODE[character];
    }
    return ESCAPE_SETS.REGULAR[character];
  }
  var object = {};
  var hasOwnProperty = object.hasOwnProperty;
  function has(object, property) {
    return hasOwnProperty.call(object, property);
  }
  var UNICODE_SET = regenerate().addRange(0x0, 0x10FFFF);
  var BMP_SET = regenerate().addRange(0x0, 0xFFFF);
  var DOT_SET_UNICODE = UNICODE_SET.clone().remove(0x000A, 0x000D, 0x2028, 0x2029);
  var DOT_SET = DOT_SET_UNICODE.clone().intersection(BMP_SET);
  regenerate.prototype.iuAddRange = function(min, max) {
    var $this = this;
    do {
      var folded = caseFold(min);
      if (folded) {
        $this.add(folded);
      }
    } while (++min <= max);
    return $this;
  };
  function assign(target, source) {
    for (var key in source) {
      target[key] = source[key];
    }
  }
  function update(item, pattern) {
    var tree = parse(pattern, '');
    switch (tree.type) {
      case 'characterClass':
      case 'group':
      case 'value':
        break;
      default:
        tree = wrap(tree, pattern);
    }
    assign(item, tree);
  }
  function wrap(tree, pattern) {
    return {
      'type': 'group',
      'behavior': 'ignore',
      'body': [tree],
      'raw': '(?:' + pattern + ')'
    };
  }
  function caseFold(codePoint) {
    return has(iuMappings, codePoint) ? iuMappings[codePoint] : false;
  }
  var ignoreCase = false;
  var unicode = false;
  function processCharacterClass(characterClassItem) {
    var set = regenerate();
    var body = characterClassItem.body.forEach(function(item) {
      switch (item.type) {
        case 'value':
          set.add(item.codePoint);
          if (ignoreCase && unicode) {
            var folded = caseFold(item.codePoint);
            if (folded) {
              set.add(folded);
            }
          }
          break;
        case 'characterClassRange':
          var min = item.min.codePoint;
          var max = item.max.codePoint;
          set.addRange(min, max);
          if (ignoreCase && unicode) {
            set.iuAddRange(min, max);
          }
          break;
        case 'characterClassEscape':
          set.add(getCharacterClassEscapeSet(item.value));
          break;
        default:
          throw Error('Unknown term type: ' + item.type);
      }
    });
    if (characterClassItem.negative) {
      set = (unicode ? UNICODE_SET : BMP_SET).clone().remove(set);
    }
    update(characterClassItem, set.toString());
    return characterClassItem;
  }
  function processTerm(item) {
    switch (item.type) {
      case 'dot':
        update(item, (unicode ? DOT_SET_UNICODE : DOT_SET).toString());
        break;
      case 'characterClass':
        item = processCharacterClass(item);
        break;
      case 'characterClassEscape':
        update(item, getCharacterClassEscapeSet(item.value).toString());
        break;
      case 'alternative':
      case 'disjunction':
      case 'group':
      case 'quantifier':
        item.body = item.body.map(processTerm);
        break;
      case 'value':
        var codePoint = item.codePoint;
        var set = regenerate(codePoint);
        if (ignoreCase && unicode) {
          var folded = caseFold(codePoint);
          if (folded) {
            set.add(folded);
          }
        }
        update(item, set.toString());
        break;
      case 'anchor':
      case 'empty':
      case 'group':
      case 'reference':
        break;
      default:
        throw Error('Unknown term type: ' + item.type);
    }
    return item;
  }
  ;
  module.exports = function(pattern, flags) {
    var tree = parse(pattern, flags);
    ignoreCase = flags ? flags.indexOf('i') > -1 : false;
    unicode = flags ? flags.indexOf('u') > -1 : false;
    assign(tree, processTerm(tree));
    return generate(tree);
  };
  var regexpuRewritePattern = module.exports;
  return {get regexpuRewritePattern() {
      return regexpuRewritePattern;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/RegularExpressionTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/RegularExpressionTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/RegularExpressionTransformer.js")).ParseTreeTransformer;
  var LiteralExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/RegularExpressionTransformer.js")).LiteralExpression;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/LiteralToken.js", "traceur@0.0.112/src/codegeneration/RegularExpressionTransformer.js")).LiteralToken;
  var REGULAR_EXPRESSION = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/RegularExpressionTransformer.js")).REGULAR_EXPRESSION;
  var regexpuRewritePattern = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../outputgeneration/regexpuRewritePattern.js", "traceur@0.0.112/src/codegeneration/RegularExpressionTransformer.js")).regexpuRewritePattern;
  var RegularExpressionTransformer = function($__super) {
    function RegularExpressionTransformer() {
      $traceurRuntime.superConstructor(RegularExpressionTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(RegularExpressionTransformer, {transformLiteralExpression: function(tree) {
        var token = tree.literalToken;
        if (token.type === REGULAR_EXPRESSION) {
          var value = token.value;
          var lastIndex = value.lastIndexOf('/');
          var pattern = value.slice(1, lastIndex);
          var flags = value.slice(lastIndex + 1);
          if (flags.indexOf('u') !== -1) {
            var result = '/' + regexpuRewritePattern(pattern, flags) + '/' + flags.replace('u', '');
            return new LiteralExpression(tree.location, new LiteralToken(REGULAR_EXPRESSION, result, token.location));
          }
        }
        return tree;
      }}, {}, $__super);
  }(ParseTreeTransformer);
  return {get RegularExpressionTransformer() {
      return RegularExpressionTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/RestParameterTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/RestParameterTransformer.js";
  var FormalParameterList = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/RestParameterTransformer.js")).FormalParameterList;
  var ParameterTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParameterTransformer.js", "traceur@0.0.112/src/codegeneration/RestParameterTransformer.js")).ParameterTransformer;
  var createIdentifierToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/RestParameterTransformer.js")).createIdentifierToken;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/RestParameterTransformer.js")).parseStatement;
  function hasRestParameter(parameterList) {
    var parameters = parameterList.parameters;
    return parameters.length > 0 && parameters[parameters.length - 1].isRestParameter();
  }
  function getRestParameterLiteralToken(parameterList) {
    var parameters = parameterList.parameters;
    return parameters[parameters.length - 1].parameter.identifier.identifierToken;
  }
  var RestParameterTransformer = function($__super) {
    function RestParameterTransformer() {
      $traceurRuntime.superConstructor(RestParameterTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(RestParameterTransformer, {transformFormalParameterList: function(tree) {
        var transformed = $traceurRuntime.superGet(this, RestParameterTransformer.prototype, "transformFormalParameterList").call(this, tree);
        if (hasRestParameter(transformed)) {
          var parametersWithoutRestParam = new FormalParameterList(transformed.location, transformed.parameters.slice(0, -1));
          var startIndex = transformed.parameters.length - 1;
          var i = createIdentifierToken(this.getTempIdentifier());
          var name = getRestParameterLiteralToken(transformed);
          var loop;
          if (startIndex) {
            loop = parseStatement($traceurRuntime.getTemplateObject(["\n            for (var ", " = [], ", " = ", ";\n                 ", " < arguments.length; ", "++)\n              ", "[", " - ", "] = arguments[", "];"]), name, i, startIndex, i, i, name, i, startIndex, i);
          } else {
            loop = parseStatement($traceurRuntime.getTemplateObject(["\n            for (var ", " = [], ", " = 0;\n                 ", " < arguments.length; ", "++)\n              ", "[", "] = arguments[", "];"]), name, i, i, i, name, i, i);
          }
          this.parameterStatements.push(loop);
          return parametersWithoutRestParam;
        }
        return transformed;
      }}, {}, $__super);
  }(ParameterTransformer);
  return {get RestParameterTransformer() {
      return RestParameterTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/SpreadTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/SpreadTransformer.js";
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/PredefinedName.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")),
      APPLY = $__3.APPLY,
      BIND = $__3.BIND,
      FUNCTION = $__3.FUNCTION,
      PROTOTYPE = $__3.PROTOTYPE;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")),
      MEMBER_EXPRESSION = $__4.MEMBER_EXPRESSION,
      MEMBER_LOOKUP_EXPRESSION = $__4.MEMBER_LOOKUP_EXPRESSION,
      SPREAD_EXPRESSION = $__4.SPREAD_EXPRESSION;
  var Script = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")).Script;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")).TempVarTransformer;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")).default;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")),
      createArgumentList = $__8.createArgumentList,
      createArrayLiteral = $__8.createArrayLiteral,
      createAssignmentExpression = $__8.createAssignmentExpression,
      createCallExpression = $__8.createCallExpression,
      createEmptyArgumentList = $__8.createEmptyArgumentList,
      createIdentifierExpression = $__8.createIdentifierExpression,
      createMemberExpression = $__8.createMemberExpression,
      createMemberLookupExpression = $__8.createMemberLookupExpression,
      createNewExpression = $__8.createNewExpression,
      createNullLiteral = $__8.createNullLiteral,
      createParenExpression = $__8.createParenExpression,
      createVoid0 = $__8.createVoid0;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")),
      parseExpression = $__9.parseExpression,
      parseStatement = $__9.parseStatement;
  var prependStatements = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PrependStatements.js", "traceur@0.0.112/src/codegeneration/SpreadTransformer.js")).prependStatements;
  function hasSpreadMember(trees) {
    return trees.some(function(tree) {
      return tree && tree.type === SPREAD_EXPRESSION;
    });
  }
  var SpreadTransformer = function($__super) {
    function SpreadTransformer() {
      $traceurRuntime.superConstructor(SpreadTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(SpreadTransformer, {
      createArrayFromElements_: function(elements) {
        var length = elements.length;
        var args = [];
        var lastArray;
        for (var i = 0; i < length; i++) {
          if (elements[i] && elements[i].type === SPREAD_EXPRESSION) {
            if (lastArray) {
              args.push(createArrayLiteral(lastArray));
              lastArray = null;
            }
            args.push(this.transformAny(elements[i].expression));
          } else {
            if (!lastArray)
              lastArray = [];
            lastArray.push(this.transformAny(elements[i]));
          }
        }
        if (lastArray)
          args.push(createArrayLiteral(lastArray));
        var spread = this.getRuntimeExpression('spread');
        return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), spread, createArgumentList(args));
      },
      desugarCallSpread_: function(tree) {
        var operand = this.transformAny(tree.operand);
        var functionObject,
            contextObject;
        this.pushTempScope();
        if (operand.type === MEMBER_EXPRESSION) {
          var tempIdent = createIdentifierExpression(this.addTempVar());
          var parenExpression = createParenExpression(createAssignmentExpression(tempIdent, operand.operand));
          var memberName = operand.memberName;
          contextObject = tempIdent;
          functionObject = createMemberExpression(parenExpression, memberName);
        } else if (tree.operand.type === MEMBER_LOOKUP_EXPRESSION) {
          var tempIdent$__1 = createIdentifierExpression(this.addTempVar());
          var parenExpression$__2 = createParenExpression(createAssignmentExpression(tempIdent$__1, operand.operand));
          var memberExpression = this.transformAny(operand.memberExpression);
          contextObject = tempIdent$__1;
          functionObject = createMemberLookupExpression(parenExpression$__2, memberExpression);
        } else {
          contextObject = createVoid0();
          functionObject = operand;
        }
        this.popTempScope();
        var arrayExpression = this.createArrayFromElements_(tree.args.args);
        return createCallExpression(createMemberExpression(functionObject, APPLY), createArgumentList([contextObject, arrayExpression]));
      },
      desugarNewSpread_: function(tree) {
        var arrayExpression = $traceurRuntime.spread([createNullLiteral()], tree.args.args);
        arrayExpression = this.createArrayFromElements_(arrayExpression);
        return createNewExpression(createParenExpression(createCallExpression(createMemberExpression(FUNCTION, PROTOTYPE, BIND, APPLY), createArgumentList([this.transformAny(tree.operand), arrayExpression]))), createEmptyArgumentList());
      },
      transformArrayLiteral: function(tree) {
        if (hasSpreadMember(tree.elements)) {
          return this.createArrayFromElements_(tree.elements);
        }
        return $traceurRuntime.superGet(this, SpreadTransformer.prototype, "transformArrayLiteral").call(this, tree);
      },
      transformCallExpression: function(tree) {
        if (hasSpreadMember(tree.args.args)) {
          return this.desugarCallSpread_(tree);
        }
        return $traceurRuntime.superGet(this, SpreadTransformer.prototype, "transformCallExpression").call(this, tree);
      },
      transformNewExpression: function(tree) {
        if (tree.args !== null && hasSpreadMember(tree.args.args)) {
          return this.desugarNewSpread_(tree);
        }
        return $traceurRuntime.superGet(this, SpreadTransformer.prototype, "transformNewExpression").call(this, tree);
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  return {get SpreadTransformer() {
      return SpreadTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/SuperTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/SuperTransformer.js";
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")).default;
  var TempVarTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TempVarTransformer.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")).TempVarTransformer;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")),
      ArgumentList = $__7.ArgumentList,
      ClassDeclaration = $__7.ClassDeclaration,
      ClassExpression = $__7.ClassExpression,
      GetAccessor = $__7.GetAccessor,
      MemberExpression = $__7.MemberExpression,
      Method = $__7.Method,
      SetAccessor = $__7.SetAccessor;
  var $__8 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")),
      MEMBER_EXPRESSION = $__8.MEMBER_EXPRESSION,
      MEMBER_LOOKUP_EXPRESSION = $__8.MEMBER_LOOKUP_EXPRESSION,
      SUPER_EXPRESSION = $__8.SUPER_EXPRESSION;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")),
      EQUAL = $__9.EQUAL,
      MINUS_MINUS = $__9.MINUS_MINUS,
      PLUS_PLUS = $__9.PLUS_PLUS;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")),
      createAssignmentExpression = $__10.createAssignmentExpression,
      createBindingIdentifier = $__10.createBindingIdentifier,
      createIdentifierExpression = $__10.createIdentifierExpression,
      createIdentifierToken = $__10.createIdentifierToken,
      createParenExpression = $__10.createParenExpression,
      createStringLiteral = $__10.createStringLiteral,
      createThisExpression = $__10.createThisExpression;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")).parseExpression;
  var ExplodeExpressionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ExplodeExpressionTransformer.js", "traceur@0.0.112/src/codegeneration/SuperTransformer.js")).ExplodeExpressionTransformer;
  function hasSuperMemberExpression(tree) {
    return (tree.type === MEMBER_EXPRESSION || tree.type === MEMBER_LOOKUP_EXPRESSION) && tree.operand.type === SUPER_EXPRESSION;
  }
  var State = function() {
    function State(transformer, home) {
      this.transformer = transformer;
      this.home_ = home;
      this.tempName = home ? null : transformer.getTempIdentifier();
      this.hasSuper = false;
    }
    return ($traceurRuntime.createClass)(State, {get home() {
        this.hasSuper = true;
        if (this.home_ === null) {
          this.home_ = createIdentifierExpression(createIdentifierToken(this.tempName));
        }
        return this.home_;
      }}, {});
  }();
  var ClassState = function($__super) {
    function ClassState(transformer, tree) {
      var home = null;
      if (tree.name !== null) {
        home = createIdentifierExpression(tree.name.identifierToken);
      }
      $traceurRuntime.superConstructor(ClassState).call(this, transformer, home);
      this.name_ = tree.name;
    }
    return ($traceurRuntime.createClass)(ClassState, {get name() {
        if (this.name_ !== null)
          return this.name_;
        if (this.hasSuper) {
          return createBindingIdentifier(this.home.identifierToken);
        }
        return null;
      }}, {}, $__super);
  }(State);
  var PrototypeState = function($__super) {
    function PrototypeState(transformer, classState) {
      $traceurRuntime.superConstructor(PrototypeState).call(this, transformer, null);
      this.classState = classState;
    }
    return ($traceurRuntime.createClass)(PrototypeState, {get home() {
        var ident = this.classState.home;
        return new MemberExpression(null, ident, createIdentifierToken('prototype'));
      }}, {}, $__super);
  }(State);
  var SuperTransformer = function($__super) {
    function SuperTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(SuperTransformer).call(this, identifierGenerator, reporter, options);
      this.stateStack_ = [];
    }
    return ($traceurRuntime.createClass)(SuperTransformer, {
      pushState: function(state) {
        this.stateStack_.push(state);
      },
      popState: function() {
        return this.stateStack_.pop();
      },
      peekState: function() {
        return this.stateStack_[this.stateStack_.length - 1];
      },
      transformObjectLiteral: function(tree) {
        var state = new State(this, null);
        this.pushState(state);
        this.pushState(state);
        var result = $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformObjectLiteral").call(this, tree);
        this.popState();
        this.popState();
        if (state.hasSuper) {
          this.registerTempVarName(state.tempName);
          return createAssignmentExpression(state.home, result);
        }
        this.releaseTempName(state.tempName);
        return result;
      },
      transformClassExpression: function(tree) {
        var superClass = this.transformAny(tree.superClass);
        var annotations = this.transformList(tree.annotations);
        var classState = new ClassState(this, tree);
        var prototypeState = new PrototypeState(this, classState);
        this.pushState(classState);
        this.pushState(prototypeState);
        var elements = this.transformList(tree.elements);
        this.popState();
        this.popState();
        if (tree.name === null && tree.superClass !== null) {
          classState.home;
        } else if (tree.superClass === superClass && tree.elements === elements && tree.annotations === annotations) {
          return tree;
        }
        return new ClassExpression(tree.location, classState.name, superClass, elements, tree.annotations, tree.typeParameters);
      },
      transformClassDeclaration: function(tree) {
        var superClass = this.transformAny(tree.superClass);
        var annotations = this.transformList(tree.annotations);
        var classState = new ClassState(this, tree);
        var prototypeState = new PrototypeState(this, classState);
        this.pushState(classState);
        this.pushState(prototypeState);
        var elements = this.transformList(tree.elements);
        this.popState();
        this.popState();
        if (tree.superClass === superClass && tree.elements === elements && tree.annotations === annotations) {
          return tree;
        }
        return new ClassDeclaration(tree.location, tree.name, superClass, elements, tree.annotations, tree.typeParameters);
      },
      transformMethod: function(tree) {
        var name = this.transformAny(tree.name);
        var prototypeState;
        if (tree.isStatic) {
          prototypeState = this.popState();
        }
        var parameterList = this.transformAny(tree.parameterList);
        var body = this.transformAny(tree.body);
        if (tree.isStatic) {
          this.pushState(prototypeState);
        }
        if (tree.name === name && tree.parameterList === parameterList && tree.body === body) {
          return tree;
        }
        return new Method(tree.location, tree.isStatic, tree.functionKind, name, parameterList, tree.typeAnnotation, tree.annotations, body, tree.debugName);
      },
      transformGetAccessor: function(tree) {
        var name = this.transformAny(tree.name);
        var prototypeState;
        if (tree.isStatic) {
          prototypeState = this.popState();
        }
        var body = this.transformAny(tree.body);
        if (tree.isStatic) {
          this.pushState(prototypeState);
        }
        if (tree.name === name && tree.body === body) {
          return tree;
        }
        return new GetAccessor(tree.location, tree.isStatic, name, tree.typeAnnotation, tree.annotations, body);
      },
      transformSetAccessor: function(tree) {
        var name = this.transformAny(tree.name);
        var prototypeState;
        if (tree.isStatic) {
          prototypeState = this.popState();
        }
        var parameterList = this.transformAny(tree.parameterList);
        var body = this.transformAny(tree.body);
        if (tree.isStatic) {
          this.pushState(prototypeState);
        }
        if (tree.name === name && tree.parameterList === parameterList && tree.body === body) {
          return tree;
        }
        return new SetAccessor(tree.location, tree.isStatic, name, parameterList, tree.annotations, body);
      },
      transformComputedPropertyName: function(tree) {
        var s1 = this.popState();
        var s2 = this.popState();
        var result = $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformComputedPropertyName").call(this, tree);
        this.pushState(s2);
        this.pushState(s1);
        return result;
      },
      transformSuperExpression: function(tree) {
        throw new Error('unreachable');
      },
      transformMemberShared_: function(name) {
        var home = this.peekState().home;
        var superGet = this.getRuntimeExpression('superGet');
        return parseExpression($traceurRuntime.getTemplateObject(["", "(this, ", ", ", ")"]), superGet, home, name);
      },
      transformMemberExpression: function(tree) {
        if (tree.operand.type === SUPER_EXPRESSION) {
          return this.transformMemberShared_(tree.memberName.value);
        }
        return $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformMemberExpression").call(this, tree);
      },
      transformMemberLookupExpression: function(tree) {
        if (tree.operand.type === SUPER_EXPRESSION)
          return this.transformMemberShared_(tree.memberExpression);
        return $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformMemberLookupExpression").call(this, tree);
      },
      transformCallExpression: function(tree) {
        var operand,
            args;
        if (tree.operand.type === SUPER_EXPRESSION) {
          args = this.transformAny(tree.args);
          args = new ArgumentList(tree.location, $traceurRuntime.spread([createThisExpression()], args.args));
          var home = this.stateStack_[this.stateStack_.length - 2].home;
          var superConstructor = this.getRuntimeExpression('superConstructor');
          operand = parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), superConstructor, home);
        } else if (hasSuperMemberExpression(tree.operand)) {
          operand = this.transformAny(tree.operand);
          args = this.transformAny(tree.args);
          args = new ArgumentList(args.location, $traceurRuntime.spread([createThisExpression()], args.args));
        } else {
          return $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformCallExpression").call(this, tree);
        }
        return parseExpression($traceurRuntime.getTemplateObject(["", ".call(", ")"]), operand, args);
      },
      transformBinaryExpression: function(tree) {
        if (tree.operator.isAssignmentOperator() && hasSuperMemberExpression(tree.left)) {
          if (tree.operator.type !== EQUAL) {
            var exploded = new ExplodeExpressionTransformer(this).transformAny(tree);
            return this.transformAny(createParenExpression(exploded));
          }
          var name = tree.left.type === MEMBER_LOOKUP_EXPRESSION ? tree.left.memberExpression : createStringLiteral(tree.left.memberName.value);
          var right = this.transformAny(tree.right);
          var home = this.peekState().home;
          var superSet = this.getRuntimeExpression('superSet');
          return parseExpression($traceurRuntime.getTemplateObject(["", "(this, ", ", ", ", ", ")"]), superSet, home, name, right);
        }
        return $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformBinaryExpression").call(this, tree);
      },
      transformUnaryExpression: function(tree) {
        var transformed = this.transformIncrementDecrement_(tree);
        if (transformed)
          return transformed;
        return $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformUnaryExpression").call(this, tree);
      },
      transformPostfixExpression: function(tree) {
        var transformed = this.transformIncrementDecrement_(tree);
        if (transformed)
          return transformed;
        return $traceurRuntime.superGet(this, SuperTransformer.prototype, "transformPostfixExpression").call(this, tree);
      },
      transformIncrementDecrement_: function(tree) {
        var operator = tree.operator;
        var operand = tree.operand;
        if ((operator.type === PLUS_PLUS || operator.type === MINUS_MINUS) && hasSuperMemberExpression(operand)) {
          var exploded = new ExplodeExpressionTransformer(this).transformAny(tree);
          if (exploded !== tree)
            exploded = createParenExpression(exploded);
          return this.transformAny(exploded);
        }
        return null;
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(TempVarTransformer));
  return {get SuperTransformer() {
      return SuperTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/SymbolTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/SymbolTransformer.js";
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/SymbolTransformer.js")),
      BinaryExpression = $__3.BinaryExpression,
      UnaryExpression = $__3.UnaryExpression;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/SymbolTransformer.js")),
      IDENTIFIER_EXPRESSION = $__4.IDENTIFIER_EXPRESSION,
      LITERAL_EXPRESSION = $__4.LITERAL_EXPRESSION,
      UNARY_EXPRESSION = $__4.UNARY_EXPRESSION;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/SymbolTransformer.js")).ParseTreeTransformer;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/SymbolTransformer.js")).default;
  var $__7 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/SymbolTransformer.js")),
      EQUAL_EQUAL = $__7.EQUAL_EQUAL,
      EQUAL_EQUAL_EQUAL = $__7.EQUAL_EQUAL_EQUAL,
      NOT_EQUAL = $__7.NOT_EQUAL,
      NOT_EQUAL_EQUAL = $__7.NOT_EQUAL_EQUAL,
      TYPEOF = $__7.TYPEOF;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/SymbolTransformer.js")).parseExpression;
  function isEqualityExpression(tree) {
    switch (tree.operator.type) {
      case EQUAL_EQUAL:
      case EQUAL_EQUAL_EQUAL:
      case NOT_EQUAL:
      case NOT_EQUAL_EQUAL:
        return true;
    }
    return false;
  }
  function isTypeof(tree) {
    return tree.type === UNARY_EXPRESSION && tree.operator.type === TYPEOF;
  }
  function isSafeTypeofString(tree) {
    if (tree.type !== LITERAL_EXPRESSION)
      return false;
    var value = tree.literalToken.processedValue;
    switch (value) {
      case 'symbol':
      case 'object':
        return false;
    }
    return true;
  }
  var SymbolTransformer = function($__super) {
    function SymbolTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(SymbolTransformer).call(this);
      this.identifierGenerator = identifierGenerator;
      this.reporter = reporter;
      this.options = options;
    }
    return ($traceurRuntime.createClass)(SymbolTransformer, {
      transformTypeofOperand_: function(tree) {
        var operand = this.transformAny(tree.operand);
        return new UnaryExpression(tree.location, tree.operator, operand);
      },
      transformBinaryExpression: function(tree) {
        if (isEqualityExpression(tree)) {
          if (isTypeof(tree.left) && isSafeTypeofString(tree.right)) {
            var left = this.transformTypeofOperand_(tree.left);
            var right = tree.right;
            return new BinaryExpression(tree.location, left, tree.operator, right);
          }
          if (isTypeof(tree.right) && isSafeTypeofString(tree.left)) {
            var left$__1 = tree.left;
            var right$__2 = this.transformTypeofOperand_(tree.right);
            return new BinaryExpression(tree.location, left$__1, tree.operator, right$__2);
          }
        }
        return $traceurRuntime.superGet(this, SymbolTransformer.prototype, "transformBinaryExpression").call(this, tree);
      },
      transformUnaryExpression: function(tree) {
        if (tree.operator.type !== TYPEOF)
          return $traceurRuntime.superGet(this, SymbolTransformer.prototype, "transformUnaryExpression").call(this, tree);
        var operand = this.transformAny(tree.operand);
        var expression = this.getRuntimeTypeof(operand);
        if (operand.type === IDENTIFIER_EXPRESSION) {
          return parseExpression($traceurRuntime.getTemplateObject(["(typeof ", " === 'undefined' ?\n          'undefined' : ", ")"]), operand, expression);
        }
        return expression;
      },
      getRuntimeTypeof: function(operand) {
        var typeOf = this.getRuntimeExpression('typeof');
        return parseExpression($traceurRuntime.getTemplateObject(["", "(", ")"]), typeOf, operand);
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(ParseTreeTransformer));
  return {get SymbolTransformer() {
      return SymbolTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js";
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")),
      BINARY_EXPRESSION = $__3.BINARY_EXPRESSION,
      COMMA_EXPRESSION = $__3.COMMA_EXPRESSION,
      CONDITIONAL_EXPRESSION = $__3.CONDITIONAL_EXPRESSION,
      TEMPLATE_LITERAL_PORTION = $__3.TEMPLATE_LITERAL_PORTION,
      TEMPLATE_LITERAL_EXPRESSION = $__3.TEMPLATE_LITERAL_EXPRESSION;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")),
      LiteralExpression = $__4.LiteralExpression,
      NewExpression = $__4.NewExpression;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/LiteralToken.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")).LiteralToken;
  var ParenTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParenTrait.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")).ParenTrait;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")).ParseTreeTransformer;
  var ImportRuntimeTrait = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ImportRuntimeTrait.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")).default;
  var $__9 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")),
      PERCENT = $__9.PERCENT,
      PLUS = $__9.PLUS,
      SLASH = $__9.SLASH,
      STAR = $__9.STAR,
      STRING = $__9.STRING;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/TemplateLiteralTransformer.js")),
      createArgumentList = $__10.createArgumentList,
      createArrayLiteral = $__10.createArrayLiteral,
      createBinaryExpression = $__10.createBinaryExpression,
      createCallExpression = $__10.createCallExpression,
      createMemberExpression = $__10.createMemberExpression,
      createOperatorToken = $__10.createOperatorToken,
      createParenExpression = $__10.createParenExpression;
  function createStringLiteralExpression(loc, str) {
    return new LiteralExpression(loc, new LiteralToken(STRING, str, loc));
  }
  function createGetTemplateObject(elements, getTemplateObject) {
    var cooked = [];
    var raw = [];
    var same = true;
    for (var i = 0; i < elements.length; i += 2) {
      var loc = elements[i].location;
      var str = elements[i].value.value;
      var cookedStr = toCookedString(str);
      var rawStr = toRawString(str);
      var cookedLiteral$__1 = createStringLiteralExpression(loc, cookedStr);
      cooked.push(cookedLiteral$__1);
      if (cookedStr !== rawStr) {
        same = false;
        var rawLiteral = createStringLiteralExpression(loc, rawStr);
        raw.push(rawLiteral);
      } else {
        raw.push(cookedLiteral$__1);
      }
    }
    maybeAddEmptyStringAtEnd(elements, cooked);
    var cookedLiteral = createArrayLiteral(cooked);
    var args = [cookedLiteral];
    if (!same) {
      maybeAddEmptyStringAtEnd(elements, raw);
      var rawLiteral$__2 = createArrayLiteral(raw);
      args.unshift(rawLiteral$__2);
    }
    return createCallExpression(getTemplateObject, createArgumentList(args));
  }
  function maybeAddEmptyStringAtEnd(elements, items) {
    var length = elements.length;
    if (!length || elements[length - 1].type !== TEMPLATE_LITERAL_PORTION) {
      items.push(createStringLiteralExpression(null, '""'));
    }
  }
  function toRawString(str) {
    str = str.replace(/\r\n?/g, '\n');
    str = JSON.stringify(str);
    return str.replace(/\u2028|\u2029/g, function(c) {
      switch (c) {
        case '\u2028':
          return '\\u2028';
        case '\u2029':
          return '\\u2029';
        default:
          throw Error('Not reachable');
      }
    });
  }
  function toCookedString(s) {
    var sb = ['"'];
    var i = 0,
        k = 1,
        c,
        c2;
    while (i < s.length) {
      c = s[i++];
      switch (c) {
        case '\\':
          c2 = s[i++];
          switch (c2) {
            case '\n':
            case '\u2028':
            case '\u2029':
              break;
            case '\r':
              if (s[i + 1] === '\n') {
                i++;
              }
              break;
            default:
              sb[k++] = c;
              sb[k++] = c2;
          }
          break;
        case '"':
          sb[k++] = '\\"';
          break;
        case '\n':
          sb[k++] = '\\n';
          break;
        case '\r':
          if (s[i] === '\n')
            i++;
          sb[k++] = '\\n';
          break;
        case '\t':
          sb[k++] = '\\t';
          break;
        case '\f':
          sb[k++] = '\\f';
          break;
        case '\b':
          sb[k++] = '\\b';
          break;
        case '\u2028':
          sb[k++] = '\\u2028';
          break;
        case '\u2029':
          sb[k++] = '\\u2029';
          break;
        default:
          sb[k++] = c;
      }
    }
    sb[k++] = '"';
    return sb.join('');
  }
  var TemplateLiteralTransformer = function($__super) {
    function TemplateLiteralTransformer(identifierGenerator, reporter, options) {
      $traceurRuntime.superConstructor(TemplateLiteralTransformer).call(this);
      this.options = options;
    }
    return ($traceurRuntime.createClass)(TemplateLiteralTransformer, {
      transformTemplateLiteralExpression: function(tree) {
        if (!tree.operand) {
          return this.createDefaultTemplateLiteral(tree);
        }
        var operand = this.transformAny(tree.operand);
        var elements = tree.elements;
        var getTemplateObject = this.getRuntimeExpression('getTemplateObject');
        var args = [createGetTemplateObject(tree.elements, getTemplateObject)];
        for (var i = 1; i < elements.length; i += 2) {
          args.push(this.transformAny(elements[i]));
        }
        return createCallExpression(operand, createArgumentList(args));
      },
      transformTemplateSubstitution: function(tree) {
        var transformedTree = this.transformAny(tree.expression);
        switch (transformedTree.type) {
          case BINARY_EXPRESSION:
            switch (transformedTree.operator.type) {
              case STAR:
              case PERCENT:
              case SLASH:
                return transformedTree;
            }
            return createParenExpression(transformedTree);
          case COMMA_EXPRESSION:
          case CONDITIONAL_EXPRESSION:
            return createParenExpression(transformedTree);
        }
        return transformedTree;
      },
      transformTemplateLiteralPortion: function(tree) {
        var str = toCookedString(tree.value.value);
        return createStringLiteralExpression(tree.location, str);
      },
      createDefaultTemplateLiteral: function(tree) {
        var elements = tree.elements;
        var length = elements.length;
        if (length === 0) {
          return createStringLiteralExpression(tree.location, '""');
        }
        var firstNonEmpty = elements[0].value.value === '';
        var binaryExpression = this.transformAny(elements[0]);
        if (length === 1)
          return binaryExpression;
        var plusToken = createOperatorToken(PLUS);
        for (var i = 1; i < length; i++) {
          var element = elements[i];
          if (element.type === TEMPLATE_LITERAL_PORTION) {
            if (element.value.value === '') {
              continue;
            }
            if (firstNonEmpty && i === 2) {
              binaryExpression = binaryExpression.right;
            }
          }
          var transformedTree = this.transformAny(elements[i]);
          binaryExpression = createBinaryExpression(binaryExpression, plusToken, transformedTree);
        }
        return new createParenExpression(binaryExpression);
      }
    }, {}, $__super);
  }(ImportRuntimeTrait(ParenTrait(ParseTreeTransformer)));
  return {get TemplateLiteralTransformer() {
      return TemplateLiteralTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/TypeToExpressionTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/TypeToExpressionTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/TypeToExpressionTransformer.js")).ParseTreeTransformer;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/TypeToExpressionTransformer.js")),
      ArgumentList = $__2.ArgumentList,
      IdentifierExpression = $__2.IdentifierExpression,
      MemberExpression = $__2.MemberExpression;
  var parseExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/TypeToExpressionTransformer.js")).parseExpression;
  var TypeToExpressionTransformer = function($__super) {
    function TypeToExpressionTransformer() {
      $traceurRuntime.superConstructor(TypeToExpressionTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(TypeToExpressionTransformer, {
      transformTypeName: function(tree) {
        if (tree.moduleName) {
          var operand = this.transformAny(tree.moduleName);
          return new MemberExpression(tree.location, operand, tree.name);
        }
        return new IdentifierExpression(tree.location, tree.name);
      },
      transformPredefinedType: function(tree) {
        return parseExpression($traceurRuntime.getTemplateObject(["$traceurRuntime.type.", ")"]), tree.typeToken);
      },
      transformTypeReference: function(tree) {
        var typeName = this.transformAny(tree.typeName);
        var args = this.transformAny(tree.args);
        var argumentList = new ArgumentList(tree.location, $traceurRuntime.spread([typeName], args));
        return parseExpression($traceurRuntime.getTemplateObject(["$traceurRuntime.genericType(", ")"]), argumentList);
      },
      transformTypeArguments: function(tree) {
        return this.transformList(tree.args);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get TypeToExpressionTransformer() {
      return TypeToExpressionTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/TypeTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/TypeTransformer.js";
  var $__1 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/TypeTransformer.js")),
      AnonBlock = $__1.AnonBlock,
      FormalParameter = $__1.FormalParameter,
      FunctionDeclaration = $__1.FunctionDeclaration,
      FunctionExpression = $__1.FunctionExpression,
      GetAccessor = $__1.GetAccessor,
      Method = $__1.Method,
      VariableDeclaration = $__1.VariableDeclaration;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/TypeTransformer.js")),
      IMPORT_TYPE_CLAUSE = $__2.IMPORT_TYPE_CLAUSE,
      TYPE_ALIAS_DECLARATION = $__2.TYPE_ALIAS_DECLARATION;
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/TypeTransformer.js")).ParseTreeTransformer;
  var TypeTransformer = function($__super) {
    function TypeTransformer() {
      $traceurRuntime.superConstructor(TypeTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(TypeTransformer, {
      transformVariableDeclaration: function(tree) {
        if (tree.typeAnnotation) {
          tree = new VariableDeclaration(tree.location, tree.lvalue, null, tree.initializer);
        }
        return $traceurRuntime.superGet(this, TypeTransformer.prototype, "transformVariableDeclaration").call(this, tree);
      },
      transformFormalParameter: function(tree) {
        if (tree.typeAnnotation !== null)
          return new FormalParameter(tree.location, tree.parameter, null, []);
        return tree;
      },
      transformFunctionDeclaration: function(tree) {
        if (tree.typeAnnotation) {
          tree = new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, null, tree.annotations, tree.body);
        }
        return $traceurRuntime.superGet(this, TypeTransformer.prototype, "transformFunctionDeclaration").call(this, tree);
      },
      transformFunctionExpression: function(tree) {
        if (tree.typeAnnotation) {
          tree = new FunctionExpression(tree.location, tree.name, tree.functionKind, tree.parameterList, null, tree.annotations, tree.body);
        }
        return $traceurRuntime.superGet(this, TypeTransformer.prototype, "transformFunctionExpression").call(this, tree);
      },
      transformMethod: function(tree) {
        if (tree.typeAnnotation) {
          tree = new Method(tree.location, tree.isStatic, tree.functionKind, tree.name, tree.parameterList, null, tree.annotations, tree.body, tree.debugName);
        }
        return $traceurRuntime.superGet(this, TypeTransformer.prototype, "transformMethod").call(this, tree);
      },
      transformGetAccessor: function(tree) {
        if (tree.typeAnnotation) {
          tree = new GetAccessor(tree.location, tree.isStatic, tree.name, null, tree.annotations, tree.body);
        }
        return $traceurRuntime.superGet(this, TypeTransformer.prototype, "transformGetAccessor").call(this, tree);
      },
      transformInterfaceDeclaration: function(tree) {
        return new AnonBlock(null, []);
      },
      transformExportDeclaration: function(tree) {
        if (tree.declaration.type === TYPE_ALIAS_DECLARATION) {
          return new AnonBlock(null, []);
        }
        return $traceurRuntime.superGet(this, TypeTransformer.prototype, "transformExportDeclaration").call(this, tree);
      },
      transformTypeAliasDeclaration: function(tree) {
        return new AnonBlock(null, []);
      },
      transformImportDeclaration: function(tree) {
        if (!tree.importClause || tree.importClause.type === IMPORT_TYPE_CLAUSE) {
          return new AnonBlock(null, []);
        }
        return $traceurRuntime.superGet(this, TypeTransformer.prototype, "transformImportDeclaration").call(this, tree);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  return {get TypeTransformer() {
      return TypeTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/UnicodeEscapeSequenceTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/UnicodeEscapeSequenceTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/UnicodeEscapeSequenceTransformer.js")).ParseTreeTransformer;
  var LiteralExpression = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/UnicodeEscapeSequenceTransformer.js")).LiteralExpression;
  var LiteralToken = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/LiteralToken.js", "traceur@0.0.112/src/codegeneration/UnicodeEscapeSequenceTransformer.js")).LiteralToken;
  var STRING = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/UnicodeEscapeSequenceTransformer.js")).STRING;
  var re = /(\\*)\\u{([0-9a-fA-F]+)}/g;
  function zeroPad(value) {
    return '0000'.slice(value.length) + value;
  }
  function needsTransform(token) {
    return token.type === STRING && re.test(token.value);
  }
  function transformToken(token) {
    return token.value.replace(re, function(match, backslashes, hexDigits) {
      var backslashIsEscaped = backslashes.length % 2 === 1;
      if (backslashIsEscaped) {
        return match;
      }
      var codePoint = parseInt(hexDigits, 16);
      var value;
      if (codePoint <= 0xFFFF) {
        value = '\\u' + zeroPad(codePoint.toString(16).toUpperCase());
      } else {
        var high = Math.floor((codePoint - 0x10000) / 0x400) + 0xD800;
        var low = (codePoint - 0x10000) % 0x400 + 0xDC00;
        value = '\\u' + high.toString(16).toUpperCase() + '\\u' + low.toString(16).toUpperCase();
      }
      return backslashes + value;
    });
  }
  var UnicodeEscapeSequenceTransformer = function($__super) {
    function UnicodeEscapeSequenceTransformer() {
      $traceurRuntime.superConstructor(UnicodeEscapeSequenceTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(UnicodeEscapeSequenceTransformer, {transformLiteralExpression: function(tree) {
        var token = tree.literalToken;
        if (needsTransform(token)) {
          var value = transformToken(token);
          return new LiteralExpression(tree.location, new LiteralToken(STRING, value, token.location));
        }
        return tree;
      }}, {}, $__super);
  }(ParseTreeTransformer);
  return {get UnicodeEscapeSequenceTransformer() {
      return UnicodeEscapeSequenceTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/UniqueIdentifierGenerator.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/UniqueIdentifierGenerator.js";
  var UniqueIdentifierGenerator = function() {
    function UniqueIdentifierGenerator() {
      this.identifierIndex = 0;
    }
    return ($traceurRuntime.createClass)(UniqueIdentifierGenerator, {generateUniqueIdentifier: function() {
        return ("$__" + this.identifierIndex++);
      }}, {});
  }();
  return {get UniqueIdentifierGenerator() {
      return UniqueIdentifierGenerator;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/ConstChecker.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/ConstChecker.js";
  var IDENTIFIER_EXPRESSION = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/semantics/ConstChecker.js")).IDENTIFIER_EXPRESSION;
  var $__3 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/semantics/ConstChecker.js")),
      CONST = $__3.CONST,
      MINUS_MINUS = $__3.MINUS_MINUS,
      PLUS_PLUS = $__3.PLUS_PLUS;
  var ScopeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeVisitor.js", "traceur@0.0.112/src/semantics/ConstChecker.js")).ScopeVisitor;
  var ScopeChainBuilder = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeChainBuilder.js", "traceur@0.0.112/src/semantics/ConstChecker.js")).ScopeChainBuilder;
  var ConstChecker = function($__super) {
    function ConstChecker(scopeBuilder, reporter) {
      $traceurRuntime.superConstructor(ConstChecker).call(this);
      this.scopeBuilder_ = scopeBuilder;
      this.reporter_ = reporter;
    }
    return ($traceurRuntime.createClass)(ConstChecker, {
      pushScope: function(tree) {
        return this.scope = this.scopeBuilder_.getScopeForTree(tree);
      },
      visitUnaryExpression: function(tree) {
        if (tree.operand.type === IDENTIFIER_EXPRESSION && (tree.operator.type === PLUS_PLUS || tree.operator.type === MINUS_MINUS)) {
          this.validateMutation_(tree.operand);
        }
        $traceurRuntime.superGet(this, ConstChecker.prototype, "visitUnaryExpression").call(this, tree);
      },
      visitPostfixExpression: function(tree) {
        if (tree.operand.type === IDENTIFIER_EXPRESSION) {
          this.validateMutation_(tree.operand);
        }
        $traceurRuntime.superGet(this, ConstChecker.prototype, "visitPostfixExpression").call(this, tree);
      },
      visitBinaryExpression: function(tree) {
        if (tree.left.type === IDENTIFIER_EXPRESSION && tree.operator.isAssignmentOperator()) {
          this.validateMutation_(tree.left);
        }
        $traceurRuntime.superGet(this, ConstChecker.prototype, "visitBinaryExpression").call(this, tree);
      },
      validateMutation_: function(identifierExpression) {
        if (this.inWithBlock) {
          return;
        }
        var binding = this.scope.getBinding(identifierExpression);
        if (binding === null) {
          return;
        }
        var $__1 = binding,
            type = $__1.type,
            tree = $__1.tree;
        if (type === CONST) {
          this.reportError_(identifierExpression.location, (tree.getStringValue() + " is read-only"));
        }
      },
      reportError_: function(location, message) {
        this.reporter_.reportError(location, message);
      }
    }, {}, $__super);
  }(ScopeVisitor);
  function validate(tree, reporter) {
    var builder = new ScopeChainBuilder(reporter);
    builder.visitAny(tree);
    var checker = new ConstChecker(builder, reporter);
    checker.visitAny(tree);
  }
  return {
    get ConstChecker() {
      return ConstChecker;
    },
    get validate() {
      return validate;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/semantics/FreeVariableChecker.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/semantics/FreeVariableChecker.js";
  var ScopeChainBuilderWithReferences = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ScopeChainBuilderWithReferences.js", "traceur@0.0.112/src/semantics/FreeVariableChecker.js")).ScopeChainBuilderWithReferences;
  var FreeVariableChecker = function($__super) {
    function FreeVariableChecker(reporter, global) {
      $traceurRuntime.superConstructor(FreeVariableChecker).call(this, reporter);
      this.global_ = global;
    }
    return ($traceurRuntime.createClass)(FreeVariableChecker, {referenceFound: function(tree, name) {
        if (this.scope.getBinding(tree))
          return;
        if (!(name in this.global_)) {
          this.reporter.reportError(tree.location, (name + " is not defined"));
        }
      }}, {}, $__super);
  }(ScopeChainBuilderWithReferences);
  function validate(tree, reporter) {
    var global = arguments[2] !== (void 0) ? arguments[2] : Reflect.global;
    var checker = new FreeVariableChecker(reporter, global);
    checker.visitAny(tree);
  }
  return {get validate() {
      return validate;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js";
  var AmdTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AmdTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).AmdTransformer;
  var AnnotationsTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AnnotationsTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).AnnotationsTransformer;
  var ArrayComprehensionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ArrayComprehensionTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ArrayComprehensionTransformer;
  var ArrowFunctionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ArrowFunctionTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ArrowFunctionTransformer;
  var AsyncGeneratorTransformPass = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AsyncGeneratorTransformPass.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).AsyncGeneratorTransformPass;
  var AsyncToGeneratorTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AsyncToGeneratorTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).AsyncToGeneratorTransformer;
  var BlockBindingTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./BlockBindingTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).BlockBindingTransformer;
  var ClassTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ClassTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ClassTransformer;
  var ClosureModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ClosureModuleTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ClosureModuleTransformer;
  var CommonJsModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./CommonJsModuleTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).CommonJsModuleTransformer;
  var DefaultParametersTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./DefaultParametersTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).DefaultParametersTransformer;
  var DestructuringTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./DestructuringTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).DestructuringTransformer;
  var ExponentiationTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ExponentiationTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ExponentiationTransformer;
  var ForOfTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ForOfTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ForOfTransformer;
  var ForOnTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ForOnTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ForOnTransformer;
  var GeneratorComprehensionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./GeneratorComprehensionTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).GeneratorComprehensionTransformer;
  var GeneratorTransformPass = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./GeneratorTransformPass.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).GeneratorTransformPass;
  var InlineModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./InlineModuleTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).InlineModuleTransformer;
  var InstantiateModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./InstantiateModuleTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).InstantiateModuleTransformer;
  var JsxTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./JsxTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).JsxTransformer;
  var MemberVariableTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./MemberVariableTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).MemberVariableTransformer;
  var ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ModuleTransformer;
  var MultiTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./MultiTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).MultiTransformer;
  var NumericLiteralTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./NumericLiteralTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).NumericLiteralTransformer;
  var ObjectLiteralTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ObjectLiteralTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ObjectLiteralTransformer;
  var ProperTailCallTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ProperTailCallTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).ProperTailCallTransformer;
  var PropertyNameShorthandTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PropertyNameShorthandTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).PropertyNameShorthandTransformer;
  var RegularExpressionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./RegularExpressionTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).RegularExpressionTransformer;
  var RestParameterTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./RestParameterTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).RestParameterTransformer;
  var SpreadPropertiesTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SpreadPropertiesTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).SpreadPropertiesTransformer;
  var SpreadTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SpreadTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).SpreadTransformer;
  var SuperTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SuperTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).SuperTransformer;
  var SymbolTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SymbolTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).SymbolTransformer;
  var TemplateLiteralTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TemplateLiteralTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).TemplateLiteralTransformer;
  var TypeToExpressionTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TypeToExpressionTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).TypeToExpressionTransformer;
  var TypeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TypeTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).TypeTransformer;
  var UnicodeEscapeSequenceTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./UnicodeEscapeSequenceTransformer.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).UnicodeEscapeSequenceTransformer;
  var UniqueIdentifierGenerator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./UniqueIdentifierGenerator.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).UniqueIdentifierGenerator;
  var validateConst = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/ConstChecker.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).validate;
  var validateFreeVariables = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/FreeVariableChecker.js", "traceur@0.0.112/src/codegeneration/FromOptionsTransformer.js")).validate;
  var FromOptionsTransformer = function($__super) {
    function FromOptionsTransformer(reporter, options) {
      var $__1;
      $traceurRuntime.superConstructor(FromOptionsTransformer).call(this, reporter, options.validate);
      var transformOptions = options.transformOptions;
      var idGenerator = new UniqueIdentifierGenerator();
      var append = ($__1 = this, function(transformer) {
        $__1.append(function(tree) {
          return new transformer(idGenerator, reporter, options).transformAny(tree);
        });
      });
      if (transformOptions.blockBinding) {
        this.append(function(tree) {
          validateConst(tree, reporter);
          return tree;
        });
      }
      if (options.freeVariableChecker) {
        this.append(function(tree) {
          validateFreeVariables(tree, reporter);
          return tree;
        });
      }
      if (transformOptions.exponentiation)
        append(ExponentiationTransformer);
      if (transformOptions.numericLiterals)
        append(NumericLiteralTransformer);
      if (transformOptions.unicodeExpressions)
        append(RegularExpressionTransformer);
      if (transformOptions.jsx) {
        append(JsxTransformer);
      }
      if (transformOptions.templateLiterals)
        append(TemplateLiteralTransformer);
      if (transformOptions.types && transformOptions.annotations) {
        append(TypeToExpressionTransformer);
      }
      if (transformOptions.unicodeEscapeSequences)
        append(UnicodeEscapeSequenceTransformer);
      if (transformOptions.annotations)
        append(AnnotationsTransformer);
      if (transformOptions.propertyNameShorthand)
        append(PropertyNameShorthandTransformer);
      if (transformOptions.memberVariables) {
        append(MemberVariableTransformer);
      }
      if (transformOptions.classes) {
        append(SuperTransformer);
      }
      if (transformOptions.arrowFunctions) {
        append(ArrowFunctionTransformer);
      }
      if (transformOptions.classes) {
        append(ClassTransformer);
      }
      if (transformOptions.spreadProperties) {
        append(SpreadPropertiesTransformer);
      }
      if (transformOptions.propertyMethods || transformOptions.computedPropertyNames || transformOptions.properTailCalls) {
        append(ObjectLiteralTransformer);
      }
      if (transformOptions.generatorComprehension)
        append(GeneratorComprehensionTransformer);
      if (transformOptions.arrayComprehension)
        append(ArrayComprehensionTransformer);
      if (transformOptions.forOf)
        append(ForOfTransformer);
      if (transformOptions.asyncGenerators) {
        append(AsyncGeneratorTransformPass);
      }
      if (transformOptions.forOn)
        append(ForOnTransformer);
      if (transformOptions.restParameters)
        append(RestParameterTransformer);
      if (transformOptions.defaultParameters)
        append(DefaultParametersTransformer);
      if (transformOptions.destructuring)
        append(DestructuringTransformer);
      if (transformOptions.types)
        append(TypeTransformer);
      if (transformOptions.spread)
        append(SpreadTransformer);
      if (transformOptions.blockBinding) {
        this.append(function(tree) {
          var transformer = new BlockBindingTransformer(idGenerator, reporter, tree);
          return transformer.transformAny(tree);
        });
      }
      if (transformOptions.asyncFunctions && options.generators === 'parse') {
        append(AsyncToGeneratorTransformer);
      } else if (transformOptions.generators || transformOptions.asyncFunctions) {
        append(GeneratorTransformPass);
      }
      if (transformOptions.symbols)
        append(SymbolTransformer);
      if (transformOptions.properTailCalls) {
        append(ProperTailCallTransformer);
      }
      if (transformOptions.modules) {
        switch (transformOptions.modules) {
          case 'commonjs':
            append(CommonJsModuleTransformer);
            break;
          case 'amd':
            append(AmdTransformer);
            break;
          case 'closure':
            append(ClosureModuleTransformer);
            break;
          case 'inline':
            append(InlineModuleTransformer);
            break;
          case 'instantiate':
            append(InstantiateModuleTransformer);
            break;
          case 'bootstrap':
            append(ModuleTransformer);
            break;
          case 'parse':
            break;
          default:
            throw new Error('Invalid modules transform option');
        }
      }
    }
    return ($traceurRuntime.createClass)(FromOptionsTransformer, {}, {}, $__super);
  }(MultiTransformer);
  return {get FromOptionsTransformer() {
      return FromOptionsTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js";
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/TokenType.js", "traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js")),
      CONST = $__2.CONST,
      LET = $__2.LET;
  var ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js")).ModuleTransformer;
  var $__4 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeFactory.js", "traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js")),
      createAssignmentStatement = $__4.createAssignmentStatement,
      createArgumentList = $__4.createArgumentList,
      createBindingIdentifier = $__4.createBindingIdentifier,
      createCallExpression = $__4.createCallExpression,
      createExpressionStatement = $__4.createExpressionStatement,
      createForInStatement = $__4.createForInStatement,
      createFunctionBody = $__4.createFunctionBody,
      createIfStatement = $__4.createIfStatement,
      createImmediatelyInvokedFunctionExpression = $__4.createImmediatelyInvokedFunctionExpression,
      createIdentifierExpression = $__4.createIdentifierExpression,
      createMemberLookupExpression = $__4.createMemberLookupExpression,
      createMemberExpression = $__4.createMemberExpression,
      createObjectLiteral = $__4.createObjectLiteral,
      createReturnStatement = $__4.createReturnStatement,
      createUseStrictDirective = $__4.createUseStrictDirective,
      createVariableDeclarationList = $__4.createVariableDeclarationList,
      createVariableStatement = $__4.createVariableStatement;
  var IMPORT_SPECIFIER_SET = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTreeType.js", "traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js")).IMPORT_SPECIFIER_SET;
  var AnonBlock = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js")).AnonBlock;
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/InlineES6ModuleTransformer.js")).parseStatement;
  var anonInlineModules = 0;
  var InlineES6ModuleTransformer = function($__super) {
    function InlineES6ModuleTransformer(identifierGenerator, reporter, options, metadata) {
      $traceurRuntime.superConstructor(InlineES6ModuleTransformer).call(this, identifierGenerator, reporter, options);
      this.metadata_ = metadata;
    }
    return ($traceurRuntime.createClass)(InlineES6ModuleTransformer, {
      moduleProlog: function() {
        return [createUseStrictDirective()];
      },
      wrapModule: function(statements) {
        var seed = this.moduleName || 'anon_' + ++anonInlineModules;
        var idName = this.getTempVarNameForModuleName(seed);
        if (this.isRootModule) {
          statements.pop();
          return statements;
        }
        var body = createFunctionBody(statements);
        var moduleExpression = createImmediatelyInvokedFunctionExpression(body);
        return [createVariableStatement(CONST, idName, moduleExpression)];
      },
      transformExportDeclaration: function(tree) {
        if (this.isRootModule)
          return tree;
        this.exportVisitor.visitAny(tree);
        return this.transformAny(tree.declaration);
      },
      transformImportDeclaration: function(tree) {
        if (!tree.importClause || (tree.importClause.type === IMPORT_SPECIFIER_SET && tree.importClause.specifiers.length === 0)) {
          return createExpressionStatement(this.transformAny(tree.moduleSpecifier));
        }
        var binding = this.transformAny(tree.importClause);
        var initializer = this.transformAny(tree.moduleSpecifier);
        return createVariableStatement(CONST, binding, initializer);
      },
      transformNamedExport: function(tree) {
        return new AnonBlock(null, []);
      },
      addExportStatement: function(statements) {
        var $__1 = this;
        var exportProperties = this.getExportProperties();
        var exportObject = createObjectLiteral(exportProperties);
        if (this.exportVisitor.starExports.length) {
          var starExports = this.exportVisitor.starExports;
          var starIdents = starExports.map(function(moduleSpecifier) {
            return createIdentifierExpression($__1.getTempVarNameForModuleSpecifier(moduleSpecifier));
          });
          if (exportProperties.length)
            starIdents.push(exportObject);
          var exports = this.getTempIdentifier();
          statements.push(createVariableStatement(LET, exports, createObjectLiteral("")));
          var key = this.getTempIdentifier();
          starIdents.forEach(function(starIdent) {
            statements.push(createForInStatement(createVariableDeclarationList(LET, key, null), starIdent, createIfStatement(createCallExpression(createMemberExpression(starIdent, 'hasOwnProperty'), createArgumentList([createIdentifierExpression(key)])), createAssignmentStatement(createMemberLookupExpression(createIdentifierExpression(exports), createIdentifierExpression(key)), createMemberLookupExpression(starIdent, createIdentifierExpression(key))))));
          });
          statements.push(createReturnStatement(createIdentifierExpression(exports)));
          return statements;
        }
        statements.push(parseStatement($traceurRuntime.getTemplateObject(["return ", ""]), exportObject));
        return statements;
      },
      transformModuleSpecifier: function(tree) {
        return createBindingIdentifier(this.getTempVarNameForModuleSpecifier(tree));
      },
      get isRootModule() {
        return this.moduleName === (this.metadata_ && this.metadata_.rootModule);
      }
    }, {}, $__super);
  }(ModuleTransformer);
  return {get InlineES6ModuleTransformer() {
      return InlineES6ModuleTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/PureES6Transformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/PureES6Transformer.js";
  var AnnotationsTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AnnotationsTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).AnnotationsTransformer;
  var AsyncToGeneratorTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./AsyncToGeneratorTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).AsyncToGeneratorTransformer;
  var InlineES6ModuleTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./InlineES6ModuleTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).InlineES6ModuleTransformer;
  var JsxTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./JsxTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).JsxTransformer;
  var MemberVariableTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./MemberVariableTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).MemberVariableTransformer;
  var MultiTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./MultiTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).MultiTransformer;
  var SpreadPropertiesTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./SpreadPropertiesTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).SpreadPropertiesTransformer;
  var TypeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TypeTransformer.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).TypeTransformer;
  var UniqueIdentifierGenerator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./UniqueIdentifierGenerator.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).UniqueIdentifierGenerator;
  var validateFreeVariables = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../semantics/FreeVariableChecker.js", "traceur@0.0.112/src/codegeneration/PureES6Transformer.js")).validate;
  var PureES6Transformer = function($__super) {
    function PureES6Transformer(reporter, options, metadata) {
      var $__1;
      $traceurRuntime.superConstructor(PureES6Transformer).call(this, reporter, options.validate);
      var idGenerator = new UniqueIdentifierGenerator();
      var append = ($__1 = this, function(transformer) {
        $__1.append(function(tree) {
          return new transformer(idGenerator, reporter, options, metadata).transformAny(tree);
        });
      });
      if (options.freeVariableChecker) {
        this.append(function(tree) {
          validateFreeVariables(tree, reporter);
          return tree;
        });
      }
      if (options.jsx) {
        append(JsxTransformer);
      }
      if (options.spreadProperties) {
        append(SpreadPropertiesTransformer);
      }
      if (options.memberVariables) {
        append(MemberVariableTransformer);
      }
      append(AnnotationsTransformer);
      append(TypeTransformer);
      append(AsyncToGeneratorTransformer);
      if (options.modules === 'inline') {
        append(InlineES6ModuleTransformer);
      }
    }
    return ($traceurRuntime.createClass)(PureES6Transformer, {}, {}, $__super);
  }(MultiTransformer);
  return {get PureES6Transformer() {
      return PureES6Transformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/Compiler.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/Compiler.js";
  var AttachModuleNameTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/module/AttachModuleNameTransformer.js", "traceur@0.0.112/src/Compiler.js")).AttachModuleNameTransformer;
  var FromOptionsTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/FromOptionsTransformer.js", "traceur@0.0.112/src/Compiler.js")).FromOptionsTransformer;
  var Parser = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./syntax/Parser.js", "traceur@0.0.112/src/Compiler.js")).Parser;
  var PureES6Transformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/PureES6Transformer.js", "traceur@0.0.112/src/Compiler.js")).PureES6Transformer;
  var SourceFile = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./syntax/SourceFile.js", "traceur@0.0.112/src/Compiler.js")).SourceFile;
  var CollectingErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util/CollectingErrorReporter.js", "traceur@0.0.112/src/Compiler.js")).CollectingErrorReporter;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Options.js", "traceur@0.0.112/src/Compiler.js")),
      Options = $__10.Options,
      versionLockedOptions = $__10.versionLockedOptions;
  var ParseTreeMapWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/ParseTreeMapWriter.js", "traceur@0.0.112/src/Compiler.js")).ParseTreeMapWriter;
  var ParseTreeWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/ParseTreeWriter.js", "traceur@0.0.112/src/Compiler.js")).ParseTreeWriter;
  var $__13 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/SourceMapIntegration.js", "traceur@0.0.112/src/Compiler.js")),
      SourceMapConsumer = $__13.SourceMapConsumer,
      SourceMapGenerator = $__13.SourceMapGenerator;
  function merge() {
    for (var srcs = [],
        $__2 = 0; $__2 < arguments.length; $__2++)
      srcs[$__2] = arguments[$__2];
    var dest = Object.create(null);
    srcs.forEach(function(src) {
      Object.keys(src).forEach(function(key) {
        dest[key] = src[key];
      });
      var srcModules = src.modules;
      if (typeof srcModules !== 'undefined') {
        dest.modules = srcModules;
      }
    });
    return dest;
  }
  function basePath(name) {
    if (!name)
      return null;
    var lastSlash = name.lastIndexOf('/');
    if (lastSlash < 0)
      return null;
    return name.substring(0, lastSlash + 1);
  }
  var Compiler = function() {
    function Compiler() {
      var overridingOptions = arguments[0] !== (void 0) ? arguments[0] : {};
      this.options_ = new Options(this.defaultOptions());
      this.options_.setFromObject(overridingOptions);
      this.sourceMapConfiguration_ = null;
      this.sourceMapInfo_ = null;
      this.sourceMapCache_ = null;
    }
    return ($traceurRuntime.createClass)(Compiler, {
      compile: function(content) {
        var sourceName = arguments[1] !== (void 0) ? arguments[1] : '<compileSource>';
        var outputName = arguments[2] !== (void 0) ? arguments[2] : '<compileOutput>';
        var sourceRoot = arguments[3];
        sourceName = this.normalize(sourceName);
        outputName = this.normalize(outputName);
        var tree = this.parse(content, sourceName);
        tree = this.transform(tree, sourceName);
        var sourceURL = sourceName !== outputName ? sourceName : undefined;
        if (sourceRoot === undefined)
          sourceRoot = this.options_.sourceRoot;
        return this.write(tree, outputName, sourceRoot, sourceURL);
      },
      throwIfErrors: function(errorReporter) {
        if (errorReporter.hadError())
          throw errorReporter.toError();
      },
      parse: function(content) {
        var sourceName = arguments[1] !== (void 0) ? arguments[1] : '<compiler-parse-input>';
        sourceName = this.normalize(sourceName);
        this.sourceMapCache_ = null;
        this.sourceMapConfiguration_ = null;
        var errorReporter = new CollectingErrorReporter();
        var sourceFile = new SourceFile(sourceName, content);
        var parser = new Parser(sourceFile, errorReporter, this.options_);
        var tree = this.options_.script ? parser.parseScript() : parser.parseModule();
        this.throwIfErrors(errorReporter);
        return tree;
      },
      transform: function(tree) {
        var candidateModuleName = arguments[1];
        var metadata = arguments[2];
        var transformer;
        if (candidateModuleName) {
          var transformer$__3 = new AttachModuleNameTransformer(candidateModuleName);
          tree = transformer$__3.transformAny(tree);
        }
        var errorReporter = new CollectingErrorReporter();
        if (this.options_.outputLanguage.toLowerCase() === 'es6') {
          transformer = new PureES6Transformer(errorReporter, this.options_, metadata);
        } else {
          transformer = new FromOptionsTransformer(errorReporter, this.options_);
        }
        var transformedTree = transformer.transform(tree);
        this.throwIfErrors(errorReporter);
        return transformedTree;
      },
      createSourceMapConfiguration_: function(outputName) {
        var sourceRoot = arguments[1];
        var sourceURL = arguments[2];
        if (this.options_.sourceMaps) {
          return {
            sourceMapGenerator: new SourceMapGenerator({
              file: outputName,
              sourceRoot: sourceRoot,
              skipValidation: true
            }),
            basepath: basePath(outputName),
            inputSourceMap: this.options_.inputSourceMap,
            sourceURL: sourceURL,
            outputName: outputName
          };
        }
      },
      getSourceMap: function() {
        if (this.sourceMapCache_) {
          return this.sourceMapCache_;
        }
        if (this.sourceMapConfiguration_) {
          var sourceMap = this.sourceMapConfiguration_.sourceMapGenerator.toString();
          var inputSourceMap = this.sourceMapConfiguration_.inputSourceMap;
          if (inputSourceMap) {
            var generator = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(sourceMap));
            generator.applySourceMap(new SourceMapConsumer(inputSourceMap));
            sourceMap = generator.toJSON();
          }
          this.sourceMapCache_ = sourceMap;
          return sourceMap;
        }
      },
      get sourceMapInfo() {
        if (!this.sourceMapInfo_ && this.sourceMapConfiguration_) {
          var sourceMap = this.getSourceMap();
          this.sourceMapInfo_ = {
            url: this.sourceMapConfiguration_.sourceURL,
            outputName: this.sourceMapConfiguration_.outputName,
            map: sourceMap
          };
        }
        return this.sourceMapInfo_;
      },
      write: function(tree) {
        var outputName = arguments[1];
        var sourceRoot = arguments[2];
        var sourceURL = arguments[3];
        outputName = this.normalize(outputName);
        if (sourceRoot === undefined)
          sourceRoot = this.options_.sourceRoot;
        if (sourceRoot === true)
          sourceRoot = basePath(outputName);
        else if (!sourceRoot)
          sourceRoot = undefined;
        else
          sourceRoot = this.normalize(sourceRoot);
        var writer;
        this.sourceMapCache_ = null;
        this.sourceMapConfiguration_ = this.createSourceMapConfiguration_(outputName, sourceRoot, sourceURL);
        if (this.sourceMapConfiguration_) {
          this.sourceMapConfiguration_.lowResolution = this.options_.lowResolutionSourceMap;
          writer = new ParseTreeMapWriter(this.sourceMapConfiguration_, this.options_);
        } else {
          writer = new ParseTreeWriter(this.options_);
        }
        writer.visitAny(tree);
        var compiledCode = writer.toString();
        var link = this.debuggerLink(sourceURL, outputName);
        if (link) {
          compiledCode += link;
        }
        return compiledCode;
      },
      debuggerLink: function(sourceURL, outputName) {
        if (this.sourceMapConfiguration_) {
          if (this.options_.sourceMaps === 'memory') {
            return;
          }
          var sourceMappingURL = this.sourceMappingURL(sourceURL || outputName || 'unnamed.js');
          return '//# sourceMappingURL=' + sourceMappingURL + '\n';
        } else {
          if (sourceURL) {
            return '//# sourceURL=' + sourceURL + '\n';
          }
        }
      },
      sourceName: function(filename) {
        return filename;
      },
      sourceMappingURL: function(path) {
        if (this.options_.sourceMaps === 'inline') {
          if (Reflect.global.btoa) {
            return 'data:application/json;base64,' + btoa(unescape(encodeURIComponent(this.getSourceMap())));
          }
        }
        path = path || 'unamed.js';
        path = path.split('/').pop();
        return path + '.map';
      },
      sourceNameFromTree: function(tree) {
        return tree.location.start.source.name;
      },
      defaultOptions: function() {
        return versionLockedOptions;
      },
      normalize: function(name) {
        return name && name.replace(/\\/g, '/');
      }
    }, {
      script: function(content) {
        var options = arguments[1] !== (void 0) ? arguments[1] : {};
        options = new Options(options);
        options.script = true;
        return new Compiler(options).compile(content);
      },
      module: function(content) {
        var options = arguments[1] !== (void 0) ? arguments[1] : {};
        options = new Options(options);
        options.modules = 'bootstrap';
        return new Compiler(options).compile(content);
      },
      amdOptions: function() {
        var options = arguments[0] !== (void 0) ? arguments[0] : {};
        var amdOptions = {
          modules: 'amd',
          sourceMaps: false,
          moduleName: false
        };
        return merge(amdOptions, options);
      },
      closureOptions: function() {
        var options = arguments[0] !== (void 0) ? arguments[0] : {};
        var closureOptions = {
          modules: 'closure',
          sourceMaps: false,
          moduleName: true
        };
        return merge(closureOptions, options);
      },
      commonJSOptions: function() {
        var options = arguments[0] !== (void 0) ? arguments[0] : {};
        var commonjsOptions = {
          modules: 'commonjs',
          sourceMaps: false,
          moduleName: false
        };
        return merge(commonjsOptions, options);
      }
    });
  }();
  return {get Compiler() {
      return Compiler;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/CloneTreeTransformer.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/CloneTreeTransformer.js";
  var ParseTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ParseTreeTransformer.js", "traceur@0.0.112/src/codegeneration/CloneTreeTransformer.js")).ParseTreeTransformer;
  var $__2 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/codegeneration/CloneTreeTransformer.js")),
      BindingIdentifier = $__2.BindingIdentifier,
      BreakStatement = $__2.BreakStatement,
      ContinueStatement = $__2.ContinueStatement,
      DebuggerStatement = $__2.DebuggerStatement,
      EmptyStatement = $__2.EmptyStatement,
      ExportSpecifier = $__2.ExportSpecifier,
      ExportStar = $__2.ExportStar,
      IdentifierExpression = $__2.IdentifierExpression,
      LiteralExpression = $__2.LiteralExpression,
      ModuleSpecifier = $__2.ModuleSpecifier,
      PredefinedType = $__2.PredefinedType,
      PropertyNameShorthand = $__2.PropertyNameShorthand,
      TemplateLiteralPortion = $__2.TemplateLiteralPortion,
      SuperExpression = $__2.SuperExpression,
      ThisExpression = $__2.ThisExpression;
  var CloneTreeTransformer = function($__super) {
    function CloneTreeTransformer() {
      $traceurRuntime.superConstructor(CloneTreeTransformer).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(CloneTreeTransformer, {
      transformBindingIdentifier: function(tree) {
        return new BindingIdentifier(tree.location, tree.identifierToken);
      },
      transformBreakStatement: function(tree) {
        return new BreakStatement(tree.location, tree.name);
      },
      transformContinueStatement: function(tree) {
        return new ContinueStatement(tree.location, tree.name);
      },
      transformDebuggerStatement: function(tree) {
        return new DebuggerStatement(tree.location);
      },
      transformEmptyStatement: function(tree) {
        return new EmptyStatement(tree.location);
      },
      transformExportSpecifier: function(tree) {
        return new ExportSpecifier(tree.location, tree.lhs, tree.rhs);
      },
      transformExportStar: function(tree) {
        return new ExportStar(tree.location);
      },
      transformIdentifierExpression: function(tree) {
        return new IdentifierExpression(tree.location, tree.identifierToken);
      },
      transformList: function(list) {
        if (!list) {
          return null;
        } else if (list.length === 0) {
          return [];
        } else {
          return $traceurRuntime.superGet(this, CloneTreeTransformer.prototype, "transformList").call(this, list);
        }
      },
      transformLiteralExpression: function(tree) {
        return new LiteralExpression(tree.location, tree.literalToken);
      },
      transformModuleSpecifier: function(tree) {
        return new ModuleSpecifier(tree.location, tree.token);
      },
      transformPredefinedType: function(tree) {
        return new PredefinedType(tree.location, tree.typeToken);
      },
      transformPropertyNameShorthand: function(tree) {
        return new PropertyNameShorthand(tree.location, tree.name);
      },
      transformTemplateLiteralPortion: function(tree) {
        return new TemplateLiteralPortion(tree.location, tree.value);
      },
      transformSuperExpression: function(tree) {
        return new SuperExpression(tree.location);
      },
      transformThisExpression: function(tree) {
        return new ThisExpression(tree.location);
      }
    }, {}, $__super);
  }(ParseTreeTransformer);
  CloneTreeTransformer.cloneTree = function(tree) {
    return new CloneTreeTransformer().transformAny(tree);
  };
  return {get CloneTreeTransformer() {
      return CloneTreeTransformer;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/createModuleEvaluationStatement.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/createModuleEvaluationStatement.js";
  var parseStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../PlaceholderParser.js", "traceur@0.0.112/src/codegeneration/module/createModuleEvaluationStatement.js")).parseStatement;
  function createModuleEvaluationStatement(normalizedName) {
    return parseStatement($traceurRuntime.getTemplateObject(["$traceurRuntime.getModule(", " +'')"]), normalizedName);
  }
  return {get createModuleEvaluationStatement() {
      return createModuleEvaluationStatement;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/compiler-imports.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/compiler-imports.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_Compiler_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Compiler.js", "traceur@0.0.112/src/compiler-imports.js"));
  var Parser = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./syntax/Parser.js", "traceur@0.0.112/src/compiler-imports.js")).Parser;
  var Script = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./syntax/trees/ParseTrees.js", "traceur@0.0.112/src/compiler-imports.js")).Script;
  var SourceFile = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./syntax/SourceFile.js", "traceur@0.0.112/src/compiler-imports.js")).SourceFile;
  var syntax = {
    Parser: Parser,
    SourceFile: SourceFile,
    trees: {Script: Script}
  };
  var ParseTreeMapWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/ParseTreeMapWriter.js", "traceur@0.0.112/src/compiler-imports.js")).ParseTreeMapWriter;
  var ParseTreeWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/ParseTreeWriter.js", "traceur@0.0.112/src/compiler-imports.js")).ParseTreeWriter;
  var regexpuRewritePattern = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/regexpuRewritePattern.js", "traceur@0.0.112/src/compiler-imports.js")).regexpuRewritePattern;
  var SourceMapConsumer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/SourceMapIntegration.js", "traceur@0.0.112/src/compiler-imports.js")).SourceMapConsumer;
  var SourceMapGenerator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/SourceMapIntegration.js", "traceur@0.0.112/src/compiler-imports.js")).SourceMapGenerator;
  var TreeWriter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./outputgeneration/TreeWriter.js", "traceur@0.0.112/src/compiler-imports.js")).TreeWriter;
  var outputgeneration = {
    ParseTreeMapWriter: ParseTreeMapWriter,
    ParseTreeWriter: ParseTreeWriter,
    regexpuRewritePattern: regexpuRewritePattern,
    SourceMapConsumer: SourceMapConsumer,
    SourceMapGenerator: SourceMapGenerator,
    TreeWriter: TreeWriter
  };
  var AttachModuleNameTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/module/AttachModuleNameTransformer.js", "traceur@0.0.112/src/compiler-imports.js")).AttachModuleNameTransformer;
  var CloneTreeTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/CloneTreeTransformer.js", "traceur@0.0.112/src/compiler-imports.js")).CloneTreeTransformer;
  var FromOptionsTransformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/FromOptionsTransformer.js", "traceur@0.0.112/src/compiler-imports.js")).FromOptionsTransformer;
  var PureES6Transformer = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/PureES6Transformer.js", "traceur@0.0.112/src/compiler-imports.js")).PureES6Transformer;
  var createModuleEvaluationStatement = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/module/createModuleEvaluationStatement.js", "traceur@0.0.112/src/compiler-imports.js")).createModuleEvaluationStatement;
  var $__16 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./codegeneration/PlaceholderParser.js", "traceur@0.0.112/src/compiler-imports.js")),
      parseExpression = $__16.parseExpression,
      parseModule = $__16.parseModule,
      parseScript = $__16.parseScript,
      parseStatement = $__16.parseStatement;
  var codegeneration = {
    CloneTreeTransformer: CloneTreeTransformer,
    FromOptionsTransformer: FromOptionsTransformer,
    PureES6Transformer: PureES6Transformer,
    parseExpression: parseExpression,
    parseModule: parseModule,
    parseScript: parseScript,
    parseStatement: parseStatement,
    module: {
      AttachModuleNameTransformer: AttachModuleNameTransformer,
      createModuleEvaluationStatement: createModuleEvaluationStatement
    }
  };
  return {
    get Compiler() {
      return $__traceur_64_0_46_0_46_112_47_src_47_Compiler_46_js__.Compiler;
    },
    get syntax() {
      return syntax;
    },
    get outputgeneration() {
      return outputgeneration;
    },
    get codegeneration() {
      return codegeneration;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/ValidationVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/ValidationVisitor.js";
  var ModuleVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ModuleVisitor.js", "traceur@0.0.112/src/codegeneration/module/ValidationVisitor.js")).ModuleVisitor;
  var ValidationVisitor = function($__super) {
    function ValidationVisitor() {
      $traceurRuntime.superConstructor(ValidationVisitor).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(ValidationVisitor, {
      checkExport_: function(tree, name) {
        var description = this.validatingModuleDescription_;
        if (description && !description.getExport(name)) {
          var moduleName = description.normalizedName;
          this.reportError(tree, ("'" + name + "' is not exported by '" + moduleName + "'"));
        }
      },
      checkImport_: function(tree, name) {
        var existingImport = this.moduleSymbol.getImport(name);
        if (existingImport) {
          this.reportError(tree, ("'" + name + "' was previously imported at " + existingImport.location.start));
        } else {
          this.moduleSymbol.addImport(name, tree);
        }
      },
      visitAndValidate_: function(moduleDescription, tree) {
        var validatingModuleDescription = this.validatingModuleDescription_;
        this.validatingModuleDescription_ = moduleDescription;
        this.visitAny(tree);
        this.validatingModuleDescription_ = validatingModuleDescription;
      },
      visitNamedExport: function(tree) {
        if (tree.moduleSpecifier) {
          var name = tree.moduleSpecifier.token.processedValue;
          var moduleDescription = this.getExportsListForModuleSpecifier(name);
          this.visitAndValidate_(moduleDescription, tree.exportClause);
        }
      },
      visitExportSpecifier: function(tree) {
        this.checkExport_(tree, tree.lhs.value);
      },
      visitForwardDefaultExport: function(tree) {
        this.checkExport_(tree, 'default');
      },
      visitImportDeclaration: function(tree) {
        var name = tree.moduleSpecifier.token.processedValue;
        var moduleDescription = this.getExportsListForModuleSpecifier(name);
        this.visitAndValidate_(moduleDescription, tree.importClause);
      },
      visitImportSpecifier: function(tree) {
        var importName = tree.binding.getStringValue();
        var exportName = tree.name ? tree.name.value : importName;
        this.checkImport_(tree, importName);
        this.checkExport_(tree, exportName);
      },
      visitImportedBinding: function(tree) {
        var importName = tree.binding.getStringValue();
        this.checkImport_(tree, importName);
        this.checkExport_(tree, 'default');
      },
      visitNameSpaceImport: function(tree) {
        var importName = tree.binding.binding.getStringValue();
        this.checkImport_(tree, importName);
      }
    }, {}, $__super);
  }(ModuleVisitor);
  return {get ValidationVisitor() {
      return ValidationVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/ExportListBuilder.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/ExportListBuilder.js";
  var ExportVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ExportVisitor.js", "traceur@0.0.112/src/codegeneration/module/ExportListBuilder.js")).ExportVisitor;
  var ValidationVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./ValidationVisitor.js", "traceur@0.0.112/src/codegeneration/module/ExportListBuilder.js")).ValidationVisitor;
  function buildExportList(deps, loader, reporter) {
    function doVisit(ctor) {
      for (var i = 0; i < deps.length; i++) {
        var visitor = new ctor(reporter, loader, deps[i]);
        visitor.visitAny(deps[i].tree);
      }
    }
    function reverseVisit(ctor) {
      for (var i = deps.length - 1; i >= 0; i--) {
        var visitor = new ctor(reporter, loader, deps[i]);
        visitor.visitAny(deps[i].tree);
      }
    }
    reverseVisit(ExportVisitor);
    doVisit(ValidationVisitor);
  }
  return {get buildExportList() {
      return buildExportList;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/codegeneration/module/ModuleSpecifierVisitor.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/codegeneration/module/ModuleSpecifierVisitor.js";
  var ParseTreeVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../syntax/ParseTreeVisitor.js", "traceur@0.0.112/src/codegeneration/module/ModuleSpecifierVisitor.js")).ParseTreeVisitor;
  var StringSet = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../../util/StringSet.js", "traceur@0.0.112/src/codegeneration/module/ModuleSpecifierVisitor.js")).StringSet;
  var ModuleSpecifierVisitor = function($__super) {
    function ModuleSpecifierVisitor(options) {
      $traceurRuntime.superConstructor(ModuleSpecifierVisitor).call(this);
      this.options_ = options;
      this.moduleSpecifiers_ = new StringSet();
    }
    return ($traceurRuntime.createClass)(ModuleSpecifierVisitor, {
      get moduleSpecifiers() {
        return this.moduleSpecifiers_.valuesAsArray();
      },
      visitModuleSpecifier: function(tree) {
        this.moduleSpecifiers_.add(tree.token.processedValue);
      }
    }, {}, $__super);
  }(ParseTreeVisitor);
  return {get ModuleSpecifierVisitor() {
      return ModuleSpecifierVisitor;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/system-map.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/system-map.js";
  function prefixMatchLength(name, prefix) {
    var prefixParts = prefix.split('/');
    var nameParts = name.split('/');
    if (prefixParts.length > nameParts.length)
      return 0;
    for (var i = 0; i < prefixParts.length; i++) {
      if (nameParts[i] != prefixParts[i])
        return 0;
    }
    return prefixParts.length;
  }
  function applyMap(map, name, parentName) {
    var curMatch,
        curMatchLength = 0;
    var curParent,
        curParentMatchLength = 0;
    if (parentName) {
      var mappedName;
      Object.getOwnPropertyNames(map).some(function(p) {
        var curMap = map[p];
        if (curMap && typeof curMap === 'object') {
          if (prefixMatchLength(parentName, p) <= curParentMatchLength)
            return;
          Object.getOwnPropertyNames(curMap).forEach(function(q) {
            if (prefixMatchLength(name, q) > curMatchLength) {
              curMatch = q;
              curMatchLength = q.split('/').length;
              curParent = p;
              curParentMatchLength = p.split('/').length;
            }
          });
        }
        if (curMatch) {
          var subPath = name.split('/').splice(curMatchLength).join('/');
          mappedName = map[curParent][curMatch] + (subPath ? '/' + subPath : '');
          return mappedName;
        }
      });
    }
    if (mappedName)
      return mappedName;
    Object.getOwnPropertyNames(map).forEach(function(p) {
      var curMap = map[p];
      if (curMap && typeof curMap === 'string') {
        if (prefixMatchLength(name, p) > curMatchLength) {
          curMatch = p;
          curMatchLength = p.split('/').length;
        }
      }
    });
    if (!curMatch)
      return name;
    var subPath = name.split('/').splice(curMatchLength).join('/');
    return map[curMatch] + (subPath ? '/' + subPath : '');
  }
  var systemjs = {applyMap: applyMap};
  return {get systemjs() {
      return systemjs;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/LoaderCompiler.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/LoaderCompiler.js";
  var buildExportList = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../codegeneration/module/ExportListBuilder.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).buildExportList;
  var CollectingErrorReporter = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/CollectingErrorReporter.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).CollectingErrorReporter;
  var Compiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../Compiler.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).Compiler;
  var ModuleSpecifierVisitor = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../codegeneration/module/ModuleSpecifierVisitor.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).ModuleSpecifierVisitor;
  var ModuleSymbol = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../codegeneration/module/ModuleSymbol.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).ModuleSymbol;
  var Parser = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/Parser.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).Parser;
  var SourceFile = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/SourceFile.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).SourceFile;
  var systemjs = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./system-map.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).systemjs;
  var UniqueIdentifierGenerator = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../codegeneration/UniqueIdentifierGenerator.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).UniqueIdentifierGenerator;
  var $__10 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/url.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")),
      isAbsolute = $__10.isAbsolute,
      resolveUrl = $__10.resolveUrl;
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/assert.js", "traceur@0.0.112/src/loader/LoaderCompiler.js")).assert;
  var NOT_STARTED = 0;
  var LOADING = 1;
  var LOADED = 2;
  var PARSED = 3;
  var TRANSFORMING = 4;
  var TRANSFORMED = 5;
  var COMPLETE = 6;
  var ERROR = 7;
  var identifierGenerator = new UniqueIdentifierGenerator();
  var anonymousSourcesSeen = 0;
  var LoaderCompiler = function() {
    function LoaderCompiler() {}
    return ($traceurRuntime.createClass)(LoaderCompiler, {
      getModuleSpecifiers: function(codeUnit) {
        this.parse(codeUnit);
        var moduleSpecifierVisitor = new ModuleSpecifierVisitor(codeUnit.metadata.traceurOptions);
        moduleSpecifierVisitor.visit(codeUnit.metadata.tree);
        return moduleSpecifierVisitor.moduleSpecifiers;
      },
      parse: function(codeUnit) {
        assert(!codeUnit.metadata.tree);
        var metadata = codeUnit.metadata;
        var options = metadata.traceurOptions;
        if (codeUnit.type === 'script')
          options.script = true;
        metadata.compiler = new Compiler(options);
        var sourceName = codeUnit.metadata.sourceName = codeUnit.address || codeUnit.normalizedName || '(unnamed)#' + String(++anonymousSourcesSeen);
        metadata.tree = metadata.compiler.parse(codeUnit.source, sourceName);
      },
      transform: function(codeUnit) {
        var metadata = codeUnit.metadata;
        metadata.transformedTree = metadata.compiler.transform(metadata.tree, codeUnit.normalizedName, metadata);
      },
      write: function(codeUnit) {
        var metadata = codeUnit.metadata;
        var outputName = metadata.outputName || metadata.sourceName || '<loaderOutput>';
        var sourceRoot = metadata.sourceRoot;
        var sourceURL = metadata.sourceName || codeUnit.normalizedName || codeUnit.address;
        metadata.transcoded = metadata.compiler.write(metadata.transformedTree, outputName, undefined, sourceURL);
      },
      evaluateCodeUnit: function(codeUnit) {
        var result = ('global', eval)(codeUnit.metadata.transcoded);
        codeUnit.metadata.transformedTree = null;
        return result;
      },
      analyzeDependencies: function(dependencies, loader) {
        var deps = [];
        for (var i = 0; i < dependencies.length; i++) {
          var codeUnit = dependencies[i];
          assert(codeUnit.state >= PARSED);
          if (codeUnit.state == PARSED) {
            var symbol = codeUnit.metadata.moduleSymbol = new ModuleSymbol(codeUnit.metadata.tree, codeUnit.normalizedName);
            deps.push(symbol);
          }
        }
        this.checkForErrors(function(reporter) {
          return buildExportList(deps, loader, reporter);
        });
      },
      checkForErrors: function(fncOfReporter) {
        var reporter = new CollectingErrorReporter();
        var result = fncOfReporter(reporter);
        if (reporter.hadError())
          throw reporter.toError();
        return result;
      }
    }, {});
  }();
  return {get LoaderCompiler() {
      return LoaderCompiler;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/InternalLoader.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/InternalLoader.js";
  var assert = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/assert.js", "traceur@0.0.112/src/loader/InternalLoader.js")).assert;
  var LoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./LoaderCompiler.js", "traceur@0.0.112/src/loader/InternalLoader.js")).LoaderCompiler;
  var ExportsList = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../codegeneration/module/ModuleSymbol.js", "traceur@0.0.112/src/loader/InternalLoader.js")).ExportsList;
  var $__13 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/url.js", "traceur@0.0.112/src/loader/InternalLoader.js")),
      isAbsolute = $__13.isAbsolute,
      resolveUrl = $__13.resolveUrl;
  var Options = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../Options.js", "traceur@0.0.112/src/loader/InternalLoader.js")).Options;
  var NOT_STARTED = 0;
  var LOADING = 1;
  var LOADED = 2;
  var PARSED = 3;
  var TRANSFORMING = 4;
  var TRANSFORMED = 5;
  var COMPLETE = 6;
  var ERROR = 7;
  function mapToValues(map) {
    var array = [];
    map.forEach(function(v) {
      array.push(v);
    });
    return array;
  }
  var LoaderError = function($__super) {
    function LoaderError(msg, tree) {
      $traceurRuntime.superConstructor(LoaderError).call(this);
      this.message = msg;
      this.tree = tree;
      this.name = 'LoaderError';
    }
    return ($traceurRuntime.createClass)(LoaderError, {}, {}, $__super);
  }(Error);
  var CodeUnit = function() {
    function CodeUnit(loaderCompiler, normalizedName, type, state, name, referrerName, address) {
      var $__8 = this;
      this.promise = new Promise(function(res, rej) {
        $__8.loaderCompiler = loaderCompiler;
        $__8.normalizedName = normalizedName;
        $__8.type = type;
        $__8.name_ = name;
        $__8.referrerName_ = referrerName;
        $__8.address = address;
        $__8.state_ = state || NOT_STARTED;
        $__8.error = null;
        $__8.result = null;
        $__8.metadata_ = {};
        $__8.dependencies = [];
        $__8.resolve = res;
        $__8.reject = rej;
      });
    }
    return ($traceurRuntime.createClass)(CodeUnit, {
      get state() {
        return this.state_;
      },
      set state(value) {
        if (value < this.state_) {
          throw new Error('Invalid state change');
        }
        this.state_ = value;
      },
      get metadata() {
        return this.metadata_;
      },
      set metadata(value) {
        assert(value);
        this.metadata_ = value;
      },
      nameTrace: function() {
        var trace = this.specifiedAs();
        if (isAbsolute(this.name_)) {
          return trace + 'An absolute name.\n';
        }
        if (this.referrerName_) {
          return trace + this.importedBy() + this.normalizesTo();
        }
        return trace + this.normalizesTo();
      },
      specifiedAs: function() {
        return ("Specified as " + this.name_ + ".\n");
      },
      importedBy: function() {
        return ("Imported by " + this.referrerName_ + ".\n");
      },
      normalizesTo: function() {
        return 'Normalizes to ' + this.normalizedName + '\n';
      }
    }, {});
  }();
  var PreCompiledCodeUnit = function($__super) {
    function PreCompiledCodeUnit(loaderCompiler, normalizedName, name, referrerName, address, module) {
      $traceurRuntime.superConstructor(PreCompiledCodeUnit).call(this, loaderCompiler, normalizedName, 'module', COMPLETE, name, referrerName, address);
      this.result = module;
      this.resolve(this.result);
    }
    return ($traceurRuntime.createClass)(PreCompiledCodeUnit, {}, {}, $__super);
  }(CodeUnit);
  var BundledCodeUnit = function($__super) {
    function BundledCodeUnit(loaderCompiler, normalizedName, name, referrerName, address, deps, execute, setModule) {
      $traceurRuntime.superConstructor(BundledCodeUnit).call(this, loaderCompiler, normalizedName, 'module', TRANSFORMED, name, referrerName, address);
      this.deps = deps;
      this.execute = execute;
    }
    return ($traceurRuntime.createClass)(BundledCodeUnit, {
      getModuleSpecifiers: function() {
        return this.deps;
      },
      evaluate: function() {
        var $__8 = this;
        var normalizedNames = this.deps.map(function(name) {
          return $__8.loader_.normalize(name);
        });
        var module = this.execute.apply(Reflect.global, normalizedNames);
        setModule(this.normalizedName, module);
        return module;
      }
    }, {}, $__super);
  }(CodeUnit);
  var HookedCodeUnit = function($__super) {
    function HookedCodeUnit() {
      $traceurRuntime.superConstructor(HookedCodeUnit).apply(this, arguments);
    }
    return ($traceurRuntime.createClass)(HookedCodeUnit, {
      getModuleSpecifiers: function() {
        return this.loaderCompiler.getModuleSpecifiers(this);
      },
      evaluate: function() {
        return this.loaderCompiler.evaluateCodeUnit(this);
      }
    }, {}, $__super);
  }(CodeUnit);
  var LoadCodeUnit = function($__super) {
    function LoadCodeUnit(loaderCompiler, normalizedName, name, referrerName, address) {
      $traceurRuntime.superConstructor(LoadCodeUnit).call(this, loaderCompiler, normalizedName, 'module', NOT_STARTED, name, referrerName, address);
    }
    return ($traceurRuntime.createClass)(LoadCodeUnit, {}, {}, $__super);
  }(HookedCodeUnit);
  var EvalCodeUnit = function($__super) {
    function EvalCodeUnit(loaderCompiler, code) {
      var type = arguments[2] !== (void 0) ? arguments[2] : 'script';
      var normalizedName = arguments[3];
      var referrerName = arguments[4];
      var address = arguments[5];
      $traceurRuntime.superConstructor(EvalCodeUnit).call(this, loaderCompiler, normalizedName, type, LOADED, null, referrerName, address);
      this.source = code;
    }
    return ($traceurRuntime.createClass)(EvalCodeUnit, {}, {}, $__super);
  }(HookedCodeUnit);
  var uniqueNameCount = 0;
  var InternalLoader = function() {
    function InternalLoader(loader, loaderCompiler) {
      assert(loaderCompiler);
      this.loader_ = loader;
      this.loaderCompiler = loaderCompiler;
      this.cache = new Map();
      this.urlToKey = Object.create(null);
      this.sync_ = false;
      this.sourceMapsByURL_ = Object.create(null);
      this.sourceMapsByOutputName_ = Object.create(null);
    }
    return ($traceurRuntime.createClass)(InternalLoader, {
      defaultMetadata_: function() {
        var metadata = arguments[0] !== (void 0) ? arguments[0] : {};
        var incoming = metadata.traceurOptions;
        if (incoming && !(incoming instanceof Options)) {
          var unknown = Options.listUnknownOptions(incoming);
          if (unknown.length) {
            console.warn('Unknown metadata.traceurOptions ignored: ' + unknown.join(','));
          }
        }
        metadata.traceurOptions = incoming || new Options();
        return metadata;
      },
      defaultModuleMetadata_: function() {
        var metadata = arguments[0] !== (void 0) ? arguments[0] : {};
        var metadata = this.defaultMetadata_(metadata);
        metadata.traceurOptions.script = false;
        return metadata;
      },
      getSourceMap: function(url) {
        return this.sourceMapsByURL_[url] || this.sourceMapsByOutputName_[url];
      },
      load: function(name) {
        var referrerName = arguments[1] !== (void 0) ? arguments[1] : this.loader_.baseURL;
        var address = arguments[2];
        var metadata = arguments[3] !== (void 0) ? arguments[3] : {};
        metadata = this.defaultMetadata_(metadata);
        var codeUnit = this.getOrCreateCodeUnit_(name, referrerName, address, metadata);
        this.load_(codeUnit);
        return codeUnit.promise.then(function() {
          return codeUnit;
        });
      },
      load_: function(codeUnit) {
        var $__8 = this;
        if (codeUnit.state === ERROR) {
          return codeUnit;
        }
        if (codeUnit.state === TRANSFORMED) {
          this.handleCodeUnitLoaded(codeUnit);
        } else {
          if (codeUnit.state !== NOT_STARTED)
            return codeUnit;
          codeUnit.state = LOADING;
          codeUnit.address = this.loader_.locate(codeUnit);
          this.loader_.fetch(codeUnit).then(function(text) {
            codeUnit.source = text;
            return codeUnit;
          }).then(function(load) {
            return $__8.loader_.translate(load);
          }).then(function(source) {
            codeUnit.source = source;
            codeUnit.state = LOADED;
            $__8.handleCodeUnitLoaded(codeUnit);
            return codeUnit;
          }).catch(function(err) {
            try {
              codeUnit.state = ERROR;
              codeUnit.error = err;
              $__8.handleCodeUnitLoadError(codeUnit);
            } catch (ex) {
              console.error('Internal Error ' + (ex.stack || ex));
            }
          });
        }
        return codeUnit;
      },
      module: function(code, referrerName, address, metadata) {
        var codeUnit = new EvalCodeUnit(this.loaderCompiler, code, 'module', null, referrerName, address);
        codeUnit.metadata = this.defaultMetadata_(metadata);
        this.cache.set({}, codeUnit);
        this.handleCodeUnitLoaded(codeUnit);
        return codeUnit.promise;
      },
      define: function(normalizedName, code, address, metadata) {
        var codeUnit = new EvalCodeUnit(this.loaderCompiler, code, 'module', normalizedName, null, address);
        var key = this.getKey(normalizedName, 'module');
        codeUnit.metadata = this.defaultMetadata_(metadata);
        this.cache.set(key, codeUnit);
        this.handleCodeUnitLoaded(codeUnit);
        return codeUnit.promise;
      },
      script: function(code, name, referrerName, address, metadata) {
        var normalizedName = this.loader_.normalize(name || '', referrerName, address);
        var codeUnit = new EvalCodeUnit(this.loaderCompiler, code, 'script', normalizedName, referrerName, address);
        var key = {};
        if (name)
          key = this.getKey(normalizedName, 'script');
        codeUnit.metadata = this.defaultMetadata_(metadata);
        this.cache.set(key, codeUnit);
        this.handleCodeUnitLoaded(codeUnit);
        return codeUnit.promise;
      },
      getKey: function(url, type) {
        var combined = type + ':' + url;
        if (combined in this.urlToKey) {
          return this.urlToKey[combined];
        }
        return this.urlToKey[combined] = {};
      },
      getCodeUnit_: function(normalizedName, type) {
        var key = this.getKey(normalizedName, type);
        var codeUnit = this.cache.get(key);
        return {
          key: key,
          codeUnit: codeUnit
        };
      },
      getOrCreateCodeUnit_: function(name, referrerName, address, metadata) {
        var normalizedName = this.loader_.normalize(name, referrerName, address);
        var type = 'module';
        if (metadata && metadata.traceurOptions && metadata.traceurOptions.script)
          type = 'script';
        var $__9 = this.getCodeUnit_(normalizedName, type),
            key = $__9.key,
            codeUnit = $__9.codeUnit;
        if (!codeUnit) {
          assert(metadata && metadata.traceurOptions);
          var module = this.loader_.get(normalizedName);
          if (module) {
            codeUnit = new PreCompiledCodeUnit(this.loaderCompiler, normalizedName, name, referrerName, address, module);
            codeUnit.type = 'module';
          } else {
            codeUnit = new LoadCodeUnit(this.loaderCompiler, normalizedName, name, referrerName, address);
            codeUnit.type = type;
          }
          codeUnit.metadata = {
            traceurOptions: metadata.traceurOptions,
            outputName: metadata.outputName,
            rootModule: metadata.rootModule
          };
          this.cache.set(key, codeUnit);
        }
        return codeUnit;
      },
      areAll: function(state) {
        return mapToValues(this.cache).every(function(codeUnit) {
          return codeUnit.state >= state;
        });
      },
      getCodeUnitForModuleSpecifier: function(name, referrerName) {
        var normalizedName = this.loader_.normalize(name, referrerName);
        return this.getCodeUnit_(normalizedName, 'module').codeUnit;
      },
      getExportsListForModuleSpecifier: function(name, referrer) {
        var codeUnit = this.getCodeUnitForModuleSpecifier(name, referrer);
        var exportsList = codeUnit.metadata.moduleSymbol;
        if (!exportsList) {
          if (codeUnit.result) {
            exportsList = new ExportsList(codeUnit.normalizedName);
            exportsList.addExportsFromModule(codeUnit.result);
          } else {
            throw new Error(("InternalError: " + name + " is not a module, required by " + referrer));
          }
        }
        return exportsList;
      },
      handleCodeUnitLoaded: function(codeUnit) {
        var $__8 = this;
        var referrerName = codeUnit.normalizedName;
        try {
          var moduleSpecifiers = codeUnit.getModuleSpecifiers();
          codeUnit.state = PARSED;
          if (!moduleSpecifiers) {
            this.abortAll(("No module specifiers in " + referrerName));
            return;
          }
          codeUnit.dependencies = moduleSpecifiers.map(function(name) {
            return $__8.getOrCreateCodeUnit_(name, referrerName, null, $__8.defaultModuleMetadata_(codeUnit.metadata));
          });
        } catch (error) {
          this.rejectOneAndAll(codeUnit, error);
          return;
        }
        codeUnit.dependencies.forEach(function(dependency) {
          $__8.load_(dependency);
        });
        if (this.areAll(PARSED)) {
          try {
            if (codeUnit.type === 'module')
              this.analyze();
            this.transform();
            this.evaluate();
          } catch (error) {
            this.rejectOneAndAll(codeUnit, error);
          }
        }
      },
      rejectOneAndAll: function(codeUnit, error) {
        codeUnit.state.ERROR;
        codeUnit.error = error;
        codeUnit.reject(error);
        this.abortAll(error);
      },
      handleCodeUnitLoadError: function(codeUnit) {
        var message = codeUnit.error ? String(codeUnit.error) + '\n' : ("Failed to load '" + codeUnit.address + "'.\n");
        message += codeUnit.nameTrace() + this.loader_.nameTrace(codeUnit);
        this.rejectOneAndAll(codeUnit, new Error(message));
      },
      abortAll: function(errorMessage) {
        this.cache.forEach(function(codeUnit) {
          if (codeUnit.state !== ERROR)
            codeUnit.reject(errorMessage);
        });
      },
      analyze: function() {
        this.loaderCompiler.analyzeDependencies(mapToValues(this.cache), this);
      },
      transform: function() {
        this.transformDependencies_(mapToValues(this.cache));
      },
      transformDependencies_: function(dependencies, dependentName) {
        for (var i = 0; i < dependencies.length; i++) {
          var codeUnit = dependencies[i];
          if (codeUnit.state >= TRANSFORMED) {
            continue;
          }
          if (codeUnit.state === TRANSFORMING) {
            var cir = codeUnit.normalizedName;
            var cle = dependentName;
            this.rejectOneAndAll(codeUnit, new Error(("Unsupported circular dependency between " + cir + " and " + cle)));
            return;
          }
          codeUnit.state = TRANSFORMING;
          try {
            this.transformCodeUnit_(codeUnit);
          } catch (error) {
            this.rejectOneAndAll(codeUnit, error);
            return;
          }
        }
      },
      transformCodeUnit_: function(codeUnit) {
        this.transformDependencies_(codeUnit.dependencies, codeUnit.normalizedName);
        if (codeUnit.state === ERROR)
          return;
        this.loaderCompiler.transform(codeUnit);
        codeUnit.state = TRANSFORMED;
        this.loaderCompiler.write(codeUnit);
        var info = codeUnit.metadata.compiler.sourceMapInfo;
        if (info) {
          this.sourceMapsByURL_[info.url] = info.map;
          this.sourceMapsByOutputName_[info.outputName] = info.map;
        }
        this.loader_.instantiate(codeUnit);
      },
      orderDependencies: function() {
        var visited = new Map();
        var ordered = [];
        function orderCodeUnits(codeUnit) {
          if (visited.has(codeUnit)) {
            return;
          }
          visited.set(codeUnit, true);
          codeUnit.dependencies.forEach(orderCodeUnits);
          ordered.push(codeUnit);
        }
        this.cache.forEach(orderCodeUnits);
        return ordered;
      },
      evaluate: function() {
        var dependencies = this.orderDependencies();
        for (var i = 0; i < dependencies.length; i++) {
          var codeUnit = dependencies[i];
          if (codeUnit.state >= COMPLETE) {
            continue;
          }
          var result = void 0;
          try {
            result = codeUnit.evaluate();
          } catch (ex) {
            this.rejectOneAndAll(codeUnit, ex);
            return;
          }
          codeUnit.result = result;
          codeUnit.source = null;
        }
        for (var i = 0; i < dependencies.length; i++) {
          var codeUnit = dependencies[i];
          if (codeUnit.state >= COMPLETE) {
            continue;
          }
          codeUnit.state = COMPLETE;
          codeUnit.resolve(codeUnit.result);
        }
      }
    }, {});
  }();
  var internals = {
    CodeUnit: CodeUnit,
    EvalCodeUnit: EvalCodeUnit,
    LoadCodeUnit: LoadCodeUnit,
    LoaderCompiler: LoaderCompiler
  };
  return {
    get InternalLoader() {
      return InternalLoader;
    },
    get internals() {
      return internals;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/Loader.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/Loader.js";
  var InternalLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./InternalLoader.js", "traceur@0.0.112/src/loader/Loader.js")).InternalLoader;
  function throwAbstractMethod() {
    throw new Error('Unimplemented Loader function, see extended class');
  }
  var Loader = function() {
    function Loader(loaderCompiler) {
      this.internalLoader_ = new InternalLoader(this, loaderCompiler);
      this.loaderCompiler_ = loaderCompiler;
    }
    return ($traceurRuntime.createClass)(Loader, {
      import: function(name) {
        var $__3 = arguments[1] !== (void 0) ? arguments[1] : {},
            referrerName = $__3.referrerName,
            address = $__3.address,
            metadata = $__3.metadata;
        var $__2 = this;
        return this.internalLoader_.load(name, referrerName, address, metadata).then(function(codeUnit) {
          return $__2.get(codeUnit.normalizedName);
        });
      },
      module: function(source) {
        var $__3 = arguments[1] !== (void 0) ? arguments[1] : {},
            referrerName = $__3.referrerName,
            address = $__3.address,
            metadata = $__3.metadata;
        return this.internalLoader_.module(source, referrerName, address, metadata);
      },
      define: function(normalizedName, source) {
        var $__3 = arguments[2] !== (void 0) ? arguments[2] : {},
            address = $__3.address,
            metadata = $__3.metadata;
        return this.internalLoader_.define(normalizedName, source, address, metadata);
      },
      get: function(normalizedName) {
        throwAbstractMethod();
      },
      set: function(normalizedName, module) {
        throwAbstractMethod();
      },
      normalize: function(name, referrerName, referrerAddress) {
        throwAbstractMethod();
      },
      locate: function(load) {
        throwAbstractMethod();
      },
      fetch: function(load) {
        throwAbstractMethod();
      },
      translate: function(load) {
        throwAbstractMethod();
      },
      instantiate: function(load) {
        throwAbstractMethod();
      }
    }, {});
  }();
  return {
    get throwAbstractMethod() {
      return throwAbstractMethod;
    },
    get Loader() {
      return Loader;
    },
    get LoaderCompiler() {
      return LoaderCompiler;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/version.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/version.js";
  var version = '0.0.112';
  return {get version() {
      return version;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/TraceurLoader.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/TraceurLoader.js";
  var $__5 = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../util/url.js", "traceur@0.0.112/src/loader/TraceurLoader.js")),
      isAbsolute = $__5.isAbsolute,
      resolveUrl = $__5.resolveUrl;
  var Loader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Loader.js", "traceur@0.0.112/src/loader/TraceurLoader.js")).Loader;
  var LoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./LoaderCompiler.js", "traceur@0.0.112/src/loader/TraceurLoader.js")).LoaderCompiler;
  var Options = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../Options.js", "traceur@0.0.112/src/loader/TraceurLoader.js")).Options;
  var systemjs = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./system-map.js", "traceur@0.0.112/src/loader/TraceurLoader.js")).systemjs;
  var webLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./webLoader.js", "traceur@0.0.112/src/loader/TraceurLoader.js")).webLoader;
  var version = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./version.js", "traceur@0.0.112/src/loader/TraceurLoader.js")).version;
  var WebPageTranscoder = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../WebPageTranscoder.js", "traceur@0.0.112/src/loader/TraceurLoader.js")).WebPageTranscoder;
  var uniqueNameCount = 0;
  var TraceurLoader = function($__super) {
    function TraceurLoader(fileLoader, baseURL) {
      var loaderCompiler = arguments[2] !== (void 0) ? arguments[2] : new LoaderCompiler();
      $traceurRuntime.superConstructor(TraceurLoader).call(this, loaderCompiler);
      this.fileLoader_ = fileLoader;
      this.baseURL_ = baseURL && String(baseURL);
      this.moduleStore_ = $traceurRuntime.ModuleStore;
    }
    return ($traceurRuntime.createClass)(TraceurLoader, {
      get baseURL() {
        return this.baseURL_;
      },
      set baseURL(value) {
        this.baseURL_ = String(value);
      },
      get: function(normalizedName) {
        return this.moduleStore_.get(normalizedName);
      },
      set: function(normalizedName, module) {
        this.moduleStore_.set(normalizedName, module);
      },
      normalize: function(name, referrerName, referrerAddress) {
        var normalizedName = this.moduleStore_.normalize(name, referrerName, referrerAddress);
        if (typeof systemjs !== 'undefined' && System.map)
          return systemjs.applyMap(System.map, normalizedName, referrerName);
        return normalizedName;
      },
      locate: function(load) {
        load.metadata.traceurOptions = load.metadata.traceurOptions || {};
        var url = load.normalizedName;
        var options = load.metadata.traceurOptions;
        var baseURL = load.metadata && load.metadata.baseURL;
        baseURL = baseURL || this.baseURL;
        var referrer = options && options.referrer;
        if (referrer) {
          var minChars = Math.min(referrer.length, baseURL.length);
          var commonChars = 0;
          for (var i = 0; i < minChars; i++) {
            var aChar = referrer[referrer.length - 1 - i];
            if (aChar === baseURL[baseURL.length - 1 - i])
              commonChars++;
            else
              break;
          }
          if (commonChars) {
            var packageName = referrer.slice(0, -commonChars);
            var rootDirectory = baseURL.slice(0, -commonChars);
            if (url.indexOf(packageName) === 0) {
              url = url.replace(packageName, rootDirectory);
            }
          }
        }
        if (!isAbsolute(url)) {
          if (baseURL) {
            load.metadata.baseURL = baseURL;
            url = resolveUrl(baseURL, url);
          }
        }
        return url;
      },
      sourceName: function(load) {
        var options = load.metadata.traceurOptions;
        var sourceName = load.address;
        if (options.sourceMaps) {
          var sourceRoot = this.baseURL;
          if (sourceName) {
            if (sourceRoot && sourceName.indexOf(sourceRoot) === 0) {
              sourceName = sourceName.substring(sourceRoot.length);
            }
          } else {
            sourceName = this.baseURL + String(uniqueNameCount++);
          }
        }
        return sourceName;
      },
      nameTrace: function(load) {
        var trace = '';
        if (load.metadata.locateMap) {
          trace += this.locateMapTrace(load);
        }
        var base = load.metadata.baseURL || this.baseURL;
        if (base) {
          trace += this.baseURLTrace(base);
        } else {
          trace += 'No baseURL\n';
        }
        return trace;
      },
      locateMapTrace: function(load) {
        var map = load.metadata.locateMap;
        return ("locate found \'" + map.pattern + "\' -> \'" + map.replacement + "\'\n");
      },
      baseURLTrace: function(base) {
        return 'locate resolved against base \'' + base + '\'\n';
      },
      fetch: function(load) {
        var $__2 = this;
        return new Promise(function(resolve, reject) {
          if (!load)
            reject(new TypeError('fetch requires argument object'));
          else if (!load.address || typeof load.address !== 'string')
            reject(new TypeError('fetch({address}) missing required string.'));
          else
            $__2.fileLoader_.load(load.address, resolve, reject);
        });
      },
      translate: function(load) {
        return load.source;
      },
      instantiate: function($__3) {
        var $__4 = $__3,
            name = $__4.name,
            metadata = $__4.metadata,
            address = $__4.address,
            source = $__4.source,
            sourceMap = $__4.sourceMap;
        return new Promise(function(resolve, reject) {
          resolve(undefined);
        });
      },
      bundledModule: function(name) {
        return this.moduleStore_.bundleStore[name];
      },
      importAll: function(names) {
        var $__3 = arguments[1] !== (void 0) ? arguments[1] : {},
            referrerName = $__3.referrerName,
            address = $__3.address,
            metadata = $__3.metadata;
        var $__2 = this;
        return Promise.all(names.map(function(name) {
          return $__2.import(name, {
            referrerName: referrerName,
            address: address,
            metadata: metadata
          });
        }));
      },
      loadAsScript: function(name) {
        var $__4;
        var $__3 = arguments[1] !== (void 0) ? arguments[1] : {},
            referrerName = $__3.referrerName,
            address = $__3.address,
            metadata = ($__4 = $__3.metadata) === void 0 ? {} : $__4;
        metadata.traceurOptions = metadata.traceurOptions || {};
        metadata.traceurOptions.script = true;
        return this.internalLoader_.load(name, referrerName, address, metadata).then(function(load) {
          return load.result;
        });
      },
      loadAsScriptAll: function(names) {
        var $__3 = arguments[1] !== (void 0) ? arguments[1] : {},
            referrerName = $__3.referrerName,
            address = $__3.address,
            metadata = $__3.metadata;
        var $__2 = this;
        return Promise.all(names.map(function(name) {
          return $__2.loadAsScript(name, {
            referrerName: referrerName,
            address: address,
            metadata: metadata
          });
        }));
      },
      script: function(source) {
        var $__3 = arguments[1] !== (void 0) ? arguments[1] : {},
            name = $__3.name,
            referrerName = $__3.referrerName,
            address = $__3.address,
            metadata = $__3.metadata;
        return this.internalLoader_.script(source, name, referrerName, address, metadata);
      },
      semVerRegExp_: function() {
        return /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+)?$/;
      },
      semverMap: function(normalizedName) {
        var slash = normalizedName.indexOf('/');
        if (slash < 0) {
          slash = normalizedName.length;
        }
        var versionPart = normalizedName.slice(0, slash);
        var at = versionPart.indexOf('@');
        if (at !== -1) {
          var semver = versionPart.slice(at + 1);
          var m = this.semVerRegExp_().exec(semver);
          if (m) {
            var major = m[1];
            var minor = m[2];
            var packageName = versionPart.slice(0, at);
            var map = Object.create(null);
            map[packageName] = versionPart;
            map[packageName + '@' + major] = versionPart;
            map[packageName + '@' + major + '.' + minor] = versionPart;
            return map;
          }
          throw new Error('semverMap found no matching semver regexp in ' + semver);
        }
        throw new Error('semverMap expected name@semver, got ' + versionPart + ' ' + normalizedName);
      },
      get version() {
        return version;
      },
      getSourceMap: function(filename) {
        return this.internalLoader_.getSourceMap(filename);
      },
      register: function(normalizedName, deps, factoryFunction) {
        $traceurRuntime.ModuleStore.register(normalizedName, deps, factoryFunction);
      },
      registerModule: function(normalizedName, deps, factoryFunction) {
        $traceurRuntime.ModuleStore.registerModule(normalizedName, deps, factoryFunction);
      },
      dirname: function(filename) {
        var lastSlash = filename.lastIndexOf('/');
        if (lastSlash === -1)
          return '.';
        if (lastSlash === 0)
          return '/';
        return filename.slice(0, lastSlash);
      }
    }, {}, $__super);
  }(Loader);
  var BrowserTraceurLoader = function($__super) {
    function BrowserTraceurLoader() {
      $traceurRuntime.superConstructor(BrowserTraceurLoader).call(this, webLoader, window.location.href, new LoaderCompiler());
    }
    return ($traceurRuntime.createClass)(BrowserTraceurLoader, {loadScriptTypeModule: function() {
        var traceurOptions = arguments[0] !== (void 0) ? arguments[0] : new Options();
        new traceur.WebPageTranscoder(document.location.href, traceurOptions).run();
      }}, {}, $__super);
  }(TraceurLoader);
  return {
    get TraceurLoader() {
      return TraceurLoader;
    },
    get BrowserTraceurLoader() {
      return BrowserTraceurLoader;
    }
  };
});
$traceurRuntime.registerModule("traceur@0.0.112/src/node/NodeLoaderCompiler.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/node/NodeLoaderCompiler.js";
  var LoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../loader/LoaderCompiler.js", "traceur@0.0.112/src/node/NodeLoaderCompiler.js")).LoaderCompiler;
  var NodeLoaderCompiler = function($__super) {
    function NodeLoaderCompiler() {
      $traceurRuntime.superConstructor(NodeLoaderCompiler).call(this);
      this.sourceMapsInMemory_ = false;
    }
    return ($traceurRuntime.createClass)(NodeLoaderCompiler, {
      evaluateCodeUnit: function(codeUnit) {
        var runInThisContext = require('vm').runInThisContext;
        var semver = require('semver');
        var content = codeUnit.metadata.transcoded;
        var filename = codeUnit.address || codeUnit.normalizedName;
        if (codeUnit.metadata.traceurOptions.sourceMaps === 'memory') {
          this.enableMemorySourceMaps_();
        }
        var options;
        if (semver.gte(process.version, '0.12.0')) {
          options = {filename: filename};
        } else {
          options = filename;
        }
        var result = runInThisContext(content, options);
        codeUnit.metadata.transformedTree = null;
        return result;
      },
      enableMemorySourceMaps_: function() {
        if (this.sourceMapsInMemory_) {
          return;
        }
        require('source-map-support').install({retrieveSourceMap: function(url) {
            try {
              var map = System.getSourceMap(url);
              if (map) {
                return {
                  url: url,
                  map: map
                };
              }
            } catch (ex) {
              console.error('retrieveSourceMap FAILED ', ex);
            }
          }});
        this.sourceMapsInMemory_ = true;
      }
    }, {}, $__super);
  }(LoaderCompiler);
  return {get NodeLoaderCompiler() {
      return NodeLoaderCompiler;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/InlineLoaderCompiler.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/InlineLoaderCompiler.js";
  var LoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./LoaderCompiler.js", "traceur@0.0.112/src/loader/InlineLoaderCompiler.js")).LoaderCompiler;
  var Script = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../syntax/trees/ParseTrees.js", "traceur@0.0.112/src/loader/InlineLoaderCompiler.js")).Script;
  var InlineLoaderCompiler = function($__super) {
    function InlineLoaderCompiler(elements) {
      $traceurRuntime.superConstructor(InlineLoaderCompiler).call(this);
      this.elements = elements;
    }
    return ($traceurRuntime.createClass)(InlineLoaderCompiler, {
      write: function() {},
      evaluateCodeUnit: function(codeUnit) {
        var $__1;
        var tree = codeUnit.metadata.transformedTree;
        ($__1 = this.elements).push.apply($__1, $traceurRuntime.spread(tree.scriptItemList));
      },
      toTree: function() {
        return new Script(null, this.elements, null);
      }
    }, {}, $__super);
  }(LoaderCompiler);
  return {get InlineLoaderCompiler() {
      return InlineLoaderCompiler;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/NodeTraceurLoader.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/NodeTraceurLoader.js";
  var TraceurLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TraceurLoader.js", "traceur@0.0.112/src/loader/NodeTraceurLoader.js")).TraceurLoader;
  var NodeLoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../node/NodeLoaderCompiler.js", "traceur@0.0.112/src/loader/NodeTraceurLoader.js")).NodeLoaderCompiler;
  var NodeTraceurLoader = function($__super) {
    function NodeTraceurLoader() {
      var path = require('path');
      var fileloader = require('../node/nodeLoader.js');
      var url = (path.resolve('./') + '/').replace(/\\/g, '/');
      $traceurRuntime.superConstructor(NodeTraceurLoader).call(this, fileloader, url, new NodeLoaderCompiler());
      this.traceurMap_ = null;
    }
    return ($traceurRuntime.createClass)(NodeTraceurLoader, {getSourceMap: function(filename) {
        var map = $traceurRuntime.superGet(this, NodeTraceurLoader.prototype, "getSourceMap").call(this, filename);
        if (!map && filename.replace(/\\/g, '/').endsWith('/bin/traceur.js')) {
          if (!this.traceurMap_) {
            var fs = require('fs');
            this.traceurMap_ = fs.readFileSync(filename + '.map', 'utf8');
          }
          map = this.traceurMap_;
        }
        return map;
      }}, {}, $__super);
  }(TraceurLoader);
  return {get NodeTraceurLoader() {
      return NodeTraceurLoader;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/loader/loader-imports.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/loader/loader-imports.js";
  var Loader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./Loader.js", "traceur@0.0.112/src/loader/loader-imports.js")).Loader;
  var LoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./LoaderCompiler.js", "traceur@0.0.112/src/loader/loader-imports.js")).LoaderCompiler;
  var BrowserTraceurLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TraceurLoader.js", "traceur@0.0.112/src/loader/loader-imports.js")).BrowserTraceurLoader;
  var NodeLoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../node/NodeLoaderCompiler.js", "traceur@0.0.112/src/loader/loader-imports.js")).NodeLoaderCompiler;
  var InlineLoaderCompiler = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./InlineLoaderCompiler.js", "traceur@0.0.112/src/loader/loader-imports.js")).InlineLoaderCompiler;
  var NodeTraceurLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./NodeTraceurLoader.js", "traceur@0.0.112/src/loader/loader-imports.js")).NodeTraceurLoader;
  var TraceurLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./TraceurLoader.js", "traceur@0.0.112/src/loader/loader-imports.js")).TraceurLoader;
  var loader = {
    BrowserTraceurLoader: BrowserTraceurLoader,
    InlineLoaderCompiler: InlineLoaderCompiler,
    Loader: Loader,
    LoaderCompiler: LoaderCompiler,
    NodeLoaderCompiler: NodeLoaderCompiler,
    NodeTraceurLoader: NodeTraceurLoader,
    TraceurLoader: TraceurLoader
  };
  return {get loader() {
      return loader;
    }};
});
$traceurRuntime.registerModule("traceur@0.0.112/src/traceur.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/traceur.js";
  var $__traceur_64_0_46_0_46_112_47_src_47_util_45_imports_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./util-imports.js", "traceur@0.0.112/src/traceur.js"));
  var $__traceur_64_0_46_0_46_112_47_src_47_compiler_45_imports_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./compiler-imports.js", "traceur@0.0.112/src/traceur.js"));
  var $__traceur_64_0_46_0_46_112_47_src_47_loader_47_loader_45_imports_46_js__ = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./loader/loader-imports.js", "traceur@0.0.112/src/traceur.js"));
  return $traceurRuntime.exportStar({}, $__traceur_64_0_46_0_46_112_47_src_47_util_45_imports_46_js__, $__traceur_64_0_46_0_46_112_47_src_47_compiler_45_imports_46_js__, $__traceur_64_0_46_0_46_112_47_src_47_loader_47_loader_45_imports_46_js__);
});
$traceurRuntime.registerModule("traceur@0.0.112/src/traceur-import.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/traceur-import.js";
  var traceur = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("./traceur.js", "traceur@0.0.112/src/traceur-import.js"));
  Reflect.global.traceur = traceur;
  $traceurRuntime.ModuleStore.set('traceur@', traceur);
  return {};
});
$traceurRuntime.getModule("traceur@0.0.112/src/traceur-import.js" + '');
$traceurRuntime.registerModule("traceur@0.0.112/src/browser/System.js", [], function() {
  "use strict";
  var __moduleName = "traceur@0.0.112/src/browser/System.js";
  var BrowserTraceurLoader = $traceurRuntime.getModule($traceurRuntime.normalizeModuleName("../loader/TraceurLoader.js", "traceur@0.0.112/src/browser/System.js")).BrowserTraceurLoader;
  var traceurLoader = new BrowserTraceurLoader();
  Reflect.global.System = traceurLoader;
  traceurLoader.map = traceurLoader.semverMap('traceur@' + traceurLoader.version);
  $traceurRuntime.normalizeModuleName = traceurLoader.normalize.bind(traceurLoader);
  return {get System() {
      return traceurLoader;
    }};
});
$traceurRuntime.getModule("traceur@0.0.112/src/browser/System.js" + '');
//# sourceMappingURL=BrowserSystem.js.map