vnfmarket/src/main/webapp/vnfmarket/node_modules/handlebars/dist/handlebars.runtime.js

   1 /**!
   2
   3  @license
   4  handlebars v4.0.6
   5
   6 Copyright (C) 2011-2016 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 /**!
  28
  29  @license
  30  handlebars v4.0.6
  31
  32 Copyright (C) 2011-2016 by Yehuda Katz
  33
  34 Permission is hereby granted, free of charge, to any person obtaining a copy
  35 of this software and associated documentation files (the "Software"), to deal
  36 in the Software without restriction, including without limitation the rights
  37 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  38 copies of the Software, and to permit persons to whom the Software is
  39 furnished to do so, subject to the following conditions:
  40
  41 The above copyright notice and this permission notice shall be included in
  42 all copies or substantial portions of the Software.
  43
  44 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  45 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  46 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  47 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  48 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  49 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  50 THE SOFTWARE.
  51
  52 */
  53 /**!
  54
  55  @license
  56  handlebars v4.0.6
  57
  58 Copyright (C) 2011-2016 by Yehuda Katz
  59
  60 Permission is hereby granted, free of charge, to any person obtaining a copy
  61 of this software and associated documentation files (the "Software"), to deal
  62 in the Software without restriction, including without limitation the rights
  63 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  64 copies of the Software, and to permit persons to whom the Software is
  65 furnished to do so, subject to the following conditions:
  66
  67 The above copyright notice and this permission notice shall be included in
  68 all copies or substantial portions of the Software.
  69
  70 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  71 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  72 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  73 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  74 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  75 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  76 THE SOFTWARE.
  77
  78 */
  79 (function webpackUniversalModuleDefinition(root, factory) {
  80         if(typeof exports === 'object' && typeof module === 'object')
  81                 module.exports = factory();
  82         else if(typeof define === 'function' && define.amd)
  83                 define([], factory);
  84         else if(typeof exports === 'object')
  85                 exports["Handlebars"] = factory();
  86         else
  87                 root["Handlebars"] = factory();
  88 })(this, function() {
  89 return /******/ (function(modules) { // webpackBootstrap
  90 /******/        // The module cache
  91 /******/        var installedModules = {};
  92
  93 /******/        // The require function
  94 /******/        function __webpack_require__(moduleId) {
  95
  96 /******/                // Check if module is in cache
  97 /******/                if(installedModules[moduleId])
  98 /******/                        return installedModules[moduleId].exports;
  99
 100 /******/                // Create a new module (and put it into the cache)
 101 /******/                var module = installedModules[moduleId] = {
 102 /******/                        exports: {},
 103 /******/                        id: moduleId,
 104 /******/                        loaded: false
 105 /******/                };
 106
 107 /******/                // Execute the module function
 108 /******/                modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
 109
 110 /******/                // Flag the module as loaded
 111 /******/                module.loaded = true;
 112
 113 /******/                // Return the exports of the module
 114 /******/                return module.exports;
 115 /******/        }
 116
 117
 118 /******/        // expose the modules object (__webpack_modules__)
 119 /******/        __webpack_require__.m = modules;
 120
 121 /******/        // expose the module cache
 122 /******/        __webpack_require__.c = installedModules;
 123
 124 /******/        // __webpack_public_path__
 125 /******/        __webpack_require__.p = "";
 126
 127 /******/        // Load entry module and return exports
 128 /******/        return __webpack_require__(0);
 129 /******/ })
 130 /************************************************************************/
 131 /******/ ([
 132 /* 0 */
 133 /***/ function(module, exports, __webpack_require__) {
 134
 135         'use strict';
 136
 137         var _interopRequireWildcard = __webpack_require__(1)['default'];
 138
 139         var _interopRequireDefault = __webpack_require__(2)['default'];
 140
 141         exports.__esModule = true;
 142
 143         var _handlebarsBase = __webpack_require__(3);
 144
 145         var base = _interopRequireWildcard(_handlebarsBase);
 146
 147         // Each of these augment the Handlebars object. No need to setup here.
 148         // (This is done to easily share code between commonjs and browse envs)
 149
 150         var _handlebarsSafeString = __webpack_require__(20);
 151
 152         var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);
 153
 154         var _handlebarsException = __webpack_require__(5);
 155
 156         var _handlebarsException2 = _interopRequireDefault(_handlebarsException);
 157
 158         var _handlebarsUtils = __webpack_require__(4);
 159
 160         var Utils = _interopRequireWildcard(_handlebarsUtils);
 161
 162         var _handlebarsRuntime = __webpack_require__(21);
 163
 164         var runtime = _interopRequireWildcard(_handlebarsRuntime);
 165
 166         var _handlebarsNoConflict = __webpack_require__(22);
 167
 168         var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);
 169
 170         // For compatibility and usage outside of module systems, make the Handlebars object a namespace
 171         function create() {
 172           var hb = new base.HandlebarsEnvironment();
 173
 174           Utils.extend(hb, base);
 175           hb.SafeString = _handlebarsSafeString2['default'];
 176           hb.Exception = _handlebarsException2['default'];
 177           hb.Utils = Utils;
 178           hb.escapeExpression = Utils.escapeExpression;
 179
 180           hb.VM = runtime;
 181           hb.template = function (spec) {
 182             return runtime.template(spec, hb);
 183           };
 184
 185           return hb;
 186         }
 187
 188         var inst = create();
 189         inst.create = create;
 190
 191         _handlebarsNoConflict2['default'](inst);
 192
 193         inst['default'] = inst;
 194
 195         exports['default'] = inst;
 196         module.exports = exports['default'];
 197
 198 /***/ },
 199 /* 1 */
 200 /***/ function(module, exports) {
 201
 202         "use strict";
 203
 204         exports["default"] = function (obj) {
 205           if (obj && obj.__esModule) {
 206             return obj;
 207           } else {
 208             var newObj = {};
 209
 210             if (obj != null) {
 211               for (var key in obj) {
 212                 if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
 213               }
 214             }
 215
 216             newObj["default"] = obj;
 217             return newObj;
 218           }
 219         };
 220
 221         exports.__esModule = true;
 222
 223 /***/ },
 224 /* 2 */
 225 /***/ function(module, exports) {
 226
 227         "use strict";
 228
 229         exports["default"] = function (obj) {
 230           return obj && obj.__esModule ? obj : {
 231             "default": obj
 232           };
 233         };
 234
 235         exports.__esModule = true;
 236
 237 /***/ },
 238 /* 3 */
 239 /***/ function(module, exports, __webpack_require__) {
 240
 241         'use strict';
 242
 243         var _interopRequireDefault = __webpack_require__(2)['default'];
 244
 245         exports.__esModule = true;
 246         exports.HandlebarsEnvironment = HandlebarsEnvironment;
 247
 248         var _utils = __webpack_require__(4);
 249
 250         var _exception = __webpack_require__(5);
 251
 252         var _exception2 = _interopRequireDefault(_exception);
 253
 254         var _helpers = __webpack_require__(9);
 255
 256         var _decorators = __webpack_require__(17);
 257
 258         var _logger = __webpack_require__(19);
 259
 260         var _logger2 = _interopRequireDefault(_logger);
 261
 262         var VERSION = '4.0.5';
 263         exports.VERSION = VERSION;
 264         var COMPILER_REVISION = 7;
 265
 266         exports.COMPILER_REVISION = COMPILER_REVISION;
 267         var REVISION_CHANGES = {
 268           1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
 269           2: '== 1.0.0-rc.3',
 270           3: '== 1.0.0-rc.4',
 271           4: '== 1.x.x',
 272           5: '== 2.0.0-alpha.x',
 273           6: '>= 2.0.0-beta.1',
 274           7: '>= 4.0.0'
 275         };
 276
 277         exports.REVISION_CHANGES = REVISION_CHANGES;
 278         var objectType = '[object Object]';
 279
 280         function HandlebarsEnvironment(helpers, partials, decorators) {
 281           this.helpers = helpers || {};
 282           this.partials = partials || {};
 283           this.decorators = decorators || {};
 284
 285           _helpers.registerDefaultHelpers(this);
 286           _decorators.registerDefaultDecorators(this);
 287         }
 288
 289         HandlebarsEnvironment.prototype = {
 290           constructor: HandlebarsEnvironment,
 291
 292           logger: _logger2['default'],
 293           log: _logger2['default'].log,
 294
 295           registerHelper: function registerHelper(name, fn) {
 296             if (_utils.toString.call(name) === objectType) {
 297               if (fn) {
 298                 throw new _exception2['default']('Arg not supported with multiple helpers');
 299               }
 300               _utils.extend(this.helpers, name);
 301             } else {
 302               this.helpers[name] = fn;
 303             }
 304           },
 305           unregisterHelper: function unregisterHelper(name) {
 306             delete this.helpers[name];
 307           },
 308
 309           registerPartial: function registerPartial(name, partial) {
 310             if (_utils.toString.call(name) === objectType) {
 311               _utils.extend(this.partials, name);
 312             } else {
 313               if (typeof partial === 'undefined') {
 314                 throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined');
 315               }
 316               this.partials[name] = partial;
 317             }
 318           },
 319           unregisterPartial: function unregisterPartial(name) {
 320             delete this.partials[name];
 321           },
 322
 323           registerDecorator: function registerDecorator(name, fn) {
 324             if (_utils.toString.call(name) === objectType) {
 325               if (fn) {
 326                 throw new _exception2['default']('Arg not supported with multiple decorators');
 327               }
 328               _utils.extend(this.decorators, name);
 329             } else {
 330               this.decorators[name] = fn;
 331             }
 332           },
 333           unregisterDecorator: function unregisterDecorator(name) {
 334             delete this.decorators[name];
 335           }
 336         };
 337
 338         var log = _logger2['default'].log;
 339
 340         exports.log = log;
 341         exports.createFrame = _utils.createFrame;
 342         exports.logger = _logger2['default'];
 343
 344 /***/ },
 345 /* 4 */
 346 /***/ function(module, exports) {
 347
 348         'use strict';
 349
 350         exports.__esModule = true;
 351         exports.extend = extend;
 352         exports.indexOf = indexOf;
 353         exports.escapeExpression = escapeExpression;
 354         exports.isEmpty = isEmpty;
 355         exports.createFrame = createFrame;
 356         exports.blockParams = blockParams;
 357         exports.appendContextPath = appendContextPath;
 358         var escape = {
 359           '&': '&amp;',
 360           '<': '&lt;',
 361           '>': '&gt;',
 362           '"': '&quot;',
 363           "'": '&#x27;',
 364           '`': '&#x60;',
 365           '=': '&#x3D;'
 366         };
 367
 368         var badChars = /[&<>"'`=]/g,
 369             possible = /[&<>"'`=]/;
 370
 371         function escapeChar(chr) {
 372           return escape[chr];
 373         }
 374
 375         function extend(obj /* , ...source */) {
 376           for (var i = 1; i < arguments.length; i++) {
 377             for (var key in arguments[i]) {
 378               if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
 379                 obj[key] = arguments[i][key];
 380               }
 381             }
 382           }
 383
 384           return obj;
 385         }
 386
 387         var toString = Object.prototype.toString;
 388
 389         exports.toString = toString;
 390         // Sourced from lodash
 391         // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
 392         /* eslint-disable func-style */
 393         var isFunction = function isFunction(value) {
 394           return typeof value === 'function';
 395         };
 396         // fallback for older versions of Chrome and Safari
 397         /* istanbul ignore next */
 398         if (isFunction(/x/)) {
 399           exports.isFunction = isFunction = function (value) {
 400             return typeof value === 'function' && toString.call(value) === '[object Function]';
 401           };
 402         }
 403         exports.isFunction = isFunction;
 404
 405         /* eslint-enable func-style */
 406
 407         /* istanbul ignore next */
 408         var isArray = Array.isArray || function (value) {
 409           return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
 410         };
 411
 412         exports.isArray = isArray;
 413         // Older IE versions do not directly support indexOf so we must implement our own, sadly.
 414
 415         function indexOf(array, value) {
 416           for (var i = 0, len = array.length; i < len; i++) {
 417             if (array[i] === value) {
 418               return i;
 419             }
 420           }
 421           return -1;
 422         }
 423
 424         function escapeExpression(string) {
 425           if (typeof string !== 'string') {
 426             // don't escape SafeStrings, since they're already safe
 427             if (string && string.toHTML) {
 428               return string.toHTML();
 429             } else if (string == null) {
 430               return '';
 431             } else if (!string) {
 432               return string + '';
 433             }
 434
 435             // Force a string conversion as this will be done by the append regardless and
 436             // the regex test will do this transparently behind the scenes, causing issues if
 437             // an object's to string has escaped characters in it.
 438             string = '' + string;
 439           }
 440
 441           if (!possible.test(string)) {
 442             return string;
 443           }
 444           return string.replace(badChars, escapeChar);
 445         }
 446
 447         function isEmpty(value) {
 448           if (!value && value !== 0) {
 449             return true;
 450           } else if (isArray(value) && value.length === 0) {
 451             return true;
 452           } else {
 453             return false;
 454           }
 455         }
 456
 457         function createFrame(object) {
 458           var frame = extend({}, object);
 459           frame._parent = object;
 460           return frame;
 461         }
 462
 463         function blockParams(params, ids) {
 464           params.path = ids;
 465           return params;
 466         }
 467
 468         function appendContextPath(contextPath, id) {
 469           return (contextPath ? contextPath + '.' : '') + id;
 470         }
 471
 472 /***/ },
 473 /* 5 */
 474 /***/ function(module, exports, __webpack_require__) {
 475
 476         'use strict';
 477
 478         var _Object$defineProperty = __webpack_require__(6)['default'];
 479
 480         exports.__esModule = true;
 481
 482         var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
 483
 484         function Exception(message, node) {
 485           var loc = node && node.loc,
 486               line = undefined,
 487               column = undefined;
 488           if (loc) {
 489             line = loc.start.line;
 490             column = loc.start.column;
 491
 492             message += ' - ' + line + ':' + column;
 493           }
 494
 495           var tmp = Error.prototype.constructor.call(this, message);
 496
 497           // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
 498           for (var idx = 0; idx < errorProps.length; idx++) {
 499             this[errorProps[idx]] = tmp[errorProps[idx]];
 500           }
 501
 502           /* istanbul ignore else */
 503           if (Error.captureStackTrace) {
 504             Error.captureStackTrace(this, Exception);
 505           }
 506
 507           try {
 508             if (loc) {
 509               this.lineNumber = line;
 510
 511               // Work around issue under safari where we can't directly set the column value
 512               /* istanbul ignore next */
 513               if (_Object$defineProperty) {
 514                 Object.defineProperty(this, 'column', { value: column });
 515               } else {
 516                 this.column = column;
 517               }
 518             }
 519           } catch (nop) {
 520             /* Ignore if the browser is very particular */
 521           }
 522         }
 523
 524         Exception.prototype = new Error();
 525
 526         exports['default'] = Exception;
 527         module.exports = exports['default'];
 528
 529 /***/ },
 530 /* 6 */
 531 /***/ function(module, exports, __webpack_require__) {
 532
 533         module.exports = { "default": __webpack_require__(7), __esModule: true };
 534
 535 /***/ },
 536 /* 7 */
 537 /***/ function(module, exports, __webpack_require__) {
 538
 539         var $ = __webpack_require__(8);
 540         module.exports = function defineProperty(it, key, desc){
 541           return $.setDesc(it, key, desc);
 542         };
 543
 544 /***/ },
 545 /* 8 */
 546 /***/ function(module, exports) {
 547
 548         var $Object = Object;
 549         module.exports = {
 550           create:     $Object.create,
 551           getProto:   $Object.getPrototypeOf,
 552           isEnum:     {}.propertyIsEnumerable,
 553           getDesc:    $Object.getOwnPropertyDescriptor,
 554           setDesc:    $Object.defineProperty,
 555           setDescs:   $Object.defineProperties,
 556           getKeys:    $Object.keys,
 557           getNames:   $Object.getOwnPropertyNames,
 558           getSymbols: $Object.getOwnPropertySymbols,
 559           each:       [].forEach
 560         };
 561
 562 /***/ },
 563 /* 9 */
 564 /***/ function(module, exports, __webpack_require__) {
 565
 566         'use strict';
 567
 568         var _interopRequireDefault = __webpack_require__(2)['default'];
 569
 570         exports.__esModule = true;
 571         exports.registerDefaultHelpers = registerDefaultHelpers;
 572
 573         var _helpersBlockHelperMissing = __webpack_require__(10);
 574
 575         var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing);
 576
 577         var _helpersEach = __webpack_require__(11);
 578
 579         var _helpersEach2 = _interopRequireDefault(_helpersEach);
 580
 581         var _helpersHelperMissing = __webpack_require__(12);
 582
 583         var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing);
 584
 585         var _helpersIf = __webpack_require__(13);
 586
 587         var _helpersIf2 = _interopRequireDefault(_helpersIf);
 588
 589         var _helpersLog = __webpack_require__(14);
 590
 591         var _helpersLog2 = _interopRequireDefault(_helpersLog);
 592
 593         var _helpersLookup = __webpack_require__(15);
 594
 595         var _helpersLookup2 = _interopRequireDefault(_helpersLookup);
 596
 597         var _helpersWith = __webpack_require__(16);
 598
 599         var _helpersWith2 = _interopRequireDefault(_helpersWith);
 600
 601         function registerDefaultHelpers(instance) {
 602           _helpersBlockHelperMissing2['default'](instance);
 603           _helpersEach2['default'](instance);
 604           _helpersHelperMissing2['default'](instance);
 605           _helpersIf2['default'](instance);
 606           _helpersLog2['default'](instance);
 607           _helpersLookup2['default'](instance);
 608           _helpersWith2['default'](instance);
 609         }
 610
 611 /***/ },
 612 /* 10 */
 613 /***/ function(module, exports, __webpack_require__) {
 614
 615         'use strict';
 616
 617         exports.__esModule = true;
 618
 619         var _utils = __webpack_require__(4);
 620
 621         exports['default'] = function (instance) {
 622           instance.registerHelper('blockHelperMissing', function (context, options) {
 623             var inverse = options.inverse,
 624                 fn = options.fn;
 625
 626             if (context === true) {
 627               return fn(this);
 628             } else if (context === false || context == null) {
 629               return inverse(this);
 630             } else if (_utils.isArray(context)) {
 631               if (context.length > 0) {
 632                 if (options.ids) {
 633                   options.ids = [options.name];
 634                 }
 635
 636                 return instance.helpers.each(context, options);
 637               } else {
 638                 return inverse(this);
 639               }
 640             } else {
 641               if (options.data && options.ids) {
 642                 var data = _utils.createFrame(options.data);
 643                 data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
 644                 options = { data: data };
 645               }
 646
 647               return fn(context, options);
 648             }
 649           });
 650         };
 651
 652         module.exports = exports['default'];
 653
 654 /***/ },
 655 /* 11 */
 656 /***/ function(module, exports, __webpack_require__) {
 657
 658         'use strict';
 659
 660         var _interopRequireDefault = __webpack_require__(2)['default'];
 661
 662         exports.__esModule = true;
 663
 664         var _utils = __webpack_require__(4);
 665
 666         var _exception = __webpack_require__(5);
 667
 668         var _exception2 = _interopRequireDefault(_exception);
 669
 670         exports['default'] = function (instance) {
 671           instance.registerHelper('each', function (context, options) {
 672             if (!options) {
 673               throw new _exception2['default']('Must pass iterator to #each');
 674             }
 675
 676             var fn = options.fn,
 677                 inverse = options.inverse,
 678                 i = 0,
 679                 ret = '',
 680                 data = undefined,
 681                 contextPath = undefined;
 682
 683             if (options.data && options.ids) {
 684               contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
 685             }
 686
 687             if (_utils.isFunction(context)) {
 688               context = context.call(this);
 689             }
 690
 691             if (options.data) {
 692               data = _utils.createFrame(options.data);
 693             }
 694
 695             function execIteration(field, index, last) {
 696               if (data) {
 697                 data.key = field;
 698                 data.index = index;
 699                 data.first = index === 0;
 700                 data.last = !!last;
 701
 702                 if (contextPath) {
 703                   data.contextPath = contextPath + field;
 704                 }
 705               }
 706
 707               ret = ret + fn(context[field], {
 708                 data: data,
 709                 blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])
 710               });
 711             }
 712
 713             if (context && typeof context === 'object') {
 714               if (_utils.isArray(context)) {
 715                 for (var j = context.length; i < j; i++) {
 716                   if (i in context) {
 717                     execIteration(i, i, i === context.length - 1);
 718                   }
 719                 }
 720               } else {
 721                 var priorKey = undefined;
 722
 723                 for (var key in context) {
 724                   if (context.hasOwnProperty(key)) {
 725                     // We're running the iterations one step out of sync so we can detect
 726                     // the last iteration without have to scan the object twice and create
 727                     // an itermediate keys array.
 728                     if (priorKey !== undefined) {
 729                       execIteration(priorKey, i - 1);
 730                     }
 731                     priorKey = key;
 732                     i++;
 733                   }
 734                 }
 735                 if (priorKey !== undefined) {
 736                   execIteration(priorKey, i - 1, true);
 737                 }
 738               }
 739             }
 740
 741             if (i === 0) {
 742               ret = inverse(this);
 743             }
 744
 745             return ret;
 746           });
 747         };
 748
 749         module.exports = exports['default'];
 750
 751 /***/ },
 752 /* 12 */
 753 /***/ function(module, exports, __webpack_require__) {
 754
 755         'use strict';
 756
 757         var _interopRequireDefault = __webpack_require__(2)['default'];
 758
 759         exports.__esModule = true;
 760
 761         var _exception = __webpack_require__(5);
 762
 763         var _exception2 = _interopRequireDefault(_exception);
 764
 765         exports['default'] = function (instance) {
 766           instance.registerHelper('helperMissing', function () /* [args, ]options */{
 767             if (arguments.length === 1) {
 768               // A missing field in a {{foo}} construct.
 769               return undefined;
 770             } else {
 771               // Someone is actually trying to call something, blow up.
 772               throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
 773             }
 774           });
 775         };
 776
 777         module.exports = exports['default'];
 778
 779 /***/ },
 780 /* 13 */
 781 /***/ function(module, exports, __webpack_require__) {
 782
 783         'use strict';
 784
 785         exports.__esModule = true;
 786
 787         var _utils = __webpack_require__(4);
 788
 789         exports['default'] = function (instance) {
 790           instance.registerHelper('if', function (conditional, options) {
 791             if (_utils.isFunction(conditional)) {
 792               conditional = conditional.call(this);
 793             }
 794
 795             // Default behavior is to render the positive path if the value is truthy and not empty.
 796             // The `includeZero` option may be set to treat the condtional as purely not empty based on the
 797             // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
 798             if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) {
 799               return options.inverse(this);
 800             } else {
 801               return options.fn(this);
 802             }
 803           });
 804
 805           instance.registerHelper('unless', function (conditional, options) {
 806             return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash });
 807           });
 808         };
 809
 810         module.exports = exports['default'];
 811
 812 /***/ },
 813 /* 14 */
 814 /***/ function(module, exports) {
 815
 816         'use strict';
 817
 818         exports.__esModule = true;
 819
 820         exports['default'] = function (instance) {
 821           instance.registerHelper('log', function () /* message, options */{
 822             var args = [undefined],
 823                 options = arguments[arguments.length - 1];
 824             for (var i = 0; i < arguments.length - 1; i++) {
 825               args.push(arguments[i]);
 826             }
 827
 828             var level = 1;
 829             if (options.hash.level != null) {
 830               level = options.hash.level;
 831             } else if (options.data && options.data.level != null) {
 832               level = options.data.level;
 833             }
 834             args[0] = level;
 835
 836             instance.log.apply(instance, args);
 837           });
 838         };
 839
 840         module.exports = exports['default'];
 841
 842 /***/ },
 843 /* 15 */
 844 /***/ function(module, exports) {
 845
 846         'use strict';
 847
 848         exports.__esModule = true;
 849
 850         exports['default'] = function (instance) {
 851           instance.registerHelper('lookup', function (obj, field) {
 852             return obj && obj[field];
 853           });
 854         };
 855
 856         module.exports = exports['default'];
 857
 858 /***/ },
 859 /* 16 */
 860 /***/ function(module, exports, __webpack_require__) {
 861
 862         'use strict';
 863
 864         exports.__esModule = true;
 865
 866         var _utils = __webpack_require__(4);
 867
 868         exports['default'] = function (instance) {
 869           instance.registerHelper('with', function (context, options) {
 870             if (_utils.isFunction(context)) {
 871               context = context.call(this);
 872             }
 873
 874             var fn = options.fn;
 875
 876             if (!_utils.isEmpty(context)) {
 877               var data = options.data;
 878               if (options.data && options.ids) {
 879                 data = _utils.createFrame(options.data);
 880                 data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
 881               }
 882
 883               return fn(context, {
 884                 data: data,
 885                 blockParams: _utils.blockParams([context], [data && data.contextPath])
 886               });
 887             } else {
 888               return options.inverse(this);
 889             }
 890           });
 891         };
 892
 893         module.exports = exports['default'];
 894
 895 /***/ },
 896 /* 17 */
 897 /***/ function(module, exports, __webpack_require__) {
 898
 899         'use strict';
 900
 901         var _interopRequireDefault = __webpack_require__(2)['default'];
 902
 903         exports.__esModule = true;
 904         exports.registerDefaultDecorators = registerDefaultDecorators;
 905
 906         var _decoratorsInline = __webpack_require__(18);
 907
 908         var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);
 909
 910         function registerDefaultDecorators(instance) {
 911           _decoratorsInline2['default'](instance);
 912         }
 913
 914 /***/ },
 915 /* 18 */
 916 /***/ function(module, exports, __webpack_require__) {
 917
 918         'use strict';
 919
 920         exports.__esModule = true;
 921
 922         var _utils = __webpack_require__(4);
 923
 924         exports['default'] = function (instance) {
 925           instance.registerDecorator('inline', function (fn, props, container, options) {
 926             var ret = fn;
 927             if (!props.partials) {
 928               props.partials = {};
 929               ret = function (context, options) {
 930                 // Create a new partials stack frame prior to exec.
 931                 var original = container.partials;
 932                 container.partials = _utils.extend({}, original, props.partials);
 933                 var ret = fn(context, options);
 934                 container.partials = original;
 935                 return ret;
 936               };
 937             }
 938
 939             props.partials[options.args[0]] = options.fn;
 940
 941             return ret;
 942           });
 943         };
 944
 945         module.exports = exports['default'];
 946
 947 /***/ },
 948 /* 19 */
 949 /***/ function(module, exports, __webpack_require__) {
 950
 951         'use strict';
 952
 953         exports.__esModule = true;
 954
 955         var _utils = __webpack_require__(4);
 956
 957         var logger = {
 958           methodMap: ['debug', 'info', 'warn', 'error'],
 959           level: 'info',
 960
 961           // Maps a given level value to the `methodMap` indexes above.
 962           lookupLevel: function lookupLevel(level) {
 963             if (typeof level === 'string') {
 964               var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());
 965               if (levelMap >= 0) {
 966                 level = levelMap;
 967               } else {
 968                 level = parseInt(level, 10);
 969               }
 970             }
 971
 972             return level;
 973           },
 974
 975           // Can be overridden in the host environment
 976           log: function log(level) {
 977             level = logger.lookupLevel(level);
 978
 979             if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {
 980               var method = logger.methodMap[level];
 981               if (!console[method]) {
 982                 // eslint-disable-line no-console
 983                 method = 'log';
 984               }
 985
 986               for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
 987                 message[_key - 1] = arguments[_key];
 988               }
 989
 990               console[method].apply(console, message); // eslint-disable-line no-console
 991             }
 992           }
 993         };
 994
 995         exports['default'] = logger;
 996         module.exports = exports['default'];
 997
 998 /***/ },
 999 /* 20 */
1000 /***/ function(module, exports) {
1001
1002         // Build out our basic SafeString type
1003         'use strict';
1004
1005         exports.__esModule = true;
1006         function SafeString(string) {
1007           this.string = string;
1008         }
1009
1010         SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
1011           return '' + this.string;
1012         };
1013
1014         exports['default'] = SafeString;
1015         module.exports = exports['default'];
1016
1017 /***/ },
1018 /* 21 */
1019 /***/ function(module, exports, __webpack_require__) {
1020
1021         'use strict';
1022
1023         var _interopRequireWildcard = __webpack_require__(1)['default'];
1024
1025         var _interopRequireDefault = __webpack_require__(2)['default'];
1026
1027         exports.__esModule = true;
1028         exports.checkRevision = checkRevision;
1029         exports.template = template;
1030         exports.wrapProgram = wrapProgram;
1031         exports.resolvePartial = resolvePartial;
1032         exports.invokePartial = invokePartial;
1033         exports.noop = noop;
1034
1035         var _utils = __webpack_require__(4);
1036
1037         var Utils = _interopRequireWildcard(_utils);
1038
1039         var _exception = __webpack_require__(5);
1040
1041         var _exception2 = _interopRequireDefault(_exception);
1042
1043         var _base = __webpack_require__(3);
1044
1045         function checkRevision(compilerInfo) {
1046           var compilerRevision = compilerInfo && compilerInfo[0] || 1,
1047               currentRevision = _base.COMPILER_REVISION;
1048
1049           if (compilerRevision !== currentRevision) {
1050             if (compilerRevision < currentRevision) {
1051               var runtimeVersions = _base.REVISION_CHANGES[currentRevision],
1052                   compilerVersions = _base.REVISION_CHANGES[compilerRevision];
1053               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 + ').');
1054             } else {
1055               // Use the embedded version info since the runtime doesn't know about this revision yet
1056               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] + ').');
1057             }
1058           }
1059         }
1060
1061         function template(templateSpec, env) {
1062           /* istanbul ignore next */
1063           if (!env) {
1064             throw new _exception2['default']('No environment passed to template');
1065           }
1066           if (!templateSpec || !templateSpec.main) {
1067             throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);
1068           }
1069
1070           templateSpec.main.decorator = templateSpec.main_d;
1071
1072           // Note: Using env.VM references rather than local var references throughout this section to allow
1073           // for external users to override these as psuedo-supported APIs.
1074           env.VM.checkRevision(templateSpec.compiler);
1075
1076           function invokePartialWrapper(partial, context, options) {
1077             if (options.hash) {
1078               context = Utils.extend({}, context, options.hash);
1079               if (options.ids) {
1080                 options.ids[0] = true;
1081               }
1082             }
1083
1084             partial = env.VM.resolvePartial.call(this, partial, context, options);
1085             var result = env.VM.invokePartial.call(this, partial, context, options);
1086
1087             if (result == null && env.compile) {
1088               options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
1089               result = options.partials[options.name](context, options);
1090             }
1091             if (result != null) {
1092               if (options.indent) {
1093                 var lines = result.split('\n');
1094                 for (var i = 0, l = lines.length; i < l; i++) {
1095                   if (!lines[i] && i + 1 === l) {
1096                     break;
1097                   }
1098
1099                   lines[i] = options.indent + lines[i];
1100                 }
1101                 result = lines.join('\n');
1102               }
1103               return result;
1104             } else {
1105               throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
1106             }
1107           }
1108
1109           // Just add water
1110           var container = {
1111             strict: function strict(obj, name) {
1112               if (!(name in obj)) {
1113                 throw new _exception2['default']('"' + name + '" not defined in ' + obj);
1114               }
1115               return obj[name];
1116             },
1117             lookup: function lookup(depths, name) {
1118               var len = depths.length;
1119               for (var i = 0; i < len; i++) {
1120                 if (depths[i] && depths[i][name] != null) {
1121                   return depths[i][name];
1122                 }
1123               }
1124             },
1125             lambda: function lambda(current, context) {
1126               return typeof current === 'function' ? current.call(context) : current;
1127             },
1128
1129             escapeExpression: Utils.escapeExpression,
1130             invokePartial: invokePartialWrapper,
1131
1132             fn: function fn(i) {
1133               var ret = templateSpec[i];
1134               ret.decorator = templateSpec[i + '_d'];
1135               return ret;
1136             },
1137
1138             programs: [],
1139             program: function program(i, data, declaredBlockParams, blockParams, depths) {
1140               var programWrapper = this.programs[i],
1141                   fn = this.fn(i);
1142               if (data || depths || blockParams || declaredBlockParams) {
1143                 programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
1144               } else if (!programWrapper) {
1145                 programWrapper = this.programs[i] = wrapProgram(this, i, fn);
1146               }
1147               return programWrapper;
1148             },
1149
1150             data: function data(value, depth) {
1151               while (value && depth--) {
1152                 value = value._parent;
1153               }
1154               return value;
1155             },
1156             merge: function merge(param, common) {
1157               var obj = param || common;
1158
1159               if (param && common && param !== common) {
1160                 obj = Utils.extend({}, common, param);
1161               }
1162
1163               return obj;
1164             },
1165
1166             noop: env.VM.noop,
1167             compilerInfo: templateSpec.compiler
1168           };
1169
1170           function ret(context) {
1171             var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
1172
1173             var data = options.data;
1174
1175             ret._setup(options);
1176             if (!options.partial && templateSpec.useData) {
1177               data = initData(context, data);
1178             }
1179             var depths = undefined,
1180                 blockParams = templateSpec.useBlockParams ? [] : undefined;
1181             if (templateSpec.useDepths) {
1182               if (options.depths) {
1183                 depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths;
1184               } else {
1185                 depths = [context];
1186               }
1187             }
1188
1189             function main(context /*, options*/) {
1190               return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
1191             }
1192             main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
1193             return main(context, options);
1194           }
1195           ret.isTop = true;
1196
1197           ret._setup = function (options) {
1198             if (!options.partial) {
1199               container.helpers = container.merge(options.helpers, env.helpers);
1200
1201               if (templateSpec.usePartial) {
1202                 container.partials = container.merge(options.partials, env.partials);
1203               }
1204               if (templateSpec.usePartial || templateSpec.useDecorators) {
1205                 container.decorators = container.merge(options.decorators, env.decorators);
1206               }
1207             } else {
1208               container.helpers = options.helpers;
1209               container.partials = options.partials;
1210               container.decorators = options.decorators;
1211             }
1212           };
1213
1214           ret._child = function (i, data, blockParams, depths) {
1215             if (templateSpec.useBlockParams && !blockParams) {
1216               throw new _exception2['default']('must pass block params');
1217             }
1218             if (templateSpec.useDepths && !depths) {
1219               throw new _exception2['default']('must pass parent depths');
1220             }
1221
1222             return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
1223           };
1224           return ret;
1225         }
1226
1227         function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
1228           function prog(context) {
1229             var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
1230
1231             var currentDepths = depths;
1232             if (depths && context != depths[0]) {
1233               currentDepths = [context].concat(depths);
1234             }
1235
1236             return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
1237           }
1238
1239           prog = executeDecorators(fn, prog, container, depths, data, blockParams);
1240
1241           prog.program = i;
1242           prog.depth = depths ? depths.length : 0;
1243           prog.blockParams = declaredBlockParams || 0;
1244           return prog;
1245         }
1246
1247         function resolvePartial(partial, context, options) {
1248           if (!partial) {
1249             if (options.name === '@partial-block') {
1250               var data = options.data;
1251               while (data['partial-block'] === noop) {
1252                 data = data._parent;
1253               }
1254               partial = data['partial-block'];
1255               data['partial-block'] = noop;
1256             } else {
1257               partial = options.partials[options.name];
1258             }
1259           } else if (!partial.call && !options.name) {
1260             // This is a dynamic partial that returned a string
1261             options.name = partial;
1262             partial = options.partials[partial];
1263           }
1264           return partial;
1265         }
1266
1267         function invokePartial(partial, context, options) {
1268           options.partial = true;
1269           if (options.ids) {
1270             options.data.contextPath = options.ids[0] || options.data.contextPath;
1271           }
1272
1273           var partialBlock = undefined;
1274           if (options.fn && options.fn !== noop) {
1275             options.data = _base.createFrame(options.data);
1276             partialBlock = options.data['partial-block'] = options.fn;
1277
1278             if (partialBlock.partials) {
1279               options.partials = Utils.extend({}, options.partials, partialBlock.partials);
1280             }
1281           }
1282
1283           if (partial === undefined && partialBlock) {
1284             partial = partialBlock;
1285           }
1286
1287           if (partial === undefined) {
1288             throw new _exception2['default']('The partial ' + options.name + ' could not be found');
1289           } else if (partial instanceof Function) {
1290             return partial(context, options);
1291           }
1292         }
1293
1294         function noop() {
1295           return '';
1296         }
1297
1298         function initData(context, data) {
1299           if (!data || !('root' in data)) {
1300             data = data ? _base.createFrame(data) : {};
1301             data.root = context;
1302           }
1303           return data;
1304         }
1305
1306         function executeDecorators(fn, prog, container, depths, data, blockParams) {
1307           if (fn.decorator) {
1308             var props = {};
1309             prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
1310             Utils.extend(prog, props);
1311           }
1312           return prog;
1313         }
1314
1315 /***/ },
1316 /* 22 */
1317 /***/ function(module, exports) {
1318
1319         /* WEBPACK VAR INJECTION */(function(global) {/* global window */
1320         'use strict';
1321
1322         exports.__esModule = true;
1323
1324         exports['default'] = function (Handlebars) {
1325           /* istanbul ignore next */
1326           var root = typeof global !== 'undefined' ? global : window,
1327               $Handlebars = root.Handlebars;
1328           /* istanbul ignore next */
1329           Handlebars.noConflict = function () {
1330             if (root.Handlebars === Handlebars) {
1331               root.Handlebars = $Handlebars;
1332             }
1333             return Handlebars;
1334           };
1335         };
1336
1337         module.exports = exports['default'];
1338         /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
1339
1340 /***/ }
1341 /******/ ])
1342 });
1343 ;