1/* 2* SystemJS 5.0.0 3*/ 4(function () { 5 const hasSelf = typeof self !== 'undefined'; 6 7 const envGlobal = hasSelf ? self : global; 8 9 let baseUrl; 10 11 if (typeof document !== 'undefined') { 12 const baseEl = document.querySelector('base[href]'); 13 if (baseEl) 14 baseUrl = baseEl.href; 15 } 16 17 if (!baseUrl && typeof location !== 'undefined') { 18 baseUrl = location.href.split('#')[0].split('?')[0]; 19 const lastSepIndex = baseUrl.lastIndexOf('/'); 20 if (lastSepIndex !== -1) 21 baseUrl = baseUrl.slice(0, lastSepIndex + 1); 22 } 23 24 const backslashRegEx = /\\/g; 25 function resolveIfNotPlainOrUrl (relUrl, parentUrl) { 26 if (relUrl.indexOf('\\') !== -1) 27 relUrl = relUrl.replace(backslashRegEx, '/'); 28 // protocol-relative 29 if (relUrl[0] === '/' && relUrl[1] === '/') { 30 return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl; 31 } 32 // relative-url 33 else if (relUrl[0] === '.' && (relUrl[1] === '/' || relUrl[1] === '.' && (relUrl[2] === '/' || relUrl.length === 2 && (relUrl += '/')) || 34 relUrl.length === 1 && (relUrl += '/')) || 35 relUrl[0] === '/') { 36 const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1); 37 // Disabled, but these cases will give inconsistent results for deep backtracking 38 //if (parentUrl[parentProtocol.length] !== '/') 39 // throw Error('Cannot resolve'); 40 // read pathname from parent URL 41 // pathname taken to be part after leading "/" 42 let pathname; 43 if (parentUrl[parentProtocol.length + 1] === '/') { 44 // resolving to a :// so we need to read out the auth and host 45 if (parentProtocol !== 'file:') { 46 pathname = parentUrl.slice(parentProtocol.length + 2); 47 pathname = pathname.slice(pathname.indexOf('/') + 1); 48 } 49 else { 50 pathname = parentUrl.slice(8); 51 } 52 } 53 else { 54 // resolving to :/ so pathname is the /... part 55 pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/')); 56 } 57 58 if (relUrl[0] === '/') 59 return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl; 60 61 // join together and split for removal of .. and . segments 62 // looping the string instead of anything fancy for perf reasons 63 // '../../../../../z' resolved to 'x/y' is just 'z' 64 const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl; 65 66 const output = []; 67 let segmentIndex = -1; 68 for (let i = 0; i < segmented.length; i++) { 69 // busy reading a segment - only terminate on '/' 70 if (segmentIndex !== -1) { 71 if (segmented[i] === '/') { 72 output.push(segmented.slice(segmentIndex, i + 1)); 73 segmentIndex = -1; 74 } 75 } 76 77 // new segment - check if it is relative 78 else if (segmented[i] === '.') { 79 // ../ segment 80 if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) { 81 output.pop(); 82 i += 2; 83 } 84 // ./ segment 85 else if (segmented[i + 1] === '/' || i + 1 === segmented.length) { 86 i += 1; 87 } 88 else { 89 // the start of a new segment as below 90 segmentIndex = i; 91 } 92 } 93 // it is the start of a new segment 94 else { 95 segmentIndex = i; 96 } 97 } 98 // finish reading out the last segment 99 if (segmentIndex !== -1) 100 output.push(segmented.slice(segmentIndex)); 101 return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join(''); 102 } 103 } 104 105 /* 106 * Import maps implementation 107 * 108 * To make lookups fast we pre-resolve the entire import map 109 * and then match based on backtracked hash lookups 110 * 111 */ 112 113 function resolveUrl (relUrl, parentUrl) { 114 return resolveIfNotPlainOrUrl(relUrl, parentUrl) || 115 relUrl.indexOf(':') !== -1 && relUrl || 116 resolveIfNotPlainOrUrl('./' + relUrl, parentUrl); 117 } 118 119 function resolvePackages(pkgs, baseUrl) { 120 var outPkgs = {}; 121 for (var p in pkgs) { 122 var value = pkgs[p]; 123 // TODO package fallback support 124 if (typeof value !== 'string') 125 continue; 126 outPkgs[resolveIfNotPlainOrUrl(p, baseUrl) || p] = resolveUrl(value, baseUrl); 127 } 128 return outPkgs; 129 } 130 131 function parseImportMap (json, baseUrl) { 132 const imports = resolvePackages(json.imports, baseUrl) || {}; 133 const scopes = {}; 134 if (json.scopes) { 135 for (let scopeName in json.scopes) { 136 const scope = json.scopes[scopeName]; 137 let resolvedScopeName = resolveUrl(scopeName, baseUrl); 138 if (resolvedScopeName[resolvedScopeName.length - 1] !== '/') 139 resolvedScopeName += '/'; 140 scopes[resolvedScopeName] = resolvePackages(scope, baseUrl) || {}; 141 } 142 } 143 144 return { imports: imports, scopes: scopes }; 145 } 146 147 function getMatch (path, matchObj) { 148 if (matchObj[path]) 149 return path; 150 let sepIndex = path.length; 151 do { 152 const segment = path.slice(0, sepIndex + 1); 153 if (segment in matchObj) 154 return segment; 155 } while ((sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1) 156 } 157 158 function applyPackages (id, packages) { 159 const pkgName = getMatch(id, packages); 160 if (pkgName) { 161 const pkg = packages[pkgName]; 162 if (pkg === null) return; 163 if (id.length > pkgName.length && pkg[pkg.length - 1] !== '/') 164 console.warn("Invalid package target " + pkg + " for '" + pkgName + "' should have a trailing '/'."); 165 return pkg + id.slice(pkgName.length); 166 } 167 } 168 169 function resolveImportMap (id, parentUrl, importMap) { 170 const urlResolved = resolveIfNotPlainOrUrl(id, parentUrl) || id.indexOf(':') !== -1 && id; 171 if (urlResolved) 172 id = urlResolved; 173 const scopeName = getMatch(parentUrl, importMap.scopes); 174 if (scopeName) { 175 const scopePackages = importMap.scopes[scopeName]; 176 const packageResolution = applyPackages(id, scopePackages); 177 if (packageResolution) 178 return packageResolution; 179 } 180 return applyPackages(id, importMap.imports) || urlResolved || throwBare(id, parentUrl); 181 } 182 183 function throwBare (id, parentUrl) { 184 throw Error('Unable to resolve bare specifier "' + id + (parentUrl ? '" from ' + parentUrl : '"')); 185 } 186 187 /* 188 * SystemJS Core 189 * 190 * Provides 191 * - System.import 192 * - System.register support for 193 * live bindings, function hoisting through circular references, 194 * reexports, dynamic import, import.meta.url, top-level await 195 * - System.getRegister to get the registration 196 * - Symbol.toStringTag support in Module objects 197 * - Hookable System.createContext to customize import.meta 198 * - System.onload(id, err?) handler for tracing / hot-reloading 199 * 200 * Core comes with no System.prototype.resolve or 201 * System.prototype.instantiate implementations 202 */ 203 204 const hasSymbol = typeof Symbol !== 'undefined'; 205 const toStringTag = hasSymbol && Symbol.toStringTag; 206 const REGISTRY = hasSymbol ? Symbol() : '@'; 207 208 function SystemJS () { 209 this[REGISTRY] = {}; 210 } 211 212 const systemJSPrototype = SystemJS.prototype; 213 systemJSPrototype.import = function (id, parentUrl) { 214 const loader = this; 215 return Promise.resolve(loader.resolve(id, parentUrl)) 216 .then(function (id) { 217 const load = getOrCreateLoad(loader, id); 218 return load.C || topLevelLoad(loader, load); 219 }); 220 }; 221 222 // Hookable createContext function -> allowing eg custom import meta 223 systemJSPrototype.createContext = function (parentId) { 224 return { 225 url: parentId 226 }; 227 }; 228 229 // onLoad(id, err) provided for tracing / hot-reloading 230 systemJSPrototype.onload = function () {}; 231 232 let lastRegister; 233 systemJSPrototype.register = function (deps, declare) { 234 lastRegister = [deps, declare]; 235 }; 236 237 /* 238 * getRegister provides the last anonymous System.register call 239 */ 240 systemJSPrototype.getRegister = function () { 241 const _lastRegister = lastRegister; 242 lastRegister = undefined; 243 return _lastRegister; 244 }; 245 246 function getOrCreateLoad (loader, id, firstParentUrl) { 247 let load = loader[REGISTRY][id]; 248 if (load) 249 return load; 250 251 const importerSetters = []; 252 const ns = Object.create(null); 253 if (toStringTag) 254 Object.defineProperty(ns, toStringTag, { value: 'Module' }); 255 256 let instantiatePromise = Promise.resolve() 257 .then(function () { 258 return loader.instantiate(id, firstParentUrl); 259 }) 260 .then(function (registration) { 261 if (!registration) 262 throw Error('Module ' + id + ' did not instantiate'); 263 function _export (name, value) {
264 // note if we have hoisted exports (including reexports) 265 load.h = true; 266 let changed = false; 267 if (typeof name !== 'object') { 268 if (!(name in ns) || ns[name] !== value) { 269 ns[name] = value; 270 changed = true; 271 } 272 } 273 else { 274 for (let p in name) { 275 let value = name[p]; 276 if (!(p in ns) || ns[p] !== value) { 277 ns[p] = value; 278 changed = true; 279 } 280 } 281 } 282 if (changed) 283 for (let i = 0; i < importerSetters.length; i++) 284 importerSetters[i](ns); 285 return value; 286 } 287 const declared = registration[1](_export, registration[1].length === 2 ? { 288 import: function (importId) { 289 return loader.import(importId, id); 290 }, 291 meta: loader.createContext(id) 292 } : undefined); 293 load.e = declared.execute || function () {}; 294 return [registration[0], declared.setters || []]; 295 }); 296 297 instantiatePromise = instantiatePromise.catch(function (err) { 298 loader.onload(load.id, err); 299 throw err; 300 }); 301 302 const linkPromise = instantiatePromise 303 .then(function (instantiation) { 304 return Promise.all(instantiation[0].map(function (dep, i) { 305 const setter = instantiation[1][i]; 306 return Promise.resolve(loader.resolve(dep, id)) 307 .then(function (depId) { 308 const depLoad = getOrCreateLoad(loader, depId, id); 309 // depLoad.I may be undefined for already-evaluated 310 return Promise.resolve(depLoad.I) 311 .then(function () { 312 if (setter) { 313 depLoad.i.push(setter); 314 // only run early setters when there are hoisted exports of that module 315 // the timing works here as pending hoisted export calls will trigger through importerSetters 316 if (depLoad.h || !depLoad.I) 317 setter(depLoad.n); 318 } 319 return depLoad; 320 }); 321 }) 322 })) 323 .then(function (depLoads) { 324 load.d = depLoads; 325 }); 326 }); 327 328 linkPromise.catch(function (err) { 329 load.e = null; 330 load.er = err; 331 }); 332 333 // Capital letter = a promise function 334 return load = loader[REGISTRY][id] = { 335 id: id, 336 // importerSetters, the setters functions registered to this dependency 337 // we retain this to add more later 338 i: importerSetters, 339 // module namespace object 340 n: ns, 341 342 // instantiate 343 I: instantiatePromise, 344 // link 345 L: linkPromise, 346 // whether it has hoisted exports 347 h: false, 348 349 // On instantiate completion we have populated: 350 // dependency load records 351 d: undefined, 352 // execution function 353 // set to NULL immediately after execution (or on any failure) to indicate execution has happened 354 // in such a case, pC should be used, and pLo, pLi will be emptied 355 e: undefined, 356 357 // On execution we have populated: 358 // the execution error if any 359 er: undefined, 360 // in the case of TLA, the execution promise 361 E: undefined, 362 363 // On execution, pLi, pLo, e cleared 364 365 // Promise for top-level completion 366 C: undefined 367 }; 368 } 369 370 function instantiateAll (loader, load, loaded) { 371 if (!loaded[load.id]) { 372 loaded[load.id] = true; 373 // load.L may be undefined for already-instantiated 374 return Promise.resolve(load.L) 375 .then(function () { 376 return Promise.all(load.d.map(function (dep) { 377 return instantiateAll(loader, dep, loaded); 378 })); 379 }) 380 } 381 } 382 383 function topLevelLoad (loader, load) { 384 return load.C = instantiateAll(loader, load, {}) 385 .then(function () { 386 return postOrderExec(loader, load, {}); 387 }) 388 .then(function () { 389 return load.n; 390 }); 391 } 392 393 // the closest we can get to call(undefined) 394 const nullContext = Object.freeze(Object.create(null)); 395 396 // returns a promise if and only if a top-level await subgraph 397 // throws on sync errors 398 function postOrderExec (loader, load, seen) { 399 if (seen[load.id]) 400 return; 401 seen[load.id] = true; 402 403 if (!load.e) { 404 if (load.er) 405 throw load.er; 406 if (load.E) 407 return load.E; 408 return; 409 } 410 411 // deps execute first, unless circular 412 let depLoadPromises; 413 load.d.forEach(function (depLoad) { 414 { 415 try { 416 const depLoadPromise = postOrderExec(loader, depLoad, seen); 417 if (depLoadPromise) 418 (depLoadPromises = depLoadPromises || []).push(depLoadPromise); 419 } 420 catch (err) { 421 loader.onload(load.id, err); 422 throw err; 423 } 424 } 425 }); 426 if (depLoadPromises) { 427 return Promise.all(depLoadPromises) 428 .then(doExec) 429 .catch(function (err) { 430 loader.onload(load.id, err); 431 throw err; 432 }); 433 } 434 435 return doExec(); 436 437 function doExec () {
438 try { 439 let execPromise = load.e.call(nullContext); 440 if (execPromise) { 441 execPromise = execPromise.then(function () { 442 load.C = load.n; 443 load.E = null; // indicates completion 444 loader.onload(load.id, null); 445 }, function (err) { 446 loader.onload(load.id, err); 447 throw err; 448 }); 449 return load.E = load.E || execPromise; 450 } 451 // (should be a promise, but a minify optimization to leave out Promise.resolve) 452 load.C = load.n; 453 loader.onload(load.id, null); 454 } 455 catch (err) { 456 loader.onload(load.id, err); 457 load.er = err; 458 throw err; 459 } 460 finally { 461 load.L = load.I = undefined; 462 load.e = null; 463 } 464 } 465 } 466 467 envGlobal.System = new SystemJS(); 468 469 /* 470 * Supports loading System.register via script tag injection 471 */ 472 473 const systemRegister = systemJSPrototype.register; 474 systemJSPrototype.register = function (deps, declare) { 475 systemRegister.call(this, deps, declare); 476 }; 477 478 systemJSPrototype.instantiate = function (url, firstParentUrl) { 479 const loader = this; 480 if (url.substr(-5) === '.json') { 481 return fetch(url).then(function (resp) { 482 return resp.text(); 483 }).then(function (source) { 484 return [[], function(_export) { 485 return {execute: function() {_export('default', JSON.parse(source));}}; 486 }]; 487 }); 488 } else { 489 return new Promise(function (resolve, reject) { 490 let err; 491 492 function windowErrorListener(evt) { 493 if (evt.filename === url) 494 err = evt.error; 495 } 496 497 window.addEventListener('error', windowErrorListener); 498 499 const script = document.createElement('script'); 500 script.charset = 'utf-8'; 501 script.async = true; 502 script.crossOrigin = 'anonymous'; 503 script.addEventListener('error', function () { 504 window.removeEventListener('error', windowErrorListener); 505 reject(Error('Error loading ' + url + (firstParentUrl ? ' from ' + firstParentUrl : ''))); 506 }); 507 script.addEventListener('load', function () { 508 window.removeEventListener('error', windowErrorListener); 509 document.head.removeChild(script); 510 // Note that if an error occurs that isn't caught by this if statement, 511 // that getRegister will return null and a "did not instantiate" error will be thrown. 512 if (err) { 513 reject(err); 514 } 515 else { 516 resolve(loader.getRegister()); 517 } 518 }); 519 script.src = url; 520 document.head.appendChild(script); 521 }); 522 } 523 }; 524 525 /* 526 * Supports loading System.register in workers 527 */ 528 529 if (hasSelf && typeof importScripts === 'function') 530 systemJSPrototype.instantiate = function (url) { 531 const loader = this; 532 return new Promise(function (resolve, reject) { 533 try { 534 importScripts(url); 535 } 536 catch (e) { 537 reject(e); 538 } 539 resolve(loader.getRegister()); 540 }); 541 }; 542 543 /* 544 * SystemJS global script loading support 545 * Extra for the s.js build only 546 * (Included by default in system.js build) 547 */ 548 (function (global) { 549 550 const systemJSPrototype = System.constructor.prototype; 551 552 // safari unpredictably lists some new globals first or second in object order 553 let firstGlobalProp, secondGlobalProp, lastGlobalProp; 554 function getGlobalProp () {
555 let cnt = 0; 556 let lastProp; 557 for (let p in global) { 558 // do not check frames cause it could be removed during import 559 if (!global.hasOwnProperty(p) || (!isNaN(p) && p < global.length)) 560 continue; 561 if (cnt === 0 && p !== firstGlobalProp || cnt === 1 && p !== secondGlobalProp) 562 return p; 563 cnt++; 564 lastProp = p; 565 } 566 if (lastProp !== lastGlobalProp) 567 return lastProp; 568 } 569 570 function noteGlobalProps () { 571 // alternatively Object.keys(global).pop() 572 // but this may be faster (pending benchmarks) 573 firstGlobalProp = secondGlobalProp = undefined; 574 for (let p in global) { 575 // do not check frames cause it could be removed during import 576 if (!global.hasOwnProperty(p) || (!isNaN(p) && p < global.length)) 577 continue; 578 if (!firstGlobalProp) 579 firstGlobalProp = p; 580 else if (!secondGlobalProp) 581 secondGlobalProp = p; 582 lastGlobalProp = p; 583 } 584 return lastGlobalProp; 585 } 586 587 const impt = systemJSPrototype.import; 588 systemJSPrototype.import = function (id, parentUrl) { 589 noteGlobalProps(); 590 return impt.call(this, id, parentUrl); 591 }; 592 593 const emptyInstantiation = [[], function () { return {} }]; 594 595 const getRegister = systemJSPrototype.getRegister; 596 systemJSPrototype.getRegister = function () { 597 const lastRegister = getRegister.call(this); 598 if (lastRegister) 599 return lastRegister; 600 601 // no registration -> attempt a global detection as difference from snapshot 602 // when multiple globals, we take the global value to be the last defined new global object property 603 // for performance, this will not support multi-version / global collisions as previous SystemJS versions did 604 // note in Edge, deleting and re-adding a global does not change its ordering 605 const globalProp = getGlobalProp(); 606 if (!globalProp) 607 return emptyInstantiation; 608 609 let globalExport; 610 try { 611 globalExport = global[globalProp]; 612 } 613 catch (e) { 614 return emptyInstantiation; 615 } 616 617 return [[], function (_export) { 618 return { 619 execute: function () { 620 _export({ default: globalExport, __useDefault: true }); 621 } 622 }; 623 }]; 624 }; 625 626 })(typeof self !== 'undefined' ? self : global); 627 628 /* 629 * Loads WASM based on file extension detection 630 * Assumes successive instantiate will handle other files 631 */ 632 const instantiate = systemJSPrototype.instantiate; 633 systemJSPrototype.instantiate = function (url, parent) { 634 if (url.slice(-5) !== '.wasm') 635 return instantiate.call(this, url, parent); 636 637 return fetch(url) 638 .then(function (res) { 639 if (!res.ok) 640 throw Error(res.status + ' ' + res.statusText + ' ' + res.url + (parent ? ' loading from ' + parent : '')); 641 642 if (WebAssembly.compileStreaming) 643 return WebAssembly.compileStreaming(res); 644 645 return res.arrayBuffer() 646 .then(function (buf) { 647 return WebAssembly.compile(buf); 648 }); 649 }) 650 .then(function (module) { 651 const deps = []; 652 const setters = []; 653 const importObj = {}; 654 655 // we can only set imports if supported (eg early Safari doesnt support) 656 if (WebAssembly.Module.imports) 657 WebAssembly.Module.imports(module).forEach(function (impt) { 658 const key = impt.module; 659 setters.push(function (m) { 660 importObj[key] = m; 661 }); 662 if (deps.indexOf(key) === -1) 663 deps.push(key); 664 }); 665 666 return [deps, function (_export) { 667 return { 668 setters: setters, 669 execute: function () { 670 return WebAssembly.instantiate(module, importObj) 671 .then(function (instance) { 672 _export(instance.exports); 673 }); 674 } 675 }; 676 }]; 677 }); 678 }; 679 680 /* 681 * Import map support for SystemJS 682 * 683 * <script type="systemjs-importmap">{}</script> 684 * OR 685 * <script type="systemjs-importmap" src=package.json></script> 686 * 687 * Only those import maps available at the time of SystemJS initialization will be loaded 688 * and they will be loaded in DOM order. 689 * 690 * There is no support for dynamic import maps injection currently. 691 */ 692 693 const baseMap = Object.create(null); 694 baseMap.imports = Object.create(null); 695 baseMap.scopes = Object.create(null); 696 let importMapPromise = Promise.resolve(baseMap); 697 let acquiringImportMaps = typeof document !== 'undefined'; 698 699 if (acquiringImportMaps) { 700 Array.prototype.forEach.call(document.querySelectorAll('script[type="systemjs-importmap"][src]'), function (script) { 701 script._j = fetch(script.src).then(function (resp) { 702 return resp.json(); 703 }); 704 }); 705 } 706 707 function mergeImportMap(originalMap, newMap) { 708 for (let i in newMap.imports) { 709 originalMap.imports[i] = newMap.imports[i]; 710 } 711 for (let i in newMap.scopes) { 712 originalMap.scopes[i] = newMap.scopes[i]; 713 } 714 return originalMap; 715 } 716 717 systemJSPrototype.resolve = function (id, parentUrl) { 718 parentUrl = parentUrl || baseUrl; 719 720 if (acquiringImportMaps) { 721 acquiringImportMaps = false;
722 Array.prototype.forEach.call(document.querySelectorAll('script[type="systemjs-importmap"]'), function (script) { 723 importMapPromise = importMapPromise.then(function (map) { 724 return (script._j || script.src && fetch(script.src).then(function (resp) {return resp.json()}) || Promise.resolve(JSON.parse(script.innerHTML))) 725 .then(function (json) { 726 return mergeImportMap(map, parseImportMap(json, script.src || baseUrl)); 727 }); 728 }); 729 }); 730 } 731 732 return importMapPromise 733 .then(function (importMap) { 734 return resolveImportMap(id, parentUrl, importMap); 735 }); 736 }; 737 738 const toStringTag$1 = typeof Symbol !== 'undefined' && Symbol.toStringTag; 739 740 systemJSPrototype.get = function (id) { 741 const load = this[REGISTRY][id]; 742 if (load && load.e === null && !load.E) { 743 if (load.er) 744 return null; 745 return load.n; 746 } 747 }; 748 749 systemJSPrototype.set = function (id, module) { 750 let ns; 751 if (toStringTag$1 && module[toStringTag$1] === 'Module') { 752 ns = module; 753 } 754 else { 755 ns = Object.assign(Object.create(null), module); 756 if (toStringTag$1) 757 Object.defineProperty(ns, toStringTag$1, { value: 'Module' }); 758 } 759 const done = Promise.resolve(ns); 760 this.delete(id); 761 this[REGISTRY][id] = { 762 id: id, 763 i: [], 764 n: ns, 765 I: done, 766 L: done, 767 h: false, 768 d: [], 769 e: null, 770 er: undefined, 771 E: undefined, 772 C: done 773 }; 774 return ns; 775 }; 776 777 systemJSPrototype.has = function (id) { 778 const load = this[REGISTRY][id]; 779 return load && load.e === null && !load.E; 780 }; 781 782 // Delete function provided for hot-reloading use cases 783 systemJSPrototype.delete = function (id) { 784 const load = this.get(id); 785 if (load === undefined) 786 return false; 787 // remove from importerSetters 788 // (release for gc) 789 if (load && load.d) 790 load.d.forEach(function (depLoad) { 791 const importerIndex = depLoad.i.indexOf(load); 792 if (importerIndex !== -1) 793 depLoad.i.splice(importerIndex, 1); 794 }); 795 return delete this[REGISTRY][id]; 796 }; 797 798 const iterator = typeof Symbol !== 'undefined' && Symbol.iterator; 799 800 systemJSPrototype.entries = function () { 801 const loader = this, keys = Object.keys(loader[REGISTRY]); 802 let index = 0, ns, key; 803 const result = { 804 next: function () { 805 while ( 806 (key = keys[index++]) !== undefined && 807 (ns = loader.get(key)) === undefined 808 ); 809 return { 810 done: key === undefined, 811 value: key !== undefined && [key, ns] 812 }; 813 } 814 }; 815 816 result[iterator] = function() { return this }; 817 818 return result; 819 }; 820 821}());
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.