added bootstrap 3rd party dependencies

lib/3rdparty/systemjs/babel-helpers/asyncGenerator.js

@@ -0,0 +1,112 @@
+export default (function () {
+  function AwaitValue(value) {
+    this.value = value;
+  }
+
+  function AsyncGenerator(gen) {
+    var front, back;
+
+    function send(key, arg) {
+      return new Promise(function (resolve, reject) {
+        var request = {
+          key: key,
+          arg: arg,
+          resolve: resolve,
+          reject: reject,
+          next: null
+        };
+
+        if (back) {
+          back = back.next = request;
+        } else {
+          front = back = request;
+          resume(key, arg);
+        }
+      });
+    }
+
+    function resume(key, arg) {
+      try {
+        var result = gen[key](arg);
+        var value = result.value;
+
+        if (value instanceof AwaitValue) {
+          Promise.resolve(value.value).then(function (arg) {
+            resume("next", arg);
+          }, function (arg) {
+            resume("throw", arg);
+          });
+        } else {
+          settle(result.done ? "return" : "normal", result.value);
+        }
+      } catch (err) {
+        settle("throw", err);
+      }
+    }
+
+    function settle(type, value) {
+      switch (type) {
+        case "return":
+          front.resolve({
+            value: value,
+            done: true
+          });
+          break;
+
+        case "throw":
+          front.reject(value);
+          break;
+
+        default:
+          front.resolve({
+            value: value,
+            done: false
+          });
+          break;
+      }
+
+      front = front.next;
+
+      if (front) {
+        resume(front.key, front.arg);
+      } else {
+        back = null;
+      }
+    }
+
+    this._invoke = send;
+
+    if (typeof gen.return !== "function") {
+      this.return = undefined;
+    }
+  }
+
+  if (typeof Symbol === "function" && Symbol.asyncIterator) {
+    AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
+      return this;
+    };
+  }
+
+  AsyncGenerator.prototype.next = function (arg) {
+    return this._invoke("next", arg);
+  };
+
+  AsyncGenerator.prototype.throw = function (arg) {
+    return this._invoke("throw", arg);
+  };
+
+  AsyncGenerator.prototype.return = function (arg) {
+    return this._invoke("return", arg);
+  };
+
+  return {
+    wrap: function (fn) {
+      return function () {
+        return new AsyncGenerator(fn.apply(this, arguments));
+      };
+    },
+    await: function (value) {
+      return new AwaitValue(value);
+    }
+  };
+})();

lib/3rdparty/systemjs/babel-helpers/asyncGeneratorDelegate.js

@@ -0,0 +1,51 @@
+export default (function (inner, awaitWrap) {
+  var iter = {},
+      waiting = false;
+
+  function pump(key, value) {
+    waiting = true;
+    value = new Promise(function (resolve) {
+      resolve(inner[key](value));
+    });
+    return {
+      done: false,
+      value: awaitWrap(value)
+    };
+  }
+
+  ;
+
+  if (typeof Symbol === "function" && Symbol.iterator) {
+    iter[Symbol.iterator] = function () {
+      return this;
+    };
+  }
+
+  iter.next = function (value) {
+    if (waiting) {
+      waiting = false;
+      return value;
+    }
+
+    return pump("next", value);
+  };
+
+  if (typeof inner.throw === "function") {
+    iter.throw = function (value) {
+      if (waiting) {
+        waiting = false;
+        throw value;
+      }
+
+      return pump("throw", value);
+    };
+  }
+
+  if (typeof inner.return === "function") {
+    iter.return = function (value) {
+      return pump("return", value);
+    };
+  }
+
+  return iter;
+});

lib/3rdparty/systemjs/babel-helpers/asyncIterator.js

@@ -0,0 +1,14 @@
+export default (function (iterable) {
+  if (typeof Symbol === "function") {
+    if (Symbol.asyncIterator) {
+      var method = iterable[Symbol.asyncIterator];
+      if (method != null) return method.call(iterable);
+    }
+
+    if (Symbol.iterator) {
+      return iterable[Symbol.iterator]();
+    }
+  }
+
+  throw new TypeError("Object is not async iterable");
+});

lib/3rdparty/systemjs/babel-helpers/asyncToGenerator.js

@@ -0,0 +1,28 @@
+export default (function (fn) {
+  return function () {
+    var gen = fn.apply(this, arguments);
+    return new Promise(function (resolve, reject) {
+      function step(key, arg) {
+        try {
+          var info = gen[key](arg);
+          var value = info.value;
+        } catch (error) {
+          reject(error);
+          return;
+        }
+
+        if (info.done) {
+          resolve(value);
+        } else {
+          return Promise.resolve(value).then(function (value) {
+            step("next", value);
+          }, function (err) {
+            step("throw", err);
+          });
+        }
+      }
+
+      return step("next");
+    });
+  };
+});

lib/3rdparty/systemjs/babel-helpers/classCallCheck.js

@@ -0,0 +1,5 @@
+export default (function (instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+});

lib/3rdparty/systemjs/babel-helpers/createClass.js

@@ -0,0 +1,17 @@
+export default (function () {
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  return function (Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
+  };
+})();

lib/3rdparty/systemjs/babel-helpers/defaults.js

@@ -0,0 +1,14 @@
+export default (function (obj, defaults) {
+  var keys = Object.getOwnPropertyNames(defaults);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+    if (value && value.configurable && obj[key] === undefined) {
+      Object.defineProperty(obj, key, value);
+    }
+  }
+
+  return obj;
+});

lib/3rdparty/systemjs/babel-helpers/defineEnumerableProperties.js

@@ -0,0 +1,10 @@
+export default (function (obj, descs) {
+  for (var key in descs) {
+    var desc = descs[key];
+    desc.configurable = desc.enumerable = true;
+    if ("value" in desc) desc.writable = true;
+    Object.defineProperty(obj, key, desc);
+  }
+
+  return obj;
+});

lib/3rdparty/systemjs/babel-helpers/defineProperty.js

@@ -0,0 +1,14 @@
+export default (function (obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+});

lib/3rdparty/systemjs/babel-helpers/extends.js

@@ -0,0 +1,13 @@
+export default Object.assign || function (target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+
+  return target;
+};

lib/3rdparty/systemjs/babel-helpers/get.js

@@ -0,0 +1,24 @@
+export default (function get(object, property, receiver) {
+  if (object === null) object = Function.prototype;
+  var desc = Object.getOwnPropertyDescriptor(object, property);
+
+  if (desc === undefined) {
+    var parent = Object.getPrototypeOf(object);
+
+    if (parent === null) {
+      return undefined;
+    } else {
+      return get(parent, property, receiver);
+    }
+  } else if ("value" in desc) {
+    return desc.value;
+  } else {
+    var getter = desc.get;
+
+    if (getter === undefined) {
+      return undefined;
+    }
+
+    return getter.call(receiver);
+  }
+});

lib/3rdparty/systemjs/babel-helpers/inherits.js

@@ -0,0 +1,15 @@
+export default (function (subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+});

lib/3rdparty/systemjs/babel-helpers/instanceof.js

@@ -0,0 +1,7 @@
+export default (function (left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+});

lib/3rdparty/systemjs/babel-helpers/interopRequireDefault.js

@@ -0,0 +1,5 @@
+export default (function (obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+});

lib/3rdparty/systemjs/babel-helpers/interopRequireWildcard.js

@@ -0,0 +1,16 @@
+export default (function (obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+});

lib/3rdparty/systemjs/babel-helpers/jsx.js

@@ -0,0 +1,42 @@
+export default (function () {
+  var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
+  return function createRawReactElement(type, props, key, children) {
+    var defaultProps = type && type.defaultProps;
+    var childrenLength = arguments.length - 3;
+
+    if (!props && childrenLength !== 0) {
+      props = {};
+    }
+
+    if (props && defaultProps) {
+      for (var propName in defaultProps) {
+        if (props[propName] === void 0) {
+          props[propName] = defaultProps[propName];
+        }
+      }
+    } else if (!props) {
+      props = defaultProps || {};
+    }
+
+    if (childrenLength === 1) {
+      props.children = children;
+    } else if (childrenLength > 1) {
+      var childArray = Array(childrenLength);
+
+      for (var i = 0; i < childrenLength; i++) {
+        childArray[i] = arguments[i + 3];
+      }
+
+      props.children = childArray;
+    }
+
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type: type,
+      key: key === undefined ? null : '' + key,
+      ref: null,
+      props: props,
+      _owner: null
+    };
+  };
+})();

lib/3rdparty/systemjs/babel-helpers/newArrowCheck.js

@@ -0,0 +1,5 @@
+export default (function (innerThis, boundThis) {
+  if (innerThis !== boundThis) {
+    throw new TypeError("Cannot instantiate an arrow function");
+  }
+});

lib/3rdparty/systemjs/babel-helpers/objectDestructuringEmpty.js

@@ -0,0 +1,3 @@
+export default (function (obj) {
+  if (obj == null) throw new TypeError("Cannot destructure undefined");
+});

lib/3rdparty/systemjs/babel-helpers/objectWithoutProperties.js

@@ -0,0 +1,11 @@
+export default (function (obj, keys) {
+  var target = {};
+
+  for (var i in obj) {
+    if (keys.indexOf(i) >= 0) continue;
+    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
+    target[i] = obj[i];
+  }
+
+  return target;
+});

lib/3rdparty/systemjs/babel-helpers/possibleConstructorReturn.js

@@ -0,0 +1,7 @@
+export default (function (self, call) {
+  if (!self) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return call && (typeof call === "object" || typeof call === "function") ? call : self;
+});

lib/3rdparty/systemjs/babel-helpers/selfGlobal.js

@@ -0,0 +1 @@
+export default typeof global === "undefined" ? self : global;

lib/3rdparty/systemjs/babel-helpers/set.js

@@ -0,0 +1,21 @@
+export default (function set(object, property, value, receiver) {
+  var desc = Object.getOwnPropertyDescriptor(object, property);
+
+  if (desc === undefined) {
+    var parent = Object.getPrototypeOf(object);
+
+    if (parent !== null) {
+      set(parent, property, value, receiver);
+    }
+  } else if ("value" in desc && desc.writable) {
+    desc.value = value;
+  } else {
+    var setter = desc.set;
+
+    if (setter !== undefined) {
+      setter.call(receiver, value);
+    }
+  }
+
+  return value;
+});

lib/3rdparty/systemjs/babel-helpers/slicedToArray.js

@@ -0,0 +1,37 @@
+export default (function () {
+  function sliceIterator(arr, i) {
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+
+    try {
+      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"]) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+
+    return _arr;
+  }
+
+  return function (arr, i) {
+    if (Array.isArray(arr)) {
+      return arr;
+    } else if (Symbol.iterator in Object(arr)) {
+      return sliceIterator(arr, i);
+    } else {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance");
+    }
+  };
+})();

lib/3rdparty/systemjs/babel-helpers/slicedToArrayLoose.js

@@ -0,0 +1,17 @@
+export default (function (arr, i) {
+  if (Array.isArray(arr)) {
+    return arr;
+  } else if (Symbol.iterator in Object(arr)) {
+    var _arr = [];
+
+    for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+      _arr.push(_step.value);
+
+      if (i && _arr.length === i) break;
+    }
+
+    return _arr;
+  } else {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance");
+  }
+});

lib/3rdparty/systemjs/babel-helpers/taggedTemplateLiteral.js

@@ -0,0 +1,7 @@
+export default (function (strings, raw) {
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
+    }
+  }));
+});

lib/3rdparty/systemjs/babel-helpers/taggedTemplateLiteralLoose.js

@@ -0,0 +1,4 @@
+export default (function (strings, raw) {
+  strings.raw = raw;
+  return strings;
+});

lib/3rdparty/systemjs/babel-helpers/temporalRef.js

@@ -0,0 +1,7 @@
+export default (function (val, name, undef) {
+  if (val === undef) {
+    throw new ReferenceError(name + " is not defined - temporal dead zone");
+  } else {
+    return val;
+  }
+});

lib/3rdparty/systemjs/babel-helpers/temporalUndefined.js

@@ -0,0 +1 @@
+export default {};

lib/3rdparty/systemjs/babel-helpers/toArray.js

@@ -0,0 +1,3 @@
+export default (function (arr) {
+  return Array.isArray(arr) ? arr : Array.from(arr);
+});

lib/3rdparty/systemjs/babel-helpers/toConsumableArray.js

@@ -0,0 +1,9 @@
+export default (function (arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+    return arr2;
+  } else {
+    return Array.from(arr);
+  }
+});

lib/3rdparty/systemjs/babel-helpers/typeof.js

@@ -0,0 +1,5 @@
+export default typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+  return typeof obj;
+} : function (obj) {
+  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+};

lib/3rdparty/systemjs/plugin-babel.js

@@ -0,0 +1,222 @@
+var babel = require('systemjs-babel-build').babel;
+
+// the SystemJS babel build includes standard presets
+var es2015 = require('systemjs-babel-build').presetES2015;
+var es2015Register = require('systemjs-babel-build').presetES2015Register;
+var modulesRegister = require('systemjs-babel-build').modulesRegister;
+var stage3 = require('systemjs-babel-build').pluginsStage3;
+var stage2 = require('systemjs-babel-build').pluginsStage2;
+var stage1 = require('systemjs-babel-build').pluginsStage1;
+var react = require('systemjs-babel-build').pluginsReact;
+
+var externalHelpers = require('systemjs-babel-build').externalHelpers;
+var runtimeTransform = require('systemjs-babel-build').runtimeTransform;
+
+var babelRuntimePath;
+var modularHelpersPath = System.decanonicalize('./babel-helpers/', module.id);
+var externalHelpersPath = System.decanonicalize('./babel-helpers.js', module.id);
+var regeneratorRuntimePath = System.decanonicalize('./regenerator-runtime.js', module.id);
+
+if (modularHelpersPath.substr(modularHelpersPath.length - 3, 3) == '.js')
+  modularHelpersPath = modularHelpersPath.substr(0, modularHelpersPath.length - 3);
+
+// in builds we want to embed canonical names to helpers
+if (System.getCanonicalName) {
+  modularHelpersPath = System.getCanonicalName(modularHelpersPath);
+  externalHelpersPath = System.getCanonicalName(externalHelpersPath);
+  regeneratorRuntimePath = System.getCanonicalName(regeneratorRuntimePath);
+}
+
+// disable SystemJS runtime detection
+SystemJS._loader.loadedTranspilerRuntime = true;
+
+function prepend(a, b) {
+  for (var p in b)
+    if (!(p in a))
+      a[p] = b[p];
+  return a;
+}
+
+/*
+ * babelOptions:
+ *   modularRuntime: true / false (whether to use babel-runtime or babel/external-helpers respectively)
+ *   sourceMaps: true / false (defaults to true)
+ *   es2015: true / false (defaults to true)
+ *   stage3: true / false (defaults to true)
+ *   stage2: true / false (defaults to true)
+ *   stage1: true / false (defaults to false)
+ *   react: true / false (defaults to false)
+ *   plugins: array of custom plugins (objects or module name strings)
+ *   presets: array of custom presets (objects or module name strings)
+ *   compact: as in Babel
+ *   comments: as in Babel
+ *
+ * babelOptions can be set at SystemJS.babelOptions OR on the metadata object for a given module
+ */
+var defaultBabelOptions = {
+  modularRuntime: true,
+  sourceMaps: true,
+  es2015: true,
+  stage3: true,
+  stage2: true,
+  stage1: false,
+  react: false,
+  compact: false,
+  comments: true
+};
+
+exports.translate = function(load, traceOpts) {
+  // we don't transpile anything other than CommonJS or ESM
+  if (load.metadata.format == 'global' || load.metadata.format == 'amd' || load.metadata.format == 'json')
+    throw new TypeError('plugin-babel cannot transpile ' + load.metadata.format + ' modules. Ensure "' + load.name + '" is configured not to use this loader.');
+
+  var loader = this;
+  var pluginLoader = loader.pluginLoader || loader;
+
+  // we only output ES modules when running in the builder
+  var outputESM = traceOpts ? traceOpts.outputESM : loader.builder;
+
+  var babelOptions = {};
+
+  if (load.metadata.babelOptions)
+    prepend(babelOptions, load.metadata.babelOptions);
+
+  if (loader.babelOptions)
+    prepend(babelOptions, loader.babelOptions);
+
+  prepend(babelOptions, defaultBabelOptions);
+
+  // determine any plugins or preset strings which need to be imported as modules
+  var pluginAndPresetModuleLoads = [];
+
+  if (babelOptions.presets)
+    babelOptions.presets.forEach(function(preset) {
+      if (typeof preset == 'string')
+        pluginAndPresetModuleLoads.push(pluginLoader['import'](preset, module.id));
+    });
+
+  if (babelOptions.plugins)
+    babelOptions.plugins.forEach(function(plugin) {
+      plugin = typeof plugin == 'string' ? plugin : Array.isArray(plugin) && typeof plugin[0] == 'string' && plugin[0];
+      if (!plugin)
+        return;
+      pluginAndPresetModuleLoads.push(pluginLoader.import(plugin, module.id).then(function (m) {
+        return m.default || m;
+      }));
+    });
+
+  return Promise.all(pluginAndPresetModuleLoads)
+  .then(function(pluginAndPresetModules) {
+    var curPluginOrPresetModule = 0;
+
+    var presets = [];
+    var plugins = [];
+
+    if (babelOptions.modularRuntime) {
+      if (load.metadata.format == 'cjs')
+        throw new TypeError('plugin-babel does not support modular runtime for CJS module transpilations. Set babelOptions.modularRuntime: false if needed.');
+      presets.push(runtimeTransform);
+    }
+    else {
+      if (load.metadata.format == 'cjs')
+        load.source = 'var babelHelpers = require("' + externalHelpersPath + '");' + load.source;
+      else
+        load.source = 'import babelHelpers from "' + externalHelpersPath + '";' + load.source;
+      presets.push(externalHelpers);
+    }
+
+    if (babelOptions.es2015)
+      presets.push((outputESM || load.metadata.format == 'cjs') ? es2015 : es2015Register);
+    else if (!(outputESM || load.metadata.format == 'cjs'))
+      presets.push(modulesRegister);
+
+    if (babelOptions.stage3)
+      presets.push({
+        plugins: stage3
+      });
+
+    if (babelOptions.stage2)
+      presets.push({
+        plugins: stage2
+      });
+
+    if (babelOptions.stage1)
+      presets.push({
+        plugins: stage1
+      });
+
+    if (babelOptions.react)
+      presets.push({
+        plugins: react
+      });
+
+    if (babelOptions.presets)
+      babelOptions.presets.forEach(function(preset) {
+        if (typeof preset == 'string')
+          presets.push(pluginAndPresetModules[curPluginOrPresetModule++]);
+        else
+          presets.push(preset);
+      });
+
+    if (babelOptions.plugins)
+      babelOptions.plugins.forEach(function(plugin) {
+        if (typeof plugin == 'string')
+          plugins.push(pluginAndPresetModules[curPluginOrPresetModule++]);
+        else if (Array.isArray(plugin) && typeof plugin[0] == 'string')
+          plugins.push([pluginAndPresetModules[curPluginOrPresetModule++], plugin[1]]);
+        else
+          plugins.push(plugin);
+      });
+
+    var output = babel.transform(load.source, {
+      babelrc: false,
+      plugins: plugins,
+      presets: presets,
+      filename: load.address,
+      sourceFileName: load.address,
+      moduleIds: false,
+      sourceMaps: traceOpts && traceOpts.sourceMaps || babelOptions.sourceMaps,
+      inputSourceMap: load.metadata.sourceMap,
+      compact: babelOptions.compact,
+      comments: babelOptions.comments,
+      code: true,
+      ast: true,
+      resolveModuleSource: function(m) {
+        if (m.substr(0, 22) == 'babel-runtime/helpers/') {
+          m = modularHelpersPath + m.substr(22) + '.js';
+        }
+        else if (m == 'babel-runtime/regenerator') {
+          m = regeneratorRuntimePath;
+        }
+        else if (m.substr(0, 14) == 'babel-runtime/') {
+          if (!babelRuntimePath) {
+            babelRuntimePath = System.decanonicalize('babel-runtime/', module.id);
+            if (babelRuntimePath[babelRuntimePath.length - 1] !== '/')
+              babelRuntimePath += '/';
+            if (babelRuntimePath.substr(babelRuntimePath.length - 3, 3) == '.js')
+              babelRuntimePath = babelRuntimePath.substr(0, babelRuntimePath.length - 3);
+            if (loader.getCanonicalName)
+              babelRuntimePath = loader.getCanonicalName(babelRuntimePath);
+            if (babelRuntimePath == 'babel-runtime/')
+              throw new Error('The babel-runtime module must be mapped to support modular helpers and builtins. If using jspm run jspm install npm:babel-runtime.');
+          }
+          m = babelRuntimePath + m.substr(14) + '.js';
+        }
+        return m;
+      }
+    });
+
+    // add babelHelpers as a dependency for non-modular runtime
+    if (!babelOptions.modularRuntime)
+      load.metadata.deps.push(externalHelpersPath);
+
+    // set output module format
+    // (in builder we output modules as esm)
+    if (!load.metadata.format || load.metadata.format == 'detect' || load.metadata.format == 'esm')
+      load.metadata.format = outputESM ? 'esm' : 'register';
+
+    load.metadata.sourceMap = output.map;
+
+    return output.code;
+  });
+};

lib/3rdparty/systemjs/system-config-es2015.js

@@ -0,0 +1,23 @@
+SystemJS.config({
+    baseURL: '../../',
+    map: {
+        'plugin-babel': 'lib/3rdparty/systemjs/plugin-babel.js',
+        'systemjs-babel-build': 'lib/3rdparty/systemjs/systemjs-babel-browser.js',
+        '3rdparty': 'lib/3rdparty/3rdparty.js',
+        /* Don't know why these should be mapped?!? */
+        'd3-selection': 'lib/3rdparty/d3/d3.js',
+        'd3-transition': 'lib/3rdparty/d3/d3.js',
+        'TweenLite': 'lib/3rdparty/greensock/src/uncompressed/TweenLite.js',
+        'CustomEase': 'lib/3rdparty/greensock/src/uncompressed/easing/CustomEase.js',
+        'CSSPlugin': 'lib/3rdparty/greensock/src/uncompressed/plugins/CSSPlugin.js'
+    },
+    transpiler: 'plugin-babel',
+    meta: {
+        '*.js': {
+            authorization: true,
+            babelOptions: {
+                es2015: true
+            }
+        }
+    }
+})

lib/3rdparty/systemjs/system-config.js

@@ -0,0 +1,23 @@
+SystemJS.config({
+	baseURL: '../../',
+	map: {
+		"plugin-babel": "lib/3rdparty/systemjs/plugin-babel.js",
+		"systemjs-babel-build": "lib/3rdparty/systemjs/systemjs-babel-browser.js",
+		"3rdparty": "lib/3rdparty/3rdparty.js",
+		/* Don't know why these should be mapped?!? */
+		"d3-selection": "lib/3rdparty/d3/d3.js",
+		"d3-transition": "lib/3rdparty/d3/d3.js",
+		"TweenLite": "lib/3rdparty/greensock/src/uncompressed/TweenLite.js",
+		"CustomEase": "lib/3rdparty/greensock/src/uncompressed/easing/CustomEase.js",
+		"CSSPlugin": "lib/3rdparty/greensock/src/uncompressed/plugins/CSSPlugin.js"
+	},
+	transpiler: "plugin-babel",
+	meta: {
+		"*.js": {
+			authorization: true,
+			babelOptions: {
+				es2015: false
+			}
+		}
+	}
+})