handlebars-source 3.0.0 → 3.0.2

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.

This version of handlebars-source might be problematic. Click here for more details.

Files changed (4) hide show
  1. checksums.yaml +4 -4
  2. data/handlebars.js +4071 -3721
  3. data/handlebars.runtime.js +840 -701
  4. metadata +2 -2
data/handlebars.runtime.js CHANGED
@@ -1,6 +1,6 @@
1
1
  /*!
2
2
 
3
- handlebars v3.0.0
3
+ handlebars v3.0.2
4
4
 
5
5
  Copyright (C) 2011-2014 by Yehuda Katz
6
6
 
@@ -24,703 +24,842 @@ THE SOFTWARE.
24
24
 
25
25
  @license
26
26
  */
27
- /* exported Handlebars */
28
- (function (root, factory) {
29
- if (typeof define === 'function' && define.amd) {
30
- define([], factory);
31
- } else if (typeof exports === 'object') {
32
- module.exports = factory();
33
- } else {
34
- root.Handlebars = factory();
35
- }
36
- }(this, function () {
37
- // handlebars/utils.js
38
- var __module2__ = (function() {
39
- "use strict";
40
- var __exports__ = {};
41
- /*jshint -W004 */
42
- var escape = {
43
- "&": "&",
44
- "<": "&lt;",
45
- ">": "&gt;",
46
- '"': "&quot;",
47
- "'": "&#x27;",
48
- "`": "&#x60;"
49
- };
50
-
51
- var badChars = /[&<>"'`]/g;
52
- var possible = /[&<>"'`]/;
53
-
54
- function escapeChar(chr) {
55
- return escape[chr];
56
- }
57
-
58
- function extend(obj /* , ...source */) {
59
- for (var i = 1; i < arguments.length; i++) {
60
- for (var key in arguments[i]) {
61
- if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
62
- obj[key] = arguments[i][key];
63
- }
64
- }
65
- }
66
-
67
- return obj;
68
- }
69
-
70
- __exports__.extend = extend;var toString = Object.prototype.toString;
71
- __exports__.toString = toString;
72
- // Sourced from lodash
73
- // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
74
- var isFunction = function(value) {
75
- return typeof value === 'function';
76
- };
77
- // fallback for older versions of Chrome and Safari
78
- /* istanbul ignore next */
79
- if (isFunction(/x/)) {
80
- isFunction = function(value) {
81
- return typeof value === 'function' && toString.call(value) === '[object Function]';
82
- };
83
- }
84
- var isFunction;
85
- __exports__.isFunction = isFunction;
86
- /* istanbul ignore next */
87
- var isArray = Array.isArray || function(value) {
88
- return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
89
- };
90
- __exports__.isArray = isArray;
91
- // Older IE versions do not directly support indexOf so we must implement our own, sadly.
92
- function indexOf(array, value) {
93
- for (var i = 0, len = array.length; i < len; i++) {
94
- if (array[i] === value) {
95
- return i;
96
- }
97
- }
98
- return -1;
99
- }
100
-
101
- __exports__.indexOf = indexOf;
102
- function escapeExpression(string) {
103
- // don't escape SafeStrings, since they're already safe
104
- if (string && string.toHTML) {
105
- return string.toHTML();
106
- } else if (string == null) {
107
- return "";
108
- } else if (!string) {
109
- return string + '';
110
- }
111
-
112
- // Force a string conversion as this will be done by the append regardless and
113
- // the regex test will do this transparently behind the scenes, causing issues if
114
- // an object's to string has escaped characters in it.
115
- string = "" + string;
116
-
117
- if(!possible.test(string)) { return string; }
118
- return string.replace(badChars, escapeChar);
119
- }
120
-
121
- __exports__.escapeExpression = escapeExpression;function isEmpty(value) {
122
- if (!value && value !== 0) {
123
- return true;
124
- } else if (isArray(value) && value.length === 0) {
125
- return true;
126
- } else {
127
- return false;
128
- }
129
- }
130
-
131
- __exports__.isEmpty = isEmpty;function blockParams(params, ids) {
132
- params.path = ids;
133
- return params;
134
- }
135
-
136
- __exports__.blockParams = blockParams;function appendContextPath(contextPath, id) {
137
- return (contextPath ? contextPath + '.' : '') + id;
138
- }
139
-
140
- __exports__.appendContextPath = appendContextPath;
141
- return __exports__;
142
- })();
143
-
144
- // handlebars/exception.js
145
- var __module3__ = (function() {
146
- "use strict";
147
- var __exports__;
148
-
149
- var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
150
-
151
- function Exception(message, node) {
152
- var loc = node && node.loc,
153
- line,
154
- column;
155
- if (loc) {
156
- line = loc.start.line;
157
- column = loc.start.column;
158
-
159
- message += ' - ' + line + ':' + column;
160
- }
161
-
162
- var tmp = Error.prototype.constructor.call(this, message);
163
-
164
- // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
165
- for (var idx = 0; idx < errorProps.length; idx++) {
166
- this[errorProps[idx]] = tmp[errorProps[idx]];
167
- }
168
-
169
- if (loc) {
170
- this.lineNumber = line;
171
- this.column = column;
172
- }
173
- }
174
-
175
- Exception.prototype = new Error();
176
-
177
- __exports__ = Exception;
178
- return __exports__;
179
- })();
180
-
181
- // handlebars/base.js
182
- var __module1__ = (function(__dependency1__, __dependency2__) {
183
- "use strict";
184
- var __exports__ = {};
185
- var Utils = __dependency1__;
186
- var Exception = __dependency2__;
187
-
188
- var VERSION = "3.0.0";
189
- __exports__.VERSION = VERSION;var COMPILER_REVISION = 6;
190
- __exports__.COMPILER_REVISION = COMPILER_REVISION;
191
- var REVISION_CHANGES = {
192
- 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
193
- 2: '== 1.0.0-rc.3',
194
- 3: '== 1.0.0-rc.4',
195
- 4: '== 1.x.x',
196
- 5: '== 2.0.0-alpha.x',
197
- 6: '>= 2.0.0-beta.1'
198
- };
199
- __exports__.REVISION_CHANGES = REVISION_CHANGES;
200
- var isArray = Utils.isArray,
201
- isFunction = Utils.isFunction,
202
- toString = Utils.toString,
203
- objectType = '[object Object]';
204
-
205
- function HandlebarsEnvironment(helpers, partials) {
206
- this.helpers = helpers || {};
207
- this.partials = partials || {};
208
-
209
- registerDefaultHelpers(this);
210
- }
211
-
212
- __exports__.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = {
213
- constructor: HandlebarsEnvironment,
214
-
215
- logger: logger,
216
- log: log,
217
-
218
- registerHelper: function(name, fn) {
219
- if (toString.call(name) === objectType) {
220
- if (fn) { throw new Exception('Arg not supported with multiple helpers'); }
221
- Utils.extend(this.helpers, name);
222
- } else {
223
- this.helpers[name] = fn;
224
- }
225
- },
226
- unregisterHelper: function(name) {
227
- delete this.helpers[name];
228
- },
229
-
230
- registerPartial: function(name, partial) {
231
- if (toString.call(name) === objectType) {
232
- Utils.extend(this.partials, name);
233
- } else {
234
- if (typeof partial === 'undefined') {
235
- throw new Exception('Attempting to register a partial as undefined');
236
- }
237
- this.partials[name] = partial;
238
- }
239
- },
240
- unregisterPartial: function(name) {
241
- delete this.partials[name];
242
- }
243
- };
244
-
245
- function registerDefaultHelpers(instance) {
246
- instance.registerHelper('helperMissing', function(/* [args, ]options */) {
247
- if(arguments.length === 1) {
248
- // A missing field in a {{foo}} constuct.
249
- return undefined;
250
- } else {
251
- // Someone is actually trying to call something, blow up.
252
- throw new Exception("Missing helper: '" + arguments[arguments.length-1].name + "'");
253
- }
254
- });
255
-
256
- instance.registerHelper('blockHelperMissing', function(context, options) {
257
- var inverse = options.inverse,
258
- fn = options.fn;
259
-
260
- if(context === true) {
261
- return fn(this);
262
- } else if(context === false || context == null) {
263
- return inverse(this);
264
- } else if (isArray(context)) {
265
- if(context.length > 0) {
266
- if (options.ids) {
267
- options.ids = [options.name];
268
- }
269
-
270
- return instance.helpers.each(context, options);
271
- } else {
272
- return inverse(this);
273
- }
274
- } else {
275
- if (options.data && options.ids) {
276
- var data = createFrame(options.data);
277
- data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
278
- options = {data: data};
279
- }
280
-
281
- return fn(context, options);
282
- }
283
- });
284
-
285
- instance.registerHelper('each', function(context, options) {
286
- if (!options) {
287
- throw new Exception('Must pass iterator to #each');
288
- }
289
-
290
- var fn = options.fn, inverse = options.inverse;
291
- var i = 0, ret = "", data;
292
-
293
- var contextPath;
294
- if (options.data && options.ids) {
295
- contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
296
- }
297
-
298
- if (isFunction(context)) { context = context.call(this); }
299
-
300
- if (options.data) {
301
- data = createFrame(options.data);
302
- }
303
-
304
- function execIteration(key, i, last) {
305
- if (data) {
306
- data.key = key;
307
- data.index = i;
308
- data.first = i === 0;
309
- data.last = !!last;
310
-
311
- if (contextPath) {
312
- data.contextPath = contextPath + key;
313
- }
314
- }
315
-
316
- ret = ret + fn(context[key], {
317
- data: data,
318
- blockParams: Utils.blockParams([context[key], key], [contextPath + key, null])
319
- });
320
- }
321
-
322
- if(context && typeof context === 'object') {
323
- if (isArray(context)) {
324
- for(var j = context.length; i<j; i++) {
325
- execIteration(i, i, i === context.length-1);
326
- }
327
- } else {
328
- var priorKey;
329
-
330
- for(var key in context) {
331
- if(context.hasOwnProperty(key)) {
332
- // We're running the iterations one step out of sync so we can detect
333
- // the last iteration without have to scan the object twice and create
334
- // an itermediate keys array.
335
- if (priorKey) {
336
- execIteration(priorKey, i-1);
337
- }
338
- priorKey = key;
339
- i++;
340
- }
341
- }
342
- if (priorKey) {
343
- execIteration(priorKey, i-1, true);
344
- }
345
- }
346
- }
347
-
348
- if(i === 0){
349
- ret = inverse(this);
350
- }
351
-
352
- return ret;
353
- });
354
-
355
- instance.registerHelper('if', function(conditional, options) {
356
- if (isFunction(conditional)) { conditional = conditional.call(this); }
357
-
358
- // Default behavior is to render the positive path if the value is truthy and not empty.
359
- // The `includeZero` option may be set to treat the condtional as purely not empty based on the
360
- // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
361
- if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) {
362
- return options.inverse(this);
363
- } else {
364
- return options.fn(this);
365
- }
366
- });
367
-
368
- instance.registerHelper('unless', function(conditional, options) {
369
- return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});
370
- });
371
-
372
- instance.registerHelper('with', function(context, options) {
373
- if (isFunction(context)) { context = context.call(this); }
374
-
375
- var fn = options.fn;
376
-
377
- if (!Utils.isEmpty(context)) {
378
- if (options.data && options.ids) {
379
- var data = createFrame(options.data);
380
- data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
381
- options = {data:data};
382
- }
383
-
384
- return fn(context, options);
385
- } else {
386
- return options.inverse(this);
387
- }
388
- });
389
-
390
- instance.registerHelper('log', function(message, options) {
391
- var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
392
- instance.log(level, message);
393
- });
394
-
395
- instance.registerHelper('lookup', function(obj, field) {
396
- return obj && obj[field];
397
- });
398
- }
399
-
400
- var logger = {
401
- methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },
402
-
403
- // State enum
404
- DEBUG: 0,
405
- INFO: 1,
406
- WARN: 2,
407
- ERROR: 3,
408
- level: 1,
409
-
410
- // Can be overridden in the host environment
411
- log: function(level, message) {
412
- if (typeof console !== 'undefined' && logger.level <= level) {
413
- var method = logger.methodMap[level];
414
- (console[method] || console.log).call(console, message);
415
- }
416
- }
417
- };
418
- __exports__.logger = logger;
419
- var log = logger.log;
420
- __exports__.log = log;
421
- var createFrame = function(object) {
422
- var frame = Utils.extend({}, object);
423
- frame._parent = object;
424
- return frame;
425
- };
426
- __exports__.createFrame = createFrame;
427
- return __exports__;
428
- })(__module2__, __module3__);
429
-
430
- // handlebars/safe-string.js
431
- var __module4__ = (function() {
432
- "use strict";
433
- var __exports__;
434
- // Build out our basic SafeString type
435
- function SafeString(string) {
436
- this.string = string;
437
- }
438
-
439
- SafeString.prototype.toString = SafeString.prototype.toHTML = function() {
440
- return "" + this.string;
441
- };
442
-
443
- __exports__ = SafeString;
444
- return __exports__;
445
- })();
446
-
447
- // handlebars/runtime.js
448
- var __module5__ = (function(__dependency1__, __dependency2__, __dependency3__) {
449
- "use strict";
450
- var __exports__ = {};
451
- var Utils = __dependency1__;
452
- var Exception = __dependency2__;
453
- var COMPILER_REVISION = __dependency3__.COMPILER_REVISION;
454
- var REVISION_CHANGES = __dependency3__.REVISION_CHANGES;
455
- var createFrame = __dependency3__.createFrame;
456
-
457
- function checkRevision(compilerInfo) {
458
- var compilerRevision = compilerInfo && compilerInfo[0] || 1,
459
- currentRevision = COMPILER_REVISION;
460
-
461
- if (compilerRevision !== currentRevision) {
462
- if (compilerRevision < currentRevision) {
463
- var runtimeVersions = REVISION_CHANGES[currentRevision],
464
- compilerVersions = REVISION_CHANGES[compilerRevision];
465
- throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+
466
- "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");
467
- } else {
468
- // Use the embedded version info since the runtime doesn't know about this revision yet
469
- throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+
470
- "Please update your runtime to a newer version ("+compilerInfo[1]+").");
471
- }
472
- }
473
- }
474
-
475
- __exports__.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial
476
-
477
- function template(templateSpec, env) {
478
- /* istanbul ignore next */
479
- if (!env) {
480
- throw new Exception("No environment passed to template");
481
- }
482
- if (!templateSpec || !templateSpec.main) {
483
- throw new Exception('Unknown template object: ' + typeof templateSpec);
484
- }
485
-
486
- // Note: Using env.VM references rather than local var references throughout this section to allow
487
- // for external users to override these as psuedo-supported APIs.
488
- env.VM.checkRevision(templateSpec.compiler);
489
-
490
- var invokePartialWrapper = function(partial, context, options) {
491
- if (options.hash) {
492
- context = Utils.extend({}, context, options.hash);
493
- }
494
-
495
- partial = env.VM.resolvePartial.call(this, partial, context, options);
496
- var result = env.VM.invokePartial.call(this, partial, context, options);
497
-
498
- if (result == null && env.compile) {
499
- options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
500
- result = options.partials[options.name](context, options);
501
- }
502
- if (result != null) {
503
- if (options.indent) {
504
- var lines = result.split('\n');
505
- for (var i = 0, l = lines.length; i < l; i++) {
506
- if (!lines[i] && i + 1 === l) {
507
- break;
508
- }
509
-
510
- lines[i] = options.indent + lines[i];
511
- }
512
- result = lines.join('\n');
513
- }
514
- return result;
515
- } else {
516
- throw new Exception("The partial " + options.name + " could not be compiled when running in runtime-only mode");
517
- }
518
- };
519
-
520
- // Just add water
521
- var container = {
522
- strict: function(obj, name) {
523
- if (!(name in obj)) {
524
- throw new Exception('"' + name + '" not defined in ' + obj);
525
- }
526
- return obj[name];
527
- },
528
- lookup: function(depths, name) {
529
- var len = depths.length;
530
- for (var i = 0; i < len; i++) {
531
- if (depths[i] && depths[i][name] != null) {
532
- return depths[i][name];
533
- }
534
- }
535
- },
536
- lambda: function(current, context) {
537
- return typeof current === 'function' ? current.call(context) : current;
538
- },
539
-
540
- escapeExpression: Utils.escapeExpression,
541
- invokePartial: invokePartialWrapper,
542
-
543
- fn: function(i) {
544
- return templateSpec[i];
545
- },
546
-
547
- programs: [],
548
- program: function(i, data, declaredBlockParams, blockParams, depths) {
549
- var programWrapper = this.programs[i],
550
- fn = this.fn(i);
551
- if (data || depths || blockParams || declaredBlockParams) {
552
- programWrapper = program(this, i, fn, data, declaredBlockParams, blockParams, depths);
553
- } else if (!programWrapper) {
554
- programWrapper = this.programs[i] = program(this, i, fn);
555
- }
556
- return programWrapper;
557
- },
558
-
559
- data: function(data, depth) {
560
- while (data && depth--) {
561
- data = data._parent;
562
- }
563
- return data;
564
- },
565
- merge: function(param, common) {
566
- var ret = param || common;
567
-
568
- if (param && common && (param !== common)) {
569
- ret = Utils.extend({}, common, param);
570
- }
571
-
572
- return ret;
573
- },
574
-
575
- noop: env.VM.noop,
576
- compilerInfo: templateSpec.compiler
577
- };
578
-
579
- var ret = function(context, options) {
580
- options = options || {};
581
- var data = options.data;
582
-
583
- ret._setup(options);
584
- if (!options.partial && templateSpec.useData) {
585
- data = initData(context, data);
586
- }
587
- var depths,
588
- blockParams = templateSpec.useBlockParams ? [] : undefined;
589
- if (templateSpec.useDepths) {
590
- depths = options.depths ? [context].concat(options.depths) : [context];
591
- }
592
-
593
- return templateSpec.main.call(container, context, container.helpers, container.partials, data, blockParams, depths);
594
- };
595
- ret.isTop = true;
596
-
597
- ret._setup = function(options) {
598
- if (!options.partial) {
599
- container.helpers = container.merge(options.helpers, env.helpers);
600
-
601
- if (templateSpec.usePartial) {
602
- container.partials = container.merge(options.partials, env.partials);
603
- }
604
- } else {
605
- container.helpers = options.helpers;
606
- container.partials = options.partials;
607
- }
608
- };
609
-
610
- ret._child = function(i, data, blockParams, depths) {
611
- if (templateSpec.useBlockParams && !blockParams) {
612
- throw new Exception('must pass block params');
613
- }
614
- if (templateSpec.useDepths && !depths) {
615
- throw new Exception('must pass parent depths');
616
- }
617
-
618
- return program(container, i, templateSpec[i], data, 0, blockParams, depths);
619
- };
620
- return ret;
621
- }
622
-
623
- __exports__.template = template;function program(container, i, fn, data, declaredBlockParams, blockParams, depths) {
624
- var prog = function(context, options) {
625
- options = options || {};
626
-
627
- return fn.call(container,
628
- context,
629
- container.helpers, container.partials,
630
- options.data || data,
631
- blockParams && [options.blockParams].concat(blockParams),
632
- depths && [context].concat(depths));
633
- };
634
- prog.program = i;
635
- prog.depth = depths ? depths.length : 0;
636
- prog.blockParams = declaredBlockParams || 0;
637
- return prog;
638
- }
639
-
640
- __exports__.program = program;function resolvePartial(partial, context, options) {
641
- if (!partial) {
642
- partial = options.partials[options.name];
643
- } else if (!partial.call && !options.name) {
644
- // This is a dynamic partial that returned a string
645
- options.name = partial;
646
- partial = options.partials[partial];
647
- }
648
- return partial;
649
- }
650
-
651
- __exports__.resolvePartial = resolvePartial;function invokePartial(partial, context, options) {
652
- options.partial = true;
653
-
654
- if(partial === undefined) {
655
- throw new Exception("The partial " + options.name + " could not be found");
656
- } else if(partial instanceof Function) {
657
- return partial(context, options);
658
- }
659
- }
660
-
661
- __exports__.invokePartial = invokePartial;function noop() { return ""; }
662
-
663
- __exports__.noop = noop;function initData(context, data) {
664
- if (!data || !('root' in data)) {
665
- data = data ? createFrame(data) : {};
666
- data.root = context;
667
- }
668
- return data;
669
- }
670
- return __exports__;
671
- })(__module2__, __module3__, __module1__);
672
-
673
- // handlebars.runtime.js
674
- var __module0__ = (function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
675
- "use strict";
676
- var __exports__;
677
- /*globals Handlebars: true */
678
- var base = __dependency1__;
679
-
680
- // Each of these augment the Handlebars object. No need to setup here.
681
- // (This is done to easily share code between commonjs and browse envs)
682
- var SafeString = __dependency2__;
683
- var Exception = __dependency3__;
684
- var Utils = __dependency4__;
685
- var runtime = __dependency5__;
686
-
687
- // For compatibility and usage outside of module systems, make the Handlebars object a namespace
688
- var create = function() {
689
- var hb = new base.HandlebarsEnvironment();
690
-
691
- Utils.extend(hb, base);
692
- hb.SafeString = SafeString;
693
- hb.Exception = Exception;
694
- hb.Utils = Utils;
695
- hb.escapeExpression = Utils.escapeExpression;
696
-
697
- hb.VM = runtime;
698
- hb.template = function(spec) {
699
- return runtime.template(spec, hb);
700
- };
701
-
702
- return hb;
703
- };
704
-
705
- var Handlebars = create();
706
- Handlebars.create = create;
707
-
708
- /*jshint -W040 */
709
- /* istanbul ignore next */
710
- var root = typeof global !== 'undefined' ? global : window,
711
- $Handlebars = root.Handlebars;
712
- /* istanbul ignore next */
713
- Handlebars.noConflict = function() {
714
- if (root.Handlebars === Handlebars) {
715
- root.Handlebars = $Handlebars;
716
- }
717
- };
718
-
719
- Handlebars['default'] = Handlebars;
720
-
721
- __exports__ = Handlebars;
722
- return __exports__;
723
- })(__module1__, __module4__, __module3__, __module2__, __module5__);
724
-
725
- return __module0__;
726
- }));
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
+ /* WEBPACK VAR INJECTION */(function(global) {'use strict';
84
+
85
+ var _interopRequireWildcard = __webpack_require__(6)['default'];
86
+
87
+ exports.__esModule = true;
88
+ /*global window */
89
+
90
+ var _import = __webpack_require__(1);
91
+
92
+ var base = _interopRequireWildcard(_import);
93
+
94
+ // Each of these augment the Handlebars object. No need to setup here.
95
+ // (This is done to easily share code between commonjs and browse envs)
96
+
97
+ var _SafeString = __webpack_require__(2);
98
+
99
+ var _SafeString2 = _interopRequireWildcard(_SafeString);
100
+
101
+ var _Exception = __webpack_require__(3);
102
+
103
+ var _Exception2 = _interopRequireWildcard(_Exception);
104
+
105
+ var _import2 = __webpack_require__(4);
106
+
107
+ var Utils = _interopRequireWildcard(_import2);
108
+
109
+ var _import3 = __webpack_require__(5);
110
+
111
+ var runtime = _interopRequireWildcard(_import3);
112
+
113
+ // For compatibility and usage outside of module systems, make the Handlebars object a namespace
114
+ function create() {
115
+ var hb = new base.HandlebarsEnvironment();
116
+
117
+ Utils.extend(hb, base);
118
+ hb.SafeString = _SafeString2['default'];
119
+ hb.Exception = _Exception2['default'];
120
+ hb.Utils = Utils;
121
+ hb.escapeExpression = Utils.escapeExpression;
122
+
123
+ hb.VM = runtime;
124
+ hb.template = function (spec) {
125
+ return runtime.template(spec, hb);
126
+ };
127
+
128
+ return hb;
129
+ }
130
+
131
+ var Handlebars = create();
132
+ Handlebars.create = create;
133
+
134
+ /*jshint -W040 */
135
+ /* istanbul ignore next */
136
+ var root = typeof global !== 'undefined' ? global : window,
137
+ $Handlebars = root.Handlebars;
138
+ /* istanbul ignore next */
139
+ Handlebars.noConflict = function () {
140
+ if (root.Handlebars === Handlebars) {
141
+ root.Handlebars = $Handlebars;
142
+ }
143
+ };
144
+
145
+ Handlebars['default'] = Handlebars;
146
+
147
+ exports['default'] = Handlebars;
148
+ module.exports = exports['default'];
149
+ /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
150
+
151
+ /***/ },
152
+ /* 1 */
153
+ /***/ function(module, exports, __webpack_require__) {
154
+
155
+ 'use strict';
156
+
157
+ var _interopRequireWildcard = __webpack_require__(6)['default'];
158
+
159
+ exports.__esModule = true;
160
+ exports.HandlebarsEnvironment = HandlebarsEnvironment;
161
+ exports.createFrame = createFrame;
162
+
163
+ var _import = __webpack_require__(4);
164
+
165
+ var Utils = _interopRequireWildcard(_import);
166
+
167
+ var _Exception = __webpack_require__(3);
168
+
169
+ var _Exception2 = _interopRequireWildcard(_Exception);
170
+
171
+ var VERSION = '3.0.1';
172
+ exports.VERSION = VERSION;
173
+ var COMPILER_REVISION = 6;
174
+
175
+ exports.COMPILER_REVISION = COMPILER_REVISION;
176
+ var REVISION_CHANGES = {
177
+ 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
178
+ 2: '== 1.0.0-rc.3',
179
+ 3: '== 1.0.0-rc.4',
180
+ 4: '== 1.x.x',
181
+ 5: '== 2.0.0-alpha.x',
182
+ 6: '>= 2.0.0-beta.1'
183
+ };
184
+
185
+ exports.REVISION_CHANGES = REVISION_CHANGES;
186
+ var isArray = Utils.isArray,
187
+ isFunction = Utils.isFunction,
188
+ toString = Utils.toString,
189
+ objectType = '[object Object]';
190
+
191
+ function HandlebarsEnvironment(helpers, partials) {
192
+ this.helpers = helpers || {};
193
+ this.partials = partials || {};
194
+
195
+ registerDefaultHelpers(this);
196
+ }
197
+
198
+ HandlebarsEnvironment.prototype = {
199
+ constructor: HandlebarsEnvironment,
200
+
201
+ logger: logger,
202
+ log: log,
203
+
204
+ registerHelper: function registerHelper(name, fn) {
205
+ if (toString.call(name) === objectType) {
206
+ if (fn) {
207
+ throw new _Exception2['default']('Arg not supported with multiple helpers');
208
+ }
209
+ Utils.extend(this.helpers, name);
210
+ } else {
211
+ this.helpers[name] = fn;
212
+ }
213
+ },
214
+ unregisterHelper: function unregisterHelper(name) {
215
+ delete this.helpers[name];
216
+ },
217
+
218
+ registerPartial: function registerPartial(name, partial) {
219
+ if (toString.call(name) === objectType) {
220
+ Utils.extend(this.partials, name);
221
+ } else {
222
+ if (typeof partial === 'undefined') {
223
+ throw new _Exception2['default']('Attempting to register a partial as undefined');
224
+ }
225
+ this.partials[name] = partial;
226
+ }
227
+ },
228
+ unregisterPartial: function unregisterPartial(name) {
229
+ delete this.partials[name];
230
+ }
231
+ };
232
+
233
+ function registerDefaultHelpers(instance) {
234
+ instance.registerHelper('helperMissing', function () {
235
+ if (arguments.length === 1) {
236
+ // A missing field in a {{foo}} constuct.
237
+ return undefined;
238
+ } else {
239
+ // Someone is actually trying to call something, blow up.
240
+ throw new _Exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
241
+ }
242
+ });
243
+
244
+ instance.registerHelper('blockHelperMissing', function (context, options) {
245
+ var inverse = options.inverse,
246
+ fn = options.fn;
247
+
248
+ if (context === true) {
249
+ return fn(this);
250
+ } else if (context === false || context == null) {
251
+ return inverse(this);
252
+ } else if (isArray(context)) {
253
+ if (context.length > 0) {
254
+ if (options.ids) {
255
+ options.ids = [options.name];
256
+ }
257
+
258
+ return instance.helpers.each(context, options);
259
+ } else {
260
+ return inverse(this);
261
+ }
262
+ } else {
263
+ if (options.data && options.ids) {
264
+ var data = createFrame(options.data);
265
+ data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
266
+ options = { data: data };
267
+ }
268
+
269
+ return fn(context, options);
270
+ }
271
+ });
272
+
273
+ instance.registerHelper('each', function (context, options) {
274
+ if (!options) {
275
+ throw new _Exception2['default']('Must pass iterator to #each');
276
+ }
277
+
278
+ var fn = options.fn,
279
+ inverse = options.inverse,
280
+ i = 0,
281
+ ret = '',
282
+ data = undefined,
283
+ contextPath = undefined;
284
+
285
+ if (options.data && options.ids) {
286
+ contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
287
+ }
288
+
289
+ if (isFunction(context)) {
290
+ context = context.call(this);
291
+ }
292
+
293
+ if (options.data) {
294
+ data = createFrame(options.data);
295
+ }
296
+
297
+ function execIteration(field, index, last) {
298
+ if (data) {
299
+ data.key = field;
300
+ data.index = index;
301
+ data.first = index === 0;
302
+ data.last = !!last;
303
+
304
+ if (contextPath) {
305
+ data.contextPath = contextPath + field;
306
+ }
307
+ }
308
+
309
+ ret = ret + fn(context[field], {
310
+ data: data,
311
+ blockParams: Utils.blockParams([context[field], field], [contextPath + field, null])
312
+ });
313
+ }
314
+
315
+ if (context && typeof context === 'object') {
316
+ if (isArray(context)) {
317
+ for (var j = context.length; i < j; i++) {
318
+ execIteration(i, i, i === context.length - 1);
319
+ }
320
+ } else {
321
+ var priorKey = undefined;
322
+
323
+ for (var key in context) {
324
+ if (context.hasOwnProperty(key)) {
325
+ // We're running the iterations one step out of sync so we can detect
326
+ // the last iteration without have to scan the object twice and create
327
+ // an itermediate keys array.
328
+ if (priorKey) {
329
+ execIteration(priorKey, i - 1);
330
+ }
331
+ priorKey = key;
332
+ i++;
333
+ }
334
+ }
335
+ if (priorKey) {
336
+ execIteration(priorKey, i - 1, true);
337
+ }
338
+ }
339
+ }
340
+
341
+ if (i === 0) {
342
+ ret = inverse(this);
343
+ }
344
+
345
+ return ret;
346
+ });
347
+
348
+ instance.registerHelper('if', function (conditional, options) {
349
+ if (isFunction(conditional)) {
350
+ conditional = conditional.call(this);
351
+ }
352
+
353
+ // Default behavior is to render the positive path if the value is truthy and not empty.
354
+ // The `includeZero` option may be set to treat the condtional as purely not empty based on the
355
+ // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
356
+ if (!options.hash.includeZero && !conditional || Utils.isEmpty(conditional)) {
357
+ return options.inverse(this);
358
+ } else {
359
+ return options.fn(this);
360
+ }
361
+ });
362
+
363
+ instance.registerHelper('unless', function (conditional, options) {
364
+ return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash });
365
+ });
366
+
367
+ instance.registerHelper('with', function (context, options) {
368
+ if (isFunction(context)) {
369
+ context = context.call(this);
370
+ }
371
+
372
+ var fn = options.fn;
373
+
374
+ if (!Utils.isEmpty(context)) {
375
+ if (options.data && options.ids) {
376
+ var data = createFrame(options.data);
377
+ data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
378
+ options = { data: data };
379
+ }
380
+
381
+ return fn(context, options);
382
+ } else {
383
+ return options.inverse(this);
384
+ }
385
+ });
386
+
387
+ instance.registerHelper('log', function (message, options) {
388
+ var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
389
+ instance.log(level, message);
390
+ });
391
+
392
+ instance.registerHelper('lookup', function (obj, field) {
393
+ return obj && obj[field];
394
+ });
395
+ }
396
+
397
+ var logger = {
398
+ methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },
399
+
400
+ // State enum
401
+ DEBUG: 0,
402
+ INFO: 1,
403
+ WARN: 2,
404
+ ERROR: 3,
405
+ level: 1,
406
+
407
+ // Can be overridden in the host environment
408
+ log: function log(level, message) {
409
+ if (typeof console !== 'undefined' && logger.level <= level) {
410
+ var method = logger.methodMap[level];
411
+ (console[method] || console.log).call(console, message); // eslint-disable-line no-console
412
+ }
413
+ }
414
+ };
415
+
416
+ exports.logger = logger;
417
+ var log = logger.log;
418
+
419
+ exports.log = log;
420
+
421
+ function createFrame(object) {
422
+ var frame = Utils.extend({}, object);
423
+ frame._parent = object;
424
+ return frame;
425
+ }
426
+
427
+ /* [args, ]options */
428
+
429
+ /***/ },
430
+ /* 2 */
431
+ /***/ function(module, exports, __webpack_require__) {
432
+
433
+ 'use strict';
434
+
435
+ exports.__esModule = true;
436
+ // Build out our basic SafeString type
437
+ function SafeString(string) {
438
+ this.string = string;
439
+ }
440
+
441
+ SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
442
+ return '' + this.string;
443
+ };
444
+
445
+ exports['default'] = SafeString;
446
+ module.exports = exports['default'];
447
+
448
+ /***/ },
449
+ /* 3 */
450
+ /***/ function(module, exports, __webpack_require__) {
451
+
452
+ 'use strict';
453
+
454
+ exports.__esModule = true;
455
+
456
+ var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
457
+
458
+ function Exception(message, node) {
459
+ var loc = node && node.loc,
460
+ line = undefined,
461
+ column = undefined;
462
+ if (loc) {
463
+ line = loc.start.line;
464
+ column = loc.start.column;
465
+
466
+ message += ' - ' + line + ':' + column;
467
+ }
468
+
469
+ var tmp = Error.prototype.constructor.call(this, message);
470
+
471
+ // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
472
+ for (var idx = 0; idx < errorProps.length; idx++) {
473
+ this[errorProps[idx]] = tmp[errorProps[idx]];
474
+ }
475
+
476
+ if (Error.captureStackTrace) {
477
+ Error.captureStackTrace(this, Exception);
478
+ }
479
+
480
+ if (loc) {
481
+ this.lineNumber = line;
482
+ this.column = column;
483
+ }
484
+ }
485
+
486
+ Exception.prototype = new Error();
487
+
488
+ exports['default'] = Exception;
489
+ module.exports = exports['default'];
490
+
491
+ /***/ },
492
+ /* 4 */
493
+ /***/ function(module, exports, __webpack_require__) {
494
+
495
+ 'use strict';
496
+
497
+ exports.__esModule = true;
498
+ exports.extend = extend;
499
+
500
+ // Older IE versions do not directly support indexOf so we must implement our own, sadly.
501
+ exports.indexOf = indexOf;
502
+ exports.escapeExpression = escapeExpression;
503
+ exports.isEmpty = isEmpty;
504
+ exports.blockParams = blockParams;
505
+ exports.appendContextPath = appendContextPath;
506
+ /*jshint -W004 */
507
+ var escape = {
508
+ '&': '&amp;',
509
+ '<': '&lt;',
510
+ '>': '&gt;',
511
+ '"': '&quot;',
512
+ '\'': '&#x27;',
513
+ '`': '&#x60;'
514
+ };
515
+
516
+ var badChars = /[&<>"'`]/g,
517
+ possible = /[&<>"'`]/;
518
+
519
+ function escapeChar(chr) {
520
+ return escape[chr];
521
+ }
522
+
523
+ function extend(obj /* , ...source */) {
524
+ for (var i = 1; i < arguments.length; i++) {
525
+ for (var key in arguments[i]) {
526
+ if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
527
+ obj[key] = arguments[i][key];
528
+ }
529
+ }
530
+ }
531
+
532
+ return obj;
533
+ }
534
+
535
+ var toString = Object.prototype.toString;
536
+
537
+ exports.toString = toString;
538
+ // Sourced from lodash
539
+ // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
540
+ /*eslint-disable func-style, no-var */
541
+ var isFunction = function isFunction(value) {
542
+ return typeof value === 'function';
543
+ };
544
+ // fallback for older versions of Chrome and Safari
545
+ /* istanbul ignore next */
546
+ if (isFunction(/x/)) {
547
+ exports.isFunction = isFunction = function (value) {
548
+ return typeof value === 'function' && toString.call(value) === '[object Function]';
549
+ };
550
+ }
551
+ var isFunction;
552
+ exports.isFunction = isFunction;
553
+ /*eslint-enable func-style, no-var */
554
+
555
+ /* istanbul ignore next */
556
+ var isArray = Array.isArray || function (value) {
557
+ return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
558
+ };exports.isArray = isArray;
559
+
560
+ function indexOf(array, value) {
561
+ for (var i = 0, len = array.length; i < len; i++) {
562
+ if (array[i] === value) {
563
+ return i;
564
+ }
565
+ }
566
+ return -1;
567
+ }
568
+
569
+ function escapeExpression(string) {
570
+ if (typeof string !== 'string') {
571
+ // don't escape SafeStrings, since they're already safe
572
+ if (string && string.toHTML) {
573
+ return string.toHTML();
574
+ } else if (string == null) {
575
+ return '';
576
+ } else if (!string) {
577
+ return string + '';
578
+ }
579
+
580
+ // Force a string conversion as this will be done by the append regardless and
581
+ // the regex test will do this transparently behind the scenes, causing issues if
582
+ // an object's to string has escaped characters in it.
583
+ string = '' + string;
584
+ }
585
+
586
+ if (!possible.test(string)) {
587
+ return string;
588
+ }
589
+ return string.replace(badChars, escapeChar);
590
+ }
591
+
592
+ function isEmpty(value) {
593
+ if (!value && value !== 0) {
594
+ return true;
595
+ } else if (isArray(value) && value.length === 0) {
596
+ return true;
597
+ } else {
598
+ return false;
599
+ }
600
+ }
601
+
602
+ function blockParams(params, ids) {
603
+ params.path = ids;
604
+ return params;
605
+ }
606
+
607
+ function appendContextPath(contextPath, id) {
608
+ return (contextPath ? contextPath + '.' : '') + id;
609
+ }
610
+
611
+ /***/ },
612
+ /* 5 */
613
+ /***/ function(module, exports, __webpack_require__) {
614
+
615
+ 'use strict';
616
+
617
+ var _interopRequireWildcard = __webpack_require__(6)['default'];
618
+
619
+ exports.__esModule = true;
620
+ exports.checkRevision = checkRevision;
621
+
622
+ // TODO: Remove this line and break up compilePartial
623
+
624
+ exports.template = template;
625
+ exports.wrapProgram = wrapProgram;
626
+ exports.resolvePartial = resolvePartial;
627
+ exports.invokePartial = invokePartial;
628
+ exports.noop = noop;
629
+
630
+ var _import = __webpack_require__(4);
631
+
632
+ var Utils = _interopRequireWildcard(_import);
633
+
634
+ var _Exception = __webpack_require__(3);
635
+
636
+ var _Exception2 = _interopRequireWildcard(_Exception);
637
+
638
+ var _COMPILER_REVISION$REVISION_CHANGES$createFrame = __webpack_require__(1);
639
+
640
+ function checkRevision(compilerInfo) {
641
+ var compilerRevision = compilerInfo && compilerInfo[0] || 1,
642
+ currentRevision = _COMPILER_REVISION$REVISION_CHANGES$createFrame.COMPILER_REVISION;
643
+
644
+ if (compilerRevision !== currentRevision) {
645
+ if (compilerRevision < currentRevision) {
646
+ var runtimeVersions = _COMPILER_REVISION$REVISION_CHANGES$createFrame.REVISION_CHANGES[currentRevision],
647
+ compilerVersions = _COMPILER_REVISION$REVISION_CHANGES$createFrame.REVISION_CHANGES[compilerRevision];
648
+ 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 + ').');
649
+ } else {
650
+ // Use the embedded version info since the runtime doesn't know about this revision yet
651
+ 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] + ').');
652
+ }
653
+ }
654
+ }
655
+
656
+ function template(templateSpec, env) {
657
+ /* istanbul ignore next */
658
+ if (!env) {
659
+ throw new _Exception2['default']('No environment passed to template');
660
+ }
661
+ if (!templateSpec || !templateSpec.main) {
662
+ throw new _Exception2['default']('Unknown template object: ' + typeof templateSpec);
663
+ }
664
+
665
+ // Note: Using env.VM references rather than local var references throughout this section to allow
666
+ // for external users to override these as psuedo-supported APIs.
667
+ env.VM.checkRevision(templateSpec.compiler);
668
+
669
+ function invokePartialWrapper(partial, context, options) {
670
+ if (options.hash) {
671
+ context = Utils.extend({}, context, options.hash);
672
+ }
673
+
674
+ partial = env.VM.resolvePartial.call(this, partial, context, options);
675
+ var result = env.VM.invokePartial.call(this, partial, context, options);
676
+
677
+ if (result == null && env.compile) {
678
+ options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
679
+ result = options.partials[options.name](context, options);
680
+ }
681
+ if (result != null) {
682
+ if (options.indent) {
683
+ var lines = result.split('\n');
684
+ for (var i = 0, l = lines.length; i < l; i++) {
685
+ if (!lines[i] && i + 1 === l) {
686
+ break;
687
+ }
688
+
689
+ lines[i] = options.indent + lines[i];
690
+ }
691
+ result = lines.join('\n');
692
+ }
693
+ return result;
694
+ } else {
695
+ throw new _Exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
696
+ }
697
+ }
698
+
699
+ // Just add water
700
+ var container = {
701
+ strict: function strict(obj, name) {
702
+ if (!(name in obj)) {
703
+ throw new _Exception2['default']('"' + name + '" not defined in ' + obj);
704
+ }
705
+ return obj[name];
706
+ },
707
+ lookup: function lookup(depths, name) {
708
+ var len = depths.length;
709
+ for (var i = 0; i < len; i++) {
710
+ if (depths[i] && depths[i][name] != null) {
711
+ return depths[i][name];
712
+ }
713
+ }
714
+ },
715
+ lambda: function lambda(current, context) {
716
+ return typeof current === 'function' ? current.call(context) : current;
717
+ },
718
+
719
+ escapeExpression: Utils.escapeExpression,
720
+ invokePartial: invokePartialWrapper,
721
+
722
+ fn: function fn(i) {
723
+ return templateSpec[i];
724
+ },
725
+
726
+ programs: [],
727
+ program: function program(i, data, declaredBlockParams, blockParams, depths) {
728
+ var programWrapper = this.programs[i],
729
+ fn = this.fn(i);
730
+ if (data || depths || blockParams || declaredBlockParams) {
731
+ programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
732
+ } else if (!programWrapper) {
733
+ programWrapper = this.programs[i] = wrapProgram(this, i, fn);
734
+ }
735
+ return programWrapper;
736
+ },
737
+
738
+ data: function data(value, depth) {
739
+ while (value && depth--) {
740
+ value = value._parent;
741
+ }
742
+ return value;
743
+ },
744
+ merge: function merge(param, common) {
745
+ var obj = param || common;
746
+
747
+ if (param && common && param !== common) {
748
+ obj = Utils.extend({}, common, param);
749
+ }
750
+
751
+ return obj;
752
+ },
753
+
754
+ noop: env.VM.noop,
755
+ compilerInfo: templateSpec.compiler
756
+ };
757
+
758
+ function ret(context) {
759
+ var options = arguments[1] === undefined ? {} : arguments[1];
760
+
761
+ var data = options.data;
762
+
763
+ ret._setup(options);
764
+ if (!options.partial && templateSpec.useData) {
765
+ data = initData(context, data);
766
+ }
767
+ var depths = undefined,
768
+ blockParams = templateSpec.useBlockParams ? [] : undefined;
769
+ if (templateSpec.useDepths) {
770
+ depths = options.depths ? [context].concat(options.depths) : [context];
771
+ }
772
+
773
+ return templateSpec.main.call(container, context, container.helpers, container.partials, data, blockParams, depths);
774
+ }
775
+ ret.isTop = true;
776
+
777
+ ret._setup = function (options) {
778
+ if (!options.partial) {
779
+ container.helpers = container.merge(options.helpers, env.helpers);
780
+
781
+ if (templateSpec.usePartial) {
782
+ container.partials = container.merge(options.partials, env.partials);
783
+ }
784
+ } else {
785
+ container.helpers = options.helpers;
786
+ container.partials = options.partials;
787
+ }
788
+ };
789
+
790
+ ret._child = function (i, data, blockParams, depths) {
791
+ if (templateSpec.useBlockParams && !blockParams) {
792
+ throw new _Exception2['default']('must pass block params');
793
+ }
794
+ if (templateSpec.useDepths && !depths) {
795
+ throw new _Exception2['default']('must pass parent depths');
796
+ }
797
+
798
+ return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
799
+ };
800
+ return ret;
801
+ }
802
+
803
+ function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
804
+ function prog(context) {
805
+ var options = arguments[1] === undefined ? {} : arguments[1];
806
+
807
+ return fn.call(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), depths && [context].concat(depths));
808
+ }
809
+ prog.program = i;
810
+ prog.depth = depths ? depths.length : 0;
811
+ prog.blockParams = declaredBlockParams || 0;
812
+ return prog;
813
+ }
814
+
815
+ function resolvePartial(partial, context, options) {
816
+ if (!partial) {
817
+ partial = options.partials[options.name];
818
+ } else if (!partial.call && !options.name) {
819
+ // This is a dynamic partial that returned a string
820
+ options.name = partial;
821
+ partial = options.partials[partial];
822
+ }
823
+ return partial;
824
+ }
825
+
826
+ function invokePartial(partial, context, options) {
827
+ options.partial = true;
828
+
829
+ if (partial === undefined) {
830
+ throw new _Exception2['default']('The partial ' + options.name + ' could not be found');
831
+ } else if (partial instanceof Function) {
832
+ return partial(context, options);
833
+ }
834
+ }
835
+
836
+ function noop() {
837
+ return '';
838
+ }
839
+
840
+ function initData(context, data) {
841
+ if (!data || !('root' in data)) {
842
+ data = data ? _COMPILER_REVISION$REVISION_CHANGES$createFrame.createFrame(data) : {};
843
+ data.root = context;
844
+ }
845
+ return data;
846
+ }
847
+
848
+ /***/ },
849
+ /* 6 */
850
+ /***/ function(module, exports, __webpack_require__) {
851
+
852
+ "use strict";
853
+
854
+ exports["default"] = function (obj) {
855
+ return obj && obj.__esModule ? obj : {
856
+ "default": obj
857
+ };
858
+ };
859
+
860
+ exports.__esModule = true;
861
+
862
+ /***/ }
863
+ /******/ ])
864
+ });
865
+ ;