├── .gitignore
├── .travis.yml
├── README.md
├── package.json
├── polyfill.js
├── rollup.config.js
├── src
    ├── msg.js
    ├── vendor
    │   ├── acorn.js
    │   └── escodegen.browser.js
    ├── window
    │   ├── cluster.js
    │   ├── dom.js
    │   ├── eval.js
    │   ├── execute.js
    │   ├── index.js
    │   ├── module-tools.js
    │   ├── modules.js
    │   ├── registry.js
    │   ├── spawn.js
    │   └── utils.js
    └── worker
    │   ├── acorn.js
    │   ├── assignment-expression.js
    │   ├── call-expression.js
    │   ├── export-all-declaration.js
    │   ├── export-default-declaration.js
    │   ├── export-named-declaration.js
    │   ├── export-set.js
    │   ├── identifier.js
    │   ├── import-call-identifier.js
    │   ├── import-declaration.js
    │   ├── index.js
    │   ├── module-tools.js
    │   ├── property.js
    │   ├── source-maps.js
    │   ├── utils.js
    │   └── visitors.js
├── test
    ├── all.html
    ├── circular.html
    ├── errors.html
    ├── everything.html
    ├── export-syntax.html
    ├── import-dynamic.html
    ├── import-syntax.html
    ├── inline-everything.html
    ├── perf
    │   └── app
    │   │   ├── config.js
    │   │   ├── generate.js
    │   │   ├── package.json
    │   │   ├── polyfill.html
    │   │   ├── steal.html
    │   │   ├── steal.js
    │   │   └── systemjs.html
    ├── scope.html
    └── tests
    │   ├── circular
    │       ├── basics.js
    │       ├── src
    │       │   ├── a.js
    │       │   ├── b.js
    │       │   ├── one.js
    │       │   ├── three.js
    │       │   └── two.js
    │       └── threeway.js
    │   ├── errors
    │       ├── ref
    │       │   ├── bad.js
    │       │   └── index.js
    │       └── sloppy
    │       │   └── index.js
    │   ├── everything
    │       ├── bar.js
    │       ├── folder
    │       │   ├── thing.js
    │       │   └── yet-another.js
    │       ├── foo.js
    │       ├── index.html
    │       └── other.js
    │   ├── exports
    │       ├── default.js
    │       ├── from.js
    │       ├── let.js
    │       ├── object.js
    │       └── src
    │       │   ├── default-expr.js
    │       │   ├── default-fn.js
    │       │   ├── default-obj-alias.js
    │       │   ├── default-object.js
    │       │   ├── from-as.js
    │       │   ├── from-name.js
    │       │   ├── from-source.js
    │       │   ├── from-source2.js
    │       │   ├── from-star.js
    │       │   ├── let-equal.js
    │       │   ├── let-use-export.js
    │       │   ├── let-var.js
    │       │   └── object-as.js
    │   ├── import-fn
    │       ├── dynamic.js
    │       ├── multi-arg.js
    │       ├── spread.js
    │       └── src
    │       │   ├── bar.js
    │       │   ├── baz.js
    │       │   ├── foo.js
    │       │   └── qux.js
    │   ├── imports
    │       ├── default-and-member.js
    │       ├── default-and-star.js
    │       ├── default.js
    │       ├── member-alias.js
    │       ├── members.js
    │       ├── side-effect.js
    │       ├── src
    │       │   ├── default-and-member.js
    │       │   ├── default-and-star.js
    │       │   ├── default.js
    │       │   ├── members.js
    │       │   ├── side-effect.js
    │       │   └── star.js
    │       └── star.js
    │   └── scope
    │       ├── main.js
    │       ├── src
    │           └── foo.js
    │       └── var.js
└── worker.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | test/perf/app/src/
3 | test/perf/app/node_modules/
4 | test/perf/app/jspm_packages/
5 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | 
 2 | language: node_js
 3 | node_js: 6.3
 4 | before_script:
 5 |   - npm install -g testee
 6 | script: npm test
 7 | before_install:
 8 |   - "export DISPLAY=:99.0"
 9 |   - "sh -e /etc/init.d/xvfb start"
10 | addons:
11 |   firefox: "49.0"
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # <script type=module> - the polyfill!
 2 | 
 3 | An attempt to build a polyfill for [\<script type="module"\>](https://blog.whatwg.org/js-modules). Because [the waiting](https://www.youtube.com/watch?v=uMyCa35_mOg) is the hardest part.
 4 | 
 5 | This polyfill includes:
 6 | 
 7 | * All `import` and `export` forms.
 8 | * Import bindings compliant with the spec; meaning a dependency can update its exported value and your module binding will reflect that change.
 9 | * A web worker architecture that allows for spawning multiple workers for faster load times (experimental).
10 | * Full source maps.
11 | 
12 | This is alpha-ish software that is tested, but not used for any real projects (yet). Check out the [tests/](https://github.com/matthewp/script-type-module/tree/master/test) folder to see what's been worked on, submit any issues you encounter.
13 | 
14 | This polyfill uses a different `type` "module-polyfill" to avoid constraining browser implementations.
15 | 
16 | ## Install
17 | 
18 | ```
19 | npm install script-type-module
20 | ```
21 | 
22 | ## Use
23 | 
24 | ```html
25 | <script src="./node_modules/script-type-module/polyfill.js"></script>
26 | 
27 | <script type="module-polyfill" src="./foo.js"></script>
28 | ```
29 | 
30 | ### Dynamic import
31 | 
32 | The [stage 2 import()](https://github.com/domenic/proposal-dynamic-import) proposal allows you to dynamically import code based on runtime considerations. This is useful if you want to delay loading parts of the application for any reason (such as based on user input).
33 | 
34 | This polyfill includes support for `import()`. Here's an example usage:
35 | 
36 | **/pages/home.js**
37 | 
38 | ```js
39 | export function page(){
40 |   let section = document.createElement('section');
41 |   section.innerHTML = `
42 |     <h1>Home</h1>
43 | 
44 |     <p>Welcome home!</p>
45 |   `;
46 | 
47 |   return section;
48 | }
49 | ```
50 | 
51 | **index.html**
52 | 
53 | ```html
54 | <main></main>
55 | 
56 | <script src="./node_modules/script-type-module/polyfill.js"></script>
57 | 
58 | <script type="module-polyfill">
59 |   let page = location.hash.substr(1);
60 | 
61 |   import(`./pages/${page}.js`).then(ns => {
62 |     document.querySelector('main').appendChild(ns.page());
63 |   });
64 | </script>
65 | ```
66 | 
67 | In this case we are dynamically inserting DOM based on the `location.hash`, so that if the URL is `http://example.com#home` the `/pages/home.js` module is dynamically imported and inserted into `<main>`.
68 | 
69 | ## FAQ
70 | 
71 | **Why use this instead of a bundler?**
72 | 
73 | Bundlers are not great for development workflows. Being able to create new `.html` pages to test out small parts of your application without creating a new build just for that, is a super powerful thing.
74 | 
75 | **Should I use this in production?**
76 | 
77 | No! This is primarily meant for better development workflows. Do a real build for production.
78 | 
79 | **How does this compare to es-module-loader?**
80 | 
81 | es-module-loader is a polyfill for the in progress [whatwg/loader](https://github.com/whatwg/loader) spec. This spec has been through several revisions going back many years and isn't likely to appear in browsers soon.
82 | 
83 | This polyfill is based on the already specified `<script type="module">` that is coming to browsers soon (in Edge developer preview already). The hope is that most evergreen browsers will have support within 6 months and this will only be used for testing on older browsers.
84 | 
85 | ## Licence
86 | 
87 | BSD 2 Clause
88 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "script-type-module",
 3 |   "version": "1.0.1",
 4 |   "description": "<script type=module> polyfill",
 5 |   "main": "script-type-module.js",
 6 |   "scripts": {
 7 |     "build:worker": "rollup -c rollup.config.js -o worker.js src/worker/index.js",
 8 |     "build:window": "npm run rollup:window && npm run prep",
 9 |     "rollup:window": "rollup -c rollup.config.js -o polyfill.js src/window/index.js",
10 |     "prep": "cat src/window/eval.js |cat - polyfill.js > /tmp/out && mv /tmp/out polyfill.js",
11 |     "build": "npm run build:worker && npm run build:window",
12 |     "test": "testee test/everything.html test/inline-everything.html test/import-syntax.html test/export-syntax.html test/scope.html test/circular.html test/errors.html test/import-dynamic.html --browsers firefox"
13 |   },
14 |   "repository": {
15 |     "type": "git",
16 |     "url": "git://github.com/matthewp/script-type-module.git"
17 |   },
18 |   "keywords": [
19 |     "script",
20 |     "module"
21 |   ],
22 |   "author": "Matthew Phillips",
23 |   "license": "BSD-2-Clause",
24 |   "bugs": {
25 |     "url": "https://github.com/matthewp/script-type-module/issues"
26 |   },
27 |   "homepage": "https://github.com/matthewp/script-type-module#readme",
28 |   "devDependencies": {
29 |     "acorn": "^4.0.3",
30 |     "mocha-test": "^1.0.3",
31 |     "rollup": "^0.36.0",
32 |     "rollup-plugin-commonjs": "^5.0.4",
33 |     "rollup-plugin-node-resolve": "^2.0.0",
34 |     "source-map": "^0.5.6",
35 |     "systemjs": "^0.19.39",
36 |     "testee": "0.7.0",
37 |     "traceur": "0.0.111",
38 |     "webcomponents.js": "^0.7.22"
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/polyfill.js:
--------------------------------------------------------------------------------
  1 | __scriptTypeModuleEval = function(__moduleSrc){
  2 |   new Function(__moduleSrc)();
  3 | };
  4 | (function () {
  5 | 'use strict';
  6 | 
  7 | function currentScript() {
  8 |   return document.currentScript || document._currentScript || getCurrentScriptTheHardWay();
  9 | }
 10 | 
 11 | function getCurrentScriptTheHardWay() {
 12 |   // Should be more complex than this.
 13 |   var scripts = document.getElementsByTagName('script');
 14 |   return scripts[scripts.length - 1];
 15 | }
 16 | 
 17 | class Cluster {
 18 |   constructor(count){
 19 |     this.count = count;
 20 |     this.workerURL = new URL('./worker.js', document.currentScript.src);
 21 |     this.workers = [];
 22 |     this.spawn();
 23 |   }
 24 | 
 25 |   post(msg, handler) {
 26 |     let worker = this.leastBusy();
 27 |     worker.handlers[msg.url] = handler;
 28 |     worker.postMessage(msg);
 29 |     worker.inProgress++;
 30 |   }
 31 | 
 32 |   spawn() {
 33 |     for(var i = 0; i < this.count; i++) {
 34 |       let worker = new Worker(this.workerURL);
 35 |       this.handleMessages(worker);
 36 |       this.workers.push(worker);
 37 |     }
 38 |   }
 39 | 
 40 |   leastBusy() {
 41 |     this.workers.sort(function(a, b){
 42 |       if(a.inProgress < b.inProgress) {
 43 |         return -1;
 44 |       } else {
 45 |         return 1;
 46 |       }
 47 |     });
 48 |     return this.workers[0];
 49 |   }
 50 | 
 51 |   handleMessages(worker) {
 52 |     worker.inProgress = 0;
 53 |     worker.handlers = {};
 54 | 
 55 |     worker.onmessage = function(ev){
 56 |       let msg = ev.data;
 57 |       let handler = worker.handlers[msg.url];
 58 |       handler(msg);
 59 |       worker.inProgress--;
 60 |     };
 61 |   }
 62 | }
 63 | 
 64 | var addModuleTools = function(registry, dynamicImport){
 65 |   self._importTypeModuleTools = function(url){
 66 |     let moduleScript = registry.get(url);
 67 |     let namespace = moduleScript.namespace;
 68 |     return {
 69 |       namespace: namespace,
 70 |       staticImport: function(specifier){
 71 |         let u = new URL(specifier, url).toString();
 72 |         let moduleScript = registry.get(u);
 73 |         return moduleScript.namespace;
 74 |       },
 75 |       dynamicImport: function(specifier){
 76 |         let u = new URL(specifier, url).toString();
 77 |         return dynamicImport(u);
 78 |       },
 79 |       set: function(name, value) {
 80 |         if(typeof name === 'object') {
 81 |           let moduleTools = this;
 82 |           Object.keys(name).forEach(function(key){
 83 |             moduleTools.set(key, name[key]);
 84 |           });
 85 |           return;
 86 |         }
 87 |         moduleScript.values[name] = value;
 88 |         return value;
 89 |       }
 90 |     };
 91 |   };
 92 | }
 93 | 
 94 | // TODO saving this space in case I want to support multiple workers
 95 | 
 96 | var execute = function({ url, code, map }){
 97 |   if(map) {
 98 |     code += encode$1(map);
 99 |   } else {
100 |     code += '\n//# sourceURL=' + url;
101 |   }
102 | 
103 |    __scriptTypeModuleEval(code);
104 | }
105 | 
106 | const prefix = '\n//# source' + 'MappingURL=data:application/json;base64,';
107 | 
108 | function encode$1(map) {
109 |   return prefix + btoa(JSON.stringify(map));
110 | }
111 | 
112 | class ModuleTree {
113 |   constructor() {
114 |     this.count = 0;
115 |     this.fetchPromise = new Promise((resolve, reject) => {
116 |       this.resolve = resolve;
117 |       this.reject = reject;
118 |     })
119 |   }
120 | 
121 |   increment() {
122 |     this.count++;
123 |   }
124 | 
125 |   decrement() {
126 |     this.count--;
127 |     if(this.count === 0) {
128 |       this.resolve();
129 |     }
130 |   }
131 | }
132 | 
133 | class ModuleRecord {
134 |   constructor() {
135 |     this.requestedModules = null;
136 |     this.instantiationStatus = 'uninstantiated';
137 |   }
138 | }
139 | 
140 | class ModuleScript {
141 |   constructor(url, resolve, reject){
142 |     this.moduleRecord = new ModuleRecord();
143 |     this.status = 'fetching';
144 |     this.baseTree = null;
145 |     this.trees = new Set();
146 |     this.url = url;
147 |     this.resolve = resolve;
148 |     this.reject = reject;
149 |     this._instantiationPromise = null;
150 | 
151 |     this.fetchMessage = null;
152 |     this.deps = null;
153 |     this.code = null;
154 | 
155 |     this.values = {};
156 |     this.namespace = {};
157 |   }
158 | 
159 |   addToTree(tree) {
160 |     if(!this.trees.has(tree)) {
161 |       this.trees.add(tree);
162 |       if(this.status === 'fetching') {
163 |         tree.increment();
164 |       }
165 |       if(!this.baseTree) {
166 |         this.baseTree = tree;
167 |       }
168 |     }
169 |   }
170 | 
171 |   addMessage(msg) {
172 |     this.status = 'fetched';
173 |     this.fetchMessage = msg;
174 |     this.code = msg.src;
175 |     this.map = msg.map;
176 |     this.deps = msg.deps;
177 |   }
178 | 
179 |   complete() {
180 |     this.resolve(this);
181 |     this.trees.forEach(function(tree){
182 |       tree.decrement();
183 |     });
184 |   }
185 | 
186 |   error(err) {
187 |     this.reject(err);
188 |   }
189 | 
190 |   isDepOf(moduleScript) {
191 |     return moduleScript.deps.indexOf(this.url) !== -1;
192 |   }
193 | 
194 |   instantiate() {
195 |     try {
196 |       execute(this);
197 |       this.moduleRecord.instantiationStatus = 'instantiated';
198 |     } catch(err) {
199 |       this.moduleRecord.instantiationStatus = 'errored';
200 |       this.moduleRecord.errorReason = err;
201 |       throw err;
202 |     }
203 |   }
204 | 
205 |   instantiatePromise() {
206 |     if(this._instantiationPromise) {
207 |       return this._instantiationPromise;
208 |     }
209 |     return this._instantiationPromise = this._getInstantiatePromise();
210 |   }
211 | 
212 |   _getInstantiatePromise() {
213 |     switch(this.moduleRecord.instantiationStatus) {
214 |       case 'instantiated':
215 |         return Promise.resolve();
216 |       case 'errored':
217 |         return Promise.reject(this.moduleRecord.errorReason);
218 |       default:
219 |         let tree = this.baseTree;
220 |         return tree.fetchPromise.then(() => {
221 |           // Wait for it to execute
222 |           return this._getInstantiatePromise();
223 |         });
224 |     }
225 |   }
226 | }
227 | 
228 | const forEach$1 = Array.prototype.forEach;
229 | 
230 | function importExisting(importScript){
231 |   let tags = document.querySelectorAll('script[type=module-polyfill]');
232 |   forEach$1.call(tags, importScript);
233 | }
234 | 
235 | function observe(importScript) {
236 |   let mo = new MutationObserver(function(mutations){
237 |     forEach$1.call(mutations, function(mutation){
238 |       forEach$1.call(mutation.addedNodes, function(el){
239 |         if(el.nodeName === 'SCRIPT' && el.type === 'module-polyfill') {
240 |           importScript(el);
241 |         }
242 |       });
243 |     });
244 |   });
245 |   mo.observe(document.documentElement, {
246 |     childList: true,
247 |     subtree: true
248 |   });
249 | 
250 |   return mo;
251 | }
252 | 
253 | var Registry = class {
254 |   constructor() {
255 |     this.moduleScriptMap = new Map();
256 |     this.fetchPromises = new Map();
257 |   }
258 | 
259 |   get(url) {
260 |     return this.moduleScriptMap.get(url);
261 |   }
262 | 
263 |   add(moduleScript) {
264 |     let url = moduleScript.url;
265 |     this.moduleScriptMap.set(url, moduleScript);
266 |   }
267 | 
268 |   addExports(moduleScript) {
269 |     let msg = moduleScript.fetchMessage;
270 |     let exports = msg.exports;
271 |     let exportStars = msg.exportStars;
272 | 
273 |     Object.keys(exports).forEach(name => {
274 |       let exp = exports[name];
275 |       if(exp.from) {
276 |         let parentModuleScript = this.moduleScriptMap.get(exp.from);
277 | 
278 |         Object.defineProperty(moduleScript.namespace, name, {
279 |           get: getValue(parentModuleScript, exp.local)
280 |         });
281 |       } else {
282 |         Object.defineProperty(moduleScript.namespace, name, {
283 |           get: getValue(moduleScript, name)
284 |         });
285 |       }
286 |     });
287 | 
288 |     exportStars.forEach(from => {
289 |       let parentModuleScript = this.moduleScriptMap.get(from);
290 |       let props = Object.getOwnPropertyNames(parentModuleScript.namespace);
291 |       props.forEach(function(prop){
292 |         Object.defineProperty(moduleScript.namespace, prop, {
293 |           get: getValue(parentModuleScript, prop)
294 |         });
295 |       });
296 |     });
297 |   }
298 | 
299 |   link(moduleScript) {
300 |     moduleScript.status = 'linking';
301 | 
302 |     let deps = moduleScript.deps;
303 |     deps.forEach(depUrl => {
304 |       let depModuleScript = this.get(depUrl);
305 |       if(depModuleScript.moduleRecord.instantiationStatus === 'uninstantiated') {
306 |         // Circular deps
307 |         if(depModuleScript.status !== 'linking') {
308 |           this.link(depModuleScript);
309 |         }
310 |       }
311 |     });
312 | 
313 |     moduleScript.status = 'linked';
314 |     this.instantiate(moduleScript);
315 |   }
316 | 
317 |   instantiate(moduleScript) {
318 |     if(moduleScript.moduleRecord.instantiationStatus === 'uninstantiated') {
319 |       this.addExports(moduleScript);
320 |       moduleScript.instantiate();
321 |     }
322 |   }
323 | }
324 | 
325 | function getValue(moduleScript, name, par) {
326 |   return function(){
327 |     return moduleScript.values[name];
328 |   };
329 | }
330 | 
331 | let cluster = new Cluster(1);
332 | 
333 | let registry = new Registry();
334 | let anonCount = 0;
335 | let pollyScript = currentScript();
336 | let includeSourceMaps = pollyScript.dataset.noSm == null;
337 | 
338 | addModuleTools(registry, dynamicImport);
339 | 
340 | function importScript(script) {
341 |   let url = "" + (script.src || new URL('./!anonymous_' + anonCount++, document.baseURI));
342 |   let src = script.src ? undefined : script.textContent;
343 | 
344 |   return internalImportModule(url, src)
345 |   .then(function(){
346 |     var ev = new Event('load');
347 |     script.dispatchEvent(ev);
348 |   })
349 |   .then(null, function(err){
350 |     console.error(err);
351 |     var ev = new ErrorEvent('error', {
352 |       message: err.message,
353 |       filename: url
354 |     });
355 |     script.dispatchEvent(ev);
356 |   });
357 | }
358 | 
359 | function internalImportModule(url, src){
360 |   let entry = registry.get(url);
361 |   if(entry) {
362 |     return entry.instantiatePromise();
363 |   }
364 |   return importModuleWithTree(url, src);
365 | }
366 | 
367 | function importModuleWithTree(url, src){
368 |   let tree = new ModuleTree();
369 | 
370 |   return fetchModule(url, src, tree)
371 |   .then(function(moduleScript){
372 |     return tree.fetchPromise.then(function(){
373 |       return moduleScript;
374 |     });
375 |   })
376 |   .then(function(moduleScript){
377 |     registry.link(moduleScript);
378 |   });
379 | 
380 | 
381 | }
382 | 
383 | function fetchModule(url, src, tree) {
384 |   var promise = registry.fetchPromises.get(url);
385 |   if(!promise) {
386 |     promise = new Promise(function(resolve, reject){
387 |       let moduleScript = new ModuleScript(url, resolve, reject);
388 |       moduleScript.addToTree(tree);
389 |       let handler = function(msg){
390 |         if(msg.type === 'error') {
391 |           let ErrorConstructor = self[msg.error.name] || Error;
392 |           let error = new ErrorConstructor(msg.error.message);
393 |           moduleScript.error(error);
394 |           return;
395 |         }
396 | 
397 |         moduleScript.addMessage(msg);
398 |         fetchTree(moduleScript, tree);
399 |         moduleScript.complete();
400 |       };
401 |       cluster.post({
402 |         type: 'fetch',
403 |         url: url,
404 |         src: src,
405 |         includeSourceMaps: includeSourceMaps
406 |       }, handler);
407 |       registry.add(moduleScript);
408 |     });
409 |     registry.fetchPromises.set(url, promise);
410 |   } else {
411 |     // See if this ModuleScript is still being fetched
412 |     let moduleScript = registry.get(url);
413 |     moduleScript.addToTree(tree);
414 |   }
415 |   return promise;
416 | }
417 | 
418 | function fetchTree(moduleScript, tree) {
419 |   let deps = moduleScript.deps;
420 |   let promises = deps.map(function(url){
421 |     let fetchPromise = fetchModule(url, null, tree);
422 |     let depModuleScript = registry.get(url);
423 |     moduleScript.trees.forEach(function(tree){
424 |       depModuleScript.addToTree(tree);
425 |     });
426 |     return fetchPromise;
427 |   });
428 |   return Promise.all(promises);
429 | }
430 | 
431 | function dynamicImport(url, src){
432 |   return internalImportModule(url, src).then(function(){
433 |     return registry.get(url).namespace;
434 |   });
435 | }
436 | 
437 | importExisting(importScript);
438 | observe(importScript);
439 | 
440 | }());
441 | 


--------------------------------------------------------------------------------
/rollup.config.js:
--------------------------------------------------------------------------------
 1 | import commonjs from 'rollup-plugin-commonjs';
 2 | import nodeResolve from 'rollup-plugin-node-resolve';
 3 | 
 4 | export default {
 5 |   format: 'iife',
 6 |   plugins: [
 7 |     nodeResolve({
 8 |       jsnext: true,
 9 |       main: true
10 |     }),
11 |     commonjs({
12 |       include: ['node_modules/**','src/vendor/acorn.js']
13 |     })
14 |   ]
15 | };
16 | 


--------------------------------------------------------------------------------
/src/msg.js:
--------------------------------------------------------------------------------
1 | export function decode(msg){
2 |   return JSON.parse(msg);
3 | }
4 | 
5 | export function encode(msg){
6 |   return JSON.stringify(msg);
7 | }
8 | 


--------------------------------------------------------------------------------
/src/window/cluster.js:
--------------------------------------------------------------------------------
 1 | class Cluster {
 2 |   constructor(count){
 3 |     this.count = count;
 4 |     this.workerURL = new URL('./worker.js', document.currentScript.src);
 5 |     this.workers = [];
 6 |     this.spawn();
 7 |   }
 8 | 
 9 |   post(msg, handler) {
10 |     let worker = this.leastBusy();
11 |     worker.handlers[msg.url] = handler;
12 |     worker.postMessage(msg);
13 |     worker.inProgress++;
14 |   }
15 | 
16 |   spawn() {
17 |     for(var i = 0; i < this.count; i++) {
18 |       let worker = new Worker(this.workerURL);
19 |       this.handleMessages(worker);
20 |       this.workers.push(worker);
21 |     }
22 |   }
23 | 
24 |   leastBusy() {
25 |     this.workers.sort(function(a, b){
26 |       if(a.inProgress < b.inProgress) {
27 |         return -1;
28 |       } else {
29 |         return 1;
30 |       }
31 |     });
32 |     return this.workers[0];
33 |   }
34 | 
35 |   handleMessages(worker) {
36 |     worker.inProgress = 0;
37 |     worker.handlers = {};
38 | 
39 |     worker.onmessage = function(ev){
40 |       let msg = ev.data;
41 |       let handler = worker.handlers[msg.url];
42 |       handler(msg);
43 |       worker.inProgress--;
44 |     };
45 |   }
46 | }
47 | 
48 | export default Cluster;
49 | 


--------------------------------------------------------------------------------
/src/window/dom.js:
--------------------------------------------------------------------------------
 1 | const forEach = Array.prototype.forEach;
 2 | 
 3 | export function importExisting(importScript){
 4 |   let tags = document.querySelectorAll('script[type=module-polyfill]');
 5 |   forEach.call(tags, importScript);
 6 | }
 7 | 
 8 | export function observe(importScript) {
 9 |   let mo = new MutationObserver(function(mutations){
10 |     forEach.call(mutations, function(mutation){
11 |       forEach.call(mutation.addedNodes, function(el){
12 |         if(el.nodeName === 'SCRIPT' && el.type === 'module-polyfill') {
13 |           importScript(el);
14 |         }
15 |       });
16 |     });
17 |   });
18 |   mo.observe(document.documentElement, {
19 |     childList: true,
20 |     subtree: true
21 |   });
22 | 
23 |   return mo;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/window/eval.js:
--------------------------------------------------------------------------------
1 | __scriptTypeModuleEval = function(__moduleSrc){
2 |   new Function(__moduleSrc)();
3 | };
4 | 


--------------------------------------------------------------------------------
/src/window/execute.js:
--------------------------------------------------------------------------------
 1 | export default function({ url, code, map }){
 2 |   if(map) {
 3 |     code += encode(map);
 4 |   } else {
 5 |     code += '\n//# sourceURL=' + url;
 6 |   }
 7 | 
 8 |    __scriptTypeModuleEval(code);
 9 | };
10 | 
11 | const prefix = '\n//# source' + 'MappingURL=data:application/json;base64,';
12 | 
13 | function encode(map) {
14 |   return prefix + btoa(JSON.stringify(map));
15 | }
16 | 


--------------------------------------------------------------------------------
/src/window/index.js:
--------------------------------------------------------------------------------
  1 | import { currentScript } from './utils.js';
  2 | import { encode, decode } from '../msg.js';
  3 | import Cluster from './cluster.js';
  4 | import addModuleTools from './module-tools.js';
  5 | import spawn from './spawn.js';
  6 | import { ModuleScript, ModuleTree } from './modules.js';
  7 | import { importExisting, observe } from './dom.js';
  8 | import Registry from './registry.js';
  9 | 
 10 | let cluster = new Cluster(1);
 11 | 
 12 | let registry = new Registry();
 13 | let forEach = Array.prototype.forEach;
 14 | let anonCount = 0;
 15 | let pollyScript = currentScript();
 16 | let includeSourceMaps = pollyScript.dataset.noSm == null;
 17 | 
 18 | addModuleTools(registry, dynamicImport);
 19 | 
 20 | function importScript(script) {
 21 |   let url = "" + (script.src || new URL('./!anonymous_' + anonCount++, document.baseURI));
 22 |   let src = script.src ? undefined : script.textContent;
 23 | 
 24 |   return internalImportModule(url, src)
 25 |   .then(function(){
 26 |     var ev = new Event('load');
 27 |     script.dispatchEvent(ev);
 28 |   })
 29 |   .then(null, function(err){
 30 |     console.error(err);
 31 |     var ev = new ErrorEvent('error', {
 32 |       message: err.message,
 33 |       filename: url
 34 |     });
 35 |     script.dispatchEvent(ev);
 36 |   });
 37 | }
 38 | 
 39 | function internalImportModule(url, src){
 40 |   let entry = registry.get(url);
 41 |   if(entry) {
 42 |     return entry.instantiatePromise();
 43 |   }
 44 |   return importModuleWithTree(url, src);
 45 | }
 46 | 
 47 | function importModuleWithTree(url, src){
 48 |   let tree = new ModuleTree();
 49 | 
 50 |   return fetchModule(url, src, tree)
 51 |   .then(function(moduleScript){
 52 |     return tree.fetchPromise.then(function(){
 53 |       return moduleScript;
 54 |     });
 55 |   })
 56 |   .then(function(moduleScript){
 57 |     registry.link(moduleScript);
 58 |   });
 59 | 
 60 | 
 61 | }
 62 | 
 63 | function fetchModule(url, src, tree) {
 64 |   var promise = registry.fetchPromises.get(url);
 65 |   if(!promise) {
 66 |     promise = new Promise(function(resolve, reject){
 67 |       let moduleScript = new ModuleScript(url, resolve, reject);
 68 |       moduleScript.addToTree(tree);
 69 |       let handler = function(msg){
 70 |         if(msg.type === 'error') {
 71 |           let ErrorConstructor = self[msg.error.name] || Error;
 72 |           let error = new ErrorConstructor(msg.error.message);
 73 |           moduleScript.error(error);
 74 |           return;
 75 |         }
 76 | 
 77 |         moduleScript.addMessage(msg);
 78 |         fetchTree(moduleScript, tree);
 79 |         moduleScript.complete();
 80 |       };
 81 |       cluster.post({
 82 |         type: 'fetch',
 83 |         url: url,
 84 |         src: src,
 85 |         includeSourceMaps: includeSourceMaps
 86 |       }, handler);
 87 |       registry.add(moduleScript);
 88 |     });
 89 |     registry.fetchPromises.set(url, promise);
 90 |   } else {
 91 |     // See if this ModuleScript is still being fetched
 92 |     let moduleScript = registry.get(url);
 93 |     moduleScript.addToTree(tree);
 94 |   }
 95 |   return promise;
 96 | }
 97 | 
 98 | function fetchTree(moduleScript, tree) {
 99 |   let deps = moduleScript.deps;
100 |   let promises = deps.map(function(url){
101 |     let fetchPromise = fetchModule(url, null, tree);
102 |     let depModuleScript = registry.get(url);
103 |     moduleScript.trees.forEach(function(tree){
104 |       depModuleScript.addToTree(tree);
105 |     });
106 |     return fetchPromise;
107 |   });
108 |   return Promise.all(promises);
109 | }
110 | 
111 | function dynamicImport(url, src){
112 |   return internalImportModule(url, src).then(function(){
113 |     return registry.get(url).namespace;
114 |   });
115 | }
116 | 
117 | importExisting(importScript);
118 | observe(importScript);
119 | 


--------------------------------------------------------------------------------
/src/window/module-tools.js:
--------------------------------------------------------------------------------
 1 | export default function(registry, dynamicImport){
 2 |   self._importTypeModuleTools = function(url){
 3 |     let moduleScript = registry.get(url);
 4 |     let namespace = moduleScript.namespace;
 5 |     return {
 6 |       namespace: namespace,
 7 |       staticImport: function(specifier){
 8 |         let u = new URL(specifier, url).toString();
 9 |         let moduleScript = registry.get(u);
10 |         return moduleScript.namespace;
11 |       },
12 |       dynamicImport: function(specifier){
13 |         let u = new URL(specifier, url).toString();
14 |         return dynamicImport(u);
15 |       },
16 |       set: function(name, value) {
17 |         if(typeof name === 'object') {
18 |           let moduleTools = this;
19 |           Object.keys(name).forEach(function(key){
20 |             moduleTools.set(key, name[key]);
21 |           });
22 |           return;
23 |         }
24 |         moduleScript.values[name] = value;
25 |         return value;
26 |       }
27 |     };
28 |   };
29 | };
30 | 


--------------------------------------------------------------------------------
/src/window/modules.js:
--------------------------------------------------------------------------------
  1 | import execute from './execute.js';
  2 | 
  3 | export class ModuleTree {
  4 |   constructor() {
  5 |     this.count = 0;
  6 |     this.fetchPromise = new Promise((resolve, reject) => {
  7 |       this.resolve = resolve;
  8 |       this.reject = reject;
  9 |     })
 10 |   }
 11 | 
 12 |   increment() {
 13 |     this.count++;
 14 |   }
 15 | 
 16 |   decrement() {
 17 |     this.count--;
 18 |     if(this.count === 0) {
 19 |       this.resolve();
 20 |     }
 21 |   }
 22 | }
 23 | 
 24 | export class ModuleRecord {
 25 |   constructor() {
 26 |     this.requestedModules = null;
 27 |     this.instantiationStatus = 'uninstantiated';
 28 |   }
 29 | }
 30 | 
 31 | export class ModuleScript {
 32 |   constructor(url, resolve, reject){
 33 |     this.moduleRecord = new ModuleRecord();
 34 |     this.status = 'fetching';
 35 |     this.baseTree = null;
 36 |     this.trees = new Set();
 37 |     this.url = url;
 38 |     this.resolve = resolve;
 39 |     this.reject = reject;
 40 |     this._instantiationPromise = null;
 41 | 
 42 |     this.fetchMessage = null;
 43 |     this.deps = null;
 44 |     this.code = null;
 45 | 
 46 |     this.values = {};
 47 |     this.namespace = {};
 48 |   }
 49 | 
 50 |   addToTree(tree) {
 51 |     if(!this.trees.has(tree)) {
 52 |       this.trees.add(tree);
 53 |       if(this.status === 'fetching') {
 54 |         tree.increment();
 55 |       }
 56 |       if(!this.baseTree) {
 57 |         this.baseTree = tree;
 58 |       }
 59 |     }
 60 |   }
 61 | 
 62 |   addMessage(msg) {
 63 |     this.status = 'fetched';
 64 |     this.fetchMessage = msg;
 65 |     this.code = msg.src;
 66 |     this.map = msg.map;
 67 |     this.deps = msg.deps;
 68 |   }
 69 | 
 70 |   complete() {
 71 |     this.resolve(this);
 72 |     this.trees.forEach(function(tree){
 73 |       tree.decrement();
 74 |     });
 75 |   }
 76 | 
 77 |   error(err) {
 78 |     this.reject(err);
 79 |   }
 80 | 
 81 |   isDepOf(moduleScript) {
 82 |     return moduleScript.deps.indexOf(this.url) !== -1;
 83 |   }
 84 | 
 85 |   instantiate() {
 86 |     try {
 87 |       execute(this);
 88 |       this.moduleRecord.instantiationStatus = 'instantiated';
 89 |     } catch(err) {
 90 |       this.moduleRecord.instantiationStatus = 'errored';
 91 |       this.moduleRecord.errorReason = err;
 92 |       throw err;
 93 |     }
 94 |   }
 95 | 
 96 |   instantiatePromise() {
 97 |     if(this._instantiationPromise) {
 98 |       return this._instantiationPromise;
 99 |     }
100 |     return this._instantiationPromise = this._getInstantiatePromise();
101 |   }
102 | 
103 |   _getInstantiatePromise() {
104 |     switch(this.moduleRecord.instantiationStatus) {
105 |       case 'instantiated':
106 |         return Promise.resolve();
107 |       case 'errored':
108 |         return Promise.reject(this.moduleRecord.errorReason);
109 |       default:
110 |         let tree = this.baseTree;
111 |         return tree.fetchPromise.then(() => {
112 |           // Wait for it to execute
113 |           return this._getInstantiatePromise();
114 |         });
115 |     }
116 |   }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/window/registry.js:
--------------------------------------------------------------------------------
 1 | import execute from './execute.js';
 2 | 
 3 | export default class {
 4 |   constructor() {
 5 |     this.moduleScriptMap = new Map();
 6 |     this.fetchPromises = new Map();
 7 |   }
 8 | 
 9 |   get(url) {
10 |     return this.moduleScriptMap.get(url);
11 |   }
12 | 
13 |   add(moduleScript) {
14 |     let url = moduleScript.url;
15 |     this.moduleScriptMap.set(url, moduleScript);
16 |   }
17 | 
18 |   addExports(moduleScript) {
19 |     let msg = moduleScript.fetchMessage;
20 |     let exports = msg.exports;
21 |     let exportStars = msg.exportStars;
22 | 
23 |     Object.keys(exports).forEach(name => {
24 |       let exp = exports[name];
25 |       if(exp.from) {
26 |         let parentModuleScript = this.moduleScriptMap.get(exp.from);
27 | 
28 |         Object.defineProperty(moduleScript.namespace, name, {
29 |           get: getValue(parentModuleScript, exp.local)
30 |         });
31 |       } else {
32 |         Object.defineProperty(moduleScript.namespace, name, {
33 |           get: getValue(moduleScript, name)
34 |         });
35 |       }
36 |     });
37 | 
38 |     exportStars.forEach(from => {
39 |       let parentModuleScript = this.moduleScriptMap.get(from);
40 |       let props = Object.getOwnPropertyNames(parentModuleScript.namespace);
41 |       props.forEach(function(prop){
42 |         Object.defineProperty(moduleScript.namespace, prop, {
43 |           get: getValue(parentModuleScript, prop)
44 |         });
45 |       });
46 |     });
47 |   }
48 | 
49 |   link(moduleScript) {
50 |     moduleScript.status = 'linking';
51 | 
52 |     let deps = moduleScript.deps;
53 |     deps.forEach(depUrl => {
54 |       let depModuleScript = this.get(depUrl);
55 |       if(depModuleScript.moduleRecord.instantiationStatus === 'uninstantiated') {
56 |         // Circular deps
57 |         if(depModuleScript.status !== 'linking') {
58 |           this.link(depModuleScript);
59 |         }
60 |       }
61 |     });
62 | 
63 |     moduleScript.status = 'linked';
64 |     this.instantiate(moduleScript);
65 |   }
66 | 
67 |   instantiate(moduleScript) {
68 |     if(moduleScript.moduleRecord.instantiationStatus === 'uninstantiated') {
69 |       this.addExports(moduleScript);
70 |       moduleScript.instantiate();
71 |     }
72 |   }
73 | };
74 | 
75 | function getValue(moduleScript, name, par) {
76 |   return function(){
77 |     return moduleScript.values[name];
78 |   };
79 | }
80 | 


--------------------------------------------------------------------------------
/src/window/spawn.js:
--------------------------------------------------------------------------------
1 | // TODO saving this space in case I want to support multiple workers
2 | 
3 | export default function(){
4 |   let workerURL = new URL('./worker.js', document.currentScript.src);
5 |   return new Worker(workerURL);
6 | };
7 | 


--------------------------------------------------------------------------------
/src/window/utils.js:
--------------------------------------------------------------------------------
 1 | export function currentScript() {
 2 |   return document.currentScript || document._currentScript || getCurrentScriptTheHardWay();
 3 | }
 4 | 
 5 | function getCurrentScriptTheHardWay() {
 6 |   // Should be more complex than this.
 7 |   var scripts = document.getElementsByTagName('script');
 8 |   return scripts[scripts.length - 1];
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/worker/acorn.js:
--------------------------------------------------------------------------------
1 | import { __moduleExports as acorn } from '../vendor/acorn.js';
2 | import { __moduleExports as walk } from 'acorn/dist/walk.js';
3 | 
4 | acorn.walk = walk;
5 | export default acorn;
6 | 


--------------------------------------------------------------------------------
/src/worker/assignment-expression.js:
--------------------------------------------------------------------------------
 1 | import exportSet from './export-set.js';
 2 | 
 3 | export default function(node, state, cont){
 4 |   if(isExportName(node, state)) {
 5 |     exportSet(node, state, node.left.name);
 6 |     return;
 7 |   }
 8 |   Object.getPrototypeOf(this).AssignmentExpression(node, state, cont);
 9 | };
10 | 
11 | function isExportName(node, state){
12 |   let left = node.left;
13 | 
14 |   return left.type === 'Identifier' && state.exportNames[left.name];
15 | }
16 | 


--------------------------------------------------------------------------------
/src/worker/call-expression.js:
--------------------------------------------------------------------------------
 1 | export default function(node, state, cont) {
 2 |   // Handle incorrect arguments for dynamic import()
 3 |   if(node.callee.type === 'ImportCallIdentifier') {
 4 |     if(node.arguments.length !== 1) {
 5 |       throw new SyntaxError('import() only takes a single argument');
 6 |     }
 7 | 
 8 |     // SpreadElement is disallowed
 9 |     let argType = node.arguments[0].type;
10 |     if(argType === 'SpreadElement') {
11 |       throw new SyntaxError('Spread syntax not allowed in import()');
12 |     }
13 |   }
14 | 
15 |   return Object.getPrototypeOf(this).CallExpression(node, state, cont);
16 | };
17 | 


--------------------------------------------------------------------------------
/src/worker/export-all-declaration.js:
--------------------------------------------------------------------------------
 1 | export default function(node, state){
 2 |   let source = node.source;
 3 |   let fromUrl = new URL(source.value, state.url).toString();
 4 |   state.deps.push(fromUrl);
 5 |   state.exportStars.push(fromUrl);
 6 | 
 7 |   node.type = 'EmptyStatement';
 8 |   delete node.source;
 9 | };
10 | 


--------------------------------------------------------------------------------
/src/worker/export-default-declaration.js:
--------------------------------------------------------------------------------
 1 | import exportSet from './export-set.js';
 2 | 
 3 | export default function(node, state, cont){
 4 |   state.includeTools = state.includesExports = true;
 5 |   state.exports.default = {};
 6 | 
 7 |   exportSet(node, state, 'default');
 8 |   delete node.declaration;
 9 | 
10 |   cont(node, state);
11 | };
12 | 


--------------------------------------------------------------------------------
/src/worker/export-named-declaration.js:
--------------------------------------------------------------------------------
 1 | import exportSet from './export-set.js';
 2 | 
 3 | export default function(node, state, cont){
 4 |   state.includeTools = true;
 5 | 
 6 |   if(node.source) {
 7 |     exportFrom(node, state);
 8 |   } else if(!node.declaration) {
 9 |     exportObj(node, state);
10 |   } else {
11 |     let name = getNameFromDeclaration(node.declaration);
12 |     exportSet(node, state, name);
13 |     state.exports[name] = {};
14 |   }
15 | 
16 |   delete node.declaration;
17 |   delete node.specifiers;
18 | 
19 |   cont(node, state);
20 | };
21 | 
22 | function getNameFromDeclaration(decl) {
23 |   switch(decl.type) {
24 |     case 'FunctionDeclaration':
25 |     case 'VariableDeclarator':
26 |       return decl.id.name;
27 |     case 'VariableDeclaration':
28 |       return getNameFromDeclaration(decl.declarations[0]);
29 |   }
30 | }
31 | 
32 | function exportObj(node, state) {
33 |   let objectExpression = {
34 |     type: 'ObjectExpression',
35 |     properties: []
36 |   };
37 | 
38 |   node.specifiers.forEach(function(specifier){
39 |     state.exports[specifier.exported.name] = {};
40 | 
41 |     let property = {
42 |       type: 'Property',
43 |       method: false,
44 |       shorthand: false,
45 |       computed: false,
46 |       key: {
47 |         type: 'Identifier',
48 |         name: specifier.exported.name
49 |       },
50 |       value: {
51 |         type: 'Identifier',
52 |         name: specifier.local.name
53 |       },
54 |       kind: 'init'
55 |     };
56 |     objectExpression.properties.push(property);
57 |   });
58 | 
59 |   node.type = 'ExpressionStatement';
60 |   node.expression = {
61 |     type: 'CallExpression',
62 |     callee: {
63 |       type: 'MemberExpression',
64 |       object: {
65 |         type: 'Identifier',
66 |         name: '_moduleTools'
67 |       },
68 |       property: {
69 |         type: 'Identifier',
70 |         name: 'set'
71 |       },
72 |       computed: false
73 |     },
74 |     arguments: [objectExpression]
75 |   };
76 | }
77 | 
78 | function exportFrom(node, state){
79 |   let source = node.source;
80 |   let fromUrl = new URL(source.value, state.url).toString();
81 |   state.deps.push(fromUrl);
82 | 
83 |   let specifiers = node.specifiers || [];
84 |   specifiers.forEach(function(specifier){
85 |     let local = specifier.local.name;
86 |     let exported = specifier.exported.name;
87 | 
88 |     state.exports[exported] = {
89 |       from: fromUrl,
90 |       local: local
91 |     };
92 |   });
93 | 
94 |   node.type = 'EmptyStatement';
95 |   delete node.source;
96 | }
97 | 


--------------------------------------------------------------------------------
/src/worker/export-set.js:
--------------------------------------------------------------------------------
 1 | export default function(node, state, name){
 2 |   state.exportNames[name] = true;
 3 | 
 4 |   let nameArg = {
 5 |     type: 'Literal',
 6 |     value: name,
 7 |     raw: "'" + name + "'"
 8 |   };
 9 | 
10 |   let valueArg;
11 | 
12 |   let decl = node.declaration || node;
13 |   switch(decl.type) {
14 |     case 'FunctionDeclaration':
15 |     case 'FunctionExpression':
16 |     case 'Identifier':
17 |     case 'Literal':
18 |     case 'ObjectExpression':
19 |       valueArg = decl;
20 |       break;
21 |     case 'AssignmentExpression':
22 |       valueArg = decl.right;
23 |       break;
24 |     default:
25 |       valueArg = decl.declarations[0].init;
26 |       // No assignment
27 |       if(valueArg == null) {
28 |         valueArg = { type: 'Identifier', name: 'undefined' };
29 |       }
30 |       break;
31 |   }
32 | 
33 |   node.type = 'ExpressionStatement';
34 |   node.expression = {
35 |     type: 'CallExpression',
36 |     callee: {
37 |       type: 'MemberExpression',
38 |       object: {
39 |         type: 'Identifier',
40 |         name: '_moduleTools'
41 |       },
42 |       property: {
43 |         type: 'Identifier',
44 |         name: 'set'
45 |       },
46 |       computed: false
47 |     },
48 |     arguments: [nameArg, valueArg]
49 |   };
50 | };
51 | 


--------------------------------------------------------------------------------
/src/worker/identifier.js:
--------------------------------------------------------------------------------
 1 | export default function(node, state){
 2 |   let specifier = state.specifiers[node.name];
 3 |   let localVar = hasLocal(state, node.name);
 4 | 
 5 |   if(specifier && !localVar) {
 6 |     if(specifier.type === 'star') {
 7 |       node.name = specifier.ns;
 8 |     } else {
 9 |       let prop = specifier.type === 'default' ? 'default': specifier.prop;
10 |       node.type = 'MemberExpression';
11 |       node.object = {
12 |         type: 'Identifier',
13 |         name: specifier.ns
14 |       };
15 |       node.property = {
16 |         type: 'Identifier',
17 |         name: prop
18 |       };
19 |       node.computed = false;
20 |       delete node.name;
21 |     }
22 |   } else if(state.exports[node.name] && !localVar) {
23 |     node.type = 'MemberExpression';
24 |     node.object = {
25 |       type: 'MemberExpression',
26 |       object: {
27 |         type: 'Identifier',
28 |         name: '_moduleTools'
29 |       },
30 |       property: {
31 |         type: 'Identifier',
32 |         name: 'namespace'
33 |       },
34 |       computed: false
35 |     };
36 |     node.property = {
37 |       type: 'Identifier',
38 |       name: node.name
39 |     };
40 |     node.computed = false;
41 |     delete node.name;
42 |   }
43 | };
44 | 
45 | function hasLocal(state, name) {
46 |   return state.vars[name];
47 | }
48 | 


--------------------------------------------------------------------------------
/src/worker/import-call-identifier.js:
--------------------------------------------------------------------------------
 1 | 
 2 | export default function(node, state, cont){
 3 |   state.includeTools = true;
 4 |   delete node.name;
 5 | 
 6 |   node.type = 'MemberExpression';
 7 |   node.object = {
 8 |     type: 'Identifier',
 9 |     name: '_moduleTools'
10 |   };
11 |   node.property = {
12 |     type: 'Identifier',
13 |     name: 'dynamicImport'
14 |   };
15 | };
16 | 


--------------------------------------------------------------------------------
/src/worker/import-declaration.js:
--------------------------------------------------------------------------------
 1 | 
 2 | export default function(node, state){
 3 |   let url = state.url;
 4 |   state.includeTools = true;
 5 |   let source = node.source;
 6 |   let specifiers = node.specifiers || [];
 7 |   // TODO better namespace naming algo
 8 |   let namespaceName = getNamespaceName(specifiers, state);
 9 | 
10 |   state.deps.push(new URL(source.value, url).toString());
11 | 
12 |   specifiers.forEach(function(node){
13 |     switch(node.type) {
14 |       case 'ImportDefaultSpecifier':
15 |         state.specifiers[node.local.name] = {
16 |           ns: namespaceName,
17 |           type: 'default'
18 |         };
19 |         break;
20 |       case 'ImportSpecifier':
21 |         state.specifiers[node.local.name] = {
22 |           ns: namespaceName,
23 |           type: 'named',
24 |           prop: node.imported.name
25 |         };
26 |         break;
27 |       case 'ImportNamespaceSpecifier':
28 |         state.specifiers[node.local.name] = {
29 |           ns: namespaceName,
30 |           type: 'star'
31 |         };
32 |         break;
33 |     }
34 |   });
35 | 
36 |   node.type = 'VariableDeclaration';
37 |   node.kind = 'const';
38 |   node.declarations = [
39 |     {
40 |       type: 'VariableDeclarator',
41 |       id: {
42 |         type: 'Identifier',
43 |         name: namespaceName
44 |       },
45 |       init:
46 |       {
47 |         type: 'CallExpression',
48 |         callee: {
49 |           type: 'MemberExpression',
50 |           object: {
51 |             type: 'Identifier',
52 |             name: '_moduleTools'
53 |           },
54 |           property: {
55 |             type: 'Identifier',
56 |             name: 'staticImport'
57 |           }
58 |         },
59 |         arguments: [
60 |           {
61 |             type: 'Literal',
62 |             value: source.value,
63 |             raw: source.raw
64 |           }
65 |         ]
66 |       }
67 |     }
68 |   ];
69 | 
70 |   delete node.specifiers;
71 |   delete node.source;
72 | };
73 | 
74 | function getNamespaceName(specifiers, state) {
75 |   let namespaceName;
76 |   if(specifiers.length) {
77 |     let specifier = specifiers[0];
78 |     if(specifier.type == 'ImportNamespaceSpecifier') {
79 |       namespaceName = specifier.local.name;
80 |     } else {
81 |       namespaceName = specifier.local.name + 'Namespace';
82 |     }
83 |   } else {
84 |     namespaceName = 'anon' + state.anonCount + 'Namespace';
85 |     state.anonCount++;
86 |   }
87 |   return namespaceName;
88 | }
89 | 


--------------------------------------------------------------------------------
/src/worker/index.js:
--------------------------------------------------------------------------------
 1 | import '../vendor/escodegen.browser.js';
 2 | import acorn from './acorn.js';
 3 | import visitors from './visitors.js';
 4 | import {
 5 |   addModuleTools,
 6 |   addModuleNamespace,
 7 |   addStrictMode
 8 | } from './module-tools.js';
 9 | import './source-maps.js';
10 | 
11 | onmessage = function(ev){
12 |   let msg = ev.data;
13 |   let url = msg.url;
14 |   let includeSourceMaps = msg.includeSourceMaps;
15 | 
16 |   let fetchPromise = msg.src ? Promise.resolve(msg.src)
17 |     : fetch(url).then(function(resp){
18 |       return resp.text();
19 |     });
20 | 
21 |   fetchPromise
22 |   .then(function(src){
23 |     let state = {
24 |       anonCount: 0,
25 |       deps: [],
26 |       exports: {},
27 |       exportStars: [],
28 |       exportNames: {},
29 |       specifiers: {},
30 |       vars: {},
31 |       url: url
32 |     };
33 |     let parseOptions = {
34 |       sourceType: 'module'
35 |     };
36 |     if(includeSourceMaps) {
37 |       parseOptions.locations = true;
38 |       parseOptions.sourceFile = url;
39 |     }
40 |     let ast = acorn.parse(src, parseOptions);
41 |     acorn.walk.recursive(ast, state, visitors);
42 | 
43 |     if(state.includesExports) {
44 |       ast.body.unshift(addModuleNamespace());
45 |     }
46 |     if(state.includeTools) {
47 |       ast.body.unshift(addModuleTools(url));
48 |     }
49 |     ast.body.unshift(addStrictMode());
50 |     let codegenOptions = {};
51 |     if(includeSourceMaps) {
52 |       codegenOptions.sourceMap = codegenOptions.sourceMapWithCode = true;
53 |     }
54 |     let result = escodegen.generate(ast, codegenOptions);
55 | 
56 |     let code = includeSourceMaps ? result.code : result;
57 |     let map = includeSourceMaps ? result.map.toJSON() : undefined;
58 | 
59 |     return {
60 |       code: code,
61 |       deps: state.deps,
62 |       exports: state.exports,
63 |       exportStars: state.exportStars,
64 |       map: map
65 |     };
66 |   })
67 |   .then(function(res){
68 |     postMessage({
69 |       type: 'fetch',
70 |       exports: res.exports,
71 |       exportStars: res.exportStars,
72 |       deps: res.deps,
73 |       url: url,
74 |       src: res.code,
75 |       map: res.map
76 |     });
77 |   })
78 |   .then(null, function(err){
79 |     postMessage({
80 |       type: 'error',
81 |       url: url,
82 |       error: {
83 |         message: err.message,
84 |         name: err.name
85 |       }
86 |     });
87 |   });
88 | }
89 | 


--------------------------------------------------------------------------------
/src/worker/module-tools.js:
--------------------------------------------------------------------------------
 1 | export function addModuleTools(url){
 2 |   return {
 3 |     type: "VariableDeclaration",
 4 |     kind: "const",
 5 |     declarations: [
 6 |       {
 7 |         type: "VariableDeclarator",
 8 |         id: {
 9 |           type: "Identifier",
10 |           name: "_moduleTools"
11 |         },
12 |         init: {
13 |           type: "CallExpression",
14 |           callee: {
15 |             type: 'Identifier',
16 |             name: '_importTypeModuleTools'
17 |           },
18 |           arguments: [
19 |             {
20 |               "type": "Literal",
21 |               "value": url,
22 |               "raw": "'" + url + "'"
23 |             }
24 |           ]
25 |         }
26 |       }
27 |     ]
28 |   };
29 | };
30 | 
31 | export function addModuleNamespace(url){
32 |   return {
33 |     type: "VariableDeclaration",
34 |     declarations: [
35 |       {
36 |         type: "VariableDeclarator",
37 |         id: {
38 |           type: "Identifier",
39 |           name: "_moduleNamespace"
40 |         },
41 |         init: {
42 |           type: "MemberExpression",
43 |           object: {
44 |             type: "Identifier",
45 |             name: "_moduleTools"
46 |           },
47 |           property: {
48 |             type: "Identifier",
49 |             name: "namespace"
50 |           },
51 |           computed: false
52 |         }
53 |       }
54 |     ],
55 |     kind: "const"
56 |   };
57 | };
58 | 
59 | export function addStrictMode() {
60 |   return {
61 |     type: 'ExpressionStatement',
62 |     expression: {
63 |       type: 'Literal',
64 |       value: 'use strict',
65 |       raw: '"use strict"'
66 |     }
67 |   };
68 | }
69 | 


--------------------------------------------------------------------------------
/src/worker/property.js:
--------------------------------------------------------------------------------
 1 | import { assign } from './utils.js';
 2 | 
 3 | export default function(node, state, cont) {
 4 |   if(node.shorthand) {
 5 |     let key = node.key.name;
 6 |     let specifier = state.specifiers[key];
 7 |     if(specifier && !state.vars[key]) {
 8 |       node.shorthand = false;
 9 |       node.key = assign({}, node.key);
10 |     }
11 |   }
12 |   Object.getPrototypeOf(this).Property(node, state, cont);
13 | };
14 | 


--------------------------------------------------------------------------------
/src/worker/source-maps.js:
--------------------------------------------------------------------------------
1 | import { SourceNode } from 'source-map/lib/source-node';
2 | self.sourceMap = { SourceNode: SourceNode };
3 | 


--------------------------------------------------------------------------------
/src/worker/utils.js:
--------------------------------------------------------------------------------
1 | export function assign(a, b) {
2 |   for(var p in b) {
3 |     a[p] = b[p];
4 |   }
5 |   return a;
6 | }
7 | 


--------------------------------------------------------------------------------
/src/worker/visitors.js:
--------------------------------------------------------------------------------
 1 | import AssignmentExpression from './assignment-expression.js';
 2 | import CallExpression from './call-expression.js';
 3 | import ExportAllDeclaration from './export-all-declaration.js';
 4 | import ExportDefaultDeclaration from './export-default-declaration.js';
 5 | import ExportNamedDeclaration from './export-named-declaration.js';
 6 | import Identifier from './identifier.js';
 7 | import ImportDeclaration from './import-declaration.js';
 8 | import ImportCallIdentifier from './import-call-identifier.js';
 9 | import Property from './property.js';
10 | 
11 | export default {
12 |   AssignmentExpression: AssignmentExpression,
13 |   CallExpression: CallExpression,
14 |   ExportAllDeclaration: ExportAllDeclaration,
15 |   ExportDefaultDeclaration: ExportDefaultDeclaration,
16 |   ExportNamedDeclaration: ExportNamedDeclaration,
17 |   ImportCallIdentifier: ImportCallIdentifier,
18 |   ImportDeclaration: ImportDeclaration,
19 |   Identifier: Identifier,
20 |   FunctionExpression: functionWithLocalState('FunctionExpression'),
21 |   FunctionDeclaration: functionWithLocalState('FunctionDeclaration'),
22 |   ArrowFunctionExpression: functionWithLocalState('ArrowFunctionExpression'),
23 |   Property: Property,
24 |   VariableDeclarator: VariableDeclarator
25 | };
26 | 
27 | function functionWithLocalState(fnType){
28 |   return function(node, state, cont){
29 |     let localState = Object.assign({}, state, {
30 |       vars: Object.assign({}, state.vars)
31 |     });
32 |     if(node.params) {
33 |       node.params.forEach(function(node){
34 |         localState.vars[node.name] = true;
35 |       });
36 |     }
37 | 
38 |     Object.getPrototypeOf(this)[fnType](node, localState, cont);
39 |   };
40 | }
41 | 
42 | function VariableDeclarator(node, state, cont){
43 |   state.vars[node.id.name] = true;
44 |   Object.getPrototypeOf(this).VariableDeclarator(node, state, cont);
45 | }
46 | 


--------------------------------------------------------------------------------
/test/all.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>script-type-module tests</title>
 5 |   <style>
 6 |     iframe {
 7 |       border: 1px solid pink;
 8 |       flex: 1;
 9 |       margin-left: .5em;
10 |     }
11 |     .tests {
12 |       display: flex;
13 |       min-height: 300px;
14 |       margin-bottom: .5em;
15 |     }
16 |     .tests iframe {
17 |       flex-grow: 1;
18 |     }
19 |   </style>
20 | </head>
21 | <body>
22 |   <div class="tests">
23 |     <iframe src="./everything.html"></iframe>
24 |     <iframe src="./inline-everything.html"></iframe>
25 |   </div>
26 |   <div class="tests">
27 |     <iframe src="./import-syntax.html"></iframe>
28 |     <iframe src="./export-syntax.html"></iframe>
29 |   </div>
30 |   <div class="tests">
31 |     <iframe src="./scope.html"></iframe>
32 |     <iframe src="./circular.html"></iframe>
33 |   </div>
34 |   <div class="tests">
35 |     <iframe src="./errors.html"></iframe>
36 |     <iframe src="./import-dynamic.html"></iframe>
37 |   </div>
38 | </body>
39 | </html>
40 | 


--------------------------------------------------------------------------------
/test/circular.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Test circular deps</title>
 5 |   <script src="../polyfill.js" defer></script>
 6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
 7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
 8 | </head>
 9 | <body>
10 |   <div id="host"></div>
11 | <mocha-test>
12 | <template>
13 | <script>
14 | (function(){
15 |   let importDynamic = function(specifier){
16 |     return new Promise(function(resolve, reject){
17 |       let script = document.createElement('script');
18 |       script.type = 'module-polyfill';
19 |       script.onload = function(){
20 |         script.parentNode.removeChild(script);
21 |         resolve();
22 |       };
23 |       script.src = new URL(specifier, document.baseURI);
24 |       document.head.appendChild(script);
25 |     });
26 |   };
27 | 
28 |   describe('circular deps', function(){
29 |     beforeEach(function(){
30 |       delete self.RESULT;
31 |     });
32 | 
33 |     it('basics works', function(done){
34 |       importDynamic('./tests/circular/basics.js')
35 |       .then(function(){
36 |         let r = self.RESULT;
37 |         assert.equal(r.a(), 'a');
38 |         assert.equal(r.b(), 'b');
39 |         assert.equal(r.aC(), 'b');
40 |         assert.equal(r.bC(), 'a');
41 |       })
42 |       .then(done, done);
43 |     });
44 | 
45 |     it('works with 3 modules that are circular', function(done){
46 |       importDynamic('./tests/circular/threeway.js')
47 |       .then(function(){
48 |         let r = self.RESULT;
49 |         assert.equal(r.one(), 'b');
50 |         assert.equal(r.two(), 'c');
51 |         assert.equal(r.three(), 'a');
52 |       })
53 |       .then(done, done);
54 |     });
55 |   });
56 | })();
57 | </script>
58 | </template>
59 | </mocha-test>
60 | </body>
61 | </html>
62 | 


--------------------------------------------------------------------------------
/test/errors.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Test error handling</title>
 5 |   <script src="../polyfill.js" defer></script>
 6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
 7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
 8 | </head>
 9 | <body>
10 |   <div id="host"></div>
11 | <mocha-test>
12 | <template>
13 | <script>
14 | (function(){
15 |   let importDynamic = function(specifier){
16 |     return new Promise(function(resolve, reject){
17 |       let script = document.createElement('script');
18 |       script.type = 'module-polyfill';
19 |       script.onload = function(){
20 |         script.parentNode.removeChild(script);
21 |         resolve();
22 |       };
23 |       script.onerror = function(e){
24 |         script.parentNode.removeChild(script);
25 |         reject(e);
26 |       };
27 |       script.src = new URL(specifier, document.baseURI);
28 |       document.head.appendChild(script);
29 |     });
30 |   };
31 | 
32 |   describe('Reference errors', function(){
33 |     this.timeout(5000);
34 | 
35 |     it('are caught and logged', function(done){
36 |       importDynamic('./tests/errors/ref/index.js')
37 |       .then(null, function(e){
38 |         assert.ok(/bar/.test(e.message), 'Got the right error');
39 |         done();
40 |       });
41 |     });
42 |   });
43 | 
44 |   describe('Sloppy mode code', function(){
45 |     this.timeout(5000);
46 | 
47 |     it('throws', function(done){
48 |       importDynamic('./tests/errors/sloppy/index.js')
49 |       .then(null, function(e){
50 |         assert.ok(/someGlobal/.test(e.message));
51 |         done();
52 |       });
53 |     });
54 |   });
55 | })();
56 | </script>
57 | </template>
58 | </mocha-test>
59 | </body>
60 | </html>
61 | 


--------------------------------------------------------------------------------
/test/everything.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Test everything</title>
 5 |   <script src="../polyfill.js" defer data-no-sm></script>
 6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
 7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
 8 | </head>
 9 | <body>
10 |   <div id="host"></div>
11 |   <div id="host2"></div>
12 |   <template id="loader">
13 |     <script type="module-polyfill" src="./tests/everything/foo.js"></script>
14 |     <script type="module-polyfill" src="./tests/everything/bar.js"></script>
15 |   </template>
16 | <mocha-test>
17 | <template>
18 | <script>
19 |   describe('Everything', function(){
20 |     this.timeout(5000);
21 | 
22 |     function whenLoaded(script){
23 |       return new Promise(function(resolve, reject){
24 |         script.onload = resolve;
25 |         script.onerror = reject;
26 |       });
27 |     }
28 | 
29 |     after(function(){
30 |       host.innerHTML = '';
31 |     });
32 | 
33 |     it('works', function(done){
34 |       var frag = document.importNode(loader.content, true);
35 |       var one = frag.firstElementChild;
36 |       var two = one.nextElementSibling;
37 | 
38 |       document.body.appendChild(frag);
39 | 
40 |       var promises = [
41 |         whenLoaded(one),
42 |         whenLoaded(two)
43 |       ];
44 | 
45 |       Promise.all(promises)
46 |       .then(function(){
47 |         assert.equal(host.textContent, 'foobar');
48 |         assert.equal(host2.textContent, 'barbar');
49 |       })
50 |       .then(done, done);
51 |     });
52 |   });
53 | </script>
54 | </template>
55 | </mocha-test>
56 | </body>
57 | </html>
58 | 


--------------------------------------------------------------------------------
/test/export-syntax.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 | <head>
  4 |   <title>Test export syntaxes</title>
  5 |   <script src="../polyfill.js" defer data-no-sm></script>
  6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
  7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
  8 | </head>
  9 | <body>
 10 |   <div id="host"></div>
 11 | <mocha-test>
 12 | <template>
 13 | <script>
 14 | (function(){
 15 |   let importDynamic = function(specifier){
 16 |     return new Promise(function(resolve, reject){
 17 |       let script = document.createElement('script');
 18 |       script.type = 'module-polyfill';
 19 |       script.onload = function(){
 20 |         script.parentNode.removeChild(script);
 21 |         resolve();
 22 |       };
 23 |       script.src = new URL(specifier, document.baseURI);
 24 |       document.head.appendChild(script);
 25 |     });
 26 |   };
 27 | 
 28 |   describe('export default', function(){
 29 |     beforeEach(function(){
 30 |       delete self.RESULT;
 31 |     });
 32 | 
 33 |     it('works', function(done){
 34 |       importDynamic('./tests/exports/default.js')
 35 |       .then(function(){
 36 |         assert.equal(self.RESULT.a(), 'a');
 37 |         assert.equal(self.RESULT.b, 'b');
 38 |         assert.equal(self.RESULT.c, 'c');
 39 | 
 40 |         let d = self.RESULT.d;
 41 |         assert.equal(d.a, 'a');
 42 |         assert.equal(d.b, 'b');
 43 |         assert.equal(typeof d.c, 'function');
 44 |         assert.equal(d.c(), 'c');
 45 |       })
 46 |       .then(done, done);
 47 |     });
 48 |   });
 49 | 
 50 |   describe('export let', function(){
 51 |     beforeEach(function(){
 52 |       delete self.RESULT;
 53 |     });
 54 | 
 55 |     it('works', function(done){
 56 |       importDynamic('./tests/exports/let.js')
 57 |       .then(function(){
 58 |         assert.equal(self.RESULT.a, 'a');
 59 |         assert.equal(self.RESULT.b, 'b');
 60 |         assert.equal(self.RESULT.c(), 'c');
 61 |       })
 62 |       .then(done, done);
 63 |     });
 64 |   });
 65 | 
 66 |   describe('export { }', function(){
 67 |     beforeEach(function(){
 68 |       delete self.RESULT;
 69 |     });
 70 | 
 71 |     it('export { a as b } works', function(done){
 72 |       importDynamic('./tests/exports/object.js')
 73 |       .then(function(){
 74 |         assert.equal(self.RESULT.b, 'a');
 75 |       })
 76 |       .then(done, done);
 77 |     });
 78 |   });
 79 | 
 80 |   describe('export from', function(){
 81 |     before(function(done){
 82 |       delete self.RESULT;
 83 | 
 84 |       importDynamic('./tests/exports/from.js')
 85 |       .then(function(){
 86 |         done();
 87 |       });
 88 |     });
 89 | 
 90 |     describe('export { a } from', function(){
 91 |       it('Names are re-exported', function(){
 92 |         assert.equal(self.RESULT.getA(), 'a');
 93 |       });
 94 | 
 95 |       it('Bindings are honored', function(){
 96 |         self.RESULT.aB();
 97 |         assert.equal(self.RESULT.getA(), 'ab');
 98 |       });
 99 |     });
100 | 
101 |     describe('export { a as b } from', function(){
102 |       it('Works', function(){
103 |         console.log(self.RESULT)
104 |         assert.equal(self.RESULT.b, 'a');
105 |       });
106 |     });
107 | 
108 |     describe('export * from', function(){
109 |       it('Works', function(){
110 |         let c = self.RESULT.c;
111 |         assert.equal(c.a, 'ab');
112 |       });
113 |     });
114 |   });
115 | })();
116 | </script>
117 | </template>
118 | </mocha-test>
119 | </body>
120 | </html>
121 | 


--------------------------------------------------------------------------------
/test/import-dynamic.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Test import syntaxes</title>
 5 |   <script src="../polyfill.js" defer data-no-sm></script>
 6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
 7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
 8 | </head>
 9 | <body>
10 |   <div id="host"></div>
11 | <mocha-test>
12 | <template>
13 | <script>
14 | (function(){
15 |   let importDynamic = function(specifier){
16 |     return new Promise(function(resolve, reject){
17 |       let script = document.createElement('script');
18 |       script.type = 'module-polyfill';
19 |       script.onload = function(){
20 |         script.parentNode.removeChild(script);
21 |         resolve();
22 |       };
23 |       script.onerror = function(e){
24 |         script.parentNode.removeChild(script);
25 |         reject(e);
26 |       };
27 |       script.src = new URL(specifier, document.baseURI);
28 |       document.head.appendChild(script);
29 |     });
30 |   };
31 |   describe('import()', function(){
32 |     this.timeout(5000);
33 | 
34 | 
35 |     it('works alongside static imports', function(done){
36 |       importDynamic('./tests/import-fn/dynamic.js')
37 |       .then(function(){
38 |         let res = self.RESULT;
39 |         assert.equal(res.foo, 'foo');
40 | 
41 |         return Promise.all([res.bar, res.qux, res.baz]);
42 |       })
43 |       .then(function(res){
44 |         let barNamespace = res[0];
45 |         let quxNamespace = res[1];
46 |         let bazNamespace = res[2];
47 | 
48 |         assert.equal(barNamespace.default, 'bar');
49 |         assert.equal(quxNamespace.default, 'qux');
50 |         assert.equal(bazNamespace.default, 'baz');
51 |       })
52 |       .then(done, done);
53 |     });
54 | 
55 |     it('SyntaxError if spread is used', function(done){
56 |       importDynamic('./tests/import-fn/spread.js')
57 |       .then(function(){
58 |         assert.ok(false, 'Import succeeded when it should have failed');
59 |       }, function(err){
60 |         assert.ok(/Spread syntax/.test(err.message));
61 |       })
62 |       .then(done, done);
63 |     });
64 | 
65 |     it('SyntaxError if multiple arguments are passed', function(done){
66 |       importDynamic('./tests/import-fn/multi-arg.js')
67 |       .then(function(){
68 |         assert.ok(false, 'Import succeeded when it should have failed');
69 |       }, function(err){
70 |         assert.ok(/single argument/.test(err.message));
71 |       })
72 |       .then(done, done);
73 |     });
74 |   });
75 | })();
76 | </script>
77 | </template>
78 | </mocha-test>
79 | </body>
80 | </html>
81 | 


--------------------------------------------------------------------------------
/test/import-syntax.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 | <head>
  4 |   <title>Test import syntaxes</title>
  5 |   <script src="../polyfill.js" defer data-no-sm></script>
  6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
  7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
  8 | </head>
  9 | <body>
 10 |   <div id="host"></div>
 11 | <mocha-test>
 12 | <template>
 13 | <script>
 14 | (function(){
 15 |   let importDynamic = function(specifier){
 16 |     return new Promise(function(resolve, reject){
 17 |       let script = document.createElement('script');
 18 |       script.type = 'module-polyfill';
 19 |       script.onload = function(){
 20 |         script.parentNode.removeChild(script);
 21 |         resolve();
 22 |       };
 23 |       script.src = new URL(specifier, document.baseURI);
 24 |       document.head.appendChild(script);
 25 |     });
 26 |   };
 27 | 
 28 |   describe('import default', function(){
 29 |     this.timeout(5000);
 30 | 
 31 |     beforeEach(function(){
 32 |       delete self.RESULT;
 33 |     });
 34 | 
 35 |     it('works', function(done){
 36 |       importDynamic('./tests/imports/default.js')
 37 |       .then(function(){
 38 |         assert.equal(self.RESULT.foo, 'bar');
 39 |       })
 40 |       .then(done, done);
 41 |     });
 42 |   });
 43 | 
 44 |   describe('import *', function(){
 45 |     this.timeout(5000);
 46 | 
 47 |     beforeEach(function(){
 48 |       delete self.RESULT;
 49 |     });
 50 | 
 51 |     it('works', function(done){
 52 |       importDynamic('./tests/imports/star.js')
 53 |       .then(function(){
 54 |         assert.equal(self.RESULT.foo, 'bar');
 55 |         assert.equal(self.RESULT.bar, 17);
 56 |       })
 57 |       .then(done, done);
 58 |     });
 59 |   });
 60 | 
 61 |   describe('import {member}', function(){
 62 |     this.timeout(5000);
 63 | 
 64 |     beforeEach(function(){
 65 |       delete self.RESULT;
 66 |     });
 67 | 
 68 |     it('import {a, b} works', function(done){
 69 |       importDynamic('./tests/imports/members.js')
 70 |       .then(function(){
 71 |         assert.equal(self.RESULT.a, 'a');
 72 |         assert.equal(self.RESULT.b, 'b');
 73 |       })
 74 |       .then(done, done);
 75 |     });
 76 | 
 77 |     it('import {a as b} works', function(done){
 78 |       importDynamic('./tests/imports/member-alias.js')
 79 |       .then(function(){
 80 |         assert.equal(self.RESULT.a, 'a');
 81 |       })
 82 |       .then(done, done);
 83 |     });
 84 |   });
 85 | 
 86 |   describe('import "side-effect.js"', function(){
 87 |     beforeEach(function(){
 88 |       delete self.RESULT;
 89 |     });
 90 | 
 91 |     it('works', function(done){
 92 |       importDynamic('./tests/imports/side-effect.js')
 93 |       .then(function(){
 94 |         assert.equal(self.RESULT, 'it worked');
 95 |       })
 96 |       .then(done, done);
 97 |     });
 98 |   });
 99 | 
100 |   describe('import default, {member}', function(){
101 |     beforeEach(function(){
102 |       delete self.RESULT;
103 |     });
104 | 
105 |     it('works', function(done){
106 |       importDynamic('./tests/imports/default-and-member.js')
107 |       .then(function(){
108 |         assert.equal(self.RESULT.a, 'a');
109 |         assert.equal(self.RESULT.b, 'b');
110 |       })
111 |       .then(done, done);
112 |     });
113 |   });
114 | 
115 |   describe('import default, * as star', function(){
116 |     beforeEach(function(){
117 |       delete self.RESULT;
118 |     });
119 | 
120 |     it('works', function(done){
121 |       importDynamic('./tests/imports/default-and-star.js')
122 |       .then(function(){
123 |         assert.equal(self.RESULT.a, 'a');
124 |         assert.equal(self.RESULT.b, 'b');
125 |         assert.equal(self.RESULT.c, 'c');
126 |       })
127 |       .then(done, done);
128 |     });
129 |   });
130 | })();
131 | </script>
132 | </template>
133 | </mocha-test>
134 | </body>
135 | </html>
136 | 


--------------------------------------------------------------------------------
/test/inline-everything.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Test everything</title>
 5 |   <script src="../polyfill.js" defer></script>
 6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
 7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
 8 | </head>
 9 | <body>
10 |   <div id="host"></div>
11 | <mocha-test>
12 | <template>
13 | <script type="module-polyfill" id="the-module">
14 |   import './tests/everything/foo.js';
15 | </script>
16 | 
17 | <script>
18 |   describe('Everything', function(){
19 |     this.timeout(5000);
20 | 
21 |     after(function(){
22 |       host.innerHTML = '';
23 |     });
24 | 
25 |     it('works', function(done){
26 |       var script = document.getElementById('the-module');
27 |       script.onload = function(){
28 |         assert.equal(host.textContent, 'foobar');
29 |         done();
30 |       };
31 |     });
32 |   });
33 | </script>
34 | </template>
35 | </mocha-test>
36 | </body>
37 | </html>
38 | 


--------------------------------------------------------------------------------
/test/perf/app/config.js:
--------------------------------------------------------------------------------
 1 | System.config({
 2 |   //baseURL: "/",
 3 |   defaultJSExtensions: true,
 4 |   transpiler: "babel",
 5 |   babelOptions: {
 6 |     "optional": [
 7 |       "runtime",
 8 |       "optimisation.modules.system"
 9 |     ]
10 |   },
11 |   paths: {
12 |     "github:*": "jspm_packages/github/*",
13 |     "npm:*": "jspm_packages/npm/*"
14 |   },
15 | 
16 |   map: {
17 |     "babel": "npm:babel-core@5.8.38",
18 |     "babel-runtime": "npm:babel-runtime@5.8.38",
19 |     "core-js": "npm:core-js@1.2.7",
20 |     "github:jspm/nodelibs-assert@0.1.0": {
21 |       "assert": "npm:assert@1.4.1"
22 |     },
23 |     "github:jspm/nodelibs-buffer@0.1.0": {
24 |       "buffer": "npm:buffer@3.6.0"
25 |     },
26 |     "github:jspm/nodelibs-path@0.1.0": {
27 |       "path-browserify": "npm:path-browserify@0.0.0"
28 |     },
29 |     "github:jspm/nodelibs-process@0.1.2": {
30 |       "process": "npm:process@0.11.9"
31 |     },
32 |     "github:jspm/nodelibs-util@0.1.0": {
33 |       "util": "npm:util@0.10.3"
34 |     },
35 |     "github:jspm/nodelibs-vm@0.1.0": {
36 |       "vm-browserify": "npm:vm-browserify@0.0.4"
37 |     },
38 |     "npm:assert@1.4.1": {
39 |       "assert": "github:jspm/nodelibs-assert@0.1.0",
40 |       "buffer": "github:jspm/nodelibs-buffer@0.1.0",
41 |       "process": "github:jspm/nodelibs-process@0.1.2",
42 |       "util": "npm:util@0.10.3"
43 |     },
44 |     "npm:babel-runtime@5.8.38": {
45 |       "process": "github:jspm/nodelibs-process@0.1.2"
46 |     },
47 |     "npm:buffer@3.6.0": {
48 |       "base64-js": "npm:base64-js@0.0.8",
49 |       "child_process": "github:jspm/nodelibs-child_process@0.1.0",
50 |       "fs": "github:jspm/nodelibs-fs@0.1.2",
51 |       "ieee754": "npm:ieee754@1.1.6",
52 |       "isarray": "npm:isarray@1.0.0",
53 |       "process": "github:jspm/nodelibs-process@0.1.2"
54 |     },
55 |     "npm:core-js@1.2.7": {
56 |       "fs": "github:jspm/nodelibs-fs@0.1.2",
57 |       "path": "github:jspm/nodelibs-path@0.1.0",
58 |       "process": "github:jspm/nodelibs-process@0.1.2",
59 |       "systemjs-json": "github:systemjs/plugin-json@0.1.2"
60 |     },
61 |     "npm:inherits@2.0.1": {
62 |       "util": "github:jspm/nodelibs-util@0.1.0"
63 |     },
64 |     "npm:path-browserify@0.0.0": {
65 |       "process": "github:jspm/nodelibs-process@0.1.2"
66 |     },
67 |     "npm:process@0.11.9": {
68 |       "assert": "github:jspm/nodelibs-assert@0.1.0",
69 |       "fs": "github:jspm/nodelibs-fs@0.1.2",
70 |       "vm": "github:jspm/nodelibs-vm@0.1.0"
71 |     },
72 |     "npm:util@0.10.3": {
73 |       "inherits": "npm:inherits@2.0.1",
74 |       "process": "github:jspm/nodelibs-process@0.1.2"
75 |     },
76 |     "npm:vm-browserify@0.0.4": {
77 |       "indexof": "npm:indexof@0.0.1"
78 |     }
79 |   }
80 | });
81 | 


--------------------------------------------------------------------------------
/test/perf/app/generate.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs');
 2 | const path = require('path');
 3 | 
 4 | const max = 500;
 5 | const deps = 10;
 6 | const first = 30;
 7 | 
 8 | let includeJS = process.argv[2] !== '--no-js';
 9 | 
10 | let cnt = 0;
11 | 
12 | let importer = function(pth){
13 |   return `
14 |     import def from './${pth}';
15 |   `;
16 | }
17 | 
18 | let exporter = function(){
19 |   return `
20 |     export default function(){
21 |     };
22 |   `;
23 | }
24 | 
25 | let importerExporter = function(pth){
26 |   return `
27 |     import def from './${pth}';
28 | 
29 |     export default function(){
30 |     };
31 |   `;
32 | };
33 | 
34 | let mainTmpl = function(names){
35 |   return `
36 |     import './${names[0]}';
37 |     import './${names[1]}';
38 |     import './${names[2]}';
39 |     import './${names[3]}';
40 |     import './${names[4]}';
41 |     import './${names[5]}';
42 |     import './${names[6]}';
43 |     import './${names[7]}';
44 |     import './${names[8]}';
45 |     import './${names[9]}';
46 |   `;
47 | }
48 | 
49 | let names = {};
50 | function makeName(){
51 |   let name = Math.random().toString(36).substring(7);
52 |   if(names[name]) {
53 |     return makeName();
54 |   }
55 |   names[name] = true;
56 |   return name;
57 | }
58 | 
59 | function makeModule(tmpl, hasChildren){
60 |   cnt++;
61 |   let name = makeName();
62 |   let fn = includeJS ? name + '.js' : name;
63 |   let pth = path.join(__dirname, 'src', name + '.js');
64 | 
65 |   let src;
66 |   if(hasChildren && cnt < max) {
67 |     let nextTmpl, willHaveChildren = true;
68 |     if((cnt + 10) < max) {
69 |       nextTmpl = importerExporter;
70 |     } else {
71 |       nextTmpl = exporter;
72 |       willHaveChildren = false;
73 |     }
74 | 
75 |     let child = makeModule(nextTmpl, willHaveChildren);
76 |     src = tmpl(child);
77 |   } else {
78 |     tmpl = exporter;
79 |     src = tmpl();
80 |   }
81 | 
82 |   //console.log(src);
83 |   fs.writeFileSync(pth, src, 'utf8');
84 | 
85 |   return fn;
86 | }
87 | 
88 | let mainDeps = [];
89 | 
90 | for(var i = 0; i < first; i++) {
91 |   let local = makeModule(importer, true);
92 |   mainDeps.push(local);
93 | }
94 | 
95 | let src = mainTmpl(mainDeps);
96 | let pth = path.join(__dirname, 'src', 'main.js');
97 | fs.writeFileSync(pth, src, 'utf8');
98 | 


--------------------------------------------------------------------------------
/test/perf/app/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "app",
 3 |   "version": "1.0.0",
 4 |   "main": "src/main.js",
 5 |   "dependencies": {
 6 |     "steal": "^1.0.0-rc.0"
 7 |   },
 8 |   "jspm": {
 9 |     "dependencies": {},
10 |     "devDependencies": {
11 |       "babel": "npm:babel-core@^5.8.24",
12 |       "babel-runtime": "npm:babel-runtime@^5.8.24",
13 |       "core-js": "npm:core-js@^1.1.4"
14 |     }
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/test/perf/app/polyfill.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Perf test</title>
 5 | </head>
 6 | <body>
 7 |   <h1>script-type-module test</h1>
 8 | 
 9 |   <h1 id="host">Loading</h1>
10 |   <h2 id="timeSpent"></h2>
11 |   <script src="../../../polyfill.js"></script>
12 |   <script type="module-polyfill" src="./src/main.js"></script>
13 | 
14 |   <script>
15 |   (function(){
16 |     let script = document.querySelector('script[type=module-polyfill]');
17 |     let start = performance.now();
18 |     script.onload = function(){
19 |       let stop = performance.now();
20 |       host.textContent = 'Done!';
21 |       timeSpent.textContent = stop - start;
22 |     };
23 |   })();
24 |   </script>
25 | </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/test/perf/app/steal.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Perf test</title>
 5 | </head>
 6 | <body>
 7 |   <h1 id="host">Loading</h1>
 8 |   <h2 id="timeSpent"></h2>
 9 |   <script src="./node_modules/steal/steal.js"></script>
10 | 
11 |   <script>
12 |   (function(){
13 |     let start = performance.now();
14 |     steal.done().then(function(){
15 |       let stop = performance.now();
16 |       host.textContent = 'Done!';
17 |       timeSpent.textContent = stop - start;
18 |     });
19 |   })();
20 |   </script>
21 | </body>
22 | </html>
23 | 


--------------------------------------------------------------------------------
/test/perf/app/systemjs.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Perf test</title>
 5 | </head>
 6 | <body>
 7 |   <h1>SystemJS test</h1>
 8 | 
 9 |   <h1 id="host">Loading</h1>
10 |   <h2 id="timeSpent"></h2>
11 |   <script src="./jspm_packages/system.js"></script>
12 |   <script src="./config.js"></script>
13 | 
14 |   <script>
15 |   (function(){
16 |     let start = performance.now();
17 | 
18 |     System.import('./src/main.js')
19 |     .then(function(){
20 |       let stop = performance.now();
21 |       host.textContent = 'Done!';
22 |       timeSpent.textContent = stop - start;
23 |     });
24 |   })();
25 |   </script>
26 | </body>
27 | </html>
28 | 


--------------------------------------------------------------------------------
/test/scope.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <head>
 4 |   <title>Test scoping</title>
 5 |   <script src="../polyfill.js" defer></script>
 6 |   <script src="../node_modules/webcomponents.js/webcomponents-lite.js" defer></script>
 7 |   <link rel="import" href="../node_modules/mocha-test/mocha-test.html" defer>
 8 | </head>
 9 | <body>
10 |   <div id="host"></div>
11 | <mocha-test>
12 | <template>
13 | <script>
14 | (function(){
15 |   let importDynamic = function(specifier){
16 |     return new Promise(function(resolve, reject){
17 |       let script = document.createElement('script');
18 |       script.type = 'module-polyfill';
19 |       script.onload = function(){
20 |         script.parentNode.removeChild(script);
21 |         resolve();
22 |       };
23 |       script.src = new URL(specifier, document.baseURI);
24 |       document.head.appendChild(script);
25 |     });
26 |   };
27 | 
28 |   describe('Scoping', function(){
29 |     this.timeout(5000);
30 | 
31 |     beforeEach(function(){
32 |       delete self.RESULT;
33 |     });
34 | 
35 |     it('Doesn\'t override arguments', function(done){
36 |       importDynamic('./tests/scope/main.js')
37 |       .then(function(){
38 |         assert.equal(self.RESULT.one, 'foo');
39 |         assert.equal(self.RESULT.two, 'bar');
40 |         assert.equal(self.RESULT.three, 'qux');
41 |         assert.equal(self.RESULT.four, 'baz');
42 |         assert.equal(self.RESULT.five, 'foo');
43 |         assert.equal(self.RESULT.six, 'quux');
44 |       })
45 |       .then(done, done);
46 |     });
47 | 
48 |     it('Doesn\'t override local variables', function(done){
49 |       importDynamic('./tests/scope/var.js')
50 |       .then(function(){
51 |         assert.equal(self.RESULT.one, 'foo');
52 |         assert.equal(self.RESULT.two, 'bar');
53 |         assert.equal(self.RESULT.three, 'baz');
54 |         assert.equal(self.RESULT.four, 'qux');
55 |       })
56 |       .then(done, done);
57 |     });
58 |   });
59 | })();
60 | </script>
61 | </template>
62 | </mocha-test>
63 | </body>
64 | </html>
65 | 


--------------------------------------------------------------------------------
/test/tests/circular/basics.js:
--------------------------------------------------------------------------------
 1 | import { a, c as aC } from './src/a.js';
 2 | import { b, c as bC } from './src/b.js';
 3 | 
 4 | self.RESULT = {
 5 |   a: a,
 6 |   b: b,
 7 |   aC: aC,
 8 |   bC: bC
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/tests/circular/src/a.js:
--------------------------------------------------------------------------------
 1 | import { b } from './b.js';
 2 | 
 3 | export function a(){
 4 |   return 'a';
 5 | };
 6 | 
 7 | export function c() {
 8 |   return b();
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/tests/circular/src/b.js:
--------------------------------------------------------------------------------
 1 | import { a } from './a.js';
 2 | 
 3 | export function b(){
 4 |   return 'b';
 5 | };
 6 | 
 7 | export function c() {
 8 |   return a();
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/tests/circular/src/one.js:
--------------------------------------------------------------------------------
 1 | import { b } from './two.js';
 2 | 
 3 | export function a(){
 4 |   return 'a';
 5 | };
 6 | 
 7 | export function one() {
 8 |   return b();
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/tests/circular/src/three.js:
--------------------------------------------------------------------------------
 1 | import { a } from './one.js';
 2 | 
 3 | export function c(){
 4 |   return 'c';
 5 | };
 6 | 
 7 | export function three(){
 8 |   return a();
 9 | }
10 | 


--------------------------------------------------------------------------------
/test/tests/circular/src/two.js:
--------------------------------------------------------------------------------
 1 | import { c } from './three.js';
 2 | 
 3 | export function b() {
 4 |   return 'b';
 5 | };
 6 | 
 7 | export function two() {
 8 |   return c();
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/tests/circular/threeway.js:
--------------------------------------------------------------------------------
 1 | import { one } from './src/one.js';
 2 | import { two } from './src/two.js';
 3 | import { three } from './src/three.js';
 4 | 
 5 | self.RESULT = {
 6 |   one: one,
 7 |   two: two,
 8 |   three: three
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/tests/errors/ref/bad.js:
--------------------------------------------------------------------------------
1 | function foo() {
2 |   bar();
3 | }
4 | 
5 | foo();
6 | 


--------------------------------------------------------------------------------
/test/tests/errors/ref/index.js:
--------------------------------------------------------------------------------
1 | import './bad.js';
2 | 


--------------------------------------------------------------------------------
/test/tests/errors/sloppy/index.js:
--------------------------------------------------------------------------------
1 | someGlobal = true;
2 | 


--------------------------------------------------------------------------------
/test/tests/everything/bar.js:
--------------------------------------------------------------------------------
1 | import { bar } from './other.js';
2 | 
3 | function someFunction(foo = []) {
4 |   // Just verifying that default args work
5 | }
6 | 
7 | host2.innerHTML = 'bar' + bar();
8 | 


--------------------------------------------------------------------------------
/test/tests/everything/folder/thing.js:
--------------------------------------------------------------------------------
1 | import './yet-another.js';
2 | 
3 | export default function(){
4 | 
5 | };
6 | 


--------------------------------------------------------------------------------
/test/tests/everything/folder/yet-another.js:
--------------------------------------------------------------------------------
1 | let foo = 'bar';
2 | 
3 | export default foo;
4 | 


--------------------------------------------------------------------------------
/test/tests/everything/foo.js:
--------------------------------------------------------------------------------
1 | import { bar } from './other.js';
2 | 
3 | host.innerHTML = 'foo' + bar();
4 | 


--------------------------------------------------------------------------------
/test/tests/everything/index.html:
--------------------------------------------------------------------------------
1 | <title>Demo</title>
2 | <h1 id="host">Loading...</h1>
3 | <script type="module" src="./foo.js"></script>
4 | <script src="../../../script-type-module.js"></script>
5 | 


--------------------------------------------------------------------------------
/test/tests/everything/other.js:
--------------------------------------------------------------------------------
1 | import thing from './folder/thing.js';
2 | 
3 | export function bar(){
4 |   return 'bar';
5 | };
6 | 


--------------------------------------------------------------------------------
/test/tests/exports/default.js:
--------------------------------------------------------------------------------
 1 | import a from './src/default-fn.js';
 2 | import b from './src/default-expr.js';
 3 | import c from './src/default-obj-alias.js';
 4 | import d from './src/default-object.js';
 5 | 
 6 | self.RESULT = {
 7 |   a: a,
 8 |   b: b,
 9 |   c: c,
10 |   d: d
11 | };
12 | 


--------------------------------------------------------------------------------
/test/tests/exports/from.js:
--------------------------------------------------------------------------------
 1 | import { a, aB } from './src/from-name.js';
 2 | import { b } from './src/from-as.js';
 3 | import * as c from './src/from-star.js';
 4 | 
 5 | /**
 6 |  * TODO:
 7 |  * export { a as b } from
 8 |  * export * from
 9 |  */
10 | 
11 | self.RESULT = {
12 |   getA: function(){
13 |     return a;
14 |   },
15 |   aB: aB,
16 |   b: b,
17 |   c: c
18 | };
19 | 


--------------------------------------------------------------------------------
/test/tests/exports/let.js:
--------------------------------------------------------------------------------
 1 | import { a } from './src/let-equal.js';
 2 | import { b } from './src/let-var.js';
 3 | import { c } from './src/let-use-export.js';
 4 | 
 5 | self.RESULT = {
 6 |   a,
 7 |   b,
 8 |   c
 9 | };
10 | 


--------------------------------------------------------------------------------
/test/tests/exports/object.js:
--------------------------------------------------------------------------------
1 | import { b } from './src/object-as.js';
2 | 
3 | self.RESULT = {
4 |   b: b
5 | };
6 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/default-expr.js:
--------------------------------------------------------------------------------
1 | export default 'b';
2 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/default-fn.js:
--------------------------------------------------------------------------------
1 | export default function(){
2 |   return 'a';
3 | };
4 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/default-obj-alias.js:
--------------------------------------------------------------------------------
1 | const c = 'c';
2 | 
3 | export { c as default };
4 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/default-object.js:
--------------------------------------------------------------------------------
 1 | let a = 'a';
 2 | let b = 'b';
 3 | 
 4 | export default {
 5 |   a: a,
 6 |   b: b,
 7 |   c: c
 8 | };
 9 | 
10 | function c(){
11 |   return 'c';
12 | }
13 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/from-as.js:
--------------------------------------------------------------------------------
1 | export { a as b } from './from-source2.js';
2 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/from-name.js:
--------------------------------------------------------------------------------
1 | export { a, aB } from './from-source.js';
2 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/from-source.js:
--------------------------------------------------------------------------------
1 | export let a = 'a';
2 | 
3 | export function aB(){
4 |   a = 'ab';
5 | }
6 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/from-source2.js:
--------------------------------------------------------------------------------
1 | export let a = 'a';
2 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/from-star.js:
--------------------------------------------------------------------------------
1 | export * from './from-source.js';
2 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/let-equal.js:
--------------------------------------------------------------------------------
1 | export let a = 'a';
2 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/let-use-export.js:
--------------------------------------------------------------------------------
 1 | export let d;
 2 | 
 3 | d = 'c';
 4 | 
 5 | export function c(){
 6 |   return d;
 7 | }
 8 | 
 9 | 
10 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/let-var.js:
--------------------------------------------------------------------------------
1 | export let b;
2 | 
3 | b = 'b';
4 | 


--------------------------------------------------------------------------------
/test/tests/exports/src/object-as.js:
--------------------------------------------------------------------------------
1 | let a = 'a';
2 | 
3 | export { a as b };
4 | 


--------------------------------------------------------------------------------
/test/tests/import-fn/dynamic.js:
--------------------------------------------------------------------------------
 1 | import foo from './src/foo.js';
 2 | 
 3 | let barPromise = import('./src/bar.js');
 4 | let quxPromise = import('./src/qux.js').then(function(qux){
 5 |   return qux;
 6 | });
 7 | let pageUrl = new URL('./tests/import-fn/src/baz.js', document.baseURI);
 8 | let bazPromise = import(pageUrl);
 9 | 
10 | self.RESULT = {
11 |   foo: foo,
12 |   bar: barPromise,
13 |   baz: bazPromise,
14 |   qux: quxPromise
15 | };
16 | 


--------------------------------------------------------------------------------
/test/tests/import-fn/multi-arg.js:
--------------------------------------------------------------------------------
1 | // This should be a SyntaxError according to
2 | // https://github.com/domenic/proposal-dynamic-import/issues/15
3 | 
4 | let barPromise = import('./src/bar.js', { something: 'else' });
5 | 
6 | self.RESULT = {
7 |   bar: barPromise
8 | };
9 | 


--------------------------------------------------------------------------------
/test/tests/import-fn/spread.js:
--------------------------------------------------------------------------------
1 | // This should be a SyntaxError according to
2 | // https://github.com/domenic/proposal-dynamic-import/issues/15
3 | 
4 | let barPromise = import(...['./src/bar.js']);
5 | 
6 | self.RESULT = {
7 |   bar: barPromise
8 | };
9 | 


--------------------------------------------------------------------------------
/test/tests/import-fn/src/bar.js:
--------------------------------------------------------------------------------
1 | export default 'bar';
2 | 


--------------------------------------------------------------------------------
/test/tests/import-fn/src/baz.js:
--------------------------------------------------------------------------------
1 | export default 'baz';
2 | 


--------------------------------------------------------------------------------
/test/tests/import-fn/src/foo.js:
--------------------------------------------------------------------------------
1 | export default 'foo';
2 | 


--------------------------------------------------------------------------------
/test/tests/import-fn/src/qux.js:
--------------------------------------------------------------------------------
1 | export default 'qux';
2 | 


--------------------------------------------------------------------------------
/test/tests/imports/default-and-member.js:
--------------------------------------------------------------------------------
1 | import a, {b} from './src/default-and-member.js';
2 | 
3 | self.RESULT = {
4 |   a: a,
5 |   b
6 | };
7 | 


--------------------------------------------------------------------------------
/test/tests/imports/default-and-star.js:
--------------------------------------------------------------------------------
1 | import a, * as star from './src/default-and-star.js';
2 | 
3 | self.RESULT = {
4 |   a: a,
5 |   b: star.b,
6 |   c: star.c
7 | };
8 | 


--------------------------------------------------------------------------------
/test/tests/imports/default.js:
--------------------------------------------------------------------------------
1 | import foo from './src/default.js';
2 | 
3 | self.RESULT = {
4 |   foo: foo()
5 | };
6 | 


--------------------------------------------------------------------------------
/test/tests/imports/member-alias.js:
--------------------------------------------------------------------------------
1 | import {a as b} from './src/members.js';
2 | 
3 | self.RESULT = {
4 |   a: b
5 | };
6 | 


--------------------------------------------------------------------------------
/test/tests/imports/members.js:
--------------------------------------------------------------------------------
1 | import {a, b} from './src/members.js';
2 | 
3 | self.RESULT = {
4 |   a: a,
5 |   b: b
6 | };
7 | 


--------------------------------------------------------------------------------
/test/tests/imports/side-effect.js:
--------------------------------------------------------------------------------
1 | import './src/side-effect.js';
2 | 


--------------------------------------------------------------------------------
/test/tests/imports/src/default-and-member.js:
--------------------------------------------------------------------------------
1 | export default a = 'a';
2 | export let b = 'b';
3 | 


--------------------------------------------------------------------------------
/test/tests/imports/src/default-and-star.js:
--------------------------------------------------------------------------------
1 | export default a = 'a';
2 | export let b = 'b';
3 | export let c = 'c';
4 | 


--------------------------------------------------------------------------------
/test/tests/imports/src/default.js:
--------------------------------------------------------------------------------
1 | export default function(){
2 |   return 'bar';
3 | };
4 | 


--------------------------------------------------------------------------------
/test/tests/imports/src/members.js:
--------------------------------------------------------------------------------
1 | export let a = 'a';
2 | export let b = 'b';
3 | 


--------------------------------------------------------------------------------
/test/tests/imports/src/side-effect.js:
--------------------------------------------------------------------------------
1 | self.RESULT = 'it worked';
2 | 


--------------------------------------------------------------------------------
/test/tests/imports/src/star.js:
--------------------------------------------------------------------------------
1 | export function foo(){
2 |   return 'bar';
3 | };
4 | 
5 | export let bar = 17;
6 | 


--------------------------------------------------------------------------------
/test/tests/imports/star.js:
--------------------------------------------------------------------------------
 1 | import * as star from './src/star.js';
 2 | 
 3 | if(self.RESULT) {
 4 |   throw new Error('This module has already loaded');
 5 | }
 6 | 
 7 | self.RESULT = {
 8 |   foo: star.foo(),
 9 |   bar: star.bar
10 | };
11 | 


--------------------------------------------------------------------------------
/test/tests/scope/main.js:
--------------------------------------------------------------------------------
 1 | import {foo} from './src/foo.js';
 2 | 
 3 | let result = self.RESULT = {};
 4 | 
 5 | result.one = foo();
 6 | 
 7 | function bar(foo){
 8 |   result.two = foo();
 9 | }
10 | 
11 | bar(function(){
12 |   return 'bar';
13 | });
14 | 
15 | let qux = (foo) => {
16 |   result.three = foo();
17 | };
18 | 
19 | qux(function(){
20 |   return 'qux';
21 | });
22 | 
23 | let baz = function(foo){
24 |   result.four = foo();
25 | };
26 | 
27 | baz(() => 'baz');
28 | 
29 | class Thing {
30 |   constructor() {
31 |     result.five = foo();
32 |   }
33 | 
34 |   another(foo) {
35 |     result.six = foo();
36 |   }
37 | }
38 | 
39 | let obj = new Thing();
40 | obj.another(() => 'quux');
41 | 


--------------------------------------------------------------------------------
/test/tests/scope/src/foo.js:
--------------------------------------------------------------------------------
1 | export function foo(){
2 |   return 'foo';
3 | };
4 | 


--------------------------------------------------------------------------------
/test/tests/scope/var.js:
--------------------------------------------------------------------------------
 1 | import {foo} from './src/foo.js';
 2 | 
 3 | let result = self.RESULT = {};
 4 | 
 5 | result.one = foo();
 6 | 
 7 | function bar(){
 8 |   var foo = () => 'bar';
 9 |   result.two = foo();
10 | }
11 | bar();
12 | 
13 | function baz(){
14 |   let foo = function() { return 'baz' };
15 |   result.three = foo();
16 | }
17 | baz();
18 | 
19 | function qux() {
20 |   const foo = () => 'qux';
21 |   result.four = foo();
22 | }
23 | qux();
24 | 


--------------------------------------------------------------------------------