ember-source 2.17.2 → 2.18.0.beta.1

Sign up to get free protection for your applications and to get access to all the features.
@@ -6,51 +6,14 @@
6
6
  * Portions Copyright 2008-2011 Apple Inc. All rights reserved.
7
7
  * @license Licensed under MIT license
8
8
  * See https://raw.github.com/emberjs/ember.js/master/LICENSE
9
- * @version 2.17.2
9
+ * @version 2.18.0-beta.1
10
10
  */
11
11
 
12
+ /*global process */
12
13
  var enifed, requireModule, Ember;
13
14
  var mainContext = this; // Used in ember-environment/lib/global.js
14
15
 
15
16
  (function() {
16
- var isNode = typeof window === 'undefined' &&
17
- typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
18
-
19
- if (!isNode) {
20
- Ember = this.Ember = this.Ember || {};
21
- }
22
-
23
- if (typeof Ember === 'undefined') { Ember = {}; }
24
-
25
- if (typeof Ember.__loader === 'undefined') {
26
- var registry = {};
27
- var seen = {};
28
-
29
- enifed = function(name, deps, callback) {
30
- var value = { };
31
-
32
- if (!callback) {
33
- value.deps = [];
34
- value.callback = deps;
35
- } else {
36
- value.deps = deps;
37
- value.callback = callback;
38
- }
39
-
40
- registry[name] = value;
41
- };
42
-
43
- requireModule = function(name) {
44
- return internalRequire(name, null);
45
- };
46
-
47
- // setup `require` module
48
- requireModule['default'] = requireModule;
49
-
50
- requireModule.has = function registryHas(moduleName) {
51
- return !!registry[moduleName] || !!registry[moduleName + '/index'];
52
- };
53
-
54
17
  function missingModule(name, referrerName) {
55
18
  if (referrerName) {
56
19
  throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
@@ -99,6 +62,44 @@ var mainContext = this; // Used in ember-environment/lib/global.js
99
62
  return exports;
100
63
  }
101
64
 
65
+ var isNode = typeof window === 'undefined' &&
66
+ typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
67
+
68
+ if (!isNode) {
69
+ Ember = this.Ember = this.Ember || {};
70
+ }
71
+
72
+ if (typeof Ember === 'undefined') { Ember = {}; }
73
+
74
+ if (typeof Ember.__loader === 'undefined') {
75
+ var registry = {};
76
+ var seen = {};
77
+
78
+ enifed = function(name, deps, callback) {
79
+ var value = { };
80
+
81
+ if (!callback) {
82
+ value.deps = [];
83
+ value.callback = deps;
84
+ } else {
85
+ value.deps = deps;
86
+ value.callback = callback;
87
+ }
88
+
89
+ registry[name] = value;
90
+ };
91
+
92
+ requireModule = function(name) {
93
+ return internalRequire(name, null);
94
+ };
95
+
96
+ // setup `require` module
97
+ requireModule['default'] = requireModule;
98
+
99
+ requireModule.has = function registryHas(moduleName) {
100
+ return !!registry[moduleName] || !!registry[moduleName + '/index'];
101
+ };
102
+
102
103
  requireModule._eak_seen = registry;
103
104
 
104
105
  Ember.__loader = {
@@ -4586,7 +4587,7 @@ enifed('backburner', ['exports'], function (exports) {
4586
4587
  var index = -1,
4587
4588
  i,
4588
4589
  l;
4589
- for (i = 0, l = collection.length; i < l; i += 3) {
4590
+ for (i = 0, l = collection.length; i < l; i += 4) {
4590
4591
  if (collection[i] === target && collection[i + 1] === method) {
4591
4592
  index = i;
4592
4593
  break;
@@ -4597,9 +4598,9 @@ enifed('backburner', ['exports'], function (exports) {
4597
4598
  function findTimer(timer, collection) {
4598
4599
  var index = -1,
4599
4600
  i;
4600
- for (i = 2; i < collection.length; i += 3) {
4601
+ for (i = 3; i < collection.length; i += 4) {
4601
4602
  if (collection[i] === timer) {
4602
- index = i - 2;
4603
+ index = i - 3;
4603
4604
  break;
4604
4605
  }
4605
4606
  }
@@ -4633,10 +4634,10 @@ enifed('backburner', ['exports'], function (exports) {
4633
4634
  var globalOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
4634
4635
 
4635
4636
 
4636
- this._queue = []; // TODO: should be private
4637
4637
  this._queueBeingFlushed = [];
4638
4638
  this.targetQueues = Object.create(null);
4639
4639
  this.index = 0;
4640
+ this._queue = [];
4640
4641
  this.name = name;
4641
4642
  this.options = options;
4642
4643
  this.globalOptions = globalOptions;
@@ -4677,27 +4678,22 @@ enifed('backburner', ['exports'], function (exports) {
4677
4678
  var args = void 0;
4678
4679
  var errorRecordedForStack = void 0;
4679
4680
  this.targetQueues = Object.create(null);
4680
- var queueItems = void 0;
4681
- if (this._queueBeingFlushed.length > 0) {
4682
- queueItems = this._queueBeingFlushed;
4683
- } else {
4684
- queueItems = this._queueBeingFlushed = this._queue;
4681
+ if (this._queueBeingFlushed.length === 0) {
4682
+ this._queueBeingFlushed = this._queue;
4685
4683
  this._queue = [];
4686
4684
  }
4687
- if (before) {
4685
+ if (before !== undefined) {
4688
4686
  before();
4689
4687
  }
4690
4688
  var invoke = void 0;
4689
+ var queueItems = this._queueBeingFlushed;
4691
4690
  if (queueItems.length > 0) {
4692
4691
  onError = getOnError(this.globalOptions);
4693
4692
 
4694
4693
  invoke = onError ? this.invokeWithOnError : this.invoke;
4695
4694
  for (i = this.index; i < queueItems.length; i += 4) {
4696
4695
  this.index += 4;
4697
- target = queueItems[i];
4698
4696
  method = queueItems[i + 1];
4699
- args = queueItems[i + 2];
4700
- errorRecordedForStack = queueItems[i + 3]; // Debugging assistance
4701
4697
  // method could have been nullified / canceled during flush
4702
4698
  if (method !== null) {
4703
4699
  //
@@ -4715,6 +4711,9 @@ enifed('backburner', ['exports'], function (exports) {
4715
4711
  // One possible long-term solution is the following Chrome issue:
4716
4712
  // https://bugs.chromium.org/p/chromium/issues/detail?id=332624
4717
4713
  //
4714
+ target = queueItems[i];
4715
+ args = queueItems[i + 2];
4716
+ errorRecordedForStack = queueItems[i + 3]; // Debugging assistance
4718
4717
  invoke(target, method, args, onError, errorRecordedForStack);
4719
4718
  }
4720
4719
  if (this.index !== this._queueBeingFlushed.length && this.globalOptions.mustYield && this.globalOptions.mustYield()) {
@@ -4722,7 +4721,7 @@ enifed('backburner', ['exports'], function (exports) {
4722
4721
  }
4723
4722
  }
4724
4723
  }
4725
- if (after) {
4724
+ if (after !== undefined) {
4726
4725
  after();
4727
4726
  }
4728
4727
  this._queueBeingFlushed.length = 0;
@@ -4739,17 +4738,17 @@ enifed('backburner', ['exports'], function (exports) {
4739
4738
 
4740
4739
  Queue.prototype.cancel = function (_ref) {
4741
4740
  var target = _ref.target,
4742
- method = _ref.method;
4741
+ method = _ref.method,
4742
+ t,
4743
+ i,
4744
+ l;
4743
4745
 
4744
4746
  var queue = this._queue;
4745
- var currentTarget = void 0;
4746
- var currentMethod = void 0;
4747
- var i = void 0;
4748
- var l = void 0;
4749
- var t = void 0;
4750
4747
  var guid = this.guidForTarget(target);
4751
4748
  var targetQueue = guid ? this.targetQueues[guid] : undefined;
4752
4749
  if (targetQueue !== undefined) {
4750
+ t = void 0;
4751
+
4753
4752
  for (i = 0, l = targetQueue.length; i < l; i += 2) {
4754
4753
  t = targetQueue[i];
4755
4754
  if (t === method) {
@@ -4757,26 +4756,18 @@ enifed('backburner', ['exports'], function (exports) {
4757
4756
  }
4758
4757
  }
4759
4758
  }
4760
- for (i = 0, l = queue.length; i < l; i += 4) {
4761
- currentTarget = queue[i];
4762
- currentMethod = queue[i + 1];
4763
- if (currentTarget === target && currentMethod === method) {
4764
- queue.splice(i, 4);
4765
- return true;
4766
- }
4759
+ var index = findItem(target, method, queue);
4760
+ if (index > -1) {
4761
+ queue.splice(index, 4);
4762
+ return true;
4767
4763
  }
4768
4764
  // if not found in current queue
4769
4765
  // could be in the queue that is being flushed
4770
4766
  queue = this._queueBeingFlushed;
4771
- for (i = 0, l = queue.length; i < l; i += 4) {
4772
- currentTarget = queue[i];
4773
- currentMethod = queue[i + 1];
4774
- if (currentTarget === target && currentMethod === method) {
4775
- // don't mess with array during flush
4776
- // just nullify the method
4777
- queue[i + 1] = null;
4778
- return true;
4779
- }
4767
+ index = findItem(target, method, queue);
4768
+ if (index > -1) {
4769
+ queue[index + 1] = null;
4770
+ return true;
4780
4771
  }
4781
4772
  return false;
4782
4773
  };
@@ -4796,22 +4787,14 @@ enifed('backburner', ['exports'], function (exports) {
4796
4787
  };
4797
4788
 
4798
4789
  Queue.prototype.pushUniqueWithoutGuid = function (target, method, args, stack) {
4799
- var queue = this._queue,
4800
- i,
4801
- l,
4802
- currentTarget,
4803
- currentMethod;
4804
- for (i = 0, l = queue.length; i < l; i += 4) {
4805
- currentTarget = queue[i];
4806
- currentMethod = queue[i + 1];
4807
-
4808
- if (currentTarget === target && currentMethod === method) {
4809
- queue[i + 2] = args; // replace args
4810
- queue[i + 3] = stack; // replace stack
4811
- return;
4812
- }
4790
+ var queue = this._queue;
4791
+ var index = findItem(target, method, queue);
4792
+ if (index > -1) {
4793
+ queue[index + 2] = args; // replace args
4794
+ queue[index + 3] = stack; // replace stack
4795
+ } else {
4796
+ queue.push(target, method, args, stack);
4813
4797
  }
4814
- queue.push(target, method, args, stack);
4815
4798
  };
4816
4799
 
4817
4800
  Queue.prototype.targetQueue = function (_targetQueue, target, method, args, stack) {
@@ -4941,6 +4924,30 @@ enifed('backburner', ['exports'], function (exports) {
4941
4924
 
4942
4925
  var noop = function () {};
4943
4926
  var SET_TIMEOUT = setTimeout;
4927
+ function parseArgs() {
4928
+ var length = arguments.length,
4929
+ i;
4930
+ var method = void 0;
4931
+ var target = void 0;
4932
+ var args = void 0;
4933
+ if (length === 1) {
4934
+ method = arguments[0];
4935
+ target = null;
4936
+ } else {
4937
+ target = arguments[0];
4938
+ method = arguments[1];
4939
+ if (isString(method)) {
4940
+ method = target[method];
4941
+ }
4942
+ if (length > 2) {
4943
+ args = new Array(length - 2);
4944
+ for (i = 0; i < length - 2; i++) {
4945
+ args[i] = arguments[i + 2];
4946
+ }
4947
+ }
4948
+ }
4949
+ return [target, method, args];
4950
+ }
4944
4951
 
4945
4952
  var Backburner = function () {
4946
4953
  function Backburner(queueNames) {
@@ -5081,32 +5088,17 @@ enifed('backburner', ['exports'], function (exports) {
5081
5088
  }
5082
5089
  };
5083
5090
 
5084
- Backburner.prototype.run = function (target, method) {
5085
- for (_len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
5086
- args[_key - 2] = arguments[_key];
5087
- }
5091
+ Backburner.prototype.run = function () {
5092
+ var _parseArgs = parseArgs.apply(undefined, arguments),
5093
+ target = _parseArgs[0],
5094
+ method = _parseArgs[1],
5095
+ args = _parseArgs[2];
5088
5096
 
5089
- var length = arguments.length,
5090
- _len,
5091
- args,
5092
- _key;
5093
- var _method = void 0;
5094
- var _target = void 0;
5095
- if (length === 1) {
5096
- _method = target;
5097
- _target = null;
5098
- } else {
5099
- _method = method;
5100
- _target = target;
5101
- if (isString(_method)) {
5102
- _method = _target[_method];
5103
- }
5104
- }
5105
5097
  var onError = getOnError(this.options);
5106
5098
  this.begin();
5107
5099
  if (onError) {
5108
5100
  try {
5109
- return _method.apply(_target, args);
5101
+ return method.apply(target, args);
5110
5102
  } catch (error) {
5111
5103
  onError(error);
5112
5104
  } finally {
@@ -5114,7 +5106,7 @@ enifed('backburner', ['exports'], function (exports) {
5114
5106
  }
5115
5107
  } else {
5116
5108
  try {
5117
- return _method.apply(_target, args);
5109
+ return method.apply(target, args);
5118
5110
  } finally {
5119
5111
  this.end();
5120
5112
  }
@@ -5125,27 +5117,13 @@ enifed('backburner', ['exports'], function (exports) {
5125
5117
  if (this.currentInstance === null) {
5126
5118
  return this.run.apply(this, arguments);
5127
5119
  }
5128
- var length = arguments.length,
5129
- i;
5130
- var method = void 0;
5131
- var target = void 0;
5132
- var args = void 0;
5133
- if (length === 1) {
5134
- method = arguments[0];
5135
- target = null;
5136
- } else {
5137
- target = arguments[0];
5138
- method = arguments[1];
5139
- if (isString(method)) {
5140
- method = target[method];
5141
- }
5142
- if (length > 2) {
5143
- args = new Array(length - 2);
5144
- for (i = 0; i < length - 2; i++) {
5145
- args[i] = arguments[i + 2];
5146
- }
5147
- }
5148
- }
5120
+
5121
+ var _parseArgs2 = parseArgs.apply(undefined, arguments),
5122
+ target = _parseArgs2[0],
5123
+ method = _parseArgs2[1],
5124
+ args = _parseArgs2[2];
5125
+
5126
+ var length = arguments.length;
5149
5127
  if (length === 1) {
5150
5128
  return method();
5151
5129
  } else if (length === 2) {
@@ -5160,27 +5138,18 @@ enifed('backburner', ['exports'], function (exports) {
5160
5138
  };
5161
5139
 
5162
5140
  Backburner.prototype.schedule = function (queueName) {
5163
- var length = arguments.length,
5164
- i;
5165
- var method = void 0;
5166
- var target = void 0;
5167
- var args = void 0;
5168
- if (length === 2) {
5169
- method = arguments[1];
5170
- target = null;
5171
- } else {
5172
- target = arguments[1];
5173
- method = arguments[2];
5174
- if (isString(method)) {
5175
- method = target[method];
5176
- }
5177
- if (length > 3) {
5178
- args = new Array(length - 3);
5179
- for (i = 3; i < length; i++) {
5180
- args[i - 3] = arguments[i];
5181
- }
5182
- }
5141
+ for (_len = arguments.length, _args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
5142
+ _args[_key - 1] = arguments[_key];
5183
5143
  }
5144
+
5145
+ var _parseArgs3 = parseArgs.apply(undefined, _args),
5146
+ target = _parseArgs3[0],
5147
+ method = _parseArgs3[1],
5148
+ args = _parseArgs3[2],
5149
+ _len,
5150
+ _args,
5151
+ _key;
5152
+
5184
5153
  var stack = this.DEBUG ? new Error() : undefined;
5185
5154
  return this._ensureInstance().schedule(queueName, target, method, args, false, stack);
5186
5155
  };
@@ -5194,28 +5163,19 @@ enifed('backburner', ['exports'], function (exports) {
5194
5163
  return this.scheduleOnce.apply(this, arguments);
5195
5164
  };
5196
5165
 
5197
- Backburner.prototype.scheduleOnce = function (queueName /* , target, method, args */) {
5198
- var length = arguments.length,
5199
- i;
5200
- var method = void 0;
5201
- var target = void 0;
5202
- var args = void 0;
5203
- if (length === 2) {
5204
- method = arguments[1];
5205
- target = null;
5206
- } else {
5207
- target = arguments[1];
5208
- method = arguments[2];
5209
- if (isString(method)) {
5210
- method = target[method];
5211
- }
5212
- if (length > 3) {
5213
- args = new Array(length - 3);
5214
- for (i = 3; i < length; i++) {
5215
- args[i - 3] = arguments[i];
5216
- }
5217
- }
5166
+ Backburner.prototype.scheduleOnce = function (queueName) {
5167
+ for (_len2 = arguments.length, _args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
5168
+ _args[_key2 - 1] = arguments[_key2];
5218
5169
  }
5170
+
5171
+ var _parseArgs4 = parseArgs.apply(undefined, _args),
5172
+ target = _parseArgs4[0],
5173
+ method = _parseArgs4[1],
5174
+ args = _parseArgs4[2],
5175
+ _len2,
5176
+ _args,
5177
+ _key2;
5178
+
5219
5179
  var stack = this.DEBUG ? new Error() : undefined;
5220
5180
  return this._ensureInstance().schedule(queueName, target, method, args, true, stack);
5221
5181
  };
@@ -5225,14 +5185,14 @@ enifed('backburner', ['exports'], function (exports) {
5225
5185
  };
5226
5186
 
5227
5187
  Backburner.prototype.later = function () {
5228
- for (_len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
5229
- args[_key2] = arguments[_key2];
5188
+ for (_len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
5189
+ args[_key3] = arguments[_key3];
5230
5190
  }
5231
5191
 
5232
5192
  var length = args.length,
5233
- _len2,
5193
+ _len3,
5234
5194
  args,
5235
- _key2,
5195
+ _key3,
5236
5196
  last;
5237
5197
  var wait = 0;
5238
5198
  var method = void 0;
@@ -5296,19 +5256,19 @@ enifed('backburner', ['exports'], function (exports) {
5296
5256
  return this._setTimeout(fn, executeAt);
5297
5257
  };
5298
5258
 
5299
- Backburner.prototype.throttle = function (target, method /*, ...args, wait, [immediate] */) {
5259
+ Backburner.prototype.throttle = function (target, method) /*, ...args, wait, [immediate] */{
5300
5260
  var _this2 = this,
5301
- i;
5261
+ _len4,
5262
+ args,
5263
+ _key4;
5302
5264
 
5303
- var args = new Array(arguments.length);
5304
- for (i = 0; i < arguments.length; i++) {
5305
- args[i] = arguments[i];
5265
+ for (_len4 = arguments.length, args = Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
5266
+ args[_key4 - 2] = arguments[_key4];
5306
5267
  }
5268
+
5307
5269
  var immediate = args.pop();
5308
5270
  var isImmediate = void 0;
5309
5271
  var wait = void 0;
5310
- var index = void 0;
5311
- var timer = void 0;
5312
5272
  if (isCoercableNumber(immediate)) {
5313
5273
  wait = immediate;
5314
5274
  isImmediate = true;
@@ -5317,40 +5277,44 @@ enifed('backburner', ['exports'], function (exports) {
5317
5277
  isImmediate = immediate === true;
5318
5278
  }
5319
5279
  wait = parseInt(wait, 10);
5320
- index = findItem(target, method, this._throttlers);
5280
+ var index = findItem(target, method, this._throttlers);
5321
5281
  if (index > -1) {
5322
- return this._throttlers[index + 2];
5282
+ this._throttlers[index + 2] = args;
5283
+ return this._throttlers[index + 3];
5323
5284
  } // throttled
5324
- timer = this._platform.setTimeout(function () {
5285
+ var timer = this._platform.setTimeout(function () {
5286
+ var i = findTimer(timer, _this2._throttlers);
5287
+
5288
+ var _throttlers$splice = _this2._throttlers.splice(i, 4),
5289
+ context = _throttlers$splice[0],
5290
+ func = _throttlers$splice[1],
5291
+ params = _throttlers$splice[2];
5292
+
5325
5293
  if (isImmediate === false) {
5326
- _this2.run.apply(_this2, args);
5327
- }
5328
- index = findTimer(timer, _this2._throttlers);
5329
- if (index > -1) {
5330
- _this2._throttlers.splice(index, 3);
5294
+ _this2.run.apply(_this2, [context, func].concat(params));
5331
5295
  }
5332
5296
  }, wait);
5333
5297
  if (isImmediate) {
5334
- this.join.apply(this, args);
5298
+ this.join.apply(this, [target, method].concat(args));
5335
5299
  }
5336
- this._throttlers.push(target, method, timer);
5300
+ this._throttlers.push(target, method, args, timer);
5337
5301
  return timer;
5338
5302
  };
5339
5303
 
5340
- Backburner.prototype.debounce = function (target, method /* , args, wait, [immediate] */) {
5304
+ Backburner.prototype.debounce = function (target, method) /* , wait, [immediate] */{
5341
5305
  var _this3 = this,
5342
- i,
5306
+ _len5,
5307
+ args,
5308
+ _key5,
5343
5309
  timerId;
5344
5310
 
5345
- var args = new Array(arguments.length);
5346
- for (i = 0; i < arguments.length; i++) {
5347
- args[i] = arguments[i];
5311
+ for (_len5 = arguments.length, args = Array(_len5 > 2 ? _len5 - 2 : 0), _key5 = 2; _key5 < _len5; _key5++) {
5312
+ args[_key5 - 2] = arguments[_key5];
5348
5313
  }
5314
+
5349
5315
  var immediate = args.pop();
5350
5316
  var isImmediate = void 0;
5351
5317
  var wait = void 0;
5352
- var index = void 0;
5353
- var timer = void 0;
5354
5318
  if (isCoercableNumber(immediate)) {
5355
5319
  wait = immediate;
5356
5320
  isImmediate = false;
@@ -5360,37 +5324,40 @@ enifed('backburner', ['exports'], function (exports) {
5360
5324
  }
5361
5325
  wait = parseInt(wait, 10);
5362
5326
  // Remove debouncee
5363
- index = findItem(target, method, this._debouncees);
5327
+ var index = findItem(target, method, this._debouncees);
5364
5328
  if (index > -1) {
5365
- timerId = this._debouncees[index + 2];
5329
+ timerId = this._debouncees[index + 3];
5366
5330
 
5367
- this._debouncees.splice(index, 3);
5368
5331
  this._platform.clearTimeout(timerId);
5332
+ this._debouncees.splice(index, 4);
5369
5333
  }
5370
- timer = this._platform.setTimeout(function () {
5334
+ var timer = this._platform.setTimeout(function () {
5335
+ var i = findTimer(timer, _this3._debouncees);
5336
+
5337
+ var _debouncees$splice = _this3._debouncees.splice(i, 4),
5338
+ context = _debouncees$splice[0],
5339
+ func = _debouncees$splice[1],
5340
+ params = _debouncees$splice[2];
5341
+
5371
5342
  if (isImmediate === false) {
5372
- _this3.run.apply(_this3, args);
5373
- }
5374
- index = findTimer(timer, _this3._debouncees);
5375
- if (index > -1) {
5376
- _this3._debouncees.splice(index, 3);
5343
+ _this3.run.apply(_this3, [context, func].concat(params));
5377
5344
  }
5378
5345
  }, wait);
5379
5346
  if (isImmediate && index === -1) {
5380
- this.join.apply(this, args);
5347
+ this.join.apply(this, [target, method].concat(args));
5381
5348
  }
5382
- this._debouncees.push(target, method, timer);
5349
+ this._debouncees.push(target, method, args, timer);
5383
5350
  return timer;
5384
5351
  };
5385
5352
 
5386
5353
  Backburner.prototype.cancelTimers = function () {
5387
5354
  var i, t;
5388
5355
 
5389
- for (i = 2; i < this._throttlers.length; i += 3) {
5356
+ for (i = 3; i < this._throttlers.length; i += 4) {
5390
5357
  this._platform.clearTimeout(this._throttlers[i]);
5391
5358
  }
5392
5359
  this._throttlers = [];
5393
- for (t = 2; t < this._debouncees.length; t += 3) {
5360
+ for (t = 3; t < this._debouncees.length; t += 4) {
5394
5361
  this._platform.clearTimeout(this._debouncees[t]);
5395
5362
  }
5396
5363
  this._debouncees = [];
@@ -5464,8 +5431,8 @@ enifed('backburner', ['exports'], function (exports) {
5464
5431
  Backburner.prototype._cancelItem = function (timer, array) {
5465
5432
  var index = findTimer(timer, array);
5466
5433
  if (index > -1) {
5467
- array.splice(index, 3);
5468
5434
  this._platform.clearTimeout(timer);
5435
+ array.splice(index, 4);
5469
5436
  return true;
5470
5437
  }
5471
5438
  return false;
@@ -5577,51 +5544,110 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
5577
5544
  @private
5578
5545
  @class Container
5579
5546
  */
5580
- function Container(registry) {
5581
- var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
5582
5547
 
5583
- this.registry = registry;
5584
- this.owner = options.owner || null;
5585
- this.cache = (0, _emberUtils.dictionary)(options.cache || null);
5586
- this.factoryManagerCache = (0, _emberUtils.dictionary)(options.factoryManagerCache || null);
5587
- this[CONTAINER_OVERRIDE] = undefined;
5588
- this.isDestroyed = false;
5548
+ var Container = function () {
5549
+ function Container(registry) {
5550
+ var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
5589
5551
 
5590
- this.validationCache = (0, _emberUtils.dictionary)(options.validationCache || null);
5591
- }
5592
5552
 
5593
- Container.prototype = {
5594
- lookup: function (fullName, options) {
5595
- true && !this.registry.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(fullName));
5553
+ this.registry = registry;
5554
+ this.owner = options.owner || null;
5555
+ this.cache = (0, _emberUtils.dictionary)(options.cache || null);
5556
+ this.factoryManagerCache = (0, _emberUtils.dictionary)(options.factoryManagerCache || null);
5557
+ this[CONTAINER_OVERRIDE] = undefined;
5558
+ this.isDestroyed = false;
5596
5559
 
5597
- return lookup(this, this.registry.normalize(fullName), options);
5598
- },
5599
- destroy: function () {
5560
+ this.validationCache = (0, _emberUtils.dictionary)(options.validationCache || null);
5561
+ }
5562
+
5563
+ /**
5564
+ @private
5565
+ @property registry
5566
+ @type Registry
5567
+ @since 1.11.0
5568
+ */
5569
+
5570
+ /**
5571
+ @private
5572
+ @property cache
5573
+ @type InheritingDict
5574
+ */
5575
+
5576
+ /**
5577
+ @private
5578
+ @property validationCache
5579
+ @type InheritingDict
5580
+ */
5581
+
5582
+ /**
5583
+ Given a fullName return a corresponding instance.
5584
+ The default behavior is for lookup to return a singleton instance.
5585
+ The singleton is scoped to the container, allowing multiple containers
5586
+ to all have their own locally scoped singletons.
5587
+ ```javascript
5588
+ let registry = new Registry();
5589
+ let container = registry.container();
5590
+ registry.register('api:twitter', Twitter);
5591
+ let twitter = container.lookup('api:twitter');
5592
+ twitter instanceof Twitter; // => true
5593
+ // by default the container will return singletons
5594
+ let twitter2 = container.lookup('api:twitter');
5595
+ twitter2 instanceof Twitter; // => true
5596
+ twitter === twitter2; //=> true
5597
+ ```
5598
+ If singletons are not wanted, an optional flag can be provided at lookup.
5599
+ ```javascript
5600
+ let registry = new Registry();
5601
+ let container = registry.container();
5602
+ registry.register('api:twitter', Twitter);
5603
+ let twitter = container.lookup('api:twitter', { singleton: false });
5604
+ let twitter2 = container.lookup('api:twitter', { singleton: false });
5605
+ twitter === twitter2; //=> false
5606
+ ```
5607
+ @private
5608
+ @method lookup
5609
+ @param {String} fullName
5610
+ @param {Object} [options]
5611
+ @param {String} [options.source] The fullname of the request source (used for local lookup)
5612
+ @return {any}
5613
+ */
5614
+
5615
+ Container.prototype.lookup = function (fullName, options) {
5616
+ true && !this.registry.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.isValidFullName(fullName));
5617
+
5618
+ return _lookup(this, this.registry.normalize(fullName), options);
5619
+ };
5620
+
5621
+ Container.prototype.destroy = function () {
5600
5622
  destroyDestroyables(this);
5601
5623
  this.isDestroyed = true;
5602
- },
5603
- reset: function (fullName) {
5624
+ };
5625
+
5626
+ Container.prototype.reset = function (fullName) {
5604
5627
  if (fullName === undefined) {
5605
5628
  resetCache(this);
5606
5629
  } else {
5607
5630
  resetMember(this, this.registry.normalize(fullName));
5608
5631
  }
5609
- },
5610
- ownerInjection: function () {
5632
+ };
5633
+
5634
+ Container.prototype.ownerInjection = function () {
5611
5635
  var _ref;
5612
5636
 
5613
5637
  return _ref = {}, _ref[_emberUtils.OWNER] = this.owner, _ref;
5614
- },
5615
- _resolverCacheKey: function (name, options) {
5638
+ };
5639
+
5640
+ Container.prototype._resolverCacheKey = function (name, options) {
5616
5641
  return this.registry.resolverCacheKey(name, options);
5617
- },
5618
- factoryFor: function (fullName) {
5642
+ };
5643
+
5644
+ Container.prototype.factoryFor = function (fullName) {
5619
5645
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
5620
5646
  expandedFullName;
5621
5647
 
5622
5648
  var normalizedName = this.registry.normalize(fullName);
5623
5649
 
5624
- true && !this.registry.validateFullName(normalizedName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.validateFullName(normalizedName));
5650
+ true && !this.registry.isValidFullName(normalizedName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
5625
5651
 
5626
5652
  if (options.source) {
5627
5653
  expandedFullName = this.registry.expandLocalLookup(fullName, options);
@@ -5665,8 +5691,10 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
5665
5691
 
5666
5692
  this.factoryManagerCache[cacheKey] = manager;
5667
5693
  return manager;
5668
- }
5669
- };
5694
+ };
5695
+
5696
+ return Container;
5697
+ }();
5670
5698
 
5671
5699
  /*
5672
5700
  * Wrap a factory manager in a proxy which will not permit properties to be
@@ -5709,7 +5737,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
5709
5737
  return container.registry.getOption(fullName, 'instantiate') !== false;
5710
5738
  }
5711
5739
 
5712
- function lookup(container, fullName) {
5740
+ function _lookup(container, fullName) {
5713
5741
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
5714
5742
  expandedFullName,
5715
5743
  cacheKey,
@@ -5803,33 +5831,19 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
5803
5831
  throw new Error('Could not create factory');
5804
5832
  }
5805
5833
 
5806
- function buildInjections() /* container, ...injections */{
5834
+ function buildInjections(container, injections) {
5807
5835
  var hash = {},
5808
- container,
5809
- injections,
5810
5836
  injection,
5811
- i,
5812
- _i;
5837
+ i;
5813
5838
  var isDynamic = false;
5814
5839
 
5815
- if (arguments.length > 1) {
5816
- container = arguments[0];
5817
- injections = [];
5818
- injection = void 0;
5819
-
5820
-
5821
- for (i = 1; i < arguments.length; i++) {
5822
- if (arguments[i]) {
5823
- injections = injections.concat(arguments[i]);
5824
- }
5825
- }
5826
-
5840
+ if (injections.length > 0) {
5827
5841
  container.registry.validateInjections(injections);
5842
+ injection = void 0;
5828
5843
 
5829
-
5830
- for (_i = 0; _i < injections.length; _i++) {
5831
- injection = injections[_i];
5832
- hash[injection.property] = lookup(container, injection.fullName);
5844
+ for (i = 0; i < injections.length; i++) {
5845
+ injection = injections[i];
5846
+ hash[injection.property] = _lookup(container, injection.fullName);
5833
5847
  if (!isDynamic) {
5834
5848
  isDynamic = !isSingleton(container, injection.fullName);
5835
5849
  }
@@ -5841,10 +5855,12 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
5841
5855
 
5842
5856
  function injectionsFor(container, fullName) {
5843
5857
  var registry = container.registry;
5844
- var splitName = fullName.split(':');
5845
- var type = splitName[0];
5846
5858
 
5847
- return buildInjections(container, registry.getTypeInjections(type), registry.getInjections(fullName));
5859
+ var _fullName$split = fullName.split(':'),
5860
+ type = _fullName$split[0];
5861
+
5862
+ var injections = registry.getTypeInjections(type).concat(registry.getInjections(fullName));
5863
+ return buildInjections(container, injections);
5848
5864
  }
5849
5865
 
5850
5866
  function destroyDestroyables(container) {
@@ -5977,40 +5993,39 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
5977
5993
  @class Registry
5978
5994
  @since 1.11.0
5979
5995
  */
5980
- function Registry() {
5981
- var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
5982
5996
 
5983
- this.fallback = options.fallback || null;
5997
+ var Registry = function () {
5998
+ function Registry() {
5999
+ var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
6000
+
6001
+
6002
+ this.fallback = options.fallback || null;
6003
+ this.resolver = options.resolver || null;
5984
6004
 
5985
- if (options.resolver) {
5986
- this.resolver = options.resolver;
5987
6005
  if (typeof this.resolver === 'function') {
5988
6006
  deprecateResolverFunction(this);
5989
6007
  }
5990
- }
5991
6008
 
5992
- this.registrations = (0, _emberUtils.dictionary)(options.registrations || null);
6009
+ this.registrations = (0, _emberUtils.dictionary)(options.registrations || null);
5993
6010
 
5994
- this._typeInjections = (0, _emberUtils.dictionary)(null);
5995
- this._injections = (0, _emberUtils.dictionary)(null);
6011
+ this._typeInjections = (0, _emberUtils.dictionary)(null);
6012
+ this._injections = (0, _emberUtils.dictionary)(null);
5996
6013
 
5997
- this._localLookupCache = Object.create(null);
5998
- this._normalizeCache = (0, _emberUtils.dictionary)(null);
5999
- this._resolveCache = (0, _emberUtils.dictionary)(null);
6000
- this._failCache = (0, _emberUtils.dictionary)(null);
6014
+ this._localLookupCache = Object.create(null);
6015
+ this._normalizeCache = (0, _emberUtils.dictionary)(null);
6016
+ this._resolveCache = (0, _emberUtils.dictionary)(null);
6017
+ this._failCache = (0, _emberUtils.dictionary)(null);
6001
6018
 
6002
- this._options = (0, _emberUtils.dictionary)(null);
6003
- this._typeOptions = (0, _emberUtils.dictionary)(null);
6004
- }
6019
+ this._options = (0, _emberUtils.dictionary)(null);
6020
+ this._typeOptions = (0, _emberUtils.dictionary)(null);
6021
+ }
6005
6022
 
6006
- Registry.prototype = {
6007
6023
  /**
6008
6024
  A backup registry for resolving registrations when no matches can be found.
6009
6025
  @private
6010
6026
  @property fallback
6011
6027
  @type Registry
6012
6028
  */
6013
- fallback: null,
6014
6029
 
6015
6030
  /**
6016
6031
  An object that has a `resolve` method that resolves a name.
@@ -6018,80 +6033,76 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6018
6033
  @property resolver
6019
6034
  @type Resolver
6020
6035
  */
6021
- resolver: null,
6022
6036
 
6023
6037
  /**
6024
6038
  @private
6025
6039
  @property registrations
6026
6040
  @type InheritingDict
6027
6041
  */
6028
- registrations: null,
6029
6042
 
6030
6043
  /**
6031
6044
  @private
6032
6045
  @property _typeInjections
6033
6046
  @type InheritingDict
6034
6047
  */
6035
- _typeInjections: null,
6036
6048
 
6037
6049
  /**
6038
6050
  @private
6039
6051
  @property _injections
6040
6052
  @type InheritingDict
6041
6053
  */
6042
- _injections: null,
6043
6054
 
6044
6055
  /**
6045
6056
  @private
6046
6057
  @property _normalizeCache
6047
6058
  @type InheritingDict
6048
6059
  */
6049
- _normalizeCache: null,
6050
6060
 
6051
6061
  /**
6052
6062
  @private
6053
6063
  @property _resolveCache
6054
6064
  @type InheritingDict
6055
6065
  */
6056
- _resolveCache: null,
6057
6066
 
6058
6067
  /**
6059
6068
  @private
6060
6069
  @property _options
6061
6070
  @type InheritingDict
6062
6071
  */
6063
- _options: null,
6064
6072
 
6065
6073
  /**
6066
6074
  @private
6067
6075
  @property _typeOptions
6068
6076
  @type InheritingDict
6069
6077
  */
6070
- _typeOptions: null,
6071
6078
 
6072
- container: function (options) {
6079
+ /**
6080
+ Creates a container based on this registry.
6081
+ @private
6082
+ @method container
6083
+ @param {Object} options
6084
+ @return {Container} created container
6085
+ */
6086
+
6087
+ Registry.prototype.container = function (options) {
6073
6088
  return new Container(this, options);
6074
- },
6075
- register: function (fullName, factory) {
6076
- var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
6077
- true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
6089
+ };
6078
6090
 
6079
- if (factory === undefined) {
6080
- throw new TypeError('Attempting to register an unknown factory: \'' + fullName + '\'');
6081
- }
6091
+ Registry.prototype.register = function (fullName, factory) {
6092
+ var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
6093
+ true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
6094
+ true && !(factory !== undefined) && (0, _emberDebug.assert)('Attempting to register an unknown factory: \'' + fullName + '\'', factory !== undefined);
6082
6095
 
6083
6096
  var normalizedName = this.normalize(fullName);
6084
-
6085
- if (this._resolveCache[normalizedName]) {
6086
- throw new Error('Cannot re-register: \'' + fullName + '\', as it has already been resolved.');
6087
- }
6097
+ true && !!this._resolveCache[normalizedName] && (0, _emberDebug.assert)('Cannot re-register: \'' + fullName + '\', as it has already been resolved.', !this._resolveCache[normalizedName]);
6088
6098
 
6089
6099
  delete this._failCache[normalizedName];
6090
6100
  this.registrations[normalizedName] = factory;
6091
6101
  this._options[normalizedName] = options;
6092
- },
6093
- unregister: function (fullName) {
6094
- true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
6102
+ };
6103
+
6104
+ Registry.prototype.unregister = function (fullName) {
6105
+ true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
6095
6106
 
6096
6107
  var normalizedName = this.normalize(fullName);
6097
6108
 
@@ -6101,83 +6112,94 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6101
6112
  delete this._resolveCache[normalizedName];
6102
6113
  delete this._failCache[normalizedName];
6103
6114
  delete this._options[normalizedName];
6104
- },
6105
- resolve: function (fullName, options) {
6106
- true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
6115
+ };
6116
+
6117
+ Registry.prototype.resolve = function (fullName, options) {
6118
+ true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
6107
6119
 
6108
- var factory = resolve(this, this.normalize(fullName), options),
6120
+ var factory = _resolve(this, this.normalize(fullName), options),
6109
6121
  _fallback;
6110
- if (factory === undefined && this.fallback) {
6122
+ if (factory === undefined && this.fallback !== null) {
6111
6123
 
6112
6124
  factory = (_fallback = this.fallback).resolve.apply(_fallback, arguments);
6113
6125
  }
6114
6126
  return factory;
6115
- },
6116
- describe: function (fullName) {
6117
- if (this.resolver && this.resolver.lookupDescription) {
6127
+ };
6128
+
6129
+ Registry.prototype.describe = function (fullName) {
6130
+ if (this.resolver !== null && this.resolver.lookupDescription) {
6118
6131
  return this.resolver.lookupDescription(fullName);
6119
- } else if (this.fallback) {
6132
+ } else if (this.fallback !== null) {
6120
6133
  return this.fallback.describe(fullName);
6121
6134
  } else {
6122
6135
  return fullName;
6123
6136
  }
6124
- },
6125
- normalizeFullName: function (fullName) {
6126
- if (this.resolver && this.resolver.normalize) {
6137
+ };
6138
+
6139
+ Registry.prototype.normalizeFullName = function (fullName) {
6140
+ if (this.resolver !== null && this.resolver.normalize) {
6127
6141
  return this.resolver.normalize(fullName);
6128
- } else if (this.fallback) {
6142
+ } else if (this.fallback !== null) {
6129
6143
  return this.fallback.normalizeFullName(fullName);
6130
6144
  } else {
6131
6145
  return fullName;
6132
6146
  }
6133
- },
6134
- normalize: function (fullName) {
6147
+ };
6148
+
6149
+ Registry.prototype.normalize = function (fullName) {
6135
6150
  return this._normalizeCache[fullName] || (this._normalizeCache[fullName] = this.normalizeFullName(fullName));
6136
- },
6137
- makeToString: function (factory, fullName) {
6138
- if (this.resolver && this.resolver.makeToString) {
6151
+ };
6152
+
6153
+ Registry.prototype.makeToString = function (factory, fullName) {
6154
+ if (this.resolver !== null && this.resolver.makeToString) {
6139
6155
  return this.resolver.makeToString(factory, fullName);
6140
- } else if (this.fallback) {
6156
+ } else if (this.fallback !== null) {
6141
6157
  return this.fallback.makeToString(factory, fullName);
6142
6158
  } else {
6143
6159
  return factory.toString();
6144
6160
  }
6145
- },
6146
- has: function (fullName, options) {
6161
+ };
6162
+
6163
+ Registry.prototype.has = function (fullName, options) {
6147
6164
  if (!this.isValidFullName(fullName)) {
6148
6165
  return false;
6149
6166
  }
6150
6167
 
6151
6168
  var source = options && options.source && this.normalize(options.source);
6152
6169
 
6153
- return has(this, this.normalize(fullName), source);
6154
- },
6155
- optionsForType: function (type, options) {
6170
+ return _has(this, this.normalize(fullName), source);
6171
+ };
6172
+
6173
+ Registry.prototype.optionsForType = function (type, options) {
6156
6174
  this._typeOptions[type] = options;
6157
- },
6158
- getOptionsForType: function (type) {
6175
+ };
6176
+
6177
+ Registry.prototype.getOptionsForType = function (type) {
6159
6178
  var optionsForType = this._typeOptions[type];
6160
- if (optionsForType === undefined && this.fallback) {
6179
+ if (optionsForType === undefined && this.fallback !== null) {
6161
6180
  optionsForType = this.fallback.getOptionsForType(type);
6162
6181
  }
6163
6182
  return optionsForType;
6164
- },
6165
- options: function (fullName) {
6166
- var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
6183
+ };
6184
+
6185
+ Registry.prototype.options = function (fullName) {
6186
+ var _options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
6167
6187
 
6168
6188
  var normalizedName = this.normalize(fullName);
6169
- this._options[normalizedName] = options;
6170
- },
6171
- getOptions: function (fullName) {
6189
+ this._options[normalizedName] = _options;
6190
+ };
6191
+
6192
+ Registry.prototype.getOptions = function (fullName) {
6172
6193
  var normalizedName = this.normalize(fullName);
6173
6194
  var options = this._options[normalizedName];
6174
6195
 
6175
- if (options === undefined && this.fallback) {
6196
+ if (options === undefined && this.fallback !== null) {
6176
6197
  options = this.fallback.getOptions(fullName);
6177
6198
  }
6178
6199
  return options;
6179
- },
6180
- getOption: function (fullName, optionName) {
6200
+ };
6201
+
6202
+ Registry.prototype.getOption = function (fullName, optionName) {
6181
6203
  var options = this._options[fullName];
6182
6204
 
6183
6205
  if (options && options[optionName] !== undefined) {
@@ -6189,39 +6211,41 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6189
6211
 
6190
6212
  if (options && options[optionName] !== undefined) {
6191
6213
  return options[optionName];
6192
- } else if (this.fallback) {
6214
+ } else if (this.fallback !== null) {
6193
6215
  return this.fallback.getOption(fullName, optionName);
6194
6216
  }
6195
- },
6196
- typeInjection: function (type, property, fullName) {
6197
- true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
6217
+ };
6218
+
6219
+ Registry.prototype.typeInjection = function (type, property, fullName) {
6220
+ true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
6198
6221
 
6199
6222
  var fullNameType = fullName.split(':')[0];
6200
- if (fullNameType === type) {
6201
- throw new Error('Cannot inject a \'' + fullName + '\' on other ' + type + '(s).');
6202
- }
6223
+ true && !(fullNameType !== type) && (0, _emberDebug.assert)('Cannot inject a \'' + fullName + '\' on other ' + type + '(s).', fullNameType !== type);
6203
6224
 
6204
6225
  var injections = this._typeInjections[type] || (this._typeInjections[type] = []);
6205
6226
 
6206
6227
  injections.push({ property: property, fullName: fullName });
6207
- },
6208
- injection: function (fullName, property, injectionName) {
6209
- this.validateFullName(injectionName);
6228
+ };
6229
+
6230
+ Registry.prototype.injection = function (fullName, property, injectionName) {
6231
+ true && !this.isValidFullName(injectionName) && (0, _emberDebug.assert)('Invalid injectionName, expected: \'type:name\' got: ' + injectionName, this.isValidFullName(injectionName));
6232
+
6210
6233
  var normalizedInjectionName = this.normalize(injectionName);
6211
6234
 
6212
6235
  if (fullName.indexOf(':') === -1) {
6213
6236
  return this.typeInjection(fullName, property, normalizedInjectionName);
6214
6237
  }
6215
6238
 
6216
- true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
6239
+ true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
6217
6240
 
6218
6241
  var normalizedName = this.normalize(fullName);
6219
6242
 
6220
6243
  var injections = this._injections[normalizedName] || (this._injections[normalizedName] = []);
6221
6244
 
6222
6245
  injections.push({ property: property, fullName: normalizedInjectionName });
6223
- },
6224
- knownForType: function (type) {
6246
+ };
6247
+
6248
+ Registry.prototype.knownForType = function (type) {
6225
6249
  var fallbackKnown = void 0,
6226
6250
  resolverKnown = void 0,
6227
6251
  index,
@@ -6240,74 +6264,72 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6240
6264
  }
6241
6265
  }
6242
6266
 
6243
- if (this.fallback) {
6267
+ if (this.fallback !== null) {
6244
6268
  fallbackKnown = this.fallback.knownForType(type);
6245
6269
  }
6246
6270
 
6247
- if (this.resolver && this.resolver.knownForType) {
6271
+ if (this.resolver !== null && this.resolver.knownForType) {
6248
6272
  resolverKnown = this.resolver.knownForType(type);
6249
6273
  }
6250
6274
 
6251
6275
  return (0, _emberUtils.assign)({}, fallbackKnown, localKnown, resolverKnown);
6252
- },
6253
- validateFullName: function (fullName) {
6254
- if (!this.isValidFullName(fullName)) {
6255
- throw new TypeError('Invalid Fullname, expected: \'type:name\' got: ' + fullName);
6256
- }
6276
+ };
6257
6277
 
6258
- return true;
6259
- },
6260
- isValidFullName: function (fullName) {
6278
+ Registry.prototype.isValidFullName = function (fullName) {
6261
6279
  return VALID_FULL_NAME_REGEXP.test(fullName);
6262
- },
6263
- getInjections: function (fullName) {
6280
+ };
6281
+
6282
+ Registry.prototype.getInjections = function (fullName) {
6264
6283
  var injections = this._injections[fullName] || [];
6265
- if (this.fallback) {
6284
+ if (this.fallback !== null) {
6266
6285
  injections = injections.concat(this.fallback.getInjections(fullName));
6267
6286
  }
6268
6287
  return injections;
6269
- },
6270
- getTypeInjections: function (type) {
6288
+ };
6289
+
6290
+ Registry.prototype.getTypeInjections = function (type) {
6271
6291
  var injections = this._typeInjections[type] || [];
6272
- if (this.fallback) {
6292
+ if (this.fallback !== null) {
6273
6293
  injections = injections.concat(this.fallback.getTypeInjections(type));
6274
6294
  }
6275
6295
  return injections;
6276
- },
6277
- resolverCacheKey: function (name, options) {
6296
+ };
6297
+
6298
+ Registry.prototype.resolverCacheKey = function (name, options) {
6278
6299
  if (!_features.EMBER_MODULE_UNIFICATION) {
6279
6300
  return name;
6280
6301
  }
6281
6302
 
6282
6303
  return options && options.source ? options.source + ':' + name : name;
6283
- },
6284
- expandLocalLookup: function (fullName, options) {
6304
+ };
6305
+
6306
+ Registry.prototype.expandLocalLookup = function (fullName, options) {
6285
6307
  var normalizedFullName, normalizedSource;
6286
6308
 
6287
- if (this.resolver && this.resolver.expandLocalLookup) {
6288
- true && !this.validateFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.validateFullName(fullName));
6309
+ if (this.resolver !== null && this.resolver.expandLocalLookup) {
6310
+ true && !this.isValidFullName(fullName) && (0, _emberDebug.assert)('fullName must be a proper full name', this.isValidFullName(fullName));
6289
6311
  true && !(options && options.source) && (0, _emberDebug.assert)('options.source must be provided to expandLocalLookup', options && options.source);
6290
- true && !this.validateFullName(options.source) && (0, _emberDebug.assert)('options.source must be a proper full name', this.validateFullName(options.source));
6312
+ true && !this.isValidFullName(options.source) && (0, _emberDebug.assert)('options.source must be a proper full name', this.isValidFullName(options.source));
6291
6313
 
6292
6314
  normalizedFullName = this.normalize(fullName);
6293
6315
  normalizedSource = this.normalize(options.source);
6294
6316
 
6295
6317
 
6296
- return expandLocalLookup(this, normalizedFullName, normalizedSource);
6297
- } else if (this.fallback) {
6318
+ return _expandLocalLookup(this, normalizedFullName, normalizedSource);
6319
+ } else if (this.fallback !== null) {
6298
6320
  return this.fallback.expandLocalLookup(fullName, options);
6299
6321
  } else {
6300
6322
  return null;
6301
6323
  }
6302
- }
6303
- };
6324
+ };
6325
+
6326
+ return Registry;
6327
+ }();
6304
6328
 
6305
6329
  function deprecateResolverFunction(registry) {
6306
6330
  true && !false && (0, _emberDebug.deprecate)('Passing a `resolver` function into a Registry is deprecated. Please pass in a Resolver object with a `resolve` method.', false, { id: 'ember-application.registry-resolver-as-function', until: '3.0.0', url: 'https://emberjs.com/deprecations/v2.x#toc_registry-resolver-as-function' });
6307
6331
 
6308
- registry.resolver = {
6309
- resolve: registry.resolver
6310
- };
6332
+ registry.resolver = { resolve: registry.resolver };
6311
6333
  }
6312
6334
 
6313
6335
  Registry.prototype.normalizeInjectionsHash = function (hash) {
@@ -6315,7 +6337,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6315
6337
 
6316
6338
  for (var key in hash) {
6317
6339
  if (hash.hasOwnProperty(key)) {
6318
- true && !this.validateFullName(hash[key]) && (0, _emberDebug.assert)('Expected a proper full name, given \'' + hash[key] + '\'', this.validateFullName(hash[key]));
6340
+ true && !this.isValidFullName(hash[key]) && (0, _emberDebug.assert)('Expected a proper full name, given \'' + hash[key] + '\'', this.isValidFullName(hash[key]));
6319
6341
 
6320
6342
  injections.push({
6321
6343
  property: key,
@@ -6343,7 +6365,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6343
6365
  };
6344
6366
 
6345
6367
 
6346
- function expandLocalLookup(registry, normalizedName, normalizedSource) {
6368
+ function _expandLocalLookup(registry, normalizedName, normalizedSource) {
6347
6369
  var cache = registry._localLookupCache;
6348
6370
  var normalizedNameCache = cache[normalizedName];
6349
6371
 
@@ -6362,7 +6384,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6362
6384
  return normalizedNameCache[normalizedSource] = expanded;
6363
6385
  }
6364
6386
 
6365
- function resolve(registry, normalizedName, options) {
6387
+ function _resolve(registry, normalizedName, options) {
6366
6388
  if (options && options.source) {
6367
6389
  // when `source` is provided expand normalizedName
6368
6390
  // and source into the full normalizedName
@@ -6413,7 +6435,7 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6413
6435
  return resolved;
6414
6436
  }
6415
6437
 
6416
- function has(registry, fullName, source) {
6438
+ function _has(registry, fullName, source) {
6417
6439
  return registry.resolve(fullName, { source: source }) !== undefined;
6418
6440
  }
6419
6441
 
@@ -6436,9 +6458,9 @@ enifed('container', ['exports', 'ember-utils', 'ember-debug', 'ember/features'],
6436
6458
  return name;
6437
6459
  }
6438
6460
 
6439
- var _fullName$split = fullName.split(':'),
6440
- type = _fullName$split[0],
6441
- rawName = _fullName$split[1];
6461
+ var _fullName$split2 = fullName.split(':'),
6462
+ type = _fullName$split2[0],
6463
+ rawName = _fullName$split2[1];
6442
6464
 
6443
6465
  return privateNames[fullName] = (0, _emberUtils.intern)(type + ':' + rawName + '-' + privateSuffix);
6444
6466
  };
@@ -6526,13 +6548,7 @@ enifed('ember-console', ['exports', 'ember-environment'], function (exports, _em
6526
6548
  return;
6527
6549
  }
6528
6550
 
6529
- if (typeof method.bind === 'function') {
6530
- return method.bind(consoleObj);
6531
- }
6532
-
6533
- return function () {
6534
- method.apply(consoleObj, arguments);
6535
- };
6551
+ return method.bind(consoleObj);
6536
6552
  }
6537
6553
 
6538
6554
  /**
@@ -11126,6 +11142,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
11126
11142
  }
11127
11143
 
11128
11144
  var ret = this._getter.call(obj, keyName);
11145
+
11129
11146
  cache[keyName] = ret === undefined ? UNDEFINED : ret;
11130
11147
 
11131
11148
  var chainWatchers = meta$$1.readableChainWatchers();
@@ -11181,14 +11198,13 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
11181
11198
  ComputedPropertyPrototype._set = function (obj, keyName, value) {
11182
11199
  var meta$$1 = meta(obj);
11183
11200
  var cache = meta$$1.writableCache();
11184
- var hadCachedValue = false;
11185
- var cachedValue = void 0;
11201
+
11186
11202
  var val = cache[keyName];
11187
- if (val !== undefined) {
11188
- if (val !== UNDEFINED) {
11189
- cachedValue = val;
11190
- }
11191
- hadCachedValue = true;
11203
+ var hadCachedValue = val !== undefined;
11204
+
11205
+ var cachedValue = void 0;
11206
+ if (hadCachedValue && val !== UNDEFINED) {
11207
+ cachedValue = val;
11192
11208
  }
11193
11209
 
11194
11210
  var ret = this._setter.call(obj, keyName, value, cachedValue);
@@ -11200,17 +11216,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
11200
11216
 
11201
11217
  propertyWillChange(obj, keyName, meta$$1);
11202
11218
 
11203
- if (hadCachedValue) {
11204
- cache[keyName] = undefined;
11205
- } else {
11219
+ if (!hadCachedValue) {
11206
11220
  addDependentKeys(this, obj, keyName, meta$$1);
11207
11221
  }
11208
11222
 
11209
- if (ret === undefined) {
11210
- cache[keyName] = UNDEFINED;
11211
- } else {
11212
- cache[keyName] = ret;
11213
- }
11223
+ cache[keyName] = ret === undefined ? UNDEFINED : ret;
11214
11224
 
11215
11225
  propertyDidChange(obj, keyName, meta$$1);
11216
11226
 
@@ -12641,17 +12651,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
12641
12651
  this._coreLibIndex = 0;
12642
12652
  }
12643
12653
 
12644
- Libraries.prototype.isRegistered = function (name) {
12645
- return !!this._getLibraryByName(name);
12646
- };
12647
-
12648
- return Libraries;
12649
- }();
12650
-
12651
- Libraries.prototype = {
12652
- constructor: Libraries,
12653
-
12654
- _getLibraryByName: function (name) {
12654
+ Libraries.prototype._getLibraryByName = function (name) {
12655
12655
  var libs = this._registry,
12656
12656
  i;
12657
12657
  var count = libs.length;
@@ -12661,8 +12661,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
12661
12661
  return libs[i];
12662
12662
  }
12663
12663
  }
12664
- },
12665
- register: function (name, version, isCoreLibrary) {
12664
+ };
12665
+
12666
+ Libraries.prototype.register = function (name, version, isCoreLibrary) {
12666
12667
  var index = this._registry.length;
12667
12668
 
12668
12669
  if (!this._getLibraryByName(name)) {
@@ -12673,11 +12674,13 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
12673
12674
  } else {
12674
12675
  true && emberDebug.warn('Library "' + name + '" is already registered with Ember.', false, { id: 'ember-metal.libraries-register' });
12675
12676
  }
12676
- },
12677
- registerCoreLibrary: function (name, version) {
12677
+ };
12678
+
12679
+ Libraries.prototype.registerCoreLibrary = function (name, version) {
12678
12680
  this.register(name, version, true);
12679
- },
12680
- deRegister: function (name) {
12681
+ };
12682
+
12683
+ Libraries.prototype.deRegister = function (name) {
12681
12684
  var lib = this._getLibraryByName(name);
12682
12685
  var index = void 0;
12683
12686
 
@@ -12685,8 +12688,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
12685
12688
  index = this._registry.indexOf(lib);
12686
12689
  this._registry.splice(index, 1);
12687
12690
  }
12688
- }
12689
- };
12691
+ };
12692
+
12693
+ return Libraries;
12694
+ }();
12690
12695
 
12691
12696
  if (ember_features.EMBER_LIBRARIES_ISREGISTERED) {
12692
12697
  Libraries.prototype.isRegistered = function (name) {
@@ -15681,7 +15686,7 @@ enifed('ember-template-compiler/plugins/transform-dot-component-invocation', ['e
15681
15686
  };
15682
15687
 
15683
15688
  function isMultipartPath(path) {
15684
- return path.parts.length > 1;
15689
+ return path.parts && path.parts.length > 1;
15685
15690
  }
15686
15691
 
15687
15692
  function isInlineInvocation(path, params, hash) {
@@ -16434,7 +16439,6 @@ enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-util
16434
16439
  var options = (0, _emberUtils.assign)({ meta: {} }, _options),
16435
16440
  meta,
16436
16441
  potententialPugins,
16437
- providedPlugins,
16438
16442
  pluginsToAdd;
16439
16443
 
16440
16444
  // move `moduleName` into `meta` property
@@ -16448,14 +16452,11 @@ enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-util
16448
16452
  options.plugins = { ast: [].concat(USER_PLUGINS, _plugins.default) };
16449
16453
  } else {
16450
16454
  potententialPugins = [].concat(USER_PLUGINS, _plugins.default);
16451
- providedPlugins = options.plugins.ast.map(function (plugin) {
16452
- return wrapLegacyPluginIfNeeded(plugin);
16453
- });
16454
16455
  pluginsToAdd = potententialPugins.filter(function (plugin) {
16455
16456
  return options.plugins.ast.indexOf(plugin) === -1;
16456
16457
  });
16457
16458
 
16458
- options.plugins.ast = providedPlugins.concat(pluginsToAdd);
16459
+ options.plugins.ast = options.plugins.ast.slice().concat(pluginsToAdd);
16459
16460
  }
16460
16461
 
16461
16462
  return options;
@@ -16465,65 +16466,40 @@ enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-util
16465
16466
  throw new Error('Attempting to register ' + _plugin + ' as "' + type + '" which is not a valid Glimmer plugin type.');
16466
16467
  }
16467
16468
 
16468
- for (i = 0; i < USER_PLUGINS.length; i++) {
16469
- PLUGIN = USER_PLUGINS[i];
16470
-
16471
- if (PLUGIN === _plugin || PLUGIN.__raw === _plugin) {
16472
- return;
16473
- }
16474
- }
16475
-
16476
- var plugin = wrapLegacyPluginIfNeeded(_plugin),
16477
- i,
16478
- PLUGIN;
16479
-
16480
- USER_PLUGINS = [plugin].concat(USER_PLUGINS);
16481
- };
16482
- exports.unregisterPlugin = function (type, PluginClass) {
16483
- if (type !== 'ast') {
16484
- throw new Error('Attempting to unregister ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.');
16485
- }
16486
-
16487
- USER_PLUGINS = USER_PLUGINS.filter(function (plugin) {
16488
- return plugin !== PluginClass && plugin.__raw !== PluginClass;
16489
- });
16490
- };
16491
-
16492
- var USER_PLUGINS = [];
16493
-
16494
- function wrapLegacyPluginIfNeeded(_plugin) {
16495
- var plugin = _plugin;
16469
+ var plugin = void 0;
16496
16470
  if (_plugin.prototype && _plugin.prototype.transform) {
16497
16471
  plugin = function (env) {
16498
- var pluginInstantiated = false;
16499
-
16500
16472
  return {
16501
16473
  name: _plugin.constructor && _plugin.constructor.name,
16502
16474
 
16503
16475
  visitors: {
16504
16476
  Program: function (node) {
16505
- var _plugin2;
16506
-
16507
- if (!pluginInstantiated) {
16508
-
16509
- pluginInstantiated = true;
16510
- _plugin2 = new _plugin(env);
16477
+ var plugin = new _plugin(env);
16511
16478
 
16479
+ plugin.syntax = env.syntax;
16512
16480
 
16513
- _plugin2.syntax = env.syntax;
16514
-
16515
- return _plugin2.transform(node);
16516
- }
16481
+ return plugin.transform(node);
16517
16482
  }
16518
16483
  }
16519
16484
  };
16520
16485
  };
16486
+ } else {
16487
+ plugin = _plugin;
16488
+ }
16521
16489
 
16522
- plugin.__raw = _plugin;
16490
+ USER_PLUGINS = [plugin].concat(USER_PLUGINS);
16491
+ };
16492
+ exports.removePlugin = function (type, PluginClass) {
16493
+ if (type !== 'ast') {
16494
+ throw new Error('Attempting to unregister ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.');
16523
16495
  }
16524
16496
 
16525
- return plugin;
16526
- }
16497
+ USER_PLUGINS = USER_PLUGINS.filter(function (plugin) {
16498
+ return plugin !== PluginClass;
16499
+ });
16500
+ };
16501
+
16502
+ var USER_PLUGINS = [];
16527
16503
  });
16528
16504
  enifed('ember-template-compiler/system/compile', ['exports', 'require', 'ember-template-compiler/system/precompile'], function (exports, _require2, _precompile) {
16529
16505
  'use strict';
@@ -16677,7 +16653,7 @@ enifed('ember-utils', ['exports'], function (exports) {
16677
16653
  @type String
16678
16654
  @final
16679
16655
  */
16680
- var GUID_PREFIX = 'ember';
16656
+
16681
16657
 
16682
16658
  // Used for guid generation...
16683
16659
  var numberCache = [];
@@ -16734,7 +16710,24 @@ enifed('ember-utils', ['exports'], function (exports) {
16734
16710
  separate the guid into separate namespaces.
16735
16711
  @return {String} the guid
16736
16712
  */
16713
+ function generateGuid(obj) {
16714
+ var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'ember';
16737
16715
 
16716
+ var ret = prefix + uuid();
16717
+ if (obj !== undefined && obj !== null) {
16718
+ if (obj[GUID_KEY] === null) {
16719
+ obj[GUID_KEY] = ret;
16720
+ } else {
16721
+ GUID_DESC.value = ret;
16722
+ if (obj.__defineNonEnumerable) {
16723
+ obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
16724
+ } else {
16725
+ Object.defineProperty(obj, GUID_KEY, GUID_DESC);
16726
+ }
16727
+ }
16728
+ }
16729
+ return ret;
16730
+ }
16738
16731
 
16739
16732
  /**
16740
16733
  Returns a unique id for the object. If the object does not yet have a guid,
@@ -16758,7 +16751,7 @@ enifed('ember-utils', ['exports'], function (exports) {
16758
16751
  // want to require non-enumerability for this API, which
16759
16752
  // would introduce a large cost.
16760
16753
  var id = GUID_KEY + Math.floor(Math.random() * new Date());
16761
- return intern('__' + debugName + '__ [id=' + id + ']');
16754
+ return intern('__' + debugName + id + '__');
16762
16755
  }
16763
16756
 
16764
16757
  /**
@@ -17151,34 +17144,8 @@ enifed('ember-utils', ['exports'], function (exports) {
17151
17144
  exports.GUID_KEY = GUID_KEY;
17152
17145
  exports.GUID_DESC = GUID_DESC;
17153
17146
  exports.GUID_KEY_PROPERTY = GUID_KEY_PROPERTY;
17154
- exports.generateGuid = function (obj, prefix) {
17155
- if (!prefix) {
17156
- prefix = GUID_PREFIX;
17157
- }
17158
-
17159
- var ret = prefix + uuid();
17160
- if (obj) {
17161
- if (obj[GUID_KEY] === null) {
17162
- obj[GUID_KEY] = ret;
17163
- } else {
17164
- GUID_DESC.value = ret;
17165
- if (obj.__defineNonEnumerable) {
17166
- obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
17167
- } else {
17168
- Object.defineProperty(obj, GUID_KEY, GUID_DESC);
17169
- }
17170
- }
17171
- }
17172
- return ret;
17173
- };
17147
+ exports.generateGuid = generateGuid;
17174
17148
  exports.guidFor = function (obj) {
17175
- var type = typeof obj;
17176
-
17177
-
17178
- if ((type === 'object' && obj !== null || type === 'function') && obj[GUID_KEY]) {
17179
- return obj[GUID_KEY];
17180
- }
17181
-
17182
17149
  // special cases where we don't want to add a key to object
17183
17150
  if (obj === undefined) {
17184
17151
  return '(undefined)';
@@ -17188,8 +17155,12 @@ enifed('ember-utils', ['exports'], function (exports) {
17188
17155
  return '(null)';
17189
17156
  }
17190
17157
 
17191
- var ret = void 0;
17158
+ var type = typeof obj;
17159
+ if ((type === 'object' || type === 'function') && obj[GUID_KEY]) {
17160
+ return obj[GUID_KEY];
17161
+ }
17192
17162
 
17163
+ var ret = void 0;
17193
17164
  // Don't allow prototype changes to String etc. to change the guidFor
17194
17165
  switch (type) {
17195
17166
  case 'number':
@@ -17222,20 +17193,7 @@ enifed('ember-utils', ['exports'], function (exports) {
17222
17193
  return '(Array)';
17223
17194
  }
17224
17195
 
17225
- ret = GUID_PREFIX + uuid();
17226
-
17227
- if (obj[GUID_KEY] === null) {
17228
- obj[GUID_KEY] = ret;
17229
- } else {
17230
- GUID_DESC.value = ret;
17231
-
17232
- if (obj.__defineNonEnumerable) {
17233
- obj.__defineNonEnumerable(GUID_KEY_PROPERTY);
17234
- } else {
17235
- Object.defineProperty(obj, GUID_KEY, GUID_DESC);
17236
- }
17237
- }
17238
- return ret;
17196
+ return generateGuid(obj);
17239
17197
  }
17240
17198
  };
17241
17199
  exports.intern = intern;
@@ -17349,7 +17307,7 @@ enifed('ember/features', ['exports', 'ember-environment', 'ember-utils'], functi
17349
17307
  enifed("ember/version", ["exports"], function (exports) {
17350
17308
  "use strict";
17351
17309
 
17352
- exports.default = "2.17.2";
17310
+ exports.default = "2.18.0-beta.1";
17353
17311
  });
17354
17312
  enifed("handlebars", ["exports"], function (exports) {
17355
17313
  "use strict";
@@ -18740,16 +18698,17 @@ enifed("handlebars", ["exports"], function (exports) {
18740
18698
  return strip.accept(handlebars.parse(input));
18741
18699
  };
18742
18700
  });
18701
+ /*global enifed */
18743
18702
  enifed('node-module', ['exports'], function(_exports) {
18744
18703
  var IS_NODE = typeof module === 'object' && typeof module.require === 'function';
18745
18704
  if (IS_NODE) {
18746
18705
  _exports.require = module.require;
18747
18706
  _exports.module = module;
18748
- _exports.IS_NODE = IS_NODE
18707
+ _exports.IS_NODE = IS_NODE;
18749
18708
  } else {
18750
18709
  _exports.require = null;
18751
18710
  _exports.module = null;
18752
- _exports.IS_NODE = IS_NODE
18711
+ _exports.IS_NODE = IS_NODE;
18753
18712
  }
18754
18713
  });
18755
18714
  enifed("simple-html-tokenizer", ["exports"], function (exports) {