1(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ 2var getConfig = (function (global) { 3 'use strict'; 4 5 /** @var string */ 6 var revisionNumber = ''; 7 8 (function initialize () { 9 var scripts = global.document.getElementsByTagName('script'); 10 var l = scripts.length; 11 var mainScript = null; 12 13 while (l--) { 14 var script = scripts[l]; 15 16 if (script.hasAttribute('data-main')) { 17 mainScript = script; 18 break; 19 } 20 } 21 22 if (mainScript === null) { 23 return; 24 } 25 26 if (mainScript.hasAttribute('data-rev')) { 27 revisionNumber = mainScript.getAttribute('data-rev'); 28 } 29 }()); 30 31 return { 32 /** 33 * @returns {string} 34 */ 35 getRevision: function () { 36 return revisionNumber; 37 } 38 }; 39}(typeof window !== 'undefined' ? window : this)); 40 41module.exports = getConfig; 42},{}],2:[function(require,module,exports){ 43(function () { 44 'use strict'; 45 46 if ('define' in window && 'require' in window) { 47 return; 48 } 49 50 var E_MALFORMED_REQUIRE = 'Malformed require'; 51 var E_REQUIRE_FAILED = 'Require failed (module not loaded)'; 52 53 /** @type {Function} */ 54 var normalizeId = require('./normalizeId'); 55 /** @type {Function} */ 56 var normalizeResource = require('./normalizeResource'); 57 /** @type {Object} */ 58 var amdModule = require('./module'); 59 /** @type {Object} */ 60 var path = require('./path'); 61 /** @type {Object} */ 62 var registry = require('./registry'); 63 /** @type {Object} */ 64 var magicModules = require('./magicModules'); 65 /** @type {Object} */ 66 var loader = require('./loader'); 67 /** @type {Object} */ 68 var globals = require('./globals'); 69 70 /** @type {Object} */ 71 var defineQueue = {}; 72 /** @type {Object} */ 73 var defineHistory = {}; 74 75 /** 76 * @param {string|Array|Function} moduleId 77 * @param {Array|Function} dependencies 78 * @param {Function} definition 79 */ 80 window.define = function (moduleId, dependencies, definition) { 81 if (typeof moduleId !== 'string') { 82 definition = dependencies; 83 dependencies = moduleId; 84 moduleId = null; 85 } 86 87 if (!dependencies || !(dependencies instanceof Array)) { 88 definition = dependencies; 89 dependencies = []; 90 } 91 92 if (moduleId === null) { 93 if (loader.useInteractive()) { 94 moduleId = loader.getIdOfCurrentlyExecutingModule(); 95 } 96 97 var queueElem = [moduleId, dependencies, definition]; 98 if (!moduleId) { 99 if (!('last' in defineQueue)) { 100 defineQueue['last'] = []; 101 } 102 defineQueue['last'].push(queueElem); 103 } else { 104 defineQueue[moduleId] = queueElem; 105 } 106 return; 107 } 108 109 moduleId = normalizeId(moduleId); 110 defineHistory[moduleId] = true; 111 var moduleToDefine = registry.getModule(moduleId) || amdModule.create(moduleId, path.get(moduleId)); 112 registry.registerModule(moduleToDefine); 113 114 if (dependencies.length < 1) { 115 definition && moduleToDefine.setValue( 116 typeof definition === 'function' ? definition() : definition 117 ); 118 registry.resolve(moduleToDefine); 119 return; 120 } 121 122 queueDependencies(dependencies, function () { 123 definition && moduleToDefine.setValue(definition.apply(null, arguments)); 124 registry.resolve(moduleToDefine); 125 }, moduleToDefine); 126 }; 127 128 /** 129 * @param {Array|string|Function}
129 dependencies 130 * @param {Function} definition 131 * @param {amdModule} context 132 * @returns {*} 133 */ 134 window.require = function (dependencies, definition, context) { 135 if (!dependencies && !definition) { 136 throw new Error(E_MALFORMED_REQUIRE); 137 } 138 139 if (dependencies instanceof Array) { 140 queueDependencies(dependencies, definition, context); 141 return; 142 } 143 144 if (typeof dependencies === 'string') { 145 var moduleId = normalizeId(dependencies); 146 var loadedModule = registry.getModule(moduleId); 147 148 if (!loadedModule || !loadedModule.isDefined()) { 149 throw new Error(E_REQUIRE_FAILED); 150 } 151 152 return loadedModule.getValue(); 153 } 154 155 if (typeof dependencies === 'function' && !definition) { 156 dependencies(); 157 return; 158 } 159 160 throw new Error(E_MALFORMED_REQUIRE); 161 }; 162 163 /** 164 * @param {string} moduleId 165 * @param {string} modulePath 166 * @returns {amdModule} 167 */ 168 function createAndLoadModule (moduleId, modulePath) { 169 if (registry.getModule(moduleId)) { 170 return registry.getModule(moduleId); 171 } 172 173 var newModule = amdModule.create(moduleId, modulePath); 174 registry.registerModule(newModule); 175 176 if (!newModule.isDefined()) { 177 try { 178 loader.load(newModule, finishDefining); 179 } catch (e) { 180 return newModule; 181 } 182 } 183 184 return newModule; 185 } 186 187 /** 188 * @param {string} loadedModuleId 189 */ 190 function finishDefining (loadedModuleId) { 191 if ( 192 !(loadedModuleId in defineQueue) 193 && !('last' in defineQueue) 194 && !globals.isGlobal(loadedModuleId) 195 && !(loadedModuleId in defineHistory) 196 ) { 197 var loadedModule = registry.getModule(loadedModuleId); 198 loadedModule && loadedModule.setDefined() && registry.resolve(loadedModule); 199 return; 200 } 201 202 var defineArguments = null; 203 204 if (loader.useInteractive() && loadedModuleId in defineQueue) { 205 defineArguments = defineQueue[loadedModuleId]; 206 delete defineQueue[loadedModuleId]; 207 } else if (!loader.useInteractive()) { 208 defineArguments = []; 209 if ('last' in defineQueue) { 210 defineArguments = defineQueue['last'].shift() || []; 211 if (defineQueue['last'].length === 0) { 212 delete defineQueue['last']; 213 } 214 } 215 defineArguments[0] = loadedModuleId; 216 } 217 218 if (!defineArguments) { 219 return; 220 } 221 222 if (globals.isGlobal(loadedModuleId) && defineArguments.length === 1) { 223 if (loadedModuleId in defineHistory) { 224 // Global is apparently using AMD to register itself 225 return; 226 } 227 228 defineArguments[1] = []; 229 defineArguments[2] = function () { return globals.get(loadedModuleId); }; 230 } 231 232 window.define.apply(null, defineArguments); 233 } 234 235 function queueDependencies () { 236 var args = arguments; 237 238 window.setTimeout(function () { 239 loadDependencies.apply(null, args); 240 }, 4); 241 } 242 243 /** 244 * @param {Array} dependencies 245 * @param {Function} definition 246 * @param {amdModule} context 247 */ 248 function loadDependencies (dependencies, definition, context) { 249 var values = []; 250 var loaded = 0; 251 252 /** 253 * @param {amdModule} loadedModule 254 * @param {string} resource 255 */ 256 function dependencyLoaded (loadedModule, resource) { 257 if (resource) { 258 var moduleValue = loadedModule.getValue(); 259 moduleValue.load(resource, function (loadedValue) { 260 applyDependencyValue(loadedModule.getId() + '!' + resource, loadedValue || moduleValue); 261 }); 262 return; 263 } 264 265 applyDependencyValue(loadedModule.getId(), loadedModule.getValue()); 266 } 267 268 /** 269 * @param {string} moduleResourceId 270 * @param {*} moduleValue 271 */ 272 function applyDependencyValue (moduleResourceId, moduleValue) { 273 values[dependencies.indexOf(moduleResourceId)] = moduleValue; 274
275 if (definition && ++loaded >= dependencies.length) { 276 definition.apply(null, values); 277 } 278 } 279 280 /** 281 * @param {string} moduleId 282 * @param {string} resource 283 */ 284 function loadDependency (moduleId, resource) { 285 var moduleToLoad; 286 287 switch (moduleId) { 288 case 'require': 289 moduleToLoad = magicModules.getLocalRequire(context); 290 break; 291 case 'exports': 292 moduleToLoad = magicModules.getExports(context); 293 break; 294 case 'module': 295 moduleToLoad = magicModules.getModule(context); 296 break; 297 default: 298 moduleToLoad = registry.getModule(moduleId) || createAndLoadModule(moduleId, path.get(moduleId, context)); 299 } 300 301 registry.addListener(moduleToLoad, function (loadedModule) { 302 dependencyLoaded(loadedModule, resource); 303 }); 304 } 305 306 for (var i = 0; i < dependencies.length; i++) { 307 var moduleId = normalizeId(dependencies[i], context); 308 var resource = normalizeResource(dependencies[i], context); 309 dependencies[i] = (resource) ? moduleId + '!' + resource : moduleId; 310 loadDependency(moduleId, resource); 311 } 312 } 313 314 /** 315 * @type {{jQuery: boolean}} 316 */ 317 window.define.amd = { 318 jQuery: true 319 }; 320})(); 321 322},{"./globals":3,"./loader":4,"./magicModules":5,"./module":6,"./normalizeId":7,"./normalizeResource":8,"./path":9,"./registry":10}],3:[function(require,module,exports){ 323var getGlobals = (function (global) { 324 'use strict'; 325 326 const globalDefineStack = {}; 327 328 /** @type {Object} */ 329 const globals = { 330 'pb/pblib': { 331 name: 'PbLib' 332 }, 333 prototype: { 334 name: '$', 335 dependencies: ['Prototype'], 336 }, 337 tinymce4: { 338 name: 'tinymce', 339 useDefine: true, 340 }, 341 tinymce5: { 342 name: 'tinymce', 343 useDefine: true, 344 } 345 }; 346 347 /** 348 * @param {string} moduleId 349 * @returns {*} 350 */ 351 function get (moduleId) { 352 if (!isGlobal(moduleId)) { 353 return null; 354 } 355 356 const name = globals[moduleId].name; 357 if (globals[moduleId].isChecked) { 358 return global[name]; 359 } 360 361 if ('dependencies' in globals[moduleId]) { 362 const dependenciesOk = globals[moduleId].dependencies.reduce( 363 (acc, current) => acc && current in global, 364 true 365 ); 366 if (!dependenciesOk) { 367 return null; 368 } 369 } 370 371 if (typeof global[name] === 'undefined') { 372 return null; 373 } 374 375 globals[moduleId].isChecked = true; 376 return global[name]; 377 } 378 379 /** 380 * @param {string} moduleId 381 * @returns {boolean} 382 */ 383 function isGlobal (moduleId) { 384 return (moduleId in globals); 385 } 386 387 /** 388 * @param {string} moduleId 389 * @returns {boolean} 390 */ 391 function isLoaded (moduleId) { 392 return get(moduleId) !== null; 393 } 394 395 function prepareForLoading (moduleId) { 396 if (!(isGlobal(moduleId) && globals[moduleId].useDefine)) { 397 return; 398 } 399 400 const globalName = globals[moduleId].name; 401 if (globalName in globalDefineStack) { 402 globalDefineStack[globalName].push(moduleId); 403 return; 404 } 405 406 globalDefineStack[globalName] = [moduleId]; 407 defineGlobalProperty(globalName); 408 } 409 410 function defineGlobalProperty(globalName) { 411 Object.defineProperty(global, globalName, { 412 configurable: true, 413 set(value) { 414 const moduleId = globalDefineStack[globalName].shift(); 415 if (moduleId) { 416 global.define(moduleId, [], () => value); 417 } 418 419 if (globalDefineStack[globalName].length === 0) { 420 delete global[globalName]; 421 delete globalDefineStack[globalName]; 422 global[globalName] = value; 423 } 424 }, 425 get: () => undefined, 426 }); 427 } 428 429 return { 430 isGlobal: isGlobal, 431 isLoaded: isLoaded, 432 get: get, 433 prepare: prepareForLoading 434 }; 435})(typeof window !== 'undefined' ? window : this); 436 437module.exports = getGlobals; 438 439},{}],4:[function(require,module,exports){ 440var getLoader = (function (global) { 441 'use strict'; 442 443 /** @type {string} */
444 var E_INVALID_PATH = 'Unable to load module: invalid path'; 445 446 /** @type {boolean} */ 447 var isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]'; 448 /** @type {boolean} */ 449 var useInteractive = false; 450 /** @type {Element} */ 451 var currentlyAddingScript; 452 /** @type {Element} */ 453 var interactiveScript; 454 455 /** @type {Node} */ 456 var baseElement = document.getElementsByTagName('base')[0]; 457 /** @type {Node} */ 458 var head = baseElement ? baseElement.parentNode : document.getElementsByTagName('head')[0]; 459 460 /** @type {Object} */ 461 var config = require('./config'); 462 463 /** 464 * @param {amdModule} amdModule 465 * @param {Function} defineCallback 466 */ 467 function load (amdModule, defineCallback) { 468 if (amdModule.getPath().match(/(^(\.{0,2}\/|(?:[a-z]+:)?\/\/)|\.js)/) === null) { 469 throw new Error(E_INVALID_PATH); 470 } 471 472 var script = getScriptElement(amdModule); 473 474 if ( 475 script.attachEvent 476 && !(script.attachEvent.toString && script.attachEvent.toString().indexOf('[native code') < 0) 477 && !isOpera 478 ) { 479 useInteractive = true; 480 script.attachEvent('onreadystatechange', function (event) { 481 onScriptLoad(script, event, defineCallback); 482 }); 483 } else { 484 script.addEventListener('load', function (event) { 485 onScriptLoad(script, event, defineCallback); 486 }, false); 487 script.addEventListener('error', function () { 488 if (!('console' in global)) { 489 return; 490 } 491 492 global['console'].error('`amdLoader`: Loading module `' + amdModule.getId() + '` failed, using script with url ' + amdModule.getPath()); 493 }, false); 494 } 495 496 script.src = getScriptSourceWithRevisionNumber(amdModule.getPath()); 497 498 // noinspection JSUnusedAssignment currentlyAddingScript is used in getInteractiveScript 499 currentlyAddingScript = script; 500 501 head.insertBefore(script, baseElement || null); 502 503 currentlyAddingScript = null; 504 } 505 506 /** 507 * @param {HTMLElement} script 508 * @param {Event} event 509 * @param {Function} defineCallback 510 */ 511 function onScriptLoad (script, event, defineCallback) { 512 if ( 513 event.type === 'load' 514 || (/^(complete|loaded)$/.test((event.currentTarget || event.srcElement).readyState)) 515 ) { 516 interactiveScript = null; 517 defineCallback(script.getAttribute('data-moduleId')); 518 script.removeAttribute('data-moduleId'); 519 } 520 } 521 522 /** 523 * @param {amdModule} amdModule 524 * @returns {Element} 525 */ 526 function getScriptElement (amdModule) { 527 var script = document.createElement('script'); 528 script.async = true; 529 script.setAttribute('data-moduleId', amdModule.getId()); 530 return script; 531 } 532 533 /** 534 * @returns {Element} 535 */ 536 function getInteractiveScript () { 537 if (currentlyAddingScript !== null) { 538 return currentlyAddingScript; 539 } 540 541 if (interactiveScript && interactiveScript.readyState === 'interactive') { 542 return interactiveScript; 543 } 544 545 var scripts = document.getElementsByTagName('script'); 546 var l = scripts.length; 547 548 while (l--) { 549 var script = scripts[l]; 550 551 if (script.readyState === 'interactive') { 552 return (interactiveScript = script); 553 } 554 } 555 556 return null; 557 } 558 559 /** 560 * @returns {string|null} 561 */ 562 function getIdOfCurrentlyExecutingModule () { 563 var script = getInteractiveScript(); 564 565 if (!script) { 566 return null; 567 } 568 569 return script.getAttribute('data-moduleId') || null; 570 } 571 572 /** 573 * @param {string} scriptPath 574 * @returns {string} 575 */ 576 function getScriptSourceWithRevisionNumber (scriptPath) { 577 if (scriptPath.split('rev=').length > 1) { 578 return scriptPath; 579 } 580 581 return scriptPath + (scriptPath.split('?')[1] ? '&' : '?') + 'rev=' + config.getRevision(); 582 } 583 584 return { 585 load: load, 586 useInteractive: function () { 587 return useInteractive; 588 }, 589 getIdOfCurrentlyExecutingModule: getIdOfCurrentlyExecutingModule 590 }; 591})(typeof window !== 'undefined' ? window : this); 592 593module.exports = getLoader; 594 595},{"./config":1}],5:[function(require,module,exports){ 596var defaultModules = (function () { 597 'use strict'; 598 599 /** @type {Function} */ 600 var normalizeId = require('./normalizeId'); 601 /** @type {Object} */ 602 var path = require('./path'); 603 /** @type {Object} */ 604 var amdModule = require('./module'); 605 606 /** 607 * @param {amdModule} context 608 * @returns {amdModule} 609 */ 610 function getLocalRequire (context) { 611 function localRequire () { 612 var args = [].slice.call(arguments); 613 args[2] = context || null; 614 return window.require.apply(window, args); 615 } 616 617 localRequire['toUrl'] = function (moduleId) { 618 return path.get(normalizeId(moduleId), context); 619 }; 620 621 return amdModule.create('require').setValue(localRequire); 622 } 623 624 /** 625 * @param {amdModule} context 626 * @returns {amdModule} 627 */ 628 function getExports (context) { 629 var exports = amdModule.create('exports'); 630 exports.setValue(context.getValue()); 631 return exports; 632 } 633 634 /** 635 * @param {amdModule} context 636 * @returns {amdModule} 637 */ 638 function getModule (context) { 639 return amdModule.create('module').setValue({ 640 id: context.getId(), 641 uri: context.getPath() 642 }); 643 } 644 645 return { 646 getLocalRequire: getLocalRequire, 647 getExports: getExports, 648 getModule: getModule 649 }; 650}()); 651 652module.exports = defaultModules; 653 654},{"./module":6,"./normalizeId":7,"./path":9}],6:[function(require,module,exports){ 655var moduleFactory = (function () { 656 'use strict'; 657 658 /** @type {Object} */ 659 var globals = require('./globals'); 660 661 /** 662 * @param {string} normalizedId 663 * @param {string} path 664 */ 665 function amdModule (normalizedId, path) { 666 this.id = normalizedId; 667 this.path = path || null; 668 this.value = null; 669 this.exports = {}; 670 this.defined = false;
671 672 if (globals.isGlobal(normalizedId)) { 673 if (globals.isLoaded(normalizedId)) { 674 this.setValue(globals.get(normalizedId)); 675 } else { 676 globals.prepare(normalizedId); 677 } 678 } 679 } 680 681 /** 682 * @returns {string} 683 */ 684 amdModule.prototype.getId = function () { 685 return this.id; 686 }; 687 688 /** 689 * @returns {string} 690 */ 691 amdModule.prototype.getPath = function () { 692 return this.path; 693 }; 694 695 /** 696 * @param {*} value 697 * @returns {amdModule} 698 */ 699 amdModule.prototype.setValue = function (value) { 700 this.value = value; 701 this.defined = true; 702 return this; 703 }; 704 705 /** 706 * @returns {*|null} 707 */ 708 amdModule.prototype.getValue = function () { 709 return this.value || this.exports; 710 }; 711 712 /** 713 * @returns {boolean} 714 */ 715 amdModule.prototype.isDefined = function () { 716 return this.defined; 717 }; 718 719 /** 720 * @returns {amdModule} 721 */ 722 amdModule.prototype.setDefined = function () { 723 this.defined = true; 724 return this; 725 }; 726 727 return { 728 /** 729 * @param {string} id 730 * @param {string} path 731 * @returns {amdModule} 732 */ 733 create: function (id, path) { 734 return new amdModule(id, path); 735 } 736 }; 737}()); 738 739module.exports = moduleFactory; 740 741},{"./globals":3}],7:[function(require,module,exports){ 742var getNormalizeId = (function () { 743 'use strict'; 744 745 /** @type {Object} */ 746 var path = require('./path'); 747 748 /** 749 * @param {string} moduleResourceId 750 * @param {amdModule} context 751 * @returns {string} 752 */ 753 return function (moduleResourceId, context) { 754 var moduleId = moduleResourceId.indexOf('!') < 0 ? moduleResourceId : moduleResourceId.split('!')[0]; 755 moduleId = path.normalizePackageId(moduleId); 756 757 if (!context || moduleId.indexOf('./') < 0) { 758 return moduleId; 759 } 760 761 return path.resolve(moduleId, context.getId()); 762 }; 763})(); 764 765module.exports = getNormalizeId; 766 767},{"./path":9}],8:[function(require,module,exports){ 768var getNormalizeResource = (function () { 769 'use strict'; 770 771 /** @type {Object} */ 772 var path = require('./path'); 773 774 /** 775 * @param {string} moduleResourceId 776 * @param {amdModule} context 777 * @returns {string|null} 778 */ 779 function normalizeResource (moduleResourceId, context) { 780 if (!moduleResourceId || moduleResourceId.indexOf('!') < 0) { 781 return null; 782 } 783 784 var resourceParts = moduleResourceId.split('!'); 785 786 if (resourceParts[1].indexOf('./') < 0) { 787 return resourceParts[1]; 788 } 789 790 return path.get(resourceParts[1], context); 791 } 792 793 return normalizeResource; 794})(); 795 796module.exports = getNormalizeResource; 797 798},{"./path":9}],9:[function(require,module,exports){ 799var path = (function () { 800 'use strict'; 801 802 /** 803 * @type {Object.string} 804 */ 805 var paths = { 806 pb: '/a/userinterface/uibase/script/pblib', 807 prototype: '/a/userinterface/uibase/script/prototype/prototype', 808 oldComponent: '/a/userinterface/uibase/components', 809 domReady: '/a/userinterface/uibase/vendor/domready/ready.min', 810 css: '/a/userinterface/uibase/vendor/procurios/amdLoader/src/plugins/css', 811 knockout: '/a/userinterface/uibase/vendor/knockout/dist/knockout', 812 knockoutmapping: '/a/userinterface/uibase/vendor/knockout-mapping/build/output/knockout.mapping-latest', 813 tinymce4: '/files/mod_editor/vendor/tinymce/4/4.9.6/tinymce.min', 814 tinymce5: '/files/mod_editor/vendor/tinymce/5/5.10.9/tinymce.min', 815 vendor: '/a/userinterface/uibase/vendor', 816 highcharts233: '/a/userinterface/uibase/vendor/highcharts-2.3.3', 817 highcharts401: '/a/userinterface/uibase/vendor/highcharts-4.0.1', 818 highcharts415: '/a/userinterface/uibase/vendor/highcharts-4.1.5', 819 highcharts711: '/a/userinterface/uibase/vendor/highcharts-7.1.1', 820 component: '/a/lib/Component/script', 821 droplet: '/a/userinterface/uibase/droplets', 822 module: '/a/userinterface/module', 823 pusher: '/a/userinterface/uibase/vendor/pusher-js/dist/web/pusher.min' 824 }; 825 826 /** 827 * @type {Object.Object} 828 */ 829 var packages = { 830 moment: { 831 location: '/a/userinterface/uibase/vendor/moment', 832 main: 'moment' 833 }, 834 'moment-timezone': { 835 location: '/a/userinterface/uibase/vendor/moment-timezone', 836 main: 'moment-timezone' 837 }, 838 codemirror: { 839 location: '/files/mod_editor/vendor/codemirror', 840 main: 'lib/codemirror' 841 } 842 }; 843 844 /** 845 * @param {string} normalizedModuleId 846 * @param {amdModule|null} context 847 * @returns {string} 848 */ 849 function getPath (normalizedModuleId, context) { 850 context = context || null; 851 852 if (context !== null && isRelativePath(normalizedModuleId)) { 853 return decorateWithExtension(resolveRelativePath(normalizedModuleId, context.getPath())); 854 } 855 856 if (isPackage(normalizedModuleId)) { 857 return decorateWithExtension(getPathFromPackage(normalizedModuleId)); 858 } 859 860 var nameParts = normalizedModuleId.split('/'); 861 var firstPart = nameParts.shift(); 862 if (!(firstPart in paths)) { 863 // Assume its a full path to (external) file 864 return normalizedModuleId; 865 } 866 867 var foundPath = paths[firstPart]; 868 if (nameParts.length > 0) { 869 foundPath += '/' + nameParts.join('/'); 870 } 871 return decorateWithExtension(foundPath); 872 } 873 874 /** 875 * @param {string} moduleName 876 * @returns {boolean} 877 */ 878 function isRelativePath (moduleName) { 879 return moduleName.match(/\.\.?\//) !== null; 880 } 881 882 /** 883 * @param {string} moduleName 884 * @param {string} filePath 885 * @returns {string} 886 */ 887 function resolveRelativePath (moduleName, filePath) { 888 var nameParts = moduleName.split(/\/(?!\/)/); 889 var filePathParts = filePath.split(/\/(?!\/)/); 890 891 // Drop file name 892 filePathParts.pop(); 893 894 var namePart; 895 while (namePart = nameParts.shift()) { 896 if (namePart === '.') { 897 continue; 898 } 899 900 if (namePart === '..') { 901 if (filePathParts.length <= 1) { 902 throw new Error('Invalid relative path'); 903 } 904 filePathParts.pop(); 905 continue; 906 } 907 908 filePathParts.push(namePart); 909 } 910 911 return filePathParts.join('/'); 912 } 913 914 /** 915 * @param {string} moduleName 916 * @returns {boolean} 917 */ 918 function isPackage (moduleName) { 919 return ( 920 (moduleName.indexOf('/') === -1 ? moduleName : moduleName.split('/')[0]) 921 in packages 922 ); 923 } 924 925 /** 926 * @param {string} moduleName 927 * @returns {string} 928 */ 929 function getPathFromPackage (moduleName) { 930 var nameParts = moduleName.split('/'); 931 var packageName = nameParts.shift(); 932 var myPackage = packages[packageName]; 933 934 return myPackage['location'] + '/' + ( 935 moduleName.indexOf('/') === -1 936 ? myPackage['main'] 937 : nameParts.join('/') 938 ); 939 } 940 941 /** 942 * @param {string} moduleName 943 * @returns {string} 944 */ 945 function normalizePackageId (moduleName) { 946 if (!isPackage(moduleName) || moduleName.indexOf('/') !== -1) { 947 return moduleName; 948 } 949 950 var nameParts = moduleName.split('/'); 951 var packageName = nameParts.shift(); 952 var myPackage = packages[packageName]; 953 954 return packageName + '/' + myPackage['main']; 955 } 956 957 /** 958 * @param {string} pathToDecorate 959 * @returns {string} 960 */ 961 function decorateWithExtension (pathToDecorate) { 962 if (pathToDecorate.match(/\.(css|js)$/) !== null) { 963 return pathToDecorate; 964 } 965 966 return pathToDecorate + '.js'; 967 } 968 969 return { 970 get: getPath, 971 normalizePackageId: normalizePackageId, 972 resolve: resolveRelativePath 973 }; 974}()); 975 976module.exports = path; 977 978},{}],10:[function(require,module,exports){ 979var getRegistry = (function () { 980 'use strict'; 981 982 /** @type {Object} */ 983 var modules = {}; 984 /** @type {Object} */ 985 var listeners = {}; 986 987 /** 988 * @param {string} normalizedModuleId 989 * @returns {amdModule|null} 990 */ 991 function getModule (normalizedModuleId) { 992 if (!(normalizedModuleId in modules)) { 993 return null; 994 } 995 996 return modules[normalizedModuleId]; 997 } 998 999 /** 1000 * @param {amdModule} amdModule 1001 */ 1002 function registerModule (amdModule) { 1003 if (amdModule.getId() in modules) { 1004 return; 1005 } 1006 1007 modules[amdModule.getId()] = amdModule; 1008 } 1009 1010 /** 1011 * @param {amdModule} targetModule 1012 * @param {Function} listener 1013 */ 1014 function addListener (targetModule, listener) { 1015 if (targetModule.isDefined()) { 1016 listener(targetModule); 1017 return; 1018 } 1019 1020 var moduleId = targetModule.getId(); 1021 if (listeners[moduleId]) { 1022 listeners[moduleId].push(listener); 1023 return; 1024 } 1025 1026 listeners[moduleId] = [listener]; 1027 } 1028 1029 /** 1030 * @param {amdModule} definedModule 1031 */ 1032 function resolve (definedModule) { 1033 var listener; 1034 var activeListeners = listeners[definedModule.getId()]; 1035 if (activeListeners) { 1036 while (listener = activeListeners.shift()) { 1037 listener(definedModule); 1038 } 1039 } 1040 } 1041 1042 return { 1043 getModule: getModule, 1044 registerModule: registerModule, 1045 addListener: addListener, 1046 resolve: resolve 1047 }; 1048}()); 1049 1050module.exports = getRegistry; 1051 1052},{}]},{},[2]) 1053//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Vzci9sb2NhbC9saWIvbm9kZV9tb2R1bGVzL2Jyb3dzZXJpZnkvbm9kZV9tb2R1bGVzL2Jyb3dzZXItcGFjay9fcHJlbHVkZS
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
1053H1cbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIG1vZHVsZUlkID0gbm9ybWFsaXplSWQobW9kdWxlSWQpO1xuICAgICAgICBkZWZpbmVIaXN0b3J5W21vZHVsZUlkXSA9IHRydWU7XG4gICAgICAgIHZhciBtb2R1bGVUb0RlZmluZSA9IHJlZ2lzdHJ5LmdldE1vZHVsZShtb2R1bGVJZCkgfHwgYW1kTW9kdWxlLmNyZWF0ZShtb2R1bGVJZCwgcGF0aC5nZXQobW9kdWxlSWQpKTtcbiAgICAgICAgcmVnaXN0cnkucmVnaXN0ZXJNb2R1bGUobW9kdWxlVG9EZWZpbmUpO1xuXG4gICAgICAgIGlmIChkZXBlbmRlbmNpZXMubGVuZ3RoIDwgMSkge1xuICAgICAgICAgICAgZGVmaW5pdGlvbiAmJiBtb2R1bGVUb0RlZmluZS5zZXRWYWx1ZShcbiAgICAgICAgICAgICAgICB0eXBlb2YgZGVmaW5pdGlvbiA9PT0gJ2Z1bmN0aW9uJyA/IGRlZmluaXRpb24oKSA6IGRlZmluaXRpb25cbiAgICAgICAgICAgICk7XG4gICAgICAgICAgICByZWdpc3RyeS5yZXNvbHZlKG1vZHVsZVRvRGVmaW5lKTtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIHF1ZXVlRGVwZW5kZW5jaWVzKGRlcGVuZGVuY2llcywgZnVuY3Rpb24gKCkge1xuICAgICAgICAgICAgZGVmaW5pdGlvbiAmJiBtb2R1bGVUb0RlZmluZS5zZXRWYWx1ZShkZWZpbml0aW9uLmFwcGx5KG51bGwsIGFyZ3VtZW50cykpO1xuICAgICAgICAgICAgcmVnaXN0cnkucmVzb2x2ZShtb2R1bGVUb0RlZmluZSk7XG4gICAgICAgIH0sIG1vZHVsZVRvRGVmaW5lKTtcbiAgICB9O1xuXG4gICAgLyoqXG4gICAgICogQHBhcmFtIHtBcnJheXxzdHJpbmd8RnVuY3Rpb259IGRlcGVuZGVuY2llc1xuICAgICAqIEBwYXJhbSB7RnVuY3Rpb259IGRlZmluaXRpb25cbiAgICAgKiBAcGFyYW0ge2FtZE1vZHVsZX0gY29udGV4dFxuICAgICAqIEByZXR1cm5zIHsqfVxuICAgICAqL1xuICAgIHdpbmRvdy5yZXF1aXJlID0gZnVuY3Rpb24gKGRlcGVuZGVuY2llcywgZGVmaW5pdGlvbiwgY29udGV4dCkge1xuICAgICAgICBpZiAoIWRlcGVuZGVuY2llcyAmJiAhZGVmaW5pdGlvbikge1xuICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKEVfTUFMRk9STUVEX1JFUVVJUkUpO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKGRlcGVuZGVuY2llcyBpbnN0YW5jZW9mIEFycmF5KSB7XG4gICAgICAgICAgICBxdWV1ZURlcGVuZGVuY2llcyhkZXBlbmRlbmNpZXMsIGRlZmluaXRpb24sIGNvbnRleHQpO1xuICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKHR5cGVvZiBkZXBlbmRlbmNpZXMgPT09ICdzdHJpbmcnKSB7XG4gICAgICAgICAgICB2Y
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
1053XIgZGVmaW5lQXJndW1lbnRzID0gbnVsbDtcblxuICAgICAgICBpZiAobG9hZGVyLnVzZUludGVyYWN0aXZlKCkgJiYgbG9hZGVkTW9kdWxlSWQgaW4gZGVmaW5lUXVldWUpIHtcbiAgICAgICAgICAgIGRlZmluZUFyZ3VtZW50cyA9IGRlZmluZVF1ZXVlW2xvYWRlZE1vZHVsZUlkXTtcbiAgICAgICAgICAgIGRlbGV0ZSBkZWZpbmVRdWV1ZVtsb2FkZWRNb2R1bGVJZF07XG4gICAgICAgIH0gZWxzZSBpZiAoIWxvYWRlci51c2VJbnRlcmFjdGl2ZSgpKSB7XG4gICAgICAgICAgICBkZWZpbmVBcmd1bWVudHMgPSBbXTtcbiAgICAgICAgICAgIGlmICgnbGFzdCcgaW4gZGVmaW5lUXVldWUpIHtcbiAgICAgICAgICAgICAgICBkZWZpbmVBcmd1bWVudHMgPSBkZWZpbmVRdWV1ZVsnbGFzdCddLnNoaWZ0KCkgfHwgW107XG4gICAgICAgICAgICAgICAgaWYgKGRlZmluZVF1ZXVlWydsYXN0J10ubGVuZ3RoID09PSAwKSB7XG4gICAgICAgICAgICAgICAgICAgIGRlbGV0ZSBkZWZpbmVRdWV1ZVsnbGFzdCddO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGRlZmluZUFyZ3VtZW50c1swXSA9IGxvYWRlZE1vZHVsZUlkO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKCFkZWZpbmVBcmd1bWVudHMpIHtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGlmIChnbG9iYWxzLmlzR2xvYmFsKGxvYWRlZE1vZHVsZUlkKSAmJiBkZWZpbmVBcmd1bWVudHMubGVuZ3RoID09PSAxKSB7XG4gICAgICAgICAgICBpZiAobG9hZGVkTW9kdWxlSWQgaW4gZGVmaW5lSGlzdG9yeSkge1xuICAgICAgICAgICAgICAgIC8vIEdsb2JhbCBpcyBhcHBhcmVudGx5IHVzaW5nIEFNRCB0byByZWdpc3RlciBpdHNlbGZcbiAgICAgICAgICAgICAgICByZXR1cm47XG4gICAgICAgICAgICB9XG5cbiAgICAgICAgICAgIGRlZmluZUFyZ3VtZW50c1sxXSA9IFtdO1xuICAgICAgICAgICAgZGVmaW5lQXJndW1lbnRzWzJdID0gZnVuY3Rpb24gKCkgeyByZXR1cm4gZ2xvYmFscy5nZXQobG9hZGVkTW9kdWxlSWQpOyB9O1xuICAgICAgICB9XG5cbiAgICAgICAgd2luZG93LmRlZmluZS5hcHBseShudWxsLCBkZWZpbmVBcmd1bWVudHMpO1xuICAgIH1cblxuICAgIGZ1bmN0aW9uIHF1ZXVlRGVwZW5kZW5jaWVzICgpIHtcbiAgICAgICAgdmFyIGFyZ3MgPSBhcmd1bWVudHM7XG5cbiAgICAgICAgd2luZG93LnNldFRpbWVvdXQoZnVuY3Rpb24gKCkge1xuICAgICAgICAgICAgbG9hZERlcGVuZGVuY2llcy5hcHBseShudWxsLCBhcmdzKTtcbiAgICAgICAgfSwgNCk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQHBhcmFtIHtBcnJheX0gZGVwZW5kZW5jaWVzXG4gICAgICogQHBhcmFtIHtGdW5jdGlvbn0gZGVmaW5pdGlvblxuICAgICAqIEBwYXJhbSB7YW1kTW9kdWxlfSBjb250ZXh0XG4gICAgICovXG4gICAgZnVuY3Rpb24gbG9hZERlcGVuZGVuY2llcyAoZGVwZW5kZW5jaWVzLCBkZWZpbml0aW9uLCBjb250ZXh0KSB7XG4gICAgICAgIHZhciB2YWx1ZXMgPSBbXTtcbiAgICAgICAgdmFyIGxvYWRlZCA9IDA7XG5cbiAgICAgICAgLyoqXG4gICAgICAgICAqIEBwYXJhbSB7YW1kTW9kdWxlfSBsb2FkZWRNb2R1bGVcbiAgICAgICAgICogQHBhcmFtIHtzdHJpbmd9IHJlc291cmNlXG4gICAgICAgICAqL1xuICAgICAgICBmdW5jdGlvbiBkZXBlbmRlbmN5TG9hZGVkIChsb2FkZWRNb2R1bGUsIHJlc291cmNlKSB7XG4gICAgICAgICAgICBpZiAocmVzb3VyY2UpIHtcbiAgICAgICAgICAgICAgICB2Y
1053XIgbW9kdWxlVmFsdWUgPSBsb2FkZWRNb2R1bGUuZ2V0VmFsdWUoKTtcbiAgICAgICAgICAgICAgICBtb2R1bGVWYWx1ZS5sb2FkKHJlc291cmNlLCBmdW5jdGlvbiAobG9hZGVkVmFsdWUpIHtcbiAgICAgICAgICAgICAgICAgICAgYXBwbHlEZXBlbmRlbmN5VmFsdWUobG9hZGVkTW9kdWxlLmdldElkKCkgKyAnIScgKyByZXNvdXJjZSwgbG9hZGVkVmFsdWUgfHwgbW9kdWxlVmFsdWUpO1xuICAgICAgICAgICAgICAgIH0pO1xuICAgICAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgICAgIH1cblxuICAgICAgICAgICAgYXBwbHlEZXBlbmRlbmN5VmFsdWUobG9hZGVkTW9kdWxlLmdldElkKCksIGxvYWRlZE1vZHVsZS5nZXRWYWx1ZSgpKTtcbiAgICAgICAgfVxuXG4gICAgICAgIC8qKlxuICAgICAgICAgKiBAcGFyYW0ge3N0cmluZ30gbW9kdWxlUmVzb3VyY2VJZFxuICAgICAgICAgKiBAcGFyYW0geyp9IG1vZHVsZVZhbHVlXG4gICAgICAgICAqL1xuICAgICAgICBmdW5jdGlvbiBhcHBseURlcGVuZGVuY3lWYWx1ZSAobW9kdWxlUmVzb3VyY2VJZCwgbW9kdWxlVmFsdWUpIHtcbiAgICAgICAgICAgIHZhbHVlc1tkZXBlbmRlbmNpZXMuaW5kZXhPZihtb2R1bGVSZXNvdXJjZUlkKV0gPSBtb2R1bGVWYWx1ZTtcblxuICAgICAgICAgICAgaWYgKGRlZmluaXRpb24gJiYgKytsb2FkZWQgPj0gZGVwZW5kZW5jaWVzLmxlbmd0aCkge1xuICAgICAgICAgICAgICAgIGRlZmluaXRpb24uYXBwbHkobnVsbCwgdmFsdWVzKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuXG4gICAgICAgIC8qKlxuICAgICAgICAgKiBAcGFyYW0ge3N0cmluZ30gbW9kdWxlSWRcbiAgICAgICAgICogQHBhcmFtIHtzdHJpbmd9IHJlc291cmNlXG4gICAgICAgICAqL1xuICAgICAgICBmdW5jdGlvbiBsb2FkRGVwZW5kZW5jeSAobW9kdWxlSWQsIHJlc291cmNlKSB7XG4gICAgICAgICAgICB2Y
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
1053Hx8ICgvXihjb21wbGV0ZXxsb2FkZWQpJC8udGVzdCgoZXZlbnQuY3VycmVudFRhcmdldCB8fCBldmVudC5zcmNFbGVtZW50KS5yZWFkeVN0YXRlKSlcbiAgICAgICAgKSB7XG4gICAgICAgICAgICBpbnRlcmFjdGl2ZVNjcmlwdCA9IG51bGw7XG4gICAgICAgICAgICBkZWZpbmVDYWxsYmFjayhzY3JpcHQuZ2V0QXR0cmlidXRlKCdkYXRhLW1vZHVsZUlkJykpO1xuICAgICAgICAgICAgc2NyaXB0LnJlbW92ZUF0dHJpYnV0ZSgnZGF0YS1tb2R1bGVJZCcpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQHBhcmFtIHthbWRNb2R1bGV9IGFtZE1vZHVsZVxuICAgICAqIEByZXR1cm5zIHtFbGVtZW50fVxuICAgICAqL1xuICAgIGZ1bmN0aW9uIGdldFNjcmlwdEVsZW1lbnQgKGFtZE1vZHVsZSkge1xuICAgICAgICB2YXIgc2NyaXB0ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc2NyaXB0Jyk7XG4gICAgICAgIHNjcmlwdC5hc3luYyA9IHRydWU7XG4gICAgICAgIHNjcmlwdC5zZXRBdHRyaWJ1dGUoJ2RhdGEtbW9kdWxlSWQnLCBhbWRNb2R1bGUuZ2V0SWQoKSk7XG4gICAgICAgIHJldHVybiBzY3JpcHQ7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQHJldHVybnMge0VsZW1lbnR9XG4gICAgICovXG4gICAgZnVuY3Rpb24gZ2V0SW50ZXJhY3RpdmVTY3JpcHQgKCkge1xuICAgICAgICBpZiAoY3VycmVudGx5QWRkaW5nU2NyaXB0ICE9PSBudWxsKSB7XG4gICAgICAgICAgICByZXR1cm4gY3VycmVudGx5QWRkaW5nU2NyaXB0O1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKGludGVyYWN0aXZlU2NyaXB0ICYmIGludGVyYWN0aXZlU2NyaXB0LnJlYWR5U3RhdGUgPT09ICdpbnRlcmFjdGl2ZScpIHtcbiAgICAgICAgICAgIHJldHVybiBpbnRlcmFjdGl2ZVNjcmlwdDtcbiAgICAgICAgfVxuXG4gICAgICAgIHZhciBzY3JpcHRzID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoJ3NjcmlwdCcpO1xuICAgICAgICB2Y
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
1053RhcmdldE1vZHVsZSk7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICB2YXIgbW9kdWxlSWQgPSB0YXJnZXRNb2R1bGUuZ2V0SWQoKTtcbiAgICAgICAgaWYgKGxpc3RlbmVyc1ttb2R1bGVJZF0pIHtcbiAgICAgICAgICAgIGxpc3RlbmVyc1ttb2R1bGVJZF0ucHVzaChsaXN0ZW5lcik7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBsaXN0ZW5lcnNbbW9kdWxlSWRdID0gW2xpc3RlbmVyXTtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBAcGFyYW0ge2FtZE1vZHVsZX0gZGVmaW5lZE1vZHVsZVxuICAgICAqL1xuICAgIGZ1bmN0aW9uIHJlc29sdmUgKGRlZmluZWRNb2R1bGUpIHtcbiAgICAgICAgdmFyIGxpc3RlbmVyO1xuICAgICAgICB2YXIgYWN0aXZlTGlzdGVuZXJzID0gbGlzdGVuZXJzW2RlZmluZWRNb2R1bGUuZ2V0SWQoKV07XG4gICAgICAgIGlmIChhY3RpdmVMaXN0ZW5lcnMpIHtcbiAgICAgICAgICAgIHdoaWxlIChsaXN0ZW5lciA9IGFjdGl2ZUxpc3RlbmVycy5zaGlmdCgpKSB7XG4gICAgICAgICAgICAgICAgbGlzdGVuZXIoZGVmaW5lZE1vZHVsZSk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICByZXR1cm4ge1xuICAgICAgICBnZXRNb2R1bGU6IGdldE1vZHVsZSxcbiAgICAgICAgcmVnaXN0ZXJNb2R1bGU6IHJlZ2lzdGVyTW9kdWxlLFxuICAgICAgICBhZGRMaXN0ZW5lcjogYWRkTGlzdGVuZXIsXG4gICAgICAgIHJlc29sdmU6IHJlc29sdmVcbiAgICB9O1xufSgpKTtcblxubW9kdWxlLmV4cG9ydHMgPSBnZXRSZWdpc3RyeTtcbiJdfQ==
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.