From 3df5de2449f14dad41d0fdf0ee281d176b0b141c Mon Sep 17 00:00:00 2001
From: guybedford <guybedford@gmail.com>
Date: Wed, 1 Apr 2015 01:38:23 +0200
Subject: [PATCH] minimal loader build, first attempt

---
 Gruntfile.js                  |  73 ++---
 package.json                  |   2 -
 src/declarative.js            | 284 +++++++++++++++++
 src/dynamic-only.js           |  30 ++
 src/loader.js                 | 306 +-----------------
 src/module-tag.js             |  39 +++
 src/polyfill-wrapper-end.js   |   2 +
 src/polyfill-wrapper-start.js |  35 +--
 src/register.js               | 566 ++++++++++++++++++++++++++++++++++
 src/system.js                 | 259 +++++++---------
 src/transpiler.js             |  14 +-
 11 files changed, 1090 insertions(+), 520 deletions(-)
 create mode 100644 src/declarative.js
 create mode 100644 src/dynamic-only.js
 create mode 100644 src/module-tag.js
 create mode 100644 src/register.js

diff --git a/Gruntfile.js b/Gruntfile.js
index 3259e20..0d0b950 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -20,48 +20,43 @@ module.exports = function (grunt) {
     concat: {
       dist: {
         files: {
+          'dist/<%= pkg.name %>-prod.src.js': [
+            'node_modules/when/es6-shim/Promise.js',
+            'src/polyfill-wrapper-start.js',
+            'src/loader.js',
+            'src/dynamic-only.js',
+            'src/system.js',
+            'src/polyfill-wrapper-end.js'
+          ],
+          'dist/<%= pkg.name %>-prod-sans-promises.src.js': [
+            'src/polyfill-wrapper-start.js',
+            'src/loader.js',
+            'src/dynamic-only.js',
+            'src/system.js',
+            'src/polyfill-wrapper-end.js'
+          ],
           'dist/<%= pkg.name %>.src.js': [
             'node_modules/when/es6-shim/Promise.js',
             'src/polyfill-wrapper-start.js',
-            'dist/<%= pkg.name %>.js',
+            'src/loader.js',
+            'src/declarative.js',
+            'src/transpiler.js',
+            'src/system.js',
+            'src/module-tag.js',
             'src/polyfill-wrapper-end.js'
           ],
           'dist/<%= pkg.name %>-sans-promises.src.js': [
             'src/polyfill-wrapper-start.js',
-            'dist/<%= pkg.name %>.js',
+            'src/loader.js',
+            'src/declarative.js',
+            'src/transpiler.js',
+            'src/system.js',
+            'src/module-tag.js',
             'src/polyfill-wrapper-end.js'
           ]
         }
       }
     },
-    esnext: {
-      dist: {
-        src: [
-          'src/loader.js',
-          'src/transpiler.js',
-          'src/system.js'
-        ],
-        dest: 'dist/<%= pkg.name %>.js'
-      }
-    },
-    'string-replace': {
-      dist: {
-        files: {
-          'dist/<%= pkg.name %>.js': 'dist/<%= pkg.name %>.js'
-        },
-        options: {
-          replacements:[{
-            pattern: 'var $__Object$getPrototypeOf = Object.getPrototypeOf;\n' +
-              'var $__Object$defineProperty = Object.defineProperty;\n' +
-              'var $__Object$create = Object.create;',
-            replacement: ''
-          }, {
-            pattern: '$__Object$getPrototypeOf(SystemLoader.prototype).constructor',
-            replacement: '$__super'
-          }]
-        }
-      }
-    },
     uglify: {
       options: {
         banner: '<%= meta.banner %>\n',
@@ -80,18 +75,26 @@ module.exports = function (grunt) {
       distSansPromises: {
         src: 'dist/<%= pkg.name %>-sans-promises.src.js',
         dest: 'dist/<%= pkg.name %>-sans-promises.js'
+      },
+      prodDist: {
+        options: {
+          banner: '<%= meta.banner %>\n'
+        },
+        src: 'dist/<%= pkg.name %>-prod.src.js',
+        dest: 'dist/<%= pkg.name %>-prod.js'
+      },
+      prodDistSansPromises: {
+        src: 'dist/<%= pkg.name %>-prod-sans-promises.src.js',
+        dest: 'dist/<%= pkg.name %>-prod-sans-promises.js'
       }
     }
   });
 
   grunt.loadNpmTasks('grunt-contrib-jshint');
   grunt.loadNpmTasks('grunt-contrib-uglify');
-  grunt.loadNpmTasks('grunt-esnext');
   grunt.loadNpmTasks('grunt-contrib-concat');
-  grunt.loadNpmTasks('grunt-string-replace');
 
   grunt.registerTask('lint', ['jshint']);
-  grunt.registerTask('compile', ['esnext', 'string-replace', 'concat']);
-  grunt.registerTask('default', [/*'jshint', */'esnext', 'string-replace', 
-                     'concat', 'uglify']);
+  grunt.registerTask('compile', ['concat']);
+  grunt.registerTask('default', [/*'jshint', */'concat', 'uglify']);
 };
diff --git a/package.json b/package.json
index 044e09c..5c047e2 100644
--- a/package.json
+++ b/package.json
@@ -29,8 +29,6 @@
     "grunt-contrib-concat": "^0.5.0",
     "grunt-contrib-jshint": "~0.6.0",
     "grunt-contrib-uglify": "~0.6.0",
-    "grunt-esnext": "0.0.3",
-    "grunt-string-replace": "^0.2.7",
     "karma": "^0.12.28",
     "karma-benchmark": "^0.4.0",
     "karma-benchmark-reporter": "^0.1.1",
diff --git a/src/declarative.js b/src/declarative.js
new file mode 100644
index 0000000..c4d3025
--- /dev/null
+++ b/src/declarative.js
@@ -0,0 +1,284 @@
+/*
+ * ES6 Module Declarative Linking Code - Dev Build Only
+ */
+
+  // 15.2.5.3 Module Linking Groups
+
+  // 15.2.5.3.2 BuildLinkageGroups alternative implementation
+  // Adjustments (also see https://bugs.ecmascript.org/show_bug.cgi?id=2755)
+  // 1. groups is an already-interleaved array of group kinds
+  // 2. load.groupIndex is set when this function runs
+  // 3. load.groupIndex is the interleaved index ie 0 declarative, 1 dynamic, 2 declarative, ... (or starting with dynamic)
+  function buildLinkageGroups(load, loads, groups) {
+    groups[load.groupIndex] = groups[load.groupIndex] || [];
+
+    // if the load already has a group index and its in its group, its already been done
+    // this logic naturally handles cycles
+    if (indexOf.call(groups[load.groupIndex], load) != -1)
+      return;
+
+    // now add it to the group to indicate its been seen
+    groups[load.groupIndex].push(load);
+
+    for (var i = 0, l = loads.length; i < l; i++) {
+      var loadDep = loads[i];
+
+      // dependencies not found are already linked
+      for (var j = 0; j < load.dependencies.length; j++) {
+        if (loadDep.name == load.dependencies[j].value) {
+          // by definition all loads in linkset are loaded, not linked
+          console.assert(loadDep.status == 'loaded', 'Load in linkSet not loaded!');
+
+          // if it is a group transition, the index of the dependency has gone up
+          // otherwise it is the same as the parent
+          var loadDepGroupIndex = load.groupIndex + (loadDep.isDeclarative != load.isDeclarative);
+
+          // the group index of an entry is always the maximum
+          if (loadDep.groupIndex === undefined || loadDep.groupIndex < loadDepGroupIndex) {
+
+            // if already in a group, remove from the old group
+            if (loadDep.groupIndex !== undefined) {
+              groups[loadDep.groupIndex].splice(indexOf.call(groups[loadDep.groupIndex], loadDep), 1);
+
+              // if the old group is empty, then we have a mixed depndency cycle
+              if (groups[loadDep.groupIndex].length == 0)
+                throw new TypeError("Mixed dependency cycle detected");
+            }
+
+            loadDep.groupIndex = loadDepGroupIndex;
+          }
+
+          buildLinkageGroups(loadDep, loads, groups);
+        }
+      }
+    }
+  }
+
+  // 15.2.5.4
+  // declarative linking implementation
+  function link(linkSet, linkError) {
+
+    var loader = linkSet.loader;
+
+    if (!linkSet.loads.length)
+      return;
+
+    // console.log('linking {' + logloads(linkSet.loads) + '}');
+    // snapshot(loader);
+
+    // 15.2.5.3.1 LinkageGroups alternative implementation
+
+    // build all the groups
+    // because the first load represents the top of the tree
+    // for a given linkset, we can work down from there
+    var groups = [];
+    var startingLoad = linkSet.loads[0];
+    startingLoad.groupIndex = 0;
+    buildLinkageGroups(startingLoad, linkSet.loads, groups);
+
+    // determine the kind of the bottom group
+    var curGroupDeclarative = startingLoad.isDeclarative == groups.length % 2;
+
+    // run through the groups from bottom to top
+    for (var i = groups.length - 1; i >= 0; i--) {
+      var group = groups[i];
+      for (var j = 0; j < group.length; j++) {
+        var load = group[j];
+
+        // 15.2.5.5 LinkDeclarativeModules adjusted
+        if (curGroupDeclarative) {
+          linkDeclarativeModule(load, linkSet.loads, loader);
+        }
+        // 15.2.5.6 LinkDynamicModules adjusted
+        else {
+          var module = doDynamicExecute(linkSet, load, linkError);
+          if (!module)
+            return;
+          load.module = {
+            name: load.name,
+            module: module
+          };
+          load.status = 'linked';
+        }
+        finishLoad(loader, load);
+      }
+
+      // alternative current kind for next loop
+      curGroupDeclarative = !curGroupDeclarative;
+    }
+  }
+
+
+  // custom module records for binding graph
+  // store linking module records in a separate table
+  function getOrCreateModuleRecord(name, loader) {
+    var moduleRecords = loader.moduleRecords;
+    return moduleRecords[name] || (moduleRecords[name] = {
+      name: name,
+      dependencies: [],
+      module: new Module(), // start from an empty module and extend
+      importers: []
+    });
+  }
+
+  // custom declarative linking function
+  function linkDeclarativeModule(load, loads, loader) {
+    if (load.module)
+      return;
+
+    var module = load.module = getOrCreateModuleRecord(load.name, loader);
+    var moduleObj = load.module.module;
+
+    var registryEntry = load.declare.call(__global, function(name, value) {
+      // NB This should be an Object.defineProperty, but that is very slow.
+      //    By disaling this module write-protection we gain performance.
+      //    It could be useful to allow an option to enable or disable this.
+      module.locked = true;
+      moduleObj[name] = value;
+
+      for (var i = 0, l = module.importers.length; i < l; i++) {
+        var importerModule = module.importers[i];
+        if (!importerModule.locked) {
+          var importerIndex = indexOf.call(importerModule.dependencies, module);
+          importerModule.setters[importerIndex](moduleObj);
+        }
+      }
+
+      module.locked = false;
+      return value;
+    });
+
+    // setup our setters and execution function
+    module.setters = registryEntry.setters;
+    module.execute = registryEntry.execute;
+
+    // now link all the module dependencies
+    // amending the depMap as we go
+    for (var i = 0, l = load.dependencies.length; i < l; i++) {
+      var depName = load.dependencies[i].value;
+      var depModule = loader.modules[depName];
+
+      // if dependency not already in the module registry
+      // then try and link it now
+      if (!depModule) {
+        // get the dependency load record
+        for (var j = 0; j < loads.length; j++) {
+          if (loads[j].name != depName)
+            continue;
+
+          // only link if already not already started linking (stops at circular / dynamic)
+          if (!loads[j].module) {
+            linkDeclarativeModule(loads[j], loads, loader);
+            depModule = loads[j].module;
+          }
+          // if circular, create the module record
+          else {
+            depModule = getOrCreateModuleRecord(depName, loader);
+          }
+        }
+      }
+
+      // only declarative modules have dynamic bindings
+      if (depModule.importers) {
+        module.dependencies.push(depModule);
+        depModule.importers.push(module);
+      }
+      else {
+        // track dynamic records as null module records as already linked
+        module.dependencies.push(null);
+      }
+
+      // run the setter for this dependency
+      if (module.setters[i])
+        module.setters[i](depModule.module);
+    }
+
+    load.status = 'linked';
+  }
+
+  /*
+   * Module Object non-exotic for ES5:
+   *
+   * module.module        bound module object
+   * module.execute       execution function for module
+   * module.dependencies  list of module objects for dependencies
+   * See getOrCreateModuleRecord for all properties
+   *
+   */
+  function doExecute(module) {
+    try {
+      module.execute.call(__global);
+    }
+    catch(e) {
+      return e;
+    }
+  }
+
+  // 15.2.5.5.1 LinkImports not implemented
+  // 15.2.5.7 ResolveExportEntries not implemented
+  // 15.2.5.8 ResolveExports not implemented
+  // 15.2.5.9 ResolveExport not implemented
+  // 15.2.5.10 ResolveImportEntries not implemented
+
+  // 15.2.6.1
+  function evaluateLoadedModule(loader, load) {
+    console.assert(load.status == 'linked', 'is linked ' + load.name);
+
+    doEnsureEvaluated(load.module, [], loader);
+    return load.module.module;
+  }
+
+  // propogate execution errors
+  // see https://bugs.ecmascript.org/show_bug.cgi?id=2993
+  function doEnsureEvaluated(module, seen, loader) {
+    var err = ensureEvaluated(module, seen, loader);
+    if (err)
+      throw err;
+  }
+  // 15.2.6.2 EnsureEvaluated adjusted
+  function ensureEvaluated(module, seen, loader) {
+    if (module.evaluated || !module.dependencies)
+      return;
+
+    seen.push(module);
+
+    var deps = module.dependencies;
+    var err;
+
+    for (var i = 0, l = deps.length; i < l; i++) {
+      var dep = deps[i];
+      // dynamic dependencies are empty in module.dependencies
+      // as they are already linked
+      if (!dep)
+        continue;
+      if (indexOf.call(seen, dep) == -1) {
+        err = ensureEvaluated(dep, seen, loader);
+        // stop on error, see https://bugs.ecmascript.org/show_bug.cgi?id=2996
+        if (err) {
+          err = addToError(err, 'Error evaluating ' + dep.name + '\n');
+          return err;
+        }
+      }
+    }
+
+    if (module.failed)
+      return new Error('Module failed execution.');
+
+    if (module.evaluated)
+      return;
+
+    module.evaluated = true;
+    err = doExecute(module);
+    if (err) {
+      module.failed = true;
+    }
+    else if (Object.preventExtensions) {
+      // spec variation
+      // we don't create a new module here because it was created and ammended
+      // we just disable further extensions instead
+      Object.preventExtensions(module.module);
+    }
+
+    module.execute = undefined;
+    return err;
+  }
\ No newline at end of file
diff --git a/src/dynamic-only.js b/src/dynamic-only.js
new file mode 100644
index 0000000..2945df8
--- /dev/null
+++ b/src/dynamic-only.js
@@ -0,0 +1,30 @@
+/*
+ * Dynamic-only Linking Code
+ */
+
+  // 15.2.5.4
+  // dynamic-only linking implementation
+  function link(linkSet, linkError) {
+    
+    var loader = linkSet.loader;
+
+    if (!linkSet.loads.length)
+      return;
+
+    for (var i = 0; i < linkSet.loads.length; i++) {
+      var load = linkSet.loads[i];
+      var module = doDynamicExecute(linkSet, load, linkError);
+      if (!module)
+        return;
+      load.module = {
+        name: load.name,
+        module: module
+      };
+      load.status = 'linked';
+      finishLoad(loader, load);
+    }
+  }
+
+  function evaluateLoadedModule(loader, load) {
+    return load.module.module;
+  }
\ No newline at end of file
diff --git a/src/loader.js b/src/loader.js
index 11ee8dc..922c3ad 100644
--- a/src/loader.js
+++ b/src/loader.js
@@ -100,9 +100,6 @@ function logloads(loads) {
     }
   }
 } */
-
-
-(function() {
   var Promise = __global.Promise || require('when/es6-shim/Promise');
   if (__global.console)
     console.assert = console.assert || function() {};
@@ -116,7 +113,22 @@ function logloads(loads) {
     }
     return -1;
   };
-  var defineProperty = $__Object$defineProperty;
+  
+  var defineProperty;
+  (function () {
+    try {
+      if (!!Object.defineProperty({}, 'a', {}))
+        defineProperty = Object.defineProperty;
+    }
+    catch (e) {
+      defineProperty = function(obj, prop, opt) {
+        try {
+          obj[prop] = opt.value || opt.get.call(obj);
+        }
+        catch(e) {}
+      }
+    }
+  })();
 
   // 15.2.3 - Runtime Semantics: Loader State
 
@@ -246,7 +258,7 @@ function logloads(loads) {
 
           // instead of load.kind, use load.isDeclarative
           load.isDeclarative = true;
-          return loader.loaderObj.transpile(load)
+          return transpile.call(loader.loaderObj, load)
           .then(function(transpiled) {
             // Hijack System.register to set declare function
             var curSystem = __global.System;
@@ -575,58 +587,6 @@ function logloads(loads) {
     load.linkSets.splice(0, load.linkSets.length);
   }
 
-  // 15.2.5.3 Module Linking Groups
-
-  // 15.2.5.3.2 BuildLinkageGroups alternative implementation
-  // Adjustments (also see https://bugs.ecmascript.org/show_bug.cgi?id=2755)
-  // 1. groups is an already-interleaved array of group kinds
-  // 2. load.groupIndex is set when this function runs
-  // 3. load.groupIndex is the interleaved index ie 0 declarative, 1 dynamic, 2 declarative, ... (or starting with dynamic)
-  function buildLinkageGroups(load, loads, groups) {
-    groups[load.groupIndex] = groups[load.groupIndex] || [];
-
-    // if the load already has a group index and its in its group, its already been done
-    // this logic naturally handles cycles
-    if (indexOf.call(groups[load.groupIndex], load) != -1)
-      return;
-
-    // now add it to the group to indicate its been seen
-    groups[load.groupIndex].push(load);
-
-    for (var i = 0, l = loads.length; i < l; i++) {
-      var loadDep = loads[i];
-
-      // dependencies not found are already linked
-      for (var j = 0; j < load.dependencies.length; j++) {
-        if (loadDep.name == load.dependencies[j].value) {
-          // by definition all loads in linkset are loaded, not linked
-          console.assert(loadDep.status == 'loaded', 'Load in linkSet not loaded!');
-
-          // if it is a group transition, the index of the dependency has gone up
-          // otherwise it is the same as the parent
-          var loadDepGroupIndex = load.groupIndex + (loadDep.isDeclarative != load.isDeclarative);
-
-          // the group index of an entry is always the maximum
-          if (loadDep.groupIndex === undefined || loadDep.groupIndex < loadDepGroupIndex) {
-
-            // if already in a group, remove from the old group
-            if (loadDep.groupIndex !== undefined) {
-              groups[loadDep.groupIndex].splice(indexOf.call(groups[loadDep.groupIndex], loadDep), 1);
-
-              // if the old group is empty, then we have a mixed depndency cycle
-              if (groups[loadDep.groupIndex].length == 0)
-                throw new TypeError("Mixed dependency cycle detected");
-            }
-
-            loadDep.groupIndex = loadDepGroupIndex;
-          }
-
-          buildLinkageGroups(loadDep, loads, groups);
-        }
-      }
-    }
-  }
-
   function doDynamicExecute(linkSet, load, linkError) {
     try {
       var module = load.execute();
@@ -641,236 +601,6 @@ function logloads(loads) {
       return module;
   }
 
-  // 15.2.5.4
-  function link(linkSet, linkError) {
-
-    var loader = linkSet.loader;
-
-    if (!linkSet.loads.length)
-      return;
-
-    // console.log('linking {' + logloads(linkSet.loads) + '}');
-    // snapshot(loader);
-
-    // 15.2.5.3.1 LinkageGroups alternative implementation
-
-    // build all the groups
-    // because the first load represents the top of the tree
-    // for a given linkset, we can work down from there
-    var groups = [];
-    var startingLoad = linkSet.loads[0];
-    startingLoad.groupIndex = 0;
-    buildLinkageGroups(startingLoad, linkSet.loads, groups);
-
-    // determine the kind of the bottom group
-    var curGroupDeclarative = startingLoad.isDeclarative == groups.length % 2;
-
-    // run through the groups from bottom to top
-    for (var i = groups.length - 1; i >= 0; i--) {
-      var group = groups[i];
-      for (var j = 0; j < group.length; j++) {
-        var load = group[j];
-
-        // 15.2.5.5 LinkDeclarativeModules adjusted
-        if (curGroupDeclarative) {
-          linkDeclarativeModule(load, linkSet.loads, loader);
-        }
-        // 15.2.5.6 LinkDynamicModules adjusted
-        else {
-          var module = doDynamicExecute(linkSet, load, linkError);
-          if (!module)
-            return;
-          load.module = {
-            name: load.name,
-            module: module
-          };
-          load.status = 'linked';
-        }
-        finishLoad(loader, load);
-      }
-
-      // alternative current kind for next loop
-      curGroupDeclarative = !curGroupDeclarative;
-    }
-  }
-
-
-  // custom module records for binding graph
-  // store linking module records in a separate table
-  function getOrCreateModuleRecord(name, loader) {
-    var moduleRecords = loader.moduleRecords;
-    return moduleRecords[name] || (moduleRecords[name] = {
-      name: name,
-      dependencies: [],
-      module: new Module(), // start from an empty module and extend
-      importers: []
-    });
-  }
-
-  // custom declarative linking function
-  function linkDeclarativeModule(load, loads, loader) {
-    if (load.module)
-      return;
-
-    var module = load.module = getOrCreateModuleRecord(load.name, loader);
-    var moduleObj = load.module.module;
-
-    var registryEntry = load.declare.call(__global, function(name, value) {
-      // NB This should be an Object.defineProperty, but that is very slow.
-      //    By disaling this module write-protection we gain performance.
-      //    It could be useful to allow an option to enable or disable this.
-      module.locked = true;
-      moduleObj[name] = value;
-
-      for (var i = 0, l = module.importers.length; i < l; i++) {
-        var importerModule = module.importers[i];
-        if (!importerModule.locked) {
-          var importerIndex = indexOf.call(importerModule.dependencies, module);
-          importerModule.setters[importerIndex](moduleObj);
-        }
-      }
-
-      module.locked = false;
-      return value;
-    });
-
-    // setup our setters and execution function
-    module.setters = registryEntry.setters;
-    module.execute = registryEntry.execute;
-
-    // now link all the module dependencies
-    // amending the depMap as we go
-    for (var i = 0, l = load.dependencies.length; i < l; i++) {
-      var depName = load.dependencies[i].value;
-      var depModule = loader.modules[depName];
-
-      // if dependency not already in the module registry
-      // then try and link it now
-      if (!depModule) {
-        // get the dependency load record
-        for (var j = 0; j < loads.length; j++) {
-          if (loads[j].name != depName)
-            continue;
-
-          // only link if already not already started linking (stops at circular / dynamic)
-          if (!loads[j].module) {
-            linkDeclarativeModule(loads[j], loads, loader);
-            depModule = loads[j].module;
-          }
-          // if circular, create the module record
-          else {
-            depModule = getOrCreateModuleRecord(depName, loader);
-          }
-        }
-      }
-
-      // only declarative modules have dynamic bindings
-      if (depModule.importers) {
-        module.dependencies.push(depModule);
-        depModule.importers.push(module);
-      }
-      else {
-        // track dynamic records as null module records as already linked
-        module.dependencies.push(null);
-      }
-
-      // run the setter for this dependency
-      if (module.setters[i])
-        module.setters[i](depModule.module);
-    }
-
-    load.status = 'linked';
-  }
-
-
-
-  // 15.2.5.5.1 LinkImports not implemented
-  // 15.2.5.7 ResolveExportEntries not implemented
-  // 15.2.5.8 ResolveExports not implemented
-  // 15.2.5.9 ResolveExport not implemented
-  // 15.2.5.10 ResolveImportEntries not implemented
-
-  // 15.2.6.1
-  function evaluateLoadedModule(loader, load) {
-    console.assert(load.status == 'linked', 'is linked ' + load.name);
-
-    doEnsureEvaluated(load.module, [], loader);
-    return load.module.module;
-  }
-
-  /*
-   * Module Object non-exotic for ES5:
-   *
-   * module.module        bound module object
-   * module.execute       execution function for module
-   * module.dependencies  list of module objects for dependencies
-   * See getOrCreateModuleRecord for all properties
-   *
-   */
-  function doExecute(module) {
-    try {
-      module.execute.call(__global);
-    }
-    catch(e) {
-      return e;
-    }
-  }
-
-  // propogate execution errors
-  // see https://bugs.ecmascript.org/show_bug.cgi?id=2993
-  function doEnsureEvaluated(module, seen, loader) {
-    var err = ensureEvaluated(module, seen, loader);
-    if (err)
-      throw err;
-  }
-  // 15.2.6.2 EnsureEvaluated adjusted
-  function ensureEvaluated(module, seen, loader) {
-    if (module.evaluated || !module.dependencies)
-      return;
-
-    seen.push(module);
-
-    var deps = module.dependencies;
-    var err;
-
-    for (var i = 0, l = deps.length; i < l; i++) {
-      var dep = deps[i];
-      // dynamic dependencies are empty in module.dependencies
-      // as they are already linked
-      if (!dep)
-        continue;
-      if (indexOf.call(seen, dep) == -1) {
-        err = ensureEvaluated(dep, seen, loader);
-        // stop on error, see https://bugs.ecmascript.org/show_bug.cgi?id=2996
-        if (err) {
-          err = addToError(err, 'Error evaluating ' + dep.name + '\n');
-          return err;
-        }
-      }
-    }
-
-    if (module.failed)
-      return new Error('Module failed execution.');
-
-    if (module.evaluated)
-      return;
-
-    module.evaluated = true;
-    err = doExecute(module);
-    if (err) {
-      module.failed = true;
-    }
-    else if (Object.preventExtensions) {
-      // spec variation
-      // we don't create a new module here because it was created and ammended
-      // we just disable further extensions instead
-      Object.preventExtensions(module.module);
-    }
-
-    module.execute = undefined;
-    return err;
-  }
-
   function addToError(err, msg) {
     if (err instanceof Error)
       err.message = msg + err.message;
@@ -1087,5 +817,3 @@ function logloads(loads) {
   __global.Reflect.global = __global.Reflect.global || __global;
   __global.LoaderPolyfill = Loader;
 
-})();
-
diff --git a/src/module-tag.js b/src/module-tag.js
new file mode 100644
index 0000000..a5a4013
--- /dev/null
+++ b/src/module-tag.js
@@ -0,0 +1,39 @@
+  // <script type="module"> support
+  // allow a data-init function callback once loaded
+  if (isBrowser && typeof document.getElementsByTagName != 'undefined') {
+    var curScript = document.getElementsByTagName('script');
+    curScript = curScript[curScript.length - 1];
+
+    function completed() {
+      document.removeEventListener( "DOMContentLoaded", completed, false );
+      window.removeEventListener( "load", completed, false );
+      ready();
+    }
+
+    function ready() {
+      var scripts = document.getElementsByTagName('script');
+      for (var i = 0; i < scripts.length; i++) {
+        var script = scripts[i];
+        if (script.type == 'module') {
+          var source = script.innerHTML.substr(1);
+          // It is important to reference the global System, rather than the one
+          // in our closure. We want to ensure that downstream users/libraries
+          // can override System w/ custom behavior.
+          System.module(source)['catch'](function(err) { setTimeout(function() { throw err; }); });
+        }
+      }
+    }
+
+    // DOM ready, taken from https://github.com/jquery/jquery/blob/master/src/core/ready.js#L63
+    if (document.readyState === 'complete') {
+      setTimeout(ready);
+    }
+    else if (document.addEventListener) {
+      document.addEventListener('DOMContentLoaded', completed, false);
+      window.addEventListener('load', completed, false);
+    }
+
+    // run the data-init function on the script tag
+    if (curScript.getAttribute('data-init'))
+      window[curScript.getAttribute('data-init')]();
+  }
\ No newline at end of file
diff --git a/src/polyfill-wrapper-end.js b/src/polyfill-wrapper-end.js
index 3c9766d..f12841e 100644
--- a/src/polyfill-wrapper-end.js
+++ b/src/polyfill-wrapper-end.js
@@ -1,4 +1,6 @@
 
+})();
+
 // Define our eval outside of the scope of any other reference defined in this
 // file to avoid adding those references to the evaluation scope.
 function __eval(__source, __global, __load) {
diff --git a/src/polyfill-wrapper-start.js b/src/polyfill-wrapper-start.js
index ed084bf..e7ef021 100644
--- a/src/polyfill-wrapper-start.js
+++ b/src/polyfill-wrapper-start.js
@@ -1,35 +1,2 @@
 (function(__global) {
-  
-$__Object$getPrototypeOf = Object.getPrototypeOf || function(obj) {
-  return obj.__proto__;
-};
-
-var $__Object$defineProperty;
-(function () {
-  try {
-    if (!!Object.defineProperty({}, 'a', {})) {
-      $__Object$defineProperty = Object.defineProperty;
-    }
-  } catch (e) {
-    $__Object$defineProperty = function (obj, prop, opt) {
-      try {
-        obj[prop] = opt.value || opt.get.call(obj);
-      }
-      catch(e) {}
-    }
-  }
-}());
-
-$__Object$create = Object.create || function(o, props) {
-  function F() {}
-  F.prototype = o;
-
-  if (typeof(props) === "object") {
-    for (prop in props) {
-      if (props.hasOwnProperty((prop))) {
-        F[prop] = props[prop];
-      }
-    }
-  }
-  return new F();
-};
+  (function() {
\ No newline at end of file
diff --git a/src/register.js b/src/register.js
new file mode 100644
index 0000000..f1470bb
--- /dev/null
+++ b/src/register.js
@@ -0,0 +1,566 @@
+/*
+ * Instantiate registry extension
+ *
+ * Supports Traceur System.register 'instantiate' output for loading ES6 as ES5.
+ *
+ * - Creates the loader.register function
+ * - Also supports metadata.format = 'register' in instantiate for anonymous register modules
+ * - Also supports metadata.deps, metadata.execute and metadata.executingRequire
+ *     for handling dynamic modules alongside register-transformed ES6 modules
+ *
+ * Works as a standalone extension, but benefits from having a more 
+ * advanced __eval defined like in SystemJS polyfill-wrapper-end.js
+ *
+ * The code here replicates the ES6 linking groups algorithm to ensure that
+ * circular ES6 compiled into System.register can work alongside circular AMD 
+ * and CommonJS, identically to the actual ES6 loader.
+ *
+ */
+function register(loader) {
+  if (typeof indexOf == 'undefined')
+    indexOf = Array.prototype.indexOf;
+  if (typeof __eval == 'undefined' || typeof document != 'undefined' && !document.addEventListener)
+    __eval = 0 || eval; // uglify breaks without the 0 ||
+
+  loader._extensions = loader._extensions || [];
+  loader._extensions.push(register);
+
+  // define exec for easy evaluation of a load record (load.name, load.source, load.address)
+  // main feature is source maps support handling
+  var curSystem;
+  function exec(load) {
+    var loader = this;
+    // support sourceMappingURL (efficiently)
+    var sourceMappingURL;
+    var lastLineIndex = load.source.lastIndexOf('\n');
+    if (lastLineIndex != -1) {
+      if (load.source.substr(lastLineIndex + 1, 21) == '//# sourceMappingURL=') {
+        sourceMappingURL = load.source.substr(lastLineIndex + 22, load.source.length - lastLineIndex - 22);
+        if (typeof toAbsoluteURL != 'undefined')
+          sourceMappingURL = toAbsoluteURL(load.address, sourceMappingURL);
+      }
+    }
+
+    __eval(load.source, load.address, sourceMappingURL);
+  }
+  loader.__exec = exec;
+
+  function dedupe(deps) {
+    var newDeps = [];
+    for (var i = 0, l = deps.length; i < l; i++)
+      if (indexOf.call(newDeps, deps[i]) == -1)
+        newDeps.push(deps[i])
+    return newDeps;
+  }
+
+  /*
+   * There are two variations of System.register:
+   * 1. System.register for ES6 conversion (2-3 params) - System.register([name, ]deps, declare)
+   *    see https://github.com/ModuleLoader/es6-module-loader/wiki/System.register-Explained
+   *
+   * 2. System.register for dynamic modules (3-4 params) - System.register([name, ]deps, executingRequire, execute)
+   * the true or false statement 
+   *
+   * this extension implements the linking algorithm for the two variations identical to the spec
+   * allowing compiled ES6 circular references to work alongside AMD and CJS circular references.
+   *
+   */
+  // loader.register sets loader.defined for declarative modules
+  var anonRegister;
+  var calledRegister;
+  function registerModule(name, deps, declare, execute) {
+    if (typeof name != 'string') {
+      execute = declare;
+      declare = deps;
+      deps = name;
+      name = null;
+    }
+
+    calledRegister = true;
+    
+    var register;
+
+    // dynamic
+    if (typeof declare == 'boolean') {
+      register = {
+        declarative: false,
+        deps: deps,
+        execute: execute,
+        executingRequire: declare
+      };
+    }
+    else {
+      // ES6 declarative
+      register = {
+        declarative: true,
+        deps: deps,
+        declare: declare
+      };
+    }
+    
+    // named register
+    if (name) {
+      register.name = name;
+      // we never overwrite an existing define
+      if (!(name in loader.defined))
+        loader.defined[name] = register; 
+    }
+    // anonymous register
+    else if (register.declarative) {
+      if (anonRegister)
+        throw new TypeError('Multiple anonymous System.register calls in the same module file.');
+      anonRegister = register;
+    }
+  }
+  /*
+   * Registry side table - loader.defined
+   * Registry Entry Contains:
+   *    - name
+   *    - deps 
+   *    - declare for declarative modules
+   *    - execute for dynamic modules, different to declarative execute on module
+   *    - executingRequire indicates require drives execution for circularity of dynamic modules
+   *    - declarative optional boolean indicating which of the above
+   *
+   * Can preload modules directly on System.defined['my/module'] = { deps, execute, executingRequire }
+   *
+   * Then the entry gets populated with derived information during processing:
+   *    - normalizedDeps derived from deps, created in instantiate
+   *    - groupIndex used by group linking algorithm
+   *    - evaluated indicating whether evaluation has happend
+   *    - module the module record object, containing:
+   *      - exports actual module exports
+   *      
+   *    Then for declarative only we track dynamic bindings with the records:
+   *      - name
+   *      - setters declarative setter functions
+   *      - exports actual module values
+   *      - dependencies, module records of dependencies
+   *      - importers, module records of dependents
+   *
+   * After linked and evaluated, entries are removed, declarative module records remain in separate
+   * module binding table
+   *
+   */
+
+  function defineRegister(loader) {
+    if (loader.register)
+      return;
+
+    loader.register = registerModule;
+
+    if (!loader.defined)
+      loader.defined = {};
+    
+    // script injection mode calls this function synchronously on load
+    var onScriptLoad = loader.onScriptLoad;
+    loader.onScriptLoad = function(load) {
+      onScriptLoad(load);
+      // anonymous define
+      if (anonRegister)
+        load.metadata.entry = anonRegister;
+      
+      if (calledRegister) {
+        load.metadata.format = load.metadata.format || 'register';
+        load.metadata.registered = true;
+      }
+    }
+  }
+
+  defineRegister(loader);
+
+  function buildGroups(entry, loader, groups) {
+    groups[entry.groupIndex] = groups[entry.groupIndex] || [];
+
+    if (indexOf.call(groups[entry.groupIndex], entry) != -1)
+      return;
+
+    groups[entry.groupIndex].push(entry);
+
+    for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) {
+      var depName = entry.normalizedDeps[i];
+      var depEntry = loader.defined[depName];
+      
+      // not in the registry means already linked / ES6
+      if (!depEntry || depEntry.evaluated)
+        continue;
+      
+      // now we know the entry is in our unlinked linkage group
+      var depGroupIndex = entry.groupIndex + (depEntry.declarative != entry.declarative);
+
+      // the group index of an entry is always the maximum
+      if (depEntry.groupIndex === undefined || depEntry.groupIndex < depGroupIndex) {
+        
+        // if already in a group, remove from the old group
+        if (depEntry.groupIndex !== undefined) {
+          groups[depEntry.groupIndex].splice(indexOf.call(groups[depEntry.groupIndex], depEntry), 1);
+
+          // if the old group is empty, then we have a mixed depndency cycle
+          if (groups[depEntry.groupIndex].length == 0)
+            throw new TypeError("Mixed dependency cycle detected");
+        }
+
+        depEntry.groupIndex = depGroupIndex;
+      }
+
+      buildGroups(depEntry, loader, groups);
+    }
+  }
+
+  function link(name, loader) {
+    var startEntry = loader.defined[name];
+
+    // skip if already linked
+    if (startEntry.module)
+      return;
+
+    startEntry.groupIndex = 0;
+
+    var groups = [];
+
+    buildGroups(startEntry, loader, groups);
+
+    var curGroupDeclarative = !!startEntry.declarative == groups.length % 2;
+    for (var i = groups.length - 1; i >= 0; i--) {
+      var group = groups[i];
+      for (var j = 0; j < group.length; j++) {
+        var entry = group[j];
+
+        // link each group
+        if (curGroupDeclarative)
+          linkDeclarativeModule(entry, loader);
+        else
+          linkDynamicModule(entry, loader);
+      }
+      curGroupDeclarative = !curGroupDeclarative; 
+    }
+  }
+
+  // module binding records
+  var moduleRecords = {};
+  function getOrCreateModuleRecord(name) {
+    return moduleRecords[name] || (moduleRecords[name] = {
+      name: name,
+      dependencies: [],
+      exports: {}, // start from an empty module and extend
+      importers: []
+    })
+  }
+
+  function linkDeclarativeModule(entry, loader) {
+    // only link if already not already started linking (stops at circular)
+    if (entry.module)
+      return;
+
+    var module = entry.module = getOrCreateModuleRecord(entry.name);
+    var exports = entry.module.exports;
+
+    var declaration = entry.declare.call(loader.global, function(name, value) {
+      module.locked = true;
+      exports[name] = value;
+
+      for (var i = 0, l = module.importers.length; i < l; i++) {
+        var importerModule = module.importers[i];
+        if (!importerModule.locked) {
+          var importerIndex = indexOf.call(importerModule.dependencies, module);
+          importerModule.setters[importerIndex](exports);
+        }
+      }
+
+      module.locked = false;
+      return value;
+    });
+    
+    module.setters = declaration.setters;
+    module.execute = declaration.execute;
+
+    if (!module.setters || !module.execute) {
+      throw new TypeError('Invalid System.register form for ' + entry.name);
+    }
+
+    // now link all the module dependencies
+    for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) {
+      var depName = entry.normalizedDeps[i];
+      var depEntry = loader.defined[depName];
+      var depModule = moduleRecords[depName];
+
+      // work out how to set depExports based on scenarios...
+      var depExports;
+
+      if (depModule) {
+        depExports = depModule.exports;
+      }
+      // dynamic, already linked in our registry
+      else if (depEntry && !depEntry.declarative) {
+        if (depEntry.module.exports && depEntry.module.exports.__esModule)
+          depExports = depEntry.module.exports;
+        else
+          depExports = { 'default': depEntry.module.exports, '__useDefault': true };
+      }
+      // in the loader registry
+      else if (!depEntry) {
+        depExports = loader.get(depName);
+      }
+      // we have an entry -> link
+      else {
+        linkDeclarativeModule(depEntry, loader);
+        depModule = depEntry.module;
+        depExports = depModule.exports;
+      }
+
+      // only declarative modules have dynamic bindings
+      if (depModule && depModule.importers) {
+        depModule.importers.push(module);
+        module.dependencies.push(depModule);
+      }
+      else {
+        module.dependencies.push(null);
+      }
+
+      // run the setter for this dependency
+      if (module.setters[i])
+        module.setters[i](depExports);
+    }
+  }
+
+  // An analog to loader.get covering execution of all three layers (real declarative, simulated declarative, simulated dynamic)
+  function getModule(name, loader) {
+    var exports;
+    var entry = loader.defined[name];
+
+    if (!entry) {
+      exports = loader.get(name);
+      if (!exports)
+        throw new Error('Unable to load dependency ' + name + '.');
+    }
+
+    else {
+      if (entry.declarative)
+        ensureEvaluated(name, [], loader);
+    
+      else if (!entry.evaluated)
+        linkDynamicModule(entry, loader);
+
+      exports = entry.module.exports;
+    }
+
+    if ((!entry || entry.declarative) && exports && exports.__useDefault)
+      return exports['default'];
+    
+    return exports;
+  }
+
+  function linkDynamicModule(entry, loader) {
+    if (entry.module)
+      return;
+
+    var exports = {};
+
+    var module = entry.module = { exports: exports, id: entry.name };
+
+    // AMD requires execute the tree first
+    if (!entry.executingRequire) {
+      for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) {
+        var depName = entry.normalizedDeps[i];
+        var depEntry = loader.defined[depName];
+        if (depEntry)
+          linkDynamicModule(depEntry, loader);
+      }
+    }
+
+    // now execute
+    entry.evaluated = true;
+    var output = entry.execute.call(loader.global, function(name) {
+      for (var i = 0, l = entry.deps.length; i < l; i++) {
+        if (entry.deps[i] != name)
+          continue;
+        return getModule(entry.normalizedDeps[i], loader);
+      }
+      throw new TypeError('Module ' + name + ' not declared as a dependency.');
+    }, exports, module);
+    
+    if (output)
+      module.exports = output;
+  }
+
+  /*
+   * Given a module, and the list of modules for this current branch,
+   *  ensure that each of the dependencies of this module is evaluated
+   *  (unless one is a circular dependency already in the list of seen
+   *  modules, in which case we execute it)
+   *
+   * Then we evaluate the module itself depth-first left to right 
+   * execution to match ES6 modules
+   */
+  function ensureEvaluated(moduleName, seen, loader) {
+    var entry = loader.defined[moduleName];
+
+    // if already seen, that means it's an already-evaluated non circular dependency
+    if (!entry || entry.evaluated || !entry.declarative)
+      return;
+
+    // this only applies to declarative modules which late-execute
+
+    seen.push(moduleName);
+
+    for (var i = 0, l = entry.normalizedDeps.length; i < l; i++) {
+      var depName = entry.normalizedDeps[i];
+      if (indexOf.call(seen, depName) == -1) {
+        if (!loader.defined[depName])
+          loader.get(depName);
+        else
+          ensureEvaluated(depName, seen, loader);
+      }
+    }
+
+    if (entry.evaluated)
+      return;
+
+    entry.evaluated = true;
+    entry.module.execute.call(loader.global);
+  }
+
+  var registerRegEx = /System\.register/;
+
+  var loaderFetch = loader.fetch;
+  loader.fetch = function(load) {
+    var loader = this;
+    defineRegister(loader);
+    if (loader.defined[load.name]) {
+      load.metadata.format = 'defined';
+      return '';
+    }
+    anonRegister = null;
+    calledRegister = false;
+    // the above get picked up by onScriptLoad
+    return loaderFetch.call(loader, load);
+  }
+
+  var loaderTranslate = loader.translate;
+  loader.translate = function(load) {
+    this.register = registerModule;
+
+    this.__exec = exec;
+
+    load.metadata.deps = load.metadata.deps || [];
+
+    // we run the meta detection here (register is after meta)
+    return Promise.resolve(loaderTranslate.call(this, load)).then(function(source) {
+      
+      // dont run format detection for globals shimmed
+      // ideally this should be in the global extension, but there is
+      // currently no neat way to separate it
+      if (load.metadata.init || load.metadata.exports)
+        load.metadata.format = load.metadata.format || 'global';
+
+      // run detection for register format
+      if (load.metadata.format == 'register' || !load.metadata.format && load.source.match(registerRegEx))
+        load.metadata.format = 'register';
+      return source;
+    });
+  }
+
+
+  var loaderInstantiate = loader.instantiate;
+  loader.instantiate = function(load) {
+    var loader = this;
+
+    var entry;
+
+    // first we check if this module has already been defined in the registry
+    if (loader.defined[load.name]) {
+      entry = loader.defined[load.name];
+      entry.deps = entry.deps.concat(load.metadata.deps);
+    }
+
+    // picked up already by a script injection
+    else if (load.metadata.entry)
+      entry = load.metadata.entry;
+
+    // otherwise check if it is dynamic
+    else if (load.metadata.execute) {
+      entry = {
+        declarative: false,
+        deps: load.metadata.deps || [],
+        execute: load.metadata.execute,
+        executingRequire: load.metadata.executingRequire // NodeJS-style requires or not
+      };
+    }
+
+    // Contains System.register calls
+    else if (load.metadata.format == 'register') {
+      anonRegister = null;
+      calledRegister = false;
+
+      var curSystem = loader.global.System;
+
+      loader.global.System = loader;
+
+      loader.__exec(load);
+
+      loader.global.System = curSystem;
+
+      if (anonRegister)
+        entry = anonRegister;
+
+      if (!entry && System.defined[load.name])
+        entry = System.defined[load.name];
+
+      if (!calledRegister && !load.metadata.registered)
+        throw new TypeError(load.name + ' detected as System.register but didn\'t execute.');
+    }
+
+    // named bundles are just an empty module
+    if (!entry && load.metadata.format != 'es6')
+      return {
+        deps: load.metadata.deps,
+        execute: function() {
+          return loader.newModule({});
+        }
+      };
+
+    // place this module onto defined for circular references
+    if (entry)
+      loader.defined[load.name] = entry;
+
+    // no entry -> treat as ES6
+    else
+      return loaderInstantiate.call(this, load);
+
+    entry.deps = dedupe(entry.deps);
+    entry.name = load.name;
+
+    // first, normalize all dependencies
+    var normalizePromises = [];
+    for (var i = 0, l = entry.deps.length; i < l; i++)
+      normalizePromises.push(Promise.resolve(loader.normalize(entry.deps[i], load.name)));
+
+    return Promise.all(normalizePromises).then(function(normalizedDeps) {
+
+      entry.normalizedDeps = normalizedDeps;
+
+      return {
+        deps: entry.deps,
+        execute: function() {
+          // recursively ensure that the module and all its 
+          // dependencies are linked (with dependency group handling)
+          link(load.name, loader);
+
+          // now handle dependency execution in correct order
+          ensureEvaluated(load.name, [], loader);
+
+          // remove from the registry
+          loader.defined[load.name] = undefined;
+
+          var module = entry.module.exports;
+
+          if (!module || !entry.declarative && module.__esModule !== true)
+            module = { 'default': module, __useDefault: true };
+
+          // return the defined module object
+          return loader.newModule(module);
+        }
+      };
+    });
+  }
+}
diff --git a/src/system.js b/src/system.js
index 3c4d506..1c34bf4 100644
--- a/src/system.js
+++ b/src/system.js
@@ -10,9 +10,8 @@
 *********************************************************************************************
 */
 
-(function() {
-
-  var isBrowser = typeof window != 'undefined' && typeof document != 'undefined';
+  var isWorker = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
+  var isBrowser = typeof window != 'undefined' && !isWorker;
   var isWindows = typeof process != 'undefined' && !!process.platform.match(/^win/);
   var Promise = __global.Promise || require('when/es6-shim/Promise');
 
@@ -132,139 +131,136 @@
     throw new TypeError('No environment fetch API available.');
   }
 
-  class SystemLoader extends __global.LoaderPolyfill {
-
-    constructor(options) {
-      super(options || {});
+  var SystemLoader = function(options) {
+    Loader.call(this, options || {});
 
-      // Set default baseURL and paths
-      if (typeof location != 'undefined' && location.href) {
-        var href = __global.location.href.split('#')[0].split('?')[0];
-        this.baseURL = href.substring(0, href.lastIndexOf('/') + 1);
-      }
-      else if (typeof process != 'undefined' && process.cwd) {
-        this.baseURL = 'file:' + process.cwd() + '/';
-        if (isWindows)
-          this.baseURL = this.baseURL.replace(/\\/g, '/');
-      }
-      else {
-        throw new TypeError('No environment baseURL');
-      }
-      this.paths = { '*': '*.js' };
+    // Set default baseURL and paths
+    if (typeof location != 'undefined' && location.href) {
+      var href = __global.location.href.split('#')[0].split('?')[0];
+      this.baseURL = href.substring(0, href.lastIndexOf('/') + 1);
     }
-
-    get global() {
-      return __global;
+    else if (typeof process != 'undefined' && process.cwd) {
+      this.baseURL = 'file:' + process.cwd() + '/';
+      if (isWindows)
+        this.baseURL = this.baseURL.replace(/\\/g, '/');
     }
-   
-    get strict() { return true; }
-
-    normalize(name, parentName, parentAddress) {
-      if (typeof name != 'string')
-        throw new TypeError('Module name must be a string');
-
-      var segments = name.split('/');
-
-      if (segments.length == 0)
-        throw new TypeError('No module name provided');
-
-      // current segment
-      var i = 0;
-      // is the module name relative
-      var rel = false;
-      // number of backtracking segments
-      var dotdots = 0;
-      if (segments[0] == '.') {
+    else {
+      throw new TypeError('No environment baseURL');
+    }
+    this.paths = { '*': '*.js' };
+  };
+
+  // inline Object.create-style class extension
+  function LoaderProto() {}
+  LoaderProto.prototype = Loader.prototype;
+  SystemLoader.prototype = new LoaderProto();
+
+  SystemLoader.prototype.global = isBrowser ? window : (isWorker ? self : __global);
+
+  SystemLoader.prototype.normalize = function(name, parentName, parentAddress) {
+    if (typeof name != 'string')
+      throw new TypeError('Module name must be a string');
+
+    var segments = name.split('/');
+
+    if (segments.length == 0)
+      throw new TypeError('No module name provided');
+
+    // current segment
+    var i = 0;
+    // is the module name relative
+    var rel = false;
+    // number of backtracking segments
+    var dotdots = 0;
+    if (segments[0] == '.') {
+      i++;
+      if (i == segments.length)
+        throw new TypeError('Illegal module name "' + name + '"');
+      rel = true;
+    }
+    else {
+      while (segments[i] == '..') {
         i++;
         if (i == segments.length)
           throw new TypeError('Illegal module name "' + name + '"');
-        rel = true;
-      }
-      else {
-        while (segments[i] == '..') {
-          i++;
-          if (i == segments.length)
-            throw new TypeError('Illegal module name "' + name + '"');
-        }
-        if (i)
-          rel = true;
-        dotdots = i;
       }
+      if (i)
+        rel = true;
+      dotdots = i;
+    }
 
-      for (var j = i; j < segments.length; j++) {
-        var segment = segments[j];
-        if (segment == '' || segment == '.' || segment == '..')
-          throw new TypeError('Illegal module name "' + name + '"');
-      }
+    for (var j = i; j < segments.length; j++) {
+      var segment = segments[j];
+      if (segment == '' || segment == '.' || segment == '..')
+        throw new TypeError('Illegal module name "' + name + '"');
+    }
 
-      if (!rel)
-        return name;
+    if (!rel)
+      return name;
 
-      // build the full module name
-      var normalizedParts = [];
-      var parentParts = (parentName || '').split('/');
-      var normalizedLen = parentParts.length - 1 - dotdots;
+    // build the full module name
+    var normalizedParts = [];
+    var parentParts = (parentName || '').split('/');
+    var normalizedLen = parentParts.length - 1 - dotdots;
 
-      normalizedParts = normalizedParts.concat(parentParts.splice(0, parentParts.length - 1 - dotdots));
-      normalizedParts = normalizedParts.concat(segments.splice(i, segments.length - i));
+    normalizedParts = normalizedParts.concat(parentParts.splice(0, parentParts.length - 1 - dotdots));
+    normalizedParts = normalizedParts.concat(segments.splice(i, segments.length - i));
 
-      return normalizedParts.join('/');
-    }
+    return normalizedParts.join('/');
+  }
 
-    locate(load) {
-      var name = load.name;
+  SystemLoader.prototype.locate = function(load) {
+    var name = load.name;
 
-      // NB no specification provided for System.paths, used ideas discussed in https://github.com/jorendorff/js-loaders/issues/25
+    // NB no specification provided for System.paths, used ideas discussed in https://github.com/jorendorff/js-loaders/issues/25
 
-      // most specific (longest) match wins
-      var pathMatch = '', wildcard;
+    // most specific (longest) match wins
+    var pathMatch = '', wildcard;
 
-      // check to see if we have a paths entry
-      for (var p in this.paths) {
-        var pathParts = p.split('*');
-        if (pathParts.length > 2)
-          throw new TypeError('Only one wildcard in a path is permitted');
+    // check to see if we have a paths entry
+    for (var p in this.paths) {
+      var pathParts = p.split('*');
+      if (pathParts.length > 2)
+        throw new TypeError('Only one wildcard in a path is permitted');
 
-        // exact path match
-        if (pathParts.length == 1) {
-          if (name == p && p.length > pathMatch.length) {
-            pathMatch = p;
-            break;
-          }
+      // exact path match
+      if (pathParts.length == 1) {
+        if (name == p && p.length > pathMatch.length) {
+          pathMatch = p;
+          break;
         }
+      }
 
-        // wildcard path match
-        else {
-          if (name.substr(0, pathParts[0].length) == pathParts[0] && name.substr(name.length - pathParts[1].length) == pathParts[1]) {
-            pathMatch = p;
-            wildcard = name.substr(pathParts[0].length, name.length - pathParts[1].length - pathParts[0].length);
-          }
+      // wildcard path match
+      else {
+        if (name.substr(0, pathParts[0].length) == pathParts[0] && name.substr(name.length - pathParts[1].length) == pathParts[1]) {
+          pathMatch = p;
+          wildcard = name.substr(pathParts[0].length, name.length - pathParts[1].length - pathParts[0].length);
         }
       }
+    }
 
-      var outPath = this.paths[pathMatch];
-      if (wildcard)
-        outPath = outPath.replace('*', wildcard);
-
-      // percent encode just '#' in module names
-      // according to https://github.com/jorendorff/js-loaders/blob/master/browser-loader.js#L238
-      // we should encode everything, but it breaks for servers that don't expect it 
-      // like in (https://github.com/systemjs/systemjs/issues/168)
-      if (isBrowser)
-        outPath = outPath.replace(/#/g, '%23');
+    var outPath = this.paths[pathMatch];
+    if (wildcard)
+      outPath = outPath.replace('*', wildcard);
 
-      return toAbsoluteURL(this.baseURL, outPath);
-    }
+    // percent encode just '#' in module names
+    // according to https://github.com/jorendorff/js-loaders/blob/master/browser-loader.js#L238
+    // we should encode everything, but it breaks for servers that don't expect it 
+    // like in (https://github.com/systemjs/systemjs/issues/168)
+    if (isBrowser)
+      outPath = outPath.replace(/#/g, '%23');
 
-    fetch(load) {
-      var self = this;
-      return new Promise(function(resolve, reject) {
-        fetchTextFromURL(toAbsoluteURL(self.baseURL, load.address), function(source) {
-          resolve(source);
-        }, reject);
-      });
-    }
+    return toAbsoluteURL(this.baseURL, outPath);
+  }
 
+  SystemLoader.prototype.fetch = function(load) {
+    var self = this;
+    return new Promise(function(resolve, reject) {
+      fetchTextFromURL(toAbsoluteURL(self.baseURL, load.address), function(source) {
+        resolve(source);
+      }, reject);
+    });
   }
 
   var System = new SystemLoader();
@@ -274,44 +270,3 @@
     module.exports = System;
 
   __global.System = System;
-
-  // <script type="module"> support
-  // allow a data-init function callback once loaded
-  if (isBrowser && document.getElementsByTagName) {
-    var curScript = document.getElementsByTagName('script');
-    curScript = curScript[curScript.length - 1];
-
-    function completed() {
-      document.removeEventListener( "DOMContentLoaded", completed, false );
-      window.removeEventListener( "load", completed, false );
-      ready();
-    }
-
-    function ready() {
-      var scripts = document.getElementsByTagName('script');
-      for (var i = 0; i < scripts.length; i++) {
-        var script = scripts[i];
-        if (script.type == 'module') {
-          var source = script.innerHTML.substr(1);
-          // It is important to reference the global System, rather than the one
-          // in our closure. We want to ensure that downstream users/libraries
-          // can override System w/ custom behavior.
-          __global.System.module(source)['catch'](function(err) { setTimeout(function() { throw err; }); });
-        }
-      }
-    }
-
-    // DOM ready, taken from https://github.com/jquery/jquery/blob/master/src/core/ready.js#L63
-    if (document.readyState === 'complete') {
-      setTimeout(ready);
-    }
-    else if (document.addEventListener) {
-      document.addEventListener('DOMContentLoaded', completed, false);
-      window.addEventListener('load', completed, false);
-    }
-
-    // run the data-init function on the script tag
-    if (curScript.getAttribute('data-init'))
-      window[curScript.getAttribute('data-init')]();
-  }
-})();
diff --git a/src/transpiler.js b/src/transpiler.js
index 30e4c22..913bd19 100644
--- a/src/transpiler.js
+++ b/src/transpiler.js
@@ -1,26 +1,27 @@
 /*
  * Traceur and Babel transpile hook for Loader
  */
-(function(Loader) {
   var g = __global;
 
   function getTranspilerModule(loader, globalName) {
     return loader.newModule({ 'default': g[globalName], __useDefault: true });
   }
+  // NB this does not support sub-classing well
+  var firstRun = true;
 
   // use Traceur by default
   Loader.prototype.transpiler = 'traceur';
 
-  Loader.prototype.transpile = function(load) {
+  function transpile(load) {
     var self = this;
 
     // pick up Transpiler modules from existing globals on first run if set
-    if (!self.transpilerHasRun) {
+    if (firstRun) {
       if (g.traceur && !self.has('traceur'))
         self.set('traceur', getTranspilerModule(self, 'traceur'));
       if (g.babel && !self.has('babel'))
         self.set('babel', getTranspilerModule(self, 'babel'));
-      self.transpilerHasRun = true;
+      firstRun = false;
     }
     
     return self['import'](self.transpiler).then(function(transpiler) {
@@ -94,7 +95,4 @@
     // add "!eval" to end of Babel sourceURL
     // I believe this does something?
     return source + '\n//# sourceURL=' + load.address + '!eval';
-  }
-
-
-})(__global.LoaderPolyfill);
+  }
\ No newline at end of file