ember-source 1.10.1 → 1.11.0.beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.


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

@@ -1,29 +1,42 @@
1
1
  /*!
2
2
  * @overview Ember - JavaScript Application Framework
3
- * @copyright Copyright 2011-2014 Tilde Inc. and contributors
3
+ * @copyright Copyright 2011-2015 Tilde Inc. and contributors
4
4
  * Portions Copyright 2006-2011 Strobe Inc.
5
5
  * Portions Copyright 2008-2011 Apple Inc. All rights reserved.
6
6
  * @license Licensed under MIT license
7
7
  * See https://raw.github.com/emberjs/ember.js/master/LICENSE
8
- * @version 1.10.1
8
+ * @version 1.11.0-beta.1
9
9
  */
10
10
 
11
11
  (function() {
12
- var define, requireModule, require, requirejs, Ember;
12
+ var enifed, requireModule, eriuqer, requirejs, Ember;
13
+ var mainContext = this;
13
14
 
14
15
  (function() {
16
+
15
17
  Ember = this.Ember = this.Ember || {};
16
18
  if (typeof Ember === 'undefined') { Ember = {}; };
17
19
  function UNDEFINED() { }
18
20
 
19
21
  if (typeof Ember.__loader === 'undefined') {
20
- var registry = {}, seen = {};
22
+ var registry = {};
23
+ var seen = {};
24
+
25
+ enifed = function(name, deps, callback) {
26
+ var value = { };
27
+
28
+ if (!callback) {
29
+ value.deps = [];
30
+ value.callback = deps;
31
+ } else {
32
+ value.deps = deps;
33
+ value.callback = callback;
34
+ }
21
35
 
22
- define = function(name, deps, callback) {
23
- registry[name] = { deps: deps, callback: callback };
36
+ registry[name] = value;
24
37
  };
25
38
 
26
- requirejs = require = requireModule = function(name) {
39
+ requirejs = eriuqer = requireModule = function(name) {
27
40
  var s = seen[name];
28
41
 
29
42
  if (s !== undefined) { return seen[name]; }
@@ -65,9 +78,13 @@ var define, requireModule, require, requirejs, Ember;
65
78
  for (var i=0, l=parts.length; i<l; i++) {
66
79
  var part = parts[i];
67
80
 
68
- if (part === '..') { parentBase.pop(); }
69
- else if (part === '.') { continue; }
70
- else { parentBase.push(part); }
81
+ if (part === '..') {
82
+ parentBase.pop();
83
+ } else if (part === '.') {
84
+ continue;
85
+ } else {
86
+ parentBase.push(part);
87
+ }
71
88
  }
72
89
 
73
90
  return parentBase.join('/');
@@ -76,599 +93,580 @@ var define, requireModule, require, requirejs, Ember;
76
93
  requirejs._eak_seen = registry;
77
94
 
78
95
  Ember.__loader = {
79
- define: define,
80
- require: require,
96
+ define: enifed,
97
+ require: eriuqer,
81
98
  registry: registry
82
99
  };
83
100
  } else {
84
- define = Ember.__loader.define;
85
- requirejs = require = requireModule = Ember.__loader.require;
101
+ enifed = Ember.__loader.define;
102
+ requirejs = eriuqer = requireModule = Ember.__loader.require;
86
103
  }
87
104
  })();
88
105
 
89
- define("ember-metal/core",
90
- ["exports"],
91
- function(__exports__) {
92
- "use strict";
93
- /*globals Ember:true,ENV,EmberENV,MetamorphENV:true */
106
+ enifed('ember-metal/core', ['exports'], function (exports) {
94
107
 
95
- /**
96
- @module ember
97
- @submodule ember-metal
98
- */
108
+ 'use strict';
99
109
 
100
- /**
101
- All Ember methods and functions are defined inside of this namespace. You
102
- generally should not add new properties to this namespace as it may be
103
- overwritten by future versions of Ember.
110
+ exports.K = K;
104
111
 
105
- You can also use the shorthand `Em` instead of `Ember`.
112
+ /*globals Ember:true,ENV,EmberENV */
106
113
 
107
- Ember-Runtime is a framework that provides core functions for Ember including
108
- cross-platform functions, support for property observing and objects. Its
109
- focus is on small size and performance. You can use this in place of or
110
- along-side other cross-platform libraries such as jQuery.
114
+ /**
115
+ @module ember
116
+ @submodule ember-metal
117
+ */
111
118
 
112
- The core Runtime framework is based on the jQuery API with a number of
113
- performance optimizations.
119
+ /**
120
+ All Ember methods and functions are defined inside of this namespace. You
121
+ generally should not add new properties to this namespace as it may be
122
+ overwritten by future versions of Ember.
114
123
 
115
- @class Ember
116
- @static
117
- @version 1.10.1
118
- */
124
+ You can also use the shorthand `Em` instead of `Ember`.
119
125
 
120
- if ('undefined' === typeof Ember) {
121
- // Create core object. Make it act like an instance of Ember.Namespace so that
122
- // objects assigned to it are given a sane string representation.
123
- Ember = {};
124
- }
126
+ Ember-Runtime is a framework that provides core functions for Ember including
127
+ cross-platform functions, support for property observing and objects. Its
128
+ focus is on small size and performance. You can use this in place of or
129
+ along-side other cross-platform libraries such as jQuery.
125
130
 
126
- // Default imports, exports and lookup to the global object;
127
- Ember.imports = Ember.imports || this;
128
- Ember.lookup = Ember.lookup || this;
129
- var exports = Ember.exports = Ember.exports || this;
131
+ The core Runtime framework is based on the jQuery API with a number of
132
+ performance optimizations.
130
133
 
131
- // aliases needed to keep minifiers from removing the global context
132
- exports.Em = exports.Ember = Ember;
134
+ @class Ember
135
+ @static
136
+ @version 1.11.0-beta.1
137
+ */
133
138
 
134
- // Make sure these are set whether Ember was already defined or not
139
+ if ('undefined' === typeof Ember) {
140
+ // Create core object. Make it act like an instance of Ember.Namespace so that
141
+ // objects assigned to it are given a sane string representation.
142
+ Ember = {};
143
+ }
135
144
 
136
- Ember.isNamespace = true;
145
+ // Default imports, exports and lookup to the global object;
146
+ var global = mainContext || {}; // jshint ignore:line
147
+ Ember.imports = Ember.imports || global;
148
+ Ember.lookup = Ember.lookup || global;
149
+ var emExports = Ember.exports = Ember.exports || global;
137
150
 
138
- Ember.toString = function() { return "Ember"; };
151
+ // aliases needed to keep minifiers from removing the global context
152
+ emExports.Em = emExports.Ember = Ember;
139
153
 
154
+ // Make sure these are set whether Ember was already defined or not
140
155
 
141
- /**
142
- @property VERSION
143
- @type String
144
- @default '1.10.1'
145
- @static
146
- */
147
- Ember.VERSION = '1.10.1';
156
+ Ember.isNamespace = true;
148
157
 
149
- /**
150
- Standard environmental variables. You can define these in a global `EmberENV`
151
- variable before loading Ember to control various configuration settings.
152
-
153
- For backwards compatibility with earlier versions of Ember the global `ENV`
154
- variable will be used if `EmberENV` is not defined.
155
-
156
- @property ENV
157
- @type Hash
158
- */
159
-
160
- if (Ember.ENV) {
161
- // do nothing if Ember.ENV is already setup
162
- } else if ('undefined' !== typeof EmberENV) {
163
- Ember.ENV = EmberENV;
164
- } else if('undefined' !== typeof ENV) {
165
- Ember.ENV = ENV;
166
- } else {
167
- Ember.ENV = {};
168
- }
158
+ Ember.toString = function() { return "Ember"; };
169
159
 
170
- Ember.config = Ember.config || {};
171
160
 
172
- // We disable the RANGE API by default for performance reasons
173
- if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
174
- Ember.ENV.DISABLE_RANGE_API = true;
175
- }
161
+ /**
162
+ @property VERSION
163
+ @type String
164
+ @default '1.11.0-beta.1'
165
+ @static
166
+ */
167
+ Ember.VERSION = '1.11.0-beta.1';
176
168
 
177
- if ("undefined" === typeof MetamorphENV) {
178
- exports.MetamorphENV = {};
179
- }
169
+ /**
170
+ Standard environmental variables. You can define these in a global `EmberENV`
171
+ variable before loading Ember to control various configuration settings.
180
172
 
181
- MetamorphENV.DISABLE_RANGE_API = Ember.ENV.DISABLE_RANGE_API;
173
+ For backwards compatibility with earlier versions of Ember the global `ENV`
174
+ variable will be used if `EmberENV` is not defined.
182
175
 
183
- /**
184
- Hash of enabled Canary features. Add to this before creating your application.
176
+ @property ENV
177
+ @type Hash
178
+ */
185
179
 
186
- You can also define `EmberENV.FEATURES` if you need to enable features flagged at runtime.
180
+ if (Ember.ENV) {
181
+ // do nothing if Ember.ENV is already setup
182
+ Ember.assert('Ember.ENV should be an object.', 'object' !== typeof Ember.ENV);
183
+ } else if ('undefined' !== typeof EmberENV) {
184
+ Ember.ENV = EmberENV;
185
+ } else if ('undefined' !== typeof ENV) {
186
+ Ember.ENV = ENV;
187
+ } else {
188
+ Ember.ENV = {};
189
+ }
187
190
 
188
- @class FEATURES
189
- @namespace Ember
190
- @static
191
- @since 1.1.0
192
- */
191
+ Ember.config = Ember.config || {};
193
192
 
194
- Ember.FEATURES = Ember.ENV.FEATURES || {};
193
+ // We disable the RANGE API by default for performance reasons
194
+ if ('undefined' === typeof Ember.ENV.DISABLE_RANGE_API) {
195
+ Ember.ENV.DISABLE_RANGE_API = true;
196
+ }
195
197
 
196
- /**
197
- Test that a feature is enabled. Parsed by Ember's build tools to leave
198
- experimental features out of beta/stable builds.
198
+ /**
199
+ Hash of enabled Canary features. Add to this before creating your application.
199
200
 
200
- You can define the following configuration options:
201
+ You can also define `EmberENV.FEATURES` if you need to enable features flagged at runtime.
201
202
 
202
- * `EmberENV.ENABLE_ALL_FEATURES` - force all features to be enabled.
203
- * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
204
- enabled/disabled.
203
+ @class FEATURES
204
+ @namespace Ember
205
+ @static
206
+ @since 1.1.0
207
+ */
205
208
 
206
- @method isEnabled
207
- @param {String} feature
208
- @return {Boolean}
209
- @for Ember.FEATURES
210
- @since 1.1.0
211
- */
209
+ Ember.FEATURES = Ember.ENV.FEATURES;
212
210
 
213
- Ember.FEATURES.isEnabled = function(feature) {
214
- var featureValue = Ember.FEATURES[feature];
211
+ if (!Ember.FEATURES) {
212
+ Ember.FEATURES = {"features-stripped-test":null,"ember-routing-named-substates":true,"ember-metal-injected-properties":true,"mandatory-setter":true,"ember-htmlbars":true,"ember-htmlbars-block-params":true,"ember-htmlbars-component-generation":null,"ember-htmlbars-component-helper":true,"ember-htmlbars-inline-if-helper":true,"ember-htmlbars-attribute-syntax":true,"ember-routing-transitioning-classes":true,"new-computed-syntax":null,"ember-testing-checkbox-helpers":null,"ember-metal-stream":null,"ember-htmlbars-each-with-index":true,"ember-application-instance-initializers":null,"ember-application-initializer-context":null,"ember-router-willtransition":true,"ember-application-visit":null}; //jshint ignore:line
213
+ }
215
214
 
216
- if (Ember.ENV.ENABLE_ALL_FEATURES) {
217
- return true;
218
- } else if (featureValue === true || featureValue === false || featureValue === undefined) {
219
- return featureValue;
220
- } else if (Ember.ENV.ENABLE_OPTIONAL_FEATURES) {
221
- return true;
222
- } else {
223
- return false;
224
- }
225
- };
215
+ /**
216
+ Test that a feature is enabled. Parsed by Ember's build tools to leave
217
+ experimental features out of beta/stable builds.
226
218
 
227
- // ..........................................................
228
- // BOOTSTRAP
229
- //
219
+ You can define the following configuration options:
230
220
 
231
- /**
232
- Determines whether Ember should enhance some built-in object prototypes to
233
- provide a more friendly API. If enabled, a few methods will be added to
234
- `Function`, `String`, and `Array`. `Object.prototype` will not be enhanced,
235
- which is the one that causes most trouble for people.
236
-
237
- In general we recommend leaving this option set to true since it rarely
238
- conflicts with other code. If you need to turn it off however, you can
239
- define an `EmberENV.EXTEND_PROTOTYPES` config to disable it.
240
-
241
- @property EXTEND_PROTOTYPES
242
- @type Boolean
243
- @default true
244
- @for Ember
245
- */
246
- Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
247
-
248
- if (typeof Ember.EXTEND_PROTOTYPES === 'undefined') {
249
- Ember.EXTEND_PROTOTYPES = true;
221
+ * `EmberENV.ENABLE_ALL_FEATURES` - force all features to be enabled.
222
+ * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
223
+ enabled/disabled.
224
+
225
+ @method isEnabled
226
+ @param {String} feature
227
+ @return {Boolean}
228
+ @for Ember.FEATURES
229
+ @since 1.1.0
230
+ */
231
+
232
+ Ember.FEATURES.isEnabled = function(feature) {
233
+ var featureValue = Ember.FEATURES[feature];
234
+
235
+ if (Ember.ENV.ENABLE_ALL_FEATURES) {
236
+ return true;
237
+ } else if (featureValue === true || featureValue === false || featureValue === undefined) {
238
+ return featureValue;
239
+ } else if (Ember.ENV.ENABLE_OPTIONAL_FEATURES) {
240
+ return true;
241
+ } else {
242
+ return false;
250
243
  }
244
+ };
251
245
 
252
- /**
253
- Determines whether Ember logs a full stack trace during deprecation warnings
246
+ // ..........................................................
247
+ // BOOTSTRAP
248
+ //
254
249
 
255
- @property LOG_STACKTRACE_ON_DEPRECATION
256
- @type Boolean
257
- @default true
258
- */
259
- Ember.LOG_STACKTRACE_ON_DEPRECATION = (Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false);
250
+ /**
251
+ Determines whether Ember should enhance some built-in object prototypes to
252
+ provide a more friendly API. If enabled, a few methods will be added to
253
+ `Function`, `String`, and `Array`. `Object.prototype` will not be enhanced,
254
+ which is the one that causes most trouble for people.
260
255
 
261
- /**
262
- Determines whether Ember should add ECMAScript 5 Array shims to older browsers.
256
+ In general we recommend leaving this option set to true since it rarely
257
+ conflicts with other code. If you need to turn it off however, you can
258
+ define an `EmberENV.EXTEND_PROTOTYPES` config to disable it.
263
259
 
264
- @property SHIM_ES5
265
- @type Boolean
266
- @default Ember.EXTEND_PROTOTYPES
267
- */
268
- Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
260
+ @property EXTEND_PROTOTYPES
261
+ @type Boolean
262
+ @default true
263
+ @for Ember
264
+ */
265
+ Ember.EXTEND_PROTOTYPES = Ember.ENV.EXTEND_PROTOTYPES;
269
266
 
270
- /**
271
- Determines whether Ember logs info about version of used libraries
267
+ if (typeof Ember.EXTEND_PROTOTYPES === 'undefined') {
268
+ Ember.EXTEND_PROTOTYPES = true;
269
+ }
272
270
 
273
- @property LOG_VERSION
274
- @type Boolean
275
- @default true
276
- */
277
- Ember.LOG_VERSION = (Ember.ENV.LOG_VERSION === false) ? false : true;
271
+ /**
272
+ Determines whether Ember logs a full stack trace during deprecation warnings
273
+
274
+ @property LOG_STACKTRACE_ON_DEPRECATION
275
+ @type Boolean
276
+ @default true
277
+ */
278
+ Ember.LOG_STACKTRACE_ON_DEPRECATION = (Ember.ENV.LOG_STACKTRACE_ON_DEPRECATION !== false);
279
+
280
+ /**
281
+ Determines whether Ember should add ECMAScript 5 Array shims to older browsers.
282
+
283
+ @property SHIM_ES5
284
+ @type Boolean
285
+ @default Ember.EXTEND_PROTOTYPES
286
+ */
287
+ Ember.SHIM_ES5 = (Ember.ENV.SHIM_ES5 === false) ? false : Ember.EXTEND_PROTOTYPES;
288
+
289
+ /**
290
+ Determines whether Ember logs info about version of used libraries
291
+
292
+ @property LOG_VERSION
293
+ @type Boolean
294
+ @default true
295
+ */
296
+ Ember.LOG_VERSION = (Ember.ENV.LOG_VERSION === false) ? false : true;
297
+
298
+ /**
299
+ Empty function. Useful for some operations. Always returns `this`.
300
+
301
+ @method K
302
+ @private
303
+ @return {Object}
304
+ */
305
+ function K() { return this; }
306
+ Ember.K = K;
307
+ //TODO: ES6 GLOBAL TODO
308
+
309
+ // Stub out the methods defined by the ember-debug package in case it's not loaded
310
+
311
+ if ('undefined' === typeof Ember.assert) { Ember.assert = K; }
312
+ if ('undefined' === typeof Ember.warn) { Ember.warn = K; }
313
+ if ('undefined' === typeof Ember.debug) { Ember.debug = K; }
314
+ if ('undefined' === typeof Ember.runInDebug) { Ember.runInDebug = K; }
315
+ if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = K; }
316
+ if ('undefined' === typeof Ember.deprecateFunc) {
317
+ Ember.deprecateFunc = function(_, func) { return func; };
318
+ }
278
319
 
279
- /**
280
- Empty function. Useful for some operations. Always returns `this`.
281
-
282
- @method K
283
- @private
284
- @return {Object}
285
- */
286
- function K() { return this; }
287
- __exports__.K = K;
288
- Ember.K = K;
289
- //TODO: ES6 GLOBAL TODO
290
-
291
- // Stub out the methods defined by the ember-debug package in case it's not loaded
292
-
293
- if ('undefined' === typeof Ember.assert) { Ember.assert = K; }
294
- if ('undefined' === typeof Ember.warn) { Ember.warn = K; }
295
- if ('undefined' === typeof Ember.debug) { Ember.debug = K; }
296
- if ('undefined' === typeof Ember.runInDebug) { Ember.runInDebug = K; }
297
- if ('undefined' === typeof Ember.deprecate) { Ember.deprecate = K; }
298
- if ('undefined' === typeof Ember.deprecateFunc) {
299
- Ember.deprecateFunc = function(_, func) { return func; };
300
- }
320
+ exports['default'] = Ember;
301
321
 
302
- __exports__["default"] = Ember;
303
- });
304
- define("ember-template-compiler",
305
- ["ember-metal/core","ember-template-compiler/system/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template","ember-template-compiler/plugins","ember-template-compiler/plugins/transform-each-in-to-hash","ember-template-compiler/plugins/transform-with-as-to-hash","ember-template-compiler/compat","exports"],
306
- function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
307
- "use strict";
308
- var _Ember = __dependency1__["default"];
309
- var precompile = __dependency2__["default"];
310
- var compile = __dependency3__["default"];
311
- var template = __dependency4__["default"];
312
- var registerPlugin = __dependency5__.registerPlugin;
322
+ });
323
+ enifed('ember-template-compiler', ['exports', 'ember-metal/core', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template', 'ember-template-compiler/plugins', 'ember-template-compiler/plugins/transform-each-in-to-hash', 'ember-template-compiler/plugins/transform-with-as-to-hash', 'ember-template-compiler/compat'], function (exports, _Ember, precompile, compile, template, plugins, TransformEachInToHash, TransformWithAsToHash) {
313
324
 
314
- var TransformEachInToHash = __dependency6__["default"];
315
- var TransformWithAsToHash = __dependency7__["default"];
325
+ 'use strict';
316
326
 
317
- // used for adding Ember.Handlebars.compile for backwards compat
327
+ plugins.registerPlugin('ast', TransformWithAsToHash['default']);
328
+ plugins.registerPlugin('ast', TransformEachInToHash['default']);
318
329
 
319
- registerPlugin('ast', TransformWithAsToHash);
320
- registerPlugin('ast', TransformEachInToHash);
330
+ exports._Ember = _Ember['default'];
331
+ exports.precompile = precompile['default'];
332
+ exports.compile = compile['default'];
333
+ exports.template = template['default'];
334
+ exports.registerPlugin = plugins.registerPlugin;
321
335
 
322
- __exports__._Ember = _Ember;
323
- __exports__.precompile = precompile;
324
- __exports__.compile = compile;
325
- __exports__.template = template;
326
- __exports__.registerPlugin = registerPlugin;
327
- });
328
- define("ember-template-compiler/compat",
329
- ["ember-metal/core","ember-template-compiler/compat/precompile","ember-template-compiler/system/compile","ember-template-compiler/system/template"],
330
- function(__dependency1__, __dependency2__, __dependency3__, __dependency4__) {
331
- "use strict";
332
- var Ember = __dependency1__["default"];
333
- var precompile = __dependency2__["default"];
334
- var compile = __dependency3__["default"];
335
- var template = __dependency4__["default"];
336
+ });
337
+ enifed('ember-template-compiler/compat', ['ember-metal/core', 'ember-template-compiler/compat/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template'], function (Ember, precompile, compile, template) {
336
338
 
337
- var EmberHandlebars = Ember.Handlebars = Ember.Handlebars || {};
339
+ 'use strict';
338
340
 
339
- EmberHandlebars.precompile = precompile;
340
- EmberHandlebars.compile = compile;
341
- EmberHandlebars.template = template;
342
- });
343
- define("ember-template-compiler/compat/precompile",
344
- ["exports"],
345
- function(__exports__) {
346
- "use strict";
347
- /**
348
- @module ember
349
- @submodule ember-template-compiler
350
- */
341
+ var EmberHandlebars = Ember['default'].Handlebars = Ember['default'].Handlebars || {};
351
342
 
352
- var compile, compileSpec;
343
+ EmberHandlebars.precompile = precompile['default'];
344
+ EmberHandlebars.compile = compile['default'];
345
+ EmberHandlebars.template = template['default'];
353
346
 
354
- __exports__["default"] = function(string) {
355
- if ((!compile || !compileSpec) && Ember.__loader.registry['htmlbars-compiler/compiler']) {
356
- var Compiler = requireModule('htmlbars-compiler/compiler');
347
+ });
348
+ enifed('ember-template-compiler/compat/precompile', ['exports'], function (exports) {
357
349
 
358
- compile = Compiler.compile;
359
- compileSpec = Compiler.compileSpec;
360
- }
350
+ 'use strict';
361
351
 
362
- if (!compile || !compileSpec) {
363
- throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.');
364
- }
352
+ /**
353
+ @module ember
354
+ @submodule ember-template-compiler
355
+ */
356
+
357
+ var compile, compileSpec;
365
358
 
366
- var asObject = arguments[1] === undefined ? true : arguments[1];
367
- var compileFunc = asObject ? compile : compileSpec;
359
+ exports['default'] = function(string) {
360
+ if ((!compile || !compileSpec) && Ember.__loader.registry['htmlbars-compiler/compiler']) {
361
+ var Compiler = requireModule('htmlbars-compiler/compiler');
368
362
 
369
- return compileFunc(string);
363
+ compile = Compiler.compile;
364
+ compileSpec = Compiler.compileSpec;
370
365
  }
371
- });
372
- define("ember-template-compiler/plugins",
373
- ["exports"],
374
- function(__exports__) {
375
- "use strict";
376
- /**
377
- @module ember
378
- @submodule ember-template-compiler
379
- */
380
366
 
381
- /**
382
- @private
383
- @property helpers
384
- */
385
- var plugins = {
386
- ast: [ ]
387
- };
367
+ if (!compile || !compileSpec) {
368
+ throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.');
369
+ }
388
370
 
389
- /**
390
- Adds an AST plugin to be used by Ember.HTMLBars.compile.
391
-
392
- @private
393
- @method registerASTPlugin
394
- */
395
- function registerPlugin(type, Plugin) {
396
- if (!plugins[type]) {
397
- throw new Error('Attempting to register "' + Plugin + '" as "' + type + '" which is not a valid HTMLBars plugin type.');
398
- }
371
+ var asObject = arguments[1] === undefined ? true : arguments[1];
372
+ var compileFunc = asObject ? compile : compileSpec;
399
373
 
400
- plugins[type].push(Plugin);
401
- }
374
+ return compileFunc(string);
375
+ }
402
376
 
403
- __exports__.registerPlugin = registerPlugin;__exports__["default"] = plugins;
404
- });
405
- define("ember-template-compiler/plugins/transform-each-in-to-hash",
406
- ["exports"],
407
- function(__exports__) {
408
- "use strict";
409
- /**
410
- @module ember
411
- @submodule ember-htmlbars
412
- */
377
+ });
378
+ enifed('ember-template-compiler/plugins', ['exports'], function (exports) {
413
379
 
380
+ 'use strict';
414
381
 
415
- /**
416
- An HTMLBars AST transformation that replaces all instances of
417
-
418
- ```handlebars
419
- {{#each item in items}}
420
- {{/each}}
421
- ```
422
-
423
- with
424
-
425
- ```handlebars
426
- {{#each items keyword="item"}}
427
- {{/each}}
428
- ```
429
-
430
- @class TransformEachInToHash
431
- @private
432
- */
433
- function TransformEachInToHash() {
434
- // set later within HTMLBars to the syntax package
435
- this.syntax = null;
382
+ exports.registerPlugin = registerPlugin;
383
+
384
+ /**
385
+ @module ember
386
+ @submodule ember-template-compiler
387
+ */
388
+
389
+ /**
390
+ @private
391
+ @property helpers
392
+ */
393
+ var plugins = {
394
+ ast: []
395
+ };
396
+
397
+ /**
398
+ Adds an AST plugin to be used by Ember.HTMLBars.compile.
399
+
400
+ @private
401
+ @method registerASTPlugin
402
+ */
403
+ function registerPlugin(type, Plugin) {
404
+ if (!plugins[type]) {
405
+ throw new Error('Attempting to register "' + Plugin + '" as "' + type + '" which is not a valid HTMLBars plugin type.');
436
406
  }
437
407
 
438
- /**
439
- @private
440
- @method transform
441
- @param {AST} The AST to be transformed.
442
- */
443
- TransformEachInToHash.prototype.transform = function TransformEachInToHash_transform(ast) {
444
- var pluginContext = this;
445
- var walker = new pluginContext.syntax.Walker();
446
- var b = pluginContext.syntax.builders;
447
-
448
- walker.visit(ast, function(node) {
449
- if (pluginContext.validate(node)) {
450
-
451
- if (node.program && node.program.blockParams.length) {
452
- throw new Error('You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.');
453
- }
408
+ plugins[type].push(Plugin);
409
+ }
454
410
 
455
- var removedParams = node.sexpr.params.splice(0, 2);
456
- var keyword = removedParams[0].original;
411
+ exports['default'] = plugins;
457
412
 
458
- // TODO: This may not be necessary.
459
- if (!node.sexpr.hash) {
460
- node.sexpr.hash = b.hash();
461
- }
413
+ });
414
+ enifed('ember-template-compiler/plugins/transform-each-in-to-hash', ['exports'], function (exports) {
462
415
 
463
- node.sexpr.hash.pairs.push(b.pair(
464
- 'keyword',
465
- b.string(keyword)
466
- ));
467
- }
468
- });
416
+ 'use strict';
469
417
 
470
- return ast;
471
- };
418
+ /**
419
+ @module ember
420
+ @submodule ember-htmlbars
421
+ */
472
422
 
473
- TransformEachInToHash.prototype.validate = function TransformEachInToHash_validate(node) {
474
- return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') &&
475
- node.sexpr.path.original === 'each' &&
476
- node.sexpr.params.length === 3 &&
477
- node.sexpr.params[1].type === 'PathExpression' &&
478
- node.sexpr.params[1].original === 'in';
479
- };
480
423
 
481
- __exports__["default"] = TransformEachInToHash;
482
- });
483
- define("ember-template-compiler/plugins/transform-with-as-to-hash",
484
- ["exports"],
485
- function(__exports__) {
486
- "use strict";
487
- /**
488
- @module ember
489
- @submodule ember-htmlbars
490
- */
424
+ /**
425
+ An HTMLBars AST transformation that replaces all instances of
491
426
 
492
- /**
493
- An HTMLBars AST transformation that replaces all instances of
494
-
495
- ```handlebars
496
- {{#with foo.bar as bar}}
497
- {{/with}}
498
- ```
499
-
500
- with
501
-
502
- ```handlebars
503
- {{#with foo.bar as |bar|}}
504
- {{/with}}
505
- ```
506
-
507
- @private
508
- @class TransformWithAsToHash
509
- */
510
- function TransformWithAsToHash() {
511
- // set later within HTMLBars to the syntax package
512
- this.syntax = null;
513
- }
427
+ ```handlebars
428
+ {{#each item in items}}
429
+ {{/each}}
430
+ ```
514
431
 
515
- /**
516
- @private
517
- @method transform
518
- @param {AST} The AST to be transformed.
519
- */
520
- TransformWithAsToHash.prototype.transform = function TransformWithAsToHash_transform(ast) {
521
- var pluginContext = this;
522
- var walker = new pluginContext.syntax.Walker();
523
-
524
- walker.visit(ast, function(node) {
525
- if (pluginContext.validate(node)) {
526
-
527
- if (node.program && node.program.blockParams.length) {
528
- throw new Error('You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.');
529
- }
432
+ with
433
+
434
+ ```handlebars
435
+ {{#each items keyword="item"}}
436
+ {{/each}}
437
+ ```
530
438
 
531
- var removedParams = node.sexpr.params.splice(1, 2);
532
- var keyword = removedParams[1].original;
533
- node.program.blockParams = [ keyword ];
439
+ @class TransformEachInToHash
440
+ @private
441
+ */
442
+ function TransformEachInToHash() {
443
+ // set later within HTMLBars to the syntax package
444
+ this.syntax = null;
445
+ }
446
+
447
+ /**
448
+ @private
449
+ @method transform
450
+ @param {AST} The AST to be transformed.
451
+ */
452
+ TransformEachInToHash.prototype.transform = function TransformEachInToHash_transform(ast) {
453
+ var pluginContext = this;
454
+ var walker = new pluginContext.syntax.Walker();
455
+ var b = pluginContext.syntax.builders;
456
+
457
+ walker.visit(ast, function(node) {
458
+ if (pluginContext.validate(node)) {
459
+
460
+ if (node.program && node.program.blockParams.length) {
461
+ throw new Error('You cannot use keyword (`{{each foo in bar}}`) and block params (`{{each bar as |foo|}}`) at the same time.');
534
462
  }
535
- });
536
463
 
537
- return ast;
538
- };
464
+ var removedParams = node.sexpr.params.splice(0, 2);
465
+ var keyword = removedParams[0].original;
539
466
 
540
- TransformWithAsToHash.prototype.validate = function TransformWithAsToHash_validate(node) {
541
- return node.type === 'BlockStatement' &&
542
- node.sexpr.path.original === 'with' &&
543
- node.sexpr.params.length === 3 &&
544
- node.sexpr.params[1].type === 'PathExpression' &&
545
- node.sexpr.params[1].original === 'as';
546
- };
467
+ // TODO: This may not be necessary.
468
+ if (!node.sexpr.hash) {
469
+ node.sexpr.hash = b.hash();
470
+ }
547
471
 
548
- __exports__["default"] = TransformWithAsToHash;
549
- });
550
- define("ember-template-compiler/system/compile",
551
- ["ember-template-compiler/system/compile_options","ember-template-compiler/system/template","exports"],
552
- function(__dependency1__, __dependency2__, __exports__) {
553
- "use strict";
554
- /**
555
- @module ember
556
- @submodule ember-template-compiler
557
- */
472
+ node.sexpr.hash.pairs.push(b.pair(
473
+ 'keyword',
474
+ b.string(keyword)
475
+ ));
476
+ }
477
+ });
558
478
 
559
- var compile;
560
- var compileOptions = __dependency1__["default"];
561
- var template = __dependency2__["default"];
479
+ return ast;
480
+ };
562
481
 
563
- /**
564
- Uses HTMLBars `compile` function to process a string into a compiled template.
482
+ TransformEachInToHash.prototype.validate = function TransformEachInToHash_validate(node) {
483
+ return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') &&
484
+ node.sexpr.path.original === 'each' &&
485
+ node.sexpr.params.length === 3 &&
486
+ node.sexpr.params[1].type === 'PathExpression' &&
487
+ node.sexpr.params[1].original === 'in';
488
+ };
565
489
 
566
- This is not present in production builds.
490
+ exports['default'] = TransformEachInToHash;
567
491
 
568
- @private
569
- @method compile
570
- @param {String} templateString This is the string to be compiled by HTMLBars.
571
- */
572
- __exports__["default"] = function(templateString) {
573
- if (!compile && Ember.__loader.registry['htmlbars-compiler/compiler']) {
574
- compile = requireModule('htmlbars-compiler/compiler').compile;
575
- }
492
+ });
493
+ enifed('ember-template-compiler/plugins/transform-with-as-to-hash', ['exports'], function (exports) {
494
+
495
+ 'use strict';
496
+
497
+ /**
498
+ @module ember
499
+ @submodule ember-htmlbars
500
+ */
501
+
502
+ /**
503
+ An HTMLBars AST transformation that replaces all instances of
504
+
505
+ ```handlebars
506
+ {{#with foo.bar as bar}}
507
+ {{/with}}
508
+ ```
509
+
510
+ with
511
+
512
+ ```handlebars
513
+ {{#with foo.bar as |bar|}}
514
+ {{/with}}
515
+ ```
516
+
517
+ @private
518
+ @class TransformWithAsToHash
519
+ */
520
+ function TransformWithAsToHash() {
521
+ // set later within HTMLBars to the syntax package
522
+ this.syntax = null;
523
+ }
524
+
525
+ /**
526
+ @private
527
+ @method transform
528
+ @param {AST} The AST to be transformed.
529
+ */
530
+ TransformWithAsToHash.prototype.transform = function TransformWithAsToHash_transform(ast) {
531
+ var pluginContext = this;
532
+ var walker = new pluginContext.syntax.Walker();
576
533
 
577
- if (!compile) {
578
- throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.');
534
+ walker.visit(ast, function(node) {
535
+ if (pluginContext.validate(node)) {
536
+
537
+ if (node.program && node.program.blockParams.length) {
538
+ throw new Error('You cannot use keyword (`{{with foo as bar}}`) and block params (`{{with foo as |bar|}}`) at the same time.');
539
+ }
540
+
541
+ var removedParams = node.sexpr.params.splice(1, 2);
542
+ var keyword = removedParams[1].original;
543
+ node.program.blockParams = [keyword];
579
544
  }
545
+ });
580
546
 
581
- var templateSpec = compile(templateString, compileOptions());
547
+ return ast;
548
+ };
582
549
 
583
- return template(templateSpec);
584
- }
585
- });
586
- define("ember-template-compiler/system/compile_options",
587
- ["ember-metal/core","ember-template-compiler/plugins","exports"],
588
- function(__dependency1__, __dependency2__, __exports__) {
589
- "use strict";
590
- /**
591
- @module ember
592
- @submodule ember-template-compiler
593
- */
550
+ TransformWithAsToHash.prototype.validate = function TransformWithAsToHash_validate(node) {
551
+ return node.type === 'BlockStatement' &&
552
+ node.sexpr.path.original === 'with' &&
553
+ node.sexpr.params.length === 3 &&
554
+ node.sexpr.params[1].type === 'PathExpression' &&
555
+ node.sexpr.params[1].original === 'as';
556
+ };
594
557
 
595
- var Ember = __dependency1__["default"];
596
- var plugins = __dependency2__["default"];
558
+ exports['default'] = TransformWithAsToHash;
597
559
 
598
- /**
599
- @private
600
- @property compileOptions
601
- */
602
- __exports__["default"] = function() {
603
- var disableComponentGeneration = true;
604
-
605
- return {
606
- disableComponentGeneration: disableComponentGeneration,
560
+ });
561
+ enifed('ember-template-compiler/system/compile', ['exports', 'ember-template-compiler/system/compile_options', 'ember-template-compiler/system/template'], function (exports, compileOptions, template) {
607
562
 
608
- plugins: plugins
609
- };
563
+ 'use strict';
564
+
565
+ /**
566
+ @module ember
567
+ @submodule ember-template-compiler
568
+ */
569
+
570
+ var compile;
571
+ exports['default'] = function(templateString) {
572
+ if (!compile && Ember.__loader.registry['htmlbars-compiler/compiler']) {
573
+ compile = requireModule('htmlbars-compiler/compiler').compile;
610
574
  }
611
- });
612
- define("ember-template-compiler/system/precompile",
613
- ["ember-template-compiler/system/compile_options","exports"],
614
- function(__dependency1__, __exports__) {
615
- "use strict";
616
- /**
617
- @module ember
618
- @submodule ember-template-compiler
619
- */
620
575
 
621
- var compileOptions = __dependency1__["default"];
622
- var compileSpec;
576
+ if (!compile) {
577
+ throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.');
578
+ }
623
579
 
624
- /**
625
- Uses HTMLBars `compile` function to process a string into a compiled template string.
626
- The returned string must be passed through `Ember.HTMLBars.template`.
627
-
628
- This is not present in production builds.
629
-
630
- @private
631
- @method precompile
632
- @param {String} templateString This is the string to be compiled by HTMLBars.
633
- */
634
- __exports__["default"] = function(templateString) {
635
- if (!compileSpec && Ember.__loader.registry['htmlbars-compiler/compiler']) {
636
- compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec;
637
- }
580
+ var templateSpec = compile(templateString, compileOptions['default']());
638
581
 
639
- if (!compileSpec) {
640
- throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.');
641
- }
582
+ return template['default'](templateSpec);
583
+ }
584
+
585
+ });
586
+ enifed('ember-template-compiler/system/compile_options', ['exports', 'ember-metal/core', 'ember-template-compiler/plugins'], function (exports, Ember, plugins) {
642
587
 
643
- return compileSpec(templateString, compileOptions());
588
+ 'use strict';
589
+
590
+ /**
591
+ @module ember
592
+ @submodule ember-template-compiler
593
+ */
594
+
595
+ exports['default'] = function() {
596
+ var disableComponentGeneration = true;
597
+ if (Ember['default'].FEATURES.isEnabled('ember-htmlbars-component-generation')) {
598
+ disableComponentGeneration = false;
644
599
  }
645
- });
646
- define("ember-template-compiler/system/template",
647
- ["exports"],
648
- function(__exports__) {
649
- "use strict";
650
- /**
651
- @module ember
652
- @submodule ember-template-compiler
653
- */
654
600
 
655
- /**
656
- Augments the detault precompiled output of an HTMLBars template with
657
- additional information needed by Ember.
601
+ return {
602
+ disableComponentGeneration: disableComponentGeneration,
658
603
 
659
- @private
660
- @method template
661
- @param {Function} templateSpec This is the compiled HTMLBars template spec.
662
- */
604
+ plugins: plugins['default']
605
+ };
606
+ }
607
+
608
+ });
609
+ enifed('ember-template-compiler/system/precompile', ['exports', 'ember-template-compiler/system/compile_options'], function (exports, compileOptions) {
610
+
611
+ 'use strict';
612
+
613
+ /**
614
+ @module ember
615
+ @submodule ember-template-compiler
616
+ */
617
+
618
+ var compileSpec;
663
619
 
664
- __exports__["default"] = function(templateSpec) {
665
- templateSpec.isTop = true;
666
- templateSpec.isMethod = false;
620
+ /**
621
+ Uses HTMLBars `compile` function to process a string into a compiled template string.
622
+ The returned string must be passed through `Ember.HTMLBars.template`.
667
623
 
668
- return templateSpec;
624
+ This is not present in production builds.
625
+
626
+ @private
627
+ @method precompile
628
+ @param {String} templateString This is the string to be compiled by HTMLBars.
629
+ */
630
+ exports['default'] = function(templateString) {
631
+ if (!compileSpec && Ember.__loader.registry['htmlbars-compiler/compiler']) {
632
+ compileSpec = requireModule('htmlbars-compiler/compiler').compileSpec;
669
633
  }
670
- });
671
- define("htmlbars-compiler",
634
+
635
+ if (!compileSpec) {
636
+ throw new Error('Cannot call `compileSpec` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compileSpec`.');
637
+ }
638
+
639
+ return compileSpec(templateString, compileOptions['default']());
640
+ }
641
+
642
+ });
643
+ enifed('ember-template-compiler/system/template', ['exports'], function (exports) {
644
+
645
+ 'use strict';
646
+
647
+ /**
648
+ @module ember
649
+ @submodule ember-template-compiler
650
+ */
651
+
652
+ /**
653
+ Augments the default precompiled output of an HTMLBars template with
654
+ additional information needed by Ember.
655
+
656
+ @private
657
+ @method template
658
+ @param {Function} templateSpec This is the compiled HTMLBars template spec.
659
+ */
660
+
661
+ exports['default'] = function(templateSpec) {
662
+ templateSpec.isTop = true;
663
+ templateSpec.isMethod = false;
664
+
665
+ return templateSpec;
666
+ }
667
+
668
+ });
669
+ enifed("htmlbars-compiler",
672
670
  ["./htmlbars-compiler/compiler","exports"],
673
671
  function(__dependency1__, __exports__) {
674
672
  "use strict";
@@ -678,7 +676,7 @@ define("htmlbars-compiler",
678
676
  __exports__.compile = compile;
679
677
  __exports__.compilerSpec = compilerSpec;
680
678
  });
681
- define("htmlbars-compiler/compiler",
679
+ enifed("htmlbars-compiler/compiler",
682
680
  ["../htmlbars-syntax/parser","./template-compiler","exports"],
683
681
  function(__dependency1__, __dependency2__, __exports__) {
684
682
  "use strict";
@@ -746,7 +744,7 @@ define("htmlbars-compiler/compiler",
746
744
 
747
745
  __exports__.compileSpec = compileSpec;
748
746
  });
749
- define("htmlbars-compiler/fragment-javascript-compiler",
747
+ enifed("htmlbars-compiler/fragment-javascript-compiler",
750
748
  ["./utils","../htmlbars-util/quoting","exports"],
751
749
  function(__dependency1__, __dependency2__, __exports__) {
752
750
  "use strict";
@@ -849,7 +847,7 @@ define("htmlbars-compiler/fragment-javascript-compiler",
849
847
  }
850
848
  };
851
849
  });
852
- define("htmlbars-compiler/fragment-opcode-compiler",
850
+ enifed("htmlbars-compiler/fragment-opcode-compiler",
853
851
  ["./template-visitor","./utils","../htmlbars-util","../htmlbars-util/array-utils","exports"],
854
852
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
855
853
  "use strict";
@@ -926,7 +924,7 @@ define("htmlbars-compiler/fragment-opcode-compiler",
926
924
  this.opcode('setNamespace', [namespace]);
927
925
  };
928
926
  });
929
- define("htmlbars-compiler/hydration-javascript-compiler",
927
+ enifed("htmlbars-compiler/hydration-javascript-compiler",
930
928
  ["./utils","../htmlbars-util/quoting","exports"],
931
929
  function(__dependency1__, __dependency2__, __exports__) {
932
930
  "use strict";
@@ -1187,7 +1185,7 @@ define("htmlbars-compiler/hydration-javascript-compiler",
1187
1185
  return this.parents[this.parents.length-1];
1188
1186
  };
1189
1187
  });
1190
- define("htmlbars-compiler/hydration-opcode-compiler",
1188
+ enifed("htmlbars-compiler/hydration-opcode-compiler",
1191
1189
  ["./template-visitor","./utils","../htmlbars-util","../htmlbars-util/array-utils","../htmlbars-syntax/utils","exports"],
1192
1190
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
1193
1191
  "use strict";
@@ -1499,7 +1497,7 @@ define("htmlbars-compiler/hydration-opcode-compiler",
1499
1497
  morphs.length = 0;
1500
1498
  }
1501
1499
  });
1502
- define("htmlbars-compiler/template-compiler",
1500
+ enifed("htmlbars-compiler/template-compiler",
1503
1501
  ["./fragment-opcode-compiler","./fragment-javascript-compiler","./hydration-opcode-compiler","./hydration-javascript-compiler","./template-visitor","./utils","../htmlbars-util/quoting","exports"],
1504
1502
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
1505
1503
  "use strict";
@@ -1670,7 +1668,7 @@ define("htmlbars-compiler/template-compiler",
1670
1668
  this.fragmentOpcodeCompiler.setNamespace(namespace);
1671
1669
  };
1672
1670
  });
1673
- define("htmlbars-compiler/template-visitor",
1671
+ enifed("htmlbars-compiler/template-visitor",
1674
1672
  ["exports"],
1675
1673
  function(__exports__) {
1676
1674
  "use strict";
@@ -1912,7 +1910,7 @@ define("htmlbars-compiler/template-visitor",
1912
1910
  return -1;
1913
1911
  }
1914
1912
  });
1915
- define("htmlbars-compiler/utils",
1913
+ enifed("htmlbars-compiler/utils",
1916
1914
  ["exports"],
1917
1915
  function(__exports__) {
1918
1916
  "use strict";
@@ -1930,7 +1928,7 @@ define("htmlbars-compiler/utils",
1930
1928
 
1931
1929
  __exports__.processOpcodes = processOpcodes;
1932
1930
  });
1933
- define("htmlbars-syntax",
1931
+ enifed("htmlbars-syntax",
1934
1932
  ["./htmlbars-syntax/walker","./htmlbars-syntax/builders","./htmlbars-syntax/parser","exports"],
1935
1933
  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
1936
1934
  "use strict";
@@ -1942,7 +1940,7 @@ define("htmlbars-syntax",
1942
1940
  __exports__.builders = builders;
1943
1941
  __exports__.parse = parse;
1944
1942
  });
1945
- define("htmlbars-syntax/builders",
1943
+ enifed("htmlbars-syntax/builders",
1946
1944
  ["exports"],
1947
1945
  function(__exports__) {
1948
1946
  "use strict";
@@ -2112,7 +2110,7 @@ define("htmlbars-syntax/builders",
2112
2110
  program: buildProgram
2113
2111
  };
2114
2112
  });
2115
- define("htmlbars-syntax/handlebars/compiler/ast",
2113
+ enifed("htmlbars-syntax/handlebars/compiler/ast",
2116
2114
  ["../exception","exports"],
2117
2115
  function(__dependency1__, __exports__) {
2118
2116
  "use strict";
@@ -2232,7 +2230,7 @@ define("htmlbars-syntax/handlebars/compiler/ast",
2232
2230
  // most modify the object to operate properly.
2233
2231
  __exports__["default"] = AST;
2234
2232
  });
2235
- define("htmlbars-syntax/handlebars/compiler/base",
2233
+ enifed("htmlbars-syntax/handlebars/compiler/base",
2236
2234
  ["./parser","./ast","./whitespace-control","./helpers","../utils","exports"],
2237
2235
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
2238
2236
  "use strict";
@@ -2264,7 +2262,7 @@ define("htmlbars-syntax/handlebars/compiler/base",
2264
2262
 
2265
2263
  __exports__.parse = parse;
2266
2264
  });
2267
- define("htmlbars-syntax/handlebars/compiler/helpers",
2265
+ enifed("htmlbars-syntax/handlebars/compiler/helpers",
2268
2266
  ["../exception","exports"],
2269
2267
  function(__dependency1__, __exports__) {
2270
2268
  "use strict";
@@ -2385,7 +2383,7 @@ define("htmlbars-syntax/handlebars/compiler/helpers",
2385
2383
 
2386
2384
  __exports__.prepareBlock = prepareBlock;
2387
2385
  });
2388
- define("htmlbars-syntax/handlebars/compiler/parser",
2386
+ enifed("htmlbars-syntax/handlebars/compiler/parser",
2389
2387
  ["exports"],
2390
2388
  function(__exports__) {
2391
2389
  "use strict";
@@ -2921,7 +2919,7 @@ define("htmlbars-syntax/handlebars/compiler/parser",
2921
2919
  })();__exports__["default"] = handlebars;
2922
2920
  /* jshint ignore:end */
2923
2921
  });
2924
- define("htmlbars-syntax/handlebars/compiler/visitor",
2922
+ enifed("htmlbars-syntax/handlebars/compiler/visitor",
2925
2923
  ["exports"],
2926
2924
  function(__exports__) {
2927
2925
  "use strict";
@@ -2992,7 +2990,7 @@ define("htmlbars-syntax/handlebars/compiler/visitor",
2992
2990
 
2993
2991
  __exports__["default"] = Visitor;
2994
2992
  });
2995
- define("htmlbars-syntax/handlebars/compiler/whitespace-control",
2993
+ enifed("htmlbars-syntax/handlebars/compiler/whitespace-control",
2996
2994
  ["./visitor","exports"],
2997
2995
  function(__dependency1__, __exports__) {
2998
2996
  "use strict";
@@ -3207,7 +3205,7 @@ define("htmlbars-syntax/handlebars/compiler/whitespace-control",
3207
3205
 
3208
3206
  __exports__["default"] = WhitespaceControl;
3209
3207
  });
3210
- define("htmlbars-syntax/handlebars/exception",
3208
+ enifed("htmlbars-syntax/handlebars/exception",
3211
3209
  ["exports"],
3212
3210
  function(__exports__) {
3213
3211
  "use strict";
@@ -3242,7 +3240,7 @@ define("htmlbars-syntax/handlebars/exception",
3242
3240
 
3243
3241
  __exports__["default"] = Exception;
3244
3242
  });
3245
- define("htmlbars-syntax/handlebars/safe-string",
3243
+ enifed("htmlbars-syntax/handlebars/safe-string",
3246
3244
  ["exports"],
3247
3245
  function(__exports__) {
3248
3246
  "use strict";
@@ -3257,7 +3255,7 @@ define("htmlbars-syntax/handlebars/safe-string",
3257
3255
 
3258
3256
  __exports__["default"] = SafeString;
3259
3257
  });
3260
- define("htmlbars-syntax/handlebars/utils",
3258
+ enifed("htmlbars-syntax/handlebars/utils",
3261
3259
  ["./safe-string","exports"],
3262
3260
  function(__dependency1__, __exports__) {
3263
3261
  "use strict";
@@ -3349,7 +3347,7 @@ define("htmlbars-syntax/handlebars/utils",
3349
3347
 
3350
3348
  __exports__.appendContextPath = appendContextPath;
3351
3349
  });
3352
- define("htmlbars-syntax/node-handlers",
3350
+ enifed("htmlbars-syntax/node-handlers",
3353
3351
  ["./builders","../htmlbars-util/array-utils","./utils","exports"],
3354
3352
  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
3355
3353
  "use strict";
@@ -3515,7 +3513,7 @@ define("htmlbars-syntax/node-handlers",
3515
3513
 
3516
3514
  __exports__["default"] = nodeHandlers;
3517
3515
  });
3518
- define("htmlbars-syntax/parser",
3516
+ enifed("htmlbars-syntax/parser",
3519
3517
  ["./handlebars/compiler/base","./tokenizer","../simple-html-tokenizer/entity-parser","../simple-html-tokenizer/char-refs/full","./node-handlers","./token-handlers","../htmlbars-syntax","exports"],
3520
3518
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
3521
3519
  "use strict";
@@ -3622,7 +3620,7 @@ define("htmlbars-syntax/parser",
3622
3620
  return string.join('\n');
3623
3621
  };
3624
3622
  });
3625
- define("htmlbars-syntax/token-handlers",
3623
+ enifed("htmlbars-syntax/token-handlers",
3626
3624
  ["../htmlbars-util/array-utils","./builders","./utils","exports"],
3627
3625
  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
3628
3626
  "use strict";
@@ -3769,7 +3767,7 @@ define("htmlbars-syntax/token-handlers",
3769
3767
 
3770
3768
  __exports__["default"] = tokenHandlers;
3771
3769
  });
3772
- define("htmlbars-syntax/tokenizer",
3770
+ enifed("htmlbars-syntax/tokenizer",
3773
3771
  ["../simple-html-tokenizer","./utils","../htmlbars-util/array-utils","./builders","exports"],
3774
3772
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
3775
3773
  "use strict";
@@ -3873,7 +3871,7 @@ define("htmlbars-syntax/tokenizer",
3873
3871
 
3874
3872
  __exports__.unwrapMustache = unwrapMustache;__exports__.Tokenizer = Tokenizer;
3875
3873
  });
3876
- define("htmlbars-syntax/utils",
3874
+ enifed("htmlbars-syntax/utils",
3877
3875
  ["./builders","../htmlbars-util/array-utils","exports"],
3878
3876
  function(__dependency1__, __dependency2__, __exports__) {
3879
3877
  "use strict";
@@ -3979,7 +3977,7 @@ define("htmlbars-syntax/utils",
3979
3977
 
3980
3978
  __exports__.isHelper = isHelper;
3981
3979
  });
3982
- define("htmlbars-syntax/walker",
3980
+ enifed("htmlbars-syntax/walker",
3983
3981
  ["exports"],
3984
3982
  function(__exports__) {
3985
3983
  "use strict";
@@ -4038,7 +4036,7 @@ define("htmlbars-syntax/walker",
4038
4036
  }
4039
4037
  };
4040
4038
  });
4041
- define("htmlbars-test-helpers",
4039
+ enifed("htmlbars-test-helpers",
4042
4040
  ["exports"],
4043
4041
  function(__exports__) {
4044
4042
  "use strict";
@@ -4150,7 +4148,7 @@ define("htmlbars-test-helpers",
4150
4148
  }
4151
4149
  __exports__.createObject = createObject;
4152
4150
  });
4153
- define("htmlbars-util",
4151
+ enifed("htmlbars-util",
4154
4152
  ["./htmlbars-util/safe-string","./htmlbars-util/handlebars/utils","./htmlbars-util/namespaces","exports"],
4155
4153
  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
4156
4154
  "use strict";
@@ -4162,7 +4160,7 @@ define("htmlbars-util",
4162
4160
  __exports__.escapeExpression = escapeExpression;
4163
4161
  __exports__.getAttrNamespace = getAttrNamespace;
4164
4162
  });
4165
- define("htmlbars-util/array-utils",
4163
+ enifed("htmlbars-util/array-utils",
4166
4164
  ["exports"],
4167
4165
  function(__exports__) {
4168
4166
  "use strict";
@@ -4214,7 +4212,7 @@ define("htmlbars-util/array-utils",
4214
4212
  var indexOfArray = getIdx;
4215
4213
  __exports__.indexOfArray = indexOfArray;
4216
4214
  });
4217
- define("htmlbars-util/handlebars/safe-string",
4215
+ enifed("htmlbars-util/handlebars/safe-string",
4218
4216
  ["exports"],
4219
4217
  function(__exports__) {
4220
4218
  "use strict";
@@ -4229,7 +4227,7 @@ define("htmlbars-util/handlebars/safe-string",
4229
4227
 
4230
4228
  __exports__["default"] = SafeString;
4231
4229
  });
4232
- define("htmlbars-util/handlebars/utils",
4230
+ enifed("htmlbars-util/handlebars/utils",
4233
4231
  ["./safe-string","exports"],
4234
4232
  function(__dependency1__, __exports__) {
4235
4233
  "use strict";
@@ -4321,7 +4319,7 @@ define("htmlbars-util/handlebars/utils",
4321
4319
 
4322
4320
  __exports__.appendContextPath = appendContextPath;
4323
4321
  });
4324
- define("htmlbars-util/namespaces",
4322
+ enifed("htmlbars-util/namespaces",
4325
4323
  ["exports"],
4326
4324
  function(__exports__) {
4327
4325
  "use strict";
@@ -4348,7 +4346,7 @@ define("htmlbars-util/namespaces",
4348
4346
 
4349
4347
  __exports__.getAttrNamespace = getAttrNamespace;
4350
4348
  });
4351
- define("htmlbars-util/object-utils",
4349
+ enifed("htmlbars-util/object-utils",
4352
4350
  ["exports"],
4353
4351
  function(__exports__) {
4354
4352
  "use strict";
@@ -4362,7 +4360,7 @@ define("htmlbars-util/object-utils",
4362
4360
 
4363
4361
  __exports__.merge = merge;
4364
4362
  });
4365
- define("htmlbars-util/quoting",
4363
+ enifed("htmlbars-util/quoting",
4366
4364
  ["exports"],
4367
4365
  function(__exports__) {
4368
4366
  "use strict";
@@ -4401,7 +4399,7 @@ define("htmlbars-util/quoting",
4401
4399
 
4402
4400
  __exports__.repeat = repeat;
4403
4401
  });
4404
- define("htmlbars-util/safe-string",
4402
+ enifed("htmlbars-util/safe-string",
4405
4403
  ["./handlebars/safe-string","exports"],
4406
4404
  function(__dependency1__, __exports__) {
4407
4405
  "use strict";
@@ -4409,7 +4407,7 @@ define("htmlbars-util/safe-string",
4409
4407
 
4410
4408
  __exports__["default"] = SafeString;
4411
4409
  });
4412
- define("simple-html-tokenizer",
4410
+ enifed("simple-html-tokenizer",
4413
4411
  ["./simple-html-tokenizer/tokenizer","./simple-html-tokenizer/tokenize","./simple-html-tokenizer/generator","./simple-html-tokenizer/generate","./simple-html-tokenizer/tokens","exports"],
4414
4412
  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
4415
4413
  "use strict";
@@ -4432,7 +4430,7 @@ define("simple-html-tokenizer",
4432
4430
  __exports__.Chars = Chars;
4433
4431
  __exports__.Comment = Comment;
4434
4432
  });
4435
- define("simple-html-tokenizer/char-refs/full",
4433
+ enifed("simple-html-tokenizer/char-refs/full",
4436
4434
  ["exports"],
4437
4435
  function(__exports__) {
4438
4436
  "use strict";
@@ -6564,7 +6562,7 @@ define("simple-html-tokenizer/char-refs/full",
6564
6562
  zwnj: [8204]
6565
6563
  };
6566
6564
  });
6567
- define("simple-html-tokenizer/char-refs/min",
6565
+ enifed("simple-html-tokenizer/char-refs/min",
6568
6566
  ["exports"],
6569
6567
  function(__exports__) {
6570
6568
  "use strict";
@@ -6576,7 +6574,7 @@ define("simple-html-tokenizer/char-refs/min",
6576
6574
  gt: [62]
6577
6575
  };
6578
6576
  });
6579
- define("simple-html-tokenizer/entity-parser",
6577
+ enifed("simple-html-tokenizer/entity-parser",
6580
6578
  ["exports"],
6581
6579
  function(__exports__) {
6582
6580
  "use strict";
@@ -6611,7 +6609,7 @@ define("simple-html-tokenizer/entity-parser",
6611
6609
 
6612
6610
  __exports__["default"] = EntityParser;
6613
6611
  });
6614
- define("simple-html-tokenizer/generate",
6612
+ enifed("simple-html-tokenizer/generate",
6615
6613
  ["./generator","exports"],
6616
6614
  function(__dependency1__, __exports__) {
6617
6615
  "use strict";
@@ -6622,7 +6620,7 @@ define("simple-html-tokenizer/generate",
6622
6620
  return generator.generate(tokens);
6623
6621
  }
6624
6622
  });
6625
- define("simple-html-tokenizer/generator",
6623
+ enifed("simple-html-tokenizer/generator",
6626
6624
  ["exports"],
6627
6625
  function(__exports__) {
6628
6626
  "use strict";
@@ -6721,7 +6719,7 @@ define("simple-html-tokenizer/generator",
6721
6719
 
6722
6720
  __exports__["default"] = Generator;
6723
6721
  });
6724
- define("simple-html-tokenizer/tokenize",
6722
+ enifed("simple-html-tokenizer/tokenize",
6725
6723
  ["./tokenizer","./entity-parser","./char-refs/full","exports"],
6726
6724
  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
6727
6725
  "use strict";
@@ -6734,7 +6732,7 @@ define("simple-html-tokenizer/tokenize",
6734
6732
  return tokenizer.tokenize();
6735
6733
  }
6736
6734
  });
6737
- define("simple-html-tokenizer/tokenizer",
6735
+ enifed("simple-html-tokenizer/tokenizer",
6738
6736
  ["./utils","./tokens","exports"],
6739
6737
  function(__dependency1__, __dependency2__, __exports__) {
6740
6738
  "use strict";
@@ -7138,7 +7136,7 @@ define("simple-html-tokenizer/tokenizer",
7138
7136
 
7139
7137
  __exports__["default"] = Tokenizer;
7140
7138
  });
7141
- define("simple-html-tokenizer/tokens",
7139
+ enifed("simple-html-tokenizer/tokens",
7142
7140
  ["exports"],
7143
7141
  function(__exports__) {
7144
7142
  "use strict";
@@ -7166,7 +7164,7 @@ define("simple-html-tokenizer/tokens",
7166
7164
 
7167
7165
  __exports__.Comment = Comment;
7168
7166
  });
7169
- define("simple-html-tokenizer/utils",
7167
+ enifed("simple-html-tokenizer/utils",
7170
7168
  ["exports"],
7171
7169
  function(__exports__) {
7172
7170
  "use strict";