(function(global) {

'use strict';
if (global.$traceurRuntime) {
  return;
}
var $Object = Object;
var $TypeError = TypeError;
var $create = $Object.create;
var $defineProperties = $Object.defineProperties;
var $defineProperty = $Object.defineProperty;
var $freeze = $Object.freeze;
var $getOwnPropertyDescriptor = $Object.getOwnPropertyDescriptor;
var $getOwnPropertyNames = $Object.getOwnPropertyNames;
var $keys = $Object.keys;
var $hasOwnProperty = $Object.prototype.hasOwnProperty;
var $toString = $Object.prototype.toString;
var $preventExtensions = Object.preventExtensions;
var $seal = Object.seal;
var $isExtensible = Object.isExtensible;
function nonEnum(value) {
  return {
    configurable: true,
    enumerable: false,
    value: value,
    writable: true
  };
}
var types = {
  void: function voidType() {},
  any: function any() {},
  string: function string() {},
  number: function number() {},
  boolean: function boolean() {}
};
var method = nonEnum;
var counter = 0;
function newUniqueString() {
  return '__$' + Math.floor(Math.random() * 1e9) + '$' + ++counter + '$__';
}
var symbolInternalProperty = newUniqueString();
var symbolDescriptionProperty = newUniqueString();
var symbolDataProperty = newUniqueString();
var symbolValues = $create(null);
var privateNames = $create(null);
function createPrivateName() {
  var s = newUniqueString();
  privateNames[s] = true;
  return s;
}
function isSymbol(symbol) {
  return typeof symbol === 'object' && symbol instanceof SymbolValue;
}
function typeOf(v) {
  if (isSymbol(v))
    return 'symbol';
  return typeof v;
}
function Symbol(description) {
  var value = new SymbolValue(description);
  if (!(this instanceof Symbol))
    return value;
  throw new TypeError('Symbol cannot be new\'ed');
}
$defineProperty(Symbol.prototype, 'constructor', nonEnum(Symbol));
$defineProperty(Symbol.prototype, 'toString', method(function() {
  var symbolValue = this[symbolDataProperty];
  if (!getOption('symbols'))
    return symbolValue[symbolInternalProperty];
  if (!symbolValue)
    throw TypeError('Conversion from symbol to string');
  var desc = symbolValue[symbolDescriptionProperty];
  if (desc === undefined)
    desc = '';
  return 'Symbol(' + desc + ')';
}));
$defineProperty(Symbol.prototype, 'valueOf', method(function() {
  var symbolValue = this[symbolDataProperty];
  if (!symbolValue)
    throw TypeError('Conversion from symbol to string');
  if (!getOption('symbols'))
    return symbolValue[symbolInternalProperty];
  return symbolValue;
}));
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(Symbol));
$defineProperty(SymbolValue.prototype, 'toString', {
  value: Symbol.prototype.toString,
  enumerable: false
});
$defineProperty(SymbolValue.prototype, 'valueOf', {
  value: Symbol.prototype.valueOf,
  enumerable: false
});
var hashProperty = createPrivateName();
var hashPropertyDescriptor = {value: undefined};
var hashObjectProperties = {
  hash: {value: undefined},
  self: {value: undefined}
};
var hashCounter = 0;
function getOwnHashObject(object) {
  var hashObject = object[hashProperty];
  if (hashObject && hashObject.self === object)
    return hashObject;
  if ($isExtensible(object)) {
    hashObjectProperties.hash.value = hashCounter++;
    hashObjectProperties.self.value = object;
    hashPropertyDescriptor.value = $create(null, hashObjectProperties);
    $defineProperty(object, hashProperty, hashPropertyDescriptor);
    return hashPropertyDescriptor.value;
  }
  return undefined;
}
function freeze(object) {
  getOwnHashObject(object);
  return $freeze.apply(this, arguments);
}
function preventExtensions(object) {
  getOwnHashObject(object);
  return $preventExtensions.apply(this, arguments);
}
function seal(object) {
  getOwnHashObject(object);
  return $seal.apply(this, arguments);
}
Symbol.iterator = Symbol();
freeze(SymbolValue.prototype);
function toProperty(name) {
  if (isSymbol(name))
    return name[symbolInternalProperty];
  return name;
}
function getOwnPropertyNames(object) {
  var rv = [];
  var names = $getOwnPropertyNames(object);
  for (var i = 0; i < names.length; i++) {
    var name = names[i];
    if (!symbolValues[name] && !privateNames[name])
      rv.push(name);
  }
  return rv;
}
function getOwnPropertyDescriptor(object, name) {
  return $getOwnPropertyDescriptor(object, toProperty(name));
}
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 hasOwnProperty(name) {
  return $hasOwnProperty.call(this, toProperty(name));
}
function getOption(name) {
  return global.traceur && global.traceur.options[name];
}
function setProperty(object, name, value) {
  var sym,
      desc;
  if (isSymbol(name)) {
    sym = name;
    name = name[symbolInternalProperty];
  }
  object[name] = value;
  if (sym && (desc = $getOwnPropertyDescriptor(object, name)))
    $defineProperty(object, name, {enumerable: false});
  return value;
}
function defineProperty(object, name, descriptor) {
  if (isSymbol(name)) {
    if (descriptor.enumerable) {
      descriptor = $create(descriptor, {enumerable: {value: false}});
    }
    name = name[symbolInternalProperty];
  }
  $defineProperty(object, name, descriptor);
  return object;
}
function polyfillObject(Object) {
  $defineProperty(Object, 'defineProperty', {value: defineProperty});
  $defineProperty(Object, 'getOwnPropertyNames', {value: getOwnPropertyNames});
  $defineProperty(Object, 'getOwnPropertyDescriptor', {value: getOwnPropertyDescriptor});
  $defineProperty(Object.prototype, 'hasOwnProperty', {value: hasOwnProperty});
  $defineProperty(Object, 'freeze', {value: freeze});
  $defineProperty(Object, 'preventExtensions', {value: preventExtensions});
  $defineProperty(Object, 'seal', {value: seal});
  Object.getOwnPropertySymbols = getOwnPropertySymbols;
}
function exportStar(object) {
  for (var i = 1; i < arguments.length; i++) {
    var names = $getOwnPropertyNames(arguments[i]);
    for (var j = 0; j < names.length; j++) {
      var name = names[j];
      if (privateNames[name])
        continue;
      (function(mod, name) {
        $defineProperty(object, name, {
          get: function() {
            return mod[name];
          },
          enumerable: true
        });
      })(arguments[i], names[j]);
    }
  }
  return object;
}
function isObject(x) {
  return x != null && (typeof x === 'object' || typeof x === 'function');
}
function toObject(x) {
  if (x == null)
    throw $TypeError();
  return $Object(x);
}
function assertObject(x) {
  if (!isObject(x))
    throw $TypeError(x + ' is not an Object');
  return x;
}
function setupGlobals(global) {
  global.Symbol = Symbol;
  polyfillObject(global.Object);
}
setupGlobals(global);
global.$traceurRuntime = {
  assertObject: assertObject,
  createPrivateName: createPrivateName,
  exportStar: exportStar,
  getOwnHashObject: getOwnHashObject,
  privateNames: privateNames,
  setProperty: setProperty,
  setupGlobals: setupGlobals,
  toObject: toObject,
  isObject: isObject,
  toProperty: toProperty,
  type: types,
  typeof: typeOf,
  defineProperties: $defineProperties,
  defineProperty: $defineProperty,
  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  getOwnPropertyNames: $getOwnPropertyNames,
  keys: $keys
};

})(typeof global !== 'undefined' ? global : this); (function() {

'use strict';
function spread() {
  var rv = [],
      j = 0,
      iterResult;
  for (var i = 0; i < arguments.length; i++) {
    var valueToSpread = arguments[i];
    if (!$traceurRuntime.isObject(valueToSpread)) {
      throw new TypeError('Cannot spread non-object.');
    }
    if (typeof valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)] !== 'function') {
      throw new TypeError('Cannot spread non-iterable object.');
    }
    var iter = valueToSpread[$traceurRuntime.toProperty(Symbol.iterator)]();
    while (!(iterResult = iter.next()).done) {
      rv[j++] = iterResult.value;
    }
  }
  return rv;
}
$traceurRuntime.spread = spread;

})(); (function() {

'use strict';
var $Object = Object;
var $TypeError = TypeError;
var $create = $Object.create;
var $defineProperties = $traceurRuntime.defineProperties;
var $defineProperty = $traceurRuntime.defineProperty;
var $getOwnPropertyDescriptor = $traceurRuntime.getOwnPropertyDescriptor;
var $getOwnPropertyNames = $traceurRuntime.getOwnPropertyNames;
var $getPrototypeOf = Object.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;
}
function superCall(self, homeObject, name, args) {
  return superGet(self, homeObject, name).apply(self, args);
}
function superGet(self, homeObject, name) {
  var descriptor = superDescriptor(homeObject, name);
  if (descriptor) {
    if (!descriptor.get)
      return descriptor.value;
    return descriptor.get.call(self);
  }
  return undefined;
}
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 + "'.");
}
function getDescriptors(object) {
  var descriptors = {},
      name,
      names = $getOwnPropertyNames(object);
  for (var i = 0; i < names.length; i++) {
    var name = names[i];
    descriptors[name] = $getOwnPropertyDescriptor(object, name);
  }
  return descriptors;
}
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 {
    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;
  }
  if (superClass === null)
    return null;
  throw new $TypeError();
}
function defaultSuperCall(self, homeObject, args) {
  if ($getPrototypeOf(homeObject) !== null)
    superCall(self, homeObject, 'constructor', args);
}
$traceurRuntime.createClass = createClass;
$traceurRuntime.defaultSuperCall = defaultSuperCall;
$traceurRuntime.superCall = superCall;
$traceurRuntime.superGet = superGet;
$traceurRuntime.superSet = superSet;

})(); (function() {

'use strict';
var createPrivateName = $traceurRuntime.createPrivateName;
var $defineProperties = $traceurRuntime.defineProperties;
var $defineProperty = $traceurRuntime.defineProperty;
var $create = Object.create;
var $TypeError = TypeError;
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);
}
function GeneratorContext() {
  this.state = 0;
  this.GState = ST_NEWBORN;
  this.storedException = undefined;
  this.finallyFallThrough = undefined;
  this.sent_ = undefined;
  this.returnValue = 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();
  },
  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;
  }
};
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
        };
      }
      throw x;
    case ST_NEWBORN:
      if (action === 'throw') {
        ctx.GState = ST_CLOSED;
        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 = moveNext(ctx);
      var done = value === ctx;
      if (done)
        value = ctx.returnValue;
      ctx.GState = done ? ST_CLOSED : ST_SUSPENDED;
      return {
        value: value,
        done: done
      };
  }
}
var ctxName = createPrivateName();
var moveNextName = createPrivateName();
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
GeneratorFunction.prototype = GeneratorFunctionPrototype;
$defineProperty(GeneratorFunctionPrototype, 'constructor', nonEnum(GeneratorFunction));
GeneratorFunctionPrototype.prototype = {
  constructor: GeneratorFunctionPrototype,
  next: function(v) {
    return nextOrThrow(this[ctxName], this[moveNextName], 'next', v);
  },
  throw: function(v) {
    return nextOrThrow(this[ctxName], this[moveNextName], 'throw', v);
  }
};
$defineProperties(GeneratorFunctionPrototype.prototype, {
  constructor: {enumerable: false},
  next: {enumerable: false},
  throw: {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);
  object[ctxName] = ctx;
  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;
}
$traceurRuntime.asyncWrap = asyncWrap;
$traceurRuntime.initGeneratorFunction = initGeneratorFunction;
$traceurRuntime.createGeneratorInstance = createGeneratorInstance;

})(); (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 $__2 = $traceurRuntime.assertObject($traceurRuntime),
    canonicalizeUrl = $__2.canonicalizeUrl,
    resolveUrl = $__2.resolveUrl,
    isAbsolute = $__2.isAbsolute;
var moduleInstantiators = Object.create(null);
var baseURL;
if (global.location && global.location.href)
  baseURL = resolveUrl(global.location.href, './');
else
  baseURL = '';
var UncoatedModuleEntry = function UncoatedModuleEntry(url, uncoatedModule) {
  this.url = url;
  this.value_ = uncoatedModule;
};
($traceurRuntime.createClass)(UncoatedModuleEntry, {}, {});
var UncoatedModuleInstantiator = function UncoatedModuleInstantiator(url, func) {
  $traceurRuntime.superCall(this, $UncoatedModuleInstantiator.prototype, "constructor", [url, null]);
  this.func = func;
};
var $UncoatedModuleInstantiator = UncoatedModuleInstantiator;
($traceurRuntime.createClass)(UncoatedModuleInstantiator, {getUncoatedModule: function() {
    if (this.value_)
      return this.value_;
    return this.value_ = this.func.call(global);
  }}, {}, UncoatedModuleEntry);
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, 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, func);
    } else {
      this.bundleStore[name] = {
        deps: deps,
        execute: function() {
          var $__0 = arguments;
          var depMap = {};
          deps.forEach((function(dep, index) {
            return depMap[dep] = $__0[index];
          }));
          var registryEntry = func.call(this, depMap);
          registryEntry.execute.call(this);
          return registryEntry.exports;
        }
      };
    }
  },
  getAnonymousModule: function(func) {
    return new Module(func.call(global), liveModuleSentinel);
  },
  getForTesting: function(name) {
    var $__0 = this;
    if (!this.testingPrefix_) {
      Object.keys(moduleInstances).some((function(key) {
        var m = /(traceur@[^\/]*\/)/.exec(key);
        if (m) {
          $__0.testingPrefix_ = m[1];
          return true;
        }
      }));
    }
    return this.get(this.testingPrefix_ + name);
  }
};
ModuleStore.set('@traceur/src/runtime/ModuleStore', new Module({ModuleStore: ModuleStore}));
var setupGlobals = $traceurRuntime.setupGlobals;
$traceurRuntime.setupGlobals = function(global) {
  setupGlobals(global);
};
$traceurRuntime.ModuleStore = ModuleStore;
global.System = {
  register: ModuleStore.register.bind(ModuleStore),
  get: ModuleStore.get,
  set: ModuleStore.set,
  normalize: ModuleStore.normalize
};
$traceurRuntime.getModuleImpl = function(name) {
  var instantiator = getUncoatedModuleInstantiator(name);
  return instantiator && instantiator.getUncoatedModule();
};

})(typeof global !== 'undefined' ? global : this); System.register(“traceur@0.0.43/src/runtime/polyfills/utils”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/utils";
var toObject = $traceurRuntime.toObject;
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 toInteger(x) {
  x = +x;
  if (isNaN(x))
    return 0;
  if (!isFinite(x) || x === 0)
    return x;
  return x > 0 ? Math.floor(x) : Math.ceil(x);
}
var MAX_SAFE_LENGTH = Math.pow(2, 53) - 1;
function toLength(x) {
  var len = toInteger(x);
  return len < 0 ? 0 : Math.min(len, MAX_SAFE_LENGTH);
}
return {
  get toObject() {
    return toObject;
  },
  get toUint32() {
    return toUint32;
  },
  get isObject() {
    return isObject;
  },
  get isCallable() {
    return isCallable;
  },
  get toInteger() {
    return toInteger;
  },
  get toLength() {
    return toLength;
  }
};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/Array”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/Array";
var $__3 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/utils")),
    toInteger = $__3.toInteger,
    toLength = $__3.toLength,
    toObject = $__3.toObject,
    isCallable = $__3.isCallable;
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++) {
    if (i in object) {
      var value = object[i];
      if (predicate.call(thisArg, value, i, object)) {
        return returnIndex ? i : value;
      }
    }
  }
  return returnIndex ? -1 : undefined;
}
return {
  get fill() {
    return fill;
  },
  get find() {
    return find;
  },
  get findIndex() {
    return findIndex;
  }
};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/ArrayIterator”, [], function() {

"use strict";
var $__5;
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/ArrayIterator";
var $__6 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/utils")),
    toObject = $__6.toObject,
    toUint32 = $__6.toUint32;
var ARRAY_ITERATOR_KIND_KEYS = 1;
var ARRAY_ITERATOR_KIND_VALUES = 2;
var ARRAY_ITERATOR_KIND_ENTRIES = 3;
var ArrayIterator = function ArrayIterator() {};
($traceurRuntime.createClass)(ArrayIterator, ($__5 = {}, Object.defineProperty($__5, "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($__5, Symbol.iterator, {
  value: function() {
    return this;
  },
  configurable: true,
  enumerable: true,
  writable: true
}), $__5), {});
function createArrayIterator(array, kind) {
  var object = toObject(array);
  var iterator = new ArrayIterator;
  iterator.iteratorObject_ = object;
  iterator.arrayIteratorNextIndex_ = 0;
  iterator.arrayIterationKind_ = kind;
  return iterator;
}
function createIteratorResultObject(value, done) {
  return {
    value: value,
    done: done
  };
}
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;
  }
};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/Map”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/Map";
var isObject = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/utils")).isObject;
var getOwnHashObject = $traceurRuntime.getOwnHashObject;
var $hasOwnProperty = Object.prototype.hasOwnProperty;
var deletedSentinel = {};
function lookupIndex(map, key) {
  if (isObject(key)) {
    var hashObject = getOwnHashObject(key);
    return hashObject && map.objectIndex_[hashObject.hash];
  }
  if (typeof key === 'string')
    return map.stringIndex_[key];
  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.deletedCount_ = 0;
}
var Map = function Map() {
  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) {
    for (var $__8 = iterable[Symbol.iterator](),
        $__9; !($__9 = $__8.next()).done; ) {
      var $__10 = $traceurRuntime.assertObject($__9.value),
          key = $__10[0],
          value = $__10[1];
      {
        this.set(key, value);
      }
    }
  }
};
($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 objectMode = isObject(key);
    var stringMode = typeof key === 'string';
    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 (objectMode) {
        var hashObject = getOwnHashObject(key);
        var hash = hashObject.hash;
        this.objectIndex_[hash] = index;
      } else if (stringMode) {
        this.stringIndex_[key] = index;
      } else {
        this.primitiveIndex_[key] = index;
      }
    }
    return this;
  },
  has: function(key) {
    return lookupIndex(this, key) !== undefined;
  },
  delete: function(key) {
    var objectMode = isObject(key);
    var stringMode = typeof key === 'string';
    var index;
    var hash;
    if (objectMode) {
      var hashObject = getOwnHashObject(key);
      if (hashObject) {
        index = this.objectIndex_[hash = hashObject.hash];
        delete this.objectIndex_[hash];
      }
    } else if (stringMode) {
      index = this.stringIndex_[key];
      delete this.stringIndex_[key];
    } else {
      index = this.primitiveIndex_[key];
      delete this.primitiveIndex_[key];
    }
    if (index !== undefined) {
      this.entries_[index] = deletedSentinel;
      this.entries_[index + 1] = undefined;
      this.deletedCount_++;
    }
  },
  clear: function() {
    initMap(this);
  },
  forEach: function(callbackFn) {
    var thisArg = arguments[1];
    for (var i = 0,
        len = this.entries_.length; i < len; 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 $__11() {
    var i,
        len,
        key,
        value;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            i = 0, len = this.entries_.length;
            $ctx.state = 12;
            break;
          case 12:
            $ctx.state = (i < len) ? 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();
        }
    }, $__11, this);
  }),
  keys: $traceurRuntime.initGeneratorFunction(function $__12() {
    var i,
        len,
        key,
        value;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            i = 0, len = this.entries_.length;
            $ctx.state = 12;
            break;
          case 12:
            $ctx.state = (i < len) ? 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();
        }
    }, $__12, this);
  }),
  values: $traceurRuntime.initGeneratorFunction(function $__13() {
    var i,
        len,
        key,
        value;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            i = 0, len = this.entries_.length;
            $ctx.state = 12;
            break;
          case 12:
            $ctx.state = (i < len) ? 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();
        }
    }, $__13, this);
  })
}, {});
Object.defineProperty(Map.prototype, Symbol.iterator, {
  configurable: true,
  writable: true,
  value: Map.prototype.entries
});
return {get Map() {
    return Map;
  }};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/Object”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/Object";
var $__14 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/utils")),
    toInteger = $__14.toInteger,
    toLength = $__14.toLength,
    toObject = $__14.toObject,
    isCallable = $__14.isCallable;
var $__14 = $traceurRuntime.assertObject($traceurRuntime),
    defineProperty = $__14.defineProperty,
    getOwnPropertyDescriptor = $__14.getOwnPropertyDescriptor,
    getOwnPropertyNames = $__14.getOwnPropertyNames,
    keys = $__14.keys,
    privateNames = $__14.privateNames;
function is(left, right) {
  if (left === right)
    return left !== 0 || 1 / left === 1 / right;
  return left !== left && right !== right;
}
function assign(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];
    var props = keys(source);
    var p,
        length = props.length;
    for (p = 0; p < length; p++) {
      var name = props[p];
      if (privateNames[name])
        continue;
      target[name] = source[name];
    }
  }
  return target;
}
function mixin(target, source) {
  var props = getOwnPropertyNames(source);
  var p,
      descriptor,
      length = props.length;
  for (p = 0; p < length; p++) {
    var name = props[p];
    if (privateNames[name])
      continue;
    descriptor = getOwnPropertyDescriptor(source, props[p]);
    defineProperty(target, props[p], descriptor);
  }
  return target;
}
return {
  get is() {
    return is;
  },
  get assign() {
    return assign;
  },
  get mixin() {
    return mixin;
  }
};

}); System.register(“traceur@0.0.43/node_modules/rsvp/lib/rsvp/asap”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/node_modules/rsvp/lib/rsvp/asap";
var $__default = function asap(callback, arg) {
  var length = queue.push([callback, arg]);
  if (length === 1) {
    scheduleFlush();
  }
};
var browserGlobal = (typeof window !== 'undefined') ? window : {};
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
function useNextTick() {
  return function() {
    process.nextTick(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 useSetTimeout() {
  return function() {
    setTimeout(flush, 1);
  };
}
var queue = [];
function flush() {
  for (var i = 0; i < queue.length; i++) {
    var tuple = queue[i];
    var callback = tuple[0],
        arg = tuple[1];
    callback(arg);
  }
  queue = [];
}
var scheduleFlush;
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
  scheduleFlush = useNextTick();
} else if (BrowserMutationObserver) {
  scheduleFlush = useMutationObserver();
} else {
  scheduleFlush = useSetTimeout();
}
return {get default() {
    return $__default;
  }};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/Promise”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/Promise";
var async = $traceurRuntime.assertObject(System.get("traceur@0.0.43/node_modules/rsvp/lib/rsvp/asap")).default;
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 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);
  }
};
($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) {
      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);
      }));
    }
  },
  cast: function(x) {
    if (x instanceof this)
      return x;
    if (isPromise(x)) {
      var result = getDeferred(this);
      chain(x, result.resolve, result.reject);
      return result.promise;
    }
    return this.resolve(x);
  },
  all: function(values) {
    var deferred = getDeferred(this);
    var resolutions = [];
    try {
      var count = values.length;
      if (count === 0) {
        deferred.resolve(resolutions);
      } else {
        for (var i = 0; i < values.length; i++) {
          this.resolve(values[i]).then(function(i, x) {
            resolutions[i] = x;
            if (--count === 0)
              deferred.resolve(resolutions);
          }.bind(undefined, i), (function(r) {
            deferred.reject(r);
          }));
        }
      }
    } 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 = '@@thenable';
function isObject(x) {
  return x && (typeof x === 'object' || typeof x === 'function');
}
function promiseCoerce(constructor, x) {
  if (!isPromise(x) && isObject(x)) {
    var then;
    try {
      then = x.then;
    } catch (r) {
      var promise = $PromiseReject.call(constructor, r);
      x[thenableSymbol] = promise;
      return promise;
    }
    if (typeof then === 'function') {
      var p = x[thenableSymbol];
      if (p) {
        return p;
      } else {
        var deferred = getDeferred(constructor);
        x[thenableSymbol] = deferred.promise;
        try {
          then.call(x, deferred.resolve, deferred.reject);
        } catch (r) {
          deferred.reject(r);
        }
        return deferred.promise;
      }
    }
  }
  return x;
}
return {get Promise() {
    return Promise;
  }};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/Set”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/Set";
var isObject = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/utils")).isObject;
var Map = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/Map")).Map;
var getOwnHashObject = $traceurRuntime.getOwnHashObject;
var $hasOwnProperty = Object.prototype.hasOwnProperty;
function initSet(set) {
  set.map_ = new Map();
}
var Set = 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');
  }
  initSet(this);
  if (iterable !== null && iterable !== undefined) {
    for (var $__19 = iterable[Symbol.iterator](),
        $__20; !($__20 = $__19.next()).done; ) {
      var item = $__20.value;
      {
        this.add(item);
      }
    }
  }
};
($traceurRuntime.createClass)(Set, {
  get size() {
    return this.map_.size;
  },
  has: function(key) {
    return this.map_.has(key);
  },
  add: function(key) {
    return this.map_.set(key, true);
  },
  delete: function(key) {
    return this.map_.delete(key);
  },
  clear: function() {
    return this.map_.clear();
  },
  forEach: function(callbackFn) {
    var thisArg = arguments[1];
    var $__17 = this;
    return this.map_.forEach((function(value, key) {
      callbackFn.call(thisArg, key, key, $__17);
    }));
  },
  values: $traceurRuntime.initGeneratorFunction(function $__22() {
    var $__23,
        $__24;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            $__23 = this.map_.keys()[Symbol.iterator]();
            $ctx.sent = void 0;
            $ctx.action = 'next';
            $ctx.state = 12;
            break;
          case 12:
            $__24 = $__23[$ctx.action]($ctx.sentIgnoreThrow);
            $ctx.state = 9;
            break;
          case 9:
            $ctx.state = ($__24.done) ? 3 : 2;
            break;
          case 3:
            $ctx.sent = $__24.value;
            $ctx.state = -2;
            break;
          case 2:
            $ctx.state = 12;
            return $__24.value;
          default:
            return $ctx.end();
        }
    }, $__22, this);
  }),
  keys: $traceurRuntime.initGeneratorFunction(function $__25() {
    var $__26,
        $__27;
    return $traceurRuntime.createGeneratorInstance(function($ctx) {
      while (true)
        switch ($ctx.state) {
          case 0:
            $__26 = this.map_.keys()[Symbol.iterator]();
            $ctx.sent = void 0;
            $ctx.action = 'next';
            $ctx.state = 12;
            break;
          case 12:
            $__27 = $__26[$ctx.action]($ctx.sentIgnoreThrow);
            $ctx.state = 9;
            break;
          case 9:
            $ctx.state = ($__27.done) ? 3 : 2;
            break;
          case 3:
            $ctx.sent = $__27.value;
            $ctx.state = -2;
            break;
          case 2:
            $ctx.state = 12;
            return $__27.value;
          default:
            return $ctx.end();
        }
    }, $__25, this);
  })
}, {});
Object.defineProperty(Set.prototype, Symbol.iterator, {
  configurable: true,
  writable: true,
  value: Set.prototype.values
});
return {get Set() {
    return Set;
  }};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/String”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/String";
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 contains(search) {
  if (this == null) {
    throw TypeError();
  }
  var string = String(this);
  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) != -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);
}
return {
  get startsWith() {
    return startsWith;
  },
  get endsWith() {
    return endsWith;
  },
  get contains() {
    return contains;
  },
  get repeat() {
    return repeat;
  },
  get codePointAt() {
    return codePointAt;
  },
  get raw() {
    return raw;
  },
  get fromCodePoint() {
    return fromCodePoint;
  }
};

}); System.register(“traceur@0.0.43/src/runtime/polyfills/polyfills”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfills/polyfills";
var Map = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/Map")).Map;
var Set = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/Set")).Set;
var Promise = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/Promise")).Promise;
var $__28 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/String")),
    codePointAt = $__28.codePointAt,
    contains = $__28.contains,
    endsWith = $__28.endsWith,
    fromCodePoint = $__28.fromCodePoint,
    repeat = $__28.repeat,
    raw = $__28.raw,
    startsWith = $__28.startsWith;
var $__28 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/Array")),
    fill = $__28.fill,
    find = $__28.find,
    findIndex = $__28.findIndex;
var $__28 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/ArrayIterator")),
    entries = $__28.entries,
    keys = $__28.keys,
    values = $__28.values;
var $__28 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/Object")),
    assign = $__28.assign,
    is = $__28.is,
    mixin = $__28.mixin;
function maybeDefineMethod(object, name, value) {
  if (!(name in object)) {
    Object.defineProperty(object, name, {
      value: value,
      configurable: true,
      enumerable: false,
      writable: true
    });
  }
}
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 polyfillPromise(global) {
  if (!global.Promise)
    global.Promise = Promise;
}
function polyfillCollections(global) {
  if (!global.Map)
    global.Map = Map;
  if (!global.Set)
    global.Set = Set;
}
function polyfillString(String) {
  maybeAddFunctions(String.prototype, ['codePointAt', codePointAt, 'contains', contains, 'endsWith', endsWith, 'startsWith', startsWith, 'repeat', repeat]);
  maybeAddFunctions(String, ['fromCodePoint', fromCodePoint, 'raw', raw]);
}
function polyfillArray(Array, Symbol) {
  maybeAddFunctions(Array.prototype, ['entries', entries, 'keys', keys, 'values', values, 'fill', fill, 'find', find, 'findIndex', findIndex]);
  if (Symbol && Symbol.iterator) {
    Object.defineProperty(Array.prototype, Symbol.iterator, {
      value: values,
      configurable: true,
      enumerable: false,
      writable: true
    });
  }
}
function polyfillObject(Object) {
  maybeAddFunctions(Object, ['assign', assign, 'is', is, 'mixin', mixin]);
}
function polyfill(global) {
  polyfillPromise(global);
  polyfillCollections(global);
  polyfillString(global.String);
  polyfillArray(global.Array, global.Symbol);
  polyfillObject(global.Object);
}
polyfill(this);
var setupGlobals = $traceurRuntime.setupGlobals;
$traceurRuntime.setupGlobals = function(global) {
  setupGlobals(global);
  polyfill(global);
};
return {};

}); System.register(“traceur@0.0.43/src/runtime/polyfill-import”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/polyfill-import";
var $__30 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/polyfills/polyfills"));
return {};

}); System.get(“traceur@0.0.43/src/runtime/polyfill-import” + ''); System.register(“traceur@0.0.43/src/options”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/options";
var parseOptions = Object.create(null);
var transformOptions = Object.create(null);
var defaultValues = Object.create(null);
var experimentalOptions = Object.create(null);
var moduleOptions = ['amd', 'commonjs', 'instantiate', 'inline', 'register'];
var options = {
  set experimental(v) {
    v = coerceOptionValue(v);
    Object.keys(experimentalOptions).forEach((function(name) {
      options[name] = v;
    }));
  },
  get experimental() {
    var value;
    Object.keys(experimentalOptions).every((function(name) {
      var currentValue = options[name];
      if (value === undefined) {
        value = currentValue;
        return true;
      }
      if (currentValue !== value) {
        value = null;
        return false;
      }
      return true;
    }));
    return value;
  },
  modules_: 'register',
  get modules() {
    return this.modules_;
  },
  set modules(value) {
    if (typeof value === 'boolean' && !value)
      value = 'register';
    if (moduleOptions.indexOf(value) === -1) {
      throw new Error('Invalid \'modules\' option \'' + value + '\', not in ' + moduleOptions.join(', '));
    }
    this.modules_ = value;
  },
  scripts: []
};
var descriptions = {experimental: 'Turns on all experimental features'};
function reset() {
  var allOff = arguments[0];
  var useDefault = allOff === undefined;
  Object.keys(options).forEach((function(name) {
    options[name] = useDefault && defaultValues[name];
  }));
}
function fromString(s) {
  fromArgv(s.split(/\s+/));
}
function fromArgv(args) {
  args.forEach(parseCommand);
}
function setFromObject(object) {
  Object.keys(object).forEach((function(name) {
    options[name] = object[name];
  }));
}
function coerceOptionValue(v) {
  switch (v) {
    case 'false':
      return false;
    case 'true':
    case true:
      return true;
    default:
      return !!v && String(v);
  }
}
function setOption(name, value) {
  name = toCamelCase(name);
  value = coerceOptionValue(value);
  if (name in options) {
    options[name] = value;
  } else {
    throw Error('Unknown option: ' + name);
  }
}
function addOptions(flags) {
  Object.keys(options).forEach(function(name) {
    var dashedName = toDashCase(name);
    if ((name in parseOptions) && (name in transformOptions)) {
      flags.option('--' + dashedName + ' [true|false|parse]', descriptions[name]);
      flags.on(dashedName, (function(value) {
        return setOption(dashedName, value);
      }));
    } else if (options[name] !== null) {
      flags.option('--' + dashedName, descriptions[name]);
      flags.on(dashedName, (function() {
        return setOption(dashedName, true);
      }));
    }
  });
  flags.option('--referrer <name>', 'Bracket output code with System.referrerName=<name>', (function(name) {
    setOption('referrer', name);
    return name;
  }));
  flags.option('--type-assertion-module <path>', 'Absolute path to the type assertion module.', (function(path) {
    setOption('type-assertion-module', path);
    return path;
  }));
  flags.option('--script <fileName>', 'Parse as Script (must precede modules)', (function(fileName) {
    options.scripts.push(fileName);
  }));
}
function filterOption(dashedName) {
  var name = toCamelCase(dashedName);
  return name === 'experimental' || !(name in options);
}
Object.defineProperties(options, {
  reset: {value: reset},
  fromString: {value: fromString},
  fromArgv: {value: fromArgv},
  setFromObject: {value: setFromObject},
  addOptions: {value: addOptions},
  filterOption: {value: filterOption}
});
function parseCommand(s) {
  var re = /--([^=]+)(?:=(.+))?/;
  var m = re.exec(s);
  if (m)
    setOption(m[1], m[2] || true);
}
function toCamelCase(s) {
  return s.replace(/-\w/g, function(ch) {
    return ch[1].toUpperCase();
  });
}
function toDashCase(s) {
  return s.replace(/[A-W]/g, function(ch) {
    return '-' + ch.toLowerCase();
  });
}
var EXPERIMENTAL = 0;
var ON_BY_DEFAULT = 1;
function addFeatureOption(name, kind) {
  if (kind === EXPERIMENTAL)
    experimentalOptions[name] = true;
  Object.defineProperty(parseOptions, name, {
    get: function() {
      return !!options[name];
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(transformOptions, name, {
    get: function() {
      var v = options[name];
      if (v === 'parse')
        return false;
      return v;
    },
    enumerable: true,
    configurable: true
  });
  var defaultValue = options[name] || kind === ON_BY_DEFAULT;
  options[name] = defaultValue;
  defaultValues[name] = defaultValue;
}
function addBoolOption(name) {
  defaultValues[name] = false;
  options[name] = false;
}
addFeatureOption('arrayComprehension', ON_BY_DEFAULT);
addFeatureOption('arrowFunctions', 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('generatorComprehension', ON_BY_DEFAULT);
addFeatureOption('generators', ON_BY_DEFAULT);
addFeatureOption('modules', ON_BY_DEFAULT);
addFeatureOption('numericLiterals', ON_BY_DEFAULT);
addFeatureOption('propertyMethods', ON_BY_DEFAULT);
addFeatureOption('propertyNameShorthand', ON_BY_DEFAULT);
addFeatureOption('restParameters', ON_BY_DEFAULT);
addFeatureOption('spread', ON_BY_DEFAULT);
addFeatureOption('templateLiterals', ON_BY_DEFAULT);
addFeatureOption('asyncFunctions', EXPERIMENTAL);
addFeatureOption('blockBinding', EXPERIMENTAL);
addFeatureOption('symbols', EXPERIMENTAL);
addFeatureOption('types', EXPERIMENTAL);
addFeatureOption('annotations', EXPERIMENTAL);
addBoolOption('commentCallback');
addBoolOption('debug');
addBoolOption('freeVariableChecker');
addBoolOption('sourceMaps');
addBoolOption('typeAssertions');
addBoolOption('validate');
defaultValues.referrer = '';
options.referrer = null;
defaultValues.typeAssertionModule = null;
options.typeAssertionModule = null;
return {
  get parseOptions() {
    return parseOptions;
  },
  get transformOptions() {
    return transformOptions;
  },
  get options() {
    return options;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/TokenType”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/TokenType";
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 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 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 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 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;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/Token”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/Token";
var $__32 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    AMPERSAND_EQUAL = $__32.AMPERSAND_EQUAL,
    BAR_EQUAL = $__32.BAR_EQUAL,
    CARET_EQUAL = $__32.CARET_EQUAL,
    EQUAL = $__32.EQUAL,
    LEFT_SHIFT_EQUAL = $__32.LEFT_SHIFT_EQUAL,
    MINUS_EQUAL = $__32.MINUS_EQUAL,
    PERCENT_EQUAL = $__32.PERCENT_EQUAL,
    PLUS_EQUAL = $__32.PLUS_EQUAL,
    RIGHT_SHIFT_EQUAL = $__32.RIGHT_SHIFT_EQUAL,
    SLASH_EQUAL = $__32.SLASH_EQUAL,
    STAR_EQUAL = $__32.STAR_EQUAL,
    UNSIGNED_RIGHT_SHIFT_EQUAL = $__32.UNSIGNED_RIGHT_SHIFT_EQUAL;
var Token = function Token(type, location) {
  this.type = type;
  this.location = location;
};
($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 UNSIGNED_RIGHT_SHIFT_EQUAL:
      return true;
  }
  return false;
}
return {
  get Token() {
    return Token;
  },
  get isAssignmentOperator() {
    return isAssignmentOperator;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/IdentifierToken”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/IdentifierToken";
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var IDENTIFIER = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).IDENTIFIER;
var IdentifierToken = function IdentifierToken(location, value) {
  this.location = location;
  this.value = value;
};
($traceurRuntime.createClass)(IdentifierToken, {
  toString: function() {
    return this.value;
  },
  get type() {
    return IDENTIFIER;
  }
}, {}, Token);
return {get IdentifierToken() {
    return IdentifierToken;
  }};

}); System.register(“traceur@0.0.43/src/syntax/ParseTreeVisitor”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/ParseTreeVisitor";
var ParseTreeVisitor = function ParseTreeVisitor() {};
($traceurRuntime.createClass)(ParseTreeVisitor, {
  visitAny: function(tree) {
    tree && 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);
  },
  visitArrayLiteralExpression: function(tree) {
    this.visitList(tree.elements);
  },
  visitArrayPattern: function(tree) {
    this.visitList(tree.elements);
  },
  visitArrowFunctionExpression: function(tree) {
    this.visitAny(tree.parameterList);
    this.visitAny(tree.functionBody);
  },
  visitAwaitExpression: function(tree) {
    this.visitAny(tree.expression);
  },
  visitBinaryOperator: 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);
  },
  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);
  },
  visitClassExpression: function(tree) {
    this.visitAny(tree.name);
    this.visitAny(tree.superClass);
    this.visitList(tree.elements);
    this.visitList(tree.annotations);
  },
  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);
  },
  visitContinueStatement: function(tree) {},
  visitCoverFormals: function(tree) {
    this.visitList(tree.expressions);
  },
  visitCoverInitialisedName: 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);
  },
  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);
  },
  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.functionBody);
  },
  visitFunctionExpression: function(tree) {
    this.visitAny(tree.name);
    this.visitAny(tree.parameterList);
    this.visitAny(tree.typeAnnotation);
    this.visitList(tree.annotations);
    this.visitAny(tree.functionBody);
  },
  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);
  },
  visitImportDeclaration: function(tree) {
    this.visitAny(tree.importClause);
    this.visitAny(tree.moduleSpecifier);
  },
  visitImportSpecifier: function(tree) {},
  visitImportSpecifierSet: function(tree) {
    this.visitList(tree.specifiers);
  },
  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);
  },
  visitModule: function(tree) {
    this.visitList(tree.scriptItemList);
  },
  visitModuleDeclaration: function(tree) {
    this.visitAny(tree.expression);
  },
  visitModuleSpecifier: function(tree) {},
  visitNamedExport: function(tree) {
    this.visitAny(tree.moduleSpecifier);
    this.visitAny(tree.specifierSet);
  },
  visitNewExpression: function(tree) {
    this.visitAny(tree.operand);
    this.visitAny(tree.args);
  },
  visitObjectLiteralExpression: function(tree) {
    this.visitList(tree.propertyNameAndValues);
  },
  visitObjectPattern: function(tree) {
    this.visitList(tree.fields);
  },
  visitObjectPatternField: function(tree) {
    this.visitAny(tree.name);
    this.visitAny(tree.element);
  },
  visitParenExpression: function(tree) {
    this.visitAny(tree.expression);
  },
  visitPostfixExpression: function(tree) {
    this.visitAny(tree.operand);
  },
  visitPredefinedType: function(tree) {},
  visitScript: function(tree) {
    this.visitList(tree.scriptItemList);
  },
  visitPropertyMethodAssignment: function(tree) {
    this.visitAny(tree.name);
    this.visitAny(tree.parameterList);
    this.visitAny(tree.typeAnnotation);
    this.visitList(tree.annotations);
    this.visitAny(tree.functionBody);
  },
  visitPropertyNameAssignment: function(tree) {
    this.visitAny(tree.name);
    this.visitAny(tree.value);
  },
  visitPropertyNameShorthand: function(tree) {},
  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);
  },
  visitTypeName: function(tree) {
    this.visitAny(tree.moduleName);
  },
  visitUnaryExpression: function(tree) {
    this.visitAny(tree.operand);
  },
  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;
  }};

}); System.register(“traceur@0.0.43/src/syntax/PredefinedName”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/PredefinedName";
var $ARGUMENTS = '$arguments';
var ANY = 'any';
var APPLY = 'apply';
var ARGUMENTS = 'arguments';
var ARRAY = 'Array';
var AS = 'as';
var ASYNC = 'async';
var AWAIT = 'await';
var BIND = 'bind';
var CALL = 'call';
var CONFIGURABLE = 'configurable';
var CONSTRUCTOR = 'constructor';
var CREATE = 'create';
var CURRENT = 'current';
var DEFINE_PROPERTIES = 'defineProperties';
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 PREVENT_EXTENSIONS = 'preventExtensions';
var PROTOTYPE = 'prototype';
var PUSH = 'push';
var RAW = 'raw';
var SET = 'set';
var SLICE = 'slice';
var THIS = 'this';
var TRACEUR_RUNTIME = '$traceurRuntime';
var UNDEFINED = 'undefined';
var WRITABLE = 'writable';
function getParameterName(index) {
  return '$' + index;
}
;
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 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_PROPERTIES() {
    return DEFINE_PROPERTIES;
  },
  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 PREVENT_EXTENSIONS() {
    return PREVENT_EXTENSIONS;
  },
  get PROTOTYPE() {
    return PROTOTYPE;
  },
  get PUSH() {
    return PUSH;
  },
  get RAW() {
    return RAW;
  },
  get SET() {
    return SET;
  },
  get SLICE() {
    return SLICE;
  },
  get THIS() {
    return THIS;
  },
  get TRACEUR_RUNTIME() {
    return TRACEUR_RUNTIME;
  },
  get UNDEFINED() {
    return UNDEFINED;
  },
  get WRITABLE() {
    return WRITABLE;
  },
  get getParameterName() {
    return getParameterName;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/trees/ParseTreeType”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/trees/ParseTreeType";
var ANNOTATION = 'ANNOTATION';
var ANON_BLOCK = 'ANON_BLOCK';
var ARGUMENT_LIST = 'ARGUMENT_LIST';
var ARRAY_COMPREHENSION = 'ARRAY_COMPREHENSION';
var ARRAY_LITERAL_EXPRESSION = 'ARRAY_LITERAL_EXPRESSION';
var ARRAY_PATTERN = 'ARRAY_PATTERN';
var ARROW_FUNCTION_EXPRESSION = 'ARROW_FUNCTION_EXPRESSION';
var AWAIT_EXPRESSION = 'AWAIT_EXPRESSION';
var BINARY_OPERATOR = 'BINARY_OPERATOR';
var BINDING_ELEMENT = 'BINDING_ELEMENT';
var BINDING_IDENTIFIER = 'BINDING_IDENTIFIER';
var BLOCK = 'BLOCK';
var BREAK_STATEMENT = 'BREAK_STATEMENT';
var CALL_EXPRESSION = 'CALL_EXPRESSION';
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 CONTINUE_STATEMENT = 'CONTINUE_STATEMENT';
var COVER_FORMALS = 'COVER_FORMALS';
var COVER_INITIALISED_NAME = 'COVER_INITIALISED_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_STATEMENT = 'FOR_STATEMENT';
var FORMAL_PARAMETER = 'FORMAL_PARAMETER';
var FORMAL_PARAMETER_LIST = 'FORMAL_PARAMETER_LIST';
var FUNCTION_BODY = 'FUNCTION_BODY';
var FUNCTION_DECLARATION = 'FUNCTION_DECLARATION';
var FUNCTION_EXPRESSION = 'FUNCTION_EXPRESSION';
var GENERATOR_COMPREHENSION = 'GENERATOR_COMPREHENSION';
var GET_ACCESSOR = 'GET_ACCESSOR';
var IDENTIFIER_EXPRESSION = 'IDENTIFIER_EXPRESSION';
var IF_STATEMENT = 'IF_STATEMENT';
var IMPORT_DECLARATION = 'IMPORT_DECLARATION';
var IMPORT_SPECIFIER = 'IMPORT_SPECIFIER';
var IMPORT_SPECIFIER_SET = 'IMPORT_SPECIFIER_SET';
var IMPORTED_BINDING = 'IMPORTED_BINDING';
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 MODULE = 'MODULE';
var MODULE_DECLARATION = 'MODULE_DECLARATION';
var MODULE_SPECIFIER = 'MODULE_SPECIFIER';
var NAMED_EXPORT = 'NAMED_EXPORT';
var NEW_EXPRESSION = 'NEW_EXPRESSION';
var OBJECT_LITERAL_EXPRESSION = 'OBJECT_LITERAL_EXPRESSION';
var OBJECT_PATTERN = 'OBJECT_PATTERN';
var OBJECT_PATTERN_FIELD = 'OBJECT_PATTERN_FIELD';
var PAREN_EXPRESSION = 'PAREN_EXPRESSION';
var POSTFIX_EXPRESSION = 'POSTFIX_EXPRESSION';
var PREDEFINED_TYPE = 'PREDEFINED_TYPE';
var PROPERTY_METHOD_ASSIGNMENT = 'PROPERTY_METHOD_ASSIGNMENT';
var PROPERTY_NAME_ASSIGNMENT = 'PROPERTY_NAME_ASSIGNMENT';
var PROPERTY_NAME_SHORTHAND = 'PROPERTY_NAME_SHORTHAND';
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_NAME = 'TYPE_NAME';
var UNARY_EXPRESSION = 'UNARY_EXPRESSION';
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_EXPRESSION() {
    return ARRAY_LITERAL_EXPRESSION;
  },
  get ARRAY_PATTERN() {
    return ARRAY_PATTERN;
  },
  get ARROW_FUNCTION_EXPRESSION() {
    return ARROW_FUNCTION_EXPRESSION;
  },
  get AWAIT_EXPRESSION() {
    return AWAIT_EXPRESSION;
  },
  get BINARY_OPERATOR() {
    return BINARY_OPERATOR;
  },
  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 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 CONTINUE_STATEMENT() {
    return CONTINUE_STATEMENT;
  },
  get COVER_FORMALS() {
    return COVER_FORMALS;
  },
  get COVER_INITIALISED_NAME() {
    return COVER_INITIALISED_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_STATEMENT() {
    return FOR_STATEMENT;
  },
  get FORMAL_PARAMETER() {
    return FORMAL_PARAMETER;
  },
  get FORMAL_PARAMETER_LIST() {
    return FORMAL_PARAMETER_LIST;
  },
  get FUNCTION_BODY() {
    return FUNCTION_BODY;
  },
  get FUNCTION_DECLARATION() {
    return FUNCTION_DECLARATION;
  },
  get FUNCTION_EXPRESSION() {
    return FUNCTION_EXPRESSION;
  },
  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_DECLARATION() {
    return IMPORT_DECLARATION;
  },
  get IMPORT_SPECIFIER() {
    return IMPORT_SPECIFIER;
  },
  get IMPORT_SPECIFIER_SET() {
    return IMPORT_SPECIFIER_SET;
  },
  get IMPORTED_BINDING() {
    return IMPORTED_BINDING;
  },
  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 MODULE() {
    return MODULE;
  },
  get MODULE_DECLARATION() {
    return MODULE_DECLARATION;
  },
  get MODULE_SPECIFIER() {
    return MODULE_SPECIFIER;
  },
  get NAMED_EXPORT() {
    return NAMED_EXPORT;
  },
  get NEW_EXPRESSION() {
    return NEW_EXPRESSION;
  },
  get OBJECT_LITERAL_EXPRESSION() {
    return OBJECT_LITERAL_EXPRESSION;
  },
  get OBJECT_PATTERN() {
    return OBJECT_PATTERN;
  },
  get OBJECT_PATTERN_FIELD() {
    return OBJECT_PATTERN_FIELD;
  },
  get PAREN_EXPRESSION() {
    return PAREN_EXPRESSION;
  },
  get POSTFIX_EXPRESSION() {
    return POSTFIX_EXPRESSION;
  },
  get PREDEFINED_TYPE() {
    return PREDEFINED_TYPE;
  },
  get PROPERTY_METHOD_ASSIGNMENT() {
    return PROPERTY_METHOD_ASSIGNMENT;
  },
  get PROPERTY_NAME_ASSIGNMENT() {
    return PROPERTY_NAME_ASSIGNMENT;
  },
  get PROPERTY_NAME_SHORTHAND() {
    return PROPERTY_NAME_SHORTHAND;
  },
  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_NAME() {
    return TYPE_NAME;
  },
  get UNARY_EXPRESSION() {
    return UNARY_EXPRESSION;
  },
  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;
  }
};

}); System.register(“traceur@0.0.43/src/util/JSON”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/JSON";
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;
  }};

}); System.register(“traceur@0.0.43/src/syntax/trees/ParseTree”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/trees/ParseTree";
var ParseTreeType = System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType");
var $__37 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    IDENTIFIER = $__37.IDENTIFIER,
    STAR = $__37.STAR,
    STRING = $__37.STRING,
    VAR = $__37.VAR;
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var utilJSON = System.get("traceur@0.0.43/src/util/JSON");
var ASYNC = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).ASYNC;
var $__37 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    ARGUMENT_LIST = $__37.ARGUMENT_LIST,
    ARRAY_COMPREHENSION = $__37.ARRAY_COMPREHENSION,
    ARRAY_LITERAL_EXPRESSION = $__37.ARRAY_LITERAL_EXPRESSION,
    ARRAY_PATTERN = $__37.ARRAY_PATTERN,
    ARROW_FUNCTION_EXPRESSION = $__37.ARROW_FUNCTION_EXPRESSION,
    AWAIT_EXPRESSION = $__37.AWAIT_EXPRESSION,
    BINARY_OPERATOR = $__37.BINARY_OPERATOR,
    BINDING_ELEMENT = $__37.BINDING_ELEMENT,
    BINDING_IDENTIFIER = $__37.BINDING_IDENTIFIER,
    BLOCK = $__37.BLOCK,
    BREAK_STATEMENT = $__37.BREAK_STATEMENT,
    CALL_EXPRESSION = $__37.CALL_EXPRESSION,
    CASE_CLAUSE = $__37.CASE_CLAUSE,
    CATCH = $__37.CATCH,
    CLASS_DECLARATION = $__37.CLASS_DECLARATION,
    CLASS_EXPRESSION = $__37.CLASS_EXPRESSION,
    COMMA_EXPRESSION = $__37.COMMA_EXPRESSION,
    COMPREHENSION_FOR = $__37.COMPREHENSION_FOR,
    COMPREHENSION_IF = $__37.COMPREHENSION_IF,
    COMPUTED_PROPERTY_NAME = $__37.COMPUTED_PROPERTY_NAME,
    CONDITIONAL_EXPRESSION = $__37.CONDITIONAL_EXPRESSION,
    CONTINUE_STATEMENT = $__37.CONTINUE_STATEMENT,
    COVER_FORMALS = $__37.COVER_FORMALS,
    COVER_INITIALISED_NAME = $__37.COVER_INITIALISED_NAME,
    DEBUGGER_STATEMENT = $__37.DEBUGGER_STATEMENT,
    DEFAULT_CLAUSE = $__37.DEFAULT_CLAUSE,
    DO_WHILE_STATEMENT = $__37.DO_WHILE_STATEMENT,
    EMPTY_STATEMENT = $__37.EMPTY_STATEMENT,
    EXPORT_DECLARATION = $__37.EXPORT_DECLARATION,
    EXPORT_SPECIFIER = $__37.EXPORT_SPECIFIER,
    EXPORT_SPECIFIER_SET = $__37.EXPORT_SPECIFIER_SET,
    EXPORT_STAR = $__37.EXPORT_STAR,
    EXPRESSION_STATEMENT = $__37.EXPRESSION_STATEMENT,
    FINALLY = $__37.FINALLY,
    FOR_IN_STATEMENT = $__37.FOR_IN_STATEMENT,
    FOR_OF_STATEMENT = $__37.FOR_OF_STATEMENT,
    FOR_STATEMENT = $__37.FOR_STATEMENT,
    FORMAL_PARAMETER = $__37.FORMAL_PARAMETER,
    FORMAL_PARAMETER_LIST = $__37.FORMAL_PARAMETER_LIST,
    FUNCTION_BODY = $__37.FUNCTION_BODY,
    FUNCTION_DECLARATION = $__37.FUNCTION_DECLARATION,
    FUNCTION_EXPRESSION = $__37.FUNCTION_EXPRESSION,
    GENERATOR_COMPREHENSION = $__37.GENERATOR_COMPREHENSION,
    GET_ACCESSOR = $__37.GET_ACCESSOR,
    IDENTIFIER_EXPRESSION = $__37.IDENTIFIER_EXPRESSION,
    IF_STATEMENT = $__37.IF_STATEMENT,
    IMPORT_DECLARATION = $__37.IMPORT_DECLARATION,
    IMPORT_SPECIFIER = $__37.IMPORT_SPECIFIER,
    IMPORT_SPECIFIER_SET = $__37.IMPORT_SPECIFIER_SET,
    LABELLED_STATEMENT = $__37.LABELLED_STATEMENT,
    LITERAL_EXPRESSION = $__37.LITERAL_EXPRESSION,
    LITERAL_PROPERTY_NAME = $__37.LITERAL_PROPERTY_NAME,
    MEMBER_EXPRESSION = $__37.MEMBER_EXPRESSION,
    MEMBER_LOOKUP_EXPRESSION = $__37.MEMBER_LOOKUP_EXPRESSION,
    MODULE = $__37.MODULE,
    MODULE_DECLARATION = $__37.MODULE_DECLARATION,
    MODULE_SPECIFIER = $__37.MODULE_SPECIFIER,
    NAMED_EXPORT = $__37.NAMED_EXPORT,
    NEW_EXPRESSION = $__37.NEW_EXPRESSION,
    OBJECT_LITERAL_EXPRESSION = $__37.OBJECT_LITERAL_EXPRESSION,
    OBJECT_PATTERN = $__37.OBJECT_PATTERN,
    OBJECT_PATTERN_FIELD = $__37.OBJECT_PATTERN_FIELD,
    PAREN_EXPRESSION = $__37.PAREN_EXPRESSION,
    POSTFIX_EXPRESSION = $__37.POSTFIX_EXPRESSION,
    PREDEFINED_TYPE = $__37.PREDEFINED_TYPE,
    PROPERTY_METHOD_ASSIGNMENT = $__37.PROPERTY_METHOD_ASSIGNMENT,
    PROPERTY_NAME_ASSIGNMENT = $__37.PROPERTY_NAME_ASSIGNMENT,
    PROPERTY_NAME_SHORTHAND = $__37.PROPERTY_NAME_SHORTHAND,
    REST_PARAMETER = $__37.REST_PARAMETER,
    RETURN_STATEMENT = $__37.RETURN_STATEMENT,
    SCRIPT = $__37.SCRIPT,
    SET_ACCESSOR = $__37.SET_ACCESSOR,
    SPREAD_EXPRESSION = $__37.SPREAD_EXPRESSION,
    SPREAD_PATTERN_ELEMENT = $__37.SPREAD_PATTERN_ELEMENT,
    STATE_MACHINE = $__37.STATE_MACHINE,
    SUPER_EXPRESSION = $__37.SUPER_EXPRESSION,
    SWITCH_STATEMENT = $__37.SWITCH_STATEMENT,
    SYNTAX_ERROR_TREE = $__37.SYNTAX_ERROR_TREE,
    TEMPLATE_LITERAL_EXPRESSION = $__37.TEMPLATE_LITERAL_EXPRESSION,
    TEMPLATE_LITERAL_PORTION = $__37.TEMPLATE_LITERAL_PORTION,
    TEMPLATE_SUBSTITUTION = $__37.TEMPLATE_SUBSTITUTION,
    THIS_EXPRESSION = $__37.THIS_EXPRESSION,
    THROW_STATEMENT = $__37.THROW_STATEMENT,
    TRY_STATEMENT = $__37.TRY_STATEMENT,
    TYPE_NAME = $__37.TYPE_NAME,
    UNARY_EXPRESSION = $__37.UNARY_EXPRESSION,
    VARIABLE_DECLARATION = $__37.VARIABLE_DECLARATION,
    VARIABLE_DECLARATION_LIST = $__37.VARIABLE_DECLARATION_LIST,
    VARIABLE_STATEMENT = $__37.VARIABLE_STATEMENT,
    WHILE_STATEMENT = $__37.WHILE_STATEMENT,
    WITH_STATEMENT = $__37.WITH_STATEMENT,
    YIELD_EXPRESSION = $__37.YIELD_EXPRESSION;
;
var ParseTree = function ParseTree(type, location) {
  throw new Error("Don't use for now. 'super' is currently very slow.");
  this.type = type;
  this.location = location;
};
var $ParseTree = ParseTree;
($traceurRuntime.createClass)(ParseTree, {
  isPattern: function() {
    switch (this.type) {
      case ARRAY_PATTERN:
      case OBJECT_PATTERN:
        return true;
      case PAREN_EXPRESSION:
        return this.expression.isPattern();
      default:
        return false;
    }
  },
  isLeftHandSideExpression: function() {
    switch (this.type) {
      case THIS_EXPRESSION:
      case CLASS_EXPRESSION:
      case SUPER_EXPRESSION:
      case IDENTIFIER_EXPRESSION:
      case LITERAL_EXPRESSION:
      case ARRAY_LITERAL_EXPRESSION:
      case OBJECT_LITERAL_EXPRESSION:
      case NEW_EXPRESSION:
      case MEMBER_EXPRESSION:
      case MEMBER_LOOKUP_EXPRESSION:
      case CALL_EXPRESSION:
      case FUNCTION_EXPRESSION:
      case TEMPLATE_LITERAL_EXPRESSION:
        return true;
      case PAREN_EXPRESSION:
        return this.expression.isLeftHandSideExpression();
      default:
        return false;
    }
  },
  isAssignmentExpression: function() {
    switch (this.type) {
      case ARRAY_COMPREHENSION:
      case ARRAY_LITERAL_EXPRESSION:
      case ARROW_FUNCTION_EXPRESSION:
      case AWAIT_EXPRESSION:
      case BINARY_OPERATOR:
      case CALL_EXPRESSION:
      case CLASS_EXPRESSION:
      case CONDITIONAL_EXPRESSION:
      case FUNCTION_EXPRESSION:
      case GENERATOR_COMPREHENSION:
      case IDENTIFIER_EXPRESSION:
      case LITERAL_EXPRESSION:
      case MEMBER_EXPRESSION:
      case MEMBER_LOOKUP_EXPRESSION:
      case NEW_EXPRESSION:
      case OBJECT_LITERAL_EXPRESSION:
      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 LITERAL_EXPRESSION:
      case ARRAY_LITERAL_EXPRESSION:
      case OBJECT_LITERAL_EXPRESSION:
      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();
  },
  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_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 MODULE_DECLARATION:
      case VARIABLE_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;
  },
  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);
  }
}, {
  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;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/trees/ParseTrees”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/trees/ParseTrees";
var ParseTree = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTree")).ParseTree;
var ParseTreeType = System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType");
var ANNOTATION = ParseTreeType.ANNOTATION;
var Annotation = function Annotation(location, name, args) {
  this.location = location;
  this.name = name;
  this.args = args;
};
($traceurRuntime.createClass)(Annotation, {
  transform: function(transformer) {
    return transformer.transformAnnotation(this);
  },
  visit: function(visitor) {
    visitor.visitAnnotation(this);
  },
  get type() {
    return ANNOTATION;
  }
}, {}, ParseTree);
var ANON_BLOCK = ParseTreeType.ANON_BLOCK;
var AnonBlock = function AnonBlock(location, statements) {
  this.location = location;
  this.statements = statements;
};
($traceurRuntime.createClass)(AnonBlock, {
  transform: function(transformer) {
    return transformer.transformAnonBlock(this);
  },
  visit: function(visitor) {
    visitor.visitAnonBlock(this);
  },
  get type() {
    return ANON_BLOCK;
  }
}, {}, ParseTree);
var ARGUMENT_LIST = ParseTreeType.ARGUMENT_LIST;
var ArgumentList = function ArgumentList(location, args) {
  this.location = location;
  this.args = args;
};
($traceurRuntime.createClass)(ArgumentList, {
  transform: function(transformer) {
    return transformer.transformArgumentList(this);
  },
  visit: function(visitor) {
    visitor.visitArgumentList(this);
  },
  get type() {
    return ARGUMENT_LIST;
  }
}, {}, ParseTree);
var ARRAY_COMPREHENSION = ParseTreeType.ARRAY_COMPREHENSION;
var ArrayComprehension = function ArrayComprehension(location, comprehensionList, expression) {
  this.location = location;
  this.comprehensionList = comprehensionList;
  this.expression = expression;
};
($traceurRuntime.createClass)(ArrayComprehension, {
  transform: function(transformer) {
    return transformer.transformArrayComprehension(this);
  },
  visit: function(visitor) {
    visitor.visitArrayComprehension(this);
  },
  get type() {
    return ARRAY_COMPREHENSION;
  }
}, {}, ParseTree);
var ARRAY_LITERAL_EXPRESSION = ParseTreeType.ARRAY_LITERAL_EXPRESSION;
var ArrayLiteralExpression = function ArrayLiteralExpression(location, elements) {
  this.location = location;
  this.elements = elements;
};
($traceurRuntime.createClass)(ArrayLiteralExpression, {
  transform: function(transformer) {
    return transformer.transformArrayLiteralExpression(this);
  },
  visit: function(visitor) {
    visitor.visitArrayLiteralExpression(this);
  },
  get type() {
    return ARRAY_LITERAL_EXPRESSION;
  }
}, {}, ParseTree);
var ARRAY_PATTERN = ParseTreeType.ARRAY_PATTERN;
var ArrayPattern = function ArrayPattern(location, elements) {
  this.location = location;
  this.elements = elements;
};
($traceurRuntime.createClass)(ArrayPattern, {
  transform: function(transformer) {
    return transformer.transformArrayPattern(this);
  },
  visit: function(visitor) {
    visitor.visitArrayPattern(this);
  },
  get type() {
    return ARRAY_PATTERN;
  }
}, {}, ParseTree);
var ARROW_FUNCTION_EXPRESSION = ParseTreeType.ARROW_FUNCTION_EXPRESSION;
var ArrowFunctionExpression = function ArrowFunctionExpression(location, functionKind, parameterList, functionBody) {
  this.location = location;
  this.functionKind = functionKind;
  this.parameterList = parameterList;
  this.functionBody = functionBody;
};
($traceurRuntime.createClass)(ArrowFunctionExpression, {
  transform: function(transformer) {
    return transformer.transformArrowFunctionExpression(this);
  },
  visit: function(visitor) {
    visitor.visitArrowFunctionExpression(this);
  },
  get type() {
    return ARROW_FUNCTION_EXPRESSION;
  }
}, {}, ParseTree);
var AWAIT_EXPRESSION = ParseTreeType.AWAIT_EXPRESSION;
var AwaitExpression = function AwaitExpression(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(AwaitExpression, {
  transform: function(transformer) {
    return transformer.transformAwaitExpression(this);
  },
  visit: function(visitor) {
    visitor.visitAwaitExpression(this);
  },
  get type() {
    return AWAIT_EXPRESSION;
  }
}, {}, ParseTree);
var BINARY_OPERATOR = ParseTreeType.BINARY_OPERATOR;
var BinaryOperator = function BinaryOperator(location, left, operator, right) {
  this.location = location;
  this.left = left;
  this.operator = operator;
  this.right = right;
};
($traceurRuntime.createClass)(BinaryOperator, {
  transform: function(transformer) {
    return transformer.transformBinaryOperator(this);
  },
  visit: function(visitor) {
    visitor.visitBinaryOperator(this);
  },
  get type() {
    return BINARY_OPERATOR;
  }
}, {}, ParseTree);
var BINDING_ELEMENT = ParseTreeType.BINDING_ELEMENT;
var BindingElement = function BindingElement(location, binding, initializer) {
  this.location = location;
  this.binding = binding;
  this.initializer = initializer;
};
($traceurRuntime.createClass)(BindingElement, {
  transform: function(transformer) {
    return transformer.transformBindingElement(this);
  },
  visit: function(visitor) {
    visitor.visitBindingElement(this);
  },
  get type() {
    return BINDING_ELEMENT;
  }
}, {}, ParseTree);
var BINDING_IDENTIFIER = ParseTreeType.BINDING_IDENTIFIER;
var BindingIdentifier = function BindingIdentifier(location, identifierToken) {
  this.location = location;
  this.identifierToken = identifierToken;
};
($traceurRuntime.createClass)(BindingIdentifier, {
  transform: function(transformer) {
    return transformer.transformBindingIdentifier(this);
  },
  visit: function(visitor) {
    visitor.visitBindingIdentifier(this);
  },
  get type() {
    return BINDING_IDENTIFIER;
  }
}, {}, ParseTree);
var BLOCK = ParseTreeType.BLOCK;
var Block = function Block(location, statements) {
  this.location = location;
  this.statements = statements;
};
($traceurRuntime.createClass)(Block, {
  transform: function(transformer) {
    return transformer.transformBlock(this);
  },
  visit: function(visitor) {
    visitor.visitBlock(this);
  },
  get type() {
    return BLOCK;
  }
}, {}, ParseTree);
var BREAK_STATEMENT = ParseTreeType.BREAK_STATEMENT;
var BreakStatement = function BreakStatement(location, name) {
  this.location = location;
  this.name = name;
};
($traceurRuntime.createClass)(BreakStatement, {
  transform: function(transformer) {
    return transformer.transformBreakStatement(this);
  },
  visit: function(visitor) {
    visitor.visitBreakStatement(this);
  },
  get type() {
    return BREAK_STATEMENT;
  }
}, {}, ParseTree);
var CALL_EXPRESSION = ParseTreeType.CALL_EXPRESSION;
var CallExpression = function CallExpression(location, operand, args) {
  this.location = location;
  this.operand = operand;
  this.args = args;
};
($traceurRuntime.createClass)(CallExpression, {
  transform: function(transformer) {
    return transformer.transformCallExpression(this);
  },
  visit: function(visitor) {
    visitor.visitCallExpression(this);
  },
  get type() {
    return CALL_EXPRESSION;
  }
}, {}, ParseTree);
var CASE_CLAUSE = ParseTreeType.CASE_CLAUSE;
var CaseClause = function CaseClause(location, expression, statements) {
  this.location = location;
  this.expression = expression;
  this.statements = statements;
};
($traceurRuntime.createClass)(CaseClause, {
  transform: function(transformer) {
    return transformer.transformCaseClause(this);
  },
  visit: function(visitor) {
    visitor.visitCaseClause(this);
  },
  get type() {
    return CASE_CLAUSE;
  }
}, {}, ParseTree);
var CATCH = ParseTreeType.CATCH;
var Catch = function Catch(location, binding, catchBody) {
  this.location = location;
  this.binding = binding;
  this.catchBody = catchBody;
};
($traceurRuntime.createClass)(Catch, {
  transform: function(transformer) {
    return transformer.transformCatch(this);
  },
  visit: function(visitor) {
    visitor.visitCatch(this);
  },
  get type() {
    return CATCH;
  }
}, {}, ParseTree);
var CLASS_DECLARATION = ParseTreeType.CLASS_DECLARATION;
var ClassDeclaration = function ClassDeclaration(location, name, superClass, elements, annotations) {
  this.location = location;
  this.name = name;
  this.superClass = superClass;
  this.elements = elements;
  this.annotations = annotations;
};
($traceurRuntime.createClass)(ClassDeclaration, {
  transform: function(transformer) {
    return transformer.transformClassDeclaration(this);
  },
  visit: function(visitor) {
    visitor.visitClassDeclaration(this);
  },
  get type() {
    return CLASS_DECLARATION;
  }
}, {}, ParseTree);
var CLASS_EXPRESSION = ParseTreeType.CLASS_EXPRESSION;
var ClassExpression = function ClassExpression(location, name, superClass, elements, annotations) {
  this.location = location;
  this.name = name;
  this.superClass = superClass;
  this.elements = elements;
  this.annotations = annotations;
};
($traceurRuntime.createClass)(ClassExpression, {
  transform: function(transformer) {
    return transformer.transformClassExpression(this);
  },
  visit: function(visitor) {
    visitor.visitClassExpression(this);
  },
  get type() {
    return CLASS_EXPRESSION;
  }
}, {}, ParseTree);
var COMMA_EXPRESSION = ParseTreeType.COMMA_EXPRESSION;
var CommaExpression = function CommaExpression(location, expressions) {
  this.location = location;
  this.expressions = expressions;
};
($traceurRuntime.createClass)(CommaExpression, {
  transform: function(transformer) {
    return transformer.transformCommaExpression(this);
  },
  visit: function(visitor) {
    visitor.visitCommaExpression(this);
  },
  get type() {
    return COMMA_EXPRESSION;
  }
}, {}, ParseTree);
var COMPREHENSION_FOR = ParseTreeType.COMPREHENSION_FOR;
var ComprehensionFor = function ComprehensionFor(location, left, iterator) {
  this.location = location;
  this.left = left;
  this.iterator = iterator;
};
($traceurRuntime.createClass)(ComprehensionFor, {
  transform: function(transformer) {
    return transformer.transformComprehensionFor(this);
  },
  visit: function(visitor) {
    visitor.visitComprehensionFor(this);
  },
  get type() {
    return COMPREHENSION_FOR;
  }
}, {}, ParseTree);
var COMPREHENSION_IF = ParseTreeType.COMPREHENSION_IF;
var ComprehensionIf = function ComprehensionIf(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(ComprehensionIf, {
  transform: function(transformer) {
    return transformer.transformComprehensionIf(this);
  },
  visit: function(visitor) {
    visitor.visitComprehensionIf(this);
  },
  get type() {
    return COMPREHENSION_IF;
  }
}, {}, ParseTree);
var COMPUTED_PROPERTY_NAME = ParseTreeType.COMPUTED_PROPERTY_NAME;
var ComputedPropertyName = function ComputedPropertyName(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(ComputedPropertyName, {
  transform: function(transformer) {
    return transformer.transformComputedPropertyName(this);
  },
  visit: function(visitor) {
    visitor.visitComputedPropertyName(this);
  },
  get type() {
    return COMPUTED_PROPERTY_NAME;
  }
}, {}, ParseTree);
var CONDITIONAL_EXPRESSION = ParseTreeType.CONDITIONAL_EXPRESSION;
var ConditionalExpression = function ConditionalExpression(location, condition, left, right) {
  this.location = location;
  this.condition = condition;
  this.left = left;
  this.right = right;
};
($traceurRuntime.createClass)(ConditionalExpression, {
  transform: function(transformer) {
    return transformer.transformConditionalExpression(this);
  },
  visit: function(visitor) {
    visitor.visitConditionalExpression(this);
  },
  get type() {
    return CONDITIONAL_EXPRESSION;
  }
}, {}, ParseTree);
var CONTINUE_STATEMENT = ParseTreeType.CONTINUE_STATEMENT;
var ContinueStatement = function ContinueStatement(location, name) {
  this.location = location;
  this.name = name;
};
($traceurRuntime.createClass)(ContinueStatement, {
  transform: function(transformer) {
    return transformer.transformContinueStatement(this);
  },
  visit: function(visitor) {
    visitor.visitContinueStatement(this);
  },
  get type() {
    return CONTINUE_STATEMENT;
  }
}, {}, ParseTree);
var COVER_FORMALS = ParseTreeType.COVER_FORMALS;
var CoverFormals = function CoverFormals(location, expressions) {
  this.location = location;
  this.expressions = expressions;
};
($traceurRuntime.createClass)(CoverFormals, {
  transform: function(transformer) {
    return transformer.transformCoverFormals(this);
  },
  visit: function(visitor) {
    visitor.visitCoverFormals(this);
  },
  get type() {
    return COVER_FORMALS;
  }
}, {}, ParseTree);
var COVER_INITIALISED_NAME = ParseTreeType.COVER_INITIALISED_NAME;
var CoverInitialisedName = function CoverInitialisedName(location, name, equalToken, initializer) {
  this.location = location;
  this.name = name;
  this.equalToken = equalToken;
  this.initializer = initializer;
};
($traceurRuntime.createClass)(CoverInitialisedName, {
  transform: function(transformer) {
    return transformer.transformCoverInitialisedName(this);
  },
  visit: function(visitor) {
    visitor.visitCoverInitialisedName(this);
  },
  get type() {
    return COVER_INITIALISED_NAME;
  }
}, {}, ParseTree);
var DEBUGGER_STATEMENT = ParseTreeType.DEBUGGER_STATEMENT;
var DebuggerStatement = function DebuggerStatement(location) {
  this.location = location;
};
($traceurRuntime.createClass)(DebuggerStatement, {
  transform: function(transformer) {
    return transformer.transformDebuggerStatement(this);
  },
  visit: function(visitor) {
    visitor.visitDebuggerStatement(this);
  },
  get type() {
    return DEBUGGER_STATEMENT;
  }
}, {}, ParseTree);
var DEFAULT_CLAUSE = ParseTreeType.DEFAULT_CLAUSE;
var DefaultClause = function DefaultClause(location, statements) {
  this.location = location;
  this.statements = statements;
};
($traceurRuntime.createClass)(DefaultClause, {
  transform: function(transformer) {
    return transformer.transformDefaultClause(this);
  },
  visit: function(visitor) {
    visitor.visitDefaultClause(this);
  },
  get type() {
    return DEFAULT_CLAUSE;
  }
}, {}, ParseTree);
var DO_WHILE_STATEMENT = ParseTreeType.DO_WHILE_STATEMENT;
var DoWhileStatement = function DoWhileStatement(location, body, condition) {
  this.location = location;
  this.body = body;
  this.condition = condition;
};
($traceurRuntime.createClass)(DoWhileStatement, {
  transform: function(transformer) {
    return transformer.transformDoWhileStatement(this);
  },
  visit: function(visitor) {
    visitor.visitDoWhileStatement(this);
  },
  get type() {
    return DO_WHILE_STATEMENT;
  }
}, {}, ParseTree);
var EMPTY_STATEMENT = ParseTreeType.EMPTY_STATEMENT;
var EmptyStatement = function EmptyStatement(location) {
  this.location = location;
};
($traceurRuntime.createClass)(EmptyStatement, {
  transform: function(transformer) {
    return transformer.transformEmptyStatement(this);
  },
  visit: function(visitor) {
    visitor.visitEmptyStatement(this);
  },
  get type() {
    return EMPTY_STATEMENT;
  }
}, {}, ParseTree);
var EXPORT_DECLARATION = ParseTreeType.EXPORT_DECLARATION;
var ExportDeclaration = function ExportDeclaration(location, declaration, annotations) {
  this.location = location;
  this.declaration = declaration;
  this.annotations = annotations;
};
($traceurRuntime.createClass)(ExportDeclaration, {
  transform: function(transformer) {
    return transformer.transformExportDeclaration(this);
  },
  visit: function(visitor) {
    visitor.visitExportDeclaration(this);
  },
  get type() {
    return EXPORT_DECLARATION;
  }
}, {}, ParseTree);
var EXPORT_DEFAULT = ParseTreeType.EXPORT_DEFAULT;
var ExportDefault = function ExportDefault(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(ExportDefault, {
  transform: function(transformer) {
    return transformer.transformExportDefault(this);
  },
  visit: function(visitor) {
    visitor.visitExportDefault(this);
  },
  get type() {
    return EXPORT_DEFAULT;
  }
}, {}, ParseTree);
var EXPORT_SPECIFIER = ParseTreeType.EXPORT_SPECIFIER;
var ExportSpecifier = function ExportSpecifier(location, lhs, rhs) {
  this.location = location;
  this.lhs = lhs;
  this.rhs = rhs;
};
($traceurRuntime.createClass)(ExportSpecifier, {
  transform: function(transformer) {
    return transformer.transformExportSpecifier(this);
  },
  visit: function(visitor) {
    visitor.visitExportSpecifier(this);
  },
  get type() {
    return EXPORT_SPECIFIER;
  }
}, {}, ParseTree);
var EXPORT_SPECIFIER_SET = ParseTreeType.EXPORT_SPECIFIER_SET;
var ExportSpecifierSet = function ExportSpecifierSet(location, specifiers) {
  this.location = location;
  this.specifiers = specifiers;
};
($traceurRuntime.createClass)(ExportSpecifierSet, {
  transform: function(transformer) {
    return transformer.transformExportSpecifierSet(this);
  },
  visit: function(visitor) {
    visitor.visitExportSpecifierSet(this);
  },
  get type() {
    return EXPORT_SPECIFIER_SET;
  }
}, {}, ParseTree);
var EXPORT_STAR = ParseTreeType.EXPORT_STAR;
var ExportStar = function ExportStar(location) {
  this.location = location;
};
($traceurRuntime.createClass)(ExportStar, {
  transform: function(transformer) {
    return transformer.transformExportStar(this);
  },
  visit: function(visitor) {
    visitor.visitExportStar(this);
  },
  get type() {
    return EXPORT_STAR;
  }
}, {}, ParseTree);
var EXPRESSION_STATEMENT = ParseTreeType.EXPRESSION_STATEMENT;
var ExpressionStatement = function ExpressionStatement(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(ExpressionStatement, {
  transform: function(transformer) {
    return transformer.transformExpressionStatement(this);
  },
  visit: function(visitor) {
    visitor.visitExpressionStatement(this);
  },
  get type() {
    return EXPRESSION_STATEMENT;
  }
}, {}, ParseTree);
var FINALLY = ParseTreeType.FINALLY;
var Finally = function Finally(location, block) {
  this.location = location;
  this.block = block;
};
($traceurRuntime.createClass)(Finally, {
  transform: function(transformer) {
    return transformer.transformFinally(this);
  },
  visit: function(visitor) {
    visitor.visitFinally(this);
  },
  get type() {
    return FINALLY;
  }
}, {}, ParseTree);
var FOR_IN_STATEMENT = ParseTreeType.FOR_IN_STATEMENT;
var ForInStatement = function ForInStatement(location, initializer, collection, body) {
  this.location = location;
  this.initializer = initializer;
  this.collection = collection;
  this.body = body;
};
($traceurRuntime.createClass)(ForInStatement, {
  transform: function(transformer) {
    return transformer.transformForInStatement(this);
  },
  visit: function(visitor) {
    visitor.visitForInStatement(this);
  },
  get type() {
    return FOR_IN_STATEMENT;
  }
}, {}, ParseTree);
var FOR_OF_STATEMENT = ParseTreeType.FOR_OF_STATEMENT;
var ForOfStatement = function ForOfStatement(location, initializer, collection, body) {
  this.location = location;
  this.initializer = initializer;
  this.collection = collection;
  this.body = body;
};
($traceurRuntime.createClass)(ForOfStatement, {
  transform: function(transformer) {
    return transformer.transformForOfStatement(this);
  },
  visit: function(visitor) {
    visitor.visitForOfStatement(this);
  },
  get type() {
    return FOR_OF_STATEMENT;
  }
}, {}, ParseTree);
var FOR_STATEMENT = ParseTreeType.FOR_STATEMENT;
var ForStatement = function ForStatement(location, initializer, condition, increment, body) {
  this.location = location;
  this.initializer = initializer;
  this.condition = condition;
  this.increment = increment;
  this.body = body;
};
($traceurRuntime.createClass)(ForStatement, {
  transform: function(transformer) {
    return transformer.transformForStatement(this);
  },
  visit: function(visitor) {
    visitor.visitForStatement(this);
  },
  get type() {
    return FOR_STATEMENT;
  }
}, {}, ParseTree);
var FORMAL_PARAMETER = ParseTreeType.FORMAL_PARAMETER;
var FormalParameter = function FormalParameter(location, parameter, typeAnnotation, annotations) {
  this.location = location;
  this.parameter = parameter;
  this.typeAnnotation = typeAnnotation;
  this.annotations = annotations;
};
($traceurRuntime.createClass)(FormalParameter, {
  transform: function(transformer) {
    return transformer.transformFormalParameter(this);
  },
  visit: function(visitor) {
    visitor.visitFormalParameter(this);
  },
  get type() {
    return FORMAL_PARAMETER;
  }
}, {}, ParseTree);
var FORMAL_PARAMETER_LIST = ParseTreeType.FORMAL_PARAMETER_LIST;
var FormalParameterList = function FormalParameterList(location, parameters) {
  this.location = location;
  this.parameters = parameters;
};
($traceurRuntime.createClass)(FormalParameterList, {
  transform: function(transformer) {
    return transformer.transformFormalParameterList(this);
  },
  visit: function(visitor) {
    visitor.visitFormalParameterList(this);
  },
  get type() {
    return FORMAL_PARAMETER_LIST;
  }
}, {}, ParseTree);
var FUNCTION_BODY = ParseTreeType.FUNCTION_BODY;
var FunctionBody = function FunctionBody(location, statements) {
  this.location = location;
  this.statements = statements;
};
($traceurRuntime.createClass)(FunctionBody, {
  transform: function(transformer) {
    return transformer.transformFunctionBody(this);
  },
  visit: function(visitor) {
    visitor.visitFunctionBody(this);
  },
  get type() {
    return FUNCTION_BODY;
  }
}, {}, ParseTree);
var FUNCTION_DECLARATION = ParseTreeType.FUNCTION_DECLARATION;
var FunctionDeclaration = function FunctionDeclaration(location, name, functionKind, parameterList, typeAnnotation, annotations, functionBody) {
  this.location = location;
  this.name = name;
  this.functionKind = functionKind;
  this.parameterList = parameterList;
  this.typeAnnotation = typeAnnotation;
  this.annotations = annotations;
  this.functionBody = functionBody;
};
($traceurRuntime.createClass)(FunctionDeclaration, {
  transform: function(transformer) {
    return transformer.transformFunctionDeclaration(this);
  },
  visit: function(visitor) {
    visitor.visitFunctionDeclaration(this);
  },
  get type() {
    return FUNCTION_DECLARATION;
  }
}, {}, ParseTree);
var FUNCTION_EXPRESSION = ParseTreeType.FUNCTION_EXPRESSION;
var FunctionExpression = function FunctionExpression(location, name, functionKind, parameterList, typeAnnotation, annotations, functionBody) {
  this.location = location;
  this.name = name;
  this.functionKind = functionKind;
  this.parameterList = parameterList;
  this.typeAnnotation = typeAnnotation;
  this.annotations = annotations;
  this.functionBody = functionBody;
};
($traceurRuntime.createClass)(FunctionExpression, {
  transform: function(transformer) {
    return transformer.transformFunctionExpression(this);
  },
  visit: function(visitor) {
    visitor.visitFunctionExpression(this);
  },
  get type() {
    return FUNCTION_EXPRESSION;
  }
}, {}, ParseTree);
var GENERATOR_COMPREHENSION = ParseTreeType.GENERATOR_COMPREHENSION;
var GeneratorComprehension = function GeneratorComprehension(location, comprehensionList, expression) {
  this.location = location;
  this.comprehensionList = comprehensionList;
  this.expression = expression;
};
($traceurRuntime.createClass)(GeneratorComprehension, {
  transform: function(transformer) {
    return transformer.transformGeneratorComprehension(this);
  },
  visit: function(visitor) {
    visitor.visitGeneratorComprehension(this);
  },
  get type() {
    return GENERATOR_COMPREHENSION;
  }
}, {}, ParseTree);
var GET_ACCESSOR = ParseTreeType.GET_ACCESSOR;
var GetAccessor = function GetAccessor(location, isStatic, name, typeAnnotation, annotations, body) {
  this.location = location;
  this.isStatic = isStatic;
  this.name = name;
  this.typeAnnotation = typeAnnotation;
  this.annotations = annotations;
  this.body = body;
};
($traceurRuntime.createClass)(GetAccessor, {
  transform: function(transformer) {
    return transformer.transformGetAccessor(this);
  },
  visit: function(visitor) {
    visitor.visitGetAccessor(this);
  },
  get type() {
    return GET_ACCESSOR;
  }
}, {}, ParseTree);
var IDENTIFIER_EXPRESSION = ParseTreeType.IDENTIFIER_EXPRESSION;
var IdentifierExpression = function IdentifierExpression(location, identifierToken) {
  this.location = location;
  this.identifierToken = identifierToken;
};
($traceurRuntime.createClass)(IdentifierExpression, {
  transform: function(transformer) {
    return transformer.transformIdentifierExpression(this);
  },
  visit: function(visitor) {
    visitor.visitIdentifierExpression(this);
  },
  get type() {
    return IDENTIFIER_EXPRESSION;
  }
}, {}, ParseTree);
var IF_STATEMENT = ParseTreeType.IF_STATEMENT;
var IfStatement = function IfStatement(location, condition, ifClause, elseClause) {
  this.location = location;
  this.condition = condition;
  this.ifClause = ifClause;
  this.elseClause = elseClause;
};
($traceurRuntime.createClass)(IfStatement, {
  transform: function(transformer) {
    return transformer.transformIfStatement(this);
  },
  visit: function(visitor) {
    visitor.visitIfStatement(this);
  },
  get type() {
    return IF_STATEMENT;
  }
}, {}, ParseTree);
var IMPORTED_BINDING = ParseTreeType.IMPORTED_BINDING;
var ImportedBinding = function ImportedBinding(location, binding) {
  this.location = location;
  this.binding = binding;
};
($traceurRuntime.createClass)(ImportedBinding, {
  transform: function(transformer) {
    return transformer.transformImportedBinding(this);
  },
  visit: function(visitor) {
    visitor.visitImportedBinding(this);
  },
  get type() {
    return IMPORTED_BINDING;
  }
}, {}, ParseTree);
var IMPORT_DECLARATION = ParseTreeType.IMPORT_DECLARATION;
var ImportDeclaration = function ImportDeclaration(location, importClause, moduleSpecifier) {
  this.location = location;
  this.importClause = importClause;
  this.moduleSpecifier = moduleSpecifier;
};
($traceurRuntime.createClass)(ImportDeclaration, {
  transform: function(transformer) {
    return transformer.transformImportDeclaration(this);
  },
  visit: function(visitor) {
    visitor.visitImportDeclaration(this);
  },
  get type() {
    return IMPORT_DECLARATION;
  }
}, {}, ParseTree);
var IMPORT_SPECIFIER = ParseTreeType.IMPORT_SPECIFIER;
var ImportSpecifier = function ImportSpecifier(location, lhs, rhs) {
  this.location = location;
  this.lhs = lhs;
  this.rhs = rhs;
};
($traceurRuntime.createClass)(ImportSpecifier, {
  transform: function(transformer) {
    return transformer.transformImportSpecifier(this);
  },
  visit: function(visitor) {
    visitor.visitImportSpecifier(this);
  },
  get type() {
    return IMPORT_SPECIFIER;
  }
}, {}, ParseTree);
var IMPORT_SPECIFIER_SET = ParseTreeType.IMPORT_SPECIFIER_SET;
var ImportSpecifierSet = function ImportSpecifierSet(location, specifiers) {
  this.location = location;
  this.specifiers = specifiers;
};
($traceurRuntime.createClass)(ImportSpecifierSet, {
  transform: function(transformer) {
    return transformer.transformImportSpecifierSet(this);
  },
  visit: function(visitor) {
    visitor.visitImportSpecifierSet(this);
  },
  get type() {
    return IMPORT_SPECIFIER_SET;
  }
}, {}, ParseTree);
var LABELLED_STATEMENT = ParseTreeType.LABELLED_STATEMENT;
var LabelledStatement = function LabelledStatement(location, name, statement) {
  this.location = location;
  this.name = name;
  this.statement = statement;
};
($traceurRuntime.createClass)(LabelledStatement, {
  transform: function(transformer) {
    return transformer.transformLabelledStatement(this);
  },
  visit: function(visitor) {
    visitor.visitLabelledStatement(this);
  },
  get type() {
    return LABELLED_STATEMENT;
  }
}, {}, ParseTree);
var LITERAL_EXPRESSION = ParseTreeType.LITERAL_EXPRESSION;
var LiteralExpression = function LiteralExpression(location, literalToken) {
  this.location = location;
  this.literalToken = literalToken;
};
($traceurRuntime.createClass)(LiteralExpression, {
  transform: function(transformer) {
    return transformer.transformLiteralExpression(this);
  },
  visit: function(visitor) {
    visitor.visitLiteralExpression(this);
  },
  get type() {
    return LITERAL_EXPRESSION;
  }
}, {}, ParseTree);
var LITERAL_PROPERTY_NAME = ParseTreeType.LITERAL_PROPERTY_NAME;
var LiteralPropertyName = function LiteralPropertyName(location, literalToken) {
  this.location = location;
  this.literalToken = literalToken;
};
($traceurRuntime.createClass)(LiteralPropertyName, {
  transform: function(transformer) {
    return transformer.transformLiteralPropertyName(this);
  },
  visit: function(visitor) {
    visitor.visitLiteralPropertyName(this);
  },
  get type() {
    return LITERAL_PROPERTY_NAME;
  }
}, {}, ParseTree);
var MEMBER_EXPRESSION = ParseTreeType.MEMBER_EXPRESSION;
var MemberExpression = function MemberExpression(location, operand, memberName) {
  this.location = location;
  this.operand = operand;
  this.memberName = memberName;
};
($traceurRuntime.createClass)(MemberExpression, {
  transform: function(transformer) {
    return transformer.transformMemberExpression(this);
  },
  visit: function(visitor) {
    visitor.visitMemberExpression(this);
  },
  get type() {
    return MEMBER_EXPRESSION;
  }
}, {}, ParseTree);
var MEMBER_LOOKUP_EXPRESSION = ParseTreeType.MEMBER_LOOKUP_EXPRESSION;
var MemberLookupExpression = function MemberLookupExpression(location, operand, memberExpression) {
  this.location = location;
  this.operand = operand;
  this.memberExpression = memberExpression;
};
($traceurRuntime.createClass)(MemberLookupExpression, {
  transform: function(transformer) {
    return transformer.transformMemberLookupExpression(this);
  },
  visit: function(visitor) {
    visitor.visitMemberLookupExpression(this);
  },
  get type() {
    return MEMBER_LOOKUP_EXPRESSION;
  }
}, {}, ParseTree);
var MODULE = ParseTreeType.MODULE;
var Module = function Module(location, scriptItemList, moduleName) {
  this.location = location;
  this.scriptItemList = scriptItemList;
  this.moduleName = moduleName;
};
($traceurRuntime.createClass)(Module, {
  transform: function(transformer) {
    return transformer.transformModule(this);
  },
  visit: function(visitor) {
    visitor.visitModule(this);
  },
  get type() {
    return MODULE;
  }
}, {}, ParseTree);
var MODULE_DECLARATION = ParseTreeType.MODULE_DECLARATION;
var ModuleDeclaration = function ModuleDeclaration(location, identifier, expression) {
  this.location = location;
  this.identifier = identifier;
  this.expression = expression;
};
($traceurRuntime.createClass)(ModuleDeclaration, {
  transform: function(transformer) {
    return transformer.transformModuleDeclaration(this);
  },
  visit: function(visitor) {
    visitor.visitModuleDeclaration(this);
  },
  get type() {
    return MODULE_DECLARATION;
  }
}, {}, ParseTree);
var MODULE_SPECIFIER = ParseTreeType.MODULE_SPECIFIER;
var ModuleSpecifier = function ModuleSpecifier(location, token) {
  this.location = location;
  this.token = token;
};
($traceurRuntime.createClass)(ModuleSpecifier, {
  transform: function(transformer) {
    return transformer.transformModuleSpecifier(this);
  },
  visit: function(visitor) {
    visitor.visitModuleSpecifier(this);
  },
  get type() {
    return MODULE_SPECIFIER;
  }
}, {}, ParseTree);
var NAMED_EXPORT = ParseTreeType.NAMED_EXPORT;
var NamedExport = function NamedExport(location, moduleSpecifier, specifierSet) {
  this.location = location;
  this.moduleSpecifier = moduleSpecifier;
  this.specifierSet = specifierSet;
};
($traceurRuntime.createClass)(NamedExport, {
  transform: function(transformer) {
    return transformer.transformNamedExport(this);
  },
  visit: function(visitor) {
    visitor.visitNamedExport(this);
  },
  get type() {
    return NAMED_EXPORT;
  }
}, {}, ParseTree);
var NEW_EXPRESSION = ParseTreeType.NEW_EXPRESSION;
var NewExpression = function NewExpression(location, operand, args) {
  this.location = location;
  this.operand = operand;
  this.args = args;
};
($traceurRuntime.createClass)(NewExpression, {
  transform: function(transformer) {
    return transformer.transformNewExpression(this);
  },
  visit: function(visitor) {
    visitor.visitNewExpression(this);
  },
  get type() {
    return NEW_EXPRESSION;
  }
}, {}, ParseTree);
var OBJECT_LITERAL_EXPRESSION = ParseTreeType.OBJECT_LITERAL_EXPRESSION;
var ObjectLiteralExpression = function ObjectLiteralExpression(location, propertyNameAndValues) {
  this.location = location;
  this.propertyNameAndValues = propertyNameAndValues;
};
($traceurRuntime.createClass)(ObjectLiteralExpression, {
  transform: function(transformer) {
    return transformer.transformObjectLiteralExpression(this);
  },
  visit: function(visitor) {
    visitor.visitObjectLiteralExpression(this);
  },
  get type() {
    return OBJECT_LITERAL_EXPRESSION;
  }
}, {}, ParseTree);
var OBJECT_PATTERN = ParseTreeType.OBJECT_PATTERN;
var ObjectPattern = function ObjectPattern(location, fields) {
  this.location = location;
  this.fields = fields;
};
($traceurRuntime.createClass)(ObjectPattern, {
  transform: function(transformer) {
    return transformer.transformObjectPattern(this);
  },
  visit: function(visitor) {
    visitor.visitObjectPattern(this);
  },
  get type() {
    return OBJECT_PATTERN;
  }
}, {}, ParseTree);
var OBJECT_PATTERN_FIELD = ParseTreeType.OBJECT_PATTERN_FIELD;
var ObjectPatternField = function ObjectPatternField(location, name, element) {
  this.location = location;
  this.name = name;
  this.element = element;
};
($traceurRuntime.createClass)(ObjectPatternField, {
  transform: function(transformer) {
    return transformer.transformObjectPatternField(this);
  },
  visit: function(visitor) {
    visitor.visitObjectPatternField(this);
  },
  get type() {
    return OBJECT_PATTERN_FIELD;
  }
}, {}, ParseTree);
var PAREN_EXPRESSION = ParseTreeType.PAREN_EXPRESSION;
var ParenExpression = function ParenExpression(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(ParenExpression, {
  transform: function(transformer) {
    return transformer.transformParenExpression(this);
  },
  visit: function(visitor) {
    visitor.visitParenExpression(this);
  },
  get type() {
    return PAREN_EXPRESSION;
  }
}, {}, ParseTree);
var POSTFIX_EXPRESSION = ParseTreeType.POSTFIX_EXPRESSION;
var PostfixExpression = function PostfixExpression(location, operand, operator) {
  this.location = location;
  this.operand = operand;
  this.operator = operator;
};
($traceurRuntime.createClass)(PostfixExpression, {
  transform: function(transformer) {
    return transformer.transformPostfixExpression(this);
  },
  visit: function(visitor) {
    visitor.visitPostfixExpression(this);
  },
  get type() {
    return POSTFIX_EXPRESSION;
  }
}, {}, ParseTree);
var PREDEFINED_TYPE = ParseTreeType.PREDEFINED_TYPE;
var PredefinedType = function PredefinedType(location, typeToken) {
  this.location = location;
  this.typeToken = typeToken;
};
($traceurRuntime.createClass)(PredefinedType, {
  transform: function(transformer) {
    return transformer.transformPredefinedType(this);
  },
  visit: function(visitor) {
    visitor.visitPredefinedType(this);
  },
  get type() {
    return PREDEFINED_TYPE;
  }
}, {}, ParseTree);
var SCRIPT = ParseTreeType.SCRIPT;
var Script = function Script(location, scriptItemList, moduleName) {
  this.location = location;
  this.scriptItemList = scriptItemList;
  this.moduleName = moduleName;
};
($traceurRuntime.createClass)(Script, {
  transform: function(transformer) {
    return transformer.transformScript(this);
  },
  visit: function(visitor) {
    visitor.visitScript(this);
  },
  get type() {
    return SCRIPT;
  }
}, {}, ParseTree);
var PROPERTY_METHOD_ASSIGNMENT = ParseTreeType.PROPERTY_METHOD_ASSIGNMENT;
var PropertyMethodAssignment = function PropertyMethodAssignment(location, isStatic, functionKind, name, parameterList, typeAnnotation, annotations, functionBody) {
  this.location = location;
  this.isStatic = isStatic;
  this.functionKind = functionKind;
  this.name = name;
  this.parameterList = parameterList;
  this.typeAnnotation = typeAnnotation;
  this.annotations = annotations;
  this.functionBody = functionBody;
};
($traceurRuntime.createClass)(PropertyMethodAssignment, {
  transform: function(transformer) {
    return transformer.transformPropertyMethodAssignment(this);
  },
  visit: function(visitor) {
    visitor.visitPropertyMethodAssignment(this);
  },
  get type() {
    return PROPERTY_METHOD_ASSIGNMENT;
  }
}, {}, ParseTree);
var PROPERTY_NAME_ASSIGNMENT = ParseTreeType.PROPERTY_NAME_ASSIGNMENT;
var PropertyNameAssignment = function PropertyNameAssignment(location, name, value) {
  this.location = location;
  this.name = name;
  this.value = value;
};
($traceurRuntime.createClass)(PropertyNameAssignment, {
  transform: function(transformer) {
    return transformer.transformPropertyNameAssignment(this);
  },
  visit: function(visitor) {
    visitor.visitPropertyNameAssignment(this);
  },
  get type() {
    return PROPERTY_NAME_ASSIGNMENT;
  }
}, {}, ParseTree);
var PROPERTY_NAME_SHORTHAND = ParseTreeType.PROPERTY_NAME_SHORTHAND;
var PropertyNameShorthand = function PropertyNameShorthand(location, name) {
  this.location = location;
  this.name = name;
};
($traceurRuntime.createClass)(PropertyNameShorthand, {
  transform: function(transformer) {
    return transformer.transformPropertyNameShorthand(this);
  },
  visit: function(visitor) {
    visitor.visitPropertyNameShorthand(this);
  },
  get type() {
    return PROPERTY_NAME_SHORTHAND;
  }
}, {}, ParseTree);
var REST_PARAMETER = ParseTreeType.REST_PARAMETER;
var RestParameter = function RestParameter(location, identifier) {
  this.location = location;
  this.identifier = identifier;
};
($traceurRuntime.createClass)(RestParameter, {
  transform: function(transformer) {
    return transformer.transformRestParameter(this);
  },
  visit: function(visitor) {
    visitor.visitRestParameter(this);
  },
  get type() {
    return REST_PARAMETER;
  }
}, {}, ParseTree);
var RETURN_STATEMENT = ParseTreeType.RETURN_STATEMENT;
var ReturnStatement = function ReturnStatement(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(ReturnStatement, {
  transform: function(transformer) {
    return transformer.transformReturnStatement(this);
  },
  visit: function(visitor) {
    visitor.visitReturnStatement(this);
  },
  get type() {
    return RETURN_STATEMENT;
  }
}, {}, ParseTree);
var SET_ACCESSOR = ParseTreeType.SET_ACCESSOR;
var SetAccessor = function SetAccessor(location, isStatic, name, parameterList, annotations, body) {
  this.location = location;
  this.isStatic = isStatic;
  this.name = name;
  this.parameterList = parameterList;
  this.annotations = annotations;
  this.body = body;
};
($traceurRuntime.createClass)(SetAccessor, {
  transform: function(transformer) {
    return transformer.transformSetAccessor(this);
  },
  visit: function(visitor) {
    visitor.visitSetAccessor(this);
  },
  get type() {
    return SET_ACCESSOR;
  }
}, {}, ParseTree);
var SPREAD_EXPRESSION = ParseTreeType.SPREAD_EXPRESSION;
var SpreadExpression = function SpreadExpression(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(SpreadExpression, {
  transform: function(transformer) {
    return transformer.transformSpreadExpression(this);
  },
  visit: function(visitor) {
    visitor.visitSpreadExpression(this);
  },
  get type() {
    return SPREAD_EXPRESSION;
  }
}, {}, ParseTree);
var SPREAD_PATTERN_ELEMENT = ParseTreeType.SPREAD_PATTERN_ELEMENT;
var SpreadPatternElement = function SpreadPatternElement(location, lvalue) {
  this.location = location;
  this.lvalue = lvalue;
};
($traceurRuntime.createClass)(SpreadPatternElement, {
  transform: function(transformer) {
    return transformer.transformSpreadPatternElement(this);
  },
  visit: function(visitor) {
    visitor.visitSpreadPatternElement(this);
  },
  get type() {
    return SPREAD_PATTERN_ELEMENT;
  }
}, {}, ParseTree);
var SUPER_EXPRESSION = ParseTreeType.SUPER_EXPRESSION;
var SuperExpression = function SuperExpression(location) {
  this.location = location;
};
($traceurRuntime.createClass)(SuperExpression, {
  transform: function(transformer) {
    return transformer.transformSuperExpression(this);
  },
  visit: function(visitor) {
    visitor.visitSuperExpression(this);
  },
  get type() {
    return SUPER_EXPRESSION;
  }
}, {}, ParseTree);
var SWITCH_STATEMENT = ParseTreeType.SWITCH_STATEMENT;
var SwitchStatement = function SwitchStatement(location, expression, caseClauses) {
  this.location = location;
  this.expression = expression;
  this.caseClauses = caseClauses;
};
($traceurRuntime.createClass)(SwitchStatement, {
  transform: function(transformer) {
    return transformer.transformSwitchStatement(this);
  },
  visit: function(visitor) {
    visitor.visitSwitchStatement(this);
  },
  get type() {
    return SWITCH_STATEMENT;
  }
}, {}, ParseTree);
var SYNTAX_ERROR_TREE = ParseTreeType.SYNTAX_ERROR_TREE;
var SyntaxErrorTree = function SyntaxErrorTree(location, nextToken, message) {
  this.location = location;
  this.nextToken = nextToken;
  this.message = message;
};
($traceurRuntime.createClass)(SyntaxErrorTree, {
  transform: function(transformer) {
    return transformer.transformSyntaxErrorTree(this);
  },
  visit: function(visitor) {
    visitor.visitSyntaxErrorTree(this);
  },
  get type() {
    return SYNTAX_ERROR_TREE;
  }
}, {}, ParseTree);
var TEMPLATE_LITERAL_EXPRESSION = ParseTreeType.TEMPLATE_LITERAL_EXPRESSION;
var TemplateLiteralExpression = function TemplateLiteralExpression(location, operand, elements) {
  this.location = location;
  this.operand = operand;
  this.elements = elements;
};
($traceurRuntime.createClass)(TemplateLiteralExpression, {
  transform: function(transformer) {
    return transformer.transformTemplateLiteralExpression(this);
  },
  visit: function(visitor) {
    visitor.visitTemplateLiteralExpression(this);
  },
  get type() {
    return TEMPLATE_LITERAL_EXPRESSION;
  }
}, {}, ParseTree);
var TEMPLATE_LITERAL_PORTION = ParseTreeType.TEMPLATE_LITERAL_PORTION;
var TemplateLiteralPortion = function TemplateLiteralPortion(location, value) {
  this.location = location;
  this.value = value;
};
($traceurRuntime.createClass)(TemplateLiteralPortion, {
  transform: function(transformer) {
    return transformer.transformTemplateLiteralPortion(this);
  },
  visit: function(visitor) {
    visitor.visitTemplateLiteralPortion(this);
  },
  get type() {
    return TEMPLATE_LITERAL_PORTION;
  }
}, {}, ParseTree);
var TEMPLATE_SUBSTITUTION = ParseTreeType.TEMPLATE_SUBSTITUTION;
var TemplateSubstitution = function TemplateSubstitution(location, expression) {
  this.location = location;
  this.expression = expression;
};
($traceurRuntime.createClass)(TemplateSubstitution, {
  transform: function(transformer) {
    return transformer.transformTemplateSubstitution(this);
  },
  visit: function(visitor) {
    visitor.visitTemplateSubstitution(this);
  },
  get type() {
    return TEMPLATE_SUBSTITUTION;
  }
}, {}, ParseTree);
var THIS_EXPRESSION = ParseTreeType.THIS_EXPRESSION;
var ThisExpression = function ThisExpression(location) {
  this.location = location;
};
($traceurRuntime.createClass)(ThisExpression, {
  transform: function(transformer) {
    return transformer.transformThisExpression(this);
  },
  visit: function(visitor) {
    visitor.visitThisExpression(this);
  },
  get type() {
    return THIS_EXPRESSION;
  }
}, {}, ParseTree);
var THROW_STATEMENT = ParseTreeType.THROW_STATEMENT;
var ThrowStatement = function ThrowStatement(location, value) {
  this.location = location;
  this.value = value;
};
($traceurRuntime.createClass)(ThrowStatement, {
  transform: function(transformer) {
    return transformer.transformThrowStatement(this);
  },
  visit: function(visitor) {
    visitor.visitThrowStatement(this);
  },
  get type() {
    return THROW_STATEMENT;
  }
}, {}, ParseTree);
var TRY_STATEMENT = ParseTreeType.TRY_STATEMENT;
var TryStatement = function TryStatement(location, body, catchBlock, finallyBlock) {
  this.location = location;
  this.body = body;
  this.catchBlock = catchBlock;
  this.finallyBlock = finallyBlock;
};
($traceurRuntime.createClass)(TryStatement, {
  transform: function(transformer) {
    return transformer.transformTryStatement(this);
  },
  visit: function(visitor) {
    visitor.visitTryStatement(this);
  },
  get type() {
    return TRY_STATEMENT;
  }
}, {}, ParseTree);
var TYPE_NAME = ParseTreeType.TYPE_NAME;
var TypeName = function TypeName(location, moduleName, name) {
  this.location = location;
  this.moduleName = moduleName;
  this.name = name;
};
($traceurRuntime.createClass)(TypeName, {
  transform: function(transformer) {
    return transformer.transformTypeName(this);
  },
  visit: function(visitor) {
    visitor.visitTypeName(this);
  },
  get type() {
    return TYPE_NAME;
  }
}, {}, ParseTree);
var UNARY_EXPRESSION = ParseTreeType.UNARY_EXPRESSION;
var UnaryExpression = function UnaryExpression(location, operator, operand) {
  this.location = location;
  this.operator = operator;
  this.operand = operand;
};
($traceurRuntime.createClass)(UnaryExpression, {
  transform: function(transformer) {
    return transformer.transformUnaryExpression(this);
  },
  visit: function(visitor) {
    visitor.visitUnaryExpression(this);
  },
  get type() {
    return UNARY_EXPRESSION;
  }
}, {}, ParseTree);
var VARIABLE_DECLARATION = ParseTreeType.VARIABLE_DECLARATION;
var VariableDeclaration = function VariableDeclaration(location, lvalue, typeAnnotation, initializer) {
  this.location = location;
  this.lvalue = lvalue;
  this.typeAnnotation = typeAnnotation;
  this.initializer = initializer;
};
($traceurRuntime.createClass)(VariableDeclaration, {
  transform: function(transformer) {
    return transformer.transformVariableDeclaration(this);
  },
  visit: function(visitor) {
    visitor.visitVariableDeclaration(this);
  },
  get type() {
    return VARIABLE_DECLARATION;
  }
}, {}, ParseTree);
var VARIABLE_DECLARATION_LIST = ParseTreeType.VARIABLE_DECLARATION_LIST;
var VariableDeclarationList = function VariableDeclarationList(location, declarationType, declarations) {
  this.location = location;
  this.declarationType = declarationType;
  this.declarations = declarations;
};
($traceurRuntime.createClass)(VariableDeclarationList, {
  transform: function(transformer) {
    return transformer.transformVariableDeclarationList(this);
  },
  visit: function(visitor) {
    visitor.visitVariableDeclarationList(this);
  },
  get type() {
    return VARIABLE_DECLARATION_LIST;
  }
}, {}, ParseTree);
var VARIABLE_STATEMENT = ParseTreeType.VARIABLE_STATEMENT;
var VariableStatement = function VariableStatement(location, declarations) {
  this.location = location;
  this.declarations = declarations;
};
($traceurRuntime.createClass)(VariableStatement, {
  transform: function(transformer) {
    return transformer.transformVariableStatement(this);
  },
  visit: function(visitor) {
    visitor.visitVariableStatement(this);
  },
  get type() {
    return VARIABLE_STATEMENT;
  }
}, {}, ParseTree);
var WHILE_STATEMENT = ParseTreeType.WHILE_STATEMENT;
var WhileStatement = function WhileStatement(location, condition, body) {
  this.location = location;
  this.condition = condition;
  this.body = body;
};
($traceurRuntime.createClass)(WhileStatement, {
  transform: function(transformer) {
    return transformer.transformWhileStatement(this);
  },
  visit: function(visitor) {
    visitor.visitWhileStatement(this);
  },
  get type() {
    return WHILE_STATEMENT;
  }
}, {}, ParseTree);
var WITH_STATEMENT = ParseTreeType.WITH_STATEMENT;
var WithStatement = function WithStatement(location, expression, body) {
  this.location = location;
  this.expression = expression;
  this.body = body;
};
($traceurRuntime.createClass)(WithStatement, {
  transform: function(transformer) {
    return transformer.transformWithStatement(this);
  },
  visit: function(visitor) {
    visitor.visitWithStatement(this);
  },
  get type() {
    return WITH_STATEMENT;
  }
}, {}, ParseTree);
var YIELD_EXPRESSION = ParseTreeType.YIELD_EXPRESSION;
var YieldExpression = function YieldExpression(location, expression, isYieldFor) {
  this.location = location;
  this.expression = expression;
  this.isYieldFor = isYieldFor;
};
($traceurRuntime.createClass)(YieldExpression, {
  transform: function(transformer) {
    return transformer.transformYieldExpression(this);
  },
  visit: function(visitor) {
    visitor.visitYieldExpression(this);
  },
  get type() {
    return YIELD_EXPRESSION;
  }
}, {}, ParseTree);
return {
  get Annotation() {
    return Annotation;
  },
  get AnonBlock() {
    return AnonBlock;
  },
  get ArgumentList() {
    return ArgumentList;
  },
  get ArrayComprehension() {
    return ArrayComprehension;
  },
  get ArrayLiteralExpression() {
    return ArrayLiteralExpression;
  },
  get ArrayPattern() {
    return ArrayPattern;
  },
  get ArrowFunctionExpression() {
    return ArrowFunctionExpression;
  },
  get AwaitExpression() {
    return AwaitExpression;
  },
  get BinaryOperator() {
    return BinaryOperator;
  },
  get BindingElement() {
    return BindingElement;
  },
  get BindingIdentifier() {
    return BindingIdentifier;
  },
  get Block() {
    return Block;
  },
  get BreakStatement() {
    return BreakStatement;
  },
  get CallExpression() {
    return CallExpression;
  },
  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 ContinueStatement() {
    return ContinueStatement;
  },
  get CoverFormals() {
    return CoverFormals;
  },
  get CoverInitialisedName() {
    return CoverInitialisedName;
  },
  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 ForStatement() {
    return ForStatement;
  },
  get FormalParameter() {
    return FormalParameter;
  },
  get FormalParameterList() {
    return FormalParameterList;
  },
  get FunctionBody() {
    return FunctionBody;
  },
  get FunctionDeclaration() {
    return FunctionDeclaration;
  },
  get FunctionExpression() {
    return FunctionExpression;
  },
  get GeneratorComprehension() {
    return GeneratorComprehension;
  },
  get GetAccessor() {
    return GetAccessor;
  },
  get IdentifierExpression() {
    return IdentifierExpression;
  },
  get IfStatement() {
    return IfStatement;
  },
  get ImportedBinding() {
    return ImportedBinding;
  },
  get ImportDeclaration() {
    return ImportDeclaration;
  },
  get ImportSpecifier() {
    return ImportSpecifier;
  },
  get ImportSpecifierSet() {
    return ImportSpecifierSet;
  },
  get LabelledStatement() {
    return LabelledStatement;
  },
  get LiteralExpression() {
    return LiteralExpression;
  },
  get LiteralPropertyName() {
    return LiteralPropertyName;
  },
  get MemberExpression() {
    return MemberExpression;
  },
  get MemberLookupExpression() {
    return MemberLookupExpression;
  },
  get Module() {
    return Module;
  },
  get ModuleDeclaration() {
    return ModuleDeclaration;
  },
  get ModuleSpecifier() {
    return ModuleSpecifier;
  },
  get NamedExport() {
    return NamedExport;
  },
  get NewExpression() {
    return NewExpression;
  },
  get ObjectLiteralExpression() {
    return ObjectLiteralExpression;
  },
  get ObjectPattern() {
    return ObjectPattern;
  },
  get ObjectPatternField() {
    return ObjectPatternField;
  },
  get ParenExpression() {
    return ParenExpression;
  },
  get PostfixExpression() {
    return PostfixExpression;
  },
  get PredefinedType() {
    return PredefinedType;
  },
  get Script() {
    return Script;
  },
  get PropertyMethodAssignment() {
    return PropertyMethodAssignment;
  },
  get PropertyNameAssignment() {
    return PropertyNameAssignment;
  },
  get PropertyNameShorthand() {
    return PropertyNameShorthand;
  },
  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 TypeName() {
    return TypeName;
  },
  get UnaryExpression() {
    return UnaryExpression;
  },
  get VariableDeclaration() {
    return VariableDeclaration;
  },
  get VariableDeclarationList() {
    return VariableDeclarationList;
  },
  get VariableStatement() {
    return VariableStatement;
  },
  get WhileStatement() {
    return WhileStatement;
  },
  get WithStatement() {
    return WithStatement;
  },
  get YieldExpression() {
    return YieldExpression;
  }
};

}); System.register(“traceur@0.0.43/src/semantics/FreeVariableChecker”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/semantics/FreeVariableChecker";
var ARGUMENTS = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).ARGUMENTS;
var $__42 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    BindingIdentifier = $__42.BindingIdentifier,
    IdentifierExpression = $__42.IdentifierExpression;
var IdentifierToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/IdentifierToken")).IdentifierToken;
var IDENTIFIER_EXPRESSION = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")).IDENTIFIER_EXPRESSION;
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var TYPEOF = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).TYPEOF;
var global = this;
var Scope = function Scope(parent) {
  this.parent = parent;
  this.references = Object.create(null);
  this.declarations = Object.create(null);
};
($traceurRuntime.createClass)(Scope, {}, {});
function getVariableName(name) {
  if (name instanceof IdentifierExpression) {
    name = name.identifierToken;
  } else if (name instanceof BindingIdentifier) {
    name = name.identifierToken;
  }
  if (name instanceof IdentifierToken) {
    name = name.value;
  }
  return name;
}
var FreeVariableChecker = function FreeVariableChecker(reporter) {
  $traceurRuntime.superCall(this, $FreeVariableChecker.prototype, "constructor", []);
  this.reporter_ = reporter;
  this.scope_ = null;
  this.disableChecksLevel_ = 0;
};
var $FreeVariableChecker = FreeVariableChecker;
($traceurRuntime.createClass)(FreeVariableChecker, {
  pushScope_: function() {
    return this.scope_ = new Scope(this.scope_);
  },
  pop_: function(scope) {
    if (this.scope_ != scope) {
      throw new Error('FreeVariableChecker scope mismatch');
    }
    this.validateScope_();
    this.scope_ = scope.parent;
  },
  visitScript: function(tree, global) {
    var scope = this.pushScope_();
    var object = global;
    while (object) {
      Object.getOwnPropertyNames(object).forEach(this.declareVariable_, this);
      object = Object.getPrototypeOf(object);
    }
    this.visitList(tree.scriptItemList);
    this.pop_(scope);
  },
  visitFunction_: function(name, parameterList, body) {
    var scope = this.pushScope_();
    this.visitAny(name);
    this.declareVariable_(ARGUMENTS);
    this.visitAny(parameterList);
    this.visitAny(body);
    this.pop_(scope);
  },
  visitFunctionDeclaration: function(tree) {
    this.declareVariable_(tree.name);
    this.visitFunction_(null, tree.parameterList, tree.functionBody);
  },
  visitFunctionExpression: function(tree) {
    this.visitFunction_(tree.name, tree.parameterList, tree.functionBody);
  },
  visitArrowFunctionExpression: function(tree) {
    this.visitFunction_(null, tree.parameterList, tree.functionBody);
  },
  visitGetAccessor: function(tree) {
    var scope = this.pushScope_();
    $traceurRuntime.superCall(this, $FreeVariableChecker.prototype, "visitGetAccessor", [tree]);
    this.pop_(scope);
  },
  visitSetAccessor: function(tree) {
    var scope = this.pushScope_();
    $traceurRuntime.superCall(this, $FreeVariableChecker.prototype, "visitSetAccessor", [tree]);
    this.pop_(scope);
  },
  visitCatch: function(tree) {
    var scope = this.pushScope_();
    $traceurRuntime.superCall(this, $FreeVariableChecker.prototype, "visitCatch", [tree]);
    this.pop_(scope);
  },
  visitBindingIdentifier: function(tree) {
    this.declareVariable_(tree);
  },
  visitIdentifierExpression: function(tree) {
    if (this.disableChecksLevel_)
      return;
    var name = getVariableName(tree);
    var scope = this.scope_;
    if (!(name in scope.references)) {
      scope.references[name] = tree.location;
    }
  },
  visitUnaryExpression: function(tree) {
    if (tree.operator.type === TYPEOF && tree.operand.type === IDENTIFIER_EXPRESSION) {
      this.declareVariable_(tree.operand);
    } else {
      $traceurRuntime.superCall(this, $FreeVariableChecker.prototype, "visitUnaryExpression", [tree]);
    }
  },
  visitWithStatement: function(tree) {
    this.visitAny(tree.expression);
    this.disableChecksLevel_++;
    this.visitAny(tree.body);
    this.disableChecksLevel_--;
  },
  declareVariable_: function(tree) {
    var name = getVariableName(tree);
    if (name) {
      var scope = this.scope_;
      if (!(name in scope.declarations)) {
        scope.declarations[name] = tree.location;
      }
    }
  },
  validateScope_: function() {
    var $__40 = this;
    if (this.disableChecksLevel_)
      return;
    var scope = this.scope_;
    var errors = [];
    for (var name in scope.references) {
      if (!(name in scope.declarations)) {
        var location = scope.references[name];
        if (!scope.parent) {
          if (!location) {
            throw new Error(("generated variable " + name + " is not defined"));
          }
          errors.push([location.start, (name + " is not defined")]);
        } else if (!(name in scope.parent.references)) {
          scope.parent.references[name] = location;
        }
      }
    }
    if (errors.length) {
      errors.sort((function(x, y) {
        return x[0].offset - y[0].offset;
      }));
      errors.forEach((function(args) {
        var $__43;
        ($__43 = $__40).reportError_.apply($__43, $traceurRuntime.toObject(args));
      }));
    }
  },
  reportError_: function(location, message) {
    this.reporter_.reportError(location, message);
  }
}, {checkScript: function(reporter, tree) {
    new $FreeVariableChecker(reporter).visitScript(tree, global);
  }}, ParseTreeVisitor);
return {
  get getVariableName() {
    return getVariableName;
  },
  get FreeVariableChecker() {
    return FreeVariableChecker;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/Keywords”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/Keywords";
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;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/KeywordToken”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/KeywordToken";
var STRICT_KEYWORD = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Keywords")).STRICT_KEYWORD;
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var KeywordToken = function KeywordToken(type, keywordType, location) {
  this.type = type;
  this.location = location;
  this.isStrictKeyword_ = keywordType === STRICT_KEYWORD;
};
($traceurRuntime.createClass)(KeywordToken, {
  isKeyword: function() {
    return true;
  },
  isStrictKeyword: function() {
    return this.isStrictKeyword_;
  }
}, {}, Token);
return {get KeywordToken() {
    return KeywordToken;
  }};

}); System.register(“traceur@0.0.43/src/syntax/LiteralToken”, [], function() {

"use strict";
var $__47;
var __moduleName = "traceur@0.0.43/src/syntax/LiteralToken";
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var $__50 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    NULL = $__50.NULL,
    NUMBER = $__50.NUMBER,
    STRING = $__50.STRING;
var StringParser = function StringParser(value) {
  this.value = value;
  this.index = 0;
};
($traceurRuntime.createClass)(StringParser, ($__47 = {}, Object.defineProperty($__47, Symbol.iterator, {
  value: function() {
    return this;
  },
  configurable: true,
  enumerable: true,
  writable: true
}), Object.defineProperty($__47, "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($__47, "parse", {
  value: function() {
    if (this.value.indexOf('\\') === -1)
      return this.value.slice(1, -1);
    var result = '';
    for (var $__48 = this[Symbol.iterator](),
        $__49; !($__49 = $__48.next()).done; ) {
      var ch = $__49.value;
      {
        result += ch === '\\' ? this.parseEscapeSequence() : ch;
      }
    }
    return result;
  },
  configurable: true,
  enumerable: true,
  writable: true
}), Object.defineProperty($__47, "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':
        return String.fromCharCode(parseInt(this.next().value + 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
}), $__47), {});
var LiteralToken = function LiteralToken(type, value, location) {
  this.type = type;
  this.location = location;
  this.value = value;
};
($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');
    }
  }
}, {}, Token);
return {get LiteralToken() {
    return LiteralToken;
  }};

}); System.register(“traceur@0.0.43/src/syntax/unicode-tables”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/unicode-tables";
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, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 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, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2417, 2418, 2423, 2425, 2431, 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, 3123, 3125, 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, 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, 6428, 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, 42647, 42656, 42725, 42726, 42735, 42775, 42783, 42786, 42863, 42864, 42864, 42865, 42887, 42888, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 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, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43631, 43632, 43632, 43633, 43638, 43642, 43642, 43648, 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, 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, 66334, 66352, 66368, 66369, 66369, 66370, 66377, 66378, 66378, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66639, 66640, 66717, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68147, 68192, 68220, 68352, 68405, 68416, 68437, 68448, 68466, 68608, 68680, 69635, 69687, 69763, 69807, 69840, 69864, 69891, 69926, 70019, 70066, 70081, 70084, 71296, 71338, 73728, 74606, 74752, 74850, 77824, 78894, 92160, 92728, 93952, 94020, 94032, 94032, 94099, 94111, 110592, 110593, 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, 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, 2302, 2304, 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, 3073, 3075, 3134, 3136, 3137, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3202, 3203, 3260, 3260, 3262, 3262, 3263, 3263, 3264, 3268, 3270, 3270, 3271, 3272, 3274, 3275, 3276, 3277, 3285, 3286, 3298, 3299, 3302, 3311, 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, 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, 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, 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, 7083, 7084, 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, 7616, 7654, 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, 43561, 43566, 43567, 43568, 43569, 43570, 43571, 43572, 43573, 43574, 43587, 43587, 43596, 43596, 43597, 43597, 43600, 43609, 43643, 43643, 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, 65062, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343, 66045, 66045, 66720, 66729, 68097, 68099, 68101, 68102, 68108, 68111, 68152, 68154, 68159, 68159, 69632, 69632, 69633, 69633, 69634, 69634, 69688, 69702, 69734, 69743, 69760, 69761, 69762, 69762, 69808, 69810, 69811, 69814, 69815, 69816, 69817, 69818, 69872, 69881, 69888, 69890, 69927, 69931, 69932, 69932, 69933, 69940, 69942, 69951, 70016, 70017, 70018, 70018, 70067, 70069, 70070, 70078, 70079, 70080, 70096, 70105, 71339, 71339, 71340, 71340, 71341, 71341, 71342, 71343, 71344, 71349, 71350, 71350, 71351, 71351, 71360, 71369, 94033, 94078, 94095, 94098, 119141, 119142, 119143, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 120782, 120831, 917760, 917999];
return {
  get idStartTable() {
    return idStartTable;
  },
  get idContinueTable() {
    return idContinueTable;
  }
};

}); System.register(“traceur@0.0.43/src/syntax/Scanner”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/Scanner";
var IdentifierToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/IdentifierToken")).IdentifierToken;
var KeywordToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/KeywordToken")).KeywordToken;
var LiteralToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/LiteralToken")).LiteralToken;
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var getKeywordType = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Keywords")).getKeywordType;
var $__52 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/unicode-tables")),
    idContinueTable = $__52.idContinueTable,
    idStartTable = $__52.idStartTable;
var $__52 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")),
    options = $__52.options,
    parseOptions = $__52.parseOptions;
var $__52 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    AMPERSAND = $__52.AMPERSAND,
    AMPERSAND_EQUAL = $__52.AMPERSAND_EQUAL,
    AND = $__52.AND,
    ARROW = $__52.ARROW,
    AT = $__52.AT,
    BACK_QUOTE = $__52.BACK_QUOTE,
    BANG = $__52.BANG,
    BAR = $__52.BAR,
    BAR_EQUAL = $__52.BAR_EQUAL,
    BREAK = $__52.BREAK,
    CARET = $__52.CARET,
    CARET_EQUAL = $__52.CARET_EQUAL,
    CASE = $__52.CASE,
    CATCH = $__52.CATCH,
    CLASS = $__52.CLASS,
    CLOSE_ANGLE = $__52.CLOSE_ANGLE,
    CLOSE_CURLY = $__52.CLOSE_CURLY,
    CLOSE_PAREN = $__52.CLOSE_PAREN,
    CLOSE_SQUARE = $__52.CLOSE_SQUARE,
    COLON = $__52.COLON,
    COMMA = $__52.COMMA,
    CONST = $__52.CONST,
    CONTINUE = $__52.CONTINUE,
    DEBUGGER = $__52.DEBUGGER,
    DEFAULT = $__52.DEFAULT,
    DELETE = $__52.DELETE,
    DO = $__52.DO,
    DOT_DOT_DOT = $__52.DOT_DOT_DOT,
    ELSE = $__52.ELSE,
    END_OF_FILE = $__52.END_OF_FILE,
    ENUM = $__52.ENUM,
    EQUAL = $__52.EQUAL,
    EQUAL_EQUAL = $__52.EQUAL_EQUAL,
    EQUAL_EQUAL_EQUAL = $__52.EQUAL_EQUAL_EQUAL,
    ERROR = $__52.ERROR,
    EXPORT = $__52.EXPORT,
    EXTENDS = $__52.EXTENDS,
    FALSE = $__52.FALSE,
    FINALLY = $__52.FINALLY,
    FOR = $__52.FOR,
    FUNCTION = $__52.FUNCTION,
    GREATER_EQUAL = $__52.GREATER_EQUAL,
    IDENTIFIER = $__52.IDENTIFIER,
    IF = $__52.IF,
    IMPLEMENTS = $__52.IMPLEMENTS,
    IMPORT = $__52.IMPORT,
    IN = $__52.IN,
    INSTANCEOF = $__52.INSTANCEOF,
    INTERFACE = $__52.INTERFACE,
    LEFT_SHIFT = $__52.LEFT_SHIFT,
    LEFT_SHIFT_EQUAL = $__52.LEFT_SHIFT_EQUAL,
    LESS_EQUAL = $__52.LESS_EQUAL,
    LET = $__52.LET,
    MINUS = $__52.MINUS,
    MINUS_EQUAL = $__52.MINUS_EQUAL,
    MINUS_MINUS = $__52.MINUS_MINUS,
    NEW = $__52.NEW,
    NO_SUBSTITUTION_TEMPLATE = $__52.NO_SUBSTITUTION_TEMPLATE,
    NOT_EQUAL = $__52.NOT_EQUAL,
    NOT_EQUAL_EQUAL = $__52.NOT_EQUAL_EQUAL,
    NULL = $__52.NULL,
    NUMBER = $__52.NUMBER,
    OPEN_ANGLE = $__52.OPEN_ANGLE,
    OPEN_CURLY = $__52.OPEN_CURLY,
    OPEN_PAREN = $__52.OPEN_PAREN,
    OPEN_SQUARE = $__52.OPEN_SQUARE,
    OR = $__52.OR,
    PACKAGE = $__52.PACKAGE,
    PERCENT = $__52.PERCENT,
    PERCENT_EQUAL = $__52.PERCENT_EQUAL,
    PERIOD = $__52.PERIOD,
    PLUS = $__52.PLUS,
    PLUS_EQUAL = $__52.PLUS_EQUAL,
    PLUS_PLUS = $__52.PLUS_PLUS,
    PRIVATE = $__52.PRIVATE,
    PROTECTED = $__52.PROTECTED,
    PUBLIC = $__52.PUBLIC,
    QUESTION = $__52.QUESTION,
    REGULAR_EXPRESSION = $__52.REGULAR_EXPRESSION,
    RETURN = $__52.RETURN,
    RIGHT_SHIFT = $__52.RIGHT_SHIFT,
    RIGHT_SHIFT_EQUAL = $__52.RIGHT_SHIFT_EQUAL,
    SEMI_COLON = $__52.SEMI_COLON,
    SLASH = $__52.SLASH,
    SLASH_EQUAL = $__52.SLASH_EQUAL,
    STAR = $__52.STAR,
    STAR_EQUAL = $__52.STAR_EQUAL,
    STATIC = $__52.STATIC,
    STRING = $__52.STRING,
    SUPER = $__52.SUPER,
    SWITCH = $__52.SWITCH,
    TEMPLATE_HEAD = $__52.TEMPLATE_HEAD,
    TEMPLATE_MIDDLE = $__52.TEMPLATE_MIDDLE,
    TEMPLATE_TAIL = $__52.TEMPLATE_TAIL,
    THIS = $__52.THIS,
    THROW = $__52.THROW,
    TILDE = $__52.TILDE,
    TRUE = $__52.TRUE,
    TRY = $__52.TRY,
    TYPEOF = $__52.TYPEOF,
    UNSIGNED_RIGHT_SHIFT = $__52.UNSIGNED_RIGHT_SHIFT,
    UNSIGNED_RIGHT_SHIFT_EQUAL = $__52.UNSIGNED_RIGHT_SHIFT_EQUAL,
    VAR = $__52.VAR,
    VOID = $__52.VOID,
    WHILE = $__52.WHILE,
    WITH = $__52.WITH,
    YIELD = $__52.YIELD;
var isWhitespaceArray = [];
for (var i = 0; i < 128; i++) {
  isWhitespaceArray[i] = i >= 9 && i <= 13 || i === 0x20;
}
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; i < 128; i++) {
  isHexDigitArray[i] = i >= 48 && i <= 57 || i >= 65 && i <= 70 || i >= 97 && i <= 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 = 0; i < 128; i++) {
  isIdentifierStartArray[i] = i === 36 || i >= 65 && i <= 90 || i === 95 || i >= 97 && i <= 122;
}
function isIdentifierStart(code) {
  return code < 128 ? isIdentifierStartArray[code] : inTable(idStartTable, code);
}
var isIdentifierPartArray = [];
for (var i = 0; i < 128; i++) {
  isIdentifierPartArray[i] = isIdentifierStart(i) || isDecimalDigit(i);
}
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;
var Scanner = function Scanner(reporter, file, parser) {
  errorReporter = reporter;
  lineNumberTable = file.lineNumberTable;
  input = file.contents;
  length = file.contents.length;
  index = 0;
  lastToken = null;
  token = null;
  lookaheadToken = null;
  updateCurrentCharCode();
  currentParser = parser;
};
($traceurRuntime.createClass)(Scanner, {
  get lastToken() {
    return lastToken;
  },
  getPosition: function() {
    return getPosition(getOffset());
  },
  nextRegularExpressionLiteralToken: function() {
    lastToken = nextRegularExpressionLiteralToken();
    token = scanToken();
    return lastToken;
  },
  nextTemplateLiteralToken: function() {
    var t = nextTemplateLiteralToken();
    token = scanToken();
    return t;
  },
  nextToken: function() {
    return nextToken();
  },
  peekToken: function(opt_index) {
    return opt_index ? peekTokenLookahead() : peekToken();
  },
  peekTokenNoLineTerminator: function() {
    return peekTokenNoLineTerminator();
  },
  isAtEnd: function() {
    return isAtEnd();
  }
}, {});
function getPosition(offset) {
  return lineNumberTable.getSourcePosition(offset);
}
function getTokenRange(startOffset) {
  return lineNumberTable.getSourceRange(startOffset, index);
}
function getOffset() {
  return token ? token.location.start.offset : index;
}
function nextRegularExpressionLiteralToken() {
  var beginIndex = index - token.toString().length;
  if (!skipRegularExpressionBody()) {
    return new LiteralToken(REGULAR_EXPRESSION, getTokenString(beginIndex), getTokenRange(beginIndex));
  }
  if (currentCharCode !== 47) {
    reportError('Expected \'/\' in regular expression literal');
    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() {
  if (!isRegularExpressionFirstChar(currentCharCode)) {
    reportError('Expected regular expression first char');
    return false;
  }
  while (!isAtEnd() && isRegularExpressionChar(currentCharCode)) {
    if (!skipRegularExpressionChar())
      return false;
  }
  return true;
}
function skipRegularExpressionChar() {
  switch (currentCharCode) {
    case 92:
      return skipRegularExpressionBackslashSequence();
    case 91:
      return skipRegularExpressionClass();
    default:
      next();
      return true;
  }
}
function skipRegularExpressionBackslashSequence() {
  next();
  if (isLineTerminator(currentCharCode) || isAtEnd()) {
    reportError('New line not allowed in regular expression literal');
    return false;
  }
  next();
  return true;
}
function skipRegularExpressionClass() {
  next();
  while (!isAtEnd() && peekRegularExpressionClassChar()) {
    if (!skipRegularExpressionClassChar()) {
      return false;
    }
  }
  if (currentCharCode !== 93) {
    reportError('\']\' expected');
    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;
      default:
        next();
    }
  }
}
function scanTemplateStart(beginIndex) {
  if (isAtEnd()) {
    reportError('Unterminated template literal');
    return lastToken = createToken(END_OF_FILE, beginIndex);
  }
  return nextTemplateLiteralTokenShared(NO_SUBSTITUTION_TEMPLATE, TEMPLATE_HEAD);
}
function nextTemplateLiteralToken() {
  if (isAtEnd()) {
    reportError('Expected \'}\' after expression in template literal');
    return createToken(END_OF_FILE, index);
  }
  if (token.type !== CLOSE_CURLY) {
    reportError('Expected \'}\' after expression in template literal');
    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 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++) {
    var code = input.charCodeAt(i);
    if (isLineTerminator(code))
      return null;
    if (code === 47) {
      code = input.charCodeAt(++i);
      if (code === 47)
        return null;
      i = input.indexOf('*/', i) + 2;
    }
  }
  return t;
}
function peekToken() {
  return token || (token = scanToken());
}
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) {
        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);
      }
      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');
      }
      skipHexDigits();
      return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex));
    case 66:
    case 98:
      if (!parseOptions.numericLiterals)
        break;
      next();
      if (!isBinaryDigit(currentCharCode)) {
        reportError('Binary Integer Literal must contain at least one digit');
      }
      skipBinaryDigits();
      return new LiteralToken(NUMBER, getTokenString(beginIndex), getTokenRange(beginIndex));
    case 79:
    case 111:
      if (!parseOptions.numericLiterals)
        break;
      next();
      if (!isOctalDigit(currentCharCode)) {
        reportError('Octal Integer Literal must contain at least one digit');
      }
      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 skipHexDigit() && skipHexDigit() && skipHexDigit() && skipHexDigit();
    default:
      return true;
  }
}
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');
      }
      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 indexArg = arguments[1] !== (void 0) ? arguments[1] : index;
  var position = getPosition(indexArg);
  errorReporter.reportError(position, message);
}
return {
  get isWhitespace() {
    return isWhitespace;
  },
  get isLineTerminator() {
    return isLineTerminator;
  },
  get isIdentifierPart() {
    return isIdentifierPart;
  },
  get Scanner() {
    return Scanner;
  }
};

}); System.register(“traceur@0.0.43/src/outputgeneration/ParseTreeWriter”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/outputgeneration/ParseTreeWriter";
var $__54 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BLOCK = $__54.BLOCK,
    IF_STATEMENT = $__54.IF_STATEMENT,
    LITERAL_EXPRESSION = $__54.LITERAL_EXPRESSION,
    POSTFIX_EXPRESSION = $__54.POSTFIX_EXPRESSION,
    UNARY_EXPRESSION = $__54.UNARY_EXPRESSION;
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var $__54 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    AS = $__54.AS,
    ASYNC = $__54.ASYNC,
    AWAIT = $__54.AWAIT,
    FROM = $__54.FROM,
    GET = $__54.GET,
    OF = $__54.OF,
    MODULE = $__54.MODULE,
    SET = $__54.SET;
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var getKeywordType = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Keywords")).getKeywordType;
var $__54 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Scanner")),
    isIdentifierPart = $__54.isIdentifierPart,
    isWhitespace = $__54.isWhitespace;
var $__54 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    AMPERSAND = $__54.AMPERSAND,
    AMPERSAND_EQUAL = $__54.AMPERSAND_EQUAL,
    AND = $__54.AND,
    ARROW = $__54.ARROW,
    AT = $__54.AT,
    BACK_QUOTE = $__54.BACK_QUOTE,
    BANG = $__54.BANG,
    BAR = $__54.BAR,
    BAR_EQUAL = $__54.BAR_EQUAL,
    BREAK = $__54.BREAK,
    CARET = $__54.CARET,
    CARET_EQUAL = $__54.CARET_EQUAL,
    CASE = $__54.CASE,
    CATCH = $__54.CATCH,
    CLASS = $__54.CLASS,
    CLOSE_ANGLE = $__54.CLOSE_ANGLE,
    CLOSE_CURLY = $__54.CLOSE_CURLY,
    CLOSE_PAREN = $__54.CLOSE_PAREN,
    CLOSE_SQUARE = $__54.CLOSE_SQUARE,
    COLON = $__54.COLON,
    COMMA = $__54.COMMA,
    CONST = $__54.CONST,
    CONTINUE = $__54.CONTINUE,
    DEBUGGER = $__54.DEBUGGER,
    DEFAULT = $__54.DEFAULT,
    DELETE = $__54.DELETE,
    DO = $__54.DO,
    DOT_DOT_DOT = $__54.DOT_DOT_DOT,
    ELSE = $__54.ELSE,
    END_OF_FILE = $__54.END_OF_FILE,
    ENUM = $__54.ENUM,
    EQUAL = $__54.EQUAL,
    EQUAL_EQUAL = $__54.EQUAL_EQUAL,
    EQUAL_EQUAL_EQUAL = $__54.EQUAL_EQUAL_EQUAL,
    ERROR = $__54.ERROR,
    EXPORT = $__54.EXPORT,
    EXTENDS = $__54.EXTENDS,
    FALSE = $__54.FALSE,
    FINALLY = $__54.FINALLY,
    FOR = $__54.FOR,
    FUNCTION = $__54.FUNCTION,
    GREATER_EQUAL = $__54.GREATER_EQUAL,
    IDENTIFIER = $__54.IDENTIFIER,
    IF = $__54.IF,
    IMPLEMENTS = $__54.IMPLEMENTS,
    IMPORT = $__54.IMPORT,
    IN = $__54.IN,
    INSTANCEOF = $__54.INSTANCEOF,
    INTERFACE = $__54.INTERFACE,
    LEFT_SHIFT = $__54.LEFT_SHIFT,
    LEFT_SHIFT_EQUAL = $__54.LEFT_SHIFT_EQUAL,
    LESS_EQUAL = $__54.LESS_EQUAL,
    LET = $__54.LET,
    MINUS = $__54.MINUS,
    MINUS_EQUAL = $__54.MINUS_EQUAL,
    MINUS_MINUS = $__54.MINUS_MINUS,
    NEW = $__54.NEW,
    NO_SUBSTITUTION_TEMPLATE = $__54.NO_SUBSTITUTION_TEMPLATE,
    NOT_EQUAL = $__54.NOT_EQUAL,
    NOT_EQUAL_EQUAL = $__54.NOT_EQUAL_EQUAL,
    NULL = $__54.NULL,
    NUMBER = $__54.NUMBER,
    OPEN_ANGLE = $__54.OPEN_ANGLE,
    OPEN_CURLY = $__54.OPEN_CURLY,
    OPEN_PAREN = $__54.OPEN_PAREN,
    OPEN_SQUARE = $__54.OPEN_SQUARE,
    OR = $__54.OR,
    PACKAGE = $__54.PACKAGE,
    PERCENT = $__54.PERCENT,
    PERCENT_EQUAL = $__54.PERCENT_EQUAL,
    PERIOD = $__54.PERIOD,
    PLUS = $__54.PLUS,
    PLUS_EQUAL = $__54.PLUS_EQUAL,
    PLUS_PLUS = $__54.PLUS_PLUS,
    PRIVATE = $__54.PRIVATE,
    PROTECTED = $__54.PROTECTED,
    PUBLIC = $__54.PUBLIC,
    QUESTION = $__54.QUESTION,
    REGULAR_EXPRESSION = $__54.REGULAR_EXPRESSION,
    RETURN = $__54.RETURN,
    RIGHT_SHIFT = $__54.RIGHT_SHIFT,
    RIGHT_SHIFT_EQUAL = $__54.RIGHT_SHIFT_EQUAL,
    SEMI_COLON = $__54.SEMI_COLON,
    SLASH = $__54.SLASH,
    SLASH_EQUAL = $__54.SLASH_EQUAL,
    STAR = $__54.STAR,
    STAR_EQUAL = $__54.STAR_EQUAL,
    STATIC = $__54.STATIC,
    STRING = $__54.STRING,
    SUPER = $__54.SUPER,
    SWITCH = $__54.SWITCH,
    TEMPLATE_HEAD = $__54.TEMPLATE_HEAD,
    TEMPLATE_MIDDLE = $__54.TEMPLATE_MIDDLE,
    TEMPLATE_TAIL = $__54.TEMPLATE_TAIL,
    THIS = $__54.THIS,
    THROW = $__54.THROW,
    TILDE = $__54.TILDE,
    TRUE = $__54.TRUE,
    TRY = $__54.TRY,
    TYPEOF = $__54.TYPEOF,
    UNSIGNED_RIGHT_SHIFT = $__54.UNSIGNED_RIGHT_SHIFT,
    UNSIGNED_RIGHT_SHIFT_EQUAL = $__54.UNSIGNED_RIGHT_SHIFT_EQUAL,
    VAR = $__54.VAR,
    VOID = $__54.VOID,
    WHILE = $__54.WHILE,
    WITH = $__54.WITH,
    YIELD = $__54.YIELD;
var NEW_LINE = '\n';
var LINE_LENGTH = 80;
var ParseTreeWriter = function ParseTreeWriter() {
  var $__55;
  var $__54 = $traceurRuntime.assertObject(arguments[0] !== (void 0) ? arguments[0] : {}),
      highlighted = ($__55 = $__54.highlighted) === void 0 ? false : $__55,
      showLineNumbers = ($__55 = $__54.showLineNumbers) === void 0 ? false : $__55,
      prettyPrint = ($__55 = $__54.prettyPrint) === void 0 ? true : $__55;
  $traceurRuntime.superCall(this, $ParseTreeWriter.prototype, "constructor", []);
  this.highlighted_ = highlighted;
  this.showLineNumbers_ = showLineNumbers;
  this.prettyPrint_ = prettyPrint;
  this.result_ = '';
  this.currentLine_ = '';
  this.currentLineComment_ = null;
  this.indentDepth_ = 0;
  this.currentParameterTypeAnnotation_ = null;
};
var $ParseTreeWriter = ParseTreeWriter;
($traceurRuntime.createClass)(ParseTreeWriter, {
  toString: function() {
    if (this.currentLine_.length > 0) {
      this.result_ += this.currentLine_;
      this.currentLine_ = '';
    }
    return this.result_;
  },
  visitAny: function(tree) {
    if (!tree) {
      return;
    }
    if (tree === this.highlighted_) {
      this.write_('\x1B[41m');
    }
    if (tree.location !== null && tree.location.start !== null && this.showLineNumbers_) {
      var line = tree.location.start.line + 1;
      var column = tree.location.start.column;
      this.currentLineComment_ = ("Line: " + line + "." + column);
    }
    $traceurRuntime.superCall(this, $ParseTreeWriter.prototype, "visitAny", [tree]);
    if (tree === this.highlighted_) {
      this.write_('\x1B[0m');
    }
  },
  visitAnnotation: function(tree) {
    this.write_(AT);
    this.visitAny(tree.name);
    if (tree.args !== null) {
      this.write_(OPEN_PAREN);
      this.writeList_(tree.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);
  },
  visitArrayLiteralExpression: function(tree) {
    this.write_(OPEN_SQUARE);
    this.writeList_(tree.elements, COMMA, false);
    this.write_(CLOSE_SQUARE);
  },
  visitArrayPattern: function(tree) {
    this.write_(OPEN_SQUARE);
    this.writeList_(tree.elements, COMMA, false);
    this.write_(CLOSE_SQUARE);
  },
  visitArrowFunctionExpression: function(tree) {
    if (tree.functionKind) {
      this.write_(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.functionBody);
  },
  visitAwaitExpression: function(tree) {
    this.write_(AWAIT);
    this.writeSpace_();
    this.visitAny(tree.expression);
  },
  visitBinaryOperator: 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.write_(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.write_(tree.identifierToken);
  },
  visitBlock: function(tree) {
    this.write_(OPEN_CURLY);
    this.writelnList_(tree.statements);
    this.write_(CLOSE_CURLY);
  },
  visitBreakStatement: function(tree) {
    this.write_(BREAK);
    if (tree.name !== null) {
      this.writeSpace_();
      this.write_(tree.name);
    }
    this.write_(SEMI_COLON);
  },
  visitCallExpression: function(tree) {
    this.visitAny(tree.operand);
    this.visitAny(tree.args);
  },
  visitCaseClause: function(tree) {
    this.write_(CASE);
    this.writeSpace_();
    this.visitAny(tree.expression);
    this.write_(COLON);
    this.indentDepth_++;
    this.writelnList_(tree.statements);
    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.superClass !== null) {
      this.writeSpace_();
      this.write_(EXTENDS);
      this.writeSpace_();
      this.visitAny(tree.superClass);
    }
    this.writeSpace_();
    this.write_(OPEN_CURLY);
    this.writelnList_(tree.elements);
    this.write_(CLOSE_CURLY);
  },
  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);
  },
  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.write_(tree.name);
    }
    this.write_(SEMI_COLON);
  },
  visitCoverInitialisedName: function(tree) {
    this.write_(tree.name);
    this.writeSpace_();
    this.write_(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);
    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);
    this.write_(SEMI_COLON);
  },
  visitNamedExport: function(tree) {
    this.visitAny(tree.specifierSet);
    if (tree.moduleSpecifier) {
      this.writeSpace_();
      this.write_(FROM);
      this.writeSpace_();
      this.visitAny(tree.moduleSpecifier);
    }
    this.write_(SEMI_COLON);
  },
  visitExportSpecifier: function(tree) {
    this.write_(tree.lhs);
    if (tree.rhs) {
      this.writeSpace_();
      this.write_(AS);
      this.writeSpace_();
      this.write_(tree.rhs);
    }
  },
  visitExportSpecifierSet: function(tree) {
    this.write_(OPEN_CURLY);
    this.writeList_(tree.specifiers, COMMA, false);
    this.write_(CLOSE_CURLY);
  },
  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);
  },
  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;
  },
  visitFunctionBody: function(tree) {
    this.write_(OPEN_CURLY);
    this.writelnList_(tree.statements);
    this.write_(CLOSE_CURLY);
  },
  visitFunctionDeclaration: function(tree) {
    this.visitFunction_(tree);
  },
  visitFunctionExpression: function(tree) {
    this.visitFunction_(tree);
  },
  visitFunction_: function(tree) {
    this.writeAnnotations_(tree.annotations);
    if (tree.isAsyncFunction())
      this.write_(tree.functionKind);
    this.write_(FUNCTION);
    if (tree.isGenerator())
      this.write_(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.functionBody);
  },
  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.write_(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);
      }
    }
  },
  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_();
    }
  },
  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) {
    this.write_(tree.lhs);
    if (tree.rhs !== null) {
      this.writeSpace_();
      this.write_(AS);
      this.writeSpace_();
      this.write_(tree.rhs);
    }
  },
  visitImportSpecifierSet: function(tree) {
    if (tree.specifiers.type == STAR) {
      this.write_(STAR);
    } else {
      this.write_(OPEN_CURLY);
      this.writelnList_(tree.specifiers, COMMA);
      this.write_(CLOSE_CURLY);
    }
  },
  visitLabelledStatement: function(tree) {
    this.write_(tree.name);
    this.write_(COLON);
    this.writeSpace_();
    this.visitAny(tree.statement);
  },
  visitLiteralExpression: function(tree) {
    this.write_(tree.literalToken);
  },
  visitLiteralPropertyName: function(tree) {
    this.write_(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.write_(tree.memberName);
  },
  visitMemberLookupExpression: function(tree) {
    this.visitAny(tree.operand);
    this.write_(OPEN_SQUARE);
    this.visitAny(tree.memberExpression);
    this.write_(CLOSE_SQUARE);
  },
  visitSyntaxErrorTree: function(tree) {
    this.write_('(function() {' + ("throw SyntaxError(" + JSON.stringify(tree.message) + ");") + '})()');
  },
  visitModule: function(tree) {
    this.writelnList_(tree.scriptItemList, null);
  },
  visitModuleSpecifier: function(tree) {
    this.write_(tree.token);
  },
  visitModuleDeclaration: function(tree) {
    this.write_(MODULE);
    this.writeSpace_();
    this.write_(tree.identifier);
    this.writeSpace_();
    this.write_(FROM);
    this.writeSpace_();
    this.visitAny(tree.expression);
    this.write_(SEMI_COLON);
  },
  visitNewExpression: function(tree) {
    this.write_(NEW);
    this.writeSpace_();
    this.visitAny(tree.operand);
    this.visitAny(tree.args);
  },
  visitObjectLiteralExpression: function(tree) {
    this.write_(OPEN_CURLY);
    if (tree.propertyNameAndValues.length > 1)
      this.writeln_();
    this.writelnList_(tree.propertyNameAndValues, COMMA);
    if (tree.propertyNameAndValues.length > 1)
      this.writeln_();
    this.write_(CLOSE_CURLY);
  },
  visitObjectPattern: function(tree) {
    this.write_(OPEN_CURLY);
    this.writelnList_(tree.fields, COMMA);
    this.write_(CLOSE_CURLY);
  },
  visitObjectPatternField: function(tree) {
    this.visitAny(tree.name);
    if (tree.element !== null) {
      this.write_(COLON);
      this.writeSpace_();
      this.visitAny(tree.element);
    }
  },
  visitParenExpression: function(tree) {
    this.write_(OPEN_PAREN);
    $traceurRuntime.superCall(this, $ParseTreeWriter.prototype, "visitParenExpression", [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.write_(tree.operator);
  },
  visitPredefinedType: function(tree) {
    this.write_(tree.typeToken);
  },
  visitScript: function(tree) {
    this.writelnList_(tree.scriptItemList, null);
  },
  visitPropertyMethodAssignment: function(tree) {
    this.writeAnnotations_(tree.annotations);
    if (tree.isStatic) {
      this.write_(STATIC);
      this.writeSpace_();
    }
    if (tree.isGenerator())
      this.write_(STAR);
    if (tree.isAsyncFunction())
      this.write_(ASYNC);
    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.functionBody);
  },
  visitPropertyNameAssignment: function(tree) {
    this.visitAny(tree.name);
    this.write_(COLON);
    this.writeSpace_();
    this.visitAny(tree.value);
  },
  visitPropertyNameShorthand: function(tree) {
    this.write_(tree.name);
  },
  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.writeRaw_(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);
    this.writeSpace_(tree.expression);
    this.visitAny(tree.expression);
    this.write_(SEMI_COLON);
  },
  visitRestParameter: function(tree) {
    this.write_(DOT_DOT_DOT);
    this.write_(tree.identifier.identifierToken);
    this.writeTypeAnnotation_(this.currentParameterTypeAnnotation_);
  },
  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.write_(OPEN_CURLY);
    this.writelnList_(tree.caseClauses);
    this.write_(CLOSE_CURLY);
  },
  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);
    }
  },
  visitTypeName: function(tree) {
    if (tree.moduleName) {
      this.visitAny(tree.moduleName);
      this.write_(PERIOD);
    }
    this.write_(tree.name);
  },
  visitUnaryExpression: function(tree) {
    var op = tree.operator;
    this.write_(op);
    var operand = tree.operand;
    if (operand.type === UNARY_EXPRESSION && requiresSpaceBetween(op.type, operand.operator.type)) {
      this.writeRequiredSpace_();
    }
    this.visitAny(operand);
  },
  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.superCall(this, $ParseTreeWriter.prototype, "visitVariableStatement", [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.currentLineComment_) {
      while (this.currentLine_.length < LINE_LENGTH) {
        this.currentLine_ += ' ';
      }
      this.currentLine_ += ' // ' + this.currentLineComment_;
      this.currentLineComment_ = null;
    }
    if (this.currentLine_)
      this.writeCurrentln_();
    this.currentLine_ = '';
  },
  writelnList_: function(list, delimiter) {
    if (delimiter) {
      this.writeList_(list, delimiter, true);
    } else {
      if (list.length > 0)
        this.writeln_();
      this.writeList_(list, null, 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++) {
      var element = list[i];
      if (first) {
        first = false;
      } else {
        if (delimiter !== null) {
          this.write_(delimiter);
          if (!writeNewLine)
            this.writeSpace_();
        }
        if (writeNewLine) {
          if (i === 1)
            this.indentDepth_ += indent;
          this.writeln_();
        }
      }
      this.visitAny(element);
    }
    if (writeNewLine && list.length > 1)
      this.indentDepth_ -= indent;
  },
  writeRaw_: function(value) {
    this.currentLine_ += value;
  },
  write_: function(value) {
    if (value === CLOSE_CURLY)
      this.indentDepth_--;
    if (value !== null) {
      if (this.prettyPrint_) {
        if (!this.currentLine_) {
          for (var i = 0,
              indent = this.indentDepth_; i < indent; i++) {
            this.currentLine_ += '  ';
          }
        }
      }
      if (this.needsSpace_(value))
        this.currentLine_ += ' ';
      this.currentLine_ += value;
    }
    if (value === OPEN_CURLY)
      this.indentDepth_++;
  },
  writeSpace_: function() {
    var useSpace = arguments[0] !== (void 0) ? arguments[0] : this.prettyPrint_;
    if (useSpace && !endsWithSpace(this.currentLine_))
      this.currentLine_ += ' ';
  },
  writeRequiredSpace_: function() {
    this.writeSpace_(true);
  },
  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, null, writeNewLine);
      if (writeNewLine)
        this.writeln_();
    }
  },
  needsSpace_: function(token) {
    var line = this.currentLine_;
    if (!line)
      return false;
    var lastCode = line.charCodeAt(line.length - 1);
    if (isWhitespace(lastCode))
      return false;
    var firstCode = token.toString().charCodeAt(0);
    return isIdentifierPart(firstCode) && (isIdentifierPart(lastCode) || lastCode === 47);
  }
}, {}, 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);
}
function endsWithSpace(s) {
  return isWhitespace(s.charCodeAt(s.length - 1));
}
return {get ParseTreeWriter() {
    return ParseTreeWriter;
  }};

}); System.register(“traceur@0.0.43/src/outputgeneration/ParseTreeMapWriter”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/outputgeneration/ParseTreeMapWriter";
var ParseTreeWriter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/ParseTreeWriter")).ParseTreeWriter;
var ParseTreeMapWriter = function ParseTreeMapWriter(sourceMapGenerator) {
  var options = arguments[1];
  $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "constructor", [options]);
  this.sourceMapGenerator_ = sourceMapGenerator;
  this.outputLineCount_ = 1;
  this.isFirstMapping_ = true;
};
var $ParseTreeMapWriter = ParseTreeMapWriter;
($traceurRuntime.createClass)(ParseTreeMapWriter, {
  visitAny: function(tree) {
    if (!tree) {
      return;
    }
    if (tree.location)
      this.enterBranch(tree.location);
    $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "visitAny", [tree]);
    if (tree.location)
      this.exitBranch(tree.location);
  },
  writeCurrentln_: function() {
    $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "writeCurrentln_", []);
    this.flushMappings();
    this.outputLineCount_++;
    this.generated_ = {
      line: this.outputLineCount_,
      column: 1
    };
    this.flushMappings();
  },
  write_: function(value) {
    if (this.entered_) {
      this.generate();
      $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "write_", [value]);
      this.generate();
    } else {
      this.generate();
      $traceurRuntime.superCall(this, $ParseTreeMapWriter.prototype, "write_", [value]);
      this.generate();
    }
  },
  generate: function() {
    this.generated_ = {
      line: this.outputLineCount_,
      column: this.currentLine_.length
    };
    this.flushMappings();
  },
  enterBranch: function(location) {
    this.originate(location.start);
    this.entered_ = true;
  },
  exitBranch: function(location) {
    this.originate(location.end);
    this.entered_ = false;
  },
  originate: function(position) {
    var line = position.line + 1;
    if (this.original_ && this.original_.line !== line)
      this.flushMappings();
    this.original_ = {
      line: line,
      column: position.column || 0
    };
    if (position.source.name !== this.sourceName_) {
      this.sourceName_ = position.source.name;
      this.sourceMapGenerator_.setSourceContent(position.source.name, position.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;
  },
  isSameMapping: function() {
    if (!this.previousMapping_)
      return false;
    if (this.isSame(this.previousMapping_.generated, this.generated_) && this.isSame(this.previousMapping_.original, this.original_))
      return true;
    ;
  },
  addMapping: function() {
    if (this.isSameMapping())
      return;
    var mapping = {
      generated: this.generated_,
      original: this.original_,
      source: this.sourceName_
    };
    this.sourceMapGenerator_.addMapping(mapping);
    this.previousMapping_ = mapping;
  }
}, {}, ParseTreeWriter);
return {get ParseTreeMapWriter() {
    return ParseTreeMapWriter;
  }};

}); System.register(“traceur@0.0.43/src/outputgeneration/SourceMapIntegration”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/outputgeneration/SourceMapIntegration";
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[3],
      host: match[4],
      port: match[6],
      path: match[7]
    };
  }
  exports.urlParse = urlParse;
  function urlGenerate(aParsedUrl) {
    var url = aParsedUrl.scheme + "://";
    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 join(aRoot, aPath) {
    var url;
    if (aPath.match(urlRegexp) || aPath.match(dataUrlRegexp)) {
      return aPath;
    }
    if (aPath.charAt(0) === '/' && (url = urlParse(aRoot))) {
      url.path = aPath;
      return urlGenerate(url);
    }
    return aRoot.replace(/\/$/, '') + '/' + aPath;
  }
  exports.join = join;
  function toSetString(aStr) {
    return '$' + aStr;
  }
  exports.toSetString = toSetString;
  function fromSetString(aStr) {
    return aStr.substr(1);
  }
  exports.fromSetString = fromSetString;
  function relative(aRoot, aPath) {
    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 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) {
    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);
    return {
      value: fromVLQSigned(result),
      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 aHaystack[mid];
    } else if (cmp > 0) {
      if (aHigh - mid > 1) {
        return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
      }
      return aHaystack[mid];
    } else {
      if (mid - aLow > 1) {
        return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
      }
      return aLow < 0 ? null : aHaystack[aLow];
    }
  }
  exports.search = function search(aNeedle, aHaystack, aCompare) {
    return aHaystack.length > 0 ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare) : null;
  };
});
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;
  function SourceMapGenerator(aArgs) {
    this._file = util.getArg(aArgs, 'file');
    this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
    this._sources = new ArraySet();
    this._names = new ArraySet();
    this._mappings = [];
    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) {
        newMapping.source = mapping.source;
        if (sourceRoot) {
          newMapping.source = util.relative(sourceRoot, newMapping.source);
        }
        newMapping.original = {
          line: mapping.originalLine,
          column: mapping.originalColumn
        };
        if (mapping.name) {
          newMapping.name = mapping.name;
        }
      }
      generator.addMapping(newMapping);
    });
    aSourceMapConsumer.sources.forEach(function(sourceFile) {
      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content) {
        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);
    this._validateMapping(generated, original, source, name);
    if (source && !this._sources.has(source)) {
      this._sources.add(source);
    }
    if (name && !this._names.has(name)) {
      this._names.add(name);
    }
    this._mappings.push({
      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) {
      source = util.relative(this._sourceRoot, source);
    }
    if (aSourceContent !== null) {
      if (!this._sourcesContents) {
        this._sourcesContents = {};
      }
      this._sourcesContents[util.toSetString(source)] = aSourceContent;
    } else {
      delete this._sourcesContents[util.toSetString(source)];
      if (Object.keys(this._sourcesContents).length === 0) {
        this._sourcesContents = null;
      }
    }
  };
  SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile) {
    if (!aSourceFile) {
      aSourceFile = aSourceMapConsumer.file;
    }
    var sourceRoot = this._sourceRoot;
    if (sourceRoot) {
      aSourceFile = util.relative(sourceRoot, aSourceFile);
    }
    var newSources = new ArraySet();
    var newNames = new ArraySet();
    this._mappings.forEach(function(mapping) {
      if (mapping.source === aSourceFile && mapping.originalLine) {
        var original = aSourceMapConsumer.originalPositionFor({
          line: mapping.originalLine,
          column: mapping.originalColumn
        });
        if (original.source !== null) {
          if (sourceRoot) {
            mapping.source = util.relative(sourceRoot, original.source);
          } else {
            mapping.source = original.source;
          }
          mapping.originalLine = original.line;
          mapping.originalColumn = original.column;
          if (original.name !== null && mapping.name !== null) {
            mapping.name = original.name;
          }
        }
      }
      var source = mapping.source;
      if (source && !newSources.has(source)) {
        newSources.add(source);
      }
      var name = mapping.name;
      if (name && !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) {
        if (sourceRoot) {
          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,
        orginal: 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;
    this._mappings.sort(util.compareByGeneratedPositions);
    for (var i = 0,
        len = this._mappings.length; i < len; i++) {
      mapping = this._mappings[i];
      if (mapping.generatedLine !== previousGeneratedLine) {
        previousGeneratedColumn = 0;
        while (mapping.generatedLine !== previousGeneratedLine) {
          result += ';';
          previousGeneratedLine++;
        }
      } else {
        if (i > 0) {
          if (!util.compareByGeneratedPositions(mapping, this._mappings[i - 1])) {
            continue;
          }
          result += ',';
        }
      }
      result += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
      previousGeneratedColumn = mapping.generatedColumn;
      if (mapping.source) {
        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) {
          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) {
        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,
      file: this._file,
      sources: this._sources.toArray(),
      names: this._names.toArray(),
      mappings: this._serializeMappings()
    };
    if (this._sourceRoot) {
      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);
    }
    this._names = ArraySet.fromArray(names, true);
    this._sources = ArraySet.fromArray(sources, true);
    this.sourceRoot = sourceRoot;
    this.sourcesContent = sourcesContent;
    this.file = file;
    this._generatedMappings = [];
    this._originalMappings = [];
    this._parseMappings(mappings, sourceRoot);
  }
  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.slice().sort(util.compareByGeneratedPositions);
    smc._originalMappings = aSourceMap._mappings.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 ? util.join(this.sourceRoot, s) : s;
      }, this);
    }});
  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 mappingSeparator = /^[,;]/;
    var str = aStr;
    var mapping;
    var temp;
    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;
        temp = base64VLQ.decode(str);
        mapping.generatedColumn = previousGeneratedColumn + temp.value;
        previousGeneratedColumn = mapping.generatedColumn;
        str = temp.rest;
        if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
          temp = base64VLQ.decode(str);
          mapping.source = this._sources.at(previousSource + temp.value);
          previousSource += temp.value;
          str = temp.rest;
          if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
            throw new Error('Found a source, but no line and column');
          }
          temp = base64VLQ.decode(str);
          mapping.originalLine = previousOriginalLine + temp.value;
          previousOriginalLine = mapping.originalLine;
          mapping.originalLine += 1;
          str = temp.rest;
          if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
            throw new Error('Found a source and line, but no column');
          }
          temp = base64VLQ.decode(str);
          mapping.originalColumn = previousOriginalColumn + temp.value;
          previousOriginalColumn = mapping.originalColumn;
          str = temp.rest;
          if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
            temp = base64VLQ.decode(str);
            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._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.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
    var needle = {
      generatedLine: util.getArg(aArgs, 'line'),
      generatedColumn: util.getArg(aArgs, 'column')
    };
    var mapping = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositions);
    if (mapping) {
      var source = util.getArg(mapping, 'source', null);
      if (source && this.sourceRoot) {
        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) {
      aSource = util.relative(this.sourceRoot, aSource);
    }
    if (this._sources.has(aSource)) {
      return this.sourcesContent[this._sources.indexOf(aSource)];
    }
    var url;
    if (this.sourceRoot && (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) {
      needle.source = util.relative(this.sourceRoot, needle.source);
    }
    var mapping = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions);
    if (mapping) {
      return {
        line: util.getArg(mapping, 'generatedLine', null),
        column: util.getArg(mapping, 'generatedColumn', null)
      };
    }
    return {
      line: null,
      column: null
    };
  };
  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 && sourceRoot) {
        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');
  function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
    this.children = [];
    this.sourceContents = {};
    this.line = aLine === undefined ? null : aLine;
    this.column = aColumn === undefined ? null : aColumn;
    this.source = aSource === undefined ? null : aSource;
    this.name = aName === undefined ? null : aName;
    if (aChunks != null)
      this.add(aChunks);
  }
  SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer) {
    var node = new SourceNode();
    var remainingLines = aGeneratedCode.split('\n');
    var lastGeneratedLine = 1,
        lastGeneratedColumn = 0;
    var lastMapping = null;
    aSourceMapConsumer.eachMapping(function(mapping) {
      if (lastMapping === null) {
        while (lastGeneratedLine < mapping.generatedLine) {
          node.add(remainingLines.shift() + "\n");
          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;
        }
      } else {
        if (lastGeneratedLine < mapping.generatedLine) {
          var code = "";
          do {
            code += remainingLines.shift() + "\n";
            lastGeneratedLine++;
            lastGeneratedColumn = 0;
          } while (lastGeneratedLine < mapping.generatedLine);
          if (lastGeneratedColumn < mapping.generatedColumn) {
            var nextLine = remainingLines[0];
            code += nextLine.substr(0, mapping.generatedColumn);
            remainingLines[0] = nextLine.substr(mapping.generatedColumn);
            lastGeneratedColumn = mapping.generatedColumn;
          }
          addMappingWithCode(lastMapping, code);
        } 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;
    }, this);
    addMappingWithCode(lastMapping, remainingLines.join("\n"));
    aSourceMapConsumer.sources.forEach(function(sourceFile) {
      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content) {
        node.setSourceContent(sourceFile, content);
      }
    });
    return node;
    function addMappingWithCode(mapping, code) {
      if (mapping === null || mapping.source === undefined) {
        node.add(code);
      } else {
        node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, mapping.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 instanceof SourceNode || 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 instanceof SourceNode || 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 instanceof SourceNode) {
        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 instanceof SourceNode) {
      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] instanceof SourceNode) {
        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;
      }
      chunk.split('').forEach(function(ch) {
        if (ch === '\n') {
          generated.line++;
          generated.column = 0;
        } 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;
return {
  get SourceMapGenerator() {
    return SourceMapGenerator;
  },
  get SourceMapConsumer() {
    return SourceMapConsumer;
  },
  get SourceNode() {
    return SourceNode;
  }
};

}); System.register(“traceur@0.0.43/src/outputgeneration/toSource”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/outputgeneration/toSource";
var ParseTreeMapWriter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/ParseTreeMapWriter")).ParseTreeMapWriter;
var ParseTreeWriter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/ParseTreeWriter")).ParseTreeWriter;
var SourceMapGenerator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/SourceMapIntegration")).SourceMapGenerator;
function toSource(tree) {
  var options = arguments[1];
  var sourceMapGenerator = options && options.sourceMapGenerator;
  if (!sourceMapGenerator && options && options.sourceMaps) {
    sourceMapGenerator = new SourceMapGenerator({
      file: options.filename,
      sourceRoot: null
    });
  }
  var writer;
  if (sourceMapGenerator)
    writer = new ParseTreeMapWriter(sourceMapGenerator, options);
  else
    writer = new ParseTreeWriter(options);
  writer.visitAny(tree);
  return [writer.toString(), sourceMapGenerator && sourceMapGenerator.toString()];
}
return {get toSource() {
    return toSource;
  }};

}); System.register(“traceur@0.0.43/src/outputgeneration/TreeWriter”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/outputgeneration/TreeWriter";
var toSource = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/toSource")).toSource;
function write(tree) {
  var options = arguments[1];
  var $__59 = $traceurRuntime.assertObject(toSource(tree, options)),
      result = $__59[0],
      sourceMap = $__59[1];
  if (sourceMap)
    options.sourceMap = sourceMap;
  return result;
}
var TreeWriter = function TreeWriter() {};
($traceurRuntime.createClass)(TreeWriter, {}, {});
TreeWriter.write = write;
return {
  get write() {
    return write;
  },
  get TreeWriter() {
    return TreeWriter;
  }
};

}); System.register(“traceur@0.0.43/src/util/assert”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/assert";
var options = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).options;
function assert(b) {
  if (!b && options.debug)
    throw Error('Assertion failed');
}
return {get assert() {
    return assert;
  }};

}); System.register(“traceur@0.0.43/src/syntax/ParseTreeValidator”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/ParseTreeValidator";
var NewExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")).NewExpression;
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var TreeWriter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/TreeWriter")).TreeWriter;
var $__62 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    AMPERSAND = $__62.AMPERSAND,
    AMPERSAND_EQUAL = $__62.AMPERSAND_EQUAL,
    AND = $__62.AND,
    BAR = $__62.BAR,
    BAR_EQUAL = $__62.BAR_EQUAL,
    CARET = $__62.CARET,
    CARET_EQUAL = $__62.CARET_EQUAL,
    CLOSE_ANGLE = $__62.CLOSE_ANGLE,
    EQUAL = $__62.EQUAL,
    EQUAL_EQUAL = $__62.EQUAL_EQUAL,
    EQUAL_EQUAL_EQUAL = $__62.EQUAL_EQUAL_EQUAL,
    GREATER_EQUAL = $__62.GREATER_EQUAL,
    IDENTIFIER = $__62.IDENTIFIER,
    IN = $__62.IN,
    INSTANCEOF = $__62.INSTANCEOF,
    LEFT_SHIFT = $__62.LEFT_SHIFT,
    LEFT_SHIFT_EQUAL = $__62.LEFT_SHIFT_EQUAL,
    LESS_EQUAL = $__62.LESS_EQUAL,
    MINUS = $__62.MINUS,
    MINUS_EQUAL = $__62.MINUS_EQUAL,
    NOT_EQUAL = $__62.NOT_EQUAL,
    NOT_EQUAL_EQUAL = $__62.NOT_EQUAL_EQUAL,
    NUMBER = $__62.NUMBER,
    OPEN_ANGLE = $__62.OPEN_ANGLE,
    OR = $__62.OR,
    PERCENT = $__62.PERCENT,
    PERCENT_EQUAL = $__62.PERCENT_EQUAL,
    PLUS = $__62.PLUS,
    PLUS_EQUAL = $__62.PLUS_EQUAL,
    RIGHT_SHIFT = $__62.RIGHT_SHIFT,
    RIGHT_SHIFT_EQUAL = $__62.RIGHT_SHIFT_EQUAL,
    SLASH = $__62.SLASH,
    SLASH_EQUAL = $__62.SLASH_EQUAL,
    STAR = $__62.STAR,
    STAR_EQUAL = $__62.STAR_EQUAL,
    STRING = $__62.STRING,
    UNSIGNED_RIGHT_SHIFT = $__62.UNSIGNED_RIGHT_SHIFT,
    UNSIGNED_RIGHT_SHIFT_EQUAL = $__62.UNSIGNED_RIGHT_SHIFT_EQUAL;
var $__62 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    ARRAY_PATTERN = $__62.ARRAY_PATTERN,
    BINDING_ELEMENT = $__62.BINDING_ELEMENT,
    BINDING_IDENTIFIER = $__62.BINDING_IDENTIFIER,
    BLOCK = $__62.BLOCK,
    CASE_CLAUSE = $__62.CASE_CLAUSE,
    CATCH = $__62.CATCH,
    CLASS_DECLARATION = $__62.CLASS_DECLARATION,
    COMPUTED_PROPERTY_NAME = $__62.COMPUTED_PROPERTY_NAME,
    DEFAULT_CLAUSE = $__62.DEFAULT_CLAUSE,
    EXPORT_DECLARATION = $__62.EXPORT_DECLARATION,
    EXPORT_DEFAULT = $__62.EXPORT_DEFAULT,
    EXPORT_SPECIFIER = $__62.EXPORT_SPECIFIER,
    EXPORT_SPECIFIER_SET = $__62.EXPORT_SPECIFIER_SET,
    EXPORT_STAR = $__62.EXPORT_STAR,
    FINALLY = $__62.FINALLY,
    FORMAL_PARAMETER = $__62.FORMAL_PARAMETER,
    FORMAL_PARAMETER_LIST = $__62.FORMAL_PARAMETER_LIST,
    FUNCTION_BODY = $__62.FUNCTION_BODY,
    FUNCTION_DECLARATION = $__62.FUNCTION_DECLARATION,
    GET_ACCESSOR = $__62.GET_ACCESSOR,
    IDENTIFIER_EXPRESSION = $__62.IDENTIFIER_EXPRESSION,
    IMPORT_DECLARATION = $__62.IMPORT_DECLARATION,
    LITERAL_PROPERTY_NAME = $__62.LITERAL_PROPERTY_NAME,
    MODULE_DECLARATION = $__62.MODULE_DECLARATION,
    MODULE_SPECIFIER = $__62.MODULE_SPECIFIER,
    NAMED_EXPORT = $__62.NAMED_EXPORT,
    OBJECT_PATTERN = $__62.OBJECT_PATTERN,
    OBJECT_PATTERN_FIELD = $__62.OBJECT_PATTERN_FIELD,
    PROPERTY_METHOD_ASSIGNMENT = $__62.PROPERTY_METHOD_ASSIGNMENT,
    PROPERTY_NAME_ASSIGNMENT = $__62.PROPERTY_NAME_ASSIGNMENT,
    PROPERTY_NAME_SHORTHAND = $__62.PROPERTY_NAME_SHORTHAND,
    REST_PARAMETER = $__62.REST_PARAMETER,
    SET_ACCESSOR = $__62.SET_ACCESSOR,
    TEMPLATE_LITERAL_PORTION = $__62.TEMPLATE_LITERAL_PORTION,
    TEMPLATE_SUBSTITUTION = $__62.TEMPLATE_SUBSTITUTION,
    VARIABLE_DECLARATION_LIST = $__62.VARIABLE_DECLARATION_LIST,
    VARIABLE_STATEMENT = $__62.VARIABLE_STATEMENT;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var ValidationError = function ValidationError(tree, message) {
  this.tree = tree;
  this.message = message;
};
($traceurRuntime.createClass)(ValidationError, {}, {}, Error);
var ParseTreeValidator = function ParseTreeValidator() {
  $traceurRuntime.defaultSuperCall(this, $ParseTreeValidator.prototype, arguments);
};
var $ParseTreeValidator = ParseTreeValidator;
($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');
    }
  },
  visitArrayLiteralExpression: 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 == IDENTIFIER_EXPRESSION || 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');
      }
    }
  },
  visitBinaryOperator: function(tree) {
    switch (tree.operator.type) {
      case EQUAL:
      case 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:
        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.type == IDENTIFIER_EXPRESSION, binding, 'expected valid binding 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.isStatement(), 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) {
    for (var i = 0; i < tree.elements.length; i++) {
      var element = tree.elements[i];
      switch (element.type) {
        case GET_ACCESSOR:
        case SET_ACCESSOR:
        case PROPERTY_METHOD_ASSIGNMENT:
          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.isAssignmentExpression(), 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');
  },
  visitCoverInitialisedName: function(tree) {
    this.fail_(tree, 'CoverInitialisedName should have been removed');
  },
  visitDefaultClause: function(tree) {
    for (var i = 0; i < tree.statements.length; i++) {
      var statement = tree.statements[i];
      this.checkVisit_(statement.isStatement(), 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 == MODULE_DECLARATION || declType == CLASS_DECLARATION || declType == NAMED_EXPORT || declType == EXPORT_DEFAULT, tree.declaration, 'expected valid export tree');
  },
  visitNamedExport: function(tree) {
    if (tree.moduleSpecifier) {
      this.checkVisit_(tree.moduleSpecifier.type == MODULE_SPECIFIER, tree.moduleSpecifier, 'module expression expected');
    }
    var specifierType = tree.specifierSet.type;
    this.checkVisit_(specifierType == EXPORT_SPECIFIER_SET || specifierType == EXPORT_STAR, tree.specifierSet, 'specifier set or identifier 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.functionBody, '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');
    }
  },
  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.moduleName, 'string or identifier expected');
  },
  visitModuleDeclaration: function(tree) {
    this.checkType_(MODULE_SPECIFIER, tree.expression, 'module expression expected');
  },
  visitNewExpression: function(tree) {
    this.checkVisit_(tree.operand.isMemberExpression(), tree.operand, 'member expression expected');
    this.visitAny(tree.args);
  },
  visitObjectLiteralExpression: 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 PROPERTY_METHOD_ASSIGNMENT:
          this.check_(!propertyNameAndValue.isStatic, propertyNameAndValue, 'static is not allowed in object literal expression');
        case PROPERTY_NAME_ASSIGNMENT:
        case PROPERTY_NAME_SHORTHAND:
          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 === BINDING_ELEMENT || field.type === IDENTIFIER_EXPRESSION, field, 'object pattern field expected');
    }
  },
  visitObjectPatternField: function(tree) {
    this.checkPropertyName_(tree.name);
    this.checkVisit_(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, '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');
    }
  },
  visitTypeName: function(tree) {},
  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');
    }
  }
}, {}, 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, {
      highlighted: e.tree,
      showLineNumbers: true
    }) + '\n');
  }
};
return {get ParseTreeValidator() {
    return ParseTreeValidator;
  }};

}); System.register(“traceur@0.0.43/src/util/ObjectMap”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/ObjectMap";
var ObjectMap = function ObjectMap() {
  this.keys_ = Object.create(null);
  this.values_ = Object.create(null);
};
($traceurRuntime.createClass)(ObjectMap, {
  set: function(key, value) {
    var uid = key.uid;
    this.keys_[uid] = key;
    this.values_[uid] = value;
  },
  get: function(key) {
    return this.values_[key.uid];
  },
  has: function(key) {
    return key.uid in this.keys_;
  },
  addAll: function(other) {
    for (var uid in other.keys_) {
      this.keys_[uid] = other.keys_[uid];
      this.values_[uid] = other.values_[uid];
    }
  },
  keys: function() {
    var $__63 = this;
    return Object.keys(this.keys_).map((function(uid) {
      return $__63.keys_[uid];
    }));
  },
  values: function() {
    var $__63 = this;
    return Object.keys(this.values_).map((function(uid) {
      return $__63.values_[uid];
    }));
  },
  remove: function(key) {
    var uid = key.uid;
    delete this.keys_[uid];
    delete this.values_[uid];
  }
}, {});
return {get ObjectMap() {
    return ObjectMap;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ParseTreeFactory”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ParseTreeFactory";
var IdentifierToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/IdentifierToken")).IdentifierToken;
var LiteralToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/LiteralToken")).LiteralToken;
var $__67 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTree")),
    ParseTree = $__67.ParseTree,
    ParseTreeType = $__67.ParseTreeType;
var $__67 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    BIND = $__67.BIND,
    CALL = $__67.CALL,
    CREATE = $__67.CREATE,
    DEFINE_PROPERTY = $__67.DEFINE_PROPERTY,
    FREEZE = $__67.FREEZE,
    OBJECT = $__67.OBJECT,
    PREVENT_EXTENSIONS = $__67.PREVENT_EXTENSIONS,
    UNDEFINED = $__67.UNDEFINED,
    getParameterName = $__67.getParameterName;
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var $__67 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    EQUAL = $__67.EQUAL,
    FALSE = $__67.FALSE,
    NULL = $__67.NULL,
    NUMBER = $__67.NUMBER,
    STRING = $__67.STRING,
    TRUE = $__67.TRUE,
    VOID = $__67.VOID;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var $__67 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    ArgumentList = $__67.ArgumentList,
    ArrayComprehension = $__67.ArrayComprehension,
    ArrayLiteralExpression = $__67.ArrayLiteralExpression,
    ArrayPattern = $__67.ArrayPattern,
    ArrowFunctionExpression = $__67.ArrowFunctionExpression,
    BinaryOperator = $__67.BinaryOperator,
    BindingElement = $__67.BindingElement,
    BindingIdentifier = $__67.BindingIdentifier,
    Block = $__67.Block,
    BreakStatement = $__67.BreakStatement,
    CallExpression = $__67.CallExpression,
    CaseClause = $__67.CaseClause,
    Catch = $__67.Catch,
    ClassDeclaration = $__67.ClassDeclaration,
    ClassExpression = $__67.ClassExpression,
    CommaExpression = $__67.CommaExpression,
    ComprehensionFor = $__67.ComprehensionFor,
    ComprehensionIf = $__67.ComprehensionIf,
    ComputedPropertyName = $__67.ComputedPropertyName,
    ConditionalExpression = $__67.ConditionalExpression,
    ContinueStatement = $__67.ContinueStatement,
    CoverFormals = $__67.CoverFormals,
    CoverInitialisedName = $__67.CoverInitialisedName,
    DebuggerStatement = $__67.DebuggerStatement,
    DefaultClause = $__67.DefaultClause,
    DoWhileStatement = $__67.DoWhileStatement,
    EmptyStatement = $__67.EmptyStatement,
    ExportDeclaration = $__67.ExportDeclaration,
    ExportSpecifier = $__67.ExportSpecifier,
    ExportSpecifierSet = $__67.ExportSpecifierSet,
    ExportStar = $__67.ExportStar,
    ExpressionStatement = $__67.ExpressionStatement,
    Finally = $__67.Finally,
    ForInStatement = $__67.ForInStatement,
    ForOfStatement = $__67.ForOfStatement,
    ForStatement = $__67.ForStatement,
    FormalParameter = $__67.FormalParameter,
    FormalParameterList = $__67.FormalParameterList,
    FunctionBody = $__67.FunctionBody,
    FunctionDeclaration = $__67.FunctionDeclaration,
    FunctionExpression = $__67.FunctionExpression,
    GeneratorComprehension = $__67.GeneratorComprehension,
    GetAccessor = $__67.GetAccessor,
    IdentifierExpression = $__67.IdentifierExpression,
    IfStatement = $__67.IfStatement,
    ImportDeclaration = $__67.ImportDeclaration,
    ImportSpecifier = $__67.ImportSpecifier,
    ImportSpecifierSet = $__67.ImportSpecifierSet,
    LabelledStatement = $__67.LabelledStatement,
    LiteralExpression = $__67.LiteralExpression,
    LiteralPropertyName = $__67.LiteralPropertyName,
    MemberExpression = $__67.MemberExpression,
    MemberLookupExpression = $__67.MemberLookupExpression,
    Module = $__67.Module,
    ModuleDeclaration = $__67.ModuleDeclaration,
    ModuleSpecifier = $__67.ModuleSpecifier,
    NamedExport = $__67.NamedExport,
    NewExpression = $__67.NewExpression,
    ObjectLiteralExpression = $__67.ObjectLiteralExpression,
    ObjectPattern = $__67.ObjectPattern,
    ObjectPatternField = $__67.ObjectPatternField,
    ParenExpression = $__67.ParenExpression,
    PostfixExpression = $__67.PostfixExpression,
    PredefinedType = $__67.PredefinedType,
    Script = $__67.Script,
    PropertyMethodAssignment = $__67.PropertyMethodAssignment,
    PropertyNameAssignment = $__67.PropertyNameAssignment,
    PropertyNameShorthand = $__67.PropertyNameShorthand,
    RestParameter = $__67.RestParameter,
    ReturnStatement = $__67.ReturnStatement,
    SetAccessor = $__67.SetAccessor,
    SpreadExpression = $__67.SpreadExpression,
    SpreadPatternElement = $__67.SpreadPatternElement,
    SuperExpression = $__67.SuperExpression,
    SwitchStatement = $__67.SwitchStatement,
    SyntaxErrorTree = $__67.SyntaxErrorTree,
    TemplateLiteralExpression = $__67.TemplateLiteralExpression,
    TemplateLiteralPortion = $__67.TemplateLiteralPortion,
    TemplateSubstitution = $__67.TemplateSubstitution,
    ThisExpression = $__67.ThisExpression,
    ThrowStatement = $__67.ThrowStatement,
    TryStatement = $__67.TryStatement,
    TypeName = $__67.TypeName,
    UnaryExpression = $__67.UnaryExpression,
    VariableDeclaration = $__67.VariableDeclaration,
    VariableDeclarationList = $__67.VariableDeclarationList,
    VariableStatement = $__67.VariableStatement,
    WhileStatement = $__67.WhileStatement,
    WithStatement = $__67.WithStatement,
    YieldExpression = $__67.YieldExpression;
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 createPropertyNameToken(name) {
  return createIdentifierToken(name);
}
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 createEmptyParameters() {
  return [];
}
function createStatementList(statementsOrHead) {
  for (var args = [],
      $__65 = 1; $__65 < arguments.length; $__65++)
    args[$__65 - 1] = arguments[$__65];
  if (statementsOrHead instanceof Array)
    return $traceurRuntime.spread(statementsOrHead, args);
  return slice(arguments);
}
function createBindingElement(arg) {
  var binding = createBindingIdentifier(arg);
  return new BindingElement(null, binding, null);
}
function createFormalParameter(arg) {
  return new FormalParameter(null, createBindingElement(arg), null, []);
}
function createParameterList(arg0, var_args) {
  if (typeof arg0 == 'string') {
    var parameterList = map(arguments, createFormalParameter);
    return new FormalParameterList(null, parameterList);
  }
  if (typeof arg0 == 'number')
    return createParameterListHelper(arg0, false);
  if (arg0 instanceof IdentifierToken) {
    return new FormalParameterList(null, [createFormalParameter(arg0)]);
  }
  var builder = arg0.map(createFormalParameter);
  return new FormalParameterList(null, builder);
}
function createParameterListHelper(numberOfParameters, hasRestParams) {
  var builder = [];
  for (var index = 0; index < numberOfParameters; index++) {
    var parameterName = getParameterName(index);
    var isRestParameter = index == numberOfParameters - 1 && hasRestParams;
    builder.push(isRestParameter ? new FormalParameter(null, createRestParameter(parameterName), null, []) : createFormalParameter(parameterName));
  }
  return new FormalParameterList(null, builder);
}
function createParameterListWithRestParams(numberOfParameters) {
  return createParameterListHelper(numberOfParameters, true);
}
function createParameterReference(index) {
  return createIdentifierExpression(getParameterName(index));
}
function createEmptyParameterList() {
  return new FormalParameterList(null, []);
}
function createEmptyList() {
  return [];
}
function createArgumentList(numberListOrFirst, var_args) {
  if (typeof numberListOrFirst == 'number') {
    return createArgumentListFromParameterList(createParameterList(numberListOrFirst));
  }
  var list;
  if (numberListOrFirst instanceof Array)
    list = numberListOrFirst;
  else
    list = slice(arguments);
  return new ArgumentList(null, list);
}
function createArgumentListFromParameterList(parameterList) {
  var builder = parameterList.parameters.map(function(parameter) {
    if (parameter.isRestParameter()) {
      return createSpreadExpression(createIdentifierExpression(parameter.identifier));
    } else {
      return parameter;
    }
  });
  return new ArgumentList(null, builder);
}
function createEmptyArgumentList() {
  return new ArgumentList(null, createEmptyList());
}
function createArrayLiteralExpression(list) {
  return new ArrayLiteralExpression(null, list);
}
function createEmptyArrayLiteralExpression() {
  return createArrayLiteralExpression(createEmptyList());
}
function createArrayPattern(list) {
  return new ArrayPattern(null, list);
}
function createAssignmentExpression(lhs, rhs) {
  return new BinaryOperator(null, lhs, createOperatorToken(EQUAL), rhs);
}
function createBinaryOperator(left, operator, right) {
  return new BinaryOperator(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 createEmptyStatement() {
  return new EmptyStatement(null);
}
function createEmptyBlock() {
  return createBlock(createEmptyList());
}
function createBlock(statements) {
  if (statements instanceof ParseTree)
    statements = slice(arguments);
  return new Block(null, statements);
}
function createFunctionBody(statements) {
  return new FunctionBody(null, statements);
}
function createScopedExpression(body) {
  var scope = arguments[1] !== (void 0) ? arguments[1] : createThisExpression();
  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 createBoundCall(func, thisTree) {
  return createCallExpression(createMemberExpression(func.type == ParseTreeType.FUNCTION_EXPRESSION ? createParenExpression(func) : func, BIND), createArgumentList(thisTree));
}
function createBreakStatement() {
  var name = arguments[0] !== (void 0) ? arguments[0] : null;
  return new BreakStatement(null, name);
}
function createCallCall(func, thisExpression, args, var_args) {
  var $__68;
  if (args instanceof ParseTree)
    args = slice(arguments, 2);
  var builder = [thisExpression];
  if (args)
    ($__68 = builder).push.apply($__68, $traceurRuntime.toObject(args));
  return createCallExpression(createMemberExpression(func, CALL), createArgumentList(builder));
}
function createCallCallStatement(func, thisExpression) {
  for (var args = [],
      $__66 = 2; $__66 < arguments.length; $__66++)
    args[$__66 - 2] = arguments[$__66];
  return createExpressionStatement(createCallCall(func, thisExpression, args));
}
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 createGetAccessor(name, body) {
  if (typeof name == 'string')
    name = createPropertyNameToken(name);
  var isStatic = false;
  return new GetAccessor(null, isStatic, name, 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 createLabelledStatement(name, statement) {
  return new LabelledStatement(null, name, statement);
}
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, memberNames) {
  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 = 2; i < arguments.length; i++) {
    tree = createMemberExpression(tree, arguments[i]);
  }
  return tree;
}
function createMemberLookupExpression(operand, memberExpression) {
  return new MemberLookupExpression(null, operand, memberExpression);
}
function createThisExpression() {
  var memberName = arguments[0];
  var result = new ThisExpression(null);
  if (memberName) {
    result = createMemberExpression(result, memberName);
  }
  return result;
}
function createNewExpression(operand, args) {
  return new NewExpression(null, operand, args);
}
function createObjectFreeze(value) {
  return createCallExpression(createMemberExpression(OBJECT, FREEZE), createArgumentList(value));
}
function createObjectPreventExtensions(value) {
  return createCallExpression(createMemberExpression(OBJECT, PREVENT_EXTENSIONS), createArgumentList(value));
}
function createObjectCreate(protoExpression, descriptors) {
  var argumentList = [protoExpression];
  if (descriptors)
    argumentList.push(descriptors);
  return createCallExpression(createMemberExpression(OBJECT, CREATE), createArgumentList(argumentList));
}
function createPropertyDescriptor(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 createObjectLiteralExpression(propertyNameAndValues);
}
function createDefineProperty(tree, name, descr) {
  if (typeof name === 'string')
    name = createStringLiteral(name);
  return createCallExpression(createMemberExpression(OBJECT, DEFINE_PROPERTY), createArgumentList(tree, name, createPropertyDescriptor(descr)));
}
function createObjectLiteralExpression(propertyNameAndValues) {
  if (propertyNameAndValues instanceof ParseTree)
    propertyNameAndValues = slice(arguments);
  return new ObjectLiteralExpression(null, propertyNameAndValues);
}
function createObjectPattern(list) {
  return new ObjectPattern(null, list);
}
function createObjectPatternField(identifier, element) {
  identifier = createBindingIdentifier(identifier);
  return new ObjectPatternField(null, identifier, element);
}
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);
}
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) {
  return new RestParameter(null, createBindingIdentifier(identifier));
}
function createReturnStatement(expression) {
  return new ReturnStatement(null, expression);
}
function createYieldStatement(expression, isYieldFor) {
  return createExpressionStatement(new YieldExpression(null, expression, isYieldFor));
}
function createSetAccessor(name, parameter, body) {
  if (typeof name == 'string')
    name = createPropertyNameToken(name);
  if (typeof parameter == 'string')
    parameter = createIdentifierToken(parameter);
  var parameterList = createParameterList(parameter);
  var isStatic = false;
  return new SetAccessor(null, isStatic, name, parameterList, [], body);
}
function createSpreadExpression(expression) {
  return new SpreadExpression(null, expression);
}
function createSpreadPatternElement(lvalue) {
  return new SpreadPatternElement(null, lvalue);
}
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, initializer) {
  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, identifier, initializer) {
  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 createPropertyNameToken() {
    return createPropertyNameToken;
  },
  get createStringLiteralToken() {
    return createStringLiteralToken;
  },
  get createBooleanLiteralToken() {
    return createBooleanLiteralToken;
  },
  get createNullLiteralToken() {
    return createNullLiteralToken;
  },
  get createNumberLiteralToken() {
    return createNumberLiteralToken;
  },
  get createEmptyParameters() {
    return createEmptyParameters;
  },
  get createStatementList() {
    return createStatementList;
  },
  get createBindingElement() {
    return createBindingElement;
  },
  get createFormalParameter() {
    return createFormalParameter;
  },
  get createParameterList() {
    return createParameterList;
  },
  get createParameterListWithRestParams() {
    return createParameterListWithRestParams;
  },
  get createParameterReference() {
    return createParameterReference;
  },
  get createEmptyParameterList() {
    return createEmptyParameterList;
  },
  get createEmptyList() {
    return createEmptyList;
  },
  get createArgumentList() {
    return createArgumentList;
  },
  get createArgumentListFromParameterList() {
    return createArgumentListFromParameterList;
  },
  get createEmptyArgumentList() {
    return createEmptyArgumentList;
  },
  get createArrayLiteralExpression() {
    return createArrayLiteralExpression;
  },
  get createEmptyArrayLiteralExpression() {
    return createEmptyArrayLiteralExpression;
  },
  get createArrayPattern() {
    return createArrayPattern;
  },
  get createAssignmentExpression() {
    return createAssignmentExpression;
  },
  get createBinaryOperator() {
    return createBinaryOperator;
  },
  get createBindingIdentifier() {
    return createBindingIdentifier;
  },
  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 createBoundCall() {
    return createBoundCall;
  },
  get createBreakStatement() {
    return createBreakStatement;
  },
  get createCallCall() {
    return createCallCall;
  },
  get createCallCallStatement() {
    return createCallCallStatement;
  },
  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 createGetAccessor() {
    return createGetAccessor;
  },
  get createIdentifierExpression() {
    return createIdentifierExpression;
  },
  get createUndefinedExpression() {
    return createUndefinedExpression;
  },
  get createIfStatement() {
    return createIfStatement;
  },
  get createLabelledStatement() {
    return createLabelledStatement;
  },
  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 createObjectPreventExtensions() {
    return createObjectPreventExtensions;
  },
  get createObjectCreate() {
    return createObjectCreate;
  },
  get createPropertyDescriptor() {
    return createPropertyDescriptor;
  },
  get createDefineProperty() {
    return createDefineProperty;
  },
  get createObjectLiteralExpression() {
    return createObjectLiteralExpression;
  },
  get createObjectPattern() {
    return createObjectPattern;
  },
  get createObjectPatternField() {
    return createObjectPatternField;
  },
  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 createYieldStatement() {
    return createYieldStatement;
  },
  get createSetAccessor() {
    return createSetAccessor;
  },
  get createSpreadExpression() {
    return createSpreadExpression;
  },
  get createSpreadPatternElement() {
    return createSpreadPatternElement;
  },
  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;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/ParseTreeTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ParseTreeTransformer";
var $__70 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    Annotation = $__70.Annotation,
    AnonBlock = $__70.AnonBlock,
    ArgumentList = $__70.ArgumentList,
    ArrayComprehension = $__70.ArrayComprehension,
    ArrayLiteralExpression = $__70.ArrayLiteralExpression,
    ArrayPattern = $__70.ArrayPattern,
    ArrowFunctionExpression = $__70.ArrowFunctionExpression,
    AwaitExpression = $__70.AwaitExpression,
    BinaryOperator = $__70.BinaryOperator,
    BindingElement = $__70.BindingElement,
    BindingIdentifier = $__70.BindingIdentifier,
    Block = $__70.Block,
    BreakStatement = $__70.BreakStatement,
    CallExpression = $__70.CallExpression,
    CaseClause = $__70.CaseClause,
    Catch = $__70.Catch,
    ClassDeclaration = $__70.ClassDeclaration,
    ClassExpression = $__70.ClassExpression,
    CommaExpression = $__70.CommaExpression,
    ComprehensionFor = $__70.ComprehensionFor,
    ComprehensionIf = $__70.ComprehensionIf,
    ComputedPropertyName = $__70.ComputedPropertyName,
    ConditionalExpression = $__70.ConditionalExpression,
    ContinueStatement = $__70.ContinueStatement,
    CoverFormals = $__70.CoverFormals,
    CoverInitialisedName = $__70.CoverInitialisedName,
    DebuggerStatement = $__70.DebuggerStatement,
    DefaultClause = $__70.DefaultClause,
    DoWhileStatement = $__70.DoWhileStatement,
    EmptyStatement = $__70.EmptyStatement,
    ExportDeclaration = $__70.ExportDeclaration,
    ExportDefault = $__70.ExportDefault,
    ExportSpecifier = $__70.ExportSpecifier,
    ExportSpecifierSet = $__70.ExportSpecifierSet,
    ExportStar = $__70.ExportStar,
    ExpressionStatement = $__70.ExpressionStatement,
    Finally = $__70.Finally,
    ForInStatement = $__70.ForInStatement,
    ForOfStatement = $__70.ForOfStatement,
    ForStatement = $__70.ForStatement,
    FormalParameter = $__70.FormalParameter,
    FormalParameterList = $__70.FormalParameterList,
    FunctionBody = $__70.FunctionBody,
    FunctionDeclaration = $__70.FunctionDeclaration,
    FunctionExpression = $__70.FunctionExpression,
    GeneratorComprehension = $__70.GeneratorComprehension,
    GetAccessor = $__70.GetAccessor,
    IdentifierExpression = $__70.IdentifierExpression,
    IfStatement = $__70.IfStatement,
    ImportedBinding = $__70.ImportedBinding,
    ImportDeclaration = $__70.ImportDeclaration,
    ImportSpecifier = $__70.ImportSpecifier,
    ImportSpecifierSet = $__70.ImportSpecifierSet,
    LabelledStatement = $__70.LabelledStatement,
    LiteralExpression = $__70.LiteralExpression,
    LiteralPropertyName = $__70.LiteralPropertyName,
    MemberExpression = $__70.MemberExpression,
    MemberLookupExpression = $__70.MemberLookupExpression,
    Module = $__70.Module,
    ModuleDeclaration = $__70.ModuleDeclaration,
    ModuleSpecifier = $__70.ModuleSpecifier,
    NamedExport = $__70.NamedExport,
    NewExpression = $__70.NewExpression,
    ObjectLiteralExpression = $__70.ObjectLiteralExpression,
    ObjectPattern = $__70.ObjectPattern,
    ObjectPatternField = $__70.ObjectPatternField,
    ParenExpression = $__70.ParenExpression,
    PostfixExpression = $__70.PostfixExpression,
    PredefinedType = $__70.PredefinedType,
    Script = $__70.Script,
    PropertyMethodAssignment = $__70.PropertyMethodAssignment,
    PropertyNameAssignment = $__70.PropertyNameAssignment,
    PropertyNameShorthand = $__70.PropertyNameShorthand,
    RestParameter = $__70.RestParameter,
    ReturnStatement = $__70.ReturnStatement,
    SetAccessor = $__70.SetAccessor,
    SpreadExpression = $__70.SpreadExpression,
    SpreadPatternElement = $__70.SpreadPatternElement,
    SuperExpression = $__70.SuperExpression,
    SwitchStatement = $__70.SwitchStatement,
    SyntaxErrorTree = $__70.SyntaxErrorTree,
    TemplateLiteralExpression = $__70.TemplateLiteralExpression,
    TemplateLiteralPortion = $__70.TemplateLiteralPortion,
    TemplateSubstitution = $__70.TemplateSubstitution,
    ThisExpression = $__70.ThisExpression,
    ThrowStatement = $__70.ThrowStatement,
    TryStatement = $__70.TryStatement,
    TypeName = $__70.TypeName,
    UnaryExpression = $__70.UnaryExpression,
    VariableDeclaration = $__70.VariableDeclaration,
    VariableDeclarationList = $__70.VariableDeclarationList,
    VariableStatement = $__70.VariableStatement,
    WhileStatement = $__70.WhileStatement,
    WithStatement = $__70.WithStatement,
    YieldExpression = $__70.YieldExpression;
var ParseTreeTransformer = function ParseTreeTransformer() {};
($traceurRuntime.createClass)(ParseTreeTransformer, {
  transformAny: function(tree) {
    return tree && tree.transform(this);
  },
  transformList: function(list) {
    var $__71;
    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)
          ($__71 = builder).push.apply($__71, $traceurRuntime.toObject(transformed.statements));
        else
          builder.push(transformed);
      }
    }
    return builder || list;
  },
  transformStateMachine: function(tree) {
    throw Error('State machines should not live outside of the GeneratorTransformer.');
  },
  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);
  },
  transformArrayLiteralExpression: function(tree) {
    var elements = this.transformList(tree.elements);
    if (elements === tree.elements) {
      return tree;
    }
    return new ArrayLiteralExpression(tree.location, elements);
  },
  transformArrayPattern: function(tree) {
    var elements = this.transformList(tree.elements);
    if (elements === tree.elements) {
      return tree;
    }
    return new ArrayPattern(tree.location, elements);
  },
  transformArrowFunctionExpression: function(tree) {
    var parameterList = this.transformAny(tree.parameterList);
    var functionBody = this.transformAny(tree.functionBody);
    if (parameterList === tree.parameterList && functionBody === tree.functionBody) {
      return tree;
    }
    return new ArrowFunctionExpression(tree.location, tree.functionKind, parameterList, functionBody);
  },
  transformAwaitExpression: function(tree) {
    var expression = this.transformAny(tree.expression);
    if (expression === tree.expression) {
      return tree;
    }
    return new AwaitExpression(tree.location, expression);
  },
  transformBinaryOperator: 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 BinaryOperator(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);
  },
  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);
    if (name === tree.name && superClass === tree.superClass && elements === tree.elements && annotations === tree.annotations) {
      return tree;
    }
    return new ClassDeclaration(tree.location, name, superClass, elements, annotations);
  },
  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);
    if (name === tree.name && superClass === tree.superClass && elements === tree.elements && annotations === tree.annotations) {
      return tree;
    }
    return new ClassExpression(tree.location, name, superClass, elements, annotations);
  },
  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);
  },
  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);
  },
  transformCoverInitialisedName: function(tree) {
    var initializer = this.transformAny(tree.initializer);
    if (initializer === tree.initializer) {
      return tree;
    }
    return new CoverInitialisedName(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.transformAny(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.transformAny(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.transformAny(tree.body);
    if (initializer === tree.initializer && collection === tree.collection && body === tree.body) {
      return tree;
    }
    return new ForOfStatement(tree.location, initializer, collection, 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.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);
  },
  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);
  },
  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 functionBody = this.transformAny(tree.functionBody);
    if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && functionBody === tree.functionBody) {
      return tree;
    }
    return new FunctionDeclaration(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, functionBody);
  },
  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 functionBody = this.transformAny(tree.functionBody);
    if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && functionBody === tree.functionBody) {
      return tree;
    }
    return new FunctionExpression(tree.location, name, tree.functionKind, parameterList, typeAnnotation, annotations, functionBody);
  },
  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.transformAny(tree.ifClause);
    var elseClause = this.transformAny(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);
  },
  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) {
    return tree;
  },
  transformImportSpecifierSet: function(tree) {
    var specifiers = this.transformList(tree.specifiers);
    if (specifiers === tree.specifiers) {
      return tree;
    }
    return new ImportSpecifierSet(tree.location, specifiers);
  },
  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);
  },
  transformModule: function(tree) {
    var scriptItemList = this.transformList(tree.scriptItemList);
    if (scriptItemList === tree.scriptItemList) {
      return tree;
    }
    return new Module(tree.location, scriptItemList, tree.moduleName);
  },
  transformModuleDeclaration: function(tree) {
    var expression = this.transformAny(tree.expression);
    if (expression === tree.expression) {
      return tree;
    }
    return new ModuleDeclaration(tree.location, tree.identifier, expression);
  },
  transformModuleSpecifier: function(tree) {
    return tree;
  },
  transformNamedExport: function(tree) {
    var moduleSpecifier = this.transformAny(tree.moduleSpecifier);
    var specifierSet = this.transformAny(tree.specifierSet);
    if (moduleSpecifier === tree.moduleSpecifier && specifierSet === tree.specifierSet) {
      return tree;
    }
    return new NamedExport(tree.location, moduleSpecifier, specifierSet);
  },
  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);
  },
  transformObjectLiteralExpression: function(tree) {
    var propertyNameAndValues = this.transformList(tree.propertyNameAndValues);
    if (propertyNameAndValues === tree.propertyNameAndValues) {
      return tree;
    }
    return new ObjectLiteralExpression(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);
  },
  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);
  },
  transformPropertyMethodAssignment: 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 functionBody = this.transformAny(tree.functionBody);
    if (name === tree.name && parameterList === tree.parameterList && typeAnnotation === tree.typeAnnotation && annotations === tree.annotations && functionBody === tree.functionBody) {
      return tree;
    }
    return new PropertyMethodAssignment(tree.location, tree.isStatic, tree.functionKind, name, parameterList, typeAnnotation, annotations, functionBody);
  },
  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;
  },
  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);
  },
  transformTypeName: function(tree) {
    var moduleName = this.transformAny(tree.moduleName);
    if (moduleName === tree.moduleName) {
      return tree;
    }
    return new TypeName(tree.location, moduleName, tree.name);
  },
  transformUnaryExpression: function(tree) {
    var operand = this.transformAny(tree.operand);
    if (operand === tree.operand) {
      return tree;
    }
    return new UnaryExpression(tree.location, tree.operator, operand);
  },
  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.transformAny(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.transformAny(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;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/AssignmentPatternTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/AssignmentPatternTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__73 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    ArrayPattern = $__73.ArrayPattern,
    BindingElement = $__73.BindingElement,
    BindingIdentifier = $__73.BindingIdentifier,
    IdentifierExpression = $__73.IdentifierExpression,
    ObjectPattern = $__73.ObjectPattern,
    ObjectPatternField = $__73.ObjectPatternField,
    SpreadPatternElement = $__73.SpreadPatternElement;
var EQUAL = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).EQUAL;
var AssignmentPatternTransformerError = function AssignmentPatternTransformerError() {
  $traceurRuntime.defaultSuperCall(this, $AssignmentPatternTransformerError.prototype, arguments);
};
var $AssignmentPatternTransformerError = AssignmentPatternTransformerError;
($traceurRuntime.createClass)(AssignmentPatternTransformerError, {}, {}, Error);
var AssignmentPatternTransformer = function AssignmentPatternTransformer() {
  $traceurRuntime.defaultSuperCall(this, $AssignmentPatternTransformer.prototype, arguments);
};
var $AssignmentPatternTransformer = AssignmentPatternTransformer;
($traceurRuntime.createClass)(AssignmentPatternTransformer, {
  transformBinaryOperator: function(tree) {
    if (tree.operator.type !== EQUAL)
      throw new AssignmentPatternTransformerError();
    var bindingElement = this.transformAny(tree.left);
    if (bindingElement instanceof BindingElement)
      bindingElement = bindingElement.binding;
    return new BindingElement(tree.location, bindingElement, tree.right);
  },
  transformArrayLiteralExpression: function(tree) {
    var elements = this.transformList(tree.elements);
    return new ArrayPattern(tree.location, elements);
  },
  transformCoverInitialisedName: function(tree) {
    return new BindingElement(tree.location, new BindingIdentifier(tree.name.location, tree.name), tree.initializer);
  },
  transformObjectLiteralExpression: function(tree) {
    var propertyNameAndValues = this.transformList(tree.propertyNameAndValues);
    return new ObjectPattern(tree.location, propertyNameAndValues);
  },
  transformPropertyNameAssignment: function(tree) {
    return new ObjectPatternField(tree.location, tree.name, this.transformAny(tree.value));
  },
  transformPropertyNameShorthand: function(tree) {
    return new IdentifierExpression(tree.location, tree.name);
  },
  transformSpreadExpression: function(tree) {
    return new SpreadPatternElement(tree.location, tree.expression);
  },
  transformSyntaxErrorTree: function(tree) {
    throw new AssignmentPatternTransformerError();
  }
}, {}, ParseTreeTransformer);
return {
  get AssignmentPatternTransformerError() {
    return AssignmentPatternTransformerError;
  },
  get AssignmentPatternTransformer() {
    return AssignmentPatternTransformer;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/CoverFormalsTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/CoverFormalsTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__75 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    ArrayPattern = $__75.ArrayPattern,
    BindingElement = $__75.BindingElement,
    BindingIdentifier = $__75.BindingIdentifier,
    CommaExpression = $__75.CommaExpression,
    FormalParameter = $__75.FormalParameter,
    FormalParameterList = $__75.FormalParameterList,
    ObjectPattern = $__75.ObjectPattern,
    ObjectPatternField = $__75.ObjectPatternField,
    ParenExpression = $__75.ParenExpression,
    RestParameter = $__75.RestParameter,
    SpreadPatternElement = $__75.SpreadPatternElement;
var EQUAL = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).EQUAL;
var IDENTIFIER_EXPRESSION = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")).IDENTIFIER_EXPRESSION;
var AssignmentPatternTransformerError = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AssignmentPatternTransformer")).AssignmentPatternTransformerError;
var CoverFormalsTransformerError = function CoverFormalsTransformerError(location, message) {
  this.location = location;
  this.message = message;
};
($traceurRuntime.createClass)(CoverFormalsTransformerError, {}, {}, Error);
var ToFormalParametersTransformer = function ToFormalParametersTransformer() {
  this.isValid = true;
  this.inArrayPattern_ = false;
};
($traceurRuntime.createClass)(ToFormalParametersTransformer, {
  transformCoverFormals: function(tree) {
    return this.transformListOfCandidates_(tree, tree.expressions);
  },
  transformArgumentList: function(tree) {
    return this.transformListOfCandidates_(tree, tree.args);
  },
  transformListOfCandidates_: function(tree, list) {
    var expressions = this.transformList(list).map((function(expression) {
      return new FormalParameter(expression.location, expression, null, []);
    }));
    return new FormalParameterList(tree.location, expressions);
  },
  transformIdentifierExpression: function(tree) {
    return new BindingElement(tree.location, new BindingIdentifier(tree.location, tree.identifierToken), null);
  },
  transformBinaryOperator: function(tree) {
    if (tree.operator.type !== EQUAL)
      throw new CoverFormalsTransformerError(tree.operator, ("Unexpected token " + tree.operator));
    var bindingElement = this.transformAny(tree.left);
    if (bindingElement instanceof BindingElement)
      bindingElement = bindingElement.binding;
    return new BindingElement(tree.location, bindingElement, tree.right);
  },
  transformArrayLiteralExpression: function(tree) {
    var wasInArrayPattern = this.inArrayPattern_;
    this.inArrayPattern_ = true;
    var elements = this.transformList(tree.elements);
    this.inArrayPattern_ = wasInArrayPattern;
    var okIndex = elements.length - 1;
    for (var i = 0; i < okIndex; i++) {
      if (elements[i] instanceof SpreadPatternElement)
        throw new CoverFormalsTransformerError(elements[i].location, 'Unexpected token ...');
    }
    return new BindingElement(tree.location, new ArrayPattern(tree.location, elements), null);
  },
  transformObjectLiteralExpression: function(tree) {
    var propertyNameAndValues = this.transformList(tree.propertyNameAndValues);
    return new BindingElement(tree.location, new ObjectPattern(tree.location, propertyNameAndValues), null);
  },
  transformCoverInitialisedName: function(tree) {
    return new BindingElement(tree.location, new BindingIdentifier(tree.location, tree.name), tree.initializer);
  },
  transformPropertyNameAssignment: function(tree) {
    return new ObjectPatternField(tree.location, tree.name, this.transformAny(tree.value));
  },
  transformPropertyNameShorthand: function(tree) {
    return new BindingElement(tree.location, new BindingIdentifier(tree.location, tree.name), null);
  },
  transformSpreadExpression: function(tree) {
    if (tree.expression.type !== IDENTIFIER_EXPRESSION)
      throw new CoverFormalsTransformerError(tree.expression.location, 'identifier expected');
    var bindingIdentifier = new BindingIdentifier(tree.expression.location, tree.expression.identifierToken);
    if (this.inArrayPattern_)
      return new SpreadPatternElement(tree.location, bindingIdentifier);
    return new RestParameter(tree.location, bindingIdentifier);
  },
  transformSyntaxErrorTree: function(tree) {
    throw new AssignmentPatternTransformerError();
  }
}, {}, ParseTreeTransformer);
function toParenExpression(tree) {
  var expressions = tree.expressions;
  var length = expressions.length;
  if (length === 0)
    throw new CoverFormalsTransformerError(tree.location, 'Unexpected token )');
  for (var i = 0; i < length; i++) {
    if (expressions[i].isRestParameter())
      throw new CoverFormalsTransformerError(expressions[i].location, 'Unexpected token ...');
  }
  var expression;
  if (expressions.length > 1) {
    expression = new CommaExpression(expressions[0].location, expressions);
  } else {
    expression = expressions[0];
  }
  return new ParenExpression(tree.location, expression);
}
function toFormalParameters(tree) {
  var transformer = new ToFormalParametersTransformer();
  return transformer.transformAny(tree);
}
return {
  get CoverFormalsTransformerError() {
    return CoverFormalsTransformerError;
  },
  get toParenExpression() {
    return toParenExpression;
  },
  get toFormalParameters() {
    return toFormalParameters;
  }
};

}); System.register(“traceur@0.0.43/src/staticsemantics/StrictParams”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/staticsemantics/StrictParams";
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var isStrictKeyword = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Keywords")).isStrictKeyword;
var StrictParams = function StrictParams(errorReporter) {
  $traceurRuntime.superCall(this, $StrictParams.prototype, "constructor", []);
  this.errorReporter = errorReporter;
};
var $StrictParams = StrictParams;
($traceurRuntime.createClass)(StrictParams, {visitBindingIdentifier: function(tree) {
    var name = tree.identifierToken.toString();
    if (isStrictKeyword(name)) {
      this.errorReporter.reportError(tree.location.start, (name + " is a reserved identifier"));
    }
  }}, {visit: function(tree, errorReporter) {
    new $StrictParams(errorReporter).visitAny(tree);
  }}, ParseTreeVisitor);
return {get StrictParams() {
    return StrictParams;
  }};

}); System.register(“traceur@0.0.43/src/util/SourceRange”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/SourceRange";
var SourceRange = function SourceRange(start, end) {
  this.start = start;
  this.end = end;
};
($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;
  }};

}); System.register(“traceur@0.0.43/src/util/ErrorReporter”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/ErrorReporter";
var ErrorReporter = function ErrorReporter() {
  this.hadError_ = false;
};
($traceurRuntime.createClass)(ErrorReporter, {
  reportError: function(location, message) {
    this.hadError_ = true;
    this.reportMessageInternal(location, message);
  },
  reportMessageInternal: function(location, message) {
    if (location)
      message = (location + ": " + 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;
  }
};

}); System.register(“traceur@0.0.43/src/util/SyntaxErrorReporter”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/SyntaxErrorReporter";
var $__81 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ErrorReporter")),
    ErrorReporter = $__81.ErrorReporter,
    format = $__81.format;
var SyntaxErrorReporter = function SyntaxErrorReporter() {
  $traceurRuntime.defaultSuperCall(this, $SyntaxErrorReporter.prototype, arguments);
};
var $SyntaxErrorReporter = SyntaxErrorReporter;
($traceurRuntime.createClass)(SyntaxErrorReporter, {reportMessageInternal: function(location, message) {
    var s = format(location, message);
    throw new SyntaxError(s);
  }}, {}, ErrorReporter);
return {get SyntaxErrorReporter() {
    return SyntaxErrorReporter;
  }};

}); System.register(“traceur@0.0.43/src/syntax/Parser”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/Parser";
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AssignmentPatternTransformer")),
    AssignmentPatternTransformer = $__85.AssignmentPatternTransformer,
    AssignmentPatternTransformerError = $__85.AssignmentPatternTransformerError;
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/CoverFormalsTransformer")),
    toFormalParameters = $__85.toFormalParameters,
    toParenExpression = $__85.toParenExpression,
    CoverFormalsTransformerError = $__85.CoverFormalsTransformerError;
var IdentifierToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/IdentifierToken")).IdentifierToken;
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    ARGUMENT_LIST = $__85.ARGUMENT_LIST,
    ARRAY_LITERAL_EXPRESSION = $__85.ARRAY_LITERAL_EXPRESSION,
    BINARY_OPERATOR = $__85.BINARY_OPERATOR,
    BINDING_IDENTIFIER = $__85.BINDING_IDENTIFIER,
    CALL_EXPRESSION = $__85.CALL_EXPRESSION,
    CLASS_DECLARATION = $__85.CLASS_DECLARATION,
    COMMA_EXPRESSION = $__85.COMMA_EXPRESSION,
    COMPUTED_PROPERTY_NAME = $__85.COMPUTED_PROPERTY_NAME,
    COVER_FORMALS = $__85.COVER_FORMALS,
    FORMAL_PARAMETER_LIST = $__85.FORMAL_PARAMETER_LIST,
    FUNCTION_DECLARATION = $__85.FUNCTION_DECLARATION,
    IDENTIFIER_EXPRESSION = $__85.IDENTIFIER_EXPRESSION,
    LITERAL_PROPERTY_NAME = $__85.LITERAL_PROPERTY_NAME,
    MEMBER_EXPRESSION = $__85.MEMBER_EXPRESSION,
    MEMBER_LOOKUP_EXPRESSION = $__85.MEMBER_LOOKUP_EXPRESSION,
    OBJECT_LITERAL_EXPRESSION = $__85.OBJECT_LITERAL_EXPRESSION,
    PAREN_EXPRESSION = $__85.PAREN_EXPRESSION,
    PROPERTY_NAME_ASSIGNMENT = $__85.PROPERTY_NAME_ASSIGNMENT,
    REST_PARAMETER = $__85.REST_PARAMETER,
    SYNTAX_ERROR_TREE = $__85.SYNTAX_ERROR_TREE;
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    AS = $__85.AS,
    ASYNC = $__85.ASYNC,
    AWAIT = $__85.AWAIT,
    FROM = $__85.FROM,
    GET = $__85.GET,
    MODULE = $__85.MODULE,
    OF = $__85.OF,
    SET = $__85.SET;
var SyntaxErrorReporter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/SyntaxErrorReporter")).SyntaxErrorReporter;
var Scanner = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Scanner")).Scanner;
var SourceRange = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/SourceRange")).SourceRange;
var StrictParams = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/staticsemantics/StrictParams")).StrictParams;
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")),
    Token = $__85.Token,
    isAssignmentOperator = $__85.isAssignmentOperator;
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")),
    parseOptions = $__85.parseOptions,
    options = $__85.options;
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    AMPERSAND = $__85.AMPERSAND,
    AMPERSAND_EQUAL = $__85.AMPERSAND_EQUAL,
    AND = $__85.AND,
    ARROW = $__85.ARROW,
    AT = $__85.AT,
    BACK_QUOTE = $__85.BACK_QUOTE,
    BANG = $__85.BANG,
    BAR = $__85.BAR,
    BAR_EQUAL = $__85.BAR_EQUAL,
    BREAK = $__85.BREAK,
    CARET = $__85.CARET,
    CARET_EQUAL = $__85.CARET_EQUAL,
    CASE = $__85.CASE,
    CATCH = $__85.CATCH,
    CLASS = $__85.CLASS,
    CLOSE_ANGLE = $__85.CLOSE_ANGLE,
    CLOSE_CURLY = $__85.CLOSE_CURLY,
    CLOSE_PAREN = $__85.CLOSE_PAREN,
    CLOSE_SQUARE = $__85.CLOSE_SQUARE,
    COLON = $__85.COLON,
    COMMA = $__85.COMMA,
    CONST = $__85.CONST,
    CONTINUE = $__85.CONTINUE,
    DEBUGGER = $__85.DEBUGGER,
    DEFAULT = $__85.DEFAULT,
    DELETE = $__85.DELETE,
    DO = $__85.DO,
    DOT_DOT_DOT = $__85.DOT_DOT_DOT,
    ELSE = $__85.ELSE,
    END_OF_FILE = $__85.END_OF_FILE,
    ENUM = $__85.ENUM,
    EQUAL = $__85.EQUAL,
    EQUAL_EQUAL = $__85.EQUAL_EQUAL,
    EQUAL_EQUAL_EQUAL = $__85.EQUAL_EQUAL_EQUAL,
    ERROR = $__85.ERROR,
    EXPORT = $__85.EXPORT,
    EXTENDS = $__85.EXTENDS,
    FALSE = $__85.FALSE,
    FINALLY = $__85.FINALLY,
    FOR = $__85.FOR,
    FUNCTION = $__85.FUNCTION,
    GREATER_EQUAL = $__85.GREATER_EQUAL,
    IDENTIFIER = $__85.IDENTIFIER,
    IF = $__85.IF,
    IMPLEMENTS = $__85.IMPLEMENTS,
    IMPORT = $__85.IMPORT,
    IN = $__85.IN,
    INSTANCEOF = $__85.INSTANCEOF,
    INTERFACE = $__85.INTERFACE,
    LEFT_SHIFT = $__85.LEFT_SHIFT,
    LEFT_SHIFT_EQUAL = $__85.LEFT_SHIFT_EQUAL,
    LESS_EQUAL = $__85.LESS_EQUAL,
    LET = $__85.LET,
    MINUS = $__85.MINUS,
    MINUS_EQUAL = $__85.MINUS_EQUAL,
    MINUS_MINUS = $__85.MINUS_MINUS,
    NEW = $__85.NEW,
    NO_SUBSTITUTION_TEMPLATE = $__85.NO_SUBSTITUTION_TEMPLATE,
    NOT_EQUAL = $__85.NOT_EQUAL,
    NOT_EQUAL_EQUAL = $__85.NOT_EQUAL_EQUAL,
    NULL = $__85.NULL,
    NUMBER = $__85.NUMBER,
    OPEN_ANGLE = $__85.OPEN_ANGLE,
    OPEN_CURLY = $__85.OPEN_CURLY,
    OPEN_PAREN = $__85.OPEN_PAREN,
    OPEN_SQUARE = $__85.OPEN_SQUARE,
    OR = $__85.OR,
    PACKAGE = $__85.PACKAGE,
    PERCENT = $__85.PERCENT,
    PERCENT_EQUAL = $__85.PERCENT_EQUAL,
    PERIOD = $__85.PERIOD,
    PLUS = $__85.PLUS,
    PLUS_EQUAL = $__85.PLUS_EQUAL,
    PLUS_PLUS = $__85.PLUS_PLUS,
    PRIVATE = $__85.PRIVATE,
    PROTECTED = $__85.PROTECTED,
    PUBLIC = $__85.PUBLIC,
    QUESTION = $__85.QUESTION,
    REGULAR_EXPRESSION = $__85.REGULAR_EXPRESSION,
    RETURN = $__85.RETURN,
    RIGHT_SHIFT = $__85.RIGHT_SHIFT,
    RIGHT_SHIFT_EQUAL = $__85.RIGHT_SHIFT_EQUAL,
    SEMI_COLON = $__85.SEMI_COLON,
    SLASH = $__85.SLASH,
    SLASH_EQUAL = $__85.SLASH_EQUAL,
    STAR = $__85.STAR,
    STAR_EQUAL = $__85.STAR_EQUAL,
    STATIC = $__85.STATIC,
    STRING = $__85.STRING,
    SUPER = $__85.SUPER,
    SWITCH = $__85.SWITCH,
    TEMPLATE_HEAD = $__85.TEMPLATE_HEAD,
    TEMPLATE_MIDDLE = $__85.TEMPLATE_MIDDLE,
    TEMPLATE_TAIL = $__85.TEMPLATE_TAIL,
    THIS = $__85.THIS,
    THROW = $__85.THROW,
    TILDE = $__85.TILDE,
    TRUE = $__85.TRUE,
    TRY = $__85.TRY,
    TYPEOF = $__85.TYPEOF,
    UNSIGNED_RIGHT_SHIFT = $__85.UNSIGNED_RIGHT_SHIFT,
    UNSIGNED_RIGHT_SHIFT_EQUAL = $__85.UNSIGNED_RIGHT_SHIFT_EQUAL,
    VAR = $__85.VAR,
    VOID = $__85.VOID,
    WHILE = $__85.WHILE,
    WITH = $__85.WITH,
    YIELD = $__85.YIELD;
var $__85 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    ArgumentList = $__85.ArgumentList,
    ArrayComprehension = $__85.ArrayComprehension,
    ArrayLiteralExpression = $__85.ArrayLiteralExpression,
    ArrayPattern = $__85.ArrayPattern,
    ArrowFunctionExpression = $__85.ArrowFunctionExpression,
    AwaitExpression = $__85.AwaitExpression,
    BinaryOperator = $__85.BinaryOperator,
    BindingElement = $__85.BindingElement,
    BindingIdentifier = $__85.BindingIdentifier,
    Block = $__85.Block,
    BreakStatement = $__85.BreakStatement,
    CallExpression = $__85.CallExpression,
    CaseClause = $__85.CaseClause,
    Catch = $__85.Catch,
    ClassDeclaration = $__85.ClassDeclaration,
    ClassExpression = $__85.ClassExpression,
    CommaExpression = $__85.CommaExpression,
    ComprehensionFor = $__85.ComprehensionFor,
    ComprehensionIf = $__85.ComprehensionIf,
    ComputedPropertyName = $__85.ComputedPropertyName,
    ConditionalExpression = $__85.ConditionalExpression,
    ContinueStatement = $__85.ContinueStatement,
    CoverFormals = $__85.CoverFormals,
    CoverInitialisedName = $__85.CoverInitialisedName,
    DebuggerStatement = $__85.DebuggerStatement,
    Annotation = $__85.Annotation,
    DefaultClause = $__85.DefaultClause,
    DoWhileStatement = $__85.DoWhileStatement,
    EmptyStatement = $__85.EmptyStatement,
    ExportDeclaration = $__85.ExportDeclaration,
    ExportDefault = $__85.ExportDefault,
    ExportSpecifier = $__85.ExportSpecifier,
    ExportSpecifierSet = $__85.ExportSpecifierSet,
    ExportStar = $__85.ExportStar,
    ExpressionStatement = $__85.ExpressionStatement,
    Finally = $__85.Finally,
    ForInStatement = $__85.ForInStatement,
    ForOfStatement = $__85.ForOfStatement,
    ForStatement = $__85.ForStatement,
    FormalParameter = $__85.FormalParameter,
    FormalParameterList = $__85.FormalParameterList,
    FunctionBody = $__85.FunctionBody,
    FunctionDeclaration = $__85.FunctionDeclaration,
    FunctionExpression = $__85.FunctionExpression,
    GeneratorComprehension = $__85.GeneratorComprehension,
    GetAccessor = $__85.GetAccessor,
    IdentifierExpression = $__85.IdentifierExpression,
    IfStatement = $__85.IfStatement,
    ImportDeclaration = $__85.ImportDeclaration,
    ImportSpecifier = $__85.ImportSpecifier,
    ImportSpecifierSet = $__85.ImportSpecifierSet,
    ImportedBinding = $__85.ImportedBinding,
    LabelledStatement = $__85.LabelledStatement,
    LiteralExpression = $__85.LiteralExpression,
    LiteralPropertyName = $__85.LiteralPropertyName,
    MemberExpression = $__85.MemberExpression,
    MemberLookupExpression = $__85.MemberLookupExpression,
    Module = $__85.Module,
    ModuleDeclaration = $__85.ModuleDeclaration,
    ModuleSpecifier = $__85.ModuleSpecifier,
    NamedExport = $__85.NamedExport,
    NewExpression = $__85.NewExpression,
    ObjectLiteralExpression = $__85.ObjectLiteralExpression,
    ObjectPattern = $__85.ObjectPattern,
    ObjectPatternField = $__85.ObjectPatternField,
    ParenExpression = $__85.ParenExpression,
    PostfixExpression = $__85.PostfixExpression,
    PredefinedType = $__85.PredefinedType,
    Script = $__85.Script,
    PropertyMethodAssignment = $__85.PropertyMethodAssignment,
    PropertyNameAssignment = $__85.PropertyNameAssignment,
    PropertyNameShorthand = $__85.PropertyNameShorthand,
    RestParameter = $__85.RestParameter,
    ReturnStatement = $__85.ReturnStatement,
    SetAccessor = $__85.SetAccessor,
    SpreadExpression = $__85.SpreadExpression,
    SpreadPatternElement = $__85.SpreadPatternElement,
    SuperExpression = $__85.SuperExpression,
    SwitchStatement = $__85.SwitchStatement,
    SyntaxErrorTree = $__85.SyntaxErrorTree,
    TemplateLiteralExpression = $__85.TemplateLiteralExpression,
    TemplateLiteralPortion = $__85.TemplateLiteralPortion,
    TemplateSubstitution = $__85.TemplateSubstitution,
    ThisExpression = $__85.ThisExpression,
    ThrowStatement = $__85.ThrowStatement,
    TryStatement = $__85.TryStatement,
    TypeName = $__85.TypeName,
    UnaryExpression = $__85.UnaryExpression,
    VariableDeclaration = $__85.VariableDeclaration,
    VariableDeclarationList = $__85.VariableDeclarationList,
    VariableStatement = $__85.VariableStatement,
    WhileStatement = $__85.WhileStatement,
    WithStatement = $__85.WithStatement,
    YieldExpression = $__85.YieldExpression;
var Expression = {
  NO_IN: 'NO_IN',
  NORMAL: 'NORMAL'
};
var DestructuringInitializer = {
  REQUIRED: 'REQUIRED',
  OPTIONAL: 'OPTIONAL'
};
var Initializer = {
  ALLOWED: 'ALLOWED',
  REQUIRED: 'REQUIRED'
};
var Parser = function Parser(file) {
  var errorReporter = arguments[1] !== (void 0) ? arguments[1] : new SyntaxErrorReporter();
  this.errorReporter_ = errorReporter;
  this.scanner_ = new Scanner(errorReporter, file, this);
  this.allowYield_ = false;
  this.allowAwait_ = false;
  this.strictMode_ = false;
  this.coverInitialisedName_ = null;
  this.annotations_ = [];
};
($traceurRuntime.createClass)(Parser, {
  parseScript: function() {
    this.strictMode_ = false;
    var start = this.getTreeStartLocation_();
    var scriptItemList = this.parseScriptItemList_();
    this.eat_(END_OF_FILE);
    return new Script(this.getTreeLocation_(start), scriptItemList);
  },
  parseScriptItemList_: function() {
    var result = [];
    var type;
    var checkUseStrictDirective = true;
    while ((type = this.peekType_()) !== END_OF_FILE) {
      var scriptItem = this.parseScriptItem_(type, false);
      if (checkUseStrictDirective) {
        if (!scriptItem.isDirectivePrologue()) {
          checkUseStrictDirective = false;
        } else if (scriptItem.isUseStrictDirective()) {
          this.strictMode_ = true;
          checkUseStrictDirective = false;
        }
      }
      result.push(scriptItem);
    }
    return result;
  },
  parseScriptItem_: function(type, allowModuleItem) {
    return this.parseStatement_(type, allowModuleItem, true);
  },
  parseModule: function() {
    var start = this.getTreeStartLocation_();
    var scriptItemList = this.parseModuleItemList_();
    this.eat_(END_OF_FILE);
    return new Module(this.getTreeLocation_(start), scriptItemList);
  },
  parseModuleItemList_: function() {
    this.strictMode_ = true;
    var result = [];
    var type;
    while ((type = this.peekType_()) !== END_OF_FILE) {
      var scriptItem = this.parseScriptItem_(type, true);
      result.push(scriptItem);
    }
    return result;
  },
  parseModuleSpecifier_: function() {
    var start = this.getTreeStartLocation_();
    var token = this.eat_(STRING);
    return new ModuleSpecifier(this.getTreeLocation_(start), token);
  },
  parseImportDeclaration_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(IMPORT);
    var importClause = null;
    if (this.peekImportClause_(this.peekType_())) {
      importClause = this.parseImportClause_();
      this.eatId_(FROM);
    }
    var moduleSpecifier = this.parseModuleSpecifier_();
    this.eatPossibleImplicitSemiColon_();
    return new ImportDeclaration(this.getTreeLocation_(start), importClause, moduleSpecifier);
  },
  peekImportClause_: function(type) {
    return type === OPEN_CURLY || this.peekBindingIdentifier_(type);
  },
  parseImportClause_: function() {
    var start = this.getTreeStartLocation_();
    if (this.eatIf_(OPEN_CURLY)) {
      var specifiers = [];
      while (!this.peek_(CLOSE_CURLY) && !this.isAtEnd()) {
        specifiers.push(this.parseImportSpecifier_());
        if (!this.eatIf_(COMMA))
          break;
      }
      this.eat_(CLOSE_CURLY);
      return new ImportSpecifierSet(this.getTreeLocation_(start), specifiers);
    }
    var binding = this.parseBindingIdentifier_();
    return new ImportedBinding(this.getTreeLocation_(start), binding);
  },
  parseImportSpecifier_: function() {
    var start = this.getTreeStartLocation_();
    var token = this.peekToken_();
    var isKeyword = token.isKeyword();
    var lhs = this.eatIdName_();
    var rhs = null;
    if (isKeyword || this.peekPredefinedString_(AS)) {
      this.eatId_(AS);
      rhs = this.eatId_();
    }
    return new ImportSpecifier(this.getTreeLocation_(start), lhs, rhs);
  },
  parseExportDeclaration_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(EXPORT);
    var exportTree;
    var annotations = this.popAnnotations_();
    var type = this.peekType_();
    switch (type) {
      case CONST:
      case LET:
      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 (options.asyncFunctions && this.peekPredefinedString_(ASYNC)) {
          var asyncToken = this.eatId_();
          exportTree = this.parseAsyncFunctionDeclaration_(asyncToken);
          break;
        }
      default:
        return this.parseUnexpectedToken_(type);
    }
    return new ExportDeclaration(this.getTreeLocation_(start), exportTree, annotations);
  },
  parseExportDefault_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(DEFAULT);
    var expression = this.parseAssignmentExpression();
    this.eatPossibleImplicitSemiColon_();
    return new ExportDefault(this.getTreeLocation_(start), expression);
  },
  parseNamedExport_: function() {
    var start = this.getTreeStartLocation_();
    var specifierSet,
        expression;
    if (this.peek_(OPEN_CURLY)) {
      specifierSet = this.parseExportSpecifierSet_();
      expression = this.parseFromModuleSpecifierOpt_(false);
    } else {
      this.eat_(STAR);
      specifierSet = new ExportStar(this.getTreeLocation_(start));
      expression = this.parseFromModuleSpecifierOpt_(true);
    }
    this.eatPossibleImplicitSemiColon_();
    return new NamedExport(this.getTreeLocation_(start), expression, specifierSet);
  },
  parseFromModuleSpecifierOpt_: function(required) {
    if (required || this.peekPredefinedString_(FROM)) {
      this.eatId_(FROM);
      return this.parseModuleSpecifier_();
    }
    return null;
  },
  parseExportSpecifierSet_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(OPEN_CURLY);
    var specifiers = [this.parseExportSpecifier_()];
    while (this.eatIf_(COMMA)) {
      if (this.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.eatId_();
    var rhs = null;
    if (this.peekPredefinedString_(AS)) {
      this.eatId_();
      rhs = this.eatIdName_();
    }
    return new ExportSpecifier(this.getTreeLocation_(start), lhs, rhs);
  },
  peekId_: function(type) {
    if (type === IDENTIFIER)
      return true;
    if (this.strictMode_)
      return false;
    return this.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 annotations = [];
    if (constr == ClassDeclaration || !this.peek_(EXTENDS) && !this.peek_(OPEN_CURLY)) {
      name = this.parseBindingIdentifier_();
      annotations = this.popAnnotations_();
    }
    var superClass = null;
    if (this.eatIf_(EXTENDS)) {
      superClass = this.parseAssignmentExpression();
    }
    this.eat_(OPEN_CURLY);
    var elements = this.parseClassElements_();
    this.eat_(CLOSE_CURLY);
    this.strictMode_ = strictMode;
    return new constr(this.getTreeLocation_(start), name, superClass, elements, annotations);
  },
  parseClassDeclaration_: function() {
    return this.parseClassShared_(ClassDeclaration);
  },
  parseClassExpression_: function() {
    return this.parseClassShared_(ClassExpression);
  },
  parseClassElements_: function() {
    var result = [];
    while (true) {
      var type = this.peekType_();
      if (type === SEMI_COLON) {
        this.nextToken_();
      } else if (this.peekClassElement_(this.peekType_())) {
        result.push(this.parseClassElement_());
      } else {
        break;
      }
    }
    return result;
  },
  peekClassElement_: function(type) {
    return this.peekPropertyName_(type) || type === STAR && parseOptions.generators || type === AT && parseOptions.annotations;
  },
  parsePropertyName_: function() {
    if (this.peek_(OPEN_SQUARE))
      return this.parseComputedPropertyName_();
    return this.parseLiteralPropertyName_();
  },
  parseLiteralPropertyName_: function() {
    var start = this.getTreeStartLocation_();
    var token = this.nextToken_();
    return new LiteralPropertyName(this.getTreeLocation_(start), token);
  },
  parseComputedPropertyName_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(OPEN_SQUARE);
    var expression = this.parseAssignmentExpression();
    this.eat_(CLOSE_SQUARE);
    return new ComputedPropertyName(this.getTreeLocation_(start), expression);
  },
  parseStatement: function() {
    return this.parseStatement_(this.peekType_(), false, false);
  },
  parseStatement_: function(type, allowModuleItem, allowScriptItem) {
    switch (type) {
      case RETURN:
        return this.parseReturnStatement_();
      case CONST:
      case LET:
        if (!parseOptions.blockBinding)
          break;
      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 FUNCTION:
        return this.parseFunctionDeclaration_();
      case AT:
        if (parseOptions.annotations)
          return this.parseAnnotatedDeclarations_(allowModuleItem, allowScriptItem);
        break;
      case CLASS:
        if (parseOptions.classes)
          return this.parseClassDeclaration_();
        break;
      case CONTINUE:
        return this.parseContinueStatement_();
      case DEBUGGER:
        return this.parseDebuggerStatement_();
      case DO:
        return this.parseDoWhileStatement_();
      case EXPORT:
        if (allowModuleItem && parseOptions.modules)
          return this.parseExportDeclaration_();
        break;
      case IMPORT:
        if (allowScriptItem && parseOptions.modules)
          return this.parseImportDeclaration_();
        break;
      case OPEN_CURLY:
        return this.parseBlock_();
      case SEMI_COLON:
        return this.parseEmptyStatement_();
      case TRY:
        return this.parseTryStatement_();
      case WITH:
        return this.parseWithStatement_();
    }
    return this.parseFallThroughStatement_(allowScriptItem);
  },
  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);
  },
  parseAsyncFunction_: function(asyncToken, ctor) {
    var start = asyncToken.location.start;
    this.eat_(FUNCTION);
    return this.parseFunction2_(start, asyncToken, ctor);
  },
  parseFunction_: function(ctor) {
    var start = this.getTreeStartLocation_();
    this.eat_(FUNCTION);
    var functionKind = null;
    if (parseOptions.generators && this.peek_(STAR))
      functionKind = this.eat_(STAR);
    return this.parseFunction2_(start, functionKind, ctor);
  },
  parseFunction2_: function(start, functionKind, ctor) {
    var name = null;
    var annotations = [];
    if (ctor === FunctionDeclaration || this.peekBindingIdentifier_(this.peekType_())) {
      name = this.parseBindingIdentifier_();
      annotations = this.popAnnotations_();
    }
    this.eat_(OPEN_PAREN);
    var parameterList = this.parseFormalParameterList_();
    this.eat_(CLOSE_PAREN);
    var typeAnnotation = this.parseTypeAnnotationOpt_();
    var functionBody = this.parseFunctionBody_(functionKind, parameterList);
    return new ctor(this.getTreeLocation_(start), name, functionKind, parameterList, typeAnnotation, annotations, functionBody);
  },
  peekRest_: function(type) {
    return type === DOT_DOT_DOT && parseOptions.restParameters;
  },
  parseFormalParameterList_: function() {
    var start = this.getTreeStartLocation_();
    var formals = [];
    this.pushAnnotations_();
    var type = this.peekType_();
    if (this.peekRest_(type)) {
      formals.push(this.parseFormalRestParameter_());
    } else {
      if (this.peekFormalParameter_(this.peekType_()))
        formals.push(this.parseFormalParameter_());
      while (this.eatIf_(COMMA)) {
        this.pushAnnotations_();
        if (this.peekRest_(this.peekType_())) {
          formals.push(this.parseFormalRestParameter_());
          break;
        }
        formals.push(this.parseFormalParameter_());
      }
    }
    return new FormalParameterList(this.getTreeLocation_(start), formals);
  },
  peekFormalParameter_: function(type) {
    return this.peekBindingElement_(type);
  },
  parseFormalParameter_: function() {
    var initializerAllowed = arguments[0];
    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_();
    return new RestParameter(this.getTreeLocation_(start), id);
  },
  parseFunctionBody_: function(functionKind, params) {
    var start = this.getTreeStartLocation_();
    this.eat_(OPEN_CURLY);
    var allowYield = this.allowYield_;
    var allowAwait = this.allowAwait_;
    var strictMode = this.strictMode_;
    this.allowYield_ = functionKind && functionKind.type === STAR;
    this.allowAwait_ = functionKind && functionKind.type === IDENTIFIER && functionKind.value === ASYNC;
    var result = this.parseStatementList_(!strictMode);
    if (!strictMode && this.strictMode_ && params)
      StrictParams.visit(params, this.errorReporter_);
    this.strictMode_ = strictMode;
    this.allowYield_ = allowYield;
    this.allowAwait_ = allowAwait;
    this.eat_(CLOSE_CURLY);
    return new FunctionBody(this.getTreeLocation_(start), result);
  },
  parseStatements: function() {
    return this.parseStatementList_(false);
  },
  parseStatementList_: function(checkUseStrictDirective) {
    var result = [];
    var type;
    while ((type = this.peekType_()) !== CLOSE_CURLY && type !== END_OF_FILE) {
      var statement = this.parseStatement_(type, false, false);
      if (checkUseStrictDirective) {
        if (!statement.isDirectivePrologue()) {
          checkUseStrictDirective = false;
        } else if (statement.isUseStrictDirective()) {
          this.strictMode_ = true;
          checkUseStrictDirective = false;
        }
      }
      result.push(statement);
    }
    return result;
  },
  parseSpreadExpression_: function() {
    if (!parseOptions.spread)
      return this.parseUnexpectedToken_(DOT_DOT_DOT);
    var start = this.getTreeStartLocation_();
    this.eat_(DOT_DOT_DOT);
    var operand = this.parseAssignmentExpression();
    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_();
    this.checkInitializers_(declarations);
    this.eatPossibleImplicitSemiColon_();
    return new VariableStatement(this.getTreeLocation_(start), declarations);
  },
  parseVariableDeclarationList_: function() {
    var expressionIn = arguments[0] !== (void 0) ? arguments[0] : Expression.NORMAL;
    var initializer = arguments[1] !== (void 0) ? arguments[1] : DestructuringInitializer.REQUIRED;
    var type = this.peekType_();
    switch (type) {
      case CONST:
      case LET:
        if (!parseOptions.blockBinding)
          debugger;
      case VAR:
        this.nextToken_();
        break;
      default:
        throw Error('unreachable');
    }
    var start = this.getTreeStartLocation_();
    var declarations = [];
    declarations.push(this.parseVariableDeclaration_(type, expressionIn, initializer));
    while (this.eatIf_(COMMA)) {
      declarations.push(this.parseVariableDeclaration_(type, expressionIn, initializer));
    }
    return new VariableDeclarationList(this.getTreeLocation_(start), type, declarations);
  },
  parseVariableDeclaration_: function(binding, expressionIn) {
    var initializer = arguments[2] !== (void 0) ? arguments[2] : DestructuringInitializer.REQUIRED;
    var initRequired = initializer !== DestructuringInitializer.OPTIONAL;
    var start = this.getTreeStartLocation_();
    var lvalue;
    var typeAnnotation;
    if (this.peekPattern_(this.peekType_())) {
      lvalue = this.parseBindingPattern_();
      typeAnnotation = null;
    } else {
      lvalue = this.parseBindingIdentifier_();
      typeAnnotation = this.parseTypeAnnotationOpt_();
    }
    var initializer = null;
    if (this.peek_(EQUAL))
      initializer = this.parseInitializer_(expressionIn);
    else if (lvalue.isPattern() && initRequired)
      this.reportError_('destructuring must have an initializer');
    return new VariableDeclaration(this.getTreeLocation_(start), lvalue, typeAnnotation, initializer);
  },
  parseInitializer_: function(expressionIn) {
    this.eat_(EQUAL);
    return this.parseAssignmentExpression(expressionIn);
  },
  parseEmptyStatement_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(SEMI_COLON);
    return new EmptyStatement(this.getTreeLocation_(start));
  },
  parseFallThroughStatement_: function(allowScriptItem) {
    var start = this.getTreeStartLocation_();
    var expression;
    if (parseOptions.asyncFunctions && this.peekPredefinedString_(ASYNC) && this.peek_(FUNCTION, 1)) {
      var asyncToken = this.eatId_();
      var functionToken = this.peekTokenNoLineTerminator_();
      if (functionToken !== null)
        return this.parseAsyncFunctionDeclaration_(asyncToken);
      expression = new IdentifierExpression(this.getTreeLocation_(start), asyncToken);
    } else {
      expression = this.parseExpression();
    }
    if (expression.type === IDENTIFIER_EXPRESSION) {
      var nameToken = expression.identifierToken;
      if (this.eatIf_(COLON)) {
        var statement = this.parseStatement();
        return new LabelledStatement(this.getTreeLocation_(start), nameToken, statement);
      }
      if (allowScriptItem && nameToken.value === MODULE && parseOptions.modules) {
        var token = this.peekTokenNoLineTerminator_();
        if (token !== null && token.type === IDENTIFIER) {
          var name = this.eatId_();
          this.eatId_(FROM);
          var moduleSpecifier = this.parseModuleSpecifier_();
          this.eatPossibleImplicitSemiColon_();
          return new ModuleDeclaration(this.getTreeLocation_(start), name, moduleSpecifier);
        }
      }
    }
    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();
    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();
    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();
    this.eat_(CLOSE_PAREN);
    var body = this.parseStatement();
    return new WhileStatement(this.getTreeLocation_(start), condition, body);
  },
  parseForStatement_: function() {
    var $__82 = this;
    var start = this.getTreeStartLocation_();
    this.eat_(FOR);
    this.eat_(OPEN_PAREN);
    var validate = (function(variables, kind) {
      if (variables.declarations.length > 1) {
        $__82.reportError_(kind + ' statement may not have more than one variable declaration');
      }
      var declaration = variables.declarations[0];
      if (declaration.lvalue.isPattern() && declaration.initializer) {
        $__82.reportError_(declaration.initializer.location, ("initializer is not allowed in " + kind + " loop with pattern"));
      }
    });
    var type = this.peekType_();
    if (this.peekVariableDeclarationList_(type)) {
      var variables = this.parseVariableDeclarationList_(Expression.NO_IN, DestructuringInitializer.OPTIONAL);
      type = this.peekType_();
      if (type === IN) {
        validate(variables, 'for-in');
        var declaration = variables.declarations[0];
        if (parseOptions.blockBinding && (variables.declarationType == LET || variables.declarationType == CONST)) {
          if (declaration.initializer != null) {
            this.reportError_('let/const in for-in statement may not have initializer');
          }
        }
        return this.parseForInStatement_(start, variables);
      } else if (this.peekOf_(type)) {
        validate(variables, 'for-of');
        var declaration = variables.declarations[0];
        if (declaration.initializer != null) {
          this.reportError_('for-of statement may not have initializer');
        }
        return this.parseForOfStatement_(start, variables);
      } else {
        this.checkInitializers_(variables);
        return this.parseForStatement2_(start, variables);
      }
    }
    if (type === SEMI_COLON) {
      return this.parseForStatement2_(start, null);
    }
    var initializer = this.parseExpression(Expression.NO_IN);
    type = this.peekType_();
    if (initializer.isLeftHandSideExpression() && (type === IN || this.peekOf_(type))) {
      initializer = this.transformLeftHandSideExpression_(initializer);
      if (this.peekOf_(type))
        return this.parseForOfStatement_(start, initializer);
      return this.parseForInStatement_(start, initializer);
    }
    return this.parseForStatement2_(start, initializer);
  },
  peekOf_: function(type) {
    return type === IDENTIFIER && parseOptions.forOf && this.peekToken_().value === OF;
  },
  parseForOfStatement_: function(start, initializer) {
    this.eatId_();
    var collection = this.parseExpression();
    this.eat_(CLOSE_PAREN);
    var body = this.parseStatement();
    return new ForOfStatement(this.getTreeLocation_(start), initializer, collection, body);
  },
  checkInitializers_: function(variables) {
    if (parseOptions.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 (parseOptions.blockBinding && type == CONST && declaration.initializer == null) {
      this.reportError_('const variables must have an initializer');
      return false;
    }
    return true;
  },
  peekVariableDeclarationList_: function(type) {
    switch (type) {
      case VAR:
        return true;
      case CONST:
      case LET:
        return parseOptions.blockBinding;
      default:
        return false;
    }
  },
  parseForStatement2_: function(start, initializer) {
    this.eat_(SEMI_COLON);
    var condition = null;
    if (!this.peek_(SEMI_COLON)) {
      condition = this.parseExpression();
    }
    this.eat_(SEMI_COLON);
    var increment = null;
    if (!this.peek_(CLOSE_PAREN)) {
      increment = this.parseExpression();
    }
    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();
    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_(this.peekType_())) {
      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_(this.peekType_())) {
      name = this.eatIdOpt_();
    }
    this.eatPossibleImplicitSemiColon_();
    return new BreakStatement(this.getTreeLocation_(start), name);
  },
  parseReturnStatement_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(RETURN);
    var expression = null;
    if (!this.peekImplicitSemiColon_(this.peekType_())) {
      expression = this.parseExpression();
    }
    this.eatPossibleImplicitSemiColon_();
    return new ReturnStatement(this.getTreeLocation_(start), expression);
  },
  parseYieldExpression_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(YIELD);
    var expression = null;
    var isYieldFor = false;
    if (!this.peekImplicitSemiColon_(this.peekType_())) {
      isYieldFor = this.eatIf_(STAR);
      expression = this.parseAssignmentExpression();
    }
    return new YieldExpression(this.getTreeLocation_(start), expression, isYieldFor);
  },
  parseWithStatement_: function() {
    if (this.strictMode_)
      this.reportError_('Strict mode code may not include a with statement');
    var start = this.getTreeStartLocation_();
    this.eat_(WITH);
    this.eat_(OPEN_PAREN);
    var expression = this.parseExpression();
    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();
    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 (this.peekType_()) {
        case CASE:
          this.nextToken_();
          var expression = this.parseExpression();
          this.eat_(COLON);
          var statements = this.parseCaseStatementsOpt_();
          result.push(new CaseClause(this.getTreeLocation_(start), expression, statements));
          break;
        case DEFAULT:
          if (foundDefaultClause) {
            this.reportError_('Switch statements may have at most one default clause');
          } else {
            foundDefaultClause = true;
          }
          this.nextToken_();
          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 = this.peekType_()) {
        case CASE:
        case DEFAULT:
        case CLOSE_CURLY:
        case END_OF_FILE:
          return result;
      }
      result.push(this.parseStatement_(type, false, false));
    }
  },
  parseThrowStatement_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(THROW);
    var value = null;
    if (!this.peekImplicitSemiColon_(this.peekType_())) {
      value = this.parseExpression();
    }
    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 (this.peek_(CATCH)) {
      catchBlock = this.parseCatch_();
    }
    var finallyBlock = null;
    if (this.peek_(FINALLY)) {
      finallyBlock = this.parseFinallyBlock_();
    }
    if (catchBlock == null && finallyBlock == null) {
      this.reportError_("'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_(this.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 (this.peekType_()) {
      case CLASS:
        return parseOptions.classes ? this.parseClassExpression_() : this.parseSyntaxError_('Unexpected reserved word');
      case THIS:
        return this.parseThisExpression_();
      case IDENTIFIER:
        var identifier = this.parseIdentifierExpression_();
        if (parseOptions.asyncFunctions && identifier.identifierToken.value === ASYNC) {
          var token = this.peekTokenNoLineTerminator_();
          if (token && token.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:
        return this.parseTemplateLiteral_(null);
      case IMPLEMENTS:
      case INTERFACE:
      case PACKAGE:
      case PRIVATE:
      case PROTECTED:
      case PUBLIC:
      case STATIC:
      case YIELD:
        if (!this.strictMode_)
          return this.parseIdentifierExpression_();
        this.reportReservedIdentifier_(this.nextToken_());
      case END_OF_FILE:
        return this.parseSyntaxError_('Unexpected end of input');
      default:
        return this.parseUnexpectedToken_(this.peekToken_());
    }
  },
  parseSuperExpression_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(SUPER);
    return new SuperExpression(this.getTreeLocation_(start));
  },
  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 this.nextToken_();
  },
  parseRegularExpressionLiteral_: function() {
    var start = this.getTreeStartLocation_();
    var literal = this.nextRegularExpressionLiteralToken_();
    return new LiteralExpression(this.getTreeLocation_(start), literal);
  },
  peekSpread_: function(type) {
    return type === DOT_DOT_DOT && parseOptions.spread;
  },
  parseArrayLiteral_: function() {
    var start = this.getTreeStartLocation_();
    var expression;
    var elements = [];
    this.eat_(OPEN_SQUARE);
    var type = this.peekType_();
    if (type === FOR && parseOptions.arrayComprehension)
      return this.parseArrayComprehension_(start);
    while (true) {
      type = this.peekType_();
      if (type === COMMA) {
        expression = null;
      } else if (this.peekSpread_(type)) {
        expression = this.parseSpreadExpression_();
      } else if (this.peekAssignmentExpression_(type)) {
        expression = this.parseAssignmentExpression();
      } else {
        break;
      }
      elements.push(expression);
      type = this.peekType_();
      if (type !== CLOSE_SQUARE)
        this.eat_(COMMA);
    }
    this.eat_(CLOSE_SQUARE);
    return new ArrayLiteralExpression(this.getTreeLocation_(start), elements);
  },
  parseArrayComprehension_: function(start) {
    var list = this.parseComprehensionList_();
    var expression = this.parseAssignmentExpression();
    this.eat_(CLOSE_SQUARE);
    return new ArrayComprehension(this.getTreeLocation_(start), list, expression);
  },
  parseComprehensionList_: function() {
    var list = [this.parseComprehensionFor_()];
    while (true) {
      var type = this.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();
    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();
    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_(this.peekType_())) {
      var propertyDefinition = this.parsePropertyDefinition();
      result.push(propertyDefinition);
      if (!this.eatIf_(COMMA))
        break;
    }
    this.eat_(CLOSE_CURLY);
    return new ObjectLiteralExpression(this.getTreeLocation_(start), result);
  },
  parsePropertyDefinition: function() {
    var start = this.getTreeStartLocation_();
    var functionKind = null;
    var isStatic = false;
    if (parseOptions.generators && parseOptions.propertyMethods && this.peek_(STAR)) {
      return this.parseGeneratorMethod_(start, isStatic, []);
    }
    var token = this.peekToken_();
    var name = this.parsePropertyName_();
    if (parseOptions.propertyMethods && this.peek_(OPEN_PAREN))
      return this.parseMethod_(start, isStatic, functionKind, name, []);
    if (this.eatIf_(COLON)) {
      var value = this.parseAssignmentExpression();
      return new PropertyNameAssignment(this.getTreeLocation_(start), name, value);
    }
    var type = this.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 (parseOptions.asyncFunctions && nameLiteral.value === ASYNC && this.peekPropertyName_(type)) {
        var async = nameLiteral;
        var name = this.parsePropertyName_();
        return this.parseMethod_(start, isStatic, async, name, []);
      }
      if (parseOptions.propertyNameShorthand && nameLiteral.type === IDENTIFIER || !this.strictMode_ && nameLiteral.type === YIELD) {
        if (this.peek_(EQUAL)) {
          token = this.nextToken_();
          var expr = this.parseAssignmentExpression();
          return this.coverInitialisedName_ = new CoverInitialisedName(this.getTreeLocation_(start), nameLiteral, token, expr);
        }
        if (nameLiteral.type === YIELD)
          nameLiteral = new IdentifierToken(nameLiteral.location, YIELD);
        return new PropertyNameShorthand(this.getTreeLocation_(start), nameLiteral);
      }
      if (this.strictMode_ && nameLiteral.isStrictKeyword())
        this.reportReservedIdentifier_(nameLiteral);
    }
    if (name.type === COMPUTED_PROPERTY_NAME)
      token = this.peekToken_();
    return this.parseUnexpectedToken_(token);
  },
  parseClassElement_: function() {
    var start = this.getTreeStartLocation_();
    var annotations = this.parseAnnotations_();
    var type = this.peekType_();
    var isStatic = false,
        functionKind = null;
    switch (type) {
      case STATIC:
        var staticToken = this.nextToken_();
        type = this.peekType_();
        switch (type) {
          case OPEN_PAREN:
            var name = new LiteralPropertyName(start, staticToken);
            return this.parseMethod_(start, isStatic, functionKind, name, annotations);
          default:
            isStatic = true;
            if (type === STAR && parseOptions.generators)
              return this.parseGeneratorMethod_(start, true, annotations);
            return this.parseGetSetOrMethod_(start, isStatic, annotations);
        }
        break;
      case STAR:
        return this.parseGeneratorMethod_(start, isStatic, annotations);
      default:
        return this.parseGetSetOrMethod_(start, isStatic, annotations);
    }
  },
  parseGeneratorMethod_: function(start, isStatic, annotations) {
    var functionKind = this.eat_(STAR);
    var name = this.parsePropertyName_();
    return this.parseMethod_(start, isStatic, functionKind, name, annotations);
  },
  parseMethod_: function(start, isStatic, functionKind, name, annotations) {
    this.eat_(OPEN_PAREN);
    var parameterList = this.parseFormalParameterList_();
    this.eat_(CLOSE_PAREN);
    var typeAnnotation = this.parseTypeAnnotationOpt_();
    var functionBody = this.parseFunctionBody_(functionKind, parameterList);
    return new PropertyMethodAssignment(this.getTreeLocation_(start), isStatic, functionKind, name, parameterList, typeAnnotation, annotations, functionBody);
  },
  parseGetSetOrMethod_: function(start, isStatic, annotations) {
    var functionKind = null;
    var name = this.parsePropertyName_();
    var type = this.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 (parseOptions.asyncFunctions && name.type === LITERAL_PROPERTY_NAME && name.literalToken.value === ASYNC && this.peekPropertyName_(type)) {
      var async = name.literalToken;
      var name = this.parsePropertyName_();
      return this.parseMethod_(start, isStatic, async, name, annotations);
    }
    return this.parseMethod_(start, isStatic, functionKind, name, annotations);
  },
  parseGetAccessor_: function(start, isStatic, annotations) {
    var functionKind = null;
    var name = this.parsePropertyName_();
    this.eat_(OPEN_PAREN);
    this.eat_(CLOSE_PAREN);
    var typeAnnotation = this.parseTypeAnnotationOpt_();
    var body = this.parseFunctionBody_(functionKind, null);
    return new GetAccessor(this.getTreeLocation_(start), isStatic, name, typeAnnotation, annotations, body);
  },
  parseSetAccessor_: function(start, isStatic, annotations) {
    var functionKind = null;
    var name = this.parsePropertyName_();
    this.eat_(OPEN_PAREN);
    var parameterList = this.parsePropertySetParameterList_();
    this.eat_(CLOSE_PAREN);
    var body = this.parseFunctionBody_(functionKind, parameterList);
    return new SetAccessor(this.getTreeLocation_(start), isStatic, name, parameterList, annotations, body);
  },
  peekPropertyDefinition_: function(type) {
    return this.peekPropertyName_(type) || type == STAR && parseOptions.propertyMethods && parseOptions.generators;
  },
  peekPropertyName_: function(type) {
    switch (type) {
      case IDENTIFIER:
      case STRING:
      case NUMBER:
        return true;
      case OPEN_SQUARE:
        return parseOptions.computedPropertyNames;
      default:
        return this.peekToken_().isKeyword();
    }
  },
  peekPredefinedString_: function(string) {
    var token = this.peekToken_();
    return token.type === IDENTIFIER && token.value === string;
  },
  parsePropertySetParameterList_: function() {
    var start = this.getTreeStartLocation_();
    var binding;
    this.pushAnnotations_();
    if (this.peekPattern_(this.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 (this.peek_(FOR) && parseOptions.generatorComprehension)
      return this.parseGeneratorComprehension_(start);
    return this.parseCoverFormals_(start);
  },
  parseSyntaxError_: function(message) {
    var start = this.getTreeStartLocation_();
    this.reportError_(message);
    var token = this.nextToken_();
    return new SyntaxErrorTree(this.getTreeLocation_(start), token, message);
  },
  parseUnexpectedToken_: function(name) {
    return this.parseSyntaxError_(("Unexpected token " + name));
  },
  peekExpression_: function(type) {
    switch (type) {
      case NO_SUBSTITUTION_TEMPLATE:
      case TEMPLATE_HEAD:
        return parseOptions.templateLiterals;
      case BANG:
      case CLASS:
      case DELETE:
      case FALSE:
      case FUNCTION:
      case IDENTIFIER:
      case MINUS:
      case MINUS_MINUS:
      case NEW:
      case NULL:
      case NUMBER:
      case OPEN_CURLY:
      case OPEN_PAREN:
      case OPEN_SQUARE:
      case PLUS:
      case PLUS_PLUS:
      case SLASH:
      case SLASH_EQUAL:
      case STRING:
      case SUPER:
      case THIS:
      case TILDE:
      case TRUE:
      case TYPEOF:
      case VOID:
      case YIELD:
        return true;
      default:
        return false;
    }
  },
  parseExpression: function() {
    var expressionIn = arguments[0] !== (void 0) ? arguments[0] : Expression.IN;
    var start = this.getTreeStartLocation_();
    var result = this.parseAssignmentExpression(expressionIn);
    if (this.peek_(COMMA)) {
      var exprs = [result];
      while (this.eatIf_(COMMA)) {
        exprs.push(this.parseAssignmentExpression(expressionIn));
      }
      return new CommaExpression(this.getTreeLocation_(start), exprs);
    }
    return result;
  },
  peekAssignmentExpression_: function(type) {
    return this.peekExpression_(type);
  },
  parseAssignmentExpression: function() {
    var expressionIn = arguments[0] !== (void 0) ? arguments[0] : Expression.NORMAL;
    var allowCoverGrammar = arguments[1];
    if (this.allowYield_ && this.peek_(YIELD))
      return this.parseYieldExpression_();
    var start = this.getTreeStartLocation_();
    var validAsyncParen = false;
    if (options.asyncFunctions && this.peekPredefinedString_(ASYNC)) {
      var asyncToken = this.peekToken_();
      var maybeOpenParenToken = this.peekToken_(1);
      validAsyncParen = maybeOpenParenToken.type === OPEN_PAREN && asyncToken.location.end.line === maybeOpenParenToken.location.start.line;
    }
    var left = this.parseConditional_(expressionIn);
    var type = this.peekType_();
    if (options.asyncFunctions && left.type === IDENTIFIER_EXPRESSION && left.identifierToken.value === ASYNC && type === IDENTIFIER) {
      if (this.peekTokenNoLineTerminator_() !== null) {
        var bindingIdentifier = this.parseBindingIdentifier_();
        var asyncToken = left.IdentifierToken;
        return this.parseArrowFunction_(start, bindingIdentifier, asyncToken);
      }
    }
    if (type === ARROW) {
      if (left.type === COVER_FORMALS || left.type === IDENTIFIER_EXPRESSION)
        return this.parseArrowFunction_(start, left, null);
      if (validAsyncParen && left.type === CALL_EXPRESSION) {
        var arrowToken = this.peekTokenNoLineTerminator_();
        if (arrowToken !== null) {
          var asyncToken = left.operand.identifierToken;
          return this.parseArrowFunction_(start, left.args, asyncToken);
        }
      }
    }
    if (this.peekAssignmentOperator_(type)) {
      if (type === EQUAL)
        left = this.transformLeftHandSideExpression_(left);
      else
        left = this.toParenExpression_(left);
      if (!allowCoverGrammar)
        this.ensureAssignmenExpression_();
      if (!left.isLeftHandSideExpression() && !left.isPattern()) {
        this.reportError_('Left hand side of assignment must be new, call, member, function, primary expressions or destructuring pattern');
      }
      var operator = this.nextToken_();
      var right = this.parseAssignmentExpression(expressionIn);
      return new BinaryOperator(this.getTreeLocation_(start), left, operator, right);
    }
    left = this.toParenExpression_(left);
    if (!allowCoverGrammar)
      this.ensureAssignmenExpression_();
    return left;
  },
  ensureAssignmenExpression_: function() {
    if (this.coverInitialisedName_) {
      var token = this.coverInitialisedName_.equalToken;
      this.reportError_(token.location, ("Unexpected token '" + token + "'"));
      this.coverInitialisedName_ = null;
    }
  },
  transformLeftHandSideExpression_: function(tree) {
    switch (tree.type) {
      case ARRAY_LITERAL_EXPRESSION:
      case OBJECT_LITERAL_EXPRESSION:
        var transformer = new AssignmentPatternTransformer();
        var transformedTree;
        try {
          transformedTree = transformer.transformAny(tree);
        } catch (ex) {
          if (!(ex instanceof AssignmentPatternTransformerError))
            throw ex;
        }
        if (transformedTree) {
          this.coverInitialisedName_ = null;
          return transformedTree;
        }
        break;
      case PAREN_EXPRESSION:
        var expression = this.transformLeftHandSideExpression_(tree.expression);
        if (expression !== tree.expression)
          return new ParenExpression(tree.location, expression);
    }
    return tree;
  },
  peekAssignmentOperator_: function(type) {
    return isAssignmentOperator(type);
  },
  parseConditional_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var condition = this.parseLogicalOR_(expressionIn);
    if (this.eatIf_(QUESTION)) {
      condition = this.toParenExpression_(condition);
      var left = this.parseAssignmentExpression();
      this.eat_(COLON);
      var right = this.parseAssignmentExpression(expressionIn);
      return new ConditionalExpression(this.getTreeLocation_(start), condition, left, right);
    }
    return condition;
  },
  newBinaryOperator_: function(start, left, operator, right) {
    left = this.toParenExpression_(left);
    right = this.toParenExpression_(right);
    return new BinaryOperator(this.getTreeLocation_(start), left, operator, right);
  },
  parseLogicalOR_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var left = this.parseLogicalAND_(expressionIn);
    var operator;
    while (operator = this.eatOpt_(OR)) {
      var right = this.parseLogicalAND_(expressionIn);
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  parseLogicalAND_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var left = this.parseBitwiseOR_(expressionIn);
    var operator;
    while (operator = this.eatOpt_(AND)) {
      var right = this.parseBitwiseOR_(expressionIn);
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  parseBitwiseOR_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var left = this.parseBitwiseXOR_(expressionIn);
    var operator;
    while (operator = this.eatOpt_(BAR)) {
      var right = this.parseBitwiseXOR_(expressionIn);
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  parseBitwiseXOR_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var left = this.parseBitwiseAND_(expressionIn);
    var operator;
    while (operator = this.eatOpt_(CARET)) {
      var right = this.parseBitwiseAND_(expressionIn);
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  parseBitwiseAND_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var left = this.parseEquality_(expressionIn);
    var operator;
    while (operator = this.eatOpt_(AMPERSAND)) {
      var right = this.parseEquality_(expressionIn);
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  parseEquality_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var left = this.parseRelational_(expressionIn);
    while (this.peekEqualityOperator_(this.peekType_())) {
      var operator = this.nextToken_();
      var right = this.parseRelational_(expressionIn);
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  peekEqualityOperator_: function(type) {
    switch (type) {
      case EQUAL_EQUAL:
      case NOT_EQUAL:
      case EQUAL_EQUAL_EQUAL:
      case NOT_EQUAL_EQUAL:
        return true;
    }
    return false;
  },
  parseRelational_: function(expressionIn) {
    var start = this.getTreeStartLocation_();
    var left = this.parseShiftExpression_();
    while (this.peekRelationalOperator_(expressionIn)) {
      var operator = this.nextToken_();
      var right = this.parseShiftExpression_();
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  peekRelationalOperator_: function(expressionIn) {
    switch (this.peekType_()) {
      case OPEN_ANGLE:
      case CLOSE_ANGLE:
      case GREATER_EQUAL:
      case LESS_EQUAL:
      case INSTANCEOF:
        return true;
      case IN:
        return expressionIn == Expression.NORMAL;
      default:
        return false;
    }
  },
  parseShiftExpression_: function() {
    var start = this.getTreeStartLocation_();
    var left = this.parseAdditiveExpression_();
    while (this.peekShiftOperator_(this.peekType_())) {
      var operator = this.nextToken_();
      var right = this.parseAdditiveExpression_();
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  peekShiftOperator_: function(type) {
    switch (type) {
      case LEFT_SHIFT:
      case RIGHT_SHIFT:
      case UNSIGNED_RIGHT_SHIFT:
        return true;
      default:
        return false;
    }
  },
  parseAdditiveExpression_: function() {
    var start = this.getTreeStartLocation_();
    var left = this.parseMultiplicativeExpression_();
    while (this.peekAdditiveOperator_(this.peekType_())) {
      var operator = this.nextToken_();
      var right = this.parseMultiplicativeExpression_();
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  peekAdditiveOperator_: function(type) {
    switch (type) {
      case PLUS:
      case MINUS:
        return true;
      default:
        return false;
    }
  },
  parseMultiplicativeExpression_: function() {
    var start = this.getTreeStartLocation_();
    var left = this.parseUnaryExpression_();
    while (this.peekMultiplicativeOperator_(this.peekType_())) {
      var operator = this.nextToken_();
      var right = this.parseUnaryExpression_();
      left = this.newBinaryOperator_(start, left, operator, right);
    }
    return left;
  },
  peekMultiplicativeOperator_: function(type) {
    switch (type) {
      case STAR:
      case SLASH:
      case PERCENT:
        return true;
      default:
        return false;
    }
  },
  parseUnaryExpression_: function() {
    var start = this.getTreeStartLocation_();
    if (this.allowAwait_ && this.peekPredefinedString_(AWAIT)) {
      this.eatId_();
      var operand = this.parseUnaryExpression_();
      operand = this.toParenExpression_(operand);
      return new AwaitExpression(this.getTreeLocation_(start), operand);
    }
    if (this.peekUnaryOperator_(this.peekType_())) {
      var operator = this.nextToken_();
      var operand = this.parseUnaryExpression_();
      operand = this.toParenExpression_(operand);
      return new UnaryExpression(this.getTreeLocation_(start), operator, operand);
    }
    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_(this.peekType_())) {
      operand = this.toParenExpression_(operand);
      var operator = this.nextToken_();
      operand = new PostfixExpression(this.getTreeLocation_(start), operand, operator);
    }
    return operand;
  },
  peekPostfixOperator_: function(type) {
    switch (type) {
      case PLUS_PLUS:
      case MINUS_MINUS:
        var token = this.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 (this.peekType_()) {
          case OPEN_PAREN:
            operand = this.toParenExpression_(operand);
            operand = this.parseCallExpression_(start, operand);
            break;
          case OPEN_SQUARE:
            operand = this.toParenExpression_(operand);
            operand = this.parseMemberLookupExpression_(start, operand);
            break;
          case PERIOD:
            operand = this.toParenExpression_(operand);
            operand = this.parseMemberExpression_(start, operand);
            break;
          case NO_SUBSTITUTION_TEMPLATE:
          case TEMPLATE_HEAD:
            if (!parseOptions.templateLiterals)
              break loop;
            operand = this.toParenExpression_(operand);
            operand = this.parseTemplateLiteral_(operand);
            break;
          default:
            break loop;
        }
      }
    }
    return operand;
  },
  parseMemberExpressionNoNew_: function() {
    var start = this.getTreeStartLocation_();
    var operand;
    if (this.peekType_() === FUNCTION) {
      operand = this.parseFunctionExpression_();
    } else {
      operand = this.parsePrimaryExpression_();
    }
    loop: while (true) {
      switch (this.peekType_()) {
        case OPEN_SQUARE:
          operand = this.toParenExpression_(operand);
          operand = this.parseMemberLookupExpression_(start, operand);
          break;
        case PERIOD:
          operand = this.toParenExpression_(operand);
          operand = this.parseMemberExpression_(start, operand);
          break;
        case NO_SUBSTITUTION_TEMPLATE:
        case TEMPLATE_HEAD:
          if (!parseOptions.templateLiterals)
            break loop;
          operand = this.toParenExpression_(operand);
          operand = this.parseTemplateLiteral_(operand);
          break;
        default:
          break loop;
      }
    }
    return operand;
  },
  parseMemberExpression_: function(start, operand) {
    this.nextToken_();
    var name = this.eatIdName_();
    return new MemberExpression(this.getTreeLocation_(start), operand, name);
  },
  parseMemberLookupExpression_: function(start, operand) {
    this.nextToken_();
    var member = this.parseExpression();
    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;
    switch (this.peekType_()) {
      case NEW:
        var start = this.getTreeStartLocation_();
        this.eat_(NEW);
        if (this.peek_(SUPER))
          operand = this.parseSuperExpression_();
        else
          operand = this.toParenExpression_(this.parseNewExpression_());
        var args = null;
        if (this.peek_(OPEN_PAREN)) {
          args = this.parseArguments_();
        }
        return new NewExpression(this.getTreeLocation_(start), operand, args);
      case SUPER:
        operand = this.parseSuperExpression_();
        var type = this.peekType_();
        switch (type) {
          case OPEN_SQUARE:
            return this.parseMemberLookupExpression_(start, operand);
          case PERIOD:
            return this.parseMemberExpression_(start, operand);
          case OPEN_PAREN:
            return this.parseCallExpression_(start, operand);
          default:
            return this.parseUnexpectedToken_(type);
        }
        break;
      default:
        return this.parseMemberExpressionNoNew_();
    }
  },
  parseArguments_: function() {
    var start = this.getTreeStartLocation_();
    var args = [];
    this.eat_(OPEN_PAREN);
    if (!this.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_(this.peekType_()))
      return this.parseSpreadExpression_();
    return this.parseAssignmentExpression();
  },
  parseArrowFunction_: function(start, tree, asyncToken) {
    var formals;
    switch (tree.type) {
      case IDENTIFIER_EXPRESSION:
        tree = new BindingIdentifier(tree.location, tree.identifierToken);
      case BINDING_IDENTIFIER:
        formals = new FormalParameterList(this.getTreeLocation_(start), [new FormalParameter(tree.location, new BindingElement(tree.location, tree, null), null, [])]);
        break;
      case FORMAL_PARAMETER_LIST:
        formals = tree;
        break;
      default:
        formals = this.toFormalParameters_(tree);
    }
    this.eat_(ARROW);
    var body = this.parseConciseBody_(asyncToken);
    return new ArrowFunctionExpression(this.getTreeLocation_(start), asyncToken, formals, body);
  },
  parseCoverFormals_: function(start) {
    var expressions = [];
    if (!this.peek_(CLOSE_PAREN)) {
      do {
        var type = this.peekType_();
        if (this.peekRest_(type)) {
          expressions.push(this.parseRestParameter_());
          break;
        } else {
          expressions.push(this.parseAssignmentExpression(Expression.NORMAL, true));
        }
        if (this.eatIf_(COMMA))
          continue;
      } while (!this.peek_(CLOSE_PAREN) && !this.isAtEnd());
    }
    this.eat_(CLOSE_PAREN);
    return new CoverFormals(this.getTreeLocation_(start), expressions);
  },
  transformCoverFormals_: function(f, tree) {
    try {
      return f(tree);
    } catch (ex) {
      if (!(ex instanceof CoverFormalsTransformerError))
        throw ex;
      this.reportError_(ex.location, ex.message);
      return new SyntaxErrorTree(ex.location, null, ex.message);
    }
  },
  toParenExpression_: function(tree) {
    if (tree.type !== COVER_FORMALS)
      return tree;
    return this.transformCoverFormals_(toParenExpression, tree);
  },
  toFormalParameters_: function(tree) {
    var transformed = this.transformCoverFormals_(toFormalParameters, tree);
    this.coverInitialisedName_ = null;
    return transformed;
  },
  transformCoverFormalsToArrowFormals_: function(coverFormals) {
    var formals = null;
    try {
      formals = toFormalParameters(coverFormals);
    } catch (ex) {
      if (!(ex instanceof CoverFormalsTransformerError))
        throw ex;
    }
    return formals;
  },
  peekArrow_: function(type) {
    return type === ARROW && parseOptions.arrowFunctions;
  },
  parseConciseBody_: function(asyncToken) {
    if (this.peek_(OPEN_CURLY))
      return this.parseFunctionBody_(asyncToken);
    var allowAwait = this.allowAwait_;
    this.allowAwait_ = asyncToken !== null;
    var expression = this.parseAssignmentExpression();
    this.allowAwait_ = allowAwait;
    return expression;
  },
  parseGeneratorComprehension_: function(start) {
    var comprehensionList = this.parseComprehensionList_();
    var expression = this.parseAssignmentExpression();
    this.eat_(CLOSE_PAREN);
    return new GeneratorComprehension(this.getTreeLocation_(start), comprehensionList, expression);
  },
  parseForBinding_: function() {
    if (this.peekPattern_(this.peekType_()))
      return this.parseBindingPattern_();
    return this.parseBindingIdentifier_();
  },
  peekPattern_: function(type) {
    return parseOptions.destructuring && (this.peekObjectPattern_(type) || this.peekArrayPattern_(type));
  },
  peekArrayPattern_: function(type) {
    return type === OPEN_SQUARE;
  },
  peekObjectPattern_: function(type) {
    return type === OPEN_CURLY;
  },
  parseBindingPattern_: function() {
    if (this.peekArrayPattern_(this.peekType_()))
      return this.parseArrayBindingPattern_();
    return this.parseObjectBindingPattern_();
  },
  parseArrayBindingPattern_: function() {
    var start = this.getTreeStartLocation_();
    var elements = [];
    this.eat_(OPEN_SQUARE);
    var type;
    while ((type = this.peekType_()) === COMMA || this.peekBindingElement_(type) || this.peekRest_(type)) {
      this.parseElisionOpt_(elements);
      if (this.peekRest_(this.peekType_())) {
        elements.push(this.parseBindingRestElement_());
        break;
      } else {
        elements.push(this.parseBindingElement_());
        if (this.peek_(COMMA) && !this.peek_(CLOSE_SQUARE, 1)) {
          this.nextToken_();
        }
      }
    }
    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 initializer = arguments[0] !== (void 0) ? arguments[0] : Initializer.OPTIONAL;
    var start = this.getTreeStartLocation_();
    var binding = this.parseBindingElementBinding_();
    var initializer = this.parseBindingElementInitializer_(initializer);
    return new BindingElement(this.getTreeLocation_(start), binding, initializer);
  },
  parseBindingElementBinding_: function() {
    if (this.peekPattern_(this.peekType_()))
      return this.parseBindingPattern_();
    return this.parseBindingIdentifier_();
  },
  parseBindingElementInitializer_: function() {
    var initializer = arguments[0] !== (void 0) ? arguments[0] : Initializer.OPTIONAL;
    if (this.peek_(EQUAL) || initializer === Initializer.REQUIRED) {
      return this.parseInitializer_();
    }
    return null;
  },
  parseBindingRestElement_: function() {
    var start = this.getTreeStartLocation_();
    this.eat_(DOT_DOT_DOT);
    var identifier = this.parseBindingIdentifier_();
    return new SpreadPatternElement(this.getTreeLocation_(start), identifier);
  },
  parseObjectBindingPattern_: function() {
    var start = this.getTreeStartLocation_();
    var elements = [];
    this.eat_(OPEN_CURLY);
    while (this.peekBindingProperty_(this.peekType_())) {
      elements.push(this.parseBindingProperty_());
      if (!this.eatIf_(COMMA))
        break;
    }
    this.eat_(CLOSE_CURLY);
    return new ObjectPattern(this.getTreeLocation_(start), elements);
  },
  peekBindingProperty_: function(type) {
    return this.peekBindingIdentifier_(type) || this.peekPropertyName_(type);
  },
  parseBindingProperty_: function() {
    var start = this.getTreeStartLocation_();
    var name = this.parsePropertyName_();
    var requireColon = name.type !== LITERAL_PROPERTY_NAME || !name.literalToken.isStrictKeyword() && name.literalToken.type !== IDENTIFIER;
    if (requireColon || this.peek_(COLON)) {
      this.eat_(COLON);
      var binding = this.parseBindingElement_();
      return new ObjectPatternField(this.getTreeLocation_(start), name, binding);
    }
    var token = name.literalToken;
    if (this.strictMode_ && token.isStrictKeyword())
      this.reportReservedIdentifier_(token);
    var binding = new BindingIdentifier(name.location, token);
    var initializer = null;
    if (this.peek_(EQUAL))
      initializer = this.parseInitializer_();
    return new BindingElement(this.getTreeLocation_(start), binding, initializer);
  },
  parseTemplateLiteral_: function(operand) {
    if (!parseOptions.templateLiterals)
      return this.parseUnexpectedToken_('`');
    var start = operand ? operand.location.start : this.getTreeStartLocation_();
    var token = this.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();
    elements.push(new TemplateSubstitution(expression.location, expression));
    while (expression.type !== SYNTAX_ERROR_TREE) {
      token = this.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();
      elements.push(new TemplateSubstitution(expression.location, expression));
    }
    return new TemplateLiteralExpression(this.getTreeLocation_(start), operand, elements);
  },
  parseTypeAnnotationOpt_: function() {
    if (parseOptions.types && this.eatOpt_(COLON)) {
      return this.parseType_();
    }
    return null;
  },
  parseType_: function() {
    var start = this.getTreeStartLocation_();
    var elementType;
    switch (this.peekType_()) {
      case IDENTIFIER:
        elementType = this.parseNamedOrPredefinedType_();
        break;
      case NEW:
        elementType = this.parseConstructorType_();
        break;
      case OPEN_CURLY:
        elementType = this.parseObjectType_();
        break;
      case OPEN_PAREN:
        elementType = this.parseFunctionType_();
        break;
      case VOID:
        var token = this.nextToken_();
        return new PredefinedType(this.getTreeLocation_(start), token);
      default:
        return this.parseUnexpectedToken_(this.peekToken_());
    }
    return this.parseArrayTypeSuffix_(start, elementType);
  },
  parseArrayTypeSuffix_: function(start, elementType) {
    return elementType;
  },
  parseConstructorType_: function() {
    throw 'NYI';
  },
  parseObjectType_: function() {
    throw 'NYI';
  },
  parseFunctionType_: function() {
    throw 'NYI';
  },
  parseNamedOrPredefinedType_: function() {
    var start = this.getTreeStartLocation_();
    switch (this.peekToken_().value) {
      case 'any':
      case 'number':
      case 'boolean':
      case 'string':
        var token = this.nextToken_();
        return new PredefinedType(this.getTreeLocation_(start), token);
      default:
        return this.parseTypeName_();
    }
  },
  parseTypeName_: function() {
    var start = this.getTreeStartLocation_();
    var typeName = new TypeName(this.getTreeLocation_(start), null, this.eatId_());
    while (this.eatIf_(PERIOD)) {
      var memberName = this.eatIdName_();
      typeName = new TypeName(this.getTreeLocation_(start), typeName, memberName);
    }
    return typeName;
  },
  parseAnnotatedDeclarations_: function(allowModuleItem, allowScriptItem) {
    this.pushAnnotations_();
    var declaration = this.parseStatement_(this.peekType_(), allowModuleItem, allowScriptItem);
    if (this.annotations_.length > 0)
      return this.parseSyntaxError_('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 (this.peek_(OPEN_PAREN))
      args = this.parseArguments_();
    return new Annotation(this.getTreeLocation_(start), expression, args);
  },
  eatPossibleImplicitSemiColon_: function() {
    var token = this.peekTokenNoLineTerminator_();
    if (!token)
      return;
    switch (token.type) {
      case SEMI_COLON:
        this.nextToken_();
        return;
      case END_OF_FILE:
      case CLOSE_CURLY:
        return;
    }
    this.reportError_('Semi-colon expected');
  },
  peekImplicitSemiColon_: function() {
    switch (this.peekType_()) {
      case SEMI_COLON:
      case CLOSE_CURLY:
      case END_OF_FILE:
        return true;
    }
    var token = this.peekTokenNoLineTerminator_();
    return token === null;
  },
  eatOpt_: function(expectedTokenType) {
    if (this.peek_(expectedTokenType))
      return this.nextToken_();
    return null;
  },
  eatIdOpt_: function() {
    return this.peek_(IDENTIFIER) ? this.eatId_() : null;
  },
  eatId_: function() {
    var expected = arguments[0];
    var token = this.nextToken_();
    if (!token) {
      if (expected)
        this.reportError_(this.peekToken_(), ("expected '" + expected + "'"));
      return null;
    }
    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 = this.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) {
    var token = this.nextToken_();
    if (token.type != expectedTokenType) {
      this.reportExpectedError_(token, expectedTokenType);
      return null;
    }
    return token;
  },
  eatIf_: function(expectedTokenType) {
    if (this.peek_(expectedTokenType)) {
      this.nextToken_();
      return true;
    }
    return false;
  },
  reportExpectedError_: function(token, expected) {
    this.reportError_(token, "'" + expected + "' expected");
  },
  getTreeStartLocation_: function() {
    return this.peekToken_().location.start;
  },
  getTreeEndLocation_: function() {
    return this.scanner_.lastToken.location.end;
  },
  getTreeLocation_: function(start) {
    return new SourceRange(start, this.getTreeEndLocation_());
  },
  handleComment: function(range) {},
  nextToken_: function() {
    return this.scanner_.nextToken();
  },
  nextRegularExpressionLiteralToken_: function() {
    return this.scanner_.nextRegularExpressionLiteralToken();
  },
  nextTemplateLiteralToken_: function() {
    return this.scanner_.nextTemplateLiteralToken();
  },
  isAtEnd: function() {
    return this.scanner_.isAtEnd();
  },
  peek_: function(expectedType, opt_index) {
    return this.peekToken_(opt_index).type === expectedType;
  },
  peekType_: function() {
    return this.peekToken_().type;
  },
  peekToken_: function(opt_index) {
    return this.scanner_.peekToken(opt_index);
  },
  peekTokenNoLineTerminator_: function() {
    return this.scanner_.peekTokenNoLineTerminator();
  },
  reportError_: function() {
    for (var args = [],
        $__84 = 0; $__84 < arguments.length; $__84++)
      args[$__84] = arguments[$__84];
    if (args.length == 1) {
      this.errorReporter_.reportError(this.scanner_.getPosition(), args[0]);
    } else {
      var location = args[0];
      if (location instanceof Token) {
        location = location.location;
      }
      this.errorReporter_.reportError(location.start, args[1]);
    }
  },
  reportReservedIdentifier_: function(token) {
    this.reportError_(token, (token.type + " is a reserved identifier"));
  }
}, {});
return {get Parser() {
    return Parser;
  }};

}); System.register(“traceur@0.0.43/src/util/uid”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/uid";
var uidCounter = 0;
function getUid() {
  return uidCounter++;
}
return {get getUid() {
    return getUid;
  }};

}); System.register(“traceur@0.0.43/src/util/SourcePosition”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/SourcePosition";
var SourcePosition = function SourcePosition(source, offset) {
  this.source = source;
  this.offset = offset;
  this.line_ = -1;
  this.column_ = -1;
};
($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;
  }};

}); System.register(“traceur@0.0.43/src/syntax/LineNumberTable”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/LineNumberTable";
var SourcePosition = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/SourcePosition")).SourcePosition;
var SourceRange = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/SourceRange")).SourceRange;
var isLineTerminator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Scanner")).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 LineNumberTable(sourceFile) {
  this.sourceFile_ = sourceFile;
  this.lineStartOffsets_ = null;
  this.lastLine_ = 0;
  this.lastOffset_ = -1;
};
($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 = this.lastLine_; true; i++) {
        if (this.lineStartOffsets_[i] > offset) {
          line = i - 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;
  }};

}); System.register(“traceur@0.0.43/src/syntax/SourceFile”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/SourceFile";
var LineNumberTable = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/LineNumberTable")).LineNumberTable;
var getUid = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/uid")).getUid;
var SourceFile = function SourceFile(name, contents) {
  this.name = name;
  this.contents = contents;
  this.lineNumberTable = new LineNumberTable(this);
  this.uid = getUid();
};
($traceurRuntime.createClass)(SourceFile, {}, {});
return {get SourceFile() {
    return SourceFile;
  }};

}); System.register(“traceur@0.0.43/src/util/ArrayMap”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/ArrayMap";
var ArrayMap = function ArrayMap() {
  this.values_ = [];
  this.keys_ = [];
};
($traceurRuntime.createClass)(ArrayMap, {
  has: function(key) {
    return this.keys_.indexOf(key) != -1;
  },
  get: function(key) {
    var index = this.keys_.indexOf(key);
    if (index == -1) {
      return undefined;
    }
    return this.values_[index];
  },
  set: function(key, value) {
    var index = this.keys_.indexOf(key);
    if (index == -1) {
      this.keys_.push(key);
      this.values_.push(value);
    } else {
      this.values_[index] = value;
    }
  },
  addAll: function(other) {
    var keys = other.keys();
    var values = other.values();
    for (var i = 0; i < keys.length; i++) {
      this.set(keys[i], values[i]);
    }
  },
  remove: function(key) {
    var index = this.keys_.indexOf(key);
    if (index == -1) {
      return;
    }
    this.keys_.splice(index, 1);
    this.values_.splice(index, 1);
  },
  keys: function() {
    return this.keys_.concat();
  },
  values: function() {
    return this.values_.concat();
  }
}, {});
return {get ArrayMap() {
    return ArrayMap;
  }};

}); System.register(“traceur@0.0.43/src/util/MutedErrorReporter”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/MutedErrorReporter";
var ErrorReporter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ErrorReporter")).ErrorReporter;
var MutedErrorReporter = function MutedErrorReporter() {
  $traceurRuntime.defaultSuperCall(this, $MutedErrorReporter.prototype, arguments);
};
var $MutedErrorReporter = MutedErrorReporter;
($traceurRuntime.createClass)(MutedErrorReporter, {reportMessageInternal: function(location, format, args) {}}, {}, ErrorReporter);
return {get MutedErrorReporter() {
    return MutedErrorReporter;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/PlaceholderParser”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/PlaceholderParser";
var ArrayMap = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ArrayMap")).ArrayMap;
var $__99 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    ARGUMENT_LIST = $__99.ARGUMENT_LIST,
    BLOCK = $__99.BLOCK,
    EXPRESSION_STATEMENT = $__99.EXPRESSION_STATEMENT,
    IDENTIFIER_EXPRESSION = $__99.IDENTIFIER_EXPRESSION;
var IdentifierToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/IdentifierToken")).IdentifierToken;
var LiteralToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/LiteralToken")).LiteralToken;
var MutedErrorReporter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/MutedErrorReporter")).MutedErrorReporter;
var ParseTree = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTree")).ParseTree;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var Parser = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Parser")).Parser;
var $__99 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    LiteralExpression = $__99.LiteralExpression,
    LiteralPropertyName = $__99.LiteralPropertyName,
    PropertyMethodAssignment = $__99.PropertyMethodAssignment,
    PropertyNameAssignment = $__99.PropertyNameAssignment,
    PropertyNameShorthand = $__99.PropertyNameShorthand;
var SourceFile = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/SourceFile")).SourceFile;
var IDENTIFIER = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).IDENTIFIER;
var $__99 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArrayLiteralExpression = $__99.createArrayLiteralExpression,
    createBindingIdentifier = $__99.createBindingIdentifier,
    createBlock = $__99.createBlock,
    createBooleanLiteral = $__99.createBooleanLiteral,
    createCommaExpression = $__99.createCommaExpression,
    createExpressionStatement = $__99.createExpressionStatement,
    createFunctionBody = $__99.createFunctionBody,
    createGetAccessor = $__99.createGetAccessor,
    createIdentifierExpression = $__99.createIdentifierExpression,
    createIdentifierToken = $__99.createIdentifierToken,
    createMemberExpression = $__99.createMemberExpression,
    createNullLiteral = $__99.createNullLiteral,
    createNumberLiteral = $__99.createNumberLiteral,
    createParenExpression = $__99.createParenExpression,
    createSetAccessor = $__99.createSetAccessor,
    createStringLiteral = $__99.createStringLiteral,
    createVoid0 = $__99.createVoid0;
var NOT_FOUND = {};
var PREFIX = '$__placeholder__';
var cache = new ArrayMap();
function parseExpression(sourceLiterals) {
  for (var values = [],
      $__95 = 1; $__95 < arguments.length; $__95++)
    values[$__95 - 1] = arguments[$__95];
  return parse(sourceLiterals, values, (function() {
    return new PlaceholderParser().parseExpression(sourceLiterals);
  }));
}
function parseStatement(sourceLiterals) {
  for (var values = [],
      $__96 = 1; $__96 < arguments.length; $__96++)
    values[$__96 - 1] = arguments[$__96];
  return parse(sourceLiterals, values, (function() {
    return new PlaceholderParser().parseStatement(sourceLiterals);
  }));
}
function parseStatements(sourceLiterals) {
  for (var values = [],
      $__97 = 1; $__97 < arguments.length; $__97++)
    values[$__97 - 1] = arguments[$__97];
  return parse(sourceLiterals, values, (function() {
    return new PlaceholderParser().parseStatements(sourceLiterals);
  }));
}
function parsePropertyDefinition(sourceLiterals) {
  for (var values = [],
      $__98 = 1; $__98 < arguments.length; $__98++)
    values[$__98 - 1] = arguments[$__98];
  return parse(sourceLiterals, values, (function() {
    return new PlaceholderParser().parsePropertyDefinition(sourceLiterals);
  }));
}
function parse(sourceLiterals, values, doParse) {
  var tree = cache.get(sourceLiterals);
  if (!tree) {
    tree = doParse();
    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 counter = 0;
var PlaceholderParser = function PlaceholderParser() {};
($traceurRuntime.createClass)(PlaceholderParser, {
  parseExpression: function(sourceLiterals) {
    return this.parse_(sourceLiterals, (function(p) {
      return p.parseExpression();
    }));
  },
  parseStatement: function(sourceLiterals) {
    return this.parse_(sourceLiterals, (function(p) {
      return p.parseStatement();
    }));
  },
  parseStatements: function(sourceLiterals) {
    return this.parse_(sourceLiterals, (function(p) {
      return p.parseStatements();
    }));
  },
  parsePropertyDefinition: function(sourceLiterals) {
    return this.parse_(sourceLiterals, (function(p) {
      return p.parsePropertyDefinition();
    }));
  },
  parse_: function(sourceLiterals, doParse) {
    var source = sourceLiterals[0];
    for (var i = 1; i < sourceLiterals.length; i++) {
      source += PREFIX + (i - 1) + sourceLiterals[i];
    }
    var file = new SourceFile('@traceur/generated/TemplateParser/' + counter++, source);
    var errorReporter = new MutedErrorReporter();
    var parser = new Parser(file, errorReporter);
    var tree = doParse(parser);
    if (errorReporter.hadError() || !tree || !parser.isAtEnd())
      throw new Error(("Internal error trying to parse:\n\n" + source));
    return tree;
  }
}, {});
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 createArrayLiteralExpression(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);
}
var PlaceholderTransformer = function PlaceholderTransformer(values) {
  $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "constructor", []);
  this.values = values;
};
var $PlaceholderTransformer = PlaceholderTransformer;
($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.isStatement())
        return transformedExpression;
      return createExpressionStatement(transformedExpression);
    }
    return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformExpressionStatement", [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.superCall(this, $PlaceholderTransformer.prototype, "transformBlock", [tree]);
  },
  transformFunctionBody: 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 createFunctionBody(transformedStatement.statements);
    }
    return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformFunctionBody", [tree]);
  },
  transformMemberExpression: function(tree) {
    var value = this.getValue_(tree.memberName.value);
    if (value === NOT_FOUND)
      return $traceurRuntime.superCall(this, $PlaceholderTransformer.prototype, "transformMemberExpression", [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.superCall(this, $PlaceholderTransformer.prototype, "transformLiteralPropertyName", [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.superCall(this, $PlaceholderTransformer.prototype, "transformArgumentList", [tree]);
  }
}, {}, ParseTreeTransformer);
return {
  get parseExpression() {
    return parseExpression;
  },
  get parseStatement() {
    return parseStatement;
  },
  get parseStatements() {
    return parseStatements;
  },
  get parsePropertyDefinition() {
    return parsePropertyDefinition;
  },
  get PlaceholderParser() {
    return PlaceholderParser;
  },
  get PlaceholderTransformer() {
    return PlaceholderTransformer;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/PrependStatements”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/PrependStatements";
var $__101 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    EXPRESSION_STATEMENT = $__101.EXPRESSION_STATEMENT,
    LITERAL_EXPRESSION = $__101.LITERAL_EXPRESSION;
var STRING = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).STRING;
function isStringExpressionStatement(tree) {
  return tree.type === EXPRESSION_STATEMENT && tree.expression.type === LITERAL_EXPRESSION && tree.expression.literalToken.type === STRING;
}
function prependStatements(statements) {
  for (var statementsToPrepend = [],
      $__100 = 1; $__100 < arguments.length; $__100++)
    statementsToPrepend[$__100 - 1] = arguments[$__100];
  if (!statements.length)
    return statementsToPrepend;
  if (!statementsToPrepend.length)
    return statements;
  var transformed = [];
  var inProlog = true;
  statements.forEach((function(statement) {
    var $__102;
    if (inProlog && !isStringExpressionStatement(statement)) {
      ($__102 = transformed).push.apply($__102, $traceurRuntime.toObject(statementsToPrepend));
      inProlog = false;
    }
    transformed.push(statement);
  }));
  return transformed;
}
return {get prependStatements() {
    return prependStatements;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/TempVarTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/TempVarTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__104 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    Module = $__104.Module,
    Script = $__104.Script;
var ARGUMENTS = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).ARGUMENTS;
var VAR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).VAR;
var $__104 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createFunctionBody = $__104.createFunctionBody,
    createThisExpression = $__104.createThisExpression,
    createIdentifierExpression = $__104.createIdentifierExpression,
    createVariableDeclaration = $__104.createVariableDeclaration,
    createVariableDeclarationList = $__104.createVariableDeclarationList,
    createVariableStatement = $__104.createVariableStatement;
var prependStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PrependStatements")).prependStatements;
function getVars(self) {
  var vars = self.tempVarStack_[self.tempVarStack_.length - 1];
  if (!vars)
    throw new Error('Invalid use of addTempVar');
  return vars;
}
var TempVarStatement = function TempVarStatement(name, initializer) {
  this.name = name;
  this.initializer = initializer;
};
($traceurRuntime.createClass)(TempVarStatement, {}, {});
var TempScope = function TempScope() {
  this.thisName = null;
  this.argumentName = null;
  this.identifiers = [];
};
($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.release_(this.identifiers[i]);
    }
  }
}, {});
var TempVarTransformer = function TempVarTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $TempVarTransformer.prototype, "constructor", []);
  this.identifierGenerator = identifierGenerator;
  this.tempVarStack_ = [[]];
  this.tempScopeStack_ = [new TempScope()];
  this.namePool_ = [];
};
var $TempVarTransformer = TempVarTransformer;
($traceurRuntime.createClass)(TempVarTransformer, {
  transformStatements_: function(statements) {
    this.tempVarStack_.push([]);
    var transformedStatements = this.transformList(statements);
    var vars = this.tempVarStack_.pop();
    if (!vars.length)
      return transformedStatements;
    var seenNames = Object.create(null);
    vars = vars.filter((function(tempVarStatement) {
      var $__104 = $traceurRuntime.assertObject(tempVarStatement),
          name = $__104.name,
          initializer = $__104.initializer;
      if (name in seenNames) {
        if (seenNames[name].initializer || initializer)
          throw new Error('Invalid use of TempVarTransformer');
        return false;
      }
      seenNames[name] = tempVarStatement;
      return true;
    }));
    var variableStatement = createVariableStatement(createVariableDeclarationList(VAR, vars.map((function($__104) {
      var name = $__104.name,
          initializer = $__104.initializer;
      return createVariableDeclaration(name, initializer);
    }))));
    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.pushTempVarState();
    var statements = this.transformStatements_(tree.statements);
    this.popTempVarState();
    if (statements == tree.statements)
      return tree;
    return createFunctionBody(statements);
  },
  getTempIdentifier: function() {
    var name = this.namePool_.length ? this.namePool_.pop() : this.identifierGenerator.generateUniqueIdentifier();
    this.tempScopeStack_[this.tempScopeStack_.length - 1].push(name);
    return name;
  },
  addTempVar: function() {
    var initializer = arguments[0] !== (void 0) ? arguments[0] : null;
    var vars = getVars(this);
    var uid = this.getTempIdentifier();
    vars.push(new TempVarStatement(uid, initializer));
    return uid;
  },
  addTempVarForThis: function() {
    var tempScope = this.tempScopeStack_[this.tempScopeStack_.length - 1];
    return tempScope.thisName || (tempScope.thisName = this.addTempVar(createThisExpression()));
  },
  addTempVarForArguments: function() {
    var tempScope = this.tempScopeStack_[this.tempScopeStack_.length - 1];
    return tempScope.argumentName || (tempScope.argumentName = this.addTempVar(createIdentifierExpression(ARGUMENTS)));
  },
  pushTempVarState: function() {
    this.tempScopeStack_.push(new TempScope());
  },
  popTempVarState: function() {
    this.tempScopeStack_.pop().release(this);
  },
  release_: function(name) {
    this.namePool_.push(name);
  }
}, {}, ParseTreeTransformer);
return {get TempVarTransformer() {
    return TempVarTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/module/ModuleSymbol”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/ModuleSymbol";
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var ExportsList = function ExportsList(normalizedName) {
  this.exports_ = Object.create(null);
  if (normalizedName !== null)
    this.normalizedName = normalizedName.replace(/\\/g, '/');
  else
    this.normalizedName = null;
};
($traceurRuntime.createClass)(ExportsList, {
  addExport: function(name, tree) {
    assert(!this.exports_[name]);
    this.exports_[name] = tree;
  },
  getExport: function(name) {
    return this.exports_[name];
  },
  getExports: function() {
    return Object.keys(this.exports_);
  }
}, {});
var ModuleDescription = function ModuleDescription(normalizedName, module) {
  var $__105 = this;
  $traceurRuntime.superCall(this, $ModuleDescription.prototype, "constructor", [normalizedName]);
  Object.getOwnPropertyNames(module).forEach((function(name) {
    $__105.addExport(name, true);
  }));
};
var $ModuleDescription = ModuleDescription;
($traceurRuntime.createClass)(ModuleDescription, {}, {}, ExportsList);
var ModuleSymbol = function ModuleSymbol(tree, normalizedName) {
  $traceurRuntime.superCall(this, $ModuleSymbol.prototype, "constructor", [normalizedName]);
  this.tree = tree;
  this.imports_ = Object.create(null);
};
var $ModuleSymbol = ModuleSymbol;
($traceurRuntime.createClass)(ModuleSymbol, {
  addImport: function(name, tree) {
    assert(!this.imports_[name]);
    this.imports_[name] = tree;
  },
  getImport: function(name) {
    return this.imports_[name];
  }
}, {}, ExportsList);
return {
  get ModuleDescription() {
    return ModuleDescription;
  },
  get ModuleSymbol() {
    return ModuleSymbol;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/module/ModuleVisitor”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/ModuleVisitor";
var ModuleDescription = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ModuleSymbol")).ModuleDescription;
var ParseTree = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTree")).ParseTree;
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var $__109 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    MODULE_DECLARATION = $__109.MODULE_DECLARATION,
    EXPORT_DECLARATION = $__109.EXPORT_DECLARATION,
    IMPORT_DECLARATION = $__109.IMPORT_DECLARATION;
var ModuleVisitor = function ModuleVisitor(reporter, loader, moduleSymbol) {
  this.reporter = reporter;
  this.loader_ = loader;
  this.moduleSymbol = moduleSymbol;
};
($traceurRuntime.createClass)(ModuleVisitor, {
  getModuleDescriptionFromCodeUnit_: function(name, codeUnitToModuleInfo) {
    var referrer = this.moduleSymbol.normalizedName;
    var codeUnit = this.loader_.getCodeUnitForModuleSpecifier(name, referrer);
    var moduleDescription = codeUnitToModuleInfo(codeUnit);
    if (!moduleDescription) {
      var msg = (name + " is not a module, required by " + referrer);
      this.reportError(codeUnit.metadata.tree, msg);
      return null;
    }
    return moduleDescription;
  },
  getModuleSymbolForModuleSpecifier: function(name) {
    return this.getModuleDescriptionFromCodeUnit_(name, (function(codeUnit) {
      return codeUnit.metadata.moduleSymbol;
    }));
  },
  getModuleDescriptionForModuleSpecifier: function(name) {
    return this.getModuleDescriptionFromCodeUnit_(name, (function(codeUnit) {
      var moduleDescription = codeUnit.metadata.moduleSymbol;
      if (!moduleDescription && codeUnit.result) {
        moduleDescription = new ModuleDescription(codeUnit.normalizedName, codeUnit.result);
      }
      return moduleDescription;
    }));
  },
  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 MODULE_DECLARATION:
      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.start, message);
  }
}, {}, ParseTreeVisitor);
return {get ModuleVisitor() {
    return ModuleVisitor;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/module/ExportVisitor”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/ExportVisitor";
var ModuleVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ModuleVisitor")).ModuleVisitor;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var ExportVisitor = function ExportVisitor(reporter, loaderHooks, moduleSymbol) {
  $traceurRuntime.superCall(this, $ExportVisitor.prototype, "constructor", [reporter, loaderHooks, moduleSymbol]);
  this.inExport_ = false;
  this.moduleSpecifier = null;
};
var $ExportVisitor = ExportVisitor;
($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.specifierSet);
    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 $__110 = this;
    var name = this.moduleSpecifier.token.processedValue;
    var moduleDescription = this.getModuleDescriptionForModuleSpecifier(name);
    if (moduleDescription) {
      moduleDescription.getExports().forEach((function(name) {
        $__110.addExport(name, tree);
      }));
    }
  },
  visitFunctionDeclaration: function(tree) {
    this.addExport_(tree.name.identifierToken.value, tree);
  },
  visitModuleDeclaration: function(tree) {
    this.addExport_(tree.identifier.value, tree);
  },
  visitVariableDeclaration: function(tree) {
    this.addExport_(tree.lvalue.identifierToken.value, tree);
  }
}, {}, ModuleVisitor);
return {get ExportVisitor() {
    return ExportVisitor;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/module/DirectExportVisitor”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/DirectExportVisitor";
var ExportVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ExportVisitor")).ExportVisitor;
var DirectExportVisitor = function DirectExportVisitor() {
  $traceurRuntime.superCall(this, $DirectExportVisitor.prototype, "constructor", [null, null, null]);
  this.namedExports = [];
  this.starExports = [];
};
var $DirectExportVisitor = DirectExportVisitor;
($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;
  }
}, {}, ExportVisitor);
return {get DirectExportVisitor() {
    return DirectExportVisitor;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ModuleTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ModuleTransformer";
var $__115 = Object.freeze(Object.defineProperties(["var __moduleName = ", ";"], {raw: {value: Object.freeze(["var __moduleName = ", ";"])}})),
    $__116 = Object.freeze(Object.defineProperties(["function() {\n      ", "\n    }"], {raw: {value: Object.freeze(["function() {\n      ", "\n    }"])}})),
    $__117 = Object.freeze(Object.defineProperties(["$traceurRuntime.ModuleStore.getAnonymousModule(\n              ", ");"], {raw: {value: Object.freeze(["$traceurRuntime.ModuleStore.getAnonymousModule(\n              ", ");"])}})),
    $__118 = Object.freeze(Object.defineProperties(["System.register(", ", [], ", ");"], {raw: {value: Object.freeze(["System.register(", ", [], ", ");"])}})),
    $__119 = Object.freeze(Object.defineProperties(["get ", "() { return ", "; }"], {raw: {value: Object.freeze(["get ", "() { return ", "; }"])}})),
    $__120 = Object.freeze(Object.defineProperties(["$traceurRuntime.exportStar(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.exportStar(", ")"])}})),
    $__121 = Object.freeze(Object.defineProperties(["return ", ""], {raw: {value: Object.freeze(["return ", ""])}})),
    $__122 = Object.freeze(Object.defineProperties(["var $__default = ", ""], {raw: {value: Object.freeze(["var $__default = ", ""])}})),
    $__123 = Object.freeze(Object.defineProperties(["System.get(", ")"], {raw: {value: Object.freeze(["System.get(", ")"])}}));
var $__126 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    BindingElement = $__126.BindingElement,
    BindingIdentifier = $__126.BindingIdentifier,
    EmptyStatement = $__126.EmptyStatement,
    LiteralPropertyName = $__126.LiteralPropertyName,
    ObjectPattern = $__126.ObjectPattern,
    ObjectPatternField = $__126.ObjectPatternField,
    Script = $__126.Script;
var DirectExportVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/DirectExportVisitor")).DirectExportVisitor;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__126 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    EXPORT_DEFAULT = $__126.EXPORT_DEFAULT,
    EXPORT_SPECIFIER = $__126.EXPORT_SPECIFIER;
var VAR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).VAR;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var $__126 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArgumentList = $__126.createArgumentList,
    createBindingIdentifier = $__126.createBindingIdentifier,
    createExpressionStatement = $__126.createExpressionStatement,
    createIdentifierExpression = $__126.createIdentifierExpression,
    createIdentifierToken = $__126.createIdentifierToken,
    createMemberExpression = $__126.createMemberExpression,
    createObjectLiteralExpression = $__126.createObjectLiteralExpression,
    createUseStrictDirective = $__126.createUseStrictDirective,
    createVariableStatement = $__126.createVariableStatement;
var $__126 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__126.parseExpression,
    parsePropertyDefinition = $__126.parsePropertyDefinition,
    parseStatement = $__126.parseStatement,
    parseStatements = $__126.parseStatements;
var ModuleTransformer = function ModuleTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $ModuleTransformer.prototype, "constructor", [identifierGenerator]);
  this.exportVisitor_ = new DirectExportVisitor();
  this.moduleSpecifierKind_ = null;
  this.moduleName = null;
};
var $ModuleTransformer = ModuleTransformer;
($traceurRuntime.createClass)(ModuleTransformer, {
  getTempVarNameForModuleName: function(moduleName) {
    return '$__' + moduleName.replace(/[^a-zA-Z0-9$]/g, function(c) {
      return '_' + c.charCodeAt(0) + '_';
    }) + '__';
  },
  getTempVarNameForModuleSpecifier: function(moduleSpecifier) {
    var normalizedName = System.normalize(moduleSpecifier.token.processedValue, this.moduleName);
    return this.getTempVarNameForModuleName(normalizedName);
  },
  transformScript: function(tree) {
    this.moduleName = tree.moduleName;
    return $traceurRuntime.superCall(this, $ModuleTransformer.prototype, "transformScript", [tree]);
  },
  transformModule: function(tree) {
    this.moduleName = tree.moduleName;
    this.pushTempVarState();
    var statements = this.transformList(tree.scriptItemList);
    statements = this.appendExportStatement(statements);
    this.popTempVarState();
    statements = this.wrapModule(this.moduleProlog().concat(statements));
    return new Script(tree.location, statements);
  },
  moduleProlog: function() {
    var statements = [createUseStrictDirective()];
    if (this.moduleName)
      statements.push(parseStatement($__115, this.moduleName));
    return statements;
  },
  wrapModule: function(statements) {
    var functionExpression = parseExpression($__116, statements);
    if (this.moduleName === null) {
      return parseStatements($__117, functionExpression);
    }
    return parseStatements($__118, this.moduleName, functionExpression);
  },
  getGetterExport: function($__126) {
    var name = $__126.name,
        tree = $__126.tree,
        moduleSpecifier = $__126.moduleSpecifier;
    var returnExpression;
    switch (tree.type) {
      case EXPORT_DEFAULT:
        returnExpression = createIdentifierExpression('$__default');
        break;
      case EXPORT_SPECIFIER:
        if (moduleSpecifier) {
          var idName = this.getTempVarNameForModuleSpecifier(moduleSpecifier);
          returnExpression = createMemberExpression(idName, tree.lhs);
        } else {
          returnExpression = createIdentifierExpression(tree.lhs);
        }
        break;
      default:
        returnExpression = createIdentifierExpression(name);
        break;
    }
    return parsePropertyDefinition($__119, name, returnExpression);
  },
  getExportProperties: function() {
    var $__124 = this;
    return this.exportVisitor_.namedExports.map((function(exp) {
      return $__124.getGetterExport(exp);
    })).concat(this.exportVisitor_.namedExports.map((function(exp) {
      return $__124.getSetterExport(exp);
    }))).filter((function(e) {
      return e;
    }));
  },
  getSetterExport: function($__127) {
    var name = $__127.name,
        tree = $__127.tree,
        moduleSpecifier = $__127.moduleSpecifier;
    return null;
  },
  getExportObject: function() {
    var $__124 = this;
    var exportObject = createObjectLiteralExpression(this.getExportProperties());
    if (this.exportVisitor_.starExports.length) {
      var starExports = this.exportVisitor_.starExports;
      var starIdents = starExports.map((function(moduleSpecifier) {
        return createIdentifierExpression($__124.getTempVarNameForModuleSpecifier(moduleSpecifier));
      }));
      var args = createArgumentList.apply(null, $traceurRuntime.spread([exportObject], starIdents));
      return parseExpression($__120, args);
    }
    return exportObject;
  },
  appendExportStatement: function(statements) {
    var exportObject = this.getExportObject();
    statements.push(parseStatement($__121, exportObject));
    return statements;
  },
  hasExports: function() {
    return this.exportVisitor_.hasExports();
  },
  transformExportDeclaration: function(tree) {
    this.exportVisitor_.visitAny(tree);
    return this.transformAny(tree.declaration);
  },
  transformExportDefault: function(tree) {
    return parseStatement($__122, 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 EmptyStatement(null);
  },
  transformModuleSpecifier: function(tree) {
    assert(this.moduleName);
    var name = tree.token.processedValue;
    var normalizedName = System.normalize(name, this.moduleName);
    return parseExpression($__123, normalizedName);
  },
  transformModuleDeclaration: function(tree) {
    this.moduleSpecifierKind_ = 'module';
    var initializer = this.transformAny(tree.expression);
    return createVariableStatement(VAR, tree.identifier, initializer);
  },
  transformImportedBinding: function(tree) {
    var bindingElement = new BindingElement(tree.location, tree.binding, null);
    var name = new LiteralPropertyName(null, createIdentifierToken('default'));
    return new ObjectPattern(null, [new ObjectPatternField(null, name, bindingElement)]);
  },
  transformImportDeclaration: function(tree) {
    this.moduleSpecifierKind_ = 'import';
    if (!tree.importClause)
      return createExpressionStatement(this.transformAny(tree.moduleSpecifier));
    var binding = this.transformAny(tree.importClause);
    var initializer = this.transformAny(tree.moduleSpecifier);
    return createVariableStatement(VAR, binding, initializer);
  },
  transformImportSpecifierSet: function(tree) {
    var fields = this.transformList(tree.specifiers);
    return new ObjectPattern(null, fields);
  },
  transformImportSpecifier: function(tree) {
    if (tree.rhs) {
      var binding = new BindingIdentifier(tree.location, tree.rhs);
      var bindingElement = new BindingElement(tree.location, binding, null);
      var name = new LiteralPropertyName(tree.lhs.location, tree.lhs);
      return new ObjectPatternField(tree.location, name, bindingElement);
    }
    return new BindingElement(tree.location, createBindingIdentifier(tree.lhs), null);
  }
}, {}, TempVarTransformer);
return {get ModuleTransformer() {
    return ModuleTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/globalThis”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/globalThis";
var $__128 = Object.freeze(Object.defineProperties(["typeof global !== 'undefined' ? global : this"], {raw: {value: Object.freeze(["typeof global !== 'undefined' ? global : this"])}}));
var parseExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseExpression;
var expr;
function globalThis() {
  if (!expr)
    expr = parseExpression($__128);
  return expr;
}
var $__default = globalThis;
return {get default() {
    return $__default;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/FindVisitor”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/FindVisitor";
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var FindVisitor = function FindVisitor(tree) {
  var keepOnGoing = arguments[1];
  this.found_ = false;
  this.shouldContinue_ = true;
  this.keepOnGoing_ = keepOnGoing;
  this.visitAny(tree);
};
($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]);
      }
    }
  }
}, {}, ParseTreeVisitor);
return {get FindVisitor() {
    return FindVisitor;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/FindInFunctionScope”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/FindInFunctionScope";
var FindVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindVisitor")).FindVisitor;
var FindInFunctionScope = function FindInFunctionScope() {
  $traceurRuntime.defaultSuperCall(this, $FindInFunctionScope.prototype, arguments);
};
var $FindInFunctionScope = FindInFunctionScope;
($traceurRuntime.createClass)(FindInFunctionScope, {
  visitFunctionDeclaration: function(tree) {},
  visitFunctionExpression: function(tree) {},
  visitSetAccessor: function(tree) {},
  visitGetAccessor: function(tree) {},
  visitPropertyMethodAssignment: function(tree) {}
}, {}, FindVisitor);
return {get FindInFunctionScope() {
    return FindInFunctionScope;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/scopeContainsThis”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/scopeContainsThis";
var FindInFunctionScope = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindInFunctionScope")).FindInFunctionScope;
var FindThis = function FindThis() {
  $traceurRuntime.defaultSuperCall(this, $FindThis.prototype, arguments);
};
var $FindThis = FindThis;
($traceurRuntime.createClass)(FindThis, {visitThisExpression: function(tree) {
    this.found = true;
  }}, {}, FindInFunctionScope);
function scopeContainsThis(tree) {
  var visitor = new FindThis(tree);
  return visitor.found;
}
var $__default = scopeContainsThis;
return {get default() {
    return $__default;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/AmdTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/AmdTransformer";
var $__136 = Object.freeze(Object.defineProperties(["__esModule: true"], {raw: {value: Object.freeze(["__esModule: true"])}})),
    $__137 = Object.freeze(Object.defineProperties(["if (!", " || !", ".__esModule)\n            ", " = { 'default': ", " }"], {raw: {value: Object.freeze(["if (!", " || !", ".__esModule)\n            ", " = { 'default': ", " }"])}})),
    $__138 = Object.freeze(Object.defineProperties(["function(", ") {\n      ", "\n    }"], {raw: {value: Object.freeze(["function(", ") {\n      ", "\n    }"])}})),
    $__139 = Object.freeze(Object.defineProperties(["", ".bind(", ")"], {raw: {value: Object.freeze(["", ".bind(", ")"])}})),
    $__140 = Object.freeze(Object.defineProperties(["define(", ", ", ", ", ");"], {raw: {value: Object.freeze(["define(", ", ", ", ", ");"])}})),
    $__141 = Object.freeze(Object.defineProperties(["define(", ", ", ");"], {raw: {value: Object.freeze(["define(", ", ", ");"])}}));
var ModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ModuleTransformer")).ModuleTransformer;
var VAR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).VAR;
var $__143 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createBindingIdentifier = $__143.createBindingIdentifier,
    createIdentifierExpression = $__143.createIdentifierExpression;
var globalThis = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/globalThis")).default;
var $__143 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__143.parseExpression,
    parseStatement = $__143.parseStatement,
    parseStatements = $__143.parseStatements,
    parsePropertyDefinition = $__143.parsePropertyDefinition;
var scopeContainsThis = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/scopeContainsThis")).default;
var AmdTransformer = function AmdTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $AmdTransformer.prototype, "constructor", [identifierGenerator]);
  this.dependencies = [];
};
var $AmdTransformer = AmdTransformer;
($traceurRuntime.createClass)(AmdTransformer, {
  getExportProperties: function() {
    var properties = $traceurRuntime.superCall(this, $AmdTransformer.prototype, "getExportProperties", []);
    if (this.exportVisitor_.hasExports())
      properties.push(parsePropertyDefinition($__136));
    return properties;
  },
  moduleProlog: function() {
    var locals = this.dependencies.map((function(dep) {
      var local = createIdentifierExpression(dep.local);
      return parseStatement($__137, local, local, local, local);
    }));
    return $traceurRuntime.superCall(this, $AmdTransformer.prototype, "moduleProlog", []).concat(locals);
  },
  wrapModule: function(statements) {
    var depPaths = this.dependencies.map((function(dep) {
      return dep.path;
    }));
    var depLocals = this.dependencies.map((function(dep) {
      return dep.local;
    }));
    var hasTopLevelThis = statements.some(scopeContainsThis);
    var func = parseExpression($__138, depLocals, statements);
    if (hasTopLevelThis)
      func = parseExpression($__139, func, globalThis());
    if (this.moduleName) {
      return parseStatements($__140, this.moduleName, depPaths, func);
    } else {
      return parseStatements($__141, depPaths, func);
    }
  },
  transformModuleSpecifier: function(tree) {
    var localName = this.getTempIdentifier();
    this.dependencies.push({
      path: tree.token,
      local: localName
    });
    return createBindingIdentifier(localName);
  }
}, {}, ModuleTransformer);
return {get AmdTransformer() {
    return AmdTransformer;
  }};

}); System.register(“traceur@0.0.43/src/staticsemantics/PropName”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/staticsemantics/PropName";
var $__144 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    COMPUTED_PROPERTY_NAME = $__144.COMPUTED_PROPERTY_NAME,
    GET_ACCESSOR = $__144.GET_ACCESSOR,
    LITERAL_PROPERTY_NAME = $__144.LITERAL_PROPERTY_NAME,
    PROPERTY_METHOD_ASSIGNMENT = $__144.PROPERTY_METHOD_ASSIGNMENT,
    PROPERTY_NAME_ASSIGNMENT = $__144.PROPERTY_NAME_ASSIGNMENT,
    PROPERTY_NAME_SHORTHAND = $__144.PROPERTY_NAME_SHORTHAND,
    SET_ACCESSOR = $__144.SET_ACCESSOR;
var IDENTIFIER = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).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 PROPERTY_METHOD_ASSIGNMENT:
    case PROPERTY_NAME_ASSIGNMENT:
    case GET_ACCESSOR:
    case SET_ACCESSOR:
      return propName(tree.name);
  }
}
return {get propName() {
    return propName;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/AnnotationsTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/AnnotationsTransformer";
var $__145 = Object.freeze(Object.defineProperties(["Object.getOwnPropertyDescriptor(", ")"], {raw: {value: Object.freeze(["Object.getOwnPropertyDescriptor(", ")"])}}));
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var CONSTRUCTOR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).CONSTRUCTOR;
var $__148 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    IDENTIFIER = $__148.IDENTIFIER,
    STRING = $__148.STRING;
var $__148 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    AnonBlock = $__148.AnonBlock,
    ClassDeclaration = $__148.ClassDeclaration,
    ExportDeclaration = $__148.ExportDeclaration,
    FormalParameter = $__148.FormalParameter,
    FunctionDeclaration = $__148.FunctionDeclaration,
    GetAccessor = $__148.GetAccessor,
    LiteralExpression = $__148.LiteralExpression,
    PropertyMethodAssignment = $__148.PropertyMethodAssignment,
    SetAccessor = $__148.SetAccessor;
var $__148 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BINDING_IDENTIFIER = $__148.BINDING_IDENTIFIER,
    IDENTIFIER_EXPRESSION = $__148.IDENTIFIER_EXPRESSION;
var propName = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/staticsemantics/PropName")).propName;
var $__148 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArgumentList = $__148.createArgumentList,
    createArrayLiteralExpression = $__148.createArrayLiteralExpression,
    createAssignmentStatement = $__148.createAssignmentStatement,
    createIdentifierExpression = $__148.createIdentifierExpression,
    createMemberExpression = $__148.createMemberExpression,
    createNewExpression = $__148.createNewExpression,
    createStatementList = $__148.createStatementList,
    createStringLiteralToken = $__148.createStringLiteralToken;
var parseExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseExpression;
var AnnotationsScope = function AnnotationsScope() {
  this.className = null;
  this.isExport = false;
  this.constructorParameters = [];
  this.annotations = [];
  this.metadata = [];
};
($traceurRuntime.createClass)(AnnotationsScope, {get inClassScope() {
    return this.className !== null;
  }}, {});
var AnnotationsTransformer = function AnnotationsTransformer() {
  this.stack_ = [new AnnotationsScope()];
};
var $AnnotationsTransformer = AnnotationsTransformer;
($traceurRuntime.createClass)(AnnotationsTransformer, {
  transformExportDeclaration: function(tree) {
    var $__149;
    var scope = this.pushAnnotationScope_();
    scope.isExport = true;
    ($__149 = scope.annotations).push.apply($__149, $traceurRuntime.toObject(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 $__149;
    var elementsChanged = false;
    var exportAnnotations = this.scope.isExport ? this.scope.annotations : [];
    var scope = this.pushAnnotationScope_();
    scope.className = tree.name;
    ($__149 = scope.annotations).push.apply($__149, $traceurRuntime.spread(exportAnnotations, tree.annotations));
    tree = $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformClassDeclaration", [tree]);
    ($__149 = scope.metadata).unshift.apply($__149, $traceurRuntime.toObject(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, []);
    }
    return this.appendMetadata_(tree);
  },
  transformFunctionDeclaration: function(tree) {
    var $__149;
    var exportAnnotations = this.scope.isExport ? this.scope.annotations : [];
    var scope = this.pushAnnotationScope_();
    ($__149 = scope.annotations).push.apply($__149, $traceurRuntime.spread(exportAnnotations, tree.annotations));
    ($__149 = scope.metadata).push.apply($__149, $traceurRuntime.toObject(this.transformMetadata_(createIdentifierExpression(tree.name), scope.annotations, tree.parameterList.parameters)));
    tree = $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformFunctionDeclaration", [tree]);
    if (tree.annotations.length > 0) {
      tree = new FunctionDeclaration(tree.location, tree.name, tree.functionKind, tree.parameterList, tree.typeAnnotation, [], tree.functionBody);
    }
    return this.appendMetadata_(tree);
  },
  transformFormalParameter: function(tree) {
    if (tree.annotations.length > 0) {
      tree = new FormalParameter(tree.location, tree.parameter, tree.typeAnnotation, []);
    }
    return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformFormalParameter", [tree]);
  },
  transformGetAccessor: function(tree) {
    var $__149;
    if (!this.scope.inClassScope)
      return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformGetAccessor", [tree]);
    ($__149 = this.scope.metadata).push.apply($__149, $traceurRuntime.toObject(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.superCall(this, $AnnotationsTransformer.prototype, "transformGetAccessor", [tree]);
  },
  transformSetAccessor: function(tree) {
    var $__149;
    if (!this.scope.inClassScope)
      return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformSetAccessor", [tree]);
    ($__149 = this.scope.metadata).push.apply($__149, $traceurRuntime.toObject(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.superCall(this, $AnnotationsTransformer.prototype, "transformSetAccessor", [tree]);
  },
  transformPropertyMethodAssignment: function(tree) {
    var $__149;
    if (!this.scope.inClassScope)
      return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformPropertyMethodAssignment", [tree]);
    if (!tree.isStatic && propName(tree) === CONSTRUCTOR) {
      ($__149 = this.scope.annotations).push.apply($__149, $traceurRuntime.toObject(tree.annotations));
      this.scope.constructorParameters = tree.parameterList.parameters;
    } else {
      ($__149 = this.scope.metadata).push.apply($__149, $traceurRuntime.toObject(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 PropertyMethodAssignment(tree.location, tree.isStatic, tree.functionKind, tree.name, parameterList, tree.typeAnnotation, [], tree.functionBody);
    }
    return $traceurRuntime.superCall(this, $AnnotationsTransformer.prototype, "transformPropertyMethodAssignment", [tree]);
  },
  appendMetadata_: function(tree) {
    var $__149;
    var metadata = this.stack_.pop().metadata;
    if (metadata.length > 0) {
      if (this.scope.isExport) {
        ($__149 = this.scope.metadata).push.apply($__149, $traceurRuntime.toObject(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($__145, args);
    return createMemberExpression(descriptor, accessor);
  },
  transformParameters_: function(parameters) {
    var $__146 = this;
    var hasParameterMetadata = false;
    parameters = parameters.map((function(param) {
      var $__149;
      var metadata = [];
      if (param.typeAnnotation)
        metadata.push($__146.transformAny(param.typeAnnotation));
      if (param.annotations && param.annotations.length > 0)
        ($__149 = metadata).push.apply($__149, $traceurRuntime.toObject($__146.transformAnnotations_(param.annotations)));
      if (metadata.length > 0) {
        hasParameterMetadata = true;
        return createArrayLiteralExpression(metadata);
      }
      return createArrayLiteralExpression([]);
    }));
    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(createAssignmentStatement(createMemberExpression(target, 'annotations'), createArrayLiteralExpression(annotations)));
      }
    }
    if (parameters !== null) {
      parameters = this.transformParameters_(parameters);
      if (parameters.length > 0) {
        metadataStatements.push(createAssignmentStatement(createMemberExpression(target, 'parameters'), createArrayLiteralExpression(parameters)));
      }
    }
    return metadataStatements;
  },
  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;
  }
}, {}, ParseTreeTransformer);
return {get AnnotationsTransformer() {
    return AnnotationsTransformer;
  }};

}); System.register(“traceur@0.0.43/src/semantics/VariableBinder”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/semantics/VariableBinder";
var $__151 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    ARRAY_PATTERN = $__151.ARRAY_PATTERN,
    BINDING_ELEMENT = $__151.BINDING_ELEMENT,
    BINDING_IDENTIFIER = $__151.BINDING_IDENTIFIER,
    FORMAL_PARAMETER = $__151.FORMAL_PARAMETER,
    OBJECT_PATTERN = $__151.OBJECT_PATTERN,
    OBJECT_PATTERN_FIELD = $__151.OBJECT_PATTERN_FIELD,
    PAREN_EXPRESSION = $__151.PAREN_EXPRESSION,
    SPREAD_PATTERN_ELEMENT = $__151.SPREAD_PATTERN_ELEMENT;
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var VAR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).VAR;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
function variablesInBlock(tree, includeFunctionScope) {
  var binder = new VariableBinder(includeFunctionScope, tree);
  binder.visitAny(tree);
  return binder.identifiers_;
}
;
function variablesInFunction(tree) {
  var binder = new VariableBinder(true, tree.functionBody);
  binder.bindVariablesInFunction_(tree);
  return binder.identifiers_;
}
;
var VariableBinder = function VariableBinder(includeFunctionScope, scope) {
  $traceurRuntime.superCall(this, $VariableBinder.prototype, "constructor", []);
  this.includeFunctionScope_ = includeFunctionScope;
  this.scope_ = scope || null;
  this.block_ = null;
  this.identifiers_ = Object.create(null);
};
var $VariableBinder = VariableBinder;
($traceurRuntime.createClass)(VariableBinder, {
  bindVariablesInFunction_: function(tree) {
    var parameters = tree.parameterList.parameters;
    for (var i = 0; i < parameters.length; i++) {
      this.bindParameter_(parameters[i]);
    }
    this.visitAny(tree.functionBody);
  },
  visitBlock: function(tree) {
    var parentBlock = this.block_;
    this.block_ = tree;
    this.visitList(tree.statements);
    this.block_ = parentBlock;
  },
  visitFunctionDeclaration: function(tree) {
    if (this.block_ == this.scope_)
      this.bind_(tree.name.identifierToken);
  },
  visitFunctionExpression: function(tree) {},
  visitVariableDeclarationList: function(tree) {
    if ((tree.declarationType == VAR && this.includeFunctionScope_) || (tree.declarationType != VAR && this.block_ == this.scope_)) {
      $traceurRuntime.superCall(this, $VariableBinder.prototype, "visitVariableDeclarationList", [tree]);
    } else {
      var decls = tree.declarations;
      for (var i = 0; i < decls.length; i++) {
        this.visitAny(decls[i].initializer);
      }
    }
  },
  visitVariableDeclaration: function(tree) {
    this.bindVariableDeclaration_(tree.lvalue);
    $traceurRuntime.superCall(this, $VariableBinder.prototype, "visitVariableDeclaration", [tree]);
  },
  bind_: function(identifier) {
    assert(typeof identifier.value == 'string');
    this.identifiers_[identifier.value] = true;
  },
  bindParameter_: function(parameter) {
    if (parameter.type === FORMAL_PARAMETER)
      parameter = parameter.parameter;
    if (parameter.isRestParameter()) {
      this.bind_(parameter.identifier);
    } else {
      this.bindVariableDeclaration_(parameter.binding);
    }
  },
  bindVariableDeclaration_: function(tree) {
    switch (tree.type) {
      case BINDING_ELEMENT:
        this.bindVariableDeclaration_(tree.binding);
        break;
      case BINDING_IDENTIFIER:
        this.bind_(tree.identifierToken);
        break;
      case ARRAY_PATTERN:
        var elements = tree.elements;
        for (var i = 0; i < elements.length; i++) {
          this.bindVariableDeclaration_(elements[i]);
        }
        break;
      case SPREAD_PATTERN_ELEMENT:
        this.bindVariableDeclaration_(tree.lvalue);
        break;
      case OBJECT_PATTERN:
        var fields = tree.fields;
        for (var i = 0; i < fields.length; i++) {
          this.bindVariableDeclaration_(fields[i]);
        }
        break;
      case OBJECT_PATTERN_FIELD:
        var field = tree;
        if (field.element == null) {
          this.bind_(field.name);
        } else {
          this.bindVariableDeclaration_(field.element);
        }
        break;
      case PAREN_EXPRESSION:
        this.bindVariableDeclaration_(tree.expression);
        break;
      default:
        throw new Error('unreachable');
    }
  }
}, {}, ParseTreeVisitor);
return {
  get variablesInBlock() {
    return variablesInBlock;
  },
  get variablesInFunction() {
    return variablesInFunction;
  },
  get VariableBinder() {
    return VariableBinder;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/AlphaRenamer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/AlphaRenamer";
var $__153 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    FunctionDeclaration = $__153.FunctionDeclaration,
    FunctionExpression = $__153.FunctionExpression;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__153 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    ARGUMENTS = $__153.ARGUMENTS,
    THIS = $__153.THIS;
var createIdentifierExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createIdentifierExpression;
var $__153 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/semantics/VariableBinder")),
    variablesInBlock = $__153.variablesInBlock,
    variablesInFunction = $__153.variablesInFunction;
var AlphaRenamer = function AlphaRenamer(oldName, newName) {
  $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "constructor", []);
  this.oldName_ = oldName;
  this.newName_ = newName;
};
var $AlphaRenamer = AlphaRenamer;
($traceurRuntime.createClass)(AlphaRenamer, {
  transformBlock: function(tree) {
    if (this.oldName_ in variablesInBlock(tree)) {
      return tree;
    } else {
      return $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "transformBlock", [tree]);
    }
  },
  transformIdentifierExpression: function(tree) {
    if (this.oldName_ == tree.identifierToken.value) {
      return createIdentifierExpression(this.newName_);
    } else {
      return tree;
    }
  },
  transformThisExpression: function(tree) {
    if (this.oldName_ !== THIS)
      return tree;
    return createIdentifierExpression(this.newName_);
  },
  transformFunctionDeclaration: function(tree) {
    if (this.oldName_ === tree.name) {
      tree = new FunctionDeclaration(tree.location, this.newName_, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.functionBody);
    }
    if (this.getDoNotRecurse(tree))
      return tree;
    return $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "transformFunctionDeclaration", [tree]);
  },
  transformFunctionExpression: function(tree) {
    if (this.oldName_ === tree.name) {
      tree = new FunctionExpression(tree.location, this.newName_, tree.functionKind, tree.parameterList, tree.typeAnnotation, tree.annotations, tree.functionBody);
    }
    if (this.getDoNotRecurse(tree))
      return tree;
    return $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "transformFunctionExpression", [tree]);
  },
  getDoNotRecurse: function(tree) {
    return this.oldName_ === ARGUMENTS || this.oldName_ === THIS || this.oldName_ in variablesInFunction(tree);
  },
  transformCatch: function(tree) {
    if (!tree.binding.isPattern() && this.oldName_ === tree.binding.identifierToken.value) {
      return tree;
    }
    return $traceurRuntime.superCall(this, $AlphaRenamer.prototype, "transformCatch", [tree]);
  }
}, {rename: function(tree, oldName, newName) {
    return new $AlphaRenamer(oldName, newName).transformAny(tree);
  }}, ParseTreeTransformer);
return {get AlphaRenamer() {
    return AlphaRenamer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/alphaRenameThisAndArguments”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/alphaRenameThisAndArguments";
var $__155 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    ARGUMENTS = $__155.ARGUMENTS,
    THIS = $__155.THIS;
var AlphaRenamer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AlphaRenamer")).AlphaRenamer;
var FindInFunctionScope = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindInFunctionScope")).FindInFunctionScope;
var FindThisOrArguments = function FindThisOrArguments(tree) {
  this.foundThis = false;
  this.foundArguments = false;
  $traceurRuntime.superCall(this, $FindThisOrArguments.prototype, "constructor", [tree]);
};
var $FindThisOrArguments = FindThisOrArguments;
($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;
    }
  }
}, {}, FindInFunctionScope);
var $__default = function alphaRenameThisAndArguments(tempVarTransformer, tree) {
  var finder = new FindThisOrArguments(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 $__default;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ComprehensionTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ComprehensionTransformer";
var alphaRenameThisAndArguments = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/alphaRenameThisAndArguments")).default;
var FunctionExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")).FunctionExpression;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__157 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    LET = $__157.LET,
    STAR = $__157.STAR,
    VAR = $__157.VAR;
var $__157 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    COMPREHENSION_FOR = $__157.COMPREHENSION_FOR,
    COMPREHENSION_IF = $__157.COMPREHENSION_IF;
var Token = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Token")).Token;
var $__157 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createCallExpression = $__157.createCallExpression,
    createEmptyParameterList = $__157.createEmptyParameterList,
    createForOfStatement = $__157.createForOfStatement,
    createFunctionBody = $__157.createFunctionBody,
    createIfStatement = $__157.createIfStatement,
    createParenExpression = $__157.createParenExpression,
    createVariableDeclarationList = $__157.createVariableDeclarationList;
var options = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).options;
var ComprehensionTransformer = function ComprehensionTransformer() {
  $traceurRuntime.defaultSuperCall(this, $ComprehensionTransformer.prototype, arguments);
};
var $ComprehensionTransformer = ComprehensionTransformer;
($traceurRuntime.createClass)(ComprehensionTransformer, {transformComprehension: function(tree, statement, isGenerator) {
    var prefix = arguments[3];
    var suffix = arguments[4];
    var bindingKind = isGenerator || !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));
  }}, {}, TempVarTransformer);
return {get ComprehensionTransformer() {
    return ComprehensionTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ArrayComprehensionTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ArrayComprehensionTransformer";
var $__158 = Object.freeze(Object.defineProperties(["var ", " = 0, ", " = [];"], {raw: {value: Object.freeze(["var ", " = 0, ", " = [];"])}})),
    $__159 = Object.freeze(Object.defineProperties(["", "[", "++] = ", ";"], {raw: {value: Object.freeze(["", "[", "++] = ", ";"])}})),
    $__160 = Object.freeze(Object.defineProperties(["return ", ";"], {raw: {value: Object.freeze(["return ", ";"])}}));
var ComprehensionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ComprehensionTransformer")).ComprehensionTransformer;
var createIdentifierExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createIdentifierExpression;
var parseStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatement;
var ArrayComprehensionTransformer = function ArrayComprehensionTransformer() {
  $traceurRuntime.defaultSuperCall(this, $ArrayComprehensionTransformer.prototype, arguments);
};
var $ArrayComprehensionTransformer = ArrayComprehensionTransformer;
($traceurRuntime.createClass)(ArrayComprehensionTransformer, {transformArrayComprehension: function(tree) {
    this.pushTempVarState();
    var expression = this.transformAny(tree.expression);
    var index = createIdentifierExpression(this.getTempIdentifier());
    var result = createIdentifierExpression(this.getTempIdentifier());
    var tempVarsStatatement = parseStatement($__158, index, result);
    var statement = parseStatement($__159, result, index, expression);
    var returnStatement = parseStatement($__160, result);
    var functionKind = null;
    var result = this.transformComprehension(tree, statement, functionKind, tempVarsStatatement, returnStatement);
    this.popTempVarState();
    return result;
  }}, {}, ComprehensionTransformer);
return {get ArrayComprehensionTransformer() {
    return ArrayComprehensionTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ArrowFunctionTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ArrowFunctionTransformer";
var $__164 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    FormalParameterList = $__164.FormalParameterList,
    FunctionExpression = $__164.FunctionExpression;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__164 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    FUNCTION_BODY = $__164.FUNCTION_BODY,
    FUNCTION_EXPRESSION = $__164.FUNCTION_EXPRESSION;
var alphaRenameThisAndArguments = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/alphaRenameThisAndArguments")).default;
var $__164 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createFunctionBody = $__164.createFunctionBody,
    createParenExpression = $__164.createParenExpression,
    createReturnStatement = $__164.createReturnStatement;
function convertConciseBody(tree) {
  if (tree.type !== FUNCTION_BODY)
    return createFunctionBody([createReturnStatement(tree)]);
  return tree;
}
var ArrowFunctionTransformer = function ArrowFunctionTransformer() {
  $traceurRuntime.defaultSuperCall(this, $ArrowFunctionTransformer.prototype, arguments);
};
var $ArrowFunctionTransformer = ArrowFunctionTransformer;
($traceurRuntime.createClass)(ArrowFunctionTransformer, {transformArrowFunctionExpression: function(tree) {
    var alphaRenamed = alphaRenameThisAndArguments(this, tree);
    var parameterList = this.transformAny(alphaRenamed.parameterList);
    var functionBody = this.transformAny(alphaRenamed.functionBody);
    functionBody = convertConciseBody(functionBody);
    var functionExpression = new FunctionExpression(tree.location, null, tree.functionKind, parameterList, null, [], functionBody);
    return createParenExpression(functionExpression);
  }}, {transform: function(tempVarTransformer, tree) {
    tree = alphaRenameThisAndArguments(tempVarTransformer, tree);
    var functionBody = convertConciseBody(tree.functionBody);
    return new FunctionExpression(tree.location, null, tree.functionKind, tree.parameterList, null, [], functionBody);
  }}, TempVarTransformer);
return {get ArrowFunctionTransformer() {
    return ArrowFunctionTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/BlockBindingTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/BlockBindingTransformer";
var AlphaRenamer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AlphaRenamer")).AlphaRenamer;
var $__167 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BINDING_IDENTIFIER = $__167.BINDING_IDENTIFIER,
    BLOCK = $__167.BLOCK,
    VARIABLE_DECLARATION_LIST = $__167.VARIABLE_DECLARATION_LIST;
var $__167 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    FunctionDeclaration = $__167.FunctionDeclaration,
    FunctionExpression = $__167.FunctionExpression;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__167 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    CONST = $__167.CONST,
    LET = $__167.LET,
    VAR = $__167.VAR;
var $__167 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentExpression = $__167.createAssignmentExpression,
    createBindingIdentifier = $__167.createBindingIdentifier,
    createBlock = $__167.createBlock,
    createCatch = $__167.createCatch,
    createEmptyStatement = $__167.createEmptyStatement,
    createExpressionStatement = $__167.createExpressionStatement,
    createFinally = $__167.createFinally,
    createForInStatement = $__167.createForInStatement,
    createForStatement = $__167.createForStatement,
    createFunctionBody = $__167.createFunctionBody,
    createIdentifierExpression = $__167.createIdentifierExpression,
    createIdentifierToken = $__167.createIdentifierToken,
    createThrowStatement = $__167.createThrowStatement,
    createTryStatement = $__167.createTryStatement,
    createUndefinedExpression = $__167.createUndefinedExpression,
    createVariableDeclaration = $__167.createVariableDeclaration,
    createVariableDeclarationList = $__167.createVariableDeclarationList,
    createVariableStatement = $__167.createVariableStatement;
var ScopeType = {
  SCRIPT: 'SCRIPT',
  FUNCTION: 'FUNCTION',
  BLOCK: 'BLOCK'
};
var Scope = function Scope(parent, type) {
  this.parent = parent;
  this.type = type;
  this.blockVariables = null;
};
($traceurRuntime.createClass)(Scope, {addBlockScopedVariable: function(value) {
    if (!this.blockVariables) {
      this.blockVariables = Object.create(null);
    }
    this.blockVariables[value] = true;
  }}, {});
;
var Rename = function Rename(oldName, newName) {
  this.oldName = oldName;
  this.newName = newName;
};
($traceurRuntime.createClass)(Rename, {}, {});
function renameAll(renames, tree) {
  renames.forEach((function(rename) {
    tree = AlphaRenamer.rename(tree, rename.oldName, rename.newName);
  }));
  return tree;
}
function toBlock(statement) {
  return statement.type == BLOCK ? statement : createBlock(statement);
}
var BlockBindingTransformer = function BlockBindingTransformer(stateAllocator) {
  $traceurRuntime.superCall(this, $BlockBindingTransformer.prototype, "constructor", []);
  this.scope_ = null;
};
var $BlockBindingTransformer = BlockBindingTransformer;
($traceurRuntime.createClass)(BlockBindingTransformer, {
  createScriptScope_: function() {
    return new Scope(this.scope_, ScopeType.SCRIPT);
  },
  createFunctionScope_: function() {
    if (this.scope_ == null) {
      throw new Error('Top level function scope found.');
    }
    return new Scope(this.scope_, ScopeType.FUNCTION);
  },
  createBlockScope_: function() {
    if (this.scope_ == null) {
      throw new Error('Top level block scope found.');
    }
    return new Scope(this.scope_, ScopeType.BLOCK);
  },
  push_: function(scope) {
    this.scope_ = scope;
    return scope;
  },
  pop_: function(scope) {
    if (this.scope_ != scope) {
      throw new Error('BlockBindingTransformer scope mismatch');
    }
    this.scope_ = scope.parent;
  },
  transformBlock: function(tree) {
    var scope = this.push_(this.createBlockScope_());
    var statements = this.transformList(tree.statements);
    if (scope.blockVariables != null) {
      tree = toBlock(this.rewriteAsCatch_(scope.blockVariables, createBlock(statements)));
    } else if (statements != tree.statements) {
      tree = createBlock(statements);
    }
    this.pop_(scope);
    return tree;
  },
  rewriteAsCatch_: function(blockVariables, statement) {
    for (var variable in blockVariables) {
      statement = createTryStatement(createBlock(createThrowStatement(createUndefinedExpression())), createCatch(createBindingIdentifier(variable), toBlock(statement)), null);
    }
    return statement;
  },
  transformClassDeclaration: function(tree) {
    throw new Error('ClassDeclaration should be transformed away.');
  },
  transformForInStatement: function(tree) {
    var treeBody = tree.body;
    var initializer;
    if (tree.initializer != null && tree.initializer.type == VARIABLE_DECLARATION_LIST) {
      var variables = tree.initializer;
      if (variables.declarations.length != 1) {
        throw new Error('for .. in has != 1 variables');
      }
      var variable = variables.declarations[0];
      var variableName = this.getVariableName_(variable);
      switch (variables.declarationType) {
        case LET:
        case CONST:
          {
            if (variable.initializer != null) {
              throw new Error('const/let in for-in may not have an initializer');
            }
            initializer = createVariableDeclarationList(VAR, ("$" + variableName), null);
            treeBody = this.prependToBlock_(createVariableStatement(LET, variableName, createIdentifierExpression(("$" + variableName))), treeBody);
            break;
          }
        case VAR:
          initializer = this.transformVariables_(variables);
          break;
        default:
          throw new Error('Unreachable.');
      }
    } else {
      initializer = this.transformAny(tree.initializer);
    }
    var result = tree;
    var collection = this.transformAny(tree.collection);
    var body = this.transformAny(treeBody);
    if (initializer != tree.initializer || collection != tree.collection || body != tree.body) {
      result = createForInStatement(initializer, collection, body);
    }
    return result;
  },
  prependToBlock_: function(statement, body) {
    if (body.type == BLOCK) {
      var block = body;
      var list = $traceurRuntime.spread([statement], block.statements);
      return createBlock(list);
    } else {
      return createBlock(statement, body);
    }
  },
  transformForStatement: function(tree) {
    var initializer;
    if (tree.initializer != null && tree.initializer.type == VARIABLE_DECLARATION_LIST) {
      var variables = tree.initializer;
      switch (variables.declarationType) {
        case LET:
        case CONST:
          return this.transformForLet_(tree, variables);
        case VAR:
          initializer = this.transformVariables_(variables);
          break;
        default:
          throw new Error('Reached unreachable.');
      }
    } else {
      initializer = this.transformAny(tree.initializer);
    }
    var condition = this.transformAny(tree.condition);
    var increment = this.transformAny(tree.increment);
    var body = this.transformAny(tree.body);
    var result = tree;
    if (initializer != tree.initializer || condition != tree.condition || increment != tree.increment || body != tree.body) {
      result = createForStatement(initializer, condition, increment, body);
    }
    return result;
  },
  transformForLet_: function(tree, variables) {
    var $__165 = this;
    var copyFwd = [];
    var copyBak = [];
    var hoisted = [];
    var renames = [];
    variables.declarations.forEach((function(variable) {
      var variableName = $__165.getVariableName_(variable);
      var hoistedName = ("$" + variableName);
      var initializer = renameAll(renames, variable.initializer);
      hoisted.push(createVariableDeclaration(hoistedName, initializer));
      copyFwd.push(createVariableDeclaration(variableName, createIdentifierExpression(hoistedName)));
      copyBak.push(createExpressionStatement(createAssignmentExpression(createIdentifierExpression(hoistedName), createIdentifierExpression(variableName))));
      renames.push(new Rename(variableName, hoistedName));
    }));
    var condition = renameAll(renames, tree.condition);
    var increment = renameAll(renames, tree.increment);
    var transformedForLoop = createBlock(createVariableStatement(createVariableDeclarationList(LET, hoisted)), createForStatement(null, condition, increment, createBlock(createVariableStatement(createVariableDeclarationList(LET, copyFwd)), createTryStatement(toBlock(tree.body), null, createFinally(createBlock(copyBak))))));
    return this.transformAny(transformedForLoop);
  },
  transformFunctionDeclaration: function(tree) {
    var body = this.transformFunctionBody(tree.functionBody);
    var parameterList = this.transformAny(tree.parameterList);
    if (this.scope_.type === ScopeType.BLOCK) {
      this.scope_.addBlockScopedVariable(tree.name.identifierToken.value);
      return createExpressionStatement(createAssignmentExpression(createIdentifierExpression(tree.name.identifierToken), new FunctionExpression(tree.location, null, tree.functionKind, parameterList, tree.typeAnnotation, tree.annotations, body)));
    }
    if (body === tree.functionBody && parameterList === tree.parameterList) {
      return tree;
    }
    return new FunctionDeclaration(tree.location, tree.name, tree.functionKind, parameterList, tree.typeAnnotation, tree.annotations, body);
  },
  transformScript: function(tree) {
    var scope = this.push_(this.createScriptScope_());
    var result = $traceurRuntime.superCall(this, $BlockBindingTransformer.prototype, "transformScript", [tree]);
    this.pop_(scope);
    return result;
  },
  transformVariableDeclaration: function(tree) {
    throw new Error('Should never see variable declaration tree.');
  },
  transformVariableDeclarationList: function(tree) {
    throw new Error('Should never see variable declaration list.');
  },
  transformVariableStatement: function(tree) {
    if (this.scope_.type == ScopeType.BLOCK) {
      switch (tree.declarations.declarationType) {
        case CONST:
        case LET:
          return this.transformBlockVariables_(tree.declarations);
        default:
          break;
      }
    }
    var variables = this.transformVariables_(tree.declarations);
    if (variables != tree.declarations) {
      tree = createVariableStatement(variables);
    }
    return tree;
  },
  transformBlockVariables_: function(tree) {
    var $__165 = this;
    var variables = tree.declarations;
    var comma = [];
    variables.forEach((function(variable) {
      switch (tree.declarationType) {
        case LET:
        case CONST:
          break;
        default:
          throw new Error('Only let/const allowed here.');
      }
      var variableName = $__165.getVariableName_(variable);
      $__165.scope_.addBlockScopedVariable(variableName);
      var initializer = $__165.transformAny(variable.initializer);
      if (initializer != null) {
        comma.push(createAssignmentExpression(createIdentifierExpression(variableName), initializer));
      }
    }));
    switch (comma.length) {
      case 0:
        return createEmptyStatement();
      case 1:
        return createExpressionStatement(comma[0]);
      default:
        for (var i = 0; i < comma.length; i++) {
          comma[i] = createExpressionStatement(comma[i]);
        }
        return createBlock(comma);
    }
  },
  transformVariables_: function(tree) {
    var variables = tree.declarations;
    var transformed = null;
    for (var index = 0; index < variables.length; index++) {
      var variable = variables[index];
      var variableName = this.getVariableName_(variable);
      var initializer = this.transformAny(variable.initializer);
      if (transformed != null || initializer != variable.initializer) {
        if (transformed == null) {
          transformed = variables.slice(0, index);
        }
        transformed.push(createVariableDeclaration(createIdentifierToken(variableName), initializer));
      }
    }
    if (transformed != null || tree.declarationType != VAR) {
      var declarations = transformed != null ? transformed : tree.declarations;
      var declarationType = tree.declarationType != VAR ? VAR : tree.declarationType;
      tree = createVariableDeclarationList(declarationType, declarations);
    }
    return tree;
  },
  transformFunctionBody: function(body) {
    var scope = this.push_(this.createFunctionScope_());
    body = this.transformFunctionBodyStatements_(body);
    this.pop_(scope);
    return body;
  },
  transformFunctionBodyStatements_: function(tree) {
    var statements = this.transformList(tree.statements);
    if (this.scope_.blockVariables != null) {
      tree = this.rewriteAsCatch_(this.scope_.blockVariables, createBlock(statements));
    } else if (statements != tree.statements) {
      tree = createFunctionBody(statements);
    }
    return tree;
  },
  getVariableName_: function(variable) {
    var lvalue = variable.lvalue;
    if (lvalue.type == BINDING_IDENTIFIER) {
      return lvalue.identifierToken.value;
    }
    throw new Error('Unexpected destructuring declaration found.');
  }
}, {}, ParseTreeTransformer);
return {get BlockBindingTransformer() {
    return BlockBindingTransformer;
  }};

}); System.register(“traceur@0.0.43/src/semantics/util”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/semantics/util";
var $__168 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    IDENTIFIER_EXPRESSION = $__168.IDENTIFIER_EXPRESSION,
    LITERAL_EXPRESSION = $__168.LITERAL_EXPRESSION,
    PAREN_EXPRESSION = $__168.PAREN_EXPRESSION,
    UNARY_EXPRESSION = $__168.UNARY_EXPRESSION;
var UNDEFINED = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).UNDEFINED;
var VOID = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).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;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/MakeStrictTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/MakeStrictTransformer";
var $__170 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    FunctionBody = $__170.FunctionBody,
    Script = $__170.Script;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var createUseStrictDirective = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createUseStrictDirective;
var hasUseStrict = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/semantics/util")).hasUseStrict;
function prepend(statements) {
  return $traceurRuntime.spread([createUseStrictDirective()], statements);
}
var MakeStrictTransformer = function MakeStrictTransformer() {
  $traceurRuntime.defaultSuperCall(this, $MakeStrictTransformer.prototype, arguments);
};
var $MakeStrictTransformer = MakeStrictTransformer;
($traceurRuntime.createClass)(MakeStrictTransformer, {
  transformScript: function(tree) {
    if (hasUseStrict(tree.scriptItemList))
      return tree;
    return new Script(tree.location, prepend(tree.scriptItemList));
  },
  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);
  }}, ParseTreeTransformer);
return {get MakeStrictTransformer() {
    return MakeStrictTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/assignmentOperatorToBinaryOperator”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/assignmentOperatorToBinaryOperator";
var $__171 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    AMPERSAND = $__171.AMPERSAND,
    AMPERSAND_EQUAL = $__171.AMPERSAND_EQUAL,
    BAR = $__171.BAR,
    BAR_EQUAL = $__171.BAR_EQUAL,
    CARET = $__171.CARET,
    CARET_EQUAL = $__171.CARET_EQUAL,
    LEFT_SHIFT = $__171.LEFT_SHIFT,
    LEFT_SHIFT_EQUAL = $__171.LEFT_SHIFT_EQUAL,
    MINUS = $__171.MINUS,
    MINUS_EQUAL = $__171.MINUS_EQUAL,
    PERCENT = $__171.PERCENT,
    PERCENT_EQUAL = $__171.PERCENT_EQUAL,
    PLUS = $__171.PLUS,
    PLUS_EQUAL = $__171.PLUS_EQUAL,
    RIGHT_SHIFT = $__171.RIGHT_SHIFT,
    RIGHT_SHIFT_EQUAL = $__171.RIGHT_SHIFT_EQUAL,
    SLASH = $__171.SLASH,
    SLASH_EQUAL = $__171.SLASH_EQUAL,
    STAR = $__171.STAR,
    STAR_EQUAL = $__171.STAR_EQUAL,
    UNSIGNED_RIGHT_SHIFT = $__171.UNSIGNED_RIGHT_SHIFT,
    UNSIGNED_RIGHT_SHIFT_EQUAL = $__171.UNSIGNED_RIGHT_SHIFT_EQUAL;
function assignmentOperatorToBinaryOperator(type) {
  switch (type) {
    case STAR_EQUAL:
      return 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;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ExplodeExpressionTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ExplodeExpressionTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__173 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentExpression = $__173.createAssignmentExpression,
    createCommaExpression = $__173.createCommaExpression,
    id = $__173.createIdentifierExpression,
    createMemberExpression = $__173.createMemberExpression,
    createNumberLiteral = $__173.createNumberLiteral,
    createOperatorToken = $__173.createOperatorToken,
    createParenExpression = $__173.createParenExpression;
var $__173 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    AND = $__173.AND,
    EQUAL = $__173.EQUAL,
    MINUS = $__173.MINUS,
    MINUS_EQUAL = $__173.MINUS_EQUAL,
    MINUS_MINUS = $__173.MINUS_MINUS,
    OR = $__173.OR,
    PLUS = $__173.PLUS,
    PLUS_EQUAL = $__173.PLUS_EQUAL,
    PLUS_PLUS = $__173.PLUS_PLUS;
var $__173 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    COMMA_EXPRESSION = $__173.COMMA_EXPRESSION,
    IDENTIFIER_EXPRESSION = $__173.IDENTIFIER_EXPRESSION,
    LITERAL_EXPRESSION = $__173.LITERAL_EXPRESSION,
    MEMBER_EXPRESSION = $__173.MEMBER_EXPRESSION,
    MEMBER_LOOKUP_EXPRESSION = $__173.MEMBER_LOOKUP_EXPRESSION,
    PROPERTY_NAME_ASSIGNMENT = $__173.PROPERTY_NAME_ASSIGNMENT,
    SPREAD_EXPRESSION = $__173.SPREAD_EXPRESSION,
    TEMPLATE_LITERAL_PORTION = $__173.TEMPLATE_LITERAL_PORTION;
var $__173 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    ArgumentList = $__173.ArgumentList,
    ArrayLiteralExpression = $__173.ArrayLiteralExpression,
    AwaitExpression = $__173.AwaitExpression,
    BinaryOperator = $__173.BinaryOperator,
    CallExpression = $__173.CallExpression,
    ConditionalExpression = $__173.ConditionalExpression,
    MemberExpression = $__173.MemberExpression,
    MemberLookupExpression = $__173.MemberLookupExpression,
    NewExpression = $__173.NewExpression,
    ObjectLiteralExpression = $__173.ObjectLiteralExpression,
    PropertyNameAssignment = $__173.PropertyNameAssignment,
    SpreadExpression = $__173.SpreadExpression,
    TemplateLiteralExpression = $__173.TemplateLiteralExpression,
    TemplateSubstitution = $__173.TemplateSubstitution,
    UnaryExpression = $__173.UnaryExpression,
    YieldExpression = $__173.YieldExpression;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var assignmentOperatorToBinaryOperator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/assignmentOperatorToBinaryOperator")).default;
var CommaExpressionBuilder = function CommaExpressionBuilder(tempVar) {
  this.tempVar = tempVar;
  this.expressions = [];
};
($traceurRuntime.createClass)(CommaExpressionBuilder, {
  add: function(tree) {
    var $__174;
    if (tree.type === COMMA_EXPRESSION)
      ($__174 = this.expressions).push.apply($__174, $traceurRuntime.toObject(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 ExplodeExpressionTransformer(tempVarTransformer) {
  $traceurRuntime.superCall(this, $ExplodeExpressionTransformer.prototype, "constructor", []);
  this.tempVarTransformer_ = tempVarTransformer;
};
var $ExplodeExpressionTransformer = ExplodeExpressionTransformer;
($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 BinaryOperator(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 BinaryOperator(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 BinaryOperator(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 BinaryOperator(tree.location, tmp, createOperatorToken(operator), createNumberLiteral(1))), tmp]);
    return createCommaExpression(expressions);
  },
  transformYieldExpression: function(tree) {
    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)));
  },
  transformBinaryOperator: 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 BinaryOperator(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) {
      var left = this.transformAny(left);
      var right = this.transformAny(tree.right);
      var expressions = $traceurRuntime.spread(getExpressions(right), [createAssignmentExpression(left, getResult(right)), getResult(right)]);
      return createCommaExpression(expressions);
    }
    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 BinaryOperator(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 = this.transformAny(left.operand);
      var right = this.transformAny(tree.right);
      var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(right), [new BinaryOperator(tree.location, new MemberExpression(left.location, getResult(operand), left.memberName), tree.operator, getResult(right)), getResult(right)]);
      return createCommaExpression(expressions);
    }
    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 BinaryOperator(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 = this.transformAny(left.operand);
      var memberExpression = this.transformAny(left.memberExpression);
      var right = this.transformAny(tree.right);
      var expressions = $traceurRuntime.spread(getExpressions(operand), getExpressions(memberExpression), getExpressions(right), [new BinaryOperator(tree.location, new MemberLookupExpression(left.location, getResult(operand), getResult(memberExpression)), tree.operator, getResult(right)), getResult(right)]);
      return createCommaExpression(expressions);
    }
    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 BinaryOperator(tree.location, tmp, binop, getResult(right))), createAssignmentExpression(memberLookupExpression, tmp2), tmp2]);
    return createCommaExpression(expressions);
  },
  transformArrayLiteralExpression: 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 ArrayLiteralExpression(tree.location, results));
  },
  transformObjectLiteralExpression: 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 ObjectLiteralExpression(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 $__174;
      ($__174 = expressions).push.apply($__174, $traceurRuntime.toObject(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 $__174;
      ($__174 = expressions).push.apply($__174, $traceurRuntime.toObject(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);
  },
  createCommaExpressionBuilder: function() {
    return new CommaExpressionBuilder(this.addTempVar());
  }
}, {}, ParseTreeTransformer);
return {get ExplodeExpressionTransformer() {
    return ExplodeExpressionTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/SuperTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/SuperTransformer";
var $__175 = Object.freeze(Object.defineProperties(["$traceurRuntime.superCall(", ", ", ", ", ",\n                                   ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.superCall(", ", ", ", ", ",\n                                   ", ")"])}})),
    $__176 = Object.freeze(Object.defineProperties(["$traceurRuntime.superGet(", ", ", ", ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.superGet(", ", ", ", ", ")"])}})),
    $__177 = Object.freeze(Object.defineProperties(["$traceurRuntime.superSet(", ", ", ", ", ",\n                                    ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.superSet(", ", ", ", ", ",\n                                    ", ")"])}}));
var ExplodeExpressionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ExplodeExpressionTransformer")).ExplodeExpressionTransformer;
var $__179 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    FunctionDeclaration = $__179.FunctionDeclaration,
    FunctionExpression = $__179.FunctionExpression;
var $__179 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    LITERAL_PROPERTY_NAME = $__179.LITERAL_PROPERTY_NAME,
    MEMBER_EXPRESSION = $__179.MEMBER_EXPRESSION,
    MEMBER_LOOKUP_EXPRESSION = $__179.MEMBER_LOOKUP_EXPRESSION,
    SUPER_EXPRESSION = $__179.SUPER_EXPRESSION;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__179 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    EQUAL = $__179.EQUAL,
    MINUS_MINUS = $__179.MINUS_MINUS,
    PLUS_PLUS = $__179.PLUS_PLUS;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var $__179 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArrayLiteralExpression = $__179.createArrayLiteralExpression,
    createIdentifierExpression = $__179.createIdentifierExpression,
    createParenExpression = $__179.createParenExpression,
    createStringLiteral = $__179.createStringLiteral,
    createThisExpression = $__179.createThisExpression;
var parseExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseExpression;
var ExplodeSuperExpression = function ExplodeSuperExpression() {
  $traceurRuntime.defaultSuperCall(this, $ExplodeSuperExpression.prototype, arguments);
};
var $ExplodeSuperExpression = ExplodeSuperExpression;
($traceurRuntime.createClass)(ExplodeSuperExpression, {
  transformArrowFunctionExpression: function(tree) {
    return tree;
  },
  transformClassExpression: function(tree) {
    return tree;
  },
  transformFunctionBody: function(tree) {
    return tree;
  }
}, {}, ExplodeExpressionTransformer);
var SuperTransformer = function SuperTransformer(tempVarTransformer, protoName, methodTree, thisName) {
  this.tempVarTransformer_ = tempVarTransformer;
  this.protoName_ = protoName;
  this.method_ = methodTree;
  this.superCount_ = 0;
  this.thisVar_ = createIdentifierExpression(thisName);
  this.inNestedFunc_ = 0;
  this.nestedSuperCount_ = 0;
};
var $SuperTransformer = SuperTransformer;
($traceurRuntime.createClass)(SuperTransformer, {
  get hasSuper() {
    return this.superCount_ > 0;
  },
  get nestedSuper() {
    return this.nestedSuperCount_ > 0;
  },
  transformFunctionDeclaration: function(tree) {
    return this.transformFunction_(tree, FunctionDeclaration);
  },
  transformFunctionExpression: function(tree) {
    return this.transformFunction_(tree, FunctionExpression);
  },
  transformFunction_: function(tree, constructor) {
    var oldSuperCount = this.superCount_;
    this.inNestedFunc_++;
    var transformedTree = constructor === FunctionExpression ? $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformFunctionExpression", [tree]) : $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformFunctionDeclaration", [tree]);
    this.inNestedFunc_--;
    if (oldSuperCount !== this.superCount_)
      this.nestedSuperCount_ += this.superCount_ - oldSuperCount;
    return transformedTree;
  },
  transformGetAccessor: function(tree) {
    return tree;
  },
  transformSetAccessor: function(tree) {
    return tree;
  },
  transformPropertyMethodAssignMent: function(tree) {
    return tree;
  },
  transformCallExpression: function(tree) {
    if (this.method_ && tree.operand.type == SUPER_EXPRESSION) {
      this.superCount_++;
      assert(this.method_.name.type === LITERAL_PROPERTY_NAME);
      var methodName = this.method_.name.literalToken.value;
      return this.createSuperCallExpression_(methodName, tree);
    }
    if (hasSuperMemberExpression(tree.operand)) {
      this.superCount_++;
      var name;
      if (tree.operand.type == MEMBER_EXPRESSION)
        name = tree.operand.memberName.value;
      else
        name = tree.operand.memberExpression;
      return this.createSuperCallExpression_(name, tree);
    }
    return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformCallExpression", [tree]);
  },
  createSuperCallExpression_: function(methodName, tree) {
    var thisExpr = this.inNestedFunc_ ? this.thisVar_ : createThisExpression();
    var args = createArrayLiteralExpression(tree.args.args);
    return this.createSuperCallExpression(thisExpr, this.protoName_, methodName, args);
  },
  createSuperCallExpression: function(thisExpr, protoName, methodName, args) {
    return parseExpression($__175, thisExpr, protoName, methodName, args);
  },
  transformMemberShared_: function(tree, name) {
    var thisExpr = this.inNestedFunc_ ? this.thisVar_ : createThisExpression();
    return parseExpression($__176, thisExpr, this.protoName_, name);
  },
  transformMemberExpression: function(tree) {
    if (tree.operand.type === SUPER_EXPRESSION) {
      this.superCount_++;
      return this.transformMemberShared_(tree, createStringLiteral(tree.memberName.value));
    }
    return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformMemberExpression", [tree]);
  },
  transformMemberLookupExpression: function(tree) {
    if (tree.operand.type === SUPER_EXPRESSION)
      return this.transformMemberShared_(tree, tree.memberExpression);
    return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformMemberLookupExpression", [tree]);
  },
  transformBinaryOperator: function(tree) {
    if (tree.operator.isAssignmentOperator() && hasSuperMemberExpression(tree.left)) {
      if (tree.operator.type !== EQUAL) {
        var exploded = new ExplodeSuperExpression(this.tempVarTransformer_).transformAny(tree);
        return this.transformAny(createParenExpression(exploded));
      }
      this.superCount_++;
      var name = tree.left.type === MEMBER_LOOKUP_EXPRESSION ? tree.left.memberExpression : createStringLiteral(tree.left.memberName.value);
      var thisExpr = this.inNestedFunc_ ? this.thisVar_ : createThisExpression();
      var right = this.transformAny(tree.right);
      return parseExpression($__177, thisExpr, this.protoName_, name, right);
    }
    return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformBinaryOperator", [tree]);
  },
  transformUnaryExpression: function(tree) {
    var transformed = this.transformIncrementDecrement_(tree);
    if (transformed)
      return transformed;
    return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformUnaryExpression", [tree]);
  },
  transformPostfixExpression: function(tree) {
    var transformed = this.transformIncrementDecrement_(tree);
    if (transformed)
      return transformed;
    return $traceurRuntime.superCall(this, $SuperTransformer.prototype, "transformPostfixExpression", [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 ExplodeSuperExpression(this.tempVarTransformer_).transformAny(tree);
      if (exploded !== tree)
        exploded = createParenExpression(exploded);
      return this.transformAny(exploded);
    }
    return null;
  }
}, {}, ParseTreeTransformer);
function hasSuperMemberExpression(tree) {
  if (tree.type !== MEMBER_EXPRESSION && tree.type !== MEMBER_LOOKUP_EXPRESSION)
    return false;
  return tree.operand.type === SUPER_EXPRESSION;
}
return {get SuperTransformer() {
    return SuperTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ClassTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ClassTransformer";
var $__180 = Object.freeze(Object.defineProperties(["($traceurRuntime.createClass)(", ", ", ", ", ",\n                                       ", ")"], {raw: {value: Object.freeze(["($traceurRuntime.createClass)(", ", ", ", ", ",\n                                       ", ")"])}})),
    $__181 = Object.freeze(Object.defineProperties(["($traceurRuntime.createClass)(", ", ", ", ", ")"], {raw: {value: Object.freeze(["($traceurRuntime.createClass)(", ", ", ", ", ")"])}})),
    $__182 = Object.freeze(Object.defineProperties(["var ", " = ", ""], {raw: {value: Object.freeze(["var ", " = ", ""])}})),
    $__183 = Object.freeze(Object.defineProperties(["var ", " = ", ""], {raw: {value: Object.freeze(["var ", " = ", ""])}})),
    $__184 = Object.freeze(Object.defineProperties(["function($__super) {\n        var ", " = ", ";\n        return ($traceurRuntime.createClass)(", ", ", ",\n                                             ", ", $__super);\n      }(", ")"], {raw: {value: Object.freeze(["function($__super) {\n        var ", " = ", ";\n        return ($traceurRuntime.createClass)(", ", ", ",\n                                             ", ", $__super);\n      }(", ")"])}})),
    $__185 = Object.freeze(Object.defineProperties(["function() {\n        var ", " = ", ";\n        return ($traceurRuntime.createClass)(", ", ", ",\n                                             ", ");\n      }()"], {raw: {value: Object.freeze(["function() {\n        var ", " = ", ";\n        return ($traceurRuntime.createClass)(", ", ", ",\n                                             ", ");\n      }()"])}})),
    $__186 = Object.freeze(Object.defineProperties(["$traceurRuntime.defaultSuperCall(this,\n                ", ".prototype, arguments)"], {raw: {value: Object.freeze(["$traceurRuntime.defaultSuperCall(this,\n                ", ".prototype, arguments)"])}}));
var AlphaRenamer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AlphaRenamer")).AlphaRenamer;
var CONSTRUCTOR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).CONSTRUCTOR;
var $__189 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    AnonBlock = $__189.AnonBlock,
    ExportDeclaration = $__189.ExportDeclaration,
    FunctionExpression = $__189.FunctionExpression,
    GetAccessor = $__189.GetAccessor,
    PropertyMethodAssignment = $__189.PropertyMethodAssignment,
    SetAccessor = $__189.SetAccessor;
var $__189 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    GET_ACCESSOR = $__189.GET_ACCESSOR,
    PROPERTY_METHOD_ASSIGNMENT = $__189.PROPERTY_METHOD_ASSIGNMENT,
    SET_ACCESSOR = $__189.SET_ACCESSOR;
var SuperTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/SuperTransformer")).SuperTransformer;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var VAR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).VAR;
var MakeStrictTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/MakeStrictTransformer")).MakeStrictTransformer;
var $__189 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createEmptyParameterList = $__189.createEmptyParameterList,
    createExpressionStatement = $__189.createExpressionStatement,
    createFunctionBody = $__189.createFunctionBody,
    id = $__189.createIdentifierExpression,
    createMemberExpression = $__189.createMemberExpression,
    createObjectLiteralExpression = $__189.createObjectLiteralExpression,
    createParenExpression = $__189.createParenExpression,
    createThisExpression = $__189.createThisExpression,
    createVariableStatement = $__189.createVariableStatement;
var hasUseStrict = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/semantics/util")).hasUseStrict;
var parseOptions = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).parseOptions;
var $__189 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__189.parseExpression,
    parseStatement = $__189.parseStatement,
    parseStatements = $__189.parseStatements;
var propName = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/staticsemantics/PropName")).propName;
function classCall(func, object, staticObject, superClass) {
  if (superClass) {
    return parseExpression($__180, func, object, staticObject, superClass);
  }
  return parseExpression($__181, func, object, staticObject);
}
var ClassTransformer = function ClassTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $ClassTransformer.prototype, "constructor", [identifierGenerator]);
  this.strictCount_ = 0;
  this.state_ = null;
};
var $ClassTransformer = ClassTransformer;
($traceurRuntime.createClass)(ClassTransformer, {
  transformExportDeclaration: function(tree) {
    var transformed = $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformExportDeclaration", [tree]);
    if (transformed === tree)
      return tree;
    var declaration = transformed.declaration;
    if (declaration instanceof AnonBlock) {
      var statements = $traceurRuntime.spread([new ExportDeclaration(null, declaration.statements[0], [])], declaration.statements.slice(1));
      return new AnonBlock(null, statements);
    }
    return transformed;
  },
  transformModule: function(tree) {
    this.strictCount_ = 1;
    return $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformModule", [tree]);
  },
  transformScript: function(tree) {
    this.strictCount_ = +hasUseStrict(tree.scriptItemList);
    return $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformScript", [tree]);
  },
  transformFunctionBody: function(tree) {
    var useStrict = +hasUseStrict(tree.statements);
    this.strictCount_ += useStrict;
    var result = $traceurRuntime.superCall(this, $ClassTransformer.prototype, "transformFunctionBody", [tree]);
    this.strictCount_ -= useStrict;
    return result;
  },
  makeStrict_: function(tree) {
    if (this.strictCount_)
      return tree;
    return MakeStrictTransformer.transformTree(tree);
  },
  transformClassElements_: function(tree, internalName) {
    var $__187 = this;
    var oldState = this.state_;
    this.state_ = {hasSuper: false};
    var superClass = this.transformAny(tree.superClass);
    var hasConstructor = false;
    var protoElements = [],
        staticElements = [];
    var constructorBody,
        constructorParams;
    tree.elements.forEach((function(tree) {
      var elements,
          homeObject;
      if (tree.isStatic) {
        elements = staticElements;
        homeObject = internalName;
      } else {
        elements = protoElements;
        homeObject = createMemberExpression(internalName, 'prototype');
      }
      switch (tree.type) {
        case GET_ACCESSOR:
          elements.push($__187.transformGetAccessor_(tree, homeObject));
          break;
        case SET_ACCESSOR:
          elements.push($__187.transformSetAccessor_(tree, homeObject));
          break;
        case PROPERTY_METHOD_ASSIGNMENT:
          var transformed = $__187.transformPropertyMethodAssignment_(tree, homeObject);
          if (!tree.isStatic && propName(tree) === CONSTRUCTOR) {
            hasConstructor = true;
            constructorParams = transformed.parameterList;
            constructorBody = transformed.functionBody;
          } else {
            elements.push(transformed);
          }
          break;
        default:
          throw new Error(("Unexpected class element: " + tree.type));
      }
    }));
    var object = createObjectLiteralExpression(protoElements);
    var staticObject = createObjectLiteralExpression(staticElements);
    var func;
    if (!hasConstructor) {
      func = this.getDefaultConstructor_(tree, internalName);
    } else {
      func = new FunctionExpression(tree.location, tree.name, false, constructorParams, null, [], constructorBody);
    }
    var state = this.state_;
    this.state_ = oldState;
    return {
      func: func,
      superClass: superClass,
      object: object,
      staticObject: staticObject,
      hasSuper: state.hasSuper
    };
  },
  transformClassDeclaration: function(tree) {
    var name = tree.name.identifierToken;
    var internalName = id(("$" + name));
    var renamed = AlphaRenamer.rename(tree, name.value, internalName.identifierToken.value);
    var referencesClassName = renamed !== tree;
    var tree = renamed;
    var $__189 = $traceurRuntime.assertObject(this.transformClassElements_(tree, internalName)),
        func = $__189.func,
        hasSuper = $__189.hasSuper,
        object = $__189.object,
        staticObject = $__189.staticObject,
        superClass = $__189.superClass;
    var statements = parseStatements($__182, name, func);
    var expr = classCall(name, object, staticObject, superClass);
    if (hasSuper || referencesClassName) {
      statements.push(parseStatement($__183, internalName, name));
    }
    statements.push(createExpressionStatement(expr));
    var anonBlock = new AnonBlock(null, statements);
    return this.makeStrict_(anonBlock);
  },
  transformClassExpression: function(tree) {
    this.pushTempVarState();
    var name;
    if (tree.name)
      name = tree.name.identifierToken;
    else
      name = id(this.getTempIdentifier());
    var $__189 = $traceurRuntime.assertObject(this.transformClassElements_(tree, name)),
        func = $__189.func,
        hasSuper = $__189.hasSuper,
        object = $__189.object,
        staticObject = $__189.staticObject,
        superClass = $__189.superClass;
    var expression;
    if (hasSuper) {
      expression = parseExpression($__184, name, func, name, object, staticObject, superClass);
    } else if (tree.name) {
      expression = parseExpression($__185, name, func, name, object, staticObject);
    } else {
      expression = classCall(func, object, staticObject, superClass);
    }
    this.popTempVarState();
    return createParenExpression(this.makeStrict_(expression));
  },
  transformPropertyMethodAssignment_: function(tree, internalName) {
    var parameterList = this.transformAny(tree.parameterList);
    var functionBody = this.transformSuperInFunctionBody_(tree, tree.functionBody, internalName);
    if (!tree.isStatic && parameterList === tree.parameterList && functionBody === tree.functionBody) {
      return tree;
    }
    var isStatic = false;
    return new PropertyMethodAssignment(tree.location, isStatic, tree.functionKind, tree.name, parameterList, tree.typeAnnotation, tree.annotations, functionBody);
  },
  transformGetAccessor_: function(tree, internalName) {
    var body = this.transformSuperInFunctionBody_(tree, tree.body, internalName);
    if (!tree.isStatic && body === tree.body)
      return tree;
    return new GetAccessor(tree.location, false, tree.name, tree.typeAnnotation, tree.annotations, body);
  },
  transformSetAccessor_: function(tree, internalName) {
    var parameterList = this.transformAny(tree.parameterList);
    var body = this.transformSuperInFunctionBody_(tree, tree.body, internalName);
    if (!tree.isStatic && body === tree.body)
      return tree;
    return new SetAccessor(tree.location, false, tree.name, parameterList, tree.annotations, body);
  },
  transformSuperInFunctionBody_: function(methodTree, tree, internalName) {
    this.pushTempVarState();
    var thisName = this.getTempIdentifier();
    var thisDecl = createVariableStatement(VAR, thisName, createThisExpression());
    var superTransformer = new SuperTransformer(this, internalName, methodTree, thisName);
    var transformedTree = superTransformer.transformFunctionBody(this.transformFunctionBody(tree));
    if (superTransformer.hasSuper)
      this.state_.hasSuper = true;
    this.popTempVarState();
    if (superTransformer.nestedSuper)
      return createFunctionBody([thisDecl].concat(transformedTree.statements));
    return transformedTree;
  },
  getDefaultConstructor_: function(tree, internalName) {
    var constructorParams = createEmptyParameterList();
    var constructorBody;
    if (tree.superClass) {
      var statement = parseStatement($__186, internalName);
      constructorBody = createFunctionBody([statement]);
      this.state_.hasSuper = true;
    } else {
      constructorBody = createFunctionBody([]);
    }
    return new FunctionExpression(tree.location, tree.name, false, constructorParams, null, [], constructorBody);
  }
}, {}, TempVarTransformer);
return {get ClassTransformer() {
    return ClassTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/CommonJsModuleTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/CommonJsModuleTransformer";
var $__190 = Object.freeze(Object.defineProperties(["module.exports = function() {\n            ", "\n          }.call(", ");"], {raw: {value: Object.freeze(["module.exports = function() {\n            ", "\n          }.call(", ");"])}})),
    $__191 = Object.freeze(Object.defineProperties(["Object.defineProperties(exports, ", ");"], {raw: {value: Object.freeze(["Object.defineProperties(exports, ", ");"])}})),
    $__192 = Object.freeze(Object.defineProperties(["{get: ", "}"], {raw: {value: Object.freeze(["{get: ", "}"])}})),
    $__193 = Object.freeze(Object.defineProperties(["{value: ", "}"], {raw: {value: Object.freeze(["{value: ", "}"])}})),
    $__194 = Object.freeze(Object.defineProperties(["require(", ")"], {raw: {value: Object.freeze(["require(", ")"])}})),
    $__195 = Object.freeze(Object.defineProperties(["__esModule: true"], {raw: {value: Object.freeze(["__esModule: true"])}}));
var ModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ModuleTransformer")).ModuleTransformer;
var $__197 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    GET_ACCESSOR = $__197.GET_ACCESSOR,
    OBJECT_LITERAL_EXPRESSION = $__197.OBJECT_LITERAL_EXPRESSION,
    PROPERTY_NAME_ASSIGNMENT = $__197.PROPERTY_NAME_ASSIGNMENT,
    RETURN_STATEMENT = $__197.RETURN_STATEMENT;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var globalThis = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/globalThis")).default;
var $__197 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__197.parseExpression,
    parsePropertyDefinition = $__197.parsePropertyDefinition,
    parseStatement = $__197.parseStatement,
    parseStatements = $__197.parseStatements;
var scopeContainsThis = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/scopeContainsThis")).default;
var $__197 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createEmptyParameterList = $__197.createEmptyParameterList,
    createFunctionExpression = $__197.createFunctionExpression,
    createObjectLiteralExpression = $__197.createObjectLiteralExpression,
    createPropertyNameAssignment = $__197.createPropertyNameAssignment;
var prependStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PrependStatements")).prependStatements;
var CommonJsModuleTransformer = function CommonJsModuleTransformer() {
  $traceurRuntime.defaultSuperCall(this, $CommonJsModuleTransformer.prototype, arguments);
};
var $CommonJsModuleTransformer = CommonJsModuleTransformer;
($traceurRuntime.createClass)(CommonJsModuleTransformer, {
  wrapModule: function(statements) {
    var needsIife = statements.some(scopeContainsThis);
    if (needsIife) {
      return parseStatements($__190, statements, globalThis());
    }
    var last = statements[statements.length - 1];
    statements = statements.slice(0, -1);
    assert(last.type === RETURN_STATEMENT);
    var exportObject = last.expression;
    if (this.hasExports()) {
      var descriptors = this.transformObjectLiteralToDescriptors(exportObject);
      var exportStatement = parseStatement($__191, descriptors);
      statements = prependStatements(statements, exportStatement);
    }
    return statements;
  },
  transformObjectLiteralToDescriptors: function(literalTree) {
    assert(literalTree.type === OBJECT_LITERAL_EXPRESSION);
    var props = literalTree.propertyNameAndValues.map((function(exp) {
      var descriptor;
      switch (exp.type) {
        case GET_ACCESSOR:
          var getterFunction = createFunctionExpression(createEmptyParameterList(), exp.body);
          descriptor = parseExpression($__192, getterFunction);
          break;
        case PROPERTY_NAME_ASSIGNMENT:
          descriptor = parseExpression($__193, exp.value);
          break;
        default:
          throw new Error(("Unexpected property type " + exp.type));
      }
      return createPropertyNameAssignment(exp.name, descriptor);
    }));
    return createObjectLiteralExpression(props);
  },
  transformModuleSpecifier: function(tree) {
    return parseExpression($__194, tree.token);
  },
  getExportProperties: function() {
    var properties = $traceurRuntime.superCall(this, $CommonJsModuleTransformer.prototype, "getExportProperties", []);
    if (this.exportVisitor_.hasExports())
      properties.push(parsePropertyDefinition($__195));
    return properties;
  }
}, {}, ModuleTransformer);
return {get CommonJsModuleTransformer() {
    return CommonJsModuleTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ParameterTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ParameterTransformer";
var FunctionBody = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")).FunctionBody;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var prependStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PrependStatements")).prependStatements;
var stack = [];
var ParameterTransformer = function ParameterTransformer() {
  $traceurRuntime.defaultSuperCall(this, $ParameterTransformer.prototype, arguments);
};
var $ParameterTransformer = ParameterTransformer;
($traceurRuntime.createClass)(ParameterTransformer, {
  transformArrowFunctionExpression: function(tree) {
    stack.push([]);
    return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformArrowFunctionExpression", [tree]);
  },
  transformFunctionDeclaration: function(tree) {
    stack.push([]);
    return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformFunctionDeclaration", [tree]);
  },
  transformFunctionExpression: function(tree) {
    stack.push([]);
    return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformFunctionExpression", [tree]);
  },
  transformGetAccessor: function(tree) {
    stack.push([]);
    return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformGetAccessor", [tree]);
  },
  transformSetAccessor: function(tree) {
    stack.push([]);
    return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformSetAccessor", [tree]);
  },
  transformPropertyMethodAssignment: function(tree) {
    stack.push([]);
    return $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformPropertyMethodAssignment", [tree]);
  },
  transformFunctionBody: function(tree) {
    var transformedTree = $traceurRuntime.superCall(this, $ParameterTransformer.prototype, "transformFunctionBody", [tree]);
    var statements = stack.pop();
    if (!statements.length)
      return transformedTree;
    statements = prependStatements.apply(null, $traceurRuntime.spread([transformedTree.statements], statements));
    return new FunctionBody(transformedTree.location, statements);
  },
  get parameterStatements() {
    return stack[stack.length - 1];
  }
}, {}, TempVarTransformer);
return {get ParameterTransformer() {
    return ParameterTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/DefaultParametersTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/DefaultParametersTransformer";
var $__201 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/semantics/util")),
    isUndefined = $__201.isUndefined,
    isVoidExpression = $__201.isVoidExpression;
var FormalParameterList = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")).FormalParameterList;
var ParameterTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParameterTransformer")).ParameterTransformer;
var ARGUMENTS = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).ARGUMENTS;
var $__201 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    FORMAL_PARAMETER = $__201.FORMAL_PARAMETER,
    REST_PARAMETER = $__201.REST_PARAMETER;
var $__201 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    NOT_EQUAL_EQUAL = $__201.NOT_EQUAL_EQUAL,
    VAR = $__201.VAR;
var $__201 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createBinaryOperator = $__201.createBinaryOperator,
    createConditionalExpression = $__201.createConditionalExpression,
    createIdentifierExpression = $__201.createIdentifierExpression,
    createMemberLookupExpression = $__201.createMemberLookupExpression,
    createNumberLiteral = $__201.createNumberLiteral,
    createOperatorToken = $__201.createOperatorToken,
    createVariableStatement = $__201.createVariableStatement,
    createVoid0 = $__201.createVoid0;
var prependStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PrependStatements")).prependStatements;
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(createBinaryOperator(argumentsExpression, createOperatorToken(NOT_EQUAL_EQUAL), createVoid0()), argumentsExpression, initializer);
  }
  return createVariableStatement(VAR, binding, assignmentExpression);
}
var DefaultParametersTransformer = function DefaultParametersTransformer() {
  $traceurRuntime.defaultSuperCall(this, $DefaultParametersTransformer.prototype, arguments);
};
var $DefaultParametersTransformer = DefaultParametersTransformer;
($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);
  }}, {}, ParameterTransformer);
return {get DefaultParametersTransformer() {
    return DefaultParametersTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/DestructuringTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/DestructuringTransformer";
var $__202 = Object.freeze(Object.defineProperties(["$traceurRuntime.assertObject(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.assertObject(", ")"])}})),
    $__203 = Object.freeze(Object.defineProperties(["", " = ", ""], {raw: {value: Object.freeze(["", " = ", ""])}})),
    $__204 = Object.freeze(Object.defineProperties(["Array.prototype.slice.call(", ", ", ")"], {raw: {value: Object.freeze(["Array.prototype.slice.call(", ", ", ")"])}})),
    $__205 = Object.freeze(Object.defineProperties(["(", " = ", ".", ") === void 0 ?\n        ", " : ", ""], {raw: {value: Object.freeze(["(", " = ", ".", ") === void 0 ?\n        ", " : ", ""])}})),
    $__206 = Object.freeze(Object.defineProperties(["(", " = ", "[", "]) === void 0 ?\n        ", " : ", ""], {raw: {value: Object.freeze(["(", " = ", "[", "]) === void 0 ?\n        ", " : ", ""])}}));
var $__209 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    ARRAY_COMPREHENSION = $__209.ARRAY_COMPREHENSION,
    ARRAY_LITERAL_EXPRESSION = $__209.ARRAY_LITERAL_EXPRESSION,
    ARRAY_PATTERN = $__209.ARRAY_PATTERN,
    ARROW_FUNCTION_EXPRESSION = $__209.ARROW_FUNCTION_EXPRESSION,
    BINDING_ELEMENT = $__209.BINDING_ELEMENT,
    BINDING_IDENTIFIER = $__209.BINDING_IDENTIFIER,
    BLOCK = $__209.BLOCK,
    CALL_EXPRESSION = $__209.CALL_EXPRESSION,
    CLASS_EXPRESSION = $__209.CLASS_EXPRESSION,
    COMPUTED_PROPERTY_NAME = $__209.COMPUTED_PROPERTY_NAME,
    FUNCTION_EXPRESSION = $__209.FUNCTION_EXPRESSION,
    GENERATOR_COMPREHENSION = $__209.GENERATOR_COMPREHENSION,
    IDENTIFIER_EXPRESSION = $__209.IDENTIFIER_EXPRESSION,
    LITERAL_EXPRESSION = $__209.LITERAL_EXPRESSION,
    MEMBER_EXPRESSION = $__209.MEMBER_EXPRESSION,
    MEMBER_LOOKUP_EXPRESSION = $__209.MEMBER_LOOKUP_EXPRESSION,
    OBJECT_LITERAL_EXPRESSION = $__209.OBJECT_LITERAL_EXPRESSION,
    OBJECT_PATTERN = $__209.OBJECT_PATTERN,
    OBJECT_PATTERN_FIELD = $__209.OBJECT_PATTERN_FIELD,
    PAREN_EXPRESSION = $__209.PAREN_EXPRESSION,
    THIS_EXPRESSION = $__209.THIS_EXPRESSION,
    VARIABLE_DECLARATION_LIST = $__209.VARIABLE_DECLARATION_LIST;
var $__209 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    BindingElement = $__209.BindingElement,
    Catch = $__209.Catch,
    ForInStatement = $__209.ForInStatement,
    ForOfStatement = $__209.ForOfStatement,
    LiteralExpression = $__209.LiteralExpression;
var ParameterTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParameterTransformer")).ParameterTransformer;
var $__209 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    EQUAL = $__209.EQUAL,
    IDENTIFIER = $__209.IDENTIFIER,
    LET = $__209.LET,
    REGULAR_EXPRESSION = $__209.REGULAR_EXPRESSION,
    VAR = $__209.VAR;
var $__209 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentExpression = $__209.createAssignmentExpression,
    createBindingIdentifier = $__209.createBindingIdentifier,
    createBlock = $__209.createBlock,
    createCommaExpression = $__209.createCommaExpression,
    createExpressionStatement = $__209.createExpressionStatement,
    createIdentifierExpression = $__209.createIdentifierExpression,
    createMemberExpression = $__209.createMemberExpression,
    createMemberLookupExpression = $__209.createMemberLookupExpression,
    createNumberLiteral = $__209.createNumberLiteral,
    createParenExpression = $__209.createParenExpression,
    createVariableDeclaration = $__209.createVariableDeclaration,
    createVariableDeclarationList = $__209.createVariableDeclarationList,
    createVariableStatement = $__209.createVariableStatement;
var options = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).options;
var parseExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseExpression;
var Desugaring = function Desugaring(rvalue) {
  this.rvalue = rvalue;
};
($traceurRuntime.createClass)(Desugaring, {}, {});
var AssignmentExpressionDesugaring = function AssignmentExpressionDesugaring(rvalue) {
  $traceurRuntime.superCall(this, $AssignmentExpressionDesugaring.prototype, "constructor", [rvalue]);
  this.expressions = [];
};
var $AssignmentExpressionDesugaring = AssignmentExpressionDesugaring;
($traceurRuntime.createClass)(AssignmentExpressionDesugaring, {assign: function(lvalue, rvalue) {
    lvalue = lvalue instanceof BindingElement ? lvalue.binding : lvalue;
    this.expressions.push(createAssignmentExpression(lvalue, rvalue));
  }}, {}, Desugaring);
var VariableDeclarationDesugaring = function VariableDeclarationDesugaring(rvalue) {
  $traceurRuntime.superCall(this, $VariableDeclarationDesugaring.prototype, "constructor", [rvalue]);
  this.declarations = [];
};
var $VariableDeclarationDesugaring = VariableDeclarationDesugaring;
($traceurRuntime.createClass)(VariableDeclarationDesugaring, {assign: function(lvalue, rvalue) {
    if (lvalue instanceof BindingElement) {
      this.declarations.push(createVariableDeclaration(lvalue.binding, rvalue));
      return;
    }
    if (lvalue.type == IDENTIFIER_EXPRESSION)
      lvalue = createBindingIdentifier(lvalue);
    this.declarations.push(createVariableDeclaration(lvalue, rvalue));
  }}, {}, Desugaring);
function staticallyKnownObject(tree) {
  switch (tree.type) {
    case OBJECT_LITERAL_EXPRESSION:
    case ARRAY_LITERAL_EXPRESSION:
    case ARRAY_COMPREHENSION:
    case GENERATOR_COMPREHENSION:
    case ARROW_FUNCTION_EXPRESSION:
    case FUNCTION_EXPRESSION:
    case CLASS_EXPRESSION:
    case THIS_EXPRESSION:
      return true;
    case LITERAL_EXPRESSION:
      return tree.literalToken.type === REGULAR_EXPRESSION;
  }
  return false;
}
function createGuardedExpression(tree) {
  if (staticallyKnownObject(tree))
    return tree;
  return parseExpression($__202, tree);
}
function createGuardedAssignment(lvalue, rvalue) {
  return parseExpression($__203, lvalue, createGuardedExpression(rvalue));
}
var DestructuringTransformer = function DestructuringTransformer() {
  $traceurRuntime.defaultSuperCall(this, $DestructuringTransformer.prototype, arguments);
};
var $DestructuringTransformer = DestructuringTransformer;
($traceurRuntime.createClass)(DestructuringTransformer, {
  transformArrayPattern: function(tree) {
    throw new Error('unreachable');
  },
  transformObjectPattern: function(tree) {
    throw new Error('unreachable');
  },
  transformBinaryOperator: function(tree) {
    this.pushTempVarState();
    var rv;
    if (tree.operator.type == EQUAL && tree.left.isPattern()) {
      rv = this.transformAny(this.desugarAssignment_(tree.left, tree.right));
    } else {
      rv = $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformBinaryOperator", [tree]);
    }
    this.popTempVarState();
    return rv;
  },
  desugarAssignment_: function(lvalue, rvalue) {
    var tempIdent = createIdentifierExpression(this.addTempVar());
    var desugaring = new AssignmentExpressionDesugaring(tempIdent);
    this.desugarPattern_(desugaring, lvalue);
    desugaring.expressions.unshift(createGuardedAssignment(tempIdent, rvalue));
    desugaring.expressions.push(tempIdent);
    return createParenExpression(createCommaExpression(desugaring.expressions));
  },
  transformVariableDeclarationList: function(tree) {
    var $__207 = this;
    if (!this.destructuringInDeclaration_(tree)) {
      return $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformVariableDeclarationList", [tree]);
    }
    this.pushTempVarState();
    var desugaredDeclarations = [];
    tree.declarations.forEach((function(declaration) {
      var $__210;
      if (declaration.lvalue.isPattern()) {
        ($__210 = desugaredDeclarations).push.apply($__210, $traceurRuntime.toObject($__207.desugarVariableDeclaration_(declaration)));
      } else {
        desugaredDeclarations.push(declaration);
      }
    }));
    var transformedTree = this.transformVariableDeclarationList(createVariableDeclarationList(tree.declarationType, desugaredDeclarations));
    this.popTempVarState();
    return transformedTree;
  },
  transformForInStatement: function(tree) {
    return this.transformForInOrOf_(tree, $traceurRuntime.superGet(this, $DestructuringTransformer.prototype, "transformForInStatement"), ForInStatement);
  },
  transformForOfStatement: function(tree) {
    return this.transformForInOrOf_(tree, $traceurRuntime.superGet(this, $DestructuringTransformer.prototype, "transformForOfStatement"), ForOfStatement);
  },
  transformForInOrOf_: function(tree, superMethod, constr) {
    var $__210;
    if (!tree.initializer.isPattern() && (tree.initializer.type !== VARIABLE_DECLARATION_LIST || !this.destructuringInDeclaration_(tree.initializer))) {
      return superMethod.call(this, tree);
    }
    this.pushTempVarState();
    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)
      body = createBlock(body);
    ($__210 = statements).push.apply($__210, $traceurRuntime.toObject(body.statements));
    body = createBlock(statements);
    this.popTempVarState();
    return new constr(tree.location, initializer, collection, body);
  },
  transformBindingElement: function(tree) {
    if (!tree.binding.isPattern() || tree.initializer)
      return tree;
    var statements = this.parameterStatements;
    var binding = this.desugarBinding_(tree.binding, statements, VAR);
    return new BindingElement(null, binding, null);
  },
  transformCatch: function(tree) {
    var $__210;
    if (!tree.binding.isPattern())
      return $traceurRuntime.superCall(this, $DestructuringTransformer.prototype, "transformCatch", [tree]);
    var body = this.transformAny(tree.catchBody);
    var statements = [];
    var kind = options.blockBinding ? LET : VAR;
    var binding = this.desugarBinding_(tree.binding, statements, kind);
    ($__210 = statements).push.apply($__210, $traceurRuntime.toObject(body.statements));
    return new Catch(tree.location, binding, createBlock(statements));
  },
  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;
  },
  destructuringInDeclaration_: function(tree) {
    return tree.declarations.some((function(declaration) {
      return declaration.lvalue.isPattern();
    }));
  },
  desugarVariableDeclaration_: function(tree) {
    var tempRValueName = this.getTempIdentifier();
    var tempRValueIdent = createIdentifierExpression(tempRValueName);
    var desugaring;
    var initializer;
    switch (tree.initializer.type) {
      case ARRAY_LITERAL_EXPRESSION:
      case CALL_EXPRESSION:
      case IDENTIFIER_EXPRESSION:
      case LITERAL_EXPRESSION:
      case MEMBER_EXPRESSION:
      case MEMBER_LOOKUP_EXPRESSION:
      case OBJECT_LITERAL_EXPRESSION:
      case PAREN_EXPRESSION:
        initializer = tree.initializer;
      default:
        desugaring = new VariableDeclarationDesugaring(tempRValueIdent);
        desugaring.assign(desugaring.rvalue, createGuardedExpression(tree.initializer));
        var initializerFound = this.desugarPattern_(desugaring, tree.lvalue);
        if (initializerFound || desugaring.declarations.length > 2)
          return desugaring.declarations;
        initializer = createGuardedExpression(initializer || tree.initializer);
        desugaring = new VariableDeclarationDesugaring(initializer);
        this.desugarPattern_(desugaring, tree.lvalue);
        return desugaring.declarations;
    }
  },
  desugarPattern_: function(desugaring, tree) {
    var $__207 = this;
    var initializerFound = false;
    switch (tree.type) {
      case ARRAY_PATTERN:
        {
          var pattern = tree;
          for (var i = 0; i < pattern.elements.length; i++) {
            var lvalue = pattern.elements[i];
            if (lvalue === null) {
              continue;
            } else if (lvalue.isSpreadPatternElement()) {
              desugaring.assign(lvalue.lvalue, parseExpression($__204, desugaring.rvalue, i));
            } else {
              if (lvalue.initializer)
                initializerFound = true;
              desugaring.assign(lvalue, this.createConditionalMemberLookupExpression(desugaring.rvalue, createNumberLiteral(i), lvalue.initializer));
            }
          }
          break;
        }
      case OBJECT_PATTERN:
        {
          var pattern = tree;
          pattern.fields.forEach((function(field) {
            var lookup;
            switch (field.type) {
              case BINDING_ELEMENT:
                if (field.initializer)
                  initializerFound = true;
                lookup = $__207.createConditionalMemberExpression(desugaring.rvalue, field.binding, field.initializer);
                desugaring.assign(createIdentifierExpression(field.binding), lookup);
                break;
              case OBJECT_PATTERN_FIELD:
                if (field.element.initializer)
                  initializerFound = true;
                var name = field.name;
                lookup = $__207.createConditionalMemberExpression(desugaring.rvalue, name, field.element.initializer);
                desugaring.assign(field.element, lookup);
                break;
              case IDENTIFIER_EXPRESSION:
                lookup = createMemberExpression(desugaring.rvalue, field.identifierToken);
                desugaring.assign(field, 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;
    if (name.type == BINDING_IDENTIFIER) {
      token = name.identifierToken;
    } else {
      token = name.literalToken;
    }
    if (!initializer)
      return createMemberExpression(rvalue, token);
    this.pushTempVarState();
    var tempIdent = createIdentifierExpression(this.addTempVar());
    this.popTempVarState();
    return parseExpression($__205, tempIdent, rvalue, token, initializer, tempIdent);
  },
  createConditionalMemberLookupExpression: function(rvalue, index, initializer) {
    if (!initializer)
      return createMemberLookupExpression(rvalue, index);
    var tempIdent = createIdentifierExpression(this.addTempVar());
    return parseExpression($__206, tempIdent, rvalue, index, initializer, tempIdent);
  }
}, {}, ParameterTransformer);
return {get DestructuringTransformer() {
    return DestructuringTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ForOfTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ForOfTransformer";
var $__211 = Object.freeze(Object.defineProperties(["", " = ", ".value;"], {raw: {value: Object.freeze(["", " = ", ".value;"])}})),
    $__212 = Object.freeze(Object.defineProperties(["\n        for (var ", " =\n                 ", "[Symbol.iterator](),\n                 ", ";\n             !(", " = ", ".next()).done; ) {\n          ", ";\n          ", ";\n        }"], {raw: {value: Object.freeze(["\n        for (var ", " =\n                 ", "[Symbol.iterator](),\n                 ", ";\n             !(", " = ", ".next()).done; ) {\n          ", ";\n          ", ";\n        }"])}}));
var VARIABLE_DECLARATION_LIST = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")).VARIABLE_DECLARATION_LIST;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__214 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    id = $__214.createIdentifierExpression,
    createMemberExpression = $__214.createMemberExpression,
    createVariableStatement = $__214.createVariableStatement;
var parseStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatement;
var ForOfTransformer = function ForOfTransformer() {
  $traceurRuntime.defaultSuperCall(this, $ForOfTransformer.prototype, arguments);
};
var $ForOfTransformer = ForOfTransformer;
($traceurRuntime.createClass)(ForOfTransformer, {transformForOfStatement: function(original) {
    var tree = $traceurRuntime.superCall(this, $ForOfTransformer.prototype, "transformForOfStatement", [original]);
    var iter = id(this.getTempIdentifier());
    var result = id(this.getTempIdentifier());
    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($__211, tree.initializer, result);
    }
    return parseStatement($__212, iter, tree.collection, result, result, iter, assignment, tree.body);
  }}, {}, TempVarTransformer);
return {get ForOfTransformer() {
    return ForOfTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/GeneratorComprehensionTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/GeneratorComprehensionTransformer";
var ComprehensionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ComprehensionTransformer")).ComprehensionTransformer;
var createYieldStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createYieldStatement;
var GeneratorComprehensionTransformer = function GeneratorComprehensionTransformer() {
  $traceurRuntime.defaultSuperCall(this, $GeneratorComprehensionTransformer.prototype, arguments);
};
var $GeneratorComprehensionTransformer = GeneratorComprehensionTransformer;
($traceurRuntime.createClass)(GeneratorComprehensionTransformer, {transformGeneratorComprehension: function(tree) {
    var expression = this.transformAny(tree.expression);
    var statement = createYieldStatement(expression);
    var isGenerator = true;
    return this.transformComprehension(tree, statement, isGenerator);
  }}, {}, ComprehensionTransformer);
return {get GeneratorComprehensionTransformer() {
    return GeneratorComprehensionTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/State”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/State";
var $__217 = Object.freeze(Object.defineProperties(["$ctx.finallyFallThrough = ", ""], {raw: {value: Object.freeze(["$ctx.finallyFallThrough = ", ""])}}));
var $__219 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignStateStatement = $__219.createAssignStateStatement,
    createAssignmentStatement = $__219.createAssignmentStatement,
    createBreakStatement = $__219.createBreakStatement,
    createCaseClause = $__219.createCaseClause,
    createIdentifierExpression = $__219.createIdentifierExpression,
    createNumberLiteral = $__219.createNumberLiteral,
    createStatementList = $__219.createStatementList;
var parseStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatement;
var State = function State(id) {
  this.id = id;
};
($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 createStatementList(State.generateAssignState(enclosingFinally, fallThroughState), createBreakStatement());
};
State.generateAssignState = function(enclosingFinally, fallThroughState) {
  var assignState;
  if (State.isFinallyExit(enclosingFinally, fallThroughState)) {
    assignState = generateAssignStateOutOfFinally(enclosingFinally, fallThroughState);
  } else {
    assignState = createStatementList(createAssignStateStatement(fallThroughState));
  }
  return assignState;
};
State.isFinallyExit = function(enclosingFinally, destination) {
  return enclosingFinally != null && enclosingFinally.tryStates.indexOf(destination) < 0;
};
function generateAssignStateOutOfFinally(enclosingFinally, destination) {
  var finallyState = enclosingFinally.finallyState;
  return createStatementList(createAssignStateStatement(finallyState), parseStatement($__217, 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;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/TryState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/TryState";
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var Kind = {
  CATCH: 'catch',
  FINALLY: 'finally'
};
var TryState = function TryState(kind, tryStates, nestedTrys) {
  this.kind = kind;
  this.tryStates = tryStates;
  this.nestedTrys = nestedTrys;
};
($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;
  }};

}); System.register(“traceur@0.0.43/src/syntax/trees/StateMachine”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/syntax/trees/StateMachine";
var ParseTree = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTree")).ParseTree;
var STATE_MACHINE = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")).STATE_MACHINE;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var TryState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/TryState")).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 StateMachine(startState, fallThroughState, states, exceptionBlocks) {
  this.location = null;
  this.startState = startState;
  this.fallThroughState = fallThroughState;
  this.states = states;
  this.exceptionBlocks = exceptionBlocks;
};
var $StateMachine = StateMachine;
($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 = 0; i < nextMachine.exceptionBlocks.length; i++) {
      var tryState = nextMachine.exceptionBlocks[i];
      exceptionBlocks.push(tryState.replaceState(nextMachine.startState, this.fallThroughState));
    }
    return new $StateMachine(this.startState, nextMachine.fallThroughState, states, exceptionBlocks);
  }
}, {}, ParseTree);
return {get StateMachine() {
    return StateMachine;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/AwaitState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/AwaitState";
var $__224 = Object.freeze(Object.defineProperties(["Promise.resolve(", ").then(\n              $ctx.createCallback(", "), $ctx.errback);\n          return"], {raw: {value: Object.freeze(["Promise.resolve(", ").then(\n              $ctx.createCallback(", "), $ctx.errback);\n          return"])}}));
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var parseStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatements;
var AwaitState = function AwaitState(id, callbackState, expression) {
  $traceurRuntime.superCall(this, $AwaitState.prototype, "constructor", [id]), this.callbackState = callbackState;
  this.expression = expression;
  this.statements_ = null;
};
var $AwaitState = AwaitState;
($traceurRuntime.createClass)(AwaitState, {
  get statements() {
    if (!this.statements_) {
      this.statements_ = parseStatements($__224, this.expression, this.callbackState);
    }
    return this.statements_;
  },
  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) {
    return this.statements;
  }
}, {}, State);
return {get AwaitState() {
    return AwaitState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/HoistVariablesTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/HoistVariablesTransformer";
var $__228 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    AnonBlock = $__228.AnonBlock,
    Catch = $__228.Catch,
    FunctionBody = $__228.FunctionBody,
    ForInStatement = $__228.ForInStatement,
    ForOfStatement = $__228.ForOfStatement,
    VariableDeclarationList = $__228.VariableDeclarationList,
    VariableStatement = $__228.VariableStatement;
var $__228 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BINDING_IDENTIFIER = $__228.BINDING_IDENTIFIER,
    OBJECT_PATTERN = $__228.OBJECT_PATTERN,
    VARIABLE_DECLARATION_LIST = $__228.VARIABLE_DECLARATION_LIST;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var VAR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).VAR;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var $__228 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentExpression = $__228.createAssignmentExpression,
    createCommaExpression = $__228.createCommaExpression,
    createExpressionStatement = $__228.createExpressionStatement,
    id = $__228.createIdentifierExpression,
    createParenExpression = $__228.createParenExpression,
    createVariableDeclaration = $__228.createVariableDeclaration;
var prependStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PrependStatements")).prependStatements;
var HoistVariablesTransformer = function HoistVariablesTransformer() {
  $traceurRuntime.superCall(this, $HoistVariablesTransformer.prototype, "constructor", []);
  this.hoistedVariables_ = Object.create(null);
  this.keepBindingIdentifiers_ = false;
};
var $HoistVariablesTransformer = HoistVariablesTransformer;
($traceurRuntime.createClass)(HoistVariablesTransformer, {
  transformFunctionBody: function(tree) {
    var statements = this.transformList(tree.statements);
    if (statements === tree.statements)
      return tree;
    var prepended = this.prependVariables(statements);
    return new FunctionBody(tree.location, prepended);
  },
  addVariable: function(name) {
    this.hoistedVariables_[name] = true;
  },
  hasVariables: function() {
    for (var key in this.hoistedVariables_) {
      return true;
    }
    return false;
  },
  getVariableNames: function() {
    return Object.keys(this.hoistedVariables_);
  },
  getVariableStatement: function() {
    if (!this.hasVariables())
      return null;
    var declarations = this.getVariableNames().map((function(name) {
      return createVariableDeclaration(name, null);
    }));
    return new VariableStatement(null, new VariableDeclarationList(null, VAR, declarations));
  },
  prependVariables: function(statements) {
    if (!this.hasVariables())
      return statements;
    return prependStatements(statements, this.getVariableStatement());
  },
  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.superCall(this, $HoistVariablesTransformer.prototype, "transformObjectPattern", [tree]);
    this.keepBindingIdentifiers_ = keepBindingIdentifiers;
    return transformed;
  },
  transformArrayPattern: function(tree) {
    var keepBindingIdentifiers = this.keepBindingIdentifiers_;
    this.keepBindingIdentifiers_ = true;
    var transformed = $traceurRuntime.superCall(this, $HoistVariablesTransformer.prototype, "transformArrayPattern", [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) {
      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 $traceurRuntime.superCall(this, $HoistVariablesTransformer.prototype, "transformVariableDeclarationList", [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);
  },
  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)
      return tree;
    return this.transformAny(tree.declarations[0].lvalue);
  },
  addMachineVariable: function(name) {
    this.machineVariables_[name] = true;
  },
  transformClassDeclaration: function(tree) {
    return tree;
  },
  transformClassExpression: function(tree) {
    return tree;
  },
  transformFunctionDeclaration: function(tree) {
    return tree;
  },
  transformFunctionExpression: function(tree) {
    return tree;
  },
  transformGetAccessor: function(tree) {
    return tree;
  },
  transformSetAccessor: function(tree) {
    return tree;
  },
  transformPropertyMethodAssignment: function(tree) {
    return tree;
  },
  transformArrowFunctionExpression: function(tree) {
    return tree;
  },
  transformComprehensionFor: function(tree) {
    return tree;
  }
}, {}, ParseTreeTransformer);
var $__default = HoistVariablesTransformer;
return {get default() {
    return $__default;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/FallThroughState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/FallThroughState";
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var FallThroughState = function FallThroughState(id, fallThroughState, statements) {
  $traceurRuntime.superCall(this, $FallThroughState.prototype, "constructor", [id]);
  this.fallThroughState = fallThroughState;
  this.statements = statements;
};
var $FallThroughState = FallThroughState;
($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));
  }
}, {}, State);
return {get FallThroughState() {
    return FallThroughState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/BreakState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/BreakState";
var FallThroughState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/FallThroughState")).FallThroughState;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var createStatementList = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createStatementList;
var BreakState = function BreakState(id, label) {
  $traceurRuntime.superCall(this, $BreakState.prototype, "constructor", [id]);
  this.label = label;
};
var $BreakState = BreakState;
($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 (this.label in labelSet) {
      return new FallThroughState(this.id, labelSet[this.label].fallThroughState, []);
    }
    return this;
  },
  transformBreakOrContinue: function(labelSet) {
    var breakState = arguments[1];
    var continueState = arguments[2];
    return this.transformBreak(labelSet, breakState);
  }
}, {}, State);
return {get BreakState() {
    return BreakState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/ContinueState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/ContinueState";
var FallThroughState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/FallThroughState")).FallThroughState;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var createStatementList = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createStatementList;
var ContinueState = function ContinueState(id, label) {
  $traceurRuntime.superCall(this, $ContinueState.prototype, "constructor", [id]);
  this.label = label;
};
var $ContinueState = ContinueState;
($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 (this.label in labelSet) {
      return new FallThroughState(this.id, labelSet[this.label].continueState, []);
    }
    return this;
  }
}, {}, State);
return {get ContinueState() {
    return ContinueState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/BreakContinueTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/BreakContinueTransformer";
var BreakState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/BreakState")).BreakState;
var ContinueState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/ContinueState")).ContinueState;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var StateMachine = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/StateMachine")).StateMachine;
function safeGetLabel(tree) {
  return tree.name ? tree.name.value : null;
}
var BreakContinueTransformer = function BreakContinueTransformer(stateAllocator) {
  $traceurRuntime.superCall(this, $BreakContinueTransformer.prototype, "constructor", []);
  this.transformBreaks_ = true;
  this.stateAllocator_ = stateAllocator;
};
var $BreakContinueTransformer = BreakContinueTransformer;
($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;
  },
  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.superCall(this, $BreakContinueTransformer.prototype, "transformSwitchStatement", [tree]);
    this.transformBreaks_ = oldState;
    return result;
  },
  transformWhileStatement: function(tree) {
    return tree;
  }
}, {}, ParseTreeTransformer);
return {get BreakContinueTransformer() {
    return BreakContinueTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/CatchState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/CatchState";
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var TryState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/TryState")).TryState;
var CatchState = function CatchState(identifier, catchState, fallThroughState, allStates, nestedTrys) {
  $traceurRuntime.superCall(this, $CatchState.prototype, "constructor", [TryState.Kind.CATCH, allStates, nestedTrys]);
  this.identifier = identifier;
  this.catchState = catchState;
  this.fallThroughState = fallThroughState;
};
var $CatchState = CatchState;
($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));
  }}, {}, TryState);
return {get CatchState() {
    return CatchState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/ConditionalState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/ConditionalState";
var $__239 = Object.freeze(Object.defineProperties(["$ctx.state = (", ") ? ", " : ", ";\n        break"], {raw: {value: Object.freeze(["$ctx.state = (", ") ? ", " : ", ";\n        break"])}}));
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var $__241 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createBlock = $__241.createBlock,
    createIfStatement = $__241.createIfStatement;
var parseStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatements;
var ConditionalState = function ConditionalState(id, ifState, elseState, condition) {
  $traceurRuntime.superCall(this, $ConditionalState.prototype, "constructor", [id]);
  this.ifState = ifState;
  this.elseState = elseState;
  this.condition = condition;
};
var $ConditionalState = ConditionalState;
($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($__239, this.condition, this.ifState, this.elseState);
  }
}, {}, State);
return {get ConditionalState() {
    return ConditionalState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/FinallyFallThroughState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/FinallyFallThroughState";
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var FinallyFallThroughState = function FinallyFallThroughState() {
  $traceurRuntime.defaultSuperCall(this, $FinallyFallThroughState.prototype, arguments);
};
var $FinallyFallThroughState = FinallyFallThroughState;
($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');
  }
}, {}, State);
return {get FinallyFallThroughState() {
    return FinallyFallThroughState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/FinallyState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/FinallyState";
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var TryState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/TryState")).TryState;
var FinallyState = function FinallyState(finallyState, fallThroughState, allStates, nestedTrys) {
  $traceurRuntime.superCall(this, $FinallyState.prototype, "constructor", [TryState.Kind.FINALLY, allStates, nestedTrys]);
  this.finallyState = finallyState;
  this.fallThroughState = fallThroughState;
};
var $FinallyState = FinallyState;
($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));
  }}, {}, TryState);
return {get FinallyState() {
    return FinallyState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/StateAllocator”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/StateAllocator";
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var StateAllocator = function StateAllocator() {
  this.nextState_ = State.START_STATE + 1;
};
($traceurRuntime.createClass)(StateAllocator, {allocateState: function() {
    return this.nextState_++;
  }}, {});
return {get StateAllocator() {
    return StateAllocator;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/SwitchState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/SwitchState";
var $__249 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    CaseClause = $__249.CaseClause,
    DefaultClause = $__249.DefaultClause,
    SwitchStatement = $__249.SwitchStatement;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var $__249 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createBreakStatement = $__249.createBreakStatement,
    createStatementList = $__249.createStatementList;
var SwitchClause = function SwitchClause(first, second) {
  this.first = first;
  this.second = second;
};
($traceurRuntime.createClass)(SwitchClause, {}, {});
var SwitchState = function SwitchState(id, expression, clauses) {
  $traceurRuntime.superCall(this, $SwitchState.prototype, "constructor", [id]);
  this.expression = expression;
  this.clauses = clauses;
};
var $SwitchState = SwitchState;
($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 createStatementList(new SwitchStatement(null, this.expression, clauses), createBreakStatement());
  }
}, {}, State);
return {
  get SwitchClause() {
    return SwitchClause;
  },
  get SwitchState() {
    return SwitchState;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/CPSTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/CPSTransformer";
var $__250 = Object.freeze(Object.defineProperties(["$ctx.pushTry(\n            ", ",\n            ", ");"], {raw: {value: Object.freeze(["$ctx.pushTry(\n            ", ",\n            ", ");"])}})),
    $__251 = Object.freeze(Object.defineProperties(["$ctx.popTry();"], {raw: {value: Object.freeze(["$ctx.popTry();"])}})),
    $__252 = Object.freeze(Object.defineProperties(["\n              $ctx.popTry();\n              ", " = $ctx.storedException;"], {raw: {value: Object.freeze(["\n              $ctx.popTry();\n              ", " = $ctx.storedException;"])}})),
    $__253 = Object.freeze(Object.defineProperties(["$ctx.popTry();"], {raw: {value: Object.freeze(["$ctx.popTry();"])}})),
    $__254 = Object.freeze(Object.defineProperties(["function($ctx) {\n      while (true) ", "\n    }"], {raw: {value: Object.freeze(["function($ctx) {\n      while (true) ", "\n    }"])}})),
    $__255 = Object.freeze(Object.defineProperties(["var $arguments = arguments;"], {raw: {value: Object.freeze(["var $arguments = arguments;"])}})),
    $__256 = Object.freeze(Object.defineProperties(["return ", "(\n              ", ",\n              ", ", this);"], {raw: {value: Object.freeze(["return ", "(\n              ", ",\n              ", ", this);"])}})),
    $__257 = Object.freeze(Object.defineProperties(["return ", "(\n              ", ", this);"], {raw: {value: Object.freeze(["return ", "(\n              ", ", this);"])}})),
    $__258 = Object.freeze(Object.defineProperties(["return $ctx.end()"], {raw: {value: Object.freeze(["return $ctx.end()"])}})),
    $__259 = Object.freeze(Object.defineProperties(["\n                  $ctx.state = $ctx.finallyFallThrough;\n                  $ctx.finallyFallThrough = ", ";\n                  break;"], {raw: {value: Object.freeze(["\n                  $ctx.state = $ctx.finallyFallThrough;\n                  $ctx.finallyFallThrough = ", ";\n                  break;"])}})),
    $__260 = Object.freeze(Object.defineProperties(["\n                      $ctx.state = $ctx.finallyFallThrough;\n                      break;"], {raw: {value: Object.freeze(["\n                      $ctx.state = $ctx.finallyFallThrough;\n                      break;"])}}));
var AlphaRenamer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AlphaRenamer")).AlphaRenamer;
var BreakContinueTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/BreakContinueTransformer")).BreakContinueTransformer;
var $__263 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BLOCK = $__263.BLOCK,
    BREAK_STATEMENT = $__263.BREAK_STATEMENT,
    CASE_CLAUSE = $__263.CASE_CLAUSE,
    CONDITIONAL_EXPRESSION = $__263.CONDITIONAL_EXPRESSION,
    CONTINUE_STATEMENT = $__263.CONTINUE_STATEMENT,
    EXPRESSION_STATEMENT = $__263.EXPRESSION_STATEMENT,
    PAREN_EXPRESSION = $__263.PAREN_EXPRESSION,
    STATE_MACHINE = $__263.STATE_MACHINE;
var $__263 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    AnonBlock = $__263.AnonBlock,
    Block = $__263.Block,
    CaseClause = $__263.CaseClause,
    IfStatement = $__263.IfStatement,
    SwitchStatement = $__263.SwitchStatement;
var CatchState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/CatchState")).CatchState;
var ConditionalState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/ConditionalState")).ConditionalState;
var ExplodeExpressionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ExplodeExpressionTransformer")).ExplodeExpressionTransformer;
var FallThroughState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/FallThroughState")).FallThroughState;
var FinallyFallThroughState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/FinallyFallThroughState")).FinallyFallThroughState;
var FinallyState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/FinallyState")).FinallyState;
var FindInFunctionScope = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindInFunctionScope")).FindInFunctionScope;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var $__263 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__263.parseExpression,
    parseStatement = $__263.parseStatement,
    parseStatements = $__263.parseStatements;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var StateAllocator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/StateAllocator")).StateAllocator;
var StateMachine = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/StateMachine")).StateMachine;
var $__263 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/SwitchState")),
    SwitchClause = $__263.SwitchClause,
    SwitchState = $__263.SwitchState;
var TryState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/TryState")).TryState;
var $__263 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignStateStatement = $__263.createAssignStateStatement,
    createBreakStatement = $__263.createBreakStatement,
    createCaseClause = $__263.createCaseClause,
    createDefaultClause = $__263.createDefaultClause,
    createExpressionStatement = $__263.createExpressionStatement,
    createFunctionBody = $__263.createFunctionBody,
    id = $__263.createIdentifierExpression,
    createMemberExpression = $__263.createMemberExpression,
    createNumberLiteral = $__263.createNumberLiteral,
    createStatementList = $__263.createStatementList,
    createSwitchStatement = $__263.createSwitchStatement;
var HoistVariablesTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/HoistVariablesTransformer")).default;
var LabelState = function LabelState(name, continueState, fallThroughState) {
  this.name = name;
  this.continueState = continueState;
  this.fallThroughState = fallThroughState;
};
($traceurRuntime.createClass)(LabelState, {}, {});
var NeedsStateMachine = function NeedsStateMachine() {
  $traceurRuntime.defaultSuperCall(this, $NeedsStateMachine.prototype, arguments);
};
var $NeedsStateMachine = NeedsStateMachine;
($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;
  }
}, {}, FindInFunctionScope);
function needsStateMachine(tree) {
  var visitor = new NeedsStateMachine(tree);
  return visitor.found;
}
var HoistVariables = function HoistVariables() {
  $traceurRuntime.defaultSuperCall(this, $HoistVariables.prototype, arguments);
};
var $HoistVariables = HoistVariables;
($traceurRuntime.createClass)(HoistVariables, {prependVariables: function(statements) {
    return statements;
  }}, {}, HoistVariablesTransformer);
var CPSTransformer = function CPSTransformer(identifierGenerator, reporter) {
  $traceurRuntime.superCall(this, $CPSTransformer.prototype, "constructor", [identifierGenerator]);
  this.reporter = reporter;
  this.stateAllocator_ = new StateAllocator();
  this.labelSet_ = Object.create(null);
  this.currentLabel_ = null;
  this.hoistVariablesTransformer_ = new HoistVariables();
};
var $CPSTransformer = CPSTransformer;
($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.superCall(this, $CPSTransformer.prototype, "transformBlock", [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.pushTempVarState();
    var oldLabels = this.clearLabels_();
    var transformedTree = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformFunctionBody", [tree]);
    var machine = this.transformStatementList_(transformedTree.statements);
    this.restoreLabels_(oldLabels);
    this.popTempVarState();
    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 = 0; i < groups.length; i++) {
      if (groups[i] instanceof Array) {
        newMachine = this.statementsToStateMachine_(groups[i]);
      } else {
        newMachine = groups[i];
      }
      if (i === 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.superCall(this, $CPSTransformer.prototype, "transformCaseClause", [tree]);
    var machine = this.transformStatementList_(result.statements);
    return machine == null ? result : new CaseClause(null, result.expression, createStatementList(machine));
  },
  transformDoWhileStatement: function(tree) {
    var $__264;
    var $__263;
    var labels = this.getLabels_();
    var label = this.clearCurrentLabel_();
    var machine,
        condition,
        body;
    if (this.expressionNeedsStateMachine(tree.condition)) {
      (($__263 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.condition)), machine = $__263.machine, condition = $__263.expression, $__263));
      body = this.transformAny(tree.body);
    } else {
      var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformDoWhileStatement", [tree]);
      (($__263 = $traceurRuntime.assertObject(result), condition = $__263.condition, body = $__263.body, $__263));
      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;
      ($__264 = states).push.apply($__264, $traceurRuntime.toObject(machine.states));
    }
    states.push(new ConditionalState(conditionState, startState, fallThroughState, condition));
    var 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 $__264;
    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;
        ($__264 = states).push.apply($__264, $traceurRuntime.toObject(initializerMachine.states));
      }
      states.push(new FallThroughState(tmpId, initialiserFallThroughId, createStatementList(createExpressionStatement(initializer))));
    }
    if (condition) {
      if (!initializer)
        startId = conditionStartId;
      var tmpId = conditionStartId;
      if (conditionMachine) {
        conditionMachine = conditionMachine.replaceStartState(conditionStartId);
        tmpId = conditionMachine.fallThroughState;
        ($__264 = states).push.apply($__264, $traceurRuntime.toObject(conditionMachine.states));
      }
      states.push(new ConditionalState(tmpId, loopStartId, fallThroughId, condition));
    }
    if (increment) {
      var incrementFallThroughId;
      if (condition)
        incrementFallThroughId = conditionStartId;
      else
        incrementFallThroughId = loopStartId;
      var tmpId = incrementStartId;
      if (incrementMachine) {
        incrementMachine = incrementMachine.replaceStartState(incrementStartId);
        tmpId = incrementMachine.fallThroughState;
        ($__264 = states).push.apply($__264, $traceurRuntime.toObject(incrementMachine.states));
      }
      states.push(new FallThroughState(tmpId, incrementFallThroughId, createStatementList(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 $__264;
    var $__263;
    var machine,
        condition,
        ifClause,
        elseClause;
    if (this.expressionNeedsStateMachine(tree.condition)) {
      (($__263 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.condition)), machine = $__263.machine, condition = $__263.expression, $__263));
      ifClause = this.transformAny(tree.ifClause);
      elseClause = this.transformAny(tree.elseClause);
    } else {
      var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformIfStatement", [tree]);
      (($__263 = $traceurRuntime.assertObject(result), condition = $__263.condition, ifClause = $__263.ifClause, elseClause = $__263.elseClause, $__263));
      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));
    ($__264 = states).push.apply($__264, $traceurRuntime.toObject(ifClause.states));
    ($__264 = exceptionBlocks).push.apply($__264, $traceurRuntime.toObject(ifClause.exceptionBlocks));
    if (elseClause != null) {
      this.replaceAndAddStates_(elseClause.states, elseClause.fallThroughState, fallThroughState, states);
      ($__264 = exceptionBlocks).push.apply($__264, $traceurRuntime.toObject(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 (i = 0; i < newStates.length; i++) {
      newStates[i] = emptyStates.reduce((function(state, $__263) {
        var id = $__263.id,
            fallThroughState = $__263.fallThroughState;
        return state.replaceState(id, fallThroughState);
      }), newStates[i]);
    }
    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 oldLabels = this.labelSet_;
    var labelSet = Object.create(null);
    for (var k in this.labelSet_) {
      labelSet[k] = this.labelSet_[k];
    }
    labelSet[label.name] = label;
    this.labelSet_ = labelSet;
    return oldLabels;
  },
  clearLabels_: function() {
    var result = this.labelSet_;
    this.labelSet_ = Object.create(null);
    return result;
  },
  clearCurrentLabel_: function() {
    var result = this.currentLabel_;
    this.currentLabel_ = null;
    return result;
  },
  transformSwitchStatement: function(tree) {
    var $__263;
    var labels = this.getLabels_();
    var expression,
        machine,
        caseClauses;
    if (this.expressionNeedsStateMachine(tree.expression)) {
      (($__263 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__263.expression, machine = $__263.machine, $__263));
      caseClauses = this.transformList(tree.caseClauses);
    } else {
      var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformSwitchStatement", [tree]);
      if (!needsStateMachine(result))
        return result;
      (($__263 = $traceurRuntime.assertObject(result), expression = $__263.expression, caseClauses = $__263.caseClauses, $__263));
    }
    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 $__264;
    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));
    }
    ($__264 = tryStates).push.apply($__264, $traceurRuntime.toObject(machine.exceptionBlocks));
    return machine.startState;
  },
  transformTryStatement: function(tree) {
    var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformTryStatement", [tree]);
    var $__263 = $traceurRuntime.assertObject(result),
        body = $__263.body,
        catchBlock = $__263.catchBlock,
        finallyBlock = $__263.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($__250, (catchBlock && outerCatchState), (finallyBlock && outerFinallyState)));
    var tryMachine = this.ensureTransformed_(body);
    tryMachine = pushTryState.append(tryMachine);
    if (catchBlock !== null) {
      var popTry = this.statementToStateMachine_(parseStatement($__251));
      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($__252, 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 = this.statementToStateMachine_(parseStatement($__253));
      finallyMachine = popTry.append(finallyMachine);
      var states = $traceurRuntime.spread(tryMachine.states, finallyMachine.states, [new FinallyFallThroughState(finallyMachine.fallThroughState)]);
      tryMachine = new StateMachine(tryMachine.startState, tryMachine.fallThroughState, states, [new FinallyState(finallyMachine.startState, finallyMachine.fallThroughState, tryMachine.getAllStateIDs(), tryMachine.exceptionBlocks)]);
      tryMachine = tryMachine.replaceStateId(finallyMachine.startState, outerFinallyState);
    }
    return tryMachine;
  },
  transformWhileStatement: function(tree) {
    var $__264;
    var $__263;
    var labels = this.getLabels_();
    var label = this.clearCurrentLabel_();
    var condition,
        machine,
        body;
    if (this.expressionNeedsStateMachine(tree.condition)) {
      (($__263 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.condition)), machine = $__263.machine, condition = $__263.expression, $__263));
      body = this.transformAny(tree.body);
    } else {
      var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformWhileStatement", [tree]);
      (($__263 = $traceurRuntime.assertObject(result), condition = $__263.condition, body = $__263.body, $__263));
      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;
      ($__264 = states).push.apply($__264, $traceurRuntime.toObject(machine.states));
    }
    states.push(new ConditionalState(conditionStart, loopBodyMachine.startState, fallThroughState, condition));
    this.addLoopBodyStates_(loopBodyMachine, startState, fallThroughState, labels, states);
    var machine = new StateMachine(startState, fallThroughState, states, loopBodyMachine.exceptionBlocks);
    if (label)
      machine = machine.replaceStateId(startState, label.continueState);
    return machine;
  },
  transformWithStatement: function(tree) {
    var result = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformWithStatement", [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($__254, SwitchStatement);
  },
  addTempVar: function() {
    var name = this.getTempIdentifier();
    this.addMachineVariable(name);
    return name;
  },
  addMachineVariable: function(name) {
    this.hoistVariablesTransformer_.addVariable(name);
  },
  transformCpsFunctionBody: function(tree, runtimeMethod) {
    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_.hasVariables())
      statements.push(this.hoistVariablesTransformer_.getVariableStatement());
    if (hasArguments)
      statements.push(parseStatement($__255));
    if (functionRef) {
      statements.push(parseStatement($__256, runtimeMethod, this.generateMachineInnerFunction(machine), functionRef));
    } else {
      statements.push(parseStatement($__257, 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;
  },
  transformArrowFunctionExpression: 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($__258)));
    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;
            if (index < enclosingFinallyState.tryStates.length) {
              statements = createStatementList();
            } else {
              statements = parseStatements($__259, State.INVALID_STATE);
            }
            caseClauses.push(createCaseClause(createNumberLiteral(destination), statements));
          }
          caseClauses.push(createDefaultClause(createStatementList(createAssignStateStatement(enclosingFinallyState.finallyState), createBreakStatement())));
          cases.push(createCaseClause(createNumberLiteral(finallyState.fallThroughState), createStatementList(createSwitchStatement(createMemberExpression('$ctx', 'finallyFallThrough'), caseClauses), createBreakStatement())));
        } else {
          cases.push(createCaseClause(createNumberLiteral(finallyState.fallThroughState), parseStatements($__260)));
        }
        this.addFinallyFallThroughDispatches(finallyState, finallyState.nestedTrys, cases);
      } else {
        this.addFinallyFallThroughDispatches(enclosingFinallyState, tryState.nestedTrys, cases);
      }
    }
  },
  transformVariableDeclarationList: function(tree) {
    this.reporter.reportError(tree.location && tree.location.start, '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 = $traceurRuntime.assertObject(new NormalizeCommaExpressionToStatementTransformer().transformAny(commaExpression)).statements;
    var lastStatement = statements.pop();
    assert(lastStatement.type === EXPRESSION_STATEMENT);
    var expression = lastStatement.expression;
    statements = $traceurRuntime.superCall(this, $CPSTransformer.prototype, "transformList", [statements]);
    var machine = this.transformStatementList_(statements);
    return {
      expression: expression,
      machine: machine
    };
  }
}, {}, TempVarTransformer);
var NormalizeCommaExpressionToStatementTransformer = function NormalizeCommaExpressionToStatementTransformer() {
  $traceurRuntime.defaultSuperCall(this, $NormalizeCommaExpressionToStatementTransformer.prototype, arguments);
};
var $NormalizeCommaExpressionToStatementTransformer = NormalizeCommaExpressionToStatementTransformer;
($traceurRuntime.createClass)(NormalizeCommaExpressionToStatementTransformer, {
  transformCommaExpression: function(tree) {
    var $__261 = this;
    var statements = tree.expressions.map((function(expr) {
      if (expr.type === CONDITIONAL_EXPRESSION)
        return $__261.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));
  }
}, {}, 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;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/EndState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/EndState";
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var EndState = function EndState() {
  $traceurRuntime.defaultSuperCall(this, $EndState.prototype, arguments);
};
var $EndState = EndState;
($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);
  }
}, {}, State);
return {get EndState() {
    return EndState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/AsyncTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/AsyncTransformer";
var $__267 = Object.freeze(Object.defineProperties(["$ctx.value"], {raw: {value: Object.freeze(["$ctx.value"])}})),
    $__268 = Object.freeze(Object.defineProperties(["$ctx.returnValue = ", ""], {raw: {value: Object.freeze(["$ctx.returnValue = ", ""])}})),
    $__269 = Object.freeze(Object.defineProperties(["$ctx.resolve(", ")"], {raw: {value: Object.freeze(["$ctx.resolve(", ")"])}})),
    $__270 = Object.freeze(Object.defineProperties(["$traceurRuntime.asyncWrap"], {raw: {value: Object.freeze(["$traceurRuntime.asyncWrap"])}}));
var AwaitState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/AwaitState")).AwaitState;
var $__272 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    BinaryOperator = $__272.BinaryOperator,
    ExpressionStatement = $__272.ExpressionStatement,
    IdentifierExpression = $__272.IdentifierExpression;
var CPSTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/CPSTransformer")).CPSTransformer;
var EndState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/EndState")).EndState;
var FallThroughState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/FallThroughState")).FallThroughState;
var $__272 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    AWAIT_EXPRESSION = $__272.AWAIT_EXPRESSION,
    BINARY_OPERATOR = $__272.BINARY_OPERATOR,
    STATE_MACHINE = $__272.STATE_MACHINE;
var $__272 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__272.parseExpression,
    parseStatement = $__272.parseStatement,
    parseStatements = $__272.parseStatements;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var StateMachine = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/StateMachine")).StateMachine;
var $__272 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    EQUAL = $__272.EQUAL,
    VAR = $__272.VAR;
var FindInFunctionScope = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindInFunctionScope")).FindInFunctionScope;
var $__272 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignStateStatement = $__272.createAssignStateStatement,
    createBreakStatement = $__272.createBreakStatement,
    createOperatorToken = $__272.createOperatorToken,
    createReturnStatement = $__272.createReturnStatement,
    createStatementList = $__272.createStatementList,
    createUndefinedExpression = $__272.createUndefinedExpression;
function isAwaitAssign(tree) {
  return tree.type === BINARY_OPERATOR && tree.operator.isAssignmentOperator() && tree.right.type === AWAIT_EXPRESSION && tree.left.isLeftHandSideExpression();
}
var AwaitFinder = function AwaitFinder() {
  $traceurRuntime.defaultSuperCall(this, $AwaitFinder.prototype, arguments);
};
var $AwaitFinder = AwaitFinder;
($traceurRuntime.createClass)(AwaitFinder, {visitAwaitExpression: function(tree) {
    this.found = true;
  }}, {}, FindInFunctionScope);
function scopeContainsAwait(tree) {
  return new AwaitFinder(tree).found;
}
var AsyncTransformer = function AsyncTransformer() {
  $traceurRuntime.defaultSuperCall(this, $AsyncTransformer.prototype, arguments);
};
var $AsyncTransformer = AsyncTransformer;
($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.superCall(this, $AsyncTransformer.prototype, "transformExpressionStatement", [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, expression, left, operator) {
    var createTaskState = this.allocateState();
    var callbackState = this.allocateState();
    var fallThroughState = this.allocateState();
    if (!left)
      callbackState = fallThroughState;
    var states = [];
    var expression = this.transformAny(expression);
    states.push(new AwaitState(createTaskState, callbackState, expression));
    if (left) {
      var statement = new ExpressionStatement(tree.location, new BinaryOperator(tree.location, left, operator, parseExpression($__267)));
      var assignment = [statement];
      states.push(new FallThroughState(callbackState, fallThroughState, assignment));
    }
    return new StateMachine(createTaskState, fallThroughState, states, []);
  },
  transformFinally: function(tree) {
    var result = $traceurRuntime.superCall(this, $AsyncTransformer.prototype, "transformFinally", [tree]);
    if (result.block.type != STATE_MACHINE) {
      return result;
    }
    this.reporter.reportError(tree.location.start, 'await not permitted within a finally block.');
    return result;
  },
  transformReturnStatement: function(tree) {
    var $__272;
    var expression,
        machine;
    if (this.expressionNeedsStateMachine(tree.expression)) {
      (($__272 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__272.expression, machine = $__272.machine, $__272));
    } else {
      expression = tree.expression || createUndefinedExpression();
    }
    var startState = this.allocateState();
    var endState = this.allocateState();
    var completeState = new FallThroughState(startState, endState, parseStatements($__268, 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($__269, result);
  },
  transformAsyncBody: function(tree) {
    var runtimeFunction = parseExpression($__270);
    return this.transformCpsFunctionBody(tree, runtimeFunction);
  }
}, {transformAsyncBody: function(identifierGenerator, reporter, body) {
    return new $AsyncTransformer(identifierGenerator, reporter).transformAsyncBody(body);
  }}, CPSTransformer);
;
return {get AsyncTransformer() {
    return AsyncTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/ForInTransformPass”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/ForInTransformPass";
var $__274 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BLOCK = $__274.BLOCK,
    VARIABLE_DECLARATION_LIST = $__274.VARIABLE_DECLARATION_LIST,
    IDENTIFIER_EXPRESSION = $__274.IDENTIFIER_EXPRESSION;
var $__274 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    LENGTH = $__274.LENGTH,
    PUSH = $__274.PUSH;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__274 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    BANG = $__274.BANG,
    IN = $__274.IN,
    OPEN_ANGLE = $__274.OPEN_ANGLE,
    PLUS_PLUS = $__274.PLUS_PLUS,
    VAR = $__274.VAR;
var $__274 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArgumentList = $__274.createArgumentList,
    createAssignmentStatement = $__274.createAssignmentStatement,
    createBinaryOperator = $__274.createBinaryOperator,
    createBlock = $__274.createBlock,
    createCallStatement = $__274.createCallStatement,
    createContinueStatement = $__274.createContinueStatement,
    createEmptyArrayLiteralExpression = $__274.createEmptyArrayLiteralExpression,
    createForInStatement = $__274.createForInStatement,
    createForStatement = $__274.createForStatement,
    createIdentifierExpression = $__274.createIdentifierExpression,
    createIfStatement = $__274.createIfStatement,
    createMemberExpression = $__274.createMemberExpression,
    createMemberLookupExpression = $__274.createMemberLookupExpression,
    createNumberLiteral = $__274.createNumberLiteral,
    createOperatorToken = $__274.createOperatorToken,
    createParenExpression = $__274.createParenExpression,
    createPostfixExpression = $__274.createPostfixExpression,
    createUnaryExpression = $__274.createUnaryExpression,
    createVariableDeclarationList = $__274.createVariableDeclarationList,
    createVariableStatement = $__274.createVariableStatement;
var ForInTransformPass = function ForInTransformPass() {
  $traceurRuntime.defaultSuperCall(this, $ForInTransformPass.prototype, arguments);
};
var $ForInTransformPass = ForInTransformPass;
($traceurRuntime.createClass)(ForInTransformPass, {transformForInStatement: function(original) {
    var $__275;
    var tree = original;
    var bodyStatements = [];
    var body = this.transformAny(tree.body);
    if (body.type == BLOCK) {
      ($__275 = bodyStatements).push.apply($__275, $traceurRuntime.toObject(body.statements));
    } else {
      bodyStatements.push(body);
    }
    var elements = [];
    var keys = this.getTempIdentifier();
    elements.push(createVariableStatement(VAR, keys, createEmptyArrayLiteralExpression()));
    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(createBinaryOperator(originalKey, createOperatorToken(IN), createIdentifierExpression(collection)))), createContinueStatement(), null));
    ($__275 = innerBlock).push.apply($__275, $traceurRuntime.toObject(bodyStatements));
    elements.push(createForStatement(createVariableDeclarationList(VAR, i, createNumberLiteral(0)), createBinaryOperator(createIdentifierExpression(i), createOperatorToken(OPEN_ANGLE), createMemberExpression(keys, LENGTH)), createPostfixExpression(createIdentifierExpression(i), createOperatorToken(PLUS_PLUS)), createBlock(innerBlock)));
    return createBlock(elements);
  }}, {}, TempVarTransformer);
return {get ForInTransformPass() {
    return ForInTransformPass;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/YieldState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/YieldState";
var $__276 = Object.freeze(Object.defineProperties(["return ", ""], {raw: {value: Object.freeze(["return ", ""])}}));
var CURRENT = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).CURRENT;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var $__278 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentStatement = $__278.createAssignmentStatement,
    createIdentifierExpression = $__278.createIdentifierExpression,
    createMemberExpression = $__278.createMemberExpression,
    createReturnStatement = $__278.createReturnStatement,
    createThisExpression = $__278.createThisExpression,
    createTrueLiteral = $__278.createTrueLiteral;
var parseStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatement;
var YieldState = function YieldState(id, fallThroughState, expression) {
  $traceurRuntime.superCall(this, $YieldState.prototype, "constructor", [id]);
  this.fallThroughState = fallThroughState;
  this.expression = expression;
};
var $YieldState = YieldState;
($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), [parseStatement($__276, this.expression)]);
  }
}, {}, State);
return {get YieldState() {
    return YieldState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/ReturnState”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/ReturnState";
var $__279 = Object.freeze(Object.defineProperties(["$ctx.returnValue = ", ""], {raw: {value: Object.freeze(["$ctx.returnValue = ", ""])}}));
var $__281 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/semantics/util")),
    isUndefined = $__281.isUndefined,
    isVoidExpression = $__281.isVoidExpression;
var YieldState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/YieldState")).YieldState;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var $__281 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentStatement = $__281.createAssignmentStatement,
    createMemberExpression = $__281.createMemberExpression,
    createThisExpression = $__281.createThisExpression;
var parseStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatement;
var ReturnState = function ReturnState() {
  $traceurRuntime.defaultSuperCall(this, $ReturnState.prototype, arguments);
};
var $ReturnState = ReturnState;
($traceurRuntime.createClass)(ReturnState, {transform: function(enclosingFinally, machineEndState, reporter) {
    var $__282;
    var e = this.expression;
    var statements = [];
    if (e && !isUndefined(e) && !isVoidExpression(e))
      statements.push(parseStatement($__279, this.expression));
    ($__282 = statements).push.apply($__282, $traceurRuntime.toObject(State.generateJump(enclosingFinally, machineEndState)));
    return statements;
  }}, {}, YieldState);
return {get ReturnState() {
    return ReturnState;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/generator/GeneratorTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/generator/GeneratorTransformer";
var $__283 = Object.freeze(Object.defineProperties(["\n        ", " = ", "[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          ", ";\n        }"], {raw: {value: Object.freeze(["\n        ", " = ", "[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          ", ";\n        }"])}})),
    $__284 = Object.freeze(Object.defineProperties(["$ctx.sentIgnoreThrow"], {raw: {value: Object.freeze(["$ctx.sentIgnoreThrow"])}})),
    $__285 = Object.freeze(Object.defineProperties(["$ctx.sent"], {raw: {value: Object.freeze(["$ctx.sent"])}})),
    $__286 = Object.freeze(Object.defineProperties(["$ctx.maybeThrow()"], {raw: {value: Object.freeze(["$ctx.maybeThrow()"])}})),
    $__287 = Object.freeze(Object.defineProperties(["$traceurRuntime.createGeneratorInstance"], {raw: {value: Object.freeze(["$traceurRuntime.createGeneratorInstance"])}}));
var CPSTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/CPSTransformer")).CPSTransformer;
var $__289 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BINARY_OPERATOR = $__289.BINARY_OPERATOR,
    STATE_MACHINE = $__289.STATE_MACHINE,
    YIELD_EXPRESSION = $__289.YIELD_EXPRESSION;
var $__289 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    BinaryOperator = $__289.BinaryOperator,
    ExpressionStatement = $__289.ExpressionStatement;
var ExplodeExpressionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ExplodeExpressionTransformer")).ExplodeExpressionTransformer;
var FallThroughState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/FallThroughState")).FallThroughState;
var FindInFunctionScope = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindInFunctionScope")).FindInFunctionScope;
var ReturnState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/ReturnState")).ReturnState;
var State = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/State")).State;
var StateMachine = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/StateMachine")).StateMachine;
var YieldState = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/YieldState")).YieldState;
var $__289 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignStateStatement = $__289.createAssignStateStatement,
    createFunctionBody = $__289.createFunctionBody,
    id = $__289.createIdentifierExpression,
    createMemberExpression = $__289.createMemberExpression,
    createStatementList = $__289.createStatementList,
    createUndefinedExpression = $__289.createUndefinedExpression,
    createYieldStatement = $__289.createYieldStatement;
var $__289 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__289.parseExpression,
    parseStatement = $__289.parseStatement,
    parseStatements = $__289.parseStatements;
function isYieldAssign(tree) {
  return tree.type === BINARY_OPERATOR && tree.operator.isAssignmentOperator() && tree.right.type === YIELD_EXPRESSION && tree.left.isLeftHandSideExpression();
}
var YieldFinder = function YieldFinder() {
  $traceurRuntime.defaultSuperCall(this, $YieldFinder.prototype, arguments);
};
var $YieldFinder = YieldFinder;
($traceurRuntime.createClass)(YieldFinder, {visitYieldExpression: function(tree) {
    this.found = true;
  }}, {}, FindInFunctionScope);
function scopeContainsYield(tree) {
  return new YieldFinder(tree).found;
}
var GeneratorTransformer = function GeneratorTransformer(identifierGenerator, reporter) {
  $traceurRuntime.superCall(this, $GeneratorTransformer.prototype, "constructor", [identifierGenerator, reporter]);
  this.shouldAppendThrowCloseState_ = true;
};
var $GeneratorTransformer = GeneratorTransformer;
($traceurRuntime.createClass)(GeneratorTransformer, {
  expressionNeedsStateMachine: function(tree) {
    if (tree === null)
      return false;
    return scopeContainsYield(tree);
  },
  transformYieldExpression_: function(tree) {
    var $__289;
    var expression,
        machine;
    if (this.expressionNeedsStateMachine(tree.expression)) {
      (($__289 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__289.expression, machine = $__289.machine, $__289));
    } else {
      expression = this.transformAny(tree.expression);
      if (!expression)
        expression = createUndefinedExpression();
    }
    if (tree.isYieldFor)
      return this.transformYieldForExpression_(expression, machine);
    var startState = this.allocateState();
    var fallThroughState = this.allocateState();
    var yieldMachine = this.stateToStateMachine_(new YieldState(startState, fallThroughState, this.transformAny(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($__283, g, expression, next, g, next, next, createYieldStatement(createMemberExpression(next, 'value')));
    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.start, '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($__284) : parseExpression($__285);
    var statement = new ExpressionStatement(tree.location, new BinaryOperator(tree.location, left, tree.operator, sentExpression));
    var assignMachine = this.statementToStateMachine_(statement);
    this.shouldAppendThrowCloseState_ = shouldAppendThrowCloseState;
    return machine.append(assignMachine);
  },
  createThrowCloseState_: function() {
    return this.statementToStateMachine_(parseStatement($__286));
  },
  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.superCall(this, $GeneratorTransformer.prototype, "transformExpressionStatement", [tree]);
  },
  transformAwaitStatement: function(tree) {
    this.reporter.reportError(tree.location.start, 'Generator function may not have an await statement.');
    return tree;
  },
  transformReturnStatement: function(tree) {
    var $__289;
    var expression,
        machine;
    if (this.expressionNeedsStateMachine(tree.expression))
      (($__289 = $traceurRuntime.assertObject(this.expressionToStateMachine(tree.expression)), expression = $__289.expression, machine = $__289.machine, $__289));
    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 runtimeFunction = parseExpression($__287);
    return this.transformCpsFunctionBody(tree, runtimeFunction, name);
  }
}, {transformGeneratorBody: function(identifierGenerator, reporter, body, name) {
    return new $GeneratorTransformer(identifierGenerator, reporter).transformGeneratorBody(body, name);
  }}, CPSTransformer);
;
return {get GeneratorTransformer() {
    return GeneratorTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/GeneratorTransformPass”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/GeneratorTransformPass";
var $__290 = Object.freeze(Object.defineProperties(["$traceurRuntime.initGeneratorFunction(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.initGeneratorFunction(", ")"])}})),
    $__291 = Object.freeze(Object.defineProperties(["var ", " = ", ""], {raw: {value: Object.freeze(["var ", " = ", ""])}})),
    $__292 = Object.freeze(Object.defineProperties(["$traceurRuntime.initGeneratorFunction(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.initGeneratorFunction(", ")"])}}));
var ArrowFunctionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ArrowFunctionTransformer")).ArrowFunctionTransformer;
var AsyncTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/AsyncTransformer")).AsyncTransformer;
var ForInTransformPass = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/ForInTransformPass")).ForInTransformPass;
var $__294 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    GetAccessor = $__294.GetAccessor,
    SetAccessor = $__294.SetAccessor;
var GeneratorTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/generator/GeneratorTransformer")).GeneratorTransformer;
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var $__294 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__294.parseExpression,
    parseStatement = $__294.parseStatement;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__294 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    EQUAL = $__294.EQUAL,
    STAR = $__294.STAR;
var $__294 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BINARY_OPERATOR = $__294.BINARY_OPERATOR,
    COMMA_EXPRESSION = $__294.COMMA_EXPRESSION,
    PAREN_EXPRESSION = $__294.PAREN_EXPRESSION,
    YIELD_EXPRESSION = $__294.YIELD_EXPRESSION;
var FindInFunctionScope = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindInFunctionScope")).FindInFunctionScope;
var $__294 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    AnonBlock = $__294.AnonBlock,
    FunctionDeclaration = $__294.FunctionDeclaration,
    FunctionExpression = $__294.FunctionExpression;
var alphaRenameThisAndArguments = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/alphaRenameThisAndArguments")).default;
var $__294 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentExpression = $__294.createAssignmentExpression,
    createAssignmentStatement = $__294.createAssignmentStatement,
    createBindingIdentifier = $__294.createBindingIdentifier,
    createBlock = $__294.createBlock,
    createCommaExpression = $__294.createCommaExpression,
    createExpressionStatement = $__294.createExpressionStatement,
    id = $__294.createIdentifierExpression,
    createIdentifierToken = $__294.createIdentifierToken,
    createMemberExpression = $__294.createMemberExpression,
    createVariableDeclaration = $__294.createVariableDeclaration,
    createVariableDeclarationList = $__294.createVariableDeclarationList,
    createVariableStatement = $__294.createVariableStatement,
    createYieldStatement = $__294.createYieldStatement;
var prependStatements = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PrependStatements")).prependStatements;
var $__294 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")),
    transformOptions = $__294.transformOptions,
    options = $__294.options;
var ForInFinder = function ForInFinder() {
  $traceurRuntime.defaultSuperCall(this, $ForInFinder.prototype, arguments);
};
var $ForInFinder = ForInFinder;
($traceurRuntime.createClass)(ForInFinder, {visitForInStatement: function(tree) {
    this.found = true;
  }}, {}, FindInFunctionScope);
function needsTransform(tree) {
  return transformOptions.generators && tree.isGenerator() || transformOptions.asyncFunctions && tree.isAsyncFunction();
}
var GeneratorTransformPass = function GeneratorTransformPass(identifierGenerator, reporter) {
  $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "constructor", [identifierGenerator]);
  this.reporter_ = reporter;
  this.inBlock_ = false;
};
var $GeneratorTransformPass = GeneratorTransformPass;
($traceurRuntime.createClass)(GeneratorTransformPass, {
  transformFunctionDeclaration: function(tree) {
    if (!needsTransform(tree))
      return $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformFunctionDeclaration", [tree]);
    if (tree.isGenerator())
      return this.transformGeneratorDeclaration_(tree);
    return this.transformFunction_(tree, FunctionDeclaration, null);
  },
  transformGeneratorDeclaration_: function(tree) {
    var nameIdExpression = id(tree.name.identifierToken);
    var setupPrototypeExpression = parseExpression($__290, 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($__291, tmpVar, setupPrototypeExpression)]);
  },
  transformFunctionExpression: function(tree) {
    if (!needsTransform(tree))
      return $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformFunctionExpression", [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.functionBody);
    } else {
      name = tree.name.identifierToken;
    }
    var functionExpression = this.transformFunction_(tree, FunctionExpression, id(name));
    return parseExpression($__292, functionExpression);
  },
  transformFunction_: function(tree, constructor, nameExpression) {
    var body = $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformAny", [tree.functionBody]);
    var finder = new ForInFinder(body);
    if (finder.found) {
      body = new ForInTransformPass(this.identifierGenerator).transformAny(body);
    }
    if (transformOptions.generators && tree.isGenerator()) {
      body = GeneratorTransformer.transformGeneratorBody(this.identifierGenerator, this.reporter_, body, nameExpression);
    } else if (transformOptions.asyncFunctions && tree.isAsyncFunction()) {
      body = AsyncTransformer.transformAsyncBody(this.identifierGenerator, this.reporter_, body);
    }
    var functionKind = null;
    return new constructor(tree.location, tree.name, functionKind, tree.parameterList, tree.typeAnnotation || null, tree.annotations || null, body);
  },
  transformArrowFunctionExpression: function(tree) {
    if (!tree.isAsyncFunction())
      return $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformArrowFunctionExpression", [tree]);
    return this.transformAny(ArrowFunctionTransformer.transform(this, tree));
  },
  transformBlock: function(tree) {
    var inBlock = this.inBlock_;
    this.inBlock_ = true;
    var rv = $traceurRuntime.superCall(this, $GeneratorTransformPass.prototype, "transformBlock", [tree]);
    this.inBlock_ = inBlock;
    return rv;
  }
}, {}, TempVarTransformer);
return {get GeneratorTransformPass() {
    return GeneratorTransformPass;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/InlineModuleTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/InlineModuleTransformer";
var VAR = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).VAR;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var ModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ModuleTransformer")).ModuleTransformer;
var $__296 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createBindingIdentifier = $__296.createBindingIdentifier,
    createEmptyStatement = $__296.createEmptyStatement,
    createFunctionBody = $__296.createFunctionBody,
    createImmediatelyInvokedFunctionExpression = $__296.createImmediatelyInvokedFunctionExpression,
    createScopedExpression = $__296.createScopedExpression,
    createVariableStatement = $__296.createVariableStatement;
var globalThis = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/globalThis")).default;
var scopeContainsThis = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/scopeContainsThis")).default;
var InlineModuleTransformer = function InlineModuleTransformer() {
  $traceurRuntime.defaultSuperCall(this, $InlineModuleTransformer.prototype, arguments);
};
var $InlineModuleTransformer = InlineModuleTransformer;
($traceurRuntime.createClass)(InlineModuleTransformer, {
  wrapModule: function(statements) {
    assert(this.moduleName);
    var idName = this.getTempVarNameForModuleName(this.moduleName);
    var body = createFunctionBody(statements);
    var moduleExpression;
    if (statements.some(scopeContainsThis)) {
      moduleExpression = createScopedExpression(body, globalThis());
    } else {
      moduleExpression = createImmediatelyInvokedFunctionExpression(body);
    }
    return [createVariableStatement(VAR, idName, moduleExpression)];
  },
  transformNamedExport: function(tree) {
    return createEmptyStatement();
  },
  transformModuleSpecifier: function(tree) {
    return createBindingIdentifier(this.getTempVarNameForModuleSpecifier(tree));
  }
}, {}, ModuleTransformer);
return {get InlineModuleTransformer() {
    return InlineModuleTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/InstantiateModuleTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/InstantiateModuleTransformer";
var $__297 = Object.freeze(Object.defineProperties(["", " = ", ""], {raw: {value: Object.freeze(["", " = ", ""])}})),
    $__298 = Object.freeze(Object.defineProperties(["System.register(", ", ", ", function(", ") {\n          ", "\n        });"], {raw: {value: Object.freeze(["System.register(", ", ", ", function(", ") {\n          ", "\n        });"])}})),
    $__299 = Object.freeze(Object.defineProperties(["System.register(", ", function(", ") {\n          ", "\n        });"], {raw: {value: Object.freeze(["System.register(", ", function(", ") {\n          ", "\n        });"])}})),
    $__300 = Object.freeze(Object.defineProperties(["function() {\n      ", "\n    }"], {raw: {value: Object.freeze(["function() {\n      ", "\n    }"])}})),
    $__301 = Object.freeze(Object.defineProperties(["function() {}"], {raw: {value: Object.freeze(["function() {}"])}})),
    $__302 = Object.freeze(Object.defineProperties(["return {\n        exports: ", ",\n        exportStar: ", ",\n        execute: ", "\n      }"], {raw: {value: Object.freeze(["return {\n        exports: ", ",\n        exportStar: ", ",\n        execute: ", "\n      }"])}})),
    $__303 = Object.freeze(Object.defineProperties(["return {\n        exports: ", ",\n        execute: ", "\n      }"], {raw: {value: Object.freeze(["return {\n        exports: ", ",\n        execute: ", "\n      }"])}})),
    $__304 = Object.freeze(Object.defineProperties(["", "[", "][", "]"], {raw: {value: Object.freeze(["", "[", "][", "]"])}})),
    $__305 = Object.freeze(Object.defineProperties(["", "[", "]"], {raw: {value: Object.freeze(["", "[", "]"])}})),
    $__306 = Object.freeze(Object.defineProperties(["set ", "(value) { ", " = value; }"], {raw: {value: Object.freeze(["set ", "(value) { ", " = value; }"])}})),
    $__307 = Object.freeze(Object.defineProperties(["get ", "() { return ", "; }"], {raw: {value: Object.freeze(["get ", "() { return ", "; }"])}}));
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).assert;
var $__310 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    ClassExpression = $__310.ClassExpression,
    EmptyStatement = $__310.EmptyStatement,
    NamedExport = $__310.NamedExport;
var THIS = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")).THIS;
var $__310 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    EXPORT_DEFAULT = $__310.EXPORT_DEFAULT,
    EXPORT_SPECIFIER = $__310.EXPORT_SPECIFIER,
    EXPORT_STAR = $__310.EXPORT_STAR;
var AlphaRenamer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AlphaRenamer")).AlphaRenamer;
var $__310 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createIdentifierExpression = $__310.createIdentifierExpression,
    createMemberExpression = $__310.createMemberExpression,
    createObjectLiteralExpression = $__310.createObjectLiteralExpression;
var ModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ModuleTransformer")).ModuleTransformer;
var $__310 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__310.parseExpression,
    parsePropertyDefinition = $__310.parsePropertyDefinition,
    parseStatement = $__310.parseStatement,
    parseStatements = $__310.parseStatements;
var HoistVariablesTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/HoistVariablesTransformer")).default;
var DeclarationExtractionTransformer = function DeclarationExtractionTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $DeclarationExtractionTransformer.prototype, "constructor", []);
  this.identifierGenerator = identifierGenerator;
  this.declarations_ = [];
};
var $DeclarationExtractionTransformer = DeclarationExtractionTransformer;
($traceurRuntime.createClass)(DeclarationExtractionTransformer, {
  getDeclarationStatements: function() {
    return $traceurRuntime.spread([this.getVariableStatement()], this.declarations_);
  },
  addDeclaration: function(tree) {
    this.declarations_.push(tree);
  },
  transformFunctionDeclaration: function(tree) {
    this.addDeclaration(tree);
    return new EmptyStatement(null);
  },
  transformClassDeclaration: function(tree) {
    this.addVariable(tree.name.identifierToken.value);
    tree = new ClassExpression(tree.location, tree.name, tree.superClass, tree.elements, tree.annotations);
    return parseStatement($__297, tree.name.identifierToken, tree);
  }
}, {}, HoistVariablesTransformer);
var ReplaceIdentifierExpressionTransformer = function ReplaceIdentifierExpressionTransformer(oldName, newExpression) {
  $traceurRuntime.superCall(this, $ReplaceIdentifierExpressionTransformer.prototype, "constructor", []);
  this.oldName_ = oldName;
  this.newExpression_ = newExpression;
};
var $ReplaceIdentifierExpressionTransformer = ReplaceIdentifierExpressionTransformer;
($traceurRuntime.createClass)(ReplaceIdentifierExpressionTransformer, {
  transformIdentifierExpression: function(tree) {
    if (this.oldName_ == tree.identifierToken.value) {
      return this.newExpression_;
    } else {
      return tree;
    }
  },
  transformThisExpression: function(tree) {
    if (this.oldName_ !== THIS)
      return tree;
    return this.newExpression_;
  }
}, {rename: function(tree, oldName, newExpression) {
    return new $ReplaceIdentifierExpressionTransformer(oldName, newExpression).transformAny(tree);
  }}, AlphaRenamer);
var InstantiateModuleTransformer = function InstantiateModuleTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $InstantiateModuleTransformer.prototype, "constructor", [identifierGenerator]);
  this.declarationExtractionTransformer = new DeclarationExtractionTransformer(identifierGenerator, this.moduleBindings_);
  this.dependencies = [];
  this.depMapIdentifier = createIdentifierExpression(this.identifierGenerator.generateUniqueIdentifier());
  this.moduleBindings_ = [];
};
var $InstantiateModuleTransformer = InstantiateModuleTransformer;
($traceurRuntime.createClass)(InstantiateModuleTransformer, {
  wrapModule: function(statements) {
    if (this.moduleName) {
      return parseStatements($__298, this.moduleName, this.dependencies, this.depMapIdentifier, statements);
    } else {
      return parseStatements($__299, this.dependencies, this.depMapIdentifier, statements);
    }
  },
  appendExportStatement: function(statements) {
    var $__308 = this;
    var executionStatements = statements.map((function(statement) {
      return $__308.declarationExtractionTransformer.transformAny(statement);
    }));
    var executionFunction = executionStatements.length ? parseExpression($__300, executionStatements) : parseExpression($__301);
    var declarationStatements = this.declarationExtractionTransformer.getDeclarationStatements();
    var exportStarDeps = this.exportVisitor_.starExports.map((function(moduleSpecifier) {
      return moduleSpecifier.token.processedValue;
    }));
    if (exportStarDeps.length) {
      declarationStatements.push(parseStatement($__302, this.getExportObject(), exportStarDeps, executionFunction));
    } else {
      declarationStatements.push(parseStatement($__303, this.getExportObject(), executionFunction));
    }
    this.moduleBindings_.forEach((function(binding) {
      var moduleMemberExpression = parseExpression($__304, $__308.depMapIdentifier, binding.depIndex, binding.importName);
      declarationStatements = declarationStatements.map((function(statement) {
        return ReplaceIdentifierExpressionTransformer.rename(statement, binding.variableName, moduleMemberExpression);
      }));
    }));
    return declarationStatements;
  },
  getExportObject: function() {
    return createObjectLiteralExpression(this.getExportProperties());
  },
  addModuleBinding: function(moduleBinding) {
    this.moduleBindings_.push(moduleBinding);
  },
  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;
  },
  transformModuleSpecifier: function(tree) {
    var depIndex = this.getOrCreateDependencyIndex(tree);
    return parseExpression($__305, this.depMapIdentifier, depIndex);
  },
  getExportExpression: function($__310) {
    var name = $__310.name,
        tree = $__310.tree,
        moduleSpecifier = $__310.moduleSpecifier;
    switch (tree.type) {
      case EXPORT_DEFAULT:
        return createIdentifierExpression('$__default');
      case EXPORT_SPECIFIER:
        if (moduleSpecifier) {
          return createMemberExpression(moduleSpecifier, tree.lhs);
        }
        return createIdentifierExpression(tree.lhs);
      default:
        return createIdentifierExpression(name);
    }
  },
  getSetterExport: function(exp) {
    return parsePropertyDefinition($__306, exp.name, this.getExportExpression(exp));
  },
  getGetterExport: function(exp) {
    return parsePropertyDefinition($__307, exp.name, this.getExportExpression(exp));
  },
  transformExportDeclaration: function(tree) {
    if (!tree.declaration.specifierSet) {
      this.exportVisitor_.visitAny(tree);
      return this.transformAny(tree.declaration);
    }
    if (tree.declaration.specifierSet.type != EXPORT_STAR) {
      tree.declaration = this.transformAny(tree.declaration);
      tree.annotations = this.transformList(tree.annotations);
    }
    this.exportVisitor_.visitAny(tree);
    return new EmptyStatement(null);
  },
  transformNamedExport: function(tree) {
    var moduleSpecifier = this.transformAny(tree.moduleSpecifier);
    var specifierSet = this.transformAny(tree.specifierSet);
    if (moduleSpecifier === tree.moduleSpecifier && specifierSet === tree.specifierSet) {
      return tree;
    }
    return new NamedExport(tree.location, moduleSpecifier, specifierSet);
  },
  transformImportDeclaration: function(tree) {
    this.moduleSpecifierKind_ = 'import';
    this.curDepIndex_ = this.getOrCreateDependencyIndex(tree.moduleSpecifier);
    this.transformAny(tree.importClause);
    return new EmptyStatement(tree.location);
  },
  transformImportedBinding: function(tree) {
    this.addModuleBinding({
      variableName: tree.binding.identifierToken.value,
      depIndex: this.curDepIndex_,
      importName: 'default'
    });
    return tree;
  },
  transformImportSpecifier: function(tree) {
    var importName;
    var localName;
    if (tree.rhs) {
      localName = tree.rhs.value;
      importName = tree.lhs.value;
    } else {
      localName = importName = tree.lhs.value;
    }
    this.addModuleBinding({
      variableName: localName,
      depIndex: this.curDepIndex_,
      importName: importName
    });
  }
}, {}, ModuleTransformer);
return {get InstantiateModuleTransformer() {
    return InstantiateModuleTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/MultiTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/MultiTransformer";
var ParseTreeValidator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeValidator")).ParseTreeValidator;
var MultiTransformer = function MultiTransformer(reporter, validate) {
  this.reporter_ = reporter;
  this.validate_ = validate;
  this.treeTransformers_ = [];
};
($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;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/NumericLiteralTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/NumericLiteralTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__314 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    LiteralExpression = $__314.LiteralExpression,
    LiteralPropertyName = $__314.LiteralPropertyName;
var LiteralToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/LiteralToken")).LiteralToken;
var NUMBER = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).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 NumericLiteralTransformer() {
  $traceurRuntime.defaultSuperCall(this, $NumericLiteralTransformer.prototype, arguments);
};
var $NumericLiteralTransformer = NumericLiteralTransformer;
($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;
  }
}, {}, ParseTreeTransformer);
return {get NumericLiteralTransformer() {
    return NumericLiteralTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/ObjectLiteralTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/ObjectLiteralTransformer";
var FindVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FindVisitor")).FindVisitor;
var $__316 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    FormalParameterList = $__316.FormalParameterList,
    FunctionExpression = $__316.FunctionExpression,
    IdentifierExpression = $__316.IdentifierExpression,
    LiteralExpression = $__316.LiteralExpression;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__316 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    IDENTIFIER = $__316.IDENTIFIER,
    STRING = $__316.STRING;
var $__316 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    COMPUTED_PROPERTY_NAME = $__316.COMPUTED_PROPERTY_NAME,
    LITERAL_PROPERTY_NAME = $__316.LITERAL_PROPERTY_NAME;
var $__316 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createAssignmentExpression = $__316.createAssignmentExpression,
    createCommaExpression = $__316.createCommaExpression,
    createDefineProperty = $__316.createDefineProperty,
    createEmptyParameterList = $__316.createEmptyParameterList,
    createFunctionExpression = $__316.createFunctionExpression,
    createIdentifierExpression = $__316.createIdentifierExpression,
    createObjectCreate = $__316.createObjectCreate,
    createObjectLiteralExpression = $__316.createObjectLiteralExpression,
    createParenExpression = $__316.createParenExpression,
    createPropertyNameAssignment = $__316.createPropertyNameAssignment,
    createStringLiteral = $__316.createStringLiteral;
var propName = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/staticsemantics/PropName")).propName;
var transformOptions = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).transformOptions;
var FindAdvancedProperty = function FindAdvancedProperty(tree) {
  this.protoExpression = null;
  $traceurRuntime.superCall(this, $FindAdvancedProperty.prototype, "constructor", [tree, true]);
};
var $FindAdvancedProperty = FindAdvancedProperty;
($traceurRuntime.createClass)(FindAdvancedProperty, {
  visitPropertyNameAssignment: function(tree) {
    if (isProtoName(tree.name))
      this.protoExpression = tree.value;
    else
      $traceurRuntime.superCall(this, $FindAdvancedProperty.prototype, "visitPropertyNameAssignment", [tree]);
  },
  visitComputedPropertyName: function(tree) {
    if (transformOptions.computedPropertyNames)
      this.found = true;
  }
}, {}, FindVisitor);
function isProtoName(tree) {
  return propName(tree) === '__proto__';
}
var ObjectLiteralTransformer = function ObjectLiteralTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "constructor", [identifierGenerator]);
  this.protoExpression = null;
  this.needsAdvancedTransform = false;
  this.seenAccessors = null;
};
var $ObjectLiteralTransformer = ObjectLiteralTransformer;
($traceurRuntime.createClass)(ObjectLiteralTransformer, {
  findSeenAccessor_: function(name) {
    if (name.type === COMPUTED_PROPERTY_NAME)
      return null;
    var s = propName(name);
    return this.seenAccessors[s];
  },
  removeSeenAccessor_: function(name) {
    if (name.type === COMPUTED_PROPERTY_NAME)
      return;
    var s = propName(name);
    delete this.seenAccessors[s];
  },
  addSeenAccessor_: function(name, descr) {
    if (name.type === COMPUTED_PROPERTY_NAME)
      return;
    var s = propName(name);
    this.seenAccessors[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;
  },
  transformObjectLiteralExpression: function(tree) {
    var oldNeedsTransform = this.needsAdvancedTransform;
    var oldSeenAccessors = this.seenAccessors;
    try {
      var finder = new FindAdvancedProperty(tree);
      if (!finder.found) {
        this.needsAdvancedTransform = false;
        return $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "transformObjectLiteralExpression", [tree]);
      }
      this.needsAdvancedTransform = true;
      this.seenAccessors = Object.create(null);
      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 = createObjectLiteralExpression([]);
      expressions.unshift(createAssignmentExpression(tempVarIdentifierExpression, objectExpression));
      expressions.push(tempVarIdentifierExpression);
      return createParenExpression(createCommaExpression(expressions));
    } finally {
      this.needsAdvancedTransform = oldNeedsTransform;
      this.seenAccessors = oldSeenAccessors;
    }
  },
  transformPropertyNameAssignment: function(tree) {
    if (!this.needsAdvancedTransform)
      return $traceurRuntime.superCall(this, $ObjectLiteralTransformer.prototype, "transformPropertyNameAssignment", [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.superCall(this, $ObjectLiteralTransformer.prototype, "transformGetAccessor", [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.superCall(this, $ObjectLiteralTransformer.prototype, "transformSetAccessor", [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
    });
  },
  transformPropertyMethodAssignment: function(tree) {
    var func = new FunctionExpression(tree.location, null, tree.functionKind, this.transformAny(tree.parameterList), tree.typeAnnotation, [], this.transformAny(tree.functionBody));
    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.superCall(this, $ObjectLiteralTransformer.prototype, "transformPropertyNameShorthand", [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
    });
  }
}, {}, TempVarTransformer);
return {get ObjectLiteralTransformer() {
    return ObjectLiteralTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/PropertyNameShorthandTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/PropertyNameShorthandTransformer";
var $__318 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    IdentifierExpression = $__318.IdentifierExpression,
    LiteralPropertyName = $__318.LiteralPropertyName,
    PropertyNameAssignment = $__318.PropertyNameAssignment;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var PropertyNameShorthandTransformer = function PropertyNameShorthandTransformer() {
  $traceurRuntime.defaultSuperCall(this, $PropertyNameShorthandTransformer.prototype, arguments);
};
var $PropertyNameShorthandTransformer = PropertyNameShorthandTransformer;
($traceurRuntime.createClass)(PropertyNameShorthandTransformer, {transformPropertyNameShorthand: function(tree) {
    return new PropertyNameAssignment(tree.location, new LiteralPropertyName(tree.location, tree.name), new IdentifierExpression(tree.location, tree.name));
  }}, {}, ParseTreeTransformer);
return {get PropertyNameShorthandTransformer() {
    return PropertyNameShorthandTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/RestParameterTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/RestParameterTransformer";
var $__319 = Object.freeze(Object.defineProperties(["\n            for (var ", " = [], ", " = ", ";\n                 ", " < arguments.length; ", "++)\n              ", "[", " - ", "] = arguments[", "];"], {raw: {value: Object.freeze(["\n            for (var ", " = [], ", " = ", ";\n                 ", " < arguments.length; ", "++)\n              ", "[", " - ", "] = arguments[", "];"])}})),
    $__320 = Object.freeze(Object.defineProperties(["\n            for (var ", " = [], ", " = 0;\n                 ", " < arguments.length; ", "++)\n              ", "[", "] = arguments[", "];"], {raw: {value: Object.freeze(["\n            for (var ", " = [], ", " = 0;\n                 ", " < arguments.length; ", "++)\n              ", "[", "] = arguments[", "];"])}}));
var FormalParameterList = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")).FormalParameterList;
var ParameterTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParameterTransformer")).ParameterTransformer;
var createIdentifierToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createIdentifierToken;
var parseStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).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 RestParameterTransformer() {
  $traceurRuntime.defaultSuperCall(this, $RestParameterTransformer.prototype, arguments);
};
var $RestParameterTransformer = RestParameterTransformer;
($traceurRuntime.createClass)(RestParameterTransformer, {transformFormalParameterList: function(tree) {
    var transformed = $traceurRuntime.superCall(this, $RestParameterTransformer.prototype, "transformFormalParameterList", [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($__319, name, i, startIndex, i, i, name, i, startIndex, i);
      } else {
        loop = parseStatement($__320, name, i, i, i, name, i, i);
      }
      this.parameterStatements.push(loop);
      return parametersWithoutRestParam;
    }
    return transformed;
  }}, {}, ParameterTransformer);
return {get RestParameterTransformer() {
    return RestParameterTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/SpreadTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/SpreadTransformer";
var $__323 = Object.freeze(Object.defineProperties(["$traceurRuntime.toObject(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.toObject(", ")"])}})),
    $__324 = Object.freeze(Object.defineProperties(["$traceurRuntime.spread(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.spread(", ")"])}}));
var $__326 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    APPLY = $__326.APPLY,
    BIND = $__326.BIND,
    FUNCTION = $__326.FUNCTION,
    PROTOTYPE = $__326.PROTOTYPE;
var $__326 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    MEMBER_EXPRESSION = $__326.MEMBER_EXPRESSION,
    MEMBER_LOOKUP_EXPRESSION = $__326.MEMBER_LOOKUP_EXPRESSION,
    SPREAD_EXPRESSION = $__326.SPREAD_EXPRESSION;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__326 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArgumentList = $__326.createArgumentList,
    createArrayLiteralExpression = $__326.createArrayLiteralExpression,
    createAssignmentExpression = $__326.createAssignmentExpression,
    createCallExpression = $__326.createCallExpression,
    createEmptyArgumentList = $__326.createEmptyArgumentList,
    createIdentifierExpression = $__326.createIdentifierExpression,
    createMemberExpression = $__326.createMemberExpression,
    createMemberLookupExpression = $__326.createMemberLookupExpression,
    createNewExpression = $__326.createNewExpression,
    createNullLiteral = $__326.createNullLiteral,
    createParenExpression = $__326.createParenExpression;
var parseExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseExpression;
function hasSpreadMember(trees) {
  return trees.some((function(tree) {
    return tree && tree.type == SPREAD_EXPRESSION;
  }));
}
var SpreadTransformer = function SpreadTransformer() {
  $traceurRuntime.defaultSuperCall(this, $SpreadTransformer.prototype, arguments);
};
var $SpreadTransformer = SpreadTransformer;
($traceurRuntime.createClass)(SpreadTransformer, {
  createArrayFromElements_: function(elements, needsNewArray) {
    var length = elements.length;
    if (length === 1 && !needsNewArray) {
      var args = createArgumentList(this.transformAny(elements[0].expression));
      return parseExpression($__323, args);
    }
    var args = [];
    var lastArray;
    for (var i = 0; i < length; i++) {
      if (elements[i] && elements[i].type === SPREAD_EXPRESSION) {
        if (lastArray) {
          args.push(createArrayLiteralExpression(lastArray));
          lastArray = null;
        }
        args.push(this.transformAny(elements[i].expression));
      } else {
        if (!lastArray)
          lastArray = [];
        lastArray.push(this.transformAny(elements[i]));
      }
    }
    if (lastArray)
      args.push(createArrayLiteralExpression(lastArray));
    return parseExpression($__324, createArgumentList(args));
  },
  desugarCallSpread_: function(tree) {
    var operand = this.transformAny(tree.operand);
    var functionObject,
        contextObject;
    this.pushTempVarState();
    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 = createIdentifierExpression(this.addTempVar());
      var parenExpression = createParenExpression(createAssignmentExpression(tempIdent, operand.operand));
      var memberExpression = this.transformAny(operand.memberExpression);
      contextObject = tempIdent;
      functionObject = createMemberLookupExpression(parenExpression, memberExpression);
    } else {
      contextObject = createNullLiteral();
      functionObject = operand;
    }
    this.popTempVarState();
    var arrayExpression = this.createArrayFromElements_(tree.args.args, false);
    return createCallExpression(createMemberExpression(functionObject, APPLY), createArgumentList(contextObject, arrayExpression));
  },
  desugarNewSpread_: function(tree) {
    var arrayExpression = $traceurRuntime.spread([createNullLiteral()], tree.args.args);
    arrayExpression = this.createArrayFromElements_(arrayExpression, false);
    return createNewExpression(createParenExpression(createCallExpression(createMemberExpression(FUNCTION, PROTOTYPE, BIND, APPLY), createArgumentList(this.transformAny(tree.operand), arrayExpression))), createEmptyArgumentList());
  },
  transformArrayLiteralExpression: function(tree) {
    if (hasSpreadMember(tree.elements)) {
      return this.createArrayFromElements_(tree.elements, true);
    }
    return $traceurRuntime.superCall(this, $SpreadTransformer.prototype, "transformArrayLiteralExpression", [tree]);
  },
  transformCallExpression: function(tree) {
    if (hasSpreadMember(tree.args.args)) {
      return this.desugarCallSpread_(tree);
    }
    return $traceurRuntime.superCall(this, $SpreadTransformer.prototype, "transformCallExpression", [tree]);
  },
  transformNewExpression: function(tree) {
    if (tree.args != null && hasSpreadMember(tree.args.args)) {
      return this.desugarNewSpread_(tree);
    }
    return $traceurRuntime.superCall(this, $SpreadTransformer.prototype, "transformNewExpression", [tree]);
  }
}, {}, TempVarTransformer);
return {get SpreadTransformer() {
    return SpreadTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/SymbolTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/SymbolTransformer";
var $__327 = Object.freeze(Object.defineProperties(["$traceurRuntime.toProperty(", ") in ", ""], {raw: {value: Object.freeze(["$traceurRuntime.toProperty(", ") in ", ""])}})),
    $__328 = Object.freeze(Object.defineProperties(["$traceurRuntime.setProperty(", ",\n          ", ", ", ")"], {raw: {value: Object.freeze(["$traceurRuntime.setProperty(", ",\n          ", ", ", ")"])}})),
    $__329 = Object.freeze(Object.defineProperties(["", "[$traceurRuntime.toProperty(", ")]"], {raw: {value: Object.freeze(["", "[$traceurRuntime.toProperty(", ")]"])}})),
    $__330 = Object.freeze(Object.defineProperties(["$traceurRuntime.typeof(", ")"], {raw: {value: Object.freeze(["$traceurRuntime.typeof(", ")"])}})),
    $__331 = Object.freeze(Object.defineProperties(["(typeof ", " === 'undefined' ?\n          'undefined' : ", ")"], {raw: {value: Object.freeze(["(typeof ", " === 'undefined' ?\n          'undefined' : ", ")"])}}));
var $__333 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    BinaryOperator = $__333.BinaryOperator,
    MemberLookupExpression = $__333.MemberLookupExpression,
    UnaryExpression = $__333.UnaryExpression;
var ExplodeExpressionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ExplodeExpressionTransformer")).ExplodeExpressionTransformer;
var $__333 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    IDENTIFIER_EXPRESSION = $__333.IDENTIFIER_EXPRESSION,
    LITERAL_EXPRESSION = $__333.LITERAL_EXPRESSION,
    MEMBER_LOOKUP_EXPRESSION = $__333.MEMBER_LOOKUP_EXPRESSION,
    UNARY_EXPRESSION = $__333.UNARY_EXPRESSION;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__333 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    EQUAL = $__333.EQUAL,
    EQUAL_EQUAL = $__333.EQUAL_EQUAL,
    EQUAL_EQUAL_EQUAL = $__333.EQUAL_EQUAL_EQUAL,
    IN = $__333.IN,
    NOT_EQUAL = $__333.NOT_EQUAL,
    NOT_EQUAL_EQUAL = $__333.NOT_EQUAL_EQUAL,
    STRING = $__333.STRING,
    TYPEOF = $__333.TYPEOF;
var createParenExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")).createParenExpression;
var parseExpression = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseExpression;
var ExplodeSymbolExpression = function ExplodeSymbolExpression() {
  $traceurRuntime.defaultSuperCall(this, $ExplodeSymbolExpression.prototype, arguments);
};
var $ExplodeSymbolExpression = ExplodeSymbolExpression;
($traceurRuntime.createClass)(ExplodeSymbolExpression, {
  transformArrowFunctionExpression: function(tree) {
    return tree;
  },
  transformClassExpression: function(tree) {
    return tree;
  },
  transformFunctionBody: function(tree) {
    return tree;
  }
}, {}, ExplodeExpressionTransformer);
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 SymbolTransformer() {
  $traceurRuntime.defaultSuperCall(this, $SymbolTransformer.prototype, arguments);
};
var $SymbolTransformer = SymbolTransformer;
($traceurRuntime.createClass)(SymbolTransformer, {
  transformTypeofOperand_: function(tree) {
    var operand = this.transformAny(tree.operand);
    return new UnaryExpression(tree.location, tree.operator, operand);
  },
  transformBinaryOperator: function(tree) {
    if (tree.operator.type === IN) {
      var name = this.transformAny(tree.left);
      var object = this.transformAny(tree.right);
      if (name.type === LITERAL_EXPRESSION)
        return new BinaryOperator(tree.location, name, tree.operator, object);
      return parseExpression($__327, name, object);
    }
    if (isEqualityExpression(tree)) {
      if (isTypeof(tree.left) && isSafeTypeofString(tree.right)) {
        var left = this.transformTypeofOperand_(tree.left);
        var right = tree.right;
        return new BinaryOperator(tree.location, left, tree.operator, right);
      }
      if (isTypeof(tree.right) && isSafeTypeofString(tree.left)) {
        var left = tree.left;
        var right = this.transformTypeofOperand_(tree.right);
        return new BinaryOperator(tree.location, left, tree.operator, right);
      }
    }
    if (tree.left.type === MEMBER_LOOKUP_EXPRESSION && tree.operator.isAssignmentOperator()) {
      if (tree.operator.type !== EQUAL) {
        var exploded = new ExplodeSymbolExpression(this).transformAny(tree);
        return this.transformAny(createParenExpression(exploded));
      }
      var operand = this.transformAny(tree.left.operand);
      var memberExpression = this.transformAny(tree.left.memberExpression);
      var value = this.transformAny(tree.right);
      return parseExpression($__328, operand, memberExpression, value);
    }
    return $traceurRuntime.superCall(this, $SymbolTransformer.prototype, "transformBinaryOperator", [tree]);
  },
  transformMemberLookupExpression: function(tree) {
    var operand = this.transformAny(tree.operand);
    var memberExpression = this.transformAny(tree.memberExpression);
    if (memberExpression.type === LITERAL_EXPRESSION && memberExpression.literalToken.type !== STRING) {
      return new MemberLookupExpression(tree.location, operand, memberExpression);
    }
    return parseExpression($__329, operand, memberExpression);
  },
  transformUnaryExpression: function(tree) {
    if (tree.operator.type !== TYPEOF)
      return $traceurRuntime.superCall(this, $SymbolTransformer.prototype, "transformUnaryExpression", [tree]);
    var operand = this.transformAny(tree.operand);
    var expression = parseExpression($__330, operand);
    if (operand.type === IDENTIFIER_EXPRESSION) {
      return parseExpression($__331, operand, expression);
    }
    return expression;
  }
}, {}, TempVarTransformer);
return {get SymbolTransformer() {
    return SymbolTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/TemplateLiteralTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/TemplateLiteralTransformer";
var $__335 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BINARY_OPERATOR = $__335.BINARY_OPERATOR,
    COMMA_EXPRESSION = $__335.COMMA_EXPRESSION,
    CONDITIONAL_EXPRESSION = $__335.CONDITIONAL_EXPRESSION,
    TEMPLATE_LITERAL_PORTION = $__335.TEMPLATE_LITERAL_PORTION;
var $__335 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    LiteralExpression = $__335.LiteralExpression,
    ParenExpression = $__335.ParenExpression;
var LiteralToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/LiteralToken")).LiteralToken;
var $__335 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/PredefinedName")),
    DEFINE_PROPERTIES = $__335.DEFINE_PROPERTIES,
    OBJECT = $__335.OBJECT,
    RAW = $__335.RAW;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var TempVarTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TempVarTransformer")).TempVarTransformer;
var $__335 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")),
    PERCENT = $__335.PERCENT,
    PLUS = $__335.PLUS,
    SLASH = $__335.SLASH,
    STAR = $__335.STAR,
    STRING = $__335.STRING;
var $__335 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArgumentList = $__335.createArgumentList,
    createArrayLiteralExpression = $__335.createArrayLiteralExpression,
    createBinaryOperator = $__335.createBinaryOperator,
    createCallExpression = $__335.createCallExpression,
    createIdentifierExpression = $__335.createIdentifierExpression,
    createMemberExpression = $__335.createMemberExpression,
    createObjectFreeze = $__335.createObjectFreeze,
    createObjectLiteralExpression = $__335.createObjectLiteralExpression,
    createOperatorToken = $__335.createOperatorToken,
    createPropertyDescriptor = $__335.createPropertyDescriptor,
    createPropertyNameAssignment = $__335.createPropertyNameAssignment,
    createStringLiteral = $__335.createStringLiteral;
function createCallSiteIdObject(tree) {
  var elements = tree.elements;
  return createObjectFreeze(createCallExpression(createMemberExpression(OBJECT, DEFINE_PROPERTIES), createArgumentList(createCookedStringArray(elements), createObjectLiteralExpression(createPropertyNameAssignment(RAW, createPropertyDescriptor({value: createObjectFreeze(createRawStringArray(elements))}))))));
}
function maybeAddEmptyStringAtEnd(elements, items) {
  var length = elements.length;
  if (!length || elements[length - 1].type !== TEMPLATE_LITERAL_PORTION)
    items.push(createStringLiteral(''));
}
function createRawStringArray(elements) {
  var items = [];
  for (var i = 0; i < elements.length; i += 2) {
    var str = replaceRaw(JSON.stringify(elements[i].value.value));
    var loc = elements[i].location;
    var expr = new LiteralExpression(loc, new LiteralToken(STRING, str, loc));
    items.push(expr);
  }
  maybeAddEmptyStringAtEnd(elements, items);
  return createArrayLiteralExpression(items);
}
function createCookedStringLiteralExpression(tree) {
  var str = cookString(tree.value.value);
  var loc = tree.location;
  return new LiteralExpression(loc, new LiteralToken(STRING, str, loc));
}
function createCookedStringArray(elements) {
  var items = [];
  for (var i = 0; i < elements.length; i += 2) {
    items.push(createCookedStringLiteralExpression(elements[i]));
  }
  maybeAddEmptyStringAtEnd(elements, items);
  return createArrayLiteralExpression(items);
}
function replaceRaw(s) {
  return s.replace(/\u2028|\u2029/g, function(c) {
    switch (c) {
      case '\u2028':
        return '\\u2028';
      case '\u2029':
        return '\\u2029';
      default:
        throw Error('Not reachable');
    }
  });
}
function cookString(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':
        sb[k++] = '\\r';
        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 TemplateLiteralTransformer() {
  $traceurRuntime.defaultSuperCall(this, $TemplateLiteralTransformer.prototype, arguments);
};
var $TemplateLiteralTransformer = TemplateLiteralTransformer;
($traceurRuntime.createClass)(TemplateLiteralTransformer, {
  transformFunctionBody: function(tree) {
    return ParseTreeTransformer.prototype.transformFunctionBody.call(this, tree);
  },
  transformTemplateLiteralExpression: function(tree) {
    if (!tree.operand)
      return this.createDefaultTemplateLiteral(tree);
    var operand = this.transformAny(tree.operand);
    var elements = tree.elements;
    var callsiteIdObject = createCallSiteIdObject(tree);
    var idName = this.addTempVar(callsiteIdObject);
    var args = [createIdentifierExpression(idName)];
    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_OPERATOR:
        switch (transformedTree.operator.type) {
          case STAR:
          case PERCENT:
          case SLASH:
            return transformedTree;
        }
      case COMMA_EXPRESSION:
      case CONDITIONAL_EXPRESSION:
        return new ParenExpression(null, transformedTree);
    }
    return transformedTree;
  },
  transformTemplateLiteralPortion: function(tree) {
    return createCookedStringLiteralExpression(tree);
  },
  createDefaultTemplateLiteral: function(tree) {
    var length = tree.elements.length;
    if (length === 0) {
      var loc = tree.location;
      return new LiteralExpression(loc, new LiteralToken(STRING, '""', loc));
    }
    var firstNonEmpty = tree.elements[0].value.value === '' ? -1 : 0;
    var binaryExpression = this.transformAny(tree.elements[0]);
    if (length == 1)
      return binaryExpression;
    var plusToken = createOperatorToken(PLUS);
    for (var i = 1; i < length; i++) {
      var element = tree.elements[i];
      if (element.type === TEMPLATE_LITERAL_PORTION) {
        if (element.value.value === '')
          continue;
        else if (firstNonEmpty < 0 && i === 2)
          binaryExpression = binaryExpression.right;
      }
      var transformedTree = this.transformAny(tree.elements[i]);
      binaryExpression = createBinaryOperator(binaryExpression, plusToken, transformedTree);
    }
    return new ParenExpression(null, binaryExpression);
  }
}, {}, TempVarTransformer);
return {get TemplateLiteralTransformer() {
    return TemplateLiteralTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/TypeAssertionTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/TypeAssertionTransformer";
var $__336 = Object.freeze(Object.defineProperties(["assert.type(", ", ", ")"], {raw: {value: Object.freeze(["assert.type(", ", ", ")"])}})),
    $__337 = Object.freeze(Object.defineProperties(["assert.argumentTypes(", ")"], {raw: {value: Object.freeze(["assert.argumentTypes(", ")"])}})),
    $__338 = Object.freeze(Object.defineProperties(["return assert.returnType((", "), ", ")"], {raw: {value: Object.freeze(["return assert.returnType((", "), ", ")"])}})),
    $__339 = Object.freeze(Object.defineProperties(["$traceurRuntime.type.any"], {raw: {value: Object.freeze(["$traceurRuntime.type.any"])}}));
var $__341 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTreeType")),
    BINDING_ELEMENT = $__341.BINDING_ELEMENT,
    REST_PARAMETER = $__341.REST_PARAMETER;
var $__341 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    ImportDeclaration = $__341.ImportDeclaration,
    ImportSpecifier = $__341.ImportSpecifier,
    ImportSpecifierSet = $__341.ImportSpecifierSet,
    Module = $__341.Module,
    ModuleSpecifier = $__341.ModuleSpecifier,
    ReturnStatement = $__341.ReturnStatement,
    Script = $__341.Script,
    VariableDeclaration = $__341.VariableDeclaration;
var $__341 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createArgumentList = $__341.createArgumentList,
    createExpressionStatement = $__341.createExpressionStatement,
    createIdentifierExpression = $__341.createIdentifierExpression,
    createIdentifierToken = $__341.createIdentifierToken,
    createStringLiteralToken = $__341.createStringLiteralToken;
var $__341 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")),
    parseExpression = $__341.parseExpression,
    parseStatement = $__341.parseStatement;
var ParameterTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParameterTransformer")).ParameterTransformer;
var options = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).options;
var TypeAssertionTransformer = function TypeAssertionTransformer(identifierGenerator) {
  $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "constructor", [identifierGenerator]);
  this.returnTypeStack_ = [];
  this.parametersStack_ = [];
  this.assertionAdded_ = false;
};
var $TypeAssertionTransformer = TypeAssertionTransformer;
($traceurRuntime.createClass)(TypeAssertionTransformer, {
  transformScript: function(tree) {
    return this.prependAssertionImport_($traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformScript", [tree]), Script);
  },
  transformModule: function(tree) {
    return this.prependAssertionImport_($traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformModule", [tree]), Module);
  },
  transformVariableDeclaration: function(tree) {
    if (tree.typeAnnotation && tree.initializer) {
      var assert = parseExpression($__336, tree.initializer, tree.typeAnnotation);
      tree = new VariableDeclaration(tree.location, tree.lvalue, tree.typeAnnotation, assert);
      this.assertionAdded_ = true;
    }
    return $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformVariableDeclaration", [tree]);
  },
  transformFormalParameterList: function(tree) {
    this.parametersStack_.push({
      atLeastOneParameterTyped: false,
      arguments: []
    });
    var transformed = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFormalParameterList", [tree]);
    var params = this.parametersStack_.pop();
    if (params.atLeastOneParameterTyped) {
      var argumentList = createArgumentList(params.arguments);
      var assertStatement = parseStatement($__337, argumentList);
      this.parameterStatements.push(assertStatement);
      this.assertionAdded_ = true;
    }
    return transformed;
  },
  transformFormalParameter: function(tree) {
    var transformed = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFormalParameter", [tree]);
    switch (transformed.parameter.type) {
      case BINDING_ELEMENT:
        this.transformBindingElementParameter_(transformed.parameter, transformed.typeAnnotation);
        break;
      case REST_PARAMETER:
        break;
    }
    return transformed;
  },
  transformGetAccessor: function(tree) {
    this.pushReturnType_(tree.typeAnnotation);
    tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformGetAccessor", [tree]);
    this.popReturnType_();
    return tree;
  },
  transformPropertyMethodAssignment: function(tree) {
    this.pushReturnType_(tree.typeAnnotation);
    tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformPropertyMethodAssignment", [tree]);
    this.popReturnType_();
    return tree;
  },
  transformFunctionDeclaration: function(tree) {
    this.pushReturnType_(tree.typeAnnotation);
    tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFunctionDeclaration", [tree]);
    this.popReturnType_();
    return tree;
  },
  transformFunctionExpression: function(tree) {
    this.pushReturnType_(tree.typeAnnotation);
    tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformFunctionExpression", [tree]);
    this.popReturnType_();
    return tree;
  },
  transformReturnStatement: function(tree) {
    tree = $traceurRuntime.superCall(this, $TypeAssertionTransformer.prototype, "transformReturnStatement", [tree]);
    if (this.returnType_ && tree.expression) {
      this.assertionAdded_ = true;
      return parseStatement($__338, tree.expression, this.returnType_);
    }
    return tree;
  },
  transformBindingElementParameter_: function(element, typeAnnotation) {
    if (!element.binding.isPattern()) {
      if (typeAnnotation) {
        this.paramTypes_.atLeastOneParameterTyped = true;
      } else {
        typeAnnotation = parseExpression($__339);
      }
      this.paramTypes_.arguments.push(createIdentifierExpression(element.binding.identifierToken), typeAnnotation);
      return;
    }
  },
  pushReturnType_: function(typeAnnotation) {
    this.returnTypeStack_.push(this.transformAny(typeAnnotation));
  },
  prependAssertionImport_: function(tree, Ctor) {
    if (!this.assertionAdded_ || options.typeAssertionModule === null)
      return tree;
    var importStatement = new ImportDeclaration(null, new ImportSpecifierSet(null, [new ImportSpecifier(null, createIdentifierToken('assert'), null)]), new ModuleSpecifier(null, createStringLiteralToken(options.typeAssertionModule)));
    tree = new Ctor(tree.location, $traceurRuntime.spread([importStatement], tree.scriptItemList), tree.moduleName);
    return tree;
  },
  popReturnType_: function() {
    return this.returnTypeStack_.pop();
  },
  get returnType_() {
    return this.returnTypeStack_.length > 0 ? this.returnTypeStack_[this.returnTypeStack_.length - 1] : null;
  },
  get paramTypes_() {
    return this.parametersStack_[this.parametersStack_.length - 1];
  }
}, {}, ParameterTransformer);
return {get TypeAssertionTransformer() {
    return TypeAssertionTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/TypeToExpressionTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/TypeToExpressionTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__343 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeFactory")),
    createIdentifierExpression = $__343.createIdentifierExpression,
    createMemberExpression = $__343.createMemberExpression;
var TypeToExpressionTransformer = function TypeToExpressionTransformer() {
  $traceurRuntime.defaultSuperCall(this, $TypeToExpressionTransformer.prototype, arguments);
};
var $TypeToExpressionTransformer = TypeToExpressionTransformer;
($traceurRuntime.createClass)(TypeToExpressionTransformer, {
  transformTypeName: function(tree) {
    return createIdentifierExpression(tree.name);
  },
  transformPredefinedType: function(tree) {
    return createMemberExpression('$traceurRuntime', 'type', tree.typeToken);
  }
}, {}, ParseTreeTransformer);
return {get TypeToExpressionTransformer() {
    return TypeToExpressionTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/TypeTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/TypeTransformer";
var $__345 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    FormalParameter = $__345.FormalParameter,
    FunctionDeclaration = $__345.FunctionDeclaration,
    FunctionExpression = $__345.FunctionExpression,
    GetAccessor = $__345.GetAccessor,
    PropertyMethodAssignment = $__345.PropertyMethodAssignment,
    VariableDeclaration = $__345.VariableDeclaration;
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var TypeTransformer = function TypeTransformer() {
  $traceurRuntime.defaultSuperCall(this, $TypeTransformer.prototype, arguments);
};
var $TypeTransformer = TypeTransformer;
($traceurRuntime.createClass)(TypeTransformer, {
  transformVariableDeclaration: function(tree) {
    if (tree.typeAnnotation) {
      tree = new VariableDeclaration(tree.location, tree.lvalue, null, tree.initializer);
    }
    return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformVariableDeclaration", [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.functionBody);
    }
    return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformFunctionDeclaration", [tree]);
  },
  transformFunctionExpression: function(tree) {
    if (tree.typeAnnotation) {
      tree = new FunctionExpression(tree.location, tree.name, tree.functionKind, tree.parameterList, null, tree.annotations, tree.functionBody);
    }
    return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformFunctionExpression", [tree]);
  },
  transformPropertyMethodAssignment: function(tree) {
    if (tree.typeAnnotation) {
      tree = new PropertyMethodAssignment(tree.location, tree.isStatic, tree.functionKind, tree.name, tree.parameterList, null, tree.annotations, tree.functionBody);
    }
    return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformPropertyMethodAssignment", [tree]);
  },
  transformGetAccessor: function(tree) {
    if (tree.typeAnnotation) {
      tree = new GetAccessor(tree.location, tree.isStatic, tree.name, null, tree.annotations, tree.body);
    }
    return $traceurRuntime.superCall(this, $TypeTransformer.prototype, "transformGetAccessor", [tree]);
  }
}, {}, ParseTreeTransformer);
return {get TypeTransformer() {
    return TypeTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/UniqueIdentifierGenerator”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/UniqueIdentifierGenerator";
var UniqueIdentifierGenerator = function UniqueIdentifierGenerator() {
  this.identifierIndex = 0;
};
($traceurRuntime.createClass)(UniqueIdentifierGenerator, {generateUniqueIdentifier: function() {
    return ("$__" + this.identifierIndex++);
  }}, {});
return {get UniqueIdentifierGenerator() {
    return UniqueIdentifierGenerator;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/FromOptionsTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/FromOptionsTransformer";
var AmdTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AmdTransformer")).AmdTransformer;
var AnnotationsTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AnnotationsTransformer")).AnnotationsTransformer;
var ArrayComprehensionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ArrayComprehensionTransformer")).ArrayComprehensionTransformer;
var ArrowFunctionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ArrowFunctionTransformer")).ArrowFunctionTransformer;
var BlockBindingTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/BlockBindingTransformer")).BlockBindingTransformer;
var ClassTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ClassTransformer")).ClassTransformer;
var CommonJsModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/CommonJsModuleTransformer")).CommonJsModuleTransformer;
var DefaultParametersTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/DefaultParametersTransformer")).DefaultParametersTransformer;
var DestructuringTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/DestructuringTransformer")).DestructuringTransformer;
var ForOfTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ForOfTransformer")).ForOfTransformer;
var FreeVariableChecker = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/semantics/FreeVariableChecker")).FreeVariableChecker;
var GeneratorComprehensionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/GeneratorComprehensionTransformer")).GeneratorComprehensionTransformer;
var GeneratorTransformPass = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/GeneratorTransformPass")).GeneratorTransformPass;
var InlineModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/InlineModuleTransformer")).InlineModuleTransformer;
var ModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ModuleTransformer")).ModuleTransformer;
var MultiTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/MultiTransformer")).MultiTransformer;
var NumericLiteralTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/NumericLiteralTransformer")).NumericLiteralTransformer;
var ObjectLiteralTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ObjectLiteralTransformer")).ObjectLiteralTransformer;
var ObjectMap = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ObjectMap")).ObjectMap;
var ParseTreeValidator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeValidator")).ParseTreeValidator;
var PropertyNameShorthandTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PropertyNameShorthandTransformer")).PropertyNameShorthandTransformer;
var InstantiateModuleTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/InstantiateModuleTransformer")).InstantiateModuleTransformer;
var RestParameterTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/RestParameterTransformer")).RestParameterTransformer;
var SpreadTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/SpreadTransformer")).SpreadTransformer;
var SymbolTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/SymbolTransformer")).SymbolTransformer;
var TemplateLiteralTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TemplateLiteralTransformer")).TemplateLiteralTransformer;
var TypeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TypeTransformer")).TypeTransformer;
var TypeAssertionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TypeAssertionTransformer")).TypeAssertionTransformer;
var TypeToExpressionTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TypeToExpressionTransformer")).TypeToExpressionTransformer;
var UniqueIdentifierGenerator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/UniqueIdentifierGenerator")).UniqueIdentifierGenerator;
var $__349 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")),
    options = $__349.options,
    transformOptions = $__349.transformOptions;
var FromOptionsTransformer = function FromOptionsTransformer(reporter) {
  var idGenerator = arguments[1] !== (void 0) ? arguments[1] : new UniqueIdentifierGenerator();
  var $__347 = this;
  $traceurRuntime.superCall(this, $FromOptionsTransformer.prototype, "constructor", [reporter, options.validate]);
  var append = (function(transformer) {
    $__347.append((function(tree) {
      return new transformer(idGenerator, reporter).transformAny(tree);
    }));
  });
  if (transformOptions.numericLiterals)
    append(NumericLiteralTransformer);
  if (transformOptions.templateLiterals)
    append(TemplateLiteralTransformer);
  if (options.types) {
    append(TypeToExpressionTransformer);
  }
  if (transformOptions.annotations)
    append(AnnotationsTransformer);
  if (options.typeAssertions)
    append(TypeAssertionTransformer);
  if (transformOptions.modules) {
    switch (transformOptions.modules) {
      case 'commonjs':
        append(CommonJsModuleTransformer);
        break;
      case 'amd':
        append(AmdTransformer);
        break;
      case 'inline':
        append(InlineModuleTransformer);
        break;
      case 'instantiate':
        append(InstantiateModuleTransformer);
        break;
      case 'register':
        append(ModuleTransformer);
        break;
      default:
        throw new Error('Invalid modules transform option');
    }
  }
  if (transformOptions.arrowFunctions)
    append(ArrowFunctionTransformer);
  if (transformOptions.classes)
    append(ClassTransformer);
  if (transformOptions.propertyNameShorthand)
    append(PropertyNameShorthandTransformer);
  if (transformOptions.propertyMethods || transformOptions.computedPropertyNames) {
    append(ObjectLiteralTransformer);
  }
  if (transformOptions.generatorComprehension)
    append(GeneratorComprehensionTransformer);
  if (transformOptions.arrayComprehension)
    append(ArrayComprehensionTransformer);
  if (transformOptions.forOf)
    append(ForOfTransformer);
  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)
    append(BlockBindingTransformer);
  if (transformOptions.generators || transformOptions.asyncFuntions)
    append(GeneratorTransformPass);
  if (transformOptions.symbols)
    append(SymbolTransformer);
  if (options.freeVariableChecker) {
    this.append((function(tree) {
      FreeVariableChecker.checkScript(reporter, tree);
      return tree;
    }));
  }
};
var $FromOptionsTransformer = FromOptionsTransformer;
($traceurRuntime.createClass)(FromOptionsTransformer, {}, {}, MultiTransformer);
return {get FromOptionsTransformer() {
    return FromOptionsTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/module/AttachModuleNameTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/AttachModuleNameTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__351 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    Module = $__351.Module,
    Script = $__351.Script;
var AttachModuleNameTransformer = function AttachModuleNameTransformer(moduleName) {
  this.moduleName_ = moduleName;
};
($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_);
  }
}, {}, ParseTreeTransformer);
return {get AttachModuleNameTransformer() {
    return AttachModuleNameTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/module/ValidationVisitor”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/ValidationVisitor";
var ModuleVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ModuleVisitor")).ModuleVisitor;
var ValidationVisitor = function ValidationVisitor() {
  $traceurRuntime.defaultSuperCall(this, $ValidationVisitor.prototype, arguments);
};
var $ValidationVisitor = ValidationVisitor;
($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.getModuleDescriptionForModuleSpecifier(name);
      this.visitAndValidate_(moduleDescription, tree.specifierSet);
    }
  },
  visitExportSpecifier: function(tree) {
    this.checkExport_(tree, tree.lhs.value);
  },
  visitImportDeclaration: function(tree) {
    var name = tree.moduleSpecifier.token.processedValue;
    var moduleDescription = this.getModuleDescriptionForModuleSpecifier(name);
    this.visitAndValidate_(moduleDescription, tree.importClause);
  },
  visitImportSpecifier: function(tree) {
    var importName = tree.rhs ? tree.rhs.value : tree.lhs.value;
    this.checkImport_(tree, importName);
    this.checkExport_(tree, tree.lhs.value);
  },
  visitImportedBinding: function(tree) {
    var importName = tree.binding.identifierToken.value;
    this.checkImport_(tree, importName);
    this.checkExport_(tree, 'default');
  }
}, {}, ModuleVisitor);
return {get ValidationVisitor() {
    return ValidationVisitor;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/module/ExportListBuilder”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/ExportListBuilder";
var ExportVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ExportVisitor")).ExportVisitor;
var ValidationVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ValidationVisitor")).ValidationVisitor;
var transformOptions = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).transformOptions;
var ExportListBuilder = function ExportListBuilder(reporter) {
  this.reporter_ = reporter;
};
($traceurRuntime.createClass)(ExportListBuilder, {buildExportList: function(deps, loader) {
    if (!transformOptions.modules)
      return;
    var reporter = this.reporter_;
    function doVisit(ctor) {
      for (var i = 0; i < deps.length; i++) {
        var visitor = new ctor(reporter, loader, deps[i].moduleSymbol);
        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].moduleSymbol);
        visitor.visitAny(deps[i].tree);
      }
    }
    reverseVisit(ExportVisitor);
    doVisit(ValidationVisitor);
  }}, {});
return {get ExportListBuilder() {
    return ExportListBuilder;
  }};

}); System.register(“traceur@0.0.43/src/util/url”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/url";
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;
  }
};

}); System.register(“traceur@0.0.43/src/codegeneration/module/ModuleSpecifierVisitor”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/ModuleSpecifierVisitor";
var ParseTreeVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/ParseTreeVisitor")).ParseTreeVisitor;
var STRING = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/TokenType")).STRING;
var LiteralToken = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/LiteralToken")).LiteralToken;
var canonicalizeUrl = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/url")).canonicalizeUrl;
var options = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).options;
var ModuleSpecifierVisitor = function ModuleSpecifierVisitor(reporter) {
  $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "constructor", []);
  this.moduleSpecifiers_ = Object.create(null);
};
var $ModuleSpecifierVisitor = ModuleSpecifierVisitor;
($traceurRuntime.createClass)(ModuleSpecifierVisitor, {
  get moduleSpecifiers() {
    return Object.keys(this.moduleSpecifiers_);
  },
  visitModuleSpecifier: function(tree) {
    this.moduleSpecifiers_[tree.token.processedValue] = true;
  },
  visitVariableDeclaration: function(tree) {
    this.addTypeAssertionDependency_(tree.typeAnnotation);
    return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitVariableDeclaration", [tree]);
  },
  visitFormalParameter: function(tree) {
    this.addTypeAssertionDependency_(tree.typeAnnotation);
    return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitFormalParameter", [tree]);
  },
  visitGetAccessor: function(tree) {
    this.addTypeAssertionDependency_(tree.typeAnnotation);
    return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitGetAccessor", [tree]);
  },
  visitPropertyMethodAssignment: function(tree) {
    this.addTypeAssertionDependency_(tree.typeAnnotation);
    return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitPropertyMethodAssignment", [tree]);
  },
  visitFunctionDeclaration: function(tree) {
    this.addTypeAssertionDependency_(tree.typeAnnotation);
    return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitFunctionDeclaration", [tree]);
  },
  visitFunctionExpression: function(tree) {
    this.addTypeAssertionDependency_(tree.typeAnnotation);
    return $traceurRuntime.superCall(this, $ModuleSpecifierVisitor.prototype, "visitFunctionExpression", [tree]);
  },
  addTypeAssertionDependency_: function(typeAnnotation) {
    if (typeAnnotation !== null && options.typeAssertionModule !== null)
      this.moduleSpecifiers_[options.typeAssertionModule] = true;
  }
}, {}, ParseTreeVisitor);
return {get ModuleSpecifierVisitor() {
    return ModuleSpecifierVisitor;
  }};

}); System.register(“traceur@0.0.43/src/runtime/system-map”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/system-map";
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;
  }};

}); System.register(“traceur@0.0.43/src/runtime/webLoader”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/webLoader";
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;
  }};

}); System.register(“traceur@0.0.43/src/runtime/LoaderHooks”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/LoaderHooks";
var AttachModuleNameTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/AttachModuleNameTransformer")).AttachModuleNameTransformer;
var FromOptionsTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FromOptionsTransformer")).FromOptionsTransformer;
var ExportListBuilder = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ExportListBuilder")).ExportListBuilder;
var ModuleSpecifierVisitor = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ModuleSpecifierVisitor")).ModuleSpecifierVisitor;
var ModuleSymbol = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/ModuleSymbol")).ModuleSymbol;
var Parser = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Parser")).Parser;
var options = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).options;
var SourceFile = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/SourceFile")).SourceFile;
var systemjs = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/system-map")).systemjs;
var UniqueIdentifierGenerator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/UniqueIdentifierGenerator")).UniqueIdentifierGenerator;
var $__360 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/url")),
    isAbsolute = $__360.isAbsolute,
    resolveUrl = $__360.resolveUrl;
var webLoader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/webLoader")).webLoader;
var assert = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/assert")).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 LoaderHooks = function LoaderHooks(reporter, baseURL) {
  var fileLoader = arguments[2] !== (void 0) ? arguments[2] : webLoader;
  var moduleStore = arguments[3] !== (void 0) ? arguments[3] : $traceurRuntime.ModuleStore;
  this.reporter = reporter;
  this.baseURL_ = baseURL;
  this.moduleStore_ = moduleStore;
  this.fileLoader = fileLoader;
  this.exportListBuilder_ = new ExportListBuilder(this.reporter);
};
($traceurRuntime.createClass)(LoaderHooks, {
  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 (System.map)
      return systemjs.applyMap(System.map, normalizedName, referrerName);
    else
      return normalizedName;
  },
  get baseURL() {
    return this.baseURL_;
  },
  set baseURL(value) {
    this.baseURL_ = String(value);
  },
  getModuleSpecifiers: function(codeUnit) {
    if (!this.parse(codeUnit))
      return;
    codeUnit.state = PARSED;
    var moduleSpecifierVisitor = new ModuleSpecifierVisitor(this.reporter);
    moduleSpecifierVisitor.visit(codeUnit.metadata.tree);
    return moduleSpecifierVisitor.moduleSpecifiers;
  },
  parse: function(codeUnit) {
    assert(!codeUnit.metadata.tree);
    var reporter = this.reporter;
    var normalizedName = codeUnit.normalizedName;
    var program = codeUnit.source;
    var url = codeUnit.url || normalizedName;
    var file = new SourceFile(url, program);
    var parser = new Parser(file, reporter);
    if (codeUnit.type == 'module')
      codeUnit.metadata.tree = parser.parseModule();
    else
      codeUnit.metadata.tree = parser.parseScript();
    codeUnit.metadata.moduleSymbol = new ModuleSymbol(codeUnit.metadata.tree, normalizedName);
    return !reporter.hadError();
  },
  transform: function(codeUnit) {
    var transformer = new AttachModuleNameTransformer(codeUnit.normalizedName);
    var transformedTree = transformer.transformAny(codeUnit.metadata.tree);
    transformer = new FromOptionsTransformer(this.reporter, identifierGenerator);
    return transformer.transform(transformedTree);
  },
  fetch: function(load) {
    var $__358 = 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
        $__358.fileLoader.load(load.address, resolve, reject);
    }));
  },
  translate: function(load) {
    return new Promise((function(resolve, reject) {
      resolve(load.source);
    }));
  },
  instantiate: function($__360) {
    var name = $__360.name,
        metadata = $__360.metadata,
        address = $__360.address,
        source = $__360.source,
        sourceMap = $__360.sourceMap;
    return new Promise((function(resolve, reject) {
      resolve(undefined);
    }));
  },
  locate: function(load) {
    load.url = this.locate_(load);
    return load.url;
  },
  locate_: function(load) {
    var normalizedModuleName = load.normalizedName;
    var asJS;
    if (load.type === 'script') {
      asJS = normalizedModuleName;
    } else {
      asJS = normalizedModuleName + '.js';
    }
    if (options.referrer) {
      if (asJS.indexOf(options.referrer) === 0) {
        asJS = asJS.slice(options.referrer.length);
        load.metadata.locateMap = {
          pattern: options.referrer,
          replacement: ''
        };
      }
    }
    if (isAbsolute(asJS))
      return asJS;
    var baseURL = load.metadata && load.metadata.baseURL;
    baseURL = baseURL || this.baseURL;
    if (baseURL) {
      load.metadata.baseURL = baseURL;
      return resolveUrl(baseURL, asJS);
    }
    return asJS;
  },
  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 ("LoaderHooks.locate found \'" + map.pattern + "\' -> \'" + map.replacement + "\'\n");
  },
  baseURLTrace: function(base) {
    return 'LoaderHooks.locate resolved against base \'' + base + '\'\n';
  },
  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) {
        deps.push(codeUnit.metadata);
      }
    }
    this.exportListBuilder_.buildExportList(deps, loader);
  },
  get options() {
    return options;
  },
  bundledModule: function(name) {
    return this.moduleStore_.bundleStore[name];
  }
}, {});
return {get LoaderHooks() {
    return LoaderHooks;
  }};

}); System.register(“traceur@0.0.43/src/runtime/InterceptOutputLoaderHooks”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/InterceptOutputLoaderHooks";
var LoaderHooks = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/LoaderHooks")).LoaderHooks;
var InterceptOutputLoaderHooks = function InterceptOutputLoaderHooks() {
  for (var args = [],
      $__362 = 0; $__362 < arguments.length; $__362++)
    args[$__362] = arguments[$__362];
  $traceurRuntime.superCall(this, $InterceptOutputLoaderHooks.prototype, "constructor", $traceurRuntime.spread(args));
  this.sourceMap = null;
  this.transcoded = null;
  this.onTranscoded = (function() {});
};
var $InterceptOutputLoaderHooks = InterceptOutputLoaderHooks;
($traceurRuntime.createClass)(InterceptOutputLoaderHooks, {instantiate: function($__363) {
    var metadata = $__363.metadata,
        url = $__363.url;
    this.sourceMap = metadata.sourceMap;
    this.transcoded = metadata.transcoded;
    this.onTranscoded(metadata, url);
    return undefined;
  }}, {}, LoaderHooks);
return {get InterceptOutputLoaderHooks() {
    return InterceptOutputLoaderHooks;
  }};

}); System.register(“traceur@0.0.43/src/runtime/InternalLoader”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/InternalLoader";
var ArrayMap = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ArrayMap")).ArrayMap;
var LoaderHooks = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/LoaderHooks")).LoaderHooks;
var ObjectMap = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ObjectMap")).ObjectMap;
var $__366 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/url")),
    canonicalizeUrl = $__366.canonicalizeUrl,
    isAbsolute = $__366.isAbsolute,
    resolveUrl = $__366.resolveUrl;
var getUid = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/uid")).getUid;
var toSource = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/toSource")).toSource;
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 global = this;
var CodeUnit = function CodeUnit(loaderHooks, normalizedName, type, state, name, referrerName, address) {
  var $__364 = this;
  this.promise = new Promise((function(res, rej) {
    $__364.loaderHooks = loaderHooks;
    $__364.normalizedName = normalizedName;
    $__364.type = type;
    $__364.name_ = name;
    $__364.referrerName_ = referrerName;
    $__364.address = address;
    $__364.url = InternalLoader.uniqueName(normalizedName, address);
    $__364.uid = getUid();
    $__364.state_ = state || NOT_STARTED;
    $__364.error = null;
    $__364.result = null;
    $__364.data_ = {};
    $__364.dependencies = [];
    $__364.resolve = res;
    $__364.reject = rej;
  }));
};
($traceurRuntime.createClass)(CodeUnit, {
  get state() {
    return this.state_;
  },
  set state(state) {
    if (state < this.state_) {
      throw new Error('Invalid state change');
    }
    this.state_ = state;
  },
  get metadata() {
    return this.data_;
  },
  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';
  },
  transform: function() {
    return this.loaderHooks.transform(this);
  },
  instantiate: function(load) {
    return this.loaderHooks.instantiate(this);
  }
}, {});
var PreCompiledCodeUnit = function PreCompiledCodeUnit(loaderHooks, normalizedName, name, referrerName, address, module) {
  $traceurRuntime.superCall(this, $PreCompiledCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, 'module', COMPLETE, name, referrerName, address]);
  this.result = module;
  this.resolve(this.result);
};
var $PreCompiledCodeUnit = PreCompiledCodeUnit;
($traceurRuntime.createClass)(PreCompiledCodeUnit, {}, {}, CodeUnit);
var BundledCodeUnit = function BundledCodeUnit(loaderHooks, normalizedName, name, referrerName, address, deps, execute) {
  $traceurRuntime.superCall(this, $BundledCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, 'module', TRANSFORMED, name, referrerName, address]);
  this.deps = deps;
  this.execute = execute;
};
var $BundledCodeUnit = BundledCodeUnit;
($traceurRuntime.createClass)(BundledCodeUnit, {
  getModuleSpecifiers: function() {
    return this.deps;
  },
  evaluate: function() {
    var $__364 = this;
    var normalizedNames = this.deps.map((function(name) {
      return $__364.loaderHooks.normalize(name);
    }));
    var module = this.execute.apply(global, normalizedNames);
    System.set(this.normalizedName, module);
    return module;
  }
}, {}, CodeUnit);
var HookedCodeUnit = function HookedCodeUnit() {
  $traceurRuntime.defaultSuperCall(this, $HookedCodeUnit.prototype, arguments);
};
var $HookedCodeUnit = HookedCodeUnit;
($traceurRuntime.createClass)(HookedCodeUnit, {
  getModuleSpecifiers: function() {
    return this.loaderHooks.getModuleSpecifiers(this);
  },
  evaluate: function() {
    return this.loaderHooks.evaluateCodeUnit(this);
  }
}, {}, CodeUnit);
var LoadCodeUnit = function LoadCodeUnit(loaderHooks, normalizedName, name, referrerName, address) {
  $traceurRuntime.superCall(this, $LoadCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, 'module', NOT_STARTED, name, referrerName, address]);
};
var $LoadCodeUnit = LoadCodeUnit;
($traceurRuntime.createClass)(LoadCodeUnit, {}, {}, HookedCodeUnit);
var EvalCodeUnit = function EvalCodeUnit(loaderHooks, code) {
  var type = arguments[2] !== (void 0) ? arguments[2] : 'script';
  var normalizedName = arguments[3];
  var referrerName = arguments[4];
  var address = arguments[5];
  $traceurRuntime.superCall(this, $EvalCodeUnit.prototype, "constructor", [loaderHooks, normalizedName, type, LOADED, null, referrerName, address]);
  this.source = code;
};
var $EvalCodeUnit = EvalCodeUnit;
($traceurRuntime.createClass)(EvalCodeUnit, {}, {}, HookedCodeUnit);
var uniqueNameCount = 0;
var InternalLoader = function InternalLoader(loaderHooks) {
  this.loaderHooks = loaderHooks;
  this.reporter = loaderHooks.reporter;
  this.cache = new ArrayMap();
  this.urlToKey = Object.create(null);
  this.sync_ = false;
};
($traceurRuntime.createClass)(InternalLoader, {
  load: function(name) {
    var referrerName = arguments[1] !== (void 0) ? arguments[1] : this.loaderHooks.baseURL;
    var address = arguments[2];
    var type = arguments[3] !== (void 0) ? arguments[3] : 'script';
    var codeUnit = this.load_(name, referrerName, address, type);
    return codeUnit.promise.then((function() {
      return codeUnit;
    }));
  },
  load_: function(name, referrerName, address, type) {
    var $__364 = this;
    var codeUnit = this.getCodeUnit_(name, referrerName, address, type);
    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.loaderHooks.locate(codeUnit);
      this.loaderHooks.fetch(codeUnit).then((function(text) {
        codeUnit.source = text;
        return codeUnit;
      })).then(this.loaderHooks.translate.bind(this.loaderHooks)).then((function(source) {
        codeUnit.source = source;
        codeUnit.state = LOADED;
        $__364.handleCodeUnitLoaded(codeUnit);
        return codeUnit;
      })).catch((function(err) {
        try {
          codeUnit.state = ERROR;
          codeUnit.abort = function() {};
          codeUnit.err = err;
          $__364.handleCodeUnitLoadError(codeUnit);
        } catch (ex) {
          console.error('Internal Error ' + (ex.stack || ex));
        }
      }));
    }
    return codeUnit;
  },
  module: function(code, referrerName, address) {
    var codeUnit = new EvalCodeUnit(this.loaderHooks, code, 'module', null, referrerName, address);
    this.cache.set({}, codeUnit);
    this.handleCodeUnitLoaded(codeUnit);
    return codeUnit.promise;
  },
  define: function(normalizedName, code, address) {
    var codeUnit = new EvalCodeUnit(this.loaderHooks, code, 'module', normalizedName, null, address);
    var key = this.getKey(normalizedName, 'module');
    this.cache.set(key, codeUnit);
    this.handleCodeUnitLoaded(codeUnit);
    return codeUnit.promise;
  },
  script: function(code, name, referrerName, address) {
    var normalizedName = System.normalize(name || '', referrerName, address);
    var codeUnit = new EvalCodeUnit(this.loaderHooks, code, 'script', normalizedName, referrerName, address);
    var key = {};
    if (name)
      key = this.getKey(normalizedName, 'script');
    this.cache.set(key, codeUnit);
    this.handleCodeUnitLoaded(codeUnit);
    return codeUnit.promise;
  },
  get options() {
    return this.loaderHooks.options;
  },
  sourceMapInfo: function(normalizedName, type) {
    var key = this.getKey(normalizedName, type);
    var codeUnit = this.cache.get(key);
    return {
      sourceMap: codeUnit && codeUnit.metadata && codeUnit.metadata.sourceMap,
      url: codeUnit && codeUnit.url
    };
  },
  getKey: function(url, type) {
    var combined = type + ':' + url;
    if (combined in this.urlToKey) {
      return this.urlToKey[combined];
    }
    return this.urlToKey[combined] = {};
  },
  getCodeUnit_: function(name, referrerName, address, type) {
    var normalizedName = System.normalize(name, referrerName, address);
    var key = this.getKey(normalizedName, type);
    var cacheObject = this.cache.get(key);
    if (!cacheObject) {
      var module = this.loaderHooks.get(normalizedName);
      if (module) {
        cacheObject = new PreCompiledCodeUnit(this.loaderHooks, normalizedName, name, referrerName, address, module);
        cacheObject.type = 'module';
      } else {
        var bundledModule = this.loaderHooks.bundledModule(name);
        if (bundledModule) {
          cacheObject = new BundledCodeUnit(this.loaderHooks, normalizedName, name, referrerName, address, bundledModule.deps, bundledModule.execute);
        } else {
          cacheObject = new LoadCodeUnit(this.loaderHooks, normalizedName, name, referrerName, address);
          cacheObject.type = type;
        }
      }
      this.cache.set(key, cacheObject);
    }
    return cacheObject;
  },
  areAll: function(state) {
    return this.cache.values().every((function(codeUnit) {
      return codeUnit.state >= state;
    }));
  },
  getCodeUnitForModuleSpecifier: function(name, referrerName) {
    return this.getCodeUnit_(name, referrerName, null, 'module');
  },
  handleCodeUnitLoaded: function(codeUnit) {
    var $__364 = this;
    var referrerName = codeUnit.normalizedName;
    var moduleSpecifiers = codeUnit.getModuleSpecifiers();
    if (!moduleSpecifiers) {
      this.abortAll(("No module specifiers in " + referrerName));
      return;
    }
    codeUnit.dependencies = moduleSpecifiers.sort().map((function(name) {
      return $__364.getCodeUnit_(name, referrerName, null, 'module');
    }));
    codeUnit.dependencies.forEach((function(dependency) {
      $__364.load(dependency.normalizedName, null, null, 'module');
    }));
    if (this.areAll(PARSED)) {
      this.analyze();
      this.transform();
      this.evaluate();
    }
  },
  handleCodeUnitLoadError: function(codeUnit) {
    var message = codeUnit.err ? String(codeUnit.err) + '\n' : ("Failed to load '" + codeUnit.address + "'.\n");
    message += codeUnit.nameTrace() + this.loaderHooks.nameTrace(codeUnit);
    this.reporter.reportError(null, message);
    this.abortAll(message);
    codeUnit.error = message;
    codeUnit.reject(this.toError(message));
  },
  toError: function(maybeError) {
    return maybeError instanceof Error ? maybeError : new Error(maybeError);
  },
  abortAll: function(errorMessage) {
    var $__364 = this;
    this.cache.values().forEach((function(codeUnit) {
      if (codeUnit.abort) {
        codeUnit.abort();
        codeUnit.state = ERROR;
      }
    }));
    this.cache.values().forEach((function(codeUnit) {
      codeUnit.reject($__364.toError(codeUnit.error));
    }));
  },
  analyze: function() {
    this.loaderHooks.analyzeDependencies(this.cache.values(), this);
    this.checkForErrors(this.cache.values(), 'build-export-list');
  },
  transform: function() {
    this.transformDependencies(this.cache.values());
  },
  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.reporter.reportError(codeUnit.metadata.tree, ("Unsupported circular dependency between " + cir + " and " + cle));
        break;
      }
      codeUnit.state = TRANSFORMING;
      this.transformCodeUnit(codeUnit);
      codeUnit.instantiate();
    }
    this.checkForErrors(dependencies, 'transform');
  },
  transformCodeUnit: function(codeUnit) {
    var $__366;
    this.transformDependencies(codeUnit.dependencies, codeUnit.normalizedName);
    if (codeUnit.state === ERROR)
      return;
    var metadata = codeUnit.metadata;
    metadata.transformedTree = codeUnit.transform();
    codeUnit.state = TRANSFORMED;
    var filename = codeUnit.address || codeUnit.normalizedName;
    ($__366 = $traceurRuntime.assertObject(toSource(metadata.transformedTree, this.options, filename)), metadata.transcoded = $__366[0], metadata.sourceMap = $__366[1], $__366);
    if (codeUnit.address && metadata.transcoded)
      metadata.transcoded += '//# sourceURL=' + codeUnit.address;
  },
  checkForErrors: function(dependencies, phase) {
    if (this.reporter.hadError()) {
      for (var i = 0; i < dependencies.length; i++) {
        var codeUnit = dependencies[i];
        if (codeUnit.state >= COMPLETE) {
          continue;
        }
        codeUnit.state = ERROR;
      }
      for (var i = 0; i < dependencies.length; i++) {
        var codeUnit = dependencies[i];
        if (codeUnit.state == ERROR)
          codeUnit.reject(this.toError(codeUnit.error));
      }
      return true;
    }
    return false;
  },
  orderDependencies: function() {
    var visited = new ObjectMap();
    var ordered = [];
    function orderCodeUnits(codeUnit) {
      if (visited.has(codeUnit)) {
        return;
      }
      visited.set(codeUnit, true);
      codeUnit.dependencies.forEach(orderCodeUnits);
      ordered.push(codeUnit);
    }
    this.cache.values().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;
      try {
        result = codeUnit.evaluate();
      } catch (ex) {
        codeUnit.error = ex;
        this.abortAll();
        codeUnit.reject(codeUnit.error);
        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);
    }
  }
}, {uniqueName: function(normalizedName, referrerAddress) {
    var importerAddress = referrerAddress || System.baseURL;
    if (!importerAddress)
      throw new Error('The System.baseURL is an empty string');
    var path = normalizedName || String(uniqueNameCount++);
    return resolveUrl(importerAddress, path);
  }});
var SystemLoaderHooks = LoaderHooks;
var internals = {
  CodeUnit: CodeUnit,
  EvalCodeUnit: EvalCodeUnit,
  LoadCodeUnit: LoadCodeUnit,
  LoaderHooks: LoaderHooks
};
return {
  get InternalLoader() {
    return InternalLoader;
  },
  get internals() {
    return internals;
  }
};

}); System.register(“traceur@0.0.43/src/runtime/Loader”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/Loader";
var InternalLoader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/InternalLoader")).InternalLoader;
var Loader = function Loader(loaderHooks) {
  this.internalLoader_ = new InternalLoader(loaderHooks);
  this.loaderHooks_ = loaderHooks;
};
($traceurRuntime.createClass)(Loader, {
  import: function(name) {
    var $__369 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}),
        referrerName = $__369.referrerName,
        address = $__369.address;
    var $__367 = this;
    return this.internalLoader_.load(name, referrerName, address, 'module').then((function(codeUnit) {
      return $__367.get(codeUnit.normalizedName);
    }));
  },
  module: function(source) {
    var $__369 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}),
        referrerName = $__369.referrerName,
        address = $__369.address;
    return this.internalLoader_.module(source, referrerName, address);
  },
  define: function(normalizedName, source) {
    var $__369 = $traceurRuntime.assertObject(arguments[2] !== (void 0) ? arguments[2] : {}),
        address = $__369.address,
        metadata = $__369.metadata;
    return this.internalLoader_.define(normalizedName, source, address, metadata);
  },
  get: function(normalizedName) {
    return this.loaderHooks_.get(normalizedName);
  },
  set: function(normalizedName, module) {
    this.loaderHooks_.set(normalizedName, module);
  },
  normalize: function(name, referrerName, referrerAddress) {
    return this.loaderHooks_.normalize(name, referrerName, referrerAddress);
  },
  locate: function(load) {
    return this.loaderHooks_.locate(load);
  },
  fetch: function(load) {
    return this.loaderHooks_.fetch(load);
  },
  translate: function(load) {
    return this.loaderHooks_.translate(load);
  },
  instantiate: function(load) {
    return this.loaderHooks_.instantiate(load);
  }
}, {});
;
return {
  get Loader() {
    return Loader;
  },
  get LoaderHooks() {
    return LoaderHooks;
  }
};

}); System.register(“traceur@0.0.43/src/WebPageTranscoder”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/WebPageTranscoder";
var Loader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/Loader")).Loader;
var ErrorReporter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ErrorReporter")).ErrorReporter;
var InterceptOutputLoaderHooks = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/InterceptOutputLoaderHooks")).InterceptOutputLoaderHooks;
var webLoader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/webLoader")).webLoader;
var WebPageTranscoder = function WebPageTranscoder(url) {
  this.url = url;
  this.numPending_ = 0;
  this.numberInlined_ = 0;
};
($traceurRuntime.createClass)(WebPageTranscoder, {
  asyncLoad_: function(url, fncOfContent, onScriptsReady) {
    var $__370 = this;
    this.numPending_++;
    webLoader.load(url, (function(content) {
      if (content)
        fncOfContent(content);
      else
        console.warn('Failed to load', url);
      if (--$__370.numPending_ <= 0)
        onScriptsReady();
    }), (function(error) {
      console.error('WebPageTranscoder FAILED to load ' + url, error.stack || error);
    }));
  },
  addFileFromScriptElement: function(scriptElement, name, content) {
    var nameInfo = {
      address: name,
      referrerName: window.location.href
    };
    this.loader.module(content, nameInfo).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_ + '_' + 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 = scriptElement.src;
        this.asyncLoad_(name, this.addFileFromScriptElement.bind(this, scriptElement, name), onScriptsReady);
      }
    }
    if (this.numPending_ <= 0)
      onScriptsReady();
  },
  get reporter() {
    if (!this.reporter_) {
      this.reporter_ = new ErrorReporter();
    }
    return this.reporter_;
  },
  get loader() {
    if (!this.loader_) {
      var loaderHooks = new InterceptOutputLoaderHooks(this.reporter, this.url);
      this.loader_ = new Loader(loaderHooks);
    }
    return this.loader_;
  },
  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 = 'script[type="module"]';
    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 $__370 = this;
    var ready = document.readyState;
    if (ready === 'complete' || ready === 'loaded') {
      this.selectAndProcessScripts(done);
    } else {
      document.addEventListener('DOMContentLoaded', (function() {
        return $__370.selectAndProcessScripts(done);
      }), false);
    }
  }
}, {});
return {get WebPageTranscoder() {
    return WebPageTranscoder;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/CloneTreeTransformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/CloneTreeTransformer";
var ParseTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/ParseTreeTransformer")).ParseTreeTransformer;
var $__374 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")),
    BindingIdentifier = $__374.BindingIdentifier,
    BreakStatement = $__374.BreakStatement,
    ContinueStatement = $__374.ContinueStatement,
    DebuggerStatement = $__374.DebuggerStatement,
    EmptyStatement = $__374.EmptyStatement,
    ExportSpecifier = $__374.ExportSpecifier,
    ExportStar = $__374.ExportStar,
    IdentifierExpression = $__374.IdentifierExpression,
    ImportSpecifier = $__374.ImportSpecifier,
    LiteralExpression = $__374.LiteralExpression,
    ModuleSpecifier = $__374.ModuleSpecifier,
    PredefinedType = $__374.PredefinedType,
    PropertyNameShorthand = $__374.PropertyNameShorthand,
    TemplateLiteralPortion = $__374.TemplateLiteralPortion,
    RestParameter = $__374.RestParameter,
    SuperExpression = $__374.SuperExpression,
    ThisExpression = $__374.ThisExpression;
var CloneTreeTransformer = function CloneTreeTransformer() {
  $traceurRuntime.defaultSuperCall(this, $CloneTreeTransformer.prototype, arguments);
};
var $CloneTreeTransformer = CloneTreeTransformer;
($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);
  },
  transformImportSpecifier: function(tree) {
    return new ImportSpecifier(tree.location, tree.lhs, tree.rhs);
  },
  transformList: function(list) {
    if (!list) {
      return null;
    } else if (list.length == 0) {
      return [];
    } else {
      return $traceurRuntime.superCall(this, $CloneTreeTransformer.prototype, "transformList", [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);
  }
}, {}, ParseTreeTransformer);
CloneTreeTransformer.cloneTree = function(tree) {
  return new CloneTreeTransformer().transformAny(tree);
};
return {get CloneTreeTransformer() {
    return CloneTreeTransformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/PureES6Transformer”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/PureES6Transformer";
var AnnotationsTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/AnnotationsTransformer")).AnnotationsTransformer;
var FreeVariableChecker = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/semantics/FreeVariableChecker")).FreeVariableChecker;
var MultiTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/MultiTransformer")).MultiTransformer;
var TypeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/TypeTransformer")).TypeTransformer;
var UniqueIdentifierGenerator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/UniqueIdentifierGenerator")).UniqueIdentifierGenerator;
var $__377 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")),
    options = $__377.options,
    transformOptions = $__377.transformOptions;
var PureES6Transformer = function PureES6Transformer(reporter) {
  var idGenerator = arguments[1] !== (void 0) ? arguments[1] : new UniqueIdentifierGenerator();
  var $__375 = this;
  $traceurRuntime.superCall(this, $PureES6Transformer.prototype, "constructor", [reporter, options.validate]);
  var append = (function(transformer) {
    $__375.append((function(tree) {
      return new transformer(idGenerator, reporter).transformAny(tree);
    }));
  });
  append(AnnotationsTransformer);
  append(TypeTransformer);
  if (options.freeVariableChecker) {
    this.append((function(tree) {
      FreeVariableChecker.checkScript(reporter, tree);
      return tree;
    }));
  }
};
var $PureES6Transformer = PureES6Transformer;
($traceurRuntime.createClass)(PureES6Transformer, {}, {}, MultiTransformer);
return {get PureES6Transformer() {
    return PureES6Transformer;
  }};

}); System.register(“traceur@0.0.43/src/codegeneration/module/createModuleEvaluationStatement”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/codegeneration/module/createModuleEvaluationStatement";
var $__378 = Object.freeze(Object.defineProperties(["System.get(", " +'')"], {raw: {value: Object.freeze(["System.get(", " +'')"])}}));
var parseStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PlaceholderParser")).parseStatement;
function createModuleEvaluationStatement(normalizedName) {
  return parseStatement($__378, normalizedName);
}
return {get createModuleEvaluationStatement() {
    return createModuleEvaluationStatement;
  }};

}); System.register(“traceur@0.0.43/src/runtime/TraceurLoader”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/TraceurLoader";
var InternalLoader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/InternalLoader")).InternalLoader;
var Loader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/Loader")).Loader;
var version = __moduleName.slice(0, __moduleName.indexOf('/'));
var TraceurLoader = function TraceurLoader(loaderHooks) {
  if (loaderHooks.translateSynchronous) {
    loaderHooks.translate = function(load) {
      return new Promise((function(resolve, reject) {
        resolve(loaderHooks.translateSynchronous(load));
      }));
    };
  }
  $traceurRuntime.superCall(this, $TraceurLoader.prototype, "constructor", [loaderHooks]);
};
var $TraceurLoader = TraceurLoader;
($traceurRuntime.createClass)(TraceurLoader, {
  importAll: function(names) {
    var $__382 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}),
        referrerName = $__382.referrerName,
        address = $__382.address;
    var $__380 = this;
    return Promise.all(names.map((function(name) {
      return $__380.import(name, {
        referrerName: referrerName,
        address: address
      });
    })));
  },
  loadAsScript: function(name) {
    var $__382 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}),
        referrerName = $__382.referrerName,
        address = $__382.address;
    return this.internalLoader_.load(name, referrerName, address, 'script').then((function(codeUnit) {
      return codeUnit.result;
    }));
  },
  loadAsScriptAll: function(names) {
    var $__382 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}),
        referrerName = $__382.referrerName,
        address = $__382.address;
    var $__380 = this;
    return Promise.all(names.map((function(name) {
      return $__380.loadAsScript(name, {
        referrerName: referrerName,
        address: address
      });
    })));
  },
  script: function(source) {
    var $__382 = $traceurRuntime.assertObject(arguments[1] !== (void 0) ? arguments[1] : {}),
        name = $__382.name,
        referrerName = $__382.referrerName,
        address = $__382.address;
    return this.internalLoader_.script(source, name, referrerName, address);
  },
  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('/');
    var version = normalizedName.slice(0, slash);
    var at = version.indexOf('@');
    if (at !== -1) {
      var semver = version.slice(at + 1);
      var m = this.semVerRegExp_().exec(semver);
      if (m) {
        var major = m[1];
        var minor = m[2];
        var packageName = version.slice(0, at);
        var map = Object.create(null);
        map[packageName] = version;
        map[packageName + '@' + major] = version;
        map[packageName + '@' + major + '.' + minor] = version;
      }
    }
    return map;
  },
  get version() {
    return version;
  },
  get options() {
    return this.internalLoader_.options;
  },
  sourceMapInfo: function(normalizedName, type) {
    return this.internalLoader_.sourceMapInfo(normalizedName, type);
  },
  register: function(normalizedName, deps, factoryFunction) {
    $traceurRuntime.ModuleStore.register(normalizedName, deps, factoryFunction);
  },
  get baseURL() {
    return this.loaderHooks_.baseURL;
  },
  set baseURL(value) {
    this.loaderHooks_.baseURL = value;
  }
}, {}, Loader);
return {get TraceurLoader() {
    return TraceurLoader;
  }};

}); System.register(“traceur@0.0.43/src/runtime/System”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/runtime/System";
var globalThis = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/globalThis")).default;
var ErrorReporter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ErrorReporter")).ErrorReporter;
var TraceurLoader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/TraceurLoader")).TraceurLoader;
var LoaderHooks = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/LoaderHooks")).LoaderHooks;
var options = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/options")).options;
var webLoader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/webLoader")).webLoader;
var url;
var fileLoader;
if (typeof window !== 'undefined' && window.location) {
  url = window.location.href;
  fileLoader = webLoader;
}
var loaderHooks = new LoaderHooks(new ErrorReporter(), url, fileLoader);
var traceurLoader = new TraceurLoader(loaderHooks);
if (typeof window !== 'undefined')
  window.System = traceurLoader;
if (typeof global !== 'undefined')
  global.System = traceurLoader;
;
traceurLoader.map = traceurLoader.semverMap(__moduleName);
return {get System() {
    return traceurLoader;
  }};

}); System.register(“traceur@0.0.43/src/util/TestErrorReporter”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/util/TestErrorReporter";
var $__386 = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ErrorReporter")),
    ErrorReporter = $__386.ErrorReporter,
    format = $__386.format;
var TestErrorReporter = function TestErrorReporter() {
  var pathRe = arguments[0];
  this.errors = [];
  this.pathRe = pathRe;
};
($traceurRuntime.createClass)(TestErrorReporter, {
  reportMessageInternal: function(location, message) {
    this.errors.push(format(location, message));
  },
  hasMatchingError: function(expected) {
    var $__384 = this;
    var m;
    if (!this.pathRe || !(m = this.pathRe.exec(expected)))
      return this.errors.some((function(error) {
        return error.indexOf(expected) !== -1;
      }));
    var expectedPath = m[1];
    var expectedNonPath = expected.replace(expectedPath, '<PATH>');
    return this.errors.some((function(error) {
      var m = $__384.pathRe.exec(error);
      if (!m)
        return false;
      var actualPath = m[1];
      var actualNonPath = error.replace(actualPath, '<PATH>');
      if (actualNonPath.indexOf(expectedNonPath) === -1)
        return false;
      actualPath = actualPath.replace(/\\/g, '/');
      return actualPath.indexOf(expectedPath) !== -1;
    }));
  }
}, {}, ErrorReporter);
return {get TestErrorReporter() {
    return TestErrorReporter;
  }};

}); System.register(“traceur@0.0.43/src/traceur”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/traceur";
System.get("traceur@0.0.43/src/runtime/System");
var $___64_traceur_47_src_47_runtime_47_ModuleStore__ = System.get("@traceur/src/runtime/ModuleStore");
;
var $__traceur_64_0_46_0_46_43_47_src_47_WebPageTranscoder__ = System.get("traceur@0.0.43/src/WebPageTranscoder");
var $__traceur_64_0_46_0_46_43_47_src_47_options__ = System.get("traceur@0.0.43/src/options");
var ErrorReporter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/ErrorReporter")).ErrorReporter;
var TestErrorReporter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/util/TestErrorReporter")).TestErrorReporter;
var util = {
  ErrorReporter: ErrorReporter,
  TestErrorReporter: TestErrorReporter
};
var Parser = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Parser")).Parser;
var Scanner = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/Scanner")).Scanner;
var Script = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/trees/ParseTrees")).Script;
var SourceFile = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/syntax/SourceFile")).SourceFile;
var syntax = {
  Parser: Parser,
  Scanner: Scanner,
  SourceFile: SourceFile,
  trees: {Script: Script}
};
var ParseTreeMapWriter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/ParseTreeMapWriter")).ParseTreeMapWriter;
var ParseTreeWriter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/ParseTreeWriter")).ParseTreeWriter;
var SourceMapConsumer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/SourceMapIntegration")).SourceMapConsumer;
var SourceMapGenerator = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/SourceMapIntegration")).SourceMapGenerator;
var TreeWriter = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/outputgeneration/TreeWriter")).TreeWriter;
var outputgeneration = {
  ParseTreeMapWriter: ParseTreeMapWriter,
  ParseTreeWriter: ParseTreeWriter,
  SourceMapConsumer: SourceMapConsumer,
  SourceMapGenerator: SourceMapGenerator,
  TreeWriter: TreeWriter
};
var AttachModuleNameTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/AttachModuleNameTransformer")).AttachModuleNameTransformer;
var CloneTreeTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/CloneTreeTransformer")).CloneTreeTransformer;
var FromOptionsTransformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/FromOptionsTransformer")).FromOptionsTransformer;
var PureES6Transformer = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/PureES6Transformer")).PureES6Transformer;
var createModuleEvaluationStatement = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/codegeneration/module/createModuleEvaluationStatement")).createModuleEvaluationStatement;
var codegeneration = {
  CloneTreeTransformer: CloneTreeTransformer,
  FromOptionsTransformer: FromOptionsTransformer,
  PureES6Transformer: PureES6Transformer,
  module: {
    AttachModuleNameTransformer: AttachModuleNameTransformer,
    createModuleEvaluationStatement: createModuleEvaluationStatement
  }
};
var Loader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/Loader")).Loader;
var LoaderHooks = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/LoaderHooks")).LoaderHooks;
var InterceptOutputLoaderHooks = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/InterceptOutputLoaderHooks")).InterceptOutputLoaderHooks;
var TraceurLoader = $traceurRuntime.assertObject(System.get("traceur@0.0.43/src/runtime/TraceurLoader")).TraceurLoader;
var runtime = {
  InterceptOutputLoaderHooks: InterceptOutputLoaderHooks,
  Loader: Loader,
  LoaderHooks: LoaderHooks,
  TraceurLoader: TraceurLoader
};
return {
  get ModuleStore() {
    return $___64_traceur_47_src_47_runtime_47_ModuleStore__.ModuleStore;
  },
  get System() {
    return System;
  },
  get WebPageTranscoder() {
    return $__traceur_64_0_46_0_46_43_47_src_47_WebPageTranscoder__.WebPageTranscoder;
  },
  get options() {
    return $__traceur_64_0_46_0_46_43_47_src_47_options__.options;
  },
  get util() {
    return util;
  },
  get syntax() {
    return syntax;
  },
  get outputgeneration() {
    return outputgeneration;
  },
  get codegeneration() {
    return codegeneration;
  },
  get runtime() {
    return runtime;
  }
};

}); System.register(“traceur@0.0.43/src/traceur-import”, [], function() {

"use strict";
var __moduleName = "traceur@0.0.43/src/traceur-import";
var traceur = System.get("traceur@0.0.43/src/traceur");
this.traceur = traceur;
$traceurRuntime.ModuleStore.set('traceur@', traceur);
return {};

}); System.get(“traceur@0.0.43/src/traceur-import” + '');