vendor: 16,887 bytes, lines 1-587
1/**! 2 3 @license 4 handlebars v4.7.7 5 6 Copyright (C) 2011-2019 by Yehuda Katz 7 8 Permission is hereby granted, free of charge, to any person obtaining a copy 9 of this software and associated documentation files (the "Software"), to deal 10 in the Software without restriction, including without limitation the rights 11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 copies of the Software, and to permit persons to whom the Software is 13 furnished to do so, subject to the following conditions: 14 15 The above copyright notice and this permission notice shall be included in 16 all copies or substantial portions of the Software. 17 18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 24 THE SOFTWARE. 25 26 */ 27(function webpackUniversalModuleDefinition(root, factory) { 28 if(typeof exports === 'object' && typeof module === 'object') 29 module.exports = factory(); 30 else if(typeof define === 'function' && define.amd) 31 define([], factory); 32 else if(typeof exports === 'object') 33 exports["Handlebars"] = factory(); 34 else 35 root["Handlebars"] = factory(); 36})(this, function() { 37 return /******/ (function(modules) { // webpackBootstrap 38 /******/ // The module cache 39 /******/ var installedModules = {}; 40 41 /******/ // The require function 42 /******/ function __webpack_require__(moduleId) { 43 44 /******/ // Check if module is in cache 45 /******/ if(installedModules[moduleId]) 46 /******/ return installedModules[moduleId].exports; 47 48 /******/ // Create a new module (and put it into the cache) 49 /******/ var module = installedModules[moduleId] = { 50 /******/ exports: {}, 51 /******/ id: moduleId, 52 /******/ loaded: false 53 /******/ }; 54 55 /******/ // Execute the module function 56 /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 57 58 /******/ // Flag the module as loaded 59 /******/ module.loaded = true; 60 61 /******/ // Return the exports of the module 62 /******/ return module.exports; 63 /******/ } 64 65 66 /******/ // expose the modules object (__webpack_modules__) 67 /******/ __webpack_require__.m = modules; 68 69 /******/ // expose the module cache 70 /******/ __webpack_require__.c = installedModules; 71 72 /******/ // __webpack_public_path__ 73 /******/ __webpack_require__.p = ""; 74 75 /******/ // Load entry module and return exports 76 /******/ return __webpack_require__(0); 77 /******/ }) 78 /************************************************************************/ 79 /******/ ([ 80 /* 0 */ 81 /***/ (function(module, exports, __webpack_require__) { 82 83 'use strict'; 84 85 var _interopRequireDefault = __webpack_require__(1)['default']; 86 87 exports.__esModule = true; 88 89 var _handlebarsRuntime = __webpack_require__(2); 90 91 var _handlebarsRuntime2 = _interopRequireDefault(_handlebarsRuntime); 92 93 // Compiler imports 94 95 var _handlebarsCompilerAst = __webpack_require__(45); 96 97 var _handlebarsCompilerAst2 = _interopRequireDefault(_handlebarsCompilerAst); 98 99 var _handlebarsCompilerBase = __webpack_require__(46); 100 101 var _handlebarsCompilerCompiler = __webpack_require__(51); 102 103 var _handlebarsCompilerJavascriptCompiler = __webpack_require__(52); 104 105 var _handlebarsCompilerJavascriptCompiler2 = _interopRequireDefault(_handlebarsCompilerJavascriptCompiler); 106 107 var _handlebarsCompilerVisitor = __webpack_require__(49); 108 109 var _handlebarsCompilerVisitor2 = _interopRequireDefault(_handlebarsCompilerVisitor); 110 111 var _handlebarsNoConflict = __webpack_require__(44); 112 113 var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict); 114 115 var _create = _handlebarsRuntime2['default'].create; 116 function create() { 117 var hb = _create(); 118 119 hb.compile = function (input, options) { 120 return _handlebarsCompilerCompiler.compile(input, options, hb); 121 }; 122 hb.precompile = function (input, options) { 123 return _handlebarsCompilerCompiler.precompile(input, options, hb); 124 }; 125 126 hb.AST = _handlebarsCompilerAst2['default']; 127 hb.Compiler = _handlebarsCompilerCompiler.Compiler; 128 hb.JavaScriptCompiler = _handlebarsCompilerJavascriptCompiler2['default']; 129 hb.Parser = _handlebarsCompilerBase.parser; 130 hb.parse = _handlebarsCompilerBase.parse; 131 hb.parseWithoutProcessing = _handlebarsCompilerBase.parseWithoutProcessing; 132 133 return hb; 134 } 135 136 var inst = create(); 137 inst.create = create; 138 139 _handlebarsNoConflict2['default'](inst); 140 141 inst.Visitor = _handlebarsCompilerVisitor2['default']; 142 143 inst['default'] = inst; 144 145 exports['default'] = inst; 146 module.exports = exports['default']; 147 148 /***/ }), 149 /* 1 */ 150 /***/ (function(module, exports) { 151 152 "use strict"; 153 154 exports["default"] = function (obj) { 155 return obj && obj.__esModule ? obj : { 156 "default": obj 157 }; 158 }; 159 160 exports.__esModule = true; 161 162 /***/ }), 163 /* 2 */ 164 /***/ (function(module, exports, __webpack_require__) { 165 166 'use strict'; 167 168 var _interopRequireWildcard = __webpack_require__(3)['default']; 169 170 var _interopRequireDefault = __webpack_require__(1)['default']; 171 172 exports.__esModule = true; 173 174 var _handlebarsBase = __webpack_require__(4); 175 176 var base = _interopRequireWildcard(_handlebarsBase); 177 178 // Each of these augment the Handlebars object. No need to setup here. 179 // (This is done to easily share code between commonjs and browse envs) 180 181 var _handlebarsSafeString = __webpack_require__(37); 182 183 var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString); 184 185 var _handlebarsException = __webpack_require__(6); 186 187 var _handlebarsException2 = _interopRequireDefault(_handlebarsException); 188 189 var _handlebarsUtils = __webpack_require__(5); 190 191 var Utils = _interopRequireWildcard(_handlebarsUtils); 192 193 var _handlebarsRuntime = __webpack_require__(38); 194 195 var runtime = _interopRequireWildcard(_handlebarsRuntime); 196 197 var _handlebarsNoConflict = __webpack_require__(44); 198 199 var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict); 200 201 // For compatibility and usage outside of module systems, make the Handlebars object a namespace 202 function create() { 203 var hb = new base.HandlebarsEnvironment(); 204 205 Utils.extend(hb, base); 206 hb.SafeString = _handlebarsSafeString2['default']; 207 hb.Exception = _handlebarsException2['default']; 208 hb.Utils = Utils; 209 hb.escapeExpression = Utils.escapeExpression; 210 211 hb.VM = runtime; 212 hb.template = function (spec) { 213 return runtime.template(spec, hb); 214 }; 215 216 return hb; 217 } 218 219 var inst = create(); 220 inst.create = create; 221 222 _handlebarsNoConflict2['default'](inst); 223 224 inst['default'] = inst; 225 226 exports['default'] = inst; 227 module.exports = exports['default']; 228 229 /***/ }), 230 /* 3 */ 231 /***/ (function(module, exports) { 232 233 "use strict"; 234 235 exports["default"] = function (obj) { 236 if (obj && obj.__esModule) { 237 return obj; 238 } else { 239 var newObj = {}; 240 241 if (obj != null) { 242 for (var key in obj) { 243 if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; 244 } 245 } 246 247 newObj["default"] = obj; 248 return newObj; 249 } 250 }; 251 252 exports.__esModule = true; 253 254 /***/ }), 255 /* 4 */ 256 /***/ (function(module, exports, __webpack_require__) { 257 258 'use strict'; 259 260 var _interopRequireDefault = __webpack_require__(1)['default']; 261 262 exports.__esModule = true; 263 exports.HandlebarsEnvironment = HandlebarsEnvironment; 264 265 var _utils = __webpack_require__(5); 266 267 var _exception = __webpack_require__(6); 268 269 var _exception2 = _interopRequireDefault(_exception); 270 271 var _helpers = __webpack_require__(10); 272 273 var _decorators = __webpack_require__(30); 274 275 var _logger = __webpack_require__(32); 276 277 var _logger2 = _interopRequireDefault(_logger); 278 279 var _internalProtoAccess = __webpack_require__(33); 280 281 var VERSION = '4.7.7'; 282 exports.VERSION = VERSION; 283 var COMPILER_REVISION = 8; 284 exports.COMPILER_REVISION = COMPILER_REVISION; 285 var LAST_COMPATIBLE_COMPILER_REVISION = 7; 286 287 exports.LAST_COMPATIBLE_COMPILER_REVISION = LAST_COMPATIBLE_COMPILER_REVISION; 288 var REVISION_CHANGES = { 289 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it 290 2: '== 1.0.0-rc.3', 291 3: '== 1.0.0-rc.4', 292 4: '== 1.x.x', 293 5: '== 2.0.0-alpha.x', 294 6: '>= 2.0.0-beta.1', 295 7: '>= 4.0.0 <4.3.0', 296 8: '>= 4.3.0' 297 }; 298 299 exports.REVISION_CHANGES = REVISION_CHANGES; 300 var objectType = '[object Object]'; 301 302 function HandlebarsEnvironment(helpers, partials, decorators) { 303 this.helpers = helpers || {}; 304 this.partials = partials || {}; 305 this.decorators = decorators || {}; 306 307 _helpers.registerDefaultHelpers(this); 308 _decorators.registerDefaultDecorators(this); 309 } 310 311 HandlebarsEnvironment.prototype = { 312 constructor: HandlebarsEnvironment, 313 314 logger: _logger2['default'], 315 log: _logger2['default'].log, 316 317 registerHelper: function registerHelper(name, fn) { 318 if (_utils.toString.call(name) === objectType) { 319 if (fn) { 320 throw new _exception2['default']('Arg not supported with multiple helpers'); 321 } 322 _utils.extend(this.helpers, name); 323 } else { 324 this.helpers[name] = fn; 325 } 326 }, 327 unregisterHelper: function unregisterHelper(name) { 328 delete this.helpers[name]; 329 }, 330 331 registerPartial: function registerPartial(name, partial) { 332 if (_utils.toString.call(name) === objectType) { 333 _utils.extend(this.partials, name); 334 } else { 335 if (typeof partial === 'undefined') { 336 throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined'); 337 } 338 this.partials[name] = partial; 339 } 340 }, 341 unregisterPartial: function unregisterPartial(name) { 342 delete this.partials[name]; 343 }, 344 345 registerDecorator: function registerDecorator(name, fn) { 346 if (_utils.toString.call(name) === objectType) { 347 if (fn) { 348 throw new _exception2['default']('Arg not supported with multiple decorators'); 349 } 350 _utils.extend(this.decorators, name); 351 } else { 352 this.decorators[name] = fn; 353 } 354 }, 355 unregisterDecorator: function unregisterDecorator(name) { 356 delete this.decorators[name]; 357 }, 358 /** 359 * Reset the memory of illegal property accesses that have already been logged. 360 * @deprecated should only be used in handlebars test-cases 361 */ 362 resetLoggedPropertyAccesses: function resetLoggedPropertyAccesses() { 363 _internalProtoAccess.resetLoggedProperties(); 364 } 365 }; 366 367 var log = _logger2['default'].log; 368 369 exports.log = log; 370 exports.createFrame = _utils.createFrame; 371 exports.logger = _logger2['default']; 372 373 /***/ }), 374 /* 5 */ 375 /***/ (function(module, exports) { 376 377 'use strict'; 378 379 exports.__esModule = true; 380 exports.extend = extend; 381 exports.indexOf = indexOf; 382 exports.escapeExpression = escapeExpression; 383 exports.isEmpty = isEmpty; 384 exports.createFrame = createFrame; 385 exports.blockParams = blockParams; 386 exports.appendContextPath = appendContextPath; 387 var escape = { 388 '&': '&', 389 '<': '<', 390 '>': '>', 391 '"': '"', 392 "'": ''', 393 '`': '`', 394 '=': '=' 395 }; 396 397 var badChars = /[&<>"'`=]/g, 398 possible = /[&<>"'`=]/; 399 400 function escapeChar(chr) { 401 return escape[chr]; 402 } 403 404 function extend(obj /* , ...source */) { 405 for (var i = 1; i < arguments.length; i++) { 406 for (var key in arguments[i]) { 407 if (Object.prototype.hasOwnProperty.call(arguments[i], key)) { 408 obj[key] = arguments[i][key]; 409 } 410 } 411 } 412 413 return obj; 414 } 415 416 var toString = Object.prototype.toString; 417 418 exports.toString = toString; 419 // Sourced from lodash 420 // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt 421 /* eslint-disable func-style */ 422 var isFunction = function isFunction(value) { 423 return typeof value === 'function'; 424 }; 425 // fallback for older versions of Chrome and Safari 426 /* istanbul ignore next */ 427 if (isFunction(/x/)) { 428 exports.isFunction = isFunction = function (value) { 429 return typeof value === 'function' && toString.call(value) === '[object Function]'; 430 }; 431 } 432 exports.isFunction = isFunction; 433 434 /* eslint-enable func-style */ 435 436 /* istanbul ignore next */ 437 var isArray = Array.isArray || function (value) { 438 return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false; 439 }; 440 441 exports.isArray = isArray; 442 // Older IE versions do not directly support indexOf so we must implement our own, sadly. 443 444 function indexOf(array, value) { 445 for (var i = 0, len = array.length; i < len; i++) { 446 if (array[i] === value) { 447 return i; 448 } 449 } 450 return -1; 451 } 452 453 function escapeExpression(string) { 454 if (typeof string !== 'string') { 455 // don't escape SafeStrings, since they're already safe 456 if (string && string.toHTML) { 457 return string.toHTML(); 458 } else if (string == null) { 459 return ''; 460 } else if (!string) { 461 return string + ''; 462 } 463 464 // Force a string conversion as this will be done by the append regardless and 465 // the regex test will do this transparently behind the scenes, causing issues if 466 // an object's to string has escaped characters in it. 467 string = '' + string; 468 } 469 470 if (!possible.test(string)) { 471 return string; 472 } 473 return string.replace(badChars, escapeChar); 474 } 475 476 function isEmpty(value) { 477 if (!value && value !== 0) { 478 return true; 479 } else if (isArray(value) && value.length === 0) { 480 return true; 481 } else { 482 return false; 483 } 484 } 485 486 function createFrame(object) { 487 var frame = extend({}, object); 488 frame._parent = object; 489 return frame; 490 } 491 492 function blockParams(params, ids) { 493 params.path = ids; 494 return params; 495 } 496 497 function appendContextPath(contextPath, id) { 498 return (contextPath ? contextPath + '.' : '') + id; 499 } 500 501 /***/ }), 502 /* 6 */ 503 /***/ (function(module, exports, __webpack_require__) { 504 505 'use strict'; 506 507 var _Object$defineProperty = __webpack_require__(7)['default']; 508 509 exports.__esModule = true; 510 var errorProps = ['description', 'fileName', 'lineNumber', 'endLineNumber', 'message', 'name', 'number', 'stack']; 511 512 function Exception(message, node) { 513 var loc = node && node.loc, 514 line = undefined, 515 endLineNumber = undefined, 516 column = undefined, 517 endColumn = undefined; 518 519 if (loc) { 520 line = loc.start.line; 521 endLineNumber = loc.end.line; 522 column = loc.start.column; 523 endColumn = loc.end.column; 524 525 message += ' - ' + line + ':' + column; 526 } 527 528 var tmp = Error.prototype.constructor.call(this, message); 529 530 // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work. 531 for (var idx = 0; idx < errorProps.length; idx++) { 532 this[errorProps[idx]] = tmp[errorProps[idx]]; 533 } 534 535 /* istanbul ignore else */ 536 if (Error.captureStackTrace) { 537 Error.captureStackTrace(this, Exception); 538 } 539 540 try { 541 if (loc) { 542 this.lineNumber = line; 543 this.endLineNumber = endLineNumber; 544 545 // Work around issue under safari where we can't directly set the column value 546 /* istanbul ignore next */ 547 if (_Object$defineProperty) { 548 Object.defineProperty(this, 'column', { 549 value: column, 550 enumerable: true 551 }); 552 Object.defineProperty(this, 'endColumn', { 553 value: endColumn, 554 enumerable: true 555 }); 556 } else { 557 this.column = column; 558 this.endColumn = endColumn; 559 } 560 } 561 } catch (nop) { 562 /* Ignore if the browser is very particular */ 563 } 564 } 565 566 Exception.prototype = new Error(); 567 568 exports['default'] = Exception; 569 module.exports = exports['default']; 570 571 /***/ }), 572 /* 7 */ 573 /***/ (function(module, exports, __webpack_require__) { 574 575 module.exports = { "default": __webpack_require__(8), __esModule: true }; 576 577 /***/ }), 578 /* 8 */ 579 /***/ (function(module, exports, __webpack_require__) { 580 581 var $ = __webpack_require__(9); 582 module.exports = function defineProperty(it, key, desc){ 583 return $.setDesc(it, key, desc); 584 }; 585 586 /***/ }), 587 /* 9 */
vendor: 10,203 bytes, lines 588-929
588 /***/ (function(module, exports) { 589 590 var $Object = Object; 591 module.exports = { 592 create: $Object.create, 593 getProto: $Object.getPrototypeOf, 594 isEnum: {}.propertyIsEnumerable, 595 getDesc: $Object.getOwnPropertyDescriptor, 596 setDesc: $Object.defineProperty, 597 setDescs: $Object.defineProperties, 598 getKeys: $Object.keys, 599 getNames: $Object.getOwnPropertyNames, 600 getSymbols: $Object.getOwnPropertySymbols, 601 each: [].forEach 602 }; 603 604 /***/ }), 605 /* 10 */ 606 /***/ (function(module, exports, __webpack_require__) { 607 608 'use strict'; 609 610 var _interopRequireDefault = __webpack_require__(1)['default']; 611 612 exports.__esModule = true; 613 exports.registerDefaultHelpers = registerDefaultHelpers; 614 exports.moveHelperToHooks = moveHelperToHooks; 615 616 var _helpersBlockHelperMissing = __webpack_require__(11); 617 618 var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing); 619 620 var _helpersEach = __webpack_require__(12); 621 622 var _helpersEach2 = _interopRequireDefault(_helpersEach); 623 624 var _helpersHelperMissing = __webpack_require__(25); 625 626 var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing); 627 628 var _helpersIf = __webpack_require__(26); 629 630 var _helpersIf2 = _interopRequireDefault(_helpersIf); 631 632 var _helpersLog = __webpack_require__(27); 633 634 var _helpersLog2 = _interopRequireDefault(_helpersLog); 635 636 var _helpersLookup = __webpack_require__(28); 637 638 var _helpersLookup2 = _interopRequireDefault(_helpersLookup); 639 640 var _helpersWith = __webpack_require__(29); 641 642 var _helpersWith2 = _interopRequireDefault(_helpersWith); 643 644 function registerDefaultHelpers(instance) { 645 _helpersBlockHelperMissing2['default'](instance); 646 _helpersEach2['default'](instance); 647 _helpersHelperMissing2['default'](instance); 648 _helpersIf2['default'](instance); 649 _helpersLog2['default'](instance); 650 _helpersLookup2['default'](instance); 651 _helpersWith2['default'](instance); 652 } 653 654 function moveHelperToHooks(instance, helperName, keepHelper) { 655 if (instance.helpers[helperName]) { 656 instance.hooks[helperName] = instance.helpers[helperName]; 657 if (!keepHelper) { 658 delete instance.helpers[helperName]; 659 } 660 } 661 } 662 663 /***/ }), 664 /* 11 */ 665 /***/ (function(module, exports, __webpack_require__) { 666 667 'use strict'; 668 669 exports.__esModule = true; 670 671 var _utils = __webpack_require__(5); 672 673 exports['default'] = function (instance) { 674 instance.registerHelper('blockHelperMissing', function (context, options) { 675 var inverse = options.inverse, 676 fn = options.fn; 677 678 if (context === true) { 679 return fn(this); 680 } else if (context === false || context == null) { 681 return inverse(this); 682 } else if (_utils.isArray(context)) { 683 if (context.length > 0) { 684 if (options.ids) { 685 options.ids = [options.name]; 686 } 687 688 return instance.helpers.each(context, options); 689 } else { 690 return inverse(this); 691 } 692 } else { 693 if (options.data && options.ids) { 694 var data = _utils.createFrame(options.data); 695 data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name); 696 options = { data: data }; 697 } 698 699 return fn(context, options); 700 } 701 }); 702 }; 703 704 module.exports = exports['default']; 705 706 /***/ }), 707 /* 12 */ 708 /***/ (function(module, exports, __webpack_require__) { 709 710 /* WEBPACK VAR INJECTION */(function(global) {'use strict'; 711 712 var _Object$keys = __webpack_require__(13)['default']; 713 714 var _interopRequireDefault = __webpack_require__(1)['default']; 715 716 exports.__esModule = true; 717 718 var _utils = __webpack_require__(5); 719 720 var _exception = __webpack_require__(6); 721 722 var _exception2 = _interopRequireDefault(_exception); 723 724 exports['default'] = function (instance) { 725 instance.registerHelper('each', function (context, options) { 726 if (!options) { 727 throw new _exception2['default']('Must pass iterator to #each'); 728 } 729 730 var fn = options.fn, 731 inverse = options.inverse, 732 i = 0, 733 ret = '', 734 data = undefined, 735 contextPath = undefined; 736 737 if (options.data && options.ids) { 738 contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.'; 739 } 740 741 if (_utils.isFunction(context)) { 742 context = context.call(this); 743 } 744 745 if (options.data) { 746 data = _utils.createFrame(options.data); 747 } 748 749 function execIteration(field, index, last) { 750 if (data) { 751 data.key = field; 752 data.index = index; 753 data.first = index === 0; 754 data.last = !!last; 755 756 if (contextPath) { 757 data.contextPath = contextPath + field; 758 } 759 } 760 761 ret = ret + fn(context[field], { 762 data: data, 763 blockParams: _utils.blockParams([context[field], field], [contextPath + field, null]) 764 }); 765 } 766 767 if (context && typeof context === 'object') { 768 if (_utils.isArray(context)) { 769 for (var j = context.length; i < j; i++) { 770 if (i in context) { 771 execIteration(i, i, i === context.length - 1); 772 } 773 } 774 } else if (global.Symbol && context[global.Symbol.iterator]) { 775 var newContext = []; 776 var iterator = context[global.Symbol.iterator](); 777 for (var it = iterator.next(); !it.done; it = iterator.next()) { 778 newContext.push(it.value); 779 } 780 context = newContext; 781 for (var j = context.length; i < j; i++) { 782 execIteration(i, i, i === context.length - 1); 783 } 784 } else { 785 (function () { 786 var priorKey = undefined; 787 788 _Object$keys(context).forEach(function (key) { 789 // We're running the iterations one step out of sync so we can detect 790 // the last iteration without have to scan the object twice and create 791 // an itermediate keys array. 792 if (priorKey !== undefined) { 793 execIteration(priorKey, i - 1); 794 } 795 priorKey = key; 796 i++; 797 }); 798 if (priorKey !== undefined) { 799 execIteration(priorKey, i - 1, true); 800 } 801 })(); 802 } 803 } 804 805 if (i === 0) { 806 ret = inverse(this); 807 } 808 809 return ret; 810 }); 811 }; 812 813 module.exports = exports['default']; 814 /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) 815 816 /***/ }), 817 /* 13 */ 818 /***/ (function(module, exports, __webpack_require__) { 819 820 module.exports = { "default": __webpack_require__(14), __esModule: true }; 821 822 /***/ }), 823 /* 14 */ 824 /***/ (function(module, exports, __webpack_require__) { 825 826 __webpack_require__(15); 827 module.exports = __webpack_require__(21).Object.keys; 828 829 /***/ }), 830 /* 15 */ 831 /***/ (function(module, exports, __webpack_require__) { 832 833 // 19.1.2.14 Object.keys(O) 834 var toObject = __webpack_require__(16); 835 836 __webpack_require__(18)('keys', function($keys){ 837 return function keys(it){ 838 return $keys(toObject(it)); 839 }; 840 }); 841 842 /***/ }), 843 /* 16 */ 844 /***/ (function(module, exports, __webpack_require__) { 845 846 // 7.1.13 ToObject(argument) 847 var defined = __webpack_require__(17); 848 module.exports = function(it){ 849 return Object(defined(it)); 850 }; 851 852 /***/ }), 853 /* 17 */ 854 /***/ (function(module, exports) { 855 856 // 7.2.1 RequireObjectCoercible(argument) 857 module.exports = function(it){ 858 if(it == undefined)throw TypeError("Can't call method on " + it); 859 return it; 860 }; 861 862 /***/ }), 863 /* 18 */ 864 /***/ (function(module, exports, __webpack_require__) { 865 866 // most Object methods by ES6 should accept primitives 867 var $export = __webpack_require__(19) 868 , core = __webpack_require__(21) 869 , fails = __webpack_require__(24); 870 module.exports = function(KEY, exec){ 871 var fn = (core.Object || {})[KEY] || Object[KEY] 872 , exp = {}; 873 exp[KEY] = exec(fn); 874 $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp); 875 }; 876 877 /***/ }), 878 /* 19 */ 879 /***/ (function(module, exports, __webpack_require__) { 880 881 var global = __webpack_require__(20) 882 , core = __webpack_require__(21) 883 , ctx = __webpack_require__(22) 884 , PROTOTYPE = 'prototype'; 885 886 var $export = function(type, name, source){ 887 var IS_FORCED = type & $export.F 888 , IS_GLOBAL = type & $export.G 889 , IS_STATIC = type & $export.S 890 , IS_PROTO = type & $export.P 891 , IS_BIND = type & $export.B 892 , IS_WRAP = type & $export.W 893 , exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) 894 , target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE] 895 , key, own, out; 896 if(IS_GLOBAL)source = name; 897 for(key in source){ 898 // contains in native 899 own = !IS_FORCED && target && key in target; 900 if(own && key in exports)continue; 901 // export native or passed 902 out = own ? target[key] : source[key]; 903 // prevent global pollution for namespaces 904 exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] 905 // bind timers to global for call from export context 906 : IS_BIND && own ? ctx(out, global) 907 // wrap global constructors for prevent change them in library 908 : IS_WRAP && target[key] == out ? (function(C){ 909 var F = function(param){ 910 return this instanceof C ? new C(param) : C(param); 911 }; 912 F[PROTOTYPE] = C[PROTOTYPE]; 913 return F; 914 // make static versions for prototype methods 915 })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; 916 if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out; 917 } 918 }; 919 // type bitmap 920 $export.F = 1; // forced 921 $export.G = 2; // global 922 $export.S = 4; // static 923 $export.P = 8; // proto 924 $export.B = 16; // bind 925 $export.W = 32; // wrap 926 module.exports = $export; 927 928 /***/ }), 929 /* 20 */
vendor: 22,174 bytes, lines 930-1642
930 /***/ (function(module, exports) { 931 932 // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 933 var global = module.exports = typeof window != 'undefined' && window.Math == Math 934 ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); 935 if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef 936 937 /***/ }), 938 /* 21 */ 939 /***/ (function(module, exports) { 940 941 var core = module.exports = {version: '1.2.6'}; 942 if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef 943 944 /***/ }), 945 /* 22 */ 946 /***/ (function(module, exports, __webpack_require__) { 947 948 // optional / simple context binding 949 var aFunction = __webpack_require__(23); 950 module.exports = function(fn, that, length){ 951 aFunction(fn); 952 if(that === undefined)return fn; 953 switch(length){ 954 case 1: return function(a){ 955 return fn.call(that, a); 956 }; 957 case 2: return function(a, b){ 958 return fn.call(that, a, b); 959 }; 960 case 3: return function(a, b, c){ 961 return fn.call(that, a, b, c); 962 }; 963 } 964 return function(/* ...args */){ 965 return fn.apply(that, arguments); 966 }; 967 }; 968 969 /***/ }), 970 /* 23 */ 971 /***/ (function(module, exports) { 972 973 module.exports = function(it){ 974 if(typeof it != 'function')throw TypeError(it + ' is not a function!'); 975 return it; 976 }; 977 978 /***/ }), 979 /* 24 */ 980 /***/ (function(module, exports) { 981 982 module.exports = function(exec){ 983 try { 984 return !!exec(); 985 } catch(e){ 986 return true; 987 } 988 }; 989 990 /***/ }), 991 /* 25 */ 992 /***/ (function(module, exports, __webpack_require__) { 993 994 'use strict'; 995 996 var _interopRequireDefault = __webpack_require__(1)['default']; 997 998 exports.__esModule = true; 999 1000 var _exception = __webpack_require__(6); 1001 1002 var _exception2 = _interopRequireDefault(_exception); 1003 1004 exports['default'] = function (instance) { 1005 instance.registerHelper('helperMissing', function () /* [args, ]options */{ 1006 if (arguments.length === 1) { 1007 // A missing field in a {{foo}} construct. 1008 return undefined; 1009 } else { 1010 // Someone is actually trying to call something, blow up. 1011 throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"'); 1012 } 1013 }); 1014 }; 1015 1016 module.exports = exports['default']; 1017 1018 /***/ }), 1019 /* 26 */ 1020 /***/ (function(module, exports, __webpack_require__) { 1021 1022 'use strict'; 1023 1024 var _interopRequireDefault = __webpack_require__(1)['default']; 1025 1026 exports.__esModule = true; 1027 1028 var _utils = __webpack_require__(5); 1029 1030 var _exception = __webpack_require__(6); 1031 1032 var _exception2 = _interopRequireDefault(_exception); 1033 1034 exports['default'] = function (instance) { 1035 instance.registerHelper('if', function (conditional, options) { 1036 if (arguments.length != 2) { 1037 throw new _exception2['default']('#if requires exactly one argument'); 1038 } 1039 if (_utils.isFunction(conditional)) { 1040 conditional = conditional.call(this); 1041 } 1042 1043 // Default behavior is to render the positive path if the value is truthy and not empty. 1044 // The `includeZero` option may be set to treat the condtional as purely not empty based on the 1045 // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative. 1046 if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) { 1047 return options.inverse(this); 1048 } else { 1049 return options.fn(this); 1050 } 1051 }); 1052 1053 instance.registerHelper('unless', function (conditional, options) { 1054 if (arguments.length != 2) { 1055 throw new _exception2['default']('#unless requires exactly one argument'); 1056 } 1057 return instance.helpers['if'].call(this, conditional, { 1058 fn: options.inverse, 1059 inverse: options.fn, 1060 hash: options.hash 1061 }); 1062 }); 1063 }; 1064 1065 module.exports = exports['default']; 1066 1067 /***/ }), 1068 /* 27 */ 1069 /***/ (function(module, exports) { 1070 1071 'use strict'; 1072 1073 exports.__esModule = true; 1074 1075 exports['default'] = function (instance) { 1076 instance.registerHelper('log', function () /* message, options */{ 1077 var args = [undefined], 1078 options = arguments[arguments.length - 1]; 1079 for (var i = 0; i < arguments.length - 1; i++) { 1080 args.push(arguments[i]); 1081 } 1082 1083 var level = 1; 1084 if (options.hash.level != null) { 1085 level = options.hash.level; 1086 } else if (options.data && options.data.level != null) { 1087 level = options.data.level; 1088 } 1089 args[0] = level; 1090 1091 instance.log.apply(instance, args); 1092 }); 1093 }; 1094 1095 module.exports = exports['default']; 1096 1097 /***/ }), 1098 /* 28 */ 1099 /***/ (function(module, exports) { 1100 1101 'use strict'; 1102 1103 exports.__esModule = true; 1104 1105 exports['default'] = function (instance) { 1106 instance.registerHelper('lookup', function (obj, field, options) { 1107 if (!obj) { 1108 // Note for 5.0: Change to "obj == null" in 5.0 1109 return obj; 1110 } 1111 return options.lookupProperty(obj, field); 1112 }); 1113 }; 1114 1115 module.exports = exports['default']; 1116 1117 /***/ }), 1118 /* 29 */ 1119 /***/ (function(module, exports, __webpack_require__) { 1120 1121 'use strict'; 1122 1123 var _interopRequireDefault = __webpack_require__(1)['default']; 1124 1125 exports.__esModule = true; 1126 1127 var _utils = __webpack_require__(5); 1128 1129 var _exception = __webpack_require__(6); 1130 1131 var _exception2 = _interopRequireDefault(_exception); 1132 1133 exports['default'] = function (instance) { 1134 instance.registerHelper('with', function (context, options) { 1135 if (arguments.length != 2) { 1136 throw new _exception2['default']('#with requires exactly one argument'); 1137 } 1138 if (_utils.isFunction(context)) { 1139 context = context.call(this); 1140 } 1141 1142 var fn = options.fn; 1143 1144 if (!_utils.isEmpty(context)) { 1145 var data = options.data; 1146 if (options.data && options.ids) { 1147 data = _utils.createFrame(options.data); 1148 data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]); 1149 } 1150 1151 return fn(context, { 1152 data: data, 1153 blockParams: _utils.blockParams([context], [data && data.contextPath]) 1154 }); 1155 } else { 1156 return options.inverse(this); 1157 } 1158 }); 1159 }; 1160 1161 module.exports = exports['default']; 1162 1163 /***/ }), 1164 /* 30 */ 1165 /***/ (function(module, exports, __webpack_require__) { 1166 1167 'use strict'; 1168 1169 var _interopRequireDefault = __webpack_require__(1)['default']; 1170 1171 exports.__esModule = true; 1172 exports.registerDefaultDecorators = registerDefaultDecorators; 1173 1174 var _decoratorsInline = __webpack_require__(31); 1175 1176 var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline); 1177 1178 function registerDefaultDecorators(instance) { 1179 _decoratorsInline2['default'](instance); 1180 } 1181 1182 /***/ }), 1183 /* 31 */ 1184 /***/ (function(module, exports, __webpack_require__) { 1185 1186 'use strict'; 1187 1188 exports.__esModule = true; 1189 1190 var _utils = __webpack_require__(5); 1191 1192 exports['default'] = function (instance) { 1193 instance.registerDecorator('inline', function (fn, props, container, options) { 1194 var ret = fn; 1195 if (!props.partials) { 1196 props.partials = {}; 1197 ret = function (context, options) { 1198 // Create a new partials stack frame prior to exec. 1199 var original = container.partials; 1200 container.partials = _utils.extend({}, original, props.partials); 1201 var ret = fn(context, options); 1202 container.partials = original; 1203 return ret; 1204 }; 1205 } 1206 1207 props.partials[options.args[0]] = options.fn; 1208 1209 return ret; 1210 }); 1211 }; 1212 1213 module.exports = exports['default']; 1214 1215 /***/ }), 1216 /* 32 */ 1217 /***/ (function(module, exports, __webpack_require__) { 1218 1219 'use strict'; 1220 1221 exports.__esModule = true; 1222 1223 var _utils = __webpack_require__(5); 1224 1225 var logger = { 1226 methodMap: ['debug', 'info', 'warn', 'error'], 1227 level: 'info', 1228 1229 // Maps a given level value to the `methodMap` indexes above. 1230 lookupLevel: function lookupLevel(level) { 1231 if (typeof level === 'string') { 1232 var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase()); 1233 if (levelMap >= 0) { 1234 level = levelMap; 1235 } else { 1236 level = parseInt(level, 10); 1237 } 1238 } 1239 1240 return level; 1241 }, 1242 1243 // Can be overridden in the host environment 1244 log: function log(level) { 1245 level = logger.lookupLevel(level); 1246 1247 if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) { 1248 var method = logger.methodMap[level]; 1249 // eslint-disable-next-line no-console 1250 if (!console[method]) { 1251 method = 'log'; 1252 } 1253 1254 for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 1255 message[_key - 1] = arguments[_key]; 1256 } 1257 1258 console[method].apply(console, message); // eslint-disable-line no-console 1259 } 1260 } 1261 }; 1262 1263 exports['default'] = logger; 1264 module.exports = exports['default']; 1265 1266 /***/ }), 1267 /* 33 */ 1268 /***/ (function(module, exports, __webpack_require__) { 1269 1270 'use strict'; 1271 1272 var _Object$create = __webpack_require__(34)['default']; 1273 1274 var _Object$keys = __webpack_require__(13)['default']; 1275 1276 var _interopRequireWildcard = __webpack_require__(3)['default']; 1277 1278 exports.__esModule = true; 1279 exports.createProtoAccessControl = createProtoAccessControl; 1280 exports.resultIsAllowed = resultIsAllowed; 1281 exports.resetLoggedProperties = resetLoggedProperties; 1282 1283 var _createNewLookupObject = __webpack_require__(36); 1284 1285 var _logger = __webpack_require__(32); 1286 1287 var logger = _interopRequireWildcard(_logger); 1288 1289 var loggedProperties = _Object$create(null); 1290 1291 function createProtoAccessControl(runtimeOptions) { 1292 var defaultMethodWhiteList = _Object$create(null); 1293 defaultMethodWhiteList['constructor'] = false; 1294 defaultMethodWhiteList['__defineGetter__'] = false; 1295 defaultMethodWhiteList['__defineSetter__'] = false; 1296 defaultMethodWhiteList['__lookupGetter__'] = false; 1297 1298 var defaultPropertyWhiteList = _Object$create(null); 1299 // eslint-disable-next-line no-proto 1300 defaultPropertyWhiteList['__proto__'] = false; 1301 1302 return { 1303 properties: { 1304 whitelist: _createNewLookupObject.createNewLookupObject(defaultPropertyWhiteList, runtimeOptions.allowedProtoProperties), 1305 defaultValue: runtimeOptions.allowProtoPropertiesByDefault 1306 }, 1307 methods: { 1308 whitelist: _createNewLookupObject.createNewLookupObject(defaultMethodWhiteList, runtimeOptions.allowedProtoMethods), 1309 defaultValue: runtimeOptions.allowProtoMethodsByDefault 1310 } 1311 }; 1312 } 1313 1314 function resultIsAllowed(result, protoAccessControl, propertyName) { 1315 if (typeof result === 'function') { 1316 return checkWhiteList(protoAccessControl.methods, propertyName); 1317 } else { 1318 return checkWhiteList(protoAccessControl.properties, propertyName); 1319 } 1320 } 1321 1322 function checkWhiteList(protoAccessControlForType, propertyName) { 1323 if (protoAccessControlForType.whitelist[propertyName] !== undefined) { 1324 return protoAccessControlForType.whitelist[propertyName] === true; 1325 } 1326 if (protoAccessControlForType.defaultValue !== undefined) { 1327 return protoAccessControlForType.defaultValue; 1328 } 1329 logUnexpecedPropertyAccessOnce(propertyName); 1330 return false; 1331 } 1332 1333 function logUnexpecedPropertyAccessOnce(propertyName) { 1334 if (loggedProperties[propertyName] !== true) { 1335 loggedProperties[propertyName] = true; 1336 logger.log('error', 'Handlebars: Access has been denied to resolve the property "' + propertyName + '" because it is not an "own property" of its parent.\n' + 'You can add a runtime option to disable the check or this warning:\n' + 'See https://handlebarsjs.com/api-reference/runtime-options.html#options-to-control-prototype-access for details'); 1337 } 1338 } 1339 1340 function resetLoggedProperties() { 1341 _Object$keys(loggedProperties).forEach(function (propertyName) { 1342 delete loggedProperties[propertyName]; 1343 }); 1344 } 1345 1346 /***/ }), 1347 /* 34 */ 1348 /***/ (function(module, exports, __webpack_require__) { 1349 1350 module.exports = { "default": __webpack_require__(35), __esModule: true }; 1351 1352 /***/ }), 1353 /* 35 */ 1354 /***/ (function(module, exports, __webpack_require__) { 1355 1356 var $ = __webpack_require__(9); 1357 module.exports = function create(P, D){ 1358 return $.create(P, D); 1359 }; 1360 1361 /***/ }), 1362 /* 36 */ 1363 /***/ (function(module, exports, __webpack_require__) { 1364 1365 'use strict'; 1366 1367 var _Object$create = __webpack_require__(34)['default']; 1368 1369 exports.__esModule = true; 1370 exports.createNewLookupObject = createNewLookupObject; 1371 1372 var _utils = __webpack_require__(5); 1373 1374 /** 1375 * Create a new object with "null"-prototype to avoid truthy results on prototype properties. 1376 * The resulting object can be used with "object[property]" to check if a property exists 1377 * @param {...object} sources a varargs parameter of source objects that will be merged 1378 * @returns {object} 1379 */ 1380 1381 function createNewLookupObject() { 1382 for (var _len = arguments.length, sources = Array(_len), _key = 0; _key < _len; _key++) { 1383 sources[_key] = arguments[_key]; 1384 } 1385 1386 return _utils.extend.apply(undefined, [_Object$create(null)].concat(sources)); 1387 } 1388 1389 /***/ }), 1390 /* 37 */ 1391 /***/ (function(module, exports) { 1392 1393 // Build out our basic SafeString type 1394 'use strict'; 1395 1396 exports.__esModule = true; 1397 function SafeString(string) { 1398 this.string = string; 1399 } 1400 1401 SafeString.prototype.toString = SafeString.prototype.toHTML = function () { 1402 return '' + this.string; 1403 }; 1404 1405 exports['default'] = SafeString; 1406 module.exports = exports['default']; 1407 1408 /***/ }), 1409 /* 38 */ 1410 /***/ (function(module, exports, __webpack_require__) { 1411 1412 'use strict'; 1413 1414 var _Object$seal = __webpack_require__(39)['default']; 1415 1416 var _Object$keys = __webpack_require__(13)['default']; 1417 1418 var _interopRequireWildcard = __webpack_require__(3)['default']; 1419 1420 var _interopRequireDefault = __webpack_require__(1)['default']; 1421 1422 exports.__esModule = true; 1423 exports.checkRevision = checkRevision; 1424 exports.template = template; 1425 exports.wrapProgram = wrapProgram; 1426 exports.resolvePartial = resolvePartial; 1427 exports.invokePartial = invokePartial; 1428 exports.noop = noop; 1429 1430 var _utils = __webpack_require__(5); 1431 1432 var Utils = _interopRequireWildcard(_utils); 1433 1434 var _exception = __webpack_require__(6); 1435 1436 var _exception2 = _interopRequireDefault(_exception); 1437 1438 var _base = __webpack_require__(4); 1439 1440 var _helpers = __webpack_require__(10); 1441 1442 var _internalWrapHelper = __webpack_require__(43); 1443 1444 var _internalProtoAccess = __webpack_require__(33); 1445 1446 function checkRevision(compilerInfo) { 1447 var compilerRevision = compilerInfo && compilerInfo[0] || 1, 1448 currentRevision = _base.COMPILER_REVISION; 1449 1450 if (compilerRevision >= _base.LAST_COMPATIBLE_COMPILER_REVISION && compilerRevision <= _base.COMPILER_REVISION) { 1451 return; 1452 } 1453 1454 if (compilerRevision < _base.LAST_COMPATIBLE_COMPILER_REVISION) { 1455 var runtimeVersions = _base.REVISION_CHANGES[currentRevision], 1456 compilerVersions = _base.REVISION_CHANGES[compilerRevision]; 1457 throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').'); 1458 } else { 1459 // Use the embedded version info since the runtime doesn't know about this revision yet 1460 throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').'); 1461 } 1462 } 1463 1464 function template(templateSpec, env) { 1465 /* istanbul ignore next */ 1466 if (!env) { 1467 throw new _exception2['default']('No environment passed to template'); 1468 } 1469 if (!templateSpec || !templateSpec.main) { 1470 throw new _exception2['default']('Unknown template object: ' + typeof templateSpec); 1471 } 1472 1473 templateSpec.main.decorator = templateSpec.main_d; 1474 1475 // Note: Using env.VM references rather than local var references throughout this section to allow 1476 // for external users to override these as pseudo-supported APIs. 1477 env.VM.checkRevision(templateSpec.compiler); 1478 1479 // backwards compatibility for precompiled templates with compiler-version 7 (<4.3.0) 1480 var templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7; 1481 1482 function invokePartialWrapper(partial, context, options) { 1483 if (options.hash) { 1484 context = Utils.extend({}, context, options.hash); 1485 if (options.ids) { 1486 options.ids[0] = true; 1487 } 1488 } 1489 partial = env.VM.resolvePartial.call(this, partial, context, options); 1490 1491 var extendedOptions = Utils.extend({}, options, { 1492 hooks: this.hooks, 1493 protoAccessControl: this.protoAccessControl 1494 }); 1495 1496 var result = env.VM.invokePartial.call(this, partial, context, extendedOptions); 1497 1498 if (result == null && env.compile) { 1499 options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env); 1500 result = options.partials[options.name](context, extendedOptions); 1501 } 1502 if (result != null) { 1503 if (options.indent) { 1504 var lines = result.split('\n'); 1505 for (var i = 0, l = lines.length; i < l; i++) { 1506 if (!lines[i] && i + 1 === l) { 1507 break; 1508 } 1509 1510 lines[i] = options.indent + lines[i]; 1511 } 1512 result = lines.join('\n'); 1513 } 1514 return result; 1515 } else { 1516 throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode'); 1517 } 1518 } 1519 1520 // Just add water 1521 var container = { 1522 strict: function strict(obj, name, loc) { 1523 if (!obj || !(name in obj)) { 1524 throw new _exception2['default']('"' + name + '" not defined in ' + obj, { 1525 loc: loc 1526 }); 1527 } 1528 return container.lookupProperty(obj, name); 1529 }, 1530 lookupProperty: function lookupProperty(parent, propertyName) { 1531 var result = parent[propertyName]; 1532 if (result == null) { 1533 return result; 1534 } 1535 if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { 1536 return result; 1537 } 1538 1539 if (_internalProtoAccess.resultIsAllowed(result, container.protoAccessControl, propertyName)) { 1540 return result; 1541 } 1542 return undefined; 1543 }, 1544 lookup: function lookup(depths, name) { 1545 var len = depths.length; 1546 for (var i = 0; i < len; i++) { 1547 var result = depths[i] && container.lookupProperty(depths[i], name); 1548 if (result != null) { 1549 return depths[i][name]; 1550 } 1551 } 1552 }, 1553 lambda: function lambda(current, context) { 1554 return typeof current === 'function' ? current.call(context) : current; 1555 }, 1556 1557 escapeExpression: Utils.escapeExpression, 1558 invokePartial: invokePartialWrapper, 1559 1560 fn: function fn(i) { 1561 var ret = templateSpec[i]; 1562 ret.decorator = templateSpec[i + '_d']; 1563 return ret; 1564 }, 1565 1566 programs: [], 1567 program: function program(i, data, declaredBlockParams, blockParams, depths) { 1568 var programWrapper = this.programs[i], 1569 fn = this.fn(i); 1570 if (data || depths || blockParams || declaredBlockParams) { 1571 programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths); 1572 } else if (!programWrapper) { 1573 programWrapper = this.programs[i] = wrapProgram(this, i, fn); 1574 } 1575 return programWrapper; 1576 }, 1577 1578 data: function data(value, depth) { 1579 while (value && depth--) { 1580 value = value._parent; 1581 } 1582 return value; 1583 }, 1584 mergeIfNeeded: function mergeIfNeeded(param, common) { 1585 var obj = param || common; 1586 1587 if (param && common && param !== common) { 1588 obj = Utils.extend({}, common, param); 1589 } 1590 1591 return obj; 1592 }, 1593 // An empty object to use as replacement for null-contexts 1594 nullContext: _Object$seal({}), 1595 1596 noop: env.VM.noop, 1597 compilerInfo: templateSpec.compiler 1598 }; 1599 1600 function ret(context) { 1601 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; 1602 1603 var data = options.data; 1604 1605 ret._setup(options); 1606 if (!options.partial && templateSpec.useData) { 1607 data = initData(context, data); 1608 } 1609 var depths = undefined, 1610 blockParams = templateSpec.useBlockParams ? [] : undefined; 1611 if (templateSpec.useDepths) { 1612 if (options.depths) { 1613 depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths; 1614 } else { 1615 depths = [context]; 1616 } 1617 } 1618 1619 function main(context /*, options*/) { 1620 return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths); 1621 } 1622 1623 main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams); 1624 return main(context, options); 1625 } 1626 1627 ret.isTop = true; 1628 1629 ret._setup = function (options) { 1630 if (!options.partial) { 1631 var mergedHelpers = Utils.extend({}, env.helpers, options.helpers); 1632 wrapHelpersToPassLookupProperty(mergedHelpers, container); 1633 container.helpers = mergedHelpers; 1634 1635 if (templateSpec.usePartial) { 1636 // Use mergeIfNeeded here to prevent compiling global partials multiple times 1637 container.partials = container.mergeIfNeeded(options.partials, env.partials); 1638 } 1639 if (templateSpec.usePartial || templateSpec.useDecorators) { 1640 container.decorators = Utils.extend({}, env.decorators, options.decorators); 1641 } 1642
vendor: 4,708 bytes, lines 1643-1771
1643 container.hooks = {}; 1644 container.protoAccessControl = _internalProtoAccess.createProtoAccessControl(options); 1645 1646 var keepHelperInHelpers = options.allowCallsToHelperMissing || templateWasPrecompiledWithCompilerV7; 1647 _helpers.moveHelperToHooks(container, 'helperMissing', keepHelperInHelpers); 1648 _helpers.moveHelperToHooks(container, 'blockHelperMissing', keepHelperInHelpers); 1649 } else { 1650 container.protoAccessControl = options.protoAccessControl; // internal option 1651 container.helpers = options.helpers; 1652 container.partials = options.partials; 1653 container.decorators = options.decorators; 1654 container.hooks = options.hooks; 1655 } 1656 }; 1657 1658 ret._child = function (i, data, blockParams, depths) { 1659 if (templateSpec.useBlockParams && !blockParams) { 1660 throw new _exception2['default']('must pass block params'); 1661 } 1662 if (templateSpec.useDepths && !depths) { 1663 throw new _exception2['default']('must pass parent depths'); 1664 } 1665 1666 return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths); 1667 }; 1668 return ret; 1669 } 1670 1671 function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) { 1672 function prog(context) { 1673 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; 1674 1675 var currentDepths = depths; 1676 if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) { 1677 currentDepths = [context].concat(depths); 1678 } 1679 1680 return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths); 1681 } 1682 1683 prog = executeDecorators(fn, prog, container, depths, data, blockParams); 1684 1685 prog.program = i; 1686 prog.depth = depths ? depths.length : 0; 1687 prog.blockParams = declaredBlockParams || 0; 1688 return prog; 1689 } 1690 1691 /** 1692 * This is currently part of the official API, therefore implementation details should not be changed. 1693 */ 1694 1695 function resolvePartial(partial, context, options) { 1696 if (!partial) { 1697 if (options.name === '@partial-block') { 1698 partial = options.data['partial-block']; 1699 } else { 1700 partial = options.partials[options.name]; 1701 } 1702 } else if (!partial.call && !options.name) { 1703 // This is a dynamic partial that returned a string 1704 options.name = partial; 1705 partial = options.partials[partial]; 1706 } 1707 return partial; 1708 } 1709 1710 function invokePartial(partial, context, options) { 1711 // Use the current closure context to save the partial-block if this partial 1712 var currentPartialBlock = options.data && options.data['partial-block']; 1713 options.partial = true; 1714 if (options.ids) { 1715 options.data.contextPath = options.ids[0] || options.data.contextPath; 1716 } 1717 1718 var partialBlock = undefined; 1719 if (options.fn && options.fn !== noop) { 1720 (function () { 1721 options.data = _base.createFrame(options.data); 1722 // Wrapper function to get access to currentPartialBlock from the closure 1723 var fn = options.fn; 1724 partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) { 1725 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; 1726 1727 // Restore the partial-block from the closure for the execution of the block 1728 // i.e. the part inside the block of the partial call. 1729 options.data = _base.createFrame(options.data); 1730 options.data['partial-block'] = currentPartialBlock; 1731 return fn(context, options); 1732 }; 1733 if (fn.partials) { 1734 options.partials = Utils.extend({}, options.partials, fn.partials); 1735 } 1736 })(); 1737 } 1738 1739 if (partial === undefined && partialBlock) { 1740 partial = partialBlock; 1741 } 1742 1743 if (partial === undefined) { 1744 throw new _exception2['default']('The partial ' + options.name + ' could not be found'); 1745 } else if (partial instanceof Function) { 1746 return partial(context, options); 1747 } 1748 } 1749 1750 function noop() { 1751 return ''; 1752 } 1753 1754 function initData(context, data) { 1755 if (!data || !('root' in data)) { 1756 data = data ? _base.createFrame(data) : {}; 1757 data.root = context; 1758 } 1759 return data; 1760 } 1761 1762 function executeDecorators(fn, prog, container, depths, data, blockParams) { 1763 if (fn.decorator) { 1764 var props = {}; 1765 prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths); 1766 Utils.extend(prog, props); 1767 } 1768 return prog; 1769 } 1770 1771 function wrapHelpersToPassLookupProperty(mergedHelpers, container) {
vendor: 12,398 bytes, lines 1772-2076
1772 _Object$keys(mergedHelpers).forEach(function (helperName) { 1773 var helper = mergedHelpers[helperName]; 1774 mergedHelpers[helperName] = passLookupPropertyOption(helper, container); 1775 }); 1776 } 1777 1778 function passLookupPropertyOption(helper, container) { 1779 var lookupProperty = container.lookupProperty; 1780 return _internalWrapHelper.wrapHelper(helper, function (options) { 1781 return Utils.extend({ lookupProperty: lookupProperty }, options); 1782 }); 1783 } 1784 1785 /***/ }), 1786 /* 39 */ 1787 /***/ (function(module, exports, __webpack_require__) { 1788 1789 module.exports = { "default": __webpack_require__(40), __esModule: true }; 1790 1791 /***/ }), 1792 /* 40 */ 1793 /***/ (function(module, exports, __webpack_require__) { 1794 1795 __webpack_require__(41); 1796 module.exports = __webpack_require__(21).Object.seal; 1797 1798 /***/ }), 1799 /* 41 */ 1800 /***/ (function(module, exports, __webpack_require__) { 1801 1802 // 19.1.2.17 Object.seal(O) 1803 var isObject = __webpack_require__(42); 1804 1805 __webpack_require__(18)('seal', function($seal){ 1806 return function seal(it){ 1807 return $seal && isObject(it) ? $seal(it) : it; 1808 }; 1809 }); 1810 1811 /***/ }), 1812 /* 42 */ 1813 /***/ (function(module, exports) { 1814 1815 module.exports = function(it){ 1816 return typeof it === 'object' ? it !== null : typeof it === 'function'; 1817 }; 1818 1819 /***/ }), 1820 /* 43 */ 1821 /***/ (function(module, exports) { 1822 1823 'use strict'; 1824 1825 exports.__esModule = true; 1826 exports.wrapHelper = wrapHelper; 1827 1828 function wrapHelper(helper, transformOptionsFn) { 1829 if (typeof helper !== 'function') { 1830 // This should not happen, but apparently it does in https://github.com/wycats/handlebars.js/issues/1639 1831 // We try to make the wrapper least-invasive by not wrapping it, if the helper is not a function. 1832 return helper; 1833 } 1834 var wrapper = function wrapper() /* dynamic arguments */{ 1835 var options = arguments[arguments.length - 1]; 1836 arguments[arguments.length - 1] = transformOptionsFn(options); 1837 return helper.apply(this, arguments); 1838 }; 1839 return wrapper; 1840 } 1841 1842 /***/ }), 1843 /* 44 */ 1844 /***/ (function(module, exports) { 1845 1846 /* WEBPACK VAR INJECTION */(function(global) {'use strict'; 1847 1848 exports.__esModule = true; 1849 1850 exports['default'] = function (Handlebars) { 1851 /* istanbul ignore next */ 1852 var root = typeof global !== 'undefined' ? global : window, 1853 $Handlebars = root.Handlebars; 1854 /* istanbul ignore next */ 1855 Handlebars.noConflict = function () { 1856 if (root.Handlebars === Handlebars) { 1857 root.Handlebars = $Handlebars; 1858 } 1859 return Handlebars; 1860 }; 1861 }; 1862 1863 module.exports = exports['default']; 1864 /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) 1865 1866 /***/ }), 1867 /* 45 */ 1868 /***/ (function(module, exports) { 1869 1870 'use strict'; 1871 1872 exports.__esModule = true; 1873 var AST = { 1874 // Public API used to evaluate derived attributes regarding AST nodes 1875 helpers: { 1876 // a mustache is definitely a helper if: 1877 // * it is an eligible helper, and 1878 // * it has at least one parameter or hash segment 1879 helperExpression: function helperExpression(node) { 1880 return node.type === 'SubExpression' || (node.type === 'MustacheStatement' || node.type === 'BlockStatement') && !!(node.params && node.params.length || node.hash); 1881 }, 1882 1883 scopedId: function scopedId(path) { 1884 return (/^\.|this\b/.test(path.original) 1885 ); 1886 }, 1887 1888 // an ID is simple if it only has one part, and that part is not 1889 // `..` or `this`. 1890 simpleId: function simpleId(path) { 1891 return path.parts.length === 1 && !AST.helpers.scopedId(path) && !path.depth; 1892 } 1893 } 1894 }; 1895 1896 // Must be exported as an object rather than the root of the module as the jison lexer 1897 // must modify the object to operate properly. 1898 exports['default'] = AST; 1899 module.exports = exports['default']; 1900 1901 /***/ }), 1902 /* 46 */ 1903 /***/ (function(module, exports, __webpack_require__) { 1904 1905 'use strict'; 1906 1907 var _interopRequireDefault = __webpack_require__(1)['default']; 1908 1909 var _interopRequireWildcard = __webpack_require__(3)['default']; 1910 1911 exports.__esModule = true; 1912 exports.parseWithoutProcessing = parseWithoutProcessing; 1913 exports.parse = parse; 1914 1915 var _parser = __webpack_require__(47); 1916 1917 var _parser2 = _interopRequireDefault(_parser); 1918 1919 var _whitespaceControl = __webpack_require__(48); 1920 1921 var _whitespaceControl2 = _interopRequireDefault(_whitespaceControl); 1922 1923 var _helpers = __webpack_require__(50); 1924 1925 var Helpers = _interopRequireWildcard(_helpers); 1926 1927 var _utils = __webpack_require__(5); 1928 1929 exports.parser = _parser2['default']; 1930 1931 var yy = {}; 1932 _utils.extend(yy, Helpers); 1933 1934 function parseWithoutProcessing(input, options) { 1935 // Just return if an already-compiled AST was passed in. 1936 if (input.type === 'Program') { 1937 return input; 1938 } 1939 1940 _parser2['default'].yy = yy; 1941 1942 // Altering the shared object here, but this is ok as parser is a sync operation 1943 yy.locInfo = function (locInfo) { 1944 return new yy.SourceLocation(options && options.srcName, locInfo); 1945 }; 1946 1947 var ast = _parser2['default'].parse(input); 1948 1949 return ast; 1950 } 1951 1952 function parse(input, options) { 1953 var ast = parseWithoutProcessing(input, options); 1954 var strip = new _whitespaceControl2['default'](options); 1955 1956 return strip.accept(ast); 1957 } 1958 1959 /***/ }), 1960 /* 47 */ 1961 /***/ (function(module, exports) { 1962 1963 // File ignored in coverage tests via setting in .istanbul.yml 1964 /* Jison generated parser */ 1965 "use strict"; 1966 1967 exports.__esModule = true; 1968 var handlebars = (function () { 1969 var parser = { trace: function trace() {}, 1970 yy: {}, 1971 symbols_: { "error": 2, "root": 3, "program": 4, "EOF": 5, "program_repetition0": 6, "statement": 7, "mustache": 8, "block": 9, "rawBlock": 10, "partial": 11, "partialBlock": 12, "content": 13, "COMMENT": 14, "CONTENT": 15, "openRawBlock": 16, "rawBlock_repetition0": 17, "END_RAW_BLOCK": 18, "OPEN_RAW_BLOCK": 19, "helperName": 20, "openRawBlock_repetition0": 21, "openRawBlock_option0": 22, "CLOSE_RAW_BLOCK": 23, "openBlock": 24, "block_option0": 25, "closeBlock": 26, "openInverse": 27, "block_option1": 28, "OPEN_BLOCK": 29, "openBlock_repetition0": 30, "openBlock_option0": 31, "openBlock_option1": 32, "CLOSE": 33, "OPEN_INVERSE": 34, "openInverse_repetition0": 35, "openInverse_option0": 36, "openInverse_option1": 37, "openInverseChain": 38, "OPEN_INVERSE_CHAIN": 39, "openInverseChain_repetition0": 40, "openInverseChain_option0": 41, "openInverseChain_option1": 42, "inverseAndProgram": 43, "INVERSE": 44, "inverseChain": 45, "inverseChain_option0": 46, "OPEN_ENDBLOCK": 47, "OPEN": 48, "mustache_repetition0": 49, "mustache_option0": 50, "OPEN_UNESCAPED": 51, "mustache_repetition1": 52, "mustache_option1": 53, "CLOSE_UNESCAPED": 54, "OPEN_PARTIAL": 55, "partialName": 56, "partial_repetition0": 57, "partial_option0": 58, "openPartialBlock": 59, "OPEN_PARTIAL_BLOCK": 60, "openPartialBlock_repetition0": 61, "openPartialBlock_option0": 62, "param": 63, "sexpr": 64, "OPEN_SEXPR": 65, "sexpr_repetition0": 66, "sexpr_option0": 67, "CLOSE_SEXPR": 68, "hash": 69, "hash_repetition_plus0": 70, "hashSegment": 71, "ID": 72, "EQUALS": 73, "blockParams": 74, "OPEN_BLOCK_PARAMS": 75, "blockParams_repetition_plus0": 76, "CLOSE_BLOCK_PARAMS": 77, "path": 78, "dataName": 79, "STRING": 80, "NUMBER": 81, "BOOLEAN": 82, "UNDEFINED": 83, "NULL": 84, "DATA": 85, "pathSegments": 86, "SEP": 87, "$accept": 0, "$end": 1 }, 1972 terminals_: { 2: "error", 5: "EOF", 14: "COMMENT", 15: "CONTENT", 18: "END_RAW_BLOCK", 19: "OPEN_RAW_BLOCK", 23: "CLOSE_RAW_BLOCK", 29: "OPEN_BLOCK", 33: "CLOSE", 34: "OPEN_INVERSE", 39: "OPEN_INVERSE_CHAIN", 44: "INVERSE", 47: "OPEN_ENDBLOCK", 48: "OPEN", 51: "OPEN_UNESCAPED", 54: "CLOSE_UNESCAPED", 55: "OPEN_PARTIAL", 60: "OPEN_PARTIAL_BLOCK", 65: "OPEN_SEXPR", 68: "CLOSE_SEXPR", 72: "ID", 73: "EQUALS", 75: "OPEN_BLOCK_PARAMS", 77: "CLOSE_BLOCK_PARAMS", 80: "STRING", 81: "NUMBER", 82: "BOOLEAN", 83: "UNDEFINED", 84: "NULL", 85: "DATA", 87: "SEP" }, 1973 productions_: [0, [3, 2], [4, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [13, 1], [10, 3], [16, 5], [9, 4], [9, 4], [24, 6], [27, 6], [38, 6], [43, 2], [45, 3], [45, 1], [26, 3], [8, 5], [8, 5], [11, 5], [12, 3], [59, 5], [63, 1], [63, 1], [64, 5], [69, 1], [71, 3], [74, 3], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [56, 1], [56, 1], [79, 2], [78, 1], [86, 3], [86, 1], [6, 0], [6, 2], [17, 0], [17, 2], [21, 0], [21, 2], [22, 0], [22, 1], [25, 0], [25, 1], [28, 0], [28, 1], [30, 0], [30, 2], [31, 0], [31, 1], [32, 0], [32, 1], [35, 0], [35, 2], [36, 0], [36, 1], [37, 0], [37, 1], [40, 0], [40, 2], [41, 0], [41, 1], [42, 0], [42, 1], [46, 0], [46, 1], [49, 0], [49, 2], [50, 0], [50, 1], [52, 0], [52, 2], [53, 0], [53, 1], [57, 0], [57, 2], [58, 0], [58, 1], [61, 0], [61, 2], [62, 0], [62, 1], [66, 0], [66, 2], [67, 0], [67, 1], [70, 1], [70, 2], [76, 1], [76, 2]], 1974 performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) { 1975 1976 var $0 = $$.length - 1; 1977 switch (yystate) { 1978 case 1: 1979 return $$[$0 - 1]; 1980 break; 1981 case 2: 1982 this.$ = yy.prepareProgram($$[$0]); 1983 break; 1984 case 3: 1985 this.$ = $$[$0]; 1986 break; 1987 case 4: 1988 this.$ = $$[$0]; 1989 break; 1990 case 5: 1991 this.$ = $$[$0]; 1992 break; 1993 case 6: 1994 this.$ = $$[$0]; 1995 break; 1996 case 7: 1997 this.$ = $$[$0]; 1998 break; 1999 case 8: 2000 this.$ = $$[$0]; 2001 break; 2002 case 9: 2003 this.$ = { 2004 type: 'CommentStatement', 2005 value: yy.stripComment($$[$0]), 2006 strip: yy.stripFlags($$[$0], $$[$0]), 2007 loc: yy.locInfo(this._$) 2008 }; 2009 2010 break; 2011 case 10: 2012 this.$ = { 2013 type: 'ContentStatement', 2014 original: $$[$0], 2015 value: $$[$0], 2016 loc: yy.locInfo(this._$) 2017 }; 2018 2019 break; 2020 case 11: 2021 this.$ = yy.prepareRawBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$); 2022 break; 2023 case 12: 2024 this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1] }; 2025 break; 2026 case 13: 2027 this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], false, this._$); 2028 break; 2029 case 14: 2030 this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], true, this._$); 2031 break; 2032 case 15: 2033 this.$ = { open: $$[$0 - 5], path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) }; 2034 break; 2035 case 16: 2036 this.$ = { path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) }; 2037 break; 2038 case 17: 2039 this.$ = { path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) }; 2040 break; 2041 case 18: 2042 this.$ = { strip: yy.stripFlags($$[$0 - 1], $$[$0 - 1]), program: $$[$0] }; 2043 break; 2044 case 19: 2045 var inverse = yy.prepareBlock($$[$0 - 2], $$[$0 - 1], $$[$0], $$[$0], false, this._$), 2046 program = yy.prepareProgram([inverse], $$[$0 - 1].loc); 2047 program.chained = true; 2048 2049 this.$ = { strip: $$[$0 - 2].strip, program: program, chain: true }; 2050 2051 break; 2052 case 20: 2053 this.$ = $$[$0]; 2054 break; 2055 case 21: 2056 this.$ = { path: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 2], $$[$0]) }; 2057 break; 2058 case 22: 2059 this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$); 2060 break; 2061 case 23: 2062 this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$); 2063 break; 2064 case 24: 2065 this.$ = { 2066 type: 'PartialStatement', 2067 name: $$[$0 - 3], 2068 params: $$[$0 - 2], 2069 hash: $$[$0 - 1], 2070 indent: '', 2071 strip: yy.stripFlags($$[$0 - 4], $$[$0]), 2072 loc: yy.locInfo(this._$) 2073 }; 2074 2075 break; 2076 case 25:
vendor: 3,917 bytes, lines 2077-2226
2077 this.$ = yy.preparePartialBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$); 2078 break; 2079 case 26: 2080 this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 4], $$[$0]) }; 2081 break; 2082 case 27: 2083 this.$ = $$[$0]; 2084 break; 2085 case 28: 2086 this.$ = $$[$0]; 2087 break; 2088 case 29: 2089 this.$ = { 2090 type: 'SubExpression', 2091 path: $$[$0 - 3], 2092 params: $$[$0 - 2], 2093 hash: $$[$0 - 1], 2094 loc: yy.locInfo(this._$) 2095 }; 2096 2097 break; 2098 case 30: 2099 this.$ = { type: 'Hash', pairs: $$[$0], loc: yy.locInfo(this._$) }; 2100 break; 2101 case 31: 2102 this.$ = { type: 'HashPair', key: yy.id($$[$0 - 2]), value: $$[$0], loc: yy.locInfo(this._$) }; 2103 break; 2104 case 32: 2105 this.$ = yy.id($$[$0 - 1]); 2106 break; 2107 case 33: 2108 this.$ = $$[$0]; 2109 break; 2110 case 34: 2111 this.$ = $$[$0]; 2112 break; 2113 case 35: 2114 this.$ = { type: 'StringLiteral', value: $$[$0], original: $$[$0], loc: yy.locInfo(this._$) }; 2115 break; 2116 case 36: 2117 this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) }; 2118 break; 2119 case 37: 2120 this.$ = { type: 'BooleanLiteral', value: $$[$0] === 'true', original: $$[$0] === 'true', loc: yy.locInfo(this._$) }; 2121 break; 2122 case 38: 2123 this.$ = { type: 'UndefinedLiteral', original: undefined, value: undefined, loc: yy.locInfo(this._$) }; 2124 break; 2125 case 39: 2126 this.$ = { type: 'NullLiteral', original: null, value: null, loc: yy.locInfo(this._$) }; 2127 break; 2128 case 40: 2129 this.$ = $$[$0]; 2130 break; 2131 case 41: 2132 this.$ = $$[$0]; 2133 break; 2134 case 42: 2135 this.$ = yy.preparePath(true, $$[$0], this._$); 2136 break; 2137 case 43: 2138 this.$ = yy.preparePath(false, $$[$0], this._$); 2139 break; 2140 case 44: 2141 $$[$0 - 2].push({ part: yy.id($$[$0]), original: $$[$0], separator: $$[$0 - 1] });this.$ = $$[$0 - 2]; 2142 break; 2143 case 45: 2144 this.$ = [{ part: yy.id($$[$0]), original: $$[$0] }]; 2145 break; 2146 case 46: 2147 this.$ = []; 2148 break; 2149 case 47: 2150 $$[$0 - 1].push($$[$0]); 2151 break; 2152 case 48: 2153 this.$ = []; 2154 break; 2155 case 49: 2156 $$[$0 - 1].push($$[$0]); 2157 break; 2158 case 50: 2159 this.$ = []; 2160 break; 2161 case 51: 2162 $$[$0 - 1].push($$[$0]); 2163 break; 2164 case 58: 2165 this.$ = []; 2166 break; 2167 case 59: 2168 $$[$0 - 1].push($$[$0]); 2169 break; 2170 case 64: 2171 this.$ = []; 2172 break; 2173 case 65: 2174 $$[$0 - 1].push($$[$0]); 2175 break; 2176 case 70: 2177 this.$ = []; 2178 break; 2179 case 71: 2180 $$[$0 - 1].push($$[$0]); 2181 break; 2182 case 78: 2183 this.$ = []; 2184 break; 2185 case 79: 2186 $$[$0 - 1].push($$[$0]); 2187 break; 2188 case 82: 2189 this.$ = []; 2190 break; 2191 case 83: 2192 $$[$0 - 1].push($$[$0]); 2193 break; 2194 case 86: 2195 this.$ = []; 2196 break; 2197 case 87: 2198 $$[$0 - 1].push($$[$0]); 2199 break; 2200 case 90: 2201 this.$ = []; 2202 break; 2203 case 91: 2204 $$[$0 - 1].push($$[$0]); 2205 break; 2206 case 94: 2207 this.$ = []; 2208 break; 2209 case 95: 2210 $$[$0 - 1].push($$[$0]); 2211 break; 2212 case 98: 2213 this.$ = [$$[$0]]; 2214 break; 2215 case 99: 2216 $$[$0 - 1].push($$[$0]); 2217 break; 2218 case 100: 2219 this.$ = [$$[$0]]; 2220 break; 2221 case 101: 2222 $$[$0 - 1].push($$[$0]); 2223 break; 2224 } 2225 }, 2226
vendor: 14,905 bytes, line 2226
2226table: [{ 3: 1, 4: 2, 5: [2, 46], 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 1: [3] }, { 5: [1, 4] }, { 5: [2, 2], 7: 5, 8: 6, 9: 7, 10: 8, 11: 9, 12: 10, 13: 11, 14: [1, 12], 15: [1, 20], 16: 17, 19: [1, 23], 24: 15, 27: 16, 29: [1, 21], 34: [1, 22], 39: [2, 2], 44: [2, 2], 47: [2, 2], 48: [1, 13], 51: [1, 14], 55: [1, 18], 59: 19, 60: [1, 24] }, { 1: [2, 1] }, { 5: [2, 47], 14: [2, 47], 15: [2, 47], 19: [2, 47], 29: [2, 47], 34: [2, 47], 39: [2, 47], 44: [2, 47], 47: [2, 47], 48: [2, 47], 51: [2, 47], 55: [2, 47], 60: [2, 47] }, { 5: [2, 3], 14: [2, 3], 15: [2, 3], 19: [2, 3], 29: [2, 3], 34: [2, 3], 39: [2, 3], 44: [2, 3], 47: [2, 3], 48: [2, 3], 51: [2, 3], 55: [2, 3], 60: [2, 3] }, { 5: [2, 4], 14: [2, 4], 15: [2, 4], 19: [2, 4], 29: [2, 4], 34: [2, 4], 39: [2, 4], 44: [2, 4], 47: [2, 4], 48: [2, 4], 51: [2, 4], 55: [2, 4], 60: [2, 4] }, { 5: [2, 5], 14: [2, 5], 15: [2, 5], 19: [2, 5], 29: [2, 5], 34: [2, 5], 39: [2, 5], 44: [2, 5], 47: [2, 5], 48: [2, 5], 51: [2, 5], 55: [2, 5], 60: [2, 5] }, { 5: [2, 6], 14: [2, 6], 15: [2, 6], 19: [2, 6], 29: [2, 6], 34: [2, 6], 39: [2, 6], 44: [2, 6], 47: [2, 6], 48: [2, 6], 51: [2, 6], 55: [2, 6], 60: [2, 6] }, { 5: [2, 7], 14: [2, 7], 15: [2, 7], 19: [2, 7], 29: [2, 7], 34: [2, 7], 39: [2, 7], 44: [2, 7], 47: [2, 7], 48: [2, 7], 51: [2, 7], 55: [2, 7], 60: [2, 7] }, { 5: [2, 8], 14: [2, 8], 15: [2, 8], 19: [2, 8], 29: [2, 8], 34: [2, 8], 39: [2, 8], 44: [2, 8], 47: [2, 8], 48: [2, 8], 51: [2, 8], 55: [2, 8], 60: [2, 8] }, { 5: [2, 9], 14: [2, 9], 15: [2, 9], 19: [2, 9], 29: [2, 9], 34: [2, 9], 39: [2, 9], 44: [2, 9], 47: [2, 9], 48: [2, 9], 51: [2, 9], 55: [2, 9], 60: [2, 9] }, { 20: 25, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 36, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 37, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 39: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 4: 38, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 15: [2, 48], 17: 39, 18: [2, 48] }, { 20: 41, 56: 40, 64: 42, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 44, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 5: [2, 10], 14: [2, 10], 15: [2, 10], 18: [2, 10], 19: [2, 10], 29: [2, 10], 34: [2, 10], 39: [2, 10], 44: [2, 10], 47: [2, 10], 48: [2, 10], 51: [2, 10], 55: [2, 10], 60: [2, 10] }, { 20: 45, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 46, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 47, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 41, 56: 48, 64: 42, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [2, 78], 49: 49, 65: [2, 78], 72: [2, 78], 80: [2, 78], 81: [2, 78], 82: [2, 78], 83: [2, 78], 84: [2, 78], 85: [2, 78] }, { 23: [2, 33], 33: [2, 33], 54: [2, 33], 65: [2, 33], 68: [2, 33], 72: [2, 33], 75: [2, 33], 80: [2, 33], 81: [2, 33], 82: [2, 33], 83: [2, 33], 84: [2, 33], 85: [2, 33] }, { 23: [2, 34], 33: [2, 34], 54: [2, 34], 65: [2, 34], 68: [2, 34], 72: [2, 34], 75: [2, 34], 80: [2, 34], 81: [2, 34], 82: [2, 34], 83: [2, 34], 84: [2, 34], 85: [2, 34] }, { 23: [2, 35], 33: [2, 35], 54: [2, 35], 65: [2, 35], 68: [2, 35], 72: [2, 35], 75: [2, 35], 80: [2, 35], 81: [2, 35], 82: [2, 35], 83: [2, 35], 84: [2, 35], 85: [2, 35] }, { 23: [2, 36], 33: [2, 36], 54: [2, 36], 65: [2, 36], 68: [2, 36], 72: [2, 36], 75: [2, 36], 80: [2, 36], 81: [2, 36], 82: [2, 36], 83: [2, 36], 84: [2, 36], 85: [2, 36] }, { 23: [2, 37], 33: [2, 37], 54: [2, 37], 65: [2, 37], 68: [2, 37], 72: [2, 37], 75: [2, 37], 80: [2, 37], 81: [2, 37], 82: [2, 37], 83: [2, 37], 84: [2, 37], 85: [2, 37] }, { 23: [2, 38], 33: [2, 38], 54: [2, 38], 65: [2, 38], 68: [2, 38], 72: [2, 38], 75: [2, 38], 80: [2, 38], 81: [2, 38], 82: [2, 38], 83: [2, 38], 84: [2, 38], 85: [2, 38] }, { 23: [2, 39], 33: [2, 39], 54: [2, 39], 65: [2, 39], 68: [2, 39], 72: [2, 39], 75: [2, 39], 80: [2, 39], 81: [2, 39], 82: [2, 39], 83: [2, 39], 84: [2, 39], 85: [2, 39] }, { 23: [2, 43], 33: [2, 43], 54: [2, 43], 65: [2, 43], 68: [2, 43], 72: [2, 43], 75: [2, 43], 80: [2, 43], 81: [2, 43], 82: [2, 43], 83: [2, 43], 84: [2, 43], 85: [2, 43], 87: [1, 50] }, { 72: [1, 35], 86: 51 }, { 23: [2, 45], 33: [2, 45], 54: [2, 45], 65: [2, 45], 68: [2, 45], 72: [2, 45], 75: [2, 45], 80: [2, 45], 81: [2, 45], 82: [2, 45], 83: [2, 45], 84: [2, 45], 85: [2, 45], 87: [2, 45] }, { 52: 52, 54: [2, 82], 65: [2, 82], 72: [2, 82], 80: [2, 82], 81: [2, 82], 82: [2, 82], 83: [2, 82], 84: [2, 82], 85: [2, 82] }, { 25: 53, 38: 55, 39: [1, 57], 43: 56, 44: [1, 58], 45: 54, 47: [2, 54] }, { 28: 59, 43: 60, 44: [1, 58], 47: [2, 56] }, { 13: 62, 15: [1, 20], 18: [1, 61] }, { 33: [2, 86], 57: 63, 65: [2, 86], 72: [2, 86], 80: [2, 86], 81: [2, 86], 82: [2, 86], 83: [2, 86], 84: [2, 86], 85: [2, 86] }, { 33: [2, 40], 65: [2, 40], 72: [2, 40], 80: [2, 40], 81: [2, 40], 82: [2, 40], 83: [2, 40], 84: [2, 40], 85: [2, 40] }, { 33: [2, 41], 65: [2, 41], 72: [2, 41], 80: [2, 41], 81: [2, 41], 82: [2, 41], 83: [2, 41], 84: [2, 41], 85: [2, 41] }, { 20: 64, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 26: 65, 47: [1, 66] }, { 30: 67, 33: [2, 58], 65: [2, 58], 72: [2, 58], 75: [2, 58], 80: [2, 58], 81: [2, 58], 82: [2, 58], 83: [2, 58], 84: [2, 58], 85: [2, 58] }, { 33: [2, 64], 35: 68, 65: [2, 64], 72: [2, 64], 75: [2, 64], 80: [2, 64], 81: [2, 64], 82: [2, 64], 83: [2, 64], 84: [2, 64], 85: [2, 64] }, { 21: 69, 23: [2, 50], 65: [2, 50], 72: [2, 50], 80: [2, 50], 81: [2, 50], 82: [2, 50], 83: [2, 50], 84: [2, 50], 85: [2, 50] }, { 33: [2, 90], 61: 70, 65: [2, 90], 72: [2, 90], 80: [2, 90], 81: [2, 90], 82: [2, 90], 83: [2, 90], 84: [2, 90], 85: [2, 90] }, { 20: 74, 33: [2, 80], 50: 71, 63: 72, 64: 75, 65: [1, 43], 69: 73, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 72: [1, 79] }, { 23: [2, 42], 33: [2, 42], 54: [2, 42], 65: [2, 42], 68: [2, 42], 72: [2, 42], 75: [2, 42], 80: [2, 42], 81: [2, 42], 82: [2, 42], 83: [2, 42], 84: [2, 42], 85: [2, 42], 87: [1, 50] }, { 20: 74, 53: 80, 54: [2, 84], 63: 81, 64: 75, 65: [1, 43], 69: 82, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 26: 83, 47: [1, 66] }, { 47: [2, 55] }, { 4: 84, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 39: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 47: [2, 20] }, { 20: 85, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 86, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 26: 87, 47: [1, 66] }, { 47: [2, 57] }, { 5: [2, 11], 14: [2, 11], 15: [2, 11], 19: [2, 11], 29: [2, 11], 34: [2, 11], 39: [2, 11], 44: [2, 11], 47: [2, 11], 48: [2, 11], 51: [2, 11], 55: [2, 11], 60: [2, 11] }, { 15: [2, 49], 18: [2, 49] }, { 20: 74, 33: [2, 88], 58: 88, 63: 89, 64: 75, 65: [1, 43], 69: 90, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 65: [2, 94], 66: 91, 68: [2, 94], 72: [2, 94], 80: [2, 94], 81: [2, 94], 82: [2, 94], 83: [2, 94], 84: [2, 94], 85: [2, 94] }, { 5: [2, 25], 14: [2, 25], 15: [2, 25], 19: [2, 25], 29: [2, 25], 34: [2, 25], 39: [2, 25], 44: [2, 25], 47: [2, 25], 48: [2, 25], 51: [2, 25], 55: [2, 25], 60: [2, 25] }, { 20: 92, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 31: 93, 33: [2, 60], 63: 94, 64: 75, 65: [1, 43], 69: 95, 70: 76, 71: 77, 72: [1, 78], 75: [2, 60], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 33: [2, 66], 36: 96, 63: 97, 64: 75, 65: [1, 43], 69: 98, 70: 76, 71: 77, 72: [1, 78], 75: [2, 66], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 22: 99, 23: [2, 52], 63: 100, 64: 75, 65: [1, 43], 69: 101, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 33: [2, 92], 62: 102, 63: 103, 64: 75, 65: [1, 43], 69: 104, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [1, 105] }, { 33: [2, 79], 65: [2, 79], 72: [2, 79], 80: [2, 79], 81: [2, 79], 82: [2, 79], 83: [2, 79], 84: [2, 79], 85: [2, 79] }, { 33: [2, 81] }, { 23: [2, 27], 33: [2, 27], 54: [2, 27], 65: [2, 27], 68: [2, 27], 72: [2, 27], 75: [2, 27], 80: [2, 27], 81: [2, 27], 82: [2, 27], 83: [2, 27], 84: [2, 27], 85: [2, 27] }, { 23: [2, 28], 33: [2, 28], 54: [2, 28], 65: [2, 28], 68: [2, 28], 72: [2, 28], 75: [2, 28], 80: [2, 28], 81: [2, 28], 82: [2, 28], 83: [2, 28], 84: [2, 28], 85: [2, 28] }, { 23: [2, 30], 33: [2, 30], 54: [2, 30], 68: [2, 30], 71: 106, 72: [1, 107], 75: [2, 30] }, { 23: [2, 98], 33: [2, 98], 54: [2, 98], 68: [2, 98], 72: [2, 98], 75: [2, 98] }, { 23: [2, 45], 33: [2, 45], 54: [2, 45], 65: [2, 45], 68: [2, 45], 72: [2, 45], 73: [1, 108], 75: [2, 45], 80: [2, 45], 81: [2, 45], 82: [2, 45], 83: [2, 45], 84: [2, 45], 85: [2, 45], 87: [2, 45] }, { 23: [2, 44], 33: [2, 44], 54: [2, 44], 65: [2, 44], 68: [2, 44], 72: [2, 44], 75: [2, 44], 80: [2, 44], 81: [2, 44], 82: [2, 44], 83: [2, 44], 84: [2, 44], 85: [2, 44], 87: [2, 44] }, { 54: [1, 109] }, { 54: [2, 83], 65: [2, 83], 72: [2, 83], 80: [2, 83], 81: [2, 83], 82: [2, 83], 83: [2, 83], 84: [2, 83], 85: [2, 83] }, { 54: [2, 85] }, { 5: [2, 13], 14: [2, 13], 15: [2, 13], 19: [2, 13], 29: [2, 13], 34: [2, 13], 39: [2, 13], 44: [2, 13], 47: [2, 13], 48: [2, 13], 51: [2, 13], 55: [2, 13], 60: [2, 13] }, { 38: 55, 39: [1, 57], 43: 56, 44: [1, 58], 45: 111, 46: 110, 47: [2, 76] }, { 33: [2, 70], 40: 112, 65: [2, 70], 72: [2, 70], 75: [2, 70], 80: [2, 70], 81: [2, 70], 82: [2, 70], 83: [2, 70], 84: [2, 70], 85: [2, 70] }, { 47: [2, 18] }, { 5: [2, 14], 14: [2, 14], 15: [2, 14], 19: [2, 14], 29: [2, 14], 34: [2, 14], 39: [2, 14], 44: [2, 14], 47: [2, 14], 48: [2, 14], 51: [2, 14], 55: [2, 14], 60: [2, 14] }, { 33: [1, 113] }, { 33: [2, 87], 65: [2, 87], 72: [2, 87], 80: [2, 87], 81: [2, 87], 82: [2, 87], 83: [2, 87], 84: [2, 87], 85: [2, 87] }, { 33: [2, 89] }, { 20: 74, 63: 115, 64: 75, 65: [1, 43], 67: 114, 68: [2, 96], 69: 116, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [1, 117] }, { 32: 118, 33: [2, 62], 74: 119, 75: [1, 120] }, { 33: [2, 59], 65: [2, 59], 72: [2, 59], 75: [2, 59], 80: [2, 59], 81: [2, 59], 82: [2, 59], 83: [2, 59], 84: [2, 59], 85: [2, 59] }, { 33: [2, 61], 75: [2, 61] }, { 33: [2, 68], 37: 121, 74: 122, 75: [1, 120] }, { 33: [2, 65], 65: [2, 65], 72: [2, 65], 75: [2, 65], 80: [2, 65], 81: [2, 65], 82: [2, 65], 83: [2, 65], 84: [2, 65], 85: [2, 65] }, { 33: [2, 67], 75: [2, 67] }, { 23: [1, 123] }, { 23: [2, 51], 65: [2, 51], 72: [2, 51], 80: [2, 51], 81: [2, 51], 82: [2, 51], 83: [2, 51], 84: [2, 51], 85: [2, 51] }, { 23: [2, 53] }, { 33: [1, 124] }, { 33: [2, 91], 65: [2, 91], 72: [2, 91], 80: [2, 91], 81: [2, 91], 82: [2, 91], 83: [2, 91], 84: [2, 91], 85: [2, 91] }, { 33: [2, 93] }, { 5: [2, 22], 14: [2, 22], 15: [2, 22], 19: [2, 22], 29: [2, 22], 34: [2, 22], 39: [2, 22], 44: [2, 22], 47: [2, 22], 48: [2, 22], 51: [2, 22], 55: [2, 22], 60: [2, 22] }, { 23: [2, 99], 33: [2, 99], 54: [2, 99], 68: [2, 99], 72: [2, 99], 75: [2, 99] }, { 73: [1, 108] }, { 20: 74, 63: 125, 64: 75, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 5: [2, 23], 14: [2, 23], 15: [2, 23], 19: [2, 23], 29: [2, 23], 34: [2, 23], 39: [2, 23], 44: [2, 23], 47: [2, 23], 48: [2, 23], 51: [2, 23], 55: [2, 23], 60: [2, 23] }, { 47: [2, 19] }, { 47: [2, 77] }, { 20: 74, 33: [2, 72], 41: 126, 63: 127, 64: 75, 65: [1, 43], 69: 128, 70: 76, 71: 77, 72: [1, 78], 75: [2, 72], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 5: [2, 24], 14: [2, 24], 15: [2, 24], 19: [2, 24], 29: [2, 24], 34: [2, 24], 39: [2, 24], 44: [2, 24], 47: [2, 24], 48: [2, 24], 51: [2, 24], 55: [2, 24], 60: [2, 24] }, { 68: [1, 129] }, { 65: [2, 95], 68: [2, 95], 72: [2, 95], 80: [2, 95], 81: [2, 95], 82: [2, 95], 83: [2, 95], 84: [2, 95], 85: [2, 95] }, { 68: [2, 97] }, { 5: [2, 21], 14: [2, 21], 15: [2, 21], 19: [2, 21], 29: [2, 21], 34: [2, 21], 39: [2, 21], 44: [2, 21], 47: [2, 21], 48: [2, 21], 51: [2, 21], 55: [2, 21], 60: [2, 21] }, { 33: [1, 130] }, { 33: [2, 63] }, { 72: [1, 132], 76: 131 }, { 33: [1, 133] }, { 33: [2, 69] }, { 15: [2, 12], 18: [2, 12] }, { 14: [2, 26], 15: [2, 26], 19: [2, 26], 29: [2, 26], 34: [2, 26], 47: [2, 26], 48: [2, 26], 51: [2, 26], 55: [2, 26], 60: [2, 26] }, { 23: [2, 31], 33: [2, 31], 54: [2, 31], 68: [2, 31], 72: [2, 31], 75: [2, 31] }, { 33: [2, 74], 42: 134, 74: 135, 75: [1, 120] }, { 33: [2, 71], 65: [2, 71], 72: [2, 71], 75: [2, 71], 80: [2, 71], 81: [2, 71], 82: [2, 71], 83: [2, 71], 84: [2, 71], 85: [2, 71] }, { 33: [2, 73], 75: [2, 73] }, { 23: [2, 29], 33: [2, 29], 54: [2, 29], 65: [2, 29], 68: [2, 29], 72: [2, 29], 75: [2, 29], 80: [2, 29], 81: [2, 29], 82: [2, 29], 83: [2, 29], 84: [2, 29], 85: [2, 29] }, { 14: [2, 15], 15: [2, 15], 19: [2, 15], 29: [2, 15], 34: [2, 15], 39: [2, 15], 44: [2, 15], 47: [2, 15], 48: [2, 15], 51: [2, 15], 55: [2, 15], 60: [2, 15] }, { 72: [1, 137], 77: [1, 136] }, { 72: [2, 100], 77: [2, 100] }, { 14: [2, 16], 15: [2, 16], 19: [2, 16], 29: [2, 16], 34: [2, 16], 44: [2, 16], 47: [2, 16], 48: [2, 16], 51: [2, 16], 55: [2, 16], 60: [2, 16] }, { 33: [1, 138] }, { 33: [2, 75] }, { 33: [2, 32] }, { 72: [2, 101], 77: [2, 101] }, { 14: [2, 17], 15: [2, 17], 19: [2, 17], 29: [2, 17], 34: [2, 17], 39: [2, 17], 44: [2, 17], 47: [2, 17], 48: [2, 17], 51: [2, 17], 55: [2, 17], 60: [2, 17] }],
vendor: 16,107 bytes, lines 2227-2690
2227 defaultActions: { 4: [2, 1], 54: [2, 55], 56: [2, 20], 60: [2, 57], 73: [2, 81], 82: [2, 85], 86: [2, 18], 90: [2, 89], 101: [2, 53], 104: [2, 93], 110: [2, 19], 111: [2, 77], 116: [2, 97], 119: [2, 63], 122: [2, 69], 135: [2, 75], 136: [2, 32] }, 2228 parseError: function parseError(str, hash) { 2229 throw new Error(str); 2230 }, 2231 parse: function parse(input) { 2232 var self = this, 2233 stack = [0], 2234 vstack = [null], 2235 lstack = [], 2236 table = this.table, 2237 yytext = "", 2238 yylineno = 0, 2239 yyleng = 0, 2240 recovering = 0, 2241 TERROR = 2, 2242 EOF = 1; 2243 this.lexer.setInput(input); 2244 this.lexer.yy = this.yy; 2245 this.yy.lexer = this.lexer; 2246 this.yy.parser = this; 2247 if (typeof this.lexer.yylloc == "undefined") this.lexer.yylloc = {}; 2248 var yyloc = this.lexer.yylloc; 2249 lstack.push(yyloc); 2250 var ranges = this.lexer.options && this.lexer.options.ranges; 2251 if (typeof this.yy.parseError === "function") this.parseError = this.yy.parseError; 2252 function popStack(n) { 2253 stack.length = stack.length - 2 * n; 2254 vstack.length = vstack.length - n; 2255 lstack.length = lstack.length - n; 2256 } 2257 function lex() { 2258 var token; 2259 token = self.lexer.lex() || 1; 2260 if (typeof token !== "number") { 2261 token = self.symbols_[token] || token; 2262 } 2263 return token; 2264 } 2265 var symbol, 2266 preErrorSymbol, 2267 state, 2268 action, 2269 a, 2270 r, 2271 yyval = {}, 2272 p, 2273 len, 2274 newState, 2275 expected; 2276 while (true) { 2277 state = stack[stack.length - 1]; 2278 if (this.defaultActions[state]) { 2279 action = this.defaultActions[state]; 2280 } else { 2281 if (symbol === null || typeof symbol == "undefined") { 2282 symbol = lex(); 2283 } 2284 action = table[state] && table[state][symbol]; 2285 } 2286 if (typeof action === "undefined" || !action.length || !action[0]) { 2287 var errStr = ""; 2288 if (!recovering) { 2289 expected = []; 2290 for (p in table[state]) if (this.terminals_[p] && p > 2) { 2291 expected.push("'" + this.terminals_[p] + "'"); 2292 } 2293 if (this.lexer.showPosition) { 2294 errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; 2295 } else { 2296 errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'"); 2297 } 2298 this.parseError(errStr, { text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected }); 2299 } 2300 } 2301 if (action[0] instanceof Array && action.length > 1) { 2302 throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol); 2303 } 2304 switch (action[0]) { 2305 case 1: 2306 stack.push(symbol); 2307 vstack.push(this.lexer.yytext); 2308 lstack.push(this.lexer.yylloc); 2309 stack.push(action[1]); 2310 symbol = null; 2311 if (!preErrorSymbol) { 2312 yyleng = this.lexer.yyleng; 2313 yytext = this.lexer.yytext; 2314 yylineno = this.lexer.yylineno; 2315 yyloc = this.lexer.yylloc; 2316 if (recovering > 0) recovering--; 2317 } else { 2318 symbol = preErrorSymbol; 2319 preErrorSymbol = null; 2320 } 2321 break; 2322 case 2: 2323 len = this.productions_[action[1]][1]; 2324 yyval.$ = vstack[vstack.length - len]; 2325 yyval._$ = { first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column }; 2326 if (ranges) { 2327 yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]]; 2328 } 2329 r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); 2330 if (typeof r !== "undefined") { 2331 return r; 2332 } 2333 if (len) { 2334 stack = stack.slice(0, -1 * len * 2); 2335 vstack = vstack.slice(0, -1 * len); 2336 lstack = lstack.slice(0, -1 * len); 2337 } 2338 stack.push(this.productions_[action[1]][0]); 2339 vstack.push(yyval.$); 2340 lstack.push(yyval._$); 2341 newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; 2342 stack.push(newState); 2343 break; 2344 case 3: 2345 return true; 2346 } 2347 } 2348 return true; 2349 } 2350 }; 2351 /* Jison generated lexer */ 2352 var lexer = (function () { 2353 var lexer = { EOF: 1, 2354 parseError: function parseError(str, hash) { 2355 if (this.yy.parser) { 2356 this.yy.parser.parseError(str, hash); 2357 } else { 2358 throw new Error(str); 2359 } 2360 }, 2361 setInput: function setInput(input) { 2362 this._input = input; 2363 this._more = this._less = this.done = false; 2364 this.yylineno = this.yyleng = 0; 2365 this.yytext = this.matched = this.match = ''; 2366 this.conditionStack = ['INITIAL']; 2367 this.yylloc = { first_line: 1, first_column: 0, last_line: 1, last_column: 0 }; 2368 if (this.options.ranges) this.yylloc.range = [0, 0]; 2369 this.offset = 0; 2370 return this; 2371 }, 2372 input: function input() { 2373 var ch = this._input[0]; 2374 this.yytext += ch; 2375 this.yyleng++; 2376 this.offset++; 2377 this.match += ch; 2378 this.matched += ch; 2379 var lines = ch.match(/(?:\r\n?|\n).*/g); 2380 if (lines) { 2381 this.yylineno++; 2382 this.yylloc.last_line++; 2383 } else { 2384 this.yylloc.last_column++; 2385 } 2386 if (this.options.ranges) this.yylloc.range[1]++; 2387 2388 this._input = this._input.slice(1); 2389 return ch; 2390 }, 2391 unput: function unput(ch) { 2392 var len = ch.length; 2393 var lines = ch.split(/(?:\r\n?|\n)/g); 2394 2395 this._input = ch + this._input; 2396 this.yytext = this.yytext.substr(0, this.yytext.length - len - 1); 2397 //this.yyleng -= len; 2398 this.offset -= len; 2399 var oldLines = this.match.split(/(?:\r\n?|\n)/g); 2400 this.match = this.match.substr(0, this.match.length - 1); 2401 this.matched = this.matched.substr(0, this.matched.length - 1); 2402 2403 if (lines.length - 1) this.yylineno -= lines.length - 1; 2404 var r = this.yylloc.range; 2405 2406 this.yylloc = { first_line: this.yylloc.first_line, 2407 last_line: this.yylineno + 1, 2408 first_column: this.yylloc.first_column, 2409 last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len 2410 }; 2411 2412 if (this.options.ranges) { 2413 this.yylloc.range = [r[0], r[0] + this.yyleng - len]; 2414 } 2415 return this; 2416 }, 2417 more: function more() { 2418 this._more = true; 2419 return this; 2420 }, 2421 less: function less(n) { 2422 this.unput(this.match.slice(n)); 2423 }, 2424 pastInput: function pastInput() { 2425 var past = this.matched.substr(0, this.matched.length - this.match.length); 2426 return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, ""); 2427 }, 2428 upcomingInput: function upcomingInput() { 2429 var next = this.match; 2430 if (next.length < 20) { 2431 next += this._input.substr(0, 20 - next.length); 2432 } 2433 return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, ""); 2434 }, 2435 showPosition: function showPosition() { 2436 var pre = this.pastInput(); 2437 var c = new Array(pre.length + 1).join("-"); 2438 return pre + this.upcomingInput() + "\n" + c + "^"; 2439 }, 2440 next: function next() { 2441 if (this.done) { 2442 return this.EOF; 2443 } 2444 if (!this._input) this.done = true; 2445 2446 var token, match, tempMatch, index, col, lines; 2447 if (!this._more) { 2448 this.yytext = ''; 2449 this.match = ''; 2450 } 2451 var rules = this._currentRules(); 2452 for (var i = 0; i < rules.length; i++) { 2453 tempMatch = this._input.match(this.rules[rules[i]]); 2454 if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { 2455 match = tempMatch; 2456 index = i; 2457 if (!this.options.flex) break; 2458 } 2459 } 2460 if (match) { 2461 lines = match[0].match(/(?:\r\n?|\n).*/g); 2462 if (lines) this.yylineno += lines.length; 2463 this.yylloc = { first_line: this.yylloc.last_line, 2464 last_line: this.yylineno + 1, 2465 first_column: this.yylloc.last_column, 2466 last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length }; 2467 this.yytext += match[0]; 2468 this.match += match[0]; 2469 this.matches = match; 2470 this.yyleng = this.yytext.length; 2471 if (this.options.ranges) { 2472 this.yylloc.range = [this.offset, this.offset += this.yyleng]; 2473 } 2474 this._more = false; 2475 this._input = this._input.slice(match[0].length); 2476 this.matched += match[0]; 2477 token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length - 1]); 2478 if (this.done && this._input) this.done = false; 2479 if (token) return token;else return; 2480 } 2481 if (this._input === "") { 2482 return this.EOF; 2483 } else { 2484 return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), { text: "", token: null, line: this.yylineno }); 2485 } 2486 }, 2487 lex: function lex() { 2488 var r = this.next(); 2489 if (typeof r !== 'undefined') { 2490 return r; 2491 } else { 2492 return this.lex(); 2493 } 2494 }, 2495 begin: function begin(condition) { 2496 this.conditionStack.push(condition); 2497 }, 2498 popState: function popState() { 2499 return this.conditionStack.pop(); 2500 }, 2501 _currentRules: function _currentRules() { 2502 return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; 2503 }, 2504 topState: function topState() { 2505 return this.conditionStack[this.conditionStack.length - 2]; 2506 }, 2507 pushState: function begin(condition) { 2508 this.begin(condition); 2509 } }; 2510 lexer.options = {}; 2511 lexer.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { 2512 2513 function strip(start, end) { 2514 return yy_.yytext = yy_.yytext.substring(start, yy_.yyleng - end + start); 2515 } 2516 2517 var YYSTATE = YY_START; 2518 switch ($avoiding_name_collisions) { 2519 case 0: 2520 if (yy_.yytext.slice(-2) === "\\\\") { 2521 strip(0, 1); 2522 this.begin("mu"); 2523 } else if (yy_.yytext.slice(-1) === "\\") { 2524 strip(0, 1); 2525 this.begin("emu"); 2526 } else { 2527 this.begin("mu"); 2528 } 2529 if (yy_.yytext) return 15; 2530 2531 break; 2532 case 1: 2533 return 15; 2534 break; 2535 case 2: 2536 this.popState(); 2537 return 15; 2538 2539 break; 2540 case 3: 2541 this.begin('raw');return 15; 2542 break; 2543 case 4: 2544 this.popState(); 2545 // Should be using `this.topState()` below, but it currently 2546 // returns the second top instead of the first top. Opened an 2547 // issue about it at https://github.com/zaach/jison/issues/291 2548 if (this.conditionStack[this.conditionStack.length - 1] === 'raw') { 2549 return 15; 2550 } else { 2551 strip(5, 9); 2552 return 'END_RAW_BLOCK'; 2553 } 2554 2555 break; 2556 case 5: 2557 return 15; 2558 break; 2559 case 6: 2560 this.popState(); 2561 return 14; 2562 2563 break; 2564 case 7: 2565 return 65; 2566 break; 2567 case 8: 2568 return 68; 2569 break; 2570 case 9: 2571 return 19; 2572 break; 2573 case 10: 2574 this.popState(); 2575 this.begin('raw'); 2576 return 23; 2577 2578 break; 2579 case 11: 2580 return 55; 2581 break; 2582 case 12: 2583 return 60; 2584 break; 2585 case 13: 2586 return 29; 2587 break; 2588 case 14: 2589 return 47; 2590 break; 2591 case 15: 2592 this.popState();return 44; 2593 break; 2594 case 16: 2595 this.popState();return 44; 2596 break; 2597 case 17: 2598 return 34; 2599 break; 2600 case 18: 2601 return 39; 2602 break; 2603 case 19: 2604 return 51; 2605 break; 2606 case 20: 2607 return 48; 2608 break; 2609 case 21: 2610 this.unput(yy_.yytext); 2611 this.popState(); 2612 this.begin('com'); 2613 2614 break; 2615 case 22: 2616 this.popState(); 2617 return 14; 2618 2619 break; 2620 case 23: 2621 return 48; 2622 break; 2623 case 24: 2624 return 73; 2625 break; 2626 case 25: 2627 return 72; 2628 break; 2629 case 26: 2630 return 72; 2631 break; 2632 case 27: 2633 return 87; 2634 break; 2635 case 28: 2636 // ignore whitespace 2637 break; 2638 case 29: 2639 this.popState();return 54; 2640 break; 2641 case 30: 2642 this.popState();return 33; 2643 break; 2644 case 31: 2645 yy_.yytext = strip(1, 2).replace(/\\"/g, '"');return 80; 2646 break; 2647 case 32: 2648 yy_.yytext = strip(1, 2).replace(/\\'/g, "'");return 80; 2649 break; 2650 case 33: 2651 return 85; 2652 break; 2653 case 34: 2654 return 82; 2655 break; 2656 case 35: 2657 return 82; 2658 break; 2659 case 36: 2660 return 83; 2661 break; 2662 case 37: 2663 return 84; 2664 break; 2665 case 38: 2666 return 81; 2667 break; 2668 case 39: 2669 return 75; 2670 break; 2671 case 40: 2672 return 77; 2673 break; 2674 case 41: 2675 return 72; 2676 break; 2677 case 42: 2678 yy_.yytext = yy_.yytext.replace(/\\([\\\]])/g, '$1');return 72; 2679 break; 2680 case 43: 2681 return 'INVALID'; 2682 break; 2683 case 44: 2684 return 5; 2685 break; 2686 } 2687 }; 2688 lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/, /^(?:[^\x00]+)/, /^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/, /^(?:\{\{\{\{(?=[^\/]))/, /^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/, /^(?:[^\x00]+?(?=(\{\{\{\{)))/, /^(?:[\s\S]*?--(~)?\}\})/, /^(?:\()/, /^(?:\))/, /^(?:\{\{\{\{)/, /^(?:\}\}\}\})/, /^(?:\{\{(~)?>)/, /^(?:\{\{(~)?#>)/, /^(?:\{\{(~)?#\*?)/, /^(?:\{\{(~)?\/)/, /^(?:\{\{(~)?\^\s*(~)?\}\})/, /^(?:\{\{(~)?\s*else\s*(~)?\}\})/, /^(?:\{\{(~)?\^)/, /^(?:\{\{(~)?\s*else\b)/, /^(?:\{\{(~)?\{)/, /^(?:\{\{(~)?&)/, /^(?:\{\{(~)?!--)/, /^(?:\{\{(~)?![\s\S]*?\}\})/, /^(?:\{\{(~)?\*?)/, /^(?:=)/, /^(?:\.\.)/, /^(?:\.(?=([=~}\s\/.)|])))/, /^(?:[\/.])/, /^(?:\s+)/, /^(?:\}(~)?\}\})/, /^(?:(~)?\}\})/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:@)/, /^(?:true(?=([~}\s)])))/, /^(?:false(?=([~}\s)])))/, /^(?:undefined(?=([~}\s)])))/, /^(?:null(?=([~}\s)])))/, /^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/, /^(?:as\s+\|)/, /^(?:\|)/, /^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)|]))))/, /^(?:\[(\\\]|[^\]])*\])/, /^(?:.)/, /^(?:$)/]; 2689 lexer.conditions = { "mu": { "rules": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44], "inclusive": false }, "emu": { "rules": [2], "inclusive": false }, "com": { "rules": [6], "inclusive": false }, "raw": { "rules": [3, 4, 5], "inclusive": false }, "INITIAL": { "rules": [0, 1, 44], "inclusive": true } }; 2690 return lexer;
vendor: 14,092 bytes, lines 2691-3168
2691 })(); 2692 parser.lexer = lexer; 2693 function Parser() { 2694 this.yy = {}; 2695 }Parser.prototype = parser;parser.Parser = Parser; 2696 return new Parser(); 2697 })();exports["default"] = handlebars; 2698 module.exports = exports["default"]; 2699 2700 /***/ }), 2701 /* 48 */ 2702 /***/ (function(module, exports, __webpack_require__) { 2703 2704 'use strict'; 2705 2706 var _interopRequireDefault = __webpack_require__(1)['default']; 2707 2708 exports.__esModule = true; 2709 2710 var _visitor = __webpack_require__(49); 2711 2712 var _visitor2 = _interopRequireDefault(_visitor); 2713 2714 function WhitespaceControl() { 2715 var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; 2716 2717 this.options = options; 2718 } 2719 WhitespaceControl.prototype = new _visitor2['default'](); 2720 2721 WhitespaceControl.prototype.Program = function (program) { 2722 var doStandalone = !this.options.ignoreStandalone; 2723 2724 var isRoot = !this.isRootSeen; 2725 this.isRootSeen = true; 2726 2727 var body = program.body; 2728 for (var i = 0, l = body.length; i < l; i++) { 2729 var current = body[i], 2730 strip = this.accept(current); 2731 2732 if (!strip) { 2733 continue; 2734 } 2735 2736 var _isPrevWhitespace = isPrevWhitespace(body, i, isRoot), 2737 _isNextWhitespace = isNextWhitespace(body, i, isRoot), 2738 openStandalone = strip.openStandalone && _isPrevWhitespace, 2739 closeStandalone = strip.closeStandalone && _isNextWhitespace, 2740 inlineStandalone = strip.inlineStandalone && _isPrevWhitespace && _isNextWhitespace; 2741 2742 if (strip.close) { 2743 omitRight(body, i, true); 2744 } 2745 if (strip.open) { 2746 omitLeft(body, i, true); 2747 } 2748 2749 if (doStandalone && inlineStandalone) { 2750 omitRight(body, i); 2751 2752 if (omitLeft(body, i)) { 2753 // If we are on a standalone node, save the indent info for partials 2754 if (current.type === 'PartialStatement') { 2755 // Pull out the whitespace from the final line 2756 current.indent = /([ \t]+$)/.exec(body[i - 1].original)[1]; 2757 } 2758 } 2759 } 2760 if (doStandalone && openStandalone) { 2761 omitRight((current.program || current.inverse).body); 2762 2763 // Strip out the previous content node if it's whitespace only 2764 omitLeft(body, i); 2765 } 2766 if (doStandalone && closeStandalone) { 2767 // Always strip the next node 2768 omitRight(body, i); 2769 2770 omitLeft((current.inverse || current.program).body); 2771 } 2772 } 2773 2774 return program; 2775 }; 2776 2777 WhitespaceControl.prototype.BlockStatement = WhitespaceControl.prototype.DecoratorBlock = WhitespaceControl.prototype.PartialBlockStatement = function (block) { 2778 this.accept(block.program); 2779 this.accept(block.inverse); 2780 2781 // Find the inverse program that is involed with whitespace stripping. 2782 var program = block.program || block.inverse, 2783 inverse = block.program && block.inverse, 2784 firstInverse = inverse, 2785 lastInverse = inverse; 2786 2787 if (inverse && inverse.chained) { 2788 firstInverse = inverse.body[0].program; 2789 2790 // Walk the inverse chain to find the last inverse that is actually in the chain. 2791 while (lastInverse.chained) { 2792 lastInverse = lastInverse.body[lastInverse.body.length - 1].program; 2793 } 2794 } 2795 2796 var strip = { 2797 open: block.openStrip.open, 2798 close: block.closeStrip.close, 2799 2800 // Determine the standalone candiacy. Basically flag our content as being possibly standalone 2801 // so our parent can determine if we actually are standalone 2802 openStandalone: isNextWhitespace(program.body), 2803 closeStandalone: isPrevWhitespace((firstInverse || program).body) 2804 }; 2805 2806 if (block.openStrip.close) { 2807 omitRight(program.body, null, true); 2808 } 2809 2810 if (inverse) { 2811 var inverseStrip = block.inverseStrip; 2812 2813 if (inverseStrip.open) { 2814 omitLeft(program.body, null, true); 2815 } 2816 2817 if (inverseStrip.close) { 2818 omitRight(firstInverse.body, null, true); 2819 } 2820 if (block.closeStrip.open) { 2821 omitLeft(lastInverse.body, null, true); 2822 } 2823 2824 // Find standalone else statments 2825 if (!this.options.ignoreStandalone && isPrevWhitespace(program.body) && isNextWhitespace(firstInverse.body)) { 2826 omitLeft(program.body); 2827 omitRight(firstInverse.body); 2828 } 2829 } else if (block.closeStrip.open) { 2830 omitLeft(program.body, null, true); 2831 } 2832 2833 return strip; 2834 }; 2835 2836 WhitespaceControl.prototype.Decorator = WhitespaceControl.prototype.MustacheStatement = function (mustache) { 2837 return mustache.strip; 2838 }; 2839 2840 WhitespaceControl.prototype.PartialStatement = WhitespaceControl.prototype.CommentStatement = function (node) { 2841 /* istanbul ignore next */ 2842 var strip = node.strip || {}; 2843 return { 2844 inlineStandalone: true, 2845 open: strip.open, 2846 close: strip.close 2847 }; 2848 }; 2849 2850 function isPrevWhitespace(body, i, isRoot) { 2851 if (i === undefined) { 2852 i = body.length; 2853 } 2854 2855 // Nodes that end with newlines are considered whitespace (but are special 2856 // cased for strip operations) 2857 var prev = body[i - 1], 2858 sibling = body[i - 2]; 2859 if (!prev) { 2860 return isRoot; 2861 } 2862 2863 if (prev.type === 'ContentStatement') { 2864 return (sibling || !isRoot ? /\r?\n\s*?$/ : /(^|\r?\n)\s*?$/).test(prev.original); 2865 } 2866 } 2867 function isNextWhitespace(body, i, isRoot) { 2868 if (i === undefined) { 2869 i = -1; 2870 } 2871 2872 var next = body[i + 1], 2873 sibling = body[i + 2]; 2874 if (!next) { 2875 return isRoot; 2876 } 2877 2878 if (next.type === 'ContentStatement') { 2879 return (sibling || !isRoot ? /^\s*?\r?\n/ : /^\s*?(\r?\n|$)/).test(next.original); 2880 } 2881 } 2882 2883 // Marks the node to the right of the position as omitted. 2884 // I.e. {{foo}}' ' will mark the ' ' node as omitted. 2885 // 2886 // If i is undefined, then the first child will be marked as such. 2887 // 2888 // If mulitple is truthy then all whitespace will be stripped out until non-whitespace 2889 // content is met. 2890 function omitRight(body, i, multiple) { 2891 var current = body[i == null ? 0 : i + 1]; 2892 if (!current || current.type !== 'ContentStatement' || !multiple && current.rightStripped) { 2893 return; 2894 } 2895 2896 var original = current.value; 2897 current.value = current.value.replace(multiple ? /^\s+/ : /^[ \t]*\r?\n?/, ''); 2898 current.rightStripped = current.value !== original; 2899 } 2900 2901 // Marks the node to the left of the position as omitted. 2902 // I.e. ' '{{foo}} will mark the ' ' node as omitted. 2903 // 2904 // If i is undefined then the last child will be marked as such. 2905 // 2906 // If mulitple is truthy then all whitespace will be stripped out until non-whitespace 2907 // content is met. 2908 function omitLeft(body, i, multiple) { 2909 var current = body[i == null ? body.length - 1 : i - 1]; 2910 if (!current || current.type !== 'ContentStatement' || !multiple && current.leftStripped) { 2911 return; 2912 } 2913 2914 // We omit the last node if it's whitespace only and not preceded by a non-content node. 2915 var original = current.value; 2916 current.value = current.value.replace(multiple ? /\s+$/ : /[ \t]+$/, ''); 2917 current.leftStripped = current.value !== original; 2918 return current.leftStripped; 2919 } 2920 2921 exports['default'] = WhitespaceControl; 2922 module.exports = exports['default']; 2923 2924 /***/ }), 2925 /* 49 */ 2926 /***/ (function(module, exports, __webpack_require__) { 2927 2928 'use strict'; 2929 2930 var _interopRequireDefault = __webpack_require__(1)['default']; 2931 2932 exports.__esModule = true; 2933 2934 var _exception = __webpack_require__(6); 2935 2936 var _exception2 = _interopRequireDefault(_exception); 2937 2938 function Visitor() { 2939 this.parents = []; 2940 } 2941 2942 Visitor.prototype = { 2943 constructor: Visitor, 2944 mutating: false, 2945 2946 // Visits a given value. If mutating, will replace the value if necessary. 2947 acceptKey: function acceptKey(node, name) { 2948 var value = this.accept(node[name]); 2949 if (this.mutating) { 2950 // Hacky sanity check: This may have a few false positives for type for the helper 2951 // methods but will generally do the right thing without a lot of overhead. 2952 if (value && !Visitor.prototype[value.type]) { 2953 throw new _exception2['default']('Unexpected node type "' + value.type + '" found when accepting ' + name + ' on ' + node.type); 2954 } 2955 node[name] = value; 2956 } 2957 }, 2958 2959 // Performs an accept operation with added sanity check to ensure 2960 // required keys are not removed. 2961 acceptRequired: function acceptRequired(node, name) { 2962 this.acceptKey(node, name); 2963 2964 if (!node[name]) { 2965 throw new _exception2['default'](node.type + ' requires ' + name); 2966 } 2967 }, 2968 2969 // Traverses a given array. If mutating, empty respnses will be removed 2970 // for child elements. 2971 acceptArray: function acceptArray(array) { 2972 for (var i = 0, l = array.length; i < l; i++) { 2973 this.acceptKey(array, i); 2974 2975 if (!array[i]) { 2976 array.splice(i, 1); 2977 i--; 2978 l--; 2979 } 2980 } 2981 }, 2982 2983 accept: function accept(object) { 2984 if (!object) { 2985 return; 2986 } 2987 2988 /* istanbul ignore next: Sanity code */ 2989 if (!this[object.type]) { 2990 throw new _exception2['default']('Unknown type: ' + object.type, object); 2991 } 2992 2993 if (this.current) { 2994 this.parents.unshift(this.current); 2995 } 2996 this.current = object; 2997 2998 var ret = this[object.type](object); 2999 3000 this.current = this.parents.shift(); 3001 3002 if (!this.mutating || ret) { 3003 return ret; 3004 } else if (ret !== false) { 3005 return object; 3006 } 3007 }, 3008 3009 Program: function Program(program) { 3010 this.acceptArray(program.body); 3011 }, 3012 3013 MustacheStatement: visitSubExpression, 3014 Decorator: visitSubExpression, 3015 3016 BlockStatement: visitBlock, 3017 DecoratorBlock: visitBlock, 3018 3019 PartialStatement: visitPartial, 3020 PartialBlockStatement: function PartialBlockStatement(partial) { 3021 visitPartial.call(this, partial); 3022 3023 this.acceptKey(partial, 'program'); 3024 }, 3025 3026 ContentStatement: function ContentStatement() /* content */{}, 3027 CommentStatement: function CommentStatement() /* comment */{}, 3028 3029 SubExpression: visitSubExpression, 3030 3031 PathExpression: function PathExpression() /* path */{}, 3032 3033 StringLiteral: function StringLiteral() /* string */{}, 3034 NumberLiteral: function NumberLiteral() /* number */{}, 3035 BooleanLiteral: function BooleanLiteral() /* bool */{}, 3036 UndefinedLiteral: function UndefinedLiteral() /* literal */{}, 3037 NullLiteral: function NullLiteral() /* literal */{}, 3038 3039 Hash: function Hash(hash) { 3040 this.acceptArray(hash.pairs); 3041 }, 3042 HashPair: function HashPair(pair) { 3043 this.acceptRequired(pair, 'value'); 3044 } 3045 }; 3046 3047 function visitSubExpression(mustache) { 3048 this.acceptRequired(mustache, 'path'); 3049 this.acceptArray(mustache.params); 3050 this.acceptKey(mustache, 'hash'); 3051 } 3052 function visitBlock(block) { 3053 visitSubExpression.call(this, block); 3054 3055 this.acceptKey(block, 'program'); 3056 this.acceptKey(block, 'inverse'); 3057 } 3058 function visitPartial(partial) { 3059 this.acceptRequired(partial, 'name'); 3060 this.acceptArray(partial.params); 3061 this.acceptKey(partial, 'hash'); 3062 } 3063 3064 exports['default'] = Visitor; 3065 module.exports = exports['default']; 3066 3067 /***/ }), 3068 /* 50 */ 3069 /***/ (function(module, exports, __webpack_require__) { 3070 3071 'use strict'; 3072 3073 var _interopRequireDefault = __webpack_require__(1)['default']; 3074 3075 exports.__esModule = true; 3076 exports.SourceLocation = SourceLocation; 3077 exports.id = id; 3078 exports.stripFlags = stripFlags; 3079 exports.stripComment = stripComment; 3080 exports.preparePath = preparePath; 3081 exports.prepareMustache = prepareMustache; 3082 exports.prepareRawBlock = prepareRawBlock; 3083 exports.prepareBlock = prepareBlock; 3084 exports.prepareProgram = prepareProgram; 3085 exports.preparePartialBlock = preparePartialBlock; 3086 3087 var _exception = __webpack_require__(6); 3088 3089 var _exception2 = _interopRequireDefault(_exception); 3090 3091 function validateClose(open, close) { 3092 close = close.path ? close.path.original : close; 3093 3094 if (open.path.original !== close) { 3095 var errorNode = { loc: open.path.loc }; 3096 3097 throw new _exception2['default'](open.path.original + " doesn't match " + close, errorNode); 3098 } 3099 } 3100 3101 function SourceLocation(source, locInfo) { 3102 this.source = source; 3103 this.start = { 3104 line: locInfo.first_line, 3105 column: locInfo.first_column 3106 }; 3107 this.end = { 3108 line: locInfo.last_line, 3109 column: locInfo.last_column 3110 }; 3111 } 3112 3113 function id(token) { 3114 if (/^\[.*\]$/.test(token)) { 3115 return token.substring(1, token.length - 1); 3116 } else { 3117 return token; 3118 } 3119 } 3120 3121 function stripFlags(open, close) { 3122 return { 3123 open: open.charAt(2) === '~', 3124 close: close.charAt(close.length - 3) === '~' 3125 }; 3126 } 3127 3128 function stripComment(comment) { 3129 return comment.replace(/^\{\{~?!-?-?/, '').replace(/-?-?~?\}\}$/, ''); 3130 } 3131 3132 function preparePath(data, parts, loc) { 3133 loc = this.locInfo(loc); 3134 3135 var original = data ? '@' : '', 3136 dig = [], 3137 depth = 0; 3138 3139 for (var i = 0, l = parts.length; i < l; i++) { 3140 var part = parts[i].part, 3141 3142 // If we have [] syntax then we do not treat path references as operators, 3143 // i.e. foo.[this] resolves to approximately context.foo['this'] 3144 isLiteral = parts[i].original !== part; 3145 original += (parts[i].separator || '') + part; 3146 3147 if (!isLiteral && (part === '..' || part === '.' || part === 'this')) { 3148 if (dig.length > 0) { 3149 throw new _exception2['default']('Invalid path: ' + original, { loc: loc }); 3150 } else if (part === '..') { 3151 depth++; 3152 } 3153 } else { 3154 dig.push(part); 3155 } 3156 } 3157 3158 return { 3159 type: 'PathExpression', 3160 data: data, 3161 depth: depth, 3162 parts: dig, 3163 original: original, 3164 loc: loc 3165 }; 3166 } 3167 3168 function prepareMustache(path, params, hash, open, strip, locInfo) {
vendor: 1,121 bytes, lines 3169-3213
3169 // Must use charAt to support IE pre-10 3170 var escapeFlag = open.charAt(3) || open.charAt(2), 3171 escaped = escapeFlag !== '{' && escapeFlag !== '&'; 3172 3173 var decorator = /\*/.test(open); 3174 return { 3175 type: decorator ? 'Decorator' : 'MustacheStatement', 3176 path: path, 3177 params: params, 3178 hash: hash, 3179 escaped: escaped, 3180 strip: strip, 3181 loc: this.locInfo(locInfo) 3182 }; 3183 } 3184 3185 function prepareRawBlock(openRawBlock, contents, close, locInfo) { 3186 validateClose(openRawBlock, close); 3187 3188 locInfo = this.locInfo(locInfo); 3189 var program = { 3190 type: 'Program', 3191 body: contents, 3192 strip: {}, 3193 loc: locInfo 3194 }; 3195 3196 return { 3197 type: 'BlockStatement', 3198 path: openRawBlock.path, 3199 params: openRawBlock.params, 3200 hash: openRawBlock.hash, 3201 program: program, 3202 openStrip: {}, 3203 inverseStrip: {}, 3204 closeStrip: {}, 3205 loc: locInfo 3206 }; 3207 } 3208 3209 function prepareBlock(openBlock, program, inverseAndProgram, close, inverted, locInfo) { 3210 if (close && close.path) { 3211 validateClose(openBlock, close); 3212 } 3213
vendor: 5,645 bytes, lines 3214-3431
3214 var decorator = /\*/.test(openBlock.open); 3215 3216 program.blockParams = openBlock.blockParams; 3217 3218 var inverse = undefined, 3219 inverseStrip = undefined; 3220 3221 if (inverseAndProgram) { 3222 if (decorator) { 3223 throw new _exception2['default']('Unexpected inverse block on decorator', inverseAndProgram); 3224 } 3225 3226 if (inverseAndProgram.chain) { 3227 inverseAndProgram.program.body[0].closeStrip = close.strip; 3228 } 3229 3230 inverseStrip = inverseAndProgram.strip; 3231 inverse = inverseAndProgram.program; 3232 } 3233 3234 if (inverted) { 3235 inverted = inverse; 3236 inverse = program; 3237 program = inverted; 3238 } 3239 3240 return { 3241 type: decorator ? 'DecoratorBlock' : 'BlockStatement', 3242 path: openBlock.path, 3243 params: openBlock.params, 3244 hash: openBlock.hash, 3245 program: program, 3246 inverse: inverse, 3247 openStrip: openBlock.strip, 3248 inverseStrip: inverseStrip, 3249 closeStrip: close && close.strip, 3250 loc: this.locInfo(locInfo) 3251 }; 3252 } 3253 3254 function prepareProgram(statements, loc) { 3255 if (!loc && statements.length) { 3256 var firstLoc = statements[0].loc, 3257 lastLoc = statements[statements.length - 1].loc; 3258 3259 /* istanbul ignore else */ 3260 if (firstLoc && lastLoc) { 3261 loc = { 3262 source: firstLoc.source, 3263 start: { 3264 line: firstLoc.start.line, 3265 column: firstLoc.start.column 3266 }, 3267 end: { 3268 line: lastLoc.end.line, 3269 column: lastLoc.end.column 3270 } 3271 }; 3272 } 3273 } 3274 3275 return { 3276 type: 'Program', 3277 body: statements, 3278 strip: {}, 3279 loc: loc 3280 }; 3281 } 3282 3283 function preparePartialBlock(open, program, close, locInfo) { 3284 validateClose(open, close); 3285 3286 return { 3287 type: 'PartialBlockStatement', 3288 name: open.path, 3289 params: open.params, 3290 hash: open.hash, 3291 program: program, 3292 openStrip: open.strip, 3293 closeStrip: close && close.strip, 3294 loc: this.locInfo(locInfo) 3295 }; 3296 } 3297 3298 /***/ }), 3299 /* 51 */ 3300 /***/ (function(module, exports, __webpack_require__) { 3301 3302 /* eslint-disable new-cap */ 3303 3304 'use strict'; 3305 3306 var _Object$create = __webpack_require__(34)['default']; 3307 3308 var _interopRequireDefault = __webpack_require__(1)['default']; 3309 3310 exports.__esModule = true; 3311 exports.Compiler = Compiler; 3312 exports.precompile = precompile; 3313 exports.compile = compile; 3314 3315 var _exception = __webpack_require__(6); 3316 3317 var _exception2 = _interopRequireDefault(_exception); 3318 3319 var _utils = __webpack_require__(5); 3320 3321 var _ast = __webpack_require__(45); 3322 3323 var _ast2 = _interopRequireDefault(_ast); 3324 3325 var slice = [].slice; 3326 3327 function Compiler() {} 3328 3329 // the foundHelper register will disambiguate helper lookup from finding a 3330 // function in a context. This is necessary for mustache compatibility, which 3331 // requires that context functions in blocks are evaluated by blockHelperMissing, 3332 // and then proceed as if the resulting value was provided to blockHelperMissing. 3333 3334 Compiler.prototype = { 3335 compiler: Compiler, 3336 3337 equals: function equals(other) { 3338 var len = this.opcodes.length; 3339 if (other.opcodes.length !== len) { 3340 return false; 3341 } 3342 3343 for (var i = 0; i < len; i++) { 3344 var opcode = this.opcodes[i], 3345 otherOpcode = other.opcodes[i]; 3346 if (opcode.opcode !== otherOpcode.opcode || !argEquals(opcode.args, otherOpcode.args)) { 3347 return false; 3348 } 3349 } 3350 3351 // We know that length is the same between the two arrays because they are directly tied 3352 // to the opcode behavior above. 3353 len = this.children.length; 3354 for (var i = 0; i < len; i++) { 3355 if (!this.children[i].equals(other.children[i])) { 3356 return false; 3357 } 3358 } 3359 3360 return true; 3361 }, 3362 3363 guid: 0, 3364 3365 compile: function compile(program, options) { 3366 this.sourceNode = []; 3367 this.opcodes = []; 3368 this.children = []; 3369 this.options = options; 3370 this.stringParams = options.stringParams; 3371 this.trackIds = options.trackIds; 3372 3373 options.blockParams = options.blockParams || []; 3374 3375 options.knownHelpers = _utils.extend(_Object$create(null), { 3376 helperMissing: true, 3377 blockHelperMissing: true, 3378 each: true, 3379 'if': true, 3380 unless: true, 3381 'with': true, 3382 log: true, 3383 lookup: true 3384 }, options.knownHelpers); 3385 3386 return this.accept(program); 3387 }, 3388 3389 compileProgram: function compileProgram(program) { 3390 var childCompiler = new this.compiler(), 3391 // eslint-disable-line new-cap 3392 result = childCompiler.compile(program, this.options), 3393 guid = this.guid++; 3394 3395 this.usePartial = this.usePartial || result.usePartial; 3396 3397 this.children[guid] = result; 3398 this.useDepths = this.useDepths || result.useDepths; 3399 3400 return guid; 3401 }, 3402 3403 accept: function accept(node) { 3404 /* istanbul ignore next: Sanity code */ 3405 if (!this[node.type]) { 3406 throw new _exception2['default']('Unknown type: ' + node.type, node); 3407 } 3408 3409 this.sourceNode.unshift(node); 3410 var ret = this[node.type](node); 3411 this.sourceNode.shift(); 3412 return ret; 3413 }, 3414 3415 Program: function Program(program) { 3416 this.options.blockParams.unshift(program.blockParams); 3417 3418 var body = program.body, 3419 bodyLength = body.length; 3420 for (var i = 0; i < bodyLength; i++) { 3421 this.accept(body[i]); 3422 } 3423 3424 this.options.blockParams.shift(); 3425 3426 this.isSimple = bodyLength === 1; 3427 this.blockParams = program.blockParams ? program.blockParams.length : 0; 3428 3429 return this; 3430 }, 3431
vendor: 12,687 bytes, lines 3432-3846
3432 BlockStatement: function BlockStatement(block) { 3433 transformLiteralToPath(block); 3434 3435 var program = block.program, 3436 inverse = block.inverse; 3437 3438 program = program && this.compileProgram(program); 3439 inverse = inverse && this.compileProgram(inverse); 3440 3441 var type = this.classifySexpr(block); 3442 3443 if (type === 'helper') { 3444 this.helperSexpr(block, program, inverse); 3445 } else if (type === 'simple') { 3446 this.simpleSexpr(block); 3447 3448 // now that the simple mustache is resolved, we need to 3449 // evaluate it by executing `blockHelperMissing` 3450 this.opcode('pushProgram', program); 3451 this.opcode('pushProgram', inverse); 3452 this.opcode('emptyHash'); 3453 this.opcode('blockValue', block.path.original); 3454 } else { 3455 this.ambiguousSexpr(block, program, inverse); 3456 3457 // now that the simple mustache is resolved, we need to 3458 // evaluate it by executing `blockHelperMissing` 3459 this.opcode('pushProgram', program); 3460 this.opcode('pushProgram', inverse); 3461 this.opcode('emptyHash'); 3462 this.opcode('ambiguousBlockValue'); 3463 } 3464 3465 this.opcode('append'); 3466 }, 3467 3468 DecoratorBlock: function DecoratorBlock(decorator) { 3469 var program = decorator.program && this.compileProgram(decorator.program); 3470 var params = this.setupFullMustacheParams(decorator, program, undefined), 3471 path = decorator.path; 3472 3473 this.useDecorators = true; 3474 this.opcode('registerDecorator', params.length, path.original); 3475 }, 3476 3477 PartialStatement: function PartialStatement(partial) { 3478 this.usePartial = true; 3479 3480 var program = partial.program; 3481 if (program) { 3482 program = this.compileProgram(partial.program); 3483 } 3484 3485 var params = partial.params; 3486 if (params.length > 1) { 3487 throw new _exception2['default']('Unsupported number of partial arguments: ' + params.length, partial); 3488 } else if (!params.length) { 3489 if (this.options.explicitPartialContext) { 3490 this.opcode('pushLiteral', 'undefined'); 3491 } else { 3492 params.push({ type: 'PathExpression', parts: [], depth: 0 }); 3493 } 3494 } 3495 3496 var partialName = partial.name.original, 3497 isDynamic = partial.name.type === 'SubExpression'; 3498 if (isDynamic) { 3499 this.accept(partial.name); 3500 } 3501 3502 this.setupFullMustacheParams(partial, program, undefined, true); 3503 3504 var indent = partial.indent || ''; 3505 if (this.options.preventIndent && indent) { 3506 this.opcode('appendContent', indent); 3507 indent = ''; 3508 } 3509 3510 this.opcode('invokePartial', isDynamic, partialName, indent); 3511 this.opcode('append'); 3512 }, 3513 PartialBlockStatement: function PartialBlockStatement(partialBlock) { 3514 this.PartialStatement(partialBlock); 3515 }, 3516 3517 MustacheStatement: function MustacheStatement(mustache) { 3518 this.SubExpression(mustache); 3519 3520 if (mustache.escaped && !this.options.noEscape) { 3521 this.opcode('appendEscaped'); 3522 } else { 3523 this.opcode('append'); 3524 } 3525 }, 3526 Decorator: function Decorator(decorator) { 3527 this.DecoratorBlock(decorator); 3528 }, 3529 3530 ContentStatement: function ContentStatement(content) { 3531 if (content.value) { 3532 this.opcode('appendContent', content.value); 3533 } 3534 }, 3535 3536 CommentStatement: function CommentStatement() {}, 3537 3538 SubExpression: function SubExpression(sexpr) { 3539 transformLiteralToPath(sexpr); 3540 var type = this.classifySexpr(sexpr); 3541 3542 if (type === 'simple') { 3543 this.simpleSexpr(sexpr); 3544 } else if (type === 'helper') { 3545 this.helperSexpr(sexpr); 3546 } else { 3547 this.ambiguousSexpr(sexpr); 3548 } 3549 }, 3550 ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) { 3551 var path = sexpr.path, 3552 name = path.parts[0], 3553 isBlock = program != null || inverse != null; 3554 3555 this.opcode('getContext', path.depth); 3556 3557 this.opcode('pushProgram', program); 3558 this.opcode('pushProgram', inverse); 3559 3560 path.strict = true; 3561 this.accept(path); 3562 3563 this.opcode('invokeAmbiguous', name, isBlock); 3564 }, 3565 3566 simpleSexpr: function simpleSexpr(sexpr) { 3567 var path = sexpr.path; 3568 path.strict = true; 3569 this.accept(path); 3570 this.opcode('resolvePossibleLambda'); 3571 }, 3572 3573 helperSexpr: function helperSexpr(sexpr, program, inverse) { 3574 var params = this.setupFullMustacheParams(sexpr, program, inverse), 3575 path = sexpr.path, 3576 name = path.parts[0]; 3577 3578 if (this.options.knownHelpers[name]) { 3579 this.opcode('invokeKnownHelper', params.length, name); 3580 } else if (this.options.knownHelpersOnly) { 3581 throw new _exception2['default']('You specified knownHelpersOnly, but used the unknown helper ' + name, sexpr); 3582 } else { 3583 path.strict = true; 3584 path.falsy = true; 3585 3586 this.accept(path); 3587 this.opcode('invokeHelper', params.length, path.original, _ast2['default'].helpers.simpleId(path)); 3588 } 3589 }, 3590 3591 PathExpression: function PathExpression(path) { 3592 this.addDepth(path.depth); 3593 this.opcode('getContext', path.depth); 3594 3595 var name = path.parts[0], 3596 scoped = _ast2['default'].helpers.scopedId(path), 3597 blockParamId = !path.depth && !scoped && this.blockParamIndex(name); 3598 3599 if (blockParamId) { 3600 this.opcode('lookupBlockParam', blockParamId, path.parts); 3601 } else if (!name) { 3602 // Context reference, i.e. `{{foo .}}` or `{{foo ..}}` 3603 this.opcode('pushContext'); 3604 } else if (path.data) { 3605 this.options.data = true; 3606 this.opcode('lookupData', path.depth, path.parts, path.strict); 3607 } else { 3608 this.opcode('lookupOnContext', path.parts, path.falsy, path.strict, scoped); 3609 } 3610 }, 3611 3612 StringLiteral: function StringLiteral(string) { 3613 this.opcode('pushString', string.value); 3614 }, 3615 3616 NumberLiteral: function NumberLiteral(number) { 3617 this.opcode('pushLiteral', number.value); 3618 }, 3619 3620 BooleanLiteral: function BooleanLiteral(bool) { 3621 this.opcode('pushLiteral', bool.value); 3622 }, 3623 3624 UndefinedLiteral: function UndefinedLiteral() { 3625 this.opcode('pushLiteral', 'undefined'); 3626 }, 3627 3628 NullLiteral: function NullLiteral() { 3629 this.opcode('pushLiteral', 'null'); 3630 }, 3631 3632 Hash: function Hash(hash) { 3633 var pairs = hash.pairs, 3634 i = 0, 3635 l = pairs.length; 3636 3637 this.opcode('pushHash'); 3638 3639 for (; i < l; i++) { 3640 this.pushParam(pairs[i].value); 3641 } 3642 while (i--) { 3643 this.opcode('assignToHash', pairs[i].key); 3644 } 3645 this.opcode('popHash'); 3646 }, 3647 3648 // HELPERS 3649 opcode: function opcode(name) { 3650 this.opcodes.push({ 3651 opcode: name, 3652 args: slice.call(arguments, 1), 3653 loc: this.sourceNode[0].loc 3654 }); 3655 }, 3656 3657 addDepth: function addDepth(depth) { 3658 if (!depth) { 3659 return; 3660 } 3661 3662 this.useDepths = true; 3663 }, 3664 3665 classifySexpr: function classifySexpr(sexpr) { 3666 var isSimple = _ast2['default'].helpers.simpleId(sexpr.path); 3667 3668 var isBlockParam = isSimple && !!this.blockParamIndex(sexpr.path.parts[0]); 3669 3670 // a mustache is an eligible helper if: 3671 // * its id is simple (a single part, not `this` or `..`) 3672 var isHelper = !isBlockParam && _ast2['default'].helpers.helperExpression(sexpr); 3673 3674 // if a mustache is an eligible helper but not a definite 3675 // helper, it is ambiguous, and will be resolved in a later 3676 // pass or at runtime. 3677 var isEligible = !isBlockParam && (isHelper || isSimple); 3678 3679 // if ambiguous, we can possibly resolve the ambiguity now 3680 // An eligible helper is one that does not have a complex path, i.e. `this.foo`, `../foo` etc. 3681 if (isEligible && !isHelper) { 3682 var _name = sexpr.path.parts[0], 3683 options = this.options; 3684 if (options.knownHelpers[_name]) { 3685 isHelper = true; 3686 } else if (options.knownHelpersOnly) { 3687 isEligible = false; 3688 } 3689 } 3690 3691 if (isHelper) { 3692 return 'helper'; 3693 } else if (isEligible) { 3694 return 'ambiguous'; 3695 } else { 3696 return 'simple'; 3697 } 3698 }, 3699 3700 pushParams: function pushParams(params) { 3701 for (var i = 0, l = params.length; i < l; i++) { 3702 this.pushParam(params[i]); 3703 } 3704 }, 3705 3706 pushParam: function pushParam(val) { 3707 var value = val.value != null ? val.value : val.original || ''; 3708 3709 if (this.stringParams) { 3710 if (value.replace) { 3711 value = value.replace(/^(\.?\.\/)*/g, '').replace(/\//g, '.'); 3712 } 3713 3714 if (val.depth) { 3715 this.addDepth(val.depth); 3716 } 3717 this.opcode('getContext', val.depth || 0); 3718 this.opcode('pushStringParam', value, val.type); 3719 3720 if (val.type === 'SubExpression') { 3721 // SubExpressions get evaluated and passed in 3722 // in string params mode. 3723 this.accept(val); 3724 } 3725 } else { 3726 if (this.trackIds) { 3727 var blockParamIndex = undefined; 3728 if (val.parts && !_ast2['default'].helpers.scopedId(val) && !val.depth) { 3729 blockParamIndex = this.blockParamIndex(val.parts[0]); 3730 } 3731 if (blockParamIndex) { 3732 var blockParamChild = val.parts.slice(1).join('.'); 3733 this.opcode('pushId', 'BlockParam', blockParamIndex, blockParamChild); 3734 } else { 3735 value = val.original || value; 3736 if (value.replace) { 3737 value = value.replace(/^this(?:\.|$)/, '').replace(/^\.\//, '').replace(/^\.$/, ''); 3738 } 3739 3740 this.opcode('pushId', val.type, value); 3741 } 3742 } 3743 this.accept(val); 3744 } 3745 }, 3746 3747 setupFullMustacheParams: function setupFullMustacheParams(sexpr, program, inverse, omitEmpty) { 3748 var params = sexpr.params; 3749 this.pushParams(params); 3750 3751 this.opcode('pushProgram', program); 3752 this.opcode('pushProgram', inverse); 3753 3754 if (sexpr.hash) { 3755 this.accept(sexpr.hash); 3756 } else { 3757 this.opcode('emptyHash', omitEmpty); 3758 } 3759 3760 return params; 3761 }, 3762 3763 blockParamIndex: function blockParamIndex(name) { 3764 for (var depth = 0, len = this.options.blockParams.length; depth < len; depth++) { 3765 var blockParams = this.options.blockParams[depth], 3766 param = blockParams && _utils.indexOf(blockParams, name); 3767 if (blockParams && param >= 0) { 3768 return [depth, param]; 3769 } 3770 } 3771 } 3772 }; 3773 3774 function precompile(input, options, env) { 3775 if (input == null || typeof input !== 'string' && input.type !== 'Program') { 3776 throw new _exception2['default']('You must pass a string or Handlebars AST to Handlebars.precompile. You passed ' + input); 3777 } 3778 3779 options = options || {}; 3780 if (!('data' in options)) { 3781 options.data = true; 3782 } 3783 if (options.compat) { 3784 options.useDepths = true; 3785 } 3786 3787 var ast = env.parse(input, options), 3788 environment = new env.Compiler().compile(ast, options); 3789 return new env.JavaScriptCompiler().compile(environment, options); 3790 } 3791 3792 function compile(input, options, env) { 3793 if (options === undefined) options = {}; 3794 3795 if (input == null || typeof input !== 'string' && input.type !== 'Program') { 3796 throw new _exception2['default']('You must pass a string or Handlebars AST to Handlebars.compile. You passed ' + input); 3797 } 3798 3799 options = _utils.extend({}, options); 3800 if (!('data' in options)) { 3801 options.data = true; 3802 } 3803 if (options.compat) { 3804 options.useDepths = true; 3805 } 3806 3807 var compiled = undefined; 3808 3809 function compileInput() { 3810 var ast = env.parse(input, options), 3811 environment = new env.Compiler().compile(ast, options), 3812 templateSpec = new env.JavaScriptCompiler().compile(environment, options, undefined, true); 3813 return env.template(templateSpec); 3814 } 3815 3816 // Template is only compiled on first use and cached after that point. 3817 function ret(context, execOptions) { 3818 if (!compiled) { 3819 compiled = compileInput(); 3820 } 3821 return compiled.call(this, context, execOptions); 3822 } 3823 ret._setup = function (setupOptions) { 3824 if (!compiled) { 3825 compiled = compileInput(); 3826 } 3827 return compiled._setup(setupOptions); 3828 }; 3829 ret._child = function (i, data, blockParams, depths) { 3830 if (!compiled) { 3831 compiled = compileInput(); 3832 } 3833 return compiled._child(i, data, blockParams, depths); 3834 }; 3835 return ret; 3836 } 3837 3838 function argEquals(a, b) { 3839 if (a === b) { 3840 return true; 3841 } 3842 3843 if (_utils.isArray(a) && _utils.isArray(b) && a.length === b.length) { 3844 for (var i = 0; i < a.length; i++) { 3845 if (!argEquals(a[i], b[i])) { 3846 return false;
vendor: 7,934 bytes, lines 3847-4107
3847 } 3848 } 3849 return true; 3850 } 3851 } 3852 3853 function transformLiteralToPath(sexpr) { 3854 if (!sexpr.path.parts) { 3855 var literal = sexpr.path; 3856 // Casting to string here to make false and 0 literal values play nicely with the rest 3857 // of the system. 3858 sexpr.path = { 3859 type: 'PathExpression', 3860 data: false, 3861 depth: 0, 3862 parts: [literal.original + ''], 3863 original: literal.original + '', 3864 loc: literal.loc 3865 }; 3866 } 3867 } 3868 3869 /***/ }), 3870 /* 52 */ 3871 /***/ (function(module, exports, __webpack_require__) { 3872 3873 'use strict'; 3874 3875 var _Object$keys = __webpack_require__(13)['default']; 3876 3877 var _interopRequireDefault = __webpack_require__(1)['default']; 3878 3879 exports.__esModule = true; 3880 3881 var _base = __webpack_require__(4); 3882 3883 var _exception = __webpack_require__(6); 3884 3885 var _exception2 = _interopRequireDefault(_exception); 3886 3887 var _utils = __webpack_require__(5); 3888 3889 var _codeGen = __webpack_require__(53); 3890 3891 var _codeGen2 = _interopRequireDefault(_codeGen); 3892 3893 function Literal(value) { 3894 this.value = value; 3895 } 3896 3897 function JavaScriptCompiler() {} 3898 3899 JavaScriptCompiler.prototype = { 3900 // PUBLIC API: You can override these methods in a subclass to provide 3901 // alternative compiled forms for name lookup and buffering semantics 3902 nameLookup: function nameLookup(parent, name /*, type */) { 3903 return this.internalNameLookup(parent, name); 3904 }, 3905 depthedLookup: function depthedLookup(name) { 3906 return [this.aliasable('container.lookup'), '(depths, ', JSON.stringify(name), ')']; 3907 }, 3908 3909 compilerInfo: function compilerInfo() { 3910 var revision = _base.COMPILER_REVISION, 3911 versions = _base.REVISION_CHANGES[revision]; 3912 return [revision, versions]; 3913 }, 3914 3915 appendToBuffer: function appendToBuffer(source, location, explicit) { 3916 // Force a source as this simplifies the merge logic. 3917 if (!_utils.isArray(source)) { 3918 source = [source]; 3919 } 3920 source = this.source.wrap(source, location); 3921 3922 if (this.environment.isSimple) { 3923 return ['return ', source, ';']; 3924 } else if (explicit) { 3925 // This is a case where the buffer operation occurs as a child of another 3926 // construct, generally braces. We have to explicitly output these buffer 3927 // operations to ensure that the emitted code goes in the correct location. 3928 return ['buffer += ', source, ';']; 3929 } else { 3930 source.appendToBuffer = true; 3931 return source; 3932 } 3933 }, 3934 3935 initializeBuffer: function initializeBuffer() { 3936 return this.quotedString(''); 3937 }, 3938 // END PUBLIC API 3939 internalNameLookup: function internalNameLookup(parent, name) { 3940 this.lookupPropertyFunctionIsUsed = true; 3941 return ['lookupProperty(', parent, ',', JSON.stringify(name), ')']; 3942 }, 3943 3944 lookupPropertyFunctionIsUsed: false, 3945 3946 compile: function compile(environment, options, context, asObject) { 3947 this.environment = environment; 3948 this.options = options; 3949 this.stringParams = this.options.stringParams; 3950 this.trackIds = this.options.trackIds; 3951 this.precompile = !asObject; 3952 3953 this.name = this.environment.name; 3954 this.isChild = !!context; 3955 this.context = context || { 3956 decorators: [], 3957 programs: [], 3958 environments: [] 3959 }; 3960 3961 this.preamble(); 3962 3963 this.stackSlot = 0; 3964 this.stackVars = []; 3965 this.aliases = {}; 3966 this.registers = { list: [] }; 3967 this.hashes = []; 3968 this.compileStack = []; 3969 this.inlineStack = []; 3970 this.blockParams = []; 3971 3972 this.compileChildren(environment, options); 3973 3974 this.useDepths = this.useDepths || environment.useDepths || environment.useDecorators || this.options.compat; 3975 this.useBlockParams = this.useBlockParams || environment.useBlockParams; 3976 3977 var opcodes = environment.opcodes, 3978 opcode = undefined, 3979 firstLoc = undefined, 3980 i = undefined, 3981 l = undefined; 3982 3983 for (i = 0, l = opcodes.length; i < l; i++) { 3984 opcode = opcodes[i]; 3985 3986 this.source.currentLocation = opcode.loc; 3987 firstLoc = firstLoc || opcode.loc; 3988 this[opcode.opcode].apply(this, opcode.args); 3989 } 3990 3991 // Flush any trailing content that might be pending. 3992 this.source.currentLocation = firstLoc; 3993 this.pushSource(''); 3994 3995 /* istanbul ignore next */ 3996 if (this.stackSlot || this.inlineStack.length || this.compileStack.length) { 3997 throw new _exception2['default']('Compile completed with content left on stack'); 3998 } 3999 4000 if (!this.decorators.isEmpty()) { 4001 this.useDecorators = true; 4002 4003 this.decorators.prepend(['var decorators = container.decorators, ', this.lookupPropertyFunctionVarDeclaration(), ';\n']); 4004 this.decorators.push('return fn;'); 4005 4006 if (asObject) { 4007 this.decorators = Function.apply(this, ['fn', 'props', 'container', 'depth0', 'data', 'blockParams', 'depths', this.decorators.merge()]); 4008 } else { 4009 this.decorators.prepend('function(fn, props, container, depth0, data, blockParams, depths) {\n'); 4010 this.decorators.push('}\n'); 4011 this.decorators = this.decorators.merge(); 4012 } 4013 } else { 4014 this.decorators = undefined; 4015 } 4016 4017 var fn = this.createFunctionContext(asObject); 4018 if (!this.isChild) { 4019 var ret = { 4020 compiler: this.compilerInfo(), 4021 main: fn 4022 }; 4023 4024 if (this.decorators) { 4025 ret.main_d = this.decorators; // eslint-disable-line camelcase 4026 ret.useDecorators = true; 4027 } 4028 4029 var _context = this.context; 4030 var programs = _context.programs; 4031 var decorators = _context.decorators; 4032 4033 for (i = 0, l = programs.length; i < l; i++) { 4034 if (programs[i]) { 4035 ret[i] = programs[i]; 4036 if (decorators[i]) { 4037 ret[i + '_d'] = decorators[i]; 4038 ret.useDecorators = true; 4039 } 4040 } 4041 } 4042 4043 if (this.environment.usePartial) { 4044 ret.usePartial = true; 4045 } 4046 if (this.options.data) { 4047 ret.useData = true; 4048 } 4049 if (this.useDepths) { 4050 ret.useDepths = true; 4051 } 4052 if (this.useBlockParams) { 4053 ret.useBlockParams = true; 4054 } 4055 if (this.options.compat) { 4056 ret.compat = true; 4057 } 4058 4059 if (!asObject) { 4060 ret.compiler = JSON.stringify(ret.compiler); 4061 4062 this.source.currentLocation = { start: { line: 1, column: 0 } }; 4063 ret = this.objectLiteral(ret); 4064 4065 if (options.srcName) { 4066 ret = ret.toStringWithSourceMap({ file: options.destName }); 4067 ret.map = ret.map && ret.map.toString(); 4068 } else { 4069 ret = ret.toString(); 4070 } 4071 } else { 4072 ret.compilerOptions = this.options; 4073 } 4074 4075 return ret; 4076 } else { 4077 return fn; 4078 } 4079 }, 4080 4081 preamble: function preamble() { 4082 // track the last context pushed into place to allow skipping the 4083 // getContext opcode when it would be a noop 4084 this.lastContext = 0; 4085 this.source = new _codeGen2['default'](this.options.srcName); 4086 this.decorators = new _codeGen2['default'](this.options.srcName); 4087 }, 4088 4089 createFunctionContext: function createFunctionContext(asObject) { 4090 // istanbul ignore next 4091 4092 var _this = this; 4093 4094 var varDeclarations = ''; 4095 4096 var locals = this.stackVars.concat(this.registers.list); 4097 if (locals.length > 0) { 4098 varDeclarations += ', ' + locals.join(', '); 4099 } 4100 4101 // Generate minimizer alias mappings 4102 // 4103 // When using true SourceNodes, this will update all references to the given alias 4104 // as the source nodes are reused in situ. For the non-source node compilation mode, 4105 // aliases will not be used, but this case is already being run on the client and 4106 // we aren't concern about minimizing the template size. 4107 var aliasCount = 0;
vendor: 5,371 bytes, lines 4108-4269
4108 _Object$keys(this.aliases).forEach(function (alias) { 4109 var node = _this.aliases[alias]; 4110 if (node.children && node.referenceCount > 1) { 4111 varDeclarations += ', alias' + ++aliasCount + '=' + alias; 4112 node.children[0] = 'alias' + aliasCount; 4113 } 4114 }); 4115 4116 if (this.lookupPropertyFunctionIsUsed) { 4117 varDeclarations += ', ' + this.lookupPropertyFunctionVarDeclaration(); 4118 } 4119 4120 var params = ['container', 'depth0', 'helpers', 'partials', 'data']; 4121 4122 if (this.useBlockParams || this.useDepths) { 4123 params.push('blockParams'); 4124 } 4125 if (this.useDepths) { 4126 params.push('depths'); 4127 } 4128 4129 // Perform a second pass over the output to merge content when possible 4130 var source = this.mergeSource(varDeclarations); 4131 4132 if (asObject) { 4133 params.push(source); 4134 4135 return Function.apply(this, params); 4136 } else { 4137 return this.source.wrap(['function(', params.join(','), ') {\n ', source, '}']); 4138 } 4139 }, 4140 mergeSource: function mergeSource(varDeclarations) { 4141 var isSimple = this.environment.isSimple, 4142 appendOnly = !this.forceBuffer, 4143 appendFirst = undefined, 4144 sourceSeen = undefined, 4145 bufferStart = undefined, 4146 bufferEnd = undefined; 4147 this.source.each(function (line) { 4148 if (line.appendToBuffer) { 4149 if (bufferStart) { 4150 line.prepend(' + '); 4151 } else { 4152 bufferStart = line; 4153 } 4154 bufferEnd = line; 4155 } else { 4156 if (bufferStart) { 4157 if (!sourceSeen) { 4158 appendFirst = true; 4159 } else { 4160 bufferStart.prepend('buffer += '); 4161 } 4162 bufferEnd.add(';'); 4163 bufferStart = bufferEnd = undefined; 4164 } 4165 4166 sourceSeen = true; 4167 if (!isSimple) { 4168 appendOnly = false; 4169 } 4170 } 4171 }); 4172 4173 if (appendOnly) { 4174 if (bufferStart) { 4175 bufferStart.prepend('return '); 4176 bufferEnd.add(';'); 4177 } else if (!sourceSeen) { 4178 this.source.push('return "";'); 4179 } 4180 } else { 4181 varDeclarations += ', buffer = ' + (appendFirst ? '' : this.initializeBuffer()); 4182 4183 if (bufferStart) { 4184 bufferStart.prepend('return buffer + '); 4185 bufferEnd.add(';'); 4186 } else { 4187 this.source.push('return buffer;'); 4188 } 4189 } 4190 4191 if (varDeclarations) { 4192 this.source.prepend('var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\n')); 4193 } 4194 4195 return this.source.merge(); 4196 }, 4197 4198 lookupPropertyFunctionVarDeclaration: function lookupPropertyFunctionVarDeclaration() { 4199 return '\n lookupProperty = container.lookupProperty || function(parent, propertyName) {\n if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {\n return parent[propertyName];\n }\n return undefined\n }\n '.trim(); 4200 }, 4201 4202 // [blockValue] 4203 // 4204 // On stack, before: hash, inverse, program, value 4205 // On stack, after: return value of blockHelperMissing 4206 // 4207 // The purpose of this opcode is to take a block of the form 4208 // `{{#this.foo}}...{{/this.foo}}`, resolve the value of `foo`, and 4209 // replace it on the stack with the result of properly 4210 // invoking blockHelperMissing. 4211 blockValue: function blockValue(name) { 4212 var blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'), 4213 params = [this.contextName(0)]; 4214 this.setupHelperArgs(name, 0, params); 4215 4216 var blockName = this.popStack(); 4217 params.splice(1, 0, blockName); 4218 4219 this.push(this.source.functionCall(blockHelperMissing, 'call', params)); 4220 }, 4221 4222 // [ambiguousBlockValue] 4223 // 4224 // On stack, before: hash, inverse, program, value 4225 // Compiler value, before: lastHelper=value of last found helper, if any 4226 // On stack, after, if no lastHelper: same as [blockValue] 4227 // On stack, after, if lastHelper: value 4228 ambiguousBlockValue: function ambiguousBlockValue() { 4229 // We're being a bit cheeky and reusing the options value from the prior exec 4230 var blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'), 4231 params = [this.contextName(0)]; 4232 this.setupHelperArgs('', 0, params, true); 4233 4234 this.flushInline(); 4235 4236 var current = this.topStack(); 4237 params.splice(1, 0, current); 4238 4239 this.pushSource(['if (!', this.lastHelper, ') { ', current, ' = ', this.source.functionCall(blockHelperMissing, 'call', params), '}']); 4240 }, 4241 4242 // [appendContent] 4243 // 4244 // On stack, before: ... 4245 // On stack, after: ... 4246 // 4247 // Appends the string value of `content` to the current buffer 4248 appendContent: function appendContent(content) { 4249 if (this.pendingContent) { 4250 content = this.pendingContent + content; 4251 } else { 4252 this.pendingLocation = this.source.currentLocation; 4253 } 4254 4255 this.pendingContent = content; 4256 }, 4257 4258 // [append] 4259 // 4260 // On stack, before: value, ... 4261 // On stack, after: ... 4262 // 4263 // Coerces `value` to a String and appends it to the current buffer. 4264 // 4265 // If `value` is truthy, or 0, it is coerced into a string and appended 4266 // Otherwise, the empty string is appended 4267 append: function append() { 4268 if (this.isInline()) { 4269 this.replaceStack(function (current) {
vendor: 13,836 bytes, lines 4270-4694
4270 return [' != null ? ', current, ' : ""']; 4271 }); 4272 4273 this.pushSource(this.appendToBuffer(this.popStack())); 4274 } else { 4275 var local = this.popStack(); 4276 this.pushSource(['if (', local, ' != null) { ', this.appendToBuffer(local, undefined, true), ' }']); 4277 if (this.environment.isSimple) { 4278 this.pushSource(['else { ', this.appendToBuffer("''", undefined, true), ' }']); 4279 } 4280 } 4281 }, 4282 4283 // [appendEscaped] 4284 // 4285 // On stack, before: value, ... 4286 // On stack, after: ... 4287 // 4288 // Escape `value` and append it to the buffer 4289 appendEscaped: function appendEscaped() { 4290 this.pushSource(this.appendToBuffer([this.aliasable('container.escapeExpression'), '(', this.popStack(), ')'])); 4291 }, 4292 4293 // [getContext] 4294 // 4295 // On stack, before: ... 4296 // On stack, after: ... 4297 // Compiler value, after: lastContext=depth 4298 // 4299 // Set the value of the `lastContext` compiler value to the depth 4300 getContext: function getContext(depth) { 4301 this.lastContext = depth; 4302 }, 4303 4304 // [pushContext] 4305 // 4306 // On stack, before: ... 4307 // On stack, after: currentContext, ... 4308 // 4309 // Pushes the value of the current context onto the stack. 4310 pushContext: function pushContext() { 4311 this.pushStackLiteral(this.contextName(this.lastContext)); 4312 }, 4313 4314 // [lookupOnContext] 4315 // 4316 // On stack, before: ... 4317 // On stack, after: currentContext[name], ... 4318 // 4319 // Looks up the value of `name` on the current context and pushes 4320 // it onto the stack. 4321 lookupOnContext: function lookupOnContext(parts, falsy, strict, scoped) { 4322 var i = 0; 4323 4324 if (!scoped && this.options.compat && !this.lastContext) { 4325 // The depthed query is expected to handle the undefined logic for the root level that 4326 // is implemented below, so we evaluate that directly in compat mode 4327 this.push(this.depthedLookup(parts[i++])); 4328 } else { 4329 this.pushContext(); 4330 } 4331 4332 this.resolvePath('context', parts, i, falsy, strict); 4333 }, 4334 4335 // [lookupBlockParam] 4336 // 4337 // On stack, before: ... 4338 // On stack, after: blockParam[name], ... 4339 // 4340 // Looks up the value of `parts` on the given block param and pushes 4341 // it onto the stack. 4342 lookupBlockParam: function lookupBlockParam(blockParamId, parts) { 4343 this.useBlockParams = true; 4344 4345 this.push(['blockParams[', blockParamId[0], '][', blockParamId[1], ']']); 4346 this.resolvePath('context', parts, 1); 4347 }, 4348 4349 // [lookupData] 4350 // 4351 // On stack, before: ... 4352 // On stack, after: data, ... 4353 // 4354 // Push the data lookup operator 4355 lookupData: function lookupData(depth, parts, strict) { 4356 if (!depth) { 4357 this.pushStackLiteral('data'); 4358 } else { 4359 this.pushStackLiteral('container.data(data, ' + depth + ')'); 4360 } 4361 4362 this.resolvePath('data', parts, 0, true, strict); 4363 }, 4364 4365 resolvePath: function resolvePath(type, parts, i, falsy, strict) { 4366 // istanbul ignore next 4367 4368 var _this2 = this; 4369 4370 if (this.options.strict || this.options.assumeObjects) { 4371 this.push(strictLookup(this.options.strict && strict, this, parts, type)); 4372 return; 4373 } 4374 4375 var len = parts.length; 4376 for (; i < len; i++) { 4377 /* eslint-disable no-loop-func */ 4378 this.replaceStack(function (current) { 4379 var lookup = _this2.nameLookup(current, parts[i], type); 4380 // We want to ensure that zero and false are handled properly if the context (falsy flag) 4381 // needs to have the special handling for these values. 4382 if (!falsy) { 4383 return [' != null ? ', lookup, ' : ', current]; 4384 } else { 4385 // Otherwise we can use generic falsy handling 4386 return [' && ', lookup]; 4387 } 4388 }); 4389 /* eslint-enable no-loop-func */ 4390 } 4391 }, 4392 4393 // [resolvePossibleLambda] 4394 // 4395 // On stack, before: value, ... 4396 // On stack, after: resolved value, ... 4397 // 4398 // If the `value` is a lambda, replace it on the stack by 4399 // the return value of the lambda 4400 resolvePossibleLambda: function resolvePossibleLambda() { 4401 this.push([this.aliasable('container.lambda'), '(', this.popStack(), ', ', this.contextName(0), ')']); 4402 }, 4403 4404 // [pushStringParam] 4405 // 4406 // On stack, before: ... 4407 // On stack, after: string, currentContext, ... 4408 // 4409 // This opcode is designed for use in string mode, which 4410 // provides the string value of a parameter along with its 4411 // depth rather than resolving it immediately. 4412 pushStringParam: function pushStringParam(string, type) { 4413 this.pushContext(); 4414 this.pushString(type); 4415 4416 // If it's a subexpression, the string result 4417 // will be pushed after this opcode. 4418 if (type !== 'SubExpression') { 4419 if (typeof string === 'string') { 4420 this.pushString(string); 4421 } else { 4422 this.pushStackLiteral(string); 4423 } 4424 } 4425 }, 4426 4427 emptyHash: function emptyHash(omitEmpty) { 4428 if (this.trackIds) { 4429 this.push('{}'); // hashIds 4430 } 4431 if (this.stringParams) { 4432 this.push('{}'); // hashContexts 4433 this.push('{}'); // hashTypes 4434 } 4435 this.pushStackLiteral(omitEmpty ? 'undefined' : '{}'); 4436 }, 4437 pushHash: function pushHash() { 4438 if (this.hash) { 4439 this.hashes.push(this.hash); 4440 } 4441 this.hash = { values: {}, types: [], contexts: [], ids: [] }; 4442 }, 4443 popHash: function popHash() { 4444 var hash = this.hash; 4445 this.hash = this.hashes.pop(); 4446 4447 if (this.trackIds) { 4448 this.push(this.objectLiteral(hash.ids)); 4449 } 4450 if (this.stringParams) { 4451 this.push(this.objectLiteral(hash.contexts)); 4452 this.push(this.objectLiteral(hash.types)); 4453 } 4454 4455 this.push(this.objectLiteral(hash.values)); 4456 }, 4457 4458 // [pushString] 4459 // 4460 // On stack, before: ... 4461 // On stack, after: quotedString(string), ... 4462 // 4463 // Push a quoted version of `string` onto the stack 4464 pushString: function pushString(string) { 4465 this.pushStackLiteral(this.quotedString(string)); 4466 }, 4467 4468 // [pushLiteral] 4469 // 4470 // On stack, before: ... 4471 // On stack, after: value, ... 4472 // 4473 // Pushes a value onto the stack. This operation prevents 4474 // the compiler from creating a temporary variable to hold 4475 // it. 4476 pushLiteral: function pushLiteral(value) { 4477 this.pushStackLiteral(value); 4478 }, 4479 4480 // [pushProgram] 4481 // 4482 // On stack, before: ... 4483 // On stack, after: program(guid), ... 4484 // 4485 // Push a program expression onto the stack. This takes 4486 // a compile-time guid and converts it into a runtime-accessible 4487 // expression. 4488 pushProgram: function pushProgram(guid) { 4489 if (guid != null) { 4490 this.pushStackLiteral(this.programExpression(guid)); 4491 } else { 4492 this.pushStackLiteral(null); 4493 } 4494 }, 4495 4496 // [registerDecorator] 4497 // 4498 // On stack, before: hash, program, params..., ... 4499 // On stack, after: ... 4500 // 4501 // Pops off the decorator's parameters, invokes the decorator, 4502 // and inserts the decorator into the decorators list. 4503 registerDecorator: function registerDecorator(paramSize, name) { 4504 var foundDecorator = this.nameLookup('decorators', name, 'decorator'), 4505 options = this.setupHelperArgs(name, paramSize); 4506 4507 this.decorators.push(['fn = ', this.decorators.functionCall(foundDecorator, '', ['fn', 'props', 'container', options]), ' || fn;']); 4508 }, 4509 4510 // [invokeHelper] 4511 // 4512 // On stack, before: hash, inverse, program, params..., ... 4513 // On stack, after: result of helper invocation 4514 // 4515 // Pops off the helper's parameters, invokes the helper, 4516 // and pushes the helper's return value onto the stack. 4517 // 4518 // If the helper is not found, `helperMissing` is called. 4519 invokeHelper: function invokeHelper(paramSize, name, isSimple) { 4520 var nonHelper = this.popStack(), 4521 helper = this.setupHelper(paramSize, name); 4522 4523 var possibleFunctionCalls = []; 4524 4525 if (isSimple) { 4526 // direct call to helper 4527 possibleFunctionCalls.push(helper.name); 4528 } 4529 // call a function from the input object 4530 possibleFunctionCalls.push(nonHelper); 4531 if (!this.options.strict) { 4532 possibleFunctionCalls.push(this.aliasable('container.hooks.helperMissing')); 4533 } 4534 4535 var functionLookupCode = ['(', this.itemsSeparatedBy(possibleFunctionCalls, '||'), ')']; 4536 var functionCall = this.source.functionCall(functionLookupCode, 'call', helper.callParams); 4537 this.push(functionCall); 4538 }, 4539 4540 itemsSeparatedBy: function itemsSeparatedBy(items, separator) { 4541 var result = []; 4542 result.push(items[0]); 4543 for (var i = 1; i < items.length; i++) { 4544 result.push(separator, items[i]); 4545 } 4546 return result; 4547 }, 4548 // [invokeKnownHelper] 4549 // 4550 // On stack, before: hash, inverse, program, params..., ... 4551 // On stack, after: result of helper invocation 4552 // 4553 // This operation is used when the helper is known to exist, 4554 // so a `helperMissing` fallback is not required. 4555 invokeKnownHelper: function invokeKnownHelper(paramSize, name) { 4556 var helper = this.setupHelper(paramSize, name); 4557 this.push(this.source.functionCall(helper.name, 'call', helper.callParams)); 4558 }, 4559 4560 // [invokeAmbiguous] 4561 // 4562 // On stack, before: hash, inverse, program, params..., ... 4563 // On stack, after: result of disambiguation 4564 // 4565 // This operation is used when an expression like `{{foo}}` 4566 // is provided, but we don't know at compile-time whether it 4567 // is a helper or a path. 4568 // 4569 // This operation emits more code than the other options, 4570 // and can be avoided by passing the `knownHelpers` and 4571 // `knownHelpersOnly` flags at compile-time. 4572 invokeAmbiguous: function invokeAmbiguous(name, helperCall) { 4573 this.useRegister('helper'); 4574 4575 var nonHelper = this.popStack(); 4576 4577 this.emptyHash(); 4578 var helper = this.setupHelper(0, name, helperCall); 4579 4580 var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper'); 4581 4582 var lookup = ['(', '(helper = ', helperName, ' || ', nonHelper, ')']; 4583 if (!this.options.strict) { 4584 lookup[0] = '(helper = '; 4585 lookup.push(' != null ? helper : ', this.aliasable('container.hooks.helperMissing')); 4586 } 4587 4588 this.push(['(', lookup, helper.paramsInit ? ['),(', helper.paramsInit] : [], '),', '(typeof helper === ', this.aliasable('"function"'), ' ? ', this.source.functionCall('helper', 'call', helper.callParams), ' : helper))']); 4589 }, 4590 4591 // [invokePartial] 4592 // 4593 // On stack, before: context, ... 4594 // On stack after: result of partial invocation 4595 // 4596 // This operation pops off a context, invokes a partial with that context, 4597 // and pushes the result of the invocation back. 4598 invokePartial: function invokePartial(isDynamic, name, indent) { 4599 var params = [], 4600 options = this.setupParams(name, 1, params); 4601 4602 if (isDynamic) { 4603 name = this.popStack(); 4604 delete options.name; 4605 } 4606 4607 if (indent) { 4608 options.indent = JSON.stringify(indent); 4609 } 4610 options.helpers = 'helpers'; 4611 options.partials = 'partials'; 4612 options.decorators = 'container.decorators'; 4613 4614 if (!isDynamic) { 4615 params.unshift(this.nameLookup('partials', name, 'partial')); 4616 } else { 4617 params.unshift(name); 4618 } 4619 4620 if (this.options.compat) { 4621 options.depths = 'depths'; 4622 } 4623 options = this.objectLiteral(options); 4624 params.push(options); 4625 4626 this.push(this.source.functionCall('container.invokePartial', '', params)); 4627 }, 4628 4629 // [assignToHash] 4630 // 4631 // On stack, before: value, ..., hash, ... 4632 // On stack, after: ..., hash, ... 4633 // 4634 // Pops a value off the stack and assigns it to the current hash 4635 assignToHash: function assignToHash(key) { 4636 var value = this.popStack(), 4637 context = undefined, 4638 type = undefined, 4639 id = undefined; 4640 4641 if (this.trackIds) { 4642 id = this.popStack(); 4643 } 4644 if (this.stringParams) { 4645 type = this.popStack(); 4646 context = this.popStack(); 4647 } 4648 4649 var hash = this.hash; 4650 if (context) { 4651 hash.contexts[key] = context; 4652 } 4653 if (type) { 4654 hash.types[key] = type; 4655 } 4656 if (id) { 4657 hash.ids[key] = id; 4658 } 4659 hash.values[key] = value; 4660 }, 4661 4662 pushId: function pushId(type, name, child) { 4663 if (type === 'BlockParam') { 4664 this.pushStackLiteral('blockParams[' + name[0] + '].path[' + name[1] + ']' + (child ? ' + ' + JSON.stringify('.' + child) : '')); 4665 } else if (type === 'PathExpression') { 4666 this.pushString(name); 4667 } else if (type === 'SubExpression') { 4668 this.pushStackLiteral('true'); 4669 } else { 4670 this.pushStackLiteral('null'); 4671 } 4672 }, 4673 4674 // HELPERS 4675 4676 compiler: JavaScriptCompiler, 4677 4678 compileChildren: function compileChildren(environment, options) { 4679 var children = environment.children, 4680 child = undefined, 4681 compiler = undefined; 4682 4683 for (var i = 0, l = children.length; i < l; i++) { 4684 child = children[i]; 4685 compiler = new this.compiler(); // eslint-disable-line new-cap 4686 4687 var existing = this.matchExistingProgram(child); 4688 4689 if (existing == null) { 4690 this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children 4691 var index = this.context.programs.length; 4692 child.index = index; 4693 child.name = 'program' + index; 4694 this.context.programs[index] = compiler.compile(child, options, this.context, !this.prec
vendor: 9,313 bytes, lines 4694-5006
4694ompile); 4695 this.context.decorators[index] = compiler.decorators; 4696 this.context.environments[index] = child; 4697 4698 this.useDepths = this.useDepths || compiler.useDepths; 4699 this.useBlockParams = this.useBlockParams || compiler.useBlockParams; 4700 child.useDepths = this.useDepths; 4701 child.useBlockParams = this.useBlockParams; 4702 } else { 4703 child.index = existing.index; 4704 child.name = 'program' + existing.index; 4705 4706 this.useDepths = this.useDepths || existing.useDepths; 4707 this.useBlockParams = this.useBlockParams || existing.useBlockParams; 4708 } 4709 } 4710 }, 4711 matchExistingProgram: function matchExistingProgram(child) { 4712 for (var i = 0, len = this.context.environments.length; i < len; i++) { 4713 var environment = this.context.environments[i]; 4714 if (environment && environment.equals(child)) { 4715 return environment; 4716 } 4717 } 4718 }, 4719 4720 programExpression: function programExpression(guid) { 4721 var child = this.environment.children[guid], 4722 programParams = [child.index, 'data', child.blockParams]; 4723 4724 if (this.useBlockParams || this.useDepths) { 4725 programParams.push('blockParams'); 4726 } 4727 if (this.useDepths) { 4728 programParams.push('depths'); 4729 } 4730 4731 return 'container.program(' + programParams.join(', ') + ')'; 4732 }, 4733 4734 useRegister: function useRegister(name) { 4735 if (!this.registers[name]) { 4736 this.registers[name] = true; 4737 this.registers.list.push(name); 4738 } 4739 }, 4740 4741 push: function push(expr) { 4742 if (!(expr instanceof Literal)) { 4743 expr = this.source.wrap(expr); 4744 } 4745 4746 this.inlineStack.push(expr); 4747 return expr; 4748 }, 4749 4750 pushStackLiteral: function pushStackLiteral(item) { 4751 this.push(new Literal(item)); 4752 }, 4753 4754 pushSource: function pushSource(source) { 4755 if (this.pendingContent) { 4756 this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation)); 4757 this.pendingContent = undefined; 4758 } 4759 4760 if (source) { 4761 this.source.push(source); 4762 } 4763 }, 4764 4765 replaceStack: function replaceStack(callback) { 4766 var prefix = ['('], 4767 stack = undefined, 4768 createdStack = undefined, 4769 usedLiteral = undefined; 4770 4771 /* istanbul ignore next */ 4772 if (!this.isInline()) { 4773 throw new _exception2['default']('replaceStack on non-inline'); 4774 } 4775 4776 // We want to merge the inline statement into the replacement statement via ',' 4777 var top = this.popStack(true); 4778 4779 if (top instanceof Literal) { 4780 // Literals do not need to be inlined 4781 stack = [top.value]; 4782 prefix = ['(', stack]; 4783 usedLiteral = true; 4784 } else { 4785 // Get or create the current stack name for use by the inline 4786 createdStack = true; 4787 var _name = this.incrStack(); 4788 4789 prefix = ['((', this.push(_name), ' = ', top, ')']; 4790 stack = this.topStack(); 4791 } 4792 4793 var item = callback.call(this, stack); 4794 4795 if (!usedLiteral) { 4796 this.popStack(); 4797 } 4798 if (createdStack) { 4799 this.stackSlot--; 4800 } 4801 this.push(prefix.concat(item, ')')); 4802 }, 4803 4804 incrStack: function incrStack() { 4805 this.stackSlot++; 4806 if (this.stackSlot > this.stackVars.length) { 4807 this.stackVars.push('stack' + this.stackSlot); 4808 } 4809 return this.topStackName(); 4810 }, 4811 topStackName: function topStackName() { 4812 return 'stack' + this.stackSlot; 4813 }, 4814 flushInline: function flushInline() { 4815 var inlineStack = this.inlineStack; 4816 this.inlineStack = []; 4817 for (var i = 0, len = inlineStack.length; i < len; i++) { 4818 var entry = inlineStack[i]; 4819 /* istanbul ignore if */ 4820 if (entry instanceof Literal) { 4821 this.compileStack.push(entry); 4822 } else { 4823 var stack = this.incrStack(); 4824 this.pushSource([stack, ' = ', entry, ';']); 4825 this.compileStack.push(stack); 4826 } 4827 } 4828 }, 4829 isInline: function isInline() { 4830 return this.inlineStack.length; 4831 }, 4832 4833 popStack: function popStack(wrapped) { 4834 var inline = this.isInline(), 4835 item = (inline ? this.inlineStack : this.compileStack).pop(); 4836 4837 if (!wrapped && item instanceof Literal) { 4838 return item.value; 4839 } else { 4840 if (!inline) { 4841 /* istanbul ignore next */ 4842 if (!this.stackSlot) { 4843 throw new _exception2['default']('Invalid stack pop'); 4844 } 4845 this.stackSlot--; 4846 } 4847 return item; 4848 } 4849 }, 4850 4851 topStack: function topStack() { 4852 var stack = this.isInline() ? this.inlineStack : this.compileStack, 4853 item = stack[stack.length - 1]; 4854 4855 /* istanbul ignore if */ 4856 if (item instanceof Literal) { 4857 return item.value; 4858 } else { 4859 return item; 4860 } 4861 }, 4862 4863 contextName: function contextName(context) { 4864 if (this.useDepths && context) { 4865 return 'depths[' + context + ']'; 4866 } else { 4867 return 'depth' + context; 4868 } 4869 }, 4870 4871 quotedString: function quotedString(str) { 4872 return this.source.quotedString(str); 4873 }, 4874 4875 objectLiteral: function objectLiteral(obj) { 4876 return this.source.objectLiteral(obj); 4877 }, 4878 4879 aliasable: function aliasable(name) { 4880 var ret = this.aliases[name]; 4881 if (ret) { 4882 ret.referenceCount++; 4883 return ret; 4884 } 4885 4886 ret = this.aliases[name] = this.source.wrap(name); 4887 ret.aliasable = true; 4888 ret.referenceCount = 1; 4889 4890 return ret; 4891 }, 4892 4893 setupHelper: function setupHelper(paramSize, name, blockHelper) { 4894 var params = [], 4895 paramsInit = this.setupHelperArgs(name, paramSize, params, blockHelper); 4896 var foundHelper = this.nameLookup('helpers', name, 'helper'), 4897 callContext = this.aliasable(this.contextName(0) + ' != null ? ' + this.contextName(0) + ' : (container.nullContext || {})'); 4898 4899 return { 4900 params: params, 4901 paramsInit: paramsInit, 4902 name: foundHelper, 4903 callParams: [callContext].concat(params) 4904 }; 4905 }, 4906 4907 setupParams: function setupParams(helper, paramSize, params) { 4908 var options = {}, 4909 contexts = [], 4910 types = [], 4911 ids = [], 4912 objectArgs = !params, 4913 param = undefined; 4914 4915 if (objectArgs) { 4916 params = []; 4917 } 4918 4919 options.name = this.quotedString(helper); 4920 options.hash = this.popStack(); 4921 4922 if (this.trackIds) { 4923 options.hashIds = this.popStack(); 4924 } 4925 if (this.stringParams) { 4926 options.hashTypes = this.popStack(); 4927 options.hashContexts = this.popStack(); 4928 } 4929 4930 var inverse = this.popStack(), 4931 program = this.popStack(); 4932 4933 // Avoid setting fn and inverse if neither are set. This allows 4934 // helpers to do a check for `if (options.fn)` 4935 if (program || inverse) { 4936 options.fn = program || 'container.noop'; 4937 options.inverse = inverse || 'container.noop'; 4938 } 4939 4940 // The parameters go on to the stack in order (making sure that they are evaluated in order) 4941 // so we need to pop them off the stack in reverse order 4942 var i = paramSize; 4943 while (i--) { 4944 param = this.popStack(); 4945 params[i] = param; 4946 4947 if (this.trackIds) { 4948 ids[i] = this.popStack(); 4949 } 4950 if (this.stringParams) { 4951 types[i] = this.popStack(); 4952 contexts[i] = this.popStack(); 4953 } 4954 } 4955 4956 if (objectArgs) { 4957 options.args = this.source.generateArray(params); 4958 } 4959 4960 if (this.trackIds) { 4961 options.ids = this.source.generateArray(ids); 4962 } 4963 if (this.stringParams) { 4964 options.types = this.source.generateArray(types); 4965 options.contexts = this.source.generateArray(contexts); 4966 } 4967 4968 if (this.options.data) { 4969 options.data = 'data'; 4970 } 4971 if (this.useBlockParams) { 4972 options.blockParams = 'blockParams'; 4973 } 4974 return options; 4975 }, 4976 4977 setupHelperArgs: function setupHelperArgs(helper, paramSize, params, useRegister) { 4978 var options = this.setupParams(helper, paramSize, params); 4979 options.loc = JSON.stringify(this.source.currentLocation); 4980 options = this.objectLiteral(options); 4981 if (useRegister) { 4982 this.useRegister('options'); 4983 params.push('options'); 4984 return ['options=', options]; 4985 } else if (params) { 4986 params.push(options); 4987 return ''; 4988 } else { 4989 return options; 4990 } 4991 } 4992 }; 4993 4994 (function () { 4995 var reservedWords = ('break else new var' + ' case finally return void' + ' catch for switch while' + ' continue function this with' + ' default if throw' + ' delete in try' + ' do instanceof typeof' + ' abstract enum int short' + ' boolean export interface static' + ' byte extends long super' + ' char final native synchronized' + ' class float package throws' + ' const goto private transient' + ' debugger implements protected volatile' + ' double import public let yield await' + ' null true false').split(' '); 4996 4997 var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {}; 4998 4999 for (var i = 0, l = reservedWords.length; i < l; i++) { 5000 compilerWords[reservedWords[i]] = true; 5001 } 5002 })(); 5003 5004 /** 5005 * @deprecated May be removed in the next major version 5006 */
vendor: 4,438 bytes, lines 5007-5160
5007 JavaScriptCompiler.isValidJavaScriptVariableName = function (name) { 5008 return !JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name); 5009 }; 5010 5011 function strictLookup(requireTerminal, compiler, parts, type) { 5012 var stack = compiler.popStack(), 5013 i = 0, 5014 len = parts.length; 5015 if (requireTerminal) { 5016 len--; 5017 } 5018 5019 for (; i < len; i++) { 5020 stack = compiler.nameLookup(stack, parts[i], type); 5021 } 5022 5023 if (requireTerminal) { 5024 return [compiler.aliasable('container.strict'), '(', stack, ', ', compiler.quotedString(parts[i]), ', ', JSON.stringify(compiler.source.currentLocation), ' )']; 5025 } else { 5026 return stack; 5027 } 5028 } 5029 5030 exports['default'] = JavaScriptCompiler; 5031 module.exports = exports['default']; 5032 5033 /***/ }), 5034 /* 53 */ 5035 /***/ (function(module, exports, __webpack_require__) { 5036 5037 /* global define */ 5038 'use strict'; 5039 5040 var _Object$keys = __webpack_require__(13)['default']; 5041 5042 exports.__esModule = true; 5043 5044 var _utils = __webpack_require__(5); 5045 5046 var SourceNode = undefined; 5047 5048 try { 5049 /* istanbul ignore next */ 5050 if (false) { 5051 // We don't support this in AMD environments. For these environments, we asusme that 5052 // they are running on the browser and thus have no need for the source-map library. 5053 var SourceMap = require('source-map'); 5054 SourceNode = SourceMap.SourceNode; 5055 } 5056 } catch (err) {} 5057 /* NOP */ 5058 5059 /* istanbul ignore if: tested but not covered in istanbul due to dist build */ 5060 if (!SourceNode) { 5061 SourceNode = function (line, column, srcFile, chunks) { 5062 this.src = ''; 5063 if (chunks) { 5064 this.add(chunks); 5065 } 5066 }; 5067 /* istanbul ignore next */ 5068 SourceNode.prototype = { 5069 add: function add(chunks) { 5070 if (_utils.isArray(chunks)) { 5071 chunks = chunks.join(''); 5072 } 5073 this.src += chunks; 5074 }, 5075 prepend: function prepend(chunks) { 5076 if (_utils.isArray(chunks)) { 5077 chunks = chunks.join(''); 5078 } 5079 this.src = chunks + this.src; 5080 }, 5081 toStringWithSourceMap: function toStringWithSourceMap() { 5082 return { code: this.toString() }; 5083 }, 5084 toString: function toString() { 5085 return this.src; 5086 } 5087 }; 5088 } 5089 5090 function castChunk(chunk, codeGen, loc) { 5091 if (_utils.isArray(chunk)) { 5092 var ret = []; 5093 5094 for (var i = 0, len = chunk.length; i < len; i++) { 5095 ret.push(codeGen.wrap(chunk[i], loc)); 5096 } 5097 return ret; 5098 } else if (typeof chunk === 'boolean' || typeof chunk === 'number') { 5099 // Handle primitives that the SourceNode will throw up on 5100 return chunk + ''; 5101 } 5102 return chunk; 5103 } 5104 5105 function CodeGen(srcFile) { 5106 this.srcFile = srcFile; 5107 this.source = []; 5108 } 5109 5110 CodeGen.prototype = { 5111 isEmpty: function isEmpty() { 5112 return !this.source.length; 5113 }, 5114 prepend: function prepend(source, loc) { 5115 this.source.unshift(this.wrap(source, loc)); 5116 }, 5117 push: function push(source, loc) { 5118 this.source.push(this.wrap(source, loc)); 5119 }, 5120 5121 merge: function merge() { 5122 var source = this.empty(); 5123 this.each(function (line) { 5124 source.add([' ', line, '\n']); 5125 }); 5126 return source; 5127 }, 5128 5129 each: function each(iter) { 5130 for (var i = 0, len = this.source.length; i < len; i++) { 5131 iter(this.source[i]); 5132 } 5133 }, 5134 5135 empty: function empty() { 5136 var loc = this.currentLocation || { start: {} }; 5137 return new SourceNode(loc.start.line, loc.start.column, this.srcFile); 5138 }, 5139 wrap: function wrap(chunk) { 5140 var loc = arguments.length <= 1 || arguments[1] === undefined ? this.currentLocation || { start: {} } : arguments[1]; 5141 5142 if (chunk instanceof SourceNode) { 5143 return chunk; 5144 } 5145 5146 chunk = castChunk(chunk, this, loc); 5147 5148 return new SourceNode(loc.start.line, loc.start.column, this.srcFile, chunk); 5149 }, 5150 5151 functionCall: function functionCall(fn, type, params) { 5152 params = this.generateList(params); 5153 return this.wrap([fn, type ? '.' + type + '(' : '(', params, ')']); 5154 }, 5155 5156 quotedString: function quotedString(str) { 5157 return '"' + (str + '').replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\u2028/g, '\\u2028') // Per Ecma-262 7.3 + 7.8.4 5158 .replace(/\u2029/g, '\\u2029') + '"'; 5159 }, 5160
vendor: 1,010 bytes, lines 5161-5210
5161 objectLiteral: function objectLiteral(obj) { 5162 // istanbul ignore next 5163 5164 var _this = this; 5165 5166 var pairs = []; 5167 5168 _Object$keys(obj).forEach(function (key) { 5169 var value = castChunk(obj[key], _this); 5170 if (value !== 'undefined') { 5171 pairs.push([_this.quotedString(key), ':', value]); 5172 } 5173 }); 5174 5175 var ret = this.generateList(pairs); 5176 ret.prepend('{'); 5177 ret.add('}'); 5178 return ret; 5179 }, 5180 5181 generateList: function generateList(entries) { 5182 var ret = this.empty(); 5183 5184 for (var i = 0, len = entries.length; i < len; i++) { 5185 if (i) { 5186 ret.add(','); 5187 } 5188 5189 ret.add(castChunk(entries[i], this)); 5190 } 5191 5192 return ret; 5193 }, 5194 5195 generateArray: function generateArray(entries) { 5196 var ret = this.generateList(entries); 5197 ret.prepend('['); 5198 ret.add(']'); 5199 5200 return ret; 5201 } 5202 }; 5203 5204 exports['default'] = CodeGen; 5205 module.exports = exports['default']; 5206 5207 /***/ }) 5208 /******/ ]) 5209}); 5210;
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.