dist/ember-template-compiler.js in ember-source-2.9.0.alpha.2 vs dist/ember-template-compiler.js in ember-source-2.9.0.beta.1

- old
+ new

@@ -4,11 +4,11 @@ * @copyright Copyright 2011-2016 Tilde Inc. and contributors * Portions Copyright 2006-2011 Strobe Inc. * Portions Copyright 2008-2011 Apple Inc. All rights reserved. * @license Licensed under MIT license * See https://raw.github.com/emberjs/ember.js/master/LICENSE - * @version v2.9.0-alpha.2 + * @version 2.9.0-beta.1 */ var enifed, requireModule, require, Ember; var mainContext = this; @@ -110,1049 +110,2454 @@ enifed = Ember.__loader.define; require = requireModule = Ember.__loader.require; } })(); -enifed('backburner', ['exports', 'backburner/utils', 'backburner/platform', 'backburner/binary-search', 'backburner/deferred-action-queues'], function (exports, _backburnerUtils, _backburnerPlatform, _backburnerBinarySearch, _backburnerDeferredActionQueues) { - 'use strict'; +var babelHelpers; - exports.default = Backburner; +function classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError('Cannot call a class as a function'); + } +} - function Backburner(queueNames, options) { - this.queueNames = queueNames; - this.options = options || {}; - if (!this.options.defaultQueue) { - this.options.defaultQueue = queueNames[0]; +function inherits(subClass, superClass) { + if (typeof superClass !== 'function' && superClass !== null) { + throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true } - this.instanceStack = []; - this._debouncees = []; - this._throttlers = []; - this._eventCallbacks = { - end: [], - begin: [] - }; + }); - var _this = this; - this._boundClearItems = function () { - clearItems(); - }; + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : defaults(subClass, superClass); +} - this._timerTimeoutId = undefined; - this._timers = []; +function taggedTemplateLiteralLoose(strings, raw) { + strings.raw = raw; + return strings; +} - this._platform = this.options._platform || _backburnerPlatform.default; +function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ('value' in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} - this._boundRunExpiredTimers = function () { - _this._runExpiredTimers(); - }; +function createClass(Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; +} + +function interopExportWildcard(obj, defaults) { + var newObj = defaults({}, obj); + delete newObj['default']; + return newObj; +} + +function defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } } + return obj; +} - Backburner.prototype = { - begin: function () { - var options = this.options; - var onBegin = options && options.onBegin; - var previousInstance = this.currentInstance; +babelHelpers = { + classCallCheck: classCallCheck, + inherits: inherits, + taggedTemplateLiteralLoose: taggedTemplateLiteralLoose, + slice: Array.prototype.slice, + createClass: createClass, + interopExportWildcard: interopExportWildcard, + defaults: defaults +}; - if (previousInstance) { - this.instanceStack.push(previousInstance); - } +enifed('backburner', ['exports'], function (exports) { 'use strict'; - this.currentInstance = new _backburnerDeferredActionQueues.default(this.queueNames, options); - this._trigger('begin', this.currentInstance, previousInstance); - if (onBegin) { - onBegin(this.currentInstance, previousInstance); - } - }, +var NUMBER = /\d+/; - end: function () { - var options = this.options; - var onEnd = options && options.onEnd; - var currentInstance = this.currentInstance; - var nextInstance = null; +function each(collection, callback) { + for (var i = 0; i < collection.length; i++) { + callback(collection[i]); + } +} - // Prevent double-finally bug in Safari 6.0.2 and iOS 6 - // This bug appears to be resolved in Safari 6.0.5 and iOS 7 - var finallyAlreadyCalled = false; - try { - currentInstance.flush(); - } finally { - if (!finallyAlreadyCalled) { - finallyAlreadyCalled = true; +function isString(suspect) { + return typeof suspect === 'string'; +} - this.currentInstance = null; +function isFunction(suspect) { + return typeof suspect === 'function'; +} - if (this.instanceStack.length) { - nextInstance = this.instanceStack.pop(); - this.currentInstance = nextInstance; - } - this._trigger('end', currentInstance, nextInstance); - if (onEnd) { - onEnd(currentInstance, nextInstance); - } - } - } - }, +function isNumber(suspect) { + return typeof suspect === 'number'; +} - /** - Trigger an event. Supports up to two arguments. Designed around - triggering transition events from one run loop instance to the - next, which requires an argument for the first instance and then - an argument for the next instance. - @private - @method _trigger - @param {String} eventName - @param {any} arg1 - @param {any} arg2 - */ - _trigger: function (eventName, arg1, arg2) { - var callbacks = this._eventCallbacks[eventName]; - if (callbacks) { - for (var i = 0; i < callbacks.length; i++) { - callbacks[i](arg1, arg2); - } +function isCoercableNumber(number) { + return isNumber(number) || NUMBER.test(number); +} + +function binarySearch(time, timers) { + var start = 0; + var end = timers.length - 2; + var middle, l; + + while (start < end) { + // since timers is an array of pairs 'l' will always + // be an integer + l = (end - start) / 2; + + // compensate for the index in case even number + // of pairs inside timers + middle = start + l - (l % 2); + + if (time >= timers[middle]) { + start = middle + 2; + } else { + end = middle; + } + } + + return (time >= timers[start]) ? start + 2 : start; +} + +function Queue(name, options, globalOptions) { + this.name = name; + this.globalOptions = globalOptions || {}; + this.options = options; + this._queue = []; + this.targetQueues = {}; + this._queueBeingFlushed = undefined; +} + +Queue.prototype = { + push: function(target, method, args, stack) { + var queue = this._queue; + queue.push(target, method, args, stack); + + return { + queue: this, + target: target, + method: method + }; + }, + + pushUniqueWithoutGuid: function(target, method, args, stack) { + var queue = this._queue; + + for (var i = 0, l = queue.length; i < l; i += 4) { + var currentTarget = queue[i]; + var currentMethod = queue[i+1]; + + if (currentTarget === target && currentMethod === method) { + queue[i+2] = args; // replace args + queue[i+3] = stack; // replace stack + return; } - }, + } - on: function (eventName, callback) { - if (typeof callback !== 'function') { - throw new TypeError('Callback must be a function'); + queue.push(target, method, args, stack); + }, + + targetQueue: function(targetQueue, target, method, args, stack) { + var queue = this._queue; + + for (var i = 0, l = targetQueue.length; i < l; i += 2) { + var currentMethod = targetQueue[i]; + var currentIndex = targetQueue[i + 1]; + + if (currentMethod === method) { + queue[currentIndex + 2] = args; // replace args + queue[currentIndex + 3] = stack; // replace stack + return; } - var callbacks = this._eventCallbacks[eventName]; - if (callbacks) { - callbacks.push(callback); - } else { - throw new TypeError('Cannot on() event "' + eventName + '" because it does not exist'); - } - }, + } - off: function (eventName, callback) { - if (eventName) { - var callbacks = this._eventCallbacks[eventName]; - var callbackFound = false; - if (!callbacks) return; - if (callback) { - for (var i = 0; i < callbacks.length; i++) { - if (callbacks[i] === callback) { - callbackFound = true; - callbacks.splice(i, 1); - i--; - } - } - } - if (!callbackFound) { - throw new TypeError('Cannot off() callback that does not exist'); - } - } else { - throw new TypeError('Cannot off() event "' + eventName + '" because it does not exist'); + targetQueue.push( + method, + queue.push(target, method, args, stack) - 4 + ); + }, + + pushUniqueWithGuid: function(guid, target, method, args, stack) { + var hasLocalQueue = this.targetQueues[guid]; + + if (hasLocalQueue) { + this.targetQueue(hasLocalQueue, target, method, args, stack); + } else { + this.targetQueues[guid] = [ + method, + this._queue.push(target, method, args, stack) - 4 + ]; + } + + return { + queue: this, + target: target, + method: method + }; + }, + + pushUnique: function(target, method, args, stack) { + var KEY = this.globalOptions.GUID_KEY; + + if (target && KEY) { + var guid = target[KEY]; + if (guid) { + return this.pushUniqueWithGuid(guid, target, method, args, stack); } - }, + } - run: function () /* target, method, args */{ - var length = arguments.length; - var method, target, args; + this.pushUniqueWithoutGuid(target, method, args, stack); - if (length === 1) { - method = arguments[0]; - target = null; + return { + queue: this, + target: target, + method: method + }; + }, + + invoke: function(target, method, args /*, onError, errorRecordedForStack */) { + if (args && args.length > 0) { + method.apply(target, args); + } else { + method.call(target); + } + }, + + invokeWithOnError: function(target, method, args, onError, errorRecordedForStack) { + try { + if (args && args.length > 0) { + method.apply(target, args); } else { - target = arguments[0]; - method = arguments[1]; + method.call(target); } + } catch(error) { + onError(error, errorRecordedForStack); + } + }, - if (_backburnerUtils.isString(method)) { + flush: function(sync) { + var queue = this._queue; + var length = queue.length; + + if (length === 0) { + return; + } + + var globalOptions = this.globalOptions; + var options = this.options; + var before = options && options.before; + var after = options && options.after; + var onError = globalOptions.onError || (globalOptions.onErrorTarget && + globalOptions.onErrorTarget[globalOptions.onErrorMethod]); + var target, method, args, errorRecordedForStack; + var invoke = onError ? this.invokeWithOnError : this.invoke; + + this.targetQueues = Object.create(null); + var queueItems = this._queueBeingFlushed = this._queue.slice(); + this._queue = []; + + if (before) { + before(); + } + + for (var i = 0; i < length; i += 4) { + target = queueItems[i]; + method = queueItems[i+1]; + args = queueItems[i+2]; + errorRecordedForStack = queueItems[i+3]; // Debugging assistance + + if (isString(method)) { method = target[method]; } - if (length > 2) { - args = new Array(length - 2); - for (var i = 0, l = length - 2; i < l; i++) { - args[i] = arguments[i + 2]; - } - } else { - args = []; + // method could have been nullified / canceled during flush + if (method) { + // + // ** Attention intrepid developer ** + // + // To find out the stack of this task when it was scheduled onto + // the run loop, add the following to your app.js: + // + // Ember.run.backburner.DEBUG = true; // NOTE: This slows your app, don't leave it on in production. + // + // Once that is in place, when you are at a breakpoint and navigate + // here in the stack explorer, you can look at `errorRecordedForStack.stack`, + // which will be the captured stack when this job was scheduled. + // + // One possible long-term solution is the following Chrome issue: + // https://bugs.chromium.org/p/chromium/issues/detail?id=332624 + // + invoke(target, method, args, onError, errorRecordedForStack); } + } - var onError = getOnError(this.options); + if (after) { + after(); + } - this.begin(); + this._queueBeingFlushed = undefined; - // guard against Safari 6's double-finally bug - var didFinally = false; + if (sync !== false && + this._queue.length > 0) { + // check if new items have been added + this.flush(true); + } + }, - if (onError) { - try { - return method.apply(target, args); - } catch (error) { - onError(error); - } finally { - if (!didFinally) { - didFinally = true; - this.end(); + cancel: function(actionToCancel) { + var queue = this._queue, currentTarget, currentMethod, i, l; + var target = actionToCancel.target; + var method = actionToCancel.method; + var GUID_KEY = this.globalOptions.GUID_KEY; + + if (GUID_KEY && this.targetQueues && target) { + var targetQueue = this.targetQueues[target[GUID_KEY]]; + + if (targetQueue) { + for (i = 0, l = targetQueue.length; i < l; i++) { + if (targetQueue[i] === method) { + targetQueue.splice(i, 1); } } - } else { - try { - return method.apply(target, args); - } finally { - if (!didFinally) { - didFinally = true; - this.end(); - } - } } - }, + } - /* - Join the passed method with an existing queue and execute immediately, - if there isn't one use `Backburner#run`. - The join method is like the run method except that it will schedule into - an existing queue if one already exists. In either case, the join method will - immediately execute the passed in function and return its result. - @method join - @param {Object} target - @param {Function} method The method to be executed - @param {any} args The method arguments - @return method result - */ - join: function () /* target, method, args */{ - if (!this.currentInstance) { - return this.run.apply(this, arguments); + for (i = 0, l = queue.length; i < l; i += 4) { + currentTarget = queue[i]; + currentMethod = queue[i+1]; + + if (currentTarget === target && + currentMethod === method) { + queue.splice(i, 4); + return true; } + } - var length = arguments.length; - var method, target; + // if not found in current queue + // could be in the queue that is being flushed + queue = this._queueBeingFlushed; - if (length === 1) { - method = arguments[0]; - target = null; - } else { - target = arguments[0]; - method = arguments[1]; - } + if (!queue) { + return; + } - if (_backburnerUtils.isString(method)) { - method = target[method]; - } + for (i = 0, l = queue.length; i < l; i += 4) { + currentTarget = queue[i]; + currentMethod = queue[i+1]; - if (length === 1) { - return method(); - } else if (length === 2) { - return method.call(target); - } else { - var args = new Array(length - 2); - for (var i = 0, l = length - 2; i < l; i++) { - args[i] = arguments[i + 2]; - } - return method.apply(target, args); + if (currentTarget === target && + currentMethod === method) { + // don't mess with array during flush + // just nullify the method + queue[i+1] = null; + return true; } - }, + } + } +}; - /* - Defer the passed function to run inside the specified queue. - @method defer - @param {String} queueName - @param {Object} target - @param {Function|String} method The method or method name to be executed - @param {any} args The method arguments - @return method result - */ - defer: function (queueName /* , target, method, args */) { - var length = arguments.length; - var method, target, args; +function DeferredActionQueues(queueNames, options) { + var queues = this.queues = {}; + this.queueNames = queueNames = queueNames || []; - if (length === 2) { - method = arguments[1]; - target = null; - } else { - target = arguments[1]; - method = arguments[2]; - } + this.options = options; - if (_backburnerUtils.isString(method)) { - method = target[method]; - } + each(queueNames, function(queueName) { + queues[queueName] = new Queue(queueName, options[queueName], options); + }); +} - var stack = this.DEBUG ? new Error() : undefined; +function noSuchQueue(name) { + throw new Error('You attempted to schedule an action in a queue (' + name + ') that doesn\'t exist'); +} - if (length > 3) { - args = new Array(length - 3); - for (var i = 3; i < length; i++) { - args[i - 3] = arguments[i]; - } - } else { - args = undefined; - } +function noSuchMethod(name) { + throw new Error('You attempted to schedule an action in a queue (' + name + ') for a method that doesn\'t exist'); +} - if (!this.currentInstance) { - createAutorun(this); - } - return this.currentInstance.schedule(queueName, target, method, args, false, stack); - }, +DeferredActionQueues.prototype = { + schedule: function(name, target, method, args, onceFlag, stack) { + var queues = this.queues; + var queue = queues[name]; - deferOnce: function (queueName /* , target, method, args */) { - var length = arguments.length; - var method, target, args; + if (!queue) { + noSuchQueue(name); + } - if (length === 2) { - method = arguments[1]; - target = null; - } else { - target = arguments[1]; - method = arguments[2]; - } + if (!method) { + noSuchMethod(name); + } - if (_backburnerUtils.isString(method)) { - method = target[method]; - } + if (onceFlag) { + return queue.pushUnique(target, method, args, stack); + } else { + return queue.push(target, method, args, stack); + } + }, - var stack = this.DEBUG ? new Error() : undefined; + flush: function() { + var queues = this.queues; + var queueNames = this.queueNames; + var queueName, queue; + var queueNameIndex = 0; + var numberOfQueues = queueNames.length; - if (length > 3) { - args = new Array(length - 3); - for (var i = 3; i < length; i++) { - args[i - 3] = arguments[i]; - } + while (queueNameIndex < numberOfQueues) { + queueName = queueNames[queueNameIndex]; + queue = queues[queueName]; + + var numberOfQueueItems = queue._queue.length; + + if (numberOfQueueItems === 0) { + queueNameIndex++; } else { - args = undefined; + queue.flush(false /* async */); + queueNameIndex = 0; } + } + } +}; - if (!this.currentInstance) { - createAutorun(this); - } - return this.currentInstance.schedule(queueName, target, method, args, true, stack); +function Backburner(queueNames, options) { + this.queueNames = queueNames; + this.options = options || {}; + if (!this.options.defaultQueue) { + this.options.defaultQueue = queueNames[0]; + } + this.instanceStack = []; + this._debouncees = []; + this._throttlers = []; + this._eventCallbacks = { + end: [], + begin: [] + }; + + var _this = this; + this._boundClearItems = function() { + clearItems(); + }; + + this._timerTimeoutId = undefined; + this._timers = []; + + this._platform = this.options._platform || { + setTimeout: function (fn, ms) { + return setTimeout(fn, ms); }, + clearTimeout: function (id) { + clearTimeout(id); + } + }; - setTimeout: function () { - var l = arguments.length; - var args = new Array(l); + this._boundRunExpiredTimers = function () { + _this._runExpiredTimers(); + }; +} - for (var x = 0; x < l; x++) { - args[x] = arguments[x]; - } +Backburner.prototype = { + begin: function() { + var options = this.options; + var onBegin = options && options.onBegin; + var previousInstance = this.currentInstance; - var length = args.length, - method, - wait, - target, - methodOrTarget, - methodOrWait, - methodOrArgs; + if (previousInstance) { + this.instanceStack.push(previousInstance); + } - if (length === 0) { - return; - } else if (length === 1) { - method = args.shift(); - wait = 0; - } else if (length === 2) { - methodOrTarget = args[0]; - methodOrWait = args[1]; + this.currentInstance = new DeferredActionQueues(this.queueNames, options); + this._trigger('begin', this.currentInstance, previousInstance); + if (onBegin) { + onBegin(this.currentInstance, previousInstance); + } + }, - if (_backburnerUtils.isFunction(methodOrWait) || _backburnerUtils.isFunction(methodOrTarget[methodOrWait])) { - target = args.shift(); - method = args.shift(); - wait = 0; - } else if (_backburnerUtils.isCoercableNumber(methodOrWait)) { - method = args.shift(); - wait = args.shift(); - } else { - method = args.shift(); - wait = 0; - } - } else { - var last = args[args.length - 1]; + end: function() { + var options = this.options; + var onEnd = options && options.onEnd; + var currentInstance = this.currentInstance; + var nextInstance = null; - if (_backburnerUtils.isCoercableNumber(last)) { - wait = args.pop(); - } else { - wait = 0; - } + // Prevent double-finally bug in Safari 6.0.2 and iOS 6 + // This bug appears to be resolved in Safari 6.0.5 and iOS 7 + var finallyAlreadyCalled = false; + try { + currentInstance.flush(); + } finally { + if (!finallyAlreadyCalled) { + finallyAlreadyCalled = true; - methodOrTarget = args[0]; - methodOrArgs = args[1]; + this.currentInstance = null; - if (_backburnerUtils.isFunction(methodOrArgs) || _backburnerUtils.isString(methodOrArgs) && methodOrTarget !== null && methodOrArgs in methodOrTarget) { - target = args.shift(); - method = args.shift(); - } else { - method = args.shift(); + if (this.instanceStack.length) { + nextInstance = this.instanceStack.pop(); + this.currentInstance = nextInstance; } + this._trigger('end', currentInstance, nextInstance); + if (onEnd) { + onEnd(currentInstance, nextInstance); + } } + } + }, - var executeAt = Date.now() + parseInt(wait !== wait ? 0 : wait, 10); + /** + Trigger an event. Supports up to two arguments. Designed around + triggering transition events from one run loop instance to the + next, which requires an argument for the first instance and then + an argument for the next instance. - if (_backburnerUtils.isString(method)) { - method = target[method]; + @private + @method _trigger + @param {String} eventName + @param {any} arg1 + @param {any} arg2 + */ + _trigger: function(eventName, arg1, arg2) { + var callbacks = this._eventCallbacks[eventName]; + if (callbacks) { + for (var i = 0; i < callbacks.length; i++) { + callbacks[i](arg1, arg2); } + } + }, - var onError = getOnError(this.options); + on: function(eventName, callback) { + if (typeof callback !== 'function') { + throw new TypeError('Callback must be a function'); + } + var callbacks = this._eventCallbacks[eventName]; + if (callbacks) { + callbacks.push(callback); + } else { + throw new TypeError('Cannot on() event "' + eventName + '" because it does not exist'); + } + }, - function fn() { - if (onError) { - try { - method.apply(target, args); - } catch (e) { - onError(e); + off: function(eventName, callback) { + if (eventName) { + var callbacks = this._eventCallbacks[eventName]; + var callbackFound = false; + if (!callbacks) return; + if (callback) { + for (var i = 0; i < callbacks.length; i++) { + if (callbacks[i] === callback) { + callbackFound = true; + callbacks.splice(i, 1); + i--; } - } else { - method.apply(target, args); } } + if (!callbackFound) { + throw new TypeError('Cannot off() callback that does not exist'); + } + } else { + throw new TypeError('Cannot off() event "' + eventName + '" because it does not exist'); + } + }, - return this._setTimeout(fn, executeAt); - }, + run: function(/* target, method, args */) { + var length = arguments.length; + var method, target, args; - _setTimeout: function (fn, executeAt) { - if (this._timers.length === 0) { - this._timers.push(executeAt, fn); - this._installTimerTimeout(); - return fn; + if (length === 1) { + method = arguments[0]; + target = null; + } else { + target = arguments[0]; + method = arguments[1]; + } + + if (isString(method)) { + method = target[method]; + } + + if (length > 2) { + args = new Array(length - 2); + for (var i = 0, l = length - 2; i < l; i++) { + args[i] = arguments[i + 2]; } + } else { + args = []; + } - // find position to insert - var i = _backburnerBinarySearch.default(executeAt, this._timers); + var onError = getOnError(this.options); - this._timers.splice(i, 0, executeAt, fn); + this.begin(); - // we should be the new earliest timer if i == 0 - if (i === 0) { - this._reinstallTimerTimeout(); + // guard against Safari 6's double-finally bug + var didFinally = false; + + if (onError) { + try { + return method.apply(target, args); + } catch(error) { + onError(error); + } finally { + if (!didFinally) { + didFinally = true; + this.end(); + } } + } else { + try { + return method.apply(target, args); + } finally { + if (!didFinally) { + didFinally = true; + this.end(); + } + } + } + }, - return fn; - }, + /* + Join the passed method with an existing queue and execute immediately, + if there isn't one use `Backburner#run`. - throttle: function (target, method /* , args, wait, [immediate] */) { - var backburner = this; - var args = new Array(arguments.length); - for (var i = 0; i < arguments.length; i++) { - args[i] = arguments[i]; - } - var immediate = args.pop(); - var wait, throttler, index, timer; + The join method is like the run method except that it will schedule into + an existing queue if one already exists. In either case, the join method will + immediately execute the passed in function and return its result. - if (_backburnerUtils.isNumber(immediate) || _backburnerUtils.isString(immediate)) { - wait = immediate; - immediate = true; - } else { - wait = args.pop(); + @method join + @param {Object} target + @param {Function} method The method to be executed + @param {any} args The method arguments + @return method result + */ + join: function(/* target, method, args */) { + if (!this.currentInstance) { + return this.run.apply(this, arguments); + } + + var length = arguments.length; + var method, target; + + if (length === 1) { + method = arguments[0]; + target = null; + } else { + target = arguments[0]; + method = arguments[1]; + } + + if (isString(method)) { + method = target[method]; + } + + if (length === 1) { + return method(); + } else if (length === 2) { + return method.call(target); + } else { + var args = new Array(length - 2); + for (var i = 0, l = length - 2; i < l; i++) { + args[i] = arguments[i + 2]; } + return method.apply(target, args); + } + }, - wait = parseInt(wait, 10); - index = findThrottler(target, method, this._throttlers); - if (index > -1) { - return this._throttlers[index]; - } // throttled + /* + Defer the passed function to run inside the specified queue. - timer = this._platform.setTimeout(function () { - if (!immediate) { - backburner.run.apply(backburner, args); - } - var index = findThrottler(target, method, backburner._throttlers); - if (index > -1) { - backburner._throttlers.splice(index, 1); - } - }, wait); + @method defer + @param {String} queueName + @param {Object} target + @param {Function|String} method The method or method name to be executed + @param {any} args The method arguments + @return method result + */ + defer: function(queueName /* , target, method, args */) { + var length = arguments.length; + var method, target, args; - if (immediate) { - this.run.apply(this, args); + if (length === 2) { + method = arguments[1]; + target = null; + } else { + target = arguments[1]; + method = arguments[2]; + } + + if (isString(method)) { + method = target[method]; + } + + var stack = this.DEBUG ? new Error() : undefined; + + if (length > 3) { + args = new Array(length - 3); + for (var i = 3; i < length; i++) { + args[i-3] = arguments[i]; } + } else { + args = undefined; + } - throttler = [target, method, timer]; + if (!this.currentInstance) { createAutorun(this); } + return this.currentInstance.schedule(queueName, target, method, args, false, stack); + }, - this._throttlers.push(throttler); + deferOnce: function(queueName /* , target, method, args */) { + var length = arguments.length; + var method, target, args; - return throttler; - }, + if (length === 2) { + method = arguments[1]; + target = null; + } else { + target = arguments[1]; + method = arguments[2]; + } - debounce: function (target, method /* , args, wait, [immediate] */) { - var backburner = this; - var args = new Array(arguments.length); - for (var i = 0; i < arguments.length; i++) { - args[i] = arguments[i]; + if (isString(method)) { + method = target[method]; + } + + var stack = this.DEBUG ? new Error() : undefined; + + if (length > 3) { + args = new Array(length - 3); + for (var i = 3; i < length; i++) { + args[i-3] = arguments[i]; } + } else { + args = undefined; + } - var immediate = args.pop(); - var wait, index, debouncee, timer; + if (!this.currentInstance) { + createAutorun(this); + } + return this.currentInstance.schedule(queueName, target, method, args, true, stack); + }, - if (_backburnerUtils.isNumber(immediate) || _backburnerUtils.isString(immediate)) { - wait = immediate; - immediate = false; + setTimeout: function() { + var l = arguments.length; + var args = new Array(l); + + for (var x = 0; x < l; x++) { + args[x] = arguments[x]; + } + + var length = args.length, + method, wait, target, + methodOrTarget, methodOrWait, methodOrArgs; + + if (length === 0) { + return; + } else if (length === 1) { + method = args.shift(); + wait = 0; + } else if (length === 2) { + methodOrTarget = args[0]; + methodOrWait = args[1]; + + if (isFunction(methodOrWait) || isFunction(methodOrTarget[methodOrWait])) { + target = args.shift(); + method = args.shift(); + wait = 0; + } else if (isCoercableNumber(methodOrWait)) { + method = args.shift(); + wait = args.shift(); } else { + method = args.shift(); + wait = 0; + } + } else { + var last = args[args.length - 1]; + + if (isCoercableNumber(last)) { wait = args.pop(); + } else { + wait = 0; } - wait = parseInt(wait, 10); - // Remove debouncee - index = findDebouncee(target, method, this._debouncees); + methodOrTarget = args[0]; + methodOrArgs = args[1]; - if (index > -1) { - debouncee = this._debouncees[index]; - this._debouncees.splice(index, 1); - this._platform.clearTimeout(debouncee[2]); + if (isFunction(methodOrArgs) || (isString(methodOrArgs) && + methodOrTarget !== null && + methodOrArgs in methodOrTarget)) { + target = args.shift(); + method = args.shift(); + } else { + method = args.shift(); } + } - timer = this._platform.setTimeout(function () { - if (!immediate) { - backburner.run.apply(backburner, args); + var executeAt = Date.now() + parseInt(wait !== wait ? 0 : wait, 10); + + if (isString(method)) { + method = target[method]; + } + + var onError = getOnError(this.options); + + function fn() { + if (onError) { + try { + method.apply(target, args); + } catch (e) { + onError(e); } - var index = findDebouncee(target, method, backburner._debouncees); - if (index > -1) { - backburner._debouncees.splice(index, 1); - } - }, wait); + } else { + method.apply(target, args); + } + } - if (immediate && index === -1) { + return this._setTimeout(fn, executeAt); + }, + + _setTimeout: function (fn, executeAt) { + if (this._timers.length === 0) { + this._timers.push(executeAt, fn); + this._installTimerTimeout(); + return fn; + } + + // find position to insert + var i = binarySearch(executeAt, this._timers); + + this._timers.splice(i, 0, executeAt, fn); + + // we should be the new earliest timer if i == 0 + if (i === 0) { + this._reinstallTimerTimeout(); + } + + return fn; + }, + + throttle: function(target, method /* , args, wait, [immediate] */) { + var backburner = this; + var args = new Array(arguments.length); + for (var i = 0; i < arguments.length; i++) { + args[i] = arguments[i]; + } + var immediate = args.pop(); + var wait, throttler, index, timer; + + if (isNumber(immediate) || isString(immediate)) { + wait = immediate; + immediate = true; + } else { + wait = args.pop(); + } + + wait = parseInt(wait, 10); + + index = findThrottler(target, method, this._throttlers); + if (index > -1) { return this._throttlers[index]; } // throttled + + timer = this._platform.setTimeout(function() { + if (!immediate) { backburner.run.apply(backburner, args); } + var index = findThrottler(target, method, backburner._throttlers); + if (index > -1) { + backburner._throttlers.splice(index, 1); + } + }, wait); - debouncee = [target, method, timer]; + if (immediate) { + this.run.apply(this, args); + } - backburner._debouncees.push(debouncee); + throttler = [target, method, timer]; - return debouncee; - }, + this._throttlers.push(throttler); - cancelTimers: function () { - _backburnerUtils.each(this._throttlers, this._boundClearItems); - this._throttlers = []; + return throttler; + }, - _backburnerUtils.each(this._debouncees, this._boundClearItems); - this._debouncees = []; + debounce: function(target, method /* , args, wait, [immediate] */) { + var backburner = this; + var args = new Array(arguments.length); + for (var i = 0; i < arguments.length; i++) { + args[i] = arguments[i]; + } - this._clearTimerTimeout(); - this._timers = []; + var immediate = args.pop(); + var wait, index, debouncee, timer; - if (this._autorun) { - this._platform.clearTimeout(this._autorun); - this._autorun = null; + if (isNumber(immediate) || isString(immediate)) { + wait = immediate; + immediate = false; + } else { + wait = args.pop(); + } + + wait = parseInt(wait, 10); + // Remove debouncee + index = findDebouncee(target, method, this._debouncees); + + if (index > -1) { + debouncee = this._debouncees[index]; + this._debouncees.splice(index, 1); + this._platform.clearTimeout(debouncee[2]); + } + + timer = this._platform.setTimeout(function() { + if (!immediate) { + backburner.run.apply(backburner, args); } - }, + var index = findDebouncee(target, method, backburner._debouncees); + if (index > -1) { + backburner._debouncees.splice(index, 1); + } + }, wait); - hasTimers: function () { - return !!this._timers.length || !!this._debouncees.length || !!this._throttlers.length || this._autorun; - }, + if (immediate && index === -1) { + backburner.run.apply(backburner, args); + } - cancel: function (timer) { - var timerType = typeof timer; + debouncee = [ + target, + method, + timer + ]; - if (timer && timerType === 'object' && timer.queue && timer.method) { - // we're cancelling a deferOnce - return timer.queue.cancel(timer); - } else if (timerType === 'function') { - // we're cancelling a setTimeout - for (var i = 0, l = this._timers.length; i < l; i += 2) { - if (this._timers[i + 1] === timer) { - this._timers.splice(i, 2); // remove the two elements - if (i === 0) { - this._reinstallTimerTimeout(); - } - return true; + backburner._debouncees.push(debouncee); + + return debouncee; + }, + + cancelTimers: function() { + each(this._throttlers, this._boundClearItems); + this._throttlers = []; + + each(this._debouncees, this._boundClearItems); + this._debouncees = []; + + this._clearTimerTimeout(); + this._timers = []; + + if (this._autorun) { + this._platform.clearTimeout(this._autorun); + this._autorun = null; + } + }, + + hasTimers: function() { + return !!this._timers.length || !!this._debouncees.length || !!this._throttlers.length || this._autorun; + }, + + cancel: function (timer) { + var timerType = typeof timer; + + if (timer && timerType === 'object' && timer.queue && timer.method) { // we're cancelling a deferOnce + return timer.queue.cancel(timer); + } else if (timerType === 'function') { // we're cancelling a setTimeout + for (var i = 0, l = this._timers.length; i < l; i += 2) { + if (this._timers[i + 1] === timer) { + this._timers.splice(i, 2); // remove the two elements + if (i === 0) { + this._reinstallTimerTimeout(); } + return true; } - } else if (Object.prototype.toString.call(timer) === '[object Array]') { - // we're cancelling a throttle or debounce - return this._cancelItem(findThrottler, this._throttlers, timer) || this._cancelItem(findDebouncee, this._debouncees, timer); - } else { - return; // timer was null or not a timer } - }, + } else if (Object.prototype.toString.call(timer) === '[object Array]'){ // we're cancelling a throttle or debounce + return this._cancelItem(findThrottler, this._throttlers, timer) || + this._cancelItem(findDebouncee, this._debouncees, timer); + } else { + return; // timer was null or not a timer + } + }, - _cancelItem: function (findMethod, array, timer) { - var item, index; + _cancelItem: function(findMethod, array, timer){ + var item, index; - if (timer.length < 3) { - return false; - } + if (timer.length < 3) { return false; } - index = findMethod(timer[0], timer[1], array); + index = findMethod(timer[0], timer[1], array); - if (index > -1) { + if (index > -1) { - item = array[index]; + item = array[index]; - if (item[2] === timer[2]) { - array.splice(index, 1); - this._platform.clearTimeout(timer[2]); - return true; - } + if (item[2] === timer[2]) { + array.splice(index, 1); + this._platform.clearTimeout(timer[2]); + return true; } + } - return false; + return false; + }, + + _runExpiredTimers: function () { + this._timerTimeoutId = undefined; + this.run(this, this._scheduleExpiredTimers); + }, + + _scheduleExpiredTimers: function () { + var n = Date.now(); + var timers = this._timers; + var i = 0; + var l = timers.length; + for (; i < l; i += 2) { + var executeAt = timers[i]; + var fn = timers[i+1]; + if (executeAt <= n) { + this.schedule(this.options.defaultQueue, null, fn); + } else { + break; + } + } + timers.splice(0, i); + this._installTimerTimeout(); + }, + + _reinstallTimerTimeout: function () { + this._clearTimerTimeout(); + this._installTimerTimeout(); + }, + + _clearTimerTimeout: function () { + if (!this._timerTimeoutId) { + return; + } + this._platform.clearTimeout(this._timerTimeoutId); + this._timerTimeoutId = undefined; + }, + + _installTimerTimeout: function () { + if (!this._timers.length) { + return; + } + var minExpiresAt = this._timers[0]; + var n = Date.now(); + var wait = Math.max(0, minExpiresAt - n); + this._timerTimeoutId = this._platform.setTimeout(this._boundRunExpiredTimers, wait); + } +}; + +Backburner.prototype.schedule = Backburner.prototype.defer; +Backburner.prototype.scheduleOnce = Backburner.prototype.deferOnce; +Backburner.prototype.later = Backburner.prototype.setTimeout; + +function getOnError(options) { + return options.onError || (options.onErrorTarget && options.onErrorTarget[options.onErrorMethod]); +} + +function createAutorun(backburner) { + var setTimeout = backburner._platform.setTimeout; + backburner.begin(); + backburner._autorun = setTimeout(function() { + backburner._autorun = null; + backburner.end(); + }, 0); +} + +function findDebouncee(target, method, debouncees) { + return findItem(target, method, debouncees); +} + +function findThrottler(target, method, throttlers) { + return findItem(target, method, throttlers); +} + +function findItem(target, method, collection) { + var item; + var index = -1; + + for (var i = 0, l = collection.length; i < l; i++) { + item = collection[i]; + if (item[0] === target && item[1] === method) { + index = i; + break; + } + } + + return index; +} + +function clearItems(item) { + this._platform.clearTimeout(item[2]); +} + +exports['default'] = Backburner; + +Object.defineProperty(exports, '__esModule', { value: true }); + +}); +enifed('container/container', ['exports', 'ember-environment', 'ember-metal', 'container/owner'], function (exports, _emberEnvironment, _emberMetal, _containerOwner) { + 'use strict'; + + exports.default = Container; + exports.buildFakeContainerWithDeprecations = buildFakeContainerWithDeprecations; + + var CONTAINER_OVERRIDE = _emberMetal.symbol('CONTAINER_OVERRIDE'); + + /** + A container used to instantiate and cache objects. + + Every `Container` must be associated with a `Registry`, which is referenced + to determine the factory and options that should be used to instantiate + objects. + + The public API for `Container` is still in flux and should not be considered + stable. + + @private + @class Container + */ + + function Container(registry, options) { + this.registry = registry; + this.owner = options && options.owner ? options.owner : null; + this.cache = _emberMetal.dictionary(options && options.cache ? options.cache : null); + this.factoryCache = _emberMetal.dictionary(options && options.factoryCache ? options.factoryCache : null); + this.validationCache = _emberMetal.dictionary(options && options.validationCache ? options.validationCache : null); + this._fakeContainerToInject = buildFakeContainerWithDeprecations(this); + this[CONTAINER_OVERRIDE] = undefined; + this.isDestroyed = false; + } + + Container.prototype = { + /** + @private + @property owner + @type Object + */ + owner: null, + + /** + @private + @property registry + @type Registry + @since 1.11.0 + */ + registry: null, + + /** + @private + @property cache + @type InheritingDict + */ + cache: null, + + /** + @private + @property factoryCache + @type InheritingDict + */ + factoryCache: null, + + /** + @private + @property validationCache + @type InheritingDict + */ + validationCache: null, + + /** + Given a fullName return a corresponding instance. + The default behaviour is for lookup to return a singleton instance. + The singleton is scoped to the container, allowing multiple containers + to all have their own locally scoped singletons. + ```javascript + let registry = new Registry(); + let container = registry.container(); + registry.register('api:twitter', Twitter); + let twitter = container.lookup('api:twitter'); + twitter instanceof Twitter; // => true + // by default the container will return singletons + let twitter2 = container.lookup('api:twitter'); + twitter2 instanceof Twitter; // => true + twitter === twitter2; //=> true + ``` + If singletons are not wanted, an optional flag can be provided at lookup. + ```javascript + let registry = new Registry(); + let container = registry.container(); + registry.register('api:twitter', Twitter); + let twitter = container.lookup('api:twitter', { singleton: false }); + let twitter2 = container.lookup('api:twitter', { singleton: false }); + twitter === twitter2; //=> false + ``` + @private + @method lookup + @param {String} fullName + @param {Object} [options] + @param {String} [options.source] The fullname of the request source (used for local lookup) + @return {any} + */ + lookup: function (fullName, options) { + _emberMetal.assert('fullName must be a proper full name', this.registry.validateFullName(fullName)); + return lookup(this, this.registry.normalize(fullName), options); }, - _runExpiredTimers: function () { - this._timerTimeoutId = undefined; - this.run(this, this._scheduleExpiredTimers); + /** + Given a fullName, return the corresponding factory. + @private + @method lookupFactory + @param {String} fullName + @param {Object} [options] + @param {String} [options.source] The fullname of the request source (used for local lookup) + @return {any} + */ + lookupFactory: function (fullName, options) { + _emberMetal.assert('fullName must be a proper full name', this.registry.validateFullName(fullName)); + return factoryFor(this, this.registry.normalize(fullName), options); }, - _scheduleExpiredTimers: function () { - var n = Date.now(); - var timers = this._timers; - var i = 0; - var l = timers.length; - for (; i < l; i += 2) { - var executeAt = timers[i]; - var fn = timers[i + 1]; - if (executeAt <= n) { - this.schedule(this.options.defaultQueue, null, fn); - } else { - break; + /** + A depth first traversal, destroying the container, its descendant containers and all + their managed objects. + @private + @method destroy + */ + destroy: function () { + eachDestroyable(this, function (item) { + if (item.destroy) { + item.destroy(); } - } - timers.splice(0, i); - this._installTimerTimeout(); - }, + }); - _reinstallTimerTimeout: function () { - this._clearTimerTimeout(); - this._installTimerTimeout(); + this.isDestroyed = true; }, - _clearTimerTimeout: function () { - if (!this._timerTimeoutId) { - return; + /** + Clear either the entire cache or just the cache for a particular key. + @private + @method reset + @param {String} fullName optional key to reset; if missing, resets everything + */ + reset: function (fullName) { + if (arguments.length > 0) { + resetMember(this, this.registry.normalize(fullName)); + } else { + resetCache(this); } - this._platform.clearTimeout(this._timerTimeoutId); - this._timerTimeoutId = undefined; }, - _installTimerTimeout: function () { - if (!this._timers.length) { + /** + Returns an object that can be used to provide an owner to a + manually created instance. + @private + @method ownerInjection + @returns { Object } + */ + ownerInjection: function () { + var _ref; + + return _ref = {}, _ref[_containerOwner.OWNER] = this.owner, _ref; + } + }; + + function isSingleton(container, fullName) { + return container.registry.getOption(fullName, 'singleton') !== false; + } + + function lookup(container, fullName) { + var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + if (options.source) { + fullName = container.registry.expandLocalLookup(fullName, options); + + // if expandLocalLookup returns falsey, we do not support local lookup + if (!fullName) { return; } - var minExpiresAt = this._timers[0]; - var n = Date.now(); - var wait = Math.max(0, minExpiresAt - n); - this._timerTimeoutId = this._platform.setTimeout(this._boundRunExpiredTimers, wait); } - }; - Backburner.prototype.schedule = Backburner.prototype.defer; - Backburner.prototype.scheduleOnce = Backburner.prototype.deferOnce; - Backburner.prototype.later = Backburner.prototype.setTimeout; + if (container.cache[fullName] !== undefined && options.singleton !== false) { + return container.cache[fullName]; + } - function getOnError(options) { - return options.onError || options.onErrorTarget && options.onErrorTarget[options.onErrorMethod]; - } + var value = instantiate(container, fullName); - function createAutorun(backburner) { - backburner.begin(); - backburner._autorun = backburner._platform.setTimeout(function () { - backburner._autorun = null; - backburner.end(); - }); + if (value === undefined) { + return; + } + + if (isSingleton(container, fullName) && options.singleton !== false) { + container.cache[fullName] = value; + } + + return value; } - function findDebouncee(target, method, debouncees) { - return findItem(target, method, debouncees); + function markInjectionsAsDynamic(injections) { + injections._dynamic = true; } - function findThrottler(target, method, throttlers) { - return findItem(target, method, throttlers); + function areInjectionsDynamic(injections) { + return !!injections._dynamic; } - function findItem(target, method, collection) { - var item; - var index = -1; + function buildInjections() /* container, ...injections */{ + var hash = {}; - for (var i = 0, l = collection.length; i < l; i++) { - item = collection[i]; - if (item[0] === target && item[1] === method) { - index = i; - break; + if (arguments.length > 1) { + var container = arguments[0]; + var injections = []; + var injection = undefined; + + for (var i = 1; i < arguments.length; i++) { + if (arguments[i]) { + injections = injections.concat(arguments[i]); + } } + + container.registry.validateInjections(injections); + + for (var i = 0; i < injections.length; i++) { + injection = injections[i]; + hash[injection.property] = lookup(container, injection.fullName); + if (!isSingleton(container, injection.fullName)) { + markInjectionsAsDynamic(hash); + } + } } - return index; + return hash; } - function clearItems(item) { - this._platform.clearTimeout(item[2]); - } -}); -enifed("backburner/binary-search", ["exports"], function (exports) { - "use strict"; + function factoryFor(container, fullName) { + var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; - exports.default = binarySearch; + var registry = container.registry; - function binarySearch(time, timers) { - var start = 0; - var end = timers.length - 2; - var middle, l; + if (options.source) { + fullName = registry.expandLocalLookup(fullName, options); - while (start < end) { - // since timers is an array of pairs 'l' will always - // be an integer - l = (end - start) / 2; + // if expandLocalLookup returns falsey, we do not support local lookup + if (!fullName) { + return; + } + } - // compensate for the index in case even number - // of pairs inside timers - middle = start + l - l % 2; + var cache = container.factoryCache; + if (cache[fullName]) { + return cache[fullName]; + } + var factory = registry.resolve(fullName); + if (factory === undefined) { + return; + } - if (time >= timers[middle]) { - start = middle + 2; - } else { - end = middle; + var type = fullName.split(':')[0]; + if (!factory || typeof factory.extend !== 'function' || !_emberEnvironment.ENV.MODEL_FACTORY_INJECTIONS && type === 'model') { + if (factory && typeof factory._onLookup === 'function') { + factory._onLookup(fullName); } - } - return time >= timers[start] ? start + 2 : start; + // TODO: think about a 'safe' merge style extension + // for now just fallback to create time injection + cache[fullName] = factory; + return factory; + } else { + var injections = injectionsFor(container, fullName); + var factoryInjections = factoryInjectionsFor(container, fullName); + var cacheable = !areInjectionsDynamic(injections) && !areInjectionsDynamic(factoryInjections); + + factoryInjections._toString = registry.makeToString(factory, fullName); + + var injectedFactory = factory.extend(injections); + + // TODO - remove all `container` injections when Ember reaches v3.0.0 + injectDeprecatedContainer(injectedFactory.prototype, container); + injectedFactory.reopenClass(factoryInjections); + + if (factory && typeof factory._onLookup === 'function') { + factory._onLookup(fullName); + } + + if (cacheable) { + cache[fullName] = injectedFactory; + } + + return injectedFactory; + } } -}); -enifed('backburner/deferred-action-queues', ['exports', 'backburner/utils', 'backburner/queue'], function (exports, _backburnerUtils, _backburnerQueue) { - 'use strict'; - exports.default = DeferredActionQueues; + function injectionsFor(container, fullName) { + var registry = container.registry; + var splitName = fullName.split(':'); + var type = splitName[0]; - function DeferredActionQueues(queueNames, options) { - var queues = this.queues = {}; - this.queueNames = queueNames = queueNames || []; + var injections = buildInjections(container, registry.getTypeInjections(type), registry.getInjections(fullName)); + injections._debugContainerKey = fullName; - this.options = options; + _containerOwner.setOwner(injections, container.owner); - _backburnerUtils.each(queueNames, function (queueName) { - queues[queueName] = new _backburnerQueue.default(queueName, options[queueName], options); - }); + return injections; } - function noSuchQueue(name) { - throw new Error('You attempted to schedule an action in a queue (' + name + ') that doesn\'t exist'); + function factoryInjectionsFor(container, fullName) { + var registry = container.registry; + var splitName = fullName.split(':'); + var type = splitName[0]; + + var factoryInjections = buildInjections(container, registry.getFactoryTypeInjections(type), registry.getFactoryInjections(fullName)); + factoryInjections._debugContainerKey = fullName; + + return factoryInjections; } - function noSuchMethod(name) { - throw new Error('You attempted to schedule an action in a queue (' + name + ') for a method that doesn\'t exist'); + function instantiate(container, fullName) { + var factory = factoryFor(container, fullName); + var lazyInjections = undefined, + validationCache = undefined; + + if (container.registry.getOption(fullName, 'instantiate') === false) { + return factory; + } + + if (factory) { + if (typeof factory.create !== 'function') { + throw new Error('Failed to create an instance of \'' + fullName + '\'. Most likely an improperly defined class or' + ' an invalid module export.'); + } + + validationCache = container.validationCache; + + _emberMetal.runInDebug(function () { + // Ensure that all lazy injections are valid at instantiation time + if (!validationCache[fullName] && typeof factory._lazyInjections === 'function') { + lazyInjections = factory._lazyInjections(); + lazyInjections = container.registry.normalizeInjectionsHash(lazyInjections); + + container.registry.validateInjections(lazyInjections); + } + }); + + validationCache[fullName] = true; + + var obj = undefined; + + if (typeof factory.extend === 'function') { + // assume the factory was extendable and is already injected + obj = factory.create(); + } else { + // assume the factory was extendable + // to create time injections + // TODO: support new'ing for instantiation and merge injections for pure JS Functions + var injections = injectionsFor(container, fullName); + + // Ensure that a container is available to an object during instantiation. + // TODO - remove when Ember reaches v3.0.0 + // This "fake" container will be replaced after instantiation with a + // property that raises deprecations every time it is accessed. + injections.container = container._fakeContainerToInject; + obj = factory.create(injections); + + // TODO - remove when Ember reaches v3.0.0 + if (!Object.isFrozen(obj) && 'container' in obj) { + injectDeprecatedContainer(obj, container); + } + } + + return obj; + } } - DeferredActionQueues.prototype = { - schedule: function (name, target, method, args, onceFlag, stack) { - var queues = this.queues; - var queue = queues[name]; + // TODO - remove when Ember reaches v3.0.0 + function injectDeprecatedContainer(object, container) { + Object.defineProperty(object, 'container', { + configurable: true, + enumerable: false, + get: function () { + _emberMetal.deprecate('Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.', false, { id: 'ember-application.injected-container', until: '3.0.0', url: 'http://emberjs.com/deprecations/v2.x#toc_injected-container-access' }); + return this[CONTAINER_OVERRIDE] || container; + }, - if (!queue) { - noSuchQueue(name); + set: function (value) { + _emberMetal.deprecate('Providing the `container` property to ' + this + ' is deprecated. Please use `Ember.setOwner` or `owner.ownerInjection()` instead to provide an owner to the instance being created.', false, { id: 'ember-application.injected-container', until: '3.0.0', url: 'http://emberjs.com/deprecations/v2.x#toc_injected-container-access' }); + + this[CONTAINER_OVERRIDE] = value; + + return value; } + }); + } - if (!method) { - noSuchMethod(name); + function eachDestroyable(container, callback) { + var cache = container.cache; + var keys = Object.keys(cache); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = cache[key]; + + if (container.registry.getOption(key, 'instantiate') !== false) { + callback(value); } + } + } - if (onceFlag) { - return queue.pushUnique(target, method, args, stack); - } else { - return queue.push(target, method, args, stack); + function resetCache(container) { + eachDestroyable(container, function (value) { + if (value.destroy) { + value.destroy(); } - }, + }); - flush: function () { - var queues = this.queues; - var queueNames = this.queueNames; - var queueName, queue; - var queueNameIndex = 0; - var numberOfQueues = queueNames.length; + container.cache.dict = _emberMetal.dictionary(null); + } - while (queueNameIndex < numberOfQueues) { - queueName = queueNames[queueNameIndex]; - queue = queues[queueName]; + function resetMember(container, fullName) { + var member = container.cache[fullName]; - var numberOfQueueItems = queue._queue.length; + delete container.factoryCache[fullName]; - if (numberOfQueueItems === 0) { - queueNameIndex++; - } else { - queue.flush(false /* async */); - queueNameIndex = 0; - } + if (member) { + delete container.cache[fullName]; + + if (member.destroy) { + member.destroy(); } } - }; + } + + function buildFakeContainerWithDeprecations(container) { + var fakeContainer = {}; + var propertyMappings = { + lookup: 'lookup', + lookupFactory: '_lookupFactory' + }; + + for (var containerProperty in propertyMappings) { + fakeContainer[containerProperty] = buildFakeContainerFunction(container, containerProperty, propertyMappings[containerProperty]); + } + + return fakeContainer; + } + + function buildFakeContainerFunction(container, containerProperty, ownerProperty) { + return function () { + _emberMetal.deprecate('Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `' + ownerProperty + '` instead.', false, { + id: 'ember-application.injected-container', + until: '3.0.0', + url: 'http://emberjs.com/deprecations/v2.x#toc_injected-container-access' + }); + return container[containerProperty].apply(container, arguments); + }; + } }); -enifed('backburner/platform', ['exports'], function (exports) { +enifed('container/index', ['exports', 'container/registry', 'container/container', 'container/owner'], function (exports, _containerRegistry, _containerContainer, _containerOwner) { + /* + Public API for the container is still in flux. + The public API, specified on the application namespace should be considered the stable API. + // @module container + @private + */ + 'use strict'; - var GlobalContext; + exports.Registry = _containerRegistry.default; + exports.privatize = _containerRegistry.privatize; + exports.Container = _containerContainer.default; + exports.buildFakeContainerWithDeprecations = _containerContainer.buildFakeContainerWithDeprecations; + exports.OWNER = _containerOwner.OWNER; + exports.getOwner = _containerOwner.getOwner; + exports.setOwner = _containerOwner.setOwner; +}); +enifed('container/owner', ['exports', 'ember-metal'], function (exports, _emberMetal) { + /** + @module ember + @submodule ember-runtime + */ - /* global self */ - if (typeof self === 'object') { - GlobalContext = self; + 'use strict'; - /* global global */ - } else if (typeof global === 'object') { - GlobalContext = global; + exports.getOwner = getOwner; + exports.setOwner = setOwner; + var OWNER = _emberMetal.symbol('OWNER'); - /* global window */ - } else if (typeof window === 'object') { - GlobalContext = window; - } else { - throw new Error('no global: `self`, `global` nor `window` was found'); + exports.OWNER = OWNER; + /** + Framework objects in an Ember application (components, services, routes, etc.) + are created via a factory and dependency injection system. Each of these + objects is the responsibility of an "owner", which handled its + instantiation and manages its lifetime. + + `getOwner` fetches the owner object responsible for an instance. This can + be used to lookup or resolve other class instances, or register new factories + into the owner. + + For example, this component dynamically looks up a service based on the + `audioType` passed as an attribute: + + ``` + // app/components/play-audio.js + import Ember from 'ember'; + + // Usage: + // + // {{play-audio audioType=model.audioType audioFile=model.file}} + // + export default Ember.Component.extend({ + audioService: Ember.computed('audioType', function() { + let owner = Ember.getOwner(this); + return owner.lookup(`service:${this.get('audioType')}`); + }), + click() { + let player = this.get('audioService'); + player.play(this.get('audioFile')); } + }); + ``` + + @method getOwner + @for Ember + @param {Object} object An object with an owner. + @return {Object} An owner object. + @since 2.3.0 + @public + */ - exports.default = GlobalContext; + function getOwner(object) { + return object[OWNER]; + } + + /** + `setOwner` forces a new owner on a given object instance. This is primarily + useful in some testing cases. + + @method setOwner + @for Ember + @param {Object} object An object with an owner. + @return {Object} An owner object. + @since 2.3.0 + @public + */ + + function setOwner(object, owner) { + object[OWNER] = owner; + } }); -enifed('backburner/queue', ['exports', 'backburner/utils'], function (exports, _backburnerUtils) { +enifed('container/registry', ['exports', 'ember-metal', 'container/container'], function (exports, _emberMetal, _containerContainer) { 'use strict'; - exports.default = Queue; + exports.default = Registry; + exports.privatize = privatize; - function Queue(name, options, globalOptions) { - this.name = name; - this.globalOptions = globalOptions || {}; - this.options = options; - this._queue = []; - this.targetQueues = {}; - this._queueBeingFlushed = undefined; + var VALID_FULL_NAME_REGEXP = /^[^:]+:[^:]+$/; + + /** + A registry used to store factory and option information keyed + by type. + + A `Registry` stores the factory and option information needed by a + `Container` to instantiate and cache objects. + + The API for `Registry` is still in flux and should not be considered stable. + + @private + @class Registry + @since 1.11.0 + */ + + function Registry(options) { + this.fallback = options && options.fallback ? options.fallback : null; + + if (options && options.resolver) { + this.resolver = options.resolver; + + if (typeof this.resolver === 'function') { + deprecateResolverFunction(this); + } + } + + this.registrations = _emberMetal.dictionary(options && options.registrations ? options.registrations : null); + + this._typeInjections = _emberMetal.dictionary(null); + this._injections = _emberMetal.dictionary(null); + this._factoryTypeInjections = _emberMetal.dictionary(null); + this._factoryInjections = _emberMetal.dictionary(null); + + this._localLookupCache = new _emberMetal.EmptyObject(); + this._normalizeCache = _emberMetal.dictionary(null); + this._resolveCache = _emberMetal.dictionary(null); + this._failCache = _emberMetal.dictionary(null); + + this._options = _emberMetal.dictionary(null); + this._typeOptions = _emberMetal.dictionary(null); } - Queue.prototype = { - push: function (target, method, args, stack) { - var queue = this._queue; - queue.push(target, method, args, stack); + Registry.prototype = { + /** + A backup registry for resolving registrations when no matches can be found. + @private + @property fallback + @type Registry + */ + fallback: null, - return { - queue: this, - target: target, - method: method - }; + /** + An object that has a `resolve` method that resolves a name. + @private + @property resolver + @type Resolver + */ + resolver: null, + + /** + @private + @property registrations + @type InheritingDict + */ + registrations: null, + + /** + @private + @property _typeInjections + @type InheritingDict + */ + _typeInjections: null, + + /** + @private + @property _injections + @type InheritingDict + */ + _injections: null, + + /** + @private + @property _factoryTypeInjections + @type InheritingDict + */ + _factoryTypeInjections: null, + + /** + @private + @property _factoryInjections + @type InheritingDict + */ + _factoryInjections: null, + + /** + @private + @property _normalizeCache + @type InheritingDict + */ + _normalizeCache: null, + + /** + @private + @property _resolveCache + @type InheritingDict + */ + _resolveCache: null, + + /** + @private + @property _options + @type InheritingDict + */ + _options: null, + + /** + @private + @property _typeOptions + @type InheritingDict + */ + _typeOptions: null, + + /** + Creates a container based on this registry. + @private + @method container + @param {Object} options + @return {Container} created container + */ + container: function (options) { + return new _containerContainer.default(this, options); }, - pushUniqueWithoutGuid: function (target, method, args, stack) { - var queue = this._queue; + /** + Registers a factory for later injection. + Example: + ```javascript + let registry = new Registry(); + registry.register('model:user', Person, {singleton: false }); + registry.register('fruit:favorite', Orange); + registry.register('communication:main', Email, {singleton: false}); + ``` + @private + @method register + @param {String} fullName + @param {Function} factory + @param {Object} options + */ + register: function (fullName, factory) { + var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; - for (var i = 0, l = queue.length; i < l; i += 4) { - var currentTarget = queue[i]; - var currentMethod = queue[i + 1]; + _emberMetal.assert('fullName must be a proper full name', this.validateFullName(fullName)); - if (currentTarget === target && currentMethod === method) { - queue[i + 2] = args; // replace args - queue[i + 3] = stack; // replace stack - return; - } + if (factory === undefined) { + throw new TypeError('Attempting to register an unknown factory: \'' + fullName + '\''); } - queue.push(target, method, args, stack); + var normalizedName = this.normalize(fullName); + + if (this._resolveCache[normalizedName]) { + throw new Error('Cannot re-register: \'' + fullName + '\', as it has already been resolved.'); + } + + delete this._failCache[normalizedName]; + this.registrations[normalizedName] = factory; + this._options[normalizedName] = options; }, - targetQueue: function (targetQueue, target, method, args, stack) { - var queue = this._queue; + /** + Unregister a fullName + ```javascript + let registry = new Registry(); + registry.register('model:user', User); + registry.resolve('model:user').create() instanceof User //=> true + registry.unregister('model:user') + registry.resolve('model:user') === undefined //=> true + ``` + @private + @method unregister + @param {String} fullName + */ + unregister: function (fullName) { + _emberMetal.assert('fullName must be a proper full name', this.validateFullName(fullName)); - for (var i = 0, l = targetQueue.length; i < l; i += 2) { - var currentMethod = targetQueue[i]; - var currentIndex = targetQueue[i + 1]; + var normalizedName = this.normalize(fullName); - if (currentMethod === method) { - queue[currentIndex + 2] = args; // replace args - queue[currentIndex + 3] = stack; // replace stack - return; - } + this._localLookupCache = new _emberMetal.EmptyObject(); + + delete this.registrations[normalizedName]; + delete this._resolveCache[normalizedName]; + delete this._failCache[normalizedName]; + delete this._options[normalizedName]; + }, + + /** + Given a fullName return the corresponding factory. + By default `resolve` will retrieve the factory from + the registry. + ```javascript + let registry = new Registry(); + registry.register('api:twitter', Twitter); + registry.resolve('api:twitter') // => Twitter + ``` + Optionally the registry can be provided with a custom resolver. + If provided, `resolve` will first provide the custom resolver + the opportunity to resolve the fullName, otherwise it will fallback + to the registry. + ```javascript + let registry = new Registry(); + registry.resolver = function(fullName) { + // lookup via the module system of choice + }; + // the twitter factory is added to the module system + registry.resolve('api:twitter') // => Twitter + ``` + @private + @method resolve + @param {String} fullName + @param {Object} [options] + @param {String} [options.source] the fullname of the request source (used for local lookups) + @return {Function} fullName's factory + */ + resolve: function (fullName, options) { + _emberMetal.assert('fullName must be a proper full name', this.validateFullName(fullName)); + var factory = resolve(this, this.normalize(fullName), options); + if (factory === undefined && this.fallback) { + var _fallback; + + factory = (_fallback = this.fallback).resolve.apply(_fallback, arguments); } + return factory; + }, - targetQueue.push(method, queue.push(target, method, args, stack) - 4); + /** + A hook that can be used to describe how the resolver will + attempt to find the factory. + For example, the default Ember `.describe` returns the full + class name (including namespace) where Ember's resolver expects + to find the `fullName`. + @private + @method describe + @param {String} fullName + @return {string} described fullName + */ + describe: function (fullName) { + if (this.resolver && this.resolver.lookupDescription) { + return this.resolver.lookupDescription(fullName); + } else if (this.fallback) { + return this.fallback.describe(fullName); + } else { + return fullName; + } }, - pushUniqueWithGuid: function (guid, target, method, args, stack) { - var hasLocalQueue = this.targetQueues[guid]; + /** + A hook to enable custom fullName normalization behaviour + @private + @method normalizeFullName + @param {String} fullName + @return {string} normalized fullName + */ + normalizeFullName: function (fullName) { + if (this.resolver && this.resolver.normalize) { + return this.resolver.normalize(fullName); + } else if (this.fallback) { + return this.fallback.normalizeFullName(fullName); + } else { + return fullName; + } + }, - if (hasLocalQueue) { - this.targetQueue(hasLocalQueue, target, method, args, stack); + /** + Normalize a fullName based on the application's conventions + @private + @method normalize + @param {String} fullName + @return {string} normalized fullName + */ + normalize: function (fullName) { + return this._normalizeCache[fullName] || (this._normalizeCache[fullName] = this.normalizeFullName(fullName)); + }, + + /** + @method makeToString + @private + @param {any} factory + @param {string} fullName + @return {function} toString function + */ + makeToString: function (factory, fullName) { + if (this.resolver && this.resolver.makeToString) { + return this.resolver.makeToString(factory, fullName); + } else if (this.fallback) { + return this.fallback.makeToString(factory, fullName); } else { - this.targetQueues[guid] = [method, this._queue.push(target, method, args, stack) - 4]; + return factory.toString(); } + }, - return { - queue: this, - target: target, - method: method - }; + /** + Given a fullName check if the container is aware of its factory + or singleton instance. + @private + @method has + @param {String} fullName + @param {Object} [options] + @param {String} [options.source] the fullname of the request source (used for local lookups) + @return {Boolean} + */ + has: function (fullName, options) { + if (!this.isValidFullName(fullName)) { + return false; + } + + var source = options && options.source && this.normalize(options.source); + + return has(this, this.normalize(fullName), source); }, - pushUnique: function (target, method, args, stack) { - var KEY = this.globalOptions.GUID_KEY; + /** + Allow registering options for all factories of a type. + ```javascript + let registry = new Registry(); + let container = registry.container(); + // if all of type `connection` must not be singletons + registry.optionsForType('connection', { singleton: false }); + registry.register('connection:twitter', TwitterConnection); + registry.register('connection:facebook', FacebookConnection); + let twitter = container.lookup('connection:twitter'); + let twitter2 = container.lookup('connection:twitter'); + twitter === twitter2; // => false + let facebook = container.lookup('connection:facebook'); + let facebook2 = container.lookup('connection:facebook'); + facebook === facebook2; // => false + ``` + @private + @method optionsForType + @param {String} type + @param {Object} options + */ + optionsForType: function (type, options) { + this._typeOptions[type] = options; + }, - if (target && KEY) { - var guid = target[KEY]; - if (guid) { - return this.pushUniqueWithGuid(guid, target, method, args, stack); - } + getOptionsForType: function (type) { + var optionsForType = this._typeOptions[type]; + if (optionsForType === undefined && this.fallback) { + optionsForType = this.fallback.getOptionsForType(type); } + return optionsForType; + }, - this.pushUniqueWithoutGuid(target, method, args, stack); + /** + @private + @method options + @param {String} fullName + @param {Object} options + */ + options: function (fullName) { + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; - return { - queue: this, - target: target, - method: method - }; + var normalizedName = this.normalize(fullName); + this._options[normalizedName] = options; }, - invoke: function (target, method, args, _, _errorRecordedForStack) { - if (args && args.length > 0) { - method.apply(target, args); - } else { - method.call(target); + getOptions: function (fullName) { + var normalizedName = this.normalize(fullName); + var options = this._options[normalizedName]; + + if (options === undefined && this.fallback) { + options = this.fallback.getOptions(fullName); } + return options; }, - invokeWithOnError: function (target, method, args, onError, errorRecordedForStack) { - try { - if (args && args.length > 0) { - method.apply(target, args); - } else { - method.call(target); - } - } catch (error) { - onError(error, errorRecordedForStack); + getOption: function (fullName, optionName) { + var options = this._options[fullName]; + + if (options && options[optionName] !== undefined) { + return options[optionName]; } + + var type = fullName.split(':')[0]; + options = this._typeOptions[type]; + + if (options && options[optionName] !== undefined) { + return options[optionName]; + } else if (this.fallback) { + return this.fallback.getOption(fullName, optionName); + } }, - flush: function (sync) { - var queue = this._queue; - var length = queue.length; + /** + Used only via `injection`. + Provides a specialized form of injection, specifically enabling + all objects of one type to be injected with a reference to another + object. + For example, provided each object of type `controller` needed a `router`. + one would do the following: + ```javascript + let registry = new Registry(); + let container = registry.container(); + registry.register('router:main', Router); + registry.register('controller:user', UserController); + registry.register('controller:post', PostController); + registry.typeInjection('controller', 'router', 'router:main'); + let user = container.lookup('controller:user'); + let post = container.lookup('controller:post'); + user.router instanceof Router; //=> true + post.router instanceof Router; //=> true + // both controllers share the same router + user.router === post.router; //=> true + ``` + @private + @method typeInjection + @param {String} type + @param {String} property + @param {String} fullName + */ + typeInjection: function (type, property, fullName) { + _emberMetal.assert('fullName must be a proper full name', this.validateFullName(fullName)); - if (length === 0) { - return; + var fullNameType = fullName.split(':')[0]; + if (fullNameType === type) { + throw new Error('Cannot inject a \'' + fullName + '\' on other ' + type + '(s).'); } - var globalOptions = this.globalOptions; - var options = this.options; - var before = options && options.before; - var after = options && options.after; - var onError = globalOptions.onError || globalOptions.onErrorTarget && globalOptions.onErrorTarget[globalOptions.onErrorMethod]; - var target, method, args, errorRecordedForStack; - var invoke = onError ? this.invokeWithOnError : this.invoke; + var injections = this._typeInjections[type] || (this._typeInjections[type] = []); - this.targetQueues = Object.create(null); - var queueItems = this._queueBeingFlushed = this._queue.slice(); - this._queue = []; + injections.push({ + property: property, + fullName: fullName + }); + }, - if (before) { - before(); + /** + Defines injection rules. + These rules are used to inject dependencies onto objects when they + are instantiated. + Two forms of injections are possible: + * Injecting one fullName on another fullName + * Injecting one fullName on a type + Example: + ```javascript + let registry = new Registry(); + let container = registry.container(); + registry.register('source:main', Source); + registry.register('model:user', User); + registry.register('model:post', Post); + // injecting one fullName on another fullName + // eg. each user model gets a post model + registry.injection('model:user', 'post', 'model:post'); + // injecting one fullName on another type + registry.injection('model', 'source', 'source:main'); + let user = container.lookup('model:user'); + let post = container.lookup('model:post'); + user.source instanceof Source; //=> true + post.source instanceof Source; //=> true + user.post instanceof Post; //=> true + // and both models share the same source + user.source === post.source; //=> true + ``` + @private + @method injection + @param {String} factoryName + @param {String} property + @param {String} injectionName + */ + injection: function (fullName, property, injectionName) { + this.validateFullName(injectionName); + var normalizedInjectionName = this.normalize(injectionName); + + if (fullName.indexOf(':') === -1) { + return this.typeInjection(fullName, property, normalizedInjectionName); } - for (var i = 0; i < length; i += 4) { - target = queueItems[i]; - method = queueItems[i + 1]; - args = queueItems[i + 2]; - errorRecordedForStack = queueItems[i + 3]; // Debugging assistance + _emberMetal.assert('fullName must be a proper full name', this.validateFullName(fullName)); + var normalizedName = this.normalize(fullName); - if (_backburnerUtils.isString(method)) { - method = target[method]; - } + var injections = this._injections[normalizedName] || (this._injections[normalizedName] = []); - // method could have been nullified / canceled during flush - if (method) { - // - // ** Attention intrepid developer ** - // - // To find out the stack of this task when it was scheduled onto - // the run loop, add the following to your app.js: - // - // Ember.run.backburner.DEBUG = true; // NOTE: This slows your app, don't leave it on in production. - // - // Once that is in place, when you are at a breakpoint and navigate - // here in the stack explorer, you can look at `errorRecordedForStack.stack`, - // which will be the captured stack when this job was scheduled. - // - invoke(target, method, args, onError, errorRecordedForStack); + injections.push({ + property: property, + fullName: normalizedInjectionName + }); + }, + + /** + Used only via `factoryInjection`. + Provides a specialized form of injection, specifically enabling + all factory of one type to be injected with a reference to another + object. + For example, provided each factory of type `model` needed a `store`. + one would do the following: + ```javascript + let registry = new Registry(); + registry.register('store:main', SomeStore); + registry.factoryTypeInjection('model', 'store', 'store:main'); + let store = registry.lookup('store:main'); + let UserFactory = registry.lookupFactory('model:user'); + UserFactory.store instanceof SomeStore; //=> true + ``` + @private + @method factoryTypeInjection + @param {String} type + @param {String} property + @param {String} fullName + */ + factoryTypeInjection: function (type, property, fullName) { + var injections = this._factoryTypeInjections[type] || (this._factoryTypeInjections[type] = []); + + injections.push({ + property: property, + fullName: this.normalize(fullName) + }); + }, + + /** + Defines factory injection rules. + Similar to regular injection rules, but are run against factories, via + `Registry#lookupFactory`. + These rules are used to inject objects onto factories when they + are looked up. + Two forms of injections are possible: + * Injecting one fullName on another fullName + * Injecting one fullName on a type + Example: + ```javascript + let registry = new Registry(); + let container = registry.container(); + registry.register('store:main', Store); + registry.register('store:secondary', OtherStore); + registry.register('model:user', User); + registry.register('model:post', Post); + // injecting one fullName on another type + registry.factoryInjection('model', 'store', 'store:main'); + // injecting one fullName on another fullName + registry.factoryInjection('model:post', 'secondaryStore', 'store:secondary'); + let UserFactory = container.lookupFactory('model:user'); + let PostFactory = container.lookupFactory('model:post'); + let store = container.lookup('store:main'); + UserFactory.store instanceof Store; //=> true + UserFactory.secondaryStore instanceof OtherStore; //=> false + PostFactory.store instanceof Store; //=> true + PostFactory.secondaryStore instanceof OtherStore; //=> true + // and both models share the same source instance + UserFactory.store === PostFactory.store; //=> true + ``` + @private + @method factoryInjection + @param {String} factoryName + @param {String} property + @param {String} injectionName + */ + factoryInjection: function (fullName, property, injectionName) { + var normalizedName = this.normalize(fullName); + var normalizedInjectionName = this.normalize(injectionName); + + this.validateFullName(injectionName); + + if (fullName.indexOf(':') === -1) { + return this.factoryTypeInjection(normalizedName, property, normalizedInjectionName); + } + + var injections = this._factoryInjections[normalizedName] || (this._factoryInjections[normalizedName] = []); + + injections.push({ + property: property, + fullName: normalizedInjectionName + }); + }, + + /** + @private + @method knownForType + @param {String} type the type to iterate over + */ + knownForType: function (type) { + var fallbackKnown = undefined, + resolverKnown = undefined; + + var localKnown = _emberMetal.dictionary(null); + var registeredNames = Object.keys(this.registrations); + for (var index = 0; index < registeredNames.length; index++) { + var fullName = registeredNames[index]; + var itemType = fullName.split(':')[0]; + + if (itemType === type) { + localKnown[fullName] = true; } } - if (after) { - after(); + if (this.fallback) { + fallbackKnown = this.fallback.knownForType(type); } - this._queueBeingFlushed = undefined; + if (this.resolver && this.resolver.knownForType) { + resolverKnown = this.resolver.knownForType(type); + } - if (sync !== false && this._queue.length > 0) { - // check if new items have been added - this.flush(true); + return _emberMetal.assign({}, fallbackKnown, localKnown, resolverKnown); + }, + + validateFullName: function (fullName) { + if (!this.isValidFullName(fullName)) { + throw new TypeError('Invalid Fullname, expected: \'type:name\' got: ' + fullName); } + + return true; }, - cancel: function (actionToCancel) { - var queue = this._queue, - currentTarget, - currentMethod, - i, - l; - var target = actionToCancel.target; - var method = actionToCancel.method; - var GUID_KEY = this.globalOptions.GUID_KEY; + isValidFullName: function (fullName) { + return !!VALID_FULL_NAME_REGEXP.test(fullName); + }, - if (GUID_KEY && this.targetQueues && target) { - var targetQueue = this.targetQueues[target[GUID_KEY]]; + validateInjections: function (injections) { + if (!injections) { + return; + } - if (targetQueue) { - for (i = 0, l = targetQueue.length; i < l; i++) { - if (targetQueue[i] === method) { - targetQueue.splice(i, 1); - } - } + var fullName = undefined; + + for (var i = 0; i < injections.length; i++) { + fullName = injections[i].fullName; + + if (!this.has(fullName)) { + throw new Error('Attempting to inject an unknown injection: \'' + fullName + '\''); } } + }, - for (i = 0, l = queue.length; i < l; i += 4) { - currentTarget = queue[i]; - currentMethod = queue[i + 1]; + normalizeInjectionsHash: function (hash) { + var injections = []; - if (currentTarget === target && currentMethod === method) { - queue.splice(i, 4); - return true; + for (var key in hash) { + if (hash.hasOwnProperty(key)) { + _emberMetal.assert('Expected a proper full name, given \'' + hash[key] + '\'', this.validateFullName(hash[key])); + + injections.push({ + property: key, + fullName: hash[key] + }); } } - // if not found in current queue - // could be in the queue that is being flushed - queue = this._queueBeingFlushed; + return injections; + }, - if (!queue) { - return; + getInjections: function (fullName) { + var injections = this._injections[fullName] || []; + if (this.fallback) { + injections = injections.concat(this.fallback.getInjections(fullName)); } + return injections; + }, - for (i = 0, l = queue.length; i < l; i += 4) { - currentTarget = queue[i]; - currentMethod = queue[i + 1]; + getTypeInjections: function (type) { + var injections = this._typeInjections[type] || []; + if (this.fallback) { + injections = injections.concat(this.fallback.getTypeInjections(type)); + } + return injections; + }, - if (currentTarget === target && currentMethod === method) { - // don't mess with array during flush - // just nullify the method - queue[i + 1] = null; - return true; - } + getFactoryInjections: function (fullName) { + var injections = this._factoryInjections[fullName] || []; + if (this.fallback) { + injections = injections.concat(this.fallback.getFactoryInjections(fullName)); } + return injections; + }, + + getFactoryTypeInjections: function (type) { + var injections = this._factoryTypeInjections[type] || []; + if (this.fallback) { + injections = injections.concat(this.fallback.getFactoryTypeInjections(type)); + } + return injections; } }; -}); -enifed('backburner/utils', ['exports'], function (exports) { - 'use strict'; - exports.each = each; - exports.isString = isString; - exports.isFunction = isFunction; - exports.isNumber = isNumber; - exports.isCoercableNumber = isCoercableNumber; - var NUMBER = /\d+/; + function deprecateResolverFunction(registry) { + _emberMetal.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: 'http://emberjs.com/deprecations/v2.x#toc_registry-resolver-as-function' }); + registry.resolver = { + resolve: registry.resolver + }; + } - function each(collection, callback) { - for (var i = 0; i < collection.length; i++) { - callback(collection[i]); + /** + Given a fullName and a source fullName returns the fully resolved + fullName. Used to allow for local lookup. + + ```javascript + let registry = new Registry(); + + // the twitter factory is added to the module system + registry.expandLocalLookup('component:post-title', { source: 'template:post' }) // => component:post/post-title + ``` + + @private + @method expandLocalLookup + @param {String} fullName + @param {Object} [options] + @param {String} [options.source] the fullname of the request source (used for local lookups) + @return {String} fullName + */ + Registry.prototype.expandLocalLookup = function Registry_expandLocalLookup(fullName, options) { + if (this.resolver && this.resolver.expandLocalLookup) { + _emberMetal.assert('fullName must be a proper full name', this.validateFullName(fullName)); + _emberMetal.assert('options.source must be provided to expandLocalLookup', options && options.source); + _emberMetal.assert('options.source must be a proper full name', this.validateFullName(options.source)); + + var normalizedFullName = this.normalize(fullName); + var normalizedSource = this.normalize(options.source); + + return expandLocalLookup(this, normalizedFullName, normalizedSource); + } else if (this.fallback) { + return this.fallback.expandLocalLookup(fullName, options); + } else { + return null; } - } + }; - function isString(suspect) { - return typeof suspect === 'string'; + function expandLocalLookup(registry, normalizedName, normalizedSource) { + var cache = registry._localLookupCache; + var normalizedNameCache = cache[normalizedName]; + + if (!normalizedNameCache) { + normalizedNameCache = cache[normalizedName] = new _emberMetal.EmptyObject(); + } + + var cached = normalizedNameCache[normalizedSource]; + + if (cached !== undefined) { + return cached; + } + + var expanded = registry.resolver.expandLocalLookup(normalizedName, normalizedSource); + + return normalizedNameCache[normalizedSource] = expanded; } - function isFunction(suspect) { - return typeof suspect === 'function'; + function resolve(registry, normalizedName, options) { + if (options && options.source) { + // when `source` is provided expand normalizedName + // and source into the full normalizedName + normalizedName = registry.expandLocalLookup(normalizedName, options); + + // if expandLocalLookup returns falsey, we do not support local lookup + if (!normalizedName) { + return; + } + } + + var cached = registry._resolveCache[normalizedName]; + if (cached !== undefined) { + return cached; + } + if (registry._failCache[normalizedName]) { + return; + } + + var resolved = undefined; + + if (registry.resolver) { + resolved = registry.resolver.resolve(normalizedName); + } + + if (resolved === undefined) { + resolved = registry.registrations[normalizedName]; + } + + if (resolved === undefined) { + registry._failCache[normalizedName] = true; + } else { + registry._resolveCache[normalizedName] = resolved; + } + + return resolved; } - function isNumber(suspect) { - return typeof suspect === 'number'; + function has(registry, fullName, source) { + return registry.resolve(fullName, { source: source }) !== undefined; } - function isCoercableNumber(number) { - return isNumber(number) || NUMBER.test(number); + var privateNames = _emberMetal.dictionary(null); + var privateSuffix = '' + Math.random() + Date.now(); + + function privatize(_ref) { + var fullName = _ref[0]; + + var name = privateNames[fullName]; + if (name) { + return name; + } + + var _fullName$split = fullName.split(':'); + + var type = _fullName$split[0]; + var rawName = _fullName$split[1]; + + return privateNames[fullName] = _emberMetal.intern(type + ':' + rawName + '-' + privateSuffix); } }); enifed('ember-console/index', ['exports', 'ember-environment'], function (exports, _emberEnvironment) { 'use strict'; @@ -1290,16 +2695,15 @@ @public */ assert: consoleMethod('assert') || assertPolyfill }; }); -enifed('ember-debug/deprecate', ['exports', 'ember-metal/error', 'ember-console', 'ember-environment', 'ember-debug/handlers'], function (exports, _emberMetalError, _emberConsole, _emberEnvironment, _emberDebugHandlers) { +enifed('ember-debug/deprecate', ['exports', 'ember-metal', 'ember-console', 'ember-environment', 'ember-debug/handlers'], function (exports, _emberMetal, _emberConsole, _emberEnvironment, _emberDebugHandlers) { /*global __fail__*/ 'use strict'; - var _slice = Array.prototype.slice; exports.registerHandler = registerHandler; exports.default = deprecate; function registerHandler(handler) { _emberDebugHandlers.registerHandler('deprecate', handler); @@ -1370,11 +2774,11 @@ registerHandler(function raiseOnDeprecation(message, options, next) { if (_emberEnvironment.ENV.RAISE_ON_DEPRECATION) { var updatedMessage = formatMessage(message); - throw new _emberMetalError.default(updatedMessage); + throw new _emberMetal.Error(updatedMessage); } else { next.apply(undefined, arguments); } }); @@ -1397,17 +2801,20 @@ * In a production build, this method is defined as an empty function (NOP). Uses of this method in Ember itself are stripped from the ember.prod.js build. @method deprecate @param {String} message A description of the deprecation. - @param {Boolean} test A boolean. If falsy, the deprecation - will be displayed. - @param {Object} options An object that can be used to pass - in a `url` to the transition guide on the emberjs.com website, and a unique - `id` for this deprecation. The `id` can be used by Ember debugging tools - to change the behavior (raise, log or silence) for that specific deprecation. - The `id` should be namespaced by dots, e.g. "view.helper.select". + @param {Boolean} test A boolean. If falsy, the deprecation will be displayed. + @param {Object} options + @param {String} options.id A unique id for this deprecation. The id can be + used by Ember debugging tools to change the behavior (raise, log or silence) + for that specific deprecation. The id should be namespaced by dots, e.g. + "view.helper.select". + @param {string} options.until The version of Ember when this deprecation + warning will be removed. + @param {String} [options.url] An optional url to the transition guide on the + emberjs.com website. @for Ember @public */ function deprecate(message, test, options) { @@ -1433,11 +2840,11 @@ until: '3.0.0', url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options' }); } - _emberDebugHandlers.invoke.apply(undefined, ['deprecate'].concat(_slice.call(arguments))); + _emberDebugHandlers.invoke.apply(undefined, ['deprecate'].concat(babelHelpers.slice.call(arguments))); } }); enifed("ember-debug/handlers", ["exports"], function (exports) { "use strict"; @@ -1469,11 +2876,11 @@ if (handlerForType) { handlerForType(message, options); } } }); -enifed('ember-debug/index', ['exports', 'ember-metal/core', 'ember-environment', 'ember-metal/testing', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-console', 'ember-debug/deprecate', 'ember-debug/warn'], function (exports, _emberMetalCore, _emberEnvironment, _emberMetalTesting, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberConsole, _emberDebugDeprecate, _emberDebugWarn) { +enifed('ember-debug/index', ['exports', 'ember-metal', 'ember-environment', 'ember-console', 'ember-debug/deprecate', 'ember-debug/warn'], function (exports, _emberMetal, _emberEnvironment, _emberConsole, _emberDebugDeprecate, _emberDebugWarn) { 'use strict'; exports._warnIfUsingStrippedFeatureFlags = _warnIfUsingStrippedFeatureFlags; /** @@ -1505,13 +2912,13 @@ the text of the Error thrown if the assertion fails. @param {Boolean} test Must be truthy for the assertion to pass. If falsy, an exception will be thrown. @public */ - _emberMetalDebug.setDebugFunction('assert', function assert(desc, test) { + _emberMetal.setDebugFunction('assert', function assert(desc, test) { if (!test) { - throw new _emberMetalError.default('Assertion Failed: ' + desc); + throw new _emberMetal.Error('Assertion Failed: ' + desc); } }); /** Display a debug notice. @@ -1525,11 +2932,11 @@ @method debug @param {String} message A debug message to display. @public */ - _emberMetalDebug.setDebugFunction('debug', function debug(message) { + _emberMetal.setDebugFunction('debug', function debug(message) { _emberConsole.default.debug('DEBUG: ' + message); }); /** Display an info notice. @@ -1538,11 +2945,11 @@ Uses of this method in Ember itself are stripped from the ember.prod.js build. @method info @private */ - _emberMetalDebug.setDebugFunction('info', function info() { + _emberMetal.setDebugFunction('info', function info() { _emberConsole.default.info.apply(undefined, arguments); }); /** Alias an old, deprecated method with its new counterpart. @@ -1561,11 +2968,11 @@ @param {Object} [options] The options object for Ember.deprecate. @param {Function} func The new function called to replace its deprecated counterpart. @return {Function} A new function that wraps the original function with a deprecation warning @private */ - _emberMetalDebug.setDebugFunction('deprecateFunc', function deprecateFunc() { + _emberMetal.setDebugFunction('deprecateFunc', function deprecateFunc() { for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { args[_key] = arguments[_key]; } if (args.length === 3) { @@ -1574,11 +2981,11 @@ var options = args[1]; var func = args[2]; return { v: function () { - _emberMetalDebug.deprecate(message, false, options); + _emberMetal.deprecate(message, false, options); return func.apply(this, arguments); } }; })(); @@ -1588,11 +2995,11 @@ var message = args[0]; var func = args[1]; return { v: function () { - _emberMetalDebug.deprecate(message); + _emberMetal.deprecate(message); return func.apply(this, arguments); } }; })(); @@ -1619,21 +3026,21 @@ @method runInDebug @param {Function} func The function to be executed. @since 1.5.0 @public */ - _emberMetalDebug.setDebugFunction('runInDebug', function runInDebug(func) { + _emberMetal.setDebugFunction('runInDebug', function runInDebug(func) { func(); }); - _emberMetalDebug.setDebugFunction('debugSeal', function debugSeal(obj) { + _emberMetal.setDebugFunction('debugSeal', function debugSeal(obj) { Object.seal(obj); }); - _emberMetalDebug.setDebugFunction('deprecate', _emberDebugDeprecate.default); + _emberMetal.setDebugFunction('deprecate', _emberDebugDeprecate.default); - _emberMetalDebug.setDebugFunction('warn', _emberDebugWarn.default); + _emberMetal.setDebugFunction('warn', _emberDebugWarn.default); /** Will call `Ember.warn()` if ENABLE_OPTIONAL_FEATURES or any specific FEATURES flag is truthy. @@ -1644,36 +3051,36 @@ @return {void} */ function _warnIfUsingStrippedFeatureFlags(FEATURES, knownFeatures, featuresWereStripped) { if (featuresWereStripped) { - _emberMetalDebug.warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !_emberEnvironment.ENV.ENABLE_OPTIONAL_FEATURES, { id: 'ember-debug.feature-flag-with-features-stripped' }); + _emberMetal.warn('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.', !_emberEnvironment.ENV.ENABLE_OPTIONAL_FEATURES, { id: 'ember-debug.feature-flag-with-features-stripped' }); var keys = Object.keys(FEATURES || {}); for (var i = 0; i < keys.length; i++) { var key = keys[i]; if (key === 'isEnabled' || !(key in knownFeatures)) { continue; } - _emberMetalDebug.warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key], { id: 'ember-debug.feature-flag-with-features-stripped' }); + _emberMetal.warn('FEATURE["' + key + '"] is set as enabled, but FEATURE flags are only available in canary builds.', !FEATURES[key], { id: 'ember-debug.feature-flag-with-features-stripped' }); } } } - if (!_emberMetalTesting.isTesting()) { + if (!_emberMetal.isTesting()) { (function () { // Complain if they're using FEATURE flags in builds other than canary - _emberMetalFeatures.FEATURES['features-stripped-test'] = true; + _emberMetal.FEATURES['features-stripped-test'] = true; var featuresWereStripped = true; - if (false) { + if (_emberMetal.isFeatureEnabled('features-stripped-test')) { featuresWereStripped = false; } - delete _emberMetalFeatures.FEATURES['features-stripped-test']; - _warnIfUsingStrippedFeatureFlags(_emberEnvironment.ENV.FEATURES, _emberMetalFeatures.DEFAULT_FEATURES, featuresWereStripped); + delete _emberMetal.FEATURES['features-stripped-test']; + _warnIfUsingStrippedFeatureFlags(_emberEnvironment.ENV.FEATURES, _emberMetal.DEFAULT_FEATURES, featuresWereStripped); // Inform the developer about the Ember Inspector if not installed. var isFirefox = _emberEnvironment.environment.isFirefox; var isChrome = _emberEnvironment.environment.isChrome; @@ -1686,21 +3093,21 @@ downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi'; } else if (isFirefox) { downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/'; } - _emberMetalDebug.debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL); + _emberMetal.debug('For more advanced debugging, install the Ember Inspector from ' + downloadURL); } }, false); } })(); } /** @public @class Ember.Debug */ - _emberMetalCore.default.Debug = {}; + _emberMetal.default.Debug = {}; /** Allows for runtime registration of handler functions that override the default deprecation behavior. Deprecations are invoked by calls to [Ember.deprecate](http://emberjs.com/api/classes/Ember.html#method_deprecate). The following example demonstrates its usage by registering a handler that throws an error if the @@ -1733,11 +3140,11 @@ @static @method registerDeprecationHandler @param handler {Function} A function to handle deprecation calls. @since 2.1.0 */ - _emberMetalCore.default.Debug.registerDeprecationHandler = _emberDebugDeprecate.registerHandler; + _emberMetal.default.Debug.registerDeprecationHandler = _emberDebugDeprecate.registerHandler; /** Allows for runtime registration of handler functions that override the default warning behavior. Warnings are invoked by calls made to [Ember.warn](http://emberjs.com/api/classes/Ember.html#method_warn). The following example demonstrates its usage by registering a handler that does nothing overriding Ember's default warning behavior. @@ -1762,11 +3169,11 @@ @static @method registerWarnHandler @param handler {Function} A function to handle warnings. @since 2.1.0 */ - _emberMetalCore.default.Debug.registerWarnHandler = _emberDebugWarn.registerHandler; + _emberMetal.default.Debug.registerWarnHandler = _emberDebugWarn.registerHandler; /* We are transitioning away from `ember.js` to `ember.debug.js` to make it much clearer that it is only for local development purposes. @@ -1775,18 +3182,17 @@ used a nice helpful warning message will be printed out. */ var runningNonEmberDebugJS = false; exports.runningNonEmberDebugJS = runningNonEmberDebugJS; if (runningNonEmberDebugJS) { - _emberMetalDebug.warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.'); + _emberMetal.warn('Please use `ember.debug.js` instead of `ember.js` for development and debugging.'); } }); // reexports -enifed('ember-debug/warn', ['exports', 'ember-console', 'ember-metal/debug', 'ember-debug/handlers'], function (exports, _emberConsole, _emberMetalDebug, _emberDebugHandlers) { +enifed('ember-debug/warn', ['exports', 'ember-console', 'ember-metal', 'ember-debug/handlers'], function (exports, _emberConsole, _emberMetal, _emberDebugHandlers) { 'use strict'; - var _slice = Array.prototype.slice; exports.registerHandler = registerHandler; exports.default = warn; function registerHandler(handler) { _emberDebugHandlers.registerHandler('warn', handler); @@ -1827,26 +3233,26 @@ @public */ function warn(message, test, options) { if (!options) { - _emberMetalDebug.deprecate(missingOptionsDeprecation, false, { + _emberMetal.deprecate(missingOptionsDeprecation, false, { id: 'ember-debug.warn-options-missing', until: '3.0.0', url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options' }); } if (options && !options.id) { - _emberMetalDebug.deprecate(missingOptionsIdDeprecation, false, { + _emberMetal.deprecate(missingOptionsIdDeprecation, false, { id: 'ember-debug.warn-id-missing', until: '3.0.0', url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-debug-function-options' }); } - _emberDebugHandlers.invoke.apply(undefined, ['warn'].concat(_slice.call(arguments))); + _emberDebugHandlers.invoke.apply(undefined, ['warn'].concat(babelHelpers.slice.call(arguments))); } }); enifed('ember-environment/global', ['exports'], function (exports) { /* globals global, window, self, mainContext */ @@ -2018,444 +3424,10 @@ Function: defaultTrue(obj.Function) }; } } }); -enifed('ember-glimmer-template-compiler/index', ['exports', 'ember-glimmer-template-compiler/system/compile', 'ember-glimmer-template-compiler/system/precompile', 'ember-glimmer-template-compiler/system/compile-options'], function (exports, _emberGlimmerTemplateCompilerSystemCompile, _emberGlimmerTemplateCompilerSystemPrecompile, _emberGlimmerTemplateCompilerSystemCompileOptions) { - 'use strict'; - - exports.compile = _emberGlimmerTemplateCompilerSystemCompile.default; - exports.precompile = _emberGlimmerTemplateCompilerSystemPrecompile.default; - exports.defaultCompileOptions = _emberGlimmerTemplateCompilerSystemCompileOptions.default; - exports.registerPlugin = _emberGlimmerTemplateCompilerSystemCompileOptions.registerPlugin; -}); -enifed('ember-glimmer-template-compiler/plugins/transform-action-syntax', ['exports'], function (exports) { - /** - @module ember - @submodule ember-glimmer - */ - - /** - A Glimmer2 AST transformation that replaces all instances of - - ```handlebars - <button {{action 'foo'}}> - <button onblur={{action 'foo'}}> - <button onblur={{action (action 'foo') 'bar'}}> - ``` - - with - - ```handlebars - <button {{action this 'foo'}}> - <button onblur={{action this 'foo'}}> - <button onblur={{action this (action this 'foo') 'bar'}}> - ``` - - @private - @class TransformActionSyntax - */ - - 'use strict'; - - exports.default = TransformActionSyntax; - - function TransformActionSyntax() { - // set later within Glimmer2 to the syntax package - this.syntax = null; - } - - /** - @private - @method transform - @param {AST} ast The AST to be transformed. - */ - TransformActionSyntax.prototype.transform = function TransformActionSyntax_transform(ast) { - var _syntax = this.syntax; - var traverse = _syntax.traverse; - var b = _syntax.builders; - - traverse(ast, { - ElementModifierStatement: function (node) { - if (isAction(node)) { - insertThisAsFirstParam(node, b); - } - }, - MustacheStatement: function (node) { - if (isAction(node)) { - insertThisAsFirstParam(node, b); - } - }, - SubExpression: function (node) { - if (isAction(node)) { - insertThisAsFirstParam(node, b); - } - } - }); - - return ast; - }; - - function isAction(node) { - return node.path.original === 'action'; - } - - function insertThisAsFirstParam(node, builders) { - node.params.unshift(builders.path('')); - } -}); -enifed('ember-glimmer-template-compiler/plugins/transform-attrs-into-args', ['exports'], function (exports) { - /** - @module ember - @submodule ember-glimmer - */ - - /** - A Glimmer2 AST transformation that replaces all instances of - - ```handlebars - {{attrs.foo.bar}} - ``` - - to - - ```handlebars - {{@foo.bar}} - ``` - - as well as `{{#if attrs.foo}}`, `{{deeply (nested attrs.foobar.baz)}}` etc - - @private - @class TransformAttrsToProps - */ - - 'use strict'; - - exports.default = TransformAttrsToProps; - - function TransformAttrsToProps() { - // set later within Glimmer2 to the syntax package - this.syntax = null; - } - - /** - @private - @method transform - @param {AST} ast The AST to be transformed. - */ - TransformAttrsToProps.prototype.transform = function TransformAttrsToProps_transform(ast) { - var _syntax = this.syntax; - var traverse = _syntax.traverse; - var b = _syntax.builders; - - traverse(ast, { - PathExpression: function (node) { - if (node.parts[0] === 'attrs') { - var path = b.path(node.original.substr(6)); - path.original = '@' + path.original; - path.data = true; - return path; - } - } - }); - - return ast; - }; -}); -enifed('ember-glimmer-template-compiler/plugins/transform-each-in-into-each', ['exports'], function (exports) { - /** - @module ember - @submodule ember-glimmer - */ - - /** - A Glimmer2 AST transformation that replaces all instances of - - ```handlebars - {{#each-in iterableThing as |key value|}} - ``` - - with - - ```handlebars - {{#each (-each-in iterableThing) as |key value|}} - ``` - - @private - @class TransformHasBlockSyntax - */ - - 'use strict'; - - exports.default = TransformEachInIntoEach; - - function TransformEachInIntoEach() { - // set later within Glimmer2 to the syntax package - this.syntax = null; - } - - /** - @private - @method transform - @param {AST} ast The AST to be transformed. - */ - TransformEachInIntoEach.prototype.transform = function TransformEachInIntoEach_transform(ast) { - var _syntax = this.syntax; - var traverse = _syntax.traverse; - var b = _syntax.builders; - - traverse(ast, { - BlockStatement: function (node) { - if (node.path.original === 'each-in') { - node.params[0] = b.sexpr(b.path('-each-in'), [node.params[0]]); - return b.block(b.path('each'), node.params, node.hash, node.program, node.inverse, node.loc); - } - } - }); - - return ast; - }; -}); -enifed('ember-glimmer-template-compiler/plugins/transform-has-block-syntax', ['exports'], function (exports) { - /** - @module ember - @submodule ember-glimmer - */ - - /** - A Glimmer2 AST transformation that replaces all instances of - - ```handlebars - {{hasBlock}} - ``` - - with - - ```handlebars - {{has-block}} - ``` - - @private - @class TransformHasBlockSyntax - */ - - 'use strict'; - - exports.default = TransformHasBlockSyntax; - - function TransformHasBlockSyntax() { - // set later within Glimmer2 to the syntax package - this.syntax = null; - } - - var TRANSFORMATIONS = { - hasBlock: 'has-block', - hasBlockParams: 'has-block-params' - }; - - /** - @private - @method transform - @param {AST} ast The AST to be transformed. - */ - TransformHasBlockSyntax.prototype.transform = function TransformHasBlockSyntax_transform(ast) { - var _syntax = this.syntax; - var traverse = _syntax.traverse; - var b = _syntax.builders; - - traverse(ast, { - PathExpression: function (node) { - if (TRANSFORMATIONS[node.original]) { - return b.sexpr(b.path(TRANSFORMATIONS[node.original])); - } - }, - MustacheStatement: function (node) { - if (TRANSFORMATIONS[node.path.original]) { - return b.mustache(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash, null, node.loc); - } - }, - SubExpression: function (node) { - if (TRANSFORMATIONS[node.path.original]) { - return b.sexpr(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash); - } - } - }); - - return ast; - }; -}); -enifed('ember-glimmer-template-compiler/plugins/transform-input-type-syntax', ['exports'], function (exports) { - /** - @module ember - @submodule ember-glimmer - */ - - /** - A Glimmer2 AST transformation that replaces all instances of - - ```handlebars - {{input type=boundType}} - ``` - - with - - ```handlebars - {{input (-input-type boundType) type=boundType}} - ``` - - Note that the type parameters is not removed as the -input-type helpers - is only used to select the component class. The component still needs - the type parameter to function. - - @private - @class TransformInputTypeSyntax - */ - - 'use strict'; - - exports.default = TransformInputTypeSyntax; - - function TransformInputTypeSyntax() { - // set later within Glimmer2 to the syntax package - this.syntax = null; - } - - /** - @private - @method transform - @param {AST} ast The AST to be transformed. - */ - TransformInputTypeSyntax.prototype.transform = function TransformInputTypeSyntax_transform(ast) { - var _syntax = this.syntax; - var traverse = _syntax.traverse; - var b = _syntax.builders; - - traverse(ast, { - MustacheStatement: function (node) { - if (isInput(node)) { - insertTypeHelperParameter(node, b); - } - } - }); - - return ast; - }; - - function isInput(node) { - return node.path.original === 'input'; - } - - function insertTypeHelperParameter(node, builders) { - var pairs = node.hash.pairs; - var pair = null; - for (var i = 0; i < pairs.length; i++) { - if (pairs[i].key === 'type') { - pair = pairs[i]; - break; - } - } - if (pair && pair.value.type !== 'StringLiteral') { - node.params.unshift(builders.sexpr('-input-type', [builders.path(pair.value.original, pair.loc)], null, pair.loc)); - } - } -}); -enifed('ember-glimmer-template-compiler/system/compile-options', ['exports', 'ember-template-compiler/plugins', 'ember-glimmer-template-compiler/plugins/transform-action-syntax', 'ember-glimmer-template-compiler/plugins/transform-input-type-syntax', 'ember-glimmer-template-compiler/plugins/transform-attrs-into-args', 'ember-glimmer-template-compiler/plugins/transform-each-in-into-each', 'ember-glimmer-template-compiler/plugins/transform-has-block-syntax', 'ember-metal/assign'], function (exports, _emberTemplateCompilerPlugins, _emberGlimmerTemplateCompilerPluginsTransformActionSyntax, _emberGlimmerTemplateCompilerPluginsTransformInputTypeSyntax, _emberGlimmerTemplateCompilerPluginsTransformAttrsIntoArgs, _emberGlimmerTemplateCompilerPluginsTransformEachInIntoEach, _emberGlimmerTemplateCompilerPluginsTransformHasBlockSyntax, _emberMetalAssign) { - 'use strict'; - - exports.default = compileOptions; - exports.registerPlugin = registerPlugin; - exports.removePlugin = removePlugin; - var PLUGINS = [].concat(_emberTemplateCompilerPlugins.default, [ - // the following are ember-glimmer specific - _emberGlimmerTemplateCompilerPluginsTransformActionSyntax.default, _emberGlimmerTemplateCompilerPluginsTransformInputTypeSyntax.default, _emberGlimmerTemplateCompilerPluginsTransformAttrsIntoArgs.default, _emberGlimmerTemplateCompilerPluginsTransformEachInIntoEach.default, _emberGlimmerTemplateCompilerPluginsTransformHasBlockSyntax.default]); - - exports.PLUGINS = PLUGINS; - var USER_PLUGINS = []; - - function compileOptions(options) { - options = options || {}; - options = _emberMetalAssign.default({}, options); - if (!options.plugins) { - options.plugins = { ast: [].concat(USER_PLUGINS, PLUGINS) }; - } else { - var potententialPugins = [].concat(USER_PLUGINS, PLUGINS); - var pluginsToAdd = potententialPugins.filter(function (plugin) { - return options.plugins.ast.indexOf(plugin) === -1; - }); - options.plugins.ast = options.plugins.ast.slice().concat(pluginsToAdd); - } - - return options; - } - - function registerPlugin(type, PluginClass) { - if (type !== 'ast') { - throw new Error('Attempting to register ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.'); - } - - if (USER_PLUGINS.indexOf(PluginClass) === -1) { - USER_PLUGINS = [PluginClass].concat(USER_PLUGINS); - } - } - - function removePlugin(type, PluginClass) { - if (type !== 'ast') { - throw new Error('Attempting to unregister ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.'); - } - - USER_PLUGINS = USER_PLUGINS.filter(function (plugin) { - return plugin !== PluginClass; - }); - } -}); -enifed('ember-glimmer-template-compiler/system/compile', ['exports', 'require', 'ember-glimmer-template-compiler/system/compile-options'], function (exports, _require, _emberGlimmerTemplateCompilerSystemCompileOptions) { - 'use strict'; - - exports.default = compile; - - var compileSpec = undefined, - template = undefined; - - function compile(string, options) { - if (!compileSpec && _require.has('glimmer-compiler')) { - compileSpec = _require.default('glimmer-compiler').compileSpec; - } - - if (!template && _require.has('ember-glimmer')) { - template = _require.default('ember-glimmer').template; - } - - if (!compileSpec) { - throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.'); - } - - if (!template) { - throw new Error('Cannot call `compile` with only the template compiler loaded. Please load `ember.debug.js` or `ember.prod.js` prior to calling `compile`.'); - } - - return template(compileSpec(string, _emberGlimmerTemplateCompilerSystemCompileOptions.default(options))); - } -}); -enifed('ember-glimmer-template-compiler/system/precompile', ['exports', 'ember-glimmer-template-compiler/system/compile-options', 'require'], function (exports, _emberGlimmerTemplateCompilerSystemCompileOptions, _require) { - 'use strict'; - - exports.default = precompile; - - var compileSpec = undefined; - - function precompile(templateString, options) { - if (!compileSpec && _require.has('glimmer-compiler')) { - compileSpec = _require.default('glimmer-compiler').compileSpec; - } - - if (!compileSpec) { - throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.'); - } - - return JSON.stringify(compileSpec(templateString, _emberGlimmerTemplateCompilerSystemCompileOptions.default(options))); - } -}); enifed('ember-metal/alias', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/error', 'ember-metal/properties', 'ember-metal/computed', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/dependent_keys'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalError, _emberMetalProperties, _emberMetalComputed, _emberMetalUtils, _emberMetalMeta, _emberMetalDependent_keys) { 'use strict'; exports.default = alias; exports.AliasedProperty = AliasedProperty; @@ -3047,15 +4019,13 @@ exports.Binding = Binding; }); enifed('ember-metal/cache', ['exports', 'ember-metal/empty_object'], function (exports, _emberMetalEmpty_object) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var Cache = (function () { function Cache(limit, func, key, store) { - _classCallCheck(this, Cache); + babelHelpers.classCallCheck(this, Cache); this.size = 0; this.misses = 0; this.hits = 0; this.limit = limit; @@ -3113,11 +4083,11 @@ function UNDEFINED() {} var DefaultStore = (function () { function DefaultStore() { - _classCallCheck(this, DefaultStore); + babelHelpers.classCallCheck(this, DefaultStore); this.data = new _emberMetalEmpty_object.default(); } DefaultStore.prototype.get = function get(key) { @@ -3145,11 +4115,11 @@ function firstKey(path) { return path.match(FIRST_KEY)[0]; } function isObject(obj) { - return obj && typeof obj === 'object'; + return typeof obj === 'object' && obj; } function isVolatile(obj) { return !(isObject(obj) && obj.isDescriptor && obj._volatile === false); } @@ -4100,11 +5070,10 @@ */ var Ember = typeof _emberEnvironment.context.imports.Ember === 'object' && _emberEnvironment.context.imports.Ember || {}; // Make sure these are set whether Ember was already defined or not Ember.isNamespace = true; - Ember.toString = function () { return 'Ember'; }; // .......................................................... @@ -4277,10 +5246,47 @@ return _emberMetalProperty_get.get(this, newKey); } }); } }); +enifed('ember-metal/descriptor', ['exports', 'ember-metal/properties'], function (exports, _emberMetalProperties) { + 'use strict'; + + exports.default = descriptor; + + function descriptor(desc) { + return new Descriptor(desc); + } + + /** + A wrapper for a native ES5 descriptor. In an ideal world, we wouldn't need + this at all, however, the way we currently flatten/merge our mixins require + a special value to denote a descriptor. + + @class Descriptor + @private + */ + + var Descriptor = (function (_EmberDescriptor) { + babelHelpers.inherits(Descriptor, _EmberDescriptor); + + function Descriptor(desc) { + babelHelpers.classCallCheck(this, Descriptor); + + _EmberDescriptor.call(this); + this.desc = desc; + } + + Descriptor.prototype.setup = function setup(obj, key) { + Object.defineProperty(obj, key, this.desc); + }; + + Descriptor.prototype.teardown = function teardown(obj, key) {}; + + return Descriptor; + })(_emberMetalProperties.Descriptor); +}); enifed('ember-metal/dictionary', ['exports', 'ember-metal/empty_object'], function (exports, _emberMetalEmpty_object) { 'use strict'; exports.default = makeDictionary; @@ -4375,11 +5381,11 @@ // To maintain stacktrace consistency across browsers var getStack = function (error) { var stack = error.stack; var message = error.message; - if (stack.indexOf(message) === -1) { + if (stack && stack.indexOf(message) === -1) { stack = message + '\n' + stack; } return stack; }; @@ -4933,331 +5939,163 @@ ret[propertyNames[i]] = _emberMetalProperty_get.get(obj, propertyNames[i]); } return ret; } }); -enifed('ember-metal/index', ['exports', 'require', 'ember-environment', 'ember/version', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/assign', 'ember-metal/merge', 'ember-metal/instrumentation', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/error', 'ember-metal/cache', 'ember-console', 'ember-metal/property_get', 'ember-metal/events', 'ember-metal/observer_set', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/property_set', 'ember-metal/weak_map', 'ember-metal/map', 'ember-metal/get_properties', 'ember-metal/set_properties', 'ember-metal/watch_key', 'ember-metal/chains', 'ember-metal/watch_path', 'ember-metal/watching', 'ember-metal/expand_properties', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/observer', 'ember-metal/mixin', 'ember-metal/binding', 'ember-metal/path_cache', 'ember-metal/testing', 'ember-metal/error_handler', 'ember-metal/run_loop', 'ember-metal/libraries', 'ember-metal/is_none', 'ember-metal/is_empty', 'ember-metal/is_blank', 'ember-metal/is_present', 'backburner'], function (exports, _require, _emberEnvironment, _emberVersion, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalAssign, _emberMetalMerge, _emberMetalInstrumentation, _emberMetalUtils, _emberMetalMeta, _emberMetalError, _emberMetalCache, _emberConsole, _emberMetalProperty_get, _emberMetalEvents, _emberMetalObserver_set, _emberMetalProperty_events, _emberMetalProperties, _emberMetalProperty_set, _emberMetalWeak_map, _emberMetalMap, _emberMetalGet_properties, _emberMetalSet_properties, _emberMetalWatch_key, _emberMetalChains, _emberMetalWatch_path, _emberMetalWatching, _emberMetalExpand_properties, _emberMetalComputed, _emberMetalAlias, _emberMetalObserver, _emberMetalMixin, _emberMetalBinding, _emberMetalPath_cache, _emberMetalTesting, _emberMetalError_handler, _emberMetalRun_loop, _emberMetalLibraries, _emberMetalIs_none, _emberMetalIs_empty, _emberMetalIs_blank, _emberMetalIs_present, _backburner) { +enifed('ember-metal/index', ['exports', 'require', 'ember-metal/core', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/assign', 'ember-metal/merge', 'ember-metal/debug', 'ember-metal/instrumentation', 'ember-metal/utils', 'ember-metal/testing', 'ember-metal/error_handler', 'ember-metal/meta', 'ember-metal/error', 'ember-metal/cache', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/weak_map', 'ember-metal/events', 'ember-metal/is_none', 'ember-metal/is_empty', 'ember-metal/is_blank', 'ember-metal/is_present', 'ember-metal/run_loop', 'ember-metal/observer_set', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/watch_key', 'ember-metal/chains', 'ember-metal/watch_path', 'ember-metal/watching', 'ember-metal/libraries', 'ember-metal/map', 'ember-metal/get_properties', 'ember-metal/set_properties', 'ember-metal/expand_properties', 'ember-metal/observer', 'ember-metal/mixin', 'ember-metal/binding', 'ember-metal/path_cache', 'ember-metal/symbol', 'ember-metal/dictionary', 'ember-metal/empty_object', 'ember-metal/injected_property', 'ember-metal/tags', 'ember-metal/replace', 'ember-metal/transaction', 'ember-metal/descriptor'], function (exports, _require, _emberMetalCore, _emberMetalComputed, _emberMetalAlias, _emberMetalAssign, _emberMetalMerge, _emberMetalDebug, _emberMetalInstrumentation, _emberMetalUtils, _emberMetalTesting, _emberMetalError_handler, _emberMetalMeta, _emberMetalError, _emberMetalCache, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalWeak_map, _emberMetalEvents, _emberMetalIs_none, _emberMetalIs_empty, _emberMetalIs_blank, _emberMetalIs_present, _emberMetalRun_loop, _emberMetalObserver_set, _emberMetalProperty_events, _emberMetalProperties, _emberMetalWatch_key, _emberMetalChains, _emberMetalWatch_path, _emberMetalWatching, _emberMetalLibraries, _emberMetalMap, _emberMetalGet_properties, _emberMetalSet_properties, _emberMetalExpand_properties, _emberMetalObserver, _emberMetalMixin, _emberMetalBinding, _emberMetalPath_cache, _emberMetalSymbol, _emberMetalDictionary, _emberMetalEmpty_object, _emberMetalInjected_property, _emberMetalTags, _emberMetalReplace, _emberMetalTransaction, _emberMetalDescriptor) { /** @module ember @submodule ember-metal */ - // BEGIN IMPORTS 'use strict'; - _emberMetalComputed.computed.alias = _emberMetalAlias.default; + exports.default = _emberMetalCore.default; + // reexports + exports.computed = _emberMetalComputed.default; + exports.cacheFor = _emberMetalComputed.cacheFor; + exports.ComputedProperty = _emberMetalComputed.ComputedProperty; + exports.alias = _emberMetalAlias.default; + exports.assign = _emberMetalAssign.default; + exports.merge = _emberMetalMerge.default; + exports.assert = _emberMetalDebug.assert; + exports.info = _emberMetalDebug.info; + exports.warn = _emberMetalDebug.warn; + exports.debug = _emberMetalDebug.debug; + exports.deprecate = _emberMetalDebug.deprecate; + exports.deprecateFunc = _emberMetalDebug.deprecateFunc; + exports.runInDebug = _emberMetalDebug.runInDebug; + exports.setDebugFunction = _emberMetalDebug.setDebugFunction; + exports.getDebugFunction = _emberMetalDebug.getDebugFunction; + exports.instrument = _emberMetalInstrumentation.instrument; + exports.flaggedInstrument = _emberMetalInstrumentation.flaggedInstrument; + exports._instrumentStart = _emberMetalInstrumentation._instrumentStart; + exports.instrumentationReset = _emberMetalInstrumentation.reset; + exports.instrumentationSubscribe = _emberMetalInstrumentation.subscribe; + exports.instrumentationUnsubscribe = _emberMetalInstrumentation.unsubscribe; + exports.intern = _emberMetalUtils.intern; + exports.GUID_KEY = _emberMetalUtils.GUID_KEY; + exports.GUID_KEY_PROPERTY = _emberMetalUtils.GUID_KEY_PROPERTY; + exports.applyStr = _emberMetalUtils.applyStr; + exports.canInvoke = _emberMetalUtils.canInvoke; + exports.generateGuid = _emberMetalUtils.generateGuid; + exports.guidFor = _emberMetalUtils.guidFor; + exports.inspect = _emberMetalUtils.inspect; + exports.makeArray = _emberMetalUtils.makeArray; + exports.tryInvoke = _emberMetalUtils.tryInvoke; + exports.uuid = _emberMetalUtils.uuid; + exports.wrap = _emberMetalUtils.wrap; + exports.isTesting = _emberMetalTesting.isTesting; + exports.setTesting = _emberMetalTesting.setTesting; + exports.getOnerror = _emberMetalError_handler.getOnerror; + exports.setOnerror = _emberMetalError_handler.setOnerror; + exports.dispatchError = _emberMetalError_handler.dispatchError; + exports.setDispatchOverride = _emberMetalError_handler.setDispatchOverride; + exports.META_DESC = _emberMetalMeta.META_DESC; + exports.meta = _emberMetalMeta.meta; + exports.peekMeta = _emberMetalMeta.peekMeta; + exports.Error = _emberMetalError.default; + exports.Cache = _emberMetalCache.default; + exports.isFeatureEnabled = _emberMetalFeatures.default; + exports.FEATURES = _emberMetalFeatures.FEATURES; + exports.DEFAULT_FEATURES = _emberMetalFeatures.DEFAULT_FEATURES; + exports._getPath = _emberMetalProperty_get._getPath; + exports.get = _emberMetalProperty_get.get; + exports.getWithDefault = _emberMetalProperty_get.getWithDefault; + exports.set = _emberMetalProperty_set.set; + exports.trySet = _emberMetalProperty_set.trySet; + exports.WeakMap = _emberMetalWeak_map.default; + exports.accumulateListeners = _emberMetalEvents.accumulateListeners; + exports.addListener = _emberMetalEvents.addListener; + exports.hasListeners = _emberMetalEvents.hasListeners; + exports.listenersFor = _emberMetalEvents.listenersFor; + exports.on = _emberMetalEvents.on; + exports.removeListener = _emberMetalEvents.removeListener; + exports.sendEvent = _emberMetalEvents.sendEvent; + exports.suspendListener = _emberMetalEvents.suspendListener; + exports.suspendListeners = _emberMetalEvents.suspendListeners; + exports.watchedEvents = _emberMetalEvents.watchedEvents; + exports.isNone = _emberMetalIs_none.default; + exports.isEmpty = _emberMetalIs_empty.default; + exports.isBlank = _emberMetalIs_blank.default; + exports.isPresent = _emberMetalIs_present.default; + exports.run = _emberMetalRun_loop.default; + exports.ObserverSet = _emberMetalObserver_set.default; + exports.beginPropertyChanges = _emberMetalProperty_events.beginPropertyChanges; + exports.changeProperties = _emberMetalProperty_events.changeProperties; + exports.endPropertyChanges = _emberMetalProperty_events.endPropertyChanges; + exports.overrideChains = _emberMetalProperty_events.overrideChains; + exports.propertyDidChange = _emberMetalProperty_events.propertyDidChange; + exports.propertyWillChange = _emberMetalProperty_events.propertyWillChange; + exports.PROPERTY_DID_CHANGE = _emberMetalProperty_events.PROPERTY_DID_CHANGE; + exports.defineProperty = _emberMetalProperties.defineProperty; + exports.Descriptor = _emberMetalProperties.Descriptor; + exports.watchKey = _emberMetalWatch_key.watchKey; + exports.unwatchKey = _emberMetalWatch_key.unwatchKey; + exports.ChainNode = _emberMetalChains.ChainNode; + exports.finishChains = _emberMetalChains.finishChains; + exports.removeChainWatcher = _emberMetalChains.removeChainWatcher; + exports.watchPath = _emberMetalWatch_path.watchPath; + exports.unwatchPath = _emberMetalWatch_path.unwatchPath; + exports.destroy = _emberMetalWatching.destroy; + exports.isWatching = _emberMetalWatching.isWatching; + exports.rewatch = _emberMetalWatching.rewatch; + exports.unwatch = _emberMetalWatching.unwatch; + exports.watch = _emberMetalWatching.watch; + exports.watcherCount = _emberMetalWatching.watcherCount; + exports.libraries = _emberMetalLibraries.default; + exports.Map = _emberMetalMap.Map; + exports.MapWithDefault = _emberMetalMap.MapWithDefault; + exports.OrderedSet = _emberMetalMap.OrderedSet; + exports.getProperties = _emberMetalGet_properties.default; + exports.setProperties = _emberMetalSet_properties.default; + exports.expandProperties = _emberMetalExpand_properties.default; + exports._suspendObserver = _emberMetalObserver._suspendObserver; + exports._suspendObservers = _emberMetalObserver._suspendObservers; + exports.addObserver = _emberMetalObserver.addObserver; + exports.observersFor = _emberMetalObserver.observersFor; + exports.removeObserver = _emberMetalObserver.removeObserver; + exports._addBeforeObserver = _emberMetalObserver._addBeforeObserver; + exports._removeBeforeObserver = _emberMetalObserver._removeBeforeObserver; + exports.NAME_KEY = _emberMetalMixin.NAME_KEY; + exports.Mixin = _emberMetalMixin.Mixin; + exports.aliasMethod = _emberMetalMixin.aliasMethod; + exports._immediateObserver = _emberMetalMixin._immediateObserver; + exports._beforeObserver = _emberMetalMixin._beforeObserver; + exports.mixin = _emberMetalMixin.mixin; + exports.observer = _emberMetalMixin.observer; + exports.required = _emberMetalMixin.required; + exports.REQUIRED = _emberMetalMixin.REQUIRED; + exports.hasUnprocessedMixins = _emberMetalMixin.hasUnprocessedMixins; + exports.clearUnprocessedMixins = _emberMetalMixin.clearUnprocessedMixins; + exports.detectBinding = _emberMetalMixin.detectBinding; + exports.Binding = _emberMetalBinding.Binding; + exports.bind = _emberMetalBinding.bind; + exports.isGlobalPath = _emberMetalPath_cache.isGlobalPath; + exports.symbol = _emberMetalSymbol.default; + exports.dictionary = _emberMetalDictionary.default; + exports.EmptyObject = _emberMetalEmpty_object.default; + exports.InjectedProperty = _emberMetalInjected_property.default; + exports.setHasViews = _emberMetalTags.setHasViews; + exports.tagFor = _emberMetalTags.tagFor; + exports.markObjectAsDirty = _emberMetalTags.markObjectAsDirty; + exports.replace = _emberMetalReplace.default; + exports.runInTransaction = _emberMetalTransaction.default; + exports.didRender = _emberMetalTransaction.didRender; + exports.assertNotRendered = _emberMetalTransaction.assertNotRendered; + exports.descriptor = _emberMetalDescriptor.default; - // END IMPORTS - - // BEGIN EXPORTS - var EmberInstrumentation = _emberMetalCore.default.Instrumentation = {}; - EmberInstrumentation.instrument = _emberMetalInstrumentation.instrument; - EmberInstrumentation.subscribe = _emberMetalInstrumentation.subscribe; - EmberInstrumentation.unsubscribe = _emberMetalInstrumentation.unsubscribe; - EmberInstrumentation.reset = _emberMetalInstrumentation.reset; - - _emberMetalCore.default.instrument = _emberMetalInstrumentation.instrument; - _emberMetalCore.default.subscribe = _emberMetalInstrumentation.subscribe; - - _emberMetalCore.default._Cache = _emberMetalCache.default; - - _emberMetalCore.default.generateGuid = _emberMetalUtils.generateGuid; - _emberMetalCore.default.GUID_KEY = _emberMetalUtils.GUID_KEY; - _emberMetalCore.default.NAME_KEY = _emberMetalMixin.NAME_KEY; - _emberMetalCore.default.platform = { - defineProperty: true, - hasPropertyAccessors: true - }; - - _emberMetalCore.default.Error = _emberMetalError.default; - _emberMetalCore.default.guidFor = _emberMetalUtils.guidFor; - _emberMetalCore.default.META_DESC = _emberMetalMeta.META_DESC; - _emberMetalCore.default.meta = _emberMetalMeta.meta; - _emberMetalCore.default.inspect = _emberMetalUtils.inspect; - - _emberMetalCore.default.tryCatchFinally = _emberMetalUtils.deprecatedTryCatchFinally; - _emberMetalCore.default.makeArray = _emberMetalUtils.makeArray; - _emberMetalCore.default.canInvoke = _emberMetalUtils.canInvoke; - _emberMetalCore.default.tryInvoke = _emberMetalUtils.tryInvoke; - _emberMetalCore.default.wrap = _emberMetalUtils.wrap; - _emberMetalCore.default.apply = _emberMetalUtils.apply; - _emberMetalCore.default.applyStr = _emberMetalUtils.applyStr; - _emberMetalCore.default.uuid = _emberMetalUtils.uuid; - - _emberMetalCore.default.Logger = _emberConsole.default; - - _emberMetalCore.default.get = _emberMetalProperty_get.get; - _emberMetalCore.default.getWithDefault = _emberMetalProperty_get.getWithDefault; - _emberMetalCore.default._getPath = _emberMetalProperty_get._getPath; - - _emberMetalCore.default.on = _emberMetalEvents.on; - _emberMetalCore.default.addListener = _emberMetalEvents.addListener; - _emberMetalCore.default.removeListener = _emberMetalEvents.removeListener; - _emberMetalCore.default._suspendListener = _emberMetalEvents.suspendListener; - _emberMetalCore.default._suspendListeners = _emberMetalEvents.suspendListeners; - _emberMetalCore.default.sendEvent = _emberMetalEvents.sendEvent; - _emberMetalCore.default.hasListeners = _emberMetalEvents.hasListeners; - _emberMetalCore.default.watchedEvents = _emberMetalEvents.watchedEvents; - _emberMetalCore.default.listenersFor = _emberMetalEvents.listenersFor; - _emberMetalCore.default.accumulateListeners = _emberMetalEvents.accumulateListeners; - - _emberMetalCore.default._ObserverSet = _emberMetalObserver_set.default; - - _emberMetalCore.default.propertyWillChange = _emberMetalProperty_events.propertyWillChange; - _emberMetalCore.default.propertyDidChange = _emberMetalProperty_events.propertyDidChange; - _emberMetalCore.default.overrideChains = _emberMetalProperty_events.overrideChains; - _emberMetalCore.default.beginPropertyChanges = _emberMetalProperty_events.beginPropertyChanges; - _emberMetalCore.default.endPropertyChanges = _emberMetalProperty_events.endPropertyChanges; - _emberMetalCore.default.changeProperties = _emberMetalProperty_events.changeProperties; - - _emberMetalCore.default.defineProperty = _emberMetalProperties.defineProperty; - - _emberMetalCore.default.set = _emberMetalProperty_set.set; - _emberMetalCore.default.trySet = _emberMetalProperty_set.trySet; - - if (false) { - _emberMetalCore.default.WeakMap = _emberMetalWeak_map.default; - } - _emberMetalCore.default.OrderedSet = _emberMetalMap.OrderedSet; - _emberMetalCore.default.Map = _emberMetalMap.Map; - _emberMetalCore.default.MapWithDefault = _emberMetalMap.MapWithDefault; - - _emberMetalCore.default.getProperties = _emberMetalGet_properties.default; - _emberMetalCore.default.setProperties = _emberMetalSet_properties.default; - - _emberMetalCore.default.watchKey = _emberMetalWatch_key.watchKey; - _emberMetalCore.default.unwatchKey = _emberMetalWatch_key.unwatchKey; - - _emberMetalCore.default.removeChainWatcher = _emberMetalChains.removeChainWatcher; - _emberMetalCore.default._ChainNode = _emberMetalChains.ChainNode; - _emberMetalCore.default.finishChains = _emberMetalChains.finishChains; - - _emberMetalCore.default.watchPath = _emberMetalWatch_path.watchPath; - _emberMetalCore.default.unwatchPath = _emberMetalWatch_path.unwatchPath; - - _emberMetalCore.default.watch = _emberMetalWatching.watch; - _emberMetalCore.default.isWatching = _emberMetalWatching.isWatching; - _emberMetalCore.default.unwatch = _emberMetalWatching.unwatch; - _emberMetalCore.default.rewatch = _emberMetalWatching.rewatch; - _emberMetalCore.default.destroy = _emberMetalWatching.destroy; - - _emberMetalCore.default.expandProperties = _emberMetalExpand_properties.default; - - _emberMetalCore.default.ComputedProperty = _emberMetalComputed.ComputedProperty; - _emberMetalCore.default.computed = _emberMetalComputed.computed; - _emberMetalCore.default.cacheFor = _emberMetalComputed.cacheFor; - - _emberMetalCore.default.addObserver = _emberMetalObserver.addObserver; - _emberMetalCore.default.observersFor = _emberMetalObserver.observersFor; - _emberMetalCore.default.removeObserver = _emberMetalObserver.removeObserver; - _emberMetalCore.default._suspendObserver = _emberMetalObserver._suspendObserver; - _emberMetalCore.default._suspendObservers = _emberMetalObserver._suspendObservers; - - _emberMetalCore.default.required = _emberMetalMixin.required; - _emberMetalCore.default.aliasMethod = _emberMetalMixin.aliasMethod; - _emberMetalCore.default.observer = _emberMetalMixin.observer; - _emberMetalCore.default.immediateObserver = _emberMetalMixin._immediateObserver; - _emberMetalCore.default.mixin = _emberMetalMixin.mixin; - _emberMetalCore.default.Mixin = _emberMetalMixin.Mixin; - - _emberMetalCore.default.bind = _emberMetalBinding.bind; - _emberMetalCore.default.Binding = _emberMetalBinding.Binding; - _emberMetalCore.default.isGlobalPath = _emberMetalPath_cache.isGlobalPath; - - _emberMetalCore.default.run = _emberMetalRun_loop.default; - - /** - @class Backburner - @for Ember - @private - */ - _emberMetalCore.default.Backburner = function () { - _emberMetalDebug.deprecate('Usage of Ember.Backburner is deprecated.', false, { - id: 'ember-metal.ember-backburner', - until: '2.8.0', - url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-backburner' - }); - - function BackburnerAlias(args) { - return _backburner.default.apply(this, args); - } - - BackburnerAlias.prototype = _backburner.default.prototype; - - return new BackburnerAlias(arguments); - }; - - _emberMetalCore.default._Backburner = _backburner.default; - - /** - The semantic version - @property VERSION - @type String - @public - */ - _emberMetalCore.default.VERSION = _emberVersion.default; - - _emberMetalCore.default.libraries = _emberMetalLibraries.default; - - _emberMetalLibraries.default.registerCoreLibrary('Ember', _emberMetalCore.default.VERSION); - - _emberMetalCore.default.isNone = _emberMetalIs_none.default; - _emberMetalCore.default.isEmpty = _emberMetalIs_empty.default; - _emberMetalCore.default.isBlank = _emberMetalIs_blank.default; - _emberMetalCore.default.isPresent = _emberMetalIs_present.default; - - _emberMetalCore.default.assign = Object.assign || _emberMetalAssign.default; - _emberMetalCore.default.merge = _emberMetalMerge.default; - - _emberMetalCore.default.FEATURES = _emberMetalFeatures.FEATURES; - _emberMetalCore.default.FEATURES.isEnabled = _emberMetalFeatures.default; - - _emberMetalCore.default.EXTEND_PROTOTYPES = _emberEnvironment.ENV.EXTEND_PROTOTYPES; - - // BACKWARDS COMPAT ACCESSORS FOR ENV FLAGS - Object.defineProperty(_emberMetalCore.default, 'LOG_STACKTRACE_ON_DEPRECATION', { - get: function () { - return _emberEnvironment.ENV.LOG_STACKTRACE_ON_DEPRECATION; - }, - set: function (value) { - _emberEnvironment.ENV.LOG_STACKTRACE_ON_DEPRECATION = !!value; - }, - enumerable: false - }); - - Object.defineProperty(_emberMetalCore.default, 'LOG_VERSION', { - get: function () { - return _emberEnvironment.ENV.LOG_VERSION; - }, - set: function (value) { - _emberEnvironment.ENV.LOG_VERSION = !!value; - }, - enumerable: false - }); - - Object.defineProperty(_emberMetalCore.default, 'MODEL_FACTORY_INJECTIONS', { - get: function () { - return _emberEnvironment.ENV.MODEL_FACTORY_INJECTIONS; - }, - set: function (value) { - _emberEnvironment.ENV.MODEL_FACTORY_INJECTIONS = !!value; - }, - enumerable: false - }); - - Object.defineProperty(_emberMetalCore.default, 'LOG_BINDINGS', { - get: function () { - return _emberEnvironment.ENV.LOG_BINDINGS; - }, - set: function (value) { - _emberEnvironment.ENV.LOG_BINDINGS = !!value; - }, - enumerable: false - }); - - Object.defineProperty(_emberMetalCore.default, 'ENV', { - get: function () { - return _emberEnvironment.ENV; - }, - enumerable: false - }); - - /** - The context that Ember searches for namespace instances on. - - @private - */ - Object.defineProperty(_emberMetalCore.default, 'lookup', { - get: function () { - return _emberEnvironment.context.lookup; - }, - set: function (value) { - _emberEnvironment.context.lookup = value; - }, - enumerable: false - }); - - Object.defineProperty(_emberMetalCore.default, 'testing', { - get: _emberMetalTesting.isTesting, - set: _emberMetalTesting.setTesting, - enumerable: false - }); - - /** - A function may be assigned to `Ember.onerror` to be called when Ember - internals encounter an error. This is useful for specialized error handling - and reporting code. - - ```javascript - Ember.onerror = function(error) { - Em.$.ajax('/report-error', 'POST', { - stack: error.stack, - otherInformation: 'whatever app state you want to provide' - }); - }; - ``` - - Internally, `Ember.onerror` is used as Backburner's error handler. - - @event onerror - @for Ember - @param {Exception} error the error object - @public - */ - Object.defineProperty(_emberMetalCore.default, 'onerror', { - get: _emberMetalError_handler.getOnerror, - set: _emberMetalError_handler.setOnerror, - enumerable: false - }); - - /** - An empty function useful for some operations. Always returns `this`. - - @method K - @return {Object} - @public - */ - _emberMetalCore.default.K = function K() { - return this; - }; - - // The debug functions are exported to globals with `require` to - // prevent babel-plugin-filter-imports from removing them. - var debugModule = _require.default('ember-metal/debug'); - _emberMetalCore.default.assert = debugModule.assert; - _emberMetalCore.default.warn = debugModule.warn; - _emberMetalCore.default.debug = debugModule.debug; - _emberMetalCore.default.deprecate = debugModule.deprecate; - _emberMetalCore.default.deprecateFunc = debugModule.deprecateFunc; - _emberMetalCore.default.runInDebug = debugModule.runInDebug; - // END EXPORTS - + // TODO: this needs to be deleted once we refactor the build tooling // do this for side-effects of updating Ember.assert, warn, etc when // ember-debug is present // This needs to be called before any deprecateFunc + if (_require.has('ember-debug')) { _require.default('ember-debug'); - } else { - _emberMetalCore.default.Debug = {}; - _emberMetalCore.default.Debug.registerDeprecationHandler = function () {}; - _emberMetalCore.default.Debug.registerWarnHandler = function () {}; } - - _emberMetalCore.default.create = _emberMetalDebug.deprecateFunc('Ember.create is deprecated in favor of Object.create', { id: 'ember-metal.ember-create', until: '3.0.0' }, Object.create); - _emberMetalCore.default.keys = _emberMetalDebug.deprecateFunc('Ember.keys is deprecated in favor of Object.keys', { id: 'ember-metal.ember.keys', until: '3.0.0' }, Object.keys); - - /* globals module */ - if (typeof module === 'object' && module.exports) { - module.exports = _emberMetalCore.default; - } else { - _emberEnvironment.context.exports.Ember = _emberEnvironment.context.exports.Em = _emberMetalCore.default; - } - - exports.default = _emberMetalCore.default; }); -// reexports -enifed('ember-metal/injected_property', ['exports', 'ember-metal/debug', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/properties', 'container/owner'], function (exports, _emberMetalDebug, _emberMetalComputed, _emberMetalAlias, _emberMetalProperties, _containerOwner) { +enifed('ember-metal/injected_property', ['exports', 'ember-metal/debug', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/properties', 'container'], function (exports, _emberMetalDebug, _emberMetalComputed, _emberMetalAlias, _emberMetalProperties, _container) { 'use strict'; exports.default = InjectedProperty; /** @@ -5280,11 +6118,11 @@ AliasedPropertyPrototype.oneWay.call(this); } function injectedPropertyGet(keyName) { var desc = this[keyName]; - var owner = _containerOwner.getOwner(this) || this.container; // fallback to `container` for backwards compat + var owner = _container.getOwner(this) || this.container; // fallback to `container` for backwards compat _emberMetalDebug.assert('InjectedProperties should be defined with the Ember.inject computed property macros.', desc && desc.isDescriptor && desc.type); _emberMetalDebug.assert('Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.', owner); return owner.lookup(desc.type + ':' + (desc.name || keyName)); @@ -5441,24 +6279,30 @@ finalizer(); return result; } } + function NOOP() {} + // private for now - function _instrumentStart(name, _payload) { + function _instrumentStart(name, _payload, _payloadParam) { + if (subscribers.length === 0) { + return NOOP; + } + var listeners = cache[name]; if (!listeners) { listeners = populateListeners(name); } if (listeners.length === 0) { - return; + return NOOP; } - var payload = _payload(); + var payload = _payload(_payloadParam); var STRUCTURED_PROFILE = _emberEnvironment.ENV.STRUCTURED_PROFILE; var timeName = undefined; if (STRUCTURED_PROFILE) { timeName = name + ': ' + payload.object; @@ -7351,26 +8195,26 @@ /** The `Ember.Mixin` class allows you to create mixins, whose properties can be added to other classes. For instance, ```javascript - App.Editable = Ember.Mixin.create({ - edit: function() { + const EditableMixin = Ember.Mixin.create({ + edit() { console.log('starting to edit'); this.set('isEditing', true); }, isEditing: false }); // Mix mixins into classes by passing them as the first arguments to - // .extend. - App.CommentView = Ember.View.extend(App.Editable, { - template: Ember.Handlebars.compile('{{#if view.isEditing}}...{{else}}...{{/if}}') + // `.extend.` + const Comment = Ember.Object.extend(EditableMixin, { + post: null }); - commentView = App.CommentView.create(); - commentView.edit(); // outputs 'starting to edit' + let comment = Comment.create(post: somePost); + comment.edit(); // outputs 'starting to edit' ``` Note that Mixins are created with `Ember.Mixin.create`, not `Ember.Mixin.extend`. @@ -7378,23 +8222,25 @@ defined as properties will be shared amongst objects that implement the mixin. If you want to define a property in a mixin that is not shared, you can define it either as a computed property or have it be created on initialization of the object. ```javascript - //filters array will be shared amongst any object implementing mixin - App.Filterable = Ember.Mixin.create({ + // filters array will be shared amongst any object implementing mixin + const FilterableMixin = Ember.Mixin.create({ filters: Ember.A() }); - //filters will be a separate array for every object implementing the mixin - App.Filterable = Ember.Mixin.create({ - filters: Ember.computed(function() {return Ember.A();}) + // filters will be a separate array for every object implementing the mixin + const FilterableMixin = Ember.Mixin.create({ + filters: Ember.computed(function() { + return Ember.A(); + }) }); - //filters will be created as a separate array during the object's initialization - App.Filterable = Ember.Mixin.create({ - init: function() { + // filters will be created as a separate array during the object's initialization + const Filterable = Ember.Mixin.create({ + init() { this._super(...arguments); this.set("filters", Ember.A()); } }); ``` @@ -7777,34 +8623,10 @@ Note, `@each.property` observer is called per each add or replace of an element and it's not called with a specific enumeration item. A `_beforeObserver` fires before a property changes. - A `_beforeObserver` is an alternative form of `.observesBefore()`. - - ```javascript - App.PersonView = Ember.View.extend({ - friends: [{ name: 'Tom' }, { name: 'Stefan' }, { name: 'Kris' }], - - valueDidChange: Ember.observer('content.value', function(obj, keyName) { - // only run if updating a value already in the DOM - if (this.get('state') === 'inDOM') { - let color = obj.get(keyName) > this.changingFrom ? 'green' : 'red'; - // logic - } - }), - - friendsDidChange: Ember.observer('friends.@each.name', function(obj, keyName) { - // some logic - // obj.get(keyName) returns friends array - }) - }); - ``` - - Also available as `Function.prototype.observesBefore` if prototype extensions are - enabled. - @method beforeObserver @for Ember @param {String} propertyNames* @param {Function} func @return func @@ -7838,11 +8660,11 @@ for (var i = 0; i < _paths.length; ++i) { _emberMetalExpand_properties.default(_paths[i], addWatchedProperty); } if (typeof func !== 'function') { - throw new _emberMetalError.default('Ember.beforeObserver called without a function'); + throw new _emberMetalError.default('_beforeObserver called without a function'); } func.__ember_observesBefore__ = paths; return func; } @@ -9681,10 +10503,11 @@ exports.setHasViews = setHasViews; exports.tagFor = tagFor; var hasGlimmer = _require2.has('glimmer-reference'); + var CONSTANT_TAG = undefined, CURRENT_TAG = undefined, DirtyableTag = undefined, makeTag = undefined, run = undefined; @@ -9735,13 +10558,16 @@ makeTag = function () { return new DirtyableTag(); }; exports.markObjectAsDirty = markObjectAsDirty = function (meta) { - ensureRunloop(); - var tag = meta && meta.readableTag() || CURRENT_TAG; - tag.dirty(); + var tag = meta && meta.readableTag(); + + if (tag) { + ensureRunloop(); + tag.dirty(); + } }; } else { exports.markObjectAsDirty = markObjectAsDirty = function () {}; } }); @@ -9765,14 +10591,10 @@ var runInTransaction = undefined, didRender = undefined, assertNotRendered = undefined; - if (true || false) { - _emberMetalDebug.assert('It appears you are trying to use the backtracking rerender feature without the "ember-glimmer" flag turned on. Please make sure that "ember-glimmer" is turned on.', true); - } - var raise = _emberMetalDebug.assert; if (false) { raise = function (message, test) { _emberMetalDebug.deprecate(message, test, { id: 'ember-views.render-double-modify', until: '3.0.0' }); }; @@ -9789,14 +10611,14 @@ (function () { var counter = 0; var inTransaction = false; var shouldReflush = undefined; - exports.default = runInTransaction = function (callback) { + exports.default = runInTransaction = function (context, methodName) { shouldReflush = false; inTransaction = true; - callback(); + context[methodName](); inTransaction = false; counter++; return shouldReflush; }; @@ -9825,11 +10647,11 @@ var lastRef = ref[key]; var label = undefined; if (lastRef) { - while (lastRef && lastRef._propertyKey && lastRef._parentReference) { + while (lastRef && lastRef._propertyKey) { parts.unshift(lastRef._propertyKey); lastRef = lastRef._parentReference; } label = parts.join(); @@ -10814,110 +11636,63 @@ */ WeakMap.prototype.toString = function () { return '[object WeakMap]'; }; }); -enifed('ember-template-compiler/compat', ['exports', 'ember-metal/core', 'ember-template-compiler/compiler'], function (exports, _emberMetalCore, _emberTemplateCompilerCompiler) { +enifed('ember-template-compiler/compat', ['exports', 'ember-metal', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/compile-options'], function (exports, _emberMetal, _emberTemplateCompilerSystemPrecompile, _emberTemplateCompilerSystemCompile, _emberTemplateCompilerSystemCompileOptions) { 'use strict'; - var EmberHandlebars = _emberMetalCore.default.Handlebars = _emberMetalCore.default.Handlebars || {}; - var EmberHTMLBars = _emberMetalCore.default.HTMLBars = _emberMetalCore.default.HTMLBars || {}; + var EmberHandlebars = _emberMetal.default.Handlebars = _emberMetal.default.Handlebars || {}; + var EmberHTMLBars = _emberMetal.default.HTMLBars = _emberMetal.default.HTMLBars || {}; - var _compiler = _emberTemplateCompilerCompiler.default(); - - var precompile = _compiler.precompile; - var compile = _compiler.compile; - var registerPlugin = _compiler.registerPlugin; - - EmberHTMLBars.precompile = EmberHandlebars.precompile = precompile; - EmberHTMLBars.compile = EmberHandlebars.compile = compile; - EmberHTMLBars.registerPlugin = registerPlugin; + EmberHTMLBars.precompile = EmberHandlebars.precompile = _emberTemplateCompilerSystemPrecompile.default; + EmberHTMLBars.compile = EmberHandlebars.compile = _emberTemplateCompilerSystemCompile.default; + EmberHTMLBars.registerPlugin = _emberTemplateCompilerSystemCompileOptions.registerPlugin; }); // reexports -enifed('ember-template-compiler/compat/precompile', ['exports', 'require', 'ember-metal/features'], function (exports, _require, _emberMetalFeatures) { - /** - @module ember - @submodule ember-template-compiler - */ +enifed('ember-template-compiler/index', ['exports', 'container', 'ember-metal', 'ember-environment', 'ember/version', 'ember-template-compiler/compat', 'ember-template-compiler/system/bootstrap', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/compile-options', 'ember-template-compiler/plugins'], function (exports, _container, _emberMetal, _emberEnvironment, _emberVersion, _emberTemplateCompilerCompat, _emberTemplateCompilerSystemBootstrap, _emberTemplateCompilerSystemPrecompile, _emberTemplateCompilerSystemCompile, _emberTemplateCompilerSystemCompileOptions, _emberTemplateCompilerPlugins) { 'use strict'; - var compile = undefined, - compileSpec = undefined, - compileOptions = undefined; - - // Note we don't really want to expose this from main file - if (true) { - compileOptions = _require.default('ember-glimmer-template-compiler/system/compile-options').default; - } else { - compileOptions = _require.default('ember-htmlbars-template-compiler/system/compile-options').default; + // private API used by ember-cli-htmlbars to setup ENV and FEATURES + if (!_emberMetal.default.ENV) { + _emberMetal.default.ENV = _emberEnvironment.ENV; } - - exports.default = function (string) { - if ((!compile || !compileSpec) && _require.has('htmlbars-compiler/compiler')) { - var Compiler = _require.default('htmlbars-compiler/compiler'); - - compile = Compiler.compile; - compileSpec = Compiler.compileSpec; - } - - if (!compile || !compileSpec) { - throw new Error('Cannot call `precompile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `precompile`.'); - } - - var asObject = arguments[1] === undefined ? true : arguments[1]; - var compileFunc = asObject ? compile : compileSpec; - - return compileFunc(string, compileOptions()); - }; -}); -enifed('ember-template-compiler/compiler', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - exports.default = pickCompiler; - - function pickCompiler() { - var compiler = undefined; - if (true) { - compiler = _require.default('ember-glimmer-template-compiler'); - } else { - compiler = _require.default('ember-htmlbars-template-compiler'); - } - - return compiler; + if (!_emberMetal.default.FEATURES) { + _emberMetal.default.FEATURES = _emberMetal.FEATURES; } -}); -enifed('ember-template-compiler/index', ['exports', 'ember-template-compiler/compat', 'ember-template-compiler/system/bootstrap', 'ember-metal', 'ember-template-compiler/system/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/register-plugin', 'ember-template-compiler/system/compile-options'], function (exports, _emberTemplateCompilerCompat, _emberTemplateCompilerSystemBootstrap, _emberMetal, _emberTemplateCompilerSystemPrecompile, _emberTemplateCompilerSystemCompile, _emberTemplateCompilerSystemRegisterPlugin, _emberTemplateCompilerSystemCompileOptions) { - 'use strict'; + if (!_emberMetal.default.VERSION) { + _emberMetal.default.VERSION = _emberVersion.default; + } exports._Ember = _emberMetal.default; - // Is this still needed exports.precompile = _emberTemplateCompilerSystemPrecompile.default; exports.compile = _emberTemplateCompilerSystemCompile.default; - exports.registerPlugin = _emberTemplateCompilerSystemRegisterPlugin.default; - exports.defaultCompileOptions = _emberTemplateCompilerSystemCompileOptions.default; + exports.compileOptions = _emberTemplateCompilerSystemCompileOptions.default; + exports.registerPlugin = _emberTemplateCompilerSystemCompileOptions.registerPlugin; + exports.defaultPlugins = _emberTemplateCompilerPlugins.default; // used for adding Ember.Handlebars.compile for backwards compat }); // used to bootstrap templates -enifed('ember-template-compiler/plugins/assert-reserved-named-arguments', ['exports', 'ember-metal/debug', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetalDebug, _emberTemplateCompilerSystemCalculateLocationDisplay) { +enifed('ember-template-compiler/plugins/assert-reserved-named-arguments', ['exports', 'ember-metal', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetal, _emberTemplateCompilerSystemCalculateLocationDisplay) { 'use strict'; exports.default = AssertReservedNamedArguments; function AssertReservedNamedArguments(options) { this.syntax = null; this.options = options; } AssertReservedNamedArguments.prototype.transform = function AssertReservedNamedArguments_transform(ast) { - var moduleName = this.options.moduleName; + var moduleName = this.options.meta.moduleName; this.syntax.traverse(ast, { PathExpression: function (node) { if (node.original[0] === '@') { - _emberMetalDebug.assert(assertMessage(moduleName, node)); + _emberMetal.assert(assertMessage(moduleName, node)); } } }); return ast; @@ -10928,22 +11703,22 @@ var source = _emberTemplateCompilerSystemCalculateLocationDisplay.default(moduleName, node.loc); return '\'' + path + '\' is not a valid path. ' + source; } }); -enifed('ember-template-compiler/plugins/deprecate-render-model', ['exports', 'ember-metal/debug', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetalDebug, _emberTemplateCompilerSystemCalculateLocationDisplay) { +enifed('ember-template-compiler/plugins/deprecate-render-model', ['exports', 'ember-metal', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetal, _emberTemplateCompilerSystemCalculateLocationDisplay) { 'use strict'; exports.default = DeprecateRenderModel; function DeprecateRenderModel(options) { this.syntax = null; this.options = options; } DeprecateRenderModel.prototype.transform = function DeprecateRenderModel_transform(ast) { - var moduleName = this.options.moduleName; + var moduleName = this.options.meta.moduleName; var walker = new this.syntax.Walker(); walker.visit(ast, function (node) { if (!validate(node)) { return; @@ -10952,11 +11727,11 @@ each(node.params, function (param) { if (param.type !== 'PathExpression') { return; } - _emberMetalDebug.deprecate(deprecationMessage(moduleName, node, param), false, { + _emberMetal.deprecate(deprecationMessage(moduleName, node, param), false, { id: 'ember-template-compiler.deprecate-render-model', until: '3.0.0', url: 'http://emberjs.com/deprecations/v2.x#toc_model-param-in-code-render-code-helper' }); }); @@ -10983,15 +11758,90 @@ var preferred = '{{' + componentName + ' model=' + modelName + '}}'; return 'Please refactor `' + original + '` to a component and invoke via' + (' `' + preferred + '`. ' + sourceInformation); } }); -enifed('ember-template-compiler/plugins/index', ['exports', 'ember-template-compiler/plugins/transform-old-binding-syntax', 'ember-template-compiler/plugins/transform-item-class', 'ember-template-compiler/plugins/transform-angle-bracket-components', 'ember-template-compiler/plugins/transform-input-on-to-onEvent', 'ember-template-compiler/plugins/transform-top-level-components', 'ember-template-compiler/plugins/transform-inline-link-to', 'ember-template-compiler/plugins/transform-old-class-binding-syntax', 'ember-template-compiler/plugins/deprecate-render-model', 'ember-template-compiler/plugins/assert-reserved-named-arguments'], function (exports, _emberTemplateCompilerPluginsTransformOldBindingSyntax, _emberTemplateCompilerPluginsTransformItemClass, _emberTemplateCompilerPluginsTransformAngleBracketComponents, _emberTemplateCompilerPluginsTransformInputOnToOnEvent, _emberTemplateCompilerPluginsTransformTopLevelComponents, _emberTemplateCompilerPluginsTransformInlineLinkTo, _emberTemplateCompilerPluginsTransformOldClassBindingSyntax, _emberTemplateCompilerPluginsDeprecateRenderModel, _emberTemplateCompilerPluginsAssertReservedNamedArguments) { +enifed('ember-template-compiler/plugins/index', ['exports', 'ember-template-compiler/plugins/transform-old-binding-syntax', 'ember-template-compiler/plugins/transform-item-class', 'ember-template-compiler/plugins/transform-angle-bracket-components', 'ember-template-compiler/plugins/transform-input-on-to-onEvent', 'ember-template-compiler/plugins/transform-top-level-components', 'ember-template-compiler/plugins/transform-inline-link-to', 'ember-template-compiler/plugins/transform-old-class-binding-syntax', 'ember-template-compiler/plugins/deprecate-render-model', 'ember-template-compiler/plugins/assert-reserved-named-arguments', 'ember-template-compiler/plugins/transform-action-syntax', 'ember-template-compiler/plugins/transform-input-type-syntax', 'ember-template-compiler/plugins/transform-attrs-into-args', 'ember-template-compiler/plugins/transform-each-in-into-each', 'ember-template-compiler/plugins/transform-has-block-syntax'], function (exports, _emberTemplateCompilerPluginsTransformOldBindingSyntax, _emberTemplateCompilerPluginsTransformItemClass, _emberTemplateCompilerPluginsTransformAngleBracketComponents, _emberTemplateCompilerPluginsTransformInputOnToOnEvent, _emberTemplateCompilerPluginsTransformTopLevelComponents, _emberTemplateCompilerPluginsTransformInlineLinkTo, _emberTemplateCompilerPluginsTransformOldClassBindingSyntax, _emberTemplateCompilerPluginsDeprecateRenderModel, _emberTemplateCompilerPluginsAssertReservedNamedArguments, _emberTemplateCompilerPluginsTransformActionSyntax, _emberTemplateCompilerPluginsTransformInputTypeSyntax, _emberTemplateCompilerPluginsTransformAttrsIntoArgs, _emberTemplateCompilerPluginsTransformEachInIntoEach, _emberTemplateCompilerPluginsTransformHasBlockSyntax) { 'use strict'; - exports.default = Object.freeze([_emberTemplateCompilerPluginsTransformOldBindingSyntax.default, _emberTemplateCompilerPluginsTransformItemClass.default, _emberTemplateCompilerPluginsTransformAngleBracketComponents.default, _emberTemplateCompilerPluginsTransformInputOnToOnEvent.default, _emberTemplateCompilerPluginsTransformTopLevelComponents.default, _emberTemplateCompilerPluginsTransformInlineLinkTo.default, _emberTemplateCompilerPluginsTransformOldClassBindingSyntax.default, _emberTemplateCompilerPluginsDeprecateRenderModel.default, _emberTemplateCompilerPluginsAssertReservedNamedArguments.default]); + exports.default = Object.freeze([_emberTemplateCompilerPluginsTransformOldBindingSyntax.default, _emberTemplateCompilerPluginsTransformItemClass.default, _emberTemplateCompilerPluginsTransformAngleBracketComponents.default, _emberTemplateCompilerPluginsTransformInputOnToOnEvent.default, _emberTemplateCompilerPluginsTransformTopLevelComponents.default, _emberTemplateCompilerPluginsTransformInlineLinkTo.default, _emberTemplateCompilerPluginsTransformOldClassBindingSyntax.default, _emberTemplateCompilerPluginsDeprecateRenderModel.default, _emberTemplateCompilerPluginsAssertReservedNamedArguments.default, _emberTemplateCompilerPluginsTransformActionSyntax.default, _emberTemplateCompilerPluginsTransformInputTypeSyntax.default, _emberTemplateCompilerPluginsTransformAttrsIntoArgs.default, _emberTemplateCompilerPluginsTransformEachInIntoEach.default, _emberTemplateCompilerPluginsTransformHasBlockSyntax.default]); }); +enifed('ember-template-compiler/plugins/transform-action-syntax', ['exports'], function (exports) { + /** + @module ember + @submodule ember-glimmer + */ + + /** + A Glimmer2 AST transformation that replaces all instances of + + ```handlebars + <button {{action 'foo'}}> + <button onblur={{action 'foo'}}> + <button onblur={{action (action 'foo') 'bar'}}> + ``` + + with + + ```handlebars + <button {{action this 'foo'}}> + <button onblur={{action this 'foo'}}> + <button onblur={{action this (action this 'foo') 'bar'}}> + ``` + + @private + @class TransformActionSyntax + */ + + 'use strict'; + + exports.default = TransformActionSyntax; + + function TransformActionSyntax() { + // set later within Glimmer2 to the syntax package + this.syntax = null; + } + + /** + @private + @method transform + @param {AST} ast The AST to be transformed. + */ + TransformActionSyntax.prototype.transform = function TransformActionSyntax_transform(ast) { + var _syntax = this.syntax; + var traverse = _syntax.traverse; + var b = _syntax.builders; + + traverse(ast, { + ElementModifierStatement: function (node) { + if (isAction(node)) { + insertThisAsFirstParam(node, b); + } + }, + MustacheStatement: function (node) { + if (isAction(node)) { + insertThisAsFirstParam(node, b); + } + }, + SubExpression: function (node) { + if (isAction(node)) { + insertThisAsFirstParam(node, b); + } + } + }); + + return ast; + }; + + function isAction(node) { + return node.path.original === 'action'; + } + + function insertThisAsFirstParam(node, builders) { + node.params.unshift(builders.path('')); + } +}); enifed('ember-template-compiler/plugins/transform-angle-bracket-components', ['exports'], function (exports) { 'use strict'; exports.default = TransformAngleBracketComponents; @@ -11021,10 +11871,190 @@ function validate(node) { return node.type === 'ComponentNode'; } }); +enifed('ember-template-compiler/plugins/transform-attrs-into-args', ['exports'], function (exports) { + /** + @module ember + @submodule ember-glimmer + */ + + /** + A Glimmer2 AST transformation that replaces all instances of + + ```handlebars + {{attrs.foo.bar}} + ``` + + to + + ```handlebars + {{@foo.bar}} + ``` + + as well as `{{#if attrs.foo}}`, `{{deeply (nested attrs.foobar.baz)}}` etc + + @private + @class TransformAttrsToProps + */ + + 'use strict'; + + exports.default = TransformAttrsToProps; + + function TransformAttrsToProps() { + // set later within Glimmer2 to the syntax package + this.syntax = null; + } + + /** + @private + @method transform + @param {AST} ast The AST to be transformed. + */ + TransformAttrsToProps.prototype.transform = function TransformAttrsToProps_transform(ast) { + var _syntax = this.syntax; + var traverse = _syntax.traverse; + var b = _syntax.builders; + + traverse(ast, { + PathExpression: function (node) { + if (node.parts[0] === 'attrs') { + var path = b.path(node.original.substr(6)); + path.original = '@' + path.original; + path.data = true; + return path; + } + } + }); + + return ast; + }; +}); +enifed('ember-template-compiler/plugins/transform-each-in-into-each', ['exports'], function (exports) { + /** + @module ember + @submodule ember-glimmer + */ + + /** + A Glimmer2 AST transformation that replaces all instances of + + ```handlebars + {{#each-in iterableThing as |key value|}} + ``` + + with + + ```handlebars + {{#each (-each-in iterableThing) as |key value|}} + ``` + + @private + @class TransformHasBlockSyntax + */ + + 'use strict'; + + exports.default = TransformEachInIntoEach; + + function TransformEachInIntoEach() { + // set later within Glimmer2 to the syntax package + this.syntax = null; + } + + /** + @private + @method transform + @param {AST} ast The AST to be transformed. + */ + TransformEachInIntoEach.prototype.transform = function TransformEachInIntoEach_transform(ast) { + var _syntax = this.syntax; + var traverse = _syntax.traverse; + var b = _syntax.builders; + + traverse(ast, { + BlockStatement: function (node) { + if (node.path.original === 'each-in') { + node.params[0] = b.sexpr(b.path('-each-in'), [node.params[0]]); + return b.block(b.path('each'), node.params, node.hash, node.program, node.inverse, node.loc); + } + } + }); + + return ast; + }; +}); +enifed('ember-template-compiler/plugins/transform-has-block-syntax', ['exports'], function (exports) { + /** + @module ember + @submodule ember-glimmer + */ + + /** + A Glimmer2 AST transformation that replaces all instances of + + ```handlebars + {{hasBlock}} + ``` + + with + + ```handlebars + {{has-block}} + ``` + + @private + @class TransformHasBlockSyntax + */ + + 'use strict'; + + exports.default = TransformHasBlockSyntax; + + function TransformHasBlockSyntax() { + // set later within Glimmer2 to the syntax package + this.syntax = null; + } + + var TRANSFORMATIONS = { + hasBlock: 'has-block', + hasBlockParams: 'has-block-params' + }; + + /** + @private + @method transform + @param {AST} ast The AST to be transformed. + */ + TransformHasBlockSyntax.prototype.transform = function TransformHasBlockSyntax_transform(ast) { + var _syntax = this.syntax; + var traverse = _syntax.traverse; + var b = _syntax.builders; + + traverse(ast, { + PathExpression: function (node) { + if (TRANSFORMATIONS[node.original]) { + return b.sexpr(b.path(TRANSFORMATIONS[node.original])); + } + }, + MustacheStatement: function (node) { + if (TRANSFORMATIONS[node.path.original]) { + return b.mustache(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash, null, node.loc); + } + }, + SubExpression: function (node) { + if (TRANSFORMATIONS[node.path.original]) { + return b.sexpr(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash); + } + } + }); + + return ast; + }; +}); enifed('ember-template-compiler/plugins/transform-inline-link-to', ['exports'], function (exports) { 'use strict'; exports.default = TransformInlineLinkTo; @@ -11070,11 +12100,11 @@ }); return ast; }; }); -enifed('ember-template-compiler/plugins/transform-input-on-to-onEvent', ['exports', 'ember-metal/debug', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetalDebug, _emberTemplateCompilerSystemCalculateLocationDisplay) { +enifed('ember-template-compiler/plugins/transform-input-on-to-onEvent', ['exports', 'ember-metal', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetal, _emberTemplateCompilerSystemCalculateLocationDisplay) { 'use strict'; exports.default = TransformInputOnToOnEvent; /** @@ -11116,32 +12146,32 @@ */ TransformInputOnToOnEvent.prototype.transform = function TransformInputOnToOnEvent_transform(ast) { var pluginContext = this; var b = pluginContext.syntax.builders; var walker = new pluginContext.syntax.Walker(); - var moduleName = pluginContext.options.moduleName; + var moduleName = pluginContext.options.meta.moduleName; walker.visit(ast, function (node) { if (pluginContext.validate(node)) { var action = hashPairForKey(node.hash, 'action'); var on = hashPairForKey(node.hash, 'on'); var onEvent = hashPairForKey(node.hash, 'onEvent'); var normalizedOn = on || onEvent; var moduleInfo = _emberTemplateCompilerSystemCalculateLocationDisplay.default(moduleName, node.loc); if (normalizedOn && normalizedOn.value.type !== 'StringLiteral') { - _emberMetalDebug.deprecate('Using a dynamic value for \'#{normalizedOn.key}=\' with the \'{{input}}\' helper ' + moduleInfo + 'is deprecated.', false, { id: 'ember-template-compiler.transform-input-on-to-onEvent.dynamic-value', until: '3.0.0' }); + _emberMetal.deprecate('Using a dynamic value for \'#{normalizedOn.key}=\' with the \'{{input}}\' helper ' + moduleInfo + 'is deprecated.', false, { id: 'ember-template-compiler.transform-input-on-to-onEvent.dynamic-value', until: '3.0.0' }); normalizedOn.key = 'onEvent'; return; // exit early, as we cannot transform further } removeFromHash(node.hash, normalizedOn); removeFromHash(node.hash, action); if (!action) { - _emberMetalDebug.deprecate('Using \'{{input ' + normalizedOn.key + '="' + normalizedOn.value.value + '" ...}}\' without specifying an action ' + moduleInfo + 'will do nothing.', false, { id: 'ember-template-compiler.transform-input-on-to-onEvent.no-action', until: '3.0.0' }); + _emberMetal.deprecate('Using \'{{input ' + normalizedOn.key + '="' + normalizedOn.value.value + '" ...}}\' without specifying an action ' + moduleInfo + 'will do nothing.', false, { id: 'ember-template-compiler.transform-input-on-to-onEvent.no-action', until: '3.0.0' }); return; // exit early, if no action was available there is nothing to do } var specifiedOn = normalizedOn ? normalizedOn.key + '="' + normalizedOn.value.value + '" ' : ''; @@ -11151,11 +12181,11 @@ normalizedOn.value.value = 'key-press'; } var expected = (normalizedOn ? normalizedOn.value.value : 'enter') + '="' + action.value.original + '"'; - _emberMetalDebug.deprecate('Using \'{{input ' + specifiedOn + 'action="' + action.value.original + '"}}\' ' + moduleInfo + 'is deprecated. Please use \'{{input ' + expected + '}}\' instead.', false, { id: 'ember-template-compiler.transform-input-on-to-onEvent.normalized-on', until: '3.0.0' }); + _emberMetal.deprecate('Using \'{{input ' + specifiedOn + 'action="' + action.value.original + '"}}\' ' + moduleInfo + 'is deprecated. Please use \'{{input ' + expected + '}}\' instead.', false, { id: 'ember-template-compiler.transform-input-on-to-onEvent.normalized-on', until: '3.0.0' }); if (!normalizedOn) { normalizedOn = b.pair('onEvent', b.string('enter')); } node.hash.pairs.push(b.pair(normalizedOn.value.value, action.value)); @@ -11191,10 +12221,85 @@ } hash.pairs = newPairs; } }); +enifed('ember-template-compiler/plugins/transform-input-type-syntax', ['exports'], function (exports) { + /** + @module ember + @submodule ember-glimmer + */ + + /** + A Glimmer2 AST transformation that replaces all instances of + + ```handlebars + {{input type=boundType}} + ``` + + with + + ```handlebars + {{input (-input-type boundType) type=boundType}} + ``` + + Note that the type parameters is not removed as the -input-type helpers + is only used to select the component class. The component still needs + the type parameter to function. + + @private + @class TransformInputTypeSyntax + */ + + 'use strict'; + + exports.default = TransformInputTypeSyntax; + + function TransformInputTypeSyntax() { + // set later within Glimmer2 to the syntax package + this.syntax = null; + } + + /** + @private + @method transform + @param {AST} ast The AST to be transformed. + */ + TransformInputTypeSyntax.prototype.transform = function TransformInputTypeSyntax_transform(ast) { + var _syntax = this.syntax; + var traverse = _syntax.traverse; + var b = _syntax.builders; + + traverse(ast, { + MustacheStatement: function (node) { + if (isInput(node)) { + insertTypeHelperParameter(node, b); + } + } + }); + + return ast; + }; + + function isInput(node) { + return node.path.original === 'input'; + } + + function insertTypeHelperParameter(node, builders) { + var pairs = node.hash.pairs; + var pair = null; + for (var i = 0; i < pairs.length; i++) { + if (pairs[i].key === 'type') { + pair = pairs[i]; + break; + } + } + if (pair && pair.value.type !== 'StringLiteral') { + node.params.unshift(builders.sexpr('-input-type', [builders.path(pair.value.original, pair.loc)], null, pair.loc)); + } + } +}); enifed('ember-template-compiler/plugins/transform-item-class', ['exports'], function (exports) { 'use strict'; exports.default = TransformItemClass; @@ -11239,22 +12344,22 @@ function validate(node) { return (node.type === 'BlockStatement' || node.type === 'MustacheStatement') && node.path.original === 'collection'; } }); -enifed('ember-template-compiler/plugins/transform-old-binding-syntax', ['exports', 'ember-metal/debug', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetalDebug, _emberTemplateCompilerSystemCalculateLocationDisplay) { +enifed('ember-template-compiler/plugins/transform-old-binding-syntax', ['exports', 'ember-metal', 'ember-template-compiler/system/calculate-location-display'], function (exports, _emberMetal, _emberTemplateCompilerSystemCalculateLocationDisplay) { 'use strict'; exports.default = TransformOldBindingSyntax; function TransformOldBindingSyntax(options) { this.syntax = null; this.options = options; } TransformOldBindingSyntax.prototype.transform = function TransformOldBindingSyntax_transform(ast) { - var moduleName = this.options.moduleName; + var moduleName = this.options.meta.moduleName; var b = this.syntax.builders; var walker = new this.syntax.Walker(); walker.visit(ast, function (node) { if (!validate(node)) { @@ -11270,16 +12375,16 @@ if (key === 'classBinding') { return; } - _emberMetalDebug.assert('Setting \'attributeBindings\' via template helpers is not allowed ' + sourceInformation, key !== 'attributeBindings'); + _emberMetal.assert('Setting \'attributeBindings\' via template helpers is not allowed ' + sourceInformation, key !== 'attributeBindings'); if (key.substr(-7) === 'Binding') { var newKey = key.slice(0, -7); - _emberMetalDebug.deprecate('You\'re using legacy binding syntax: ' + key + '=' + exprToString(value) + ' ' + sourceInformation + '. Please replace with ' + newKey + '=' + value.original, false, { id: 'ember-template-compiler.transform-old-binding-syntax', until: '3.0.0' }); + _emberMetal.deprecate('You\'re using legacy binding syntax: ' + key + '=' + exprToString(value) + ' ' + sourceInformation + '. Please replace with ' + newKey + '=' + value.original, false, { id: 'ember-template-compiler.transform-old-binding-syntax', until: '3.0.0' }); pair.key = newKey; if (value.type === 'StringLiteral') { pair.value = b.path(value.original); } @@ -11406,11 +12511,11 @@ if (inactiveClass !== undefined) { hash.pairs.push(b.pair('inactiveClass', b.string(inactiveClass))); } - params.push(b.sexpr(b.string('-normalize-class'), sexprParams, hash)); + params.push(b.sexpr(b.path('-normalize-class'), sexprParams, hash)); } if (inactiveClass || inactiveClass === '') { params.push(b.string(inactiveClass)); } @@ -11505,11 +12610,11 @@ if (lastComponentNode.type === 'ComponentNode') { componentCallback(lastComponentNode); } } }); -enifed('ember-template-compiler/system/bootstrap', ['exports', 'ember-metal/error', 'ember-template-compiler', 'ember-templates/template_registry'], function (exports, _emberMetalError, _emberTemplateCompiler, _emberTemplatesTemplate_registry) { +enifed('ember-template-compiler/system/bootstrap', ['exports', 'ember-metal', 'ember-template-compiler/system/compile'], function (exports, _emberMetal, _emberTemplateCompilerSystemCompile) { /** @module ember @submodule ember-templates */ @@ -11531,13 +12636,19 @@ @method bootstrap @for Ember.HTMLBars @static @param ctx */ - function bootstrap() { - var context = arguments.length <= 0 || arguments[0] === undefined ? document : arguments[0]; + function bootstrap(_ref) { + var context = _ref.context; + var hasTemplate = _ref.hasTemplate; + var setTemplate = _ref.setTemplate; + if (!context) { + context = document; + } + var selector = 'script[type="text/x-handlebars"]'; var elements = context.querySelectorAll(selector); for (var i = 0; i < elements.length; i++) { @@ -11547,21 +12658,21 @@ // First look for data-template-name attribute, then fall back to its // id if no name is found. var templateName = script.getAttribute('data-template-name') || script.getAttribute('id') || 'application'; var template = undefined; - template = _emberTemplateCompiler.compile(script.innerHTML, { + template = _emberTemplateCompilerSystemCompile.default(script.innerHTML, { moduleName: templateName }); // Check if template of same name already exists. - if (_emberTemplatesTemplate_registry.has(templateName)) { - throw new _emberMetalError.default('Template named "' + templateName + '" already exists.'); + if (hasTemplate(templateName)) { + throw new _emberMetal.Error('Template named "' + templateName + '" already exists.'); } // For templates which have a name, we save them and then remove them from the DOM. - _emberTemplatesTemplate_registry.set(templateName, template); + setTemplate(templateName, template); // Remove script tag from DOM. script.parentNode.removeChild(script); } } @@ -11599,25 +12710,74 @@ } return moduleInfo; } }); -enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-template-compiler/compiler'], function (exports, _emberTemplateCompilerCompiler) { +enifed('ember-template-compiler/system/compile-options', ['exports', 'ember-template-compiler/plugins', 'ember-metal'], function (exports, _emberTemplateCompilerPlugins, _emberMetal) { 'use strict'; - var _compiler = _emberTemplateCompilerCompiler.default(); + exports.default = compileOptions; + exports.registerPlugin = registerPlugin; + exports.removePlugin = removePlugin; - var defaultCompileOptions = _compiler.defaultCompileOptions; - exports.default = defaultCompileOptions; + var USER_PLUGINS = []; + + function compileOptions(_options) { + var options = _emberMetal.assign({ meta: {} }, _options); + + // move `moduleName` into `meta` property + if (options.moduleName) { + var meta = options.meta; + meta.moduleName = options.moduleName; + + delete options.moduleName; + } + + if (!options.plugins) { + options.plugins = { ast: [].concat(USER_PLUGINS, _emberTemplateCompilerPlugins.default) }; + } else { + var potententialPugins = [].concat(USER_PLUGINS, _emberTemplateCompilerPlugins.default); + var pluginsToAdd = potententialPugins.filter(function (plugin) { + return options.plugins.ast.indexOf(plugin) === -1; + }); + options.plugins.ast = options.plugins.ast.slice().concat(pluginsToAdd); + } + + return options; + } + + function registerPlugin(type, PluginClass) { + if (type !== 'ast') { + throw new Error('Attempting to register ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.'); + } + + if (USER_PLUGINS.indexOf(PluginClass) === -1) { + USER_PLUGINS = [PluginClass].concat(USER_PLUGINS); + } + } + + function removePlugin(type, PluginClass) { + if (type !== 'ast') { + throw new Error('Attempting to unregister ' + PluginClass + ' as "' + type + '" which is not a valid Glimmer plugin type.'); + } + + USER_PLUGINS = USER_PLUGINS.filter(function (plugin) { + return plugin !== PluginClass; + }); + } }); -enifed('ember-template-compiler/system/compile', ['exports', 'ember-template-compiler/compiler', 'ember-template-compiler/system/compile-options', 'ember-metal/assign'], function (exports, _emberTemplateCompilerCompiler, _emberTemplateCompilerSystemCompileOptions, _emberMetalAssign) { +enifed('ember-template-compiler/system/compile', ['exports', 'require', 'ember-template-compiler/system/precompile'], function (exports, _require, _emberTemplateCompilerSystemPrecompile) { /** @module ember @submodule ember-template-compiler */ 'use strict'; + exports.default = compile; + + var template = undefined; + /** Uses HTMLBars `compile` function to process a string into a compiled template. This is not present in production builds. @@ -11625,26 +12785,36 @@ @method compile @param {String} templateString This is the string to be compiled by HTMLBars. @param {Object} options This is an options hash to augment the compiler options. */ - exports.default = function (templateString, options) { - var _compiler = _emberTemplateCompilerCompiler.default(); + function compile(templateString, options) { + if (!template && _require.has('ember-glimmer')) { + template = _require.default('ember-glimmer').template; + } - var compile = _compiler.compile; + if (!template) { + throw new Error('Cannot call `compile` with only the template compiler loaded. Please load `ember.debug.js` or `ember.prod.js` prior to calling `compile`.'); + } - return compile(templateString, _emberMetalAssign.default({}, _emberTemplateCompilerSystemCompileOptions.default(), options)); - }; + var precompiledTemplateString = _emberTemplateCompilerSystemPrecompile.default(templateString, options); + var templateJS = new Function('return ' + precompiledTemplateString)(); + return template(templateJS); + } }); -enifed('ember-template-compiler/system/precompile', ['exports', 'ember-metal/assign', 'ember-template-compiler/compiler', 'ember-template-compiler/system/compile-options'], function (exports, _emberMetalAssign, _emberTemplateCompilerCompiler, _emberTemplateCompilerSystemCompileOptions) { +enifed('ember-template-compiler/system/precompile', ['exports', 'ember-template-compiler/system/compile-options', 'require'], function (exports, _emberTemplateCompilerSystemCompileOptions, _require) { /** @module ember @submodule ember-template-compiler */ 'use strict'; + exports.default = precompile; + + var glimmerPrecompile = undefined; + /** Uses HTMLBars `compile` function to process a string into a compiled template string. The returned string must be passed through `Ember.HTMLBars.template`. This is not present in production builds. @@ -11652,339 +12822,108 @@ @private @method precompile @param {String} templateString This is the string to be compiled by HTMLBars. */ - exports.default = function (templateString, options) { - var _compiler = _emberTemplateCompilerCompiler.default(); - - var precompile = _compiler.precompile; - - return precompile(templateString, _emberMetalAssign.default({}, _emberTemplateCompilerSystemCompileOptions.default(), options)); - }; -}); -enifed('ember-template-compiler/system/register-plugin', ['exports', 'ember-template-compiler/compiler'], function (exports, _emberTemplateCompilerCompiler) { - 'use strict'; - - var _compiler = _emberTemplateCompilerCompiler.default(); - - var registerPlugin = _compiler.registerPlugin; - exports.default = registerPlugin; -}); -enifed('ember-templates/compat', ['exports', 'ember-metal/core', 'ember-templates/template', 'ember-templates/string', 'ember-runtime/system/string', 'ember-metal/features', 'ember-templates/make-bound-helper'], function (exports, _emberMetalCore, _emberTemplatesTemplate, _emberTemplatesString, _emberRuntimeSystemString, _emberMetalFeatures, _emberTemplatesMakeBoundHelper) { - 'use strict'; - - var EmberHandlebars = _emberMetalCore.default.Handlebars = _emberMetalCore.default.Handlebars || {}; - exports.EmberHandlebars = EmberHandlebars; - var EmberHTMLBars = _emberMetalCore.default.HTMLBars = _emberMetalCore.default.HTMLBars || {}; - exports.EmberHTMLBars = EmberHTMLBars; - var EmberHandleBarsUtils = EmberHandlebars.Utils = EmberHandlebars.Utils || {}; - - exports.EmberHandleBarsUtils = EmberHandleBarsUtils; - Object.defineProperty(EmberHandlebars, 'SafeString', { - get: _emberTemplatesString.getSafeString - }); - - EmberHTMLBars.template = EmberHandlebars.template = _emberTemplatesTemplate.default; - EmberHandleBarsUtils.escapeExpression = _emberTemplatesString.escapeExpression; - _emberRuntimeSystemString.default.htmlSafe = _emberTemplatesString.htmlSafe; - - if (true) { - _emberRuntimeSystemString.default.isHTMLSafe = _emberTemplatesString.isHTMLSafe; - } - EmberHTMLBars.makeBoundHelper = _emberTemplatesMakeBoundHelper.default; -}); -// reexports -enifed('ember-templates/component', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - exports.default = (function () { - if (true) { - return _require.default('ember-glimmer/component').default; - } else { - return _require.default('ember-htmlbars/component').default; + function precompile(templateString, options) { + if (!glimmerPrecompile && _require.has('glimmer-compiler')) { + glimmerPrecompile = _require.default('glimmer-compiler').precompile; } - })(); -}); -enifed('ember-templates/components/checkbox', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - exports.default = (function () { - if (true) { - return _require.default('ember-glimmer/components/checkbox').default; - } else { - return _require.default('ember-htmlbars/components/checkbox').default; + if (!glimmerPrecompile) { + throw new Error('Cannot call `compile` without the template compiler loaded. Please load `ember-template-compiler.js` prior to calling `compile`.'); } - })(); -}); -enifed('ember-templates/components/link-to', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - exports.default = (function () { - if (true) { - return _require.default('ember-glimmer/components/link-to').default; - } else { - return _require.default('ember-htmlbars/components/link-to').default; - } - })(); -}); -enifed('ember-templates/components/text_area', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - exports.default = (function () { - if (true) { - return _require.default('ember-glimmer/components/text_area').default; - } else { - return _require.default('ember-htmlbars/components/text_area').default; - } - })(); -}); -enifed('ember-templates/components/text_field', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - exports.default = (function () { - if (true) { - return _require.default('ember-glimmer/components/text_field').default; - } else { - return _require.default('ember-htmlbars/components/text_field').default; - } - })(); -}); -enifed('ember-templates/helper', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - exports.default = (function () { - if (true) { - return _require.default('ember-glimmer/helper').default; - } else { - return _require.default('ember-htmlbars/helper').default; - } - })(); - - var helper = (function () { - if (true) { - return _require.default('ember-glimmer/helper').helper; - } else { - return _require.default('ember-htmlbars/helper').helper; - } - })(); - exports.helper = helper; -}); -enifed('ember-templates/index', ['exports', 'ember-metal/core', 'ember-templates/template_registry', 'ember-templates/renderer', 'ember-templates/component', 'ember-templates/helper', 'ember-templates/components/checkbox', 'ember-templates/components/text_field', 'ember-templates/components/text_area', 'ember-templates/components/link-to', 'ember-templates/string', 'ember-environment', 'ember-templates/compat'], function (exports, _emberMetalCore, _emberTemplatesTemplate_registry, _emberTemplatesRenderer, _emberTemplatesComponent, _emberTemplatesHelper, _emberTemplatesComponentsCheckbox, _emberTemplatesComponentsText_field, _emberTemplatesComponentsText_area, _emberTemplatesComponentsLinkTo, _emberTemplatesString, _emberEnvironment, _emberTemplatesCompat) { - 'use strict'; - - _emberMetalCore.default._Renderer = _emberTemplatesRenderer.Renderer; - _emberMetalCore.default.Component = _emberTemplatesComponent.default; - _emberTemplatesHelper.default.helper = _emberTemplatesHelper.helper; - _emberMetalCore.default.Helper = _emberTemplatesHelper.default; - _emberMetalCore.default.Checkbox = _emberTemplatesComponentsCheckbox.default; - _emberMetalCore.default.TextField = _emberTemplatesComponentsText_field.default; - _emberMetalCore.default.TextArea = _emberTemplatesComponentsText_area.default; - _emberMetalCore.default.LinkComponent = _emberTemplatesComponentsLinkTo.default; - - if (_emberEnvironment.ENV.EXTEND_PROTOTYPES.String) { - String.prototype.htmlSafe = function () { - return _emberTemplatesString.htmlSafe(this); - }; + return glimmerPrecompile(templateString, _emberTemplateCompilerSystemCompileOptions.default(options)); } - - /** - Global hash of shared templates. This will automatically be populated - by the build tools so that you can store your Handlebars templates in - separate files that get loaded into JavaScript at buildtime. - - @property TEMPLATES - @for Ember - @type Object - @private - */ - Object.defineProperty(_emberMetalCore.default, 'TEMPLATES', { - get: _emberTemplatesTemplate_registry.getTemplates, - set: _emberTemplatesTemplate_registry.setTemplates, - configurable: false, - enumerable: false - }); - - exports.default = _emberMetalCore.default; }); -// reexports -enifed('ember-templates/make-bound-helper', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - exports.default = (function () { - if (true) { - return _require.default('ember-glimmer/make-bound-helper').default; - } else { - return _require.default('ember-htmlbars/make-bound-helper').default; - } - })(); -}); -enifed('ember-templates/renderer', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - var InteractiveRenderer = (function () { - if (true) { - return _require.default('ember-glimmer/renderer').InteractiveRenderer; - } else { - return _require.default('ember-htmlbars/renderer').InteractiveRenderer; - } - })(); - - exports.InteractiveRenderer = InteractiveRenderer; - var InertRenderer = (function () { - if (true) { - return _require.default('ember-glimmer/renderer').InertRenderer; - } else { - return _require.default('ember-htmlbars/renderer').InertRenderer; - } - })(); - - exports.InertRenderer = InertRenderer; - var Renderer = (function () { - if (true) { - return _require.default('ember-glimmer/renderer').Renderer; - } else { - return _require.default('ember-htmlbars/renderer').Renderer; - } - })(); - exports.Renderer = Renderer; -}); -enifed('ember-templates/string', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - var strings = (function () { - if (true) { - return _require.default('ember-glimmer/utils/string'); - } else { - return _require.default('ember-htmlbars/utils/string'); - } - })(); - - var SafeString = strings.SafeString; - exports.SafeString = SafeString; - var escapeExpression = strings.escapeExpression; - exports.escapeExpression = escapeExpression; - var htmlSafe = strings.htmlSafe; - exports.htmlSafe = htmlSafe; - var isHTMLSafe = strings.isHTMLSafe; - exports.isHTMLSafe = isHTMLSafe; - var getSafeString = strings.getSafeString; - exports.getSafeString = getSafeString; -}); -enifed('ember-templates/template', ['exports', 'ember-metal/features', 'require'], function (exports, _emberMetalFeatures, _require) { - 'use strict'; - - var htmlbarsTemplate = undefined, - glimmerTemplate = undefined; - if (_require.has('ember-htmlbars')) { - htmlbarsTemplate = _require.default('ember-htmlbars').template; - } - - if (_require.has('ember-glimmer')) { - glimmerTemplate = _require.default('ember-glimmer').template; - } - - var template = true ? glimmerTemplate : htmlbarsTemplate; - - exports.default = template; -}); -enifed("ember-templates/template_registry", ["exports"], function (exports) { - // STATE within a module is frowned apon, this exists - // to support Ember.TEMPLATES but shield ember internals from this legacy - // global API. - "use strict"; - - exports.setTemplates = setTemplates; - exports.getTemplates = getTemplates; - exports.get = get; - exports.has = has; - exports.set = set; - var TEMPLATES = {}; - - function setTemplates(templates) { - TEMPLATES = templates; - } - - function getTemplates() { - return TEMPLATES; - } - - function get(name) { - if (TEMPLATES.hasOwnProperty(name)) { - return TEMPLATES[name]; - } - } - - function has(name) { - return TEMPLATES.hasOwnProperty(name); - } - - function set(name, template) { - return TEMPLATES[name] = template; - } -}); enifed("ember/features", ["exports"], function (exports) { "use strict"; - exports.default = { "features-stripped-test": false, "ember-routing-route-configured-query-params": false, "ember-libraries-isregistered": false, "ember-application-engines": true, "ember-glimmer": true, "ember-runtime-computed-uniq-by": true, "ember-improved-instrumentation": false, "ember-runtime-enumerable-includes": true, "ember-string-ishtmlsafe": true, "ember-testing-check-waiters": true, "ember-metal-weakmap": false, "ember-glimmer-allow-backtracking-rerender": false, "mandatory-setter": true, "ember-glimmer-detect-backtracking-rerender": true }; + exports.default = { "features-stripped-test": false, "ember-routing-route-configured-query-params": false, "ember-libraries-isregistered": false, "ember-runtime-computed-uniq-by": true, "ember-improved-instrumentation": false, "ember-runtime-enumerable-includes": true, "ember-string-ishtmlsafe": true, "ember-testing-check-waiters": true, "ember-metal-weakmap": false, "ember-glimmer-allow-backtracking-rerender": false, "mandatory-setter": true, "ember-glimmer-detect-backtracking-rerender": true }; }); enifed("ember/version", ["exports"], function (exports) { "use strict"; - exports.default = "v2.9.0-alpha.2"; + exports.default = "2.9.0-beta.1"; }); -enifed('glimmer-compiler/index', ['exports', 'glimmer-compiler/lib/compiler', 'glimmer-compiler/lib/template-compiler', 'glimmer-compiler/lib/template-visitor'], function (exports, _glimmerCompilerLibCompiler, _glimmerCompilerLibTemplateCompiler, _glimmerCompilerLibTemplateVisitor) { - 'use strict'; +enifed("glimmer-compiler/index", ["exports", "glimmer-compiler/lib/compiler", "glimmer-compiler/lib/template-visitor"], function (exports, _glimmerCompilerLibCompiler, _glimmerCompilerLibTemplateVisitor) { + "use strict"; - exports.TemplateSpec = _glimmerCompilerLibCompiler.TemplateSpec; - exports.compileSpec = _glimmerCompilerLibCompiler.compileSpec; - exports.TemplateCompiler = _glimmerCompilerLibTemplateCompiler.default; - exports.CompileOptions = _glimmerCompilerLibTemplateCompiler.CompileOptions; + exports.precompile = _glimmerCompilerLibCompiler.precompile; + exports.PrecompileOptions = _glimmerCompilerLibCompiler.PrecompileOptions; + + // exported only for tests exports.TemplateVisitor = _glimmerCompilerLibTemplateVisitor.default; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItY29tcGlsZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O1VBQ0UsWUFBWSwrQkFBWixZQUFZO1VBQ1osV0FBVywrQkFBWCxXQUFXO1VBSUEsZ0JBQWdCLHVDQUEzQixPQUFPO1VBQ1AsY0FBYyx1Q0FBZCxjQUFjO1VBR0ksZUFBZSxzQ0FBMUIsT0FBTyIsImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIFRlbXBsYXRlU3BlYyxcbiAgY29tcGlsZVNwZWNcbn0gZnJvbSBcIi4vbGliL2NvbXBpbGVyXCI7XG5cbmV4cG9ydCB7XG4gIGRlZmF1bHQgYXMgVGVtcGxhdGVDb21waWxlcixcbiAgQ29tcGlsZU9wdGlvbnNcbn0gZnJvbSAnLi9saWIvdGVtcGxhdGUtY29tcGlsZXInO1xuXG5leHBvcnQgeyBkZWZhdWx0IGFzIFRlbXBsYXRlVmlzaXRvciB9IGZyb20gJy4vbGliL3RlbXBsYXRlLXZpc2l0b3InO1xuIl19 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItY29tcGlsZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O1VBQ0UsVUFBVSwrQkFBVixVQUFVO1VBQUUsaUJBQWlCLCtCQUFqQixpQkFBaUI7OztVQUlYLGVBQWUsc0NBQTFCLE9BQU8iLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBwcmVjb21waWxlLCBQcmVjb21waWxlT3B0aW9uc1xufSBmcm9tIFwiLi9saWIvY29tcGlsZXJcIjtcblxuLy8gZXhwb3J0ZWQgb25seSBmb3IgdGVzdHNcbmV4cG9ydCB7IGRlZmF1bHQgYXMgVGVtcGxhdGVWaXNpdG9yIH0gZnJvbSAnLi9saWIvdGVtcGxhdGUtdmlzaXRvcic7XG4iXX0= enifed("glimmer-compiler/lib/compiler", ["exports", "glimmer-syntax", "glimmer-compiler/lib/template-compiler"], function (exports, _glimmerSyntax, _glimmerCompilerLibTemplateCompiler) { - "use strict"; + "use strict"; - exports.compileSpec = compileSpec; + exports.precompile = precompile; - /* - * Compile a string into a template spec string. The template spec is a string - * representation of a template. Usually, you would use compileSpec for - * pre-compilation of a template on the server. - * - * Example usage: - * - * let templateSpec = compileSpec("Howdy {{name}}"); - * // This next step is basically what plain compile does - * let template = new Function("return " + templateSpec)(); - * - * @method compileSpec - * @param {String} string An Glimmer template string - * @return {TemplateSpec} A template spec string - */ + var defaultId = (function () { + var idFn = undefined; + return function () { + if (!idFn) { + if (typeof require === 'function') { + try { + (function () { + /* tslint:disable:no-require-imports */ + var crypto = require('crypto'); + /* tslint:enable:no-require-imports */ + idFn = function (src) { + var hash = crypto.createHash('sha1'); + hash.update(src, 'utf8'); + // trim to 6 bytes of data (2^48 - 1) + return hash.digest('base64').substring(0, 8); + }; + idFn("test"); + })(); + } catch (e) { + idFn = null; + } + } + if (!idFn) { + idFn = function () { + return null; + }; + } + } + return idFn; + }; + })(); - function compileSpec(string, options) { - var ast = _glimmerSyntax.preprocess(string, options); - var program = _glimmerCompilerLibTemplateCompiler.default.compile(options, ast); - return JSON.stringify(program); - } + function precompile(string, options) { + var opts = options || { + id: defaultId(), + meta: {} + }; + var ast = _glimmerSyntax.preprocess(string, opts); + + var _TemplateCompiler$compile = _glimmerCompilerLibTemplateCompiler.default.compile(opts, ast); + + var block = _TemplateCompiler$compile.block; + var meta = _TemplateCompiler$compile.meta; + + var idFn = opts.id || defaultId(); + var blockJSON = JSON.stringify(block.toJSON()); + var templateJSONObject = { + id: idFn(JSON.stringify(meta) + blockJSON), + block: blockJSON, + meta: meta + }; + // JSON is javascript + return JSON.stringify(templateJSONObject); + } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItY29tcGlsZXIvbGliL2NvbXBpbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQW9CQSxXQUFBLFdBQUEsQ0FBNEIsTUFBYyxFQUFFLE9BQVksRUFBQTtBQUN0RCxRQUFJLEdBQUcsR0FBRyxlQXJCSCxVQUFVLENBcUJJLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztBQUN0QyxRQUFJLE9BQU8sR0FBRyw0Q0FBaUIsT0FBTyxDQUFDLE9BQU8sRUFBRSxHQUFHLENBQUMsQ0FBQztBQUNyRCxXQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUM7R0FDaEMiLCJmaWxlIjoiY29tcGlsZXIuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBwcmVwcm9jZXNzIH0gZnJvbSBcImdsaW1tZXItc3ludGF4XCI7XG5pbXBvcnQgVGVtcGxhdGVDb21waWxlciBmcm9tIFwiLi90ZW1wbGF0ZS1jb21waWxlclwiO1xuXG5leHBvcnQgdHlwZSBUZW1wbGF0ZVNwZWMgPSBzdHJpbmc7XG5cbi8qXG4gKiBDb21waWxlIGEgc3RyaW5nIGludG8gYSB0ZW1wbGF0ZSBzcGVjIHN0cmluZy4gVGhlIHRlbXBsYXRlIHNwZWMgaXMgYSBzdHJpbmdcbiAqIHJlcHJlc2VudGF0aW9uIG9mIGEgdGVtcGxhdGUuIFVzdWFsbHksIHlvdSB3b3VsZCB1c2UgY29tcGlsZVNwZWMgZm9yXG4gKiBwcmUtY29tcGlsYXRpb24gb2YgYSB0ZW1wbGF0ZSBvbiB0aGUgc2VydmVyLlxuICpcbiAqIEV4YW1wbGUgdXNhZ2U6XG4gKlxuICogICAgIGxldCB0ZW1wbGF0ZVNwZWMgPSBjb21waWxlU3BlYyhcIkhvd2R5IHt7bmFtZX19XCIpO1xuICogICAgIC8vIFRoaXMgbmV4dCBzdGVwIGlzIGJhc2ljYWxseSB3aGF0IHBsYWluIGNvbXBpbGUgZG9lc1xuICogICAgIGxldCB0ZW1wbGF0ZSA9IG5ldyBGdW5jdGlvbihcInJldHVybiBcIiArIHRlbXBsYXRlU3BlYykoKTtcbiAqXG4gKiBAbWV0aG9kIGNvbXBpbGVTcGVjXG4gKiBAcGFyYW0ge1N0cmluZ30gc3RyaW5nIEFuIEdsaW1tZXIgdGVtcGxhdGUgc3RyaW5nXG4gKiBAcmV0dXJuIHtUZW1wbGF0ZVNwZWN9IEEgdGVtcGxhdGUgc3BlYyBzdHJpbmdcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvbXBpbGVTcGVjKHN0cmluZzogc3RyaW5nLCBvcHRpb25zOiBhbnkpOiBUZW1wbGF0ZVNwZWMge1xuICBsZXQgYXN0ID0gcHJlcHJvY2VzcyhzdHJpbmcsIG9wdGlvbnMpO1xuICBsZXQgcHJvZ3JhbSA9IFRlbXBsYXRlQ29tcGlsZXIuY29tcGlsZShvcHRpb25zLCBhc3QpO1xuICByZXR1cm4gSlNPTi5zdHJpbmdpZnkocHJvZ3JhbSk7XG59XG4iXX0= +//# sourceMappingURL=data:application/json;base64,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 enifed("glimmer-compiler/lib/javascript-compiler", ["exports", "glimmer-util"], function (exports, _glimmerUtil) { "use strict"; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var Block = (function () { function Block() { - _classCallCheck(this, Block); - this.statements = []; this.positionals = []; } Block.prototype.toJSON = function toJSON() { @@ -12001,47 +12940,57 @@ return Block; })(); exports.Block = Block; - var Template = (function (_Block) { - _inherits(Template, _Block); + var TemplateBlock = (function (_Block) { + babelHelpers.inherits(TemplateBlock, _Block); - function Template(meta) { - _classCallCheck(this, Template); - - _Block.call(this); - this.meta = null; + function TemplateBlock() { + _Block.apply(this, arguments); this.yields = new _glimmerUtil.DictSet(); this.named = new _glimmerUtil.DictSet(); this.blocks = []; - this.meta = meta; } - Template.prototype.toJSON = function toJSON() { + TemplateBlock.prototype.toJSON = function toJSON() { return { statements: this.statements, locals: this.positionals, named: this.named.toArray(), yields: this.yields.toArray(), blocks: this.blocks.map(function (b) { return b.toJSON(); - }), + }) + }; + }; + + return TemplateBlock; + })(Block); + + exports.TemplateBlock = TemplateBlock; + + var Template = (function () { + function Template(meta) { + this.meta = meta; + this.block = new TemplateBlock(); + } + + Template.prototype.toJSON = function toJSON() { + return { + block: this.block.toJSON(), meta: this.meta }; }; return Template; - })(Block); + })(); exports.Template = Template; var JavaScriptCompiler = (function () { function JavaScriptCompiler(opcodes, meta) { - _classCallCheck(this, JavaScriptCompiler); - - this.template = null; this.blocks = new _glimmerUtil.Stack(); this.values = []; this.opcodes = opcodes; this.template = new Template(meta); } @@ -12079,15 +13028,15 @@ JavaScriptCompiler.prototype.endBlock = function endBlock() { var template = this.template; var blocks = this.blocks; - template.blocks.push(blocks.pop()); + template.block.blocks.push(blocks.pop()); }; JavaScriptCompiler.prototype.startProgram = function startProgram() { - this.blocks.push(this.template); + this.blocks.push(this.template.block); }; JavaScriptCompiler.prototype.endProgram = function endProgram() {}; /// Statements @@ -12115,77 +13064,81 @@ var hash = this.popValue(); this.push(['block', path, params, hash, template, inverse]); }; JavaScriptCompiler.prototype.openElement = function openElement(tag, blockParams) { - this.push(['openElement', tag, blockParams]); + this.push(['open-element', tag, blockParams]); }; + JavaScriptCompiler.prototype.flushElement = function flushElement() { + this.push(['flush-element']); + }; + JavaScriptCompiler.prototype.closeElement = function closeElement() { - this.push(['closeElement']); + this.push(['close-element']); }; JavaScriptCompiler.prototype.staticAttr = function staticAttr(name, namespace) { var value = this.popValue(); - this.push(['staticAttr', name, value, namespace]); + this.push(['static-attr', name, value, namespace]); }; JavaScriptCompiler.prototype.dynamicAttr = function dynamicAttr(name, namespace) { var value = this.popValue(); - this.push(['dynamicAttr', name, value, namespace]); + this.push(['dynamic-attr', name, value, namespace]); }; JavaScriptCompiler.prototype.trustingAttr = function trustingAttr(name, namespace) { var value = this.popValue(); - this.push(['trustingAttr', name, value, namespace]); + this.push(['trusting-attr', name, value, namespace]); }; JavaScriptCompiler.prototype.staticArg = function staticArg(name) { var value = this.popValue(); - this.push(['staticArg', name.slice(1), value]); + this.push(['static-arg', name.slice(1), value]); }; JavaScriptCompiler.prototype.dynamicArg = function dynamicArg(name) { var value = this.popValue(); - this.push(['dynamicArg', name.slice(1), value]); + this.push(['dynamic-arg', name.slice(1), value]); }; JavaScriptCompiler.prototype.yield = function _yield(to) { var params = this.popValue(); this.push(['yield', to, params]); - this.template.yields.add(to); + this.template.block.yields.add(to); }; JavaScriptCompiler.prototype.hasBlock = function hasBlock(name) { - this.pushValue(['hasBlock', name]); - this.template.yields.add(name); + this.pushValue(['has-block', name]); + this.template.block.yields.add(name); }; JavaScriptCompiler.prototype.hasBlockParams = function hasBlockParams(name) { - this.pushValue(['hasBlockParams', name]); - this.template.yields.add(name); + this.pushValue(['has-block-params', name]); + this.template.block.yields.add(name); }; /// Expressions JavaScriptCompiler.prototype.literal = function literal(value) { - this.pushValue(value); + if (value === undefined) { + this.pushValue(['undefined']); + } else { + this.pushValue(value); + } }; JavaScriptCompiler.prototype.unknown = function unknown(path) { this.pushValue(['unknown', path]); }; JavaScriptCompiler.prototype.arg = function arg(path) { - this.template.named.add(path[0]); + this.template.block.named.add(path[0]); this.pushValue(['arg', path]); }; - JavaScriptCompiler.prototype.selfGet = function selfGet(path) { - this.pushValue(['self-get', path]); - }; - JavaScriptCompiler.prototype.get = function get(path) { this.pushValue(['get', path]); }; JavaScriptCompiler.prototype.concat = function concat() { @@ -12208,15 +13161,17 @@ this.pushValue(values); }; JavaScriptCompiler.prototype.prepareObject = function prepareObject(size) { _glimmerUtil.assert(this.values.length >= size, "Expected " + size + " values on the stack, found " + this.values.length); - var object = _glimmerUtil.dict(); + var keys = new Array(size); + var values = new Array(size); for (var i = 0; i < size; i++) { - object[this.popValue()] = this.popValue(); + keys[i] = this.popValue(); + values[i] = this.popValue(); } - this.pushValue(object); + this.pushValue([keys, values]); }; /// Utilities JavaScriptCompiler.prototype.push = function push(args) { @@ -12238,42 +13193,33 @@ return JavaScriptCompiler; })(); exports.default = JavaScriptCompiler; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-compiler/lib/javascript-compiler.ts"],"names":[],"mappings":"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","file":"javascript-compiler.js","sourcesContent":["import { assert } from \"glimmer-util\";\nimport { Stack, DictSet, InternedString, dict } from \"glimmer-util\";\n\nimport {\n  BlockMeta,\n  SerializedBlock,\n  SerializedTemplate,\n  Core,\n  Statement,\n  Expression\n} from 'glimmer-wire-format';\n\ntype str = string;\ntype Params = Core.Params;\ntype Hash = Core.Hash;\ntype Path = Core.Path;\ntype StackValue = Expression | Params | Hash | str;\n\nexport class Block {\n  statements: Statement[] = [];\n  positionals: string[] = [];\n\n  toJSON(): SerializedBlock {\n    return {\n      statements: this.statements,\n      locals: this.positionals as InternedString[]\n    };\n  }\n\n  push(statement: Statement) {\n    this.statements.push(statement);\n  }\n}\n\nexport class Template extends Block {\n  public meta: BlockMeta = null;\n\n  public yields = new DictSet();\n  public named = new DictSet();\n  public blocks: Block[] = [];\n\n  constructor(meta) {\n    super();\n    this.meta = meta;\n  }\n\n  toJSON(): SerializedTemplate {\n    return {\n      statements: this.statements,\n      locals: this.positionals as InternedString[],\n      named: this.named.toArray(),\n      yields: this.yields.toArray(),\n      blocks: this.blocks.map(b => b.toJSON()),\n      meta: this.meta\n    };\n  }\n}\n\nexport default class JavaScriptCompiler {\n  static process(opcodes, meta): Template {\n    let compiler = new JavaScriptCompiler(opcodes, meta);\n    return compiler.process();\n  }\n\n  private template: Template = null;\n  private blocks = new Stack<Block>();\n  private opcodes: any[];\n  private values: StackValue[] = [];\n\n  constructor(opcodes, meta) {\n    this.opcodes = opcodes;\n    this.template = new Template(meta);\n  }\n\n  process() {\n    this.opcodes.forEach(([opcode, ...args]) => {\n      if (!this[opcode]) { throw new Error(`unimplemented ${opcode} on JavaScriptCompiler`); }\n      this[opcode](...args);\n    });\n\n    return this.template;\n  }\n\n  /// Nesting\n\n  startBlock([program]) {\n    let block: Block = new Block();\n    block.positionals = program.blockParams;\n    this.blocks.push(block);\n  }\n\n  endBlock() {\n    let { template, blocks } = this;\n    template.blocks.push(blocks.pop());\n  }\n\n  startProgram() {\n    this.blocks.push(this.template);\n  }\n\n  endProgram() {\n\n  }\n\n  /// Statements\n\n  text(content: string) {\n    this.push(['text', content]);\n  }\n\n  append(trusted: boolean) {\n    this.push(['append', this.popValue<Expression>(), trusted]);\n  }\n\n  comment(value: string) {\n    this.push(['comment', value]);\n  }\n\n  modifier(path: Path) {\n    let params = this.popValue<Params>();\n    let hash = this.popValue<Hash>();\n\n    this.push(['modifier', path, params, hash]);\n  }\n\n  block(path: Path, template: number, inverse: number) {\n    let params = this.popValue<Params>();\n    let hash = this.popValue<Hash>();\n\n    this.push(['block', path, params, hash, template, inverse]);\n  }\n\n  openElement(tag: str, blockParams: string[]) {\n    this.push(['openElement', tag, blockParams]);\n  }\n\n  closeElement() {\n    this.push(['closeElement']);\n  }\n\n  staticAttr(name: str, namespace: str) {\n    let value = this.popValue<Expression>();\n    this.push(['staticAttr', name, value, namespace]);\n  }\n\n  dynamicAttr(name: str, namespace: str) {\n    let value = this.popValue<Expression>();\n    this.push(['dynamicAttr', name, value, namespace]);\n  }\n\n  trustingAttr(name: str, namespace: str) {\n    let value = this.popValue<Expression>();\n    this.push(['trustingAttr', name, value, namespace]);\n  }\n\n  staticArg(name: str) {\n    let value = this.popValue<Expression>();\n    this.push(['staticArg', name.slice(1), value]);\n  }\n\n  dynamicArg(name: str) {\n    let value = this.popValue<Expression>();\n    this.push(['dynamicArg', name.slice(1), value]);\n  }\n\n  yield(to: string) {\n    let params = this.popValue<Params>();\n    this.push(['yield', to, params]);\n    this.template.yields.add(to);\n  }\n\n  hasBlock(name: string) {\n    this.pushValue(['hasBlock', name]);\n    this.template.yields.add(name);\n  }\n\n  hasBlockParams(name: string) {\n    this.pushValue(['hasBlockParams', name]);\n    this.template.yields.add(name);\n  }\n\n  /// Expressions\n\n  literal(value: any) {\n    this.pushValue(value);\n  }\n\n  unknown(path: string[]) {\n    this.pushValue(['unknown', path]);\n  }\n\n  arg(path: string[]) {\n    this.template.named.add(path[0]);\n    this.pushValue(['arg', path]);\n  }\n\n  selfGet(path: string[]) {\n    this.pushValue(['self-get', path]);\n  }\n\n  get(path: string[]) {\n    this.pushValue(['get', path]);\n  }\n\n  concat() {\n    this.pushValue(['concat', this.popValue<Params>()]);\n  }\n\n  helper(path: string[]) {\n    let params = this.popValue<Params>();\n    let hash = this.popValue<Hash>();\n\n    this.pushValue(['helper', path, params, hash]);\n  }\n\n  /// Stack Management Opcodes\n\n  prepareArray(size: number) {\n    let values = [];\n\n    for (let i = 0; i < size; i++) {\n      values.push(this.popValue());\n    }\n\n    this.pushValue(values);\n  }\n\n  prepareObject(size: number) {\n    assert(this.values.length >= size, `Expected ${size} values on the stack, found ${this.values.length}`);\n\n    let object = dict<Expression>();\n\n    for (let i = 0; i < size; i++) {\n      object[this.popValue<str>()] = this.popValue<Expression>();\n    }\n\n    this.pushValue(object);\n  }\n\n  /// Utilities\n\n  push(args: Statement) {\n    while (args[args.length - 1] === null) {\n      args.pop();\n    }\n\n    this.blocks.current.push(args);\n  }\n\n  pushValue(val: Expression | Params | Hash) {\n    this.values.push(val);\n  }\n\n  popValue<T extends StackValue>(): T {\n    assert(this.values.length, \"No expression found on stack\");\n    return this.values.pop() as T;\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-compiler/lib/javascript-compiler.ts"],"names":[],"mappings":"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","file":"javascript-compiler.js","sourcesContent":["import { assert } from \"glimmer-util\";\nimport { Stack, DictSet } from \"glimmer-util\";\n\nimport {\n  TemplateMeta,\n  SerializedBlock,\n  SerializedTemplateBlock,\n  SerializedTemplate,\n  Core,\n  Statement,\n  Expression,\n  Expressions\n} from 'glimmer-wire-format';\n\ntype str = string;\ntype Params = Core.Params;\ntype Hash = Core.Hash;\ntype Path = Core.Path;\ntype StackValue = Expression | Params | Hash | str;\n\nexport class Block {\n  statements: Statement[] = [];\n  positionals: string[] = [];\n\n  toJSON(): SerializedBlock {\n    return {\n      statements: this.statements,\n      locals: this.positionals\n    };\n  }\n\n  push(statement: Statement) {\n    this.statements.push(statement);\n  }\n}\n\nexport class TemplateBlock extends Block {\n  public yields = new DictSet();\n  public named = new DictSet();\n  public blocks: Block[] = [];\n\n  toJSON(): SerializedTemplateBlock {\n    return {\n      statements: this.statements,\n      locals: this.positionals,\n      named: this.named.toArray(),\n      yields: this.yields.toArray(),\n      blocks: this.blocks.map(b => b.toJSON())\n    };\n  }\n}\n\nexport class Template<T extends TemplateMeta> {\n  public block = new TemplateBlock();\n\n  constructor(public meta: T) {}\n\n  toJSON(): SerializedTemplate<T> {\n    return {\n      block: this.block.toJSON(),\n      meta: this.meta\n    };\n  }\n}\n\nexport default class JavaScriptCompiler<T extends TemplateMeta> {\n  static process<T extends TemplateMeta>(opcodes, meta): Template<T> {\n    let compiler = new JavaScriptCompiler<T>(opcodes, meta);\n    return compiler.process();\n  }\n\n  private template: Template<T>;\n  private blocks = new Stack<Block>();\n  private opcodes: any[];\n  private values: StackValue[] = [];\n\n  constructor(opcodes, meta: T) {\n    this.opcodes = opcodes;\n    this.template = new Template(meta);\n  }\n\n  process(): Template<T> {\n    this.opcodes.forEach(([opcode, ...args]) => {\n      if (!this[opcode]) { throw new Error(`unimplemented ${opcode} on JavaScriptCompiler`); }\n      this[opcode](...args);\n    });\n\n    return this.template;\n  }\n\n  /// Nesting\n\n  startBlock([program]) {\n    let block: Block = new Block();\n    block.positionals = program.blockParams;\n    this.blocks.push(block);\n  }\n\n  endBlock() {\n    let { template, blocks } = this;\n    template.block.blocks.push(blocks.pop());\n  }\n\n  startProgram() {\n    this.blocks.push(this.template.block);\n  }\n\n  endProgram() {\n\n  }\n\n  /// Statements\n\n  text(content: string) {\n    this.push(['text', content]);\n  }\n\n  append(trusted: boolean) {\n    this.push(['append', this.popValue<Expression>(), trusted]);\n  }\n\n  comment(value: string) {\n    this.push(['comment', value]);\n  }\n\n  modifier(path: Path) {\n    let params = this.popValue<Params>();\n    let hash = this.popValue<Hash>();\n\n    this.push(['modifier', path, params, hash]);\n  }\n\n  block(path: Path, template: number, inverse: number) {\n    let params = this.popValue<Params>();\n    let hash = this.popValue<Hash>();\n\n    this.push(['block', path, params, hash, template, inverse]);\n  }\n\n  openElement(tag: str, blockParams: string[]) {\n    this.push(['open-element', tag, blockParams]);\n  }\n\n  flushElement() {\n    this.push(['flush-element']);\n  }\n\n  closeElement() {\n    this.push(['close-element']);\n  }\n\n  staticAttr(name: str, namespace: str) {\n    let value = this.popValue<Expression>();\n    this.push(['static-attr', name, value, namespace]);\n  }\n\n  dynamicAttr(name: str, namespace: str) {\n    let value = this.popValue<Expression>();\n    this.push(['dynamic-attr', name, value, namespace]);\n  }\n\n  trustingAttr(name: str, namespace: str) {\n    let value = this.popValue<Expression>();\n    this.push(['trusting-attr', name, value, namespace]);\n  }\n\n  staticArg(name: str) {\n    let value = this.popValue<Expression>();\n    this.push(['static-arg', name.slice(1), value]);\n  }\n\n  dynamicArg(name: str) {\n    let value = this.popValue<Expression>();\n    this.push(['dynamic-arg', name.slice(1), value]);\n  }\n\n  yield(to: string) {\n    let params = this.popValue<Params>();\n    this.push(['yield', to, params]);\n    this.template.block.yields.add(to);\n  }\n\n  hasBlock(name: string) {\n    this.pushValue<Expressions.HasBlock>(['has-block', name]);\n    this.template.block.yields.add(name);\n  }\n\n  hasBlockParams(name: string) {\n    this.pushValue<Expressions.HasBlockParams>(['has-block-params', name]);\n    this.template.block.yields.add(name);\n  }\n\n  /// Expressions\n\n  literal(value: Expressions.Value | undefined) {\n    if (value === undefined) {\n      this.pushValue<Expressions.Undefined>(['undefined']);\n    } else {\n      this.pushValue<Expressions.Value>(value);\n    }\n  }\n\n  unknown(path: string[]) {\n    this.pushValue<Expressions.Unknown>(['unknown', path]);\n  }\n\n  arg(path: string[]) {\n    this.template.block.named.add(path[0]);\n    this.pushValue<Expressions.Arg>(['arg', path]);\n  }\n\n  get(path: string[]) {\n    this.pushValue<Expressions.Get>(['get', path]);\n  }\n\n  concat() {\n    this.pushValue<Expressions.Concat>(['concat', this.popValue<Params>()]);\n  }\n\n  helper(path: string[]) {\n    let params = this.popValue<Params>();\n    let hash = this.popValue<Hash>();\n\n    this.pushValue<Expressions.Helper>(['helper', path, params, hash]);\n  }\n\n  /// Stack Management Opcodes\n\n  prepareArray(size: number) {\n    let values = [];\n\n    for (let i = 0; i < size; i++) {\n      values.push(this.popValue());\n    }\n\n    this.pushValue<Params>(values);\n  }\n\n  prepareObject(size: number) {\n    assert(this.values.length >= size, `Expected ${size} values on the stack, found ${this.values.length}`);\n\n    let keys: string[] = new Array(size);\n    let values: Expression[] = new Array(size);\n\n    for (let i = 0; i < size; i++) {\n      keys[i] = this.popValue<str>();\n      values[i] = this.popValue<Expression>();\n    }\n\n    this.pushValue<Hash>([keys, values]);\n  }\n\n  /// Utilities\n\n  push(args: Statement) {\n    while (args[args.length - 1] === null) {\n      args.pop();\n    }\n\n    this.blocks.current.push(args);\n  }\n\n  pushValue<S extends Expression | Params | Hash>(val: S) {\n    this.values.push(val);\n  }\n\n  popValue<T extends StackValue>(): T {\n    assert(this.values.length, \"No expression found on stack\");\n    return this.values.pop() as T;\n  }\n}\n","import { assert } from \"glimmer-util\";\nimport { Stack, DictSet } from \"glimmer-util\";\nexport class Block {\n    constructor() {\n        this.statements = [];\n        this.positionals = [];\n    }\n    toJSON() {\n        return {\n            statements: this.statements,\n            locals: this.positionals\n        };\n    }\n    push(statement) {\n        this.statements.push(statement);\n    }\n}\nexport class TemplateBlock extends Block {\n    constructor() {\n        super(...arguments);\n        this.yields = new DictSet();\n        this.named = new DictSet();\n        this.blocks = [];\n    }\n    toJSON() {\n        return {\n            statements: this.statements,\n            locals: this.positionals,\n            named: this.named.toArray(),\n            yields: this.yields.toArray(),\n            blocks: this.blocks.map(b => b.toJSON())\n        };\n    }\n}\nexport class Template {\n    constructor(meta) {\n        this.meta = meta;\n        this.block = new TemplateBlock();\n    }\n    toJSON() {\n        return {\n            block: this.block.toJSON(),\n            meta: this.meta\n        };\n    }\n}\nexport default class JavaScriptCompiler {\n    constructor(opcodes, meta) {\n        this.blocks = new Stack();\n        this.values = [];\n        this.opcodes = opcodes;\n        this.template = new Template(meta);\n    }\n    static process(opcodes, meta) {\n        let compiler = new JavaScriptCompiler(opcodes, meta);\n        return compiler.process();\n    }\n    process() {\n        this.opcodes.forEach(([opcode, ...args]) => {\n            if (!this[opcode]) {\n                throw new Error(`unimplemented ${opcode} on JavaScriptCompiler`);\n            }\n            this[opcode](...args);\n        });\n        return this.template;\n    }\n    /// Nesting\n    startBlock([program]) {\n        let block = new Block();\n        block.positionals = program.blockParams;\n        this.blocks.push(block);\n    }\n    endBlock() {\n        let { template, blocks } = this;\n        template.block.blocks.push(blocks.pop());\n    }\n    startProgram() {\n        this.blocks.push(this.template.block);\n    }\n    endProgram() {\n    }\n    /// Statements\n    text(content) {\n        this.push(['text', content]);\n    }\n    append(trusted) {\n        this.push(['append', this.popValue(), trusted]);\n    }\n    comment(value) {\n        this.push(['comment', value]);\n    }\n    modifier(path) {\n        let params = this.popValue();\n        let hash = this.popValue();\n        this.push(['modifier', path, params, hash]);\n    }\n    block(path, template, inverse) {\n        let params = this.popValue();\n        let hash = this.popValue();\n        this.push(['block', path, params, hash, template, inverse]);\n    }\n    openElement(tag, blockParams) {\n        this.push(['open-element', tag, blockParams]);\n    }\n    flushElement() {\n        this.push(['flush-element']);\n    }\n    closeElement() {\n        this.push(['close-element']);\n    }\n    staticAttr(name, namespace) {\n        let value = this.popValue();\n        this.push(['static-attr', name, value, namespace]);\n    }\n    dynamicAttr(name, namespace) {\n        let value = this.popValue();\n        this.push(['dynamic-attr', name, value, namespace]);\n    }\n    trustingAttr(name, namespace) {\n        let value = this.popValue();\n        this.push(['trusting-attr', name, value, namespace]);\n    }\n    staticArg(name) {\n        let value = this.popValue();\n        this.push(['static-arg', name.slice(1), value]);\n    }\n    dynamicArg(name) {\n        let value = this.popValue();\n        this.push(['dynamic-arg', name.slice(1), value]);\n    }\n    yield(to) {\n        let params = this.popValue();\n        this.push(['yield', to, params]);\n        this.template.block.yields.add(to);\n    }\n    hasBlock(name) {\n        this.pushValue(['has-block', name]);\n        this.template.block.yields.add(name);\n    }\n    hasBlockParams(name) {\n        this.pushValue(['has-block-params', name]);\n        this.template.block.yields.add(name);\n    }\n    /// Expressions\n    literal(value) {\n        if (value === undefined) {\n            this.pushValue(['undefined']);\n        }\n        else {\n            this.pushValue(value);\n        }\n    }\n    unknown(path) {\n        this.pushValue(['unknown', path]);\n    }\n    arg(path) {\n        this.template.block.named.add(path[0]);\n        this.pushValue(['arg', path]);\n    }\n    get(path) {\n        this.pushValue(['get', path]);\n    }\n    concat() {\n        this.pushValue(['concat', this.popValue()]);\n    }\n    helper(path) {\n        let params = this.popValue();\n        let hash = this.popValue();\n        this.pushValue(['helper', path, params, hash]);\n    }\n    /// Stack Management Opcodes\n    prepareArray(size) {\n        let values = [];\n        for (let i = 0; i < size; i++) {\n            values.push(this.popValue());\n        }\n        this.pushValue(values);\n    }\n    prepareObject(size) {\n        assert(this.values.length >= size, `Expected ${size} values on the stack, found ${this.values.length}`);\n        let keys = new Array(size);\n        let values = new Array(size);\n        for (let i = 0; i < size; i++) {\n            keys[i] = this.popValue();\n            values[i] = this.popValue();\n        }\n        this.pushValue([keys, values]);\n    }\n    /// Utilities\n    push(args) {\n        while (args[args.length - 1] === null) {\n            args.pop();\n        }\n        this.blocks.current.push(args);\n    }\n    pushValue(val) {\n        this.values.push(val);\n    }\n    popValue() {\n        assert(this.values.length, \"No expression found on stack\");\n        return this.values.pop();\n    }\n}\n"]} enifed("glimmer-compiler/lib/template-compiler", ["exports", "glimmer-compiler/lib/template-visitor", "glimmer-compiler/lib/javascript-compiler", "glimmer-util", "glimmer-syntax"], function (exports, _glimmerCompilerLibTemplateVisitor, _glimmerCompilerLibJavascriptCompiler, _glimmerUtil, _glimmerSyntax) { "use strict"; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - function isTrustedValue(value) { return value.escaped !== undefined && !value.escaped; } var TemplateCompiler = (function () { - function TemplateCompiler() { - var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; - - _classCallCheck(this, TemplateCompiler); - + function TemplateCompiler(options) { this.templateId = 0; this.templateIds = []; this.opcodes = []; this.includeMeta = false; - this.options = options; + this.options = options || {}; } TemplateCompiler.compile = function compile(options, ast) { var templateVisitor = new _glimmerCompilerLibTemplateVisitor.default(); templateVisitor.visit(ast); var compiler = new TemplateCompiler(options); var opcodes = compiler.process(templateVisitor.actions); - var meta = { - moduleName: options.moduleName - }; - return _glimmerCompilerLibJavascriptCompiler.default.process(opcodes, meta); + return _glimmerCompilerLibJavascriptCompiler.default.process(opcodes, options.meta); }; TemplateCompiler.prototype.process = function process(actions) { var _this = this; @@ -12328,10 +13274,11 @@ this.attribute([action.attributes[i]]); } for (var i = 0; i < action.modifiers.length; i++) { this.modifier([action.modifiers[i]]); } + this.opcode('flushElement', null); }; TemplateCompiler.prototype.closeElement = function closeElement() { this.opcode('closeElement', null); }; @@ -12412,12 +13359,10 @@ } else if (isArg(expr)) { this.arg([expr.path]); } else if (_glimmerSyntax.isHelper(expr)) { this.prepareHelper(expr); this.opcode('helper', expr, expr.path.parts); - } else if (_glimmerSyntax.isSelfGet(expr)) { - this.opcode('selfGet', expr, expr.path.parts); } else { this.opcode('unknown', expr, expr.path.parts); } }; @@ -12664,21 +13609,17 @@ } else { throw new Error("has-block-params only takes a single positional argument"); } } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-compiler/lib/template-compiler.ts"],"names":[],"mappings":"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","file":"template-compiler.js","sourcesContent":["import TemplateVisitor from \"./template-visitor\";\nimport JavaScriptCompiler from \"./javascript-compiler\";\nimport { FIXME, getAttrNamespace } from \"glimmer-util\";\nimport { isHelper, isSelfGet } from \"glimmer-syntax\";\nimport { assert } from \"glimmer-util\";\n\nexport interface CompileOptions {\n  buildMeta?: FIXME<'currently does nothing'>;\n  moduleName?: string;\n}\n\nfunction isTrustedValue(value) {\n  return value.escaped !== undefined && !value.escaped;\n}\n\nexport default class TemplateCompiler {\n  static compile(options: CompileOptions, ast) {\n    let templateVisitor = new TemplateVisitor();\n    templateVisitor.visit(ast);\n\n    let compiler = new TemplateCompiler(options);\n    let opcodes = compiler.process(templateVisitor.actions);\n    let meta = {\n      moduleName: options.moduleName\n    };\n    return JavaScriptCompiler.process(opcodes, meta);\n  }\n\n  private options: CompileOptions;\n  private templateId = 0;\n  private templateIds: number[] = [];\n  private opcodes: any[] = [];\n  private includeMeta = false;\n\n  constructor(options: CompileOptions = {}) {\n    this.options = options;\n  }\n\n  process(actions): any[] {\n    actions.forEach(([name, ...args]) => {\n      if (!this[name]) { throw new Error(`Unimplemented ${name} on TemplateCompiler`); }\n      this[name](...args);\n    });\n    return this.opcodes;\n  }\n\n  startProgram(program) {\n    this.opcode('startProgram', program, program);\n  }\n\n  endProgram() {\n    this.opcode('endProgram', null);\n  }\n\n  startBlock(program) {\n    this.templateId++;\n    this.opcode('startBlock', program, program);\n  }\n\n  endBlock() {\n    this.templateIds.push(this.templateId - 1);\n    this.opcode('endBlock', null);\n  }\n\n  text([action]) {\n    this.opcode('text', action, action.chars);\n  }\n\n  comment([action]) {\n    this.opcode('comment', action, action.value);\n  }\n\n  openElement([action]) {\n    this.opcode('openElement', action, action.tag, action.blockParams);\n    for (let i = 0; i < action.attributes.length; i++) {\n      this.attribute([action.attributes[i]]);\n    }\n\n    for (let i = 0; i < action.modifiers.length; i++) {\n      this.modifier([action.modifiers[i]]);\n    }\n  }\n\n  closeElement() {\n    this.opcode('closeElement', null);\n  }\n\n  attribute([action]) {\n    let { name, value } = action;\n\n    let namespace = getAttrNamespace(name);\n\n    let isStatic = this.prepareAttributeValue(value);\n\n    if (name.charAt(0) === '@') {\n      // Arguments\n      if (isStatic) {\n        this.opcode('staticArg', action, name);\n      } else if (action.value.type === 'MustacheStatement') {\n        this.opcode('dynamicArg', action, name);\n      } else {\n        this.opcode('dynamicArg', action, name);\n      }\n    } else {\n      let isTrusting = isTrustedValue(value);\n\n      if (isStatic) {\n        this.opcode('staticAttr', action, name, namespace);\n      } else if (isTrusting) {\n        this.opcode('trustingAttr', action, name, namespace);\n      } else if (action.value.type === 'MustacheStatement') {\n        this.opcode('dynamicAttr', action, name);\n      } else {\n        this.opcode('dynamicAttr', action, name, namespace);\n      }\n    }\n  }\n\n  modifier([action]) {\n    let { path: { parts } } = action;\n\n    this.prepareHelper(action);\n    this.opcode('modifier', action, parts);\n  }\n\n  mustache([action]) {\n    if (isYield(action)) {\n      let to = assertValidYield(action);\n      this.yield(to, action);\n    } else {\n      this.mustacheExpression(action);\n      this.opcode('append', action, !action.escaped);\n    }\n  }\n\n  block([action/*, index, count*/]) {\n    this.prepareHelper(action);\n    let templateId = this.templateIds.pop();\n    let inverseId = action.inverse === null ? null : this.templateIds.pop();\n    this.opcode('block', action, action.path.parts, templateId, inverseId);\n  }\n\n  /// Internal actions, not found in the original processed actions\n\n  arg([path]) {\n    let { parts } = path;\n    this.opcode('arg', path, parts);\n  }\n\n  mustacheExpression(expr) {\n    if (isBuiltInHelper(expr)) {\n      this.builtInHelper(expr);\n    } else if (isLiteral(expr)) {\n      this.opcode('literal', expr, expr.path.value);\n    } else if (isArg(expr)) {\n      this.arg([expr.path]);\n    } else if (isHelper(expr)) {\n      this.prepareHelper(expr);\n      this.opcode('helper', expr, expr.path.parts);\n    } else if (isSelfGet(expr)) {\n      this.opcode('selfGet', expr, expr.path.parts);\n    } else {\n      this.opcode('unknown', expr, expr.path.parts);\n    }\n  }\n\n  /// Internal Syntax\n\n  yield(to: string, action) {\n    this.prepareParams(action.params);\n    this.opcode('yield', action, to);\n  }\n\n  hasBlock(name: string, action) {\n    this.opcode('hasBlock', action, name);\n  }\n\n  hasBlockParams(name: string, action) {\n    this.opcode('hasBlockParams', action, name);\n  }\n\n  builtInHelper(expr) {\n    if (isHasBlock(expr)) {\n      let name = assertValidHasBlock(expr);\n      this.hasBlock(name, expr);\n    } else if (isHasBlockParams(expr)) {\n      let name = assertValidHasBlockParams(expr);\n      this.hasBlockParams(name, expr);\n    }\n  }\n\n  /// Expressions, invoked recursively from prepareParams and prepareHash\n\n  SubExpression(expr) {\n    if (isBuiltInHelper(expr)) {\n      this.builtInHelper(expr);\n    } else {\n      this.prepareHelper(expr);\n      this.opcode('helper', expr, expr.path.parts);\n    }\n  }\n\n  PathExpression(expr) {\n    if (expr.data) {\n      this.arg([expr]);\n    } else {\n      this.opcode('get', expr, expr.parts);\n    }\n  }\n\n  StringLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  BooleanLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  NumberLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  NullLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  UndefinedLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  /// Utilities\n\n  opcode(name, action, ...args) {\n    let opcode = [name, ...args];\n    if (this.includeMeta && action) {\n      opcode.push(this.meta(action));\n    }\n\n    this.opcodes.push(opcode);\n  }\n\n  prepareHelper({ params, hash }) {\n    this.prepareHash(hash);\n    this.prepareParams(params);\n  }\n\n  preparePath(path) {\n    this.opcode('literal', path, path.parts);\n  }\n\n  prepareParams(params) {\n    if (!params.length) {\n      this.opcode('literal', null, null);\n      return;\n    }\n\n    for (let i = params.length - 1; i >= 0; i--) {\n      let param = params[i];\n\n      assert(this[param.type], `Unimplemented ${param.type} on TemplateCompiler`);\n      this[param.type](param);\n    }\n\n    this.opcode('prepareArray', null, params.length);\n  }\n\n  prepareHash(hash) {\n    let pairs = hash.pairs;\n\n    if (!pairs.length) {\n      this.opcode('literal', null, null);\n      return;\n    }\n\n    for (let i = pairs.length - 1; i >= 0; i--) {\n      let { key, value } = pairs[i];\n\n      assert(this[value.type], `Unimplemented ${value.type} on TemplateCompiler`);\n      this[value.type](value);\n      this.opcode('literal', null, key);\n    }\n\n    this.opcode('prepareObject', null, pairs.length);\n  }\n\n  prepareAttributeValue(value) {\n    // returns the static value if the value is static\n\n    switch (value.type) {\n      case 'TextNode':\n        this.opcode('literal', value, value.chars);\n        return true;\n      case 'MustacheStatement':\n        this.attributeMustache([value]);\n        return false;\n      case 'ConcatStatement':\n        this.prepareConcatParts(value.parts);\n        this.opcode('concat', value);\n        return false;\n    }\n  }\n\n  prepareConcatParts(parts) {\n    for (let i = parts.length - 1; i >= 0; i--) {\n      let part = parts[i];\n\n      if (part.type === 'MustacheStatement') {\n        this.attributeMustache([part]);\n      } else if (part.type === 'TextNode') {\n        this.opcode('literal', null, part.chars);\n      }\n    }\n\n    this.opcode('prepareArray', null, parts.length);\n  }\n\n  attributeMustache([action]) {\n    this.mustacheExpression(action);\n  }\n\n  meta(node) {\n    let loc = node.loc;\n    if (!loc) { return []; }\n\n    let { source, start, end } = loc;\n    return [ 'loc', [source || null, [start.line, start.column], [end.line, end.column]] ];\n  }\n}\n\nfunction isYield({ path }) {\n  return path.original === 'yield';\n}\n\nfunction isArg({ path }) {\n  return path.data;\n}\n\nfunction isLiteral({ path }) {\n  return path.type === 'StringLiteral'\n      || path.type === 'BooleanLiteral'\n      || path.type === 'NumberLiteral'\n      || path.type === 'NullLiteral'\n      || path.type === 'UndefinedLiteral';\n}\n\nfunction isHasBlock({ path }) {\n  return path.original === 'has-block';\n}\n\nfunction isHasBlockParams({ path }) {\n  return path.original === 'has-block-params';\n}\n\nfunction isBuiltInHelper(expr) {\n  return isHasBlock(expr)\n      || isHasBlockParams(expr);\n}\n\nfunction assertValidYield({ hash }): string {\n  let pairs = hash.pairs;\n\n  if ((pairs.length === 1 && pairs[0].key !== 'to') || pairs.length > 1) {\n    throw new Error(`yield only takes a single named argument: 'to'`);\n  } else if (pairs.length === 1 && pairs[0].value.type !== 'StringLiteral') {\n    throw new Error(`you can only yield to a literal value`);\n  } else if (pairs.length === 0) {\n    return 'default';\n  } else {\n    return pairs[0].value.value;\n  }\n}\n\nfunction assertValidHasBlock({ params }): string {\n  if (params.length === 0) {\n    return 'default';\n  } else if (params.length === 1) {\n    if (params[0].type === 'StringLiteral') {\n      return params[0].value;\n    } else {\n      throw new Error(`you can only yield to a literal value`);\n    }\n  } else {\n    throw new Error(`has-block only takes a single positional argument`);\n  }\n}\n\nfunction assertValidHasBlockParams({ params }): string {\n  if (params.length === 0) {\n    return 'default';\n  } else if (params.length === 1) {\n    if (params[0].type === 'StringLiteral') {\n      return params[0].value;\n    } else {\n      throw new Error(`you can only yield to a literal value`);\n    }\n  } else {\n    throw new Error(`has-block-params only takes a single positional argument`);\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-compiler/lib/template-compiler.ts"],"names":[],"mappings":"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","file":"template-compiler.js","sourcesContent":["import TemplateVisitor from \"./template-visitor\";\nimport JavaScriptCompiler, { Template } from \"./javascript-compiler\";\nimport { getAttrNamespace } from \"glimmer-util\";\nimport { isHelper } from \"glimmer-syntax\";\nimport { assert } from \"glimmer-util\";\nimport { TemplateMeta } from \"glimmer-wire-format\";\n\nexport interface CompileOptions<T extends TemplateMeta> {\n  meta?: T;\n}\n\nfunction isTrustedValue(value) {\n  return value.escaped !== undefined && !value.escaped;\n}\n\nexport default class TemplateCompiler<T extends TemplateMeta> {\n  static compile<T>(options: CompileOptions<T>, ast): Template<T> {\n    let templateVisitor = new TemplateVisitor();\n    templateVisitor.visit(ast);\n\n    let compiler = new TemplateCompiler(options);\n    let opcodes = compiler.process(templateVisitor.actions);\n    return JavaScriptCompiler.process<T>(opcodes, options.meta);\n  }\n\n  private options: CompileOptions<T>;\n  private templateId = 0;\n  private templateIds: number[] = [];\n  private opcodes: any[] = [];\n  private includeMeta = false;\n\n  constructor(options: CompileOptions<T>) {\n    this.options = options || {};\n  }\n\n  process(actions): any[] {\n    actions.forEach(([name, ...args]) => {\n      if (!this[name]) { throw new Error(`Unimplemented ${name} on TemplateCompiler`); }\n      this[name](...args);\n    });\n    return this.opcodes;\n  }\n\n  startProgram(program) {\n    this.opcode('startProgram', program, program);\n  }\n\n  endProgram() {\n    this.opcode('endProgram', null);\n  }\n\n  startBlock(program) {\n    this.templateId++;\n    this.opcode('startBlock', program, program);\n  }\n\n  endBlock() {\n    this.templateIds.push(this.templateId - 1);\n    this.opcode('endBlock', null);\n  }\n\n  text([action]) {\n    this.opcode('text', action, action.chars);\n  }\n\n  comment([action]) {\n    this.opcode('comment', action, action.value);\n  }\n\n  openElement([action]) {\n    this.opcode('openElement', action, action.tag, action.blockParams);\n    for (let i = 0; i < action.attributes.length; i++) {\n      this.attribute([action.attributes[i]]);\n    }\n\n    for (let i = 0; i < action.modifiers.length; i++) {\n      this.modifier([action.modifiers[i]]);\n    }\n    this.opcode('flushElement', null);\n  }\n\n  closeElement() {\n    this.opcode('closeElement', null);\n  }\n\n  attribute([action]) {\n    let { name, value } = action;\n\n    let namespace = getAttrNamespace(name);\n\n    let isStatic = this.prepareAttributeValue(value);\n\n    if (name.charAt(0) === '@') {\n      // Arguments\n      if (isStatic) {\n        this.opcode('staticArg', action, name);\n      } else if (action.value.type === 'MustacheStatement') {\n        this.opcode('dynamicArg', action, name);\n      } else {\n        this.opcode('dynamicArg', action, name);\n      }\n    } else {\n      let isTrusting = isTrustedValue(value);\n\n      if (isStatic) {\n        this.opcode('staticAttr', action, name, namespace);\n      } else if (isTrusting) {\n        this.opcode('trustingAttr', action, name, namespace);\n      } else if (action.value.type === 'MustacheStatement') {\n        this.opcode('dynamicAttr', action, name);\n      } else {\n        this.opcode('dynamicAttr', action, name, namespace);\n      }\n    }\n  }\n\n  modifier([action]) {\n    let { path: { parts } } = action;\n\n    this.prepareHelper(action);\n    this.opcode('modifier', action, parts);\n  }\n\n  mustache([action]) {\n    if (isYield(action)) {\n      let to = assertValidYield(action);\n      this.yield(to, action);\n    } else {\n      this.mustacheExpression(action);\n      this.opcode('append', action, !action.escaped);\n    }\n  }\n\n  block([action/*, index, count*/]) {\n    this.prepareHelper(action);\n    let templateId = this.templateIds.pop();\n    let inverseId = action.inverse === null ? null : this.templateIds.pop();\n    this.opcode('block', action, action.path.parts, templateId, inverseId);\n  }\n\n  /// Internal actions, not found in the original processed actions\n\n  arg([path]) {\n    let { parts } = path;\n    this.opcode('arg', path, parts);\n  }\n\n  mustacheExpression(expr) {\n    if (isBuiltInHelper(expr)) {\n      this.builtInHelper(expr);\n    } else if (isLiteral(expr)) {\n      this.opcode('literal', expr, expr.path.value);\n    } else if (isArg(expr)) {\n      this.arg([expr.path]);\n    } else if (isHelper(expr)) {\n      this.prepareHelper(expr);\n      this.opcode('helper', expr, expr.path.parts);\n    } else {\n      this.opcode('unknown', expr, expr.path.parts);\n    }\n  }\n\n  /// Internal Syntax\n\n  yield(to: string, action) {\n    this.prepareParams(action.params);\n    this.opcode('yield', action, to);\n  }\n\n  hasBlock(name: string, action) {\n    this.opcode('hasBlock', action, name);\n  }\n\n  hasBlockParams(name: string, action) {\n    this.opcode('hasBlockParams', action, name);\n  }\n\n  builtInHelper(expr) {\n    if (isHasBlock(expr)) {\n      let name = assertValidHasBlock(expr);\n      this.hasBlock(name, expr);\n    } else if (isHasBlockParams(expr)) {\n      let name = assertValidHasBlockParams(expr);\n      this.hasBlockParams(name, expr);\n    }\n  }\n\n  /// Expressions, invoked recursively from prepareParams and prepareHash\n\n  SubExpression(expr) {\n    if (isBuiltInHelper(expr)) {\n      this.builtInHelper(expr);\n    } else {\n      this.prepareHelper(expr);\n      this.opcode('helper', expr, expr.path.parts);\n    }\n  }\n\n  PathExpression(expr) {\n    if (expr.data) {\n      this.arg([expr]);\n    } else {\n      this.opcode('get', expr, expr.parts);\n    }\n  }\n\n  StringLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  BooleanLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  NumberLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  NullLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  UndefinedLiteral(action) {\n    this.opcode('literal', null, action.value);\n  }\n\n  /// Utilities\n\n  opcode(name, action, ...args) {\n    let opcode = [name, ...args];\n    if (this.includeMeta && action) {\n      opcode.push(this.meta(action));\n    }\n\n    this.opcodes.push(opcode);\n  }\n\n  prepareHelper({ params, hash }) {\n    this.prepareHash(hash);\n    this.prepareParams(params);\n  }\n\n  preparePath(path) {\n    this.opcode('literal', path, path.parts);\n  }\n\n  prepareParams(params) {\n    if (!params.length) {\n      this.opcode('literal', null, null);\n      return;\n    }\n\n    for (let i = params.length - 1; i >= 0; i--) {\n      let param = params[i];\n\n      assert(this[param.type], `Unimplemented ${param.type} on TemplateCompiler`);\n      this[param.type](param);\n    }\n\n    this.opcode('prepareArray', null, params.length);\n  }\n\n  prepareHash(hash) {\n    let pairs = hash.pairs;\n\n    if (!pairs.length) {\n      this.opcode('literal', null, null);\n      return;\n    }\n\n    for (let i = pairs.length - 1; i >= 0; i--) {\n      let { key, value } = pairs[i];\n\n      assert(this[value.type], `Unimplemented ${value.type} on TemplateCompiler`);\n      this[value.type](value);\n      this.opcode('literal', null, key);\n    }\n\n    this.opcode('prepareObject', null, pairs.length);\n  }\n\n  prepareAttributeValue(value) {\n    // returns the static value if the value is static\n\n    switch (value.type) {\n      case 'TextNode':\n        this.opcode('literal', value, value.chars);\n        return true;\n      case 'MustacheStatement':\n        this.attributeMustache([value]);\n        return false;\n      case 'ConcatStatement':\n        this.prepareConcatParts(value.parts);\n        this.opcode('concat', value);\n        return false;\n    }\n  }\n\n  prepareConcatParts(parts) {\n    for (let i = parts.length - 1; i >= 0; i--) {\n      let part = parts[i];\n\n      if (part.type === 'MustacheStatement') {\n        this.attributeMustache([part]);\n      } else if (part.type === 'TextNode') {\n        this.opcode('literal', null, part.chars);\n      }\n    }\n\n    this.opcode('prepareArray', null, parts.length);\n  }\n\n  attributeMustache([action]) {\n    this.mustacheExpression(action);\n  }\n\n  meta(node) {\n    let loc = node.loc;\n    if (!loc) { return []; }\n\n    let { source, start, end } = loc;\n    return [ 'loc', [source || null, [start.line, start.column], [end.line, end.column]] ];\n  }\n}\n\nfunction isYield({ path }) {\n  return path.original === 'yield';\n}\n\nfunction isArg({ path }) {\n  return path.data;\n}\n\nfunction isLiteral({ path }) {\n  return path.type === 'StringLiteral'\n      || path.type === 'BooleanLiteral'\n      || path.type === 'NumberLiteral'\n      || path.type === 'NullLiteral'\n      || path.type === 'UndefinedLiteral';\n}\n\nfunction isHasBlock({ path }) {\n  return path.original === 'has-block';\n}\n\nfunction isHasBlockParams({ path }) {\n  return path.original === 'has-block-params';\n}\n\nfunction isBuiltInHelper(expr) {\n  return isHasBlock(expr)\n      || isHasBlockParams(expr);\n}\n\nfunction assertValidYield({ hash }): string {\n  let pairs = hash.pairs;\n\n  if ((pairs.length === 1 && pairs[0].key !== 'to') || pairs.length > 1) {\n    throw new Error(`yield only takes a single named argument: 'to'`);\n  } else if (pairs.length === 1 && pairs[0].value.type !== 'StringLiteral') {\n    throw new Error(`you can only yield to a literal value`);\n  } else if (pairs.length === 0) {\n    return 'default';\n  } else {\n    return pairs[0].value.value;\n  }\n}\n\nfunction assertValidHasBlock({ params }): string {\n  if (params.length === 0) {\n    return 'default';\n  } else if (params.length === 1) {\n    if (params[0].type === 'StringLiteral') {\n      return params[0].value;\n    } else {\n      throw new Error(`you can only yield to a literal value`);\n    }\n  } else {\n    throw new Error(`has-block only takes a single positional argument`);\n  }\n}\n\nfunction assertValidHasBlockParams({ params }): string {\n  if (params.length === 0) {\n    return 'default';\n  } else if (params.length === 1) {\n    if (params[0].type === 'StringLiteral') {\n      return params[0].value;\n    } else {\n      throw new Error(`you can only yield to a literal value`);\n    }\n  } else {\n    throw new Error(`has-block-params only takes a single positional argument`);\n  }\n}\n"]} enifed('glimmer-compiler/lib/template-visitor', ['exports'], function (exports) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var push = Array.prototype.push; var Frame = function Frame() { - _classCallCheck(this, Frame); - this.parentNode = null; this.children = null; this.childIndex = null; this.childCount = null; this.childTemplateCount = 0; @@ -12870,11 +13811,11 @@ } } return -1; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-compiler/lib/template-visitor.ts"],"names":[],"mappings":"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","file":"template-visitor.js","sourcesContent":["let push = Array.prototype.push;\n\nclass Frame {\n  public parentNode: Object = null;\n  public children: Object = null;\n  public childIndex: number = null;\n  public childCount: number = null;\n  public childTemplateCount: number = 0;\n  public mustacheCount: number = 0;\n  public actions: any[] = [];\n  public blankChildTextNodes: number[] = null;\n}\n\n/**\n * Takes in an AST and outputs a list of actions to be consumed\n * by a compiler. For example, the template\n *\n *     foo{{bar}}<div>baz</div>\n *\n * produces the actions\n *\n *     [['startProgram', [programNode, 0]],\n *      ['text', [textNode, 0, 3]],\n *      ['mustache', [mustacheNode, 1, 3]],\n *      ['openElement', [elementNode, 2, 3, 0]],\n *      ['text', [textNode, 0, 1]],\n *      ['closeElement', [elementNode, 2, 3],\n *      ['endProgram', [programNode]]]\n *\n * This visitor walks the AST depth first and backwards. As\n * a result the bottom-most child template will appear at the\n * top of the actions list whereas the root template will appear\n * at the bottom of the list. For example,\n *\n *     <div>{{#if}}foo{{else}}bar<b></b>{{/if}}</div>\n *\n * produces the actions\n *\n *     [['startProgram', [programNode, 0]],\n *      ['text', [textNode, 0, 2, 0]],\n *      ['openElement', [elementNode, 1, 2, 0]],\n *      ['closeElement', [elementNode, 1, 2]],\n *      ['endProgram', [programNode]],\n *      ['startProgram', [programNode, 0]],\n *      ['text', [textNode, 0, 1]],\n *      ['endProgram', [programNode]],\n *      ['startProgram', [programNode, 2]],\n *      ['openElement', [elementNode, 0, 1, 1]],\n *      ['block', [blockNode, 0, 1]],\n *      ['closeElement', [elementNode, 0, 1]],\n *      ['endProgram', [programNode]]]\n *\n * The state of the traversal is maintained by a stack of frames.\n * Whenever a node with children is entered (either a ProgramNode\n * or an ElementNode) a frame is pushed onto the stack. The frame\n * contains information about the state of the traversal of that\n * node. For example,\n *\n *   - index of the current child node being visited\n *   - the number of mustaches contained within its child nodes\n *   - the list of actions generated by its child nodes\n */\n\nfunction TemplateVisitor() {\n  this.frameStack = [];\n  this.actions = [];\n  this.programDepth = -1;\n}\n\n// Traversal methods\n\nTemplateVisitor.prototype.visit = function(node) {\n  this[node.type](node);\n};\n\nTemplateVisitor.prototype.Program = function(program) {\n  this.programDepth++;\n\n  let parentFrame = this.getCurrentFrame();\n  let programFrame = this.pushFrame();\n\n  let startType, endType;\n\n  if (this.programDepth === 0) {\n    startType = 'startProgram';\n    endType = 'endProgram';\n  } else {\n    startType = 'startBlock';\n    endType = 'endBlock';\n  }\n\n  programFrame.parentNode = program;\n  programFrame.children = program.body;\n  programFrame.childCount = program.body.length;\n  programFrame.blankChildTextNodes = [];\n  programFrame.actions.push([endType, [program, this.programDepth]]);\n\n  for (let i = program.body.length - 1; i >= 0; i--) {\n    programFrame.childIndex = i;\n    this.visit(program.body[i]);\n  }\n\n  programFrame.actions.push([startType, [\n    program, programFrame.childTemplateCount,\n    programFrame.blankChildTextNodes.reverse()\n  ]]);\n  this.popFrame();\n\n  this.programDepth--;\n\n  // Push the completed template into the global actions list\n  if (parentFrame) { parentFrame.childTemplateCount++; }\n  push.apply(this.actions, programFrame.actions.reverse());\n};\n\nTemplateVisitor.prototype.ElementNode = function(element) {\n  let parentFrame = this.getCurrentFrame();\n  let elementFrame = this.pushFrame();\n\n  elementFrame.parentNode = element;\n  elementFrame.children = element.children;\n  elementFrame.childCount = element.children.length;\n  elementFrame.mustacheCount += element.modifiers.length;\n  elementFrame.blankChildTextNodes = [];\n\n  let actionArgs = [\n    element,\n    parentFrame.childIndex,\n    parentFrame.childCount\n  ];\n\n  elementFrame.actions.push(['closeElement', actionArgs]);\n\n  for (let i = element.attributes.length - 1; i >= 0; i--) {\n    this.visit(element.attributes[i]);\n  }\n\n  for (let i = element.children.length - 1; i >= 0; i--) {\n    elementFrame.childIndex = i;\n    this.visit(element.children[i]);\n  }\n\n  elementFrame.actions.push(['openElement', actionArgs.concat([\n    elementFrame.mustacheCount, elementFrame.blankChildTextNodes.reverse() ])]);\n  this.popFrame();\n\n  // Propagate the element's frame state to the parent frame\n  if (elementFrame.mustacheCount > 0) { parentFrame.mustacheCount++; }\n  parentFrame.childTemplateCount += elementFrame.childTemplateCount;\n  push.apply(parentFrame.actions, elementFrame.actions);\n};\n\nTemplateVisitor.prototype.AttrNode = function(attr) {\n  if (attr.value.type !== 'TextNode') {\n    this.getCurrentFrame().mustacheCount++;\n  }\n};\n\nTemplateVisitor.prototype.TextNode = function(text) {\n  let frame = this.getCurrentFrame();\n  if (text.chars === '') {\n    frame.blankChildTextNodes.push(domIndexOf(frame.children, text));\n  }\n  frame.actions.push(['text', [text, frame.childIndex, frame.childCount]]);\n};\n\nTemplateVisitor.prototype.BlockStatement = function(node) {\n  let frame = this.getCurrentFrame();\n\n  frame.mustacheCount++;\n  frame.actions.push(['block', [node, frame.childIndex, frame.childCount]]);\n\n  if (node.inverse) { this.visit(node.inverse); }\n  if (node.program) { this.visit(node.program); }\n};\n\nTemplateVisitor.prototype.PartialStatement = function(node) {\n  let frame = this.getCurrentFrame();\n  frame.mustacheCount++;\n  frame.actions.push(['mustache', [node, frame.childIndex, frame.childCount]]);\n};\n\nTemplateVisitor.prototype.CommentStatement = function(text) {\n  let frame = this.getCurrentFrame();\n  frame.actions.push(['comment', [text, frame.childIndex, frame.childCount]]);\n};\n\nTemplateVisitor.prototype.MustacheStatement = function(mustache) {\n  let frame = this.getCurrentFrame();\n  frame.mustacheCount++;\n  frame.actions.push(['mustache', [mustache, frame.childIndex, frame.childCount]]);\n};\n\n// Frame helpers\n\nTemplateVisitor.prototype.getCurrentFrame = function() {\n  return this.frameStack[this.frameStack.length - 1];\n};\n\nTemplateVisitor.prototype.pushFrame = function() {\n  let frame = new Frame();\n  this.frameStack.push(frame);\n  return frame;\n};\n\nTemplateVisitor.prototype.popFrame = function() {\n  return this.frameStack.pop();\n};\n\nexport default TemplateVisitor;\n\n// Returns the index of `domNode` in the `nodes` array, skipping\n// over any nodes which do not represent DOM nodes.\nfunction domIndexOf(nodes, domNode) {\n  let index = -1;\n\n  for (let i = 0; i < nodes.length; i++) {\n    let node = nodes[i];\n\n    if (node.type !== 'TextNode' && node.type !== 'ElementNode') {\n      continue;\n    } else {\n      index++;\n    }\n\n    if (node === domNode) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-compiler/lib/template-visitor.ts"],"names":[],"mappings":"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","file":"template-visitor.js","sourcesContent":["let push = Array.prototype.push;\n\nclass Frame {\n  public parentNode: Object = null;\n  public children: Object = null;\n  public childIndex: number = null;\n  public childCount: number = null;\n  public childTemplateCount: number = 0;\n  public mustacheCount: number = 0;\n  public actions: any[] = [];\n  public blankChildTextNodes: number[] = null;\n}\n\n/**\n * Takes in an AST and outputs a list of actions to be consumed\n * by a compiler. For example, the template\n *\n *     foo{{bar}}<div>baz</div>\n *\n * produces the actions\n *\n *     [['startProgram', [programNode, 0]],\n *      ['text', [textNode, 0, 3]],\n *      ['mustache', [mustacheNode, 1, 3]],\n *      ['openElement', [elementNode, 2, 3, 0]],\n *      ['text', [textNode, 0, 1]],\n *      ['closeElement', [elementNode, 2, 3],\n *      ['endProgram', [programNode]]]\n *\n * This visitor walks the AST depth first and backwards. As\n * a result the bottom-most child template will appear at the\n * top of the actions list whereas the root template will appear\n * at the bottom of the list. For example,\n *\n *     <div>{{#if}}foo{{else}}bar<b></b>{{/if}}</div>\n *\n * produces the actions\n *\n *     [['startProgram', [programNode, 0]],\n *      ['text', [textNode, 0, 2, 0]],\n *      ['openElement', [elementNode, 1, 2, 0]],\n *      ['closeElement', [elementNode, 1, 2]],\n *      ['endProgram', [programNode]],\n *      ['startProgram', [programNode, 0]],\n *      ['text', [textNode, 0, 1]],\n *      ['endProgram', [programNode]],\n *      ['startProgram', [programNode, 2]],\n *      ['openElement', [elementNode, 0, 1, 1]],\n *      ['block', [blockNode, 0, 1]],\n *      ['closeElement', [elementNode, 0, 1]],\n *      ['endProgram', [programNode]]]\n *\n * The state of the traversal is maintained by a stack of frames.\n * Whenever a node with children is entered (either a ProgramNode\n * or an ElementNode) a frame is pushed onto the stack. The frame\n * contains information about the state of the traversal of that\n * node. For example,\n *\n *   - index of the current child node being visited\n *   - the number of mustaches contained within its child nodes\n *   - the list of actions generated by its child nodes\n */\n\nfunction TemplateVisitor() {\n  this.frameStack = [];\n  this.actions = [];\n  this.programDepth = -1;\n}\n\n// Traversal methods\n\nTemplateVisitor.prototype.visit = function(node) {\n  this[node.type](node);\n};\n\nTemplateVisitor.prototype.Program = function(program) {\n  this.programDepth++;\n\n  let parentFrame = this.getCurrentFrame();\n  let programFrame = this.pushFrame();\n\n  let startType, endType;\n\n  if (this.programDepth === 0) {\n    startType = 'startProgram';\n    endType = 'endProgram';\n  } else {\n    startType = 'startBlock';\n    endType = 'endBlock';\n  }\n\n  programFrame.parentNode = program;\n  programFrame.children = program.body;\n  programFrame.childCount = program.body.length;\n  programFrame.blankChildTextNodes = [];\n  programFrame.actions.push([endType, [program, this.programDepth]]);\n\n  for (let i = program.body.length - 1; i >= 0; i--) {\n    programFrame.childIndex = i;\n    this.visit(program.body[i]);\n  }\n\n  programFrame.actions.push([startType, [\n    program, programFrame.childTemplateCount,\n    programFrame.blankChildTextNodes.reverse()\n  ]]);\n  this.popFrame();\n\n  this.programDepth--;\n\n  // Push the completed template into the global actions list\n  if (parentFrame) { parentFrame.childTemplateCount++; }\n  push.apply(this.actions, programFrame.actions.reverse());\n};\n\nTemplateVisitor.prototype.ElementNode = function(element) {\n  let parentFrame = this.getCurrentFrame();\n  let elementFrame = this.pushFrame();\n\n  elementFrame.parentNode = element;\n  elementFrame.children = element.children;\n  elementFrame.childCount = element.children.length;\n  elementFrame.mustacheCount += element.modifiers.length;\n  elementFrame.blankChildTextNodes = [];\n\n  let actionArgs = [\n    element,\n    parentFrame.childIndex,\n    parentFrame.childCount\n  ];\n\n  elementFrame.actions.push(['closeElement', actionArgs]);\n\n  for (let i = element.attributes.length - 1; i >= 0; i--) {\n    this.visit(element.attributes[i]);\n  }\n\n  for (let i = element.children.length - 1; i >= 0; i--) {\n    elementFrame.childIndex = i;\n    this.visit(element.children[i]);\n  }\n\n  elementFrame.actions.push(['openElement', actionArgs.concat([\n    elementFrame.mustacheCount, elementFrame.blankChildTextNodes.reverse() ])]);\n  this.popFrame();\n\n  // Propagate the element's frame state to the parent frame\n  if (elementFrame.mustacheCount > 0) { parentFrame.mustacheCount++; }\n  parentFrame.childTemplateCount += elementFrame.childTemplateCount;\n  push.apply(parentFrame.actions, elementFrame.actions);\n};\n\nTemplateVisitor.prototype.AttrNode = function(attr) {\n  if (attr.value.type !== 'TextNode') {\n    this.getCurrentFrame().mustacheCount++;\n  }\n};\n\nTemplateVisitor.prototype.TextNode = function(text) {\n  let frame = this.getCurrentFrame();\n  if (text.chars === '') {\n    frame.blankChildTextNodes.push(domIndexOf(frame.children, text));\n  }\n  frame.actions.push(['text', [text, frame.childIndex, frame.childCount]]);\n};\n\nTemplateVisitor.prototype.BlockStatement = function(node) {\n  let frame = this.getCurrentFrame();\n\n  frame.mustacheCount++;\n  frame.actions.push(['block', [node, frame.childIndex, frame.childCount]]);\n\n  if (node.inverse) { this.visit(node.inverse); }\n  if (node.program) { this.visit(node.program); }\n};\n\nTemplateVisitor.prototype.PartialStatement = function(node) {\n  let frame = this.getCurrentFrame();\n  frame.mustacheCount++;\n  frame.actions.push(['mustache', [node, frame.childIndex, frame.childCount]]);\n};\n\nTemplateVisitor.prototype.CommentStatement = function(text) {\n  let frame = this.getCurrentFrame();\n  frame.actions.push(['comment', [text, frame.childIndex, frame.childCount]]);\n};\n\nTemplateVisitor.prototype.MustacheStatement = function(mustache) {\n  let frame = this.getCurrentFrame();\n  frame.mustacheCount++;\n  frame.actions.push(['mustache', [mustache, frame.childIndex, frame.childCount]]);\n};\n\n// Frame helpers\n\nTemplateVisitor.prototype.getCurrentFrame = function() {\n  return this.frameStack[this.frameStack.length - 1];\n};\n\nTemplateVisitor.prototype.pushFrame = function() {\n  let frame = new Frame();\n  this.frameStack.push(frame);\n  return frame;\n};\n\nTemplateVisitor.prototype.popFrame = function() {\n  return this.frameStack.pop();\n};\n\nexport default TemplateVisitor;\n\n// Returns the index of `domNode` in the `nodes` array, skipping\n// over any nodes which do not represent DOM nodes.\nfunction domIndexOf(nodes, domNode) {\n  let index = -1;\n\n  for (let i = 0; i < nodes.length; i++) {\n    let node = nodes[i];\n\n    if (node.type !== 'TextNode' && node.type !== 'ElementNode') {\n      continue;\n    } else {\n      index++;\n    }\n\n    if (node === domNode) {\n      return index;\n    }\n  }\n\n  return -1;\n}\n"]} enifed("glimmer-compiler/lib/utils", ["exports"], function (exports) { "use strict"; exports.processOpcodes = processOpcodes; @@ -12888,25 +13829,19 @@ compiler[method].call(compiler); } } } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItY29tcGlsZXIvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsYUFBQSxjQUFBLENBQStCLFFBQVEsRUFBRSxPQUFPLEVBQUE7QUFDOUMsYUFBSyxJQUFJLENBQUMsR0FBQyxDQUFDLEVBQUUsQ0FBQyxHQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRTtBQUN4QyxnQkFBSSxNQUFNLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQzNCLGdCQUFJLE1BQU0sR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDM0IsZ0JBQUksTUFBTSxFQUFFO0FBQ1Ysd0JBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxDQUFDO2FBQzFDLE1BQU07QUFDTCx3QkFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQzthQUNqQztTQUNGO0tBQ0YiLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gcHJvY2Vzc09wY29kZXMoY29tcGlsZXIsIG9wY29kZXMpIHtcbiAgZm9yIChsZXQgaT0wLCBsPW9wY29kZXMubGVuZ3RoOyBpPGw7IGkrKykge1xuICAgIGxldCBtZXRob2QgPSBvcGNvZGVzW2ldWzBdO1xuICAgIGxldCBwYXJhbXMgPSBvcGNvZGVzW2ldWzFdO1xuICAgIGlmIChwYXJhbXMpIHtcbiAgICAgIGNvbXBpbGVyW21ldGhvZF0uYXBwbHkoY29tcGlsZXIsIHBhcmFtcyk7XG4gICAgfSBlbHNlIHtcbiAgICAgIGNvbXBpbGVyW21ldGhvZF0uY2FsbChjb21waWxlcik7XG4gICAgfVxuICB9XG59Il19 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItY29tcGlsZXIvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQU0sYUFBQSxjQUFBLENBQXlCLFFBQVEsRUFBRSxPQUFPLEVBQUE7QUFDOUMsYUFBSyxJQUFJLENBQUMsR0FBQyxDQUFDLEVBQUUsQ0FBQyxHQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRTtBQUN4QyxnQkFBSSxNQUFNLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQzNCLGdCQUFJLE1BQU0sR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDM0IsZ0JBQUksTUFBTSxFQUFFO0FBQ1Ysd0JBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxDQUFDO2FBQzFDLE1BQU07QUFDTCx3QkFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQzthQUNqQztTQUNGO0tBQ0YiLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gcHJvY2Vzc09wY29kZXMoY29tcGlsZXIsIG9wY29kZXMpIHtcbiAgZm9yIChsZXQgaT0wLCBsPW9wY29kZXMubGVuZ3RoOyBpPGw7IGkrKykge1xuICAgIGxldCBtZXRob2QgPSBvcGNvZGVzW2ldWzBdO1xuICAgIGxldCBwYXJhbXMgPSBvcGNvZGVzW2ldWzFdO1xuICAgIGlmIChwYXJhbXMpIHtcbiAgICAgIGNvbXBpbGVyW21ldGhvZF0uYXBwbHkoY29tcGlsZXIsIHBhcmFtcyk7XG4gICAgfSBlbHNlIHtcbiAgICAgIGNvbXBpbGVyW21ldGhvZF0uY2FsbChjb21waWxlcik7XG4gICAgfVxuICB9XG59Il19 enifed('glimmer-reference/index', ['exports', 'glimmer-reference/lib/reference', 'glimmer-reference/lib/const', 'glimmer-reference/lib/validators', 'glimmer-reference/lib/utils', 'glimmer-reference/lib/iterable'], function (exports, _glimmerReferenceLibReference, _glimmerReferenceLibConst, _glimmerReferenceLibValidators, _glimmerReferenceLibUtils, _glimmerReferenceLibIterable) { 'use strict'; - function _interopExportWildcard(obj, defaults) { var newObj = defaults({}, obj); delete newObj['default']; return newObj; } - - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - exports.BasicReference = _glimmerReferenceLibReference.Reference; exports.BasicPathReference = _glimmerReferenceLibReference.PathReference; exports.ConstReference = _glimmerReferenceLibConst.ConstReference; exports.isConst = _glimmerReferenceLibConst.isConst; - - _defaults(exports, _interopExportWildcard(_glimmerReferenceLibValidators, _defaults)); - + babelHelpers.defaults(exports, babelHelpers.interopExportWildcard(_glimmerReferenceLibValidators, babelHelpers.defaults)); exports.Reference = _glimmerReferenceLibValidators.VersionedReference; exports.PathReference = _glimmerReferenceLibValidators.VersionedPathReference; exports.referenceFromParts = _glimmerReferenceLibUtils.referenceFromParts; exports.IterationItem = _glimmerReferenceLibIterable.IterationItem; exports.Iterator = _glimmerReferenceLibIterable.Iterator; @@ -12918,28 +13853,20 @@ exports.IterationArtifacts = _glimmerReferenceLibIterable.IterationArtifacts; exports.ReferenceIterator = _glimmerReferenceLibIterable.ReferenceIterator; exports.IteratorSynchronizer = _glimmerReferenceLibIterable.IteratorSynchronizer; exports.IteratorSynchronizerDelegate = _glimmerReferenceLibIterable.IteratorSynchronizerDelegate; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcmVmZXJlbmNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7VUFDZSxjQUFjLGlDQUEzQixTQUFTO1VBQ1Esa0JBQWtCLGlDQUFuQyxhQUFhO1VBSWIsY0FBYyw2QkFBZCxjQUFjO1VBQ2QsT0FBTyw2QkFBUCxPQUFPOzs7O1VBTWUsU0FBUyxrQ0FBL0Isa0JBQWtCO1VBQ1EsYUFBYSxrQ0FBdkMsc0JBQXNCO1VBSXRCLGtCQUFrQiw2QkFBbEIsa0JBQWtCO1VBSWxCLGFBQWEsZ0NBQWIsYUFBYTtVQUNiLFFBQVEsZ0NBQVIsUUFBUTtVQUNSLFFBQVEsZ0NBQVIsUUFBUTtVQUNSLGNBQWMsZ0NBQWQsY0FBYztVQUNkLGNBQWMsZ0NBQWQsY0FBYztVQUNkLGdCQUFnQixnQ0FBaEIsZ0JBQWdCO1VBQ2hCLGdCQUFnQixnQ0FBaEIsZ0JBQWdCO1VBQ2hCLGtCQUFrQixnQ0FBbEIsa0JBQWtCO1VBQ2xCLGlCQUFpQixnQ0FBakIsaUJBQWlCO1VBQ2pCLG9CQUFvQixnQ0FBcEIsb0JBQW9CO1VBQ3BCLDRCQUE0QixnQ0FBNUIsNEJBQTRCIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgUmVmZXJlbmNlIGFzIEJhc2ljUmVmZXJlbmNlLFxuICBQYXRoUmVmZXJlbmNlIGFzIEJhc2ljUGF0aFJlZmVyZW5jZVxufSBmcm9tICcuL2xpYi9yZWZlcmVuY2UnO1xuXG5leHBvcnQge1xuICBDb25zdFJlZmVyZW5jZSxcbiAgaXNDb25zdFxufSBmcm9tICcuL2xpYi9jb25zdCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3ZhbGlkYXRvcnMnO1xuXG5leHBvcnQge1xuICBWZXJzaW9uZWRSZWZlcmVuY2UgYXMgUmVmZXJlbmNlLFxuICBWZXJzaW9uZWRQYXRoUmVmZXJlbmNlIGFzIFBhdGhSZWZlcmVuY2Vcbn0gZnJvbSAnLi9saWIvdmFsaWRhdG9ycyc7XG5cbmV4cG9ydCB7XG4gIHJlZmVyZW5jZUZyb21QYXJ0c1xufSBmcm9tICcuL2xpYi91dGlscyc7XG5cbmV4cG9ydCB7XG4gIEl0ZXJhdGlvbkl0ZW0sXG4gIEl0ZXJhdG9yLFxuICBJdGVyYWJsZSxcbiAgT3BhcXVlSXRlcmF0b3IsXG4gIE9wYXF1ZUl0ZXJhYmxlLFxuICBBYnN0cmFjdEl0ZXJhdG9yLFxuICBBYnN0cmFjdEl0ZXJhYmxlLFxuICBJdGVyYXRpb25BcnRpZmFjdHMsXG4gIFJlZmVyZW5jZUl0ZXJhdG9yLFxuICBJdGVyYXRvclN5bmNocm9uaXplcixcbiAgSXRlcmF0b3JTeW5jaHJvbml6ZXJEZWxlZ2F0ZVxufSBmcm9tICcuL2xpYi9pdGVyYWJsZSc7XG4iXX0= -enifed("glimmer-reference/lib/const", ["exports", "glimmer-reference/lib/validators"], function (exports, _glimmerReferenceLibValidators) { - "use strict"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcmVmZXJlbmNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztVQUNlLGNBQWMsaUNBQTNCLFNBQVM7VUFDUSxrQkFBa0IsaUNBQW5DLGFBQWE7VUFJYixjQUFjLDZCQUFkLGNBQWM7VUFDZCxPQUFPLDZCQUFQLE9BQU87O1VBTWUsU0FBUyxrQ0FBL0Isa0JBQWtCO1VBQ1EsYUFBYSxrQ0FBdkMsc0JBQXNCO1VBSXRCLGtCQUFrQiw2QkFBbEIsa0JBQWtCO1VBSWxCLGFBQWEsZ0NBQWIsYUFBYTtVQUNiLFFBQVEsZ0NBQVIsUUFBUTtVQUNSLFFBQVEsZ0NBQVIsUUFBUTtVQUNSLGNBQWMsZ0NBQWQsY0FBYztVQUNkLGNBQWMsZ0NBQWQsY0FBYztVQUNkLGdCQUFnQixnQ0FBaEIsZ0JBQWdCO1VBQ2hCLGdCQUFnQixnQ0FBaEIsZ0JBQWdCO1VBQ2hCLGtCQUFrQixnQ0FBbEIsa0JBQWtCO1VBQ2xCLGlCQUFpQixnQ0FBakIsaUJBQWlCO1VBQ2pCLG9CQUFvQixnQ0FBcEIsb0JBQW9CO1VBQ3BCLDRCQUE0QixnQ0FBNUIsNEJBQTRCIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgUmVmZXJlbmNlIGFzIEJhc2ljUmVmZXJlbmNlLFxuICBQYXRoUmVmZXJlbmNlIGFzIEJhc2ljUGF0aFJlZmVyZW5jZVxufSBmcm9tICcuL2xpYi9yZWZlcmVuY2UnO1xuXG5leHBvcnQge1xuICBDb25zdFJlZmVyZW5jZSxcbiAgaXNDb25zdFxufSBmcm9tICcuL2xpYi9jb25zdCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3ZhbGlkYXRvcnMnO1xuXG5leHBvcnQge1xuICBWZXJzaW9uZWRSZWZlcmVuY2UgYXMgUmVmZXJlbmNlLFxuICBWZXJzaW9uZWRQYXRoUmVmZXJlbmNlIGFzIFBhdGhSZWZlcmVuY2Vcbn0gZnJvbSAnLi9saWIvdmFsaWRhdG9ycyc7XG5cbmV4cG9ydCB7XG4gIHJlZmVyZW5jZUZyb21QYXJ0c1xufSBmcm9tICcuL2xpYi91dGlscyc7XG5cbmV4cG9ydCB7XG4gIEl0ZXJhdGlvbkl0ZW0sXG4gIEl0ZXJhdG9yLFxuICBJdGVyYWJsZSxcbiAgT3BhcXVlSXRlcmF0b3IsXG4gIE9wYXF1ZUl0ZXJhYmxlLFxuICBBYnN0cmFjdEl0ZXJhdG9yLFxuICBBYnN0cmFjdEl0ZXJhYmxlLFxuICBJdGVyYXRpb25BcnRpZmFjdHMsXG4gIFJlZmVyZW5jZUl0ZXJhdG9yLFxuICBJdGVyYXRvclN5bmNocm9uaXplcixcbiAgSXRlcmF0b3JTeW5jaHJvbml6ZXJEZWxlZ2F0ZVxufSBmcm9tICcuL2xpYi9pdGVyYWJsZSc7XG4iXX0= +enifed('glimmer-reference/lib/const', ['exports', 'glimmer-reference/lib/validators'], function (exports, _glimmerReferenceLibValidators) { + 'use strict'; exports.isConst = isConst; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - - var CONST_REFERENCE = "503c5a44-e4a9-4bb5-85bc-102d35af6985"; - exports.CONST_REFERENCE = CONST_REFERENCE; - var ConstReference = (function () { function ConstReference(inner) { - _classCallCheck(this, ConstReference); - - this.tag = _glimmerReferenceLibValidators.CONSTANT_TAG; - this["503c5a44-e4a9-4bb5-85bc-102d35af6985"] = true; this.inner = inner; + this.tag = _glimmerReferenceLibValidators.CONSTANT_TAG; } ConstReference.prototype.value = function value() { return this.inner; }; @@ -12948,29 +13875,21 @@ })(); exports.ConstReference = ConstReference; function isConst(reference) { - return !!reference[CONST_REFERENCE]; + return reference.tag === _glimmerReferenceLibValidators.CONSTANT_TAG; } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcmVmZXJlbmNlL2xpYi9jb25zdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBSU8sUUFBTSxlQUFlLEdBQUcsc0NBQXNDLENBQUM7OztRQUV0RSxjQUFBO0FBTUUsaUJBTkYsY0FBQSxDQU1jLEtBQVEsRUFBQTtrQ0FOdEIsY0FBQTs7QUFFUyxnQkFBQSxDQUFBLEdBQUcsa0NBUkgsWUFBWSxBQVFNLENBQUM7QUFFbkIsZ0JBQUEsQ0FBQSxzQ0FBQSxDQUFzQyxHQUFHLElBQUksQ0FBQztBQUduRCxnQkFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7U0FDcEI7O0FBUkgsc0JBQUEsV0FVRSxLQUFLLEdBQUEsaUJBQUE7QUFBUSxtQkFBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1NBQUU7O2VBVm5DLGNBQUE7Ozs7O0FBYUEsYUFBQSxPQUFBLENBQXdCLFNBQTRCLEVBQUE7QUFDbEQsZUFBTyxDQUFDLENBQUMsU0FBUyxDQUFDLGVBQWUsQ0FBQyxDQUFDO0tBQ3JDIiwiZmlsZSI6ImNvbnN0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ09OU1RBTlRfVEFHLCBWZXJzaW9uZWRSZWZlcmVuY2UgfSBmcm9tICcuL3ZhbGlkYXRvcnMnO1xuaW1wb3J0IFJlZmVyZW5jZSBmcm9tICcuL3JlZmVyZW5jZSc7XG5pbXBvcnQgeyBPcGFxdWUgfSBmcm9tICdnbGltbWVyLXV0aWwnO1xuXG5leHBvcnQgY29uc3QgQ09OU1RfUkVGRVJFTkNFID0gXCI1MDNjNWE0NC1lNGE5LTRiYjUtODViYy0xMDJkMzVhZjY5ODVcIjtcblxuZXhwb3J0IGNsYXNzIENvbnN0UmVmZXJlbmNlPFQ+IGltcGxlbWVudHMgVmVyc2lvbmVkUmVmZXJlbmNlPFQ+IHtcbiAgcHJvdGVjdGVkIGlubmVyOiBUO1xuICBwdWJsaWMgdGFnID0gQ09OU1RBTlRfVEFHO1xuXG4gIHB1YmxpYyBcIjUwM2M1YTQ0LWU0YTktNGJiNS04NWJjLTEwMmQzNWFmNjk4NVwiID0gdHJ1ZTtcblxuICBjb25zdHJ1Y3Rvcihpbm5lcjogVCkge1xuICAgIHRoaXMuaW5uZXIgPSBpbm5lcjtcbiAgfVxuXG4gIHZhbHVlKCk6IFQgeyByZXR1cm4gdGhpcy5pbm5lcjsgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNDb25zdChyZWZlcmVuY2U6IFJlZmVyZW5jZTxPcGFxdWU+KTogYm9vbGVhbiB7XG4gIHJldHVybiAhIXJlZmVyZW5jZVtDT05TVF9SRUZFUkVOQ0VdO1xufVxuIl19 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcmVmZXJlbmNlL2xpYi9jb25zdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztRQUdNLGNBQUE7QUFHSixpQkFISSxjQUFBLENBR2tCLEtBQVEsRUFBQTtBQUFSLGdCQUFBLENBQUEsS0FBSyxHQUFMLEtBQUssQ0FBRztBQUZ2QixnQkFBQSxDQUFBLEdBQUcsa0NBSkgsWUFBWSxBQUlNLENBQUM7U0FFUzs7QUFIL0Isc0JBQUEsV0FLSixLQUFLLEdBQUEsaUJBQUE7QUFBUSxtQkFBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1NBQUU7O2VBTDdCLGNBQUE7Ozs7O0FBUUEsYUFBQSxPQUFBLENBQWtCLFNBQXFDLEVBQUE7QUFDM0QsZUFBTyxTQUFTLENBQUMsR0FBRyxvQ0FaYixZQUFZLEFBWWtCLENBQUM7S0FDdkMiLCJmaWxlIjoiY29uc3QuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDT05TVEFOVF9UQUcsIFZlcnNpb25lZFJlZmVyZW5jZSB9IGZyb20gJy4vdmFsaWRhdG9ycyc7XG5pbXBvcnQgeyBPcGFxdWUgfSBmcm9tICdnbGltbWVyLXV0aWwnO1xuXG5leHBvcnQgY2xhc3MgQ29uc3RSZWZlcmVuY2U8VD4gaW1wbGVtZW50cyBWZXJzaW9uZWRSZWZlcmVuY2U8VD4ge1xuICBwdWJsaWMgdGFnID0gQ09OU1RBTlRfVEFHO1xuXG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBpbm5lcjogVCkgeyB9XG5cbiAgdmFsdWUoKTogVCB7IHJldHVybiB0aGlzLmlubmVyOyB9XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0NvbnN0KHJlZmVyZW5jZTogVmVyc2lvbmVkUmVmZXJlbmNlPE9wYXF1ZT4pOiBib29sZWFuIHtcbiAgcmV0dXJuIHJlZmVyZW5jZS50YWcgPT09IENPTlNUQU5UX1RBRztcbn1cbiJdfQ== enifed("glimmer-reference/lib/iterable", ["exports", "glimmer-util"], function (exports, _glimmerUtil) { "use strict"; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var ListItem = (function (_ListNode) { - _inherits(ListItem, _ListNode); + babelHelpers.inherits(ListItem, _ListNode); function ListItem(iterable, result) { - _classCallCheck(this, ListItem); - _ListNode.call(this, iterable.valueReferenceFor(result)); this.retained = false; this.seen = false; this.key = result.key; this.iterable = iterable; @@ -12995,12 +13914,10 @@ return ListItem; })(_glimmerUtil.ListNode); var IterationArtifacts = (function () { function IterationArtifacts(iterable) { - _classCallCheck(this, IterationArtifacts); - this.map = _glimmerUtil.dict(); this.list = new _glimmerUtil.LinkedList(); this.tag = iterable.tag; this.iterable = iterable; } @@ -13081,12 +13998,10 @@ var ReferenceIterator = (function () { // if anyone needs to construct this object with something other than // an iterable, let @wycats know. function ReferenceIterator(iterable) { - _classCallCheck(this, ReferenceIterator); - this.iterator = null; var artifacts = new IterationArtifacts(iterable); this.artifacts = artifacts; } @@ -13114,12 +14029,10 @@ var IteratorSynchronizer = (function () { function IteratorSynchronizer(_ref) { var target = _ref.target; var artifacts = _ref.artifacts; - _classCallCheck(this, IteratorSynchronizer); - this.target = target; this.artifacts = artifacts; this.iterator = artifacts.iterate(); this.current = artifacts.head(); } @@ -13239,11 +14152,11 @@ return IteratorSynchronizer; })(); exports.IteratorSynchronizer = IteratorSynchronizer; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-reference/lib/iterable.ts"],"names":[],"mappings":"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","file":"iterable.js","sourcesContent":["import { FIXME, LinkedList, ListNode, InternedString, Opaque, dict } from 'glimmer-util';\nimport { VersionedPathReference as PathReference, RevisionTag } from './validators';\n\nexport interface IterationItem<T, U> {\n  key: string;\n  value: T;\n  memo: U;\n}\n\nexport interface AbstractIterator<T, U, V extends IterationItem<T, U>> {\n  isEmpty(): boolean;\n  next(): V;\n}\n\nexport interface AbstractIterable<T, U, ItemType extends IterationItem<T, U>, ValueReferenceType extends PathReference<T>, MemoReferenceType extends PathReference<U>> {\n  tag: RevisionTag;\n  iterate(): AbstractIterator<T, U, ItemType>;\n\n  valueReferenceFor(item: ItemType): ValueReferenceType;\n  updateValueReference(reference: ValueReferenceType, item: ItemType);\n\n  memoReferenceFor(item: ItemType): MemoReferenceType;\n  updateMemoReference(reference: MemoReferenceType, item: ItemType);\n}\n\nexport type Iterator<T, U> = AbstractIterator<T, U, IterationItem<T, U>>;\nexport type Iterable<T, U> = AbstractIterable<T, U, IterationItem<T, U>, PathReference<T>, PathReference<U>>;\n\ntype OpaqueIterationItem = IterationItem<Opaque, Opaque>;\nexport type OpaqueIterator = AbstractIterator<Opaque, Opaque, OpaqueIterationItem>;\nexport type OpaqueIterable = AbstractIterable<Opaque, Opaque, OpaqueIterationItem, PathReference<Opaque>, PathReference<Opaque>>;\n\nclass ListItem extends ListNode<PathReference<Opaque>> implements IterationItem<PathReference<Opaque>, PathReference<Opaque>> {\n  public key: InternedString;\n  public memo: PathReference<Opaque>;\n  public retained: boolean = false;\n  public seen: boolean = false;\n  private iterable: OpaqueIterable;\n\n  constructor(iterable: OpaqueIterable, result: OpaqueIterationItem) {\n    super(iterable.valueReferenceFor(result));\n    this.key = result.key as FIXME<'user string to InternedString'>;\n    this.iterable = iterable;\n    this.memo = iterable.memoReferenceFor(result);\n  }\n\n  update(item: OpaqueIterationItem) {\n    this.retained = true;\n    this.iterable.updateValueReference(this.value, item);\n    this.iterable.updateMemoReference(this.memo, item);\n  }\n\n  shouldRemove(): boolean {\n    return !this.retained;\n  }\n\n  reset() {\n    this.retained = false;\n    this.seen = false;\n  }\n}\n\nexport class IterationArtifacts {\n  public tag: RevisionTag;\n\n  private iterable: OpaqueIterable;\n  private iterator: OpaqueIterator;\n  private map = dict<ListItem>();\n  private list = new LinkedList<ListItem>();\n\n  constructor(iterable: OpaqueIterable) {\n    this.tag = iterable.tag;\n    this.iterable = iterable;\n  }\n\n  isEmpty(): boolean {\n    let iterator = this.iterator = this.iterable.iterate();\n    return iterator.isEmpty();\n  }\n\n  iterate(): OpaqueIterator {\n    let iterator = this.iterator || this.iterable.iterate();\n    this.iterator = null;\n\n    return iterator;\n  }\n\n  has(key: string): boolean {\n    return !!this.map[key];\n  }\n\n  get(key: string): ListItem {\n    return this.map[key];\n  }\n\n  wasSeen(key: string): boolean {\n    let node = this.map[key];\n    return node && node.seen;\n  }\n\n  append(item: OpaqueIterationItem): ListItem {\n    let { map, list, iterable } = this;\n    let node = map[item.key] = new ListItem(iterable, item);\n\n    list.append(node);\n    return node;\n  }\n\n  insertBefore(item: OpaqueIterationItem, reference: ListItem): ListItem {\n    let { map, list, iterable } = this;\n\n    let node = map[item.key] = new ListItem(iterable, item);\n    node.retained = true;\n    list.insertBefore(node, reference);\n    return node;\n  }\n\n  move(item: ListItem, reference: ListItem) {\n    let { list } = this;\n\n    item.retained = true;\n    list.remove(item);\n    list.insertBefore(item, reference);\n  }\n\n  remove(item: ListItem) {\n    let { list } = this;\n\n    list.remove(item);\n    delete this.map[<string>item.key];\n  }\n\n  nextNode(item: ListItem) {\n    return this.list.nextNode(item);\n  }\n\n  head() {\n    return this.list.head();\n  }\n}\n\nexport class ReferenceIterator {\n  public artifacts: IterationArtifacts;\n  private iterator: OpaqueIterator = null;\n\n  // if anyone needs to construct this object with something other than\n  // an iterable, let @wycats know.\n  constructor(iterable: OpaqueIterable) {\n    let artifacts = new IterationArtifacts(iterable);\n    this.artifacts = artifacts;\n  }\n\n  next(): ListItem {\n    let { artifacts } = this;\n\n    let iterator = (this.iterator = this.iterator || artifacts.iterate());\n\n    let item = iterator.next();\n\n    if (!item) return null;\n\n    return artifacts.append(item);\n  }\n}\n\nexport interface IteratorSynchronizerDelegate {\n  retain(key: InternedString, item: PathReference<Opaque>, memo: PathReference<Opaque>);\n  insert(key: InternedString, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: InternedString);\n  move(key: InternedString, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: InternedString);\n  delete(key: InternedString);\n  done();\n}\n\ninterface IteratorSynchronizerOptions {\n  target: IteratorSynchronizerDelegate;\n  artifacts: IterationArtifacts;\n}\n\nenum Phase {\n  Append,\n  Prune,\n  Done\n}\n\nexport class IteratorSynchronizer {\n  private target: IteratorSynchronizerDelegate;\n  private iterator: OpaqueIterator;\n  private current: ListItem;\n  private artifacts: IterationArtifacts;\n\n  constructor({ target, artifacts }: IteratorSynchronizerOptions) {\n    this.target = target;\n    this.artifacts = artifacts;\n    this.iterator = artifacts.iterate();\n    this.current = artifacts.head();\n  }\n\n  sync() {\n    let phase: Phase = Phase.Append;\n\n    while (true) {\n      switch (phase) {\n        case Phase.Append: phase = this.nextAppend(); break;\n        case Phase.Prune: phase = this.nextPrune(); break;\n        case Phase.Done: this.nextDone(); return;\n      }\n    }\n  }\n\n  private advanceToKey(key: InternedString) {\n    let { current, artifacts } = this;\n\n    let seek = current;\n\n    while (seek && seek.key !== key) {\n      seek.seen = true;\n      seek = artifacts.nextNode(seek);\n    }\n\n    this.current = seek && artifacts.nextNode(seek);\n  }\n\n  private nextAppend(): Phase {\n    let { iterator, current, artifacts } = this;\n\n    let item = iterator.next();\n\n    if (item === null) {\n      return this.startPrune();\n    }\n\n    let { key } = item;\n\n    if (current && current.key === key) {\n      this.nextRetain(item);\n    } else if (artifacts.has(key)) {\n      this.nextMove(item);\n    } else {\n      this.nextInsert(item);\n    }\n\n    return Phase.Append;\n  }\n\n  private nextRetain(item: OpaqueIterationItem) {\n    let { artifacts, current } = this;\n\n    current.update(item);\n    this.current = artifacts.nextNode(current);\n    this.target.retain(item.key as FIXME<'user string to InternedString'>, current.value, current.memo);\n  }\n\n  private nextMove(item: OpaqueIterationItem) {\n    let { current, artifacts, target } = this;\n    let { key } = item;\n\n    let found = artifacts.get(item.key);\n    found.update(item);\n\n    if (artifacts.wasSeen(item.key)) {\n      artifacts.move(found, current);\n      target.move(found.key, found.value, found.memo, current ? current.key : null);\n    } else {\n      this.advanceToKey(key as FIXME<'user string to InternedString'>);\n    }\n  }\n\n  private nextInsert(item: OpaqueIterationItem) {\n    let { artifacts, target, current } = this;\n\n    let node = artifacts.insertBefore(item, current);\n    target.insert(node.key, node.value, node.memo, current ? current.key : null);\n  }\n\n  private startPrune(): Phase {\n    this.current = this.artifacts.head();\n    return Phase.Prune;\n  }\n\n  private nextPrune(): Phase {\n    let { artifacts, target, current } = this;\n\n    if (current === null) {\n      return Phase.Done;\n    }\n\n    let node = current;\n    this.current = artifacts.nextNode(node);\n\n    if (node.shouldRemove()) {\n      artifacts.remove(node);\n      target.delete(node.key);\n    } else {\n      node.reset();\n    }\n\n    return Phase.Prune;\n  }\n\n  private nextDone() {\n    this.target.done();\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-reference/lib/iterable.ts"],"names":[],"mappings":"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","file":"iterable.js","sourcesContent":["import { LinkedList, ListNode, Opaque, dict } from 'glimmer-util';\nimport { VersionedPathReference as PathReference, RevisionTag } from './validators';\n\nexport interface IterationItem<T, U> {\n  key: string;\n  value: T;\n  memo: U;\n}\n\nexport interface AbstractIterator<T, U, V extends IterationItem<T, U>> {\n  isEmpty(): boolean;\n  next(): V;\n}\n\nexport interface AbstractIterable<T, U, ItemType extends IterationItem<T, U>, ValueReferenceType extends PathReference<T>, MemoReferenceType extends PathReference<U>> {\n  tag: RevisionTag;\n  iterate(): AbstractIterator<T, U, ItemType>;\n\n  valueReferenceFor(item: ItemType): ValueReferenceType;\n  updateValueReference(reference: ValueReferenceType, item: ItemType);\n\n  memoReferenceFor(item: ItemType): MemoReferenceType;\n  updateMemoReference(reference: MemoReferenceType, item: ItemType);\n}\n\nexport type Iterator<T, U> = AbstractIterator<T, U, IterationItem<T, U>>;\nexport type Iterable<T, U> = AbstractIterable<T, U, IterationItem<T, U>, PathReference<T>, PathReference<U>>;\n\ntype OpaqueIterationItem = IterationItem<Opaque, Opaque>;\nexport type OpaqueIterator = AbstractIterator<Opaque, Opaque, OpaqueIterationItem>;\nexport type OpaqueIterable = AbstractIterable<Opaque, Opaque, OpaqueIterationItem, PathReference<Opaque>, PathReference<Opaque>>;\n\nclass ListItem extends ListNode<PathReference<Opaque>> implements IterationItem<PathReference<Opaque>, PathReference<Opaque>> {\n  public key: string;\n  public memo: PathReference<Opaque>;\n  public retained: boolean = false;\n  public seen: boolean = false;\n  private iterable: OpaqueIterable;\n\n  constructor(iterable: OpaqueIterable, result: OpaqueIterationItem) {\n    super(iterable.valueReferenceFor(result));\n    this.key = result.key;\n    this.iterable = iterable;\n    this.memo = iterable.memoReferenceFor(result);\n  }\n\n  update(item: OpaqueIterationItem) {\n    this.retained = true;\n    this.iterable.updateValueReference(this.value, item);\n    this.iterable.updateMemoReference(this.memo, item);\n  }\n\n  shouldRemove(): boolean {\n    return !this.retained;\n  }\n\n  reset() {\n    this.retained = false;\n    this.seen = false;\n  }\n}\n\nexport class IterationArtifacts {\n  public tag: RevisionTag;\n\n  private iterable: OpaqueIterable;\n  private iterator: OpaqueIterator;\n  private map = dict<ListItem>();\n  private list = new LinkedList<ListItem>();\n\n  constructor(iterable: OpaqueIterable) {\n    this.tag = iterable.tag;\n    this.iterable = iterable;\n  }\n\n  isEmpty(): boolean {\n    let iterator = this.iterator = this.iterable.iterate();\n    return iterator.isEmpty();\n  }\n\n  iterate(): OpaqueIterator {\n    let iterator = this.iterator || this.iterable.iterate();\n    this.iterator = null;\n\n    return iterator;\n  }\n\n  has(key: string): boolean {\n    return !!this.map[key];\n  }\n\n  get(key: string): ListItem {\n    return this.map[key];\n  }\n\n  wasSeen(key: string): boolean {\n    let node = this.map[key];\n    return node && node.seen;\n  }\n\n  append(item: OpaqueIterationItem): ListItem {\n    let { map, list, iterable } = this;\n    let node = map[item.key] = new ListItem(iterable, item);\n\n    list.append(node);\n    return node;\n  }\n\n  insertBefore(item: OpaqueIterationItem, reference: ListItem): ListItem {\n    let { map, list, iterable } = this;\n\n    let node = map[item.key] = new ListItem(iterable, item);\n    node.retained = true;\n    list.insertBefore(node, reference);\n    return node;\n  }\n\n  move(item: ListItem, reference: ListItem) {\n    let { list } = this;\n\n    item.retained = true;\n    list.remove(item);\n    list.insertBefore(item, reference);\n  }\n\n  remove(item: ListItem) {\n    let { list } = this;\n\n    list.remove(item);\n    delete this.map[item.key];\n  }\n\n  nextNode(item: ListItem) {\n    return this.list.nextNode(item);\n  }\n\n  head() {\n    return this.list.head();\n  }\n}\n\nexport class ReferenceIterator {\n  public artifacts: IterationArtifacts;\n  private iterator: OpaqueIterator = null;\n\n  // if anyone needs to construct this object with something other than\n  // an iterable, let @wycats know.\n  constructor(iterable: OpaqueIterable) {\n    let artifacts = new IterationArtifacts(iterable);\n    this.artifacts = artifacts;\n  }\n\n  next(): ListItem {\n    let { artifacts } = this;\n\n    let iterator = (this.iterator = this.iterator || artifacts.iterate());\n\n    let item = iterator.next();\n\n    if (!item) return null;\n\n    return artifacts.append(item);\n  }\n}\n\nexport interface IteratorSynchronizerDelegate {\n  retain(key: string, item: PathReference<Opaque>, memo: PathReference<Opaque>);\n  insert(key: string, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: string);\n  move(key: string, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: string);\n  delete(key: string);\n  done();\n}\n\ninterface IteratorSynchronizerOptions {\n  target: IteratorSynchronizerDelegate;\n  artifacts: IterationArtifacts;\n}\n\nenum Phase {\n  Append,\n  Prune,\n  Done\n}\n\nexport class IteratorSynchronizer {\n  private target: IteratorSynchronizerDelegate;\n  private iterator: OpaqueIterator;\n  private current: ListItem;\n  private artifacts: IterationArtifacts;\n\n  constructor({ target, artifacts }: IteratorSynchronizerOptions) {\n    this.target = target;\n    this.artifacts = artifacts;\n    this.iterator = artifacts.iterate();\n    this.current = artifacts.head();\n  }\n\n  sync() {\n    let phase: Phase = Phase.Append;\n\n    while (true) {\n      switch (phase) {\n        case Phase.Append: phase = this.nextAppend(); break;\n        case Phase.Prune: phase = this.nextPrune(); break;\n        case Phase.Done: this.nextDone(); return;\n      }\n    }\n  }\n\n  private advanceToKey(key: string) {\n    let { current, artifacts } = this;\n\n    let seek = current;\n\n    while (seek && seek.key !== key) {\n      seek.seen = true;\n      seek = artifacts.nextNode(seek);\n    }\n\n    this.current = seek && artifacts.nextNode(seek);\n  }\n\n  private nextAppend(): Phase {\n    let { iterator, current, artifacts } = this;\n\n    let item = iterator.next();\n\n    if (item === null) {\n      return this.startPrune();\n    }\n\n    let { key } = item;\n\n    if (current && current.key === key) {\n      this.nextRetain(item);\n    } else if (artifacts.has(key)) {\n      this.nextMove(item);\n    } else {\n      this.nextInsert(item);\n    }\n\n    return Phase.Append;\n  }\n\n  private nextRetain(item: OpaqueIterationItem) {\n    let { artifacts, current } = this;\n\n    current.update(item);\n    this.current = artifacts.nextNode(current);\n    this.target.retain(item.key, current.value, current.memo);\n  }\n\n  private nextMove(item: OpaqueIterationItem) {\n    let { current, artifacts, target } = this;\n    let { key } = item;\n\n    let found = artifacts.get(item.key);\n    found.update(item);\n\n    if (artifacts.wasSeen(item.key)) {\n      artifacts.move(found, current);\n      target.move(found.key, found.value, found.memo, current ? current.key : null);\n    } else {\n      this.advanceToKey(key);\n    }\n  }\n\n  private nextInsert(item: OpaqueIterationItem) {\n    let { artifacts, target, current } = this;\n\n    let node = artifacts.insertBefore(item, current);\n    target.insert(node.key, node.value, node.memo, current ? current.key : null);\n  }\n\n  private startPrune(): Phase {\n    this.current = this.artifacts.head();\n    return Phase.Prune;\n  }\n\n  private nextPrune(): Phase {\n    let { artifacts, target, current } = this;\n\n    if (current === null) {\n      return Phase.Done;\n    }\n\n    let node = current;\n    this.current = artifacts.nextNode(node);\n\n    if (node.shouldRemove()) {\n      artifacts.remove(node);\n      target.delete(node.key);\n    } else {\n      node.reset();\n    }\n\n    return Phase.Prune;\n  }\n\n  private nextDone() {\n    this.target.done();\n  }\n}\n"]} enifed("glimmer-reference/lib/reference", ["exports"], function (exports) { "use strict"; }); //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcmVmZXJlbmNlL2xpYi9yZWZlcmVuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJyZWZlcmVuY2UuanMiLCJzb3VyY2VzQ29udGVudCI6W119 enifed("glimmer-reference/lib/utils", ["exports"], function (exports) { @@ -13257,37 +14170,28 @@ reference = reference.get(parts[i]); } return reference; } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcmVmZXJlbmNlL2xpYi91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUdBLGFBQUEsa0JBQUEsQ0FBbUMsSUFBb0MsRUFBRSxLQUF1QixFQUFBO0FBQzlGLFlBQUksU0FBUyxHQUFHLElBQUksQ0FBQztBQUVyQixhQUFLLElBQUksQ0FBQyxHQUFDLENBQUMsRUFBRSxDQUFDLEdBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRTtBQUNqQyxxQkFBUyxHQUFHLFNBQVMsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7U0FDckM7QUFFRCxlQUFPLFNBQVMsQ0FBQztLQUNsQiIsImZpbGUiOiJ1dGlscy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFZlcnNpb25lZFBhdGhSZWZlcmVuY2UgfSBmcm9tICcuL3ZhbGlkYXRvcnMnO1xuaW1wb3J0IHsgSW50ZXJuZWRTdHJpbmcsIE9wYXF1ZSB9IGZyb20gJ2dsaW1tZXItdXRpbCc7XG5cbmV4cG9ydCBmdW5jdGlvbiByZWZlcmVuY2VGcm9tUGFydHMocm9vdDogVmVyc2lvbmVkUGF0aFJlZmVyZW5jZTxPcGFxdWU+LCBwYXJ0czogSW50ZXJuZWRTdHJpbmdbXSk6IFZlcnNpb25lZFBhdGhSZWZlcmVuY2U8T3BhcXVlPiB7XG4gIGxldCByZWZlcmVuY2UgPSByb290O1xuXG4gIGZvciAobGV0IGk9MDsgaTxwYXJ0cy5sZW5ndGg7IGkrKykge1xuICAgIHJlZmVyZW5jZSA9IHJlZmVyZW5jZS5nZXQocGFydHNbaV0pO1xuICB9XG5cbiAgcmV0dXJuIHJlZmVyZW5jZTtcbn1cbiJdfQ== +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcmVmZXJlbmNlL2xpYi91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUdNLGFBQUEsa0JBQUEsQ0FBNkIsSUFBb0MsRUFBRSxLQUFlLEVBQUE7QUFDdEYsWUFBSSxTQUFTLEdBQUcsSUFBSSxDQUFDO0FBRXJCLGFBQUssSUFBSSxDQUFDLEdBQUMsQ0FBQyxFQUFFLENBQUMsR0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO0FBQ2pDLHFCQUFTLEdBQUcsU0FBUyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztTQUNyQztBQUVELGVBQU8sU0FBUyxDQUFDO0tBQ2xCIiwiZmlsZSI6InV0aWxzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVmVyc2lvbmVkUGF0aFJlZmVyZW5jZSB9IGZyb20gJy4vdmFsaWRhdG9ycyc7XG5pbXBvcnQgeyBPcGFxdWUgfSBmcm9tICdnbGltbWVyLXV0aWwnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVmZXJlbmNlRnJvbVBhcnRzKHJvb3Q6IFZlcnNpb25lZFBhdGhSZWZlcmVuY2U8T3BhcXVlPiwgcGFydHM6IHN0cmluZ1tdKTogVmVyc2lvbmVkUGF0aFJlZmVyZW5jZTxPcGFxdWU+IHtcbiAgbGV0IHJlZmVyZW5jZSA9IHJvb3Q7XG5cbiAgZm9yIChsZXQgaT0wOyBpPHBhcnRzLmxlbmd0aDsgaSsrKSB7XG4gICAgcmVmZXJlbmNlID0gcmVmZXJlbmNlLmdldChwYXJ0c1tpXSk7XG4gIH1cblxuICByZXR1cm4gcmVmZXJlbmNlO1xufVxuIl19 enifed("glimmer-reference/lib/validators", ["exports"], function (exports) { "use strict"; exports.combineTagged = combineTagged; exports.combineSlice = combineSlice; exports.combine = combine; exports.map = map; exports.isModified = isModified; - - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var CONSTANT = 0; exports.CONSTANT = CONSTANT; var INITIAL = 1; exports.INITIAL = INITIAL; var VOLATILE = NaN; exports.VOLATILE = VOLATILE; var RevisionTag = (function () { - function RevisionTag() { - _classCallCheck(this, RevisionTag); - } + function RevisionTag() {} RevisionTag.prototype.validate = function validate(snapshot) { return this.value() === snapshot; }; @@ -13297,17 +14201,15 @@ exports.RevisionTag = RevisionTag; var $REVISION = INITIAL; var DirtyableTag = (function (_RevisionTag) { - _inherits(DirtyableTag, _RevisionTag); + babelHelpers.inherits(DirtyableTag, _RevisionTag); function DirtyableTag() { var revision = arguments.length <= 0 || arguments[0] === undefined ? $REVISION : arguments[0]; - _classCallCheck(this, DirtyableTag); - _RevisionTag.call(this); this.revision = revision; } DirtyableTag.prototype.value = function value() { @@ -13370,20 +14272,14 @@ } ; } var CachedTag = (function (_RevisionTag2) { - _inherits(CachedTag, _RevisionTag2); + babelHelpers.inherits(CachedTag, _RevisionTag2); function CachedTag() { - _classCallCheck(this, CachedTag); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _RevisionTag2.call.apply(_RevisionTag2, [this].concat(args)); + _RevisionTag2.apply(this, arguments); this.lastChecked = null; this.lastValue = null; } CachedTag.prototype.value = function value() { @@ -13405,15 +14301,13 @@ })(RevisionTag); exports.CachedTag = CachedTag; var TagsPair = (function (_CachedTag) { - _inherits(TagsPair, _CachedTag); + babelHelpers.inherits(TagsPair, _CachedTag); function TagsPair(first, second) { - _classCallCheck(this, TagsPair); - _CachedTag.call(this); this.first = first; this.second = second; } @@ -13423,15 +14317,13 @@ return TagsPair; })(CachedTag); var TagsCombinator = (function (_CachedTag2) { - _inherits(TagsCombinator, _CachedTag2); + babelHelpers.inherits(TagsCombinator, _CachedTag2); function TagsCombinator(tags) { - _classCallCheck(this, TagsCombinator); - _CachedTag2.call(this); this.tags = tags; } TagsCombinator.prototype.compute = function compute() { @@ -13447,15 +14339,13 @@ return TagsCombinator; })(CachedTag); var UpdatableTag = (function (_CachedTag3) { - _inherits(UpdatableTag, _CachedTag3); + babelHelpers.inherits(UpdatableTag, _CachedTag3); function UpdatableTag(tag) { - _classCallCheck(this, UpdatableTag); - _CachedTag3.call(this); this.tag = tag; this.lastUpdated = INITIAL; } @@ -13476,15 +14366,13 @@ return UpdatableTag; })(CachedTag); exports.UpdatableTag = UpdatableTag; var CONSTANT_TAG = new ((function (_RevisionTag3) { - _inherits(ConstantTag, _RevisionTag3); + babelHelpers.inherits(ConstantTag, _RevisionTag3); function ConstantTag() { - _classCallCheck(this, ConstantTag); - _RevisionTag3.apply(this, arguments); } ConstantTag.prototype.value = function value() { return CONSTANT; @@ -13492,15 +14380,13 @@ return ConstantTag; })(RevisionTag))(); exports.CONSTANT_TAG = CONSTANT_TAG; var VOLATILE_TAG = new ((function (_RevisionTag4) { - _inherits(VolatileTag, _RevisionTag4); + babelHelpers.inherits(VolatileTag, _RevisionTag4); function VolatileTag() { - _classCallCheck(this, VolatileTag); - _RevisionTag4.apply(this, arguments); } VolatileTag.prototype.value = function value() { return VOLATILE; @@ -13508,15 +14394,13 @@ return VolatileTag; })(RevisionTag))(); exports.VOLATILE_TAG = VOLATILE_TAG; var CURRENT_TAG = new ((function (_DirtyableTag) { - _inherits(CurrentTag, _DirtyableTag); + babelHelpers.inherits(CurrentTag, _DirtyableTag); function CurrentTag() { - _classCallCheck(this, CurrentTag); - _DirtyableTag.apply(this, arguments); } CurrentTag.prototype.value = function value() { return $REVISION; @@ -13526,12 +14410,10 @@ })(DirtyableTag))(); exports.CURRENT_TAG = CURRENT_TAG; var CachedReference = (function () { function CachedReference() { - _classCallCheck(this, CachedReference); - this.lastRevision = null; this.lastValue = null; } CachedReference.prototype.value = function value() { @@ -13554,15 +14436,13 @@ })(); exports.CachedReference = CachedReference; var MapperReference = (function (_CachedReference) { - _inherits(MapperReference, _CachedReference); + babelHelpers.inherits(MapperReference, _CachedReference); function MapperReference(reference, mapper) { - _classCallCheck(this, MapperReference); - _CachedReference.call(this); this.tag = reference.tag; this.reference = reference; this.mapper = mapper; } @@ -13583,12 +14463,10 @@ ////////// var ReferenceCache = (function () { function ReferenceCache(reference) { - _classCallCheck(this, ReferenceCache); - this.lastValue = null; this.lastRevision = null; this.initialized = false; this.tag = reference.tag; this.reference = reference; @@ -13637,23 +14515,25 @@ function isModified(value) { return value !== NOT_MODIFIED; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-reference/lib/validators.ts"],"names":[],"mappings":"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","file":"validators.js","sourcesContent":["import Reference, { PathReference } from './reference';\nimport { InternedString, Opaque, Slice, LinkedListNode } from 'glimmer-util';\n\n//////////\n\nexport interface EntityTag<T> extends Reference<T> {\n  value(): T;\n  validate(snapshot: T);\n}\n\nexport interface Tagged<T> {\n  tag: EntityTag<T>;\n}\n\n//////////\n\nexport type Revision = number;\n\nexport const CONSTANT: Revision = 0;\nexport const INITIAL:  Revision = 1;\nexport const VOLATILE: Revision = NaN;\n\nexport abstract class RevisionTag implements RevisionTag {\n  abstract value(): Revision;\n\n  validate(snapshot: Revision): boolean {\n    return this.value() === snapshot;\n  }\n}\n\nlet $REVISION = INITIAL;\n\nexport class DirtyableTag extends RevisionTag {\n  private revision: Revision;\n\n  constructor(revision = $REVISION) {\n    super();\n    this.revision = revision;\n  }\n\n  value(): Revision {\n    return this.revision;\n  }\n\n  dirty() {\n    this.revision = ++$REVISION;\n  }\n}\n\nexport function combineTagged(tagged: Tagged<Revision>[]): RevisionTag {\n  let optimized = [];\n\n  for (let i=0, l=tagged.length; i<l; i++) {\n    let tag = tagged[i].tag;\n    if (tag === VOLATILE_TAG) return VOLATILE_TAG;\n    if (tag === CONSTANT_TAG) continue;\n    optimized.push(tag);\n  }\n\n  return _combine(optimized);\n}\n\nexport function combineSlice(slice: Slice<Tagged<Revision> & LinkedListNode>): RevisionTag {\n  let optimized = [];\n\n  let node = slice.head();\n\n  while(node !== null) {\n    let tag = node.tag;\n\n    if (tag === VOLATILE_TAG) return VOLATILE_TAG;\n    if (tag !== CONSTANT_TAG) optimized.push(tag);\n\n    node = slice.nextNode(node);\n  }\n\n  return _combine(optimized);\n}\n\nexport function combine(tags: RevisionTag[]): RevisionTag {\n  let optimized = [];\n\n  for (let i=0, l=tags.length; i<l; i++) {\n    let tag = tags[i];\n    if (tag === VOLATILE_TAG) return VOLATILE_TAG;\n    if (tag === CONSTANT_TAG) continue;\n    optimized.push(tag);\n  }\n\n  return _combine(optimized);\n}\n\nfunction _combine(tags: RevisionTag[]): RevisionTag {\n  switch (tags.length) {\n    case 0:\n      return CONSTANT_TAG;\n    case 1:\n      return tags[0];\n    case 2:\n      return new TagsPair(tags[0], tags[1]);\n    default:\n      return new TagsCombinator(tags);\n  };\n}\n\nexport abstract class CachedTag extends RevisionTag {\n  private lastChecked: Revision = null;\n  private lastValue: Revision = null;\n\n  value(): Revision {\n    let { lastChecked, lastValue } = this;\n\n    if (lastChecked !== $REVISION) {\n      this.lastChecked = $REVISION;\n      this.lastValue = lastValue = this.compute();\n    }\n\n    return this.lastValue;\n  }\n\n  protected invalidate() {\n    this.lastChecked = null;\n  }\n\n  protected abstract compute(): Revision;\n}\n\nclass TagsPair extends CachedTag {\n  private first: RevisionTag;\n  private second: RevisionTag;\n\n  constructor(first: RevisionTag, second: RevisionTag) {\n    super();\n    this.first = first;\n    this.second = second;\n  }\n\n  protected compute(): Revision {\n    return Math.max(this.first.value(), this.second.value());\n  }\n}\n\nclass TagsCombinator extends CachedTag {\n  private tags: RevisionTag[];\n\n  constructor(tags: RevisionTag[]) {\n    super();\n    this.tags = tags;\n  }\n\n  protected compute(): Revision {\n    let { tags } = this;\n\n    let max = -1;\n\n    for (let i=0; i<tags.length; i++) {\n      let value = tags[i].value();\n      max = Math.max(value, max);\n    }\n\n    return max;\n  }\n}\n\nexport class UpdatableTag extends CachedTag {\n  private tag: RevisionTag;\n  private lastUpdated: Revision;\n\n  constructor(tag: RevisionTag) {\n    super();\n    this.tag = tag;\n    this.lastUpdated = INITIAL;\n  }\n\n  protected compute(): Revision {\n    return Math.max(this.lastUpdated, this.tag.value());\n  }\n\n  update(tag: RevisionTag) {\n    if (tag !== this.tag) {\n      this.tag = tag;\n      this.lastUpdated = $REVISION;\n      this.invalidate();\n    }\n  }\n}\n\n//////////\n\nexport const CONSTANT_TAG: RevisionTag = new (\n  class ConstantTag extends RevisionTag {\n    value(): Revision {\n      return CONSTANT;\n    }\n  }\n);\n\nexport const VOLATILE_TAG: RevisionTag = new (\n  class VolatileTag extends RevisionTag {\n    value(): Revision {\n      return VOLATILE;\n    }\n  }\n);\n\nexport const CURRENT_TAG: DirtyableTag = new (\n  class CurrentTag extends DirtyableTag {\n    value(): Revision {\n      return $REVISION;\n    }\n  }\n);\n\n//////////\n\nexport interface VersionedReference<T> extends Reference<T>, Tagged<Revision> {}\n\nexport interface VersionedPathReference<T> extends PathReference<T>, Tagged<Revision> {\n  get(property: InternedString): VersionedPathReference<Opaque>;\n}\n\nexport abstract class CachedReference<T> implements VersionedReference<T> {\n  public abstract tag: RevisionTag;\n\n  private lastRevision: Revision = null;\n  private lastValue: T = null;\n\n  value(): T {\n    let { tag, lastRevision, lastValue } = this;\n\n    if (!lastRevision || !tag.validate(lastRevision)) {\n      lastValue = this.lastValue = this.compute();\n      this.lastRevision = tag.value();\n    }\n\n    return lastValue;\n  }\n\n  protected abstract compute(): T;\n\n  protected invalidate() {\n    this.lastRevision = null;\n  }\n}\n\n//////////\n\ntype Mapper<T, U> = (value: T) => U;\n\nclass MapperReference<T, U> extends CachedReference<U> {\n  public tag: RevisionTag;\n\n  private reference: VersionedReference<T>;\n  private mapper: Mapper<T, U>;\n\n  constructor(reference: VersionedReference<T>, mapper: Mapper<T, U>) {\n    super();\n    this.tag = reference.tag;\n    this.reference = reference;\n    this.mapper = mapper;\n  }\n\n  protected compute(): U {\n    let { reference, mapper } = this;\n    return mapper(reference.value());\n  }\n}\n\nexport function map<T, U>(reference: VersionedReference<T>, mapper: Mapper<T, U>) {\n  return new MapperReference(reference, mapper);\n}\n\n//////////\n\nexport class ReferenceCache<T> implements Tagged<Revision> {\n  public tag: RevisionTag;\n\n  private reference: VersionedReference<T>;\n  private lastValue: T = null;\n  private lastRevision: Revision = null;\n  private initialized: boolean = false;\n\n  constructor(reference: VersionedReference<T>) {\n    this.tag = reference.tag;\n    this.reference = reference;\n  }\n\n  peek(): T {\n    if (!this.initialized) {\n      return this.initialize();\n    }\n\n    return this.lastValue;\n  }\n\n  revalidate(): Validation<T> {\n    if (!this.initialized) {\n      return this.initialize();\n    }\n\n    let { reference, lastRevision } = this;\n    let tag = reference.tag;\n\n    if (tag.validate(lastRevision)) return NOT_MODIFIED;\n    this.lastRevision = tag.value();\n\n    let { lastValue } = this;\n    let value = reference.value();\n    if (value === lastValue) return NOT_MODIFIED;\n    this.lastValue = value;\n\n    return value;\n  }\n\n  private initialize(): T {\n    let { reference } = this;\n\n    let value = this.lastValue = reference.value();\n    this.lastRevision = reference.tag.value();\n    this.initialized = true;\n\n    return value;\n  }\n}\n\nexport type Validation<T> = T | NotModified;\n\ntype NotModified = \"adb3b78e-3d22-4e4b-877a-6317c2c5c145\";\n\nconst NOT_MODIFIED: NotModified = \"adb3b78e-3d22-4e4b-877a-6317c2c5c145\";\n\nexport function isModified<T>(value: Validation<T>): value is T {\n  return value !== NOT_MODIFIED;\n}\n"]} -enifed('glimmer-runtime/index', ['exports', 'glimmer-runtime/lib/syntax', 'glimmer-runtime/lib/template', 'glimmer-runtime/lib/symbol-table', 'glimmer-runtime/lib/references', 'glimmer-runtime/lib/syntax/core', 'glimmer-runtime/lib/compiler', 'glimmer-runtime/lib/opcode-builder', 'glimmer-runtime/lib/compiled/opcodes/builder', 'glimmer-runtime/lib/compiled/blocks', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/opcodes/vm', 'glimmer-runtime/lib/compiled/opcodes/component', 'glimmer-runtime/lib/compiled/opcodes/dom', 'glimmer-runtime/lib/dom/change-lists', 'glimmer-runtime/lib/compiled/opcodes/content', 'glimmer-runtime/lib/compiled/expressions', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-runtime/lib/compiled/expressions/value', 'glimmer-runtime/lib/compiled/expressions/function', 'glimmer-runtime/lib/compiled/opcodes/lists', 'glimmer-runtime/lib/vm', 'glimmer-runtime/lib/upsert', 'glimmer-runtime/lib/environment', 'glimmer-runtime/lib/partial', 'glimmer-runtime/lib/component/interfaces', 'glimmer-runtime/lib/modifier/interfaces', 'glimmer-runtime/lib/dom/helper', 'glimmer-runtime/lib/builder'], function (exports, _glimmerRuntimeLibSyntax, _glimmerRuntimeLibTemplate, _glimmerRuntimeLibSymbolTable, _glimmerRuntimeLibReferences, _glimmerRuntimeLibSyntaxCore, _glimmerRuntimeLibCompiler, _glimmerRuntimeLibOpcodeBuilder, _glimmerRuntimeLibCompiledOpcodesBuilder, _glimmerRuntimeLibCompiledBlocks, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledOpcodesVm, _glimmerRuntimeLibCompiledOpcodesComponent, _glimmerRuntimeLibCompiledOpcodesDom, _glimmerRuntimeLibDomChangeLists, _glimmerRuntimeLibCompiledOpcodesContent, _glimmerRuntimeLibCompiledExpressions, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerRuntimeLibCompiledExpressionsValue, _glimmerRuntimeLibCompiledExpressionsFunction, _glimmerRuntimeLibCompiledOpcodesLists, _glimmerRuntimeLibVm, _glimmerRuntimeLibUpsert, _glimmerRuntimeLibEnvironment, _glimmerRuntimeLibPartial, _glimmerRuntimeLibComponentInterfaces, _glimmerRuntimeLibModifierInterfaces, _glimmerRuntimeLibDomHelper, _glimmerRuntimeLibBuilder) { +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-reference/lib/validators.ts"],"names":[],"mappings":"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","file":"validators.js","sourcesContent":["import Reference, { PathReference } from './reference';\nimport { Opaque, Slice, LinkedListNode } from 'glimmer-util';\n\n//////////\n\nexport interface EntityTag<T> extends Reference<T> {\n  value(): T;\n  validate(snapshot: T);\n}\n\nexport interface Tagged<T> {\n  tag: EntityTag<T>;\n}\n\n//////////\n\nexport type Revision = number;\n\nexport const CONSTANT: Revision = 0;\nexport const INITIAL:  Revision = 1;\nexport const VOLATILE: Revision = NaN;\n\nexport abstract class RevisionTag implements RevisionTag {\n  abstract value(): Revision;\n\n  validate(snapshot: Revision): boolean {\n    return this.value() === snapshot;\n  }\n}\n\nlet $REVISION = INITIAL;\n\nexport class DirtyableTag extends RevisionTag {\n  private revision: Revision;\n\n  constructor(revision = $REVISION) {\n    super();\n    this.revision = revision;\n  }\n\n  value(): Revision {\n    return this.revision;\n  }\n\n  dirty() {\n    this.revision = ++$REVISION;\n  }\n}\n\nexport function combineTagged(tagged: Tagged<Revision>[]): RevisionTag {\n  let optimized = [];\n\n  for (let i=0, l=tagged.length; i<l; i++) {\n    let tag = tagged[i].tag;\n    if (tag === VOLATILE_TAG) return VOLATILE_TAG;\n    if (tag === CONSTANT_TAG) continue;\n    optimized.push(tag);\n  }\n\n  return _combine(optimized);\n}\n\nexport function combineSlice(slice: Slice<Tagged<Revision> & LinkedListNode>): RevisionTag {\n  let optimized = [];\n\n  let node = slice.head();\n\n  while(node !== null) {\n    let tag = node.tag;\n\n    if (tag === VOLATILE_TAG) return VOLATILE_TAG;\n    if (tag !== CONSTANT_TAG) optimized.push(tag);\n\n    node = slice.nextNode(node);\n  }\n\n  return _combine(optimized);\n}\n\nexport function combine(tags: RevisionTag[]): RevisionTag {\n  let optimized = [];\n\n  for (let i=0, l=tags.length; i<l; i++) {\n    let tag = tags[i];\n    if (tag === VOLATILE_TAG) return VOLATILE_TAG;\n    if (tag === CONSTANT_TAG) continue;\n    optimized.push(tag);\n  }\n\n  return _combine(optimized);\n}\n\nfunction _combine(tags: RevisionTag[]): RevisionTag {\n  switch (tags.length) {\n    case 0:\n      return CONSTANT_TAG;\n    case 1:\n      return tags[0];\n    case 2:\n      return new TagsPair(tags[0], tags[1]);\n    default:\n      return new TagsCombinator(tags);\n  };\n}\n\nexport abstract class CachedTag extends RevisionTag {\n  private lastChecked: Revision = null;\n  private lastValue: Revision = null;\n\n  value(): Revision {\n    let { lastChecked, lastValue } = this;\n\n    if (lastChecked !== $REVISION) {\n      this.lastChecked = $REVISION;\n      this.lastValue = lastValue = this.compute();\n    }\n\n    return this.lastValue;\n  }\n\n  protected invalidate() {\n    this.lastChecked = null;\n  }\n\n  protected abstract compute(): Revision;\n}\n\nclass TagsPair extends CachedTag {\n  private first: RevisionTag;\n  private second: RevisionTag;\n\n  constructor(first: RevisionTag, second: RevisionTag) {\n    super();\n    this.first = first;\n    this.second = second;\n  }\n\n  protected compute(): Revision {\n    return Math.max(this.first.value(), this.second.value());\n  }\n}\n\nclass TagsCombinator extends CachedTag {\n  private tags: RevisionTag[];\n\n  constructor(tags: RevisionTag[]) {\n    super();\n    this.tags = tags;\n  }\n\n  protected compute(): Revision {\n    let { tags } = this;\n\n    let max = -1;\n\n    for (let i=0; i<tags.length; i++) {\n      let value = tags[i].value();\n      max = Math.max(value, max);\n    }\n\n    return max;\n  }\n}\n\nexport class UpdatableTag extends CachedTag {\n  private tag: RevisionTag;\n  private lastUpdated: Revision;\n\n  constructor(tag: RevisionTag) {\n    super();\n    this.tag = tag;\n    this.lastUpdated = INITIAL;\n  }\n\n  protected compute(): Revision {\n    return Math.max(this.lastUpdated, this.tag.value());\n  }\n\n  update(tag: RevisionTag) {\n    if (tag !== this.tag) {\n      this.tag = tag;\n      this.lastUpdated = $REVISION;\n      this.invalidate();\n    }\n  }\n}\n\n//////////\n\nexport const CONSTANT_TAG: RevisionTag = new (\n  class ConstantTag extends RevisionTag {\n    value(): Revision {\n      return CONSTANT;\n    }\n  }\n);\n\nexport const VOLATILE_TAG: RevisionTag = new (\n  class VolatileTag extends RevisionTag {\n    value(): Revision {\n      return VOLATILE;\n    }\n  }\n);\n\nexport const CURRENT_TAG: DirtyableTag = new (\n  class CurrentTag extends DirtyableTag {\n    value(): Revision {\n      return $REVISION;\n    }\n  }\n);\n\n//////////\n\nexport interface VersionedReference<T> extends Reference<T>, Tagged<Revision> {}\n\nexport interface VersionedPathReference<T> extends PathReference<T>, Tagged<Revision> {\n  get(property: string): VersionedPathReference<Opaque>;\n}\n\nexport abstract class CachedReference<T> implements VersionedReference<T> {\n  public abstract tag: RevisionTag;\n\n  private lastRevision: Revision = null;\n  private lastValue: T = null;\n\n  value(): T {\n    let { tag, lastRevision, lastValue } = this;\n\n    if (!lastRevision || !tag.validate(lastRevision)) {\n      lastValue = this.lastValue = this.compute();\n      this.lastRevision = tag.value();\n    }\n\n    return lastValue;\n  }\n\n  protected abstract compute(): T;\n\n  protected invalidate() {\n    this.lastRevision = null;\n  }\n}\n\n//////////\n\ntype Mapper<T, U> = (value: T) => U;\n\nclass MapperReference<T, U> extends CachedReference<U> {\n  public tag: RevisionTag;\n\n  private reference: VersionedReference<T>;\n  private mapper: Mapper<T, U>;\n\n  constructor(reference: VersionedReference<T>, mapper: Mapper<T, U>) {\n    super();\n    this.tag = reference.tag;\n    this.reference = reference;\n    this.mapper = mapper;\n  }\n\n  protected compute(): U {\n    let { reference, mapper } = this;\n    return mapper(reference.value());\n  }\n}\n\nexport function map<T, U>(reference: VersionedReference<T>, mapper: Mapper<T, U>) {\n  return new MapperReference(reference, mapper);\n}\n\n//////////\n\nexport class ReferenceCache<T> implements Tagged<Revision> {\n  public tag: RevisionTag;\n\n  private reference: VersionedReference<T>;\n  private lastValue: T = null;\n  private lastRevision: Revision = null;\n  private initialized: boolean = false;\n\n  constructor(reference: VersionedReference<T>) {\n    this.tag = reference.tag;\n    this.reference = reference;\n  }\n\n  peek(): T {\n    if (!this.initialized) {\n      return this.initialize();\n    }\n\n    return this.lastValue;\n  }\n\n  revalidate(): Validation<T> {\n    if (!this.initialized) {\n      return this.initialize();\n    }\n\n    let { reference, lastRevision } = this;\n    let tag = reference.tag;\n\n    if (tag.validate(lastRevision)) return NOT_MODIFIED;\n    this.lastRevision = tag.value();\n\n    let { lastValue } = this;\n    let value = reference.value();\n    if (value === lastValue) return NOT_MODIFIED;\n    this.lastValue = value;\n\n    return value;\n  }\n\n  private initialize(): T {\n    let { reference } = this;\n\n    let value = this.lastValue = reference.value();\n    this.lastRevision = reference.tag.value();\n    this.initialized = true;\n\n    return value;\n  }\n}\n\nexport type Validation<T> = T | NotModified;\n\ntype NotModified = \"adb3b78e-3d22-4e4b-877a-6317c2c5c145\";\n\nconst NOT_MODIFIED: NotModified = \"adb3b78e-3d22-4e4b-877a-6317c2c5c145\";\n\nexport function isModified<T>(value: Validation<T>): value is T {\n  return value !== NOT_MODIFIED;\n}\n","export const CONSTANT = 0;\nexport const INITIAL = 1;\nexport const VOLATILE = NaN;\nexport class RevisionTag {\n    validate(snapshot) {\n        return this.value() === snapshot;\n    }\n}\nlet $REVISION = INITIAL;\nexport class DirtyableTag extends RevisionTag {\n    constructor(revision = $REVISION) {\n        super();\n        this.revision = revision;\n    }\n    value() {\n        return this.revision;\n    }\n    dirty() {\n        this.revision = ++$REVISION;\n    }\n}\nexport function combineTagged(tagged) {\n    let optimized = [];\n    for (let i = 0, l = tagged.length; i < l; i++) {\n        let tag = tagged[i].tag;\n        if (tag === VOLATILE_TAG)\n            return VOLATILE_TAG;\n        if (tag === CONSTANT_TAG)\n            continue;\n        optimized.push(tag);\n    }\n    return _combine(optimized);\n}\nexport function combineSlice(slice) {\n    let optimized = [];\n    let node = slice.head();\n    while (node !== null) {\n        let tag = node.tag;\n        if (tag === VOLATILE_TAG)\n            return VOLATILE_TAG;\n        if (tag !== CONSTANT_TAG)\n            optimized.push(tag);\n        node = slice.nextNode(node);\n    }\n    return _combine(optimized);\n}\nexport function combine(tags) {\n    let optimized = [];\n    for (let i = 0, l = tags.length; i < l; i++) {\n        let tag = tags[i];\n        if (tag === VOLATILE_TAG)\n            return VOLATILE_TAG;\n        if (tag === CONSTANT_TAG)\n            continue;\n        optimized.push(tag);\n    }\n    return _combine(optimized);\n}\nfunction _combine(tags) {\n    switch (tags.length) {\n        case 0:\n            return CONSTANT_TAG;\n        case 1:\n            return tags[0];\n        case 2:\n            return new TagsPair(tags[0], tags[1]);\n        default:\n            return new TagsCombinator(tags);\n    }\n    ;\n}\nexport class CachedTag extends RevisionTag {\n    constructor() {\n        super(...arguments);\n        this.lastChecked = null;\n        this.lastValue = null;\n    }\n    value() {\n        let { lastChecked, lastValue } = this;\n        if (lastChecked !== $REVISION) {\n            this.lastChecked = $REVISION;\n            this.lastValue = lastValue = this.compute();\n        }\n        return this.lastValue;\n    }\n    invalidate() {\n        this.lastChecked = null;\n    }\n}\nclass TagsPair extends CachedTag {\n    constructor(first, second) {\n        super();\n        this.first = first;\n        this.second = second;\n    }\n    compute() {\n        return Math.max(this.first.value(), this.second.value());\n    }\n}\nclass TagsCombinator extends CachedTag {\n    constructor(tags) {\n        super();\n        this.tags = tags;\n    }\n    compute() {\n        let { tags } = this;\n        let max = -1;\n        for (let i = 0; i < tags.length; i++) {\n            let value = tags[i].value();\n            max = Math.max(value, max);\n        }\n        return max;\n    }\n}\nexport class UpdatableTag extends CachedTag {\n    constructor(tag) {\n        super();\n        this.tag = tag;\n        this.lastUpdated = INITIAL;\n    }\n    compute() {\n        return Math.max(this.lastUpdated, this.tag.value());\n    }\n    update(tag) {\n        if (tag !== this.tag) {\n            this.tag = tag;\n            this.lastUpdated = $REVISION;\n            this.invalidate();\n        }\n    }\n}\n//////////\nexport const CONSTANT_TAG = new (class ConstantTag extends RevisionTag {\n    value() {\n        return CONSTANT;\n    }\n});\nexport const VOLATILE_TAG = new (class VolatileTag extends RevisionTag {\n    value() {\n        return VOLATILE;\n    }\n});\nexport const CURRENT_TAG = new (class CurrentTag extends DirtyableTag {\n    value() {\n        return $REVISION;\n    }\n});\nexport class CachedReference {\n    constructor() {\n        this.lastRevision = null;\n        this.lastValue = null;\n    }\n    value() {\n        let { tag, lastRevision, lastValue } = this;\n        if (!lastRevision || !tag.validate(lastRevision)) {\n            lastValue = this.lastValue = this.compute();\n            this.lastRevision = tag.value();\n        }\n        return lastValue;\n    }\n    invalidate() {\n        this.lastRevision = null;\n    }\n}\nclass MapperReference extends CachedReference {\n    constructor(reference, mapper) {\n        super();\n        this.tag = reference.tag;\n        this.reference = reference;\n        this.mapper = mapper;\n    }\n    compute() {\n        let { reference, mapper } = this;\n        return mapper(reference.value());\n    }\n}\nexport function map(reference, mapper) {\n    return new MapperReference(reference, mapper);\n}\n//////////\nexport class ReferenceCache {\n    constructor(reference) {\n        this.lastValue = null;\n        this.lastRevision = null;\n        this.initialized = false;\n        this.tag = reference.tag;\n        this.reference = reference;\n    }\n    peek() {\n        if (!this.initialized) {\n            return this.initialize();\n        }\n        return this.lastValue;\n    }\n    revalidate() {\n        if (!this.initialized) {\n            return this.initialize();\n        }\n        let { reference, lastRevision } = this;\n        let tag = reference.tag;\n        if (tag.validate(lastRevision))\n            return NOT_MODIFIED;\n        this.lastRevision = tag.value();\n        let { lastValue } = this;\n        let value = reference.value();\n        if (value === lastValue)\n            return NOT_MODIFIED;\n        this.lastValue = value;\n        return value;\n    }\n    initialize() {\n        let { reference } = this;\n        let value = this.lastValue = reference.value();\n        this.lastRevision = reference.tag.value();\n        this.initialized = true;\n        return value;\n    }\n}\nconst NOT_MODIFIED = \"adb3b78e-3d22-4e4b-877a-6317c2c5c145\";\nexport function isModified(value) {\n    return value !== NOT_MODIFIED;\n}\n"]} +enifed('glimmer-runtime/index', ['exports', 'glimmer-runtime/lib/dom/interfaces', 'glimmer-runtime/lib/syntax', 'glimmer-runtime/lib/template', 'glimmer-runtime/lib/symbol-table', 'glimmer-runtime/lib/references', 'glimmer-runtime/lib/syntax/core', 'glimmer-runtime/lib/compiler', 'glimmer-runtime/lib/opcode-builder', 'glimmer-runtime/lib/compiled/opcodes/builder', 'glimmer-runtime/lib/compiled/blocks', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/opcodes/vm', 'glimmer-runtime/lib/compiled/opcodes/component', 'glimmer-runtime/lib/compiled/opcodes/dom', 'glimmer-runtime/lib/dom/change-lists', 'glimmer-runtime/lib/compiled/opcodes/content', 'glimmer-runtime/lib/compiled/expressions', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-runtime/lib/compiled/expressions/value', 'glimmer-runtime/lib/compiled/expressions/function', 'glimmer-runtime/lib/compiled/opcodes/lists', 'glimmer-runtime/lib/helpers/get-dynamic-var', 'glimmer-runtime/lib/syntax/builtins/with-dynamic-vars', 'glimmer-runtime/lib/vm', 'glimmer-runtime/lib/upsert', 'glimmer-runtime/lib/environment', 'glimmer-runtime/lib/partial', 'glimmer-runtime/lib/component/interfaces', 'glimmer-runtime/lib/modifier/interfaces', 'glimmer-runtime/lib/dom/helper', 'glimmer-runtime/lib/builder', 'glimmer-runtime/lib/bounds'], function (exports, _glimmerRuntimeLibDomInterfaces, _glimmerRuntimeLibSyntax, _glimmerRuntimeLibTemplate, _glimmerRuntimeLibSymbolTable, _glimmerRuntimeLibReferences, _glimmerRuntimeLibSyntaxCore, _glimmerRuntimeLibCompiler, _glimmerRuntimeLibOpcodeBuilder, _glimmerRuntimeLibCompiledOpcodesBuilder, _glimmerRuntimeLibCompiledBlocks, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledOpcodesVm, _glimmerRuntimeLibCompiledOpcodesComponent, _glimmerRuntimeLibCompiledOpcodesDom, _glimmerRuntimeLibDomChangeLists, _glimmerRuntimeLibCompiledOpcodesContent, _glimmerRuntimeLibCompiledExpressions, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerRuntimeLibCompiledExpressionsValue, _glimmerRuntimeLibCompiledExpressionsFunction, _glimmerRuntimeLibCompiledOpcodesLists, _glimmerRuntimeLibHelpersGetDynamicVar, _glimmerRuntimeLibSyntaxBuiltinsWithDynamicVars, _glimmerRuntimeLibVm, _glimmerRuntimeLibUpsert, _glimmerRuntimeLibEnvironment, _glimmerRuntimeLibPartial, _glimmerRuntimeLibComponentInterfaces, _glimmerRuntimeLibModifierInterfaces, _glimmerRuntimeLibDomHelper, _glimmerRuntimeLibBuilder, _glimmerRuntimeLibBounds) { 'use strict'; exports.ATTRIBUTE_SYNTAX = _glimmerRuntimeLibSyntax.ATTRIBUTE; exports.StatementSyntax = _glimmerRuntimeLibSyntax.Statement; exports.ExpressionSyntax = _glimmerRuntimeLibSyntax.Expression; exports.AttributeSyntax = _glimmerRuntimeLibSyntax.Attribute; exports.StatementCompilationBuffer = _glimmerRuntimeLibSyntax.StatementCompilationBuffer; exports.SymbolLookup = _glimmerRuntimeLibSyntax.SymbolLookup; exports.CompileInto = _glimmerRuntimeLibSyntax.CompileInto; exports.isAttribute = _glimmerRuntimeLibSyntax.isAttribute; - exports.Template = _glimmerRuntimeLibTemplate.default; + exports.templateFactory = _glimmerRuntimeLibTemplate.default; + exports.TemplateFactory = _glimmerRuntimeLibTemplate.TemplateFactory; + exports.Template = _glimmerRuntimeLibTemplate.Template; exports.SymbolTable = _glimmerRuntimeLibSymbolTable.default; exports.ConditionalReference = _glimmerRuntimeLibReferences.ConditionalReference; exports.NULL_REFERENCE = _glimmerRuntimeLibReferences.NULL_REFERENCE; exports.UNDEFINED_REFERENCE = _glimmerRuntimeLibReferences.UNDEFINED_REFERENCE; exports.Templates = _glimmerRuntimeLibSyntaxCore.Templates; @@ -13676,21 +14556,18 @@ exports.CloseElementSyntax = _glimmerRuntimeLibSyntaxCore.CloseElement; exports.Compiler = _glimmerRuntimeLibCompiler.default; exports.Compilable = _glimmerRuntimeLibCompiler.Compilable; exports.CompileIntoList = _glimmerRuntimeLibCompiler.CompileIntoList; exports.compileLayout = _glimmerRuntimeLibCompiler.compileLayout; - exports.OpcodeBuilder = _glimmerRuntimeLibOpcodeBuilder.default; - exports.DynamicComponentOptions = _glimmerRuntimeLibOpcodeBuilder.DynamicComponentOptions; - exports.StaticComponentOptions = _glimmerRuntimeLibOpcodeBuilder.StaticComponentOptions; + exports.ComponentBuilder = _glimmerRuntimeLibOpcodeBuilder.ComponentBuilder; + exports.StaticDefinition = _glimmerRuntimeLibOpcodeBuilder.StaticDefinition; + exports.DynamicDefinition = _glimmerRuntimeLibOpcodeBuilder.DynamicDefinition; exports.OpcodeBuilderDSL = _glimmerRuntimeLibCompiledOpcodesBuilder.default; exports.Block = _glimmerRuntimeLibCompiledBlocks.Block; - exports.BlockOptions = _glimmerRuntimeLibCompiledBlocks.BlockOptions; exports.CompiledBlock = _glimmerRuntimeLibCompiledBlocks.CompiledBlock; exports.Layout = _glimmerRuntimeLibCompiledBlocks.Layout; - exports.LayoutOptions = _glimmerRuntimeLibCompiledBlocks.LayoutOptions; exports.InlineBlock = _glimmerRuntimeLibCompiledBlocks.InlineBlock; - exports.InlineBlockOptions = _glimmerRuntimeLibCompiledBlocks.InlineBlockOptions; exports.EntryPoint = _glimmerRuntimeLibCompiledBlocks.EntryPoint; exports.Opcode = _glimmerRuntimeLibOpcodes.Opcode; exports.OpSeq = _glimmerRuntimeLibOpcodes.OpSeq; exports.OpSeqBuilder = _glimmerRuntimeLibOpcodes.OpSeqBuilder; exports.inspectOpcodes = _glimmerRuntimeLibOpcodes.inspect; @@ -13709,11 +14586,10 @@ exports.JumpOpcode = _glimmerRuntimeLibCompiledOpcodesVm.JumpOpcode; exports.JumpIfOpcode = _glimmerRuntimeLibCompiledOpcodesVm.JumpIfOpcode; exports.JumpUnlessOpcode = _glimmerRuntimeLibCompiledOpcodesVm.JumpUnlessOpcode; exports.BindNamedArgsOpcode = _glimmerRuntimeLibCompiledOpcodesVm.BindNamedArgsOpcode; exports.BindDynamicScopeOpcode = _glimmerRuntimeLibCompiledOpcodesVm.BindDynamicScopeOpcode; - exports.OpenComponentOptions = _glimmerRuntimeLibCompiledOpcodesComponent.OpenComponentOptions; exports.OpenComponentOpcode = _glimmerRuntimeLibCompiledOpcodesComponent.OpenComponentOpcode; exports.CloseComponentOpcode = _glimmerRuntimeLibCompiledOpcodesComponent.CloseComponentOpcode; exports.ShadowAttributesOpcode = _glimmerRuntimeLibCompiledOpcodesComponent.ShadowAttributesOpcode; exports.OpenPrimitiveElementOpcode = _glimmerRuntimeLibCompiledOpcodesDom.OpenPrimitiveElementOpcode; exports.CloseElementOpcode = _glimmerRuntimeLibCompiledOpcodesDom.CloseElementOpcode; @@ -13739,10 +14615,12 @@ exports.FunctionExpression = _glimmerRuntimeLibCompiledExpressionsFunction.FunctionExpression; exports.EnterListOpcode = _glimmerRuntimeLibCompiledOpcodesLists.EnterListOpcode; exports.ExitListOpcode = _glimmerRuntimeLibCompiledOpcodesLists.ExitListOpcode; exports.EnterWithKeyOpcode = _glimmerRuntimeLibCompiledOpcodesLists.EnterWithKeyOpcode; exports.NextIterOpcode = _glimmerRuntimeLibCompiledOpcodesLists.NextIterOpcode; + exports.getDynamicVar = _glimmerRuntimeLibHelpersGetDynamicVar.default; + exports.WithDynamicVarsSyntax = _glimmerRuntimeLibSyntaxBuiltinsWithDynamicVars.default; exports.VM = _glimmerRuntimeLibVm.PublicVM; exports.UpdatingVM = _glimmerRuntimeLibVm.UpdatingVM; exports.RenderResult = _glimmerRuntimeLibVm.RenderResult; exports.SafeString = _glimmerRuntimeLibUpsert.SafeString; exports.isSafeString = _glimmerRuntimeLibUpsert.isSafeString; @@ -13756,42 +14634,63 @@ exports.ComponentClass = _glimmerRuntimeLibComponentInterfaces.ComponentClass; exports.ComponentManager = _glimmerRuntimeLibComponentInterfaces.ComponentManager; exports.ComponentDefinition = _glimmerRuntimeLibComponentInterfaces.ComponentDefinition; exports.ComponentLayoutBuilder = _glimmerRuntimeLibComponentInterfaces.ComponentLayoutBuilder; exports.ComponentAttrsBuilder = _glimmerRuntimeLibComponentInterfaces.ComponentAttrsBuilder; + exports.isComponentDefinition = _glimmerRuntimeLibComponentInterfaces.isComponentDefinition; exports.ModifierManager = _glimmerRuntimeLibModifierInterfaces.ModifierManager; - exports.DOMHelper = _glimmerRuntimeLibDomHelper.default; - exports.IDOMHelper = _glimmerRuntimeLibDomHelper.DOMHelper; + exports.DOMChanges = _glimmerRuntimeLibDomHelper.default; + exports.IDOMChanges = _glimmerRuntimeLibDomHelper.DOMChanges; + exports.DOMTreeConstruction = _glimmerRuntimeLibDomHelper.DOMTreeConstruction; exports.isWhitespace = _glimmerRuntimeLibDomHelper.isWhitespace; + exports.insertHTMLBefore = _glimmerRuntimeLibDomHelper.insertHTMLBefore; + exports.Simple = _glimmerRuntimeLibDomInterfaces; exports.ElementStack = _glimmerRuntimeLibBuilder.ElementStack; exports.ElementOperations = _glimmerRuntimeLibBuilder.ElementOperations; + exports.Bounds = _glimmerRuntimeLibBounds.default; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["export {\n  ATTRIBUTE as ATTRIBUTE_SYNTAX,\n  Statement as StatementSyntax,\n  Expression as ExpressionSyntax,\n  Attribute as AttributeSyntax,\n  StatementCompilationBuffer,\n  SymbolLookup,\n  CompileInto,\n  isAttribute\n} from './lib/syntax';\n\nexport { default as Template } from './lib/template';\n\nexport { default as SymbolTable } from './lib/symbol-table';\n\nexport { ConditionalReference, NULL_REFERENCE, UNDEFINED_REFERENCE } from './lib/references';\n\nexport {\n  Templates,\n  OptimizedAppend,\n  UnoptimizedAppend,\n  Unknown,\n  StaticAttr,\n  DynamicAttr,\n  Args as ArgsSyntax,\n  NamedArgs as NamedArgsSyntax,\n  PositionalArgs as PositionalArgsSyntax,\n  Ref as RefSyntax,\n  GetArgument as GetNamedParameterSyntax,\n  Get as GetSyntax,\n  Value as ValueSyntax,\n  OpenElement,\n  Helper as HelperSyntax,\n  Block as BlockSyntax,\n  OpenPrimitiveElement as OpenPrimitiveElementSyntax,\n  CloseElement as CloseElementSyntax\n} from './lib/syntax/core';\n\nexport {\n  default as Compiler,\n  Compilable,\n  CompileIntoList,\n  compileLayout\n} from './lib/compiler';\n\nexport {\n  default as OpcodeBuilder,\n  DynamicComponentOptions,\n  StaticComponentOptions\n} from './lib/opcode-builder';\n\nexport {\n  default as OpcodeBuilderDSL\n} from './lib/compiled/opcodes/builder';\n\nexport {\n  Block,\n  BlockOptions,\n  CompiledBlock,\n  Layout,\n  LayoutOptions,\n  InlineBlock,\n  InlineBlockOptions,\n  EntryPoint\n} from './lib/compiled/blocks';\n\nexport {\n  Opcode,\n  OpSeq,\n  OpSeqBuilder,\n  inspect as inspectOpcodes\n} from './lib/opcodes';\n\nexport {\n  PushChildScopeOpcode,\n  PopScopeOpcode,\n  PushDynamicScopeOpcode,\n  PopDynamicScopeOpcode,\n  PutValueOpcode,\n  PutNullOpcode,\n  PutArgsOpcode,\n  LabelOpcode,\n  EnterOpcode,\n  ExitOpcode,\n  EvaluateOpcode,\n  TestOpcode,\n  JumpOpcode,\n  JumpIfOpcode,\n  JumpUnlessOpcode,\n  BindNamedArgsOpcode,\n  BindDynamicScopeOpcode\n} from './lib/compiled/opcodes/vm';\n\nexport {\n  OpenComponentOptions,\n  OpenComponentOpcode,\n  CloseComponentOpcode,\n  ShadowAttributesOpcode\n} from './lib/compiled/opcodes/component';\n\nexport {\n  OpenPrimitiveElementOpcode,\n  CloseElementOpcode\n} from './lib/compiled/opcodes/dom';\n\nexport {\n  IChangeList,\n  AttributeChangeList,\n  PropertyChangeList,\n  SafeHrefAttributeChangeList,\n  SafeHrefPropertyChangeList,\n  InputValuePropertyChangeList,\n  defaultChangeLists,\n  defaultAttributeChangeLists,\n  defaultPropertyChangeLists,\n  readDOMAttr\n} from './lib/dom/change-lists';\n\nexport {\n  normalizeTextValue\n} from './lib/compiled/opcodes/content';\n\nexport {\n  CompiledExpression\n} from './lib/compiled/expressions';\n\nexport {\n  CompiledArgs,\n  CompiledNamedArgs,\n  CompiledPositionalArgs,\n  EvaluatedArgs,\n  EvaluatedNamedArgs,\n  EvaluatedPositionalArgs\n} from './lib/compiled/expressions/args';\n\nexport {\n  ValueReference\n} from './lib/compiled/expressions/value';\n\nexport {\n  FunctionExpression\n} from './lib/compiled/expressions/function';\n\nexport {\n  EnterListOpcode,\n  ExitListOpcode,\n  EnterWithKeyOpcode,\n  NextIterOpcode\n} from './lib/compiled/opcodes/lists';\n\nexport { PublicVM as VM, UpdatingVM, RenderResult } from './lib/vm';\n\nexport { SafeString, isSafeString } from './lib/upsert';\n\nexport {\n  Scope,\n  default as Environment,\n  Helper,\n  ParsedStatement,\n  DynamicScope,\n} from './lib/environment';\n\nexport {\n  PartialDefinition\n} from './lib/partial';\n\nexport {\n  Component,\n  ComponentClass,\n  ComponentManager,\n  ComponentDefinition,\n  ComponentLayoutBuilder,\n  ComponentAttrsBuilder\n} from './lib/component/interfaces';\n\nexport {\n  ModifierManager\n} from './lib/modifier/interfaces';\n\nexport { default as DOMHelper, DOMHelper as IDOMHelper, isWhitespace } from './lib/dom/helper';\nexport { ElementStack, ElementOperations } from './lib/builder';\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["export {\n  ATTRIBUTE as ATTRIBUTE_SYNTAX,\n  Statement as StatementSyntax,\n  Expression as ExpressionSyntax,\n  Attribute as AttributeSyntax,\n  StatementCompilationBuffer,\n  SymbolLookup,\n  CompileInto,\n  isAttribute\n} from './lib/syntax';\n\nexport { default as templateFactory, TemplateFactory, Template } from './lib/template';\n\nexport { default as SymbolTable } from './lib/symbol-table';\n\nexport { ConditionalReference, NULL_REFERENCE, UNDEFINED_REFERENCE } from './lib/references';\n\nexport {\n  Templates,\n  OptimizedAppend,\n  UnoptimizedAppend,\n  Unknown,\n  StaticAttr,\n  DynamicAttr,\n  Args as ArgsSyntax,\n  NamedArgs as NamedArgsSyntax,\n  PositionalArgs as PositionalArgsSyntax,\n  Ref as RefSyntax,\n  GetArgument as GetNamedParameterSyntax,\n  Get as GetSyntax,\n  Value as ValueSyntax,\n  OpenElement,\n  Helper as HelperSyntax,\n  Block as BlockSyntax,\n  OpenPrimitiveElement as OpenPrimitiveElementSyntax,\n  CloseElement as CloseElementSyntax\n} from './lib/syntax/core';\n\nexport {\n  default as Compiler,\n  Compilable,\n  CompileIntoList,\n  compileLayout\n} from './lib/compiler';\n\nexport {\n  ComponentBuilder,\n  StaticDefinition,\n  DynamicDefinition\n} from './lib/opcode-builder';\n\nexport {\n  default as OpcodeBuilderDSL\n} from './lib/compiled/opcodes/builder';\n\nexport {\n  Block,\n  CompiledBlock,\n  Layout,\n  InlineBlock,\n  EntryPoint\n} from './lib/compiled/blocks';\n\nexport {\n  Opcode,\n  OpSeq,\n  OpSeqBuilder,\n  inspect as inspectOpcodes\n} from './lib/opcodes';\n\nexport {\n  PushChildScopeOpcode,\n  PopScopeOpcode,\n  PushDynamicScopeOpcode,\n  PopDynamicScopeOpcode,\n  PutValueOpcode,\n  PutNullOpcode,\n  PutArgsOpcode,\n  LabelOpcode,\n  EnterOpcode,\n  ExitOpcode,\n  EvaluateOpcode,\n  TestOpcode,\n  JumpOpcode,\n  JumpIfOpcode,\n  JumpUnlessOpcode,\n  BindNamedArgsOpcode,\n  BindDynamicScopeOpcode\n} from './lib/compiled/opcodes/vm';\n\nexport {\n  OpenComponentOpcode,\n  CloseComponentOpcode,\n  ShadowAttributesOpcode\n} from './lib/compiled/opcodes/component';\n\nexport {\n  OpenPrimitiveElementOpcode,\n  CloseElementOpcode\n} from './lib/compiled/opcodes/dom';\n\nexport {\n  IChangeList,\n  AttributeChangeList,\n  PropertyChangeList,\n  SafeHrefAttributeChangeList,\n  SafeHrefPropertyChangeList,\n  InputValuePropertyChangeList,\n  defaultChangeLists,\n  defaultAttributeChangeLists,\n  defaultPropertyChangeLists,\n  readDOMAttr\n} from './lib/dom/change-lists';\n\nexport {\n  normalizeTextValue\n} from './lib/compiled/opcodes/content';\n\nexport {\n  CompiledExpression\n} from './lib/compiled/expressions';\n\nexport {\n  CompiledArgs,\n  CompiledNamedArgs,\n  CompiledPositionalArgs,\n  EvaluatedArgs,\n  EvaluatedNamedArgs,\n  EvaluatedPositionalArgs\n} from './lib/compiled/expressions/args';\n\nexport {\n  ValueReference\n} from './lib/compiled/expressions/value';\n\nexport {\n  FunctionExpression\n} from './lib/compiled/expressions/function';\n\nexport {\n  EnterListOpcode,\n  ExitListOpcode,\n  EnterWithKeyOpcode,\n  NextIterOpcode\n} from './lib/compiled/opcodes/lists';\n\nexport {\n  default as getDynamicVar\n} from './lib/helpers/get-dynamic-var';\n\nexport {\n  default as WithDynamicVarsSyntax\n} from './lib/syntax/builtins/with-dynamic-vars';\n\nexport { PublicVM as VM, UpdatingVM, RenderResult } from './lib/vm';\n\nexport { SafeString, isSafeString } from './lib/upsert';\n\nexport {\n  Scope,\n  default as Environment,\n  Helper,\n  ParsedStatement,\n  DynamicScope,\n} from './lib/environment';\n\nexport {\n  PartialDefinition\n} from './lib/partial';\n\nexport {\n  Component,\n  ComponentClass,\n  ComponentManager,\n  ComponentDefinition,\n  ComponentLayoutBuilder,\n  ComponentAttrsBuilder,\n  isComponentDefinition\n} from './lib/component/interfaces';\n\nexport {\n  ModifierManager\n} from './lib/modifier/interfaces';\n\nexport { default as DOMChanges, DOMChanges as IDOMChanges, DOMTreeConstruction, isWhitespace, insertHTMLBefore } from './lib/dom/helper';\nimport  * as Simple from './lib/dom/interfaces';\nexport { Simple };\nexport { ElementStack, ElementOperations } from './lib/builder';\nexport { default as Bounds } from './lib/bounds';\n"]} enifed("glimmer-runtime/lib/bounds", ["exports"], function (exports) { "use strict"; exports.bounds = bounds; exports.single = single; exports.move = move; exports.clear = clear; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var Cursor = function Cursor(element, nextSibling) { - _classCallCheck(this, Cursor); - this.element = element; this.nextSibling = nextSibling; }; exports.Cursor = Cursor; - var ConcreteBounds = (function () { - function ConcreteBounds(parent, first, last) { - _classCallCheck(this, ConcreteBounds); + var RealDOMBounds = (function () { + function RealDOMBounds(bounds) { + this.bounds = bounds; + } - this.parentNode = parent; + RealDOMBounds.prototype.parentElement = function parentElement() { + return this.bounds.parentElement(); + }; + + RealDOMBounds.prototype.firstNode = function firstNode() { + return this.bounds.firstNode(); + }; + + RealDOMBounds.prototype.lastNode = function lastNode() { + return this.bounds.lastNode(); + }; + + return RealDOMBounds; + })(); + + exports.RealDOMBounds = RealDOMBounds; + + var ConcreteBounds = (function () { + function ConcreteBounds(parentNode, first, last) { + this.parentNode = parentNode; this.first = first; this.last = last; } ConcreteBounds.prototype.parentElement = function parentElement() { @@ -13811,12 +14710,10 @@ exports.ConcreteBounds = ConcreteBounds; var SingleNodeBounds = (function () { function SingleNodeBounds(parentNode, node) { - _classCallCheck(this, SingleNodeBounds); - this.parentNode = parentNode; this.node = node; } SingleNodeBounds.prototype.parentElement = function parentElement() { @@ -13870,20 +14767,16 @@ node = next; } return null; } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvYm91bmRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O1FBVU0sTUFBQSxHQUNKLFNBREksTUFBQSxDQUNlLE9BQXVCLEVBQVMsV0FBd0IsRUFBQTtBQUF4RCxZQUFBLENBQUEsT0FBTyxHQUFQLE9BQU8sQ0FBZ0I7QUFBUyxZQUFBLENBQUEsV0FBVyxHQUFYLFdBQVcsQ0FBYTtLQUFJOzs7O1FBTzNFLGFBQUE7QUFDSixpQkFESSxhQUFBLENBQ2dCLE1BQWMsRUFBQTtBQUFkLGdCQUFBLENBQUEsTUFBTSxHQUFOLE1BQU0sQ0FBUTtTQUFJOztBQURsQyxxQkFBQSxXQUdKLGFBQWEsR0FBQSx5QkFBQTtBQUFLLG1CQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxFQUFhLENBQUM7U0FBRTs7QUFIOUQscUJBQUEsV0FJSixTQUFTLEdBQUEscUJBQUE7QUFBSyxtQkFBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBVSxDQUFDO1NBQUU7O0FBSm5ELHFCQUFBLFdBS0osUUFBUSxHQUFBLG9CQUFBO0FBQUssbUJBQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQVUsQ0FBQztTQUFFOztlQUxqRCxhQUFBOzs7OztRQVFBLGNBQUE7QUFDSixpQkFESSxjQUFBLENBQ2UsVUFBMEIsRUFBVSxLQUFrQixFQUFVLElBQWlCLEVBQUE7QUFBakYsZ0JBQUEsQ0FBQSxVQUFVLEdBQVYsVUFBVSxDQUFnQjtBQUFVLGdCQUFBLENBQUEsS0FBSyxHQUFMLEtBQUssQ0FBYTtBQUFVLGdCQUFBLENBQUEsSUFBSSxHQUFKLElBQUksQ0FBYTtTQUFJOztBQURwRyxzQkFBQSxXQUdKLGFBQWEsR0FBQSx5QkFBQTtBQUFLLG1CQUFPLElBQUksQ0FBQyxVQUFVLENBQUM7U0FBRTs7QUFIdkMsc0JBQUEsV0FJSixTQUFTLEdBQUEscUJBQUE7QUFBSyxtQkFBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1NBQUU7O0FBSjlCLHNCQUFBLFdBS0osUUFBUSxHQUFBLG9CQUFBO0FBQUssbUJBQU8sSUFBSSxDQUFDLElBQUksQ0FBQztTQUFFOztlQUw1QixjQUFBOzs7OztRQVFBLGdCQUFBO0FBSUosaUJBSkksZ0JBQUEsQ0FJUSxVQUEwQixFQUFFLElBQWlCLEVBQUE7QUFDdkQsZ0JBQUksQ0FBQyxVQUFVLEdBQUcsVUFBcUIsQ0FBQztBQUN4QyxnQkFBSSxDQUFDLElBQUksR0FBRyxJQUFZLENBQUM7U0FDMUI7O0FBUEcsd0JBQUEsV0FTSixhQUFhLEdBQUEseUJBQUE7QUFBSyxtQkFBTyxJQUFJLENBQUMsVUFBVSxDQUFDO1NBQUU7O0FBVHZDLHdCQUFBLFdBVUosU0FBUyxHQUFBLHFCQUFBO0FBQUssbUJBQU8sSUFBSSxDQUFDLElBQUksQ0FBQztTQUFFOztBQVY3Qix3QkFBQSxXQVdKLFFBQVEsR0FBQSxvQkFBQTtBQUFLLG1CQUFPLElBQUksQ0FBQyxJQUFJLENBQUM7U0FBRTs7ZUFYNUIsZ0JBQUE7Ozs7O0FBY0EsYUFBQSxNQUFBLENBQWlCLE1BQXNCLEVBQUUsS0FBa0IsRUFBRSxJQUFpQixFQUFBO0FBQ2xGLGVBQU8sSUFBSSxjQUFjLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztLQUNoRDs7QUFFSyxhQUFBLE1BQUEsQ0FBaUIsTUFBc0IsRUFBRSxJQUFpQixFQUFBO0FBQzlELGVBQU8sSUFBSSxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7S0FDM0M7O0FBRUssYUFBQSxJQUFBLENBQWUsTUFBYyxFQUFFLFNBQXNCLEVBQUE7QUFDekQsWUFBSSxNQUFNLEdBQUcsTUFBTSxDQUFDLGFBQWEsRUFBRSxDQUFDO0FBQ3BDLFlBQUksS0FBSyxHQUFHLE1BQU0sQ0FBQyxTQUFTLEVBQUUsQ0FBQztBQUMvQixZQUFJLElBQUksR0FBRyxNQUFNLENBQUMsUUFBUSxFQUFFLENBQUM7QUFFN0IsWUFBSSxJQUFJLEdBQUcsS0FBSyxDQUFDO0FBRWpCLGVBQU8sSUFBSSxFQUFFO0FBQ1gsZ0JBQUksSUFBSSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUM7QUFDNUIsa0JBQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0FBQ3JDLGdCQUFJLElBQUksS0FBSyxJQUFJLEVBQUUsT0FBTyxJQUFJLENBQUM7QUFDL0IsZ0JBQUksR0FBRyxJQUFJLENBQUM7U0FDYjtBQUVELGVBQU8sSUFBSSxDQUFDO0tBQ2I7O0FBRUssYUFBQSxLQUFBLENBQWdCLE1BQWMsRUFBQTtBQUNsQyxZQUFJLE1BQU0sR0FBRyxNQUFNLENBQUMsYUFBYSxFQUFFLENBQUM7QUFDcEMsWUFBSSxLQUFLLEdBQUcsTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDO0FBQy9CLFlBQUksSUFBSSxHQUFHLE1BQU0sQ0FBQyxRQUFRLEVBQUUsQ0FBQztBQUU3QixZQUFJLElBQUksR0FBRyxLQUFLLENBQUM7QUFFakIsZUFBTyxJQUFJLEVBQUU7QUFDWCxnQkFBSSxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQztBQUM1QixrQkFBTSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUN6QixnQkFBSSxJQUFJLEtBQUssSUFBSSxFQUFFLE9BQU8sSUFBSSxDQUFDO0FBQy9CLGdCQUFJLEdBQUcsSUFBSSxDQUFDO1NBQ2I7QUFFRCxlQUFPLElBQUksQ0FBQztLQUNiIiwiZmlsZSI6ImJvdW5kcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFNpbXBsZSBmcm9tICcuL2RvbS9pbnRlcmZhY2VzJztcbmltcG9ydCB7IERlc3Ryb3lhYmxlIH0gZnJvbSAnZ2xpbW1lci11dGlsJztcblxuZXhwb3J0IGludGVyZmFjZSBCb3VuZHMge1xuICAvLyBhIG1ldGhvZCB0byBmdXR1cmUtcHJvb2YgZm9yIHdvcm1ob2xpbmc7IG1heSBub3QgYmUgbmVlZGVkIHVsdGltYXRlbHlcbiAgcGFyZW50RWxlbWVudCgpOiBTaW1wbGUuRWxlbWVudDtcbiAgZmlyc3ROb2RlKCk6IFNpbXBsZS5Ob2RlO1xuICBsYXN0Tm9kZSgpOiBTaW1wbGUuTm9kZTtcbn1cblxuZXhwb3J0IGNsYXNzIEN1cnNvciB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBlbGVtZW50OiBTaW1wbGUuRWxlbWVudCwgcHVibGljIG5leHRTaWJsaW5nOiBTaW1wbGUuTm9kZSkge31cbn1cblxuZXhwb3J0IGRlZmF1bHQgQm91bmRzO1xuXG5leHBvcnQgaW50ZXJmYWNlIERlc3Ryb3lhYmxlQm91bmRzIGV4dGVuZHMgQm91bmRzLCBEZXN0cm95YWJsZSB7fVxuXG5leHBvcnQgY2xhc3MgUmVhbERPTUJvdW5kcyBpbXBsZW1lbnRzIEJvdW5kcyB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgYm91bmRzOiBCb3VuZHMpIHt9XG5cbiAgcGFyZW50RWxlbWVudCgpIHsgcmV0dXJuIHRoaXMuYm91bmRzLnBhcmVudEVsZW1lbnQoKSBhcyBFbGVtZW50OyB9XG4gIGZpcnN0Tm9kZSgpIHsgcmV0dXJuIHRoaXMuYm91bmRzLmZpcnN0Tm9kZSgpIGFzIE5vZGU7IH1cbiAgbGFzdE5vZGUoKSB7IHJldHVybiB0aGlzLmJvdW5kcy5sYXN0Tm9kZSgpIGFzIE5vZGU7IH1cbn1cblxuZXhwb3J0IGNsYXNzIENvbmNyZXRlQm91bmRzIGltcGxlbWVudHMgQm91bmRzIHtcbiAgY29uc3RydWN0b3IocHVibGljIHBhcmVudE5vZGU6IFNpbXBsZS5FbGVtZW50LCBwcml2YXRlIGZpcnN0OiBTaW1wbGUuTm9kZSwgcHJpdmF0ZSBsYXN0OiBTaW1wbGUuTm9kZSkge31cblxuICBwYXJlbnRFbGVtZW50KCkgeyByZXR1cm4gdGhpcy5wYXJlbnROb2RlOyB9XG4gIGZpcnN0Tm9kZSgpIHsgcmV0dXJuIHRoaXMuZmlyc3Q7IH1cbiAgbGFzdE5vZGUoKSB7IHJldHVybiB0aGlzLmxhc3Q7IH1cbn1cblxuZXhwb3J0IGNsYXNzIFNpbmdsZU5vZGVCb3VuZHMgaW1wbGVtZW50cyBCb3VuZHMge1xuICBwcml2YXRlIHBhcmVudE5vZGU6IEVsZW1lbnQ7XG4gIHByaXZhdGUgbm9kZTogTm9kZTtcblxuICBjb25zdHJ1Y3RvcihwYXJlbnROb2RlOiBTaW1wbGUuRWxlbWVudCwgbm9kZTogU2ltcGxlLk5vZGUpIHtcbiAgICB0aGlzLnBhcmVudE5vZGUgPSBwYXJlbnROb2RlIGFzIEVsZW1lbnQ7XG4gICAgdGhpcy5ub2RlID0gbm9kZSBhcyBOb2RlO1xuICB9XG5cbiAgcGFyZW50RWxlbWVudCgpIHsgcmV0dXJuIHRoaXMucGFyZW50Tm9kZTsgfVxuICBmaXJzdE5vZGUoKSB7IHJldHVybiB0aGlzLm5vZGU7IH1cbiAgbGFzdE5vZGUoKSB7IHJldHVybiB0aGlzLm5vZGU7IH1cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGJvdW5kcyhwYXJlbnQ6IFNpbXBsZS5FbGVtZW50LCBmaXJzdDogU2ltcGxlLk5vZGUsIGxhc3Q6IFNpbXBsZS5Ob2RlKTogQm91bmRzIHtcbiAgcmV0dXJuIG5ldyBDb25jcmV0ZUJvdW5kcyhwYXJlbnQsIGZpcnN0LCBsYXN0KTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHNpbmdsZShwYXJlbnQ6IFNpbXBsZS5FbGVtZW50LCBub2RlOiBTaW1wbGUuTm9kZSk6IEJvdW5kcyB7XG4gIHJldHVybiBuZXcgU2luZ2xlTm9kZUJvdW5kcyhwYXJlbnQsIG5vZGUpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gbW92ZShib3VuZHM6IEJvdW5kcywgcmVmZXJlbmNlOiBTaW1wbGUuTm9kZSkge1xuICBsZXQgcGFyZW50ID0gYm91bmRzLnBhcmVudEVsZW1lbnQoKTtcbiAgbGV0IGZpcnN0ID0gYm91bmRzLmZpcnN0Tm9kZSgpO1xuICBsZXQgbGFzdCA9IGJvdW5kcy5sYXN0Tm9kZSgpO1xuXG4gIGxldCBub2RlID0gZmlyc3Q7XG5cbiAgd2hpbGUgKG5vZGUpIHtcbiAgICBsZXQgbmV4dCA9IG5vZGUubmV4dFNpYmxpbmc7XG4gICAgcGFyZW50Lmluc2VydEJlZm9yZShub2RlLCByZWZlcmVuY2UpO1xuICAgIGlmIChub2RlID09PSBsYXN0KSByZXR1cm4gbmV4dDtcbiAgICBub2RlID0gbmV4dDtcbiAgfVxuXG4gIHJldHVybiBudWxsO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gY2xlYXIoYm91bmRzOiBCb3VuZHMpOiBTaW1wbGUuTm9kZSB7XG4gIGxldCBwYXJlbnQgPSBib3VuZHMucGFyZW50RWxlbWVudCgpO1xuICBsZXQgZmlyc3QgPSBib3VuZHMuZmlyc3ROb2RlKCk7XG4gIGxldCBsYXN0ID0gYm91bmRzLmxhc3ROb2RlKCk7XG5cbiAgbGV0IG5vZGUgPSBmaXJzdDtcblxuICB3aGlsZSAobm9kZSkge1xuICAgIGxldCBuZXh0ID0gbm9kZS5uZXh0U2libGluZztcbiAgICBwYXJlbnQucmVtb3ZlQ2hpbGQobm9kZSk7XG4gICAgaWYgKG5vZGUgPT09IGxhc3QpIHJldHVybiBuZXh0O1xuICAgIG5vZGUgPSBuZXh0O1xuICB9XG5cbiAgcmV0dXJuIG51bGw7XG59XG4iXX0= enifed('glimmer-runtime/lib/builder', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-util', 'glimmer-runtime/lib/compiled/opcodes/dom'], function (exports, _glimmerRuntimeLibBounds, _glimmerUtil, _glimmerRuntimeLibCompiledOpcodesDom) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var First = (function () { function First(node) { - _classCallCheck(this, First); - this.node = node; } First.prototype.firstNode = function firstNode() { return this.node; @@ -13892,63 +14785,22 @@ return First; })(); var Last = (function () { function Last(node) { - _classCallCheck(this, Last); - this.node = node; } Last.prototype.lastNode = function lastNode() { return this.node; }; return Last; })(); - var BlockStackElement = function BlockStackElement() { - _classCallCheck(this, BlockStackElement); - - this.firstNode = null; - this.lastNode = null; - }; - - var GroupedElementOperations = (function () { - function GroupedElementOperations(element, env) { - _classCallCheck(this, GroupedElementOperations); - - this.env = env; - this.element = element; - var group = this.group = []; - this.groups = [group]; - } - - GroupedElementOperations.prototype.startGroup = function startGroup() { - var group = this.group = []; - this.groups.push(group); - }; - - GroupedElementOperations.prototype.addAttribute = function addAttribute(name, reference, isTrusting) { - var attributeManager = this.env.attributeFor(this.element, name, reference, isTrusting); - var attribute = new _glimmerRuntimeLibCompiledOpcodesDom.Attribute(this.element, attributeManager, name, reference); - this.group.push(attribute); - }; - - GroupedElementOperations.prototype.addAttributeNS = function addAttributeNS(namespace, name, reference, isTrusting) { - var attributeManager = this.env.attributeFor(this.element, name, reference, isTrusting, namespace); - var nsAttribute = new _glimmerRuntimeLibCompiledOpcodesDom.Attribute(this.element, attributeManager, name, reference, namespace); - this.group.push(nsAttribute); - }; - - return GroupedElementOperations; - })(); - var Fragment = (function () { function Fragment(bounds) { - _classCallCheck(this, Fragment); - this.bounds = bounds; } Fragment.prototype.parentElement = function parentElement() { return this.bounds.parentElement(); @@ -13971,21 +14823,21 @@ exports.Fragment = Fragment; var ElementStack = (function () { function ElementStack(env, parentNode, nextSibling) { - _classCallCheck(this, ElementStack); - - this.elementOperations = null; + this.constructing = null; + this.operations = null; this.elementStack = new _glimmerUtil.Stack(); this.nextSiblingStack = new _glimmerUtil.Stack(); - this.elementOperationsStack = new _glimmerUtil.Stack(); this.blockStack = new _glimmerUtil.Stack(); this.env = env; - this.dom = env.getDOM(); + this.dom = env.getAppendOperations(); + this.updateOperations = env.getDOM(); this.element = parentNode; this.nextSibling = nextSibling; + this.defaultOperations = new _glimmerRuntimeLibCompiledOpcodesDom.SimpleElementOperations(env); this.elementStack.push(this.element); this.nextSiblingStack.push(this.nextSibling); } ElementStack.forInitialRender = function forInitialRender(env, parentNode, nextSibling) { @@ -14001,42 +14853,33 @@ ElementStack.prototype.block = function block() { return this.blockStack.current; }; - ElementStack.prototype.pushElement = function pushElement(tag) { - var element = this.dom.createElement(tag, this.element); - var elementOperations = new GroupedElementOperations(element, this.env); - this.elementOperations = elementOperations; - this.element = element; - this.nextSibling = null; - this.elementStack.push(element); - this.elementOperationsStack.push(elementOperations); - this.nextSiblingStack.push(null); - return element; - }; - ElementStack.prototype.popElement = function popElement() { var elementStack = this.elementStack; var nextSiblingStack = this.nextSiblingStack; - var elementOperationsStack = this.elementOperationsStack; var topElement = elementStack.pop(); nextSiblingStack.pop(); - elementOperationsStack.pop(); this.element = elementStack.current; this.nextSibling = nextSiblingStack.current; - this.elementOperations = elementOperationsStack.current; return topElement; }; - ElementStack.prototype.pushBlock = function pushBlock() { - var tracker = new BlockTracker(this.element); + ElementStack.prototype.pushSimpleBlock = function pushSimpleBlock() { + var tracker = new SimpleBlockTracker(this.element); this.pushBlockTracker(tracker); return tracker; }; + ElementStack.prototype.pushUpdatableBlock = function pushUpdatableBlock() { + var tracker = new UpdatableBlockTracker(this.element); + this.pushBlockTracker(tracker); + return tracker; + }; + ElementStack.prototype.pushBlockTracker = function pushBlockTracker(tracker) { var current = this.blockStack.current; if (current !== null) { current.newDestroyable(tracker); current.newBounds(tracker); @@ -14060,15 +14903,30 @@ this.blockStack.current.finalize(this); return this.blockStack.pop(); }; ElementStack.prototype.openElement = function openElement(tag) { - var element = this.pushElement(tag); - this.blockStack.current.openElement(element); + var operations = arguments.length <= 1 || arguments[1] === undefined ? this.defaultOperations : arguments[1]; + + var element = this.dom.createElement(tag, this.element); + this.constructing = element; + this.operations = operations; return element; }; + ElementStack.prototype.flushElement = function flushElement() { + var parent = this.element; + var element = this.element = this.constructing; + this.dom.insertBefore(parent, element, this.nextSibling); + this.constructing = null; + this.operations = null; + this.nextSibling = null; + this.elementStack.push(element); + this.nextSiblingStack.push(null); + this.blockStack.current.openElement(element); + }; + ElementStack.prototype.newDestroyable = function newDestroyable(d) { this.blockStack.current.newDestroyable(d); }; ElementStack.prototype.newBounds = function newBounds(bounds) { @@ -14091,99 +14949,117 @@ dom.insertBefore(this.element, comment, this.nextSibling); this.blockStack.current.newNode(comment); return comment; }; - ElementStack.prototype.setAttribute = function setAttribute(name, reference, isTrusting) { - this.elementOperations.addAttribute(name, reference, isTrusting); + ElementStack.prototype.setStaticAttribute = function setStaticAttribute(name, value) { + this.operations.addStaticAttribute(this.constructing, name, value); }; - ElementStack.prototype.setAttributeNS = function setAttributeNS(namespace, name, reference, isTrusting) { - this.elementOperations.addAttributeNS(namespace, name, reference, isTrusting); + ElementStack.prototype.setStaticAttributeNS = function setStaticAttributeNS(namespace, name, value) { + this.operations.addStaticAttributeNS(this.constructing, namespace, name, value); }; + ElementStack.prototype.setDynamicAttribute = function setDynamicAttribute(name, reference, isTrusting) { + this.operations.addDynamicAttribute(this.constructing, name, reference, isTrusting); + }; + + ElementStack.prototype.setDynamicAttributeNS = function setDynamicAttributeNS(namespace, name, reference, isTrusting) { + this.operations.addDynamicAttributeNS(this.constructing, namespace, name, reference, isTrusting); + }; + ElementStack.prototype.closeElement = function closeElement() { this.blockStack.current.closeElement(); - var child = this.popElement(); - this.dom.insertBefore(this.element, child, this.nextSibling); + this.popElement(); }; return ElementStack; })(); exports.ElementStack = ElementStack; - var BlockTracker = (function () { - function BlockTracker(parent) { - _classCallCheck(this, BlockTracker); - + var SimpleBlockTracker = (function () { + function SimpleBlockTracker(parent) { + this.parent = parent; this.first = null; this.last = null; this.destroyables = null; this.nesting = 0; this.parent = parent; } - BlockTracker.prototype.destroy = function destroy() { + SimpleBlockTracker.prototype.destroy = function destroy() { var destroyables = this.destroyables; if (destroyables && destroyables.length) { for (var i = 0; i < destroyables.length; i++) { destroyables[i].destroy(); } } }; - BlockTracker.prototype.parentElement = function parentElement() { + SimpleBlockTracker.prototype.parentElement = function parentElement() { return this.parent; }; - BlockTracker.prototype.firstNode = function firstNode() { + SimpleBlockTracker.prototype.firstNode = function firstNode() { return this.first && this.first.firstNode(); }; - BlockTracker.prototype.lastNode = function lastNode() { + SimpleBlockTracker.prototype.lastNode = function lastNode() { return this.last && this.last.lastNode(); }; - BlockTracker.prototype.openElement = function openElement(element) { + SimpleBlockTracker.prototype.openElement = function openElement(element) { this.newNode(element); this.nesting++; }; - BlockTracker.prototype.closeElement = function closeElement() { + SimpleBlockTracker.prototype.closeElement = function closeElement() { this.nesting--; }; - BlockTracker.prototype.newNode = function newNode(node) { + SimpleBlockTracker.prototype.newNode = function newNode(node) { if (this.nesting !== 0) return; if (!this.first) { this.first = new First(node); } this.last = new Last(node); }; - BlockTracker.prototype.newBounds = function newBounds(bounds) { + SimpleBlockTracker.prototype.newBounds = function newBounds(bounds) { if (this.nesting !== 0) return; if (!this.first) { this.first = bounds; } this.last = bounds; }; - BlockTracker.prototype.newDestroyable = function newDestroyable(d) { + SimpleBlockTracker.prototype.newDestroyable = function newDestroyable(d) { this.destroyables = this.destroyables || []; this.destroyables.push(d); }; - BlockTracker.prototype.finalize = function finalize(stack) { + SimpleBlockTracker.prototype.finalize = function finalize(stack) { if (!this.first) { stack.appendComment(''); } }; - BlockTracker.prototype.reset = function reset(env) { + return SimpleBlockTracker; + })(); + + exports.SimpleBlockTracker = SimpleBlockTracker; + + var UpdatableBlockTracker = (function (_SimpleBlockTracker) { + babelHelpers.inherits(UpdatableBlockTracker, _SimpleBlockTracker); + + function UpdatableBlockTracker() { + _SimpleBlockTracker.apply(this, arguments); + } + + UpdatableBlockTracker.prototype.reset = function reset(env) { var destroyables = this.destroyables; if (destroyables && destroyables.length) { for (var i = 0; i < destroyables.length; i++) { env.didDestroy(destroyables[i]); @@ -14194,21 +15070,21 @@ this.first = null; this.last = null; return nextSibling; }; - return BlockTracker; - })(); + return UpdatableBlockTracker; + })(SimpleBlockTracker); - exports.BlockTracker = BlockTracker; + exports.UpdatableBlockTracker = UpdatableBlockTracker; var BlockListTracker = (function () { function BlockListTracker(parent, boundList) { - _classCallCheck(this, BlockListTracker); - this.parent = parent; this.boundList = boundList; + this.parent = parent; + this.boundList = boundList; } BlockListTracker.prototype.destroy = function destroy() { this.boundList.forEachNode(function (node) { return node.destroy(); @@ -14243,105 +15119,129 @@ BlockListTracker.prototype.newDestroyable = function newDestroyable(d) {}; BlockListTracker.prototype.finalize = function finalize(stack) {}; - BlockListTracker.prototype.reset = function reset() {}; - return BlockListTracker; })(); }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/builder.ts"],"names":[],"mappings":"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","file":"builder.js","sourcesContent":["import Bounds, { clear, Cursor } from './bounds';\n\nimport { DOMHelper } from './dom/helper';\n\nimport { Destroyable, InternedString, Stack, LinkedList, LinkedListNode, assert } from 'glimmer-util';\n\nimport { Environment } from './environment';\n\nimport {\n  PathReference\n} from 'glimmer-reference';\n\nimport {\n  Attribute\n} from './compiled/opcodes/dom';\n\ninterface FirstNode {\n  firstNode(): Node;\n}\n\ninterface LastNode {\n  lastNode(): Node;\n}\n\nclass First {\n  private node: Node;\n\n  constructor(node) {\n    this.node = node;\n  }\n\n  firstNode(): Node {\n    return this.node;\n  }\n}\n\nclass Last {\n  private node: Node;\n\n  constructor(node) {\n    this.node = node;\n  }\n\n  lastNode(): Node {\n    return this.node;\n  }\n}\n\ninterface ElementStackOptions {\n  parentNode: Element;\n  nextSibling: Node;\n  dom: DOMHelper;\n}\n\ninterface ElementStackClass<T extends ElementStack> {\n  new (options: ElementStackOptions): T;\n}\n\nclass BlockStackElement {\n  public firstNode: Node = null;\n  public lastNode: Node = null;\n}\n\nexport interface ElementOperations {\n  addAttribute(name: InternedString, value: PathReference<string>, isTrusting: boolean);\n  addAttributeNS(namespace: InternedString, name: InternedString, value: PathReference<string>, isTrusting: boolean);\n}\n\nclass GroupedElementOperations implements ElementOperations {\n  public groups: Attribute[][];\n  public group: Attribute[];\n\n  private env: Environment;\n  private element: Element;\n\n  constructor(element: Element, env: Environment) {\n    this.env = env;\n    this.element = element;\n    let group = this.group = [];\n    this.groups = [group];\n  }\n\n  startGroup() {\n    let group = this.group = [];\n    this.groups.push(group);\n  }\n\n  addAttribute(name: InternedString, reference: PathReference<string>, isTrusting: boolean) {\n    let attributeManager = this.env.attributeFor(this.element, name, reference, isTrusting);\n    let attribute = new Attribute(this.element, attributeManager, name, reference);\n    this.group.push(attribute);\n  }\n\n  addAttributeNS(namespace: InternedString, name: InternedString, reference: PathReference<string>, isTrusting: boolean) {\n    let attributeManager = this.env.attributeFor(this.element, name, reference,isTrusting, namespace);\n    let nsAttribute = new Attribute(this.element, attributeManager, name, reference, namespace);\n\n    this.group.push(nsAttribute);\n  }\n}\n\nexport class Fragment implements Bounds {\n  private bounds: Bounds;\n\n  constructor(bounds: Bounds) {\n    this.bounds = bounds;\n  }\n\n  parentElement(): Element {\n    return this.bounds.parentElement();\n  }\n\n  firstNode(): Node {\n    return this.bounds.firstNode();\n  }\n\n  lastNode(): Node {\n    return this.bounds.lastNode();\n  }\n\n  update(bounds: Bounds) {\n    this.bounds = bounds;\n  }\n}\n\ninterface InitialRenderOptions {\n  parentNode: Element;\n  nextSibling: Node;\n  dom: DOMHelper;\n}\n\ninterface UpdateTrackerOptions {\n  tracker: Tracker;\n  nextSibling: Node;\n  dom: DOMHelper;\n}\n\nexport class ElementStack implements Cursor {\n  public nextSibling: Node;\n  public dom: DOMHelper;\n  public element: Element;\n  public elementOperations: GroupedElementOperations = null;\n  public env: Environment;\n\n  private elementStack = new Stack<Element>();\n  private nextSiblingStack = new Stack<Node>();\n  private elementOperationsStack = new Stack<GroupedElementOperations>();\n  private blockStack = new Stack<Tracker>();\n\n  static forInitialRender(env: Environment, parentNode: Element, nextSibling: Node) {\n    return new ElementStack(env, parentNode, nextSibling);\n  }\n\n  static resume(env: Environment, tracker: Tracker, nextSibling: Node) {\n    let parentNode = tracker.parentElement();\n\n    let stack = new ElementStack(env, parentNode, nextSibling);\n    stack.pushBlockTracker(tracker);\n\n    return stack;\n  }\n\n  constructor(env: Environment, parentNode: Element, nextSibling: Node) {\n    this.env = env;\n    this.dom = env.getDOM();\n    this.element = parentNode;\n    this.nextSibling = nextSibling;\n\n    this.elementStack.push(this.element);\n    this.nextSiblingStack.push(this.nextSibling);\n  }\n\n  block(): Tracker {\n    return this.blockStack.current;\n  }\n\n  private pushElement(tag: InternedString): Element {\n    let element = this.dom.createElement(tag, this.element);\n    let elementOperations = new GroupedElementOperations(element, this.env);\n\n    this.elementOperations = elementOperations;\n    this.element = element;\n    this.nextSibling = null;\n\n    this.elementStack.push(element);\n    this.elementOperationsStack.push(elementOperations);\n    this.nextSiblingStack.push(null);\n\n    return element;\n  }\n\n  private popElement() {\n    let { elementStack, nextSiblingStack, elementOperationsStack }  = this;\n\n    let topElement = elementStack.pop();\n    nextSiblingStack.pop();\n    elementOperationsStack.pop();\n\n    this.element = elementStack.current;\n    this.nextSibling = nextSiblingStack.current;\n    this.elementOperations = elementOperationsStack.current;\n\n    return topElement;\n  }\n\n  pushBlock(): Tracker {\n    let tracker = new BlockTracker(this.element);\n    this.pushBlockTracker(tracker);\n    return tracker;\n  }\n\n  private pushBlockTracker(tracker: Tracker) {\n    let current = this.blockStack.current;\n\n    if (current !== null) {\n      current.newDestroyable(tracker);\n      current.newBounds(tracker);\n    }\n\n    this.blockStack.push(tracker);\n    return tracker;\n  }\n\n  pushBlockList(list: LinkedList<LinkedListNode & Bounds & Destroyable>): Tracker {\n    let tracker = new BlockListTracker(this.element, list);\n    let current = this.blockStack.current;\n\n    if (current !== null) {\n      current.newDestroyable(tracker);\n      current.newBounds(tracker);\n    }\n\n    this.blockStack.push(tracker);\n    return tracker;\n  }\n\n  popBlock(): Tracker {\n    this.blockStack.current.finalize(this);\n\n    return this.blockStack.pop();\n  }\n\n  openElement(tag: InternedString): Element {\n    let element = this.pushElement(tag);\n    this.blockStack.current.openElement(element);\n    return element;\n  }\n\n  newDestroyable(d: Destroyable) {\n    this.blockStack.current.newDestroyable(d);\n  }\n\n  newBounds(bounds: Bounds) {\n    this.blockStack.current.newBounds(bounds);\n  }\n\n  appendText(string: string): Text {\n    let { dom } = this;\n    let text = dom.createTextNode(string);\n    dom.insertBefore(this.element, text, this.nextSibling);\n    this.blockStack.current.newNode(text);\n    return text;\n  }\n\n  appendComment(string: string): Comment {\n    let { dom } = this;\n    let comment = dom.createComment(string);\n    dom.insertBefore(this.element, comment, this.nextSibling);\n    this.blockStack.current.newNode(comment);\n    return comment;\n  }\n\n  setAttribute(name: InternedString, reference: PathReference<string>, isTrusting: boolean) {\n    this.elementOperations.addAttribute(name, reference, isTrusting);\n  }\n\n  setAttributeNS(namespace: InternedString, name: InternedString, reference: PathReference<string>, isTrusting: boolean) {\n    this.elementOperations.addAttributeNS(namespace, name, reference, isTrusting);\n  }\n\n  closeElement() {\n    this.blockStack.current.closeElement();\n    let child = this.popElement();\n    this.dom.insertBefore(this.element, child, this.nextSibling);\n  }\n}\n\nexport interface Tracker extends Bounds, Destroyable {\n  openElement(element: Element);\n  closeElement();\n  newNode(node: Node);\n  newBounds(bounds: Bounds);\n  newDestroyable(d: Destroyable);\n  finalize(stack: ElementStack);\n  reset(env: Environment);\n}\n\nexport class BlockTracker implements Tracker {\n  private first: FirstNode = null;\n  private last: LastNode = null;\n  private destroyables: Destroyable[] = null;\n  private nesting = 0;\n\n  private parent: Element;\n\n  constructor(parent: Element){\n    this.parent = parent;\n  }\n\n  destroy() {\n    let { destroyables } = this;\n\n    if (destroyables && destroyables.length) {\n      for (let i=0; i<destroyables.length; i++) {\n        destroyables[i].destroy();\n      }\n    }\n  }\n\n  parentElement() {\n    return this.parent;\n  }\n\n  firstNode() {\n    return this.first && this.first.firstNode();\n  }\n\n  lastNode() {\n    return this.last && this.last.lastNode();\n  }\n\n  openElement(element: Element) {\n    this.newNode(element);\n    this.nesting++;\n  }\n\n  closeElement() {\n    this.nesting--;\n  }\n\n  newNode(node: Node) {\n    if (this.nesting !== 0) return;\n\n    if (!this.first) {\n      this.first = new First(node);\n    }\n\n    this.last = new Last(node);\n  }\n\n  newBounds(bounds: Bounds) {\n    if (this.nesting !== 0) return;\n\n    if (!this.first) {\n      this.first = bounds;\n    }\n\n    this.last = bounds;\n  }\n\n  newDestroyable(d: Destroyable) {\n    this.destroyables = this.destroyables || [];\n    this.destroyables.push(d);\n  }\n\n  finalize(stack: ElementStack) {\n    if (!this.first) {\n      stack.appendComment('');\n    }\n  }\n\n  reset(env: Environment) {\n    let { destroyables } = this;\n\n    if (destroyables && destroyables.length) {\n      for (let i=0; i<destroyables.length; i++) {\n        env.didDestroy(destroyables[i]);\n      }\n    }\n\n    let nextSibling = clear(this);\n\n    this.destroyables = null;\n    this.first = null;\n    this.last = null;\n\n    return nextSibling;\n  }\n}\n\nclass BlockListTracker implements Tracker {\n  private parent: Element;\n  private boundList: LinkedList<LinkedListNode & Bounds & Destroyable>;\n\n  constructor(parent: Element, boundList: LinkedList<LinkedListNode & Bounds & Destroyable>) {\n    this.parent = parent;\n    this.boundList = boundList;\n  }\n\n  destroy() {\n    this.boundList.forEachNode(node => node.destroy());\n  }\n\n  parentElement() {\n    return this.parent;\n  }\n\n  firstNode() {\n    return this.boundList.head().firstNode();\n  }\n\n  lastNode() {\n    return this.boundList.tail().lastNode();\n  }\n\n  openElement(element: Element) {\n    assert(false, 'Cannot openElement directly inside a block list');\n  }\n\n  closeElement() {\n    assert(false, 'Cannot closeElement directly inside a block list');\n  }\n\n  newNode(node: Node) {\n    assert(false, 'Cannot create a new node directly inside a block list');\n  }\n\n  newBounds(bounds: Bounds) {\n  }\n\n  newDestroyable(d: Destroyable) {\n  }\n\n  finalize(stack: ElementStack) {\n  }\n\n  reset() {}\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/builder.ts"],"names":[],"mappings":"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","file":"builder.js","sourcesContent":["import Bounds, { Cursor, DestroyableBounds, clear } from './bounds';\n\nimport { DOMChanges, DOMTreeConstruction } from './dom/helper';\n\nimport { Destroyable, Stack, LinkedList, LinkedListNode, assert } from 'glimmer-util';\n\nimport { Environment } from './environment';\n\nimport { VM } from './vm';\n\nimport {\n  PathReference\n} from 'glimmer-reference';\n\nimport {\n  SimpleElementOperations\n} from './compiled/opcodes/dom';\n\nimport * as Simple from './dom/interfaces';\n\ninterface FirstNode {\n  firstNode(): Simple.Node;\n}\n\ninterface LastNode {\n  lastNode(): Simple.Node;\n}\n\nclass First {\n  private node: Node;\n\n  constructor(node) {\n    this.node = node;\n  }\n\n  firstNode(): Node {\n    return this.node;\n  }\n}\n\nclass Last {\n  private node: Node;\n\n  constructor(node) {\n    this.node = node;\n  }\n\n  lastNode(): Node {\n    return this.node;\n  }\n}\n\nexport interface ElementOperations {\n  addStaticAttribute(element: Simple.Element, name: string, value: string);\n  addStaticAttributeNS(element: Simple.Element, namespace: string, name: string, value: string);\n  addDynamicAttribute(element: Simple.Element, name: string, value: PathReference<string>, isTrusting: boolean);\n  addDynamicAttributeNS(element: Simple.Element, namespace: string, name: string, value: PathReference<string>, isTrusting: boolean);\n  flush(element: Simple.Element, vm: VM);\n}\n\nexport class Fragment implements Bounds {\n  private bounds: Bounds;\n\n  constructor(bounds: Bounds) {\n    this.bounds = bounds;\n  }\n\n  parentElement(): Simple.Element {\n    return this.bounds.parentElement();\n  }\n\n  firstNode(): Simple.Node {\n    return this.bounds.firstNode();\n  }\n\n  lastNode(): Simple.Node {\n    return this.bounds.lastNode();\n  }\n\n  update(bounds: Bounds) {\n    this.bounds = bounds;\n  }\n}\n\nexport class ElementStack implements Cursor {\n  public nextSibling: Simple.Node;\n  public dom: DOMTreeConstruction;\n  public updateOperations: DOMChanges;\n  public constructing: Simple.Element = null;\n  public operations: ElementOperations = null;\n  public element: Simple.Element;\n  public env: Environment;\n\n  private elementStack = new Stack<Simple.Element>();\n  private nextSiblingStack = new Stack<Simple.Node>();\n  private blockStack = new Stack<Tracker>();\n\n  private defaultOperations: ElementOperations;\n\n  static forInitialRender(env: Environment, parentNode: Simple.Element, nextSibling: Simple.Node) {\n    return new ElementStack(env, parentNode, nextSibling);\n  }\n\n  static resume(env: Environment, tracker: Tracker, nextSibling: Node) {\n    let parentNode = tracker.parentElement();\n\n    let stack = new ElementStack(env, parentNode, nextSibling);\n    stack.pushBlockTracker(tracker);\n\n    return stack;\n  }\n\n  constructor(env: Environment, parentNode: Simple.Element, nextSibling: Simple.Node) {\n    this.env = env;\n    this.dom = env.getAppendOperations();\n    this.updateOperations = env.getDOM();\n    this.element = parentNode;\n    this.nextSibling = nextSibling;\n\n    this.defaultOperations = new SimpleElementOperations(env);\n\n    this.elementStack.push(this.element);\n    this.nextSiblingStack.push(this.nextSibling);\n  }\n\n  block(): Tracker {\n    return this.blockStack.current;\n  }\n\n  private popElement() {\n    let { elementStack, nextSiblingStack }  = this;\n\n    let topElement = elementStack.pop();\n    nextSiblingStack.pop();\n\n    this.element = elementStack.current;\n    this.nextSibling = nextSiblingStack.current;\n\n    return topElement;\n  }\n\n  pushSimpleBlock(): Tracker {\n    let tracker = new SimpleBlockTracker(this.element);\n    this.pushBlockTracker(tracker);\n    return tracker;\n  }\n\n  pushUpdatableBlock(): UpdatableTracker {\n    let tracker = new UpdatableBlockTracker(this.element);\n    this.pushBlockTracker(tracker);\n    return tracker;\n  }\n\n  private pushBlockTracker(tracker: Tracker) {\n    let current = this.blockStack.current;\n\n    if (current !== null) {\n      current.newDestroyable(tracker);\n      current.newBounds(tracker);\n    }\n\n    this.blockStack.push(tracker);\n    return tracker;\n  }\n\n  pushBlockList(list: LinkedList<LinkedListNode & Bounds & Destroyable>): Tracker {\n    let tracker = new BlockListTracker(this.element, list);\n    let current = this.blockStack.current;\n\n    if (current !== null) {\n      current.newDestroyable(tracker);\n      current.newBounds(tracker);\n    }\n\n    this.blockStack.push(tracker);\n    return tracker;\n  }\n\n  popBlock(): Tracker {\n    this.blockStack.current.finalize(this);\n\n    return this.blockStack.pop();\n  }\n\n  openElement(tag: string, operations = this.defaultOperations): Simple.Element {\n    let element = this.dom.createElement(tag, this.element);\n\n    this.constructing = element;\n    this.operations = operations;\n\n    return element;\n  }\n\n  flushElement() {\n    let parent  = this.element;\n    let element = this.element = this.constructing;\n\n    this.dom.insertBefore(parent, element, this.nextSibling);\n\n    this.constructing = null;\n    this.operations = null;\n    this.nextSibling = null;\n    this.elementStack.push(element);\n    this.nextSiblingStack.push(null);\n    this.blockStack.current.openElement(element);\n  }\n\n  newDestroyable(d: Destroyable) {\n    this.blockStack.current.newDestroyable(d);\n  }\n\n  newBounds(bounds: Bounds) {\n    this.blockStack.current.newBounds(bounds);\n  }\n\n  appendText(string: string): Simple.Text {\n    let { dom } = this;\n    let text = dom.createTextNode(string);\n    dom.insertBefore(this.element, text, this.nextSibling);\n    this.blockStack.current.newNode(text);\n    return text;\n  }\n\n  appendComment(string: string): Simple.Comment {\n    let { dom } = this;\n    let comment = dom.createComment(string);\n    dom.insertBefore(this.element, comment, this.nextSibling);\n    this.blockStack.current.newNode(comment);\n    return comment;\n  }\n\n  setStaticAttribute(name: string, value: string) {\n    this.operations.addStaticAttribute(this.constructing, name, value);\n  }\n\n  setStaticAttributeNS(namespace: string, name: string, value: string) {\n    this.operations.addStaticAttributeNS(this.constructing, namespace, name, value);\n  }\n\n  setDynamicAttribute(name: string, reference: PathReference<string>, isTrusting: boolean) {\n    this.operations.addDynamicAttribute(this.constructing, name, reference, isTrusting);\n  }\n\n  setDynamicAttributeNS(namespace: string, name: string, reference: PathReference<string>, isTrusting: boolean) {\n    this.operations.addDynamicAttributeNS(this.constructing, namespace, name, reference, isTrusting);\n  }\n\n  closeElement() {\n    this.blockStack.current.closeElement();\n    this.popElement();\n  }\n}\n\nexport interface Tracker extends DestroyableBounds {\n  openElement(element: Simple.Element);\n  closeElement();\n  newNode(node: Simple.Node);\n  newBounds(bounds: Bounds);\n  newDestroyable(d: Destroyable);\n  finalize(stack: ElementStack);\n}\n\nexport class SimpleBlockTracker implements Tracker {\n  protected first: FirstNode = null;\n  protected last: LastNode = null;\n  protected destroyables: Destroyable[] = null;\n  protected nesting = 0;\n\n  constructor(private parent: Simple.Element){\n    this.parent = parent;\n  }\n\n  destroy() {\n    let { destroyables } = this;\n\n    if (destroyables && destroyables.length) {\n      for (let i=0; i<destroyables.length; i++) {\n        destroyables[i].destroy();\n      }\n    }\n  }\n\n  parentElement() {\n    return this.parent;\n  }\n\n  firstNode() {\n    return this.first && this.first.firstNode();\n  }\n\n  lastNode() {\n    return this.last && this.last.lastNode();\n  }\n\n  openElement(element: Element) {\n    this.newNode(element);\n    this.nesting++;\n  }\n\n  closeElement() {\n    this.nesting--;\n  }\n\n  newNode(node: Node) {\n    if (this.nesting !== 0) return;\n\n    if (!this.first) {\n      this.first = new First(node);\n    }\n\n    this.last = new Last(node);\n  }\n\n  newBounds(bounds: Bounds) {\n    if (this.nesting !== 0) return;\n\n    if (!this.first) {\n      this.first = bounds;\n    }\n\n    this.last = bounds;\n  }\n\n  newDestroyable(d: Destroyable) {\n    this.destroyables = this.destroyables || [];\n    this.destroyables.push(d);\n  }\n\n  finalize(stack: ElementStack) {\n    if (!this.first) {\n      stack.appendComment('');\n    }\n  }\n}\n\nexport interface UpdatableTracker extends Tracker {\n  reset(env: Environment);\n}\n\nexport class UpdatableBlockTracker extends SimpleBlockTracker implements UpdatableTracker {\n  reset(env: Environment) {\n    let { destroyables } = this;\n\n    if (destroyables && destroyables.length) {\n      for (let i=0; i<destroyables.length; i++) {\n        env.didDestroy(destroyables[i]);\n      }\n    }\n\n    let nextSibling = clear(this);\n\n    this.destroyables = null;\n    this.first = null;\n    this.last = null;\n\n    return nextSibling;\n  }\n}\n\nclass BlockListTracker implements Tracker {\n  constructor(private parent: Simple.Element, private boundList: LinkedList<LinkedListNode & Bounds & Destroyable>) {\n    this.parent = parent;\n    this.boundList = boundList;\n  }\n\n  destroy() {\n    this.boundList.forEachNode(node => node.destroy());\n  }\n\n  parentElement() {\n    return this.parent;\n  }\n\n  firstNode() {\n    return this.boundList.head().firstNode();\n  }\n\n  lastNode() {\n    return this.boundList.tail().lastNode();\n  }\n\n  openElement(element: Element) {\n    assert(false, 'Cannot openElement directly inside a block list');\n  }\n\n  closeElement() {\n    assert(false, 'Cannot closeElement directly inside a block list');\n  }\n\n  newNode(node: Node) {\n    assert(false, 'Cannot create a new node directly inside a block list');\n  }\n\n  newBounds(bounds: Bounds) {\n  }\n\n  newDestroyable(d: Destroyable) {\n  }\n\n  finalize(stack: ElementStack) {\n  }\n}\n"]} enifed('glimmer-runtime/lib/compat/inner-html-fix', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/dom/helper'], function (exports, _glimmerRuntimeLibBounds, _glimmerRuntimeLibDomHelper) { 'use strict'; - exports.default = applyInnerHTMLFix; + exports.domChanges = domChanges; + exports.treeConstruction = treeConstruction; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - + var innerHTMLWrapper = { + colgroup: { depth: 2, before: '<table><colgroup>', after: '</colgroup></table>' }, + table: { depth: 1, before: '<table>', after: '</table>' }, + tbody: { depth: 2, before: '<table><tbody>', after: '</tbody></table>' }, + tfoot: { depth: 2, before: '<table><tfoot>', after: '</tfoot></table>' }, + thead: { depth: 2, before: '<table><thead>', after: '</thead></table>' }, + tr: { depth: 3, before: '<table><tbody><tr>', after: '</tr></tbody></table>' } + }; // Patch: innerHTML Fix // Browsers: IE9 // Reason: IE9 don't allow us to set innerHTML on col, colgroup, frameset, // html, style, table, tbody, tfoot, thead, title, tr. // Fix: Wrap the innerHTML we are about to set in its parents, apply the // wrapped innerHTML on a div, then move the unwrapped nodes into the // target position. - function applyInnerHTMLFix(document, DOMHelperClass) { - if (!document) return DOMHelperClass; - var table = document.createElement('table'); - try { - table.innerHTML = '<tbody></tbody>'; - } catch (e) {} finally { - if (table.childNodes.length !== 0) { - // It worked as expected, no fix required - return DOMHelperClass; - } + function domChanges(document, DOMChangesClass) { + if (!document) return DOMChangesClass; + if (!shouldApplyFix(document)) { + return DOMChangesClass; } - table = null; - var innerHTMLWrapper = { - colgroup: { depth: 2, before: '<table><colgroup>', after: '</colgroup></table>' }, - table: { depth: 1, before: '<table>', after: '</table>' }, - tbody: { depth: 2, before: '<table><tbody>', after: '</tbody></table>' }, - tfoot: { depth: 2, before: '<table><tfoot>', after: '</tfoot></table>' }, - thead: { depth: 2, before: '<table><thead>', after: '</thead></table>' }, - tr: { depth: 3, before: '<table><tbody><tr>', after: '</tr></tbody></table>' } - }; var div = document.createElement('div'); - return (function (_DOMHelperClass) { - _inherits(DOMHelperWithInnerHTMLFix, _DOMHelperClass); + return (function (_DOMChangesClass) { + babelHelpers.inherits(DOMChangesWithInnerHTMLFix, _DOMChangesClass); - function DOMHelperWithInnerHTMLFix() { - _classCallCheck(this, DOMHelperWithInnerHTMLFix); - - _DOMHelperClass.apply(this, arguments); + function DOMChangesWithInnerHTMLFix() { + _DOMChangesClass.apply(this, arguments); } - DOMHelperWithInnerHTMLFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, nextSibling, html) { + DOMChangesWithInnerHTMLFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, nextSibling, html) { if (html === null || html === '') { - return _DOMHelperClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + return _DOMChangesClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); } var parentTag = parent.tagName.toLowerCase(); var wrapper = innerHTMLWrapper[parentTag]; if (wrapper === undefined) { - return _DOMHelperClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + return _DOMChangesClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); } - var wrappedHtml = wrapper.before + html + wrapper.after; - div.innerHTML = wrappedHtml; - var parentNode = div; - for (var i = 0; i < wrapper.depth; i++) { - parentNode = parentNode.childNodes[0]; - } + return fixInnerHTML(parent, wrapper, div, html, nextSibling); + }; - var _moveNodesBefore = _glimmerRuntimeLibDomHelper.moveNodesBefore(parentNode, parent, nextSibling); + return DOMChangesWithInnerHTMLFix; + })(DOMChangesClass); + } - var first = _moveNodesBefore[0]; - var last = _moveNodesBefore[1]; + function treeConstruction(document, DOMTreeConstructionClass) { + if (!document) return DOMTreeConstructionClass; + if (!shouldApplyFix(document)) { + return DOMTreeConstructionClass; + } + var div = document.createElement('div'); + return (function (_DOMTreeConstructionClass) { + babelHelpers.inherits(DOMTreeConstructionWithInnerHTMLFix, _DOMTreeConstructionClass); - return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, first, last); + function DOMTreeConstructionWithInnerHTMLFix() { + _DOMTreeConstructionClass.apply(this, arguments); + } + + DOMTreeConstructionWithInnerHTMLFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, html, reference) { + if (html === null || html === '') { + return _DOMTreeConstructionClass.prototype.insertHTMLBefore.call(this, parent, html, reference); + } + var parentTag = parent.tagName.toLowerCase(); + var wrapper = innerHTMLWrapper[parentTag]; + if (wrapper === undefined) { + return _DOMTreeConstructionClass.prototype.insertHTMLBefore.call(this, parent, html, reference); + } + return fixInnerHTML(parent, wrapper, div, html, reference); }; - return DOMHelperWithInnerHTMLFix; - })(DOMHelperClass); + return DOMTreeConstructionWithInnerHTMLFix; + })(DOMTreeConstructionClass); } -}); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-runtime/lib/compat/svg-inner-html-fix', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/dom/helper'], function (exports, _glimmerRuntimeLibBounds, _glimmerRuntimeLibDomHelper) { - 'use strict'; - exports.default = applyInnerHTMLFix; + function fixInnerHTML(parent, wrapper, div, html, reference) { + var wrappedHtml = wrapper.before + html + wrapper.after; + div.innerHTML = wrappedHtml; + var parentNode = div; + for (var i = 0; i < wrapper.depth; i++) { + parentNode = parentNode.childNodes[0]; + } - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + var _moveNodesBefore = _glimmerRuntimeLibDomHelper.moveNodesBefore(parentNode, parent, reference); - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + var first = _moveNodesBefore[0]; + var last = _moveNodesBefore[1]; - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } + return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, first, last); + } + function shouldApplyFix(document) { + var table = document.createElement('table'); + try { + table.innerHTML = '<tbody></tbody>'; + } catch (e) {} finally { + if (table.childNodes.length !== 0) { + // It worked as expected, no fix required + return false; + } + } + return true; + } +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compat/inner-html-fix.ts"],"names":[],"mappings":"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","file":"inner-html-fix.js","sourcesContent":["import { Bounds, ConcreteBounds } from '../bounds';\nimport { moveNodesBefore, DOMChanges, DOMTreeConstruction } from '../dom/helper';\n\ninterface Wrapper {\n  depth: number;\n  before: string;\n  after: string;\n}\n\nlet innerHTMLWrapper = {\n  colgroup: { depth: 2, before: '<table><colgroup>', after: '</colgroup></table>' },\n  table:    { depth: 1, before: '<table>', after: '</table>' },\n  tbody:    { depth: 2, before: '<table><tbody>', after: '</tbody></table>' },\n  tfoot:    { depth: 2, before: '<table><tfoot>', after: '</tfoot></table>' },\n  thead:    { depth: 2, before: '<table><thead>', after: '</thead></table>' },\n  tr:       { depth: 3, before: '<table><tbody><tr>', after: '</tr></tbody></table>' }\n};\n\n// Patch:    innerHTML Fix\n// Browsers: IE9\n// Reason:   IE9 don't allow us to set innerHTML on col, colgroup, frameset,\n//           html, style, table, tbody, tfoot, thead, title, tr.\n// Fix:      Wrap the innerHTML we are about to set in its parents, apply the\n//           wrapped innerHTML on a div, then move the unwrapped nodes into the\n//           target position.\nexport function domChanges(document: Document, DOMChangesClass: typeof DOMChanges): typeof DOMChanges {\n  if (!document) return DOMChangesClass;\n\n  if (!shouldApplyFix(document)) {\n    return DOMChangesClass;\n  }\n\n  let div = document.createElement('div');\n\n  return class DOMChangesWithInnerHTMLFix extends DOMChangesClass {\n    insertHTMLBefore(parent: HTMLElement, nextSibling: Node, html: string): Bounds {\n      if (html === null || html === '') {\n        return super.insertHTMLBefore(parent, nextSibling, html);\n      }\n\n      let parentTag = parent.tagName.toLowerCase();\n      let wrapper = innerHTMLWrapper[parentTag];\n\n      if(wrapper === undefined) {\n        return super.insertHTMLBefore(parent, nextSibling, html);\n      }\n\n      return fixInnerHTML(parent, wrapper, div, html, nextSibling);\n    }\n  };\n}\n\nexport function treeConstruction(document: Document, DOMTreeConstructionClass: typeof DOMTreeConstruction) {\n  if (!document) return DOMTreeConstructionClass;\n\n  if (!shouldApplyFix(document)) {\n    return DOMTreeConstructionClass;\n  }\n\n  let div = document.createElement('div');\n\n  return class DOMTreeConstructionWithInnerHTMLFix extends DOMTreeConstructionClass {\n    insertHTMLBefore(parent: HTMLElement, html: string, reference: Node): Bounds {\n      if (html === null || html === '') {\n        return super.insertHTMLBefore(parent, html, reference);\n      }\n\n      let parentTag = parent.tagName.toLowerCase();\n      let wrapper = innerHTMLWrapper[parentTag];\n\n      if(wrapper === undefined) {\n        return super.insertHTMLBefore(parent, html, reference);\n      }\n\n      return fixInnerHTML(parent, wrapper, div, html, reference);\n    }\n  };\n}\n\nfunction fixInnerHTML(parent: HTMLElement, wrapper: Wrapper, div: HTMLElement, html: string, reference: Node): Bounds {\n  let wrappedHtml = wrapper.before + html + wrapper.after;\n\n  div.innerHTML = wrappedHtml;\n\n  let parentNode: Node = div;\n\n  for (let i=0; i<wrapper.depth; i++) {\n    parentNode = parentNode.childNodes[0];\n  }\n\n  let [first, last] = moveNodesBefore(parentNode, parent, reference);\n  return new ConcreteBounds(parent, first, last);\n}\n\nfunction shouldApplyFix(document) {\n  let table = document.createElement('table');\n  try {\n    table.innerHTML = '<tbody></tbody>';\n  } catch (e) {\n  } finally {\n    if (table.childNodes.length !== 0) {\n      // It worked as expected, no fix required\n      return false;\n    }\n  }\n\n  return true;\n}\n"]} +enifed('glimmer-runtime/lib/compat/svg-inner-html-fix', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/dom/helper'], function (exports, _glimmerRuntimeLibBounds, _glimmerRuntimeLibDomHelper) { + 'use strict'; + exports.domChanges = domChanges; + exports.treeConstruction = treeConstruction; + var SVG_NAMESPACE = 'http://www.w3.org/2000/svg'; // Patch: insertAdjacentHTML on SVG Fix // Browsers: Safari, IE, Edge, Firefox ~33-34 // Reason: insertAdjacentHTML does not exist on SVG elements in Safari. It is // present but throws an exception on IE and Edge. Old versions of @@ -14351,58 +15251,93 @@ // namespace using innerHTML on SVG elements, an HTML-string wrapping // approach is used. A pre/post SVG tag is added to the string, then // that whole string is added to a div. The created nodes are plucked // out and applied to the target location on DOM. - function applyInnerHTMLFix(document, DOMHelperClass, svgNamespace) { - if (!document) return DOMHelperClass; - var svg = document.createElementNS(svgNamespace, 'svg'); - try { - svg['insertAdjacentHTML']('beforeEnd', '<circle></circle>'); - } catch (e) {} finally { - // FF: Old versions will create a node in the wrong namespace - if (svg.childNodes.length === 1 && svg.firstChild.namespaceURI === SVG_NAMESPACE) { - // The test worked as expected, no fix required - return DOMHelperClass; - } - svg = null; + function domChanges(document, DOMChangesClass, svgNamespace) { + if (!document) return DOMChangesClass; + if (!shouldApplyFix(document, svgNamespace)) { + return DOMChangesClass; } var div = document.createElement('div'); - return (function (_DOMHelperClass) { - _inherits(DOMHelperWithSVGInnerHTMLFix, _DOMHelperClass); + return (function (_DOMChangesClass) { + babelHelpers.inherits(DOMChangesWithSVGInnerHTMLFix, _DOMChangesClass); - function DOMHelperWithSVGInnerHTMLFix() { - _classCallCheck(this, DOMHelperWithSVGInnerHTMLFix); - - _DOMHelperClass.apply(this, arguments); + function DOMChangesWithSVGInnerHTMLFix() { + _DOMChangesClass.apply(this, arguments); } - DOMHelperWithSVGInnerHTMLFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, nextSibling, html) { + DOMChangesWithSVGInnerHTMLFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, nextSibling, html) { if (html === null || html === '') { - return _DOMHelperClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + return _DOMChangesClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); } if (parent.namespaceURI !== svgNamespace) { - return _DOMHelperClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + return _DOMChangesClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); } - // IE, Edge: also do not correctly support using `innerHTML` on SVG - // namespaced elements. So here a wrapper is used. - var wrappedHtml = '<svg>' + html + '</svg>'; - div.innerHTML = wrappedHtml; + return fixSVG(parent, div, html, nextSibling); + }; - var _moveNodesBefore = _glimmerRuntimeLibDomHelper.moveNodesBefore(div.firstChild, parent, nextSibling); + return DOMChangesWithSVGInnerHTMLFix; + })(DOMChangesClass); + } - var first = _moveNodesBefore[0]; - var last = _moveNodesBefore[1]; + function treeConstruction(document, TreeConstructionClass, svgNamespace) { + if (!document) return TreeConstructionClass; + if (!shouldApplyFix(document, svgNamespace)) { + return TreeConstructionClass; + } + var div = document.createElement('div'); + return (function (_TreeConstructionClass) { + babelHelpers.inherits(TreeConstructionWithSVGInnerHTMLFix, _TreeConstructionClass); - return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, first, last); + function TreeConstructionWithSVGInnerHTMLFix() { + _TreeConstructionClass.apply(this, arguments); + } + + TreeConstructionWithSVGInnerHTMLFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, html, reference) { + if (html === null || html === '') { + return _TreeConstructionClass.prototype.insertHTMLBefore.call(this, parent, html, reference); + } + if (parent.namespaceURI !== svgNamespace) { + return _TreeConstructionClass.prototype.insertHTMLBefore.call(this, parent, html, reference); + } + return fixSVG(parent, div, html, reference); }; - return DOMHelperWithSVGInnerHTMLFix; - })(DOMHelperClass); + return TreeConstructionWithSVGInnerHTMLFix; + })(TreeConstructionClass); } + + function fixSVG(parent, div, html, reference) { + // IE, Edge: also do not correctly support using `innerHTML` on SVG + // namespaced elements. So here a wrapper is used. + var wrappedHtml = '<svg>' + html + '</svg>'; + div.innerHTML = wrappedHtml; + + var _moveNodesBefore = _glimmerRuntimeLibDomHelper.moveNodesBefore(div.firstChild, parent, reference); + + var first = _moveNodesBefore[0]; + var last = _moveNodesBefore[1]; + + return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, first, last); + } + function shouldApplyFix(document, svgNamespace) { + var svg = document.createElementNS(svgNamespace, 'svg'); + try { + svg['insertAdjacentHTML']('beforeEnd', '<circle></circle>'); + } catch (e) {} finally { + // FF: Old versions will create a node in the wrong namespace + if (svg.childNodes.length === 1 && svg.firstChild.namespaceURI === SVG_NAMESPACE) { + // The test worked as expected, no fix required + return false; + } + svg = null; + return true; + } + } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/compat/text-node-merging-fix', ['exports'], function (exports) { // Patch: Adjacent text node merging fix // Browsers: IE, Edge, Firefox w/o inspector open // Reason: These browsers will merge adjacent text nodes. For exmaple given // <div>Hello</div> with div.insertAdjacentHTML(' world') browsers @@ -14414,98 +15349,121 @@ // Note that this fix must only apply to the previous text node, as // the base implementation of `insertHTMLBefore` already handles // following text nodes correctly. 'use strict'; - exports.default = applyTextNodeMergingFix; + exports.domChanges = domChanges; + exports.treeConstruction = treeConstruction; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + function domChanges(document, DOMChangesClass) { + if (!document) return DOMChangesClass; + if (!shouldApplyFix(document)) { + return DOMChangesClass; + } + return (function (_DOMChangesClass) { + babelHelpers.inherits(DOMChangesWithTextNodeMergingFix, _DOMChangesClass); - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + function DOMChangesWithTextNodeMergingFix(document) { + _DOMChangesClass.call(this, document); + this.uselessComment = document.createComment(''); + } - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } + DOMChangesWithTextNodeMergingFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, nextSibling, html) { + if (html === null) { + return _DOMChangesClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + } + var didSetUselessComment = false; + var nextPrevious = nextSibling ? nextSibling.previousSibling : parent.lastChild; + if (nextPrevious && nextPrevious instanceof Text) { + didSetUselessComment = true; + parent.insertBefore(this.uselessComment, nextSibling); + } + var bounds = _DOMChangesClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + if (didSetUselessComment) { + parent.removeChild(this.uselessComment); + } + return bounds; + }; - function applyTextNodeMergingFix(document, DOMHelperClass) { - if (!document) return DOMHelperClass; - var mergingTextDiv = document.createElement('div'); - mergingTextDiv.innerHTML = 'first'; - mergingTextDiv.insertAdjacentHTML('beforeEnd', 'second'); - if (mergingTextDiv.childNodes.length === 2) { - // It worked as expected, no fix required - return DOMHelperClass; + return DOMChangesWithTextNodeMergingFix; + })(DOMChangesClass); + } + + function treeConstruction(document, TreeConstructionClass) { + if (!document) return TreeConstructionClass; + if (!shouldApplyFix(document)) { + return TreeConstructionClass; } - mergingTextDiv = null; - return (function (_DOMHelperClass) { - _inherits(DOMHelperWithTextNodeMergingFix, _DOMHelperClass); + return (function (_TreeConstructionClass) { + babelHelpers.inherits(TreeConstructionWithTextNodeMergingFix, _TreeConstructionClass); - function DOMHelperWithTextNodeMergingFix(document) { - _classCallCheck(this, DOMHelperWithTextNodeMergingFix); - - _DOMHelperClass.call(this, document); + function TreeConstructionWithTextNodeMergingFix(document) { + _TreeConstructionClass.call(this, document); this.uselessComment = this.createComment(''); } - DOMHelperWithTextNodeMergingFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, nextSibling, html) { + TreeConstructionWithTextNodeMergingFix.prototype.insertHTMLBefore = function insertHTMLBefore(parent, html, reference) { if (html === null) { - return _DOMHelperClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + return _TreeConstructionClass.prototype.insertHTMLBefore.call(this, parent, html, reference); } var didSetUselessComment = false; - var nextPrevious = nextSibling ? nextSibling.previousSibling : parent.lastChild; + var nextPrevious = reference ? reference.previousSibling : parent.lastChild; if (nextPrevious && nextPrevious instanceof Text) { didSetUselessComment = true; - parent.insertBefore(this.uselessComment, nextSibling); + parent.insertBefore(this.uselessComment, reference); } - var bounds = _DOMHelperClass.prototype.insertHTMLBefore.call(this, parent, nextSibling, html); + var bounds = _TreeConstructionClass.prototype.insertHTMLBefore.call(this, parent, html, reference); if (didSetUselessComment) { parent.removeChild(this.uselessComment); } return bounds; }; - return DOMHelperWithTextNodeMergingFix; - })(DOMHelperClass); + return TreeConstructionWithTextNodeMergingFix; + })(TreeConstructionClass); } + + function shouldApplyFix(document) { + var mergingTextDiv = document.createElement('div'); + mergingTextDiv.innerHTML = 'first'; + mergingTextDiv.insertAdjacentHTML('beforeEnd', 'second'); + if (mergingTextDiv.childNodes.length === 2) { + mergingTextDiv = null; + // It worked as expected, no fix required + return false; + } + mergingTextDiv = null; + return true; + } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcGF0L3RleHQtbm9kZS1tZXJnaW5nLWZpeC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7c0JBZUEsdUJBQUE7Ozs7Ozs7O0FBQUEsYUFBQSx1QkFBQSxDQUFnRCxRQUFrQixFQUFFLGNBQWdDLEVBQUE7QUFDbEcsWUFBSSxDQUFDLFFBQVEsRUFBRSxPQUFPLGNBQWMsQ0FBQztBQUVyQyxZQUFJLGNBQWMsR0FBaUIsUUFBUSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUVqRSxzQkFBYyxDQUFDLFNBQVMsR0FBRyxPQUFPLENBQUM7QUFDbkMsc0JBQWMsQ0FBQyxrQkFBa0IsQ0FBQyxXQUFXLEVBQUUsUUFBUSxDQUFDLENBQUM7QUFFekQsWUFBSSxjQUFjLENBQUMsVUFBVSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7O0FBRTFDLG1CQUFPLGNBQWMsQ0FBQztTQUN2QjtBQUVELHNCQUFjLEdBQUcsSUFBSSxDQUFDO0FBRXRCO3NCQUFPLCtCQUFBOztBQUdMLHFCQUhLLCtCQUFBLENBR08sUUFBUSxFQUFBO3NDQUhmLCtCQUFBOztBQUlILDJDQUFNLFFBQVEsQ0FBQyxDQUFDO0FBQ2hCLG9CQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsRUFBRSxDQUFDLENBQUM7YUFDOUM7O0FBTkksMkNBQUEsV0FRTCxnQkFBZ0IsR0FBQSwwQkFBQyxNQUFtQixFQUFFLFdBQWlCLEVBQUUsSUFBWSxFQUFBO0FBQ25FLG9CQUFJLElBQUksS0FBSyxJQUFJLEVBQUU7QUFDakIsMkJBQU8sMEJBQU0sZ0JBQWdCLEtBQUEsT0FBQyxNQUFNLEVBQUUsV0FBVyxFQUFFLElBQUksQ0FBQyxDQUFDO2lCQUMxRDtBQUVELG9CQUFJLG9CQUFvQixHQUFHLEtBQUssQ0FBQztBQUVqQyxvQkFBSSxZQUFZLEdBQUcsV0FBVyxHQUFHLFdBQVcsQ0FBQyxlQUFlLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQztBQUNoRixvQkFBSSxZQUFZLElBQUksWUFBWSxZQUFZLElBQUksRUFBRTtBQUNoRCx3Q0FBb0IsR0FBRyxJQUFJLENBQUM7QUFDNUIsMEJBQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRSxXQUFXLENBQUMsQ0FBQztpQkFDdkQ7QUFFRCxvQkFBSSxNQUFNLEdBQUcsMEJBQU0sZ0JBQWdCLEtBQUEsT0FBQyxNQUFNLEVBQUUsV0FBVyxFQUFFLElBQUksQ0FBQyxDQUFDO0FBRS9ELG9CQUFJLG9CQUFvQixFQUFFO0FBQ3hCLDBCQUFNLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztpQkFDekM7QUFFRCx1QkFBTyxNQUFNLENBQUM7YUFDZjs7bUJBNUJJLCtCQUFBO1dBQThDLGNBQWMsRUE2QmpFO0tBQ0giLCJmaWxlIjoidGV4dC1ub2RlLW1lcmdpbmctZml4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQm91bmRzIH0gZnJvbSAnLi4vYm91bmRzJztcbmltcG9ydCB7IERPTUhlbHBlciB9IGZyb20gJy4uL2RvbS9oZWxwZXInO1xuXG4vLyBQYXRjaDogICAgQWRqYWNlbnQgdGV4dCBub2RlIG1lcmdpbmcgZml4XG4vLyBCcm93c2VyczogSUUsIEVkZ2UsIEZpcmVmb3ggdy9vIGluc3BlY3RvciBvcGVuXG4vLyBSZWFzb246ICAgVGhlc2UgYnJvd3NlcnMgd2lsbCBtZXJnZSBhZGphY2VudCB0ZXh0IG5vZGVzLiBGb3IgZXhtYXBsZSBnaXZlblxuLy8gICAgICAgICAgIDxkaXY+SGVsbG88L2Rpdj4gd2l0aCBkaXYuaW5zZXJ0QWRqYWNlbnRIVE1MKCcgd29ybGQnKSBicm93c2Vyc1xuLy8gICAgICAgICAgIHdpdGggcHJvcGVyIGJlaGF2aW9yIHdpbGwgcG9wdWxhdGUgZGl2LmNoaWxkTm9kZXMgd2l0aCB0d28gaXRlbXMuXG4vLyAgICAgICAgICAgVGhlc2UgYnJvd3NlcnMgd2lsbCBwb3B1bGF0ZSBpdCB3aXRoIG9uZSBtZXJnZWQgbm9kZSBpbnN0ZWFkLlxuLy8gRml4OiAgICAgIEFkZCB0aGVzZSBub2RlcyB0byBhIHdyYXBwZXIgZWxlbWVudCwgdGhlbiBpdGVyYXRlIHRoZSBjaGlsZE5vZGVzXG4vLyAgICAgICAgICAgb2YgdGhhdCB3cmFwcGVyIGFuZCBtb3ZlIHRoZSBub2RlcyB0byB0aGVpciB0YXJnZXQgbG9jYXRpb24uIE5vdGVcbi8vICAgICAgICAgICB0aGF0IHBvdGVudGlhbCBTVkcgYnVncyB3aWxsIGhhdmUgYmVlbiBoYW5kbGVkIGJlZm9yZSB0aGlzIGZpeC5cbi8vICAgICAgICAgICBOb3RlIHRoYXQgdGhpcyBmaXggbXVzdCBvbmx5IGFwcGx5IHRvIHRoZSBwcmV2aW91cyB0ZXh0IG5vZGUsIGFzXG4vLyAgICAgICAgICAgdGhlIGJhc2UgaW1wbGVtZW50YXRpb24gb2YgYGluc2VydEhUTUxCZWZvcmVgIGFscmVhZHkgaGFuZGxlc1xuLy8gICAgICAgICAgIGZvbGxvd2luZyB0ZXh0IG5vZGVzIGNvcnJlY3RseS5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGFwcGx5VGV4dE5vZGVNZXJnaW5nRml4KGRvY3VtZW50OiBEb2N1bWVudCwgRE9NSGVscGVyQ2xhc3M6IHR5cGVvZiBET01IZWxwZXIpOiB0eXBlb2YgRE9NSGVscGVyIHtcbiAgaWYgKCFkb2N1bWVudCkgcmV0dXJuIERPTUhlbHBlckNsYXNzO1xuXG4gIGxldCBtZXJnaW5nVGV4dERpdiA9IDxIVE1MRWxlbWVudD4gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7XG5cbiAgbWVyZ2luZ1RleHREaXYuaW5uZXJIVE1MID0gJ2ZpcnN0JztcbiAgbWVyZ2luZ1RleHREaXYuaW5zZXJ0QWRqYWNlbnRIVE1MKCdiZWZvcmVFbmQnLCAnc2Vjb25kJyk7XG5cbiAgaWYgKG1lcmdpbmdUZXh0RGl2LmNoaWxkTm9kZXMubGVuZ3RoID09PSAyKSB7XG4gICAgLy8gSXQgd29ya2VkIGFzIGV4cGVjdGVkLCBubyBmaXggcmVxdWlyZWRcbiAgICByZXR1cm4gRE9NSGVscGVyQ2xhc3M7XG4gIH1cblxuICBtZXJnaW5nVGV4dERpdiA9IG51bGw7XG5cbiAgcmV0dXJuIGNsYXNzIERPTUhlbHBlcldpdGhUZXh0Tm9kZU1lcmdpbmdGaXggZXh0ZW5kcyBET01IZWxwZXJDbGFzcyB7XG4gICAgcHJpdmF0ZSB1c2VsZXNzQ29tbWVudDogQ29tbWVudDtcblxuICAgIGNvbnN0cnVjdG9yKGRvY3VtZW50KSB7XG4gICAgICBzdXBlcihkb2N1bWVudCk7XG4gICAgICB0aGlzLnVzZWxlc3NDb21tZW50ID0gdGhpcy5jcmVhdGVDb21tZW50KCcnKTtcbiAgICB9XG5cbiAgICBpbnNlcnRIVE1MQmVmb3JlKHBhcmVudDogSFRNTEVsZW1lbnQsIG5leHRTaWJsaW5nOiBOb2RlLCBodG1sOiBzdHJpbmcpOiBCb3VuZHMge1xuICAgICAgaWYgKGh0bWwgPT09IG51bGwpIHtcbiAgICAgICAgcmV0dXJuIHN1cGVyLmluc2VydEhUTUxCZWZvcmUocGFyZW50LCBuZXh0U2libGluZywgaHRtbCk7XG4gICAgICB9XG5cbiAgICAgIGxldCBkaWRTZXRVc2VsZXNzQ29tbWVudCA9IGZhbHNlO1xuXG4gICAgICBsZXQgbmV4dFByZXZpb3VzID0gbmV4dFNpYmxpbmcgPyBuZXh0U2libGluZy5wcmV2aW91c1NpYmxpbmcgOiBwYXJlbnQubGFzdENoaWxkO1xuICAgICAgaWYgKG5leHRQcmV2aW91cyAmJiBuZXh0UHJldmlvdXMgaW5zdGFuY2VvZiBUZXh0KSB7XG4gICAgICAgIGRpZFNldFVzZWxlc3NDb21tZW50ID0gdHJ1ZTtcbiAgICAgICAgcGFyZW50Lmluc2VydEJlZm9yZSh0aGlzLnVzZWxlc3NDb21tZW50LCBuZXh0U2libGluZyk7XG4gICAgICB9XG5cbiAgICAgIGxldCBib3VuZHMgPSBzdXBlci5pbnNlcnRIVE1MQmVmb3JlKHBhcmVudCwgbmV4dFNpYmxpbmcsIGh0bWwpO1xuXG4gICAgICBpZiAoZGlkU2V0VXNlbGVzc0NvbW1lbnQpIHtcbiAgICAgICAgcGFyZW50LnJlbW92ZUNoaWxkKHRoaXMudXNlbGVzc0NvbW1lbnQpO1xuICAgICAgfVxuXG4gICAgICByZXR1cm4gYm91bmRzO1xuICAgIH1cbiAgfTtcbn1cbiJdfQ== -enifed('glimmer-runtime/lib/compiled/blocks', ['exports', 'glimmer-runtime/lib/symbol-table', 'glimmer-runtime/lib/compiler'], function (exports, _glimmerRuntimeLibSymbolTable, _glimmerRuntimeLibCompiler) { +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compat/text-node-merging-fix.ts"],"names":[],"mappings":"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","file":"text-node-merging-fix.js","sourcesContent":["import { Bounds } from '../bounds';\nimport { DOMChanges, DOMTreeConstruction } from '../dom/helper';\n\n// Patch:    Adjacent text node merging fix\n// Browsers: IE, Edge, Firefox w/o inspector open\n// Reason:   These browsers will merge adjacent text nodes. For exmaple given\n//           <div>Hello</div> with div.insertAdjacentHTML(' world') browsers\n//           with proper behavior will populate div.childNodes with two items.\n//           These browsers will populate it with one merged node instead.\n// Fix:      Add these nodes to a wrapper element, then iterate the childNodes\n//           of that wrapper and move the nodes to their target location. Note\n//           that potential SVG bugs will have been handled before this fix.\n//           Note that this fix must only apply to the previous text node, as\n//           the base implementation of `insertHTMLBefore` already handles\n//           following text nodes correctly.\nexport function domChanges(document: Document, DOMChangesClass: typeof DOMChanges): typeof DOMChanges {\n  if (!document) return DOMChangesClass;\n\n  if (!shouldApplyFix(document)) {\n    return DOMChangesClass;\n  }\n\n  return class DOMChangesWithTextNodeMergingFix extends DOMChangesClass {\n    private uselessComment: Comment;\n\n    constructor(document) {\n      super(document);\n      this.uselessComment = document.createComment('');\n    }\n\n    insertHTMLBefore(parent: HTMLElement, nextSibling: Node, html: string): Bounds {\n      if (html === null) {\n        return super.insertHTMLBefore(parent, nextSibling, html);\n      }\n\n      let didSetUselessComment = false;\n\n      let nextPrevious = nextSibling ? nextSibling.previousSibling : parent.lastChild;\n      if (nextPrevious && nextPrevious instanceof Text) {\n        didSetUselessComment = true;\n        parent.insertBefore(this.uselessComment, nextSibling);\n      }\n\n      let bounds = super.insertHTMLBefore(parent, nextSibling, html);\n\n      if (didSetUselessComment) {\n        parent.removeChild(this.uselessComment);\n      }\n\n      return bounds;\n    }\n  };\n}\n\nexport function treeConstruction(document: Document, TreeConstructionClass: typeof DOMTreeConstruction): typeof DOMTreeConstruction {\n  if (!document) return TreeConstructionClass;\n\n  if (!shouldApplyFix(document)) {\n    return TreeConstructionClass;\n  }\n\n  return class TreeConstructionWithTextNodeMergingFix extends TreeConstructionClass {\n    private uselessComment: Comment;\n\n    constructor(document) {\n      super(document);\n      this.uselessComment = this.createComment('') as Comment;\n    }\n\n    insertHTMLBefore(parent: HTMLElement, html: string, reference: Node): Bounds {\n      if (html === null) {\n        return super.insertHTMLBefore(parent, html, reference);\n      }\n\n      let didSetUselessComment = false;\n\n      let nextPrevious = reference ? reference.previousSibling : parent.lastChild;\n      if (nextPrevious && nextPrevious instanceof Text) {\n        didSetUselessComment = true;\n        parent.insertBefore(this.uselessComment, reference);\n      }\n\n      let bounds = super.insertHTMLBefore(parent, html, reference);\n\n      if (didSetUselessComment) {\n        parent.removeChild(this.uselessComment);\n      }\n\n      return bounds;\n    }\n  };\n}\n\nfunction shouldApplyFix(document) {\n  let mergingTextDiv = <HTMLElement> document.createElement('div');\n\n  mergingTextDiv.innerHTML = 'first';\n  mergingTextDiv.insertAdjacentHTML('beforeEnd', 'second');\n\n  if (mergingTextDiv.childNodes.length === 2) {\n    mergingTextDiv = null;\n    // It worked as expected, no fix required\n    return false;\n  }\n\n  mergingTextDiv = null;\n\n  return true;\n}\n"]} +enifed('glimmer-runtime/lib/compiled/blocks', ['exports', 'glimmer-runtime/lib/utils', 'glimmer-runtime/lib/compiler'], function (exports, _glimmerRuntimeLibUtils, _glimmerRuntimeLibCompiler) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var CompiledBlock = function CompiledBlock(ops, symbols) { - _classCallCheck(this, CompiledBlock); - this.ops = ops; this.symbols = symbols; }; exports.CompiledBlock = CompiledBlock; - var Block = function Block(options) { - _classCallCheck(this, Block); - + var Block = function Block(program, symbolTable) { + this.program = program; + this.symbolTable = symbolTable; this.compiled = null; - this.symbolTable = options.symbolTable || null; - this.children = options.children; - this.program = options.program; - this.meta = options.meta; }; exports.Block = Block; var InlineBlock = (function (_Block) { - _inherits(InlineBlock, _Block); + babelHelpers.inherits(InlineBlock, _Block); - function InlineBlock(options) { - _classCallCheck(this, InlineBlock); + function InlineBlock(program, symbolTable) { + var locals = arguments.length <= 2 || arguments[2] === undefined ? _glimmerRuntimeLibUtils.EMPTY_ARRAY : arguments[2]; - _Block.call(this, options); - this.locals = options.locals; + _Block.call(this, program, symbolTable); + this.locals = locals; } InlineBlock.prototype.hasPositionalParameters = function hasPositionalParameters() { return !!this.locals.length; }; @@ -14521,78 +15479,40 @@ })(Block); exports.InlineBlock = InlineBlock; var PartialBlock = (function (_InlineBlock) { - _inherits(PartialBlock, _InlineBlock); + babelHelpers.inherits(PartialBlock, _InlineBlock); function PartialBlock() { - _classCallCheck(this, PartialBlock); - _InlineBlock.apply(this, arguments); } - PartialBlock.prototype.initBlocks = function initBlocks() { - var _this = this; - - var blocks = arguments.length <= 0 || arguments[0] === undefined ? this['children'] : arguments[0]; - var parentTable = arguments.length <= 1 || arguments[1] === undefined ? this['symbolTable'] : arguments[1]; - - blocks.forEach(function (block) { - var table = _glimmerRuntimeLibSymbolTable.default.initForBlock({ parent: parentTable, block: block }); - _this.initBlocks(block['children'], table); - }); - return this; - }; - return PartialBlock; })(InlineBlock); exports.PartialBlock = PartialBlock; var TopLevelTemplate = (function (_Block2) { - _inherits(TopLevelTemplate, _Block2); + babelHelpers.inherits(TopLevelTemplate, _Block2); function TopLevelTemplate() { - _classCallCheck(this, TopLevelTemplate); - _Block2.apply(this, arguments); } - TopLevelTemplate.prototype.initBlocks = function initBlocks() { - var _this2 = this; - - var blocks = arguments.length <= 0 || arguments[0] === undefined ? this['children'] : arguments[0]; - var parentTable = arguments.length <= 1 || arguments[1] === undefined ? this['symbolTable'] : arguments[1]; - - blocks.forEach(function (block) { - var table = _glimmerRuntimeLibSymbolTable.default.initForBlock({ parent: parentTable, block: block }); - _this2.initBlocks(block['children'], table); - }); - return this; - }; - return TopLevelTemplate; })(Block); exports.TopLevelTemplate = TopLevelTemplate; var EntryPoint = (function (_TopLevelTemplate) { - _inherits(EntryPoint, _TopLevelTemplate); + babelHelpers.inherits(EntryPoint, _TopLevelTemplate); function EntryPoint() { - _classCallCheck(this, EntryPoint); - _TopLevelTemplate.apply(this, arguments); } - EntryPoint.create = function create(options) { - var top = new EntryPoint(options); - _glimmerRuntimeLibSymbolTable.default.initForEntryPoint(top); - return top; - }; - EntryPoint.prototype.compile = function compile(env) { var compiled = this.compiled; if (compiled) return compiled; var ops = new _glimmerRuntimeLibCompiler.EntryPointCompiler(this, env).compile(); return this.compiled = new CompiledBlock(ops, this.symbolTable.size); @@ -14602,31 +15522,18 @@ })(TopLevelTemplate); exports.EntryPoint = EntryPoint; var Layout = (function (_TopLevelTemplate2) { - _inherits(Layout, _TopLevelTemplate2); + babelHelpers.inherits(Layout, _TopLevelTemplate2); - function Layout(options) { - _classCallCheck(this, Layout); - - _TopLevelTemplate2.call(this, options); - var named = options.named; - var yields = options.yields; - - // positional params in Ember may want this - // this.locals = locals; + function Layout(program, symbolTable, named, yields) { + _TopLevelTemplate2.call(this, program, symbolTable); this.named = named; this.yields = yields; } - Layout.create = function create(options) { - var layout = new Layout(options); - _glimmerRuntimeLibSymbolTable.default.initForLayout(layout); - return layout; - }; - Layout.prototype.hasNamedParameters = function hasNamedParameters() { return !!this.named.length; }; Layout.prototype.hasYields = function hasYields() { @@ -14636,207 +15543,113 @@ return Layout; })(TopLevelTemplate); exports.Layout = Layout; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/blocks.ts"],"names":[],"mappings":"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","file":"blocks.js","sourcesContent":["import { InternedString } from 'glimmer-util';\nimport { OpSeq } from '../opcodes';\nimport { Program } from '../syntax';\nimport { Environment } from '../environment';\nimport SymbolTable from '../symbol-table';\nimport {\n  BlockMeta\n} from 'glimmer-wire-format';\n\nimport {\n  EntryPointCompiler,\n  InlineBlockCompiler\n} from '../compiler';\n\nexport interface BlockOptions {\n  children: InlineBlock[];\n  program: Program;\n  symbolTable: SymbolTable;\n  meta: BlockMeta;\n}\n\nexport class CompiledBlock {\n  public ops: OpSeq;\n  public symbols: number;\n\n  constructor(ops: OpSeq, symbols: number) {\n    this.ops = ops;\n    this.symbols = symbols;\n  }\n}\n\nexport abstract class Block {\n  public meta: BlockMeta;\n  public children: InlineBlock[];\n  public program: Program;\n  public symbolTable: SymbolTable;\n  protected compiled: CompiledBlock = null;\n\n  constructor(options: BlockOptions) {\n    this.symbolTable = options.symbolTable || null;\n    this.children = options.children;\n    this.program = options.program;\n    this.meta = options.meta;\n  }\n}\n\nexport interface InlineBlockOptions extends BlockOptions {\n  locals: InternedString[];\n}\n\nexport class InlineBlock extends Block {\n  public locals: InternedString[];\n\n  constructor(options: InlineBlockOptions) {\n    super(options);\n    this.locals = options.locals;\n  }\n\n  hasPositionalParameters(): boolean {\n    return !!this.locals.length;\n  }\n\n  compile(env: Environment): CompiledBlock {\n    let compiled = this.compiled;\n    if (compiled) return compiled;\n\n    let ops = new InlineBlockCompiler(this, env).compile();\n    return this.compiled = new CompiledBlock(ops, this.symbolTable.size);\n  }\n}\n\nexport class PartialBlock extends InlineBlock {\n  initBlocks(blocks = this['children'], parentTable = this['symbolTable']): this {\n    blocks.forEach(block => {\n      let table = SymbolTable.initForBlock({ parent: parentTable, block });\n      this.initBlocks(block['children'], table);\n    });\n    return this;\n  }\n}\n\nexport abstract class TopLevelTemplate extends Block {\n  initBlocks(blocks = this['children'], parentTable = this['symbolTable']): this {\n    blocks.forEach(block => {\n      let table = SymbolTable.initForBlock({ parent: parentTable, block });\n      this.initBlocks(block['children'], table);\n    });\n    return this;\n  }\n}\n\nexport class EntryPoint extends TopLevelTemplate {\n  static create(options: BlockOptions): EntryPoint {\n    let top = new EntryPoint(options);\n    SymbolTable.initForEntryPoint(top);\n    return top;\n  }\n\n  compile(env: Environment) {\n    let compiled = this.compiled;\n    if (compiled) return compiled;\n\n    let ops = new EntryPointCompiler(this, env).compile();\n    return this.compiled = new CompiledBlock(ops, this.symbolTable.size);\n  }\n}\n\nexport interface LayoutOptions extends BlockOptions {\n  named: InternedString[];\n  yields: InternedString[];\n  program: Program;\n}\n\nexport class Layout extends TopLevelTemplate {\n  static create(options: LayoutOptions): Layout {\n    let layout = new Layout(options);\n    SymbolTable.initForLayout(layout);\n    return layout;\n  }\n\n  public named: InternedString[];\n  public yields: InternedString[];\n\n  constructor(options: LayoutOptions) {\n    super(options);\n\n    let { named, yields } = options;\n\n    // positional params in Ember may want this\n    // this.locals = locals;\n    this.named = named;\n    this.yields = yields;\n  }\n\n  hasNamedParameters(): boolean {\n    return !!this.named.length;\n  }\n\n  hasYields(): boolean {\n    return !!this.yields.length;\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,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 enifed("glimmer-runtime/lib/compiled/expressions", ["exports"], function (exports) { "use strict"; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var CompiledExpression = (function () { - function CompiledExpression() { - _classCallCheck(this, CompiledExpression); - } + function CompiledExpression() {} CompiledExpression.prototype.toJSON = function toJSON() { return "UNIMPL: " + this.type.toUpperCase(); }; return CompiledExpression; })(); exports.CompiledExpression = CompiledExpression; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcGlsZWQvZXhwcmVzc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7UUFHQSxrQkFBQTtpQkFBQSxrQkFBQTtrQ0FBQSxrQkFBQTs7O0FBQUEsMEJBQUEsV0FJRSxNQUFNLEdBQUEsa0JBQUE7QUFDSixnQ0FBa0IsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBRztTQUM3Qzs7ZUFOSCxrQkFBQSIsImZpbGUiOiJleHByZXNzaW9ucy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBWTSBmcm9tICcuLi92bS9hcHBlbmQnO1xuaW1wb3J0IHsgUGF0aFJlZmVyZW5jZSB9IGZyb20gJ2dsaW1tZXItcmVmZXJlbmNlJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIENvbXBpbGVkRXhwcmVzc2lvbjxUPiB7XG4gIHR5cGU6IHN0cmluZztcbiAgYWJzdHJhY3QgZXZhbHVhdGUodm06IFZNKTogUGF0aFJlZmVyZW5jZTxUPjtcblxuICB0b0pTT04oKTogc3RyaW5nIHtcbiAgICByZXR1cm4gYFVOSU1QTDogJHt0aGlzLnR5cGUudG9VcHBlckNhc2UoKX1gO1xuICB9XG59XG4iXX0= -enifed('glimmer-runtime/lib/compiled/expressions/args', ['exports', 'glimmer-runtime/lib/compiled/expressions/positional-args', 'glimmer-runtime/lib/compiled/expressions/named-args', 'glimmer-reference', 'glimmer-util'], function (exports, _glimmerRuntimeLibCompiledExpressionsPositionalArgs, _glimmerRuntimeLibCompiledExpressionsNamedArgs, _glimmerReference, _glimmerUtil) { +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcGlsZWQvZXhwcmVzc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O1FBR00sa0JBQUE7aUJBQUEsa0JBQUE7O0FBQUEsMEJBQUEsV0FJSixNQUFNLEdBQUEsa0JBQUE7QUFDSixnQ0FBa0IsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBRztTQUM3Qzs7ZUFORyxrQkFBQSIsImZpbGUiOiJleHByZXNzaW9ucy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBWTSBmcm9tICcuLi92bS9hcHBlbmQnO1xuaW1wb3J0IHsgUGF0aFJlZmVyZW5jZSB9IGZyb20gJ2dsaW1tZXItcmVmZXJlbmNlJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIENvbXBpbGVkRXhwcmVzc2lvbjxUPiB7XG4gIHR5cGU6IHN0cmluZztcbiAgYWJzdHJhY3QgZXZhbHVhdGUodm06IFZNKTogUGF0aFJlZmVyZW5jZTxUPjtcblxuICB0b0pTT04oKTogc3RyaW5nIHtcbiAgICByZXR1cm4gYFVOSU1QTDogJHt0aGlzLnR5cGUudG9VcHBlckNhc2UoKX1gO1xuICB9XG59XG4iXX0= +enifed('glimmer-runtime/lib/compiled/expressions/args', ['exports', 'glimmer-runtime/lib/compiled/expressions/positional-args', 'glimmer-runtime/lib/compiled/expressions/named-args', 'glimmer-reference'], function (exports, _glimmerRuntimeLibCompiledExpressionsPositionalArgs, _glimmerRuntimeLibCompiledExpressionsNamedArgs, _glimmerReference) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var CompiledArgs = (function () { - function CompiledArgs() { - _classCallCheck(this, CompiledArgs); + function CompiledArgs(positional, named) { + this.positional = positional; + this.named = named; } - CompiledArgs.create = function create(_ref) { - var positional = _ref.positional; - var named = _ref.named; - + CompiledArgs.create = function create(positional, named) { if (positional === _glimmerRuntimeLibCompiledExpressionsPositionalArgs.COMPILED_EMPTY_POSITIONAL_ARGS && named === _glimmerRuntimeLibCompiledExpressionsNamedArgs.COMPILED_EMPTY_NAMED_ARGS) { - return COMPILED_EMPTY_ARGS; + return this.empty(); } else { - return new CompiledNonEmptyArgs({ positional: positional, named: named }); + return new this(positional, named); } }; CompiledArgs.empty = function empty() { return COMPILED_EMPTY_ARGS; }; + CompiledArgs.prototype.evaluate = function evaluate(vm) { + return EvaluatedArgs.create(this.positional.evaluate(vm), this.named.evaluate(vm)); + }; + return CompiledArgs; })(); exports.CompiledArgs = CompiledArgs; - var CompiledNonEmptyArgs = (function (_CompiledArgs) { - _inherits(CompiledNonEmptyArgs, _CompiledArgs); + var COMPILED_EMPTY_ARGS = new ((function (_CompiledArgs) { + babelHelpers.inherits(_class, _CompiledArgs); - function CompiledNonEmptyArgs(_ref2) { - var positional = _ref2.positional; - var named = _ref2.named; - - _classCallCheck(this, CompiledNonEmptyArgs); - - _CompiledArgs.call(this); - this.type = "args"; - this.positional = positional; - this.named = named; - } - - CompiledNonEmptyArgs.prototype.evaluate = function evaluate(vm) { - return EvaluatedArgs.create({ - positional: this.positional.evaluate(vm), - named: this.named.evaluate(vm) - }); - }; - - return CompiledNonEmptyArgs; - })(CompiledArgs); - - var COMPILED_EMPTY_ARGS = new ((function (_CompiledArgs2) { - _inherits(_class, _CompiledArgs2); - function _class() { - _classCallCheck(this, _class); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _CompiledArgs2.call.apply(_CompiledArgs2, [this].concat(args)); - this.type = "empty-args"; + _CompiledArgs.call(this, _glimmerRuntimeLibCompiledExpressionsPositionalArgs.COMPILED_EMPTY_POSITIONAL_ARGS, _glimmerRuntimeLibCompiledExpressionsNamedArgs.COMPILED_EMPTY_NAMED_ARGS); } _class.prototype.evaluate = function evaluate(vm) { - return EvaluatedArgs.empty(); + return EMPTY_EVALUATED_ARGS; }; return _class; })(CompiledArgs))(); - exports.COMPILED_EMPTY_ARGS = COMPILED_EMPTY_ARGS; var EvaluatedArgs = (function () { - function EvaluatedArgs() { - _classCallCheck(this, EvaluatedArgs); + function EvaluatedArgs(positional, named) { + this.positional = positional; + this.named = named; + this.tag = _glimmerReference.combineTagged([positional, named]); } EvaluatedArgs.empty = function empty() { return EMPTY_EVALUATED_ARGS; }; - EvaluatedArgs.create = function create(options) { - return new NonEmptyEvaluatedArgs(options); + EvaluatedArgs.create = function create(positional, named) { + return new this(positional, named); }; EvaluatedArgs.positional = function positional(values) { - return new NonEmptyEvaluatedArgs({ positional: _glimmerRuntimeLibCompiledExpressionsPositionalArgs.EvaluatedPositionalArgs.create({ values: values }), named: _glimmerRuntimeLibCompiledExpressionsNamedArgs.EvaluatedNamedArgs.empty() }); + return new this(_glimmerRuntimeLibCompiledExpressionsPositionalArgs.EvaluatedPositionalArgs.create(values), _glimmerRuntimeLibCompiledExpressionsNamedArgs.EVALUATED_EMPTY_NAMED_ARGS); }; - EvaluatedArgs.prototype.withInternal = function withInternal() { - if (!this.internal) { - this.internal = _glimmerUtil.dict(); - } - return this; + EvaluatedArgs.named = function named(map) { + return new this(_glimmerRuntimeLibCompiledExpressionsPositionalArgs.EVALUATED_EMPTY_POSITIONAL_ARGS, _glimmerRuntimeLibCompiledExpressionsNamedArgs.EvaluatedNamedArgs.create(map)); }; return EvaluatedArgs; })(); exports.EvaluatedArgs = EvaluatedArgs; - var NonEmptyEvaluatedArgs = (function (_EvaluatedArgs) { - _inherits(NonEmptyEvaluatedArgs, _EvaluatedArgs); - - function NonEmptyEvaluatedArgs(_ref3) { - var positional = _ref3.positional; - var named = _ref3.named; - - _classCallCheck(this, NonEmptyEvaluatedArgs); - - _EvaluatedArgs.call(this); - this.tag = _glimmerReference.combine([positional.tag, named.tag]); - this.positional = positional; - this.named = named; - this.internal = null; - } - - return NonEmptyEvaluatedArgs; - })(EvaluatedArgs); - - var EMPTY_EVALUATED_ARGS = new ((function (_EvaluatedArgs2) { - _inherits(_class2, _EvaluatedArgs2); - - function _class2() { - _classCallCheck(this, _class2); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _EvaluatedArgs2.call.apply(_EvaluatedArgs2, [this].concat(args)); - this.tag = _glimmerReference.CONSTANT_TAG; - this.positional = _glimmerRuntimeLibCompiledExpressionsPositionalArgs.EVALUATED_EMPTY_POSITIONAL_ARGS; - this.named = _glimmerRuntimeLibCompiledExpressionsNamedArgs.EVALUATED_EMPTY_NAMED_ARGS; - this.internal = null; - } - - _class2.prototype.withInternal = function withInternal() { - var args = new NonEmptyEvaluatedArgs(this); - args.internal = _glimmerUtil.dict(); - return args; - }; - - return _class2; - })(EvaluatedArgs))(); - exports.EMPTY_EVALUATED_ARGS = EMPTY_EVALUATED_ARGS; + var EMPTY_EVALUATED_ARGS = new EvaluatedArgs(_glimmerRuntimeLibCompiledExpressionsPositionalArgs.EVALUATED_EMPTY_POSITIONAL_ARGS, _glimmerRuntimeLibCompiledExpressionsNamedArgs.EVALUATED_EMPTY_NAMED_ARGS); exports.CompiledPositionalArgs = _glimmerRuntimeLibCompiledExpressionsPositionalArgs.CompiledPositionalArgs; exports.EvaluatedPositionalArgs = _glimmerRuntimeLibCompiledExpressionsPositionalArgs.EvaluatedPositionalArgs; exports.CompiledNamedArgs = _glimmerRuntimeLibCompiledExpressionsNamedArgs.CompiledNamedArgs; exports.EvaluatedNamedArgs = _glimmerRuntimeLibCompiledExpressionsNamedArgs.EvaluatedNamedArgs; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/expressions/args.ts"],"names":[],"mappings":";;;;;;;;;QAYA,YAAA;iBAAA,YAAA;kCAAA,YAAA;;;AAAA,oBAAA,CAKS,MAAM,GAAA,gBAAC,IAAyC,EAAA;gBAAvC,UAAU,GAAZ,IAAyC,CAAvC,UAAU;gBAAE,KAAK,GAAnB,IAAyC,CAA3B,KAAK;;AAC/B,gBAAI,UAAU,yDAlBT,8BAA8B,AAkBc,IAAI,KAAK,oDAjBrD,yBAAyB,AAiB2D,EAAE;AACzF,uBAAO,mBAAmB,CAAC;aAC5B,MAAM;AACL,uBAAO,IAAI,oBAAoB,CAAC,EAAE,UAAU,EAAV,UAAU,EAAE,KAAK,EAAL,KAAK,EAAE,CAAC,CAAC;aACxD;SACF;;AAXH,oBAAA,CAaS,KAAK,GAAA,iBAAA;AACV,mBAAO,mBAAmB,CAAC;SAC5B;;eAfH,YAAA;;;;;QAoBA,oBAAA;kBAAA,oBAAA;;AAKE,iBALF,oBAAA,CAKc,KAAyC,EAAA;gBAAvC,UAAU,GAAZ,KAAyC,CAAvC,UAAU;gBAAE,KAAK,GAAnB,KAAyC,CAA3B,KAAK;;kCALjC,oBAAA;;AAMI,oCAAO,CAAC;AALH,gBAAA,CAAA,IAAI,GAAG,MAAM,CAAC;AAMnB,gBAAI,CAAC,UAAU,GAAG,UAAU,CAAC;AAC7B,gBAAI,CAAC,KAAK,GAAG,KAAK,CAAC;SACpB;;AATH,4BAAA,WAWE,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,mBAAO,aAAa,CAAC,MAAM,CAAC;AAC1B,0BAAU,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;AACxC,qBAAK,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;aAC/B,CAAC,CAAC;SACJ;;eAhBH,oBAAA;OAAmC,YAAY;;AAmBxC,QAAM,mBAAmB,GAAG;;;AAAK,0BAAA;;;8CAAA,IAAA;AAAA,oBAAA;;;AAAc,oEAAA,IAAA,EAAA,CAAY;AACzD,gBAAA,CAAA,IAAI,GAAG,YAAY,CAAC;SAK5B;;yBAHC,QAAQ,GAAA,kBAAC,EAAE,EAAA;AACT,mBAAO,aAAa,CAAC,KAAK,EAAE,CAAC;SAC9B;;;OALmD,YAAY,IAMhE,CAAC;;;QAOH,aAAA;iBAAA,aAAA;kCAAA,aAAA;;;AAAA,qBAAA,CAGS,KAAK,GAAA,iBAAA;AACV,mBAAO,oBAAoB,CAAC;SAC7B;;AALH,qBAAA,CAOS,MAAM,GAAA,gBAAC,OAA6B,EAAA;AACzC,mBAAO,IAAI,qBAAqB,CAAC,OAAO,CAAC,CAAC;SAC3C;;AATH,qBAAA,CAWS,UAAU,GAAA,oBAAC,MAA4B,EAAA;AAC5C,mBAAO,IAAI,qBAAqB,CAAC,EAAE,UAAU,EAAE,oDA5E+C,uBAAuB,CA4E9C,MAAM,CAAC,EAAE,MAAM,EAAN,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,+CA3EnB,kBAAkB,CA2EoB,KAAK,EAAE,EAAE,CAAC,CAAC;SACjI;;AAbH,qBAAA,WAqBS,YAAY,GAAA,wBAAA;AACjB,gBAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;AAClB,oBAAI,CAAC,QAAQ,GAAG,aAlFP,IAAI,EAkFiB,CAAC;aAChC;AACD,mBAAO,IAAI,CAAC;SACb;;eA1BH,aAAA;;;;;QA6BA,qBAAA;kBAAA,qBAAA;;AACE,iBADF,qBAAA,CACc,KAA2C,EAAA;gBAAzC,UAAU,GAAZ,KAA2C,CAAzC,UAAU;gBAAE,KAAK,GAAnB,KAA2C,CAA7B,KAAK;;kCADjC,qBAAA;;AAEI,qCAAO,CAAC;AACR,gBAAI,CAAC,GAAG,GAAG,kBA5FoC,OAAO,CA4FnC,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAChD,gBAAI,CAAC,UAAU,GAAG,UAAU,CAAC;AAC7B,gBAAI,CAAC,KAAK,GAAG,KAAK,CAAC;AACnB,gBAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;SACtB;;eAPH,qBAAA;OAAoC,aAAa;;AAU1C,QAAM,oBAAoB,GAAG;;;AAAK,2BAAA;;;+CAAA,IAAA;AAAA,oBAAA;;;AAAc,sEAAA,IAAA,EAAA,CAAa;AAC3D,gBAAA,CAAA,GAAG,qBApGH,YAAY,AAoGM,CAAC;AACnB,gBAAA,CAAA,UAAU,uDAzGsB,+BAA+B,AAyGnB,CAAC;AAC7C,gBAAA,CAAA,KAAK,kDAzGsB,0BAA0B,AAyGnB,CAAC;AACnC,gBAAA,CAAA,QAAQ,GAAG,IAAI,CAAC;SAOxB;;0BALQ,YAAY,GAAA,wBAAA;AACjB,gBAAI,IAAI,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,CAAC;AAC3C,gBAAI,CAAC,QAAQ,GAAG,aA1GL,IAAI,EA0Ge,CAAC;AAC/B,mBAAO,IAAI,CAAC;SACb;;;OAVoD,aAAa,IAWlE,CAAC;;YAEM,sBAAsB,uDApH2C,sBAAsB;YAoH/D,uBAAuB,uDApH0C,uBAAuB;YAoH/D,iBAAiB,kDAnHX,iBAAiB;YAmHJ,kBAAkB,kDAnHZ,kBAAkB","file":"args.js","sourcesContent":["import { COMPILED_EMPTY_POSITIONAL_ARGS, EVALUATED_EMPTY_POSITIONAL_ARGS, CompiledPositionalArgs, EvaluatedPositionalArgs } from './positional-args';\nimport { COMPILED_EMPTY_NAMED_ARGS, EVALUATED_EMPTY_NAMED_ARGS, CompiledNamedArgs, EvaluatedNamedArgs } from './named-args';\nimport VM from '../../vm/append';\nimport { Block  } from '../blocks';\nimport { CONSTANT_TAG, RevisionTag, PathReference, combine } from 'glimmer-reference';\nimport { Dict, dict, Opaque } from 'glimmer-util';\n\ninterface CompiledArgOptions {\n  positional: CompiledPositionalArgs;\n  named: CompiledNamedArgs;\n}\n\nexport abstract class CompiledArgs {\n  public type: string;\n  public positional: CompiledPositionalArgs;\n  public named: CompiledNamedArgs;\n\n  static create({ positional, named }: CompiledArgOptions): CompiledArgs {\n    if (positional === COMPILED_EMPTY_POSITIONAL_ARGS && named ===  COMPILED_EMPTY_NAMED_ARGS) {\n      return COMPILED_EMPTY_ARGS;\n    } else {\n      return new CompiledNonEmptyArgs({ positional, named });\n    }\n  }\n\n  static empty(): CompiledArgs {\n    return COMPILED_EMPTY_ARGS;\n  }\n\n  abstract evaluate(vm: VM): EvaluatedArgs;\n}\n\nclass CompiledNonEmptyArgs extends CompiledArgs {\n  public type = \"args\";\n  public positional: CompiledPositionalArgs;\n  public named: CompiledNamedArgs;\n\n  constructor({ positional, named }: CompiledArgOptions) {\n    super();\n    this.positional = positional;\n    this.named = named;\n  }\n\n  evaluate(vm: VM): EvaluatedArgs {\n    return EvaluatedArgs.create({\n      positional: this.positional.evaluate(vm),\n      named: this.named.evaluate(vm)\n    });\n  }\n}\n\nexport const COMPILED_EMPTY_ARGS = new (class extends CompiledArgs {\n  public type = \"empty-args\";\n\n  evaluate(vm): EvaluatedArgs {\n    return EvaluatedArgs.empty();\n  }\n});\n\ninterface EvaluatedArgsOptions {\n  positional: EvaluatedPositionalArgs;\n  named: EvaluatedNamedArgs;\n}\n\nexport abstract class EvaluatedArgs {\n  public tag: RevisionTag;\n\n  static empty(): EvaluatedArgs {\n    return EMPTY_EVALUATED_ARGS;\n  }\n\n  static create(options: EvaluatedArgsOptions): EvaluatedArgs {\n    return new NonEmptyEvaluatedArgs(options);\n  }\n\n  static positional(values: PathReference<any>[]): EvaluatedArgs {\n    return new NonEmptyEvaluatedArgs({ positional: EvaluatedPositionalArgs.create({ values }), named: EvaluatedNamedArgs.empty() });\n  }\n\n  public type: string;\n  public positional: EvaluatedPositionalArgs;\n  public named: EvaluatedNamedArgs;\n  public blocks: Block[];\n  public internal: Dict<Opaque>;\n\n  public withInternal(): EvaluatedArgs {\n    if (!this.internal) {\n      this.internal = dict<Opaque>();\n    }\n    return this;\n  }\n}\n\nclass NonEmptyEvaluatedArgs extends EvaluatedArgs {\n  constructor({ positional, named }: EvaluatedArgsOptions) {\n    super();\n    this.tag = combine([positional.tag, named.tag]);\n    this.positional = positional;\n    this.named = named;\n    this.internal = null;\n  }\n}\n\nexport const EMPTY_EVALUATED_ARGS = new (class extends EvaluatedArgs {\n  public tag = CONSTANT_TAG;\n  public positional = EVALUATED_EMPTY_POSITIONAL_ARGS;\n  public named = EVALUATED_EMPTY_NAMED_ARGS;\n  public internal = null;\n\n  public withInternal(): EvaluatedArgs {\n    let args = new NonEmptyEvaluatedArgs(this);\n    args.internal = dict<Opaque>();\n    return args;\n  }\n});\n\nexport { CompiledPositionalArgs, EvaluatedPositionalArgs, CompiledNamedArgs, EvaluatedNamedArgs };\n"]} +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/compiled/expressions/concat', ['exports', 'glimmer-runtime/lib/compiled/opcodes/content', 'glimmer-reference'], function (exports, _glimmerRuntimeLibCompiledOpcodesContent, _glimmerReference) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var CompiledConcat = (function () { function CompiledConcat(_ref) { var parts = _ref.parts; - _classCallCheck(this, CompiledConcat); - this.type = "concat"; this.parts = parts; } CompiledConcat.prototype.evaluate = function evaluate(vm) { @@ -14857,15 +15670,13 @@ })(); exports.default = CompiledConcat; var ConcatReference = (function (_CachedReference) { - _inherits(ConcatReference, _CachedReference); + babelHelpers.inherits(ConcatReference, _CachedReference); function ConcatReference(parts) { - _classCallCheck(this, ConcatReference); - _CachedReference.call(this); this.tag = _glimmerReference.combineTagged(parts); this.parts = parts; } @@ -14878,59 +15689,52 @@ }; return ConcatReference; })(_glimmerReference.CachedReference); }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/compiled/expressions/function', ['exports', 'glimmer-runtime/lib/syntax', 'glimmer-runtime/lib/compiled/expressions'], function (exports, _glimmerRuntimeLibSyntax, _glimmerRuntimeLibCompiledExpressions) { 'use strict'; exports.default = make; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - function make(func) { return new FunctionExpressionSyntax(func); } var FunctionExpressionSyntax = (function (_ExpressionSyntax) { - _inherits(FunctionExpressionSyntax, _ExpressionSyntax); + babelHelpers.inherits(FunctionExpressionSyntax, _ExpressionSyntax); function FunctionExpressionSyntax(func) { - _classCallCheck(this, FunctionExpressionSyntax); - _ExpressionSyntax.call(this); this.type = "function-expression"; this.func = func; } - FunctionExpressionSyntax.prototype.compile = function compile() { - return new CompiledFunctionExpression(this.func); + FunctionExpressionSyntax.prototype.compile = function compile(lookup, env, symbolTable) { + return new CompiledFunctionExpression(this.func, symbolTable); }; return FunctionExpressionSyntax; })(_glimmerRuntimeLibSyntax.Expression); var CompiledFunctionExpression = (function (_CompiledExpression) { - _inherits(CompiledFunctionExpression, _CompiledExpression); + babelHelpers.inherits(CompiledFunctionExpression, _CompiledExpression); - function CompiledFunctionExpression(func) { - _classCallCheck(this, CompiledFunctionExpression); - + function CompiledFunctionExpression(func, symbolTable) { _CompiledExpression.call(this); + this.func = func; + this.symbolTable = symbolTable; this.type = "function"; this.func = func; } CompiledFunctionExpression.prototype.evaluate = function evaluate(vm) { var func = this.func; + var symbolTable = this.symbolTable; - return func(vm); + return func(vm, symbolTable); }; CompiledFunctionExpression.prototype.toJSON = function toJSON() { var func = this.func; @@ -14942,29 +15746,21 @@ }; return CompiledFunctionExpression; })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/compiled/expressions/has-block-params', ['exports', 'glimmer-runtime/lib/compiled/expressions', 'glimmer-runtime/lib/compiled/expressions/value'], function (exports, _glimmerRuntimeLibCompiledExpressions, _glimmerRuntimeLibCompiledExpressionsValue) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var CompiledHasBlockParams = (function (_CompiledExpression) { - _inherits(CompiledHasBlockParams, _CompiledExpression); + babelHelpers.inherits(CompiledHasBlockParams, _CompiledExpression); function CompiledHasBlockParams(_ref) { var blockName = _ref.blockName; var blockSymbol = _ref.blockSymbol; - _classCallCheck(this, CompiledHasBlockParams); - _CompiledExpression.call(this); this.type = "has-block-params"; this.blockName = blockName; this.blockSymbol = blockSymbol; } @@ -14981,29 +15777,21 @@ return CompiledHasBlockParams; })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); exports.default = CompiledHasBlockParams; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcGlsZWQvZXhwcmVzc2lvbnMvaGFzLWJsb2NrLXBhcmFtcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7UUFLQSxzQkFBQTtrQkFBQSxzQkFBQTs7QUFLRSxpQkFMRixzQkFBQSxDQUtjLElBQThFLEVBQUE7Z0JBQTVFLFNBQVMsR0FBWCxJQUE4RSxDQUE1RSxTQUFTO2dCQUFFLFdBQVcsR0FBeEIsSUFBOEUsQ0FBakUsV0FBVzs7a0NBTHRDLHNCQUFBOztBQU1JLDBDQUFPLENBQUM7QUFMSCxnQkFBQSxDQUFBLElBQUksR0FBRyxrQkFBa0IsQ0FBQztBQU0vQixnQkFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7QUFDM0IsZ0JBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1NBQ2hDOztBQVRILDhCQUFBLFdBV0UsUUFBUSxHQUFBLGtCQUFDLEVBQU0sRUFBQTtBQUNiLGdCQUFJLFFBQVEsR0FBRyxFQUFFLENBQUMsS0FBSyxFQUFFLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztBQUNyRCxtQkFBTywrQ0FoQkYsY0FBYyxDQWdCTyxDQUFDLEVBQUUsUUFBUSxJQUFJLFFBQVEsQ0FBQyxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQSxBQUFDLENBQUMsQ0FBQztTQUN2RTs7QUFkSCw4QkFBQSxXQWdCRSxNQUFNLEdBQUEsa0JBQUE7QUFDSix5Q0FBMkIsSUFBSSxDQUFDLFNBQVMsT0FBSTtTQUM5Qzs7ZUFsQkgsc0JBQUE7NkNBSlMsa0JBQWtCOztzQkFJM0Isc0JBQUEiLCJmaWxlIjoiaGFzLWJsb2NrLXBhcmFtcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBWTSBmcm9tICcuLi8uLi92bS9hcHBlbmQnO1xuaW1wb3J0IHsgQ29tcGlsZWRFeHByZXNzaW9uIH0gZnJvbSAnLi4vZXhwcmVzc2lvbnMnO1xuaW1wb3J0IHsgVmFsdWVSZWZlcmVuY2UgfSBmcm9tICcuL3ZhbHVlJztcbmltcG9ydCB7IEludGVybmVkU3RyaW5nIH0gZnJvbSAnZ2xpbW1lci11dGlsJztcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQ29tcGlsZWRIYXNCbG9ja1BhcmFtcyBleHRlbmRzIENvbXBpbGVkRXhwcmVzc2lvbjxib29sZWFuPiB7XG4gIHB1YmxpYyB0eXBlID0gXCJoYXMtYmxvY2stcGFyYW1zXCI7XG4gIHB1YmxpYyBibG9ja05hbWU6IEludGVybmVkU3RyaW5nO1xuICBwdWJsaWMgYmxvY2tTeW1ib2w6IG51bWJlcjtcblxuICBjb25zdHJ1Y3Rvcih7IGJsb2NrTmFtZSwgYmxvY2tTeW1ib2wgfTogeyBibG9ja05hbWU6IEludGVybmVkU3RyaW5nLCBibG9ja1N5bWJvbDogbnVtYmVyIH0pIHtcbiAgICBzdXBlcigpO1xuICAgIHRoaXMuYmxvY2tOYW1lID0gYmxvY2tOYW1lO1xuICAgIHRoaXMuYmxvY2tTeW1ib2wgPSBibG9ja1N5bWJvbDtcbiAgfVxuXG4gIGV2YWx1YXRlKHZtOiBWTSk6IFZhbHVlUmVmZXJlbmNlPGJvb2xlYW4+IHtcbiAgICBsZXQgYmxvY2tSZWYgPSB2bS5zY29wZSgpLmdldEJsb2NrKHRoaXMuYmxvY2tTeW1ib2wpO1xuICAgIHJldHVybiBuZXcgVmFsdWVSZWZlcmVuY2UoISEoYmxvY2tSZWYgJiYgYmxvY2tSZWYubG9jYWxzLmxlbmd0aCA+IDApKTtcbiAgfVxuXG4gIHRvSlNPTigpOiBzdHJpbmcge1xuICAgIHJldHVybiBgaGFzLWJsb2NrLXBhcmFtcygke3RoaXMuYmxvY2tOYW1lfSlgO1xuICB9XG59XG4iXX0= +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/compiled/expressions/has-block', ['exports', 'glimmer-runtime/lib/compiled/expressions', 'glimmer-runtime/lib/compiled/expressions/value'], function (exports, _glimmerRuntimeLibCompiledExpressions, _glimmerRuntimeLibCompiledExpressionsValue) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var CompiledHasBlock = (function (_CompiledExpression) { - _inherits(CompiledHasBlock, _CompiledExpression); + babelHelpers.inherits(CompiledHasBlock, _CompiledExpression); function CompiledHasBlock(_ref) { var blockName = _ref.blockName; var blockSymbol = _ref.blockSymbol; - _classCallCheck(this, CompiledHasBlock); - _CompiledExpression.call(this); this.type = "has-block"; this.blockName = blockName; this.blockSymbol = blockSymbol; } @@ -15020,41 +15808,30 @@ return CompiledHasBlock; })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); exports.default = CompiledHasBlock; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcGlsZWQvZXhwcmVzc2lvbnMvaGFzLWJsb2NrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztRQUljLGdCQUF3Qjs4QkFBeEIsZ0JBQXdCOztBQUtwQyxpQkFMWSxnQkFBd0IsQ0FLeEIsSUFBc0UsRUFBQTtnQkFBcEUsU0FBUyxHQUFYLElBQXNFLENBQXBFLFNBQVM7Z0JBQUUsV0FBVyxHQUF4QixJQUFzRSxDQUF6RCxXQUFXOztBQUNsQywwQ0FBTyxDQUFDO0FBTEgsZ0JBQUEsQ0FBQSxJQUFJLEdBQUcsV0FBVyxDQUFDO0FBTXhCLGdCQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztBQUMzQixnQkFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7U0FDaEM7O0FBVFcsd0JBQXdCLFdBV3BDLFFBQVEsR0FBQSxrQkFBQyxFQUFNLEVBQUE7QUFDYixnQkFBSSxRQUFRLEdBQUcsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7QUFDckQsbUJBQU8sK0NBZkYsY0FBYyxDQWVPLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQztTQUN2Qzs7QUFkVyx3QkFBd0IsV0FnQnBDLE1BQU0sR0FBQSxrQkFBQTtBQUNKLGtDQUFvQixJQUFJLENBQUMsU0FBUyxPQUFJO1NBQ3ZDOztlQWxCVyxnQkFBd0I7NkNBSDdCLGtCQUFrQjs7c0JBR2IsZ0JBQXdCIiwiZmlsZSI6Imhhcy1ibG9jay5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBWTSBmcm9tICcuLi8uLi92bS9hcHBlbmQnO1xuaW1wb3J0IHsgQ29tcGlsZWRFeHByZXNzaW9uIH0gZnJvbSAnLi4vZXhwcmVzc2lvbnMnO1xuaW1wb3J0IHsgVmFsdWVSZWZlcmVuY2UgfSBmcm9tICcuL3ZhbHVlJztcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQ29tcGlsZWRIYXNCbG9jayBleHRlbmRzIENvbXBpbGVkRXhwcmVzc2lvbjxib29sZWFuPiB7XG4gIHB1YmxpYyB0eXBlID0gXCJoYXMtYmxvY2tcIjtcbiAgcHVibGljIGJsb2NrTmFtZTogc3RyaW5nO1xuICBwdWJsaWMgYmxvY2tTeW1ib2w6IG51bWJlcjtcblxuICBjb25zdHJ1Y3Rvcih7IGJsb2NrTmFtZSwgYmxvY2tTeW1ib2wgfTogeyBibG9ja05hbWU6IHN0cmluZywgYmxvY2tTeW1ib2w6IG51bWJlciB9KSB7XG4gICAgc3VwZXIoKTtcbiAgICB0aGlzLmJsb2NrTmFtZSA9IGJsb2NrTmFtZTtcbiAgICB0aGlzLmJsb2NrU3ltYm9sID0gYmxvY2tTeW1ib2w7XG4gIH1cblxuICBldmFsdWF0ZSh2bTogVk0pOiBWYWx1ZVJlZmVyZW5jZTxib29sZWFuPiB7XG4gICAgbGV0IGJsb2NrUmVmID0gdm0uc2NvcGUoKS5nZXRCbG9jayh0aGlzLmJsb2NrU3ltYm9sKTtcbiAgICByZXR1cm4gbmV3IFZhbHVlUmVmZXJlbmNlKCEhYmxvY2tSZWYpO1xuICB9XG5cbiAgdG9KU09OKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIGBoYXMtYmxvY2soJHt0aGlzLmJsb2NrTmFtZX0pYDtcbiAgfVxufVxuIl19 enifed('glimmer-runtime/lib/compiled/expressions/helper', ['exports', 'glimmer-runtime/lib/compiled/expressions'], function (exports, _glimmerRuntimeLibCompiledExpressions) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var CompiledHelper = (function (_CompiledExpression) { - _inherits(CompiledHelper, _CompiledExpression); + babelHelpers.inherits(CompiledHelper, _CompiledExpression); - function CompiledHelper(_ref) { - var name = _ref.name; - var helper = _ref.helper; - var args = _ref.args; - - _classCallCheck(this, CompiledHelper); - + function CompiledHelper(name, helper, args, symbolTable) { _CompiledExpression.call(this); - this.type = "helper"; this.name = name; this.helper = helper; this.args = args; + this.symbolTable = symbolTable; + this.type = "helper"; } CompiledHelper.prototype.evaluate = function evaluate(vm) { var helper = this.helper; - return helper(vm, this.args.evaluate(vm)); + return helper(vm, this.args.evaluate(vm), this.symbolTable); }; CompiledHelper.prototype.toJSON = function toJSON() { return '`' + this.name.join('.') + '($ARGS)`'; }; @@ -15062,94 +15839,136 @@ return CompiledHelper; })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); exports.default = CompiledHelper; }); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-runtime/lib/compiled/expressions/named-args', ['exports', 'glimmer-runtime/lib/references', 'glimmer-reference', 'glimmer-util'], function (exports, _glimmerRuntimeLibReferences, _glimmerReference, _glimmerUtil) { +//# sourceMappingURL=data:application/json;base64,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 +enifed('glimmer-runtime/lib/compiled/expressions/lookups', ['exports', 'glimmer-runtime/lib/compiled/expressions', 'glimmer-reference'], function (exports, _glimmerRuntimeLibCompiledExpressions, _glimmerReference) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + var CompiledLocalLookup = (function (_CompiledExpression) { + babelHelpers.inherits(CompiledLocalLookup, _CompiledExpression); - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - var CompiledNamedArgs = (function () { - function CompiledNamedArgs() { - _classCallCheck(this, CompiledNamedArgs); + function CompiledLocalLookup(symbol, path, debug) { + _CompiledExpression.call(this); + this.symbol = symbol; + this.path = path; + this.debug = debug; + this.type = "local-lookup"; } - CompiledNamedArgs.create = function create(_ref) { - var map = _ref.map; + CompiledLocalLookup.prototype.evaluate = function evaluate(vm) { + var base = vm.referenceForSymbol(this.symbol); + return _glimmerReference.referenceFromParts(base, this.path); + }; - if (Object.keys(map).length) { - return new CompiledNonEmptyNamedArgs({ map: map }); + CompiledLocalLookup.prototype.toJSON = function toJSON() { + var debug = this.debug; + var symbol = this.symbol; + var path = this.path; + + if (path.length) { + return '$' + symbol + '(' + debug + ').' + path.join('.'); } else { - return COMPILED_EMPTY_NAMED_ARGS; + return '$' + symbol + '(' + debug + ')'; } }; - return CompiledNamedArgs; - })(); + return CompiledLocalLookup; + })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); - exports.CompiledNamedArgs = CompiledNamedArgs; + exports.CompiledLocalLookup = CompiledLocalLookup; - var CompiledNonEmptyNamedArgs = (function (_CompiledNamedArgs) { - _inherits(CompiledNonEmptyNamedArgs, _CompiledNamedArgs); + var CompiledSelfLookup = (function (_CompiledExpression2) { + babelHelpers.inherits(CompiledSelfLookup, _CompiledExpression2); - function CompiledNonEmptyNamedArgs(_ref2) { - var map = _ref2.map; + function CompiledSelfLookup(parts) { + _CompiledExpression2.call(this); + this.parts = parts; + this.type = "self-lookup"; + } - _classCallCheck(this, CompiledNonEmptyNamedArgs); + CompiledSelfLookup.prototype.evaluate = function evaluate(vm) { + return _glimmerReference.referenceFromParts(vm.getSelf(), this.parts); + }; - _CompiledNamedArgs.call(this); - this.type = "named-args"; - this.map = map; + CompiledSelfLookup.prototype.toJSON = function toJSON() { + var path = ['self']; + path.push.apply(path, this.parts); + return path.join('.'); + }; + + return CompiledSelfLookup; + })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); + + exports.CompiledSelfLookup = CompiledSelfLookup; +}); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcGlsZWQvZXhwcmVzc2lvbnMvbG9va3Vwcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7UUFLTSxtQkFBMkI7OEJBQTNCLG1CQUEyQjs7QUFHL0IsaUJBSEksbUJBQTJCLENBSXJCLE1BQWMsRUFDZCxJQUFjLEVBQ2QsS0FBYSxFQUFBO0FBRXJCLDBDQUFPLENBQUM7QUFKQSxnQkFBQSxDQUFBLE1BQU0sR0FBTixNQUFNLENBQVE7QUFDZCxnQkFBQSxDQUFBLElBQUksR0FBSixJQUFJLENBQVU7QUFDZCxnQkFBQSxDQUFBLEtBQUssR0FBTCxLQUFLLENBQVE7QUFMaEIsZ0JBQUEsQ0FBQSxJQUFJLEdBQUcsY0FBYyxDQUFDO1NBUTVCOztBQVRHLDJCQUEyQixXQVcvQixRQUFRLEdBQUEsa0JBQUMsRUFBTSxFQUFBO0FBQ2IsZ0JBQUksSUFBSSxHQUFHLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDOUMsbUJBQU8sa0JBZkYsa0JBQWtCLENBZUcsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUM1Qzs7QUFkRywyQkFBMkIsV0FnQi9CLE1BQU0sR0FBQSxrQkFBQTtnQkFDRSxLQUFLLEdBQW1CLElBQUksQ0FBNUIsS0FBSztnQkFBRSxNQUFNLEdBQVcsSUFBSSxDQUFyQixNQUFNO2dCQUFFLElBQUksR0FBSyxJQUFJLENBQWIsSUFBSTs7QUFFekIsZ0JBQUksSUFBSSxDQUFDLE1BQU0sRUFBRTtBQUNmLDZCQUFXLE1BQU0sU0FBSSxLQUFLLFVBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBRzthQUNqRCxNQUFNO0FBQ0wsNkJBQVcsTUFBTSxTQUFJLEtBQUssT0FBSTthQUMvQjtTQUNGOztlQXhCRyxtQkFBMkI7NkNBTHhCLGtCQUFrQjs7OztRQWdDckIsa0JBQTBCOzhCQUExQixrQkFBMEI7O0FBRzlCLGlCQUhJLGtCQUEwQixDQUdWLEtBQWUsRUFBQTtBQUNqQywyQ0FBTyxDQUFDO0FBRFUsZ0JBQUEsQ0FBQSxLQUFLLEdBQUwsS0FBSyxDQUFVO0FBRjVCLGdCQUFBLENBQUEsSUFBSSxHQUFHLGFBQWEsQ0FBQztTQUkzQjs7QUFMRywwQkFBMEIsV0FPOUIsUUFBUSxHQUFBLGtCQUFDLEVBQU0sRUFBQTtBQUNiLG1CQUFPLGtCQXJDRixrQkFBa0IsQ0FxQ0csRUFBRSxDQUFDLE9BQU8sRUFBRSxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztTQUNyRDs7QUFURywwQkFBMEIsV0FXOUIsTUFBTSxHQUFBLGtCQUFBO0FBQ0osZ0JBQUksSUFBSSxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDcEIsZ0JBQUksQ0FBQyxJQUFJLE1BQUEsQ0FBVCxJQUFJLEVBQVMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ3pCLG1CQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7U0FDdkI7O2VBZkcsa0JBQTBCOzZDQWhDdkIsa0JBQWtCIiwiZmlsZSI6Imxvb2t1cHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21waWxlZEV4cHJlc3Npb24gfSBmcm9tICcuLi9leHByZXNzaW9ucyc7XG5pbXBvcnQgVk0gZnJvbSAnLi4vLi4vdm0vYXBwZW5kJztcbmltcG9ydCB7IFBhdGhSZWZlcmVuY2UgfSBmcm9tICdnbGltbWVyLXJlZmVyZW5jZSc7XG5pbXBvcnQgeyByZWZlcmVuY2VGcm9tUGFydHMgfSBmcm9tICdnbGltbWVyLXJlZmVyZW5jZSc7XG5cbmV4cG9ydCBjbGFzcyBDb21waWxlZExvY2FsTG9va3VwIGV4dGVuZHMgQ29tcGlsZWRFeHByZXNzaW9uPGFueT4ge1xuICBwdWJsaWMgdHlwZSA9IFwibG9jYWwtbG9va3VwXCI7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBzeW1ib2w6IG51bWJlcixcbiAgICBwcml2YXRlIHBhdGg6IHN0cmluZ1tdLFxuICAgIHByaXZhdGUgZGVidWc6IHN0cmluZ1xuICApIHtcbiAgICBzdXBlcigpO1xuICB9XG5cbiAgZXZhbHVhdGUodm06IFZNKTogUGF0aFJlZmVyZW5jZTxhbnk+IHtcbiAgICBsZXQgYmFzZSA9IHZtLnJlZmVyZW5jZUZvclN5bWJvbCh0aGlzLnN5bWJvbCk7XG4gICAgcmV0dXJuIHJlZmVyZW5jZUZyb21QYXJ0cyhiYXNlLCB0aGlzLnBhdGgpO1xuICB9XG5cbiAgdG9KU09OKCk6IHN0cmluZyB7XG4gICAgbGV0IHsgZGVidWcsIHN5bWJvbCwgcGF0aCB9ID0gdGhpcztcblxuICAgIGlmIChwYXRoLmxlbmd0aCkge1xuICAgICAgcmV0dXJuIGAkJHtzeW1ib2x9KCR7ZGVidWd9KS4ke3BhdGguam9pbignLicpfWA7XG4gICAgfSBlbHNlIHtcbiAgICAgIHJldHVybiBgJCR7c3ltYm9sfSgke2RlYnVnfSlgO1xuICAgIH1cbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgQ29tcGlsZWRTZWxmTG9va3VwIGV4dGVuZHMgQ29tcGlsZWRFeHByZXNzaW9uPGFueT4ge1xuICBwdWJsaWMgdHlwZSA9IFwic2VsZi1sb29rdXBcIjtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHBhcnRzOiBzdHJpbmdbXSkge1xuICAgIHN1cGVyKCk7XG4gIH1cblxuICBldmFsdWF0ZSh2bTogVk0pOiBQYXRoUmVmZXJlbmNlPGFueT4ge1xuICAgIHJldHVybiByZWZlcmVuY2VGcm9tUGFydHModm0uZ2V0U2VsZigpLCB0aGlzLnBhcnRzKTtcbiAgfVxuXG4gIHRvSlNPTigpOiBzdHJpbmcge1xuICAgIGxldCBwYXRoID0gWydzZWxmJ107XG4gICAgcGF0aC5wdXNoKC4uLnRoaXMucGFydHMpO1xuICAgIHJldHVybiBwYXRoLmpvaW4oJy4nKTtcbiAgfVxufVxuIl19 +enifed('glimmer-runtime/lib/compiled/expressions/named-args', ['exports', 'glimmer-runtime/lib/references', 'glimmer-runtime/lib/utils', 'glimmer-reference', 'glimmer-util'], function (exports, _glimmerRuntimeLibReferences, _glimmerRuntimeLibUtils, _glimmerReference, _glimmerUtil) { + 'use strict'; + + var CompiledNamedArgs = (function () { + function CompiledNamedArgs(keys, values) { + this.keys = keys; + this.values = values; + this.length = keys.length; + _glimmerUtil.assert(keys.length === values.length, 'Keys and values do not have the same length'); } - CompiledNonEmptyNamedArgs.prototype.evaluate = function evaluate(vm) { - var map = this.map; + CompiledNamedArgs.empty = function empty() { + return COMPILED_EMPTY_NAMED_ARGS; + }; - var compiledMap = _glimmerUtil.dict(); - var compiledKeys = Object.keys(map); - for (var i = 0; i < compiledKeys.length; i++) { - var key = compiledKeys[i]; - compiledMap[key] = map[key].evaluate(vm); + CompiledNamedArgs.create = function create(map) { + var keys = Object.keys(map); + var length = keys.length; + if (length > 0) { + var values = []; + for (var i = 0; i < length; i++) { + values[i] = map[keys[i]]; + } + return new this(keys, values); + } else { + return COMPILED_EMPTY_NAMED_ARGS; } - return EvaluatedNamedArgs.create({ map: compiledMap }); }; - CompiledNonEmptyNamedArgs.prototype.toJSON = function toJSON() { - var map = this.map; + CompiledNamedArgs.prototype.evaluate = function evaluate(vm) { + var keys = this.keys; + var values = this.values; + var length = this.length; - var inner = Object.keys(map).map(function (key) { - return key + ': ' + map[key].toJSON(); + var evaluated = new Array(length); + for (var i = 0; i < length; i++) { + evaluated[i] = values[i].evaluate(vm); + } + return new EvaluatedNamedArgs(keys, evaluated); + }; + + CompiledNamedArgs.prototype.toJSON = function toJSON() { + var keys = this.keys; + var values = this.values; + + var inner = keys.map(function (key, i) { + return key + ': ' + values[i].toJSON(); }).join(", "); return '{' + inner + '}'; }; - return CompiledNonEmptyNamedArgs; - })(CompiledNamedArgs); + return CompiledNamedArgs; + })(); - var COMPILED_EMPTY_NAMED_ARGS = new ((function (_CompiledNamedArgs2) { - _inherits(_class, _CompiledNamedArgs2); + exports.CompiledNamedArgs = CompiledNamedArgs; + var COMPILED_EMPTY_NAMED_ARGS = new ((function (_CompiledNamedArgs) { + babelHelpers.inherits(_class, _CompiledNamedArgs); function _class() { - _classCallCheck(this, _class); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _CompiledNamedArgs2.call.apply(_CompiledNamedArgs2, [this].concat(args)); - this.type = "empty-named-args"; - this.map = _glimmerUtil.dict(); + _CompiledNamedArgs.call(this, _glimmerRuntimeLibUtils.EMPTY_ARRAY, _glimmerRuntimeLibUtils.EMPTY_ARRAY); } _class.prototype.evaluate = function evaluate(vm) { - return EvaluatedNamedArgs.empty(); + return EVALUATED_EMPTY_NAMED_ARGS; }; _class.prototype.toJSON = function toJSON() { return '<EMPTY>'; }; @@ -15157,94 +15976,92 @@ return _class; })(CompiledNamedArgs))(); exports.COMPILED_EMPTY_NAMED_ARGS = COMPILED_EMPTY_NAMED_ARGS; var EvaluatedNamedArgs = (function () { - function EvaluatedNamedArgs() { - _classCallCheck(this, EvaluatedNamedArgs); + function EvaluatedNamedArgs(keys, values) { + var _map = arguments.length <= 2 || arguments[2] === undefined ? undefined : arguments[2]; + + this.keys = keys; + this.values = values; + this._map = _map; + this.tag = _glimmerReference.combineTagged(values); + this.length = keys.length; + _glimmerUtil.assert(keys.length === values.length, 'Keys and values do not have the same length'); } + EvaluatedNamedArgs.create = function create(map) { + var keys = Object.keys(map); + var length = keys.length; + if (length > 0) { + var values = new Array(length); + for (var i = 0; i < length; i++) { + values[i] = map[keys[i]]; + } + return new this(keys, values, map); + } else { + return EVALUATED_EMPTY_NAMED_ARGS; + } + }; + EvaluatedNamedArgs.empty = function empty() { return EVALUATED_EMPTY_NAMED_ARGS; }; - EvaluatedNamedArgs.create = function create(_ref3) { - var map = _ref3.map; + EvaluatedNamedArgs.prototype.get = function get(key) { + var keys = this.keys; + var values = this.values; - return new NonEmptyEvaluatedNamedArgs({ map: map }); + var index = keys.indexOf(key); + return index === -1 ? _glimmerRuntimeLibReferences.UNDEFINED_REFERENCE : values[index]; }; - EvaluatedNamedArgs.prototype.forEach = function forEach(callback) { - var map = this.map; - - var mapKeys = Object.keys(map); - for (var i = 0; i < mapKeys.length; i++) { - var key = mapKeys[i]; - callback(key, map[key]); - } + EvaluatedNamedArgs.prototype.has = function has(key) { + return this.keys.indexOf(key) !== -1; }; - return EvaluatedNamedArgs; - })(); - - exports.EvaluatedNamedArgs = EvaluatedNamedArgs; - - var NonEmptyEvaluatedNamedArgs = (function (_EvaluatedNamedArgs) { - _inherits(NonEmptyEvaluatedNamedArgs, _EvaluatedNamedArgs); - - function NonEmptyEvaluatedNamedArgs(_ref4) { - var map = _ref4.map; - - _classCallCheck(this, NonEmptyEvaluatedNamedArgs); - - _EvaluatedNamedArgs.call(this); - var keys = this.keys = Object.keys(map); - this.map = map; - var tags = []; - for (var i = 0; i < keys.length; i++) { - var key = keys[i]; - tags.push(map[key].tag); - } - this.tag = _glimmerReference.combine(tags); - } - - NonEmptyEvaluatedNamedArgs.prototype.get = function get(key) { - return this.map[key] || _glimmerRuntimeLibReferences.UNDEFINED_REFERENCE; - }; - - NonEmptyEvaluatedNamedArgs.prototype.has = function has(key) { - return !!this.map[key]; - }; - - NonEmptyEvaluatedNamedArgs.prototype.value = function value() { - var map = this.map; + EvaluatedNamedArgs.prototype.value = function value() { var keys = this.keys; + var values = this.values; var out = _glimmerUtil.dict(); for (var i = 0; i < keys.length; i++) { var key = keys[i]; - out[key] = map[key].value(); + var ref = values[i]; + out[key] = ref.value(); } return out; }; - return NonEmptyEvaluatedNamedArgs; - })(EvaluatedNamedArgs); + babelHelpers.createClass(EvaluatedNamedArgs, [{ + key: 'map', + get: function () { + var map = this._map; - var EVALUATED_EMPTY_NAMED_ARGS = new ((function (_EvaluatedNamedArgs2) { - _inherits(_class2, _EvaluatedNamedArgs2); + if (map) { + return map; + } + map = this._map = _glimmerUtil.dict(); + var keys = this.keys; + var values = this.values; + var length = this.length; - function _class2() { - _classCallCheck(this, _class2); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; + for (var i = 0; i < length; i++) { + map[keys[i]] = values[i]; + } + return map; } + }]); + return EvaluatedNamedArgs; + })(); - _EvaluatedNamedArgs2.call.apply(_EvaluatedNamedArgs2, [this].concat(args)); - this.tag = _glimmerReference.CONSTANT_TAG; - this.keys = []; + exports.EvaluatedNamedArgs = EvaluatedNamedArgs; + var EVALUATED_EMPTY_NAMED_ARGS = new ((function (_EvaluatedNamedArgs) { + babelHelpers.inherits(_class2, _EvaluatedNamedArgs); + + function _class2() { + _EvaluatedNamedArgs.call(this, _glimmerRuntimeLibUtils.EMPTY_ARRAY, _glimmerRuntimeLibUtils.EMPTY_ARRAY, _glimmerRuntimeLibUtils.EMPTY_DICT); } _class2.prototype.get = function get() { return _glimmerRuntimeLibReferences.UNDEFINED_REFERENCE; }; @@ -15252,97 +16069,69 @@ _class2.prototype.has = function has(key) { return false; }; _class2.prototype.value = function value() { - return {}; + return _glimmerRuntimeLibUtils.EMPTY_DICT; }; return _class2; })(EvaluatedNamedArgs))(); exports.EVALUATED_EMPTY_NAMED_ARGS = EVALUATED_EMPTY_NAMED_ARGS; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/expressions/named-args.ts"],"names":[],"mappings":"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","file":"named-args.js","sourcesContent":["import { UNDEFINED_REFERENCE } from '../../references';\nimport { CompiledExpression } from '../expressions';\nimport VM from '../../vm/append';\nimport { CONSTANT_TAG, PathReference, RevisionTag, combine } from 'glimmer-reference';\nimport { InternedString, Dict, dict } from 'glimmer-util';\n\nexport abstract class CompiledNamedArgs {\n  static create({ map }: { map: Dict<CompiledExpression<any>> }): CompiledNamedArgs {\n    if (Object.keys(map).length) {\n      return new CompiledNonEmptyNamedArgs({ map });\n    } else {\n      return COMPILED_EMPTY_NAMED_ARGS;\n    }\n  }\n\n  public type: string;\n  public map: Dict<CompiledExpression<any>>;\n  abstract evaluate(vm: VM): EvaluatedNamedArgs;\n  abstract toJSON(): string;\n}\n\nclass CompiledNonEmptyNamedArgs extends CompiledNamedArgs {\n  public type = \"named-args\";\n  public map: Dict<CompiledExpression<any>>;\n\n  constructor({ map }: { map: Dict<CompiledExpression<any>> }) {\n    super();\n    this.map = map;\n  }\n\n  evaluate(vm: VM): EvaluatedNamedArgs {\n    let { map } = this;\n\n    let compiledMap = dict<PathReference<any>>();\n    let compiledKeys = Object.keys(map);\n\n    for (let i = 0; i < compiledKeys.length; i++) {\n      let key = compiledKeys[i];\n      compiledMap[key] = map[key].evaluate(vm);\n    }\n\n    return EvaluatedNamedArgs.create({ map: compiledMap });\n  }\n\n  toJSON(): string {\n    let { map } = this;\n    let inner = Object.keys(map).map(key => `${key}: ${map[key].toJSON()}`).join(\", \");\n    return `{${inner}}`;\n  }\n}\n\nexport const COMPILED_EMPTY_NAMED_ARGS = new (class extends CompiledNamedArgs {\n  public type = \"empty-named-args\";\n  public map = dict<CompiledExpression<any>>();\n\n  evaluate(vm): EvaluatedNamedArgs {\n    return EvaluatedNamedArgs.empty();\n  }\n\n  toJSON(): string {\n    return `<EMPTY>`;\n  }\n});\n\nexport abstract class EvaluatedNamedArgs {\n  public tag: RevisionTag;\n  public keys: InternedString[];\n\n  static empty(): EvaluatedNamedArgs {\n    return EVALUATED_EMPTY_NAMED_ARGS;\n  }\n\n  static create({ map }: { map: Dict<PathReference<any>> }) {\n    return new NonEmptyEvaluatedNamedArgs({ map });\n  }\n\n  public type: string;\n  public map: Dict<PathReference<any>>;\n\n  forEach(callback: (key: InternedString, value: PathReference<any>) => void) {\n    let { map } = this;\n    let mapKeys = Object.keys(map);\n\n    for (let i = 0; i < mapKeys.length; i++) {\n      let key = mapKeys[i];\n      callback(key as InternedString, map[key]);\n    }\n  }\n\n  abstract get(key: InternedString): PathReference<any>;\n  abstract has(key: InternedString): boolean;\n  abstract value(): Dict<any>;\n}\n\nclass NonEmptyEvaluatedNamedArgs extends EvaluatedNamedArgs {\n  public values: PathReference<any>[];\n  public map: Dict<PathReference<any>>;\n\n  constructor({ map }: { map: Dict<PathReference<any>> }) {\n    super();\n\n    let keys = this.keys = Object.keys(map) as InternedString[];\n    this.map = map;\n\n    let tags = [];\n\n    for (let i = 0; i < keys.length; i++) {\n      let key = keys[i];\n      tags.push(map[key].tag);\n    }\n\n    this.tag = combine(tags);\n  }\n\n  get(key: InternedString): PathReference<any> {\n    return this.map[<string>key] || UNDEFINED_REFERENCE;\n  }\n\n  has(key: InternedString): boolean {\n    return !!this.map[<string>key];\n  }\n\n  value(): Dict<any> {\n    let { map, keys } = this;\n\n    let out = dict();\n\n    for (let i = 0; i < keys.length; i++) {\n      let key = keys[i];\n      out[key] = map[key].value();\n    }\n\n    return out;\n  }\n}\n\nexport const EVALUATED_EMPTY_NAMED_ARGS = new (class extends EvaluatedNamedArgs {\n  public tag = CONSTANT_TAG;\n  public keys = [];\n\n  get(): PathReference<any> {\n    return UNDEFINED_REFERENCE;\n  }\n\n  has(key: InternedString): boolean {\n    return false;\n  }\n\n  value(): Dict<any> {\n    return {};\n  }\n});\n"]} -enifed('glimmer-runtime/lib/compiled/expressions/positional-args', ['exports', 'glimmer-runtime/lib/references', 'glimmer-reference'], function (exports, _glimmerRuntimeLibReferences, _glimmerReference) { +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/expressions/named-args.ts"],"names":[],"mappings":"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","file":"named-args.js","sourcesContent":["import { UNDEFINED_REFERENCE } from '../../references';\nimport { CompiledExpression } from '../expressions';\nimport VM from '../../vm/append';\nimport { EMPTY_ARRAY, EMPTY_DICT } from '../../utils';\nimport { PathReference, RevisionTag, combineTagged } from 'glimmer-reference';\nimport { Dict, Opaque, assert, dict } from 'glimmer-util';\n\nexport class CompiledNamedArgs {\n  static empty(): CompiledNamedArgs {\n    return COMPILED_EMPTY_NAMED_ARGS;\n  }\n\n  static create(map: Dict<CompiledExpression<Opaque>>): CompiledNamedArgs {\n    let keys = Object.keys(map);\n    let length = keys.length;\n\n    if (length > 0) {\n      let values: CompiledExpression<Opaque>[] = [];\n\n      for (let i = 0; i < length; i++) {\n        values[i] = map[keys[i]];\n      }\n\n      return new this(keys, values);\n    } else {\n      return COMPILED_EMPTY_NAMED_ARGS;\n    }\n  }\n\n  public length: number;\n\n  constructor(\n    public keys: string[],\n    public values: CompiledExpression<Opaque>[]\n  ) {\n    this.length = keys.length;\n    assert(keys.length === values.length, 'Keys and values do not have the same length');\n  }\n\n  evaluate(vm: VM): EvaluatedNamedArgs {\n    let { keys, values, length } = this;\n    let evaluated: PathReference<Opaque>[] = new Array(length);\n\n    for (let i=0; i<length; i++) {\n      evaluated[i] = values[i].evaluate(vm);\n    }\n\n    return new EvaluatedNamedArgs(keys, evaluated);\n  }\n\n  toJSON(): string {\n    let { keys, values } = this;\n    let inner = keys.map((key, i) => `${key}: ${values[i].toJSON()}`).join(\", \");\n    return `{${inner}}`;\n  }\n}\n\nexport const COMPILED_EMPTY_NAMED_ARGS: CompiledNamedArgs = new (class extends CompiledNamedArgs {\n  constructor() {\n    super(EMPTY_ARRAY, EMPTY_ARRAY);\n  }\n\n  evaluate(vm: VM): EvaluatedNamedArgs {\n    return EVALUATED_EMPTY_NAMED_ARGS;\n  }\n\n  toJSON(): string {\n    return `<EMPTY>`;\n  }\n});\n\nexport class EvaluatedNamedArgs {\n  static create(map: Dict<PathReference<Opaque>>) {\n    let keys = Object.keys(map);\n    let length = keys.length;\n\n    if (length > 0) {\n      let values: PathReference<Opaque>[] = new Array(length);\n\n      for (let i=0; i<length; i++) {\n        values[i] = map[keys[i]];\n      }\n\n      return new this(keys, values, map);\n    } else {\n      return EVALUATED_EMPTY_NAMED_ARGS;\n    }\n  }\n\n  static empty(): EvaluatedNamedArgs {\n    return EVALUATED_EMPTY_NAMED_ARGS;\n  }\n\n  public tag: RevisionTag;\n  public length: number;\n\n  constructor(\n    public keys: string[],\n    public values: PathReference<Opaque>[],\n    private _map: Dict<PathReference<Opaque>> = undefined\n  ) {\n    this.tag = combineTagged(values);\n    this.length = keys.length;\n    assert(keys.length === values.length, 'Keys and values do not have the same length');\n  }\n\n  get map(): Dict<PathReference<Opaque>> {\n    let { _map: map } = this;\n\n    if (map) {\n      return map;\n    }\n\n    map = this._map = dict<PathReference<Opaque>>();\n\n    let { keys, values, length } = this;\n\n    for(let i=0; i<length; i++) {\n      map[keys[i]] = values[i];\n    }\n\n    return map;\n  }\n\n  get(key: string): PathReference<Opaque> {\n    let { keys, values } = this;\n    let index = keys.indexOf(key);\n    return (index === -1) ? UNDEFINED_REFERENCE : values[index];\n  }\n\n  has(key: string): boolean {\n    return this.keys.indexOf(key) !== -1;\n  }\n\n  value(): Dict<Opaque> {\n    let { keys, values } = this;\n\n    let out = dict<Opaque>();\n\n    for (let i = 0; i < keys.length; i++) {\n      let key = keys[i];\n      let ref = values[i];\n      out[key] = ref.value();\n    }\n\n    return out;\n  }\n}\n\nexport const EVALUATED_EMPTY_NAMED_ARGS = new (class extends EvaluatedNamedArgs {\n  constructor() {\n    super(EMPTY_ARRAY, EMPTY_ARRAY, EMPTY_DICT);\n  }\n\n  get(): PathReference<Opaque> {\n    return UNDEFINED_REFERENCE;\n  }\n\n  has(key: string): boolean {\n    return false;\n  }\n\n  value(): Dict<Opaque> {\n    return EMPTY_DICT;\n  }\n});\n"]} +enifed('glimmer-runtime/lib/compiled/expressions/positional-args', ['exports', 'glimmer-runtime/lib/references', 'glimmer-runtime/lib/utils', 'glimmer-reference'], function (exports, _glimmerRuntimeLibReferences, _glimmerRuntimeLibUtils, _glimmerReference) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var CompiledPositionalArgs = (function () { - function CompiledPositionalArgs() { - _classCallCheck(this, CompiledPositionalArgs); + function CompiledPositionalArgs(values) { + this.values = values; + this.length = values.length; } - CompiledPositionalArgs.create = function create(_ref) { - var values = _ref.values; - + CompiledPositionalArgs.create = function create(values) { if (values.length) { - return new CompiledNonEmptyPositionalArgs({ values: values }); + return new this(values); } else { return COMPILED_EMPTY_POSITIONAL_ARGS; } }; - return CompiledPositionalArgs; - })(); + CompiledPositionalArgs.empty = function empty() { + return COMPILED_EMPTY_POSITIONAL_ARGS; + }; - exports.CompiledPositionalArgs = CompiledPositionalArgs; - - var CompiledNonEmptyPositionalArgs = (function (_CompiledPositionalArgs) { - _inherits(CompiledNonEmptyPositionalArgs, _CompiledPositionalArgs); - - function CompiledNonEmptyPositionalArgs(_ref2) { - var values = _ref2.values; - - _classCallCheck(this, CompiledNonEmptyPositionalArgs); - - _CompiledPositionalArgs.call(this); - this.type = "positional-args"; - this.length = values.length; - this.values = values; - } - - CompiledNonEmptyPositionalArgs.prototype.evaluate = function evaluate(vm) { + CompiledPositionalArgs.prototype.evaluate = function evaluate(vm) { var values = this.values; + var length = this.length; - var valueReferences = new Array(values.length); - for (var i = 0; i < values.length; i++) { - valueReferences[i] = values[i].evaluate(vm); + var references = new Array(length); + for (var i = 0; i < length; i++) { + references[i] = values[i].evaluate(vm); } - return EvaluatedPositionalArgs.create({ values: valueReferences }); + return EvaluatedPositionalArgs.create(references); }; - CompiledNonEmptyPositionalArgs.prototype.toJSON = function toJSON() { + CompiledPositionalArgs.prototype.toJSON = function toJSON() { return '[' + this.values.map(function (value) { return value.toJSON(); }).join(", ") + ']'; }; - return CompiledNonEmptyPositionalArgs; - })(CompiledPositionalArgs); + return CompiledPositionalArgs; + })(); - var COMPILED_EMPTY_POSITIONAL_ARGS = new ((function (_CompiledPositionalArgs2) { - _inherits(_class, _CompiledPositionalArgs2); + exports.CompiledPositionalArgs = CompiledPositionalArgs; + var COMPILED_EMPTY_POSITIONAL_ARGS = new ((function (_CompiledPositionalArgs) { + babelHelpers.inherits(_class, _CompiledPositionalArgs); function _class() { - _classCallCheck(this, _class); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _CompiledPositionalArgs2.call.apply(_CompiledPositionalArgs2, [this].concat(args)); - this.type = "empty-positional-args"; - this.length = 0; + _CompiledPositionalArgs.call(this, _glimmerRuntimeLibUtils.EMPTY_ARRAY); } _class.prototype.evaluate = function evaluate(vm) { - return EvaluatedPositionalArgs.empty(); + return EVALUATED_EMPTY_POSITIONAL_ARGS; }; _class.prototype.toJSON = function toJSON() { return '<EMPTY>'; }; @@ -15350,244 +16139,75 @@ return _class; })(CompiledPositionalArgs))(); exports.COMPILED_EMPTY_POSITIONAL_ARGS = COMPILED_EMPTY_POSITIONAL_ARGS; var EvaluatedPositionalArgs = (function () { - function EvaluatedPositionalArgs() { - _classCallCheck(this, EvaluatedPositionalArgs); + function EvaluatedPositionalArgs(values) { + this.values = values; + this.tag = _glimmerReference.combineTagged(values); + this.length = values.length; } + EvaluatedPositionalArgs.create = function create(values) { + return new this(values); + }; + EvaluatedPositionalArgs.empty = function empty() { return EVALUATED_EMPTY_POSITIONAL_ARGS; }; - EvaluatedPositionalArgs.create = function create(_ref3) { - var values = _ref3.values; + EvaluatedPositionalArgs.prototype.at = function at(index) { + var values = this.values; + var length = this.length; - return new NonEmptyEvaluatedPositionalArgs({ values: values }); + return index < length ? values[index] : _glimmerRuntimeLibReferences.UNDEFINED_REFERENCE; }; - EvaluatedPositionalArgs.prototype.forEach = function forEach(callback) { + EvaluatedPositionalArgs.prototype.value = function value() { var values = this.values; - for (var i = 0; i < values.length; i++) { - callback(values[i]); + var length = this.length; + + var ret = new Array(length); + for (var i = 0; i < length; i++) { + ret[i] = values[i].value(); } + return ret; }; return EvaluatedPositionalArgs; })(); exports.EvaluatedPositionalArgs = EvaluatedPositionalArgs; + var EVALUATED_EMPTY_POSITIONAL_ARGS = new ((function (_EvaluatedPositionalArgs) { + babelHelpers.inherits(_class2, _EvaluatedPositionalArgs); - var NonEmptyEvaluatedPositionalArgs = (function (_EvaluatedPositionalArgs) { - _inherits(NonEmptyEvaluatedPositionalArgs, _EvaluatedPositionalArgs); - - function NonEmptyEvaluatedPositionalArgs(_ref4) { - var values = _ref4.values; - - _classCallCheck(this, NonEmptyEvaluatedPositionalArgs); - - _EvaluatedPositionalArgs.call(this); - this.tag = _glimmerReference.combineTagged(values); - this.length = values.length; - this.values = values; - } - - NonEmptyEvaluatedPositionalArgs.prototype.at = function at(index) { - return this.values[index]; - }; - - NonEmptyEvaluatedPositionalArgs.prototype.value = function value() { - var ret = new Array(this.values.length); - for (var i = 0; i < this.values.length; i++) { - ret[i] = this.values[i].value(); - } - return ret; - }; - - return NonEmptyEvaluatedPositionalArgs; - })(EvaluatedPositionalArgs); - - var EVALUATED_EMPTY_POSITIONAL_ARGS = new ((function (_EvaluatedPositionalArgs2) { - _inherits(_class2, _EvaluatedPositionalArgs2); - function _class2() { - _classCallCheck(this, _class2); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _EvaluatedPositionalArgs2.call.apply(_EvaluatedPositionalArgs2, [this].concat(args)); - this.tag = _glimmerReference.CONSTANT_TAG; - this.length = 0; - this.values = []; + _EvaluatedPositionalArgs.call(this, _glimmerRuntimeLibUtils.EMPTY_ARRAY); } _class2.prototype.at = function at() { - return _glimmerRuntimeLibReferences.NULL_REFERENCE; + return _glimmerRuntimeLibReferences.UNDEFINED_REFERENCE; }; _class2.prototype.value = function value() { - return []; + return this.values; }; return _class2; })(EvaluatedPositionalArgs))(); exports.EVALUATED_EMPTY_POSITIONAL_ARGS = EVALUATED_EMPTY_POSITIONAL_ARGS; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/expressions/positional-args.ts"],"names":[],"mappings":"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","file":"positional-args.js","sourcesContent":["import { NULL_REFERENCE } from '../../references';\nimport { CompiledExpression } from '../expressions';\nimport VM from '../../vm/append';\nimport { CONSTANT_TAG, PathReference, RevisionTag, combineTagged } from 'glimmer-reference';\n\nexport abstract class CompiledPositionalArgs {\n  static create({ values }: { values: CompiledExpression<any>[] }): CompiledPositionalArgs {\n    if (values.length) {\n      return new CompiledNonEmptyPositionalArgs({ values });\n    } else {\n      return COMPILED_EMPTY_POSITIONAL_ARGS;\n    }\n  }\n\n  public type: string;\n  public length: number;\n  abstract evaluate(vm: VM): EvaluatedPositionalArgs;\n  abstract toJSON(): string;\n}\n\nclass CompiledNonEmptyPositionalArgs extends CompiledPositionalArgs {\n  public type = \"positional-args\";\n  public values: CompiledExpression<any>[];\n\n  constructor({ values }: { values: CompiledExpression<any>[] }) {\n    super();\n    this.length = values.length;\n    this.values = values;\n  }\n\n  evaluate(vm: VM): EvaluatedPositionalArgs {\n    let { values } = this;\n    let valueReferences = new Array<any>(values.length);\n\n    for (let i = 0; i < values.length; i++) {\n      valueReferences[i] = <PathReference<any>>values[i].evaluate(vm);\n    }\n\n    return EvaluatedPositionalArgs.create({ values: valueReferences });\n  }\n\n  toJSON(): string {\n    return `[${this.values.map(value => value.toJSON()).join(\", \")}]`;\n  }\n}\n\nexport const COMPILED_EMPTY_POSITIONAL_ARGS = new (class extends CompiledPositionalArgs {\n  public type = \"empty-positional-args\";\n\n  public length = 0;\n\n  evaluate(vm): EvaluatedPositionalArgs {\n    return EvaluatedPositionalArgs.empty();\n  }\n\n  toJSON(): string {\n    return `<EMPTY>`;\n  }\n});\n\nexport abstract class EvaluatedPositionalArgs {\n  public tag: RevisionTag;\n\n  static empty(): EvaluatedPositionalArgs {\n    return EVALUATED_EMPTY_POSITIONAL_ARGS;\n  }\n\n  static create({ values }: { values: PathReference<any>[] }) {\n    return new NonEmptyEvaluatedPositionalArgs({ values });\n  }\n\n  public type: string;\n  public values: PathReference<any>[];\n  public length: number;\n\n  forEach(callback: (value: PathReference<any>) => void) {\n    let values = this.values;\n    for (let i = 0; i < values.length; i++) {\n      callback(values[i]);\n    }\n  }\n\n  abstract at(index: number): PathReference<any>;\n  abstract value(): any[];\n}\n\nclass NonEmptyEvaluatedPositionalArgs extends EvaluatedPositionalArgs {\n  public values: PathReference<any>[];\n\n  constructor({ values }: { values: PathReference<any>[] }) {\n    super();\n    this.tag = combineTagged(values);\n    this.length = values.length;\n    this.values = values;\n  }\n\n  at(index: number): PathReference<any> {\n    return this.values[index];\n  }\n\n  value(): any[] {\n    let ret = new Array(this.values.length);\n    for (let i = 0; i < this.values.length; i++) {\n      ret[i] = this.values[i].value();\n    }\n\n    return ret;\n  }\n}\n\nexport const EVALUATED_EMPTY_POSITIONAL_ARGS = new (class extends EvaluatedPositionalArgs {\n  public tag = CONSTANT_TAG;\n  public length = 0;\n  public values = [];\n\n  at(): PathReference<any> {\n    return NULL_REFERENCE;\n  }\n\n  value(): any[] {\n    return [];\n  }\n});\n"]} -enifed('glimmer-runtime/lib/compiled/expressions/ref', ['exports', 'glimmer-runtime/lib/compiled/expressions', 'glimmer-reference'], function (exports, _glimmerRuntimeLibCompiledExpressions, _glimmerReference) { - 'use strict'; - - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - var CompiledSymbolRef = (function (_CompiledExpression) { - _inherits(CompiledSymbolRef, _CompiledExpression); - - function CompiledSymbolRef(_ref) { - var debug = _ref.debug; - var symbol = _ref.symbol; - var path = _ref.path; - - _classCallCheck(this, CompiledSymbolRef); - - _CompiledExpression.call(this); - this.debug = debug; - this.symbol = symbol; - this.path = path; - } - - CompiledSymbolRef.prototype.evaluate = function evaluate(vm) { - var base = this.referenceForSymbol(vm); - return _glimmerReference.referenceFromParts(base, this.path); - }; - - CompiledSymbolRef.prototype.toJSON = function toJSON() { - var debug = this.debug; - var symbol = this.symbol; - var path = this.path; - - if (path.length) { - return '$' + symbol + '(' + debug + ').' + path.join('.'); - } else { - return '$' + symbol + '(' + debug + ')'; - } - }; - - return CompiledSymbolRef; - })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); - - exports.CompiledSymbolRef = CompiledSymbolRef; - - var CompiledKeywordRef = (function () { - function CompiledKeywordRef(_ref2) { - var name = _ref2.name; - var path = _ref2.path; - - _classCallCheck(this, CompiledKeywordRef); - - this.type = "keyword-ref"; - this.name = name; - this.path = path; - } - - CompiledKeywordRef.prototype.evaluate = function evaluate(vm) { - var base = vm.dynamicScope()[this.name]; - ; - return _glimmerReference.referenceFromParts(base, this.path); - }; - - CompiledKeywordRef.prototype.toJSON = function toJSON() { - var name = this.name; - var path = this.path; - - if (path.length) { - return '$KEYWORDS[' + name + '].' + path.join('.'); - } else { - return '$KEYWORDS[' + name + ']'; - } - }; - - return CompiledKeywordRef; - })(); - - exports.CompiledKeywordRef = CompiledKeywordRef; - - var CompiledLocalRef = (function (_CompiledSymbolRef) { - _inherits(CompiledLocalRef, _CompiledSymbolRef); - - function CompiledLocalRef() { - _classCallCheck(this, CompiledLocalRef); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _CompiledSymbolRef.call.apply(_CompiledSymbolRef, [this].concat(args)); - this.type = "local-ref"; - } - - CompiledLocalRef.prototype.referenceForSymbol = function referenceForSymbol(vm) { - return vm.referenceForSymbol(this.symbol); - }; - - return CompiledLocalRef; - })(CompiledSymbolRef); - - exports.CompiledLocalRef = CompiledLocalRef; - - var CompiledSelfRef = (function (_CompiledExpression2) { - _inherits(CompiledSelfRef, _CompiledExpression2); - - function CompiledSelfRef(_ref3) { - var parts = _ref3.parts; - - _classCallCheck(this, CompiledSelfRef); - - _CompiledExpression2.call(this); - this.type = "self-ref"; - this.parts = parts; - } - - CompiledSelfRef.prototype.evaluate = function evaluate(vm) { - return _glimmerReference.referenceFromParts(vm.getSelf(), this.parts); - }; - - CompiledSelfRef.prototype.toJSON = function toJSON() { - var path = ['self']; - path.push.apply(path, this.parts); - return path.join('.'); - }; - - return CompiledSelfRef; - })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); - - exports.CompiledSelfRef = CompiledSelfRef; -}); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcGlsZWQvZXhwcmVzc2lvbnMvcG9zaXRpb25hbC1hcmdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztRQU9NLHNCQUFBO0FBZUosaUJBZkksc0JBQUEsQ0FlZSxNQUFvQyxFQUFBO0FBQXBDLGdCQUFBLENBQUEsTUFBTSxHQUFOLE1BQU0sQ0FBOEI7QUFDckQsZ0JBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztTQUM3Qjs7QUFqQkcsOEJBQUEsQ0FDRyxNQUFNLEdBQUEsZ0JBQUMsTUFBb0MsRUFBQTtBQUNoRCxnQkFBSSxNQUFNLENBQUMsTUFBTSxFQUFFO0FBQ2pCLHVCQUFPLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2FBQ3pCLE1BQU07QUFDTCx1QkFBTyw4QkFBOEIsQ0FBQzthQUN2QztTQUNGOztBQVBHLDhCQUFBLENBU0csS0FBSyxHQUFBLGlCQUFBO0FBQ1YsbUJBQU8sOEJBQThCLENBQUM7U0FDdkM7O0FBWEcsOEJBQUEsV0FtQkosUUFBUSxHQUFBLGtCQUFDLEVBQU0sRUFBQTtnQkFDUCxNQUFNLEdBQWEsSUFBSSxDQUF2QixNQUFNO2dCQUFFLE1BQU0sR0FBSyxJQUFJLENBQWYsTUFBTTs7QUFDcEIsZ0JBQUksVUFBVSxHQUE0QixJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUU1RCxpQkFBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRTtBQUMvQiwwQkFBVSxDQUFDLENBQUMsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7YUFDeEM7QUFFRCxtQkFBTyx1QkFBdUIsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7U0FDbkQ7O0FBNUJHLDhCQUFBLFdBOEJKLE1BQU0sR0FBQSxrQkFBQTtBQUNKLHlCQUFXLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLFVBQUEsS0FBSzt1QkFBSSxLQUFLLENBQUMsTUFBTSxFQUFFO2FBQUEsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBSTtTQUNuRTs7ZUFoQ0csc0JBQUE7Ozs7QUFtQ0MsUUFBTSw4QkFBOEIsR0FBMkI7OztBQUNwRSwwQkFBQTtBQUNFLHVFQXpDSyxXQUFXLENBeUNFLENBQUM7U0FDcEI7O3lCQUVELFFBQVEsR0FBQSxrQkFBQyxFQUFNLEVBQUE7QUFDYixtQkFBTywrQkFBK0IsQ0FBQztTQUN4Qzs7eUJBRUQsTUFBTSxHQUFBLGtCQUFBO0FBQ0osNkJBQWlCO1NBQ2xCOzs7T0FYc0Ysc0JBQXNCLElBWTdHLENBQUM7OztRQUVHLHVCQUFBO0FBWUosaUJBWkksdUJBQUEsQ0FZZSxNQUErQixFQUFBO0FBQS9CLGdCQUFBLENBQUEsTUFBTSxHQUFOLE1BQU0sQ0FBeUI7QUFDaEQsZ0JBQUksQ0FBQyxHQUFHLEdBQUcsa0JBakVzQixhQUFhLENBaUVyQixNQUFNLENBQUMsQ0FBQztBQUNqQyxnQkFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO1NBQzdCOztBQWZHLCtCQUFBLENBQ0csTUFBTSxHQUFBLGdCQUFDLE1BQStCLEVBQUE7QUFDM0MsbUJBQU8sSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7U0FDekI7O0FBSEcsK0JBQUEsQ0FLRyxLQUFLLEdBQUEsaUJBQUE7QUFDVixtQkFBTywrQkFBK0IsQ0FBQztTQUN4Qzs7QUFQRywrQkFBQSxXQWlCSixFQUFFLEdBQUEsWUFBQyxLQUFhLEVBQUE7Z0JBQ1IsTUFBTSxHQUFhLElBQUksQ0FBdkIsTUFBTTtnQkFBRSxNQUFNLEdBQUssSUFBSSxDQUFmLE1BQU07O0FBQ3BCLG1CQUFPLEFBQUMsS0FBSyxHQUFHLE1BQU0sR0FBSSxNQUFNLENBQUMsS0FBSyxDQUFDLGdDQTNFbEMsbUJBQW1CLEFBMkVxQyxDQUFDO1NBQy9EOztBQXBCRywrQkFBQSxXQXNCSixLQUFLLEdBQUEsaUJBQUE7Z0JBQ0csTUFBTSxHQUFhLElBQUksQ0FBdkIsTUFBTTtnQkFBRSxNQUFNLEdBQUssSUFBSSxDQUFmLE1BQU07O0FBQ3BCLGdCQUFJLEdBQUcsR0FBYSxJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUV0QyxpQkFBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRTtBQUMvQixtQkFBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQzthQUM1QjtBQUVELG1CQUFPLEdBQUcsQ0FBQztTQUNaOztlQS9CRyx1QkFBQTs7OztBQWtDQyxRQUFNLCtCQUErQixHQUFHOzs7QUFDN0MsMkJBQUE7QUFDRSx3RUF6RkssV0FBVyxDQXlGRSxDQUFDO1NBQ3BCOzswQkFFRCxFQUFFLEdBQUEsY0FBQTtBQUNBLGdEQWhHSyxtQkFBbUIsQ0FnR0c7U0FDNUI7OzBCQUVELEtBQUssR0FBQSxpQkFBQTtBQUNILG1CQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7U0FDcEI7OztPQVgrRCx1QkFBdUIsSUFZdkYsQ0FBQyIsImZpbGUiOiJwb3NpdGlvbmFsLWFyZ3MuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVTkRFRklORURfUkVGRVJFTkNFIH0gZnJvbSAnLi4vLi4vcmVmZXJlbmNlcyc7XG5pbXBvcnQgeyBDb21waWxlZEV4cHJlc3Npb24gfSBmcm9tICcuLi9leHByZXNzaW9ucyc7XG5pbXBvcnQgVk0gZnJvbSAnLi4vLi4vdm0vYXBwZW5kJztcbmltcG9ydCB7IEVNUFRZX0FSUkFZIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IHsgUGF0aFJlZmVyZW5jZSwgUmV2aXNpb25UYWcsIGNvbWJpbmVUYWdnZWQgfSBmcm9tICdnbGltbWVyLXJlZmVyZW5jZSc7XG5pbXBvcnQgeyBPcGFxdWUgfSBmcm9tICdnbGltbWVyLXV0aWwnO1xuXG5leHBvcnQgY2xhc3MgQ29tcGlsZWRQb3NpdGlvbmFsQXJncyB7XG4gIHN0YXRpYyBjcmVhdGUodmFsdWVzOiBDb21waWxlZEV4cHJlc3Npb248T3BhcXVlPltdKTogQ29tcGlsZWRQb3NpdGlvbmFsQXJncyB7XG4gICAgaWYgKHZhbHVlcy5sZW5ndGgpIHtcbiAgICAgIHJldHVybiBuZXcgdGhpcyh2YWx1ZXMpO1xuICAgIH0gZWxzZSB7XG4gICAgICByZXR1cm4gQ09NUElMRURfRU1QVFlfUE9TSVRJT05BTF9BUkdTO1xuICAgIH1cbiAgfVxuXG4gIHN0YXRpYyBlbXB0eSgpIHtcbiAgICByZXR1cm4gQ09NUElMRURfRU1QVFlfUE9TSVRJT05BTF9BUkdTO1xuICB9XG5cbiAgcHVibGljIGxlbmd0aDogbnVtYmVyO1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB2YWx1ZXM6IENvbXBpbGVkRXhwcmVzc2lvbjxPcGFxdWU+W10pIHtcbiAgICB0aGlzLmxlbmd0aCA9IHZhbHVlcy5sZW5ndGg7XG4gIH1cblxuICBldmFsdWF0ZSh2bTogVk0pOiBFdmFsdWF0ZWRQb3NpdGlvbmFsQXJncyB7XG4gICAgbGV0IHsgdmFsdWVzLCBsZW5ndGggfSA9IHRoaXM7XG4gICAgbGV0IHJlZmVyZW5jZXM6IFBhdGhSZWZlcmVuY2U8T3BhcXVlPltdID0gbmV3IEFycmF5KGxlbmd0aCk7XG5cbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKSB7XG4gICAgICByZWZlcmVuY2VzW2ldID0gdmFsdWVzW2ldLmV2YWx1YXRlKHZtKTtcbiAgICB9XG5cbiAgICByZXR1cm4gRXZhbHVhdGVkUG9zaXRpb25hbEFyZ3MuY3JlYXRlKHJlZmVyZW5jZXMpO1xuICB9XG5cbiAgdG9KU09OKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIGBbJHt0aGlzLnZhbHVlcy5tYXAodmFsdWUgPT4gdmFsdWUudG9KU09OKCkpLmpvaW4oXCIsIFwiKX1dYDtcbiAgfVxufVxuXG5leHBvcnQgY29uc3QgQ09NUElMRURfRU1QVFlfUE9TSVRJT05BTF9BUkdTOiBDb21waWxlZFBvc2l0aW9uYWxBcmdzID0gbmV3IChjbGFzcyBleHRlbmRzIENvbXBpbGVkUG9zaXRpb25hbEFyZ3Mge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcihFTVBUWV9BUlJBWSk7XG4gIH1cblxuICBldmFsdWF0ZSh2bTogVk0pOiBFdmFsdWF0ZWRQb3NpdGlvbmFsQXJncyB7XG4gICAgcmV0dXJuIEVWQUxVQVRFRF9FTVBUWV9QT1NJVElPTkFMX0FSR1M7XG4gIH1cblxuICB0b0pTT04oKTogc3RyaW5nIHtcbiAgICByZXR1cm4gYDxFTVBUWT5gO1xuICB9XG59KTtcblxuZXhwb3J0IGNsYXNzIEV2YWx1YXRlZFBvc2l0aW9uYWxBcmdzIHtcbiAgc3RhdGljIGNyZWF0ZSh2YWx1ZXM6IFBhdGhSZWZlcmVuY2U8T3BhcXVlPltdKSB7XG4gICAgcmV0dXJuIG5ldyB0aGlzKHZhbHVlcyk7XG4gIH1cblxuICBzdGF0aWMgZW1wdHkoKTogRXZhbHVhdGVkUG9zaXRpb25hbEFyZ3Mge1xuICAgIHJldHVybiBFVkFMVUFURURfRU1QVFlfUE9TSVRJT05BTF9BUkdTO1xuICB9XG5cbiAgcHVibGljIHRhZzogUmV2aXNpb25UYWc7XG4gIHB1YmxpYyBsZW5ndGg6IG51bWJlcjtcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgdmFsdWVzOiBQYXRoUmVmZXJlbmNlPE9wYXF1ZT5bXSkge1xuICAgIHRoaXMudGFnID0gY29tYmluZVRhZ2dlZCh2YWx1ZXMpO1xuICAgIHRoaXMubGVuZ3RoID0gdmFsdWVzLmxlbmd0aDtcbiAgfVxuXG4gIGF0KGluZGV4OiBudW1iZXIpOiBQYXRoUmVmZXJlbmNlPE9wYXF1ZT4ge1xuICAgIGxldCB7IHZhbHVlcywgbGVuZ3RoIH0gPSB0aGlzO1xuICAgIHJldHVybiAoaW5kZXggPCBsZW5ndGgpID8gdmFsdWVzW2luZGV4XSA6IFVOREVGSU5FRF9SRUZFUkVOQ0U7XG4gIH1cblxuICB2YWx1ZSgpOiBPcGFxdWVbXSB7XG4gICAgbGV0IHsgdmFsdWVzLCBsZW5ndGggfSA9IHRoaXM7XG4gICAgbGV0IHJldDogT3BhcXVlW10gPSBuZXcgQXJyYXkobGVuZ3RoKTtcblxuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspIHtcbiAgICAgIHJldFtpXSA9IHZhbHVlc1tpXS52YWx1ZSgpO1xuICAgIH1cblxuICAgIHJldHVybiByZXQ7XG4gIH1cbn1cblxuZXhwb3J0IGNvbnN0IEVWQUxVQVRFRF9FTVBUWV9QT1NJVElPTkFMX0FSR1MgPSBuZXcgKGNsYXNzIGV4dGVuZHMgRXZhbHVhdGVkUG9zaXRpb25hbEFyZ3Mge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcihFTVBUWV9BUlJBWSk7XG4gIH1cblxuICBhdCgpOiBQYXRoUmVmZXJlbmNlPE9wYXF1ZT4ge1xuICAgIHJldHVybiBVTkRFRklORURfUkVGRVJFTkNFO1xuICB9XG5cbiAgdmFsdWUoKTogT3BhcXVlW10ge1xuICAgIHJldHVybiB0aGlzLnZhbHVlcztcbiAgfVxufSk7XG4iXX0= enifed('glimmer-runtime/lib/compiled/expressions/value', ['exports', 'glimmer-runtime/lib/compiled/expressions', 'glimmer-reference', 'glimmer-util'], function (exports, _glimmerRuntimeLibCompiledExpressions, _glimmerReference, _glimmerUtil) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var CompiledValue = (function (_CompiledExpression) { - _inherits(CompiledValue, _CompiledExpression); + babelHelpers.inherits(CompiledValue, _CompiledExpression); function CompiledValue(_ref) { var value = _ref.value; - _classCallCheck(this, CompiledValue); - _CompiledExpression.call(this); this.type = "value"; this.reference = new ValueReference(value); } @@ -15603,20 +16223,14 @@ })(_glimmerRuntimeLibCompiledExpressions.CompiledExpression); exports.default = CompiledValue; var ValueReference = (function (_ConstReference) { - _inherits(ValueReference, _ConstReference); + babelHelpers.inherits(ValueReference, _ConstReference); function ValueReference() { - _classCallCheck(this, ValueReference); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _ConstReference.call.apply(_ConstReference, [this].concat(args)); + _ConstReference.apply(this, arguments); this.children = _glimmerUtil.dict(); } ValueReference.prototype.get = function get(key) { var children = this.children; @@ -15635,26 +16249,16 @@ return ValueReference; })(_glimmerReference.ConstReference); exports.ValueReference = ValueReference; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/compiled/opcodes/builder', ['exports', 'glimmer-runtime/lib/compiled/opcodes/component', 'glimmer-runtime/lib/compiled/opcodes/content', 'glimmer-runtime/lib/compiled/opcodes/dom', 'glimmer-runtime/lib/compiled/opcodes/lists', 'glimmer-runtime/lib/compiled/opcodes/vm', 'glimmer-util', 'glimmer-runtime/lib/utils'], function (exports, _glimmerRuntimeLibCompiledOpcodesComponent, _glimmerRuntimeLibCompiledOpcodesContent, _glimmerRuntimeLibCompiledOpcodesDom, _glimmerRuntimeLibCompiledOpcodesLists, _glimmerRuntimeLibCompiledOpcodesVm, _glimmerUtil, _glimmerRuntimeLibUtils) { 'use strict'; - var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); - - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var StatementCompilationBufferProxy = (function () { function StatementCompilationBufferProxy(inner) { - _classCallCheck(this, StatementCompilationBufferProxy); - this.inner = inner; } StatementCompilationBufferProxy.prototype.toOpSeq = function toOpSeq() { return this.inner.toOpSeq(); @@ -15686,34 +16290,25 @@ StatementCompilationBufferProxy.prototype.hasBlockSymbol = function hasBlockSymbol(name) { return this.inner.hasBlockSymbol(name); }; - // only used for {{view.name}} - - StatementCompilationBufferProxy.prototype.hasKeyword = function hasKeyword(name) { - return this.inner.hasKeyword(name); - }; - - _createClass(StatementCompilationBufferProxy, [{ + babelHelpers.createClass(StatementCompilationBufferProxy, [{ key: 'component', get: function () { return this.inner.component; } }]); - return StatementCompilationBufferProxy; })(); var BasicOpcodeBuilder = (function (_StatementCompilationBufferProxy) { - _inherits(BasicOpcodeBuilder, _StatementCompilationBufferProxy); + babelHelpers.inherits(BasicOpcodeBuilder, _StatementCompilationBufferProxy); - function BasicOpcodeBuilder(inner, _block, env) { - _classCallCheck(this, BasicOpcodeBuilder); - + function BasicOpcodeBuilder(inner, symbolTable, env) { _StatementCompilationBufferProxy.call(this, inner); - this._block = _block; + this.symbolTable = symbolTable; this.env = env; this.labelsStack = new _glimmerUtil.Stack(); this.templatesStack = new _glimmerUtil.Stack(); } @@ -15746,32 +16341,36 @@ return label; }; // components - BasicOpcodeBuilder.prototype.putComponentDefinition = function putComponentDefinition(args, definition) { - this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.PutComponentDefinitionOpcode({ args: this.compile(args), definition: definition })); + BasicOpcodeBuilder.prototype.putComponentDefinition = function putComponentDefinition(definition) { + this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.PutComponentDefinitionOpcode(definition)); }; - BasicOpcodeBuilder.prototype.putDynamicComponentDefinition = function putDynamicComponentDefinition(args) { - this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.PutDynamicComponentDefinitionOpcode({ args: this.compile(args) })); + BasicOpcodeBuilder.prototype.putDynamicComponentDefinition = function putDynamicComponentDefinition() { + this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.PutDynamicComponentDefinitionOpcode()); }; - BasicOpcodeBuilder.prototype.openComponent = function openComponent() { - var shadow = arguments.length <= 0 || arguments[0] === undefined ? _glimmerRuntimeLibUtils.EMPTY_ARRAY : arguments[0]; + BasicOpcodeBuilder.prototype.openComponent = function openComponent(args) { + var shadow = arguments.length <= 1 || arguments[1] === undefined ? _glimmerRuntimeLibUtils.EMPTY_ARRAY : arguments[1]; - this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.OpenComponentOpcode({ shadow: shadow, templates: this.templates })); + this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.OpenComponentOpcode(this.compile(args), shadow, this.templates)); }; BasicOpcodeBuilder.prototype.didCreateElement = function didCreateElement() { this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.DidCreateElementOpcode()); }; BasicOpcodeBuilder.prototype.shadowAttributes = function shadowAttributes() { this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.ShadowAttributesOpcode()); }; + BasicOpcodeBuilder.prototype.didRenderLayout = function didRenderLayout() { + this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.DidRenderLayoutOpcode()); + }; + BasicOpcodeBuilder.prototype.closeComponent = function closeComponent() { this.append(new _glimmerRuntimeLibCompiledOpcodesComponent.CloseComponentOpcode()); }; // content @@ -15789,17 +16388,25 @@ BasicOpcodeBuilder.prototype.text = function text(_text) { this.append(new _glimmerRuntimeLibCompiledOpcodesDom.TextOpcode({ text: _text })); }; BasicOpcodeBuilder.prototype.openPrimitiveElement = function openPrimitiveElement(tag) { - this.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenPrimitiveElementOpcode({ tag: tag })); + this.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenPrimitiveElementOpcode(tag)); }; + BasicOpcodeBuilder.prototype.openComponentElement = function openComponentElement(tag) { + this.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenComponentElementOpcode(tag)); + }; + BasicOpcodeBuilder.prototype.openDynamicPrimitiveElement = function openDynamicPrimitiveElement() { this.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenDynamicPrimitiveElementOpcode()); }; + BasicOpcodeBuilder.prototype.flushElement = function flushElement() { + this.append(new _glimmerRuntimeLibCompiledOpcodesDom.FlushElementOpcode()); + }; + BasicOpcodeBuilder.prototype.closeElement = function closeElement() { this.append(new _glimmerRuntimeLibCompiledOpcodesDom.CloseElementOpcode()); }; BasicOpcodeBuilder.prototype.staticAttr = function staticAttr(options) { @@ -15872,24 +16479,24 @@ BasicOpcodeBuilder.prototype.putArgs = function putArgs(args) { this.append(new _glimmerRuntimeLibCompiledOpcodesVm.PutArgsOpcode({ args: this.compile(args) })); }; - BasicOpcodeBuilder.prototype.bindPositionalArgs = function bindPositionalArgs(block) { - this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindPositionalArgsOpcode({ block: block })); + BasicOpcodeBuilder.prototype.bindDynamicScope = function bindDynamicScope(names) { + this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindDynamicScopeOpcode(names)); }; - BasicOpcodeBuilder.prototype.bindNamedArgs = function bindNamedArgs(named) { - this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindNamedArgsOpcode({ named: named })); + BasicOpcodeBuilder.prototype.bindPositionalArgs = function bindPositionalArgs(names, symbols) { + this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindPositionalArgsOpcode(names, symbols)); }; - BasicOpcodeBuilder.prototype.bindBlocks = function bindBlocks(blocks) { - this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindBlocksOpcode({ blocks: blocks })); + BasicOpcodeBuilder.prototype.bindNamedArgs = function bindNamedArgs(names, symbols) { + this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindNamedArgsOpcode(names, symbols)); }; - BasicOpcodeBuilder.prototype.bindDynamicScope = function bindDynamicScope(callback) { - this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindDynamicScopeOpcode(callback)); + BasicOpcodeBuilder.prototype.bindBlocks = function bindBlocks(names, symbols) { + this.append(new _glimmerRuntimeLibCompiledOpcodesVm.BindBlocksOpcode(names, symbols)); }; BasicOpcodeBuilder.prototype.enter = function enter(_enter, exit) { this.append(new _glimmerRuntimeLibCompiledOpcodesVm.EnterOpcode({ begin: this.labelFor(_enter), end: this.labelFor(exit) })); }; @@ -15929,22 +16536,21 @@ BasicOpcodeBuilder.prototype.jumpUnless = function jumpUnless(target) { this.append(new _glimmerRuntimeLibCompiledOpcodesVm.JumpUnlessOpcode({ target: this.labelFor(target) })); }; - _createClass(BasicOpcodeBuilder, [{ + babelHelpers.createClass(BasicOpcodeBuilder, [{ key: 'labels', get: function () { return this.labelsStack.current; } }, { key: 'templates', get: function () { return this.templatesStack.current; } }]); - return BasicOpcodeBuilder; })(StatementCompilationBufferProxy); exports.BasicOpcodeBuilder = BasicOpcodeBuilder; @@ -15952,29 +16558,26 @@ return expr && typeof expr['compile'] === 'function'; } var SIMPLE_BLOCK = { templates: null }; var OpcodeBuilder = (function (_BasicOpcodeBuilder) { - _inherits(OpcodeBuilder, _BasicOpcodeBuilder); + babelHelpers.inherits(OpcodeBuilder, _BasicOpcodeBuilder); function OpcodeBuilder() { - _classCallCheck(this, OpcodeBuilder); - _BasicOpcodeBuilder.apply(this, arguments); } OpcodeBuilder.prototype.compile = function compile(expr) { if (isCompilableExpression(expr)) { - return expr.compile(this, this.env, this._block); + return expr.compile(this, this.env, this.symbolTable); } else { return expr; } }; - OpcodeBuilder.prototype.setupDynamicScope = function setupDynamicScope(callback) { - this.pushDynamicScope(); - this.bindDynamicScope(callback); + OpcodeBuilder.prototype.bindPositionalArgsForBlock = function bindPositionalArgsForBlock(block) { + this.append(_glimmerRuntimeLibCompiledOpcodesVm.BindPositionalArgsOpcode.create(block)); }; OpcodeBuilder.prototype.bindNamedArgsForLayout = function bindNamedArgsForLayout(layout) { this.append(_glimmerRuntimeLibCompiledOpcodesVm.BindNamedArgsOpcode.create(layout)); }; @@ -16036,40 +16639,27 @@ return OpcodeBuilder; })(BasicOpcodeBuilder); exports.default = OpcodeBuilder; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/builder.ts"],"names":[],"mappings":"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","file":"builder.js","sourcesContent":["import * as component from './component';\nimport * as content from './content';\nimport * as dom from './dom';\nimport * as lists from './lists';\nimport * as vm from './vm';\nimport * as Syntax from '../../syntax/core';\n\nimport { Stack, Dict, Opaque, InternedString, dict } from 'glimmer-util';\nimport { StatementCompilationBuffer } from '../../syntax';\nimport { Opcode, OpSeq } from '../../opcodes';\nimport { CompiledArgs } from '../expressions/args';\nimport { CompiledExpression } from '../expressions';\nimport { ComponentDefinition } from '../../component/interfaces';\nimport Environment from '../../environment';\nimport { InlineBlock, Layout, Block } from '../blocks';\nimport { EMPTY_ARRAY } from '../../utils';\n\ninterface CompilesInto<T> {\n  compile(dsl: OpcodeBuilder, env: Environment, block: Block): T;\n}\n\ntype Represents<E> = CompilesInto<E> | E;\n\nexport type Label = string;\n\nclass StatementCompilationBufferProxy implements StatementCompilationBuffer {\n\n  constructor(protected inner: StatementCompilationBuffer) {}\n\n  get component() {\n    return this.inner.component;\n  }\n\n  toOpSeq(): OpSeq {\n    return this.inner.toOpSeq();\n  }\n\n  append<T extends Opcode>(opcode: T) {\n    this.inner.append(opcode);\n  }\n\n  getLocalSymbol(name: InternedString): number {\n    return this.inner.getLocalSymbol(name);\n  }\n\n  hasLocalSymbol(name: InternedString): boolean {\n    return this.inner.hasLocalSymbol(name);\n  }\n\n  getNamedSymbol(name: InternedString): number {\n    return this.inner.getNamedSymbol(name);\n  }\n\n  hasNamedSymbol(name: InternedString): boolean {\n    return this.inner.hasNamedSymbol(name);\n  }\n\n  getBlockSymbol(name: InternedString): number {\n    return this.inner.getBlockSymbol(name);\n  }\n\n  hasBlockSymbol(name: InternedString): boolean {\n    return this.inner.hasBlockSymbol(name);\n  }\n\n  // only used for {{view.name}}\n  hasKeyword(name: InternedString): boolean {\n    return this.inner.hasKeyword(name);\n  }\n}\n\nexport abstract class BasicOpcodeBuilder extends StatementCompilationBufferProxy {\n  private labelsStack = new Stack<Dict<vm.LabelOpcode>>();\n  private templatesStack = new Stack<Syntax.Templates>();\n\n  constructor(inner: StatementCompilationBuffer, public _block: Block, public env: Environment) {\n    super(inner);\n  }\n\n  abstract compile<E>(expr: Represents<E>): E;\n\n  // helpers\n\n  get labels() {\n    return this.labelsStack.current;\n  }\n\n  get templates() {\n    return this.templatesStack.current;\n  }\n\n  startBlock({ templates }: { templates: Syntax.Templates }) {\n    this.templatesStack.push(templates);\n  }\n\n  endBlock() {\n    this.templatesStack.pop();\n  }\n\n  startLabels() {\n    this.labelsStack.push(dict<vm.LabelOpcode>());\n  }\n\n  stopLabels() {\n    this.labelsStack.pop();\n  }\n\n  labelFor(name: string): vm.LabelOpcode {\n    let labels = this.labels;\n    let label = labels[name];\n\n    if (!label) {\n      label = labels[name] = new vm.LabelOpcode(name);\n    }\n\n    return label;\n  }\n\n  // components\n\n  putComponentDefinition(args: Represents<CompiledArgs>, definition: ComponentDefinition<Opaque>) {\n    this.append(new component.PutComponentDefinitionOpcode({ args: this.compile(args), definition }));\n  }\n\n  putDynamicComponentDefinition(args: Represents<CompiledArgs>) {\n    this.append(new component.PutDynamicComponentDefinitionOpcode({ args: this.compile(args) }));\n  }\n\n  openComponent(shadow: InternedString[] = EMPTY_ARRAY) {\n    this.append(new component.OpenComponentOpcode({ shadow, templates: this.templates }));\n  }\n\n  didCreateElement() {\n    this.append(new component.DidCreateElementOpcode());\n  }\n\n  shadowAttributes() {\n    this.append(new component.ShadowAttributesOpcode());\n  }\n\n  closeComponent() {\n    this.append(new component.CloseComponentOpcode());\n  }\n\n  // content\n\n  cautiousAppend() {\n    this.append(new content.OptimizedCautiousAppendOpcode());\n  }\n\n  trustingAppend() {\n    this.append(new content.OptimizedTrustingAppendOpcode());\n  }\n\n  // dom\n\n  text(text: InternedString) {\n    this.append(new dom.TextOpcode({ text }));\n  }\n\n  openPrimitiveElement(tag: InternedString) {\n    this.append(new dom.OpenPrimitiveElementOpcode({ tag }));\n  }\n\n  openDynamicPrimitiveElement() {\n    this.append(new dom.OpenDynamicPrimitiveElementOpcode());\n  }\n\n  closeElement() {\n    this.append(new dom.CloseElementOpcode());\n  }\n\n  staticAttr(options: dom.StaticAttrOptions) {\n    this.append(new dom.StaticAttrOpcode(options));\n  }\n\n  dynamicAttrNS(options: dom.DynamicAttrNSOptions) {\n    this.append(new dom.DynamicAttrNSOpcode(options));\n  }\n\n  dynamicAttr(options: dom.SimpleAttrOptions) {\n    this.append(new dom.DynamicAttrOpcode(options));\n  }\n\n  comment(comment: InternedString) {\n    this.append(new dom.CommentOpcode({ comment }));\n  }\n\n  // lists\n\n  putIterator() {\n    this.append(new lists.PutIteratorOpcode());\n  }\n\n  enterList(start: string, end: string) {\n    this.append(new lists.EnterListOpcode(this.labelFor(start), this.labelFor(end)));\n  }\n\n  exitList() {\n    this.append(new lists.ExitListOpcode());\n  }\n\n  enterWithKey(start: string, end: string) {\n    this.append(new lists.EnterWithKeyOpcode(this.labelFor(start), this.labelFor(end)));\n  }\n\n  nextIter(end: string) {\n    this.append(new lists.NextIterOpcode(this.labelFor(end)));\n  }\n\n  // vm\n\n  label(name: string) {\n    this.append(this.labelFor(name));\n  }\n\n  pushChildScope() {\n    this.append(new vm.PushChildScopeOpcode());\n  }\n\n  popScope() {\n    this.append(new vm.PopScopeOpcode());\n  }\n\n  pushDynamicScope() {\n    this.append(new vm.PushDynamicScopeOpcode());\n  }\n\n  popDynamicScope() {\n    this.append(new vm.PopDynamicScopeOpcode());\n  }\n\n  putNull() {\n    this.append(new vm.PutNullOpcode());\n  }\n\n  putValue(expression: Represents<CompiledExpression<Opaque>>) {\n    this.append(new vm.PutValueOpcode({ expression: this.compile(expression) }));\n  }\n\n  putArgs(args: Represents<CompiledArgs>) {\n    this.append(new vm.PutArgsOpcode({ args: this.compile(args) }));\n  }\n\n  bindPositionalArgs(block: InlineBlock) {\n    this.append(new vm.BindPositionalArgsOpcode({ block }));\n  }\n\n  bindNamedArgs(named: Dict<number>) {\n    this.append(new vm.BindNamedArgsOpcode({ named }));\n  }\n\n  bindBlocks(blocks: Dict<number>) {\n    this.append(new vm.BindBlocksOpcode({ blocks }));\n  }\n\n  bindDynamicScope(callback: vm.BindDynamicScopeCallback) {\n    this.append(new vm.BindDynamicScopeOpcode(callback));\n  }\n\n  enter(enter: Label, exit: Label) {\n    this.append(new vm.EnterOpcode({ begin: this.labelFor(enter), end: this.labelFor(exit) }));\n  }\n\n  exit() {\n    this.append(new vm.ExitOpcode());\n  }\n\n  evaluate(name: string, block = this.templates[name]) {\n    this.append(new vm.EvaluateOpcode({ debug: name, block }));\n  }\n\n  test(testFunc: 'const' | 'simple' | 'environment' | vm.TestFunction) {\n    if (testFunc === 'const') {\n      this.append(new vm.TestOpcode(vm.ConstTest));\n    } else if (testFunc === 'simple') {\n      this.append(new vm.TestOpcode(vm.SimpleTest));\n    } else if (testFunc === 'environment') {\n      this.append(new vm.TestOpcode(vm.EnvironmentTest));\n    } else if (typeof testFunc === 'function') {\n      this.append(new vm.TestOpcode(testFunc));\n    } else {\n      throw new Error('unreachable');\n    }\n  }\n\n  jump(target: string) {\n    this.append(new vm.JumpOpcode({ target: this.labelFor(target) }));\n  }\n\n  jumpIf(target: string) {\n    this.append(new vm.JumpIfOpcode({ target: this.labelFor(target) }));\n  }\n\n  jumpUnless(target: string) {\n    this.append(new vm.JumpUnlessOpcode({ target: this.labelFor(target) }));\n  }\n}\n\nfunction isCompilableExpression<E>(expr: Represents<E>): expr is CompilesInto<E> {\n  return expr && typeof expr['compile'] === 'function';\n}\n\ntype BlockArgs = { templates: Syntax.Templates, args?: Syntax.Args };\n\nconst SIMPLE_BLOCK: BlockArgs = { templates: null };\n\nexport default class OpcodeBuilder extends BasicOpcodeBuilder {\n  compile<E>(expr: Represents<E>): E {\n    if (isCompilableExpression(expr)) {\n      return expr.compile(this, this.env, this._block);\n    } else {\n      return expr;\n    }\n  }\n\n  setupDynamicScope(callback: vm.BindDynamicScopeCallback) {\n    this.pushDynamicScope();\n    this.bindDynamicScope(callback);\n  }\n\n  bindNamedArgsForLayout(layout: Layout) {\n    this.append(vm.BindNamedArgsOpcode.create(layout));\n  }\n\n  bindBlocksForLayout(layout: Layout) {\n    this.append(vm.BindBlocksOpcode.create(layout));\n  }\n\n  simpleBlock(callback: BlockCallback) {\n    this.block(SIMPLE_BLOCK, callback);\n  }\n\n  block({ templates, args }: BlockArgs, callback: BlockCallback) {\n    this.startLabels();\n    this.startBlock({ templates });\n    this.enter('BEGIN', 'END');\n    this.label('BEGIN');\n\n    if (args) this.putArgs(args);\n\n    callback(this, 'BEGIN', 'END');\n\n    this.label('END');\n    this.exit();\n    this.endBlock();\n    this.stopLabels();\n  }\n\n  iter({ templates }: { templates: Syntax.Templates }, callback: BlockCallback) {\n    this.startLabels();\n    this.startBlock({ templates });\n    this.enterList('BEGIN', 'END');\n    this.label('ITER');\n    this.nextIter('BREAK');\n    this.enterWithKey('BEGIN', 'END');\n    this.label('BEGIN');\n\n    callback(this, 'BEGIN', 'END');\n\n    this.label('END');\n    this.exit();\n    this.jump('ITER');\n    this.label('BREAK');\n    this.exitList();\n    this.endBlock();\n    this.stopLabels();\n  }\n\n  unit({ templates }: { templates: Syntax.Templates }, callback: (builder: OpcodeBuilder) => void) {\n    this.startLabels();\n    this.startBlock({ templates });\n    callback(this);\n    this.endBlock();\n    this.stopLabels();\n  }\n}\n\nexport interface UnitOptions {\n  templates: Syntax.Templates;\n}\n\nexport interface BlockOptions extends UnitOptions {\n  args: Syntax.Args;\n}\nexport type BlockCallback = (dsl: OpcodeBuilder, BEGIN: Label, END: Label) => void;\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/builder.ts"],"names":[],"mappings":"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","file":"builder.js","sourcesContent":["import * as component from './component';\nimport * as content from './content';\nimport * as dom from './dom';\nimport * as lists from './lists';\nimport * as vm from './vm';\nimport * as Syntax from '../../syntax/core';\n\nimport { Stack, Dict, Opaque, dict } from 'glimmer-util';\nimport { StatementCompilationBuffer, CompilesInto } from '../../syntax';\nimport { Opcode, OpSeq } from '../../opcodes';\nimport { CompiledArgs } from '../expressions/args';\nimport { CompiledExpression } from '../expressions';\nimport { ComponentDefinition } from '../../component/interfaces';\nimport Environment from '../../environment';\nimport { InlineBlock, Layout } from '../blocks';\nimport { EMPTY_ARRAY } from '../../utils';\nimport SymbolTable from '../../symbol-table';\n\ntype Represents<E> = CompilesInto<E> | E;\n\nexport type Label = string;\n\nclass StatementCompilationBufferProxy implements StatementCompilationBuffer {\n\n  constructor(protected inner: StatementCompilationBuffer) {}\n\n  get component() {\n    return this.inner.component;\n  }\n\n  toOpSeq(): OpSeq {\n    return this.inner.toOpSeq();\n  }\n\n  append<T extends Opcode>(opcode: T) {\n    this.inner.append(opcode);\n  }\n\n  getLocalSymbol(name: string): number {\n    return this.inner.getLocalSymbol(name);\n  }\n\n  hasLocalSymbol(name: string): boolean {\n    return this.inner.hasLocalSymbol(name);\n  }\n\n  getNamedSymbol(name: string): number {\n    return this.inner.getNamedSymbol(name);\n  }\n\n  hasNamedSymbol(name: string): boolean {\n    return this.inner.hasNamedSymbol(name);\n  }\n\n  getBlockSymbol(name: string): number {\n    return this.inner.getBlockSymbol(name);\n  }\n\n  hasBlockSymbol(name: string): boolean {\n    return this.inner.hasBlockSymbol(name);\n  }\n}\n\nexport abstract class BasicOpcodeBuilder extends StatementCompilationBufferProxy {\n  private labelsStack = new Stack<Dict<vm.LabelOpcode>>();\n  private templatesStack = new Stack<Syntax.Templates>();\n\n  constructor(inner: StatementCompilationBuffer, protected symbolTable: SymbolTable, public env: Environment) {\n    super(inner);\n  }\n\n  abstract compile<E>(expr: Represents<E>): E;\n\n  // helpers\n\n  get labels() {\n    return this.labelsStack.current;\n  }\n\n  get templates() {\n    return this.templatesStack.current;\n  }\n\n  startBlock({ templates }: { templates: Syntax.Templates }) {\n    this.templatesStack.push(templates);\n  }\n\n  endBlock() {\n    this.templatesStack.pop();\n  }\n\n  startLabels() {\n    this.labelsStack.push(dict<vm.LabelOpcode>());\n  }\n\n  stopLabels() {\n    this.labelsStack.pop();\n  }\n\n  labelFor(name: string): vm.LabelOpcode {\n    let labels = this.labels;\n    let label = labels[name];\n\n    if (!label) {\n      label = labels[name] = new vm.LabelOpcode(name);\n    }\n\n    return label;\n  }\n\n  // components\n\n  putComponentDefinition(definition: ComponentDefinition<Opaque>) {\n    this.append(new component.PutComponentDefinitionOpcode(definition));\n  }\n\n  putDynamicComponentDefinition() {\n    this.append(new component.PutDynamicComponentDefinitionOpcode());\n  }\n\n  openComponent(args: Represents<CompiledArgs>, shadow: string[] = EMPTY_ARRAY) {\n    this.append(new component.OpenComponentOpcode(this.compile(args), shadow, this.templates));\n  }\n\n  didCreateElement() {\n    this.append(new component.DidCreateElementOpcode());\n  }\n\n  shadowAttributes() {\n    this.append(new component.ShadowAttributesOpcode());\n  }\n\n  didRenderLayout() {\n    this.append(new component.DidRenderLayoutOpcode());\n  }\n\n  closeComponent() {\n    this.append(new component.CloseComponentOpcode());\n  }\n\n  // content\n\n  cautiousAppend() {\n    this.append(new content.OptimizedCautiousAppendOpcode());\n  }\n\n  trustingAppend() {\n    this.append(new content.OptimizedTrustingAppendOpcode());\n  }\n\n  // dom\n\n  text(text: string) {\n    this.append(new dom.TextOpcode({ text }));\n  }\n\n  openPrimitiveElement(tag: string) {\n    this.append(new dom.OpenPrimitiveElementOpcode(tag));\n  }\n\n  openComponentElement(tag: string) {\n    this.append(new dom.OpenComponentElementOpcode(tag));\n  }\n\n  openDynamicPrimitiveElement() {\n    this.append(new dom.OpenDynamicPrimitiveElementOpcode());\n  }\n\n  flushElement() {\n    this.append(new dom.FlushElementOpcode());\n  }\n\n  closeElement() {\n    this.append(new dom.CloseElementOpcode());\n  }\n\n  staticAttr(options: dom.StaticAttrOptions) {\n    this.append(new dom.StaticAttrOpcode(options));\n  }\n\n  dynamicAttrNS(options: dom.DynamicAttrNSOptions) {\n    this.append(new dom.DynamicAttrNSOpcode(options));\n  }\n\n  dynamicAttr(options: dom.SimpleAttrOptions) {\n    this.append(new dom.DynamicAttrOpcode(options));\n  }\n\n  comment(comment: string) {\n    this.append(new dom.CommentOpcode({ comment }));\n  }\n\n  // lists\n\n  putIterator() {\n    this.append(new lists.PutIteratorOpcode());\n  }\n\n  enterList(start: string, end: string) {\n    this.append(new lists.EnterListOpcode(this.labelFor(start), this.labelFor(end)));\n  }\n\n  exitList() {\n    this.append(new lists.ExitListOpcode());\n  }\n\n  enterWithKey(start: string, end: string) {\n    this.append(new lists.EnterWithKeyOpcode(this.labelFor(start), this.labelFor(end)));\n  }\n\n  nextIter(end: string) {\n    this.append(new lists.NextIterOpcode(this.labelFor(end)));\n  }\n\n  // vm\n\n  label(name: string) {\n    this.append(this.labelFor(name));\n  }\n\n  pushChildScope() {\n    this.append(new vm.PushChildScopeOpcode());\n  }\n\n  popScope() {\n    this.append(new vm.PopScopeOpcode());\n  }\n\n  pushDynamicScope() {\n    this.append(new vm.PushDynamicScopeOpcode());\n  }\n\n  popDynamicScope() {\n    this.append(new vm.PopDynamicScopeOpcode());\n  }\n\n  putNull() {\n    this.append(new vm.PutNullOpcode());\n  }\n\n  putValue(expression: Represents<CompiledExpression<Opaque>>) {\n    this.append(new vm.PutValueOpcode({ expression: this.compile(expression) }));\n  }\n\n  putArgs(args: Represents<CompiledArgs>) {\n    this.append(new vm.PutArgsOpcode({ args: this.compile(args) }));\n  }\n\n  bindDynamicScope(names: string[]) {\n    this.append(new vm.BindDynamicScopeOpcode(names));\n  }\n\n  bindPositionalArgs(names: string[], symbols: number[]) {\n    this.append(new vm.BindPositionalArgsOpcode(names, symbols));\n  }\n\n  bindNamedArgs(names: string[], symbols: number[]) {\n    this.append(new vm.BindNamedArgsOpcode(names, symbols));\n  }\n\n  bindBlocks(names: string[], symbols: number[]) {\n    this.append(new vm.BindBlocksOpcode(names, symbols));\n  }\n\n  enter(enter: Label, exit: Label) {\n    this.append(new vm.EnterOpcode({ begin: this.labelFor(enter), end: this.labelFor(exit) }));\n  }\n\n  exit() {\n    this.append(new vm.ExitOpcode());\n  }\n\n  evaluate(name: string, block = this.templates[name]) {\n    this.append(new vm.EvaluateOpcode({ debug: name, block }));\n  }\n\n  test(testFunc: 'const' | 'simple' | 'environment' | vm.TestFunction) {\n    if (testFunc === 'const') {\n      this.append(new vm.TestOpcode(vm.ConstTest));\n    } else if (testFunc === 'simple') {\n      this.append(new vm.TestOpcode(vm.SimpleTest));\n    } else if (testFunc === 'environment') {\n      this.append(new vm.TestOpcode(vm.EnvironmentTest));\n    } else if (typeof testFunc === 'function') {\n      this.append(new vm.TestOpcode(testFunc));\n    } else {\n      throw new Error('unreachable');\n    }\n  }\n\n  jump(target: string) {\n    this.append(new vm.JumpOpcode({ target: this.labelFor(target) }));\n  }\n\n  jumpIf(target: string) {\n    this.append(new vm.JumpIfOpcode({ target: this.labelFor(target) }));\n  }\n\n  jumpUnless(target: string) {\n    this.append(new vm.JumpUnlessOpcode({ target: this.labelFor(target) }));\n  }\n}\n\nfunction isCompilableExpression<E>(expr: Represents<E>): expr is CompilesInto<E> {\n  return expr && typeof expr['compile'] === 'function';\n}\n\ntype BlockArgs = { templates: Syntax.Templates, args?: Syntax.Args };\n\nconst SIMPLE_BLOCK: BlockArgs = { templates: null };\n\nexport default class OpcodeBuilder extends BasicOpcodeBuilder {\n  compile<E>(expr: Represents<E>): E {\n    if (isCompilableExpression(expr)) {\n      return expr.compile(this, this.env, this.symbolTable);\n    } else {\n      return expr;\n    }\n  }\n\n  bindPositionalArgsForBlock(block: InlineBlock) {\n    this.append(vm.BindPositionalArgsOpcode.create(block));\n  }\n\n  bindNamedArgsForLayout(layout: Layout) {\n    this.append(vm.BindNamedArgsOpcode.create(layout));\n  }\n\n  bindBlocksForLayout(layout: Layout) {\n    this.append(vm.BindBlocksOpcode.create(layout));\n  }\n\n  simpleBlock(callback: BlockCallback) {\n    this.block(SIMPLE_BLOCK, callback);\n  }\n\n  block({ templates, args }: BlockArgs, callback: BlockCallback) {\n    this.startLabels();\n    this.startBlock({ templates });\n    this.enter('BEGIN', 'END');\n    this.label('BEGIN');\n\n    if (args) this.putArgs(args);\n\n    callback(this, 'BEGIN', 'END');\n\n    this.label('END');\n    this.exit();\n    this.endBlock();\n    this.stopLabels();\n  }\n\n  iter({ templates }: { templates: Syntax.Templates }, callback: BlockCallback) {\n    this.startLabels();\n    this.startBlock({ templates });\n    this.enterList('BEGIN', 'END');\n    this.label('ITER');\n    this.nextIter('BREAK');\n    this.enterWithKey('BEGIN', 'END');\n    this.label('BEGIN');\n\n    callback(this, 'BEGIN', 'END');\n\n    this.label('END');\n    this.exit();\n    this.jump('ITER');\n    this.label('BREAK');\n    this.exitList();\n    this.endBlock();\n    this.stopLabels();\n  }\n\n  unit({ templates }: { templates: Syntax.Templates }, callback: (builder: OpcodeBuilder) => void) {\n    this.startLabels();\n    this.startBlock({ templates });\n    callback(this);\n    this.endBlock();\n    this.stopLabels();\n  }\n}\n\nexport interface UnitOptions {\n  templates: Syntax.Templates;\n}\n\nexport interface BlockOptions extends UnitOptions {\n  args: Syntax.Args;\n}\nexport type BlockCallback = (dsl: OpcodeBuilder, BEGIN: Label, END: Label) => void;\n"]} enifed('glimmer-runtime/lib/compiled/opcodes/component', ['exports', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/opcodes/vm', 'glimmer-reference'], function (exports, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledOpcodesVm, _glimmerReference) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var PutDynamicComponentDefinitionOpcode = (function (_Opcode) { - _inherits(PutDynamicComponentDefinitionOpcode, _Opcode); + babelHelpers.inherits(PutDynamicComponentDefinitionOpcode, _Opcode); - function PutDynamicComponentDefinitionOpcode(_ref) { - var args = _ref.args; - - _classCallCheck(this, PutDynamicComponentDefinitionOpcode); - - _Opcode.call(this); + function PutDynamicComponentDefinitionOpcode() { + _Opcode.apply(this, arguments); this.type = "put-dynamic-component-definition"; - this.args = args; } PutDynamicComponentDefinitionOpcode.prototype.evaluate = function evaluate(vm) { - var definitionRef = vm.frame.getOperand(); - var cache = _glimmerReference.isConst(definitionRef) ? undefined : new _glimmerReference.ReferenceCache(definitionRef); - var definition = cache ? cache.peek() : definitionRef.value(); - var args = this.args.evaluate(vm).withInternal(); - vm.frame.setArgs(args); - args.internal["definition"] = definition; + var reference = vm.frame.getOperand(); + var cache = _glimmerReference.isConst(reference) ? undefined : new _glimmerReference.ReferenceCache(reference); + var definition = cache ? cache.peek() : reference.value(); + vm.frame.setComponentDefinition(definition); if (cache) { vm.updateWith(new _glimmerRuntimeLibCompiledOpcodesVm.Assert(cache)); } }; @@ -16077,124 +16667,92 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PutDynamicComponentDefinitionOpcode = PutDynamicComponentDefinitionOpcode; var PutComponentDefinitionOpcode = (function (_Opcode2) { - _inherits(PutComponentDefinitionOpcode, _Opcode2); + babelHelpers.inherits(PutComponentDefinitionOpcode, _Opcode2); - function PutComponentDefinitionOpcode(_ref2) { - var args = _ref2.args; - var definition = _ref2.definition; - - _classCallCheck(this, PutComponentDefinitionOpcode); - + function PutComponentDefinitionOpcode(definition) { _Opcode2.call(this); - this.type = "put-component-definition"; - this.args = args; this.definition = definition; + this.type = "put-component-definition"; } PutComponentDefinitionOpcode.prototype.evaluate = function evaluate(vm) { - var args = this.args.evaluate(vm).withInternal(); - args.internal["definition"] = this.definition; - vm.frame.setArgs(args); + vm.frame.setComponentDefinition(this.definition); }; return PutComponentDefinitionOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.PutComponentDefinitionOpcode = PutComponentDefinitionOpcode; var OpenComponentOpcode = (function (_Opcode3) { - _inherits(OpenComponentOpcode, _Opcode3); + babelHelpers.inherits(OpenComponentOpcode, _Opcode3); - function OpenComponentOpcode(_ref3) { - var shadow = _ref3.shadow; - var templates = _ref3.templates; - - _classCallCheck(this, OpenComponentOpcode); - + function OpenComponentOpcode(args, shadow, templates) { _Opcode3.call(this); - this.type = "open-component"; + this.args = args; this.shadow = shadow; this.templates = templates; + this.type = "open-component"; } OpenComponentOpcode.prototype.evaluate = function evaluate(vm) { + var rawArgs = this.args; var shadow = this.shadow; var templates = this.templates; - var args = vm.frame.getArgs(); - var definition = args.internal["definition"]; - vm.pushDynamicScope(); - var dynamicScope = vm.dynamicScope(); + var definition = vm.frame.getComponentDefinition(); + var dynamicScope = vm.pushDynamicScope(); + var callerScope = vm.scope(); var manager = definition.manager; var hasDefaultBlock = templates && !!templates.default; // TODO Cleanup? - var preparedArgs = manager.prepareArgs(definition, args); - var component = manager.create(definition, preparedArgs, dynamicScope, hasDefaultBlock); + var args = manager.prepareArgs(definition, rawArgs.evaluate(vm)); + var component = manager.create(vm.env, definition, args, dynamicScope, vm.getSelf(), hasDefaultBlock); var destructor = manager.getDestructor(component); if (destructor) vm.newDestroyable(destructor); - preparedArgs.internal["component"] = component; - preparedArgs.internal["definition"] = definition; - preparedArgs.internal["shadow"] = shadow; - vm.beginCacheGroup(); var layout = manager.layoutFor(definition, component, vm.env); - var callerScope = vm.scope(); var selfRef = manager.getSelf(component); + vm.beginCacheGroup(); + vm.stack().pushSimpleBlock(); vm.pushRootScope(selfRef, layout.symbols); - vm.invokeLayout({ templates: templates, args: preparedArgs, shadow: shadow, layout: layout, callerScope: callerScope }); - vm.env.didCreate(component, manager); - vm.updateWith(new UpdateComponentOpcode({ name: definition.name, component: component, manager: manager, args: preparedArgs, dynamicScope: dynamicScope })); + vm.invokeLayout(args, layout, templates, callerScope, component, manager, shadow); + vm.updateWith(new UpdateComponentOpcode(definition.name, component, manager, args, dynamicScope)); }; return OpenComponentOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.OpenComponentOpcode = OpenComponentOpcode; var UpdateComponentOpcode = (function (_UpdatingOpcode) { - _inherits(UpdateComponentOpcode, _UpdatingOpcode); + babelHelpers.inherits(UpdateComponentOpcode, _UpdatingOpcode); - function UpdateComponentOpcode(_ref4) { - var name = _ref4.name; - var component = _ref4.component; - var manager = _ref4.manager; - var args = _ref4.args; - var dynamicScope = _ref4.dynamicScope; - - _classCallCheck(this, UpdateComponentOpcode); - + function UpdateComponentOpcode(name, component, manager, args, dynamicScope) { _UpdatingOpcode.call(this); - this.type = "update-component"; - var tag = undefined; - var componentTag = manager.getTag(component); - if (componentTag) { - tag = this.tag = _glimmerReference.combine([args.tag, componentTag]); - } else { - tag = this.tag = args.tag; - } this.name = name; this.component = component; this.manager = manager; this.args = args; this.dynamicScope = dynamicScope; - this.lastUpdated = tag.value(); + this.type = "update-component"; + var componentTag = manager.getTag(component); + if (componentTag) { + this.tag = _glimmerReference.combine([args.tag, componentTag]); + } else { + this.tag = args.tag; + } } UpdateComponentOpcode.prototype.evaluate = function evaluate(vm) { var component = this.component; var manager = this.manager; - var tag = this.tag; var args = this.args; var dynamicScope = this.dynamicScope; - var lastUpdated = this.lastUpdated; - if (!tag.validate(lastUpdated)) { - manager.update(component, args, dynamicScope); - vm.env.didUpdate(component, manager); - this.lastUpdated = tag.value(); - } + manager.update(component, args, dynamicScope); }; UpdateComponentOpcode.prototype.toJSON = function toJSON() { return { guid: this._guid, @@ -16207,33 +16765,24 @@ })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); exports.UpdateComponentOpcode = UpdateComponentOpcode; var DidCreateElementOpcode = (function (_Opcode4) { - _inherits(DidCreateElementOpcode, _Opcode4); + babelHelpers.inherits(DidCreateElementOpcode, _Opcode4); function DidCreateElementOpcode() { - _classCallCheck(this, DidCreateElementOpcode); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _Opcode4.call.apply(_Opcode4, [this].concat(args)); + _Opcode4.apply(this, arguments); this.type = "did-create-element"; } // Slow path for non-specialized component invocations. Uses an internal // named lookup on the args. DidCreateElementOpcode.prototype.evaluate = function evaluate(vm) { - var args = vm.frame.getArgs(); - var internal = args.internal; - var definition = internal['definition']; - var manager = definition.manager; - var component = internal['component']; - manager.didCreateElement(component, vm.stack().element, vm.stack().elementOperations); + var manager = vm.frame.getManager(); + var component = vm.frame.getComponent(); + manager.didCreateElement(component, vm.stack().constructing, vm.stack().operations); }; DidCreateElementOpcode.prototype.toJSON = function toJSON() { return { guid: this._guid, @@ -16246,31 +16795,27 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.DidCreateElementOpcode = DidCreateElementOpcode; var ShadowAttributesOpcode = (function (_Opcode5) { - _inherits(ShadowAttributesOpcode, _Opcode5); + babelHelpers.inherits(ShadowAttributesOpcode, _Opcode5); function ShadowAttributesOpcode() { - _classCallCheck(this, ShadowAttributesOpcode); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _Opcode5.call.apply(_Opcode5, [this].concat(args)); + _Opcode5.apply(this, arguments); this.type = "shadow-attributes"; } ShadowAttributesOpcode.prototype.evaluate = function evaluate(vm) { - var args = vm.frame.getArgs(); - var internal = args.internal; - var shadow = internal['shadow']; - var named = args.named; + var shadow = vm.frame.getShadow(); if (!shadow) return; + + var _vm$frame$getArgs = vm.frame.getArgs(); + + var named = _vm$frame$getArgs.named; + shadow.forEach(function (name) { - vm.stack().setAttribute(name, named.get(name), false); + vm.stack().setDynamicAttribute(name, named.get(name), false); }); }; ShadowAttributesOpcode.prototype.toJSON = function toJSON() { return { @@ -16283,21 +16828,63 @@ return ShadowAttributesOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.ShadowAttributesOpcode = ShadowAttributesOpcode; - var CloseComponentOpcode = (function (_Opcode6) { - _inherits(CloseComponentOpcode, _Opcode6); + var DidRenderLayoutOpcode = (function (_Opcode6) { + babelHelpers.inherits(DidRenderLayoutOpcode, _Opcode6); - function CloseComponentOpcode() { - _classCallCheck(this, CloseComponentOpcode); + function DidRenderLayoutOpcode() { + _Opcode6.apply(this, arguments); + this.type = "did-render-layout"; + } - for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } + DidRenderLayoutOpcode.prototype.evaluate = function evaluate(vm) { + var manager = vm.frame.getManager(); + var component = vm.frame.getComponent(); + var bounds = vm.stack().popBlock(); + manager.didRenderLayout(component, bounds); + vm.env.didCreate(component, manager); + vm.updateWith(new DidUpdateLayoutOpcode(manager, component, bounds)); + }; - _Opcode6.call.apply(_Opcode6, [this].concat(args)); + return DidRenderLayoutOpcode; + })(_glimmerRuntimeLibOpcodes.Opcode); + + exports.DidRenderLayoutOpcode = DidRenderLayoutOpcode; + + var DidUpdateLayoutOpcode = (function (_UpdatingOpcode2) { + babelHelpers.inherits(DidUpdateLayoutOpcode, _UpdatingOpcode2); + + function DidUpdateLayoutOpcode(manager, component, bounds) { + _UpdatingOpcode2.call(this); + this.manager = manager; + this.component = component; + this.bounds = bounds; + this.type = "did-update-layout"; + this.tag = _glimmerReference.CONSTANT_TAG; + } + + DidUpdateLayoutOpcode.prototype.evaluate = function evaluate(vm) { + var manager = this.manager; + var component = this.component; + var bounds = this.bounds; + + manager.didUpdateLayout(component, bounds); + vm.env.didUpdate(component, manager); + }; + + return DidUpdateLayoutOpcode; + })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); + + exports.DidUpdateLayoutOpcode = DidUpdateLayoutOpcode; + + var CloseComponentOpcode = (function (_Opcode7) { + babelHelpers.inherits(CloseComponentOpcode, _Opcode7); + + function CloseComponentOpcode() { + _Opcode7.apply(this, arguments); this.type = "close-component"; } CloseComponentOpcode.prototype.evaluate = function evaluate(vm) { vm.popScope(); @@ -16308,24 +16895,18 @@ return CloseComponentOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.CloseComponentOpcode = CloseComponentOpcode; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/component.ts"],"names":[],"mappings":"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","file":"component.js","sourcesContent":["import { Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { Assert } from './vm';\nimport { Component, ComponentManager, ComponentDefinition } from '../../component/interfaces';\nimport { VM, UpdatingVM } from '../../vm';\nimport { CompiledArgs, EvaluatedArgs } from '../../compiled/expressions/args';\nimport { Templates } from '../../syntax/core';\nimport { DynamicScope } from '../../environment';\nimport { InternedString, Opaque } from 'glimmer-util';\nimport { ReferenceCache, Revision, combine, isConst } from 'glimmer-reference';\n\nexport class PutDynamicComponentDefinitionOpcode extends Opcode {\n  public type = \"put-dynamic-component-definition\";\n\n  private args: CompiledArgs;\n\n  constructor({ args }: { args: CompiledArgs }) {\n    super();\n    this.args = args;\n  }\n\n  evaluate(vm: VM) {\n    let definitionRef = vm.frame.getOperand();\n    let cache = isConst(definitionRef) ? undefined : new ReferenceCache(definitionRef);\n    let definition = cache ? cache.peek() : definitionRef.value();\n\n    let args = this.args.evaluate(vm).withInternal();\n    vm.frame.setArgs(args);\n    args.internal[\"definition\"] = definition;\n\n    if (cache) {\n      vm.updateWith(new Assert(cache));\n    }\n  }\n}\n\nexport interface PutComponentDefinitionOptions {\n  args: CompiledArgs;\n  definition: ComponentDefinition<Opaque>;\n}\n\nexport class PutComponentDefinitionOpcode extends Opcode {\n  public type = \"put-component-definition\";\n  private args: CompiledArgs;\n  private definition: ComponentDefinition<Opaque>;\n\n  constructor({ args, definition }: PutComponentDefinitionOptions) {\n    super();\n    this.args = args;\n    this.definition = definition;\n  }\n\n  evaluate(vm: VM) {\n    let args = this.args.evaluate(vm).withInternal();\n    args.internal[\"definition\"] = this.definition;\n    vm.frame.setArgs(args);\n  }\n}\n\nexport interface OpenComponentOptions {\n  shadow: InternedString[];\n  templates: Templates;\n}\n\nexport class OpenComponentOpcode extends Opcode {\n  public type = \"open-component\";\n  public definition: ComponentDefinition<Opaque>;\n  public args: CompiledArgs;\n  public shadow: InternedString[];\n  public templates: Templates;\n\n  constructor({ shadow, templates }: OpenComponentOptions) {\n    super();\n    this.shadow = shadow;\n    this.templates = templates;\n  }\n\n  evaluate(vm: VM) {\n    let { shadow, templates } = this;\n    let args = vm.frame.getArgs();\n    let definition = args.internal[\"definition\"] as ComponentDefinition<Opaque>;\n\n    vm.pushDynamicScope();\n    let dynamicScope = vm.dynamicScope();\n\n    let manager = definition.manager;\n    let hasDefaultBlock = templates && !!templates.default; // TODO Cleanup?\n    let preparedArgs = manager.prepareArgs(definition, args);\n    let component = manager.create(definition, preparedArgs, dynamicScope, hasDefaultBlock);\n    let destructor = manager.getDestructor(component);\n    if (destructor) vm.newDestroyable(destructor);\n    preparedArgs.internal[\"component\"] = component;\n    preparedArgs.internal[\"definition\"] = definition;\n    preparedArgs.internal[\"shadow\"] = shadow;\n\n    vm.beginCacheGroup();\n    let layout = manager.layoutFor(definition, component, vm.env);\n    let callerScope = vm.scope();\n    let selfRef = manager.getSelf(component);\n    vm.pushRootScope(selfRef, layout.symbols);\n    vm.invokeLayout({ templates, args: preparedArgs, shadow, layout, callerScope });\n    vm.env.didCreate(component, manager);\n\n    vm.updateWith(new UpdateComponentOpcode({ name: definition.name, component, manager, args: preparedArgs, dynamicScope }));\n  }\n}\n\nexport class UpdateComponentOpcode extends UpdatingOpcode {\n  public type = \"update-component\";\n\n  private name: string;\n  private component: Component;\n  private manager: ComponentManager<Opaque>;\n  private args: EvaluatedArgs;\n  private dynamicScope: DynamicScope;\n  private lastUpdated: Revision;\n\n  constructor({ name, component, manager, args, dynamicScope } : { name: string, component: Component, manager: ComponentManager<any>, args: EvaluatedArgs, dynamicScope: DynamicScope }) {\n    super();\n\n    let tag;\n    let componentTag = manager.getTag(component);\n\n    if (componentTag) {\n      tag = this.tag = combine([args.tag, componentTag]);\n    } else {\n      tag = this.tag = args.tag;\n    }\n\n    this.name = name;\n    this.component = component;\n    this.manager = manager;\n    this.args = args;\n    this.dynamicScope = dynamicScope;\n    this.lastUpdated = tag.value();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { component, manager, tag, args, dynamicScope, lastUpdated } = this;\n\n    if (!tag.validate(lastUpdated)) {\n      manager.update(component, args, dynamicScope);\n      vm.env.didUpdate(component, manager);\n      this.lastUpdated = tag.value();\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.name)]\n    };\n  }\n}\n\nexport class DidCreateElementOpcode extends Opcode {\n  public type = \"did-create-element\";\n\n  evaluate(vm: VM) {\n    let args = vm.frame.getArgs();\n    let internal = args.internal;\n    let definition = internal['definition'] as ComponentDefinition<Opaque>;\n    let manager = definition.manager;\n    let component: Component = internal['component'];\n\n    manager.didCreateElement(component, vm.stack().element, vm.stack().elementOperations);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$ARGS\"]\n    };\n  }\n}\n\n// Slow path for non-specialized component invocations. Uses an internal\n// named lookup on the args.\nexport class ShadowAttributesOpcode extends Opcode {\n  public type = \"shadow-attributes\";\n\n  evaluate(vm: VM) {\n    let args = vm.frame.getArgs();\n    let internal = args.internal;\n    let shadow: InternedString[] = internal['shadow'] as InternedString[];\n\n    let named = args.named;\n\n    if (!shadow) return;\n\n    shadow.forEach(name => {\n      vm.stack().setAttribute(name, named.get(name), false);\n    });\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$ARGS\"]\n    };\n  }\n}\n\nexport class CloseComponentOpcode extends Opcode {\n  public type = \"close-component\";\n\n  evaluate(vm: VM) {\n    vm.popScope();\n    vm.popDynamicScope();\n    vm.commitCacheGroup();\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/component.ts"],"names":[],"mappings":"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","file":"component.js","sourcesContent":["import { Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { Assert } from './vm';\nimport { Component, ComponentManager, ComponentDefinition } from '../../component/interfaces';\nimport { VM, UpdatingVM } from '../../vm';\nimport { CompiledArgs, EvaluatedArgs } from '../../compiled/expressions/args';\nimport { Templates } from '../../syntax/core';\nimport { DynamicScope } from '../../environment';\nimport Bounds from '../../bounds';\nimport { CONSTANT_TAG, PathReference, ReferenceCache, combine, isConst } from 'glimmer-reference';\nimport { FIXME } from 'glimmer-util';\n\nexport class PutDynamicComponentDefinitionOpcode extends Opcode {\n  public type = \"put-dynamic-component-definition\";\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getOperand();\n    let cache = isConst(reference) ? undefined : new ReferenceCache(reference);\n    let definition = cache ? cache.peek() : reference.value();\n\n    vm.frame.setComponentDefinition(definition);\n\n    if (cache) {\n      vm.updateWith(new Assert(cache));\n    }\n  }\n}\n\nexport class PutComponentDefinitionOpcode extends Opcode {\n  public type = \"put-component-definition\";\n\n  constructor(private definition: ComponentDefinition<Component>) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.frame.setComponentDefinition(this.definition);\n  }\n}\n\nexport class OpenComponentOpcode extends Opcode {\n  public type = \"open-component\";\n\n  constructor(\n    private args: CompiledArgs,\n    private shadow: string[],\n    private templates: Templates\n  ) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    let { args: rawArgs, shadow, templates } = this;\n\n    let definition = vm.frame.getComponentDefinition();\n    let dynamicScope = vm.pushDynamicScope();\n    let callerScope = vm.scope();\n\n    let manager = definition.manager;\n    let hasDefaultBlock = templates && !!templates.default; // TODO Cleanup?\n    let args = manager.prepareArgs(definition, rawArgs.evaluate(vm));\n    let component = manager.create(vm.env, definition, args, dynamicScope, vm.getSelf(), hasDefaultBlock);\n    let destructor = manager.getDestructor(component);\n    if (destructor) vm.newDestroyable(destructor);\n\n    let layout = manager.layoutFor(definition, component, vm.env);\n    let selfRef = manager.getSelf(component);\n\n    vm.beginCacheGroup();\n    vm.stack().pushSimpleBlock();\n    vm.pushRootScope(selfRef, layout.symbols);\n    vm.invokeLayout(args, layout, templates, callerScope, component, manager, shadow);\n\n    vm.updateWith(new UpdateComponentOpcode(definition.name, component, manager, args, dynamicScope));\n  }\n}\n\nexport class UpdateComponentOpcode extends UpdatingOpcode {\n  public type = \"update-component\";\n\n  constructor(\n    private name: string,\n    private component: Component,\n    private manager: ComponentManager<Component>,\n    private args: EvaluatedArgs,\n    private dynamicScope: DynamicScope,\n  ) {\n    super();\n\n    let componentTag = manager.getTag(component);\n\n    if (componentTag) {\n      this.tag = combine([args.tag, componentTag]);\n    } else {\n      this.tag = args.tag;\n    }\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { component, manager, args, dynamicScope } = this;\n\n    manager.update(component, args, dynamicScope);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.name)]\n    };\n  }\n}\n\nexport class DidCreateElementOpcode extends Opcode {\n  public type = \"did-create-element\";\n\n  evaluate(vm: VM) {\n    let manager = vm.frame.getManager();\n    let component = vm.frame.getComponent();\n\n    manager.didCreateElement(component, vm.stack().constructing, vm.stack().operations);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$ARGS\"]\n    };\n  }\n}\n\n// Slow path for non-specialized component invocations. Uses an internal\n// named lookup on the args.\nexport class ShadowAttributesOpcode extends Opcode {\n  public type = \"shadow-attributes\";\n\n  evaluate(vm: VM) {\n    let shadow = vm.frame.getShadow();\n\n    if (!shadow) return;\n\n    let { named } = vm.frame.getArgs();\n\n    shadow.forEach(name => {\n      vm.stack().setDynamicAttribute(name, named.get(name) as FIXME<PathReference<string>, 'setDynamicAttribute should take an Ref<Opaque> instead'>, false);\n    });\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$ARGS\"]\n    };\n  }\n}\n\nexport class DidRenderLayoutOpcode extends Opcode {\n  public type = \"did-render-layout\";\n\n  evaluate(vm: VM) {\n    let manager = vm.frame.getManager();\n    let component = vm.frame.getComponent();\n    let bounds = vm.stack().popBlock();\n\n    manager.didRenderLayout(component, bounds);\n\n    vm.env.didCreate(component, manager);\n\n    vm.updateWith(new DidUpdateLayoutOpcode(manager, component, bounds));\n  }\n}\n\nexport class DidUpdateLayoutOpcode extends UpdatingOpcode {\n  public type = \"did-update-layout\";\n  public tag = CONSTANT_TAG;\n\n  constructor(\n    private manager: ComponentManager<Component>,\n    private component: Component,\n    private bounds: Bounds\n  ) {\n    super();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { manager, component, bounds } = this;\n\n    manager.didUpdateLayout(component, bounds);\n\n    vm.env.didUpdate(component, manager);\n  }\n}\n\nexport class CloseComponentOpcode extends Opcode {\n  public type = \"close-component\";\n\n  evaluate(vm: VM) {\n    vm.popScope();\n    vm.popDynamicScope();\n    vm.commitCacheGroup();\n  }\n}\n","import { Opcode, UpdatingOpcode } from '../../opcodes';\nimport { Assert } from './vm';\nimport { CONSTANT_TAG, ReferenceCache, combine, isConst } from 'glimmer-reference';\nexport class PutDynamicComponentDefinitionOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"put-dynamic-component-definition\";\n    }\n    evaluate(vm) {\n        let reference = vm.frame.getOperand();\n        let cache = isConst(reference) ? undefined : new ReferenceCache(reference);\n        let definition = cache ? cache.peek() : reference.value();\n        vm.frame.setComponentDefinition(definition);\n        if (cache) {\n            vm.updateWith(new Assert(cache));\n        }\n    }\n}\nexport class PutComponentDefinitionOpcode extends Opcode {\n    constructor(definition) {\n        super();\n        this.definition = definition;\n        this.type = \"put-component-definition\";\n    }\n    evaluate(vm) {\n        vm.frame.setComponentDefinition(this.definition);\n    }\n}\nexport class OpenComponentOpcode extends Opcode {\n    constructor(args, shadow, templates) {\n        super();\n        this.args = args;\n        this.shadow = shadow;\n        this.templates = templates;\n        this.type = \"open-component\";\n    }\n    evaluate(vm) {\n        let { args: rawArgs, shadow, templates } = this;\n        let definition = vm.frame.getComponentDefinition();\n        let dynamicScope = vm.pushDynamicScope();\n        let callerScope = vm.scope();\n        let manager = definition.manager;\n        let hasDefaultBlock = templates && !!templates.default; // TODO Cleanup?\n        let args = manager.prepareArgs(definition, rawArgs.evaluate(vm));\n        let component = manager.create(vm.env, definition, args, dynamicScope, vm.getSelf(), hasDefaultBlock);\n        let destructor = manager.getDestructor(component);\n        if (destructor)\n            vm.newDestroyable(destructor);\n        let layout = manager.layoutFor(definition, component, vm.env);\n        let selfRef = manager.getSelf(component);\n        vm.beginCacheGroup();\n        vm.stack().pushSimpleBlock();\n        vm.pushRootScope(selfRef, layout.symbols);\n        vm.invokeLayout(args, layout, templates, callerScope, component, manager, shadow);\n        vm.updateWith(new UpdateComponentOpcode(definition.name, component, manager, args, dynamicScope));\n    }\n}\nexport class UpdateComponentOpcode extends UpdatingOpcode {\n    constructor(name, component, manager, args, dynamicScope) {\n        super();\n        this.name = name;\n        this.component = component;\n        this.manager = manager;\n        this.args = args;\n        this.dynamicScope = dynamicScope;\n        this.type = \"update-component\";\n        let componentTag = manager.getTag(component);\n        if (componentTag) {\n            this.tag = combine([args.tag, componentTag]);\n        }\n        else {\n            this.tag = args.tag;\n        }\n    }\n    evaluate(vm) {\n        let { component, manager, args, dynamicScope } = this;\n        manager.update(component, args, dynamicScope);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.name)]\n        };\n    }\n}\nexport class DidCreateElementOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"did-create-element\";\n    }\n    evaluate(vm) {\n        let manager = vm.frame.getManager();\n        let component = vm.frame.getComponent();\n        manager.didCreateElement(component, vm.stack().constructing, vm.stack().operations);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [\"$ARGS\"]\n        };\n    }\n}\n// Slow path for non-specialized component invocations. Uses an internal\n// named lookup on the args.\nexport class ShadowAttributesOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"shadow-attributes\";\n    }\n    evaluate(vm) {\n        let shadow = vm.frame.getShadow();\n        if (!shadow)\n            return;\n        let { named } = vm.frame.getArgs();\n        shadow.forEach(name => {\n            vm.stack().setDynamicAttribute(name, named.get(name), false);\n        });\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [\"$ARGS\"]\n        };\n    }\n}\nexport class DidRenderLayoutOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"did-render-layout\";\n    }\n    evaluate(vm) {\n        let manager = vm.frame.getManager();\n        let component = vm.frame.getComponent();\n        let bounds = vm.stack().popBlock();\n        manager.didRenderLayout(component, bounds);\n        vm.env.didCreate(component, manager);\n        vm.updateWith(new DidUpdateLayoutOpcode(manager, component, bounds));\n    }\n}\nexport class DidUpdateLayoutOpcode extends UpdatingOpcode {\n    constructor(manager, component, bounds) {\n        super();\n        this.manager = manager;\n        this.component = component;\n        this.bounds = bounds;\n        this.type = \"did-update-layout\";\n        this.tag = CONSTANT_TAG;\n    }\n    evaluate(vm) {\n        let { manager, component, bounds } = this;\n        manager.didUpdateLayout(component, bounds);\n        vm.env.didUpdate(component, manager);\n    }\n}\nexport class CloseComponentOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"close-component\";\n    }\n    evaluate(vm) {\n        vm.popScope();\n        vm.popDynamicScope();\n        vm.commitCacheGroup();\n    }\n}\n"]} enifed('glimmer-runtime/lib/compiled/opcodes/content', ['exports', 'glimmer-runtime/lib/upsert', 'glimmer-runtime/lib/component/interfaces', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/vm/update', 'glimmer-reference', 'glimmer-util', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/builder', 'glimmer-runtime/lib/compiler', 'glimmer-runtime/lib/compiled/opcodes/builder', 'glimmer-runtime/lib/references', 'glimmer-runtime/lib/syntax/core'], function (exports, _glimmerRuntimeLibUpsert, _glimmerRuntimeLibComponentInterfaces, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibVmUpdate, _glimmerReference, _glimmerUtil, _glimmerRuntimeLibBounds, _glimmerRuntimeLibBuilder, _glimmerRuntimeLibCompiler, _glimmerRuntimeLibCompiledOpcodesBuilder, _glimmerRuntimeLibReferences, _glimmerRuntimeLibSyntaxCore) { 'use strict'; exports.normalizeTextValue = normalizeTextValue; exports.normalizeTrustedValue = normalizeTrustedValue; exports.normalizeValue = normalizeValue; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - function isEmpty(value) { return value === null || value === undefined || typeof value['toString'] !== 'function'; } function normalizeTextValue(value) { @@ -16363,15 +16944,13 @@ } return String(value); } var AppendOpcode = (function (_Opcode) { - _inherits(AppendOpcode, _Opcode); + babelHelpers.inherits(AppendOpcode, _Opcode); function AppendOpcode() { - _classCallCheck(this, AppendOpcode); - _Opcode.apply(this, arguments); } AppendOpcode.prototype.evaluate = function evaluate(vm) { var reference = vm.frame.getOperand(); @@ -16383,11 +16962,11 @@ } else { cache = new _glimmerReference.ReferenceCache(normalized); value = cache.peek(); } var stack = vm.stack(); - var upsert = this.insert(stack.dom, stack, value); + var upsert = this.insert(vm.env.getAppendOperations(), stack, value); var bounds = new _glimmerRuntimeLibBuilder.Fragment(upsert.bounds); stack.newBounds(bounds); if (cache /* i.e. !isConst(reference) */) { vm.updateWith(this.updateWith(vm, reference, cache, bounds, upsert)); } @@ -16405,18 +16984,17 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.AppendOpcode = AppendOpcode; var GuardedAppendOpcode = (function (_AppendOpcode) { - _inherits(GuardedAppendOpcode, _AppendOpcode); + babelHelpers.inherits(GuardedAppendOpcode, _AppendOpcode); - function GuardedAppendOpcode(expression) { - _classCallCheck(this, GuardedAppendOpcode); - + function GuardedAppendOpcode(expression, symbolTable) { _AppendOpcode.call(this); - this.deopted = null; this.expression = expression; + this.symbolTable = symbolTable; + this.deopted = null; } GuardedAppendOpcode.prototype.evaluate = function evaluate(vm) { if (this.deopted) { vm.pushEvalFrame(this.deopted); @@ -16476,18 +17054,18 @@ // it is still possible (although quite rare) that the simple value we // encounter during initial render could later change into a component // definition object at update time. That is handled by the "lazy deopt" // code on the update side (scroll down for the next big block of comment). var buffer = new _glimmerRuntimeLibCompiler.CompileIntoList(env, null); - var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(buffer, null, env); + var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(buffer, this.symbolTable, env); dsl.block({ templates: null }, function (dsl, BEGIN, END) { dsl.putValue(_this.expression); dsl.test(IsComponentDefinitionReference.create); dsl.jumpUnless('VALUE'); dsl.label('COMPONENT'); - dsl.putDynamicComponentDefinition(_glimmerRuntimeLibSyntaxCore.Args.empty()); - dsl.openComponent(); + dsl.putDynamicComponentDefinition(); + dsl.openComponent(_glimmerRuntimeLibSyntaxCore.Args.empty()); dsl.closeComponent(); dsl.jump(END); dsl.label('VALUE'); dsl.append(new _this.AppendOpcode()); }); @@ -16527,15 +17105,13 @@ })(AppendOpcode); exports.GuardedAppendOpcode = GuardedAppendOpcode; var IsComponentDefinitionReference = (function (_ConditionalReference) { - _inherits(IsComponentDefinitionReference, _ConditionalReference); + babelHelpers.inherits(IsComponentDefinitionReference, _ConditionalReference); function IsComponentDefinitionReference() { - _classCallCheck(this, IsComponentDefinitionReference); - _ConditionalReference.apply(this, arguments); } IsComponentDefinitionReference.create = function create(inner) { return new IsComponentDefinitionReference(inner); @@ -16547,15 +17123,13 @@ return IsComponentDefinitionReference; })(_glimmerRuntimeLibReferences.ConditionalReference); var UpdateOpcode = (function (_UpdatingOpcode) { - _inherits(UpdateOpcode, _UpdatingOpcode); + babelHelpers.inherits(UpdateOpcode, _UpdatingOpcode); function UpdateOpcode(cache, bounds, upsert) { - _classCallCheck(this, UpdateOpcode); - _UpdatingOpcode.call(this); this.cache = cache; this.bounds = bounds; this.upsert = upsert; this.tag = cache.tag; @@ -16568,11 +17142,11 @@ var upsert = this.upsert; var dom = vm.dom; if (!this.upsert.update(dom, value)) { var cursor = new _glimmerRuntimeLibBounds.Cursor(bounds.parentElement(), _glimmerRuntimeLibBounds.clear(bounds)); - upsert = this.upsert = this.insert(dom, cursor, value); + upsert = this.upsert = this.insert(vm.env.getAppendOperations(), cursor, value); } bounds.update(upsert.bounds); } }; @@ -16590,22 +17164,19 @@ return UpdateOpcode; })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); var GuardedUpdateOpcode = (function (_UpdateOpcode) { - _inherits(GuardedUpdateOpcode, _UpdateOpcode); + babelHelpers.inherits(GuardedUpdateOpcode, _UpdateOpcode); function GuardedUpdateOpcode(reference, cache, bounds, upsert, appendOpcode, state) { - _classCallCheck(this, GuardedUpdateOpcode); - _UpdateOpcode.call(this, cache, bounds, upsert); this.reference = reference; this.appendOpcode = appendOpcode; this.state = state; this.deopted = null; this.tag = this._tag = new _glimmerReference.UpdatableTag(this.tag); - this.state.block = null; } GuardedUpdateOpcode.prototype.evaluate = function evaluate(vm) { if (this.deopted) { vm.evaluateOpcode(this.deopted); @@ -16653,14 +17224,14 @@ var state = this.state; var appendOps = appendOpcode.deopt(vm.env); var enter = appendOps.head(); var ops = enter.slice; - var tracker = state.block = new _glimmerRuntimeLibBuilder.BlockTracker(bounds.parentElement()); + var tracker = new _glimmerRuntimeLibBuilder.UpdatableBlockTracker(bounds.parentElement()); tracker.newBounds(this.bounds); var children = new _glimmerUtil.LinkedList(); - var deopted = this.deopted = new _glimmerRuntimeLibVmUpdate.TryOpcode({ ops: ops, state: state, children: children }); + var deopted = this.deopted = new _glimmerRuntimeLibVmUpdate.TryOpcode(ops, state, tracker, children); this._tag.update(deopted.tag); vm.evaluateOpcode(deopted); vm.throw(); // From this point on, we have essentially replaced ourselve with a new // opcode. Since we will always be executing the new/deopted code, it's a @@ -16696,20 +17267,14 @@ })(UpdateOpcode); exports.GuardedUpdateOpcode = GuardedUpdateOpcode; var OptimizedCautiousAppendOpcode = (function (_AppendOpcode2) { - _inherits(OptimizedCautiousAppendOpcode, _AppendOpcode2); + babelHelpers.inherits(OptimizedCautiousAppendOpcode, _AppendOpcode2); function OptimizedCautiousAppendOpcode() { - _classCallCheck(this, OptimizedCautiousAppendOpcode); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _AppendOpcode2.call.apply(_AppendOpcode2, [this].concat(args)); + _AppendOpcode2.apply(this, arguments); this.type = 'optimized-cautious-append'; } OptimizedCautiousAppendOpcode.prototype.normalize = function normalize(reference) { return _glimmerReference.map(reference, normalizeValue); @@ -16727,20 +17292,14 @@ })(AppendOpcode); exports.OptimizedCautiousAppendOpcode = OptimizedCautiousAppendOpcode; var OptimizedCautiousUpdateOpcode = (function (_UpdateOpcode2) { - _inherits(OptimizedCautiousUpdateOpcode, _UpdateOpcode2); + babelHelpers.inherits(OptimizedCautiousUpdateOpcode, _UpdateOpcode2); function OptimizedCautiousUpdateOpcode() { - _classCallCheck(this, OptimizedCautiousUpdateOpcode); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _UpdateOpcode2.call.apply(_UpdateOpcode2, [this].concat(args)); + _UpdateOpcode2.apply(this, arguments); this.type = 'optimized-cautious-update'; } OptimizedCautiousUpdateOpcode.prototype.insert = function insert(dom, cursor, value) { return _glimmerRuntimeLibUpsert.cautiousInsert(dom, cursor, value); @@ -16748,20 +17307,14 @@ return OptimizedCautiousUpdateOpcode; })(UpdateOpcode); var GuardedCautiousAppendOpcode = (function (_GuardedAppendOpcode) { - _inherits(GuardedCautiousAppendOpcode, _GuardedAppendOpcode); + babelHelpers.inherits(GuardedCautiousAppendOpcode, _GuardedAppendOpcode); function GuardedCautiousAppendOpcode() { - _classCallCheck(this, GuardedCautiousAppendOpcode); - - for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } - - _GuardedAppendOpcode.call.apply(_GuardedAppendOpcode, [this].concat(args)); + _GuardedAppendOpcode.apply(this, arguments); this.type = 'guarded-cautious-append'; this.AppendOpcode = OptimizedCautiousAppendOpcode; } GuardedCautiousAppendOpcode.prototype.normalize = function normalize(reference) { @@ -16780,20 +17333,14 @@ })(GuardedAppendOpcode); exports.GuardedCautiousAppendOpcode = GuardedCautiousAppendOpcode; var GuardedCautiousUpdateOpcode = (function (_GuardedUpdateOpcode) { - _inherits(GuardedCautiousUpdateOpcode, _GuardedUpdateOpcode); + babelHelpers.inherits(GuardedCautiousUpdateOpcode, _GuardedUpdateOpcode); function GuardedCautiousUpdateOpcode() { - _classCallCheck(this, GuardedCautiousUpdateOpcode); - - for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { - args[_key4] = arguments[_key4]; - } - - _GuardedUpdateOpcode.call.apply(_GuardedUpdateOpcode, [this].concat(args)); + _GuardedUpdateOpcode.apply(this, arguments); this.type = 'guarded-cautious-update'; } GuardedCautiousUpdateOpcode.prototype.insert = function insert(dom, cursor, value) { return _glimmerRuntimeLibUpsert.cautiousInsert(dom, cursor, value); @@ -16801,20 +17348,14 @@ return GuardedCautiousUpdateOpcode; })(GuardedUpdateOpcode); var OptimizedTrustingAppendOpcode = (function (_AppendOpcode3) { - _inherits(OptimizedTrustingAppendOpcode, _AppendOpcode3); + babelHelpers.inherits(OptimizedTrustingAppendOpcode, _AppendOpcode3); function OptimizedTrustingAppendOpcode() { - _classCallCheck(this, OptimizedTrustingAppendOpcode); - - for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { - args[_key5] = arguments[_key5]; - } - - _AppendOpcode3.call.apply(_AppendOpcode3, [this].concat(args)); + _AppendOpcode3.apply(this, arguments); this.type = 'optimized-trusting-append'; } OptimizedTrustingAppendOpcode.prototype.normalize = function normalize(reference) { return _glimmerReference.map(reference, normalizeTrustedValue); @@ -16832,20 +17373,14 @@ })(AppendOpcode); exports.OptimizedTrustingAppendOpcode = OptimizedTrustingAppendOpcode; var OptimizedTrustingUpdateOpcode = (function (_UpdateOpcode3) { - _inherits(OptimizedTrustingUpdateOpcode, _UpdateOpcode3); + babelHelpers.inherits(OptimizedTrustingUpdateOpcode, _UpdateOpcode3); function OptimizedTrustingUpdateOpcode() { - _classCallCheck(this, OptimizedTrustingUpdateOpcode); - - for (var _len6 = arguments.length, args = Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { - args[_key6] = arguments[_key6]; - } - - _UpdateOpcode3.call.apply(_UpdateOpcode3, [this].concat(args)); + _UpdateOpcode3.apply(this, arguments); this.type = 'optimized-trusting-update'; } OptimizedTrustingUpdateOpcode.prototype.insert = function insert(dom, cursor, value) { return _glimmerRuntimeLibUpsert.trustingInsert(dom, cursor, value); @@ -16853,20 +17388,14 @@ return OptimizedTrustingUpdateOpcode; })(UpdateOpcode); var GuardedTrustingAppendOpcode = (function (_GuardedAppendOpcode2) { - _inherits(GuardedTrustingAppendOpcode, _GuardedAppendOpcode2); + babelHelpers.inherits(GuardedTrustingAppendOpcode, _GuardedAppendOpcode2); function GuardedTrustingAppendOpcode() { - _classCallCheck(this, GuardedTrustingAppendOpcode); - - for (var _len7 = arguments.length, args = Array(_len7), _key7 = 0; _key7 < _len7; _key7++) { - args[_key7] = arguments[_key7]; - } - - _GuardedAppendOpcode2.call.apply(_GuardedAppendOpcode2, [this].concat(args)); + _GuardedAppendOpcode2.apply(this, arguments); this.type = 'guarded-trusting-append'; this.AppendOpcode = OptimizedTrustingAppendOpcode; } GuardedTrustingAppendOpcode.prototype.normalize = function normalize(reference) { @@ -16885,48 +17414,34 @@ })(GuardedAppendOpcode); exports.GuardedTrustingAppendOpcode = GuardedTrustingAppendOpcode; var GuardedTrustingUpdateOpcode = (function (_GuardedUpdateOpcode2) { - _inherits(GuardedTrustingUpdateOpcode, _GuardedUpdateOpcode2); + babelHelpers.inherits(GuardedTrustingUpdateOpcode, _GuardedUpdateOpcode2); function GuardedTrustingUpdateOpcode() { - _classCallCheck(this, GuardedTrustingUpdateOpcode); - - for (var _len8 = arguments.length, args = Array(_len8), _key8 = 0; _key8 < _len8; _key8++) { - args[_key8] = arguments[_key8]; - } - - _GuardedUpdateOpcode2.call.apply(_GuardedUpdateOpcode2, [this].concat(args)); + _GuardedUpdateOpcode2.apply(this, arguments); this.type = 'trusting-update'; } GuardedTrustingUpdateOpcode.prototype.insert = function insert(dom, cursor, value) { return _glimmerRuntimeLibUpsert.trustingInsert(dom, cursor, value); }; return GuardedTrustingUpdateOpcode; })(GuardedUpdateOpcode); }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/content.ts"],"names":[],"mappings":"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","file":"content.js","sourcesContent":["import Upsert, {\n  Insertion,\n  CautiousInsertion,\n  TrustingInsertion,\n\n  isSafeString,\n  isNode,\n  isString,\n\n  cautiousInsert,\n  trustingInsert\n} from '../../upsert';\nimport { isComponentDefinition } from '../../component/interfaces';\nimport { DOMHelper } from '../../dom/helper';\nimport { OpSeq, Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { CompiledExpression } from '../expressions';\nimport { VM, UpdatingVM } from '../../vm';\nimport { TryOpcode, VMState } from '../../vm/update';\nimport { EnterOpcode } from './vm';\nimport { Reference, ReferenceCache, UpdatableTag, isModified, isConst, map } from 'glimmer-reference';\nimport { Opaque, LinkedList } from 'glimmer-util';\nimport { Cursor, clear } from '../../bounds';\nimport { Fragment } from '../../builder';\nimport { CompileIntoList } from '../../compiler';\nimport OpcodeBuilderDSL from './builder';\nimport { ConditionalReference } from '../../references';\nimport { Args } from '../../syntax/core';\nimport { Environment } from '../../environment';\nimport { BlockTracker } from '../../builder';\n\nfunction isEmpty(value: Opaque): boolean {\n  return value === null || value === undefined || typeof value['toString'] !== 'function';\n}\n\nexport function normalizeTextValue(value: Opaque): string {\n  if (isEmpty(value)) {\n    return '';\n  }\n  return String(value);\n}\n\nexport function normalizeTrustedValue(value: Opaque): TrustingInsertion {\n  if (isEmpty(value)) {\n    return '';\n  }\n  if (isString(value)) {\n    return value;\n  }\n  if (isSafeString(value)) {\n    return value.toHTML();\n  }\n  if (isNode(value)) {\n    return value;\n  }\n  return String(value);\n}\n\nexport function normalizeValue(value: Opaque): CautiousInsertion {\n  if (isEmpty(value)) {\n    return '';\n  }\n  if (isString(value)) {\n    return value;\n  }\n  if (isSafeString(value) || isNode(value)) {\n    return value;\n  }\n  return String(value);\n}\n\nexport abstract class AppendOpcode<T extends Insertion> extends Opcode {\n  protected abstract normalize(reference: Reference<Opaque>): Reference<T>;\n  protected abstract insert(dom: DOMHelper, cursor: Cursor, value: T): Upsert;\n  protected abstract updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<T>, bounds: Fragment, upsert: Upsert): UpdateOpcode<T>;\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getOperand();\n    let normalized = this.normalize(reference);\n\n    let value, cache;\n\n    if (isConst(reference)) {\n      value = normalized.value();\n    } else {\n      cache = new ReferenceCache(normalized);\n      value = cache.peek();\n    }\n\n    let stack = vm.stack();\n    let upsert = this.insert(stack.dom, stack, value);\n    let bounds = new Fragment(upsert.bounds);\n\n    stack.newBounds(bounds);\n\n    if (cache /* i.e. !isConst(reference) */) {\n      vm.updateWith(this.updateWith(vm, reference, cache, bounds, upsert));\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\"]\n    };\n  }\n}\n\nexport abstract class GuardedAppendOpcode<T extends Insertion> extends AppendOpcode<T> {\n  protected abstract AppendOpcode: typeof OptimizedCautiousAppendOpcode | typeof OptimizedTrustingAppendOpcode;\n  private expression: CompiledExpression<any>;\n  private deopted: OpSeq = null;\n\n  constructor(expression: CompiledExpression<any>) {\n    super();\n    this.expression = expression;\n  }\n\n  evaluate(vm: VM) {\n    if (this.deopted) {\n      vm.pushEvalFrame(this.deopted);\n    } else {\n      vm.evaluateOperand(this.expression);\n\n      let value = vm.frame.getOperand().value();\n\n      if(isComponentDefinition(value)) {\n        vm.pushEvalFrame(this.deopt(vm.env));\n      } else {\n        super.evaluate(vm);\n      }\n    }\n  }\n\n  public deopt(env: Environment): OpSeq { // Public because it's used in the lazy deopt\n    // At compile time, we determined that this append callsite might refer\n    // to a local variable/property lookup that resolves to a component\n    // definition at runtime.\n    //\n    // We could have eagerly compiled this callsite into something like this:\n    //\n    //   {{#if (is-component-definition foo)}}\n    //     {{component foo}}\n    //   {{else}}\n    //     {{foo}}\n    //   {{/if}}\n    //\n    // However, in practice, there might be a large amout of these callsites\n    // and most of them would resolve to a simple value lookup. Therefore, we\n    // tried to be optimistic and assumed that the callsite will resolve to\n    // appending a simple value.\n    //\n    // However, we have reached here because at runtime, the guard conditional\n    // have detected that this callsite is indeed referring to a component\n    // definition object. Since this is likely going to be true for other\n    // instances of the same callsite, it is now appropiate to deopt into the\n    // expanded version that handles both cases. The compilation would look\n    // like this:\n    //\n    //               Enter(BEGIN, END)\n    //   BEGIN:      Noop\n    //               Test(is-component-definition)\n    //               JumpUnless(VALUE)\n    //   COMPONENT:  Noop\n    //               PutDynamicComponentDefinitionOpcode\n    //               OpenComponent\n    //               CloseComponent\n    //               Jump(END)\n    //   VALUE:      Noop\n    //               OptimizedAppend\n    //   END:        Noop\n    //               Exit\n    //\n    // Keep in mind that even if we *don't* reach here at initial render time,\n    // it is still possible (although quite rare) that the simple value we\n    // encounter during initial render could later change into a component\n    // definition object at update time. That is handled by the \"lazy deopt\"\n    // code on the update side (scroll down for the next big block of comment).\n\n    let buffer = new CompileIntoList(env, null);\n    let dsl = new OpcodeBuilderDSL(buffer, null, env);\n\n    dsl.block({ templates: null }, (dsl, BEGIN, END) => {\n      dsl.putValue(this.expression);\n      dsl.test(IsComponentDefinitionReference.create);\n      dsl.jumpUnless('VALUE');\n      dsl.label('COMPONENT');\n      dsl.putDynamicComponentDefinition(Args.empty());\n      dsl.openComponent();\n      dsl.closeComponent();\n      dsl.jump(END);\n      dsl.label('VALUE');\n      dsl.append(new this.AppendOpcode());\n    });\n\n    let deopted = this.deopted = dsl.toOpSeq();\n\n    // From this point on, we have essentially replaced ourselve with a new set\n    // of opcodes. Since we will always be executing the new/deopted code, it's\n    // a good idea (as a pattern) to null out any unneeded fields here to avoid\n    // holding on to unneeded/stale objects:\n\n    this.expression = null;\n\n    return deopted;\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, deopted } = this;\n\n    if (deopted) {\n      return {\n        guid,\n        type,\n        deopted: true,\n        children: deopted.toArray().map(op => op.toJSON())\n      };\n    } else {\n      return {\n        guid,\n        type,\n        args: [this.expression.toJSON()]\n      };\n    }\n  }\n}\n\nclass IsComponentDefinitionReference extends ConditionalReference {\n  static create(inner: Reference<Opaque>): IsComponentDefinitionReference {\n    return new IsComponentDefinitionReference(inner);\n  }\n\n  toBool(value: Opaque): boolean {\n    return isComponentDefinition(value);\n  }\n}\n\nabstract class UpdateOpcode<T extends Insertion> extends UpdatingOpcode {\n  constructor(\n    protected cache: ReferenceCache<T>,\n    protected bounds: Fragment,\n    protected upsert: Upsert\n  ) {\n    super();\n    this.tag = cache.tag;\n  }\n\n  protected abstract insert(dom: DOMHelper, cursor: Cursor, value: T): Upsert;\n\n  evaluate(vm: UpdatingVM) {\n    let value = this.cache.revalidate();\n\n    if (isModified(value)) {\n      let { bounds, upsert } = this;\n      let { dom } = vm;\n\n      if(!this.upsert.update(dom, value)) {\n        let cursor = new Cursor(bounds.parentElement(), clear(bounds));\n        upsert = this.upsert = this.insert(dom, cursor, value);\n      }\n\n      bounds.update(upsert.bounds);\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, cache } = this;\n\n    return {\n      guid,\n      type,\n      details: { lastValue: JSON.stringify(cache.peek()) }\n    };\n  }\n}\n\nexport abstract class GuardedUpdateOpcode<T extends Insertion> extends UpdateOpcode<T> {\n  private _tag: UpdatableTag;\n  private deopted: TryOpcode = null;\n\n  constructor(\n    private reference: Reference<Opaque>,\n    cache: ReferenceCache<T>,\n    bounds: Fragment,\n    upsert: Upsert,\n    private appendOpcode: GuardedAppendOpcode<T>,\n    private state: VMState\n  ) {\n    super(cache, bounds, upsert);\n    this.tag = this._tag = new UpdatableTag(this.tag);\n    this.state.block = null;\n  }\n\n  evaluate(vm: UpdatingVM) {\n    if (this.deopted) {\n      vm.evaluateOpcode(this.deopted);\n    } else {\n      if (isComponentDefinition(this.reference.value())) {\n        this.lazyDeopt(vm);\n      } else {\n        super.evaluate(vm);\n      }\n    }\n  }\n\n  private lazyDeopt(vm: UpdatingVM) {\n    // Durign initial render, we know that the reference does not contain a\n    // component definition, so we optimistically assumed that this append\n    // is just a normal append. However, at update time, we discovered that\n    // the reference has switched into containing a component definition, so\n    // we need to do a \"lazy deopt\", simulating what would have happened if\n    // we had decided to perform the deopt in the first place during initial\n    // render.\n    //\n    // More concretely, we would have expanded the curly into a if/else, and\n    // based on whether the value is a component definition or not, we would\n    // have entered either the dynamic component branch or the simple value\n    // branch.\n    //\n    // Since we rendered a simple value during initial render (and all the\n    // updates up until this point), we need to pretend that the result is\n    // produced by the \"VALUE\" branch of the deopted append opcode:\n    //\n    //   Try(BEGIN, END)\n    //     Assert(IsComponentDefinition, expected=false)\n    //     OptimizedUpdate\n    //\n    // In this case, because the reference has switched from being a simple\n    // value into a component definition, what would have happened is that\n    // the assert would throw, causing the Try opcode to teardown the bounds\n    // and rerun the original append opcode.\n    //\n    // Since the Try opcode would have nuked the updating opcodes anyway, we\n    // wouldn't have to worry about simulating those. All we have to do is to\n    // execute the Try opcode and immediately throw.\n\n    let { bounds, appendOpcode, state } = this;\n\n    let appendOps = appendOpcode.deopt(vm.env);\n    let enter     = appendOps.head() as EnterOpcode;\n    let ops       = enter.slice;\n\n    let tracker = state.block = new BlockTracker(bounds.parentElement());\n    tracker.newBounds(this.bounds);\n\n    let children = new LinkedList<UpdatingOpcode>();\n\n    let deopted = this.deopted = new TryOpcode({ ops, state, children });\n\n    this._tag.update(deopted.tag);\n\n    vm.evaluateOpcode(deopted);\n    vm.throw();\n\n    // From this point on, we have essentially replaced ourselve with a new\n    // opcode. Since we will always be executing the new/deopted code, it's a\n    // good idea (as a pattern) to null out any unneeded fields here to avoid\n    // holding on to unneeded/stale objects:\n\n    this._tag         = null;\n    this.reference    = null;\n    this.cache        = null;\n    this.bounds       = null;\n    this.upsert       = null;\n    this.appendOpcode = null;\n    this.state        = null;\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, deopted } = this;\n\n    if (deopted) {\n      return {\n        guid,\n        type,\n        deopted: true,\n        children: [deopted.toJSON()]\n      };\n    } else {\n      return super.toJSON();\n    }\n  }\n}\n\nexport class OptimizedCautiousAppendOpcode extends AppendOpcode<CautiousInsertion> {\n  type = 'optimized-cautious-append';\n\n  protected normalize(reference: Reference<Opaque>): Reference<CautiousInsertion> {\n    return map(reference, normalizeValue);\n  }\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<CautiousInsertion>, bounds: Fragment, upsert: Upsert): OptimizedCautiousUpdateOpcode {\n    return new OptimizedCautiousUpdateOpcode(cache, bounds, upsert);\n  }\n}\n\nclass OptimizedCautiousUpdateOpcode extends UpdateOpcode<CautiousInsertion> {\n  type = 'optimized-cautious-update';\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n}\n\nexport class GuardedCautiousAppendOpcode extends GuardedAppendOpcode<CautiousInsertion> {\n  type = 'guarded-cautious-append';\n\n  protected AppendOpcode = OptimizedCautiousAppendOpcode;\n\n  protected normalize(reference: Reference<Opaque>): Reference<CautiousInsertion> {\n    return map(reference, normalizeValue);\n  }\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<CautiousInsertion>, bounds: Fragment, upsert: Upsert): GuardedCautiousUpdateOpcode {\n    return new GuardedCautiousUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());\n  }\n}\n\nclass GuardedCautiousUpdateOpcode extends GuardedUpdateOpcode<CautiousInsertion> {\n  type = 'guarded-cautious-update';\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n}\n\nexport class OptimizedTrustingAppendOpcode extends AppendOpcode<TrustingInsertion> {\n  type = 'optimized-trusting-append';\n\n  protected normalize(reference: Reference<Opaque>): Reference<TrustingInsertion> {\n    return map(reference, normalizeTrustedValue);\n  }\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<TrustingInsertion>, bounds: Fragment, upsert: Upsert): OptimizedTrustingUpdateOpcode {\n    return new OptimizedTrustingUpdateOpcode(cache, bounds, upsert);\n  }\n}\n\nclass OptimizedTrustingUpdateOpcode extends UpdateOpcode<TrustingInsertion> {\n  type = 'optimized-trusting-update';\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n}\n\nexport class GuardedTrustingAppendOpcode extends GuardedAppendOpcode<TrustingInsertion> {\n  type = 'guarded-trusting-append';\n\n  protected AppendOpcode = OptimizedTrustingAppendOpcode;\n\n  protected normalize(reference: Reference<Opaque>): Reference<TrustingInsertion> {\n    return map(reference, normalizeTrustedValue);\n  }\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<TrustingInsertion>, bounds: Fragment, upsert: Upsert): GuardedTrustingUpdateOpcode {\n    return new GuardedTrustingUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());\n  }\n}\n\nclass GuardedTrustingUpdateOpcode extends GuardedUpdateOpcode<TrustingInsertion> {\n  type = 'trusting-update';\n\n  protected insert(dom: DOMHelper, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/content.ts"],"names":[],"mappings":";;;;;;;AA+BA,aAAA,OAAA,CAAiB,KAAa,EAAA;AAC5B,eAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,CAAC,UAAU,CAAC,KAAK,UAAU,CAAC;KACzF;;AAEK,aAAA,kBAAA,CAA6B,KAAa,EAAA;AAC9C,YAAI,OAAO,CAAC,KAAK,CAAC,EAAE;AAClB,mBAAO,EAAE,CAAC;SACX;AACD,eAAO,MAAM,CAAC,KAAK,CAAC,CAAC;KACtB;;AAEK,aAAA,qBAAA,CAAgC,KAAa,EAAA;AACjD,YAAI,OAAO,CAAC,KAAK,CAAC,EAAE;AAClB,mBAAO,EAAE,CAAC;SACX;AACD,YAAI,yBAvCJ,QAAQ,CAuCK,KAAK,CAAC,EAAE;AACnB,mBAAO,KAAK,CAAC;SACd;AACD,YAAI,yBA5CJ,YAAY,CA4CK,KAAK,CAAC,EAAE;AACvB,mBAAO,KAAK,CAAC,MAAM,EAAE,CAAC;SACvB;AACD,YAAI,yBA9CJ,MAAM,CA8CK,KAAK,CAAC,EAAE;AACjB,mBAAO,KAAK,CAAC;SACd;AACD,eAAO,MAAM,CAAC,KAAK,CAAC,CAAC;KACtB;;AAEK,aAAA,cAAA,CAAyB,KAAa,EAAA;AAC1C,YAAI,OAAO,CAAC,KAAK,CAAC,EAAE;AAClB,mBAAO,EAAE,CAAC;SACX;AACD,YAAI,yBAvDJ,QAAQ,CAuDK,KAAK,CAAC,EAAE;AACnB,mBAAO,KAAK,CAAC;SACd;AACD,YAAI,yBA5DJ,YAAY,CA4DK,KAAK,CAAC,IAAI,yBA3D3B,MAAM,CA2D4B,KAAK,CAAC,EAAE;AACxC,mBAAO,KAAK,CAAC;SACd;AACD,eAAO,MAAM,CAAC,KAAK,CAAC,CAAC;KACtB;;QAEK,YAAkD;8BAAlD,YAAkD;;iBAAlD,YAAkD;;;;AAAlD,oBAAkD,WAKtD,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,gBAAI,SAAS,GAAG,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;AACtC,gBAAI,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AAE3C,gBAAI,KAAK,YAAA;gBAAE,KAAK,YAAA,CAAC;AAEjB,gBAAI,kBA/DsD,OAAO,CA+DrD,SAAS,CAAC,EAAE;AACtB,qBAAK,GAAG,UAAU,CAAC,KAAK,EAAE,CAAC;aAC5B,MAAM;AACL,qBAAK,GAAG,sBAlEM,cAAc,CAkED,UAAU,CAAC,CAAC;AACvC,qBAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;aACtB;AAED,gBAAI,KAAK,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC;AACvB,gBAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AACrE,gBAAI,MAAM,GAAG,8BArER,QAAQ,CAqEa,MAAM,CAAC,MAAM,CAAC,CAAC;AAEzC,iBAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAExB,gBAAI,KAAK,iCAAiC;AACxC,sBAAE,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;iBACtE;SACF;;AA3BG,oBAAkD,WA6BtD,MAAM,GAAA,kBAAA;AACJ,mBAAO;AACL,oBAAI,EAAE,IAAI,CAAC,KAAK;AAChB,oBAAI,EAAE,IAAI,CAAC,IAAI;AACf,oBAAI,EAAE,CAAC,UAAU,CAAC;aACnB,CAAC;SACH;;eAnCG,YAAkD;iCAzDxC,MAAM;;;;QA+FhB,mBAAyD;8BAAzD,mBAAyD;;AAI7D,iBAJI,mBAAyD,CAIzC,UAAmC,EAAU,WAAwB,EAAA;AACvF,oCAAO,CAAC;AADU,gBAAA,CAAA,UAAU,GAAV,UAAU,CAAyB;AAAU,gBAAA,CAAA,WAAW,GAAX,WAAW,CAAa;AAFjF,gBAAA,CAAA,OAAO,GAAU,IAAI,CAAC;SAI7B;;AANG,2BAAyD,WAQ7D,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,gBAAI,IAAI,CAAC,OAAO,EAAE;AAChB,kBAAE,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aAChC,MAAM;AACL,kBAAE,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAEpC,oBAAI,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC;AAE1C,oBAAG,sCAjHA,qBAAqB,CAiHC,KAAK,CAAC,EAAE;AAC/B,sBAAE,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;iBACtC,MAAM;AACL,4CAAM,QAAQ,KAAA,OAAC,EAAE,CAAC,CAAC;iBACpB;aACF;SACF;;AAtBG,2BAAyD,WAwBtD,KAAK,GAAA,eAAC,GAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6C3B,gBAAI,MAAM,GAAG,+BA3JR,eAAe,CA2Ja,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5C,gBAAI,GAAG,GAAG,qDAAqB,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;AAE9D,eAAG,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,UAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAA;AAC7C,mBAAG,CAAC,QAAQ,CAAC,MAAK,UAAU,CAAC,CAAC;AAC9B,mBAAG,CAAC,IAAI,CAAC,8BAA8B,CAAC,MAAM,CAAC,CAAC;AAChD,mBAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACxB,mBAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AACvB,mBAAG,CAAC,6BAA6B,EAAE,CAAC;AACpC,mBAAG,CAAC,aAAa,CAAC,6BAjKf,IAAI,CAiKgB,KAAK,EAAE,CAAC,CAAC;AAChC,mBAAG,CAAC,cAAc,EAAE,CAAC;AACrB,mBAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACd,mBAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AACnB,mBAAG,CAAC,MAAM,CAAC,IAAI,MAAK,YAAY,EAAE,CAAC,CAAC;aACrC,CAAC,CAAC;AAEH,gBAAI,OAAO,GAAG,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC;;;;;AAO3C,gBAAI,CAAC,UAAU,GAAG,IAAI,CAAC;AAEvB,mBAAO,OAAO,CAAC;SAChB;;AA/FG,2BAAyD,WAiG7D,MAAM,GAAA,kBAAA;gBACS,IAAI,GAAoB,IAAI,CAAnC,KAAK;gBAAQ,IAAI,GAAc,IAAI,CAAtB,IAAI;gBAAE,OAAO,GAAK,IAAI,CAAhB,OAAO;;AAEhC,gBAAI,OAAO,EAAE;AACX,uBAAO;AACL,wBAAI,EAAJ,IAAI;AACJ,wBAAI,EAAJ,IAAI;AACJ,2BAAO,EAAE,IAAI;AACb,4BAAQ,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,UAAA,EAAE;+BAAI,EAAE,CAAC,MAAM,EAAE;qBAAA,CAAC;iBACnD,CAAC;aACH,MAAM;AACL,uBAAO;AACL,wBAAI,EAAJ,IAAI;AACJ,wBAAI,EAAJ,IAAI;AACJ,wBAAI,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;iBACjC,CAAC;aACH;SACF;;eAlHG,mBAAyD;OAAQ,YAAe;;;;QAqHtF,8BAAqC;8BAArC,8BAAqC;;iBAArC,8BAAqC;;;;AAArC,sCAAqC,CAC5B,MAAM,GAAA,gBAAC,KAAwB,EAAA;AACpC,mBAAO,IAAI,8BAA8B,CAAC,KAAK,CAAC,CAAC;SAClD;;AAHH,sCAAqC,WAKnC,MAAM,GAAA,gBAAC,KAAa,EAAA;AAClB,mBAAO,sCA5NF,qBAAqB,CA4NG,KAAK,CAAC,CAAC;SACrC;;eAPH,8BAAqC;oCAzM5B,oBAAoB;;QAmN7B,YAAiD;8BAAjD,YAAiD;;AAC/C,iBADF,YAAiD,CAEnC,KAAwB,EACxB,MAAgB,EAChB,MAAc,EAAA;AAExB,sCAAO,CAAC;AAJE,gBAAA,CAAA,KAAK,GAAL,KAAK,CAAmB;AACxB,gBAAA,CAAA,MAAM,GAAN,MAAM,CAAU;AAChB,gBAAA,CAAA,MAAM,GAAN,MAAM,CAAQ;AAGxB,gBAAI,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;SACtB;;AARH,oBAAiD,WAY/C,QAAQ,GAAA,kBAAC,EAAc,EAAA;AACrB,gBAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;AAEpC,gBAAI,kBAxO0C,UAAU,CAwOzC,KAAK,CAAC,EAAE;oBACf,MAAM,GAAa,IAAI,CAAvB,MAAM;oBAAE,MAAM,GAAK,IAAI,CAAf,MAAM;oBACd,GAAG,GAAK,EAAE,CAAV,GAAG;;AAET,oBAAG,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE;AAClC,wBAAI,MAAM,GAAG,6BA3OZ,MAAM,CA2OiB,MAAM,CAAC,aAAa,EAAE,EAAE,yBA3OvC,KAAK,CA2OwC,MAAM,CAAC,CAAC,CAAC;AAC/D,0BAAM,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;iBACjF;AAED,sBAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;aAC9B;SACF;;AA1BH,oBAAiD,WA4B/C,MAAM,GAAA,kBAAA;gBACS,IAAI,GAAkB,IAAI,CAAjC,KAAK;gBAAQ,IAAI,GAAY,IAAI,CAApB,IAAI;gBAAE,KAAK,GAAK,IAAI,CAAd,KAAK;;AAE9B,mBAAO;AACL,oBAAI,EAAJ,IAAI;AACJ,oBAAI,EAAJ,IAAI;AACJ,uBAAO,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE;aACrD,CAAC;SACH;;eApCH,YAAiD;iCA9Nb,cAAc;;QAqQ5C,mBAAyD;8BAAzD,mBAAyD;;AAI7D,iBAJI,mBAAyD,CAKnD,SAA4B,EACpC,KAAwB,EACxB,MAAgB,EAChB,MAAc,EACN,YAAoC,EACpC,KAAc,EAAA;AAEtB,qCAAM,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAPrB,gBAAA,CAAA,SAAS,GAAT,SAAS,CAAmB;AAI5B,gBAAA,CAAA,YAAY,GAAZ,YAAY,CAAwB;AACpC,gBAAA,CAAA,KAAK,GAAL,KAAK,CAAS;AARhB,gBAAA,CAAA,OAAO,GAAc,IAAI,CAAC;AAWhC,gBAAI,CAAC,GAAG,GAAG,IAAI,CAAC,IAAI,GAAG,sBA7QS,YAAY,CA6QJ,IAAI,CAAC,GAAG,CAAC,CAAC;SACnD;;AAdG,2BAAyD,WAgB7D,QAAQ,GAAA,kBAAC,EAAc,EAAA;AACrB,gBAAI,IAAI,CAAC,OAAO,EAAE;AAChB,kBAAE,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aACjC,MAAM;AACL,oBAAI,sCA3RD,qBAAqB,CA2RE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE;AACjD,wBAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;iBACpB,MAAM;AACL,4CAAM,QAAQ,KAAA,OAAC,EAAE,CAAC,CAAC;iBACpB;aACF;SACF;;AA1BG,2BAAyD,WA4BrD,SAAS,GAAA,mBAAC,EAAc,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA+BxB,MAAM,GAA0B,IAAI,CAApC,MAAM;gBAAE,YAAY,GAAY,IAAI,CAA5B,YAAY;gBAAE,KAAK,GAAK,IAAI,CAAd,KAAK;;AAEjC,gBAAI,SAAS,GAAG,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;AAC3C,gBAAI,KAAK,GAAO,SAAS,CAAC,IAAI,EAAiB,CAAC;AAChD,gBAAI,GAAG,GAAS,KAAK,CAAC,KAAK,CAAC;AAE5B,gBAAI,OAAO,GAAG,8BAxTT,qBAAqB,CAwTc,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;AAChE,mBAAO,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAE/B,gBAAI,QAAQ,GAAG,iBAnUF,UAAU,EAmUwB,CAAC;AAEhD,gBAAI,OAAO,GAAG,IAAI,CAAC,OAAO,GAAG,+BAxUxB,SAAS,CAwU6B,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;AAE1E,gBAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;AAE9B,cAAE,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;AAC3B,cAAE,CAAC,KAAK,EAAE,CAAC;;;;;AAOX,gBAAI,CAAC,IAAI,GAAW,IAAI,CAAC;AACzB,gBAAI,CAAC,SAAS,GAAM,IAAI,CAAC;AACzB,gBAAI,CAAC,KAAK,GAAU,IAAI,CAAC;AACzB,gBAAI,CAAC,MAAM,GAAS,IAAI,CAAC;AACzB,gBAAI,CAAC,MAAM,GAAS,IAAI,CAAC;AACzB,gBAAI,CAAC,YAAY,GAAG,IAAI,CAAC;AACzB,gBAAI,CAAC,KAAK,GAAU,IAAI,CAAC;SAC1B;;AAzFG,2BAAyD,WA2F7D,MAAM,GAAA,kBAAA;gBACS,IAAI,GAAoB,IAAI,CAAnC,KAAK;gBAAQ,IAAI,GAAc,IAAI,CAAtB,IAAI;gBAAE,OAAO,GAAK,IAAI,CAAhB,OAAO;;AAEhC,gBAAI,OAAO,EAAE;AACX,uBAAO;AACL,wBAAI,EAAJ,IAAI;AACJ,wBAAI,EAAJ,IAAI;AACJ,2BAAO,EAAE,IAAI;AACb,4BAAQ,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;iBAC7B,CAAC;aACH,MAAM;AACL,uBAAO,wBAAM,MAAM,KAAA,MAAE,CAAC;aACvB;SACF;;eAxGG,mBAAyD;OAAQ,YAAe;;;;QA2GhF,6BAAqC;8BAArC,6BAAqC;;AAA3C,iBAAM,6BAAqC,GAA3C;ACrEQ,uCAAS,SAAS,CAAC,CAAC;ADsE1B,gBAAA,CAAA,IAAI,GAAG,2BAA2B,CAAC;SAapC;;AAdK,qCAAqC,WAG/B,SAAS,GAAA,mBAAC,SAA4B,EAAA;AAC9C,mBAAO,kBA/W4D,GAAG,CA+W3D,SAAS,EAAE,cAAc,CAAC,CAAC;SACvC;;AALG,qCAAqC,WAO/B,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBA7XT,cAAc,CA6XU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;AATG,qCAAqC,WAW/B,UAAU,GAAA,oBAAC,EAAM,EAAE,SAA4B,EAAE,KAAwC,EAAE,MAAgB,EAAE,MAAc,EAAA;AACnI,mBAAO,IAAI,6BAA6B,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;SACjE;;eAbG,6BAAqC;OAAQ,YAA+B;;;;QAgBlF,6BAAoC;8BAApC,6BAAoC;;AAApC,iBAAA,6BAAoC,GAApC;ACtEQ,uCAAS,SAAS,CAAC,CAAC;ADuE1B,gBAAA,CAAA,IAAI,GAAG,2BAA2B,CAAC;SAKpC;;AAND,qCAAoC,WAGxB,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBAzYT,cAAc,CAyYU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;eALH,6BAAoC;OAAQ,YAA+B;;QAQrE,2BAAmC;8BAAnC,2BAAmC;;AAAzC,iBAAM,2BAAmC,GAAzC;ACrEQ,6CAAS,SAAS,CAAC,CAAC;ADsE1B,gBAAA,CAAA,IAAI,GAAG,yBAAyB,CAAC;AAEvB,gBAAA,CAAA,YAAY,GAAG,6BAA6B,CAAC;SAaxD;;AAhBK,mCAAmC,WAK7B,SAAS,GAAA,mBAAC,SAA4B,EAAA;AAC9C,mBAAO,kBAzY4D,GAAG,CAyY3D,SAAS,EAAE,cAAc,CAAC,CAAC;SACvC;;AAPG,mCAAmC,WAS7B,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBAvZT,cAAc,CAuZU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;AAXG,mCAAmC,WAa7B,UAAU,GAAA,oBAAC,EAAM,EAAE,SAA4B,EAAE,KAAwC,EAAE,MAAgB,EAAE,MAAc,EAAA;AACnI,mBAAO,IAAI,2BAA2B,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;SAC9F;;eAfG,2BAAmC;OAAQ,mBAAsC;;;;QAkBvF,2BAAkC;8BAAlC,2BAAkC;;AAAlC,iBAAA,2BAAkC,GAAlC;ACvEQ,6CAAS,SAAS,CAAC,CAAC;ADwE1B,gBAAA,CAAA,IAAI,GAAG,yBAAyB,CAAC;SAKlC;;AAND,mCAAkC,WAGtB,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBAnaT,cAAc,CAmaU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;eALH,2BAAkC;OAAQ,mBAAsC;;QAQ1E,6BAAqC;8BAArC,6BAAqC;;AAA3C,iBAAM,6BAAqC,GAA3C;ACtEQ,uCAAS,SAAS,CAAC,CAAC;ADuE1B,gBAAA,CAAA,IAAI,GAAG,2BAA2B,CAAC;SAapC;;AAdK,qCAAqC,WAG/B,SAAS,GAAA,mBAAC,SAA4B,EAAA;AAC9C,mBAAO,kBAja4D,GAAG,CAia3D,SAAS,EAAE,qBAAqB,CAAC,CAAC;SAC9C;;AALG,qCAAqC,WAO/B,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBA9aT,cAAc,CA8aU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;AATG,qCAAqC,WAW/B,UAAU,GAAA,oBAAC,EAAM,EAAE,SAA4B,EAAE,KAAwC,EAAE,MAAgB,EAAE,MAAc,EAAA;AACnI,mBAAO,IAAI,6BAA6B,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;SACjE;;eAbG,6BAAqC;OAAQ,YAA+B;;;;QAgBlF,6BAAoC;8BAApC,6BAAoC;;AAApC,iBAAA,6BAAoC,GAApC;ACvEQ,uCAAS,SAAS,CAAC,CAAC;ADwE1B,gBAAA,CAAA,IAAI,GAAG,2BAA2B,CAAC;SAKpC;;AAND,qCAAoC,WAGxB,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBA1bT,cAAc,CA0bU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;eALH,6BAAoC;OAAQ,YAA+B;;QAQrE,2BAAmC;8BAAnC,2BAAmC;;AAAzC,iBAAM,2BAAmC,GAAzC;ACtEQ,8CAAS,SAAS,CAAC,CAAC;ADuE1B,gBAAA,CAAA,IAAI,GAAG,yBAAyB,CAAC;AAEvB,gBAAA,CAAA,YAAY,GAAG,6BAA6B,CAAC;SAaxD;;AAhBK,mCAAmC,WAK7B,SAAS,GAAA,mBAAC,SAA4B,EAAA;AAC9C,mBAAO,kBA3b4D,GAAG,CA2b3D,SAAS,EAAE,qBAAqB,CAAC,CAAC;SAC9C;;AAPG,mCAAmC,WAS7B,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBAxcT,cAAc,CAwcU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;AAXG,mCAAmC,WAa7B,UAAU,GAAA,oBAAC,EAAM,EAAE,SAA4B,EAAE,KAAwC,EAAE,MAAgB,EAAE,MAAc,EAAA;AACnI,mBAAO,IAAI,2BAA2B,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;SAC9F;;eAfG,2BAAmC;OAAQ,mBAAsC;;;;QAkBvF,2BAAkC;8BAAlC,2BAAkC;;AAAlC,iBAAA,2BAAkC,GAAlC;ACxEQ,8CAAS,SAAS,CAAC,CAAC;ADyE1B,gBAAA,CAAA,IAAI,GAAG,iBAAiB,CAAC;SAK1B;;AAND,mCAAkC,WAGtB,MAAM,GAAA,gBAAC,GAAwB,EAAE,MAAc,EAAE,KAAwB,EAAA;AACjF,mBAAO,yBApdT,cAAc,CAodU,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SAC3C;;eALH,2BAAkC;OAAQ,mBAAsC","file":"content.js","sourcesContent":["import Upsert, {\n  Insertion,\n  CautiousInsertion,\n  TrustingInsertion,\n\n  isSafeString,\n  isNode,\n  isString,\n\n  cautiousInsert,\n  trustingInsert\n} from '../../upsert';\nimport { isComponentDefinition } from '../../component/interfaces';\nimport { DOMTreeConstruction } from '../../dom/helper';\nimport { OpSeq, Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { CompiledExpression } from '../expressions';\nimport { VM, UpdatingVM } from '../../vm';\nimport { TryOpcode, VMState } from '../../vm/update';\nimport { EnterOpcode } from './vm';\nimport { Reference, ReferenceCache, UpdatableTag, isModified, isConst, map } from 'glimmer-reference';\nimport { Opaque, LinkedList } from 'glimmer-util';\nimport { Cursor, clear } from '../../bounds';\nimport { Fragment } from '../../builder';\nimport { CompileIntoList } from '../../compiler';\nimport OpcodeBuilderDSL from './builder';\nimport { ConditionalReference } from '../../references';\nimport { Args } from '../../syntax/core';\nimport { Environment } from '../../environment';\nimport { UpdatableBlockTracker } from '../../builder';\nimport SymbolTable from '../../symbol-table';\n\nfunction isEmpty(value: Opaque): boolean {\n  return value === null || value === undefined || typeof value['toString'] !== 'function';\n}\n\nexport function normalizeTextValue(value: Opaque): string {\n  if (isEmpty(value)) {\n    return '';\n  }\n  return String(value);\n}\n\nexport function normalizeTrustedValue(value: Opaque): TrustingInsertion {\n  if (isEmpty(value)) {\n    return '';\n  }\n  if (isString(value)) {\n    return value;\n  }\n  if (isSafeString(value)) {\n    return value.toHTML();\n  }\n  if (isNode(value)) {\n    return value;\n  }\n  return String(value);\n}\n\nexport function normalizeValue(value: Opaque): CautiousInsertion {\n  if (isEmpty(value)) {\n    return '';\n  }\n  if (isString(value)) {\n    return value;\n  }\n  if (isSafeString(value) || isNode(value)) {\n    return value;\n  }\n  return String(value);\n}\n\nexport abstract class AppendOpcode<T extends Insertion> extends Opcode {\n  protected abstract normalize(reference: Reference<Opaque>): Reference<T>;\n  protected abstract insert(dom: DOMTreeConstruction, cursor: Cursor, value: T): Upsert;\n  protected abstract updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<T>, bounds: Fragment, upsert: Upsert): UpdateOpcode<T>;\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getOperand();\n    let normalized = this.normalize(reference);\n\n    let value, cache;\n\n    if (isConst(reference)) {\n      value = normalized.value();\n    } else {\n      cache = new ReferenceCache(normalized);\n      value = cache.peek();\n    }\n\n    let stack = vm.stack();\n    let upsert = this.insert(vm.env.getAppendOperations(), stack, value);\n    let bounds = new Fragment(upsert.bounds);\n\n    stack.newBounds(bounds);\n\n    if (cache /* i.e. !isConst(reference) */) {\n      vm.updateWith(this.updateWith(vm, reference, cache, bounds, upsert));\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\"]\n    };\n  }\n}\n\nexport abstract class GuardedAppendOpcode<T extends Insertion> extends AppendOpcode<T> {\n  protected abstract AppendOpcode: typeof OptimizedCautiousAppendOpcode | typeof OptimizedTrustingAppendOpcode;\n  private deopted: OpSeq = null;\n\n  constructor(private expression: CompiledExpression<any>, private symbolTable: SymbolTable) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    if (this.deopted) {\n      vm.pushEvalFrame(this.deopted);\n    } else {\n      vm.evaluateOperand(this.expression);\n\n      let value = vm.frame.getOperand().value();\n\n      if(isComponentDefinition(value)) {\n        vm.pushEvalFrame(this.deopt(vm.env));\n      } else {\n        super.evaluate(vm);\n      }\n    }\n  }\n\n  public deopt(env: Environment): OpSeq { // Public because it's used in the lazy deopt\n    // At compile time, we determined that this append callsite might refer\n    // to a local variable/property lookup that resolves to a component\n    // definition at runtime.\n    //\n    // We could have eagerly compiled this callsite into something like this:\n    //\n    //   {{#if (is-component-definition foo)}}\n    //     {{component foo}}\n    //   {{else}}\n    //     {{foo}}\n    //   {{/if}}\n    //\n    // However, in practice, there might be a large amout of these callsites\n    // and most of them would resolve to a simple value lookup. Therefore, we\n    // tried to be optimistic and assumed that the callsite will resolve to\n    // appending a simple value.\n    //\n    // However, we have reached here because at runtime, the guard conditional\n    // have detected that this callsite is indeed referring to a component\n    // definition object. Since this is likely going to be true for other\n    // instances of the same callsite, it is now appropiate to deopt into the\n    // expanded version that handles both cases. The compilation would look\n    // like this:\n    //\n    //               Enter(BEGIN, END)\n    //   BEGIN:      Noop\n    //               Test(is-component-definition)\n    //               JumpUnless(VALUE)\n    //   COMPONENT:  Noop\n    //               PutDynamicComponentDefinitionOpcode\n    //               OpenComponent\n    //               CloseComponent\n    //               Jump(END)\n    //   VALUE:      Noop\n    //               OptimizedAppend\n    //   END:        Noop\n    //               Exit\n    //\n    // Keep in mind that even if we *don't* reach here at initial render time,\n    // it is still possible (although quite rare) that the simple value we\n    // encounter during initial render could later change into a component\n    // definition object at update time. That is handled by the \"lazy deopt\"\n    // code on the update side (scroll down for the next big block of comment).\n\n    let buffer = new CompileIntoList(env, null);\n    let dsl = new OpcodeBuilderDSL(buffer, this.symbolTable, env);\n\n    dsl.block({ templates: null }, (dsl, BEGIN, END) => {\n      dsl.putValue(this.expression);\n      dsl.test(IsComponentDefinitionReference.create);\n      dsl.jumpUnless('VALUE');\n      dsl.label('COMPONENT');\n      dsl.putDynamicComponentDefinition();\n      dsl.openComponent(Args.empty());\n      dsl.closeComponent();\n      dsl.jump(END);\n      dsl.label('VALUE');\n      dsl.append(new this.AppendOpcode());\n    });\n\n    let deopted = this.deopted = dsl.toOpSeq();\n\n    // From this point on, we have essentially replaced ourselve with a new set\n    // of opcodes. Since we will always be executing the new/deopted code, it's\n    // a good idea (as a pattern) to null out any unneeded fields here to avoid\n    // holding on to unneeded/stale objects:\n\n    this.expression = null;\n\n    return deopted;\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, deopted } = this;\n\n    if (deopted) {\n      return {\n        guid,\n        type,\n        deopted: true,\n        children: deopted.toArray().map(op => op.toJSON())\n      };\n    } else {\n      return {\n        guid,\n        type,\n        args: [this.expression.toJSON()]\n      };\n    }\n  }\n}\n\nclass IsComponentDefinitionReference extends ConditionalReference {\n  static create(inner: Reference<Opaque>): IsComponentDefinitionReference {\n    return new IsComponentDefinitionReference(inner);\n  }\n\n  toBool(value: Opaque): boolean {\n    return isComponentDefinition(value);\n  }\n}\n\nabstract class UpdateOpcode<T extends Insertion> extends UpdatingOpcode {\n  constructor(\n    protected cache: ReferenceCache<T>,\n    protected bounds: Fragment,\n    protected upsert: Upsert\n  ) {\n    super();\n    this.tag = cache.tag;\n  }\n\n  protected abstract insert(dom: DOMTreeConstruction, cursor: Cursor, value: T): Upsert;\n\n  evaluate(vm: UpdatingVM) {\n    let value = this.cache.revalidate();\n\n    if (isModified(value)) {\n      let { bounds, upsert } = this;\n      let { dom } = vm;\n\n      if(!this.upsert.update(dom, value)) {\n        let cursor = new Cursor(bounds.parentElement(), clear(bounds));\n        upsert = this.upsert = this.insert(vm.env.getAppendOperations(), cursor, value);\n      }\n\n      bounds.update(upsert.bounds);\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, cache } = this;\n\n    return {\n      guid,\n      type,\n      details: { lastValue: JSON.stringify(cache.peek()) }\n    };\n  }\n}\n\nexport abstract class GuardedUpdateOpcode<T extends Insertion> extends UpdateOpcode<T> {\n  private _tag: UpdatableTag;\n  private deopted: TryOpcode = null;\n\n  constructor(\n    private reference: Reference<Opaque>,\n    cache: ReferenceCache<T>,\n    bounds: Fragment,\n    upsert: Upsert,\n    private appendOpcode: GuardedAppendOpcode<T>,\n    private state: VMState\n  ) {\n    super(cache, bounds, upsert);\n    this.tag = this._tag = new UpdatableTag(this.tag);\n  }\n\n  evaluate(vm: UpdatingVM) {\n    if (this.deopted) {\n      vm.evaluateOpcode(this.deopted);\n    } else {\n      if (isComponentDefinition(this.reference.value())) {\n        this.lazyDeopt(vm);\n      } else {\n        super.evaluate(vm);\n      }\n    }\n  }\n\n  private lazyDeopt(vm: UpdatingVM) {\n    // Durign initial render, we know that the reference does not contain a\n    // component definition, so we optimistically assumed that this append\n    // is just a normal append. However, at update time, we discovered that\n    // the reference has switched into containing a component definition, so\n    // we need to do a \"lazy deopt\", simulating what would have happened if\n    // we had decided to perform the deopt in the first place during initial\n    // render.\n    //\n    // More concretely, we would have expanded the curly into a if/else, and\n    // based on whether the value is a component definition or not, we would\n    // have entered either the dynamic component branch or the simple value\n    // branch.\n    //\n    // Since we rendered a simple value during initial render (and all the\n    // updates up until this point), we need to pretend that the result is\n    // produced by the \"VALUE\" branch of the deopted append opcode:\n    //\n    //   Try(BEGIN, END)\n    //     Assert(IsComponentDefinition, expected=false)\n    //     OptimizedUpdate\n    //\n    // In this case, because the reference has switched from being a simple\n    // value into a component definition, what would have happened is that\n    // the assert would throw, causing the Try opcode to teardown the bounds\n    // and rerun the original append opcode.\n    //\n    // Since the Try opcode would have nuked the updating opcodes anyway, we\n    // wouldn't have to worry about simulating those. All we have to do is to\n    // execute the Try opcode and immediately throw.\n\n    let { bounds, appendOpcode, state } = this;\n\n    let appendOps = appendOpcode.deopt(vm.env);\n    let enter     = appendOps.head() as EnterOpcode;\n    let ops       = enter.slice;\n\n    let tracker = new UpdatableBlockTracker(bounds.parentElement());\n    tracker.newBounds(this.bounds);\n\n    let children = new LinkedList<UpdatingOpcode>();\n\n    let deopted = this.deopted = new TryOpcode(ops, state, tracker, children);\n\n    this._tag.update(deopted.tag);\n\n    vm.evaluateOpcode(deopted);\n    vm.throw();\n\n    // From this point on, we have essentially replaced ourselve with a new\n    // opcode. Since we will always be executing the new/deopted code, it's a\n    // good idea (as a pattern) to null out any unneeded fields here to avoid\n    // holding on to unneeded/stale objects:\n\n    this._tag         = null;\n    this.reference    = null;\n    this.cache        = null;\n    this.bounds       = null;\n    this.upsert       = null;\n    this.appendOpcode = null;\n    this.state        = null;\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, deopted } = this;\n\n    if (deopted) {\n      return {\n        guid,\n        type,\n        deopted: true,\n        children: [deopted.toJSON()]\n      };\n    } else {\n      return super.toJSON();\n    }\n  }\n}\n\nexport class OptimizedCautiousAppendOpcode extends AppendOpcode<CautiousInsertion> {\n  type = 'optimized-cautious-append';\n\n  protected normalize(reference: Reference<Opaque>): Reference<CautiousInsertion> {\n    return map(reference, normalizeValue);\n  }\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<CautiousInsertion>, bounds: Fragment, upsert: Upsert): OptimizedCautiousUpdateOpcode {\n    return new OptimizedCautiousUpdateOpcode(cache, bounds, upsert);\n  }\n}\n\nclass OptimizedCautiousUpdateOpcode extends UpdateOpcode<CautiousInsertion> {\n  type = 'optimized-cautious-update';\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n}\n\nexport class GuardedCautiousAppendOpcode extends GuardedAppendOpcode<CautiousInsertion> {\n  type = 'guarded-cautious-append';\n\n  protected AppendOpcode = OptimizedCautiousAppendOpcode;\n\n  protected normalize(reference: Reference<Opaque>): Reference<CautiousInsertion> {\n    return map(reference, normalizeValue);\n  }\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<CautiousInsertion>, bounds: Fragment, upsert: Upsert): GuardedCautiousUpdateOpcode {\n    return new GuardedCautiousUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());\n  }\n}\n\nclass GuardedCautiousUpdateOpcode extends GuardedUpdateOpcode<CautiousInsertion> {\n  type = 'guarded-cautious-update';\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: CautiousInsertion): Upsert {\n    return cautiousInsert(dom, cursor, value);\n  }\n}\n\nexport class OptimizedTrustingAppendOpcode extends AppendOpcode<TrustingInsertion> {\n  type = 'optimized-trusting-append';\n\n  protected normalize(reference: Reference<Opaque>): Reference<TrustingInsertion> {\n    return map(reference, normalizeTrustedValue);\n  }\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<TrustingInsertion>, bounds: Fragment, upsert: Upsert): OptimizedTrustingUpdateOpcode {\n    return new OptimizedTrustingUpdateOpcode(cache, bounds, upsert);\n  }\n}\n\nclass OptimizedTrustingUpdateOpcode extends UpdateOpcode<TrustingInsertion> {\n  type = 'optimized-trusting-update';\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n}\n\nexport class GuardedTrustingAppendOpcode extends GuardedAppendOpcode<TrustingInsertion> {\n  type = 'guarded-trusting-append';\n\n  protected AppendOpcode = OptimizedTrustingAppendOpcode;\n\n  protected normalize(reference: Reference<Opaque>): Reference<TrustingInsertion> {\n    return map(reference, normalizeTrustedValue);\n  }\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n\n  protected updateWith(vm: VM, reference: Reference<Opaque>, cache: ReferenceCache<TrustingInsertion>, bounds: Fragment, upsert: Upsert): GuardedTrustingUpdateOpcode {\n    return new GuardedTrustingUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());\n  }\n}\n\nclass GuardedTrustingUpdateOpcode extends GuardedUpdateOpcode<TrustingInsertion> {\n  type = 'trusting-update';\n\n  protected insert(dom: DOMTreeConstruction, cursor: Cursor, value: TrustingInsertion): Upsert {\n    return trustingInsert(dom, cursor, value);\n  }\n}\n","import { isSafeString, isNode, isString, cautiousInsert, trustingInsert } from '../../upsert';\nimport { isComponentDefinition } from '../../component/interfaces';\nimport { Opcode, UpdatingOpcode } from '../../opcodes';\nimport { TryOpcode } from '../../vm/update';\nimport { ReferenceCache, UpdatableTag, isModified, isConst, map } from 'glimmer-reference';\nimport { LinkedList } from 'glimmer-util';\nimport { Cursor, clear } from '../../bounds';\nimport { Fragment } from '../../builder';\nimport { CompileIntoList } from '../../compiler';\nimport OpcodeBuilderDSL from './builder';\nimport { ConditionalReference } from '../../references';\nimport { Args } from '../../syntax/core';\nimport { UpdatableBlockTracker } from '../../builder';\nfunction isEmpty(value) {\n    return value === null || value === undefined || typeof value['toString'] !== 'function';\n}\nexport function normalizeTextValue(value) {\n    if (isEmpty(value)) {\n        return '';\n    }\n    return String(value);\n}\nexport function normalizeTrustedValue(value) {\n    if (isEmpty(value)) {\n        return '';\n    }\n    if (isString(value)) {\n        return value;\n    }\n    if (isSafeString(value)) {\n        return value.toHTML();\n    }\n    if (isNode(value)) {\n        return value;\n    }\n    return String(value);\n}\nexport function normalizeValue(value) {\n    if (isEmpty(value)) {\n        return '';\n    }\n    if (isString(value)) {\n        return value;\n    }\n    if (isSafeString(value) || isNode(value)) {\n        return value;\n    }\n    return String(value);\n}\nexport class AppendOpcode extends Opcode {\n    evaluate(vm) {\n        let reference = vm.frame.getOperand();\n        let normalized = this.normalize(reference);\n        let value, cache;\n        if (isConst(reference)) {\n            value = normalized.value();\n        }\n        else {\n            cache = new ReferenceCache(normalized);\n            value = cache.peek();\n        }\n        let stack = vm.stack();\n        let upsert = this.insert(vm.env.getAppendOperations(), stack, value);\n        let bounds = new Fragment(upsert.bounds);\n        stack.newBounds(bounds);\n        if (cache /* i.e. !isConst(reference) */) {\n            vm.updateWith(this.updateWith(vm, reference, cache, bounds, upsert));\n        }\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [\"$OPERAND\"]\n        };\n    }\n}\nexport class GuardedAppendOpcode extends AppendOpcode {\n    constructor(expression, symbolTable) {\n        super();\n        this.expression = expression;\n        this.symbolTable = symbolTable;\n        this.deopted = null;\n    }\n    evaluate(vm) {\n        if (this.deopted) {\n            vm.pushEvalFrame(this.deopted);\n        }\n        else {\n            vm.evaluateOperand(this.expression);\n            let value = vm.frame.getOperand().value();\n            if (isComponentDefinition(value)) {\n                vm.pushEvalFrame(this.deopt(vm.env));\n            }\n            else {\n                super.evaluate(vm);\n            }\n        }\n    }\n    deopt(env) {\n        // At compile time, we determined that this append callsite might refer\n        // to a local variable/property lookup that resolves to a component\n        // definition at runtime.\n        //\n        // We could have eagerly compiled this callsite into something like this:\n        //\n        //   {{#if (is-component-definition foo)}}\n        //     {{component foo}}\n        //   {{else}}\n        //     {{foo}}\n        //   {{/if}}\n        //\n        // However, in practice, there might be a large amout of these callsites\n        // and most of them would resolve to a simple value lookup. Therefore, we\n        // tried to be optimistic and assumed that the callsite will resolve to\n        // appending a simple value.\n        //\n        // However, we have reached here because at runtime, the guard conditional\n        // have detected that this callsite is indeed referring to a component\n        // definition object. Since this is likely going to be true for other\n        // instances of the same callsite, it is now appropiate to deopt into the\n        // expanded version that handles both cases. The compilation would look\n        // like this:\n        //\n        //               Enter(BEGIN, END)\n        //   BEGIN:      Noop\n        //               Test(is-component-definition)\n        //               JumpUnless(VALUE)\n        //   COMPONENT:  Noop\n        //               PutDynamicComponentDefinitionOpcode\n        //               OpenComponent\n        //               CloseComponent\n        //               Jump(END)\n        //   VALUE:      Noop\n        //               OptimizedAppend\n        //   END:        Noop\n        //               Exit\n        //\n        // Keep in mind that even if we *don't* reach here at initial render time,\n        // it is still possible (although quite rare) that the simple value we\n        // encounter during initial render could later change into a component\n        // definition object at update time. That is handled by the \"lazy deopt\"\n        // code on the update side (scroll down for the next big block of comment).\n        let buffer = new CompileIntoList(env, null);\n        let dsl = new OpcodeBuilderDSL(buffer, this.symbolTable, env);\n        dsl.block({ templates: null }, (dsl, BEGIN, END) => {\n            dsl.putValue(this.expression);\n            dsl.test(IsComponentDefinitionReference.create);\n            dsl.jumpUnless('VALUE');\n            dsl.label('COMPONENT');\n            dsl.putDynamicComponentDefinition();\n            dsl.openComponent(Args.empty());\n            dsl.closeComponent();\n            dsl.jump(END);\n            dsl.label('VALUE');\n            dsl.append(new this.AppendOpcode());\n        });\n        let deopted = this.deopted = dsl.toOpSeq();\n        // From this point on, we have essentially replaced ourselve with a new set\n        // of opcodes. Since we will always be executing the new/deopted code, it's\n        // a good idea (as a pattern) to null out any unneeded fields here to avoid\n        // holding on to unneeded/stale objects:\n        this.expression = null;\n        return deopted;\n    }\n    toJSON() {\n        let { _guid: guid, type, deopted } = this;\n        if (deopted) {\n            return {\n                guid,\n                type,\n                deopted: true,\n                children: deopted.toArray().map(op => op.toJSON())\n            };\n        }\n        else {\n            return {\n                guid,\n                type,\n                args: [this.expression.toJSON()]\n            };\n        }\n    }\n}\nclass IsComponentDefinitionReference extends ConditionalReference {\n    static create(inner) {\n        return new IsComponentDefinitionReference(inner);\n    }\n    toBool(value) {\n        return isComponentDefinition(value);\n    }\n}\nclass UpdateOpcode extends UpdatingOpcode {\n    constructor(cache, bounds, upsert) {\n        super();\n        this.cache = cache;\n        this.bounds = bounds;\n        this.upsert = upsert;\n        this.tag = cache.tag;\n    }\n    evaluate(vm) {\n        let value = this.cache.revalidate();\n        if (isModified(value)) {\n            let { bounds, upsert } = this;\n            let { dom } = vm;\n            if (!this.upsert.update(dom, value)) {\n                let cursor = new Cursor(bounds.parentElement(), clear(bounds));\n                upsert = this.upsert = this.insert(vm.env.getAppendOperations(), cursor, value);\n            }\n            bounds.update(upsert.bounds);\n        }\n    }\n    toJSON() {\n        let { _guid: guid, type, cache } = this;\n        return {\n            guid,\n            type,\n            details: { lastValue: JSON.stringify(cache.peek()) }\n        };\n    }\n}\nexport class GuardedUpdateOpcode extends UpdateOpcode {\n    constructor(reference, cache, bounds, upsert, appendOpcode, state) {\n        super(cache, bounds, upsert);\n        this.reference = reference;\n        this.appendOpcode = appendOpcode;\n        this.state = state;\n        this.deopted = null;\n        this.tag = this._tag = new UpdatableTag(this.tag);\n    }\n    evaluate(vm) {\n        if (this.deopted) {\n            vm.evaluateOpcode(this.deopted);\n        }\n        else {\n            if (isComponentDefinition(this.reference.value())) {\n                this.lazyDeopt(vm);\n            }\n            else {\n                super.evaluate(vm);\n            }\n        }\n    }\n    lazyDeopt(vm) {\n        // Durign initial render, we know that the reference does not contain a\n        // component definition, so we optimistically assumed that this append\n        // is just a normal append. However, at update time, we discovered that\n        // the reference has switched into containing a component definition, so\n        // we need to do a \"lazy deopt\", simulating what would have happened if\n        // we had decided to perform the deopt in the first place during initial\n        // render.\n        //\n        // More concretely, we would have expanded the curly into a if/else, and\n        // based on whether the value is a component definition or not, we would\n        // have entered either the dynamic component branch or the simple value\n        // branch.\n        //\n        // Since we rendered a simple value during initial render (and all the\n        // updates up until this point), we need to pretend that the result is\n        // produced by the \"VALUE\" branch of the deopted append opcode:\n        //\n        //   Try(BEGIN, END)\n        //     Assert(IsComponentDefinition, expected=false)\n        //     OptimizedUpdate\n        //\n        // In this case, because the reference has switched from being a simple\n        // value into a component definition, what would have happened is that\n        // the assert would throw, causing the Try opcode to teardown the bounds\n        // and rerun the original append opcode.\n        //\n        // Since the Try opcode would have nuked the updating opcodes anyway, we\n        // wouldn't have to worry about simulating those. All we have to do is to\n        // execute the Try opcode and immediately throw.\n        let { bounds, appendOpcode, state } = this;\n        let appendOps = appendOpcode.deopt(vm.env);\n        let enter = appendOps.head();\n        let ops = enter.slice;\n        let tracker = new UpdatableBlockTracker(bounds.parentElement());\n        tracker.newBounds(this.bounds);\n        let children = new LinkedList();\n        let deopted = this.deopted = new TryOpcode(ops, state, tracker, children);\n        this._tag.update(deopted.tag);\n        vm.evaluateOpcode(deopted);\n        vm.throw();\n        // From this point on, we have essentially replaced ourselve with a new\n        // opcode. Since we will always be executing the new/deopted code, it's a\n        // good idea (as a pattern) to null out any unneeded fields here to avoid\n        // holding on to unneeded/stale objects:\n        this._tag = null;\n        this.reference = null;\n        this.cache = null;\n        this.bounds = null;\n        this.upsert = null;\n        this.appendOpcode = null;\n        this.state = null;\n    }\n    toJSON() {\n        let { _guid: guid, type, deopted } = this;\n        if (deopted) {\n            return {\n                guid,\n                type,\n                deopted: true,\n                children: [deopted.toJSON()]\n            };\n        }\n        else {\n            return super.toJSON();\n        }\n    }\n}\nexport class OptimizedCautiousAppendOpcode extends AppendOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'optimized-cautious-append';\n    }\n    normalize(reference) {\n        return map(reference, normalizeValue);\n    }\n    insert(dom, cursor, value) {\n        return cautiousInsert(dom, cursor, value);\n    }\n    updateWith(vm, reference, cache, bounds, upsert) {\n        return new OptimizedCautiousUpdateOpcode(cache, bounds, upsert);\n    }\n}\nclass OptimizedCautiousUpdateOpcode extends UpdateOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'optimized-cautious-update';\n    }\n    insert(dom, cursor, value) {\n        return cautiousInsert(dom, cursor, value);\n    }\n}\nexport class GuardedCautiousAppendOpcode extends GuardedAppendOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'guarded-cautious-append';\n        this.AppendOpcode = OptimizedCautiousAppendOpcode;\n    }\n    normalize(reference) {\n        return map(reference, normalizeValue);\n    }\n    insert(dom, cursor, value) {\n        return cautiousInsert(dom, cursor, value);\n    }\n    updateWith(vm, reference, cache, bounds, upsert) {\n        return new GuardedCautiousUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());\n    }\n}\nclass GuardedCautiousUpdateOpcode extends GuardedUpdateOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'guarded-cautious-update';\n    }\n    insert(dom, cursor, value) {\n        return cautiousInsert(dom, cursor, value);\n    }\n}\nexport class OptimizedTrustingAppendOpcode extends AppendOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'optimized-trusting-append';\n    }\n    normalize(reference) {\n        return map(reference, normalizeTrustedValue);\n    }\n    insert(dom, cursor, value) {\n        return trustingInsert(dom, cursor, value);\n    }\n    updateWith(vm, reference, cache, bounds, upsert) {\n        return new OptimizedTrustingUpdateOpcode(cache, bounds, upsert);\n    }\n}\nclass OptimizedTrustingUpdateOpcode extends UpdateOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'optimized-trusting-update';\n    }\n    insert(dom, cursor, value) {\n        return trustingInsert(dom, cursor, value);\n    }\n}\nexport class GuardedTrustingAppendOpcode extends GuardedAppendOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'guarded-trusting-append';\n        this.AppendOpcode = OptimizedTrustingAppendOpcode;\n    }\n    normalize(reference) {\n        return map(reference, normalizeTrustedValue);\n    }\n    insert(dom, cursor, value) {\n        return trustingInsert(dom, cursor, value);\n    }\n    updateWith(vm, reference, cache, bounds, upsert) {\n        return new GuardedTrustingUpdateOpcode(reference, cache, bounds, upsert, this, vm.capture());\n    }\n}\nclass GuardedTrustingUpdateOpcode extends GuardedUpdateOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = 'trusting-update';\n    }\n    insert(dom, cursor, value) {\n        return trustingInsert(dom, cursor, value);\n    }\n}\n"]} enifed('glimmer-runtime/lib/compiled/opcodes/dom', ['exports', 'glimmer-runtime/lib/opcodes', 'glimmer-util', 'glimmer-reference', 'glimmer-runtime/lib/references', 'glimmer-runtime/lib/compiled/expressions/value'], function (exports, _glimmerRuntimeLibOpcodes, _glimmerUtil, _glimmerReference, _glimmerRuntimeLibReferences, _glimmerRuntimeLibCompiledExpressionsValue) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var TextOpcode = (function (_Opcode) { - _inherits(TextOpcode, _Opcode); + babelHelpers.inherits(TextOpcode, _Opcode); function TextOpcode(_ref) { var text = _ref.text; - _classCallCheck(this, TextOpcode); - _Opcode.call(this); this.type = "text"; this.text = text; } @@ -16946,20 +17461,16 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.TextOpcode = TextOpcode; var OpenPrimitiveElementOpcode = (function (_Opcode2) { - _inherits(OpenPrimitiveElementOpcode, _Opcode2); + babelHelpers.inherits(OpenPrimitiveElementOpcode, _Opcode2); - function OpenPrimitiveElementOpcode(_ref2) { - var tag = _ref2.tag; - - _classCallCheck(this, OpenPrimitiveElementOpcode); - + function OpenPrimitiveElementOpcode(tag) { _Opcode2.call(this); - this.type = "open-primitive-element"; this.tag = tag; + this.type = "open-primitive-element"; } OpenPrimitiveElementOpcode.prototype.evaluate = function evaluate(vm) { vm.stack().openElement(this.tag); }; @@ -16975,21 +17486,41 @@ return OpenPrimitiveElementOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.OpenPrimitiveElementOpcode = OpenPrimitiveElementOpcode; - var OpenDynamicPrimitiveElementOpcode = (function (_Opcode3) { - _inherits(OpenDynamicPrimitiveElementOpcode, _Opcode3); + var OpenComponentElementOpcode = (function (_Opcode3) { + babelHelpers.inherits(OpenComponentElementOpcode, _Opcode3); - function OpenDynamicPrimitiveElementOpcode() { - _classCallCheck(this, OpenDynamicPrimitiveElementOpcode); + function OpenComponentElementOpcode(tag) { + _Opcode3.call(this); + this.tag = tag; + this.type = "open-component-element"; + } - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } + OpenComponentElementOpcode.prototype.evaluate = function evaluate(vm) { + vm.stack().openElement(this.tag, new ComponentElementOperations(vm.env)); + }; - _Opcode3.call.apply(_Opcode3, [this].concat(args)); + OpenComponentElementOpcode.prototype.toJSON = function toJSON() { + return { + guid: this._guid, + type: this.type, + args: [JSON.stringify(this.tag)] + }; + }; + + return OpenComponentElementOpcode; + })(_glimmerRuntimeLibOpcodes.Opcode); + + exports.OpenComponentElementOpcode = OpenComponentElementOpcode; + + var OpenDynamicPrimitiveElementOpcode = (function (_Opcode4) { + babelHelpers.inherits(OpenDynamicPrimitiveElementOpcode, _Opcode4); + + function OpenDynamicPrimitiveElementOpcode() { + _Opcode4.apply(this, arguments); this.type = "open-dynamic-primitive-element"; } OpenDynamicPrimitiveElementOpcode.prototype.evaluate = function evaluate(vm) { var tagName = vm.frame.getOperand().value(); @@ -17009,12 +17540,10 @@ exports.OpenDynamicPrimitiveElementOpcode = OpenDynamicPrimitiveElementOpcode; var ClassList = (function () { function ClassList() { - _classCallCheck(this, ClassList); - this.list = null; this.isConst = true; } ClassList.prototype.append = function append(reference) { @@ -17037,15 +17566,13 @@ return ClassList; })(); var ClassListReference = (function (_CachedReference) { - _inherits(ClassListReference, _CachedReference); + babelHelpers.inherits(ClassListReference, _CachedReference); function ClassListReference(list) { - _classCallCheck(this, ClassListReference); - _CachedReference.call(this); this.list = []; this.tag = _glimmerReference.combineTagged(list); this.list = list; } @@ -17064,96 +17591,242 @@ if (value !== false && value !== null && value !== undefined) ret.push(value); } return ret.length === 0 ? null : ret.join(' '); } - var CloseElementOpcode = (function (_Opcode4) { - _inherits(CloseElementOpcode, _Opcode4); + var SimpleElementOperations = (function () { + function SimpleElementOperations(env) { + this.env = env; + this.opcodes = null; + this.classList = null; + } - function CloseElementOpcode() { - _classCallCheck(this, CloseElementOpcode); + SimpleElementOperations.prototype.addStaticAttribute = function addStaticAttribute(element, name, value) { + if (name === 'class') { + this.addClass(new _glimmerRuntimeLibCompiledExpressionsValue.ValueReference(value)); + } else { + this.env.getAppendOperations().setAttribute(element, name, value); + } + }; - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; + SimpleElementOperations.prototype.addStaticAttributeNS = function addStaticAttributeNS(element, namespace, name, value) { + this.env.getAppendOperations().setAttribute(element, name, value, namespace); + }; + + SimpleElementOperations.prototype.addDynamicAttribute = function addDynamicAttribute(element, name, reference, isTrusting) { + if (name === 'class') { + this.addClass(reference); + } else { + var attributeManager = this.env.attributeFor(element, name, isTrusting); + var attribute = new DynamicAttribute(element, attributeManager, name, reference); + this.addAttribute(attribute); } + }; - _Opcode4.call.apply(_Opcode4, [this].concat(args)); - this.type = "close-element"; - } + SimpleElementOperations.prototype.addDynamicAttributeNS = function addDynamicAttributeNS(element, namespace, name, reference, isTrusting) { + var attributeManager = this.env.attributeFor(element, name, isTrusting, namespace); + var nsAttribute = new DynamicAttribute(element, attributeManager, name, reference, namespace); + this.addAttribute(nsAttribute); + }; - CloseElementOpcode.prototype.evaluate = function evaluate(vm) { - var dom = vm.env.getDOM(); - var stack = vm.stack(); - var element = stack.element; - var groups = stack.elementOperations.groups; + SimpleElementOperations.prototype.flush = function flush(element, vm) { + var env = vm.env; + var opcodes = this.opcodes; + var classList = this.classList; - var classList = new ClassList(); - var flattened = _glimmerUtil.dict(); - var flattenedKeys = []; - // This is a hardcoded merge strategy: - // 1. Classes are merged together split by whitespace - // 2. Other attributes are first-write-wins (which means invocation - // wins over top-level element in components) - for (var i = 0; i < groups.length; i++) { - for (var j = 0; j < groups[i].length; j++) { - var op = groups[i][j]; - var _name = op['name']; - var reference = op['reference']; - if (_name === 'class') { - classList.append(reference); - } else if (!flattened[_name]) { - flattenedKeys.push(_name); - flattened[_name] = op; - } + for (var i = 0; opcodes && i < opcodes.length; i++) { + vm.updateWith(opcodes[i]); + } + if (classList) { + var attributeManager = env.attributeFor(element, 'class', false); + var attribute = new DynamicAttribute(element, attributeManager, 'class', classList.toReference()); + var opcode = attribute.flush(env); + if (opcode) { + vm.updateWith(opcode); } } - var className = classList.toReference(); - var attr = 'class'; - var attributeManager = vm.env.attributeFor(element, attr, className, false); - var attribute = new Attribute(element, attributeManager, attr, className); - var opcode = attribute.flush(dom); + this.opcodes = null; + this.classList = null; + }; + + SimpleElementOperations.prototype.addClass = function addClass(reference) { + var classList = this.classList; + + if (!classList) { + classList = this.classList = new ClassList(); + } + classList.append(reference); + }; + + SimpleElementOperations.prototype.addAttribute = function addAttribute(attribute) { + var opcode = attribute.flush(this.env); if (opcode) { - vm.updateWith(opcode); + var opcodes = this.opcodes; + + if (!opcodes) { + opcodes = this.opcodes = []; + } + opcodes.push(opcode); } - for (var k = 0; k < flattenedKeys.length; k++) { - var _opcode = flattened[flattenedKeys[k]].flush(dom); - if (_opcode) vm.updateWith(_opcode); + }; + + return SimpleElementOperations; + })(); + + exports.SimpleElementOperations = SimpleElementOperations; + + var ComponentElementOperations = (function () { + function ComponentElementOperations(env) { + this.env = env; + this.attributeNames = null; + this.attributes = null; + this.classList = null; + } + + ComponentElementOperations.prototype.addStaticAttribute = function addStaticAttribute(element, name, value) { + if (name === 'class') { + this.addClass(new _glimmerRuntimeLibCompiledExpressionsValue.ValueReference(value)); + } else if (this.shouldAddAttribute(name)) { + this.addAttribute(name, new StaticAttribute(element, name, value)); } - stack.closeElement(); }; + ComponentElementOperations.prototype.addStaticAttributeNS = function addStaticAttributeNS(element, namespace, name, value) { + if (this.shouldAddAttribute(name)) { + this.addAttribute(name, new StaticAttribute(element, name, value, namespace)); + } + }; + + ComponentElementOperations.prototype.addDynamicAttribute = function addDynamicAttribute(element, name, reference, isTrusting) { + if (name === 'class') { + this.addClass(reference); + } else if (this.shouldAddAttribute(name)) { + var attributeManager = this.env.attributeFor(element, name, isTrusting); + var attribute = new DynamicAttribute(element, attributeManager, name, reference); + this.addAttribute(name, attribute); + } + }; + + ComponentElementOperations.prototype.addDynamicAttributeNS = function addDynamicAttributeNS(element, namespace, name, reference, isTrusting) { + if (this.shouldAddAttribute(name)) { + var attributeManager = this.env.attributeFor(element, name, isTrusting, namespace); + var nsAttribute = new DynamicAttribute(element, attributeManager, name, reference, namespace); + this.addAttribute(name, nsAttribute); + } + }; + + ComponentElementOperations.prototype.flush = function flush(element, vm) { + var env = this.env; + var attributes = this.attributes; + var classList = this.classList; + + for (var i = 0; attributes && i < attributes.length; i++) { + var opcode = attributes[i].flush(env); + if (opcode) { + vm.updateWith(opcode); + } + } + if (classList) { + var attributeManager = env.attributeFor(element, 'class', false); + var attribute = new DynamicAttribute(element, attributeManager, 'class', classList.toReference()); + var opcode = attribute.flush(env); + if (opcode) { + vm.updateWith(opcode); + } + } + }; + + ComponentElementOperations.prototype.shouldAddAttribute = function shouldAddAttribute(name) { + return !this.attributeNames || this.attributeNames.indexOf(name) === -1; + }; + + ComponentElementOperations.prototype.addClass = function addClass(reference) { + var classList = this.classList; + + if (!classList) { + classList = this.classList = new ClassList(); + } + classList.append(reference); + }; + + ComponentElementOperations.prototype.addAttribute = function addAttribute(name, attribute) { + var attributeNames = this.attributeNames; + var attributes = this.attributes; + + if (!attributeNames) { + attributeNames = this.attributeNames = []; + attributes = this.attributes = []; + } + attributeNames.push(name); + attributes.push(attribute); + }; + + return ComponentElementOperations; + })(); + + exports.ComponentElementOperations = ComponentElementOperations; + + var FlushElementOpcode = (function (_Opcode5) { + babelHelpers.inherits(FlushElementOpcode, _Opcode5); + + function FlushElementOpcode() { + _Opcode5.apply(this, arguments); + this.type = "flush-element"; + } + + FlushElementOpcode.prototype.evaluate = function evaluate(vm) { + var stack = vm.stack(); + stack.operations.flush(stack.constructing, vm); + stack.flushElement(); + }; + + return FlushElementOpcode; + })(_glimmerRuntimeLibOpcodes.Opcode); + + exports.FlushElementOpcode = FlushElementOpcode; + + var CloseElementOpcode = (function (_Opcode6) { + babelHelpers.inherits(CloseElementOpcode, _Opcode6); + + function CloseElementOpcode() { + _Opcode6.apply(this, arguments); + this.type = "close-element"; + } + + CloseElementOpcode.prototype.evaluate = function evaluate(vm) { + vm.stack().closeElement(); + }; + return CloseElementOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.CloseElementOpcode = CloseElementOpcode; - var StaticAttrOpcode = (function (_Opcode5) { - _inherits(StaticAttrOpcode, _Opcode5); + var StaticAttrOpcode = (function (_Opcode7) { + babelHelpers.inherits(StaticAttrOpcode, _Opcode7); - function StaticAttrOpcode(_ref3) { - var namespace = _ref3.namespace; - var name = _ref3.name; - var value = _ref3.value; + function StaticAttrOpcode(_ref2) { + var namespace = _ref2.namespace; + var name = _ref2.name; + var value = _ref2.value; - _classCallCheck(this, StaticAttrOpcode); - - _Opcode5.call(this); + _Opcode7.call(this); this.type = "static-attr"; this.namespace = namespace; this.name = name; - this.value = new _glimmerRuntimeLibCompiledExpressionsValue.ValueReference(value); + this.value = value; } StaticAttrOpcode.prototype.evaluate = function evaluate(vm) { var name = this.name; var value = this.value; var namespace = this.namespace; if (namespace) { - vm.stack().setAttributeNS(namespace, name, value, false); + vm.stack().setStaticAttributeNS(namespace, name, value); } else { - vm.stack().setAttribute(name, value, false); + vm.stack().setStaticAttribute(name, value); } }; StaticAttrOpcode.prototype.toJSON = function toJSON() { var guid = this._guid; @@ -17165,57 +17838,46 @@ var details = _glimmerUtil.dict(); if (namespace) { details["namespace"] = JSON.stringify(namespace); } details["name"] = JSON.stringify(name); - details["value"] = JSON.stringify(value.value()); + details["value"] = JSON.stringify(value); return { guid: guid, type: type, details: details }; }; return StaticAttrOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.StaticAttrOpcode = StaticAttrOpcode; - var ModifierOpcode = (function (_Opcode6) { - _inherits(ModifierOpcode, _Opcode6); + var ModifierOpcode = (function (_Opcode8) { + babelHelpers.inherits(ModifierOpcode, _Opcode8); - function ModifierOpcode(_ref4) { - var name = _ref4.name; - var manager = _ref4.manager; - var args = _ref4.args; - - _classCallCheck(this, ModifierOpcode); - - _Opcode6.call(this); - this.type = "modifier"; + function ModifierOpcode(name, manager, args) { + _Opcode8.call(this); this.name = name; this.manager = manager; this.args = args; + this.type = "modifier"; } ModifierOpcode.prototype.evaluate = function evaluate(vm) { var manager = this.manager; var stack = vm.stack(); - var element = stack.element; - var dom = stack.dom; + var element = stack.constructing; + var updateOperations = stack.updateOperations; var args = this.args.evaluate(vm); var dynamicScope = vm.dynamicScope(); - var modifier = manager.install(element, args, dom, dynamicScope); + var modifier = manager.create(element, args, dynamicScope, updateOperations); + vm.env.scheduleInstallModifier(modifier, manager); var destructor = manager.getDestructor(modifier); if (destructor) { vm.newDestroyable(destructor); } - vm.updateWith(new UpdateModifierOpcode({ - manager: manager, - modifier: modifier, - element: element, - dynamicScope: dynamicScope, - args: args - })); + vm.updateWith(new UpdateModifierOpcode(manager, modifier, args)); }; ModifierOpcode.prototype.toJSON = function toJSON() { var guid = this._guid; var type = this.type; @@ -17233,43 +17895,31 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.ModifierOpcode = ModifierOpcode; var UpdateModifierOpcode = (function (_UpdatingOpcode) { - _inherits(UpdateModifierOpcode, _UpdatingOpcode); + babelHelpers.inherits(UpdateModifierOpcode, _UpdatingOpcode); - function UpdateModifierOpcode(_ref5) { - var manager = _ref5.manager; - var modifier = _ref5.modifier; - var element = _ref5.element; - var dynamicScope = _ref5.dynamicScope; - var args = _ref5.args; - - _classCallCheck(this, UpdateModifierOpcode); - + function UpdateModifierOpcode(manager, modifier, args) { _UpdatingOpcode.call(this); - this.type = "update-modifier"; - this.modifier = modifier; this.manager = manager; - this.element = element; - this.dynamicScope = dynamicScope; + this.modifier = modifier; this.args = args; + this.type = "update-modifier"; this.tag = args.tag; this.lastUpdated = args.tag.value(); } UpdateModifierOpcode.prototype.evaluate = function evaluate(vm) { var manager = this.manager; var modifier = this.modifier; - var element = this.element; - var dynamicScope = this.dynamicScope; - var args = this.args; + var tag = this.tag; var lastUpdated = this.lastUpdated; - if (!args.tag.validate(lastUpdated)) { - manager.update(modifier, element, args, vm.dom, dynamicScope); - this.lastUpdated = args.tag.value(); + if (!tag.validate(lastUpdated)) { + vm.env.scheduleUpdateModifier(modifier, manager); + this.lastUpdated = tag.value(); } }; UpdateModifierOpcode.prototype.toJSON = function toJSON() { return { @@ -17282,49 +17932,71 @@ return UpdateModifierOpcode; })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); exports.UpdateModifierOpcode = UpdateModifierOpcode; - var Attribute = (function () { - function Attribute(element, changeList, name, reference, namespace) { - _classCallCheck(this, Attribute); + var StaticAttribute = (function () { + function StaticAttribute(element, name, value, namespace) { + this.element = element; + this.name = name; + this.value = value; + this.namespace = namespace; + } + StaticAttribute.prototype.flush = function flush(env) { + env.getAppendOperations().setAttribute(this.element, this.name, this.value, this.namespace); + return null; + }; + + return StaticAttribute; + })(); + + exports.StaticAttribute = StaticAttribute; + + var DynamicAttribute = (function () { + function DynamicAttribute(element, changeList, name, reference, namespace) { this.element = element; + this.changeList = changeList; + this.name = name; this.reference = reference; + this.namespace = namespace; + this.element = element; + this.reference = reference; this.changeList = changeList; this.tag = reference.tag; this.name = name; this.cache = null; this.namespace = namespace; } - Attribute.prototype.patch = function patch(dom) { + DynamicAttribute.prototype.patch = function patch(env) { var element = this.element; var cache = this.cache; var value = cache.revalidate(); if (_glimmerReference.isModified(value)) { - this.changeList.updateAttribute(dom, element, this.name, value, this.namespace); + this.changeList.updateAttribute(env, element, this.name, value, this.namespace); } }; - Attribute.prototype.flush = function flush(dom) { + DynamicAttribute.prototype.flush = function flush(env) { var reference = this.reference; var element = this.element; if (_glimmerReference.isConst(reference)) { var value = reference.value(); - this.changeList.setAttribute(dom, element, this.name, value, this.namespace); + this.changeList.setAttribute(env, element, this.name, value, this.namespace); + return null; } else { var cache = this.cache = new _glimmerReference.ReferenceCache(reference); var value = cache.peek(); - this.changeList.setAttribute(dom, element, this.name, value, this.namespace); + this.changeList.setAttribute(env, element, this.name, value, this.namespace); return new PatchElementOpcode(this); } }; - Attribute.prototype.toJSON = function toJSON() { + DynamicAttribute.prototype.toJSON = function toJSON() { var element = this.element; var namespace = this.namespace; var name = this.name; var cache = this.cache; @@ -17346,30 +18018,28 @@ name: name, lastValue: lastValue }; }; - return Attribute; + return DynamicAttribute; })(); - exports.Attribute = Attribute; + exports.DynamicAttribute = DynamicAttribute; function formatElement(element) { return JSON.stringify('<' + element.tagName.toLowerCase() + ' />'); } - var DynamicAttrNSOpcode = (function (_Opcode7) { - _inherits(DynamicAttrNSOpcode, _Opcode7); + var DynamicAttrNSOpcode = (function (_Opcode9) { + babelHelpers.inherits(DynamicAttrNSOpcode, _Opcode9); - function DynamicAttrNSOpcode(_ref6) { - var name = _ref6.name; - var namespace = _ref6.namespace; - var isTrusting = _ref6.isTrusting; + function DynamicAttrNSOpcode(_ref3) { + var name = _ref3.name; + var namespace = _ref3.namespace; + var isTrusting = _ref3.isTrusting; - _classCallCheck(this, DynamicAttrNSOpcode); - - _Opcode7.call(this); + _Opcode9.call(this); this.type = "dynamic-attr"; this.name = name; this.namespace = namespace; this.isTrusting = isTrusting; } @@ -17378,11 +18048,11 @@ var name = this.name; var namespace = this.namespace; var isTrusting = this.isTrusting; var reference = vm.frame.getOperand(); - vm.stack().setAttributeNS(namespace, name, reference, isTrusting); + vm.stack().setDynamicAttributeNS(namespace, name, reference, isTrusting); }; DynamicAttrNSOpcode.prototype.toJSON = function toJSON() { var guid = this._guid; var type = this.type; @@ -17401,31 +18071,29 @@ return DynamicAttrNSOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.DynamicAttrNSOpcode = DynamicAttrNSOpcode; - var DynamicAttrOpcode = (function (_Opcode8) { - _inherits(DynamicAttrOpcode, _Opcode8); + var DynamicAttrOpcode = (function (_Opcode10) { + babelHelpers.inherits(DynamicAttrOpcode, _Opcode10); - function DynamicAttrOpcode(_ref7) { - var name = _ref7.name; - var isTrusting = _ref7.isTrusting; + function DynamicAttrOpcode(_ref4) { + var name = _ref4.name; + var isTrusting = _ref4.isTrusting; - _classCallCheck(this, DynamicAttrOpcode); - - _Opcode8.call(this); + _Opcode10.call(this); this.type = "dynamic-attr"; this.name = name; this.isTrusting = isTrusting; } DynamicAttrOpcode.prototype.evaluate = function evaluate(vm) { var name = this.name; var isTrusting = this.isTrusting; var reference = vm.frame.getOperand(); - vm.stack().setAttribute(name, reference, isTrusting); + vm.stack().setDynamicAttribute(name, reference, isTrusting); }; DynamicAttrOpcode.prototype.toJSON = function toJSON() { var guid = this._guid; var type = this.type; @@ -17441,23 +18109,21 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.DynamicAttrOpcode = DynamicAttrOpcode; var PatchElementOpcode = (function (_UpdatingOpcode2) { - _inherits(PatchElementOpcode, _UpdatingOpcode2); + babelHelpers.inherits(PatchElementOpcode, _UpdatingOpcode2); function PatchElementOpcode(operation) { - _classCallCheck(this, PatchElementOpcode); - _UpdatingOpcode2.call(this); this.type = "patch-element"; this.tag = operation.tag; this.operation = operation; } PatchElementOpcode.prototype.evaluate = function evaluate(vm) { - this.operation.patch(vm.env.getDOM()); + this.operation.patch(vm.env); }; PatchElementOpcode.prototype.toJSON = function toJSON() { var _guid = this._guid; var type = this.type; @@ -17473,19 +18139,17 @@ return PatchElementOpcode; })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); exports.PatchElementOpcode = PatchElementOpcode; - var CommentOpcode = (function (_Opcode9) { - _inherits(CommentOpcode, _Opcode9); + var CommentOpcode = (function (_Opcode11) { + babelHelpers.inherits(CommentOpcode, _Opcode11); - function CommentOpcode(_ref8) { - var comment = _ref8.comment; + function CommentOpcode(_ref5) { + var comment = _ref5.comment; - _classCallCheck(this, CommentOpcode); - - _Opcode9.call(this); + _Opcode11.call(this); this.type = "comment"; this.comment = comment; } CommentOpcode.prototype.evaluate = function evaluate(vm) { @@ -17503,24 +18167,16 @@ return CommentOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.CommentOpcode = CommentOpcode; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/dom.ts"],"names":[],"mappings":"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","file":"dom.js","sourcesContent":["import { Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { VM, UpdatingVM } from '../../vm';\nimport { DynamicScope } from '../../environment';\nimport { FIXME, InternedString, Opaque, Dict, dict } from 'glimmer-util';\nimport {\n  CachedReference,\n  Reference,\n  ReferenceCache,\n  RevisionTag,\n  Revision,\n  combineTagged,\n  isConst as isConstReference,\n  isModified\n} from 'glimmer-reference';\nimport { ModifierManager } from '../../modifier/interfaces';\nimport { DOMHelper } from '../../dom/helper';\nimport { NULL_REFERENCE } from '../../references';\nimport { ValueReference } from '../../compiled/expressions/value';\nimport { CompiledArgs, EvaluatedArgs } from '../../compiled/expressions/args';\nimport { IChangeList } from '../../dom/change-lists';\n\nexport class TextOpcode extends Opcode {\n  public type = \"text\";\n  public text: InternedString;\n\n  constructor({ text }: { text: InternedString }) {\n    super();\n    this.text = text;\n  }\n\n  evaluate(vm: VM) {\n    vm.stack().appendText(this.text);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.text)]\n    };\n  }\n}\n\nexport class OpenPrimitiveElementOpcode extends Opcode {\n  public type = \"open-primitive-element\";\n  public tag: InternedString;\n\n  constructor({ tag }: { tag: InternedString }) {\n    super();\n    this.tag = tag;\n  }\n\n  evaluate(vm: VM) {\n    vm.stack().openElement(this.tag);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.tag)]\n    };\n  }\n}\n\nexport class OpenDynamicPrimitiveElementOpcode extends Opcode {\n  public type = \"open-dynamic-primitive-element\";\n\n  evaluate(vm: VM) {\n    let tagName = vm.frame.getOperand().value() as FIXME<'user string to InternedString'>;\n    vm.stack().openElement(tagName);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\"]\n    };\n  }\n}\n\nclass ClassList {\n  private list: Reference<string>[] = null;\n  private isConst = true;\n\n  append(reference: Reference<string>) {\n    let { list, isConst } = this;\n\n    if (list === null) list = this.list = [];\n\n    list.push(reference);\n    this.isConst = isConst && isConstReference(reference);\n  }\n\n  toReference(): Reference<string> {\n    let { list, isConst } = this;\n\n    if (!list) return NULL_REFERENCE;\n\n    if (isConst) return new ValueReference(toClassName(list));\n\n    return new ClassListReference(list);\n  }\n\n}\n\nclass ClassListReference extends CachedReference<string> {\n  public tag: RevisionTag;\n  private list: Reference<string>[] = [];\n\n  constructor(list: Reference<string>[]) {\n    super();\n    this.tag = combineTagged(list);\n    this.list = list;\n  }\n\n  protected compute(): string {\n    return toClassName(this.list);\n  }\n}\n\nfunction toClassName(list: Reference<string>[]) {\n  let ret = [];\n\n  for (let i = 0; i < list.length; i++) {\n    let value: FIXME<'use Opaque and normalize'> = list[i].value();\n    if (value !== false && value !== null && value !== undefined) ret.push(value);\n  }\n\n  return (ret.length === 0) ? null : ret.join(' ');\n}\n\nexport class CloseElementOpcode extends Opcode {\n  public type = \"close-element\";\n\n  evaluate(vm: VM) {\n    let dom = vm.env.getDOM();\n    let stack = vm.stack();\n    let { element, elementOperations: { groups } } = stack;\n\n    let classList = new ClassList();\n    let flattened = dict<Attribute>();\n    let flattenedKeys = [];\n\n    // This is a hardcoded merge strategy:\n    // 1. Classes are merged together split by whitespace\n    // 2. Other attributes are first-write-wins (which means invocation\n    //    wins over top-level element in components)\n\n    for (let i = 0; i < groups.length; i++) {\n      for (let j = 0; j < groups[i].length; j++) {\n        let op = groups[i][j];\n        let name = op['name'] as FIXME<string>;\n        let reference = op['reference'] as FIXME<Reference<string>>;\n        if (name === 'class') {\n          classList.append(reference);\n        } else if (!flattened[name]) {\n          flattenedKeys.push(name);\n          flattened[name] = op;\n        }\n      }\n    }\n\n    let className = classList.toReference();\n    let attr = 'class' as InternedString;\n    let attributeManager = vm.env.attributeFor(element, attr, className, false);\n    let attribute = new Attribute(element, attributeManager, attr, className);\n    let opcode = attribute.flush(dom);\n\n    if (opcode) {\n      vm.updateWith(opcode);\n    }\n\n    for (let k = 0; k < flattenedKeys.length; k++) {\n      let opcode = flattened[flattenedKeys[k]].flush(dom);\n      if (opcode) vm.updateWith(opcode);\n    }\n\n    stack.closeElement();\n  }\n}\n\nexport interface StaticAttrOptions {\n  namespace: InternedString;\n  name: InternedString;\n  value: InternedString;\n}\n\nexport class StaticAttrOpcode extends Opcode {\n  public type = \"static-attr\";\n  public namespace: InternedString;\n  public name: InternedString;\n  public value: ValueReference<string>;\n\n  constructor({ namespace, name, value }: StaticAttrOptions) {\n    super();\n    this.namespace = namespace;\n    this.name = name;\n    this.value = new ValueReference(value);\n  }\n\n  evaluate(vm: VM) {\n    let { name, value, namespace } = this;\n    if (namespace) {\n      vm.stack().setAttributeNS(namespace, name, value, false);\n    } else {\n      vm.stack().setAttribute(name, value, false);\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, namespace, name, value } = this;\n\n    let details = dict<string>();\n\n    if (namespace) {\n      details[\"namespace\"] = JSON.stringify(namespace);\n    }\n\n    details[\"name\"] = JSON.stringify(name);\n    details[\"value\"] = JSON.stringify(value.value());\n\n    return { guid, type, details };\n  }\n}\n\nexport class ModifierOpcode extends Opcode {\n  public type = \"modifier\";\n  public name: InternedString;\n  public args: CompiledArgs;\n  private manager: ModifierManager<Opaque>;\n\n  constructor({ name, manager, args }: { name: InternedString, manager: ModifierManager<Opaque>, args: CompiledArgs }) {\n    super();\n    this.name = name;\n    this.manager = manager;\n    this.args = args;\n  }\n\n  evaluate(vm: VM) {\n    let { manager } = this;\n    let stack = vm.stack();\n    let { element, dom } = stack;\n    let args = this.args.evaluate(vm);\n    let dynamicScope = vm.dynamicScope();\n\n    let modifier = manager.install(element, args, dom, dynamicScope);\n    let destructor = manager.getDestructor(modifier);\n\n    if (destructor) {\n      vm.newDestroyable(destructor);\n    }\n\n    vm.updateWith(new UpdateModifierOpcode({\n      manager,\n      modifier,\n      element,\n      dynamicScope,\n      args\n    }));\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, name, args } = this;\n\n    let details = dict<string>();\n\n    details[\"type\"] = JSON.stringify(type);\n    details[\"name\"] = JSON.stringify(name);\n    details[\"args\"] = JSON.stringify(args);\n\n    return { guid, type, details };\n  }\n}\n\nexport class UpdateModifierOpcode extends UpdatingOpcode {\n  public type = \"update-modifier\";\n\n  private element: Element;\n  private dynamicScope: DynamicScope;\n  private args: EvaluatedArgs;\n  private manager: ModifierManager<Opaque>;\n  private modifier: Opaque;\n  private lastUpdated: Revision;\n\n  constructor({ manager, modifier, element, dynamicScope, args }: { manager: ModifierManager<Opaque>, modifier: Opaque, element: Element, dynamicScope: DynamicScope, args: EvaluatedArgs }) {\n    super();\n    this.modifier = modifier;\n    this.manager = manager;\n    this.element = element;\n    this.dynamicScope = dynamicScope;\n    this.args = args;\n    this.tag = args.tag;\n    this.lastUpdated = args.tag.value();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { manager, modifier, element, dynamicScope, args, lastUpdated } = this;\n\n    if (!args.tag.validate(lastUpdated)) {\n      manager.update(modifier, element, args, vm.dom, dynamicScope);\n      this.lastUpdated = args.tag.value();\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.args)]\n    };\n  }\n}\n\nexport class Attribute {\n  private changeList: IChangeList;\n  private element: Element;\n  private reference: Reference<Opaque>;\n  private cache: ReferenceCache<Opaque>;\n  private namespace: string | undefined;\n\n  protected name: InternedString;\n\n  public tag: RevisionTag;\n\n  constructor(element: Element, changeList: IChangeList, name: InternedString, reference: Reference<Opaque>, namespace?: string) {\n    this.element = element;\n    this.reference = reference;\n    this.changeList = changeList;\n    this.tag = reference.tag;\n    this.name = name;\n    this.cache = null;\n    this.namespace = namespace;\n  }\n\n  patch(dom: DOMHelper) {\n    let { element, cache } = this;\n\n    let value = cache.revalidate();\n\n    if (isModified(value)) {\n      this.changeList.updateAttribute(dom, element, this.name, value, this.namespace);\n    }\n  }\n\n  flush(dom: DOMHelper): UpdatingOpcode {\n    let { reference, element } = this;\n\n    if (isConstReference(reference)) {\n      let value = reference.value();\n      this.changeList.setAttribute(dom, element, this.name, value, this.namespace);\n    } else {\n      let cache = this.cache = new ReferenceCache(reference);\n      let value = cache.peek();\n      this.changeList.setAttribute(dom, element, this.name, value, this.namespace);\n      return new PatchElementOpcode(this);\n    }\n  }\n\n  toJSON(): Dict<string> {\n    let { element, namespace, name, cache } = this;\n\n    let formattedElement = formatElement(element);\n    let lastValue = cache.peek() as string;\n\n    if (namespace) {\n      return {\n        element: formattedElement,\n        type: 'attribute',\n        namespace,\n        name,\n        lastValue\n      };\n    }\n\n    return {\n      element: formattedElement,\n      type: 'attribute',\n      namespace,\n      name,\n      lastValue\n    };\n  }\n}\n\nfunction formatElement(element: Element): string {\n  return JSON.stringify(`<${element.tagName.toLowerCase()} />`);\n}\n\nexport interface DynamicAttrNSOptions {\n  name: InternedString;\n  namespace: InternedString;\n  isTrusting: boolean;\n}\n\nexport class DynamicAttrNSOpcode extends Opcode {\n  public type = \"dynamic-attr\";\n  public name: InternedString;\n  public namespace: InternedString;\n  public isTrusting: boolean;\n\n  constructor({ name, namespace, isTrusting }: DynamicAttrNSOptions) {\n    super();\n    this.name = name;\n    this.namespace = namespace;\n    this.isTrusting = isTrusting;\n  }\n\n  evaluate(vm: VM) {\n    let { name, namespace, isTrusting } = this;\n    let reference = vm.frame.getOperand();\n    vm.stack().setAttributeNS(namespace, name, reference, isTrusting);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, name, namespace } = this;\n\n    let details = dict<string>();\n\n    details[\"name\"] = JSON.stringify(name);\n    details[\"value\"] = \"$OPERAND\";\n\n    if (namespace) {\n      details[\"namespace\"] = JSON.stringify(namespace);\n    }\n\n    return { guid, type, details };\n  }\n}\n\nexport interface SimpleAttrOptions {\n  name: InternedString;\n  isTrusting: boolean;\n}\n\nexport class DynamicAttrOpcode extends Opcode {\n  public type = \"dynamic-attr\";\n  public name: InternedString;\n  public isTrusting: boolean;\n\n  constructor({ name, isTrusting }: SimpleAttrOptions) {\n    super();\n    this.name = name;\n    this.isTrusting = isTrusting;\n  }\n\n  evaluate(vm: VM) {\n    let { name, isTrusting } = this;\n    let reference = vm.frame.getOperand();\n    vm.stack().setAttribute(name, reference, isTrusting);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, name } = this;\n\n    let details = dict<string>();\n\n    details[\"name\"] = JSON.stringify(name);\n    details[\"value\"] = \"$OPERAND\";\n\n    return { guid, type, details };\n  }\n}\n\nexport class PatchElementOpcode extends UpdatingOpcode {\n  public type = \"patch-element\";\n\n  private operation: Attribute;\n\n  constructor(operation: Attribute) {\n    super();\n    this.tag = operation.tag;\n    this.operation = operation;\n  }\n\n  evaluate(vm: UpdatingVM) {\n    this.operation.patch(vm.env.getDOM());\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid, type, operation } = this;\n\n    return {\n      guid: _guid,\n      type,\n      details: operation.toJSON()\n    };\n  }\n}\n\nexport interface CommentOptions {\n  comment: InternedString;\n}\n\nexport class CommentOpcode extends Opcode {\n  public type = \"comment\";\n  public comment: InternedString;\n\n  constructor({ comment }: CommentOptions) {\n    super();\n    this.comment = comment;\n  }\n\n  evaluate(vm: VM) {\n    vm.stack().appendComment(this.comment);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.comment)]\n    };\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/dom.ts"],"names":[],"mappings":"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","file":"dom.js","sourcesContent":["import { Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { VM, UpdatingVM } from '../../vm';\nimport * as Simple from '../../dom/interfaces';\nimport { FIX_REIFICATION } from '../../dom/interfaces';\nimport { Environment } from '../../environment';\nimport { FIXME, Option, Opaque, Dict, dict } from 'glimmer-util';\nimport {\n  CachedReference,\n  Reference,\n  ReferenceCache,\n  RevisionTag,\n  Revision,\n  PathReference,\n  combineTagged,\n  isConst as isConstReference,\n  isModified\n} from 'glimmer-reference';\nimport { ModifierManager } from '../../modifier/interfaces';\nimport { NULL_REFERENCE } from '../../references';\nimport { ValueReference } from '../../compiled/expressions/value';\nimport { CompiledArgs, EvaluatedArgs } from '../../compiled/expressions/args';\nimport { IChangeList } from '../../dom/change-lists';\nimport { ElementOperations } from '../../builder';\n\nexport class TextOpcode extends Opcode {\n  public type = \"text\";\n  public text: string;\n\n  constructor({ text }: { text: string }) {\n    super();\n    this.text = text;\n  }\n\n  evaluate(vm: VM) {\n    vm.stack().appendText(this.text);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.text)]\n    };\n  }\n}\n\nexport class OpenPrimitiveElementOpcode extends Opcode {\n  public type = \"open-primitive-element\";\n\n  constructor(private tag: string) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.stack().openElement(this.tag);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.tag)]\n    };\n  }\n}\n\nexport class OpenComponentElementOpcode extends Opcode {\n  public type = \"open-component-element\";\n\n  constructor(private tag: string) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.stack().openElement(this.tag, new ComponentElementOperations(vm.env));\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.tag)]\n    };\n  }\n}\n\nexport class OpenDynamicPrimitiveElementOpcode extends Opcode {\n  public type = \"open-dynamic-primitive-element\";\n\n  evaluate(vm: VM) {\n    let tagName = vm.frame.getOperand().value();\n    vm.stack().openElement(tagName);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\"]\n    };\n  }\n}\n\nclass ClassList {\n  private list: Reference<string>[] = null;\n  private isConst = true;\n\n  append(reference: Reference<string>) {\n    let { list, isConst } = this;\n\n    if (list === null) list = this.list = [];\n\n    list.push(reference);\n    this.isConst = isConst && isConstReference(reference);\n  }\n\n  toReference(): Reference<string> {\n    let { list, isConst } = this;\n\n    if (!list) return NULL_REFERENCE;\n\n    if (isConst) return new ValueReference(toClassName(list));\n\n    return new ClassListReference(list);\n  }\n\n}\n\nclass ClassListReference extends CachedReference<string> {\n  public tag: RevisionTag;\n  private list: Reference<string>[] = [];\n\n  constructor(list: Reference<string>[]) {\n    super();\n    this.tag = combineTagged(list);\n    this.list = list;\n  }\n\n  protected compute(): string {\n    return toClassName(this.list);\n  }\n}\n\nfunction toClassName(list: Reference<string>[]) {\n  let ret = [];\n\n  for (let i = 0; i < list.length; i++) {\n    let value: FIXME<Opaque, 'use Opaque and normalize'> = list[i].value();\n    if (value !== false && value !== null && value !== undefined) ret.push(value);\n  }\n\n  return (ret.length === 0) ? null : ret.join(' ');\n}\n\nexport class SimpleElementOperations implements ElementOperations {\n  private opcodes: UpdatingOpcode[] = null;\n  private classList: ClassList = null;\n\n  constructor(private env: Environment) {\n  }\n\n  addStaticAttribute(element: Simple.Element, name: string, value: string) {\n    if (name === 'class') {\n      this.addClass(new ValueReference(value));\n    } else {\n      this.env.getAppendOperations().setAttribute(element, name, value);\n    }\n  }\n\n  addStaticAttributeNS(element: Simple.Element, namespace: string, name: string, value: string) {\n    this.env.getAppendOperations().setAttribute(element, name, value, namespace);\n  }\n\n  addDynamicAttribute(element: Simple.Element, name: string, reference: PathReference<string>, isTrusting: boolean) {\n    if (name === 'class') {\n      this.addClass(reference);\n    } else {\n      let attributeManager = this.env.attributeFor(element, name, isTrusting);\n      let attribute = new DynamicAttribute(element, attributeManager, name, reference);\n\n      this.addAttribute(attribute);\n    }\n  }\n\n  addDynamicAttributeNS(element: Simple.Element, namespace: string, name: string, reference: PathReference<string>, isTrusting: boolean) {\n    let attributeManager = this.env.attributeFor(element, name,isTrusting, namespace);\n    let nsAttribute = new DynamicAttribute(element, attributeManager, name, reference, namespace);\n\n    this.addAttribute(nsAttribute);\n  }\n\n  flush(element: Simple.Element, vm: VM) {\n    let { env } = vm;\n    let { opcodes, classList } = this;\n\n    for (let i = 0; opcodes && i < opcodes.length; i++) {\n      vm.updateWith(opcodes[i]);\n    }\n\n    if (classList) {\n      let attributeManager = env.attributeFor(element, 'class', false);\n      let attribute = new DynamicAttribute(element, attributeManager, 'class', classList.toReference());\n      let opcode = attribute.flush(env);\n\n      if (opcode) {\n        vm.updateWith(opcode);\n      }\n    }\n\n    this.opcodes = null;\n    this.classList = null;\n  }\n\n  private addClass(reference: PathReference<string>) {\n    let { classList } = this;\n\n    if (!classList) {\n      classList = this.classList = new ClassList();\n    }\n\n    classList.append(reference);\n  }\n\n  private addAttribute(attribute: Attribute) {\n    let opcode = attribute.flush(this.env);\n\n    if (opcode) {\n      let { opcodes } = this;\n\n      if (!opcodes) {\n        opcodes = this.opcodes = [];\n      }\n\n      opcodes.push(opcode);\n    }\n  }\n}\n\nexport class ComponentElementOperations implements ElementOperations {\n  private attributeNames = null;\n  private attributes: Attribute[] = null;\n  private classList: ClassList = null;\n\n  constructor(private env: Environment) {\n  }\n\n  addStaticAttribute(element: Simple.Element, name: string, value: string) {\n    if (name === 'class') {\n      this.addClass(new ValueReference(value));\n    } else if (this.shouldAddAttribute(name)) {\n      this.addAttribute(name, new StaticAttribute(element, name, value));\n    }\n  }\n\n  addStaticAttributeNS(element: Simple.Element, namespace: string, name: string, value: string) {\n    if (this.shouldAddAttribute(name)) {\n      this.addAttribute(name, new StaticAttribute(element, name, value, namespace));\n    }\n  }\n\n  addDynamicAttribute(element: Simple.Element, name: string, reference: PathReference<string>, isTrusting: boolean) {\n    if (name === 'class') {\n      this.addClass(reference);\n    } else if (this.shouldAddAttribute(name)) {\n      let attributeManager = this.env.attributeFor(element, name, isTrusting);\n      let attribute = new DynamicAttribute(element, attributeManager, name, reference);\n\n      this.addAttribute(name, attribute);\n    }\n  }\n\n  addDynamicAttributeNS(element: Simple.Element, namespace: string, name: string, reference: PathReference<string>, isTrusting: boolean) {\n    if (this.shouldAddAttribute(name)) {\n      let attributeManager = this.env.attributeFor(element, name,isTrusting, namespace);\n      let nsAttribute = new DynamicAttribute(element, attributeManager, name, reference, namespace);\n\n      this.addAttribute(name, nsAttribute);\n    }\n  }\n\n  flush(element: Simple.Element, vm: VM) {\n    let { env } = this;\n    let { attributes, classList } = this;\n\n    for (let i = 0; attributes && i < attributes.length; i++) {\n      let opcode = attributes[i].flush(env);\n\n      if (opcode) {\n        vm.updateWith(opcode);\n      }\n    }\n\n    if (classList) {\n      let attributeManager = env.attributeFor(element, 'class', false);\n      let attribute = new DynamicAttribute(element, attributeManager, 'class', classList.toReference());\n      let opcode = attribute.flush(env);\n\n      if (opcode) {\n        vm.updateWith(opcode);\n      }\n    }\n  }\n\n  private shouldAddAttribute(name: string) {\n    return !this.attributeNames || this.attributeNames.indexOf(name) === -1;\n  }\n\n  private addClass(reference: PathReference<string>) {\n    let { classList } = this;\n\n    if (!classList) {\n      classList = this.classList = new ClassList();\n    }\n\n    classList.append(reference);\n  }\n\n  private addAttribute(name: string, attribute: Attribute) {\n    let { attributeNames, attributes } = this;\n\n    if (!attributeNames) {\n      attributeNames = this.attributeNames = [];\n      attributes = this.attributes = [];\n    }\n\n    attributeNames.push(name);\n    attributes.push(attribute);\n  }\n}\n\nexport class FlushElementOpcode extends Opcode {\n  public type = \"flush-element\";\n\n  evaluate(vm: VM) {\n    let stack = vm.stack();\n\n    stack.operations.flush(stack.constructing, vm);\n    stack.flushElement();\n  }\n}\n\nexport class CloseElementOpcode extends Opcode {\n  public type = \"close-element\";\n\n  evaluate(vm: VM) {\n    vm.stack().closeElement();\n  }\n}\n\nexport interface StaticAttrOptions {\n  namespace: string;\n  name: string;\n  value: string;\n}\n\nexport class StaticAttrOpcode extends Opcode {\n  public type = \"static-attr\";\n  public namespace: string;\n  public name: string;\n  public value: string;\n\n  constructor({ namespace, name, value }: StaticAttrOptions) {\n    super();\n    this.namespace = namespace;\n    this.name = name;\n    this.value = value;\n  }\n\n  evaluate(vm: VM) {\n    let { name, value, namespace } = this;\n    if (namespace) {\n      vm.stack().setStaticAttributeNS(namespace, name, value);\n    } else {\n      vm.stack().setStaticAttribute(name, value);\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, namespace, name, value } = this;\n\n    let details = dict<string>();\n\n    if (namespace) {\n      details[\"namespace\"] = JSON.stringify(namespace);\n    }\n\n    details[\"name\"] = JSON.stringify(name);\n    details[\"value\"] = JSON.stringify(value);\n\n    return { guid, type, details };\n  }\n}\n\nexport class ModifierOpcode extends Opcode {\n  public type = \"modifier\";\n\n  constructor(private name: string, private manager: ModifierManager<Opaque>, private args: CompiledArgs) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    let { manager } = this;\n    let stack = vm.stack();\n    let { constructing: element, updateOperations } = stack;\n    let args = this.args.evaluate(vm);\n    let dynamicScope = vm.dynamicScope();\n    let modifier = manager.create(element as FIX_REIFICATION<Element>, args, dynamicScope, updateOperations);\n\n    vm.env.scheduleInstallModifier(modifier, manager);\n    let destructor = manager.getDestructor(modifier);\n\n    if (destructor) {\n      vm.newDestroyable(destructor);\n    }\n\n    vm.updateWith(new UpdateModifierOpcode(\n      manager,\n      modifier,\n      args\n    ));\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, name, args } = this;\n\n    let details = dict<string>();\n\n    details[\"type\"] = JSON.stringify(type);\n    details[\"name\"] = JSON.stringify(name);\n    details[\"args\"] = JSON.stringify(args);\n\n    return { guid, type, details };\n  }\n}\n\nexport class UpdateModifierOpcode extends UpdatingOpcode {\n  public type = \"update-modifier\";\n  private lastUpdated: Revision;\n\n  constructor(\n    private manager: ModifierManager<Opaque>,\n    private modifier: Opaque,\n    private args: EvaluatedArgs\n  ) {\n    super();\n    this.tag = args.tag;\n    this.lastUpdated = args.tag.value();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { manager, modifier, tag, lastUpdated } = this;\n\n    if (!tag.validate(lastUpdated)) {\n      vm.env.scheduleUpdateModifier(modifier, manager);\n      this.lastUpdated = tag.value();\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.args)]\n    };\n  }\n}\n\nexport interface Attribute {\n  name: string;\n  flush(env: Environment): Option<UpdatingOpcode>;\n}\n\nexport class StaticAttribute implements Attribute {\n  constructor(\n    private element: Simple.Element,\n    public name: string,\n    private value: string,\n    private namespace?: string\n  ) {}\n\n  flush(env: Environment): Option<UpdatingOpcode> {\n    env.getAppendOperations().setAttribute(this.element, this.name, this.value, this.namespace);\n    return null;\n  }\n}\n\nexport class DynamicAttribute implements Attribute  {\n  private cache: ReferenceCache<Opaque>;\n\n  public tag: RevisionTag;\n\n  constructor(\n    private element: Simple.Element,\n    private changeList: IChangeList,\n    public name: string,\n    private reference: Reference<Opaque>,\n    private namespace?: string\n  ) {\n    this.element = element;\n    this.reference = reference;\n    this.changeList = changeList;\n    this.tag = reference.tag;\n    this.name = name;\n    this.cache = null;\n    this.namespace = namespace;\n  }\n\n  patch(env: Environment) {\n    let { element, cache } = this;\n\n    let value = cache.revalidate();\n\n    if (isModified(value)) {\n      this.changeList.updateAttribute(env, element as FIXME<Element, 'needs to be reified properly'>, this.name, value, this.namespace);\n    }\n  }\n\n  flush(env: Environment): Option<UpdatingOpcode> {\n    let { reference, element } = this;\n\n    if (isConstReference(reference)) {\n      let value = reference.value();\n      this.changeList.setAttribute(env, element, this.name, value, this.namespace);\n      return null;\n    } else {\n      let cache = this.cache = new ReferenceCache(reference);\n      let value = cache.peek();\n      this.changeList.setAttribute(env, element, this.name, value, this.namespace);\n      return new PatchElementOpcode(this);\n    }\n  }\n\n  toJSON(): Dict<string> {\n    let { element, namespace, name, cache } = this;\n\n    let formattedElement = formatElement(element);\n    let lastValue = cache.peek() as string;\n\n    if (namespace) {\n      return {\n        element: formattedElement,\n        type: 'attribute',\n        namespace,\n        name,\n        lastValue\n      };\n    }\n\n    return {\n      element: formattedElement,\n      type: 'attribute',\n      namespace,\n      name,\n      lastValue\n    };\n  }\n}\n\nfunction formatElement(element: Simple.Element): string {\n  return JSON.stringify(`<${element.tagName.toLowerCase()} />`);\n}\n\nexport interface DynamicAttrNSOptions {\n  name: string;\n  namespace: string;\n  isTrusting: boolean;\n}\n\nexport class DynamicAttrNSOpcode extends Opcode {\n  public type = \"dynamic-attr\";\n  public name: string;\n  public namespace: string;\n  public isTrusting: boolean;\n\n  constructor({ name, namespace, isTrusting }: DynamicAttrNSOptions) {\n    super();\n    this.name = name;\n    this.namespace = namespace;\n    this.isTrusting = isTrusting;\n  }\n\n  evaluate(vm: VM) {\n    let { name, namespace, isTrusting } = this;\n    let reference = vm.frame.getOperand();\n    vm.stack().setDynamicAttributeNS(namespace, name, reference, isTrusting);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, name, namespace } = this;\n\n    let details = dict<string>();\n\n    details[\"name\"] = JSON.stringify(name);\n    details[\"value\"] = \"$OPERAND\";\n\n    if (namespace) {\n      details[\"namespace\"] = JSON.stringify(namespace);\n    }\n\n    return { guid, type, details };\n  }\n}\n\nexport interface SimpleAttrOptions {\n  name: string;\n  isTrusting: boolean;\n}\n\nexport class DynamicAttrOpcode extends Opcode {\n  public type = \"dynamic-attr\";\n  public name: string;\n  public isTrusting: boolean;\n\n  constructor({ name, isTrusting }: SimpleAttrOptions) {\n    super();\n    this.name = name;\n    this.isTrusting = isTrusting;\n  }\n\n  evaluate(vm: VM) {\n    let { name, isTrusting } = this;\n    let reference = vm.frame.getOperand();\n    vm.stack().setDynamicAttribute(name, reference, isTrusting);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, name } = this;\n\n    let details = dict<string>();\n\n    details[\"name\"] = JSON.stringify(name);\n    details[\"value\"] = \"$OPERAND\";\n\n    return { guid, type, details };\n  }\n}\n\nexport class PatchElementOpcode extends UpdatingOpcode {\n  public type = \"patch-element\";\n\n  private operation: DynamicAttribute;\n\n  constructor(operation: DynamicAttribute) {\n    super();\n    this.tag = operation.tag;\n    this.operation = operation;\n  }\n\n  evaluate(vm: UpdatingVM) {\n    this.operation.patch(vm.env);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid, type, operation } = this;\n\n    return {\n      guid: _guid,\n      type,\n      details: operation.toJSON()\n    };\n  }\n}\n\nexport interface CommentOptions {\n  comment: string;\n}\n\nexport class CommentOpcode extends Opcode {\n  public type = \"comment\";\n  public comment: string;\n\n  constructor({ comment }: CommentOptions) {\n    super();\n    this.comment = comment;\n  }\n\n  evaluate(vm: VM) {\n    vm.stack().appendComment(this.comment);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.comment)]\n    };\n  }\n}\n","import { Opcode, UpdatingOpcode } from '../../opcodes';\nimport { dict } from 'glimmer-util';\nimport { CachedReference, ReferenceCache, combineTagged, isConst as isConstReference, isModified } from 'glimmer-reference';\nimport { NULL_REFERENCE } from '../../references';\nimport { ValueReference } from '../../compiled/expressions/value';\nexport class TextOpcode extends Opcode {\n    constructor({ text }) {\n        super();\n        this.type = \"text\";\n        this.text = text;\n    }\n    evaluate(vm) {\n        vm.stack().appendText(this.text);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.text)]\n        };\n    }\n}\nexport class OpenPrimitiveElementOpcode extends Opcode {\n    constructor(tag) {\n        super();\n        this.tag = tag;\n        this.type = \"open-primitive-element\";\n    }\n    evaluate(vm) {\n        vm.stack().openElement(this.tag);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.tag)]\n        };\n    }\n}\nexport class OpenComponentElementOpcode extends Opcode {\n    constructor(tag) {\n        super();\n        this.tag = tag;\n        this.type = \"open-component-element\";\n    }\n    evaluate(vm) {\n        vm.stack().openElement(this.tag, new ComponentElementOperations(vm.env));\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.tag)]\n        };\n    }\n}\nexport class OpenDynamicPrimitiveElementOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"open-dynamic-primitive-element\";\n    }\n    evaluate(vm) {\n        let tagName = vm.frame.getOperand().value();\n        vm.stack().openElement(tagName);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [\"$OPERAND\"]\n        };\n    }\n}\nclass ClassList {\n    constructor() {\n        this.list = null;\n        this.isConst = true;\n    }\n    append(reference) {\n        let { list, isConst } = this;\n        if (list === null)\n            list = this.list = [];\n        list.push(reference);\n        this.isConst = isConst && isConstReference(reference);\n    }\n    toReference() {\n        let { list, isConst } = this;\n        if (!list)\n            return NULL_REFERENCE;\n        if (isConst)\n            return new ValueReference(toClassName(list));\n        return new ClassListReference(list);\n    }\n}\nclass ClassListReference extends CachedReference {\n    constructor(list) {\n        super();\n        this.list = [];\n        this.tag = combineTagged(list);\n        this.list = list;\n    }\n    compute() {\n        return toClassName(this.list);\n    }\n}\nfunction toClassName(list) {\n    let ret = [];\n    for (let i = 0; i < list.length; i++) {\n        let value = list[i].value();\n        if (value !== false && value !== null && value !== undefined)\n            ret.push(value);\n    }\n    return (ret.length === 0) ? null : ret.join(' ');\n}\nexport class SimpleElementOperations {\n    constructor(env) {\n        this.env = env;\n        this.opcodes = null;\n        this.classList = null;\n    }\n    addStaticAttribute(element, name, value) {\n        if (name === 'class') {\n            this.addClass(new ValueReference(value));\n        }\n        else {\n            this.env.getAppendOperations().setAttribute(element, name, value);\n        }\n    }\n    addStaticAttributeNS(element, namespace, name, value) {\n        this.env.getAppendOperations().setAttribute(element, name, value, namespace);\n    }\n    addDynamicAttribute(element, name, reference, isTrusting) {\n        if (name === 'class') {\n            this.addClass(reference);\n        }\n        else {\n            let attributeManager = this.env.attributeFor(element, name, isTrusting);\n            let attribute = new DynamicAttribute(element, attributeManager, name, reference);\n            this.addAttribute(attribute);\n        }\n    }\n    addDynamicAttributeNS(element, namespace, name, reference, isTrusting) {\n        let attributeManager = this.env.attributeFor(element, name, isTrusting, namespace);\n        let nsAttribute = new DynamicAttribute(element, attributeManager, name, reference, namespace);\n        this.addAttribute(nsAttribute);\n    }\n    flush(element, vm) {\n        let { env } = vm;\n        let { opcodes, classList } = this;\n        for (let i = 0; opcodes && i < opcodes.length; i++) {\n            vm.updateWith(opcodes[i]);\n        }\n        if (classList) {\n            let attributeManager = env.attributeFor(element, 'class', false);\n            let attribute = new DynamicAttribute(element, attributeManager, 'class', classList.toReference());\n            let opcode = attribute.flush(env);\n            if (opcode) {\n                vm.updateWith(opcode);\n            }\n        }\n        this.opcodes = null;\n        this.classList = null;\n    }\n    addClass(reference) {\n        let { classList } = this;\n        if (!classList) {\n            classList = this.classList = new ClassList();\n        }\n        classList.append(reference);\n    }\n    addAttribute(attribute) {\n        let opcode = attribute.flush(this.env);\n        if (opcode) {\n            let { opcodes } = this;\n            if (!opcodes) {\n                opcodes = this.opcodes = [];\n            }\n            opcodes.push(opcode);\n        }\n    }\n}\nexport class ComponentElementOperations {\n    constructor(env) {\n        this.env = env;\n        this.attributeNames = null;\n        this.attributes = null;\n        this.classList = null;\n    }\n    addStaticAttribute(element, name, value) {\n        if (name === 'class') {\n            this.addClass(new ValueReference(value));\n        }\n        else if (this.shouldAddAttribute(name)) {\n            this.addAttribute(name, new StaticAttribute(element, name, value));\n        }\n    }\n    addStaticAttributeNS(element, namespace, name, value) {\n        if (this.shouldAddAttribute(name)) {\n            this.addAttribute(name, new StaticAttribute(element, name, value, namespace));\n        }\n    }\n    addDynamicAttribute(element, name, reference, isTrusting) {\n        if (name === 'class') {\n            this.addClass(reference);\n        }\n        else if (this.shouldAddAttribute(name)) {\n            let attributeManager = this.env.attributeFor(element, name, isTrusting);\n            let attribute = new DynamicAttribute(element, attributeManager, name, reference);\n            this.addAttribute(name, attribute);\n        }\n    }\n    addDynamicAttributeNS(element, namespace, name, reference, isTrusting) {\n        if (this.shouldAddAttribute(name)) {\n            let attributeManager = this.env.attributeFor(element, name, isTrusting, namespace);\n            let nsAttribute = new DynamicAttribute(element, attributeManager, name, reference, namespace);\n            this.addAttribute(name, nsAttribute);\n        }\n    }\n    flush(element, vm) {\n        let { env } = this;\n        let { attributes, classList } = this;\n        for (let i = 0; attributes && i < attributes.length; i++) {\n            let opcode = attributes[i].flush(env);\n            if (opcode) {\n                vm.updateWith(opcode);\n            }\n        }\n        if (classList) {\n            let attributeManager = env.attributeFor(element, 'class', false);\n            let attribute = new DynamicAttribute(element, attributeManager, 'class', classList.toReference());\n            let opcode = attribute.flush(env);\n            if (opcode) {\n                vm.updateWith(opcode);\n            }\n        }\n    }\n    shouldAddAttribute(name) {\n        return !this.attributeNames || this.attributeNames.indexOf(name) === -1;\n    }\n    addClass(reference) {\n        let { classList } = this;\n        if (!classList) {\n            classList = this.classList = new ClassList();\n        }\n        classList.append(reference);\n    }\n    addAttribute(name, attribute) {\n        let { attributeNames, attributes } = this;\n        if (!attributeNames) {\n            attributeNames = this.attributeNames = [];\n            attributes = this.attributes = [];\n        }\n        attributeNames.push(name);\n        attributes.push(attribute);\n    }\n}\nexport class FlushElementOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"flush-element\";\n    }\n    evaluate(vm) {\n        let stack = vm.stack();\n        stack.operations.flush(stack.constructing, vm);\n        stack.flushElement();\n    }\n}\nexport class CloseElementOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"close-element\";\n    }\n    evaluate(vm) {\n        vm.stack().closeElement();\n    }\n}\nexport class StaticAttrOpcode extends Opcode {\n    constructor({ namespace, name, value }) {\n        super();\n        this.type = \"static-attr\";\n        this.namespace = namespace;\n        this.name = name;\n        this.value = value;\n    }\n    evaluate(vm) {\n        let { name, value, namespace } = this;\n        if (namespace) {\n            vm.stack().setStaticAttributeNS(namespace, name, value);\n        }\n        else {\n            vm.stack().setStaticAttribute(name, value);\n        }\n    }\n    toJSON() {\n        let { _guid: guid, type, namespace, name, value } = this;\n        let details = dict();\n        if (namespace) {\n            details[\"namespace\"] = JSON.stringify(namespace);\n        }\n        details[\"name\"] = JSON.stringify(name);\n        details[\"value\"] = JSON.stringify(value);\n        return { guid, type, details };\n    }\n}\nexport class ModifierOpcode extends Opcode {\n    constructor(name, manager, args) {\n        super();\n        this.name = name;\n        this.manager = manager;\n        this.args = args;\n        this.type = \"modifier\";\n    }\n    evaluate(vm) {\n        let { manager } = this;\n        let stack = vm.stack();\n        let { constructing: element, updateOperations } = stack;\n        let args = this.args.evaluate(vm);\n        let dynamicScope = vm.dynamicScope();\n        let modifier = manager.create(element, args, dynamicScope, updateOperations);\n        vm.env.scheduleInstallModifier(modifier, manager);\n        let destructor = manager.getDestructor(modifier);\n        if (destructor) {\n            vm.newDestroyable(destructor);\n        }\n        vm.updateWith(new UpdateModifierOpcode(manager, modifier, args));\n    }\n    toJSON() {\n        let { _guid: guid, type, name, args } = this;\n        let details = dict();\n        details[\"type\"] = JSON.stringify(type);\n        details[\"name\"] = JSON.stringify(name);\n        details[\"args\"] = JSON.stringify(args);\n        return { guid, type, details };\n    }\n}\nexport class UpdateModifierOpcode extends UpdatingOpcode {\n    constructor(manager, modifier, args) {\n        super();\n        this.manager = manager;\n        this.modifier = modifier;\n        this.args = args;\n        this.type = \"update-modifier\";\n        this.tag = args.tag;\n        this.lastUpdated = args.tag.value();\n    }\n    evaluate(vm) {\n        let { manager, modifier, tag, lastUpdated } = this;\n        if (!tag.validate(lastUpdated)) {\n            vm.env.scheduleUpdateModifier(modifier, manager);\n            this.lastUpdated = tag.value();\n        }\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.args)]\n        };\n    }\n}\nexport class StaticAttribute {\n    constructor(element, name, value, namespace) {\n        this.element = element;\n        this.name = name;\n        this.value = value;\n        this.namespace = namespace;\n    }\n    flush(env) {\n        env.getAppendOperations().setAttribute(this.element, this.name, this.value, this.namespace);\n        return null;\n    }\n}\nexport class DynamicAttribute {\n    constructor(element, changeList, name, reference, namespace) {\n        this.element = element;\n        this.changeList = changeList;\n        this.name = name;\n        this.reference = reference;\n        this.namespace = namespace;\n        this.element = element;\n        this.reference = reference;\n        this.changeList = changeList;\n        this.tag = reference.tag;\n        this.name = name;\n        this.cache = null;\n        this.namespace = namespace;\n    }\n    patch(env) {\n        let { element, cache } = this;\n        let value = cache.revalidate();\n        if (isModified(value)) {\n            this.changeList.updateAttribute(env, element, this.name, value, this.namespace);\n        }\n    }\n    flush(env) {\n        let { reference, element } = this;\n        if (isConstReference(reference)) {\n            let value = reference.value();\n            this.changeList.setAttribute(env, element, this.name, value, this.namespace);\n            return null;\n        }\n        else {\n            let cache = this.cache = new ReferenceCache(reference);\n            let value = cache.peek();\n            this.changeList.setAttribute(env, element, this.name, value, this.namespace);\n            return new PatchElementOpcode(this);\n        }\n    }\n    toJSON() {\n        let { element, namespace, name, cache } = this;\n        let formattedElement = formatElement(element);\n        let lastValue = cache.peek();\n        if (namespace) {\n            return {\n                element: formattedElement,\n                type: 'attribute',\n                namespace,\n                name,\n                lastValue\n            };\n        }\n        return {\n            element: formattedElement,\n            type: 'attribute',\n            namespace,\n            name,\n            lastValue\n        };\n    }\n}\nfunction formatElement(element) {\n    return JSON.stringify(`<${element.tagName.toLowerCase()} />`);\n}\nexport class DynamicAttrNSOpcode extends Opcode {\n    constructor({ name, namespace, isTrusting }) {\n        super();\n        this.type = \"dynamic-attr\";\n        this.name = name;\n        this.namespace = namespace;\n        this.isTrusting = isTrusting;\n    }\n    evaluate(vm) {\n        let { name, namespace, isTrusting } = this;\n        let reference = vm.frame.getOperand();\n        vm.stack().setDynamicAttributeNS(namespace, name, reference, isTrusting);\n    }\n    toJSON() {\n        let { _guid: guid, type, name, namespace } = this;\n        let details = dict();\n        details[\"name\"] = JSON.stringify(name);\n        details[\"value\"] = \"$OPERAND\";\n        if (namespace) {\n            details[\"namespace\"] = JSON.stringify(namespace);\n        }\n        return { guid, type, details };\n    }\n}\nexport class DynamicAttrOpcode extends Opcode {\n    constructor({ name, isTrusting }) {\n        super();\n        this.type = \"dynamic-attr\";\n        this.name = name;\n        this.isTrusting = isTrusting;\n    }\n    evaluate(vm) {\n        let { name, isTrusting } = this;\n        let reference = vm.frame.getOperand();\n        vm.stack().setDynamicAttribute(name, reference, isTrusting);\n    }\n    toJSON() {\n        let { _guid: guid, type, name } = this;\n        let details = dict();\n        details[\"name\"] = JSON.stringify(name);\n        details[\"value\"] = \"$OPERAND\";\n        return { guid, type, details };\n    }\n}\nexport class PatchElementOpcode extends UpdatingOpcode {\n    constructor(operation) {\n        super();\n        this.type = \"patch-element\";\n        this.tag = operation.tag;\n        this.operation = operation;\n    }\n    evaluate(vm) {\n        this.operation.patch(vm.env);\n    }\n    toJSON() {\n        let { _guid, type, operation } = this;\n        return {\n            guid: _guid,\n            type,\n            details: operation.toJSON()\n        };\n    }\n}\nexport class CommentOpcode extends Opcode {\n    constructor({ comment }) {\n        super();\n        this.type = \"comment\";\n        this.comment = comment;\n    }\n    evaluate(vm) {\n        vm.stack().appendComment(this.comment);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.comment)]\n        };\n    }\n}\n"]} enifed('glimmer-runtime/lib/compiled/opcodes/lists', ['exports', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-util', 'glimmer-reference'], function (exports, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerUtil, _glimmerReference) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var IterablePresenceReference = (function () { function IterablePresenceReference(artifacts) { - _classCallCheck(this, IterablePresenceReference); - this.tag = artifacts.tag; this.artifacts = artifacts; } IterablePresenceReference.prototype.value = function value() { @@ -17529,20 +18185,14 @@ return IterablePresenceReference; })(); var PutIteratorOpcode = (function (_Opcode) { - _inherits(PutIteratorOpcode, _Opcode); + babelHelpers.inherits(PutIteratorOpcode, _Opcode); function PutIteratorOpcode() { - _classCallCheck(this, PutIteratorOpcode); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _Opcode.call.apply(_Opcode, [this].concat(args)); + _Opcode.apply(this, arguments); this.type = "put-iterator"; } PutIteratorOpcode.prototype.evaluate = function evaluate(vm) { var listRef = vm.frame.getOperand(); @@ -17557,15 +18207,13 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PutIteratorOpcode = PutIteratorOpcode; var EnterListOpcode = (function (_Opcode2) { - _inherits(EnterListOpcode, _Opcode2); + babelHelpers.inherits(EnterListOpcode, _Opcode2); function EnterListOpcode(start, end) { - _classCallCheck(this, EnterListOpcode); - _Opcode2.call(this); this.type = "enter-list"; this.slice = new _glimmerUtil.ListSlice(start, end); } @@ -17591,20 +18239,14 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.EnterListOpcode = EnterListOpcode; var ExitListOpcode = (function (_Opcode3) { - _inherits(ExitListOpcode, _Opcode3); + babelHelpers.inherits(ExitListOpcode, _Opcode3); function ExitListOpcode() { - _classCallCheck(this, ExitListOpcode); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _Opcode3.call.apply(_Opcode3, [this].concat(args)); + _Opcode3.apply(this, arguments); this.type = "exit-list"; } ExitListOpcode.prototype.evaluate = function evaluate(vm) { vm.exitList(); @@ -17614,15 +18256,13 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.ExitListOpcode = ExitListOpcode; var EnterWithKeyOpcode = (function (_Opcode4) { - _inherits(EnterWithKeyOpcode, _Opcode4); + babelHelpers.inherits(EnterWithKeyOpcode, _Opcode4); function EnterWithKeyOpcode(start, end) { - _classCallCheck(this, EnterWithKeyOpcode); - _Opcode4.call(this); this.type = "enter-with-key"; this.slice = new _glimmerUtil.ListSlice(start, end); } @@ -17651,15 +18291,13 @@ var TRUE_REF = new _glimmerReference.ConstReference(true); var FALSE_REF = new _glimmerReference.ConstReference(false); var NextIterOpcode = (function (_Opcode5) { - _inherits(NextIterOpcode, _Opcode5); + babelHelpers.inherits(NextIterOpcode, _Opcode5); function NextIterOpcode(end) { - _classCallCheck(this, NextIterOpcode); - _Opcode5.call(this); this.type = "next-iter"; this.end = end; } @@ -17679,31 +18317,19 @@ return NextIterOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.NextIterOpcode = NextIterOpcode; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/lists.ts"],"names":[],"mappings":";;;;;;;;;QAOA,yBAAA;AAIE,iBAJF,yBAAA,CAIc,SAA6B,EAAA;kCAJ3C,yBAAA;;AAKI,gBAAI,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC;AACzB,gBAAI,CAAC,SAAS,GAAG,SAAS,CAAC;SAC5B;;AAPH,iCAAA,WASE,KAAK,GAAA,iBAAA;AACH,mBAAO,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;SAClC;;eAXH,yBAAA;;;QAcA,iBAAA;kBAAA,iBAAA;;AAAA,iBAAA,iBAAA,GAAA;kCAAA,iBAAA;;8CAAA,IAAA;AAAA,oBAAA;;;AAAuC,sDAAA,IAAA,EAAA,CAAM;AACpC,gBAAA,CAAA,IAAI,GAAG,cAAc,CAAC;SAW9B;;AAZD,yBAAA,WAGE,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,gBAAI,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;AACpC,gBAAI,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;AAC9B,gBAAI,QAAQ,GAAG,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACjD,gBAAI,QAAQ,GAAG,sBAvB8B,iBAAiB,CAuBzB,QAAQ,CAAC,CAAC;AAE/C,cAAE,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;AAC/B,cAAE,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,yBAAyB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;SAC1E;;eAXH,iBAAA;iCArBS,MAAM;;;;QAmCf,eAAA;kBAAA,eAAA;;AAKE,iBALF,eAAA,CAKc,KAAkB,EAAE,GAAgB,EAAA;kCALlD,eAAA;;AAMI,+BAAO,CAAC;AALH,gBAAA,CAAA,IAAI,GAAG,YAAY,CAAC;AAMzB,gBAAI,CAAC,KAAK,GAAG,iBAtCD,SAAS,CAsCM,KAAK,EAAE,GAAG,CAAC,CAAC;SACxC;;AARH,uBAAA,WAUE,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,cAAE,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC1B;;AAZH,uBAAA,WAcE,MAAM,GAAA,kBAAA;gBACE,KAAK,GAAkB,IAAI,CAA3B,KAAK;gBAAE,IAAI,GAAY,IAAI,CAApB,IAAI;gBAAE,KAAK,GAAK,IAAI,CAAd,KAAK;;AAExB,gBAAI,KAAK,GAAG,KAAK,CAAC,IAAI,EAAiB,CAAC;AACxC,gBAAI,GAAG,GAAG,KAAK,CAAC,IAAI,EAAiB,CAAC;AAEtC,mBAAO;AACL,oBAAI,EAAE,KAAK;AACX,oBAAI,EAAJ,IAAI;AACJ,oBAAI,EAAE,CACJ,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,EAC/B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAC9B;aACF,CAAC;SACH;;eA5BH,eAAA;iCAnCS,MAAM;;;;QAkEf,cAAA;kBAAA,cAAA;;AAAA,iBAAA,cAAA,GAAA;kCAAA,cAAA;;+CAAA,IAAA;AAAA,oBAAA;;;AAAoC,wDAAA,IAAA,EAAA,CAAM;AACjC,gBAAA,CAAA,IAAI,GAAG,WAAW,CAAC;SAK3B;;AAND,sBAAA,WAGE,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,cAAE,CAAC,QAAQ,EAAE,CAAC;SACf;;eALH,cAAA;iCAlES,MAAM;;;;QA0Ef,kBAAA;kBAAA,kBAAA;;AAKE,iBALF,kBAAA,CAKc,KAAkB,EAAE,GAAgB,EAAA;kCALlD,kBAAA;;AAMI,+BAAO,CAAC;AALH,gBAAA,CAAA,IAAI,GAAG,gBAAgB,CAAC;AAM7B,gBAAI,CAAC,KAAK,GAAG,iBA7ED,SAAS,CA6EM,KAAK,EAAE,GAAG,CAAC,CAAC;SACxC;;AARH,0BAAA,WAUE,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,cAAE,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;SAChD;;AAZH,0BAAA,WAcE,MAAM,GAAA,kBAAA;gBACE,KAAK,GAAkB,IAAI,CAA3B,KAAK;gBAAE,KAAK,GAAW,IAAI,CAApB,KAAK;gBAAE,IAAI,GAAK,IAAI,CAAb,IAAI;;AAExB,gBAAI,KAAK,GAAG,KAAK,CAAC,IAAI,EAAiB,CAAC;AACxC,gBAAI,GAAG,GAAG,KAAK,CAAC,IAAI,EAAiB,CAAC;AAEtC,mBAAO;AACL,oBAAI,EAAE,KAAK;AACX,oBAAI,EAAJ,IAAI;AACJ,oBAAI,EAAE,CACJ,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,EAC/B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAC9B;aACF,CAAC;SACH;;eA5BH,kBAAA;iCA1ES,MAAM;;;;AAyGf,QAAM,QAAQ,GAAG,sBApGgB,cAAc,CAoGX,IAAI,CAAC,CAAC;AAC1C,QAAM,SAAS,GAAG,sBArGe,cAAc,CAqGV,KAAK,CAAC,CAAC;;QAE5C,cAAA;kBAAA,cAAA;;AAKE,iBALF,cAAA,CAKc,GAAgB,EAAA;kCAL9B,cAAA;;AAMI,+BAAO,CAAC;AALH,gBAAA,CAAA,IAAI,GAAG,WAAW,CAAC;AAMxB,gBAAI,CAAC,GAAG,GAAG,GAAG,CAAC;SAChB;;AARH,sBAAA,WAUE,QAAQ,GAAA,kBAAC,EAAM,EAAA;AACb,gBAAI,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;AAEzC,gBAAI,IAAI,EAAE;AACR,kBAAE,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;AAChC,kBAAE,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,GAA0C,CAAC,CAAC;AACjE,kBAAE,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAChC,kBAAE,CAAC,KAAK,CAAC,OAAO,CAAC,0CA1Hd,aAAa,CA0He,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACrE,MAAM;AACL,kBAAE,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;AACjC,kBAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACnB;SACF;;eAtBH,cAAA;iCA5GS,MAAM","file":"lists.js","sourcesContent":["import { Opcode, OpcodeJSON } from '../../opcodes';\nimport { VM } from '../../vm';\nimport { LabelOpcode } from '../../compiled/opcodes/vm';\nimport { EvaluatedArgs } from '../expressions/args';\nimport { FIXME, ListSlice, Slice } from 'glimmer-util';\nimport { RevisionTag, Reference, ConstReference, ReferenceIterator, IterationArtifacts } from 'glimmer-reference';\n\nclass IterablePresenceReference implements Reference<boolean> {\n  public tag: RevisionTag;\n  private artifacts: IterationArtifacts;\n\n  constructor(artifacts: IterationArtifacts) {\n    this.tag = artifacts.tag;\n    this.artifacts = artifacts;\n  }\n\n  value(): boolean {\n    return !this.artifacts.isEmpty();\n  }\n}\n\nexport class PutIteratorOpcode extends Opcode {\n  public type = \"put-iterator\";\n\n  evaluate(vm: VM) {\n    let listRef = vm.frame.getOperand();\n    let args = vm.frame.getArgs();\n    let iterable = vm.env.iterableFor(listRef, args);\n    let iterator = new ReferenceIterator(iterable);\n\n    vm.frame.setIterator(iterator);\n    vm.frame.setCondition(new IterablePresenceReference(iterator.artifacts));\n  }\n}\n\nexport class EnterListOpcode extends Opcode {\n  public type = \"enter-list\";\n\n  public slice: Slice<Opcode>;\n\n  constructor(start: LabelOpcode, end: LabelOpcode) {\n    super();\n    this.slice = new ListSlice(start, end);\n  }\n\n  evaluate(vm: VM) {\n    vm.enterList(this.slice);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { slice, type, _guid } = this;\n\n    let begin = slice.head() as LabelOpcode;\n    let end = slice.tail() as LabelOpcode;\n\n    return {\n      guid: _guid,\n      type,\n      args: [\n        JSON.stringify(begin.inspect()),\n        JSON.stringify(end.inspect())\n      ]\n    };\n  }\n}\n\nexport class ExitListOpcode extends Opcode {\n  public type = \"exit-list\";\n\n  evaluate(vm: VM) {\n    vm.exitList();\n  }\n}\n\nexport class EnterWithKeyOpcode extends Opcode {\n  public type = \"enter-with-key\";\n\n  private slice: Slice<Opcode>;\n\n  constructor(start: LabelOpcode, end: LabelOpcode) {\n    super();\n    this.slice = new ListSlice(start, end);\n  }\n\n  evaluate(vm: VM) {\n    vm.enterWithKey(vm.frame.getKey(), this.slice);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { slice, _guid, type } = this;\n\n    let begin = slice.head() as LabelOpcode;\n    let end = slice.tail() as LabelOpcode;\n\n    return {\n      guid: _guid,\n      type,\n      args: [\n        JSON.stringify(begin.inspect()),\n        JSON.stringify(end.inspect())\n      ]\n    };\n  }\n}\n\nconst TRUE_REF = new ConstReference(true);\nconst FALSE_REF = new ConstReference(false);\n\nexport class NextIterOpcode extends Opcode {\n  public type = \"next-iter\";\n\n  private end: LabelOpcode;\n\n  constructor(end: LabelOpcode) {\n    super();\n    this.end = end;\n  }\n\n  evaluate(vm: VM) {\n    let item = vm.frame.getIterator().next();\n\n    if (item) {\n      vm.frame.setCondition(TRUE_REF);\n      vm.frame.setKey(item.key as FIXME<'user str to InternedString'>);\n      vm.frame.setOperand(item.value);\n      vm.frame.setArgs(EvaluatedArgs.positional([item.value, item.memo]));\n    } else {\n      vm.frame.setCondition(FALSE_REF);\n      vm.goto(this.end);\n    }\n  }\n}\n"]} -enifed('glimmer-runtime/lib/compiled/opcodes/vm', ['exports', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-runtime/lib/vm', 'glimmer-runtime/lib/utils', 'glimmer-runtime/lib/references', 'glimmer-reference', 'glimmer-runtime/lib/compiled/expressions/value', 'glimmer-util', 'glimmer-runtime/lib/scanner'], function (exports, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerRuntimeLibVm, _glimmerRuntimeLibUtils, _glimmerRuntimeLibReferences, _glimmerReference, _glimmerRuntimeLibCompiledExpressionsValue, _glimmerUtil, _glimmerRuntimeLibScanner) { +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/lists.ts"],"names":[],"mappings":"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","file":"lists.js","sourcesContent":["import { Opcode, OpcodeJSON } from '../../opcodes';\nimport { VM } from '../../vm';\nimport { LabelOpcode } from '../../compiled/opcodes/vm';\nimport { EvaluatedArgs } from '../expressions/args';\nimport { ListSlice, Slice } from 'glimmer-util';\nimport { RevisionTag, Reference, ConstReference, ReferenceIterator, IterationArtifacts } from 'glimmer-reference';\n\nclass IterablePresenceReference implements Reference<boolean> {\n  public tag: RevisionTag;\n  private artifacts: IterationArtifacts;\n\n  constructor(artifacts: IterationArtifacts) {\n    this.tag = artifacts.tag;\n    this.artifacts = artifacts;\n  }\n\n  value(): boolean {\n    return !this.artifacts.isEmpty();\n  }\n}\n\nexport class PutIteratorOpcode extends Opcode {\n  public type = \"put-iterator\";\n\n  evaluate(vm: VM) {\n    let listRef = vm.frame.getOperand();\n    let args = vm.frame.getArgs();\n    let iterable = vm.env.iterableFor(listRef, args);\n    let iterator = new ReferenceIterator(iterable);\n\n    vm.frame.setIterator(iterator);\n    vm.frame.setCondition(new IterablePresenceReference(iterator.artifacts));\n  }\n}\n\nexport class EnterListOpcode extends Opcode {\n  public type = \"enter-list\";\n\n  public slice: Slice<Opcode>;\n\n  constructor(start: LabelOpcode, end: LabelOpcode) {\n    super();\n    this.slice = new ListSlice(start, end);\n  }\n\n  evaluate(vm: VM) {\n    vm.enterList(this.slice);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { slice, type, _guid } = this;\n\n    let begin = slice.head() as LabelOpcode;\n    let end = slice.tail() as LabelOpcode;\n\n    return {\n      guid: _guid,\n      type,\n      args: [\n        JSON.stringify(begin.inspect()),\n        JSON.stringify(end.inspect())\n      ]\n    };\n  }\n}\n\nexport class ExitListOpcode extends Opcode {\n  public type = \"exit-list\";\n\n  evaluate(vm: VM) {\n    vm.exitList();\n  }\n}\n\nexport class EnterWithKeyOpcode extends Opcode {\n  public type = \"enter-with-key\";\n\n  private slice: Slice<Opcode>;\n\n  constructor(start: LabelOpcode, end: LabelOpcode) {\n    super();\n    this.slice = new ListSlice(start, end);\n  }\n\n  evaluate(vm: VM) {\n    vm.enterWithKey(vm.frame.getKey(), this.slice);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { slice, _guid, type } = this;\n\n    let begin = slice.head() as LabelOpcode;\n    let end = slice.tail() as LabelOpcode;\n\n    return {\n      guid: _guid,\n      type,\n      args: [\n        JSON.stringify(begin.inspect()),\n        JSON.stringify(end.inspect())\n      ]\n    };\n  }\n}\n\nconst TRUE_REF = new ConstReference(true);\nconst FALSE_REF = new ConstReference(false);\n\nexport class NextIterOpcode extends Opcode {\n  public type = \"next-iter\";\n\n  private end: LabelOpcode;\n\n  constructor(end: LabelOpcode) {\n    super();\n    this.end = end;\n  }\n\n  evaluate(vm: VM) {\n    let item = vm.frame.getIterator().next();\n\n    if (item) {\n      vm.frame.setCondition(TRUE_REF);\n      vm.frame.setKey(item.key);\n      vm.frame.setOperand(item.value);\n      vm.frame.setArgs(EvaluatedArgs.positional([item.value, item.memo]));\n    } else {\n      vm.frame.setCondition(FALSE_REF);\n      vm.goto(this.end);\n    }\n  }\n}\n","import { Opcode } from '../../opcodes';\nimport { EvaluatedArgs } from '../expressions/args';\nimport { ListSlice } from 'glimmer-util';\nimport { ConstReference, ReferenceIterator } from 'glimmer-reference';\nclass IterablePresenceReference {\n    constructor(artifacts) {\n        this.tag = artifacts.tag;\n        this.artifacts = artifacts;\n    }\n    value() {\n        return !this.artifacts.isEmpty();\n    }\n}\nexport class PutIteratorOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"put-iterator\";\n    }\n    evaluate(vm) {\n        let listRef = vm.frame.getOperand();\n        let args = vm.frame.getArgs();\n        let iterable = vm.env.iterableFor(listRef, args);\n        let iterator = new ReferenceIterator(iterable);\n        vm.frame.setIterator(iterator);\n        vm.frame.setCondition(new IterablePresenceReference(iterator.artifacts));\n    }\n}\nexport class EnterListOpcode extends Opcode {\n    constructor(start, end) {\n        super();\n        this.type = \"enter-list\";\n        this.slice = new ListSlice(start, end);\n    }\n    evaluate(vm) {\n        vm.enterList(this.slice);\n    }\n    toJSON() {\n        let { slice, type, _guid } = this;\n        let begin = slice.head();\n        let end = slice.tail();\n        return {\n            guid: _guid,\n            type,\n            args: [\n                JSON.stringify(begin.inspect()),\n                JSON.stringify(end.inspect())\n            ]\n        };\n    }\n}\nexport class ExitListOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"exit-list\";\n    }\n    evaluate(vm) {\n        vm.exitList();\n    }\n}\nexport class EnterWithKeyOpcode extends Opcode {\n    constructor(start, end) {\n        super();\n        this.type = \"enter-with-key\";\n        this.slice = new ListSlice(start, end);\n    }\n    evaluate(vm) {\n        vm.enterWithKey(vm.frame.getKey(), this.slice);\n    }\n    toJSON() {\n        let { slice, _guid, type } = this;\n        let begin = slice.head();\n        let end = slice.tail();\n        return {\n            guid: _guid,\n            type,\n            args: [\n                JSON.stringify(begin.inspect()),\n                JSON.stringify(end.inspect())\n            ]\n        };\n    }\n}\nconst TRUE_REF = new ConstReference(true);\nconst FALSE_REF = new ConstReference(false);\nexport class NextIterOpcode extends Opcode {\n    constructor(end) {\n        super();\n        this.type = \"next-iter\";\n        this.end = end;\n    }\n    evaluate(vm) {\n        let item = vm.frame.getIterator().next();\n        if (item) {\n            vm.frame.setCondition(TRUE_REF);\n            vm.frame.setKey(item.key);\n            vm.frame.setOperand(item.value);\n            vm.frame.setArgs(EvaluatedArgs.positional([item.value, item.memo]));\n        }\n        else {\n            vm.frame.setCondition(FALSE_REF);\n            vm.goto(this.end);\n        }\n    }\n}\n"]} +enifed('glimmer-runtime/lib/compiled/opcodes/vm', ['exports', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-runtime/lib/references', 'glimmer-reference', 'glimmer-runtime/lib/compiled/expressions/value', 'glimmer-util'], function (exports, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerRuntimeLibReferences, _glimmerReference, _glimmerRuntimeLibCompiledExpressionsValue, _glimmerUtil) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var PushChildScopeOpcode = (function (_Opcode) { - _inherits(PushChildScopeOpcode, _Opcode); + babelHelpers.inherits(PushChildScopeOpcode, _Opcode); function PushChildScopeOpcode() { - _classCallCheck(this, PushChildScopeOpcode); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _Opcode.call.apply(_Opcode, [this].concat(args)); + _Opcode.apply(this, arguments); this.type = "push-child-scope"; } PushChildScopeOpcode.prototype.evaluate = function evaluate(vm) { vm.pushChildScope(); @@ -17713,20 +18339,14 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PushChildScopeOpcode = PushChildScopeOpcode; var PopScopeOpcode = (function (_Opcode2) { - _inherits(PopScopeOpcode, _Opcode2); + babelHelpers.inherits(PopScopeOpcode, _Opcode2); function PopScopeOpcode() { - _classCallCheck(this, PopScopeOpcode); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _Opcode2.call.apply(_Opcode2, [this].concat(args)); + _Opcode2.apply(this, arguments); this.type = "pop-scope"; } PopScopeOpcode.prototype.evaluate = function evaluate(vm) { vm.popScope(); @@ -17736,20 +18356,14 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PopScopeOpcode = PopScopeOpcode; var PushDynamicScopeOpcode = (function (_Opcode3) { - _inherits(PushDynamicScopeOpcode, _Opcode3); + babelHelpers.inherits(PushDynamicScopeOpcode, _Opcode3); function PushDynamicScopeOpcode() { - _classCallCheck(this, PushDynamicScopeOpcode); - - for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } - - _Opcode3.call.apply(_Opcode3, [this].concat(args)); + _Opcode3.apply(this, arguments); this.type = "push-dynamic-scope"; } PushDynamicScopeOpcode.prototype.evaluate = function evaluate(vm) { vm.pushDynamicScope(); @@ -17759,20 +18373,14 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PushDynamicScopeOpcode = PushDynamicScopeOpcode; var PopDynamicScopeOpcode = (function (_Opcode4) { - _inherits(PopDynamicScopeOpcode, _Opcode4); + babelHelpers.inherits(PopDynamicScopeOpcode, _Opcode4); function PopDynamicScopeOpcode() { - _classCallCheck(this, PopDynamicScopeOpcode); - - for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { - args[_key4] = arguments[_key4]; - } - - _Opcode4.call.apply(_Opcode4, [this].concat(args)); + _Opcode4.apply(this, arguments); this.type = "pop-dynamic-scope"; } PopDynamicScopeOpcode.prototype.evaluate = function evaluate(vm) { vm.popDynamicScope(); @@ -17782,20 +18390,14 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PopDynamicScopeOpcode = PopDynamicScopeOpcode; var PutNullOpcode = (function (_Opcode5) { - _inherits(PutNullOpcode, _Opcode5); + babelHelpers.inherits(PutNullOpcode, _Opcode5); function PutNullOpcode() { - _classCallCheck(this, PutNullOpcode); - - for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { - args[_key5] = arguments[_key5]; - } - - _Opcode5.call.apply(_Opcode5, [this].concat(args)); + _Opcode5.apply(this, arguments); this.type = "put-null"; } PutNullOpcode.prototype.evaluate = function evaluate(vm) { vm.frame.setOperand(_glimmerRuntimeLibReferences.NULL_REFERENCE); @@ -17805,17 +18407,15 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PutNullOpcode = PutNullOpcode; var PutValueOpcode = (function (_Opcode6) { - _inherits(PutValueOpcode, _Opcode6); + babelHelpers.inherits(PutValueOpcode, _Opcode6); function PutValueOpcode(_ref) { var expression = _ref.expression; - _classCallCheck(this, PutValueOpcode); - _Opcode6.call(this); this.type = "put-value"; this.expression = expression; } @@ -17835,17 +18435,15 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PutValueOpcode = PutValueOpcode; var PutArgsOpcode = (function (_Opcode7) { - _inherits(PutArgsOpcode, _Opcode7); + babelHelpers.inherits(PutArgsOpcode, _Opcode7); function PutArgsOpcode(_ref2) { var args = _ref2.args; - _classCallCheck(this, PutArgsOpcode); - _Opcode7.call(this); this.type = "put-args"; this.args = args; } @@ -17868,28 +18466,29 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.PutArgsOpcode = PutArgsOpcode; var BindPositionalArgsOpcode = (function (_Opcode8) { - _inherits(BindPositionalArgsOpcode, _Opcode8); + babelHelpers.inherits(BindPositionalArgsOpcode, _Opcode8); - function BindPositionalArgsOpcode(_ref3) { - var block = _ref3.block; - - _classCallCheck(this, BindPositionalArgsOpcode); - + function BindPositionalArgsOpcode(names, symbols) { _Opcode8.call(this); + this.names = names; + this.symbols = symbols; this.type = "bind-positional-args"; - this.names = block.locals; - var positional = this.positional = []; - block.locals.forEach(function (name) { - positional.push(block.symbolTable.getLocal(name)); - }); } + BindPositionalArgsOpcode.create = function create(block) { + var names = block.locals; + var symbols = names.map(function (name) { + return block.symbolTable.getLocal(name); + }); + return new this(names, symbols); + }; + BindPositionalArgsOpcode.prototype.evaluate = function evaluate(vm) { - vm.bindPositionalArgs(this.positional); + vm.bindPositionalArgs(this.symbols); }; BindPositionalArgsOpcode.prototype.toJSON = function toJSON() { return { guid: this._guid, @@ -17904,41 +18503,37 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.BindPositionalArgsOpcode = BindPositionalArgsOpcode; var BindNamedArgsOpcode = (function (_Opcode9) { - _inherits(BindNamedArgsOpcode, _Opcode9); + babelHelpers.inherits(BindNamedArgsOpcode, _Opcode9); - function BindNamedArgsOpcode(_ref4) { - var named = _ref4.named; - - _classCallCheck(this, BindNamedArgsOpcode); - + function BindNamedArgsOpcode(names, symbols) { _Opcode9.call(this); + this.names = names; + this.symbols = symbols; this.type = "bind-named-args"; - this.named = named; } BindNamedArgsOpcode.create = function create(layout) { - var named = layout['named'].reduce(function (obj, name) { - var _assign; - - return _glimmerUtil.assign(obj, (_assign = {}, _assign[name] = layout.symbolTable.getNamed(name), _assign)); - }, _glimmerUtil.dict()); - _glimmerRuntimeLibUtils.turbocharge(named); - return new BindNamedArgsOpcode({ named: named }); + var names = layout.named; + var symbols = names.map(function (name) { + return layout.symbolTable.getNamed(name); + }); + return new BindNamedArgsOpcode(names, symbols); }; BindNamedArgsOpcode.prototype.evaluate = function evaluate(vm) { - vm.bindNamedArgs(this.named); + vm.bindNamedArgs(this.names, this.symbols); }; BindNamedArgsOpcode.prototype.toJSON = function toJSON() { - var _this = this; + var names = this.names; + var symbols = this.symbols; - var args = Object.keys(this.named).map(function (name) { - return '$' + _this.named[name] + ': $ARGS[' + name + ']'; + var args = names.map(function (name, i) { + return '$' + symbols[i] + ': $ARGS[' + name + ']'; }); return { guid: this._guid, type: this.type, args: args @@ -17948,71 +18543,61 @@ return BindNamedArgsOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.BindNamedArgsOpcode = BindNamedArgsOpcode; - var BindBlocksOpcode = (function (_Opcode10) { - _inherits(BindBlocksOpcode, _Opcode10); + var BindBlocksOpcode = (function (_BindNamedArgsOpcode) { + babelHelpers.inherits(BindBlocksOpcode, _BindNamedArgsOpcode); - function BindBlocksOpcode(_ref5) { - var blocks = _ref5.blocks; - - _classCallCheck(this, BindBlocksOpcode); - - _Opcode10.call(this); + function BindBlocksOpcode() { + _BindNamedArgsOpcode.apply(this, arguments); this.type = "bind-blocks"; - this.blocks = blocks; } - BindBlocksOpcode.create = function create(template) { - var blocks = _glimmerUtil.dict(); - template['yields'].forEach(function (name) { - blocks[name] = template.symbolTable.getYield(name); + BindBlocksOpcode.create = function create(layout) { + var names = layout.yields; + var symbols = names.map(function (name) { + return layout.symbolTable.getYield(name); }); - return new BindBlocksOpcode({ blocks: blocks }); + return new this(names, symbols); }; BindBlocksOpcode.prototype.evaluate = function evaluate(vm) { - vm.bindBlocks(this.blocks); + vm.bindBlocks(this.names, this.symbols); }; return BindBlocksOpcode; - })(_glimmerRuntimeLibOpcodes.Opcode); + })(BindNamedArgsOpcode); exports.BindBlocksOpcode = BindBlocksOpcode; - exports.BindDynamicScopeCallback = _glimmerRuntimeLibVm.BindDynamicScopeCallback; - var BindDynamicScopeOpcode = (function (_Opcode11) { - _inherits(BindDynamicScopeOpcode, _Opcode11); + var BindDynamicScopeOpcode = (function (_Opcode10) { + babelHelpers.inherits(BindDynamicScopeOpcode, _Opcode10); - function BindDynamicScopeOpcode(callback) { - _classCallCheck(this, BindDynamicScopeOpcode); - - _Opcode11.call(this); + function BindDynamicScopeOpcode(names) { + _Opcode10.call(this); + this.names = names; this.type = "bind-dynamic-scope"; - this.callback = callback; } BindDynamicScopeOpcode.prototype.evaluate = function evaluate(vm) { - vm.bindDynamicScope(this.callback); + vm.bindDynamicScope(this.names); }; return BindDynamicScopeOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.BindDynamicScopeOpcode = BindDynamicScopeOpcode; - var EnterOpcode = (function (_Opcode12) { - _inherits(EnterOpcode, _Opcode12); + var EnterOpcode = (function (_Opcode11) { + babelHelpers.inherits(EnterOpcode, _Opcode11); - function EnterOpcode(_ref6) { - var begin = _ref6.begin; - var end = _ref6.end; + function EnterOpcode(_ref3) { + var begin = _ref3.begin; + var end = _ref3.end; - _classCallCheck(this, EnterOpcode); - - _Opcode12.call(this); + _Opcode11.call(this); this.type = "enter"; this.slice = new _glimmerUtil.ListSlice(begin, end); } EnterOpcode.prototype.evaluate = function evaluate(vm) { @@ -18036,21 +18621,15 @@ return EnterOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.EnterOpcode = EnterOpcode; - var ExitOpcode = (function (_Opcode13) { - _inherits(ExitOpcode, _Opcode13); + var ExitOpcode = (function (_Opcode12) { + babelHelpers.inherits(ExitOpcode, _Opcode12); function ExitOpcode() { - _classCallCheck(this, ExitOpcode); - - for (var _len6 = arguments.length, args = Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { - args[_key6] = arguments[_key6]; - } - - _Opcode13.call.apply(_Opcode13, [this].concat(args)); + _Opcode12.apply(this, arguments); this.type = "exit"; } ExitOpcode.prototype.evaluate = function evaluate(vm) { vm.exit(); @@ -18059,17 +18638,15 @@ return ExitOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.ExitOpcode = ExitOpcode; - var LabelOpcode = (function (_Opcode14) { - _inherits(LabelOpcode, _Opcode14); + var LabelOpcode = (function (_Opcode13) { + babelHelpers.inherits(LabelOpcode, _Opcode13); function LabelOpcode(label) { - _classCallCheck(this, LabelOpcode); - - _Opcode14.call(this); + _Opcode13.call(this); this.tag = _glimmerReference.CONSTANT_TAG; this.type = "label"; this.label = null; this.prev = null; this.next = null; @@ -18093,20 +18670,18 @@ return LabelOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.LabelOpcode = LabelOpcode; - var EvaluateOpcode = (function (_Opcode15) { - _inherits(EvaluateOpcode, _Opcode15); + var EvaluateOpcode = (function (_Opcode14) { + babelHelpers.inherits(EvaluateOpcode, _Opcode14); - function EvaluateOpcode(_ref7) { - var debug = _ref7.debug; - var block = _ref7.block; + function EvaluateOpcode(_ref4) { + var debug = _ref4.debug; + var block = _ref4.block; - _classCallCheck(this, EvaluateOpcode); - - _Opcode15.call(this); + _Opcode14.call(this); this.type = "evaluate"; this.debug = debug; this.block = block; } @@ -18140,20 +18715,18 @@ return EvaluateOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.EvaluateOpcode = EvaluateOpcode; - var EvaluatePartialOpcode = (function (_Opcode16) { - _inherits(EvaluatePartialOpcode, _Opcode16); + var EvaluatePartialOpcode = (function (_Opcode15) { + babelHelpers.inherits(EvaluatePartialOpcode, _Opcode15); - function EvaluatePartialOpcode(_ref8) { - var name = _ref8.name; - var symbolTable = _ref8.symbolTable; + function EvaluatePartialOpcode(_ref5) { + var name = _ref5.name; + var symbolTable = _ref5.symbolTable; - _classCallCheck(this, EvaluatePartialOpcode); - - _Opcode16.call(this); + _Opcode15.call(this); this.type = "evaluate-partial"; this.cache = _glimmerUtil.dict(); this.name = name; this.symbolTable = symbolTable; } @@ -18162,16 +18735,15 @@ var reference = this.name.evaluate(vm); var referenceCache = new _glimmerReference.ReferenceCache(reference); var name = referenceCache.revalidate(); var block = this.cache[name]; if (!block) { - var _vm$env$lookupPartial = vm.env.lookupPartial([name]); + var _vm$env$lookupPartial = vm.env.lookupPartial([name], this.symbolTable); var template = _vm$env$lookupPartial.template; - var scanner = new _glimmerRuntimeLibScanner.default(template, vm.env); - block = scanner.scanPartial(this.symbolTable); + block = template.asPartial(this.symbolTable); } vm.invokeBlock(block, _glimmerRuntimeLibCompiledExpressionsArgs.EvaluatedArgs.empty()); if (!_glimmerReference.isConst(reference)) { vm.updateWith(new Assert(referenceCache)); } @@ -18188,29 +18760,24 @@ return EvaluatePartialOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.EvaluatePartialOpcode = EvaluatePartialOpcode; - var NameToPartialOpcode = (function (_Opcode17) { - _inherits(NameToPartialOpcode, _Opcode17); + var NameToPartialOpcode = (function (_Opcode16) { + babelHelpers.inherits(NameToPartialOpcode, _Opcode16); - function NameToPartialOpcode() { - _classCallCheck(this, NameToPartialOpcode); - - for (var _len7 = arguments.length, args = Array(_len7), _key7 = 0; _key7 < _len7; _key7++) { - args[_key7] = arguments[_key7]; - } - - _Opcode17.call.apply(_Opcode17, [this].concat(args)); + function NameToPartialOpcode(symbolTable) { + _Opcode16.call(this); + this.symbolTable = symbolTable; this.type = "name-to-partial"; } NameToPartialOpcode.prototype.evaluate = function evaluate(vm) { var reference = vm.frame.getOperand(); var referenceCache = new _glimmerReference.ReferenceCache(reference); var name = referenceCache.revalidate(); - var partial = name && vm.env.hasPartial([name]) ? vm.env.lookupPartial([name]) : false; + var partial = name && vm.env.hasPartial([name], this.symbolTable) ? vm.env.lookupPartial([name], this.symbolTable) : false; vm.frame.setOperand(new _glimmerRuntimeLibCompiledExpressionsValue.ValueReference(partial)); if (!_glimmerReference.isConst(reference)) { vm.updateWith(new Assert(referenceCache)); } }; @@ -18238,17 +18805,15 @@ var EnvironmentTest = function (ref, env) { return env.toConditionalReference(ref); }; exports.EnvironmentTest = EnvironmentTest; - var TestOpcode = (function (_Opcode18) { - _inherits(TestOpcode, _Opcode18); + var TestOpcode = (function (_Opcode17) { + babelHelpers.inherits(TestOpcode, _Opcode17); function TestOpcode(testFunc) { - _classCallCheck(this, TestOpcode); - - _Opcode18.call(this); + _Opcode17.call(this); this.testFunc = testFunc; this.type = "test"; } TestOpcode.prototype.evaluate = function evaluate(vm) { @@ -18266,19 +18831,17 @@ return TestOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.TestOpcode = TestOpcode; - var JumpOpcode = (function (_Opcode19) { - _inherits(JumpOpcode, _Opcode19); + var JumpOpcode = (function (_Opcode18) { + babelHelpers.inherits(JumpOpcode, _Opcode18); - function JumpOpcode(_ref9) { - var target = _ref9.target; + function JumpOpcode(_ref6) { + var target = _ref6.target; - _classCallCheck(this, JumpOpcode); - - _Opcode19.call(this); + _Opcode18.call(this); this.type = "jump"; this.target = target; } JumpOpcode.prototype.evaluate = function evaluate(vm) { @@ -18297,20 +18860,14 @@ })(_glimmerRuntimeLibOpcodes.Opcode); exports.JumpOpcode = JumpOpcode; var JumpIfOpcode = (function (_JumpOpcode) { - _inherits(JumpIfOpcode, _JumpOpcode); + babelHelpers.inherits(JumpIfOpcode, _JumpOpcode); function JumpIfOpcode() { - _classCallCheck(this, JumpIfOpcode); - - for (var _len8 = arguments.length, args = Array(_len8), _key8 = 0; _key8 < _len8; _key8++) { - args[_key8] = arguments[_key8]; - } - - _JumpOpcode.call.apply(_JumpOpcode, [this].concat(args)); + _JumpOpcode.apply(this, arguments); this.type = "jump-if"; } JumpIfOpcode.prototype.evaluate = function evaluate(vm) { var reference = vm.frame.getCondition(); @@ -18331,20 +18888,14 @@ })(JumpOpcode); exports.JumpIfOpcode = JumpIfOpcode; var JumpUnlessOpcode = (function (_JumpOpcode2) { - _inherits(JumpUnlessOpcode, _JumpOpcode2); + babelHelpers.inherits(JumpUnlessOpcode, _JumpOpcode2); function JumpUnlessOpcode() { - _classCallCheck(this, JumpUnlessOpcode); - - for (var _len9 = arguments.length, args = Array(_len9), _key9 = 0; _key9 < _len9; _key9++) { - args[_key9] = arguments[_key9]; - } - - _JumpOpcode2.call.apply(_JumpOpcode2, [this].concat(args)); + _JumpOpcode2.apply(this, arguments); this.type = "jump-unless"; } JumpUnlessOpcode.prototype.evaluate = function evaluate(vm) { var reference = vm.frame.getCondition(); @@ -18365,15 +18916,13 @@ })(JumpOpcode); exports.JumpUnlessOpcode = JumpUnlessOpcode; var Assert = (function (_UpdatingOpcode) { - _inherits(Assert, _UpdatingOpcode); + babelHelpers.inherits(Assert, _UpdatingOpcode); function Assert(cache) { - _classCallCheck(this, Assert); - _UpdatingOpcode.call(this); this.type = "assert"; this.tag = cache.tag; this.cache = cache; } @@ -18409,18 +18958,16 @@ })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); exports.Assert = Assert; var JumpIfNotModifiedOpcode = (function (_UpdatingOpcode2) { - _inherits(JumpIfNotModifiedOpcode, _UpdatingOpcode2); + babelHelpers.inherits(JumpIfNotModifiedOpcode, _UpdatingOpcode2); - function JumpIfNotModifiedOpcode(_ref10) { - var tag = _ref10.tag; - var target = _ref10.target; + function JumpIfNotModifiedOpcode(_ref7) { + var tag = _ref7.tag; + var target = _ref7.target; - _classCallCheck(this, JumpIfNotModifiedOpcode); - _UpdatingOpcode2.call(this); this.type = "jump-if-not-modified"; this.tag = tag; this.target = target; this.lastRevision = tag.value(); @@ -18452,17 +18999,15 @@ })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); exports.JumpIfNotModifiedOpcode = JumpIfNotModifiedOpcode; var DidModifyOpcode = (function (_UpdatingOpcode3) { - _inherits(DidModifyOpcode, _UpdatingOpcode3); + babelHelpers.inherits(DidModifyOpcode, _UpdatingOpcode3); - function DidModifyOpcode(_ref11) { - var target = _ref11.target; + function DidModifyOpcode(_ref8) { + var target = _ref8.target; - _classCallCheck(this, DidModifyOpcode); - _UpdatingOpcode3.call(this); this.type = "did-modify"; this.tag = _glimmerReference.CONSTANT_TAG; this.target = target; } @@ -18474,55 +19019,43 @@ return DidModifyOpcode; })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); exports.DidModifyOpcode = DidModifyOpcode; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/vm.ts"],"names":[],"mappings":"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","file":"vm.js","sourcesContent":["import { Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { CompiledExpression } from '../expressions';\nimport { CompiledArgs, EvaluatedArgs } from '../expressions/args';\nimport { VM, UpdatingVM, BindDynamicScopeCallback } from '../../vm';\nimport { CompiledBlock, Layout, InlineBlock, PartialBlock } from '../blocks';\nimport { turbocharge } from '../../utils';\nimport { NULL_REFERENCE } from '../../references';\nimport SymbolTable from '../../symbol-table';\nimport { Reference, PathReference, ConstReference } from 'glimmer-reference';\nimport { ValueReference } from '../expressions/value';\nimport { ListSlice, Opaque, Slice, Dict, dict, assign, InternedString } from 'glimmer-util';\nimport { CONSTANT_TAG, ReferenceCache, Revision, RevisionTag, isConst, isModified } from 'glimmer-reference';\nimport Scanner from '../../scanner';\nimport Environment from '../../environment';\n\nexport class PushChildScopeOpcode extends Opcode {\n  public type = \"push-child-scope\";\n\n  evaluate(vm: VM) {\n    vm.pushChildScope();\n  }\n}\n\nexport class PopScopeOpcode extends Opcode {\n  public type = \"pop-scope\";\n\n  evaluate(vm: VM) {\n    vm.popScope();\n  }\n}\n\nexport class PushDynamicScopeOpcode extends Opcode {\n  public type = \"push-dynamic-scope\";\n\n  evaluate(vm: VM) {\n    vm.pushDynamicScope();\n  }\n}\n\nexport class PopDynamicScopeOpcode extends Opcode {\n  public type = \"pop-dynamic-scope\";\n\n  evaluate(vm: VM) {\n    vm.popDynamicScope();\n  }\n}\n\nexport class PutNullOpcode extends Opcode {\n  public type = \"put-null\";\n\n  evaluate(vm: VM) {\n    vm.frame.setOperand(NULL_REFERENCE);\n  }\n}\n\nexport class PutValueOpcode extends Opcode {\n  public type = \"put-value\";\n  private expression: CompiledExpression<any>;\n\n  constructor({ expression }: { expression: CompiledExpression<any> }) {\n    super();\n    this.expression = expression;\n  }\n\n  evaluate(vm: VM) {\n    vm.evaluateOperand(this.expression);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [this.expression.toJSON()]\n    };\n  }\n}\n\nexport interface PutArgsOptions {\n  args: CompiledArgs;\n}\n\nexport class PutArgsOpcode extends Opcode {\n  public type = \"put-args\";\n\n  private args: CompiledArgs;\n\n  constructor({ args }: PutArgsOptions) {\n    super();\n    this.args = args;\n  }\n\n  evaluate(vm: VM) {\n    vm.evaluateArgs(this.args);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      details: {\n        \"positional\": this.args.positional.toJSON(),\n        \"named\": this.args.named.toJSON()\n      }\n    };\n  }\n}\n\nexport interface BindPositionalArgsOptions {\n  block: InlineBlock;\n}\n\nexport class BindPositionalArgsOpcode extends Opcode {\n  public type = \"bind-positional-args\";\n\n  private names: string[];\n  private positional: number[];\n\n  constructor({ block }: BindPositionalArgsOptions) {\n    super();\n\n    this.names = block.locals;\n    let positional = this.positional = [];\n\n    block.locals.forEach((name) => {\n      positional.push(block.symbolTable.getLocal(name));\n    });\n  }\n\n  evaluate(vm: VM) {\n    vm.bindPositionalArgs(this.positional);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [`[${this.names.map(name => JSON.stringify(name)).join(\", \")}]`]\n    };\n  }\n}\n\nexport interface BindNamedArgsOptions {\n  named: Dict<number>;\n}\n\nexport class BindNamedArgsOpcode extends Opcode {\n  public type = \"bind-named-args\";\n\n  public named: Dict<number>;\n\n  static create(layout: Layout) {\n    let named = layout['named'].reduce(\n      (obj, name) => assign(obj, { [<string>name]: layout.symbolTable.getNamed(name) }),\n      dict<number>()\n    );\n\n    turbocharge(named);\n    return new BindNamedArgsOpcode({ named });\n  }\n\n  constructor({ named }: { named: Dict<number> }) {\n    super();\n    this.named = named;\n  }\n\n  evaluate(vm: VM) {\n    vm.bindNamedArgs(this.named);\n  }\n\n  toJSON(): OpcodeJSON {\n    let args = Object.keys(this.named).map(name => {\n      return `$${this.named[name]}: $ARGS[${name}]`;\n    });\n\n    return {\n      guid: this._guid,\n      type: this.type,\n      args\n    };\n  }\n}\n\nexport interface BindBlocksOptions {\n  blocks: Dict<number>;\n}\n\nexport class BindBlocksOpcode extends Opcode {\n  public type = \"bind-blocks\";\n\n  public blocks: Dict<number>;\n\n  static create(template: Layout) {\n    let blocks = dict<number>();\n    template['yields'].forEach(name => {\n      blocks[<string>name] = template.symbolTable.getYield(name);\n    });\n\n    return new BindBlocksOpcode({ blocks });\n  }\n\n  constructor({ blocks }: { blocks: Dict<number> }) {\n    super();\n    this.blocks = blocks;\n  }\n\n  evaluate(vm: VM) {\n    vm.bindBlocks(this.blocks);\n  }\n}\n\nexport { BindDynamicScopeCallback };\n\nexport class BindDynamicScopeOpcode extends Opcode {\n  public type = \"bind-dynamic-scope\";\n\n  public callback: BindDynamicScopeCallback;\n\n  constructor(callback: BindDynamicScopeCallback) {\n    super();\n    this.callback = callback;\n  }\n\n  evaluate(vm: VM) {\n    vm.bindDynamicScope(this.callback);\n  }\n}\n\nexport interface EnterOptions {\n  begin: LabelOpcode;\n  end: LabelOpcode;\n}\n\nexport class EnterOpcode extends Opcode {\n  public type = \"enter\";\n  public slice: Slice<Opcode>; // Public because it's used by lazy content deopt\n\n  constructor({ begin, end }: EnterOptions) {\n    super();\n    this.slice = new ListSlice(begin, end);\n  }\n\n  evaluate(vm: VM) {\n    vm.enter(this.slice);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { slice, type, _guid } = this;\n\n    let begin = slice.head() as LabelOpcode;\n    let end = slice.tail() as LabelOpcode;\n\n    return {\n      guid: _guid,\n      type,\n      args: [\n        JSON.stringify(begin.inspect()),\n        JSON.stringify(end.inspect())\n      ]\n    };\n  }\n}\n\nexport class ExitOpcode extends Opcode {\n  public type = \"exit\";\n\n  evaluate(vm: VM) {\n    vm.exit();\n  }\n}\n\nexport interface LabelOptions {\n  label?: string;\n}\n\nexport class LabelOpcode extends Opcode implements UpdatingOpcode {\n  public tag = CONSTANT_TAG;\n  public type = \"label\";\n  public label: string = null;\n\n  prev: any = null;\n  next: any = null;\n\n  constructor(label: string) {\n    super();\n    if (label) this.label = label;\n  }\n\n  evaluate() {}\n\n  inspect(): string {\n    return `${this.label} [${this._guid}]`;\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.inspect())]\n    };\n  }\n}\n\nexport interface EvaluateOptions {\n  debug: string;\n  block: InlineBlock;\n}\n\nexport class EvaluateOpcode extends Opcode {\n  public type = \"evaluate\";\n  public debug: string;\n  public block: InlineBlock;\n\n  constructor({ debug, block }: { debug: string, block: InlineBlock }) {\n    super();\n    this.debug = debug;\n    this.block = block;\n  }\n\n  evaluate(vm: VM) {\n    vm.invokeBlock(this.block, vm.frame.getArgs());\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, debug, block } = this;\n\n    let compiled: CompiledBlock = block['compiled'];\n    let children: OpcodeJSON[];\n\n    if (compiled) {\n      children = compiled.ops.toArray().map(op => op.toJSON());\n    } else {\n      children = [{ guid: null, type: '[ UNCOMPILED BLOCK ]' }];\n    }\n\n    return {\n      guid,\n      type,\n      args: [debug],\n      children\n    };\n  }\n}\n\nexport class EvaluatePartialOpcode extends Opcode {\n  public type = \"evaluate-partial\";\n  public symbolTable: SymbolTable;\n  public name: CompiledExpression<any>;\n  private cache = dict<PartialBlock>();\n\n  constructor({ name, symbolTable }: { symbolTable: SymbolTable, name: CompiledExpression<any> }) {\n    super();\n    this.name = name;\n    this.symbolTable = symbolTable;\n  }\n\n  evaluate(vm: VM) {\n    let reference: PathReference<any> = this.name.evaluate(vm);\n    let referenceCache = new ReferenceCache(reference);\n    let name: InternedString = referenceCache.revalidate();\n\n    let block = this.cache[name];\n    if (!block) {\n      let { template } = vm.env.lookupPartial([name]);\n      let scanner = new Scanner(template, vm.env);\n      block = scanner.scanPartial(this.symbolTable);\n    }\n\n    vm.invokeBlock(block, EvaluatedArgs.empty());\n\n    if (!isConst(reference)) {\n      vm.updateWith(new Assert(referenceCache));\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [this.name.toJSON()]\n    };\n  }\n}\n\nexport class NameToPartialOpcode extends Opcode {\n  public type = \"name-to-partial\";\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getOperand();\n    let referenceCache = new ReferenceCache(reference);\n    let name: InternedString = referenceCache.revalidate();\n    let partial = name && vm.env.hasPartial([name]) ? vm.env.lookupPartial([name]) : false;\n    vm.frame.setOperand(new ValueReference(partial));\n\n    if (!isConst(reference)) {\n      vm.updateWith(new Assert(referenceCache));\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\"]\n    };\n  }\n}\n\nexport type TestFunction = (ref: Reference<Opaque>, env: Environment) => Reference<boolean>;\n\nexport const ConstTest: TestFunction = function(ref: Reference<Opaque>, env: Environment): Reference<boolean> {\n  return new ConstReference(!!ref.value());\n};\n\nexport const SimpleTest: TestFunction = function(ref: Reference<Opaque>, env: Environment): Reference<boolean> {\n  return ref as Reference<boolean>;\n};\n\nexport const EnvironmentTest: TestFunction = function(ref: Reference<Opaque>, env: Environment): Reference<boolean> {\n  return env.toConditionalReference(ref);\n};\n\nexport class TestOpcode extends Opcode {\n  public type = \"test\";\n\n  constructor(private testFunc: TestFunction) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.frame.setCondition(this.testFunc(vm.frame.getOperand(), vm.env));\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\", this.testFunc.name]\n    };\n  }\n}\n\nexport interface JumpOptions {\n  target: LabelOpcode;\n}\n\nexport class JumpOpcode extends Opcode {\n  public type = \"jump\";\n\n  private target: LabelOpcode;\n\n  constructor({ target }: { target: LabelOpcode }) {\n    super();\n    this.target = target;\n  }\n\n  evaluate(vm: VM) {\n    vm.goto(this.target);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.target.inspect())]\n    };\n  }\n}\n\nexport class JumpIfOpcode extends JumpOpcode {\n  public type = \"jump-if\";\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getCondition();\n\n    if (isConst(reference)) {\n      if (reference.value()) {\n        super.evaluate(vm);\n      }\n    } else {\n      let cache = new ReferenceCache(reference);\n\n      if (cache.peek()) {\n        super.evaluate(vm);\n      }\n\n      vm.updateWith(new Assert(cache));\n    }\n  }\n}\n\nexport class JumpUnlessOpcode extends JumpOpcode {\n  public type = \"jump-unless\";\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getCondition();\n\n    if (isConst(reference)) {\n      if (!reference.value()) {\n        super.evaluate(vm);\n      }\n    } else {\n      let cache = new ReferenceCache(reference);\n\n      if (!cache.peek()) {\n        super.evaluate(vm);\n      }\n\n      vm.updateWith(new Assert(cache));\n    }\n  }\n}\n\nexport class Assert extends UpdatingOpcode {\n  public type = \"assert\";\n\n  private cache: ReferenceCache<Opaque>;\n\n  constructor(cache: ReferenceCache<Opaque>) {\n    super();\n    this.tag = cache.tag;\n    this.cache = cache;\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { cache } = this;\n\n    if (isModified(cache.revalidate())) {\n      vm.throw();\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    let { type, _guid, cache } = this;\n\n    let expected;\n\n    try {\n      expected = JSON.stringify(cache.peek());\n    } catch(e) {\n      expected = String(cache.peek());\n    }\n\n    return {\n      guid: _guid,\n      type,\n      args: [],\n      details: { expected }\n    };\n  }\n}\n\nexport class JumpIfNotModifiedOpcode extends UpdatingOpcode {\n  public type = \"jump-if-not-modified\";\n\n  private target: LabelOpcode;\n  private lastRevision: Revision;\n\n  constructor({ tag, target }: { tag: RevisionTag, target: LabelOpcode }) {\n    super();\n    this.tag = tag;\n    this.target = target;\n    this.lastRevision = tag.value();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { tag, target, lastRevision } = this;\n\n    if (!vm.alwaysRevalidate && tag.validate(lastRevision)) {\n      vm.goto(target);\n    }\n  }\n\n  didModify() {\n    this.lastRevision = this.tag.value();\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.target.inspect())]\n    };\n  }\n}\n\nexport class DidModifyOpcode extends UpdatingOpcode {\n  public type = \"did-modify\";\n\n  private target: JumpIfNotModifiedOpcode;\n\n  constructor({ target }: { target: JumpIfNotModifiedOpcode }) {\n    super();\n    this.tag = CONSTANT_TAG;\n    this.target = target;\n  }\n\n  evaluate() {\n    this.target.didModify();\n  }\n}\n"]} -enifed('glimmer-runtime/lib/compiler', ['exports', 'glimmer-util', 'glimmer-runtime/lib/syntax/core', 'glimmer-runtime/lib/compiled/blocks', 'glimmer-runtime/lib/compiled/expressions/function', 'glimmer-runtime/lib/compiled/opcodes/builder'], function (exports, _glimmerUtil, _glimmerRuntimeLibSyntaxCore, _glimmerRuntimeLibCompiledBlocks, _glimmerRuntimeLibCompiledExpressionsFunction, _glimmerRuntimeLibCompiledOpcodesBuilder) { +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiled/opcodes/vm.ts"],"names":[],"mappings":"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","file":"vm.js","sourcesContent":["import { Opcode, OpcodeJSON, UpdatingOpcode } from '../../opcodes';\nimport { CompiledExpression } from '../expressions';\nimport { CompiledArgs, EvaluatedArgs } from '../expressions/args';\nimport { VM, UpdatingVM } from '../../vm';\nimport { CompiledBlock, Layout, InlineBlock, PartialBlock } from '../blocks';\nimport { NULL_REFERENCE } from '../../references';\nimport SymbolTable from '../../symbol-table';\nimport { Reference, PathReference, ConstReference } from 'glimmer-reference';\nimport { ValueReference } from '../expressions/value';\nimport { ListSlice, Opaque, Slice, dict } from 'glimmer-util';\nimport { CONSTANT_TAG, ReferenceCache, Revision, RevisionTag, isConst, isModified } from 'glimmer-reference';\nimport Environment from '../../environment';\n\nexport class PushChildScopeOpcode extends Opcode {\n  public type = \"push-child-scope\";\n\n  evaluate(vm: VM) {\n    vm.pushChildScope();\n  }\n}\n\nexport class PopScopeOpcode extends Opcode {\n  public type = \"pop-scope\";\n\n  evaluate(vm: VM) {\n    vm.popScope();\n  }\n}\n\nexport class PushDynamicScopeOpcode extends Opcode {\n  public type = \"push-dynamic-scope\";\n\n  evaluate(vm: VM) {\n    vm.pushDynamicScope();\n  }\n}\n\nexport class PopDynamicScopeOpcode extends Opcode {\n  public type = \"pop-dynamic-scope\";\n\n  evaluate(vm: VM) {\n    vm.popDynamicScope();\n  }\n}\n\nexport class PutNullOpcode extends Opcode {\n  public type = \"put-null\";\n\n  evaluate(vm: VM) {\n    vm.frame.setOperand(NULL_REFERENCE);\n  }\n}\n\nexport class PutValueOpcode extends Opcode {\n  public type = \"put-value\";\n  private expression: CompiledExpression<any>;\n\n  constructor({ expression }: { expression: CompiledExpression<any> }) {\n    super();\n    this.expression = expression;\n  }\n\n  evaluate(vm: VM) {\n    vm.evaluateOperand(this.expression);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [this.expression.toJSON()]\n    };\n  }\n}\n\nexport interface PutArgsOptions {\n  args: CompiledArgs;\n}\n\nexport class PutArgsOpcode extends Opcode {\n  public type = \"put-args\";\n\n  private args: CompiledArgs;\n\n  constructor({ args }: PutArgsOptions) {\n    super();\n    this.args = args;\n  }\n\n  evaluate(vm: VM) {\n    vm.evaluateArgs(this.args);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      details: {\n        \"positional\": this.args.positional.toJSON(),\n        \"named\": this.args.named.toJSON()\n      }\n    };\n  }\n}\n\nexport class BindPositionalArgsOpcode extends Opcode {\n  public type = \"bind-positional-args\";\n\n  static create(block: InlineBlock): BindPositionalArgsOpcode {\n    let names = block.locals;\n    let symbols = names.map(name => block.symbolTable.getLocal(name));\n    return new this(names, symbols);\n  }\n\n  constructor(\n    private names: string[],\n    private symbols: number[]\n  ) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.bindPositionalArgs(this.symbols);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [`[${this.names.map(name => JSON.stringify(name)).join(\", \")}]`]\n    };\n  }\n}\n\nexport class BindNamedArgsOpcode extends Opcode {\n  public type = \"bind-named-args\";\n\n  static create(layout: Layout) {\n    let names = layout.named;\n    let symbols = names.map(name => layout.symbolTable.getNamed(name));\n\n    return new BindNamedArgsOpcode(names, symbols);\n  }\n\n  constructor(\n    protected names: string[],\n    protected symbols: number[]\n  ) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.bindNamedArgs(this.names, this.symbols);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { names, symbols } = this;\n\n    let args = names.map((name, i) => `$${symbols[i]}: $ARGS[${name}]`);\n\n    return {\n      guid: this._guid,\n      type: this.type,\n      args\n    };\n  }\n}\n\nexport class BindBlocksOpcode extends BindNamedArgsOpcode {\n  public type = \"bind-blocks\";\n\n  static create(layout: Layout) {\n    let names = layout.yields;\n    let symbols = names.map(name => layout.symbolTable.getYield(name));\n\n    return new this(names, symbols);\n  }\n\n  evaluate(vm: VM) {\n    vm.bindBlocks(this.names, this.symbols);\n  }\n}\n\nexport class BindDynamicScopeOpcode extends Opcode {\n  public type = \"bind-dynamic-scope\";\n\n  constructor(private names: string[]) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.bindDynamicScope(this.names);\n  }\n}\n\nexport interface EnterOptions {\n  begin: LabelOpcode;\n  end: LabelOpcode;\n}\n\nexport class EnterOpcode extends Opcode {\n  public type = \"enter\";\n  public slice: Slice<Opcode>; // Public because it's used by lazy content deopt\n\n  constructor({ begin, end }: EnterOptions) {\n    super();\n    this.slice = new ListSlice(begin, end);\n  }\n\n  evaluate(vm: VM) {\n    vm.enter(this.slice);\n  }\n\n  toJSON(): OpcodeJSON {\n    let { slice, type, _guid } = this;\n\n    let begin = slice.head() as LabelOpcode;\n    let end = slice.tail() as LabelOpcode;\n\n    return {\n      guid: _guid,\n      type,\n      args: [\n        JSON.stringify(begin.inspect()),\n        JSON.stringify(end.inspect())\n      ]\n    };\n  }\n}\n\nexport class ExitOpcode extends Opcode {\n  public type = \"exit\";\n\n  evaluate(vm: VM) {\n    vm.exit();\n  }\n}\n\nexport interface LabelOptions {\n  label?: string;\n}\n\nexport class LabelOpcode extends Opcode implements UpdatingOpcode {\n  public tag = CONSTANT_TAG;\n  public type = \"label\";\n  public label: string = null;\n\n  prev: any = null;\n  next: any = null;\n\n  constructor(label: string) {\n    super();\n    if (label) this.label = label;\n  }\n\n  evaluate() {}\n\n  inspect(): string {\n    return `${this.label} [${this._guid}]`;\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.inspect())]\n    };\n  }\n}\n\nexport interface EvaluateOptions {\n  debug: string;\n  block: InlineBlock;\n}\n\nexport class EvaluateOpcode extends Opcode {\n  public type = \"evaluate\";\n  public debug: string;\n  public block: InlineBlock;\n\n  constructor({ debug, block }: { debug: string, block: InlineBlock }) {\n    super();\n    this.debug = debug;\n    this.block = block;\n  }\n\n  evaluate(vm: VM) {\n    vm.invokeBlock(this.block, vm.frame.getArgs());\n  }\n\n  toJSON(): OpcodeJSON {\n    let { _guid: guid, type, debug, block } = this;\n\n    let compiled: CompiledBlock = block['compiled'];\n    let children: OpcodeJSON[];\n\n    if (compiled) {\n      children = compiled.ops.toArray().map(op => op.toJSON());\n    } else {\n      children = [{ guid: null, type: '[ UNCOMPILED BLOCK ]' }];\n    }\n\n    return {\n      guid,\n      type,\n      args: [debug],\n      children\n    };\n  }\n}\n\nexport class EvaluatePartialOpcode extends Opcode {\n  public type = \"evaluate-partial\";\n  public symbolTable: SymbolTable;\n  public name: CompiledExpression<any>;\n  private cache = dict<PartialBlock>();\n\n  constructor({ name, symbolTable }: { symbolTable: SymbolTable, name: CompiledExpression<any> }) {\n    super();\n    this.name = name;\n    this.symbolTable = symbolTable;\n  }\n\n  evaluate(vm: VM) {\n    let reference: PathReference<any> = this.name.evaluate(vm);\n    let referenceCache = new ReferenceCache(reference);\n    let name: string = referenceCache.revalidate();\n\n    let block = this.cache[name];\n    if (!block) {\n      let { template } = vm.env.lookupPartial([name], this.symbolTable);\n      block = template.asPartial(this.symbolTable);\n    }\n\n    vm.invokeBlock(block, EvaluatedArgs.empty());\n\n    if (!isConst(reference)) {\n      vm.updateWith(new Assert(referenceCache));\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [this.name.toJSON()]\n    };\n  }\n}\n\nexport class NameToPartialOpcode extends Opcode {\n  public type = \"name-to-partial\";\n\n  constructor(private symbolTable: SymbolTable) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getOperand();\n    let referenceCache = new ReferenceCache(reference);\n    let name: string = referenceCache.revalidate();\n    let partial = name && vm.env.hasPartial([name], this.symbolTable) ? vm.env.lookupPartial([name], this.symbolTable) : false;\n    vm.frame.setOperand(new ValueReference(partial));\n\n    if (!isConst(reference)) {\n      vm.updateWith(new Assert(referenceCache));\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\"]\n    };\n  }\n}\n\nexport type TestFunction = (ref: Reference<Opaque>, env: Environment) => Reference<boolean>;\n\nexport const ConstTest: TestFunction = function(ref: Reference<Opaque>, env: Environment): Reference<boolean> {\n  return new ConstReference(!!ref.value());\n};\n\nexport const SimpleTest: TestFunction = function(ref: Reference<Opaque>, env: Environment): Reference<boolean> {\n  return ref as Reference<boolean>;\n};\n\nexport const EnvironmentTest: TestFunction = function(ref: Reference<Opaque>, env: Environment): Reference<boolean> {\n  return env.toConditionalReference(ref);\n};\n\nexport class TestOpcode extends Opcode {\n  public type = \"test\";\n\n  constructor(private testFunc: TestFunction) {\n    super();\n  }\n\n  evaluate(vm: VM) {\n    vm.frame.setCondition(this.testFunc(vm.frame.getOperand(), vm.env));\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [\"$OPERAND\", this.testFunc.name]\n    };\n  }\n}\n\nexport interface JumpOptions {\n  target: LabelOpcode;\n}\n\nexport class JumpOpcode extends Opcode {\n  public type = \"jump\";\n\n  private target: LabelOpcode;\n\n  constructor({ target }: { target: LabelOpcode }) {\n    super();\n    this.target = target;\n  }\n\n  evaluate(vm: VM) {\n    vm.goto(this.target);\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.target.inspect())]\n    };\n  }\n}\n\nexport class JumpIfOpcode extends JumpOpcode {\n  public type = \"jump-if\";\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getCondition();\n\n    if (isConst(reference)) {\n      if (reference.value()) {\n        super.evaluate(vm);\n      }\n    } else {\n      let cache = new ReferenceCache(reference);\n\n      if (cache.peek()) {\n        super.evaluate(vm);\n      }\n\n      vm.updateWith(new Assert(cache));\n    }\n  }\n}\n\nexport class JumpUnlessOpcode extends JumpOpcode {\n  public type = \"jump-unless\";\n\n  evaluate(vm: VM) {\n    let reference = vm.frame.getCondition();\n\n    if (isConst(reference)) {\n      if (!reference.value()) {\n        super.evaluate(vm);\n      }\n    } else {\n      let cache = new ReferenceCache(reference);\n\n      if (!cache.peek()) {\n        super.evaluate(vm);\n      }\n\n      vm.updateWith(new Assert(cache));\n    }\n  }\n}\n\nexport class Assert extends UpdatingOpcode {\n  public type = \"assert\";\n\n  private cache: ReferenceCache<Opaque>;\n\n  constructor(cache: ReferenceCache<Opaque>) {\n    super();\n    this.tag = cache.tag;\n    this.cache = cache;\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { cache } = this;\n\n    if (isModified(cache.revalidate())) {\n      vm.throw();\n    }\n  }\n\n  toJSON(): OpcodeJSON {\n    let { type, _guid, cache } = this;\n\n    let expected;\n\n    try {\n      expected = JSON.stringify(cache.peek());\n    } catch(e) {\n      expected = String(cache.peek());\n    }\n\n    return {\n      guid: _guid,\n      type,\n      args: [],\n      details: { expected }\n    };\n  }\n}\n\nexport class JumpIfNotModifiedOpcode extends UpdatingOpcode {\n  public type = \"jump-if-not-modified\";\n\n  private target: LabelOpcode;\n  private lastRevision: Revision;\n\n  constructor({ tag, target }: { tag: RevisionTag, target: LabelOpcode }) {\n    super();\n    this.tag = tag;\n    this.target = target;\n    this.lastRevision = tag.value();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { tag, target, lastRevision } = this;\n\n    if (!vm.alwaysRevalidate && tag.validate(lastRevision)) {\n      vm.goto(target);\n    }\n  }\n\n  didModify() {\n    this.lastRevision = this.tag.value();\n  }\n\n  toJSON(): OpcodeJSON {\n    return {\n      guid: this._guid,\n      type: this.type,\n      args: [JSON.stringify(this.target.inspect())]\n    };\n  }\n}\n\nexport class DidModifyOpcode extends UpdatingOpcode {\n  public type = \"did-modify\";\n\n  private target: JumpIfNotModifiedOpcode;\n\n  constructor({ target }: { target: JumpIfNotModifiedOpcode }) {\n    super();\n    this.tag = CONSTANT_TAG;\n    this.target = target;\n  }\n\n  evaluate() {\n    this.target.didModify();\n  }\n}\n","import { Opcode, UpdatingOpcode } from '../../opcodes';\nimport { EvaluatedArgs } from '../expressions/args';\nimport { NULL_REFERENCE } from '../../references';\nimport { ConstReference } from 'glimmer-reference';\nimport { ValueReference } from '../expressions/value';\nimport { ListSlice, dict } from 'glimmer-util';\nimport { CONSTANT_TAG, ReferenceCache, isConst, isModified } from 'glimmer-reference';\nexport class PushChildScopeOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"push-child-scope\";\n    }\n    evaluate(vm) {\n        vm.pushChildScope();\n    }\n}\nexport class PopScopeOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"pop-scope\";\n    }\n    evaluate(vm) {\n        vm.popScope();\n    }\n}\nexport class PushDynamicScopeOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"push-dynamic-scope\";\n    }\n    evaluate(vm) {\n        vm.pushDynamicScope();\n    }\n}\nexport class PopDynamicScopeOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"pop-dynamic-scope\";\n    }\n    evaluate(vm) {\n        vm.popDynamicScope();\n    }\n}\nexport class PutNullOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"put-null\";\n    }\n    evaluate(vm) {\n        vm.frame.setOperand(NULL_REFERENCE);\n    }\n}\nexport class PutValueOpcode extends Opcode {\n    constructor({ expression }) {\n        super();\n        this.type = \"put-value\";\n        this.expression = expression;\n    }\n    evaluate(vm) {\n        vm.evaluateOperand(this.expression);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [this.expression.toJSON()]\n        };\n    }\n}\nexport class PutArgsOpcode extends Opcode {\n    constructor({ args }) {\n        super();\n        this.type = \"put-args\";\n        this.args = args;\n    }\n    evaluate(vm) {\n        vm.evaluateArgs(this.args);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            details: {\n                \"positional\": this.args.positional.toJSON(),\n                \"named\": this.args.named.toJSON()\n            }\n        };\n    }\n}\nexport class BindPositionalArgsOpcode extends Opcode {\n    constructor(names, symbols) {\n        super();\n        this.names = names;\n        this.symbols = symbols;\n        this.type = \"bind-positional-args\";\n    }\n    static create(block) {\n        let names = block.locals;\n        let symbols = names.map(name => block.symbolTable.getLocal(name));\n        return new this(names, symbols);\n    }\n    evaluate(vm) {\n        vm.bindPositionalArgs(this.symbols);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [`[${this.names.map(name => JSON.stringify(name)).join(\", \")}]`]\n        };\n    }\n}\nexport class BindNamedArgsOpcode extends Opcode {\n    constructor(names, symbols) {\n        super();\n        this.names = names;\n        this.symbols = symbols;\n        this.type = \"bind-named-args\";\n    }\n    static create(layout) {\n        let names = layout.named;\n        let symbols = names.map(name => layout.symbolTable.getNamed(name));\n        return new BindNamedArgsOpcode(names, symbols);\n    }\n    evaluate(vm) {\n        vm.bindNamedArgs(this.names, this.symbols);\n    }\n    toJSON() {\n        let { names, symbols } = this;\n        let args = names.map((name, i) => `$${symbols[i]}: $ARGS[${name}]`);\n        return {\n            guid: this._guid,\n            type: this.type,\n            args\n        };\n    }\n}\nexport class BindBlocksOpcode extends BindNamedArgsOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"bind-blocks\";\n    }\n    static create(layout) {\n        let names = layout.yields;\n        let symbols = names.map(name => layout.symbolTable.getYield(name));\n        return new this(names, symbols);\n    }\n    evaluate(vm) {\n        vm.bindBlocks(this.names, this.symbols);\n    }\n}\nexport class BindDynamicScopeOpcode extends Opcode {\n    constructor(names) {\n        super();\n        this.names = names;\n        this.type = \"bind-dynamic-scope\";\n    }\n    evaluate(vm) {\n        vm.bindDynamicScope(this.names);\n    }\n}\nexport class EnterOpcode extends Opcode {\n    constructor({ begin, end }) {\n        super();\n        this.type = \"enter\";\n        this.slice = new ListSlice(begin, end);\n    }\n    evaluate(vm) {\n        vm.enter(this.slice);\n    }\n    toJSON() {\n        let { slice, type, _guid } = this;\n        let begin = slice.head();\n        let end = slice.tail();\n        return {\n            guid: _guid,\n            type,\n            args: [\n                JSON.stringify(begin.inspect()),\n                JSON.stringify(end.inspect())\n            ]\n        };\n    }\n}\nexport class ExitOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"exit\";\n    }\n    evaluate(vm) {\n        vm.exit();\n    }\n}\nexport class LabelOpcode extends Opcode {\n    constructor(label) {\n        super();\n        this.tag = CONSTANT_TAG;\n        this.type = \"label\";\n        this.label = null;\n        this.prev = null;\n        this.next = null;\n        if (label)\n            this.label = label;\n    }\n    evaluate() { }\n    inspect() {\n        return `${this.label} [${this._guid}]`;\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.inspect())]\n        };\n    }\n}\nexport class EvaluateOpcode extends Opcode {\n    constructor({ debug, block }) {\n        super();\n        this.type = \"evaluate\";\n        this.debug = debug;\n        this.block = block;\n    }\n    evaluate(vm) {\n        vm.invokeBlock(this.block, vm.frame.getArgs());\n    }\n    toJSON() {\n        let { _guid: guid, type, debug, block } = this;\n        let compiled = block['compiled'];\n        let children;\n        if (compiled) {\n            children = compiled.ops.toArray().map(op => op.toJSON());\n        }\n        else {\n            children = [{ guid: null, type: '[ UNCOMPILED BLOCK ]' }];\n        }\n        return {\n            guid,\n            type,\n            args: [debug],\n            children\n        };\n    }\n}\nexport class EvaluatePartialOpcode extends Opcode {\n    constructor({ name, symbolTable }) {\n        super();\n        this.type = \"evaluate-partial\";\n        this.cache = dict();\n        this.name = name;\n        this.symbolTable = symbolTable;\n    }\n    evaluate(vm) {\n        let reference = this.name.evaluate(vm);\n        let referenceCache = new ReferenceCache(reference);\n        let name = referenceCache.revalidate();\n        let block = this.cache[name];\n        if (!block) {\n            let { template } = vm.env.lookupPartial([name], this.symbolTable);\n            block = template.asPartial(this.symbolTable);\n        }\n        vm.invokeBlock(block, EvaluatedArgs.empty());\n        if (!isConst(reference)) {\n            vm.updateWith(new Assert(referenceCache));\n        }\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [this.name.toJSON()]\n        };\n    }\n}\nexport class NameToPartialOpcode extends Opcode {\n    constructor(symbolTable) {\n        super();\n        this.symbolTable = symbolTable;\n        this.type = \"name-to-partial\";\n    }\n    evaluate(vm) {\n        let reference = vm.frame.getOperand();\n        let referenceCache = new ReferenceCache(reference);\n        let name = referenceCache.revalidate();\n        let partial = name && vm.env.hasPartial([name], this.symbolTable) ? vm.env.lookupPartial([name], this.symbolTable) : false;\n        vm.frame.setOperand(new ValueReference(partial));\n        if (!isConst(reference)) {\n            vm.updateWith(new Assert(referenceCache));\n        }\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [\"$OPERAND\"]\n        };\n    }\n}\nexport const ConstTest = function (ref, env) {\n    return new ConstReference(!!ref.value());\n};\nexport const SimpleTest = function (ref, env) {\n    return ref;\n};\nexport const EnvironmentTest = function (ref, env) {\n    return env.toConditionalReference(ref);\n};\nexport class TestOpcode extends Opcode {\n    constructor(testFunc) {\n        super();\n        this.testFunc = testFunc;\n        this.type = \"test\";\n    }\n    evaluate(vm) {\n        vm.frame.setCondition(this.testFunc(vm.frame.getOperand(), vm.env));\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [\"$OPERAND\", this.testFunc.name]\n        };\n    }\n}\nexport class JumpOpcode extends Opcode {\n    constructor({ target }) {\n        super();\n        this.type = \"jump\";\n        this.target = target;\n    }\n    evaluate(vm) {\n        vm.goto(this.target);\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.target.inspect())]\n        };\n    }\n}\nexport class JumpIfOpcode extends JumpOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"jump-if\";\n    }\n    evaluate(vm) {\n        let reference = vm.frame.getCondition();\n        if (isConst(reference)) {\n            if (reference.value()) {\n                super.evaluate(vm);\n            }\n        }\n        else {\n            let cache = new ReferenceCache(reference);\n            if (cache.peek()) {\n                super.evaluate(vm);\n            }\n            vm.updateWith(new Assert(cache));\n        }\n    }\n}\nexport class JumpUnlessOpcode extends JumpOpcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"jump-unless\";\n    }\n    evaluate(vm) {\n        let reference = vm.frame.getCondition();\n        if (isConst(reference)) {\n            if (!reference.value()) {\n                super.evaluate(vm);\n            }\n        }\n        else {\n            let cache = new ReferenceCache(reference);\n            if (!cache.peek()) {\n                super.evaluate(vm);\n            }\n            vm.updateWith(new Assert(cache));\n        }\n    }\n}\nexport class Assert extends UpdatingOpcode {\n    constructor(cache) {\n        super();\n        this.type = \"assert\";\n        this.tag = cache.tag;\n        this.cache = cache;\n    }\n    evaluate(vm) {\n        let { cache } = this;\n        if (isModified(cache.revalidate())) {\n            vm.throw();\n        }\n    }\n    toJSON() {\n        let { type, _guid, cache } = this;\n        let expected;\n        try {\n            expected = JSON.stringify(cache.peek());\n        }\n        catch (e) {\n            expected = String(cache.peek());\n        }\n        return {\n            guid: _guid,\n            type,\n            args: [],\n            details: { expected }\n        };\n    }\n}\nexport class JumpIfNotModifiedOpcode extends UpdatingOpcode {\n    constructor({ tag, target }) {\n        super();\n        this.type = \"jump-if-not-modified\";\n        this.tag = tag;\n        this.target = target;\n        this.lastRevision = tag.value();\n    }\n    evaluate(vm) {\n        let { tag, target, lastRevision } = this;\n        if (!vm.alwaysRevalidate && tag.validate(lastRevision)) {\n            vm.goto(target);\n        }\n    }\n    didModify() {\n        this.lastRevision = this.tag.value();\n    }\n    toJSON() {\n        return {\n            guid: this._guid,\n            type: this.type,\n            args: [JSON.stringify(this.target.inspect())]\n        };\n    }\n}\nexport class DidModifyOpcode extends UpdatingOpcode {\n    constructor({ target }) {\n        super();\n        this.type = \"did-modify\";\n        this.tag = CONSTANT_TAG;\n        this.target = target;\n    }\n    evaluate() {\n        this.target.didModify();\n    }\n}\n"]} +enifed('glimmer-runtime/lib/compiler', ['exports', 'glimmer-util', 'glimmer-runtime/lib/utils', 'glimmer-runtime/lib/syntax/core', 'glimmer-runtime/lib/compiled/blocks', 'glimmer-runtime/lib/compiled/expressions/function', 'glimmer-runtime/lib/compiled/opcodes/builder'], function (exports, _glimmerUtil, _glimmerRuntimeLibUtils, _glimmerRuntimeLibSyntaxCore, _glimmerRuntimeLibCompiledBlocks, _glimmerRuntimeLibCompiledExpressionsFunction, _glimmerRuntimeLibCompiledOpcodesBuilder) { 'use strict'; - var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); - exports.compileLayout = compileLayout; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var Compiler = (function () { function Compiler(block, env) { - _classCallCheck(this, Compiler); - this.block = block; this.current = block.program.head(); this.env = env; this.symbolTable = block.symbolTable; } Compiler.prototype.compileStatement = function compileStatement(statement, ops) { - this.env.statement(statement, this.block.meta).compile(ops, this.env, this.block); + this.env.statement(statement, this.symbolTable).compile(ops, this.env, this.symbolTable); }; return Compiler; })(); function compileStatement(env, statement, ops, layout) { - env.statement(statement, layout.meta).compile(ops, env, layout); + env.statement(statement, layout.symbolTable).compile(ops, env, layout.symbolTable); } exports.default = Compiler; var EntryPointCompiler = (function (_Compiler) { - _inherits(EntryPointCompiler, _Compiler); + babelHelpers.inherits(EntryPointCompiler, _Compiler); function EntryPointCompiler(template, env) { - _classCallCheck(this, EntryPointCompiler); - _Compiler.call(this, template, env); - var list = new CompileIntoList(env, template); - this.ops = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(list, template, env); + var list = new CompileIntoList(env, template.symbolTable); + this.ops = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(list, template.symbolTable, env); } EntryPointCompiler.prototype.compile = function compile() { var block = this.block; var ops = this.ops; @@ -18557,27 +19090,25 @@ })(Compiler); exports.EntryPointCompiler = EntryPointCompiler; var InlineBlockCompiler = (function (_Compiler2) { - _inherits(InlineBlockCompiler, _Compiler2); + babelHelpers.inherits(InlineBlockCompiler, _Compiler2); function InlineBlockCompiler(block, env) { - _classCallCheck(this, InlineBlockCompiler); - _Compiler2.call(this, block, env); - var list = new CompileIntoList(env, block); - this.ops = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(list, block, env); + var list = new CompileIntoList(env, block.symbolTable); + this.ops = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(list, block.symbolTable, env); } InlineBlockCompiler.prototype.compile = function compile() { var block = this.block; var ops = this.ops; var program = block.program; if (block.hasPositionalParameters()) { - ops.bindPositionalArgs(block); + ops.bindPositionalArgsForBlock(block); } var current = program.head(); while (current) { var next = program.nextNode(current); this.compileStatement(current, ops); @@ -18597,12 +19128,10 @@ return builder.compile(); } var ComponentLayoutBuilder = (function () { function ComponentLayoutBuilder(env) { - _classCallCheck(this, ComponentLayoutBuilder); - this.env = env; } ComponentLayoutBuilder.prototype.empty = function empty() { this.inner = new EmptyBuilder(this.env); @@ -18618,58 +19147,52 @@ ComponentLayoutBuilder.prototype.compile = function compile() { return this.inner.compile(); }; - _createClass(ComponentLayoutBuilder, [{ + babelHelpers.createClass(ComponentLayoutBuilder, [{ key: 'tag', get: function () { return this.inner.tag; } }, { key: 'attrs', get: function () { return this.inner.attrs; } }]); - return ComponentLayoutBuilder; })(); var EmptyBuilder = (function () { function EmptyBuilder(env) { - _classCallCheck(this, EmptyBuilder); - this.env = env; } EmptyBuilder.prototype.compile = function compile() { var env = this.env; var list = new CompileIntoList(env, null); return new _glimmerRuntimeLibCompiledBlocks.CompiledBlock(list, 0); }; - _createClass(EmptyBuilder, [{ + babelHelpers.createClass(EmptyBuilder, [{ key: 'tag', get: function () { throw new Error('Nope'); } }, { key: 'attrs', get: function () { throw new Error('Nope'); } }]); - return EmptyBuilder; })(); var WrappedBuilder = (function () { function WrappedBuilder(env, layout) { - _classCallCheck(this, WrappedBuilder); - this.tag = new ComponentTagBuilder(); this.attrs = new ComponentAttrsBuilder(); this.env = env; this.layout = layout; } @@ -18680,48 +19203,56 @@ // Test // JumpUnless(BODY) // OpenDynamicPrimitiveElement // DidCreateElement // ...attr statements... + // FlushElement // BODY: Noop + // ...body statements... // PutValue(TagExpr) // Test // JumpUnless(END) // CloseElement // END: Noop + // DidRenderLayout // Exit // //========STATIC // OpenPrimitiveElementOpcode // DidCreateElement // ...attr statements... + // FlushElement + // ...body statements... // CloseElement + // DidRenderLayout // Exit var env = this.env; var layout = this.layout; var symbolTable = layout.symbolTable; - var buffer = new CompileIntoList(env, layout); - var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(buffer, layout, env); + var buffer = new CompileIntoList(env, layout.symbolTable); + var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(buffer, layout.symbolTable, env); dsl.startLabels(); if (this.tag.isDynamic) { dsl.putValue(this.tag.dynamicTagName); dsl.test('simple'); dsl.jumpUnless('BODY'); dsl.openDynamicPrimitiveElement(); dsl.didCreateElement(); this.attrs['buffer'].forEach(function (statement) { return compileStatement(env, statement, dsl, layout); }); + dsl.flushElement(); dsl.label('BODY'); } else if (this.tag.isStatic) { var tag = this.tag.staticTagName; dsl.openPrimitiveElement(tag); dsl.didCreateElement(); this.attrs['buffer'].forEach(function (statement) { return compileStatement(env, statement, dsl, layout); }); + dsl.flushElement(); } if (layout.hasNamedParameters()) { dsl.bindNamedArgsForLayout(layout); } if (layout.hasYields()) { @@ -18737,74 +19268,73 @@ dsl.closeElement(); dsl.label('END'); } else if (this.tag.isStatic) { dsl.closeElement(); } + dsl.didRenderLayout(); dsl.stopLabels(); return new _glimmerRuntimeLibCompiledBlocks.CompiledBlock(dsl.toOpSeq(), symbolTable.size); }; return WrappedBuilder; })(); var UnwrappedBuilder = (function () { function UnwrappedBuilder(env, layout) { - _classCallCheck(this, UnwrappedBuilder); - this.attrs = new ComponentAttrsBuilder(); this.env = env; this.layout = layout; } UnwrappedBuilder.prototype.compile = function compile() { var env = this.env; var layout = this.layout; - var buffer = new CompileIntoList(env, layout); - var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(buffer, layout, env); + var buffer = new CompileIntoList(env, layout.symbolTable); + var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(buffer, layout.symbolTable, env); dsl.startLabels(); if (layout.hasNamedParameters()) { dsl.bindNamedArgsForLayout(layout); } if (layout.hasYields()) { dsl.bindBlocksForLayout(layout); } var attrs = this.attrs['buffer']; var attrsInserted = false; this.layout.program.forEachNode(function (statement) { - compileStatement(env, statement, dsl, layout); if (!attrsInserted && isOpenElement(statement)) { + dsl.openComponentElement(statement.tag); dsl.didCreateElement(); dsl.shadowAttributes(); attrs.forEach(function (statement) { return compileStatement(env, statement, dsl, layout); }); attrsInserted = true; + } else { + compileStatement(env, statement, dsl, layout); } }); + dsl.didRenderLayout(); dsl.stopLabels(); return new _glimmerRuntimeLibCompiledBlocks.CompiledBlock(dsl.toOpSeq(), layout.symbolTable.size); }; - _createClass(UnwrappedBuilder, [{ + babelHelpers.createClass(UnwrappedBuilder, [{ key: 'tag', get: function () { throw new Error('BUG: Cannot call `tag` on an UnwrappedBuilder'); } }]); - return UnwrappedBuilder; })(); function isOpenElement(syntax) { return syntax instanceof _glimmerRuntimeLibSyntaxCore.OpenElement || syntax instanceof _glimmerRuntimeLibSyntaxCore.OpenPrimitiveElement; } var ComponentTagBuilder = (function () { function ComponentTagBuilder() { - _classCallCheck(this, ComponentTagBuilder); - this.isDynamic = null; this.isStatic = null; this.staticTagName = null; this.dynamicTagName = null; } @@ -18822,12 +19352,10 @@ return ComponentTagBuilder; })(); var ComponentAttrsBuilder = (function () { function ComponentAttrsBuilder() { - _classCallCheck(this, ComponentAttrsBuilder); - this.buffer = []; } ComponentAttrsBuilder.prototype.static = function _static(name, value) { this.buffer.push(new _glimmerRuntimeLibSyntaxCore.StaticAttr({ name: name, value: value })); @@ -18840,130 +19368,110 @@ return ComponentAttrsBuilder; })(); var ComponentBuilder = (function () { function ComponentBuilder(dsl) { - _classCallCheck(this, ComponentBuilder); - this.dsl = dsl; this.env = dsl.env; } - ComponentBuilder.prototype.static = function _static(_ref) { - var definition = _ref.definition; - var args = _ref.args; - var shadow = _ref.shadow; - var templates = _ref.templates; + ComponentBuilder.prototype.static = function _static(definition, args, templates, symbolTable) { + var shadow = arguments.length <= 4 || arguments[4] === undefined ? _glimmerRuntimeLibUtils.EMPTY_ARRAY : arguments[4]; this.dsl.unit({ templates: templates }, function (dsl) { - dsl.putComponentDefinition(args, definition); - dsl.openComponent(shadow); + dsl.putComponentDefinition(definition); + dsl.openComponent(args, shadow); dsl.closeComponent(); }); }; - ComponentBuilder.prototype.dynamic = function dynamic(_ref2) { - var definitionArgs = _ref2.definitionArgs; - var definition = _ref2.definition; - var args = _ref2.args; - var shadow = _ref2.shadow; - var templates = _ref2.templates; + ComponentBuilder.prototype.dynamic = function dynamic(definitionArgs, definition, args, templates, symbolTable) { + var shadow = arguments.length <= 5 || arguments[5] === undefined ? _glimmerRuntimeLibUtils.EMPTY_ARRAY : arguments[5]; this.dsl.unit({ templates: templates }, function (dsl) { dsl.enter('BEGIN', 'END'); dsl.label('BEGIN'); dsl.putArgs(definitionArgs); dsl.putValue(_glimmerRuntimeLibCompiledExpressionsFunction.default(definition)); dsl.test('simple'); dsl.jumpUnless('END'); - dsl.putDynamicComponentDefinition(args); - dsl.openComponent(shadow); + dsl.putDynamicComponentDefinition(); + dsl.openComponent(args, shadow); dsl.closeComponent(); dsl.label('END'); dsl.exit(); }); }; return ComponentBuilder; })(); var CompileIntoList = (function (_LinkedList) { - _inherits(CompileIntoList, _LinkedList); + babelHelpers.inherits(CompileIntoList, _LinkedList); - function CompileIntoList(env, block) { - _classCallCheck(this, CompileIntoList); - + function CompileIntoList(env, symbolTable) { _LinkedList.call(this); this.env = env; - this.block = block; - var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(this, block, env); + this.symbolTable = symbolTable; + var dsl = new _glimmerRuntimeLibCompiledOpcodesBuilder.default(this, symbolTable, env); this.component = new ComponentBuilder(dsl); } CompileIntoList.prototype.getLocalSymbol = function getLocalSymbol(name) { - return this.block.symbolTable.getLocal(name); + return this.symbolTable.getLocal(name); }; CompileIntoList.prototype.hasLocalSymbol = function hasLocalSymbol(name) { - return typeof this.block.symbolTable.getLocal(name) === 'number'; + return typeof this.symbolTable.getLocal(name) === 'number'; }; CompileIntoList.prototype.getNamedSymbol = function getNamedSymbol(name) { - return this.block.symbolTable.getNamed(name); + return this.symbolTable.getNamed(name); }; CompileIntoList.prototype.hasNamedSymbol = function hasNamedSymbol(name) { - return typeof this.block.symbolTable.getNamed(name) === 'number'; + return typeof this.symbolTable.getNamed(name) === 'number'; }; CompileIntoList.prototype.getBlockSymbol = function getBlockSymbol(name) { - return this.block.symbolTable.getYield(name); + return this.symbolTable.getYield(name); }; CompileIntoList.prototype.hasBlockSymbol = function hasBlockSymbol(name) { - return typeof this.block.symbolTable.getYield(name) === 'number'; + return typeof this.symbolTable.getYield(name) === 'number'; }; - CompileIntoList.prototype.hasKeyword = function hasKeyword(name) { - return this.env.hasKeyword(name); - }; - CompileIntoList.prototype.toOpSeq = function toOpSeq() { return this; }; return CompileIntoList; })(_glimmerUtil.LinkedList); exports.CompileIntoList = CompileIntoList; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiler.ts"],"names":[],"mappings":"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","file":"compiler.js","sourcesContent":["import { FIXME, Opaque, Slice, LinkedList, InternedString } from 'glimmer-util';\nimport { OpSeq, Opcode } from './opcodes';\n\nimport * as Syntax from './syntax/core';\nimport { Environment } from './environment';\nimport SymbolTable from './symbol-table';\nimport { Block, CompiledBlock, EntryPoint, InlineBlock, Layout } from './compiled/blocks';\n\nimport OpcodeBuilder, {\n  StaticComponentOptions,\n  DynamicComponentOptions\n} from './opcode-builder';\n\nimport {\n  Statement as StatementSyntax,\n  Attribute as AttributeSyntax,\n  StatementCompilationBuffer,\n} from './syntax';\n\nimport {\n  Expression\n} from './syntax';\n\nimport {\n  FunctionExpression,\n  default as makeFunctionExpression\n} from './compiled/expressions/function';\n\nimport OpcodeBuilderDSL from './compiled/opcodes/builder';\n\nimport * as Component from './component/interfaces';\n\nabstract class Compiler {\n  public env: Environment;\n  protected block: Block;\n  protected symbolTable: SymbolTable;\n  protected current: StatementSyntax;\n\n  constructor(block: Block, env: Environment) {\n    this.block = block;\n    this.current = block.program.head();\n    this.env = env;\n    this.symbolTable = block.symbolTable;\n  }\n\n  protected compileStatement(statement: StatementSyntax, ops: OpcodeBuilderDSL) {\n    this.env.statement(statement, this.block.meta).compile(ops, this.env, this.block);\n  }\n}\n\nfunction compileStatement(env: Environment, statement: StatementSyntax, ops: OpcodeBuilderDSL, layout: Layout) {\n  env.statement(statement, layout.meta).compile(ops, env, layout);\n}\n\nexport default Compiler;\n\nexport class EntryPointCompiler extends Compiler {\n  private ops: OpcodeBuilderDSL;\n  protected block: EntryPoint;\n\n  constructor(template: EntryPoint, env: Environment) {\n    super(template, env);\n    let list = new CompileIntoList(env, template);\n    this.ops = new OpcodeBuilderDSL(list, template, env);\n  }\n\n  compile(): OpSeq {\n    let { block, ops } = this;\n    let { program } = block;\n\n    let current = program.head();\n\n    while (current) {\n      let next = program.nextNode(current);\n      this.compileStatement(current, ops);\n      current = next;\n    }\n\n    return ops.toOpSeq();\n  }\n\n  append(op: Opcode) {\n    this.ops.append(op);\n  }\n\n  getLocalSymbol(name: InternedString): number {\n    return this.symbolTable.getLocal(name);\n  }\n\n  getNamedSymbol(name: InternedString): number {\n    return this.symbolTable.getNamed(name);\n  }\n\n  getYieldSymbol(name: InternedString): number {\n    return this.symbolTable.getYield(name);\n  }\n}\n\nexport class InlineBlockCompiler extends Compiler {\n  private ops: OpcodeBuilderDSL;\n  protected block: InlineBlock;\n  protected current: StatementSyntax;\n\n  constructor(block: InlineBlock, env: Environment) {\n    super(block, env);\n    let list = new CompileIntoList(env, block);\n    this.ops = new OpcodeBuilderDSL(list, block, env);\n  }\n\n  compile(): OpSeq {\n    let { block, ops } = this;\n    let { program } = block;\n\n    if (block.hasPositionalParameters()) {\n      ops.bindPositionalArgs(block);\n    }\n\n    let current = program.head();\n\n    while (current) {\n      let next = program.nextNode(current);\n      this.compileStatement(current, ops);\n      current = next;\n    }\n\n    return ops.toOpSeq();\n  }\n}\n\nexport interface ComponentParts {\n  tag: InternedString;\n  attrs: Slice<AttributeSyntax<Opaque>>;\n  body: Slice<StatementSyntax>;\n}\n\nexport interface CompiledComponentParts {\n  tag: InternedString;\n  preamble: CompileIntoList;\n  main: CompileIntoList;\n}\n\nexport interface Compilable {\n  compile(builder: ComponentLayoutBuilder);\n}\n\nexport function compileLayout(compilable: Compilable, env: Environment): CompiledBlock {\n  let builder = new ComponentLayoutBuilder(env);\n\n  compilable.compile(builder);\n\n  return builder.compile();\n}\n\nclass ComponentLayoutBuilder implements Component.ComponentLayoutBuilder {\n  public env: Environment;\n\n  private inner: EmptyBuilder | WrappedBuilder | UnwrappedBuilder;\n\n  constructor(env: Environment) {\n    this.env = env;\n  }\n\n  empty() {\n    this.inner = new EmptyBuilder(this.env);\n  }\n\n  wrapLayout(layout: Layout) {\n    this.inner = new WrappedBuilder(this.env, layout);\n  }\n\n  fromLayout(layout: Layout) {\n    this.inner = new UnwrappedBuilder(this.env, layout);\n  }\n\n  compile(): CompiledBlock {\n    return this.inner.compile();\n  }\n\n  get tag(): Component.ComponentTagBuilder {\n    return this.inner.tag;\n  }\n\n  get attrs(): Component.ComponentAttrsBuilder {\n    return this.inner.attrs;\n  }\n}\n\nclass EmptyBuilder {\n  public env: Environment;\n\n  constructor(env: Environment) {\n    this.env = env;\n  }\n\n  get tag(): Component.ComponentTagBuilder {\n    throw new Error('Nope');\n  }\n\n  get attrs(): Component.ComponentAttrsBuilder {\n    throw new Error('Nope');\n  }\n\n  compile(): CompiledBlock {\n    let { env } = this;\n\n    let list = new CompileIntoList(env, null);\n    return new CompiledBlock(list, 0);\n  }\n}\n\nclass WrappedBuilder {\n  private layout: Layout;\n  public env: Environment;\n\n  public tag = new ComponentTagBuilder();\n  public attrs = new ComponentAttrsBuilder();\n\n  constructor(env: Environment, layout: Layout) {\n    this.env = env;\n    this.layout = layout;\n  }\n\n  compile(): CompiledBlock {\n    //========DYNAMIC\n    //        PutValue(TagExpr)\n    //        Test\n    //        JumpUnless(BODY)\n    //        OpenDynamicPrimitiveElement\n    //        DidCreateElement\n    //        ...attr statements...\n    // BODY:  Noop\n    //        PutValue(TagExpr)\n    //        Test\n    //        JumpUnless(END)\n    //        CloseElement\n    // END:   Noop\n    //        Exit\n    //\n    //========STATIC\n    //        OpenPrimitiveElementOpcode\n    //        DidCreateElement\n    //        ...attr statements...\n    //        CloseElement\n    //        Exit\n\n    let { env, layout } = this;\n\n    let symbolTable = layout.symbolTable;\n    let buffer = new CompileIntoList(env, layout);\n    let dsl = new OpcodeBuilderDSL(buffer, layout, env);\n\n    dsl.startLabels();\n\n    if (this.tag.isDynamic) {\n      dsl.putValue(this.tag.dynamicTagName);\n      dsl.test('simple');\n      dsl.jumpUnless('BODY');\n      dsl.openDynamicPrimitiveElement();\n      dsl.didCreateElement();\n      this.attrs['buffer'].forEach(statement => compileStatement(env, statement, dsl, layout));\n      dsl.label('BODY');\n    } else if (this.tag.isStatic) {\n      let tag = this.tag.staticTagName;\n      dsl.openPrimitiveElement(tag);\n      dsl.didCreateElement();\n      this.attrs['buffer'].forEach(statement => compileStatement(env, statement, dsl, layout));\n    }\n\n    if (layout.hasNamedParameters()) {\n      dsl.bindNamedArgsForLayout(layout);\n    }\n\n    if (layout.hasYields()) {\n      dsl.bindBlocksForLayout(layout);\n    }\n    layout.program.forEachNode(statement => compileStatement(env, statement, dsl, layout));\n\n    if (this.tag.isDynamic) {\n      dsl.putValue(this.tag.dynamicTagName);\n      dsl.test('simple');\n      dsl.jumpUnless('END');\n      dsl.closeElement();\n      dsl.label('END');\n    } else if (this.tag.isStatic) {\n      dsl.closeElement();\n    }\n\n    dsl.stopLabels();\n\n    return new CompiledBlock(dsl.toOpSeq(), symbolTable.size);\n  }\n}\n\nclass UnwrappedBuilder {\n  private layout: Layout;\n  public env: Environment;\n\n  public attrs = new ComponentAttrsBuilder();\n\n  constructor(env: Environment, layout: Layout) {\n    this.env = env;\n    this.layout = layout;\n  }\n\n  get tag(): Component.ComponentTagBuilder {\n    throw new Error('BUG: Cannot call `tag` on an UnwrappedBuilder');\n  }\n\n  compile(): CompiledBlock {\n    let { env, layout } = this;\n\n    let buffer = new CompileIntoList(env, layout);\n    let dsl = new OpcodeBuilderDSL(buffer, layout, env);\n\n    dsl.startLabels();\n\n    if (layout.hasNamedParameters()) {\n      dsl.bindNamedArgsForLayout(layout);\n    }\n\n    if (layout.hasYields()) {\n      dsl.bindBlocksForLayout(layout);\n    }\n\n    let attrs = this.attrs['buffer'];\n    let attrsInserted = false;\n\n    this.layout.program.forEachNode(statement => {\n      compileStatement(env, statement, dsl, layout);\n\n      if (!attrsInserted && isOpenElement(statement)) {\n        dsl.didCreateElement();\n        dsl.shadowAttributes();\n        attrs.forEach(statement => compileStatement(env, statement, dsl, layout));\n        attrsInserted = true;\n      }\n    });\n\n    dsl.stopLabels();\n\n    return new CompiledBlock(dsl.toOpSeq(), layout.symbolTable.size);\n  }\n}\n\ntype OpenElement = Syntax.OpenElement | Syntax.OpenPrimitiveElement;\n\nfunction isOpenElement(syntax: StatementSyntax): syntax is OpenElement {\n  return syntax instanceof Syntax.OpenElement || syntax instanceof Syntax.OpenPrimitiveElement;\n}\n\nclass ComponentTagBuilder implements Component.ComponentTagBuilder {\n  public isDynamic = null;\n  public isStatic = null;\n  public staticTagName: InternedString = null;\n  public dynamicTagName: Expression<string> = null;\n\n  static(tagName: InternedString) {\n    this.isStatic = true;\n    this.staticTagName = tagName;\n  }\n\n  dynamic(tagName: FunctionExpression<string>) {\n    this.isDynamic = true;\n    this.dynamicTagName = makeFunctionExpression(tagName);\n  }\n}\n\nclass ComponentAttrsBuilder implements Component.ComponentAttrsBuilder {\n  private buffer: AttributeSyntax<string>[] = [];\n\n  static(name: string, value: string) {\n    this.buffer.push(new Syntax.StaticAttr({ name: name as FIXME<'intern'>, value: value as FIXME<'intern'> }));\n  }\n\n  dynamic(name: string, value: FunctionExpression<string>) {\n    this.buffer.push(new Syntax.DynamicAttr({ name: name as FIXME<'intern'>, value: makeFunctionExpression(value), isTrusting: false }));\n  }\n}\n\nclass ComponentBuilder {\n  private env: Environment;\n\n  constructor(private dsl: OpcodeBuilderDSL) {\n    this.env = dsl.env;\n  }\n\n  static({ definition, args, shadow, templates }: StaticComponentOptions) {\n    this.dsl.unit({ templates }, dsl => {\n      dsl.putComponentDefinition(args, definition);\n      dsl.openComponent(shadow);\n      dsl.closeComponent();\n    });\n  }\n\n  dynamic({ definitionArgs, definition, args, shadow, templates }: DynamicComponentOptions) {\n    this.dsl.unit({ templates }, dsl => {\n      dsl.enter('BEGIN', 'END');\n      dsl.label('BEGIN');\n      dsl.putArgs(definitionArgs);\n      dsl.putValue(makeFunctionExpression(definition));\n      dsl.test('simple');\n      dsl.jumpUnless('END');\n      dsl.putDynamicComponentDefinition(args);\n      dsl.openComponent(shadow);\n      dsl.closeComponent();\n      dsl.label('END');\n      dsl.exit();\n    });\n  }\n}\n\nexport class CompileIntoList extends LinkedList<Opcode> implements OpcodeBuilder, StatementCompilationBuffer {\n  private env: Environment;\n  private block: Block;\n\n  public component: ComponentBuilder;\n\n  constructor(env: Environment, block: Block) {\n    super();\n    this.env = env;\n    this.block = block;\n\n    let dsl = new OpcodeBuilderDSL(this, block, env);\n    this.component = new ComponentBuilder(dsl);\n  }\n\n  getLocalSymbol(name: InternedString): number {\n    return this.block.symbolTable.getLocal(name);\n  }\n\n  hasLocalSymbol(name: InternedString): boolean {\n    return typeof this.block.symbolTable.getLocal(name) === 'number';\n  }\n\n  getNamedSymbol(name: InternedString): number {\n    return this.block.symbolTable.getNamed(name);\n  }\n\n  hasNamedSymbol(name: InternedString): boolean {\n    return typeof this.block.symbolTable.getNamed(name) === 'number';\n  }\n\n  getBlockSymbol(name: InternedString): number {\n    return this.block.symbolTable.getYield(name);\n  }\n\n  hasBlockSymbol(name: InternedString): boolean {\n    return typeof this.block.symbolTable.getYield(name) === 'number';\n  }\n\n  hasKeyword(name: InternedString): boolean {\n    return this.env.hasKeyword(name);\n  }\n\n  toOpSeq(): OpSeq {\n    return this;\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/compiler.ts"],"names":[],"mappings":"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","file":"compiler.js","sourcesContent":["import { Opaque, Slice, LinkedList } from 'glimmer-util';\nimport { OpSeq, Opcode } from './opcodes';\n\nimport { EMPTY_ARRAY } from './utils';\nimport * as Syntax from './syntax/core';\nimport { Environment } from './environment';\nimport SymbolTable from './symbol-table';\nimport { Block, CompiledBlock, EntryPoint, InlineBlock, Layout } from './compiled/blocks';\n\nimport {\n  ComponentBuilder as IComponentBuilder,\n  DynamicDefinition,\n  StaticDefinition\n} from './opcode-builder';\n\nimport {\n  Statement as StatementSyntax,\n  Attribute as AttributeSyntax,\n  StatementCompilationBuffer,\n} from './syntax';\n\nimport {\n  Expression\n} from './syntax';\n\nimport {\n  FunctionExpression,\n  default as makeFunctionExpression\n} from './compiled/expressions/function';\n\nimport OpcodeBuilderDSL from './compiled/opcodes/builder';\n\nimport * as Component from './component/interfaces';\n\nabstract class Compiler {\n  public env: Environment;\n  protected block: Block;\n  protected symbolTable: SymbolTable;\n  protected current: StatementSyntax;\n\n  constructor(block: Block, env: Environment) {\n    this.block = block;\n    this.current = block.program.head();\n    this.env = env;\n    this.symbolTable = block.symbolTable;\n  }\n\n  protected compileStatement(statement: StatementSyntax, ops: OpcodeBuilderDSL) {\n    this.env.statement(statement, this.symbolTable).compile(ops, this.env, this.symbolTable);\n  }\n}\n\nfunction compileStatement(env: Environment, statement: StatementSyntax, ops: OpcodeBuilderDSL, layout: Layout) {\n  env.statement(statement, layout.symbolTable).compile(ops, env, layout.symbolTable);\n}\n\nexport default Compiler;\n\nexport class EntryPointCompiler extends Compiler {\n  private ops: OpcodeBuilderDSL;\n  protected block: EntryPoint;\n\n  constructor(template: EntryPoint, env: Environment) {\n    super(template, env);\n    let list = new CompileIntoList(env, template.symbolTable);\n    this.ops = new OpcodeBuilderDSL(list, template.symbolTable, env);\n  }\n\n  compile(): OpSeq {\n    let { block, ops } = this;\n    let { program } = block;\n\n    let current = program.head();\n\n    while (current) {\n      let next = program.nextNode(current);\n      this.compileStatement(current, ops);\n      current = next;\n    }\n\n    return ops.toOpSeq();\n  }\n\n  append(op: Opcode) {\n    this.ops.append(op);\n  }\n\n  getLocalSymbol(name: string): number {\n    return this.symbolTable.getLocal(name);\n  }\n\n  getNamedSymbol(name: string): number {\n    return this.symbolTable.getNamed(name);\n  }\n\n  getYieldSymbol(name: string): number {\n    return this.symbolTable.getYield(name);\n  }\n}\n\nexport class InlineBlockCompiler extends Compiler {\n  private ops: OpcodeBuilderDSL;\n  protected block: InlineBlock;\n  protected current: StatementSyntax;\n\n  constructor(block: InlineBlock, env: Environment) {\n    super(block, env);\n    let list = new CompileIntoList(env, block.symbolTable);\n    this.ops = new OpcodeBuilderDSL(list, block.symbolTable, env);\n  }\n\n  compile(): OpSeq {\n    let { block, ops } = this;\n    let { program } = block;\n\n    if (block.hasPositionalParameters()) {\n      ops.bindPositionalArgsForBlock(block);\n    }\n\n    let current = program.head();\n\n    while (current) {\n      let next = program.nextNode(current);\n      this.compileStatement(current, ops);\n      current = next;\n    }\n\n    return ops.toOpSeq();\n  }\n}\n\nexport interface ComponentParts {\n  tag: string;\n  attrs: Slice<AttributeSyntax<Opaque>>;\n  body: Slice<StatementSyntax>;\n}\n\nexport interface CompiledComponentParts {\n  tag: string;\n  preamble: CompileIntoList;\n  main: CompileIntoList;\n}\n\nexport interface Compilable {\n  compile(builder: ComponentLayoutBuilder);\n}\n\nexport function compileLayout(compilable: Compilable, env: Environment): CompiledBlock {\n  let builder = new ComponentLayoutBuilder(env);\n\n  compilable.compile(builder);\n\n  return builder.compile();\n}\n\nclass ComponentLayoutBuilder implements Component.ComponentLayoutBuilder {\n  public env: Environment;\n\n  private inner: EmptyBuilder | WrappedBuilder | UnwrappedBuilder;\n\n  constructor(env: Environment) {\n    this.env = env;\n  }\n\n  empty() {\n    this.inner = new EmptyBuilder(this.env);\n  }\n\n  wrapLayout(layout: Layout) {\n    this.inner = new WrappedBuilder(this.env, layout);\n  }\n\n  fromLayout(layout: Layout) {\n    this.inner = new UnwrappedBuilder(this.env, layout);\n  }\n\n  compile(): CompiledBlock {\n    return this.inner.compile();\n  }\n\n  get tag(): Component.ComponentTagBuilder {\n    return this.inner.tag;\n  }\n\n  get attrs(): Component.ComponentAttrsBuilder {\n    return this.inner.attrs;\n  }\n}\n\nclass EmptyBuilder {\n  public env: Environment;\n\n  constructor(env: Environment) {\n    this.env = env;\n  }\n\n  get tag(): Component.ComponentTagBuilder {\n    throw new Error('Nope');\n  }\n\n  get attrs(): Component.ComponentAttrsBuilder {\n    throw new Error('Nope');\n  }\n\n  compile(): CompiledBlock {\n    let { env } = this;\n\n    let list = new CompileIntoList(env, null);\n    return new CompiledBlock(list, 0);\n  }\n}\n\nclass WrappedBuilder {\n  private layout: Layout;\n  public env: Environment;\n\n  public tag = new ComponentTagBuilder();\n  public attrs = new ComponentAttrsBuilder();\n\n  constructor(env: Environment, layout: Layout) {\n    this.env = env;\n    this.layout = layout;\n  }\n\n  compile(): CompiledBlock {\n    //========DYNAMIC\n    //        PutValue(TagExpr)\n    //        Test\n    //        JumpUnless(BODY)\n    //        OpenDynamicPrimitiveElement\n    //        DidCreateElement\n    //        ...attr statements...\n    //        FlushElement\n    // BODY:  Noop\n    //        ...body statements...\n    //        PutValue(TagExpr)\n    //        Test\n    //        JumpUnless(END)\n    //        CloseElement\n    // END:   Noop\n    //        DidRenderLayout\n    //        Exit\n    //\n    //========STATIC\n    //        OpenPrimitiveElementOpcode\n    //        DidCreateElement\n    //        ...attr statements...\n    //        FlushElement\n    //        ...body statements...\n    //        CloseElement\n    //        DidRenderLayout\n    //        Exit\n\n    let { env, layout } = this;\n\n    let symbolTable = layout.symbolTable;\n    let buffer = new CompileIntoList(env, layout.symbolTable);\n    let dsl = new OpcodeBuilderDSL(buffer, layout.symbolTable, env);\n\n    dsl.startLabels();\n\n    if (this.tag.isDynamic) {\n      dsl.putValue(this.tag.dynamicTagName);\n      dsl.test('simple');\n      dsl.jumpUnless('BODY');\n      dsl.openDynamicPrimitiveElement();\n      dsl.didCreateElement();\n      this.attrs['buffer'].forEach(statement => compileStatement(env, statement, dsl, layout));\n      dsl.flushElement();\n      dsl.label('BODY');\n    } else if (this.tag.isStatic) {\n      let tag = this.tag.staticTagName;\n      dsl.openPrimitiveElement(tag);\n      dsl.didCreateElement();\n      this.attrs['buffer'].forEach(statement => compileStatement(env, statement, dsl, layout));\n      dsl.flushElement();\n    }\n\n    if (layout.hasNamedParameters()) {\n      dsl.bindNamedArgsForLayout(layout);\n    }\n\n    if (layout.hasYields()) {\n      dsl.bindBlocksForLayout(layout);\n    }\n    layout.program.forEachNode(statement => compileStatement(env, statement, dsl, layout));\n\n    if (this.tag.isDynamic) {\n      dsl.putValue(this.tag.dynamicTagName);\n      dsl.test('simple');\n      dsl.jumpUnless('END');\n      dsl.closeElement();\n      dsl.label('END');\n    } else if (this.tag.isStatic) {\n      dsl.closeElement();\n    }\n\n    dsl.didRenderLayout();\n    dsl.stopLabels();\n\n    return new CompiledBlock(dsl.toOpSeq(), symbolTable.size);\n  }\n}\n\nclass UnwrappedBuilder {\n  private layout: Layout;\n  public env: Environment;\n\n  public attrs = new ComponentAttrsBuilder();\n\n  constructor(env: Environment, layout: Layout) {\n    this.env = env;\n    this.layout = layout;\n  }\n\n  get tag(): Component.ComponentTagBuilder {\n    throw new Error('BUG: Cannot call `tag` on an UnwrappedBuilder');\n  }\n\n  compile(): CompiledBlock {\n    let { env, layout } = this;\n\n    let buffer = new CompileIntoList(env, layout.symbolTable);\n    let dsl = new OpcodeBuilderDSL(buffer, layout.symbolTable, env);\n\n    dsl.startLabels();\n\n    if (layout.hasNamedParameters()) {\n      dsl.bindNamedArgsForLayout(layout);\n    }\n\n    if (layout.hasYields()) {\n      dsl.bindBlocksForLayout(layout);\n    }\n\n    let attrs = this.attrs['buffer'];\n    let attrsInserted = false;\n\n    this.layout.program.forEachNode(statement => {\n      if (!attrsInserted && isOpenElement(statement)) {\n        dsl.openComponentElement(statement.tag);\n        dsl.didCreateElement();\n        dsl.shadowAttributes();\n        attrs.forEach(statement => compileStatement(env, statement, dsl, layout));\n        attrsInserted = true;\n      } else {\n        compileStatement(env, statement, dsl, layout);\n      }\n    });\n\n    dsl.didRenderLayout();\n    dsl.stopLabels();\n\n    return new CompiledBlock(dsl.toOpSeq(), layout.symbolTable.size);\n  }\n}\n\ntype OpenElement = Syntax.OpenElement | Syntax.OpenPrimitiveElement;\n\nfunction isOpenElement(syntax: StatementSyntax): syntax is OpenElement {\n  return syntax instanceof Syntax.OpenElement || syntax instanceof Syntax.OpenPrimitiveElement;\n}\n\nclass ComponentTagBuilder implements Component.ComponentTagBuilder {\n  public isDynamic = null;\n  public isStatic = null;\n  public staticTagName: string = null;\n  public dynamicTagName: Expression<string> = null;\n\n  static(tagName: string) {\n    this.isStatic = true;\n    this.staticTagName = tagName;\n  }\n\n  dynamic(tagName: FunctionExpression<string>) {\n    this.isDynamic = true;\n    this.dynamicTagName = makeFunctionExpression(tagName);\n  }\n}\n\nclass ComponentAttrsBuilder implements Component.ComponentAttrsBuilder {\n  private buffer: AttributeSyntax<string>[] = [];\n\n  static(name: string, value: string) {\n    this.buffer.push(new Syntax.StaticAttr({ name, value }));\n  }\n\n  dynamic(name: string, value: FunctionExpression<string>) {\n    this.buffer.push(new Syntax.DynamicAttr({ name, value: makeFunctionExpression(value), isTrusting: false }));\n  }\n}\n\nclass ComponentBuilder implements IComponentBuilder {\n  private env: Environment;\n\n  constructor(private dsl: OpcodeBuilderDSL) {\n    this.env = dsl.env;\n  }\n\n  static(definition: StaticDefinition, args: Syntax.Args, templates: Syntax.Templates, symbolTable: SymbolTable, shadow: string[] = EMPTY_ARRAY) {\n    this.dsl.unit({ templates }, dsl => {\n      dsl.putComponentDefinition(definition);\n      dsl.openComponent(args, shadow);\n      dsl.closeComponent();\n    });\n  }\n\n  dynamic(definitionArgs: Syntax.Args, definition: DynamicDefinition, args: Syntax.Args, templates: Syntax.Templates, symbolTable: SymbolTable, shadow: string[] = EMPTY_ARRAY) {\n    this.dsl.unit({ templates }, dsl => {\n      dsl.enter('BEGIN', 'END');\n      dsl.label('BEGIN');\n      dsl.putArgs(definitionArgs);\n      dsl.putValue(makeFunctionExpression(definition));\n      dsl.test('simple');\n      dsl.jumpUnless('END');\n      dsl.putDynamicComponentDefinition();\n      dsl.openComponent(args, shadow);\n      dsl.closeComponent();\n      dsl.label('END');\n      dsl.exit();\n    });\n  }\n}\n\nexport class CompileIntoList extends LinkedList<Opcode> implements StatementCompilationBuffer {\n  public component: ComponentBuilder;\n\n  constructor(private env: Environment, private symbolTable: SymbolTable) {\n    super();\n\n    let dsl = new OpcodeBuilderDSL(this, symbolTable, env);\n    this.component = new ComponentBuilder(dsl);\n  }\n\n  getLocalSymbol(name: string): number {\n    return this.symbolTable.getLocal(name);\n  }\n\n  hasLocalSymbol(name: string): boolean {\n    return typeof this.symbolTable.getLocal(name) === 'number';\n  }\n\n  getNamedSymbol(name: string): number {\n    return this.symbolTable.getNamed(name);\n  }\n\n  hasNamedSymbol(name: string): boolean {\n    return typeof this.symbolTable.getNamed(name) === 'number';\n  }\n\n  getBlockSymbol(name: string): number {\n    return this.symbolTable.getYield(name);\n  }\n\n  hasBlockSymbol(name: string): boolean {\n    return typeof this.symbolTable.getYield(name) === 'number';\n  }\n\n  toOpSeq(): OpSeq {\n    return this;\n  }\n}\n"]} enifed('glimmer-runtime/lib/component/interfaces', ['exports'], function (exports) { 'use strict'; exports.isComponentDefinition = isComponentDefinition; - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var COMPONENT_DEFINITION_BRAND = 'COMPONENT DEFINITION [id=e59c754e-61eb-4392-8c4a-2c0ac72bfcd4]'; function isComponentDefinition(obj) { return typeof obj === 'object' && obj && obj[COMPONENT_DEFINITION_BRAND]; } var ComponentDefinition = function ComponentDefinition(name, manager, ComponentClass) { - _classCallCheck(this, ComponentDefinition); - this['COMPONENT DEFINITION [id=e59c754e-61eb-4392-8c4a-2c0ac72bfcd4]'] = true; this.name = name; this.manager = manager; this.ComponentClass = ComponentClass; }; exports.ComponentDefinition = ComponentDefinition; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvY29tcG9uZW50L2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQW1GQSxRQUFNLDBCQUEwQixHQUFHLGdFQUFnRSxDQUFDOztBQUVwRyxhQUFBLHFCQUFBLENBQXNDLEdBQVEsRUFBQTtBQUM1QyxlQUFPLE9BQU8sR0FBRyxLQUFLLFFBQVEsSUFBSSxHQUFHLElBQUksR0FBRyxDQUFDLDBCQUEwQixDQUFDLENBQUM7S0FDMUU7O1FBRUQsbUJBQUEsR0FPRSxTQVBGLG1CQUFBLENBT2MsSUFBWSxFQUFFLE9BQTRCLEVBQUUsY0FBOEIsRUFBQTs4QkFQeEYsbUJBQUE7O0FBS1UsWUFBQSxDQUFDLGdFQUFnRSxDQUFDLEdBQUcsSUFBSSxDQUFDO0FBR2hGLFlBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0FBQ2pCLFlBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO0FBQ3ZCLFlBQUksQ0FBQyxjQUFjLEdBQUcsY0FBYyxDQUFDO0tBQ3RDIiwiZmlsZSI6ImludGVyZmFjZXMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFdmFsdWF0ZWRBcmdzIH0gZnJvbSAnLi4vY29tcGlsZWQvZXhwcmVzc2lvbnMvYXJncyc7XG5pbXBvcnQgeyBGdW5jdGlvbkV4cHJlc3Npb24gfSBmcm9tICcuLi9jb21waWxlZC9leHByZXNzaW9ucy9mdW5jdGlvbic7XG5pbXBvcnQgeyBMYXlvdXQsIENvbXBpbGVkQmxvY2sgfSBmcm9tICcuLi9jb21waWxlZC9ibG9ja3MnO1xuXG5pbXBvcnQgRW52aXJvbm1lbnQsIHsgRHluYW1pY1Njb3BlIH0gZnJvbSAnLi4vZW52aXJvbm1lbnQnO1xuaW1wb3J0IHsgRWxlbWVudE9wZXJhdGlvbnMgfSBmcm9tICcuLi9idWlsZGVyJztcblxuaW1wb3J0IHsgRGVzdHJveWFibGUsIE9wYXF1ZSB9IGZyb20gJ2dsaW1tZXItdXRpbCc7XG5pbXBvcnQgeyBQYXRoUmVmZXJlbmNlLCBSZXZpc2lvblRhZyB9IGZyb20gJ2dsaW1tZXItcmVmZXJlbmNlJztcblxuZXhwb3J0IHR5cGUgQ29tcG9uZW50ID0gT3BhcXVlO1xuZXhwb3J0IHR5cGUgQ29tcG9uZW50Q2xhc3MgPSBhbnk7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29tcG9uZW50TWFuYWdlcjxUIGV4dGVuZHMgQ29tcG9uZW50PiB7XG4gIC8vIEZpcnN0LCB0aGUgY29tcG9uZW50IG1hbmFnZXIgaXMgYXNrZWQgdG8gcHJlcGFyZSB0aGUgYXJndW1lbnRzIG5lZWRlZFxuICAvLyBmb3IgYGNyZWF0ZWAuIFRoaXMgYWxsb3dzIGZvciB0aGluZ3MgbGlrZSBjbG9zdXJlIGNvbXBvbmVudHMgd2hlcmUgdGhlXG4gIC8vIGFyZ3MgbmVlZCB0byBiZSBjdXJyaWVkIGJlZm9yZSBjb25zdHJ1Y3RpbmcgdGhlIGluc3RhbmNlIG9mIHRoZSBzdGF0ZVxuICAvLyBidWNrZXQuXG4gIHByZXBhcmVBcmdzKGRlZmluaXRpb246IENvbXBvbmVudERlZmluaXRpb248VD4sIGFyZ3M6IEV2YWx1YXRlZEFyZ3MpOiBFdmFsdWF0ZWRBcmdzO1xuXG4gIC8vIFRoZW4sIHRoZSBjb21wb25lbnQgbWFuYWdlciBpcyBhc2tlZCB0byBjcmVhdGUgYSBidWNrZXQgb2Ygc3RhdGUgZm9yXG4gIC8vIHRoZSBzdXBwbGllZCBhcmd1bWVudHMuIEZyb20gdGhlIHBlcnNwZWN0aXZlIG9mIEdsaW1tZXIsIHRoaXMgaXNcbiAgLy8gYW4gb3BhcXVlIHRva2VuLCBidXQgaW4gcHJhY3RpY2UgaXQgaXMgcHJvYmFibHkgYSBjb21wb25lbnQgb2JqZWN0LlxuICBjcmVhdGUoZGVmaW5pdGlvbjogQ29tcG9uZW50RGVmaW5pdGlvbjxUPiwgYXJnczogRXZhbHVhdGVkQXJncywgZHluYW1pY1Njb3BlOiBEeW5hbWljU2NvcGUsIGhhc0RlZmF1bHRCbG9jazogYm9vbGVhbik6IFQ7XG5cbiAgLy8gUmV0dXJuIHRoZSBjb21waWxlZCBsYXlvdXQgdG8gdXNlIGZvciB0aGlzIGNvbXBvbmVudC4gVGhpcyBpcyBjYWxsZWRcbiAgLy8gKmFmdGVyKiB0aGUgY29tcG9uZW50IGluc3RhbmNlIGhhcyBiZWVuIGNyZWF0ZWQsIGJlY2F1c2UgeW91IG1pZ2h0XG4gIC8vIHdhbnQgdG8gcmV0dXJuIGEgZGlmZmVyZW50IGxheW91dCBwZXItaW5zdGFuY2UgZm9yIG9wdGltaXphdGlvbiByZWFzb25zXG4gIC8vIG9yIHRvIGltcGxlbWVudCBmZWF0dXJlcyBsaWtlIEVtYmVyJ3MgXCJsYXRlLWJvdW5kXCIgbGF5b3V0cy5cbiAgbGF5b3V0Rm9yKGRlZmluaXRpb246IENvbXBvbmVudERlZmluaXRpb248VD4sIGNvbXBvbmVudDogVCwgZW52OiBFbnZpcm9ubWVudCk6IENvbXBpbGVkQmxvY2s7XG5cbiAgLy8gTmV4dCwgR2xpbW1lciBhc2tzIHRoZSBtYW5hZ2VyIHRvIGNyZWF0ZSBhIHJlZmVyZW5jZSBmb3IgdGhlIGBzZWxmYFxuICAvLyBpdCBzaG91bGQgdXNlIGluIHRoZSBsYXlvdXQuXG4gIGdldFNlbGYoY29tcG9uZW50OiBUKTogUGF0aFJlZmVyZW5jZTxPcGFxdWU+O1xuXG4gIC8vIFRoZSBgZGlkQ3JlYXRlRWxlbWVudGAgaG9vayBpcyBtZWFudCB0byBiZSB1c2VkIGJ5IHRoZSBob3N0IHRvIHNhdmVcbiAgLy8gb2ZmIHRoZSBlbGVtZW50LiBIb3N0cyBzaG91bGQgdXNlIGBkaWRDcmVhdGVgLCB3aGljaCBydW5zIGFzeW5jaHJvbm91c2x5XG4gIC8vIGFmdGVyIHRoZSByZW5kZXJpbmcgcHJvY2VzcywgdG8gcHJvdmlkZSBob29rcyBmb3IgdXNlciBjb2RlLlxuICBkaWRDcmVhdGVFbGVtZW50KGNvbXBvbmVudDogVCwgZWxlbWVudDogRWxlbWVudCwgb3BlcmF0aW9uczogRWxlbWVudE9wZXJhdGlvbnMpO1xuXG4gIC8vIE9uY2UgdGhlIHdob2xlIHRvcC1kb3duIHJlbmRlcmluZyBwcm9jZXNzIGlzIGNvbXBsZXRlLCBHbGltbWVyIGludm9rZXNcbiAgLy8gdGhlIGBkaWRDcmVhdGVgIGNhbGxiYWNrcy5cbiAgZGlkQ3JlYXRlKGNvbXBvbmVudDogVCk7XG5cbiAgLy8gQ29udmVydCB0aGUgb3BhcXVlIGNvbXBvbmVudCBpbnRvIGEgYFJldmlzaW9uVGFnYCB0aGF0IGRldGVybWlucyB3aGVuXG4gIC8vIHRoZSBjb21wb25lbnQncyB1cGRhdGUgaG9va3MgbmVlZCB0byBiZSBjYWxsZWQsIGluIGFkZGl0aW9uIHRvIGFueVxuICAvLyBvdXRzaWRlIGNoYW5nZXMgY2FwdHVyZWQgaW4gdGhlIGlucHV0IGFyZ3VtZW50cy4gSWYgaXQgcmV0dXJucyBudWxsLFxuICAvLyB0aGUgdXBkYXRlIGhvb2tzIHdpbGwgb25seSBiZSBjYWxsZWQgd2hlbiBvbmUgb3IgbW9yZSBvZiB0aGUgaW5wdXRcbiAgLy8gYXJndW1lbnRzIGhhcyBjaGFuZ2VkLlxuICBnZXRUYWcoY29tcG9uZW50OiBUKTogUmV2aXNpb25UYWc7XG5cbiAgLy8gV2hlbiB0aGUgaW5wdXQgYXJndW1lbnRzIGhhdmUgY2hhbmdlZCwgYW5kIHRvcC1kb3duIHJldmFsaWRhdGlvbiBoYXNcbiAgLy8gYmVndW4sIHRoZSBtYW5hZ2VyJ3MgYHVwZGF0ZWAgaG9vayBpcyBjYWxsZWQuXG4gIHVwZGF0ZShjb21wb25lbnQ6IFQsIGFyZ3M6IEV2YWx1YXRlZEFyZ3MsIGR5bmFtaWNTY29wZTogRHluYW1pY1Njb3BlKTtcblxuICAvLyBGaW5hbGx5LCBvbmNlIHRvcC1kb3duIHJldmFsaWRhdGlvbiBoYXMgY29tcGxldGVkLCBHbGltbWVyIGludm9rZXNcbiAgLy8gdGhlIGBkaWRVcGRhdGVgIGNhbGxiYWNrcyBvbiBjb21wb25lbnRzIHRoYXQgY2hhbmdlZC5cbiAgZGlkVXBkYXRlKGNvbXBvbmVudDogVCk7XG5cbiAgLy8gQ29udmVydCB0aGUgb3BhcXVlIGNvbXBvbmVudCBpbnRvIGFuIG9iamVjdCB0aGF0IGltcGxlbWVudHMgRGVzdHJveWFibGUuXG4gIC8vIElmIGl0IHJldHVybnMgbnVsbCwgdGhlIGNvbXBvbmVudCB3aWxsIG5vdCBiZSBkZXN0cm95ZWQuXG4gIGdldERlc3RydWN0b3IoY29tcG9uZW50OiBUKTogRGVzdHJveWFibGU7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29tcG9uZW50TGF5b3V0QnVpbGRlciB7XG4gIGVudjogRW52aXJvbm1lbnQ7XG4gIHRhZzogQ29tcG9uZW50VGFnQnVpbGRlcjtcbiAgYXR0cnM6IENvbXBvbmVudEF0dHJzQnVpbGRlcjtcblxuICB3cmFwTGF5b3V0KGxheW91dDogTGF5b3V0KTtcbiAgZnJvbUxheW91dChsYXlvdXQ6IExheW91dCk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29tcG9uZW50VGFnQnVpbGRlciB7XG4gIHN0YXRpYyh0YWdOYW1lOiBzdHJpbmcpO1xuICBkeW5hbWljKHRhZ05hbWU6IEZ1bmN0aW9uRXhwcmVzc2lvbjxzdHJpbmc+KTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb21wb25lbnRBdHRyc0J1aWxkZXIge1xuICBzdGF0aWMobmFtZTogc3RyaW5nLCB2YWx1ZTogc3RyaW5nKTtcbiAgZHluYW1pYyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBGdW5jdGlvbkV4cHJlc3Npb248c3RyaW5nPik7XG59XG5cbmNvbnN0IENPTVBPTkVOVF9ERUZJTklUSU9OX0JSQU5EID0gJ0NPTVBPTkVOVCBERUZJTklUSU9OIFtpZD1lNTljNzU0ZS02MWViLTQzOTItOGM0YS0yYzBhYzcyYmZjZDRdJztcblxuZXhwb3J0IGZ1bmN0aW9uIGlzQ29tcG9uZW50RGVmaW5pdGlvbihvYmo6IGFueSk6IG9iaiBpcyBDb21wb25lbnREZWZpbml0aW9uPE9wYXF1ZT4ge1xuICByZXR1cm4gdHlwZW9mIG9iaiA9PT0gJ29iamVjdCcgJiYgb2JqICYmIG9ialtDT01QT05FTlRfREVGSU5JVElPTl9CUkFORF07XG59XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBDb21wb25lbnREZWZpbml0aW9uPFQ+IHtcbiAgcHVibGljIG5hbWU6IHN0cmluZzsgLy8gZm9yIGRlYnVnZ2luZ1xuICBwdWJsaWMgbWFuYWdlcjogQ29tcG9uZW50TWFuYWdlcjxUPjtcbiAgcHVibGljIENvbXBvbmVudENsYXNzOiBDb21wb25lbnRDbGFzcztcblxuICBwcml2YXRlIFsnQ09NUE9ORU5UIERFRklOSVRJT04gW2lkPWU1OWM3NTRlLTYxZWItNDM5Mi04YzRhLTJjMGFjNzJiZmNkNF0nXSA9IHRydWU7XG5cbiAgY29uc3RydWN0b3IobmFtZTogc3RyaW5nLCBtYW5hZ2VyOiBDb21wb25lbnRNYW5hZ2VyPFQ+LCBDb21wb25lbnRDbGFzczogQ29tcG9uZW50Q2xhc3MpIHtcbiAgICB0aGlzLm5hbWUgPSBuYW1lO1xuICAgIHRoaXMubWFuYWdlciA9IG1hbmFnZXI7XG4gICAgdGhpcy5Db21wb25lbnRDbGFzcyA9IENvbXBvbmVudENsYXNzO1xuICB9XG59XG4iXX0= +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/dom/change-lists', ['exports', 'glimmer-runtime/lib/dom/sanitized-values', 'glimmer-runtime/lib/dom/props', 'glimmer-runtime/lib/dom/helper', 'glimmer-runtime/lib/compiled/opcodes/content'], function (exports, _glimmerRuntimeLibDomSanitizedValues, _glimmerRuntimeLibDomProps, _glimmerRuntimeLibDomHelper, _glimmerRuntimeLibCompiledOpcodesContent) { 'use strict'; exports.defaultChangeLists = defaultChangeLists; exports.defaultPropertyChangeLists = defaultPropertyChangeLists; @@ -18990,13 +19498,16 @@ function defaultPropertyChangeLists(tagName, attr) { if (_glimmerRuntimeLibDomSanitizedValues.requiresSanitization(tagName, attr)) { return SafeHrefPropertyChangeList; } - if (isInputValue(tagName, attr)) { + if (isUserInputValue(tagName, attr)) { return InputValuePropertyChangeList; } + if (isOptionSelected(tagName, attr)) { + return OptionSelectedChangeList; + } return PropertyChangeList; } function defaultAttributeChangeLists(tagName, attr) { if (_glimmerRuntimeLibDomSanitizedValues.requiresSanitization(tagName, attr)) { @@ -19024,94 +19535,135 @@ } } ; var PropertyChangeList = { - setAttribute: function (dom, element, attr, value, namespace) { + setAttribute: function (env, element, attr, value, namespace) { if (value !== null) { var normalized = attr.toLowerCase(); - element[normalized] = _glimmerRuntimeLibDomProps.normalizePropertyValue(value); + element[normalized] = _glimmerRuntimeLibDomProps.normalizePropertyValue(value); // TODO: This doesn't work } }, - updateAttribute: function (dom, element, attr, value, namespace) { + updateAttribute: function (env, element, attr, value, namespace) { if (value === null) { var normalized = attr.toLowerCase(); element[normalized] = value; } else { this.setAttribute.apply(this, arguments); } } }; exports.PropertyChangeList = PropertyChangeList; - var AttributeChangeList = { - setAttribute: function (dom, element, attr, value, namespace) { + var AttributeChangeList = new ((function () { + function _class() {} + + _class.prototype.setAttribute = function setAttribute(env, element, attr, value, namespace) { + var dom = env.getAppendOperations(); if (value !== null && value !== undefined) { - if (namespace) { - dom.setAttributeNS(element, namespace, attr, _glimmerRuntimeLibCompiledOpcodesContent.normalizeTextValue(value)); - } else { - dom.setAttribute(element, attr, _glimmerRuntimeLibCompiledOpcodesContent.normalizeTextValue(value)); - } + dom.setAttribute(element, attr, _glimmerRuntimeLibCompiledOpcodesContent.normalizeTextValue(value), namespace); } - }, - updateAttribute: function (dom, element, attr, value, namespace) { + }; + + _class.prototype.updateAttribute = function updateAttribute(env, element, attr, value, namespace) { if (value === null) { if (namespace) { - dom.removeAttributeNS(element, namespace, attr); + env.getDOM().removeAttributeNS(element, namespace, attr); } else { - dom.removeAttribute(element, attr); + env.getDOM().removeAttribute(element, attr); } } else { - this.setAttribute(dom, element, attr, value); + this.setAttribute(env, element, attr, value); } - } - }; + }; + + return _class; + })())(); exports.AttributeChangeList = AttributeChangeList; - function isInputValue(tagName, attribute) { - return tagName === 'INPUT' && attribute === 'value'; + function isUserInputValue(tagName, attribute) { + return (tagName === 'INPUT' || tagName === 'TEXTAREA') && attribute === 'value'; } - var InputValuePropertyChangeList = { - setAttribute: function (dom, element, attr, value) { + var InputValuePropertyChangeList = new ((function () { + function _class2() {} + + _class2.prototype.setAttribute = function setAttribute(env, element, attr, value) { var input = element; + input.value = _glimmerRuntimeLibCompiledOpcodesContent.normalizeTextValue(value); + }; + + _class2.prototype.updateAttribute = function updateAttribute(env, element, attr, value) { + var input = element; var currentValue = input.value; var normalizedValue = _glimmerRuntimeLibCompiledOpcodesContent.normalizeTextValue(value); if (currentValue !== normalizedValue) { input.value = normalizedValue; } - }, - updateAttribute: function (dom, element, attr, value) { - this.setAttribute(dom, element, attr, value); - } - }; + }; + + return _class2; + })())(); exports.InputValuePropertyChangeList = InputValuePropertyChangeList; - var SafeHrefPropertyChangeList = { - setAttribute: function (dom, element, attr, value) { - PropertyChangeList.setAttribute(dom, element, attr, _glimmerRuntimeLibDomSanitizedValues.sanitizeAttributeValue(dom, element, attr, value)); - }, - updateAttribute: function (dom, element, attr, value) { - this.setAttribute(dom, element, attr, value); - } - }; + function isOptionSelected(tagName, attribute) { + return tagName === 'OPTION' && attribute === 'selected'; + } + var OptionSelectedChangeList = new ((function () { + function _class3() {} + + _class3.prototype.setAttribute = function setAttribute(env, element, attr, value) { + if (value !== null && value !== undefined && value !== false) { + env.getAppendOperations().setAttribute(element, 'selected', ''); + } + }; + + _class3.prototype.updateAttribute = function updateAttribute(env, element, attr, value) { + var option = element; + if (value === null || value === undefined || value === false) { + option.selected = false; + } else { + option.selected = true; + } + }; + + return _class3; + })())(); + exports.OptionSelectedChangeList = OptionSelectedChangeList; + var SafeHrefPropertyChangeList = new ((function () { + function _class4() {} + + _class4.prototype.setAttribute = function setAttribute(env, element, attr, value) { + var tree = env.getAppendOperations(); + PropertyChangeList.setAttribute(env, element, attr, _glimmerRuntimeLibDomSanitizedValues.sanitizeAttributeValue(env, element, attr, value)); + }; + + _class4.prototype.updateAttribute = function updateAttribute(env, element, attr, value) { + this.setAttribute(env, element, attr, value); + }; + + return _class4; + })())(); exports.SafeHrefPropertyChangeList = SafeHrefPropertyChangeList; - var SafeHrefAttributeChangeList = { - setAttribute: function (dom, element, attr, value) { - AttributeChangeList.setAttribute(dom, element, attr, _glimmerRuntimeLibDomSanitizedValues.sanitizeAttributeValue(dom, element, attr, value)); - }, - updateAttribute: function (dom, element, attr, value) { - this.setAttribute(dom, element, attr, value); - } - }; + var SafeHrefAttributeChangeList = new ((function () { + function _class5() {} + + _class5.prototype.setAttribute = function setAttribute(env, element, attr, value) { + AttributeChangeList.setAttribute(env, element, attr, _glimmerRuntimeLibDomSanitizedValues.sanitizeAttributeValue(env, element, attr, value)); + }; + + _class5.prototype.updateAttribute = function updateAttribute(env, element, attr, value) { + this.setAttribute(env, element, attr, value); + }; + + return _class5; + })())(); exports.SafeHrefAttributeChangeList = SafeHrefAttributeChangeList; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/dom/change-lists.ts"],"names":[],"mappings":"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","file":"change-lists.js","sourcesContent":["import { Opaque } from 'glimmer-util';\nimport { DOMHelper } from './helper';\nimport {\n  sanitizeAttributeValue,\n  requiresSanitization\n} from './sanitized-values';\nimport { normalizeProperty, normalizePropertyValue } from './props';\nimport { SVG_NAMESPACE } from './helper';\nimport { normalizeTextValue } from '../compiled/opcodes/content';\n\nexport interface IChangeList {\n  setAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque, namespace?: string): void;\n  updateAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque, namespace?: string): void;\n}\n\nexport function defaultChangeLists(element: Element, attr: string, isTrusting: boolean, namespace: string) {\n  let tagName = element.tagName;\n  let isSVG = element.namespaceURI === SVG_NAMESPACE;\n\n  if (isSVG) {\n    return defaultAttributeChangeLists(tagName, attr);\n  }\n\n  let { type } = normalizeProperty(element, attr);\n\n  if (type === 'attr') {\n    return defaultAttributeChangeLists(tagName, attr);\n  } else {\n    return defaultPropertyChangeLists(tagName, attr);\n  }\n}\n\nexport function defaultPropertyChangeLists(tagName: string, attr: string) {\n  if (requiresSanitization(tagName, attr)) {\n    return SafeHrefPropertyChangeList;\n  }\n\n  if (isInputValue(tagName, attr)) {\n    return InputValuePropertyChangeList;\n  }\n\n  return PropertyChangeList;\n}\n\nexport function defaultAttributeChangeLists(tagName: string, attr: string) {\n  if (requiresSanitization(tagName, attr)) {\n    return SafeHrefAttributeChangeList;\n  }\n\n  return AttributeChangeList;\n}\n\nexport function readDOMAttr(element: Element, attr: string) {\n   let isSVG = element.namespaceURI === SVG_NAMESPACE;\n   let { type, normalized } = normalizeProperty(element, attr);\n\n   if (isSVG) {\n     return element.getAttribute(normalized);\n   }\n\n   if (type === 'attr') {\n     return element.getAttribute(normalized);\n   } {\n     return element[normalized];\n   }\n};\n\nexport const PropertyChangeList = {\n  setAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque, namespace?: string) {\n    if (value !== null) {\n      let normalized = attr.toLowerCase();\n      element[normalized] = normalizePropertyValue(value);\n    }\n  },\n\n  updateAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque, namespace?: string) {\n    if (value === null) {\n      let normalized = attr.toLowerCase();\n      element[normalized] = value;\n    } else {\n      this.setAttribute(...arguments);\n    }\n  }\n};\n\nexport const AttributeChangeList = {\n  setAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque, namespace?: string) {\n    if (value !== null && value !== undefined) {\n      if (namespace) {\n        dom.setAttributeNS(element, namespace, attr, normalizeTextValue(value));\n      } else {\n        dom.setAttribute(element, attr, normalizeTextValue(value));\n      }\n    }\n  },\n\n  updateAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque, namespace?: string) {\n    if (value === null) {\n      if (namespace) {\n        dom.removeAttributeNS(element, namespace, attr);\n      } else {\n        dom.removeAttribute(element, attr);\n      }\n    } else {\n      this.setAttribute(dom, element, attr, value);\n    }\n  }\n};\n\nfunction isInputValue(tagName: string, attribute: string) {\n  return tagName === 'INPUT' && attribute === 'value';\n}\n\nexport const InputValuePropertyChangeList = {\n  setAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque) {\n    let input = <HTMLInputElement>element;\n    let currentValue = input.value;\n    let normalizedValue = normalizeTextValue(value);\n    if (currentValue !== normalizedValue) {\n      input.value = normalizedValue;\n    }\n  },\n\n  updateAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque) {\n    this.setAttribute(dom, element, attr, value);\n  }\n};\n\nexport const SafeHrefPropertyChangeList = {\n  setAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque) {\n    PropertyChangeList.setAttribute(dom, element, attr, sanitizeAttributeValue(dom, element, attr, value));\n  },\n\n  updateAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque) {\n    this.setAttribute(dom, element, attr, value);\n  }\n};\n\nexport const SafeHrefAttributeChangeList = {\n  setAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque) {\n    AttributeChangeList.setAttribute(dom, element, attr, sanitizeAttributeValue(dom, element, attr, value));\n  },\n  updateAttribute(dom: DOMHelper, element: Element, attr: string, value: Opaque) {\n    this.setAttribute(dom, element, attr, value);\n  }\n};\n"]} -enifed('glimmer-runtime/lib/dom/helper', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/compat/inner-html-fix', 'glimmer-runtime/lib/compat/svg-inner-html-fix', 'glimmer-runtime/lib/compat/text-node-merging-fix'], function (exports, _glimmerRuntimeLibBounds, _glimmerRuntimeLibCompatInnerHtmlFix, _glimmerRuntimeLibCompatSvgInnerHtmlFix, _glimmerRuntimeLibCompatTextNodeMergingFix) { +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/dom/change-lists.ts"],"names":[],"mappings":"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","file":"change-lists.js","sourcesContent":["import { FIXME, Opaque } from 'glimmer-util';\nimport { DOMNamespace } from './helper';\nimport * as Simple from './interfaces';\nimport {\n  sanitizeAttributeValue,\n  requiresSanitization\n} from './sanitized-values';\nimport { normalizeProperty, normalizePropertyValue } from './props';\nimport { SVG_NAMESPACE } from './helper';\nimport { normalizeTextValue } from '../compiled/opcodes/content';\nimport { Environment } from '../environment';\n\nexport interface IChangeList {\n  setAttribute(env: Environment, element: Simple.Element, attr: string, value: Opaque, namespace?: string): void;\n  updateAttribute(env: Environment, element: Element, attr: string, value: Opaque, namespace?: string): void;\n}\n\nexport function defaultChangeLists(element: Simple.Element, attr: string, isTrusting: boolean, namespace: string) {\n  let tagName = element.tagName;\n  let isSVG = element.namespaceURI === SVG_NAMESPACE;\n\n  if (isSVG) {\n    return defaultAttributeChangeLists(tagName, attr);\n  }\n\n  let { type } = normalizeProperty(element, attr);\n\n  if (type === 'attr') {\n    return defaultAttributeChangeLists(tagName, attr);\n  } else {\n    return defaultPropertyChangeLists(tagName, attr);\n  }\n}\n\nexport function defaultPropertyChangeLists(tagName: string, attr: string) {\n  if (requiresSanitization(tagName, attr)) {\n    return SafeHrefPropertyChangeList;\n  }\n\n  if (isUserInputValue(tagName, attr)) {\n    return InputValuePropertyChangeList;\n  }\n\n  if (isOptionSelected(tagName, attr)) {\n    return OptionSelectedChangeList;\n  }\n\n  return PropertyChangeList;\n}\n\nexport function defaultAttributeChangeLists(tagName: string, attr: string) {\n  if (requiresSanitization(tagName, attr)) {\n    return SafeHrefAttributeChangeList;\n  }\n\n  return AttributeChangeList;\n}\n\nexport function readDOMAttr(element: Element, attr: string) {\n   let isSVG = element.namespaceURI === SVG_NAMESPACE;\n   let { type, normalized } = normalizeProperty(element, attr);\n\n   if (isSVG) {\n     return element.getAttribute(normalized);\n   }\n\n   if (type === 'attr') {\n     return element.getAttribute(normalized);\n   } {\n     return element[normalized];\n   }\n};\n\nexport const PropertyChangeList: IChangeList = {\n  setAttribute(env: Environment, element: Simple.Element, attr: string, value: Opaque, namespace?: DOMNamespace) {\n    if (value !== null) {\n      let normalized = attr.toLowerCase();\n      element[normalized] = normalizePropertyValue(value); // TODO: This doesn't work\n    }\n  },\n\n  updateAttribute(env: Environment, element: Element, attr: string, value: Opaque, namespace?: DOMNamespace) {\n    if (value === null) {\n      let normalized = attr.toLowerCase();\n      element[normalized] = value;\n    } else {\n      this.setAttribute(...arguments);\n    }\n  }\n};\n\nexport const AttributeChangeList: IChangeList = new class {\n  setAttribute(env: Environment, element: Simple.Element, attr: string, value: Opaque, namespace?: DOMNamespace) {\n    let dom = env.getAppendOperations();\n\n    if (value !== null && value !== undefined) {\n      dom.setAttribute(element, attr, normalizeTextValue(value), namespace);\n    }\n  }\n\n  updateAttribute(env: Environment, element: Element, attr: string, value: Opaque, namespace?: DOMNamespace) {\n    if (value === null) {\n      if (namespace) {\n        env.getDOM().removeAttributeNS(element, namespace, attr);\n      } else {\n        env.getDOM().removeAttribute(element, attr);\n      }\n    } else {\n      this.setAttribute(env, element, attr, value);\n    }\n  }\n};\n\nfunction isUserInputValue(tagName: string, attribute: string) {\n  return (tagName === 'INPUT' || tagName === 'TEXTAREA') && attribute === 'value';\n}\n\nexport const InputValuePropertyChangeList: IChangeList = new class {\n  setAttribute(env: Environment, element: Simple.Element, attr: string, value: Opaque) {\n    let input = element as FIXME<HTMLInputElement, \"This breaks SSR\">;\n    input.value = normalizeTextValue(value);\n  }\n\n  updateAttribute(env: Environment, element: Element, attr: string, value: Opaque) {\n    let input = <HTMLInputElement>element;\n    let currentValue = input.value;\n    let normalizedValue = normalizeTextValue(value);\n    if (currentValue !== normalizedValue) {\n      input.value = normalizedValue;\n    }\n  }\n};\n\nfunction isOptionSelected(tagName: string, attribute: string) {\n  return tagName === 'OPTION' && attribute === 'selected';\n}\n\nexport const OptionSelectedChangeList: IChangeList = new class {\n  setAttribute(env: Environment, element: Simple.Element, attr: string, value: Opaque) {\n    if (value !== null && value !== undefined && value !== false) {\n      env.getAppendOperations().setAttribute(element, 'selected', '');\n    }\n  }\n\n  updateAttribute(env: Environment, element: Element, attr: string, value: Opaque) {\n    let option = <HTMLOptionElement>element;\n\n    if (value === null || value === undefined || value === false) {\n      option.selected = false;\n    } else {\n      option.selected = true;\n    }\n  }\n};\n\nexport const SafeHrefPropertyChangeList: IChangeList = new class {\n  setAttribute(env: Environment, element: Simple.Element, attr: string, value: Opaque) {\n    let tree = env.getAppendOperations();\n    PropertyChangeList.setAttribute(env, element, attr, sanitizeAttributeValue(env, element, attr, value));\n  }\n\n  updateAttribute(env: Environment, element: Element, attr: string, value: Opaque) {\n    this.setAttribute(env, element, attr, value);\n  }\n};\n\nexport const SafeHrefAttributeChangeList: IChangeList = new class {\n  setAttribute(env: Environment, element: Element, attr: string, value: Opaque) {\n    AttributeChangeList.setAttribute(env, element, attr, sanitizeAttributeValue(env, element, attr, value));\n  }\n\n  updateAttribute(env: Environment, element: Element, attr: string, value: Opaque) {\n    this.setAttribute(env, element, attr, value);\n  }\n};\n"]} +enifed('glimmer-runtime/lib/dom/helper', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/compat/inner-html-fix', 'glimmer-runtime/lib/compat/svg-inner-html-fix', 'glimmer-runtime/lib/compat/text-node-merging-fix', 'glimmer-runtime/lib/dom/interfaces'], function (exports, _glimmerRuntimeLibBounds, _glimmerRuntimeLibCompatInnerHtmlFix, _glimmerRuntimeLibCompatSvgInnerHtmlFix, _glimmerRuntimeLibCompatTextNodeMergingFix, _glimmerRuntimeLibDomInterfaces) { 'use strict'; exports.isWhitespace = isWhitespace; exports.moveNodesBefore = moveNodesBefore; - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - + exports.insertHTMLBefore = _insertHTMLBefore; var SVG_NAMESPACE = 'http://www.w3.org/2000/svg'; exports.SVG_NAMESPACE = SVG_NAMESPACE; // http://www.w3.org/TR/html/syntax.html#html-integration-point var SVG_INTEGRATION_POINTS = { foreignObject: 1, desc: 1, title: 1 }; // http://www.w3.org/TR/html/syntax.html#adjust-svg-attributes @@ -19123,10 +19675,11 @@ exports.BLACKLIST_TABLE = BLACKLIST_TABLE; ["b", "big", "blockquote", "body", "br", "center", "code", "dd", "div", "dl", "dt", "em", "embed", "h1", "h2", "h3", "h4", "h5", "h6", "head", "hr", "i", "img", "li", "listing", "main", "meta", "nobr", "ol", "p", "pre", "ruby", "s", "small", "span", "strong", "strike", "sub", "sup", "table", "tt", "u", "ul", "var"].forEach(function (tag) { return BLACKLIST_TABLE[tag] = 1; }); var WHITESPACE = /[\t-\r \xA0\u1680\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]/; + var doc = typeof document === 'undefined' ? undefined : document; function isWhitespace(string) { return WHITESPACE.test(string); } @@ -19140,99 +19693,144 @@ target.insertBefore(last, nextSibling); } return [first, last]; } - var DOMHelper = (function () { - function DOMHelper(document) { - _classCallCheck(this, DOMHelper); + var DOM; + (function (DOM) { + var TreeConstruction = (function () { + function TreeConstruction(document) { + this.document = document; + this.uselessElement = null; + this.setupUselessElement(); + } + TreeConstruction.prototype.setupUselessElement = function setupUselessElement() { + this.uselessElement = this.document.createElement('div'); + }; + + TreeConstruction.prototype.createElement = function createElement(tag, context) { + var isElementInSVGNamespace = undefined, + isHTMLIntegrationPoint = undefined; + if (context) { + isElementInSVGNamespace = context.namespaceURI === SVG_NAMESPACE || tag === 'svg'; + isHTMLIntegrationPoint = SVG_INTEGRATION_POINTS[context.tagName]; + } else { + isElementInSVGNamespace = tag === 'svg'; + isHTMLIntegrationPoint = false; + } + if (isElementInSVGNamespace && !isHTMLIntegrationPoint) { + // FIXME: This does not properly handle <font> with color, face, or + // size attributes, which is also disallowed by the spec. We should fix + // this. + if (BLACKLIST_TABLE[tag]) { + throw new Error('Cannot create a ' + tag + ' inside an SVG context'); + } + return this.document.createElementNS(SVG_NAMESPACE, tag); + } else { + return this.document.createElement(tag); + } + }; + + TreeConstruction.prototype.createElementNS = function createElementNS(namespace, tag) { + return this.document.createElementNS(namespace, tag); + }; + + TreeConstruction.prototype.setAttribute = function setAttribute(element, name, value, namespace) { + if (namespace) { + element.setAttributeNS(namespace, name, value); + } else { + element.setAttribute(name, value); + } + }; + + TreeConstruction.prototype.createTextNode = function createTextNode(text) { + return this.document.createTextNode(text); + }; + + TreeConstruction.prototype.createComment = function createComment(data) { + return this.document.createComment(data); + }; + + TreeConstruction.prototype.insertBefore = function insertBefore(parent, node, reference) { + parent.insertBefore(node, reference); + }; + + TreeConstruction.prototype.insertHTMLBefore = function insertHTMLBefore(parent, html, reference) { + return _insertHTMLBefore(this.uselessElement, parent, reference, html); + }; + + return TreeConstruction; + })(); + + var appliedTreeContruction = TreeConstruction; + appliedTreeContruction = _glimmerRuntimeLibCompatTextNodeMergingFix.treeConstruction(doc, appliedTreeContruction); + appliedTreeContruction = _glimmerRuntimeLibCompatInnerHtmlFix.treeConstruction(doc, appliedTreeContruction); + appliedTreeContruction = _glimmerRuntimeLibCompatSvgInnerHtmlFix.treeConstruction(doc, appliedTreeContruction, SVG_NAMESPACE); + DOM.DOMTreeConstruction = appliedTreeContruction; + })(DOM || (DOM = {})); + + var DOMChanges = (function () { + function DOMChanges(document) { this.document = document; + this.uselessElement = null; this.namespace = null; this.uselessElement = this.document.createElement('div'); - this.uselessAnchor = this.document.createElement('a'); } - DOMHelper.prototype.protocolForURL = function protocolForURL(url) { - var uselessAnchor = this.uselessAnchor; - - uselessAnchor.href = url; - return uselessAnchor.protocol; - }; - - DOMHelper.prototype.setAttribute = function setAttribute(element, name, value) { + DOMChanges.prototype.setAttribute = function setAttribute(element, name, value) { element.setAttribute(name, value); }; - DOMHelper.prototype.setAttributeNS = function setAttributeNS(element, namespace, name, value) { + DOMChanges.prototype.setAttributeNS = function setAttributeNS(element, namespace, name, value) { element.setAttributeNS(namespace, name, value); }; - DOMHelper.prototype.removeAttribute = function removeAttribute(element, name) { + DOMChanges.prototype.removeAttribute = function removeAttribute(element, name) { element.removeAttribute(name); }; - DOMHelper.prototype.removeAttributeNS = function removeAttributeNS(element, namespace, name) { + DOMChanges.prototype.removeAttributeNS = function removeAttributeNS(element, namespace, name) { element.removeAttributeNS(namespace, name); }; - DOMHelper.prototype.createTextNode = function createTextNode(text) { + DOMChanges.prototype.createTextNode = function createTextNode(text) { return this.document.createTextNode(text); }; - DOMHelper.prototype.createComment = function createComment(data) { + DOMChanges.prototype.createComment = function createComment(data) { return this.document.createComment(data); }; - DOMHelper.prototype.createElement = function createElement(tag, context) { - var isElementInSVGNamespace = context.namespaceURI === SVG_NAMESPACE || tag === 'svg'; - var isHTMLIntegrationPoint = SVG_INTEGRATION_POINTS[context.tagName]; + DOMChanges.prototype.createElement = function createElement(tag, context) { + var isElementInSVGNamespace = undefined, + isHTMLIntegrationPoint = undefined; + if (context) { + isElementInSVGNamespace = context.namespaceURI === SVG_NAMESPACE || tag === 'svg'; + isHTMLIntegrationPoint = SVG_INTEGRATION_POINTS[context.tagName]; + } else { + isElementInSVGNamespace = tag === 'svg'; + isHTMLIntegrationPoint = false; + } if (isElementInSVGNamespace && !isHTMLIntegrationPoint) { // FIXME: This does not properly handle <font> with color, face, or // size attributes, which is also disallowed by the spec. We should fix // this. if (BLACKLIST_TABLE[tag]) { - throw new Error('Cannot create a ' + tag + ' inside of a <' + context.tagName + '>, because it\'s inside an SVG context'); + throw new Error('Cannot create a ' + tag + ' inside an SVG context'); } return this.document.createElementNS(SVG_NAMESPACE, tag); + } else { + return this.document.createElement(tag); } - return this.document.createElement(tag); }; - DOMHelper.prototype.insertHTMLBefore = function insertHTMLBefore(_parent, nextSibling, html) { - // TypeScript vendored an old version of the DOM spec where `insertAdjacentHTML` - // only exists on `HTMLElement` but not on `Element`. We actually work with the - // newer version of the DOM API here (and monkey-patch this method in `./compat` - // when we detect older browsers). This is a hack to work around this limitation. - var parent = _parent; - var prev = nextSibling ? nextSibling.previousSibling : parent.lastChild; - var last = undefined; - if (html === null || html === '') { - return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, null, null); - } - if (nextSibling === null) { - parent.insertAdjacentHTML('beforeEnd', html); - last = parent.lastChild; - } else if (nextSibling instanceof HTMLElement) { - nextSibling.insertAdjacentHTML('beforeBegin', html); - last = nextSibling.previousSibling; - } else { - // Non-element nodes do not support insertAdjacentHTML, so add an - // element and call it on that element. Then remove the element. - // - // This also protects Edge, IE and Firefox w/o the inspector open - // from merging adjacent text nodes. See ./compat/text-node-merging-fix.ts - parent.insertBefore(this.uselessElement, nextSibling); - this.uselessElement.insertAdjacentHTML('beforeBegin', html); - last = this.uselessElement.previousSibling; - parent.removeChild(this.uselessElement); - } - var first = prev ? prev.nextSibling : parent.firstChild; - return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, first, last); + DOMChanges.prototype.insertHTMLBefore = function insertHTMLBefore(_parent, nextSibling, html) { + return _insertHTMLBefore(this.uselessElement, _parent, nextSibling, html); }; - DOMHelper.prototype.insertNodeBefore = function insertNodeBefore(parent, node, reference) { + DOMChanges.prototype.insertNodeBefore = function insertNodeBefore(parent, node, reference) { if (isDocumentFragment(node)) { var firstChild = node.firstChild; var lastChild = node.lastChild; this.insertBefore(parent, node, reference); @@ -19241,47 +19839,113 @@ this.insertBefore(parent, node, reference); return new _glimmerRuntimeLibBounds.SingleNodeBounds(parent, node); } }; - DOMHelper.prototype.insertTextBefore = function insertTextBefore(parent, nextSibling, text) { + DOMChanges.prototype.insertTextBefore = function insertTextBefore(parent, nextSibling, text) { var textNode = this.createTextNode(text); this.insertBefore(parent, textNode, nextSibling); return textNode; }; - DOMHelper.prototype.insertBefore = function insertBefore(element, node, reference) { + DOMChanges.prototype.insertBefore = function insertBefore(element, node, reference) { element.insertBefore(node, reference); }; - DOMHelper.prototype.insertAfter = function insertAfter(element, node, reference) { + DOMChanges.prototype.insertAfter = function insertAfter(element, node, reference) { this.insertBefore(element, node, reference.nextSibling); }; - return DOMHelper; + return DOMChanges; })(); + exports.DOMChanges = DOMChanges; + + function _insertHTMLBefore(_useless, _parent, _nextSibling, html) { + // TypeScript vendored an old version of the DOM spec where `insertAdjacentHTML` + // only exists on `HTMLElement` but not on `Element`. We actually work with the + // newer version of the DOM API here (and monkey-patch this method in `./compat` + // when we detect older browsers). This is a hack to work around this limitation. + var parent = _parent; + var useless = _useless; + var nextSibling = _nextSibling; + var prev = nextSibling ? nextSibling.previousSibling : parent.lastChild; + var last = undefined; + if (html === null || html === '') { + return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, null, null); + } + if (nextSibling === null) { + parent.insertAdjacentHTML('beforeEnd', html); + last = parent.lastChild; + } else if (nextSibling instanceof HTMLElement) { + nextSibling.insertAdjacentHTML('beforeBegin', html); + last = nextSibling.previousSibling; + } else { + // Non-element nodes do not support insertAdjacentHTML, so add an + // element and call it on that element. Then remove the element. + // + // This also protects Edge, IE and Firefox w/o the inspector open + // from merging adjacent text nodes. See ./compat/text-node-merging-fix.ts + parent.insertBefore(useless, nextSibling); + useless.insertAdjacentHTML('beforeBegin', html); + last = useless.previousSibling; + parent.removeChild(useless); + } + var first = prev ? prev.nextSibling : parent.firstChild; + return new _glimmerRuntimeLibBounds.ConcreteBounds(parent, first, last); + } + function isDocumentFragment(node) { return node.nodeType === Node.DOCUMENT_FRAGMENT_NODE; } - var helper = DOMHelper; - var doc = typeof document === 'undefined' ? undefined : document; - helper = _glimmerRuntimeLibCompatTextNodeMergingFix.default(doc, helper); - helper = _glimmerRuntimeLibCompatInnerHtmlFix.default(doc, helper); - helper = _glimmerRuntimeLibCompatSvgInnerHtmlFix.default(doc, helper, SVG_NAMESPACE); + var helper = DOMChanges; + helper = _glimmerRuntimeLibCompatTextNodeMergingFix.domChanges(doc, helper); + helper = _glimmerRuntimeLibCompatInnerHtmlFix.domChanges(doc, helper); + helper = _glimmerRuntimeLibCompatSvgInnerHtmlFix.domChanges(doc, helper, SVG_NAMESPACE); exports.default = helper; - exports.DOMHelper = DOMHelper; + var DOMTreeConstruction = DOM.DOMTreeConstruction; + exports.DOMTreeConstruction = DOMTreeConstruction; + exports.DOMNamespace = _glimmerRuntimeLibDomInterfaces.Namespace; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/dom/helper.ts"],"names":[],"mappings":"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","file":"helper.js","sourcesContent":["import { ConcreteBounds, SingleNodeBounds, Bounds } from '../bounds';\nimport applyTableElementFix from '../compat/inner-html-fix';\nimport applySVGElementFix from '../compat/svg-inner-html-fix';\nimport applyTextNodeMergingFix from '../compat/text-node-merging-fix';\n\nexport const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\n\n// http://www.w3.org/TR/html/syntax.html#html-integration-point\nconst SVG_INTEGRATION_POINTS = { foreignObject: 1, desc: 1, title: 1 };\n\n// http://www.w3.org/TR/html/syntax.html#adjust-svg-attributes\n// TODO: Adjust SVG attributes\n\n// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign\n// TODO: Adjust SVG elements\n\n// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign\nexport const BLACKLIST_TABLE = Object.create(null);\n\n([\n  \"b\", \"big\", \"blockquote\", \"body\", \"br\", \"center\", \"code\", \"dd\", \"div\", \"dl\", \"dt\", \"em\", \"embed\",\n  \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\", \"hr\", \"i\", \"img\", \"li\", \"listing\", \"main\", \"meta\", \"nobr\",\n  \"ol\", \"p\", \"pre\", \"ruby\", \"s\", \"small\", \"span\", \"strong\", \"strike\", \"sub\", \"sup\", \"table\", \"tt\", \"u\",\n  \"ul\", \"var\"\n]).forEach(tag => BLACKLIST_TABLE[tag] = 1);\n\nconst WHITESPACE = /[\\t-\\r \\xA0\\u1680\\u180E\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]/;\n\nexport function isWhitespace(string: string) {\n  return WHITESPACE.test(string);\n}\n\nexport function moveNodesBefore(source, target, nextSibling) {\n  let first = source.firstChild;\n  let last = null;\n  let current = first;\n  while (current) {\n    last = current;\n    current = current.nextSibling;\n    target.insertBefore(last, nextSibling);\n  }\n  return [first, last];\n}\n\nclass DOMHelper {\n  private document: HTMLDocument;\n  private namespace: string;\n  private uselessElement: HTMLElement;\n  private uselessAnchor: HTMLAnchorElement;\n\n  constructor(document) {\n    this.document = document;\n    this.namespace = null;\n    this.uselessElement = this.document.createElement('div');\n    this.uselessAnchor = this.document.createElement('a');\n  }\n\n  protocolForURL(url: string): string {\n    let { uselessAnchor } = this;\n    uselessAnchor.href = url;\n    return uselessAnchor.protocol;\n  }\n\n  setAttribute(element: Element, name: string, value: string) {\n    element.setAttribute(name, value);\n  }\n\n  setAttributeNS(element: Element, namespace: string, name: string, value: string) {\n    element.setAttributeNS(namespace, name, value);\n  }\n\n  removeAttribute(element: Element, name: string) {\n    element.removeAttribute(name);\n  }\n\n  removeAttributeNS(element: Element, namespace: string, name: string) {\n    element.removeAttributeNS(namespace, name);\n  }\n\n  createTextNode(text: string): Text {\n    return this.document.createTextNode(text);\n  }\n\n  createComment(data: string): Comment {\n    return this.document.createComment(data);\n  }\n\n  createElement(tag: string, context: Element): Element {\n    let isElementInSVGNamespace = context.namespaceURI === SVG_NAMESPACE || tag === 'svg';\n    let isHTMLIntegrationPoint = SVG_INTEGRATION_POINTS[context.tagName];\n\n    if (isElementInSVGNamespace && !isHTMLIntegrationPoint) {\n      // FIXME: This does not properly handle <font> with color, face, or\n      // size attributes, which is also disallowed by the spec. We should fix\n      // this.\n      if (BLACKLIST_TABLE[tag]) {\n        throw new Error(`Cannot create a ${tag} inside of a <${context.tagName}>, because it's inside an SVG context`);\n      }\n\n      return this.document.createElementNS(SVG_NAMESPACE, tag);\n    }\n\n    return this.document.createElement(tag);\n  }\n\n  insertHTMLBefore(_parent: Element, nextSibling: Node, html: string): Bounds {\n    // TypeScript vendored an old version of the DOM spec where `insertAdjacentHTML`\n    // only exists on `HTMLElement` but not on `Element`. We actually work with the\n    // newer version of the DOM API here (and monkey-patch this method in `./compat`\n    // when we detect older browsers). This is a hack to work around this limitation.\n    let parent = _parent as HTMLElement;\n\n    let prev = nextSibling ? nextSibling.previousSibling : parent.lastChild;\n    let last;\n\n    if (html === null || html === '') {\n      return new ConcreteBounds(parent, null, null);\n    }\n\n    if (nextSibling === null) {\n      parent.insertAdjacentHTML('beforeEnd', html);\n      last = parent.lastChild;\n    } else if (nextSibling instanceof HTMLElement) {\n      nextSibling.insertAdjacentHTML('beforeBegin', html);\n      last = nextSibling.previousSibling;\n    } else {\n      // Non-element nodes do not support insertAdjacentHTML, so add an\n      // element and call it on that element. Then remove the element.\n      //\n      // This also protects Edge, IE and Firefox w/o the inspector open\n      // from merging adjacent text nodes. See ./compat/text-node-merging-fix.ts\n      parent.insertBefore(this.uselessElement, nextSibling);\n      this.uselessElement.insertAdjacentHTML('beforeBegin', html);\n      last = this.uselessElement.previousSibling;\n      parent.removeChild(this.uselessElement);\n    }\n\n    let first = prev ? prev.nextSibling : parent.firstChild;\n    return new ConcreteBounds(parent, first, last);\n  }\n\n  insertNodeBefore(parent: Element, node: Node, reference: Node): Bounds {\n    if (isDocumentFragment(node)) {\n      let { firstChild, lastChild } = node;\n      this.insertBefore(parent, node, reference);\n      return new ConcreteBounds(parent, firstChild, lastChild);\n    } else {\n      this.insertBefore(parent, node, reference);\n      return new SingleNodeBounds(parent, node);\n    }\n  }\n\n  insertTextBefore(parent: Element, nextSibling: Node, text: string): Text {\n    let textNode = this.createTextNode(text);\n    this.insertBefore(parent, textNode, nextSibling);\n    return textNode;\n  }\n\n  insertBefore(element: Element, node: Node, reference: Node) {\n    element.insertBefore(node, reference);\n  }\n\n  insertAfter(element: Element, node: Node, reference: Node) {\n    this.insertBefore(element, node, reference.nextSibling);\n  }\n}\n\nfunction isDocumentFragment(node: Node): node is DocumentFragment {\n  return node.nodeType === Node.DOCUMENT_FRAGMENT_NODE;\n}\n\nlet helper = DOMHelper;\nlet doc = typeof document === 'undefined' ? undefined : document;\n\nhelper = applyTextNodeMergingFix(doc, helper);\nhelper = applyTableElementFix(doc, helper);\nhelper = applySVGElementFix(doc, helper, SVG_NAMESPACE);\n\nexport default helper;\nexport { DOMHelper };\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/dom/helper.ts"],"names":[],"mappings":"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","file":"helper.js","sourcesContent":["import { ConcreteBounds, SingleNodeBounds, Bounds } from '../bounds';\nimport {\n  domChanges as domChangesTableElementFix,\n  treeConstruction as treeConstructionTableElementFix\n} from '../compat/inner-html-fix';\nimport {\n  domChanges as domChangesSvgElementFix,\n  treeConstruction as treeConstructionSvgElementFix\n} from '../compat/svg-inner-html-fix';\nimport {\n  domChanges as domChangesNodeMergingFix,\n  treeConstruction as treeConstructionNodeMergingFix\n} from '../compat/text-node-merging-fix';\nimport * as Simple from './interfaces';\n\nexport const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\n\n// http://www.w3.org/TR/html/syntax.html#html-integration-point\nconst SVG_INTEGRATION_POINTS = { foreignObject: 1, desc: 1, title: 1 };\n\n// http://www.w3.org/TR/html/syntax.html#adjust-svg-attributes\n// TODO: Adjust SVG attributes\n\n// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign\n// TODO: Adjust SVG elements\n\n// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign\nexport const BLACKLIST_TABLE = Object.create(null);\n\n([\n  \"b\", \"big\", \"blockquote\", \"body\", \"br\", \"center\", \"code\", \"dd\", \"div\", \"dl\", \"dt\", \"em\", \"embed\",\n  \"h1\", \"h2\", \"h3\", \"h4\", \"h5\", \"h6\", \"head\", \"hr\", \"i\", \"img\", \"li\", \"listing\", \"main\", \"meta\", \"nobr\",\n  \"ol\", \"p\", \"pre\", \"ruby\", \"s\", \"small\", \"span\", \"strong\", \"strike\", \"sub\", \"sup\", \"table\", \"tt\", \"u\",\n  \"ul\", \"var\"\n]).forEach(tag => BLACKLIST_TABLE[tag] = 1);\n\nconst WHITESPACE = /[\\t-\\r \\xA0\\u1680\\u180E\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]/;\n\nlet doc = typeof document === 'undefined' ? undefined : document;\n\nexport function isWhitespace(string: string) {\n  return WHITESPACE.test(string);\n}\n\nexport function moveNodesBefore(source, target, nextSibling) {\n  let first = source.firstChild;\n  let last = null;\n  let current = first;\n  while (current) {\n    last = current;\n    current = current.nextSibling;\n    target.insertBefore(last, nextSibling);\n  }\n  return [first, last];\n}\n\nnamespace DOM {\n  type Node = Simple.Node;\n  type Element = Simple.Element;\n  type Document = Simple.Document;\n  type Comment = Simple.Comment;\n  type Text = Simple.Text;\n  type Namespace = Simple.Namespace;\n  type HTMLElement = Simple.HTMLElement;\n\n  class TreeConstruction {\n    protected uselessElement: HTMLElement = null;\n    constructor(protected document: Document) {\n      this.setupUselessElement();\n    }\n\n    protected setupUselessElement() {\n      this.uselessElement = this.document.createElement('div');\n    }\n\n    createElement(tag: string, context?: Element): Element {\n      let isElementInSVGNamespace, isHTMLIntegrationPoint;\n\n      if (context) {\n        isElementInSVGNamespace = context.namespaceURI === SVG_NAMESPACE || tag === 'svg';\n        isHTMLIntegrationPoint = SVG_INTEGRATION_POINTS[context.tagName];\n      } else {\n        isElementInSVGNamespace = tag === 'svg';\n        isHTMLIntegrationPoint = false;\n      }\n\n      if (isElementInSVGNamespace && !isHTMLIntegrationPoint) {\n        // FIXME: This does not properly handle <font> with color, face, or\n        // size attributes, which is also disallowed by the spec. We should fix\n        // this.\n        if (BLACKLIST_TABLE[tag]) {\n          throw new Error(`Cannot create a ${tag} inside an SVG context`);\n        }\n\n        return this.document.createElementNS(SVG_NAMESPACE as Namespace, tag);\n      } else {\n        return this.document.createElement(tag);\n      }\n    }\n\n    createElementNS(namespace: Namespace, tag: string): Element {\n      return this.document.createElementNS(namespace, tag);\n    }\n\n    setAttribute(element: Element, name: string, value: string, namespace?: string) {\n      if (namespace) {\n        element.setAttributeNS(namespace, name, value);\n      } else {\n        element.setAttribute(name, value);\n      }\n    }\n\n    createTextNode(text: string): Text {\n      return this.document.createTextNode(text);\n    }\n\n    createComment(data: string): Comment {\n      return this.document.createComment(data);\n    }\n\n    insertBefore(parent: Element, node: Node, reference: Node) {\n      parent.insertBefore(node, reference);\n    }\n\n    insertHTMLBefore(parent: Element, html: string, reference: Node): Bounds {\n      return insertHTMLBefore(this.uselessElement, parent, reference, html);\n    };\n  }\n\n  let appliedTreeContruction = TreeConstruction;\n  appliedTreeContruction = treeConstructionNodeMergingFix(doc, appliedTreeContruction);\n  appliedTreeContruction = treeConstructionTableElementFix(doc, appliedTreeContruction);\n  appliedTreeContruction = treeConstructionSvgElementFix(doc, appliedTreeContruction, SVG_NAMESPACE);\n\n  export const DOMTreeConstruction = appliedTreeContruction;\n  export type DOMTreeConstruction = TreeConstruction;\n}\n\nexport class DOMChanges {\n  protected namespace: string;\n  private uselessElement: HTMLElement = null;\n\n  constructor(protected document: HTMLDocument) {\n    this.namespace = null;\n    this.uselessElement = this.document.createElement('div');\n  }\n\n  setAttribute(element: Simple.Element, name: string, value: string) {\n    element.setAttribute(name, value);\n  }\n\n  setAttributeNS(element: Simple.Element, namespace: string, name: string, value: string) {\n    element.setAttributeNS(namespace, name, value);\n  }\n\n  removeAttribute(element: Simple.Element, name: string) {\n    element.removeAttribute(name);\n  }\n\n  removeAttributeNS(element: Simple.Element, namespace: string, name: string) {\n    element.removeAttributeNS(namespace, name);\n  }\n\n  createTextNode(text: string): Simple.Text {\n    return this.document.createTextNode(text);\n  }\n\n  createComment(data: string): Simple.Comment {\n    return this.document.createComment(data);\n  }\n\n  createElement(tag: string, context?: Simple.Element): Simple.Element {\n    let isElementInSVGNamespace, isHTMLIntegrationPoint;\n\n    if (context) {\n      isElementInSVGNamespace = context.namespaceURI === SVG_NAMESPACE || tag === 'svg';\n      isHTMLIntegrationPoint = SVG_INTEGRATION_POINTS[context.tagName];\n    } else {\n      isElementInSVGNamespace = tag === 'svg';\n      isHTMLIntegrationPoint = false;\n    }\n\n    if (isElementInSVGNamespace && !isHTMLIntegrationPoint) {\n      // FIXME: This does not properly handle <font> with color, face, or\n      // size attributes, which is also disallowed by the spec. We should fix\n      // this.\n      if (BLACKLIST_TABLE[tag]) {\n        throw new Error(`Cannot create a ${tag} inside an SVG context`);\n      }\n\n      return this.document.createElementNS(SVG_NAMESPACE as Simple.Namespace, tag);\n    } else {\n      return this.document.createElement(tag);\n    }\n  }\n\n  insertHTMLBefore(_parent: Element, nextSibling: Node, html: string): Bounds {\n    return insertHTMLBefore(this.uselessElement, _parent, nextSibling, html);\n  }\n\n  insertNodeBefore(parent: Simple.Element, node: Simple.Node, reference: Simple.Node): Bounds {\n    if (isDocumentFragment(node)) {\n      let { firstChild, lastChild } = node;\n      this.insertBefore(parent, node, reference);\n      return new ConcreteBounds(parent, firstChild, lastChild);\n    } else {\n      this.insertBefore(parent, node, reference);\n      return new SingleNodeBounds(parent, node);\n    }\n  }\n\n  insertTextBefore(parent: Simple.Element, nextSibling: Simple.Node, text: string): Simple.Text {\n    let textNode = this.createTextNode(text);\n    this.insertBefore(parent, textNode, nextSibling);\n    return textNode;\n  }\n\n  insertBefore(element: Simple.Element, node: Simple.Node, reference: Simple.Node) {\n    element.insertBefore(node, reference);\n  }\n\n  insertAfter(element: Simple.Element, node: Simple.Node, reference: Simple.Node) {\n    this.insertBefore(element, node, reference.nextSibling);\n  }\n}\n\nexport function insertHTMLBefore(this: void, _useless: Simple.HTMLElement, _parent: Simple.Element, _nextSibling: Simple.Node, html: string): Bounds { // tslint:disable-line\n  // TypeScript vendored an old version of the DOM spec where `insertAdjacentHTML`\n  // only exists on `HTMLElement` but not on `Element`. We actually work with the\n  // newer version of the DOM API here (and monkey-patch this method in `./compat`\n  // when we detect older browsers). This is a hack to work around this limitation.\n  let parent = _parent as HTMLElement;\n  let useless = _useless as HTMLElement;\n  let nextSibling = _nextSibling as Node;\n\n  let prev = nextSibling ? nextSibling.previousSibling : parent.lastChild;\n  let last;\n\n  if (html === null || html === '') {\n    return new ConcreteBounds(parent, null, null);\n  }\n\n  if (nextSibling === null) {\n    parent.insertAdjacentHTML('beforeEnd', html);\n    last = parent.lastChild;\n  } else if (nextSibling instanceof HTMLElement) {\n    nextSibling.insertAdjacentHTML('beforeBegin', html);\n    last = nextSibling.previousSibling;\n  } else {\n    // Non-element nodes do not support insertAdjacentHTML, so add an\n    // element and call it on that element. Then remove the element.\n    //\n    // This also protects Edge, IE and Firefox w/o the inspector open\n    // from merging adjacent text nodes. See ./compat/text-node-merging-fix.ts\n    parent.insertBefore(useless, nextSibling);\n    useless.insertAdjacentHTML('beforeBegin', html);\n    last = useless.previousSibling;\n    parent.removeChild(useless);\n  }\n\n  let first = prev ? prev.nextSibling : parent.firstChild;\n  return new ConcreteBounds(parent, first, last);\n}\n\nfunction isDocumentFragment(node: Simple.Node): node is DocumentFragment {\n  return node.nodeType === Node.DOCUMENT_FRAGMENT_NODE;\n}\n\nlet helper = DOMChanges;\n\nhelper = domChangesNodeMergingFix(doc, helper);\nhelper = domChangesTableElementFix(doc, helper);\nhelper = domChangesSvgElementFix(doc, helper, SVG_NAMESPACE);\n\nexport default helper;\nexport const DOMTreeConstruction = DOM.DOMTreeConstruction;\nexport type DOMTreeConstruction = DOM.DOMTreeConstruction;\nexport { Namespace as DOMNamespace } from './interfaces';\n"]} +enifed("glimmer-runtime/lib/dom/interface", ["exports"], function (exports) { + "use strict"; +}); +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvZG9tL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwiZmlsZSI6ImludGVyZmFjZS5qcyIsInNvdXJjZXNDb250ZW50IjpbXX0= +enifed("glimmer-runtime/lib/dom/interfaces", ["exports"], function (exports) { + "use strict"; + + var NodeType; + (function (NodeType) { + NodeType[NodeType["Element"] = 0] = "Element"; + NodeType[NodeType["Attribute"] = 1] = "Attribute"; + NodeType[NodeType["Text"] = 2] = "Text"; + NodeType[NodeType["CdataSection"] = 3] = "CdataSection"; + NodeType[NodeType["EntityReference"] = 4] = "EntityReference"; + NodeType[NodeType["Entity"] = 5] = "Entity"; + NodeType[NodeType["ProcessingInstruction"] = 6] = "ProcessingInstruction"; + NodeType[NodeType["Comment"] = 7] = "Comment"; + NodeType[NodeType["Document"] = 8] = "Document"; + NodeType[NodeType["DocumentType"] = 9] = "DocumentType"; + NodeType[NodeType["DocumentFragment"] = 10] = "DocumentFragment"; + NodeType[NodeType["Notation"] = 11] = "Notation"; + })(NodeType || (NodeType = {})); +}); +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/dom/props', ['exports'], function (exports) { /* * @method normalizeProperty * @param element {HTMLElement} * @param slotName {String} * @returns {Object} { name, type } */ - 'use strict'; + /* + * @method normalizeProperty + * @param element {HTMLElement} + * @param slotName {String} + * @returns {Object} { name, type } + */'use strict'; exports.normalizeProperty = normalizeProperty; exports.normalizePropertyValue = normalizePropertyValue; function normalizeProperty(element, slotName) { @@ -19343,12 +20007,12 @@ function preferAttr(tagName, propName) { var tag = ATTR_OVERRIDES[tagName.toUpperCase()]; return tag && tag[propName.toLowerCase()] || false; } }); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-runtime/lib/dom/sanitized-values', ['exports', 'glimmer-runtime/lib/upsert'], function (exports, _glimmerRuntimeLibUpsert) { +//# sourceMappingURL=data:application/json;base64,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 +enifed('glimmer-runtime/lib/dom/sanitized-values', ['exports', 'glimmer-runtime/lib/compiled/opcodes/content', 'glimmer-runtime/lib/upsert'], function (exports, _glimmerRuntimeLibCompiledOpcodesContent, _glimmerRuntimeLibUpsert) { 'use strict'; exports.requiresSanitization = requiresSanitization; exports.sanitizeAttributeValue = sanitizeAttributeValue; @@ -19370,52 +20034,52 @@ function requiresSanitization(tagName, attribute) { return checkURI(tagName, attribute) || checkDataURI(tagName, attribute); } - function sanitizeAttributeValue(dom, element, attribute, value) { + function sanitizeAttributeValue(env, element, attribute, value) { var tagName = undefined; if (_glimmerRuntimeLibUpsert.isSafeString(value)) { return value.toHTML(); } if (!element) { tagName = null; } else { tagName = element.tagName.toUpperCase(); } + var str = _glimmerRuntimeLibCompiledOpcodesContent.normalizeTextValue(value); if (checkURI(tagName, attribute)) { - var protocol = dom.protocolForURL(value); + var protocol = env.protocolForURL(str); if (has(badProtocols, protocol)) { - return 'unsafe:' + value; + return 'unsafe:' + str; } } if (checkDataURI(tagName, attribute)) { - return 'unsafe:' + value; + return 'unsafe:' + str; } - return value; + return str; } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/environment', ['exports', 'glimmer-runtime/lib/references', 'glimmer-runtime/lib/dom/change-lists', 'glimmer-util', 'glimmer-runtime/lib/syntax/core', 'glimmer-runtime/lib/syntax/builtins/if', 'glimmer-runtime/lib/syntax/builtins/unless', 'glimmer-runtime/lib/syntax/builtins/with', 'glimmer-runtime/lib/syntax/builtins/each', 'glimmer-runtime/lib/syntax/builtins/partial'], function (exports, _glimmerRuntimeLibReferences, _glimmerRuntimeLibDomChangeLists, _glimmerUtil, _glimmerRuntimeLibSyntaxCore, _glimmerRuntimeLibSyntaxBuiltinsIf, _glimmerRuntimeLibSyntaxBuiltinsUnless, _glimmerRuntimeLibSyntaxBuiltinsWith, _glimmerRuntimeLibSyntaxBuiltinsEach, _glimmerRuntimeLibSyntaxBuiltinsPartial) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var Scope = (function () { function Scope(references) { - _classCallCheck(this, Scope); + var callerScope = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1]; this.callerScope = null; this.slots = references; + this.callerScope = callerScope; } Scope.root = function root(self) { var size = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1]; var refs = new Array(size + 1); for (var i = 0; i <= size; i++) { - refs[i] = _glimmerRuntimeLibReferences.NULL_REFERENCE; + refs[i] = _glimmerRuntimeLibReferences.UNDEFINED_REFERENCE; } return new Scope(refs).init({ self: self }); }; Scope.prototype.init = function init(_ref) { @@ -19452,57 +20116,67 @@ Scope.prototype.getCallerScope = function getCallerScope() { return this.callerScope; }; Scope.prototype.child = function child() { - return new Scope(this.slots.slice()); + return new Scope(this.slots.slice(), this.callerScope); }; return Scope; })(); exports.Scope = Scope; var Environment = (function () { - function Environment(dom) { - _classCallCheck(this, Environment); + function Environment(_ref2) { + var appendOperations = _ref2.appendOperations; + var updateOperations = _ref2.updateOperations; + this.scheduledInstallManagers = null; + this.scheduledInstallModifiers = null; + this.scheduledUpdateModifierManagers = null; + this.scheduledUpdateModifiers = null; this.createdComponents = null; this.createdManagers = null; this.updatedComponents = null; this.updatedManagers = null; this.destructors = null; - this.dom = dom; + this.appendOperations = appendOperations; + this.updateOperations = updateOperations; } Environment.prototype.toConditionalReference = function toConditionalReference(reference) { return new _glimmerRuntimeLibReferences.ConditionalReference(reference); }; + Environment.prototype.getAppendOperations = function getAppendOperations() { + return this.appendOperations; + }; + Environment.prototype.getDOM = function getDOM() { - return this.dom; + return this.updateOperations; }; Environment.prototype.getIdentity = function getIdentity(object) { - return _glimmerUtil.intern(_glimmerUtil.ensureGuid(object) + ''); + return _glimmerUtil.ensureGuid(object) + ''; }; - Environment.prototype.statement = function statement(_statement, blockMeta) { - return this.refineStatement(parseStatement(_statement), blockMeta) || _statement; + Environment.prototype.statement = function statement(_statement, symbolTable) { + return this.refineStatement(parseStatement(_statement), symbolTable) || _statement; }; - Environment.prototype.refineStatement = function refineStatement(statement, blockMeta) { + Environment.prototype.refineStatement = function refineStatement(statement, symbolTable) { var isSimple = statement.isSimple; var isBlock = statement.isBlock; var isInline = statement.isInline; var key = statement.key; var args = statement.args; var templates = statement.templates; if (isSimple && isInline) { if (key === 'partial') { - return new _glimmerRuntimeLibSyntaxBuiltinsPartial.default({ args: args }); + return new _glimmerRuntimeLibSyntaxBuiltinsPartial.default({ args: args, symbolTable: symbolTable }); } } if (isSimple && isBlock) { switch (key) { case 'each': @@ -19521,10 +20195,14 @@ this.createdComponents = []; this.createdManagers = []; this.updatedComponents = []; this.updatedManagers = []; this.destructors = []; + this.scheduledInstallManagers = []; + this.scheduledInstallModifiers = []; + this.scheduledUpdateModifierManagers = []; + this.scheduledUpdateModifiers = []; }; Environment.prototype.didCreate = function didCreate(component, manager) { this.createdComponents.push(component); this.createdManagers.push(manager); @@ -19533,35 +20211,60 @@ Environment.prototype.didUpdate = function didUpdate(component, manager) { this.updatedComponents.push(component); this.updatedManagers.push(manager); }; + Environment.prototype.scheduleInstallModifier = function scheduleInstallModifier(modifier, manager) { + this.scheduledInstallManagers.push(manager); + this.scheduledInstallModifiers.push(modifier); + }; + + Environment.prototype.scheduleUpdateModifier = function scheduleUpdateModifier(modifier, manager) { + this.scheduledUpdateModifierManagers.push(manager); + this.scheduledUpdateModifiers.push(modifier); + }; + Environment.prototype.didDestroy = function didDestroy(d) { this.destructors.push(d); }; Environment.prototype.commit = function commit() { for (var i = 0; i < this.createdComponents.length; i++) { var component = this.createdComponents[i]; var manager = this.createdManagers[i]; manager.didCreate(component); } - for (var i = this.updatedComponents.length - 1; i >= 0; i--) { + for (var i = 0; i < this.updatedComponents.length; i++) { var component = this.updatedComponents[i]; var manager = this.updatedManagers[i]; manager.didUpdate(component); } for (var i = 0; i < this.destructors.length; i++) { this.destructors[i].destroy(); } + for (var i = 0; i < this.scheduledInstallManagers.length; i++) { + var manager = this.scheduledInstallManagers[i]; + var modifier = this.scheduledInstallModifiers[i]; + manager.install(modifier); + } + for (var i = 0; i < this.scheduledUpdateModifierManagers.length; i++) { + var manager = this.scheduledUpdateModifierManagers[i]; + var modifier = this.scheduledUpdateModifiers[i]; + manager.update(modifier); + } + this.createdComponents = null; + this.createdManagers = null; + this.updatedComponents = null; + this.updatedManagers = null; + this.destructors = null; + this.scheduledInstallManagers = null; + this.scheduledInstallModifiers = null; + this.scheduledUpdateModifierManagers = null; + this.scheduledUpdateModifiers = null; }; - Environment.prototype.hasKeyword = function hasKeyword(string) { - return false; - }; - - Environment.prototype.attributeFor = function attributeFor(element, attr, reference, isTrusting, namespace) { + Environment.prototype.attributeFor = function attributeFor(element, attr, isTrusting, namespace) { return _glimmerRuntimeLibDomChangeLists.defaultChangeLists(element, attr, isTrusting, namespace); }; return Environment; })(); @@ -19581,15 +20284,15 @@ args = block.args; path = block.path; } else if (append && (appendType === 'unknown' || appendType === 'get')) { var appendValue = append.value; args = _glimmerRuntimeLibSyntaxCore.Args.empty(); - path = appendValue.ref.path(); + path = appendValue.ref.parts; } else if (append && append.value.type === 'helper') { var helper = append.value; args = helper.args; - path = helper.ref.path(); + path = helper.ref.parts; } else if (modifier) { path = modifier.path; args = modifier.args; } var key = undefined, @@ -19610,11 +20313,48 @@ isModifier: !!modifier, templates: block && block.templates }; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/environment.ts"],"names":[],"mappings":";;;;;QA8DA,KAAA;AAeE,iBAfF,KAAA,CAec,UAAuB,EAAA;kCAfrC,KAAA;;AAaU,gBAAA,CAAA,WAAW,GAAU,IAAI,CAAC;AAGhC,gBAAI,CAAC,KAAK,GAAG,UAAU,CAAC;SACzB;;AAjBH,aAAA,CACS,IAAI,GAAA,cAAC,IAA2B,EAAU;gBAAR,IAAI,yDAAG,CAAC;;AAC/C,gBAAI,IAAI,GAA4B,IAAI,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;AAExD,iBAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EAAE;AAC9B,oBAAI,CAAC,CAAC,CAAC,gCA/DJ,cAAc,AA+DO,CAAC;aAC1B;AAED,mBAAO,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAC,CAAC;SACvC;;AATH,aAAA,WAmBE,IAAI,GAAA,cAAC,IAAyC,EAAA;gBAAvC,IAAI,GAAN,IAAyC,CAAvC,IAAI;;AACT,gBAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AACrB,mBAAO,IAAI,CAAC;SACb;;AAtBH,aAAA,WAwBE,OAAO,GAAA,mBAAA;AACL,mBAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAA0B,CAAC;SAC/C;;AA1BH,aAAA,WA4BE,SAAS,GAAA,mBAAC,MAAc,EAAA;AACtB,mBAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAA0B,CAAC;SACpD;;AA9BH,aAAA,WAgCE,QAAQ,GAAA,kBAAC,MAAc,EAAA;AACrB,mBAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAgB,CAAC;SAC1C;;AAlCH,aAAA,WAoCE,UAAU,GAAA,oBAAC,MAAc,EAAE,KAA4B,EAAA;AACrD,gBAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;SAC5B;;AAtCH,aAAA,WAwCE,SAAS,GAAA,mBAAC,MAAc,EAAE,KAAkB,EAAA;AAC1C,gBAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;SAC5B;;AA1CH,aAAA,WA4CE,eAAe,GAAA,yBAAC,KAAY,EAAA;AAC1B,gBAAI,CAAC,WAAW,GAAG,KAAK,CAAC;SAC1B;;AA9CH,aAAA,WAgDE,cAAc,GAAA,0BAAA;AACZ,mBAAO,IAAI,CAAC,WAAW,CAAC;SACzB;;AAlDH,aAAA,WAoDE,KAAK,GAAA,iBAAA;AACH,mBAAO,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;SACtC;;eAtDH,KAAA;;;;;QAyDA,WAAA;AAQE,iBARF,WAAA,CAQc,GAAc,EAAA;kCAR5B,WAAA;;AAEU,gBAAA,CAAA,iBAAiB,GAAgB,IAAI,CAAC;AACtC,gBAAA,CAAA,eAAe,GAAkC,IAAI,CAAC;AACtD,gBAAA,CAAA,iBAAiB,GAAgB,IAAI,CAAC;AACtC,gBAAA,CAAA,eAAe,GAAkC,IAAI,CAAC;AACtD,gBAAA,CAAA,WAAW,GAAkB,IAAI,CAAC;AAGxC,gBAAI,CAAC,GAAG,GAAG,GAAG,CAAC;SAChB;;AAVH,mBAAA,WAYE,sBAAsB,GAAA,gCAAC,SAA4B,EAAA;AACjD,mBAAO,iCAhIc,oBAAoB,CAgIT,SAAS,CAAC,CAAC;SAC5C;;AAdH,mBAAA,WAkBE,MAAM,GAAA,kBAAA;AAAgB,mBAAO,IAAI,CAAC,GAAG,CAAC;SAAE;;AAlB1C,mBAAA,WAoBE,WAAW,GAAA,qBAAC,MAAe,EAAA;AACzB,mBAAO,aA1GT,MAAM,CA0GU,aAzGhB,UAAU,CAyGiB,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC;SACxC;;AAtBH,mBAAA,WAwBE,SAAS,GAAA,mBAAC,UAA0B,EAAE,SAAoB,EAAA;AACxD,mBAAO,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,UAAS,CAAC,EAAE,SAAS,CAAC,IAAI,UAAS,CAAC;SAChF;;AA1BH,mBAAA,WA4BY,eAAe,GAAA,yBAAC,SAA0B,EAAE,SAAoB,EAAA;gBAEtE,QAAQ,GAMN,SAAS,CANX,QAAQ;gBACR,OAAO,GAKL,SAAS,CALX,OAAO;gBACP,QAAQ,GAIN,SAAS,CAJX,QAAQ;gBACR,GAAG,GAGD,SAAS,CAHX,GAAG;gBACH,IAAI,GAEF,SAAS,CAFX,IAAI;gBACJ,SAAS,GACP,SAAS,CADX,SAAS;;AAGX,gBAAI,QAAQ,IAAI,QAAQ,EAAE;AACxB,oBAAI,GAAG,KAAK,SAAS,EAAE;AACrB,2BAAO,oDAAkB,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAC,CAAC;iBACpC;aACF;AAED,gBAAI,QAAQ,IAAI,OAAO,EAAE;AACvB,wBAAQ,GAAG;AACT,yBAAK,MAAM;AACT,+BAAO,iDAAe,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,AAC7C,yBAAK,IAAI;AACP,+BAAO,+CAAa,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,AAC3C,yBAAK,MAAM;AACT,+BAAO,iDAAe,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,AAC7C,yBAAK,QAAQ;AACX,+BAAO,mDAAiB,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,iBAChD;aACF;SACF;;AAxDH,mBAAA,WA0DE,KAAK,GAAA,iBAAA;AACH,gBAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;AAC5B,gBAAI,CAAC,eAAe,GAAG,EAAE,CAAC;AAC1B,gBAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;AAC5B,gBAAI,CAAC,eAAe,GAAG,EAAE,CAAC;AAC1B,gBAAI,CAAC,WAAW,GAAG,EAAE,CAAC;SACvB;;AAhEH,mBAAA,WAkEE,SAAS,GAAA,mBAAI,SAAY,EAAE,OAA4B,EAAA;AACrD,gBAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAgB,CAAC,CAAC;AAC9C,gBAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAc,CAAC,CAAC;SAC3C;;AArEH,mBAAA,WAuEE,SAAS,GAAA,mBAAI,SAAY,EAAE,OAA4B,EAAA;AACrD,gBAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAgB,CAAC,CAAC;AAC9C,gBAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAc,CAAC,CAAC;SAC3C;;AA1EH,mBAAA,WA4EE,UAAU,GAAA,oBAAC,CAAc,EAAA;AACvB,gBAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAC1B;;AA9EH,mBAAA,WAgFE,MAAM,GAAA,kBAAA;AACJ,iBAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAClD,oBAAI,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAC1C,oBAAI,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;AACtC,uBAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;aAC9B;AAED,iBAAK,IAAI,CAAC,GAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,GAAC,CAAC,EAAE,CAAC,IAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACrD,oBAAI,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAC1C,oBAAI,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;AACtC,uBAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;aAC9B;AAED,iBAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAC5C,oBAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;aAC/B;SACF;;AAhGH,mBAAA,WAkGE,UAAU,GAAA,oBAAC,MAAsB,EAAA;AAC/B,mBAAO,KAAK,CAAC;SACd;;AApGH,mBAAA,WAyGE,YAAY,GAAA,sBAAC,OAAgB,EAAE,IAAoB,EAAE,SAA4B,EAAE,UAAmB,EAAE,SAA0B,EAAA;AAChI,mBAAO,iCA3NT,kBAAkB,CA2NU,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;SACjE;;eA3GH,WAAA;;;;sBAsHe,WAAW;;AAsB1B,aAAA,cAAA,CAAwB,SAA0B,EAAA;AAC9C,YAAI,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;AAC1B,YAAI,KAAK,GAAG,IAAI,KAAK,OAAO,GAAiB,SAAS,GAAG,IAAI,CAAC;AAC9D,YAAI,MAAM,GAAG,IAAI,KAAK,kBAAkB,GAA2B,SAAS,GAAG,IAAI,CAAC;AACpF,YAAI,QAAQ,GAAG,IAAI,KAAK,UAAU,GAAoB,SAAS,GAAG,IAAI,CAAC;AACvE,YAAI,UAAU,GAAG,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;AAG7C,YAAI,IAAiB,YAAA,CAAC;AACtB,YAAI,IAAsB,YAAA,CAAC;AAE3B,YAAI,KAAK,EAAE;AACT,gBAAI,GAAG,KAAK,CAAC,IAAI,CAAC;AAClB,gBAAI,GAAG,KAAK,CAAC,IAAI,CAAC;SACnB,MAAM,IAAI,MAAM,KAAK,UAAU,KAAK,SAAS,IAAI,UAAU,KAAK,KAAK,CAAA,AAAC,EAAE;AACvE,gBAAI,WAAW,GAAgB,MAAM,CAAC,KAAK,CAAC;AAC5C,gBAAI,GAAG,6BAAO,IAAI,CAAC,KAAK,EAAE,CAAC;AAC3B,gBAAI,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;SAC/B,MAAM,IAAI,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE;AACnD,gBAAI,MAAM,GAAkB,MAAM,CAAC,KAAK,CAAC;AACzC,gBAAI,GAAG,MAAM,CAAC,IAAI,CAAC;AACnB,gBAAI,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;SAC1B,MAAM,IAAI,QAAQ,EAAE;AACnB,gBAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;AACrB,gBAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;SACtB;AAED,YAAI,GAAmB,YAAA;YAAE,QAAiB,YAAA,CAAC;AAE3C,YAAI,IAAI,EAAE;AACR,oBAAQ,GAAG,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7B,eAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;SACf;AAED,eAAO;AACL,oBAAQ,EAAR,QAAQ;AACR,gBAAI,EAAJ,IAAI;AACJ,eAAG,EAAH,GAAG;AACH,gBAAI,EAAJ,IAAI;AACJ,sBAAU,EAAV,UAAU;AACV,oBAAQ,EAAE,SAAS;AACnB,oBAAQ,EAAE,CAAC,CAAC,MAAM;AAClB,mBAAO,EAAE,CAAC,CAAC,KAAK;AAChB,sBAAU,EAAE,CAAC,CAAC,QAAQ;AACtB,qBAAS,EAAE,KAAK,IAAI,KAAK,CAAC,SAAS;SACpC,CAAC;KACL","file":"environment.js","sourcesContent":["import { Statement as StatementSyntax } from './syntax';\n\nimport { DOMHelper } from './dom/helper';\nimport { Reference, OpaqueIterable } from 'glimmer-reference';\nimport { NULL_REFERENCE, ConditionalReference } from './references';\nimport {\n  defaultChangeLists,\n  IChangeList\n} from './dom/change-lists';\n\nimport {\n  PartialDefinition\n} from './partial';\n\nimport {\n  Component,\n  ComponentManager,\n  ComponentDefinition\n} from './component/interfaces';\n\nimport {\n  ModifierManager\n} from './modifier/interfaces';\n\nimport {\n  PathReference\n} from 'glimmer-reference';\n\nimport {\n  Destroyable,\n  Dict,\n  Opaque,\n  HasGuid,\n  InternedString,\n  intern,\n  ensureGuid\n} from 'glimmer-util';\n\nimport {\n  BlockMeta\n} from 'glimmer-wire-format';\n\nimport { EvaluatedArgs } from './compiled/expressions/args';\n\nimport { InlineBlock } from './compiled/blocks';\n\nimport * as Syntax from './syntax/core';\n\nimport IfSyntax from './syntax/builtins/if';\nimport UnlessSyntax from './syntax/builtins/unless';\nimport WithSyntax from './syntax/builtins/with';\nimport EachSyntax from './syntax/builtins/each';\nimport PartialSyntax from './syntax/builtins/partial';\n\nimport { PublicVM } from './vm/append';\n\ntype ScopeSlot = PathReference<Opaque> | InlineBlock;\n\nexport interface DynamicScope {\n  child(): DynamicScope;\n}\n\nexport class Scope {\n  static root(self: PathReference<Opaque>, size = 0) {\n    let refs: PathReference<Opaque>[] = new Array(size + 1);\n\n    for (let i = 0; i <= size; i++) {\n      refs[i] = NULL_REFERENCE;\n    }\n\n    return new Scope(refs).init({ self });\n  }\n\n  // the 0th slot is `self`\n  private slots: ScopeSlot[];\n  private callerScope: Scope = null;\n\n  constructor(references: ScopeSlot[]) {\n    this.slots = references;\n  }\n\n  init({ self }: { self: PathReference<Opaque> }): this {\n    this.slots[0] = self;\n    return this;\n  }\n\n  getSelf(): PathReference<Opaque> {\n    return this.slots[0] as PathReference<Opaque>;\n  }\n\n  getSymbol(symbol: number): PathReference<Opaque> {\n    return this.slots[symbol] as PathReference<Opaque>;\n  }\n\n  getBlock(symbol: number): InlineBlock {\n    return this.slots[symbol] as InlineBlock;\n  }\n\n  bindSymbol(symbol: number, value: PathReference<Opaque>) {\n    this.slots[symbol] = value;\n  }\n\n  bindBlock(symbol: number, value: InlineBlock) {\n    this.slots[symbol] = value;\n  }\n\n  bindCallerScope(scope: Scope) {\n    this.callerScope = scope;\n  }\n\n  getCallerScope(): Scope {\n    return this.callerScope;\n  }\n\n  child(): Scope {\n    return new Scope(this.slots.slice());\n  }\n}\n\nexport abstract class Environment {\n  protected dom: DOMHelper;\n  private createdComponents: Component[] = null;\n  private createdManagers: ComponentManager<Component>[] = null;\n  private updatedComponents: Component[] = null;\n  private updatedManagers: ComponentManager<Component>[] = null;\n  private destructors: Destroyable[] = null;\n\n  constructor(dom: DOMHelper) {\n    this.dom = dom;\n  }\n\n  toConditionalReference(reference: Reference<Opaque>): Reference<boolean> {\n    return new ConditionalReference(reference);\n  }\n\n  abstract iterableFor(reference: Reference<Opaque>, args: EvaluatedArgs): OpaqueIterable;\n\n  getDOM(): DOMHelper { return this.dom; }\n\n  getIdentity(object: HasGuid): InternedString {\n    return intern(ensureGuid(object) + '');\n  }\n\n  statement(statement: StatementSyntax, blockMeta: BlockMeta): StatementSyntax {\n    return this.refineStatement(parseStatement(statement), blockMeta) || statement;\n  }\n\n  protected refineStatement(statement: ParsedStatement, blockMeta: BlockMeta): StatementSyntax {\n    let {\n      isSimple,\n      isBlock,\n      isInline,\n      key,\n      args,\n      templates\n    } = statement;\n\n    if (isSimple && isInline) {\n      if (key === 'partial') {\n        return new PartialSyntax({ args });\n      }\n    }\n\n    if (isSimple && isBlock) {\n      switch (key) {\n        case 'each':\n          return new EachSyntax({ args, templates });\n        case 'if':\n          return new IfSyntax({ args, templates });\n        case 'with':\n          return new WithSyntax({ args, templates });\n        case 'unless':\n          return new UnlessSyntax({ args, templates });\n      }\n    }\n  }\n\n  begin() {\n    this.createdComponents = [];\n    this.createdManagers = [];\n    this.updatedComponents = [];\n    this.updatedManagers = [];\n    this.destructors = [];\n  }\n\n  didCreate<T>(component: T, manager: ComponentManager<T>) {\n    this.createdComponents.push(component as any);\n    this.createdManagers.push(manager as any);\n  }\n\n  didUpdate<T>(component: T, manager: ComponentManager<T>) {\n    this.updatedComponents.push(component as any);\n    this.updatedManagers.push(manager as any);\n  }\n\n  didDestroy(d: Destroyable) {\n    this.destructors.push(d);\n  }\n\n  commit() {\n    for (let i=0; i<this.createdComponents.length; i++) {\n      let component = this.createdComponents[i];\n      let manager = this.createdManagers[i];\n      manager.didCreate(component);\n    }\n\n    for (let i=this.updatedComponents.length-1; i>=0; i--) {\n      let component = this.updatedComponents[i];\n      let manager = this.updatedManagers[i];\n      manager.didUpdate(component);\n    }\n\n    for (let i=0; i<this.destructors.length; i++) {\n      this.destructors[i].destroy();\n    }\n  }\n\n  hasKeyword(string: InternedString): boolean {\n    return false;\n  }\n\n  abstract hasHelper(helperName: InternedString[], blockMeta: BlockMeta): boolean;\n  abstract lookupHelper(helperName: InternedString[], blockMeta: BlockMeta): Helper;\n\n  attributeFor(element: Element, attr: InternedString, reference: Reference<Opaque>, isTrusting: boolean, namespace?: InternedString): IChangeList {\n    return defaultChangeLists(element, attr, isTrusting, namespace);\n  }\n\n  abstract hasPartial(partialName: InternedString[]): boolean;\n  abstract lookupPartial(PartialName: InternedString[]): PartialDefinition;\n  abstract hasComponentDefinition(tagName: InternedString[]): boolean;\n  abstract getComponentDefinition(tagName: InternedString[]): ComponentDefinition<Opaque>;\n\n  abstract hasModifier(modifierName: InternedString[]): boolean;\n  abstract lookupModifier(modifierName: InternedString[]): ModifierManager<Opaque>;\n}\n\nexport default Environment;\n\ntype PositionalArguments = Opaque[];\ntype KeywordArguments = Dict<Opaque>;\n\nexport interface Helper {\n  (vm: PublicVM, args: EvaluatedArgs): PathReference<Opaque>;\n}\n\nexport interface ParsedStatement {\n  isSimple: boolean;\n  path: InternedString[];\n  key: InternedString;\n  appendType: string;\n  args: Syntax.Args;\n  isInline: boolean;\n  isBlock: boolean;\n  isModifier: boolean;\n  templates: Syntax.Templates;\n  original: StatementSyntax;\n}\n\nfunction parseStatement(statement: StatementSyntax): ParsedStatement {\n    let type = statement.type;\n    let block = type === 'block' ? <Syntax.Block>statement : null;\n    let append = type === 'optimized-append' ? <Syntax.OptimizedAppend>statement : null;\n    let modifier = type === 'modifier' ? <Syntax.Modifier>statement : null;\n    let appendType = append && append.value.type;\n\n    type AppendValue = Syntax.Unknown | Syntax.Get;\n    let args: Syntax.Args;\n    let path: InternedString[];\n\n    if (block) {\n      args = block.args;\n      path = block.path;\n    } else if (append && (appendType === 'unknown' || appendType === 'get')) {\n      let appendValue = <AppendValue>append.value;\n      args = Syntax.Args.empty();\n      path = appendValue.ref.path();\n    } else if (append && append.value.type === 'helper') {\n      let helper = <Syntax.Helper>append.value;\n      args = helper.args;\n      path = helper.ref.path();\n    } else if (modifier) {\n      path = modifier.path;\n      args = modifier.args;\n    }\n\n    let key: InternedString, isSimple: boolean;\n\n    if (path) {\n      isSimple = path.length === 1;\n      key = path[0];\n    }\n\n    return {\n      isSimple,\n      path,\n      key,\n      args,\n      appendType,\n      original: statement,\n      isInline: !!append,\n      isBlock: !!block,\n      isModifier: !!modifier,\n      templates: block && block.templates\n    };\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/environment.ts"],"names":[],"mappings":";;;QA4DM,KAAA;AAeJ,iBAfI,KAAA,CAeQ,UAAuB,EAA2B;gBAAzB,WAAW,yDAAU,IAAI;;AAFtD,gBAAA,CAAA,WAAW,GAAU,IAAI,CAAC;AAGhC,gBAAI,CAAC,KAAK,GAAG,UAAU,CAAC;AACxB,gBAAI,CAAC,WAAW,GAAG,WAAW,CAAC;SAChC;;AAlBG,aAAA,CACG,IAAI,GAAA,cAAC,IAA2B,EAAU;gBAAR,IAAI,yDAAG,CAAC;;AAC/C,gBAAI,IAAI,GAA4B,IAAI,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;AAExD,iBAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EAAE;AAC9B,oBAAI,CAAC,CAAC,CAAC,gCA1DJ,mBAAmB,AA0DO,CAAC;aAC/B;AAED,mBAAO,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAC,CAAC;SACvC;;AATG,aAAA,WAoBJ,IAAI,GAAA,cAAC,IAAyC,EAAA;gBAAvC,IAAI,GAAN,IAAyC,CAAvC,IAAI;;AACT,gBAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AACrB,mBAAO,IAAI,CAAC;SACb;;AAvBG,aAAA,WAyBJ,OAAO,GAAA,mBAAA;AACL,mBAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAA0B,CAAC;SAC/C;;AA3BG,aAAA,WA6BJ,SAAS,GAAA,mBAAC,MAAc,EAAA;AACtB,mBAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAA0B,CAAC;SACpD;;AA/BG,aAAA,WAiCJ,QAAQ,GAAA,kBAAC,MAAc,EAAA;AACrB,mBAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAgB,CAAC;SAC1C;;AAnCG,aAAA,WAqCJ,UAAU,GAAA,oBAAC,MAAc,EAAE,KAA4B,EAAA;AACrD,gBAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;SAC5B;;AAvCG,aAAA,WAyCJ,SAAS,GAAA,mBAAC,MAAc,EAAE,KAAkB,EAAA;AAC1C,gBAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;SAC5B;;AA3CG,aAAA,WA6CJ,eAAe,GAAA,yBAAC,KAAY,EAAA;AAC1B,gBAAI,CAAC,WAAW,GAAG,KAAK,CAAC;SAC1B;;AA/CG,aAAA,WAiDJ,cAAc,GAAA,0BAAA;AACZ,mBAAO,IAAI,CAAC,WAAW,CAAC;SACzB;;AAnDG,aAAA,WAqDJ,KAAK,GAAA,iBAAA;AACH,mBAAO,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SACxD;;eAvDG,KAAA;;;;;QA0DA,WAAA;AAaJ,iBAbI,WAAA,CAaQ,KAA+G,EAAA;gBAA7G,gBAAgB,GAAlB,KAA+G,CAA7G,gBAAgB;gBAAE,gBAAgB,GAApC,KAA+G,CAA3F,gBAAgB;;AAVxC,gBAAA,CAAA,wBAAwB,GAA8B,IAAI,CAAC;AAC3D,gBAAA,CAAA,yBAAyB,GAAa,IAAI,CAAC;AAC3C,gBAAA,CAAA,+BAA+B,GAA8B,IAAI,CAAC;AAClE,gBAAA,CAAA,wBAAwB,GAAa,IAAI,CAAC;AAC1C,gBAAA,CAAA,iBAAiB,GAAgB,IAAI,CAAC;AACtC,gBAAA,CAAA,eAAe,GAAkC,IAAI,CAAC;AACtD,gBAAA,CAAA,iBAAiB,GAAgB,IAAI,CAAC;AACtC,gBAAA,CAAA,eAAe,GAAkC,IAAI,CAAC;AACtD,gBAAA,CAAA,WAAW,GAAkB,IAAI,CAAC;AAGxC,gBAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;AACzC,gBAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;SAC1C;;AAhBG,mBAAA,WAkBJ,sBAAsB,GAAA,gCAAC,SAA4B,EAAA;AACjD,mBAAO,iCAlImB,oBAAoB,CAkId,SAAS,CAAC,CAAC;SAC5C;;AApBG,mBAAA,WAyBJ,mBAAmB,GAAA,+BAAA;AAA0B,mBAAO,IAAI,CAAC,gBAAgB,CAAC;SAAE;;AAzBxE,mBAAA,WA0BJ,MAAM,GAAA,kBAAA;AAAiB,mBAAO,IAAI,CAAC,gBAAgB,CAAC;SAAE;;AA1BlD,mBAAA,WA4BJ,WAAW,GAAA,qBAAC,MAAe,EAAA;AACzB,mBAAO,aApHT,UAAU,CAoHU,MAAM,CAAC,GAAG,EAAE,CAAC;SAChC;;AA9BG,mBAAA,WAgCJ,SAAS,GAAA,mBAAC,UAA0B,EAAE,WAAwB,EAAA;AAC5D,mBAAO,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,UAAS,CAAC,EAAE,WAAW,CAAC,IAAI,UAAS,CAAC;SAClF;;AAlCG,mBAAA,WAoCM,eAAe,GAAA,yBAAC,SAA0B,EAAE,WAAwB,EAAA;gBAE1E,QAAQ,GAMN,SAAS,CANX,QAAQ;gBACR,OAAO,GAKL,SAAS,CALX,OAAO;gBACP,QAAQ,GAIN,SAAS,CAJX,QAAQ;gBACR,GAAG,GAGD,SAAS,CAHX,GAAG;gBACH,IAAI,GAEF,SAAS,CAFX,IAAI;gBACJ,SAAS,GACP,SAAS,CADX,SAAS;;AAGX,gBAAI,QAAQ,IAAI,QAAQ,EAAE;AACxB,oBAAI,GAAG,KAAK,SAAS,EAAE;AACrB,2BAAO,oDAAkB,EAAE,IAAI,EAAJ,IAAI,EAAE,WAAW,EAAX,WAAW,EAAE,CAAC,CAAC;iBACjD;aACF;AAED,gBAAI,QAAQ,IAAI,OAAO,EAAE;AACvB,wBAAQ,GAAG;AACT,yBAAK,MAAM;AACT,+BAAO,iDAAe,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,AAC7C,yBAAK,IAAI;AACP,+BAAO,+CAAa,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,AAC3C,yBAAK,MAAM;AACT,+BAAO,iDAAe,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,AAC7C,yBAAK,QAAQ;AACX,+BAAO,mDAAiB,EAAE,IAAI,EAAJ,IAAI,EAAE,SAAS,EAAT,SAAS,EAAE,CAAC,CAAC;AAAA,iBAChD;aACF;SACF;;AAhEG,mBAAA,WAkEJ,KAAK,GAAA,iBAAA;AACH,gBAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;AAC5B,gBAAI,CAAC,eAAe,GAAG,EAAE,CAAC;AAC1B,gBAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;AAC5B,gBAAI,CAAC,eAAe,GAAG,EAAE,CAAC;AAC1B,gBAAI,CAAC,WAAW,GAAG,EAAE,CAAC;AACtB,gBAAI,CAAC,wBAAwB,GAAG,EAAE,CAAC;AACnC,gBAAI,CAAC,yBAAyB,GAAG,EAAE,CAAC;AACpC,gBAAI,CAAC,+BAA+B,GAAG,EAAE,CAAC;AAC1C,gBAAI,CAAC,wBAAwB,GAAG,EAAE,CAAC;SACpC;;AA5EG,mBAAA,WA8EJ,SAAS,GAAA,mBAAI,SAAY,EAAE,OAA4B,EAAA;AACrD,gBAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAgB,CAAC,CAAC;AAC9C,gBAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAc,CAAC,CAAC;SAC3C;;AAjFG,mBAAA,WAmFJ,SAAS,GAAA,mBAAI,SAAY,EAAE,OAA4B,EAAA;AACrD,gBAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAgB,CAAC,CAAC;AAC9C,gBAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAc,CAAC,CAAC;SAC3C;;AAtFG,mBAAA,WAwFJ,uBAAuB,GAAA,iCAAI,QAAW,EAAE,OAA2B,EAAA;AACjE,gBAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC5C,gBAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SAC/C;;AA3FG,mBAAA,WA6FJ,sBAAsB,GAAA,gCAAI,QAAW,EAAE,OAA2B,EAAA;AAChE,gBAAI,CAAC,+BAA+B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACnD,gBAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SAC9C;;AAhGG,mBAAA,WAkGJ,UAAU,GAAA,oBAAC,CAAc,EAAA;AACvB,gBAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAC1B;;AApGG,mBAAA,WAsGJ,MAAM,GAAA,kBAAA;AACJ,iBAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAClD,oBAAI,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAC1C,oBAAI,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;AACtC,uBAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;aAC9B;AAED,iBAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAClD,oBAAI,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAC1C,oBAAI,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;AACtC,uBAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;aAC9B;AAED,iBAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAC5C,oBAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;aAC/B;AAED,iBAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAC7D,oBAAI,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAC/C,oBAAI,QAAQ,GAAG,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC;AACjD,uBAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;aAC3B;AAED,iBAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,+BAA+B,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACpE,oBAAI,OAAO,GAAG,IAAI,CAAC,+BAA+B,CAAC,CAAC,CAAC,CAAC;AACtD,oBAAI,QAAQ,GAAG,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAChD,uBAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;aAC1B;AAED,gBAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;AAC9B,gBAAI,CAAC,eAAe,GAAG,IAAI,CAAC;AAC5B,gBAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;AAC9B,gBAAI,CAAC,eAAe,GAAG,IAAI,CAAC;AAC5B,gBAAI,CAAC,WAAW,GAAG,IAAI,CAAC;AACxB,gBAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;AACrC,gBAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;AACtC,gBAAI,CAAC,+BAA+B,GAAG,IAAI,CAAC;AAC5C,gBAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;SACtC;;AA5IG,mBAAA,WAiJJ,YAAY,GAAA,sBAAC,OAAuB,EAAE,IAAY,EAAE,UAAmB,EAAE,SAAkB,EAAA;AACzF,mBAAO,iCA/PT,kBAAkB,CA+PU,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;SACjE;;eAnJG,WAAA;;;;sBA8JS,WAAW;;AAmB1B,aAAA,cAAA,CAAwB,SAA0B,EAAA;AAC9C,YAAI,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;AAC1B,YAAI,KAAK,GAAG,IAAI,KAAK,OAAO,GAAiB,SAAS,GAAG,IAAI,CAAC;AAC9D,YAAI,MAAM,GAAG,IAAI,KAAK,kBAAkB,GAA2B,SAAS,GAAG,IAAI,CAAC;AACpF,YAAI,QAAQ,GAAG,IAAI,KAAK,UAAU,GAAoB,SAAS,GAAG,IAAI,CAAC;AACvE,YAAI,UAAU,GAAG,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;AAG7C,YAAI,IAAiB,YAAA,CAAC;AACtB,YAAI,IAAc,YAAA,CAAC;AAEnB,YAAI,KAAK,EAAE;AACT,gBAAI,GAAG,KAAK,CAAC,IAAI,CAAC;AAClB,gBAAI,GAAG,KAAK,CAAC,IAAI,CAAC;SACnB,MAAM,IAAI,MAAM,KAAK,UAAU,KAAK,SAAS,IAAI,UAAU,KAAK,KAAK,CAAA,AAAC,EAAE;AACvE,gBAAI,WAAW,GAAgB,MAAM,CAAC,KAAK,CAAC;AAC5C,gBAAI,GAAG,6BAAO,IAAI,CAAC,KAAK,EAAE,CAAC;AAC3B,gBAAI,GAAG,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC;SAC9B,MAAM,IAAI,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE;AACnD,gBAAI,MAAM,GAAkB,MAAM,CAAC,KAAK,CAAC;AACzC,gBAAI,GAAG,MAAM,CAAC,IAAI,CAAC;AACnB,gBAAI,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;SACzB,MAAM,IAAI,QAAQ,EAAE;AACnB,gBAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;AACrB,gBAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;SACtB;AAED,YAAI,GAAW,YAAA;YAAE,QAAiB,YAAA,CAAC;AAEnC,YAAI,IAAI,EAAE;AACR,oBAAQ,GAAG,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7B,eAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;SACf;AAED,eAAO;AACL,oBAAQ,EAAR,QAAQ;AACR,gBAAI,EAAJ,IAAI;AACJ,eAAG,EAAH,GAAG;AACH,gBAAI,EAAJ,IAAI;AACJ,sBAAU,EAAV,UAAU;AACV,oBAAQ,EAAE,SAAS;AACnB,oBAAQ,EAAE,CAAC,CAAC,MAAM;AAClB,mBAAO,EAAE,CAAC,CAAC,KAAK;AAChB,sBAAU,EAAE,CAAC,CAAC,QAAQ;AACtB,qBAAS,EAAE,KAAK,IAAI,KAAK,CAAC,SAAS;SACpC,CAAC;KACL","file":"environment.js","sourcesContent":["import { Statement as StatementSyntax } from './syntax';\n\nimport SymbolTable from './symbol-table';\n\nimport * as Simple from './dom/interfaces';\nimport { DOMChanges, DOMTreeConstruction } from './dom/helper';\nimport { Reference, PathReference, OpaqueIterable } from 'glimmer-reference';\nimport { UNDEFINED_REFERENCE, ConditionalReference } from './references';\nimport {\n  defaultChangeLists,\n  IChangeList\n} from './dom/change-lists';\n\nimport {\n  PartialDefinition\n} from './partial';\n\nimport {\n  Component,\n  ComponentManager,\n  ComponentDefinition\n} from './component/interfaces';\n\nimport {\n  ModifierManager\n} from './modifier/interfaces';\n\nimport {\n  Destroyable,\n  Opaque,\n  HasGuid,\n  ensureGuid\n} from 'glimmer-util';\n\nimport {\n  TemplateMeta\n} from 'glimmer-wire-format';\n\nimport { EvaluatedArgs } from './compiled/expressions/args';\n\nimport { InlineBlock } from './compiled/blocks';\n\nimport * as Syntax from './syntax/core';\n\nimport IfSyntax from './syntax/builtins/if';\nimport UnlessSyntax from './syntax/builtins/unless';\nimport WithSyntax from './syntax/builtins/with';\nimport EachSyntax from './syntax/builtins/each';\nimport PartialSyntax from './syntax/builtins/partial';\n\nimport { PublicVM } from './vm/append';\n\ntype ScopeSlot = PathReference<Opaque> | InlineBlock;\n\nexport interface DynamicScope {\n  get(key: string): PathReference<Opaque>;\n  set(key: string, reference: PathReference<Opaque>): PathReference<Opaque>;\n  child(): DynamicScope;\n}\n\nexport class Scope {\n  static root(self: PathReference<Opaque>, size = 0) {\n    let refs: PathReference<Opaque>[] = new Array(size + 1);\n\n    for (let i = 0; i <= size; i++) {\n      refs[i] = UNDEFINED_REFERENCE;\n    }\n\n    return new Scope(refs).init({ self });\n  }\n\n  // the 0th slot is `self`\n  private slots: ScopeSlot[];\n  private callerScope: Scope = null;\n\n  constructor(references: ScopeSlot[], callerScope: Scope = null) {\n    this.slots = references;\n    this.callerScope = callerScope;\n  }\n\n  init({ self }: { self: PathReference<Opaque> }): this {\n    this.slots[0] = self;\n    return this;\n  }\n\n  getSelf(): PathReference<Opaque> {\n    return this.slots[0] as PathReference<Opaque>;\n  }\n\n  getSymbol(symbol: number): PathReference<Opaque> {\n    return this.slots[symbol] as PathReference<Opaque>;\n  }\n\n  getBlock(symbol: number): InlineBlock {\n    return this.slots[symbol] as InlineBlock;\n  }\n\n  bindSymbol(symbol: number, value: PathReference<Opaque>) {\n    this.slots[symbol] = value;\n  }\n\n  bindBlock(symbol: number, value: InlineBlock) {\n    this.slots[symbol] = value;\n  }\n\n  bindCallerScope(scope: Scope) {\n    this.callerScope = scope;\n  }\n\n  getCallerScope(): Scope {\n    return this.callerScope;\n  }\n\n  child(): Scope {\n    return new Scope(this.slots.slice(), this.callerScope);\n  }\n}\n\nexport abstract class Environment {\n  protected updateOperations: DOMChanges;\n  protected appendOperations: DOMTreeConstruction;\n  private scheduledInstallManagers: ModifierManager<Opaque>[] = null;\n  private scheduledInstallModifiers: Object[] = null;\n  private scheduledUpdateModifierManagers: ModifierManager<Opaque>[] = null;\n  private scheduledUpdateModifiers: Object[] = null;\n  private createdComponents: Component[] = null;\n  private createdManagers: ComponentManager<Component>[] = null;\n  private updatedComponents: Component[] = null;\n  private updatedManagers: ComponentManager<Component>[] = null;\n  private destructors: Destroyable[] = null;\n\n  constructor({ appendOperations, updateOperations }: { appendOperations: DOMTreeConstruction, updateOperations: DOMChanges }) {\n    this.appendOperations = appendOperations;\n    this.updateOperations = updateOperations;\n  }\n\n  toConditionalReference(reference: Reference<Opaque>): Reference<boolean> {\n    return new ConditionalReference(reference);\n  }\n\n  abstract iterableFor(reference: Reference<Opaque>, args: EvaluatedArgs): OpaqueIterable;\n  abstract protocolForURL(s: string): string;\n\n  getAppendOperations(): DOMTreeConstruction { return this.appendOperations; }\n  getDOM(): DOMChanges { return this.updateOperations; }\n\n  getIdentity(object: HasGuid): string {\n    return ensureGuid(object) + '';\n  }\n\n  statement(statement: StatementSyntax, symbolTable: SymbolTable): StatementSyntax {\n    return this.refineStatement(parseStatement(statement), symbolTable) || statement;\n  }\n\n  protected refineStatement(statement: ParsedStatement, symbolTable: SymbolTable): StatementSyntax {\n    let {\n      isSimple,\n      isBlock,\n      isInline,\n      key,\n      args,\n      templates\n    } = statement;\n\n    if (isSimple && isInline) {\n      if (key === 'partial') {\n        return new PartialSyntax({ args, symbolTable });\n      }\n    }\n\n    if (isSimple && isBlock) {\n      switch (key) {\n        case 'each':\n          return new EachSyntax({ args, templates });\n        case 'if':\n          return new IfSyntax({ args, templates });\n        case 'with':\n          return new WithSyntax({ args, templates });\n        case 'unless':\n          return new UnlessSyntax({ args, templates });\n      }\n    }\n  }\n\n  begin() {\n    this.createdComponents = [];\n    this.createdManagers = [];\n    this.updatedComponents = [];\n    this.updatedManagers = [];\n    this.destructors = [];\n    this.scheduledInstallManagers = [];\n    this.scheduledInstallModifiers = [];\n    this.scheduledUpdateModifierManagers = [];\n    this.scheduledUpdateModifiers = [];\n  }\n\n  didCreate<T>(component: T, manager: ComponentManager<T>) {\n    this.createdComponents.push(component as any);\n    this.createdManagers.push(manager as any);\n  }\n\n  didUpdate<T>(component: T, manager: ComponentManager<T>) {\n    this.updatedComponents.push(component as any);\n    this.updatedManagers.push(manager as any);\n  }\n\n  scheduleInstallModifier<T>(modifier: T, manager: ModifierManager<T>) {\n    this.scheduledInstallManagers.push(manager);\n    this.scheduledInstallModifiers.push(modifier);\n  }\n\n  scheduleUpdateModifier<T>(modifier: T, manager: ModifierManager<T>) {\n    this.scheduledUpdateModifierManagers.push(manager);\n    this.scheduledUpdateModifiers.push(modifier);\n  }\n\n  didDestroy(d: Destroyable) {\n    this.destructors.push(d);\n  }\n\n  commit() {\n    for (let i=0; i<this.createdComponents.length; i++) {\n      let component = this.createdComponents[i];\n      let manager = this.createdManagers[i];\n      manager.didCreate(component);\n    }\n\n    for (let i=0; i<this.updatedComponents.length; i++) {\n      let component = this.updatedComponents[i];\n      let manager = this.updatedManagers[i];\n      manager.didUpdate(component);\n    }\n\n    for (let i=0; i<this.destructors.length; i++) {\n      this.destructors[i].destroy();\n    }\n\n    for (let i = 0; i < this.scheduledInstallManagers.length; i++) {\n      let manager = this.scheduledInstallManagers[i];\n      let modifier = this.scheduledInstallModifiers[i];\n      manager.install(modifier);\n    }\n\n    for (let i = 0; i < this.scheduledUpdateModifierManagers.length; i++) {\n      let manager = this.scheduledUpdateModifierManagers[i];\n      let modifier = this.scheduledUpdateModifiers[i];\n      manager.update(modifier);\n    }\n\n    this.createdComponents = null;\n    this.createdManagers = null;\n    this.updatedComponents = null;\n    this.updatedManagers = null;\n    this.destructors = null;\n    this.scheduledInstallManagers = null;\n    this.scheduledInstallModifiers = null;\n    this.scheduledUpdateModifierManagers = null;\n    this.scheduledUpdateModifiers = null;\n  }\n\n  abstract hasHelper(helperName: string[], blockMeta: TemplateMeta): boolean;\n  abstract lookupHelper(helperName: string[], blockMeta: TemplateMeta): Helper;\n\n  attributeFor(element: Simple.Element, attr: string, isTrusting: boolean, namespace?: string): IChangeList {\n    return defaultChangeLists(element, attr, isTrusting, namespace);\n  }\n\n  abstract hasPartial(partialName: string[], symbolTable: SymbolTable): boolean;\n  abstract lookupPartial(PartialName: string[], symbolTable: SymbolTable): PartialDefinition<TemplateMeta>;\n  abstract hasComponentDefinition(tagName: string[], symbolTable: SymbolTable): boolean;\n  abstract getComponentDefinition(tagName: string[], symbolTable: SymbolTable): ComponentDefinition<Opaque>;\n\n  abstract hasModifier(modifierName: string[], blockMeta: TemplateMeta): boolean;\n  abstract lookupModifier(modifierName: string[], blockMeta: TemplateMeta): ModifierManager<Opaque>;\n}\n\nexport default Environment;\n\nexport interface Helper {\n  (vm: PublicVM, args: EvaluatedArgs, symbolTable: SymbolTable): PathReference<Opaque>;\n}\n\nexport interface ParsedStatement {\n  isSimple: boolean;\n  path: string[];\n  key: string;\n  appendType: string;\n  args: Syntax.Args;\n  isInline: boolean;\n  isBlock: boolean;\n  isModifier: boolean;\n  templates: Syntax.Templates;\n  original: StatementSyntax;\n}\n\nfunction parseStatement(statement: StatementSyntax): ParsedStatement {\n    let type = statement.type;\n    let block = type === 'block' ? <Syntax.Block>statement : null;\n    let append = type === 'optimized-append' ? <Syntax.OptimizedAppend>statement : null;\n    let modifier = type === 'modifier' ? <Syntax.Modifier>statement : null;\n    let appendType = append && append.value.type;\n\n    type AppendValue = Syntax.Unknown | Syntax.Get;\n    let args: Syntax.Args;\n    let path: string[];\n\n    if (block) {\n      args = block.args;\n      path = block.path;\n    } else if (append && (appendType === 'unknown' || appendType === 'get')) {\n      let appendValue = <AppendValue>append.value;\n      args = Syntax.Args.empty();\n      path = appendValue.ref.parts;\n    } else if (append && append.value.type === 'helper') {\n      let helper = <Syntax.Helper>append.value;\n      args = helper.args;\n      path = helper.ref.parts;\n    } else if (modifier) {\n      path = modifier.path;\n      args = modifier.args;\n    }\n\n    let key: string, isSimple: boolean;\n\n    if (path) {\n      isSimple = path.length === 1;\n      key = path[0];\n    }\n\n    return {\n      isSimple,\n      path,\n      key,\n      args,\n      appendType,\n      original: statement,\n      isInline: !!append,\n      isBlock: !!block,\n      isModifier: !!modifier,\n      templates: block && block.templates\n    };\n}\n"]} +enifed('glimmer-runtime/lib/helpers/get-dynamic-var', ['exports', 'glimmer-reference'], function (exports, _glimmerReference) { + 'use strict'; + + var DynamicVarReference = (function () { + function DynamicVarReference(scope, nameRef) { + this.scope = scope; + this.nameRef = nameRef; + var varTag = this.varTag = new _glimmerReference.UpdatableTag(_glimmerReference.CONSTANT_TAG); + this.tag = _glimmerReference.combine([nameRef.tag, varTag]); + } + + DynamicVarReference.prototype.value = function value() { + return this.getVar().value(); + }; + + DynamicVarReference.prototype.get = function get(key) { + return this.getVar().get(key); + }; + + DynamicVarReference.prototype.getVar = function getVar() { + var name = String(this.nameRef.value()); + var ref = this.scope.get(name); + this.varTag.update(ref.tag); + return ref; + }; + + return DynamicVarReference; + })(); + + function getDynamicVar(vm, args, symbolTable) { + var scope = vm.dynamicScope(); + var nameRef = args.positional.at(0); + return new DynamicVarReference(scope, nameRef); + } + exports.default = getDynamicVar; +}); +//# sourceMappingURL=data:application/json;base64,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 enifed("glimmer-runtime/lib/modifier/interfaces", ["exports"], function (exports) { "use strict"; }); //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvbW9kaWZpZXIvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwiZmlsZSI6ImludGVyZmFjZXMuanMiLCJzb3VyY2VzQ29udGVudCI6W119 enifed("glimmer-runtime/lib/opcode-builder", ["exports"], function (exports) { @@ -19624,20 +20364,12 @@ enifed('glimmer-runtime/lib/opcodes', ['exports', 'glimmer-util'], function (exports, _glimmerUtil) { 'use strict'; exports.inspect = inspect; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var AbstractOpcode = (function () { function AbstractOpcode() { - _classCallCheck(this, AbstractOpcode); - _glimmerUtil.initializeGuid(this); } AbstractOpcode.prototype.toJSON = function toJSON() { return { guid: this._guid, type: this.type }; @@ -19647,40 +20379,28 @@ })(); exports.AbstractOpcode = AbstractOpcode; var Opcode = (function (_AbstractOpcode) { - _inherits(Opcode, _AbstractOpcode); + babelHelpers.inherits(Opcode, _AbstractOpcode); function Opcode() { - _classCallCheck(this, Opcode); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _AbstractOpcode.call.apply(_AbstractOpcode, [this].concat(args)); + _AbstractOpcode.apply(this, arguments); this.next = null; this.prev = null; } return Opcode; })(AbstractOpcode); exports.Opcode = Opcode; var UpdatingOpcode = (function (_AbstractOpcode2) { - _inherits(UpdatingOpcode, _AbstractOpcode2); + babelHelpers.inherits(UpdatingOpcode, _AbstractOpcode2); function UpdatingOpcode() { - _classCallCheck(this, UpdatingOpcode); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _AbstractOpcode2.call.apply(_AbstractOpcode2, [this].concat(args)); + _AbstractOpcode2.apply(this, arguments); this.next = null; this.prev = null; } return UpdatingOpcode; @@ -19707,16 +20427,16 @@ buffer.push('('); if (opcode.args) { buffer.push(opcode.args.join(', ')); } if (opcode.details) { - var _keys = Object.keys(opcode.details); - if (_keys.length) { + var keys = Object.keys(opcode.details); + if (keys.length) { if (opcode.args && opcode.args.length) { buffer.push(', '); } - buffer.push(_keys.map(function (key) { + buffer.push(keys.map(function (key) { return key + '=' + opcode.details[key]; }).join(', ')); } } buffer.push(')'); @@ -19727,41 +20447,29 @@ _inspect(opcode.children[i], buffer, level + 1, i); } } } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/opcodes.ts"],"names":[],"mappings":"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","file":"opcodes.js","sourcesContent":["import { Dict, LinkedList, LinkedListNode, Slice, initializeGuid } from 'glimmer-util';\nimport { RevisionTag } from 'glimmer-reference';\nimport { VM, UpdatingVM } from './vm';\n\nexport interface OpcodeJSON {\n  guid: number;\n  type: string;\n  deopted?: boolean;\n  args?: string[];\n  details?: Dict<string>;\n  children?: OpcodeJSON[];\n}\n\nexport abstract class AbstractOpcode implements LinkedListNode {\n  public type: string;\n  public _guid: number;\n\n  prev: AbstractOpcode;\n  next: AbstractOpcode;\n\n  constructor() {\n    initializeGuid(this);\n  }\n\n  toJSON(): OpcodeJSON {\n    return { guid: this._guid, type: this.type };\n  }\n}\n\nexport abstract class Opcode extends AbstractOpcode {\n  next: Opcode = null;\n  prev: Opcode = null;\n\n  abstract evaluate(vm: VM);\n}\n\nexport type OpSeq = Slice<Opcode>;\nexport type OpSeqBuilder = LinkedList<Opcode>;\n\nexport abstract class UpdatingOpcode extends AbstractOpcode {\n  public tag: RevisionTag;\n\n  next: UpdatingOpcode = null;\n  prev: UpdatingOpcode = null;\n\n  abstract evaluate(vm: UpdatingVM);\n}\n\nexport type UpdatingOpSeq = Slice<UpdatingOpcode>;\n\ninterface OpcodeFactory<T extends Opcode> {\n  new(options: T): T;\n}\n\nexport function inspect(opcodes: LinkedList<AbstractOpcode>): string {\n  let buffer = [];\n\n  opcodes.toArray().forEach((opcode, i) => {\n    _inspect(opcode.toJSON(), buffer, 0, i);\n  });\n\n  return buffer.join('');\n}\n\nfunction _inspect(opcode: OpcodeJSON, buffer: string[], level: number, index: number) {\n  let indentation = [];\n\n  for (let i=0; i<level; i++) {\n    indentation.push('  ');\n  }\n\n  buffer.push(...indentation);\n  buffer.push(`${index+1}. ${opcode.type.toUpperCase()}`);\n\n  if (opcode.args || opcode.details) {\n    buffer.push('(');\n\n    if (opcode.args) {\n      buffer.push(opcode.args.join(', '));\n    }\n\n    if (opcode.details) {\n      let keys = Object.keys(opcode.details);\n\n      if (keys.length) {\n        if (opcode.args && opcode.args.length) {\n          buffer.push(', ');\n        }\n\n        buffer.push(keys.map(key => `${key}=${opcode.details[key]}`).join(', '));\n      }\n    }\n\n    buffer.push(')');\n  }\n\n  buffer.push('\\n');\n\n  if (opcode.children && opcode.children.length) {\n    for (let i=0; i<opcode.children.length; i++) {\n      _inspect(opcode.children[i], buffer, level+1, i);\n    }\n  }\n}\n","import { initializeGuid } from 'glimmer-util';\nexport class AbstractOpcode {\n    constructor() {\n        initializeGuid(this);\n    }\n    toJSON() {\n        return { guid: this._guid, type: this.type };\n    }\n}\nexport class Opcode extends AbstractOpcode {\n    constructor() {\n        super(...arguments);\n        this.next = null;\n        this.prev = null;\n    }\n}\nexport class UpdatingOpcode extends AbstractOpcode {\n    constructor() {\n        super(...arguments);\n        this.next = null;\n        this.prev = null;\n    }\n}\nexport function inspect(opcodes) {\n    let buffer = [];\n    opcodes.toArray().forEach((opcode, i) => {\n        _inspect(opcode.toJSON(), buffer, 0, i);\n    });\n    return buffer.join('');\n}\nfunction _inspect(opcode, buffer, level, index) {\n    let indentation = [];\n    for (let i = 0; i < level; i++) {\n        indentation.push('  ');\n    }\n    buffer.push(...indentation);\n    buffer.push(`${index + 1}. ${opcode.type.toUpperCase()}`);\n    if (opcode.args || opcode.details) {\n        buffer.push('(');\n        if (opcode.args) {\n            buffer.push(opcode.args.join(', '));\n        }\n        if (opcode.details) {\n            let keys = Object.keys(opcode.details);\n            if (keys.length) {\n                if (opcode.args && opcode.args.length) {\n                    buffer.push(', ');\n                }\n                buffer.push(keys.map(key => `${key}=${opcode.details[key]}`).join(', '));\n            }\n        }\n        buffer.push(')');\n    }\n    buffer.push('\\n');\n    if (opcode.children && opcode.children.length) {\n        for (let i = 0; i < opcode.children.length; i++) {\n            _inspect(opcode.children[i], buffer, level + 1, i);\n        }\n    }\n}\n"]} enifed("glimmer-runtime/lib/partial", ["exports"], function (exports) { "use strict"; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var PartialDefinition = function PartialDefinition(name, template) { - _classCallCheck(this, PartialDefinition); - this.name = name; this.template = template; }; exports.PartialDefinition = PartialDefinition; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvcGFydGlhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztRQUVBLGlCQUFBLEdBSUUsU0FKRixpQkFBQSxDQUljLElBQVksRUFBRSxRQUE0QixFQUFBOzhCQUp4RCxpQkFBQTs7QUFLSSxZQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztBQUNqQixZQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztLQUMxQiIsImZpbGUiOiJwYXJ0aWFsLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VyaWFsaXplZFRlbXBsYXRlIH0gZnJvbSAnZ2xpbW1lci13aXJlLWZvcm1hdCc7XG5cbmV4cG9ydCBjbGFzcyBQYXJ0aWFsRGVmaW5pdGlvbiB7XG4gIG5hbWU6IHN0cmluZztcbiAgdGVtcGxhdGU6IFNlcmlhbGl6ZWRUZW1wbGF0ZTtcblxuICBjb25zdHJ1Y3RvcihuYW1lOiBzdHJpbmcsIHRlbXBsYXRlOiBTZXJpYWxpemVkVGVtcGxhdGUpIHtcbiAgICB0aGlzLm5hbWUgPSBuYW1lO1xuICAgIHRoaXMudGVtcGxhdGUgPSB0ZW1wbGF0ZTtcbiAgfVxuXG59XG4iXX0= +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvcGFydGlhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7UUFFTSxpQkFBQSxHQUlKLFNBSkksaUJBQUEsQ0FJUSxJQUFZLEVBQUUsUUFBcUIsRUFBQTtBQUM3QyxZQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztBQUNqQixZQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztLQUMxQiIsImZpbGUiOiJwYXJ0aWFsLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGVtcGxhdGUgfSBmcm9tICcuL3RlbXBsYXRlJztcblxuZXhwb3J0IGNsYXNzIFBhcnRpYWxEZWZpbml0aW9uPFQ+IHtcbiAgbmFtZTogc3RyaW5nO1xuICB0ZW1wbGF0ZTogVGVtcGxhdGU8VD47XG5cbiAgY29uc3RydWN0b3IobmFtZTogc3RyaW5nLCB0ZW1wbGF0ZTogVGVtcGxhdGU8VD4pIHtcbiAgICB0aGlzLm5hbWUgPSBuYW1lO1xuICAgIHRoaXMudGVtcGxhdGUgPSB0ZW1wbGF0ZTtcbiAgfVxufVxuIl19 enifed('glimmer-runtime/lib/references', ['exports', 'glimmer-reference'], function (exports, _glimmerReference) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var PrimitiveReference = (function (_ConstReference) { - _inherits(PrimitiveReference, _ConstReference); + babelHelpers.inherits(PrimitiveReference, _ConstReference); function PrimitiveReference() { - _classCallCheck(this, PrimitiveReference); - _ConstReference.apply(this, arguments); } PrimitiveReference.prototype.get = function get() { return UNDEFINED_REFERENCE; @@ -19772,12 +20480,10 @@ exports.PrimitiveReference = PrimitiveReference; var ConditionalReference = (function () { function ConditionalReference(inner) { - _classCallCheck(this, ConditionalReference); - this.inner = inner; this.tag = inner.tag; } ConditionalReference.prototype.value = function value() { @@ -19795,132 +20501,101 @@ var NULL_REFERENCE = new PrimitiveReference(null); exports.NULL_REFERENCE = NULL_REFERENCE; var UNDEFINED_REFERENCE = new PrimitiveReference(undefined); exports.UNDEFINED_REFERENCE = UNDEFINED_REFERENCE; }); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-runtime/lib/scanner', ['exports', 'glimmer-runtime/lib/syntax/statements', 'glimmer-runtime/lib/compiled/blocks', 'glimmer-util'], function (exports, _glimmerRuntimeLibSyntaxStatements, _glimmerRuntimeLibCompiledBlocks, _glimmerUtil) { +//# sourceMappingURL=data:application/json;base64,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 +enifed('glimmer-runtime/lib/scanner', ['exports', 'glimmer-runtime/lib/syntax/statements', 'glimmer-runtime/lib/compiled/blocks', 'glimmer-util', 'glimmer-runtime/lib/symbol-table'], function (exports, _glimmerRuntimeLibSyntaxStatements, _glimmerRuntimeLibCompiledBlocks, _glimmerUtil, _glimmerRuntimeLibSymbolTable) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var Scanner = (function () { - function Scanner(spec, env) { - _classCallCheck(this, Scanner); - - this.spec = spec; + function Scanner(block, meta, env) { + this.block = block; + this.meta = meta; this.env = env; } Scanner.prototype.scanEntryPoint = function scanEntryPoint() { - var _this = this; + var block = this.block; + var meta = this.meta; - return this.scanTop(function (_ref) { - var program = _ref.program; - var children = _ref.children; - var meta = _this.spec.meta; - - return _glimmerRuntimeLibCompiledBlocks.EntryPoint.create({ children: children, program: program, symbolTable: null, meta: meta }); - }); + var symbolTable = _glimmerRuntimeLibSymbolTable.default.forEntryPoint(meta); + var program = buildStatements(block, block.blocks, symbolTable, this.env); + return new _glimmerRuntimeLibCompiledBlocks.EntryPoint(program, symbolTable); }; Scanner.prototype.scanLayout = function scanLayout() { - var _this2 = this; + var block = this.block; + var meta = this.meta; + var blocks = block.blocks; + var named = block.named; + var yields = block.yields; - return this.scanTop(function (_ref2) { - var program = _ref2.program; - var children = _ref2.children; - var _spec = _this2.spec; - var named = _spec.named; - var yields = _spec.yields; - var meta = _spec.meta; - - return _glimmerRuntimeLibCompiledBlocks.Layout.create({ children: children, program: program, named: named, yields: yields, symbolTable: null, meta: meta }); - }); + var symbolTable = _glimmerRuntimeLibSymbolTable.default.forLayout(named, yields, meta); + var program = buildStatements(block, blocks, symbolTable, this.env); + return new _glimmerRuntimeLibCompiledBlocks.Layout(program, symbolTable, named, yields); }; Scanner.prototype.scanPartial = function scanPartial(symbolTable) { - var _this3 = this; + var block = this.block; + var blocks = block.blocks; + var locals = block.locals; - return this.scanTop(function (_ref3) { - var program = _ref3.program; - var children = _ref3.children; - var _spec2 = _this3.spec; - var locals = _spec2.locals; - var meta = _spec2.meta; - - return new _glimmerRuntimeLibCompiledBlocks.PartialBlock({ children: children, program: program, locals: locals, symbolTable: symbolTable, meta: meta }); - }); + var program = buildStatements(block, blocks, symbolTable, this.env); + return new _glimmerRuntimeLibCompiledBlocks.PartialBlock(program, symbolTable, locals); }; - Scanner.prototype.scanTop = function scanTop(makeTop) { - var spec = this.spec; - var specBlocks = spec.blocks; - var meta = spec.meta; - - var blocks = []; - for (var i = 0, block = undefined; block = specBlocks[i]; i++) { - blocks.push(this.buildBlock(block, blocks, meta)); - } - return makeTop(this.buildStatements(spec, blocks)).initBlocks(); - }; - - Scanner.prototype.buildBlock = function buildBlock(block, blocks, meta) { - var _buildStatements = this.buildStatements(block, blocks); - - var program = _buildStatements.program; - var children = _buildStatements.children; - - return new _glimmerRuntimeLibCompiledBlocks.InlineBlock({ children: children, locals: block.locals, program: program, symbolTable: null, meta: meta }); - }; - - Scanner.prototype.buildStatements = function buildStatements(_ref4, blocks) { - var statements = _ref4.statements; - - if (statements.length === 0) return EMPTY_PROGRAM; - return new BlockScanner(statements, blocks, this.env).scan(); - }; - return Scanner; })(); exports.default = Scanner; - var EMPTY_PROGRAM = { - program: _glimmerUtil.EMPTY_SLICE, - children: [] - }; + function buildStatements(_ref, blocks, symbolTable, env) { + var statements = _ref.statements; - var BlockScanner = (function () { - function BlockScanner(statements, blocks, env) { - _classCallCheck(this, BlockScanner); + if (statements.length === 0) return EMPTY_PROGRAM; + return new BlockScanner(statements, blocks, symbolTable, env).scan(); + } + var EMPTY_PROGRAM = _glimmerUtil.EMPTY_SLICE; + var BlockScanner = (function () { + function BlockScanner(statements, blocks, symbolTable, env) { + this.blocks = blocks; + this.symbolTable = symbolTable; this.stack = new _glimmerUtil.Stack(); - this.stack.push(new ChildBlockScanner()); - this.reader = new SyntaxReader(statements, blocks); + this.stack.push(new ChildBlockScanner(symbolTable)); + this.reader = new SyntaxReader(statements, symbolTable, this); this.env = env; } BlockScanner.prototype.scan = function scan() { var statement = undefined; while (statement = this.reader.next()) { this.addStatement(statement); } - return { program: this.stack.current.program, children: this.stack.current.children }; + return this.stack.current.program; }; - BlockScanner.prototype.startBlock = function startBlock() { - this.stack.push(new ChildBlockScanner()); + BlockScanner.prototype.blockFor = function blockFor(symbolTable, id) { + var block = this.blocks[id]; + var childTable = _glimmerRuntimeLibSymbolTable.default.forBlock(this.symbolTable, block.locals); + var program = buildStatements(block, this.blocks, childTable, this.env); + return new _glimmerRuntimeLibCompiledBlocks.InlineBlock(program, childTable, block.locals); }; - BlockScanner.prototype.endBlock = function endBlock() { + BlockScanner.prototype.startBlock = function startBlock(locals) { + var childTable = _glimmerRuntimeLibSymbolTable.default.forBlock(this.symbolTable, locals); + this.stack.push(new ChildBlockScanner(childTable)); + }; + + BlockScanner.prototype.endBlock = function endBlock(locals) { var _stack$pop = this.stack.pop(); - var children = _stack$pop.children; var program = _stack$pop.program; + var symbolTable = _stack$pop.symbolTable; - var block = new _glimmerRuntimeLibCompiledBlocks.InlineBlock({ children: children, program: program, symbolTable: null, meta: null, locals: [] }); + var block = new _glimmerRuntimeLibCompiledBlocks.InlineBlock(program, symbolTable, locals); this.addChild(block); return block; }; BlockScanner.prototype.addChild = function addChild(block) { @@ -19933,23 +20608,18 @@ BlockScanner.prototype.next = function next() { return this.reader.next(); }; - BlockScanner.prototype.unput = function unput(statement) { - this.reader.unput(statement); - }; - return BlockScanner; })(); exports.BlockScanner = BlockScanner; var ChildBlockScanner = (function () { - function ChildBlockScanner() { - _classCallCheck(this, ChildBlockScanner); - + function ChildBlockScanner(symbolTable) { + this.symbolTable = symbolTable; this.children = []; this.program = new _glimmerUtil.LinkedList(); } ChildBlockScanner.prototype.addChild = function addChild(block) { @@ -19962,89 +20632,74 @@ return ChildBlockScanner; })(); var SyntaxReader = (function () { - function SyntaxReader(statements, blocks) { - _classCallCheck(this, SyntaxReader); - + function SyntaxReader(statements, symbolTable, scanner) { + this.statements = statements; + this.symbolTable = symbolTable; + this.scanner = scanner; this.current = 0; this.last = null; - this.statements = statements; - this.blocks = blocks; } - SyntaxReader.prototype.unput = function unput(statement) { - this.last = statement; - }; - SyntaxReader.prototype.next = function next() { var last = this.last; if (last) { this.last = null; return last; } else if (this.current === this.statements.length) { return null; } var sexp = this.statements[this.current++]; - return _glimmerRuntimeLibSyntaxStatements.default(sexp, this.blocks); + return _glimmerRuntimeLibSyntaxStatements.default(sexp, this.symbolTable, this.scanner); }; return SyntaxReader; })(); exports.SyntaxReader = SyntaxReader; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/scanner.ts"],"names":[],"mappings":"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","file":"scanner.js","sourcesContent":["import { Program, Statement as StatementSyntax } from './syntax';\nimport buildStatement from './syntax/statements';\nimport { TopLevelTemplate, EntryPoint, InlineBlock, PartialBlock, Layout } from './compiled/blocks';\nimport Environment from './environment';\nimport { EMPTY_SLICE, LinkedList, Stack } from 'glimmer-util';\nimport { SerializedTemplate, SerializedBlock, Statement as SerializedStatement, BlockMeta } from 'glimmer-wire-format';\nimport SymbolTable from './symbol-table';\n\nexport default class Scanner {\n  private spec: SerializedTemplate;\n  private env: Environment;\n\n  constructor(spec: SerializedTemplate, env: Environment) {\n    this.spec = spec;\n    this.env = env;\n  }\n\n  scanEntryPoint(): EntryPoint {\n    return this.scanTop<EntryPoint>(({ program, children }) => {\n      let { meta } = this.spec;\n      return EntryPoint.create({ children, program, symbolTable: null, meta });\n    });\n  }\n\n  scanLayout(): Layout {\n    return this.scanTop<Layout>(({ program, children }) => {\n      let { named, yields, meta } = this.spec;\n      return Layout.create({ children, program, named, yields, symbolTable: null, meta });\n    });\n  }\n\n  scanPartial(symbolTable: SymbolTable): PartialBlock {\n    return this.scanTop<PartialBlock>(({ program, children }) => {\n      let { locals, meta } = this.spec;\n      return new PartialBlock({ children, program, locals, symbolTable, meta });\n    });\n  }\n\n  private scanTop<T extends TopLevelTemplate>(makeTop: (options: { program: Program, children: InlineBlock[] }) => T): T {\n    let { spec } = this;\n    let { blocks: specBlocks, meta } = spec;\n\n    let blocks: InlineBlock[] = [];\n\n    for (let i = 0, block: SerializedBlock; block = specBlocks[i]; i++) {\n      blocks.push(this.buildBlock(block, blocks, meta));\n    }\n\n    return makeTop(this.buildStatements(spec, blocks)).initBlocks();\n  }\n\n  private buildBlock(block: SerializedBlock, blocks: InlineBlock[], meta: BlockMeta): InlineBlock{\n    let { program, children } = this.buildStatements(block, blocks);\n    return new InlineBlock({ children, locals: block.locals, program, symbolTable: null, meta });\n  }\n\n  private buildStatements({ statements }: SerializedBlock, blocks: InlineBlock[]): ScanResults {\n    if (statements.length === 0) return EMPTY_PROGRAM;\n    return new BlockScanner(statements, blocks, this.env).scan();\n  }\n}\n\ninterface ScanResults {\n  program: Program;\n  children: InlineBlock[];\n}\n\nconst EMPTY_PROGRAM = {\n  program: EMPTY_SLICE,\n  children: []\n};\n\nexport class BlockScanner {\n  public env: Environment;\n\n  private stack = new Stack<ChildBlockScanner>();\n  private reader: SyntaxReader;\n\n  constructor(statements: SerializedStatement[], blocks: InlineBlock[], env: Environment) {\n    this.stack.push(new ChildBlockScanner());\n    this.reader = new SyntaxReader(statements, blocks);\n    this.env = env;\n  }\n\n  scan(): ScanResults {\n    let statement: StatementSyntax;\n\n    while (statement = this.reader.next()) {\n      this.addStatement(statement);\n    }\n\n    return { program: this.stack.current.program, children: this.stack.current.children };\n  }\n\n  startBlock() {\n    this.stack.push(new ChildBlockScanner());\n  }\n\n  endBlock(): InlineBlock {\n    let { children, program } = this.stack.pop();\n    let block = new InlineBlock({ children, program, symbolTable: null, meta: null, locals: [] });\n    this.addChild(block);\n    return block;\n  }\n\n  addChild(block: InlineBlock) {\n    this.stack.current.addChild(block);\n  }\n\n  addStatement(statement: StatementSyntax) {\n    this.stack.current.addStatement(statement.scan(this));\n  }\n\n  next(): StatementSyntax {\n    return this.reader.next();\n  }\n\n  unput(statement: StatementSyntax) {\n    this.reader.unput(statement);\n  }\n}\n\nclass ChildBlockScanner {\n  public children: InlineBlock[] = [];\n  public program = new LinkedList<StatementSyntax>();\n\n  addChild(block: InlineBlock) {\n    this.children.push(block);\n  }\n\n  addStatement(statement: StatementSyntax) {\n    this.program.append(statement);\n  }\n}\n\nexport class SyntaxReader {\n  statements: SerializedStatement[];\n  current: number = 0;\n  blocks: InlineBlock[];\n  last: StatementSyntax = null;\n\n  constructor(statements: SerializedStatement[], blocks: InlineBlock[]) {\n    this.statements = statements;\n    this.blocks = blocks;\n  }\n\n  unput(statement: StatementSyntax) {\n    this.last = statement;\n  }\n\n  next(): StatementSyntax {\n    let last = this.last;\n    if (last) {\n      this.last = null;\n      return last;\n    } else if (this.current === this.statements.length) {\n      return null;\n    }\n\n    let sexp = this.statements[this.current++];\n    return buildStatement(sexp, this.blocks);\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/scanner.ts"],"names":[],"mappings":"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","file":"scanner.js","sourcesContent":["import { Program, Statement as StatementSyntax } from './syntax';\nimport buildStatement from './syntax/statements';\nimport { EntryPoint, InlineBlock, PartialBlock, Layout } from './compiled/blocks';\nimport Environment from './environment';\nimport { EMPTY_SLICE, LinkedList, Stack } from 'glimmer-util';\nimport { SerializedTemplateBlock, TemplateMeta, SerializedBlock, Statement as SerializedStatement } from 'glimmer-wire-format';\nimport SymbolTable from './symbol-table';\n\nexport default class Scanner {\n  constructor(private block: SerializedTemplateBlock, private meta: TemplateMeta, private env: Environment) {\n  }\n\n  scanEntryPoint(): EntryPoint {\n    let { block, meta } = this;\n\n    let symbolTable = SymbolTable.forEntryPoint(meta);\n    let program = buildStatements(block, block.blocks, symbolTable, this.env);\n    return new EntryPoint(program, symbolTable);\n  }\n\n  scanLayout(): Layout {\n    let { block, meta } = this;\n    let { blocks, named, yields } = block;\n\n    let symbolTable = SymbolTable.forLayout(named, yields, meta);\n    let program = buildStatements(block, blocks, symbolTable, this.env);\n\n    return new Layout(program, symbolTable, named, yields);\n  }\n\n  scanPartial(symbolTable: SymbolTable): PartialBlock {\n    let { block } = this;\n    let { blocks, locals } = block;\n\n    let program = buildStatements(block, blocks, symbolTable, this.env);\n\n    return new PartialBlock(program, symbolTable, locals);\n  }\n}\n\nfunction buildStatements({ statements }: SerializedBlock, blocks: SerializedBlock[], symbolTable: SymbolTable, env: Environment): Program {\n  if (statements.length === 0) return EMPTY_PROGRAM;\n  return new BlockScanner(statements, blocks, symbolTable, env).scan();\n}\n\nconst EMPTY_PROGRAM = EMPTY_SLICE;\n\nexport class BlockScanner {\n  public env: Environment;\n\n  private stack = new Stack<ChildBlockScanner>();\n  private reader: SyntaxReader;\n\n  constructor(statements: SerializedStatement[], private blocks: SerializedBlock[], private symbolTable: SymbolTable, env: Environment) {\n    this.stack.push(new ChildBlockScanner(symbolTable));\n    this.reader = new SyntaxReader(statements, symbolTable, this);\n    this.env = env;\n  }\n\n  scan(): Program {\n    let statement: StatementSyntax;\n\n    while (statement = this.reader.next()) {\n      this.addStatement(statement);\n    }\n\n    return this.stack.current.program;\n  }\n\n  blockFor(symbolTable: SymbolTable, id: number): InlineBlock {\n    let block = this.blocks[id];\n    let childTable = SymbolTable.forBlock(this.symbolTable, block.locals);\n    let program = buildStatements(block, this.blocks, childTable, this.env);\n    return new InlineBlock(program, childTable, block.locals);\n  }\n\n  startBlock(locals: string[]) {\n    let childTable = SymbolTable.forBlock(this.symbolTable, locals);\n    this.stack.push(new ChildBlockScanner(childTable));\n  }\n\n  endBlock(locals: string[]): InlineBlock {\n    let { program, symbolTable } = this.stack.pop();\n    let block = new InlineBlock(program, symbolTable, locals);\n    this.addChild(block);\n    return block;\n  }\n\n  addChild(block: InlineBlock) {\n    this.stack.current.addChild(block);\n  }\n\n  addStatement(statement: StatementSyntax) {\n    this.stack.current.addStatement(statement.scan(this));\n  }\n\n  next(): StatementSyntax {\n    return this.reader.next();\n  }\n}\n\nclass ChildBlockScanner {\n  public children: InlineBlock[] = [];\n  public program = new LinkedList<StatementSyntax>();\n\n  constructor(public symbolTable: SymbolTable) {}\n\n  addChild(block: InlineBlock) {\n    this.children.push(block);\n  }\n\n  addStatement(statement: StatementSyntax) {\n    this.program.append(statement);\n  }\n}\n\nexport class SyntaxReader {\n  current: number = 0;\n  last: StatementSyntax = null;\n\n  constructor(private statements: SerializedStatement[], private symbolTable: SymbolTable, private scanner: BlockScanner) {}\n\n  next(): StatementSyntax {\n    let last = this.last;\n    if (last) {\n      this.last = null;\n      return last;\n    } else if (this.current === this.statements.length) {\n      return null;\n    }\n\n    let sexp = this.statements[this.current++];\n    return buildStatement(sexp, this.symbolTable, this.scanner);\n  }\n}\n"]} enifed('glimmer-runtime/lib/symbol-table', ['exports', 'glimmer-util'], function (exports, _glimmerUtil) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var SymbolTable = (function () { - function SymbolTable(parent, template) { - _classCallCheck(this, SymbolTable); + function SymbolTable(parent) { + var meta = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1]; + this.parent = parent; + this.meta = meta; this.locals = _glimmerUtil.dict(); this.named = _glimmerUtil.dict(); this.yields = _glimmerUtil.dict(); this.size = 1; - this.parent = parent; this.top = parent ? parent.top : this; - this.template = template; } - SymbolTable.initForEntryPoint = function initForEntryPoint(top) { - return top.symbolTable = new SymbolTable(null, top).initEntryPoint(top); + SymbolTable.forEntryPoint = function forEntryPoint(meta) { + return new SymbolTable(null, meta).initEntryPoint(); }; - SymbolTable.initForLayout = function initForLayout(layout) { - return layout.symbolTable = new SymbolTable(null, layout).initLayout(layout); + SymbolTable.forLayout = function forLayout(named, yields, meta) { + return new SymbolTable(null, meta).initLayout(named, yields); }; - SymbolTable.initForBlock = function initForBlock(_ref) { - var parent = _ref.parent; - var block = _ref.block; - - return block.symbolTable = new SymbolTable(parent, block).initBlock(block); + SymbolTable.forBlock = function forBlock(parent, locals) { + return new SymbolTable(parent, null).initBlock(locals); }; - SymbolTable.prototype.initEntryPoint = function initEntryPoint(_) { + SymbolTable.prototype.initEntryPoint = function initEntryPoint() { return this; }; - SymbolTable.prototype.initBlock = function initBlock(_ref2) { - var locals = _ref2.locals; - + SymbolTable.prototype.initBlock = function initBlock(locals) { this.initPositionals(locals); return this; }; - SymbolTable.prototype.initLayout = function initLayout(_ref3) { - var named = _ref3.named; - var yields = _ref3.yields; - + SymbolTable.prototype.initLayout = function initLayout(named, yields) { this.initNamed(named); this.initYields(yields); return this; }; @@ -20073,10 +20728,20 @@ return _this3.yields[b] = _this3.top.size++; }); return this; }; + SymbolTable.prototype.getMeta = function getMeta() { + var meta = this.meta; + var parent = this.parent; + + if (!meta && parent) { + meta = parent.getMeta(); + } + return meta; + }; + SymbolTable.prototype.getYield = function getYield(name) { var yields = this.yields; var parent = this.parent; var symbol = yields[name]; @@ -20115,31 +20780,23 @@ return SymbolTable; })(); exports.default = SymbolTable; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed("glimmer-runtime/lib/syntax", ["exports"], function (exports) { "use strict"; exports.isAttribute = isAttribute; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var Statement = (function () { function Statement() { - _classCallCheck(this, Statement); - this.next = null; this.prev = null; } - Statement.fromSpec = function fromSpec(spec, blocks) { + Statement.fromSpec = function fromSpec(spec, symbolTable, scanner) { throw new Error("You need to implement fromSpec on " + this); }; Statement.prototype.clone = function clone() { // not type safe but the alternative is extreme boilerplate per @@ -20155,13 +20812,11 @@ })(); exports.Statement = Statement; var Expression = (function () { - function Expression() { - _classCallCheck(this, Expression); - } + function Expression() {} Expression.fromSpec = function fromSpec(spec, blocks) { throw new Error("You need to implement fromSpec on " + this); }; @@ -20173,39 +20828,27 @@ exports.ATTRIBUTE = ATTRIBUTE; var ARGUMENT = "0f3802314-d747-bbc5-0168-97875185c3rt"; exports.ARGUMENT = ARGUMENT; var Attribute = (function (_Statement) { - _inherits(Attribute, _Statement); + babelHelpers.inherits(Attribute, _Statement); function Attribute() { - _classCallCheck(this, Attribute); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _Statement.call.apply(_Statement, [this].concat(args)); + _Statement.apply(this, arguments); this["e1185d30-7cac-4b12-b26a-35327d905d92"] = true; } return Attribute; })(Statement); exports.Attribute = Attribute; var Argument = (function (_Statement2) { - _inherits(Argument, _Statement2); + babelHelpers.inherits(Argument, _Statement2); function Argument() { - _classCallCheck(this, Argument); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _Statement2.call.apply(_Statement2, [this].concat(args)); + _Statement2.apply(this, arguments); this["0f3802314-d747-bbc5-0168-97875185c3rt"] = true; } return Argument; })(Statement); @@ -20214,29 +20857,21 @@ function isAttribute(value) { return value && value[ATTRIBUTE] === true; } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/syntax/builtins/each', ['exports', 'glimmer-runtime/lib/syntax'], function (exports, _glimmerRuntimeLibSyntax) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var EachSyntax = (function (_StatementSyntax) { - _inherits(EachSyntax, _StatementSyntax); + babelHelpers.inherits(EachSyntax, _StatementSyntax); function EachSyntax(_ref) { var args = _ref.args; var templates = _ref.templates; - _classCallCheck(this, EachSyntax); - _StatementSyntax.call(this); this.type = "each-statement"; this.isStatic = false; this.args = args; this.templates = templates; @@ -20292,29 +20927,21 @@ return EachSyntax; })(_glimmerRuntimeLibSyntax.Statement); exports.default = EachSyntax; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvc3ludGF4L2J1aWx0aW5zL2VhY2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O1FBVUEsVUFBQTtrQkFBQSxVQUFBOztBQU9FLGlCQVBGLFVBQUEsQ0FPYyxJQUF1RSxFQUFBO2dCQUFyRSxJQUFJLEdBQU4sSUFBdUUsQ0FBckUsSUFBSTtnQkFBRSxTQUFTLEdBQWpCLElBQXVFLENBQS9ELFNBQVM7O2tDQVAvQixVQUFBOztBQVFJLHVDQUFPLENBQUM7QUFQVixnQkFBQSxDQUFBLElBQUksR0FBRyxnQkFBZ0IsQ0FBQztBQUlqQixnQkFBQSxDQUFBLFFBQVEsR0FBRyxLQUFLLENBQUM7QUFJdEIsZ0JBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0FBQ2pCLGdCQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztTQUM1Qjs7QUFYSCxrQkFBQSxXQWFFLE9BQU8sR0FBQSxpQkFBQyxHQUFxQixFQUFFLEdBQWdCLEVBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztnQkF5QnZDLElBQUksR0FBZ0IsSUFBSSxDQUF4QixJQUFJO2dCQUFFLFNBQVMsR0FBSyxJQUFJLENBQWxCLFNBQVM7O0FBRXJCLGVBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQVQsU0FBUyxFQUFFLElBQUksRUFBSixJQUFJLEVBQUUsRUFBRSxVQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFBO0FBQzdDLG1CQUFHLENBQUMsV0FBVyxFQUFFLENBQUM7QUFFbEIsb0JBQUksU0FBUyxDQUFDLE9BQU8sRUFBRTtBQUNyQix1QkFBRyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztpQkFDeEIsTUFBTTtBQUNMLHVCQUFHLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2lCQUNyQjtBQUVELG1CQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsU0FBUyxFQUFULFNBQVMsRUFBRSxFQUFFLFVBQUMsR0FBRyxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUE7QUFDdEMsdUJBQUcsQ0FBQyxjQUFjLEVBQUUsQ0FBQztBQUNyQix1QkFBRyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUN4Qix1QkFBRyxDQUFDLFFBQVEsRUFBRSxDQUFDO2lCQUNoQixDQUFDLENBQUM7QUFFSCxvQkFBSSxTQUFTLENBQUMsT0FBTyxFQUFFO0FBQ3JCLHVCQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2QsdUJBQUcsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDbEIsdUJBQUcsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUM7aUJBQ3pCO2FBQ0YsQ0FBQyxDQUFDO1NBQ0o7O2VBN0RILFVBQUE7Z0NBVEUsU0FBUzs7c0JBU1gsVUFBQSIsImZpbGUiOiJlYWNoLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgU3RhdGVtZW50IGFzIFN0YXRlbWVudFN5bnRheFxufSBmcm9tICcuLi8uLi9zeW50YXgnO1xuXG5pbXBvcnQgKiBhcyBTeW50YXggZnJvbSAnLi4vY29yZSc7XG5cbmltcG9ydCBPcGNvZGVCdWlsZGVyRFNMIGZyb20gJy4uLy4uL2NvbXBpbGVkL29wY29kZXMvYnVpbGRlcic7XG5cbmltcG9ydCBFbnZpcm9ubWVudCBmcm9tICcuLi8uLi9lbnZpcm9ubWVudCc7XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEVhY2hTeW50YXggZXh0ZW5kcyBTdGF0ZW1lbnRTeW50YXgge1xuICB0eXBlID0gXCJlYWNoLXN0YXRlbWVudFwiO1xuXG4gIHB1YmxpYyBhcmdzOiBTeW50YXguQXJncztcbiAgcHVibGljIHRlbXBsYXRlczogU3ludGF4LlRlbXBsYXRlcztcbiAgcHVibGljIGlzU3RhdGljID0gZmFsc2U7XG5cbiAgY29uc3RydWN0b3IoeyBhcmdzLCB0ZW1wbGF0ZXMgfTogeyBhcmdzOiBTeW50YXguQXJncywgdGVtcGxhdGVzOiBTeW50YXguVGVtcGxhdGVzIH0pIHtcbiAgICBzdXBlcigpO1xuICAgIHRoaXMuYXJncyA9IGFyZ3M7XG4gICAgdGhpcy50ZW1wbGF0ZXMgPSB0ZW1wbGF0ZXM7XG4gIH1cblxuICBjb21waWxlKGRzbDogT3Bjb2RlQnVpbGRlckRTTCwgZW52OiBFbnZpcm9ubWVudCkge1xuICAgIC8vICAgICAgICAgRW50ZXIoQkVHSU4sIEVORClcbiAgICAvLyBCRUdJTjogIE5vb3BcbiAgICAvLyAgICAgICAgIFB1dEFyZ3NcbiAgICAvLyAgICAgICAgIFB1dEl0ZXJhYmxlXG4gICAgLy8gICAgICAgICBKdW1wVW5sZXNzKEVMU0UpXG4gICAgLy8gICAgICAgICBFbnRlckxpc3QoQkVHSU4yLCBFTkQyKVxuICAgIC8vIElURVI6ICAgTm9vcFxuICAgIC8vICAgICAgICAgTmV4dEl0ZXIoQlJFQUspXG4gICAgLy8gICAgICAgICBFbnRlcldpdGhLZXkoQkVHSU4yLCBFTkQyKVxuICAgIC8vIEJFR0lOMjogTm9vcFxuICAgIC8vICAgICAgICAgUHVzaENoaWxkU2NvcGVcbiAgICAvLyAgICAgICAgIEV2YWx1YXRlKGRlZmF1bHQpXG4gICAgLy8gICAgICAgICBQb3BTY29wZVxuICAgIC8vIEVORDI6ICAgTm9vcFxuICAgIC8vICAgICAgICAgRXhpdFxuICAgIC8vICAgICAgICAgSnVtcChJVEVSKVxuICAgIC8vIEJSRUFLOiAgTm9vcFxuICAgIC8vICAgICAgICAgRXhpdExpc3RcbiAgICAvLyAgICAgICAgIEp1bXAoRU5EKVxuICAgIC8vIEVMU0U6ICAgTm9vcFxuICAgIC8vICAgICAgICAgRXZhbHVsYXRlKGludmVyc2UpXG4gICAgLy8gRU5EOiAgICBOb29wXG4gICAgLy8gICAgICAgICBFeGl0XG5cbiAgICBsZXQgeyBhcmdzLCB0ZW1wbGF0ZXMgfSA9IHRoaXM7XG5cbiAgICBkc2wuYmxvY2soeyB0ZW1wbGF0ZXMsIGFyZ3MgfSwgKGRzbCwgQkVHSU4sIEVORCkgPT4ge1xuICAgICAgZHNsLnB1dEl0ZXJhdG9yKCk7XG5cbiAgICAgIGlmICh0ZW1wbGF0ZXMuaW52ZXJzZSkge1xuICAgICAgICBkc2wuanVtcFVubGVzcygnRUxTRScpO1xuICAgICAgfSBlbHNlIHtcbiAgICAgICAgZHNsLmp1bXBVbmxlc3MoRU5EKTtcbiAgICAgIH1cblxuICAgICAgZHNsLml0ZXIoeyB0ZW1wbGF0ZXMgfSwgKGRzbCwgQkVHSU4sIEVORCkgPT4ge1xuICAgICAgICBkc2wucHVzaENoaWxkU2NvcGUoKTtcbiAgICAgICAgZHNsLmV2YWx1YXRlKCdkZWZhdWx0Jyk7XG4gICAgICAgIGRzbC5wb3BTY29wZSgpO1xuICAgICAgfSk7XG5cbiAgICAgIGlmICh0ZW1wbGF0ZXMuaW52ZXJzZSkge1xuICAgICAgICBkc2wuanVtcChFTkQpO1xuICAgICAgICBkc2wubGFiZWwoJ0VMU0UnKTtcbiAgICAgICAgZHNsLmV2YWx1YXRlKCdpbnZlcnNlJyk7XG4gICAgICB9XG4gICAgfSk7XG4gIH1cbn1cbiJdfQ== +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/syntax/builtins/if', ['exports', 'glimmer-runtime/lib/syntax'], function (exports, _glimmerRuntimeLibSyntax) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var IfSyntax = (function (_StatementSyntax) { - _inherits(IfSyntax, _StatementSyntax); + babelHelpers.inherits(IfSyntax, _StatementSyntax); function IfSyntax(_ref) { var args = _ref.args; var templates = _ref.templates; - _classCallCheck(this, IfSyntax); - _StatementSyntax.call(this); this.type = "if-statement"; this.isStatic = false; this.args = args; this.templates = templates; @@ -20353,35 +20980,29 @@ return IfSyntax; })(_glimmerRuntimeLibSyntax.Statement); exports.default = IfSyntax; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/syntax/builtins/partial', ['exports', 'glimmer-util', 'glimmer-runtime/lib/syntax', 'glimmer-runtime/lib/compiled/opcodes/vm'], function (exports, _glimmerUtil, _glimmerRuntimeLibSyntax, _glimmerRuntimeLibCompiledOpcodesVm) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var PartialSyntax = (function (_StatementSyntax) { - _inherits(PartialSyntax, _StatementSyntax); + babelHelpers.inherits(PartialSyntax, _StatementSyntax); function PartialSyntax(_ref) { var args = _ref.args; + var symbolTable = _ref.symbolTable; - _classCallCheck(this, PartialSyntax); - _StatementSyntax.call(this); this.type = "partial-statement"; this.isStatic = false; this.args = args; + this.symbolTable = symbolTable; } - PartialSyntax.prototype.compile = function compile(compiler, env, block) { + PartialSyntax.prototype.compile = function compile(compiler, env, symbolTable) { /* // Enter(BEGIN, END) // BEGIN: Noop // PutArgs // NameToPartial @@ -20391,51 +21012,43 @@ // END: Noop // Exit */ _glimmerUtil.assert(this.args.positional.values.length > 0, 'Partial found with no arguments. You must specify a template.'); _glimmerUtil.assert(this.args.positional.values.length < 2, 'Partial found with more than one argument. You can only specify a single template.'); - var compiledPartialNameExpression = this.args.positional.values[0].compile(compiler, env); + var compiledPartialNameExpression = this.args.positional.values[0].compile(compiler, env, symbolTable); var BEGIN = new _glimmerRuntimeLibCompiledOpcodesVm.LabelOpcode("BEGIN"); var END = new _glimmerRuntimeLibCompiledOpcodesVm.LabelOpcode("END"); compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.EnterOpcode({ begin: BEGIN, end: END })); compiler.append(BEGIN); - compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.PutArgsOpcode({ args: this.args.compile(compiler, env) })); - compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.NameToPartialOpcode()); + compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.PutArgsOpcode({ args: this.args.compile(compiler, env, symbolTable) })); + compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.NameToPartialOpcode(this.symbolTable)); compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.TestOpcode(_glimmerRuntimeLibCompiledOpcodesVm.SimpleTest)); compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.JumpUnlessOpcode({ target: END })); compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.EvaluatePartialOpcode({ name: compiledPartialNameExpression, - symbolTable: block.symbolTable + symbolTable: symbolTable })); compiler.append(END); compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.ExitOpcode()); }; return PartialSyntax; })(_glimmerRuntimeLibSyntax.Statement); exports.default = PartialSyntax; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/syntax/builtins/unless', ['exports', 'glimmer-runtime/lib/syntax'], function (exports, _glimmerRuntimeLibSyntax) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var UnlessSyntax = (function (_StatementSyntax) { - _inherits(UnlessSyntax, _StatementSyntax); + babelHelpers.inherits(UnlessSyntax, _StatementSyntax); function UnlessSyntax(_ref) { var args = _ref.args; var templates = _ref.templates; - _classCallCheck(this, UnlessSyntax); - _StatementSyntax.call(this); this.type = "unless-statement"; this.isStatic = false; this.args = args; this.templates = templates; @@ -20474,29 +21087,57 @@ return UnlessSyntax; })(_glimmerRuntimeLibSyntax.Statement); exports.default = UnlessSyntax; }); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-runtime/lib/syntax/builtins/with', ['exports', 'glimmer-runtime/lib/syntax'], function (exports, _glimmerRuntimeLibSyntax) { +//# sourceMappingURL=data:application/json;base64,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 +enifed('glimmer-runtime/lib/syntax/builtins/with-dynamic-vars', ['exports', 'glimmer-runtime/lib/syntax'], function (exports, _glimmerRuntimeLibSyntax) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } + var WithDynamicVarsSyntax = (function (_StatementSyntax) { + babelHelpers.inherits(WithDynamicVarsSyntax, _StatementSyntax); - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + function WithDynamicVarsSyntax(_ref) { + var args = _ref.args; + var templates = _ref.templates; - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } + _StatementSyntax.call(this); + this.type = "with-dynamic-vars-statement"; + this.isStatic = false; + this.args = args; + this.templates = templates; + } + WithDynamicVarsSyntax.prototype.compile = function compile(dsl, env) { + var args = this.args; + var templates = this.templates; + + dsl.unit({ templates: templates }, function (dsl) { + dsl.putArgs(args); + dsl.pushDynamicScope(); + dsl.bindDynamicScope(args.named.keys); + dsl.evaluate('default'); + dsl.popDynamicScope(); + }); + }; + + return WithDynamicVarsSyntax; + })(_glimmerRuntimeLibSyntax.Statement); + + exports.default = WithDynamicVarsSyntax; +}); +//# sourceMappingURL=data:application/json;base64,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 +enifed('glimmer-runtime/lib/syntax/builtins/with', ['exports', 'glimmer-runtime/lib/syntax'], function (exports, _glimmerRuntimeLibSyntax) { + 'use strict'; + var WithSyntax = (function (_StatementSyntax) { - _inherits(WithSyntax, _StatementSyntax); + babelHelpers.inherits(WithSyntax, _StatementSyntax); function WithSyntax(_ref) { var args = _ref.args; var templates = _ref.templates; - _classCallCheck(this, WithSyntax); - _StatementSyntax.call(this); this.type = "with-statement"; this.isStatic = false; this.args = args; this.templates = templates; @@ -20535,44 +21176,38 @@ return WithSyntax; })(_glimmerRuntimeLibSyntax.Statement); exports.default = WithSyntax; }); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-runtime/lib/syntax/core', ['exports', 'glimmer-runtime/lib/syntax', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/opcodes/vm', 'glimmer-runtime/lib/compiled/opcodes/component', 'glimmer-runtime/lib/compiled/opcodes/dom', 'glimmer-runtime/lib/syntax/expressions', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-runtime/lib/compiled/expressions/value', 'glimmer-runtime/lib/compiled/expressions/ref', 'glimmer-runtime/lib/compiled/expressions/has-block', 'glimmer-runtime/lib/compiled/expressions/has-block-params', 'glimmer-runtime/lib/compiled/expressions/helper', 'glimmer-runtime/lib/compiled/expressions/concat', 'glimmer-util', 'glimmer-runtime/lib/compiled/opcodes/content'], function (exports, _glimmerRuntimeLibSyntax, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledOpcodesVm, _glimmerRuntimeLibCompiledOpcodesComponent, _glimmerRuntimeLibCompiledOpcodesDom, _glimmerRuntimeLibSyntaxExpressions, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerRuntimeLibCompiledExpressionsValue, _glimmerRuntimeLibCompiledExpressionsRef, _glimmerRuntimeLibCompiledExpressionsHasBlock, _glimmerRuntimeLibCompiledExpressionsHasBlockParams, _glimmerRuntimeLibCompiledExpressionsHelper, _glimmerRuntimeLibCompiledExpressionsConcat, _glimmerUtil, _glimmerRuntimeLibCompiledOpcodesContent) { +//# sourceMappingURL=data:application/json;base64,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 +enifed('glimmer-runtime/lib/syntax/core', ['exports', 'glimmer-runtime/lib/syntax', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/compiled/opcodes/vm', 'glimmer-runtime/lib/compiled/opcodes/component', 'glimmer-runtime/lib/compiled/opcodes/dom', 'glimmer-runtime/lib/syntax/expressions', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-runtime/lib/compiled/expressions/value', 'glimmer-runtime/lib/compiled/expressions/lookups', 'glimmer-runtime/lib/compiled/expressions/has-block', 'glimmer-runtime/lib/compiled/expressions/has-block-params', 'glimmer-runtime/lib/compiled/expressions/helper', 'glimmer-runtime/lib/compiled/expressions/concat', 'glimmer-runtime/lib/utils', 'glimmer-runtime/lib/compiled/opcodes/content'], function (exports, _glimmerRuntimeLibSyntax, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibCompiledOpcodesVm, _glimmerRuntimeLibCompiledOpcodesComponent, _glimmerRuntimeLibCompiledOpcodesDom, _glimmerRuntimeLibSyntaxExpressions, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerRuntimeLibCompiledExpressionsValue, _glimmerRuntimeLibCompiledExpressionsLookups, _glimmerRuntimeLibCompiledExpressionsHasBlock, _glimmerRuntimeLibCompiledExpressionsHasBlockParams, _glimmerRuntimeLibCompiledExpressionsHelper, _glimmerRuntimeLibCompiledExpressionsConcat, _glimmerRuntimeLibUtils, _glimmerRuntimeLibCompiledOpcodesContent) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - var Block = (function (_StatementSyntax) { - _inherits(Block, _StatementSyntax); + babelHelpers.inherits(Block, _StatementSyntax); function Block(options) { - _classCallCheck(this, Block); - _StatementSyntax.call(this); this.type = "block"; this.path = options.path; this.args = options.args; this.templates = options.templates; } - Block.fromSpec = function fromSpec(sexp, children) { + Block.fromSpec = function fromSpec(sexp, symbolTable, scanner) { var path = sexp[1]; var params = sexp[2]; var hash = sexp[3]; var templateId = sexp[4]; var inverseId = sexp[5]; + var template = scanner.blockFor(symbolTable, templateId); + var inverse = typeof inverseId === 'number' ? scanner.blockFor(symbolTable, inverseId) : null; return new Block({ path: path, args: Args.fromSpec(params, hash), - templates: Templates.fromSpec([templateId, inverseId], children) + templates: Templates.fromSpec(template, inverse) }); }; Block.build = function build(options) { return new this(options); @@ -20595,95 +21230,46 @@ return Block; })(_glimmerRuntimeLibSyntax.Statement); exports.Block = Block; - var Unknown = (function (_ExpressionSyntax) { - _inherits(Unknown, _ExpressionSyntax); + var Append = (function (_StatementSyntax2) { + babelHelpers.inherits(Append, _StatementSyntax2); - function Unknown(options) { - _classCallCheck(this, Unknown); + Append.fromSpec = function fromSpec(sexp) { + var value = sexp[1]; + var trustingMorph = sexp[2]; - _ExpressionSyntax.call(this); - this.type = "unknown"; - this.ref = options.ref; - this.trustingMorph = !!options.unsafe; - } - - Unknown.fromSpec = function fromSpec(sexp) { - var path = sexp[1]; - - return new Unknown({ ref: new Ref({ parts: path }) }); + return new OptimizedAppend({ value: _glimmerRuntimeLibSyntaxExpressions.default(value), trustingMorph: trustingMorph }); }; - Unknown.build = function build(path, unsafe) { - return new this({ ref: Ref.build(path), unsafe: unsafe }); - }; - - Unknown.prototype.compile = function compile(compiler, env, parentMeta) { - var ref = this.ref; - - if (env.hasHelper(ref.parts, parentMeta)) { - return new _glimmerRuntimeLibCompiledExpressionsHelper.default({ name: ref.parts, helper: env.lookupHelper(ref.parts, parentMeta), args: _glimmerRuntimeLibCompiledExpressionsArgs.CompiledArgs.empty() }); - } else { - return this.ref.compile(compiler); - } - }; - - Unknown.prototype.simplePath = function simplePath() { - return this.ref.simplePath(); - }; - - return Unknown; - })(_glimmerRuntimeLibSyntax.Expression); - - exports.Unknown = Unknown; - - var Append = (function (_StatementSyntax2) { - _inherits(Append, _StatementSyntax2); - function Append(_ref) { var value = _ref.value; var trustingMorph = _ref.trustingMorph; - _classCallCheck(this, Append); - _StatementSyntax2.call(this); this.value = value; this.trustingMorph = trustingMorph; } - Append.fromSpec = function fromSpec(sexp) { - var value = sexp[1]; - var trustingMorph = sexp[2]; - - return new OptimizedAppend({ value: _glimmerRuntimeLibSyntaxExpressions.default(value), trustingMorph: trustingMorph }); - }; - return Append; })(_glimmerRuntimeLibSyntax.Statement); var OptimizedAppend = (function (_Append) { - _inherits(OptimizedAppend, _Append); + babelHelpers.inherits(OptimizedAppend, _Append); function OptimizedAppend() { - _classCallCheck(this, OptimizedAppend); - - for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - _Append.call.apply(_Append, [this].concat(args)); + _Append.apply(this, arguments); this.type = "optimized-append"; } OptimizedAppend.prototype.deopt = function deopt() { return new UnoptimizedAppend(this); }; - OptimizedAppend.prototype.compile = function compile(compiler, env, block) { - compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.PutValueOpcode({ expression: this.value.compile(compiler, env, block.meta) })); + OptimizedAppend.prototype.compile = function compile(compiler, env, symbolTable) { + compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.PutValueOpcode({ expression: this.value.compile(compiler, env, symbolTable) })); if (this.trustingMorph) { compiler.append(new _glimmerRuntimeLibCompiledOpcodesContent.OptimizedTrustingAppendOpcode()); } else { compiler.append(new _glimmerRuntimeLibCompiledOpcodesContent.OptimizedCautiousAppendOpcode()); } @@ -20693,29 +21279,23 @@ })(Append); exports.OptimizedAppend = OptimizedAppend; var UnoptimizedAppend = (function (_Append2) { - _inherits(UnoptimizedAppend, _Append2); + babelHelpers.inherits(UnoptimizedAppend, _Append2); function UnoptimizedAppend() { - _classCallCheck(this, UnoptimizedAppend); - - for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - - _Append2.call.apply(_Append2, [this].concat(args)); + _Append2.apply(this, arguments); this.type = "unoptimized-append"; } - UnoptimizedAppend.prototype.compile = function compile(compiler, env, block) { - var expression = this.value.compile(compiler, env, block.meta); + UnoptimizedAppend.prototype.compile = function compile(compiler, env, symbolTable) { + var expression = this.value.compile(compiler, env, symbolTable); if (this.trustingMorph) { - compiler.append(new _glimmerRuntimeLibCompiledOpcodesContent.GuardedTrustingAppendOpcode(expression)); + compiler.append(new _glimmerRuntimeLibCompiledOpcodesContent.GuardedTrustingAppendOpcode(expression, symbolTable)); } else { - compiler.append(new _glimmerRuntimeLibCompiledOpcodesContent.GuardedCautiousAppendOpcode(expression)); + compiler.append(new _glimmerRuntimeLibCompiledOpcodesContent.GuardedCautiousAppendOpcode(expression, symbolTable)); } }; return UnoptimizedAppend; })(Append); @@ -20723,15 +21303,13 @@ exports.UnoptimizedAppend = UnoptimizedAppend; var MODIFIER_SYNTAX = "c0420397-8ff1-4241-882b-4b7a107c9632"; exports.MODIFIER_SYNTAX = MODIFIER_SYNTAX; var Modifier = (function (_StatementSyntax3) { - _inherits(Modifier, _StatementSyntax3); + babelHelpers.inherits(Modifier, _StatementSyntax3); function Modifier(options) { - _classCallCheck(this, Modifier); - _StatementSyntax3.call(this); this["c0420397-8ff1-4241-882b-4b7a107c9632"] = true; this.type = "modifier"; this.path = options.path; this.args = options.args; @@ -20754,18 +21332,14 @@ params: options.params, hash: options.hash }); }; - Modifier.prototype.compile = function compile(compiler, env) { - var args = this.args.compile(compiler, env); - if (env.hasModifier(this.path)) { - compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.ModifierOpcode({ - name: this.path[0], - manager: env.lookupModifier(this.path), - args: args - })); + Modifier.prototype.compile = function compile(compiler, env, symbolTable) { + var args = this.args.compile(compiler, env, symbolTable); + if (env.hasModifier(this.path, symbolTable)) { + compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.ModifierOpcode(this.path[0], env.lookupModifier(this.path, symbolTable), args)); } else { throw new Error('Compile Error: ' + this.path.join('.') + ' is not a modifier'); } }; @@ -20773,18 +21347,16 @@ })(_glimmerRuntimeLibSyntax.Statement); exports.Modifier = Modifier; var StaticArg = (function (_ArgumentSyntax) { - _inherits(StaticArg, _ArgumentSyntax); + babelHelpers.inherits(StaticArg, _ArgumentSyntax); function StaticArg(_ref2) { var name = _ref2.name; var value = _ref2.value; - _classCallCheck(this, StaticArg); - _ArgumentSyntax.call(this); this.type = "static-arg"; this.name = name; this.value = value; } @@ -20797,11 +21369,11 @@ }; StaticArg.build = function build(name, value) { var namespace = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2]; - return new this({ name: _glimmerUtil.intern(name), value: _glimmerUtil.intern(value) }); + return new this({ name: name, value: value }); }; StaticArg.prototype.compile = function compile() { throw new Error('Cannot compiler StaticArg "' + this.name + '" as it is a delegate for ValueSyntax<string>.'); }; @@ -20814,20 +21386,18 @@ })(_glimmerRuntimeLibSyntax.Argument); exports.StaticArg = StaticArg; var DynamicArg = (function (_ArgumentSyntax2) { - _inherits(DynamicArg, _ArgumentSyntax2); + babelHelpers.inherits(DynamicArg, _ArgumentSyntax2); function DynamicArg(_ref3) { var name = _ref3.name; var value = _ref3.value; var _ref3$namespace = _ref3.namespace; var namespace = _ref3$namespace === undefined ? null : _ref3$namespace; - _classCallCheck(this, DynamicArg); - _ArgumentSyntax2.call(this); this.type = 'dynamic-arg'; this.name = name; this.value = value; this.namespace = namespace; @@ -20841,12 +21411,11 @@ name: name, value: _glimmerRuntimeLibSyntaxExpressions.default(value) }); }; - DynamicArg.build = function build(_name, value) { - var name = _glimmerUtil.intern(_name); + DynamicArg.build = function build(name, value) { return new this({ name: name, value: value }); }; DynamicArg.prototype.compile = function compile() { throw new Error('Cannot compile DynamicArg for "' + this.name + '" as it is delegate for ExpressionSyntax<Opaque>.'); @@ -20860,13 +21429,11 @@ })(_glimmerRuntimeLibSyntax.Argument); exports.DynamicArg = DynamicArg; var TrustingAttr = (function () { - function TrustingAttr() { - _classCallCheck(this, TrustingAttr); - } + function TrustingAttr() {} TrustingAttr.fromSpec = function fromSpec(sexp) { var name = sexp[1]; var value = sexp[2]; var namespace = sexp[3]; @@ -20877,15 +21444,13 @@ isTrusting: true, value: _glimmerRuntimeLibSyntaxExpressions.default(value) }); }; - TrustingAttr.build = function build(_name, value, isTrusting) { - var _namespace = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3]; + TrustingAttr.build = function build(name, value, isTrusting) { + var namespace = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3]; - var name = _glimmerUtil.intern(_name); - var namespace = _namespace ? _glimmerUtil.intern(_namespace) : null; return new DynamicAttr({ name: name, value: value, namespace: namespace, isTrusting: isTrusting }); }; TrustingAttr.prototype.compile = function compile() { throw new Error('Attempting to compile a TrustingAttr which is just a delegate for DynamicAttr.'); @@ -20895,20 +21460,18 @@ })(); exports.TrustingAttr = TrustingAttr; var StaticAttr = (function (_AttributeSyntax) { - _inherits(StaticAttr, _AttributeSyntax); + babelHelpers.inherits(StaticAttr, _AttributeSyntax); function StaticAttr(_ref4) { var name = _ref4.name; var value = _ref4.value; var _ref4$namespace = _ref4.namespace; var namespace = _ref4$namespace === undefined ? null : _ref4$namespace; - _classCallCheck(this, StaticAttr); - _AttributeSyntax.call(this); this["e1185d30-7cac-4b12-b26a-35327d905d92"] = true; this.type = "static-attr"; this.isTrusting = false; this.name = name; @@ -20925,11 +21488,11 @@ }; StaticAttr.build = function build(name, value) { var namespace = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2]; - return new this({ name: _glimmerUtil.intern(name), value: _glimmerUtil.intern(value), namespace: namespace && _glimmerUtil.intern(namespace) }); + return new this({ name: name, value: value, namespace: namespace }); }; StaticAttr.prototype.compile = function compile(compiler) { compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.StaticAttrOpcode(this)); }; @@ -20942,22 +21505,20 @@ })(_glimmerRuntimeLibSyntax.Attribute); exports.StaticAttr = StaticAttr; var DynamicAttr = (function (_AttributeSyntax2) { - _inherits(DynamicAttr, _AttributeSyntax2); + babelHelpers.inherits(DynamicAttr, _AttributeSyntax2); function DynamicAttr(_ref5) { var name = _ref5.name; var value = _ref5.value; var _ref5$isTrusting = _ref5.isTrusting; var isTrusting = _ref5$isTrusting === undefined ? false : _ref5$isTrusting; var _ref5$namespace = _ref5.namespace; var namespace = _ref5$namespace === undefined ? null : _ref5$namespace; - _classCallCheck(this, DynamicAttr); - _AttributeSyntax2.call(this); this["e1185d30-7cac-4b12-b26a-35327d905d92"] = true; this.type = "dynamic-attr"; this.name = name; this.value = value; @@ -20975,25 +21536,22 @@ namespace: namespace, value: _glimmerRuntimeLibSyntaxExpressions.default(value) }); }; - DynamicAttr.build = function build(_name, value) { + DynamicAttr.build = function build(name, value) { var isTrusting = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2]; + var namespace = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3]; - var _namespace = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3]; - - var name = _glimmerUtil.intern(_name); - var namespace = _namespace ? _glimmerUtil.intern(_namespace) : null; return new this({ name: name, value: value, namespace: namespace, isTrusting: isTrusting }); }; - DynamicAttr.prototype.compile = function compile(compiler, env) { + DynamicAttr.prototype.compile = function compile(compiler, env, symbolTable) { var namespace = this.namespace; var value = this.value; - compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.PutValueOpcode({ expression: value.compile(compiler, env) })); + compiler.append(new _glimmerRuntimeLibCompiledOpcodesVm.PutValueOpcode({ expression: value.compile(compiler, env, symbolTable) })); if (namespace) { compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.DynamicAttrNSOpcode(this)); } else { compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.DynamicAttrOpcode(this)); } @@ -21006,21 +21564,40 @@ return DynamicAttr; })(_glimmerRuntimeLibSyntax.Attribute); exports.DynamicAttr = DynamicAttr; - var CloseElement = (function (_StatementSyntax4) { - _inherits(CloseElement, _StatementSyntax4); + var FlushElement = (function (_StatementSyntax4) { + babelHelpers.inherits(FlushElement, _StatementSyntax4); - function CloseElement() { - _classCallCheck(this, CloseElement); + function FlushElement() { + _StatementSyntax4.apply(this, arguments); + this.type = "flush-element"; + } - for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } + FlushElement.fromSpec = function fromSpec() { + return new FlushElement(); + }; - _StatementSyntax4.call.apply(_StatementSyntax4, [this].concat(args)); + FlushElement.build = function build() { + return new this(); + }; + + FlushElement.prototype.compile = function compile(compiler) { + compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.FlushElementOpcode()); + }; + + return FlushElement; + })(_glimmerRuntimeLibSyntax.Statement); + + exports.FlushElement = FlushElement; + + var CloseElement = (function (_StatementSyntax5) { + babelHelpers.inherits(CloseElement, _StatementSyntax5); + + function CloseElement() { + _StatementSyntax5.apply(this, arguments); this.type = "close-element"; } CloseElement.fromSpec = function fromSpec() { return new CloseElement(); @@ -21037,17 +21614,15 @@ return CloseElement; })(_glimmerRuntimeLibSyntax.Statement); exports.CloseElement = CloseElement; - var Text = (function (_StatementSyntax5) { - _inherits(Text, _StatementSyntax5); + var Text = (function (_StatementSyntax6) { + babelHelpers.inherits(Text, _StatementSyntax6); function Text(options) { - _classCallCheck(this, Text); - - _StatementSyntax5.call(this); + _StatementSyntax6.call(this); this.type = "text"; this.content = options.content; } Text.fromSpec = function fromSpec(node) { @@ -21067,17 +21642,15 @@ return Text; })(_glimmerRuntimeLibSyntax.Statement); exports.Text = Text; - var Comment = (function (_StatementSyntax6) { - _inherits(Comment, _StatementSyntax6); + var Comment = (function (_StatementSyntax7) { + babelHelpers.inherits(Comment, _StatementSyntax7); function Comment(options) { - _classCallCheck(this, Comment); - - _StatementSyntax6.call(this); + _StatementSyntax7.call(this); this.type = "comment"; this.comment = options.value; } Comment.fromSpec = function fromSpec(sexp) { @@ -21085,11 +21658,11 @@ return new Comment({ value: value }); }; Comment.build = function build(value) { - return new this({ value: _glimmerUtil.intern(value) }); + return new this({ value: value }); }; Comment.prototype.compile = function compile(dsl) { dsl.comment(this.comment); }; @@ -21097,81 +21670,88 @@ return Comment; })(_glimmerRuntimeLibSyntax.Statement); exports.Comment = Comment; - var OpenElement = (function (_StatementSyntax7) { - _inherits(OpenElement, _StatementSyntax7); + var OpenElement = (function (_StatementSyntax8) { + babelHelpers.inherits(OpenElement, _StatementSyntax8); function OpenElement(options) { - _classCallCheck(this, OpenElement); - - _StatementSyntax7.call(this); + _StatementSyntax8.call(this); this.type = "open-element"; this.tag = options.tag; this.blockParams = options.blockParams; + this.symbolTable = options.symbolTable; } - OpenElement.fromSpec = function fromSpec(sexp) { + OpenElement.fromSpec = function fromSpec(sexp, symbolTable) { var tag = sexp[1]; var blockParams = sexp[2]; return new OpenElement({ tag: tag, - blockParams: blockParams + blockParams: blockParams, + symbolTable: symbolTable }); }; - OpenElement.build = function build(tag, blockParams) { - return new this({ tag: _glimmerUtil.intern(tag), blockParams: blockParams && blockParams.map(_glimmerUtil.intern) }); + OpenElement.build = function build(tag, blockParams, symbolTable) { + return new this({ tag: tag, blockParams: blockParams, symbolTable: symbolTable }); }; OpenElement.prototype.scan = function scan(scanner) { var tag = this.tag; - if (scanner.env.hasComponentDefinition([tag])) { + if (scanner.env.hasComponentDefinition([tag], this.symbolTable)) { var _parameters = this.parameters(scanner); var args = _parameters.args; var attrs = _parameters.attrs; - scanner.startBlock(); + scanner.startBlock(this.blockParams); this.tagContents(scanner); - var template = scanner.endBlock(); - return new Component({ tag: tag, args: args, attrs: attrs, template: template }); + var template = scanner.endBlock(this.blockParams); + return new Component(tag, attrs, args, template); } else { return new OpenPrimitiveElement({ tag: tag }); } }; OpenElement.prototype.compile = function compile(list, env) { - list.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenPrimitiveElementOpcode(this)); + list.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenPrimitiveElementOpcode(this.tag)); }; OpenElement.prototype.toIdentity = function toIdentity() { var tag = this.tag; return new OpenPrimitiveElement({ tag: tag }); }; OpenElement.prototype.parameters = function parameters(scanner) { var current = scanner.next(); - var args = _glimmerUtil.dict(); var attrs = []; - while (current[_glimmerRuntimeLibSyntax.ATTRIBUTE] || current[MODIFIER_SYNTAX] || current[_glimmerRuntimeLibSyntax.ARGUMENT]) { + var argKeys = []; + var argValues = []; + while (!(current instanceof FlushElement)) { if (current[MODIFIER_SYNTAX]) { throw new Error('Compile Error: Element modifiers are not allowed in components'); } var param = current; if (current[_glimmerRuntimeLibSyntax.ATTRIBUTE]) { attrs.push(param.name); + // REMOVE ME: attributes should not be treated as args + argKeys.push(param.name); + argValues.push(param.valueSyntax()); + } else if (current[_glimmerRuntimeLibSyntax.ARGUMENT]) { + argKeys.push(param.name); + argValues.push(param.valueSyntax()); + } else { + throw new Error("Expected FlushElement, but got ${current}"); } - args[param.name] = param.valueSyntax(); current = scanner.next(); } - scanner.unput(current); - return { args: Args.fromNamedArgs(NamedArgs.build(args)), attrs: attrs }; + return { args: Args.fromNamedArgs(NamedArgs.build(argKeys, argValues)), attrs: attrs }; }; OpenElement.prototype.tagContents = function tagContents(scanner) { var nesting = 1; while (true) { @@ -21189,78 +21769,67 @@ return OpenElement; })(_glimmerRuntimeLibSyntax.Statement); exports.OpenElement = OpenElement; - var Component = (function (_StatementSyntax8) { - _inherits(Component, _StatementSyntax8); + var Component = (function (_StatementSyntax9) { + babelHelpers.inherits(Component, _StatementSyntax9); - function Component(_ref6) { - var tag = _ref6.tag; - var args = _ref6.args; - var attrs = _ref6.attrs; - var template = _ref6.template; - - _classCallCheck(this, Component); - - _StatementSyntax8.call(this); - this.type = 'component'; + function Component(tag, attrs, args, template) { + _StatementSyntax9.call(this); this.tag = tag; - this.args = args; this.attrs = attrs; + this.args = args; this.template = template; + this.type = 'component'; } - Component.prototype.compile = function compile(list, env) { - var definition = env.getComponentDefinition([this.tag]); - var args = this.args.compile(list, env); + Component.prototype.compile = function compile(list, env, symbolTable) { + var definition = env.getComponentDefinition([this.tag], symbolTable); + var args = this.args.compile(list, env, symbolTable); var shadow = this.attrs; - var templates = new Templates({ template: this.template, inverse: null }); - list.append(new _glimmerRuntimeLibCompiledOpcodesComponent.PutComponentDefinitionOpcode({ args: args, definition: definition })); - list.append(new _glimmerRuntimeLibCompiledOpcodesComponent.OpenComponentOpcode({ shadow: shadow, templates: templates })); + var templates = new Templates(this.template); + list.append(new _glimmerRuntimeLibCompiledOpcodesComponent.PutComponentDefinitionOpcode(definition)); + list.append(new _glimmerRuntimeLibCompiledOpcodesComponent.OpenComponentOpcode(args, shadow, templates)); list.append(new _glimmerRuntimeLibCompiledOpcodesComponent.CloseComponentOpcode()); }; return Component; })(_glimmerRuntimeLibSyntax.Statement); exports.Component = Component; - var OpenPrimitiveElement = (function (_StatementSyntax9) { - _inherits(OpenPrimitiveElement, _StatementSyntax9); + var OpenPrimitiveElement = (function (_StatementSyntax10) { + babelHelpers.inherits(OpenPrimitiveElement, _StatementSyntax10); function OpenPrimitiveElement(options) { - _classCallCheck(this, OpenPrimitiveElement); - - _StatementSyntax9.call(this); + _StatementSyntax10.call(this); this.type = "open-primitive-element"; this.tag = options.tag; } OpenPrimitiveElement.build = function build(tag) { - return new this({ tag: _glimmerUtil.intern(tag) }); + return new this({ tag: tag }); }; OpenPrimitiveElement.prototype.compile = function compile(compiler) { - compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenPrimitiveElementOpcode({ tag: this.tag })); + compiler.append(new _glimmerRuntimeLibCompiledOpcodesDom.OpenPrimitiveElementOpcode(this.tag)); }; return OpenPrimitiveElement; })(_glimmerRuntimeLibSyntax.Statement); exports.OpenPrimitiveElement = OpenPrimitiveElement; - var Yield = (function (_StatementSyntax10) { - _inherits(Yield, _StatementSyntax10); + var Yield = (function (_StatementSyntax11) { + babelHelpers.inherits(Yield, _StatementSyntax11); - function Yield(_ref7) { - var to = _ref7.to; - var args = _ref7.args; + function Yield(_ref6) { + var to = _ref6.to; + var args = _ref6.args; - _classCallCheck(this, Yield); - - _StatementSyntax10.call(this); + _StatementSyntax11.call(this); this.type = "yield"; this.to = to; this.args = args; } @@ -21272,35 +21841,33 @@ return new Yield({ to: to, args: args }); }; Yield.build = function build(params, to) { var args = Args.fromPositionalArgs(PositionalArgs.build(params)); - return new this({ to: _glimmerUtil.intern(to), args: args }); + return new this({ to: to, args: args }); }; - Yield.prototype.compile = function compile(compiler, env) { - var to = compiler.getBlockSymbol(this.to); - var args = this.args.compile(compiler, env); - compiler.append(new OpenBlockOpcode({ to: to, label: this.to, args: args })); - compiler.append(new CloseBlockOpcode()); + Yield.prototype.compile = function compile(dsl, env, symbolTable) { + var to = dsl.getBlockSymbol(this.to); + var args = this.args.compile(dsl, env, symbolTable); + dsl.append(new OpenBlockOpcode({ to: to, label: this.to, args: args })); + dsl.append(new CloseBlockOpcode()); }; return Yield; })(_glimmerRuntimeLibSyntax.Statement); exports.Yield = Yield; var OpenBlockOpcode = (function (_Opcode) { - _inherits(OpenBlockOpcode, _Opcode); + babelHelpers.inherits(OpenBlockOpcode, _Opcode); - function OpenBlockOpcode(_ref8) { - var to = _ref8.to; - var label = _ref8.label; - var args = _ref8.args; + function OpenBlockOpcode(_ref7) { + var to = _ref7.to; + var label = _ref7.label; + var args = _ref7.args; - _classCallCheck(this, OpenBlockOpcode); - _Opcode.call(this); this.type = "open-block"; this.to = to; this.label = label; this.args = args; @@ -21321,20 +21888,14 @@ return OpenBlockOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); var CloseBlockOpcode = (function (_Opcode2) { - _inherits(CloseBlockOpcode, _Opcode2); + babelHelpers.inherits(CloseBlockOpcode, _Opcode2); function CloseBlockOpcode() { - _classCallCheck(this, CloseBlockOpcode); - - for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { - args[_key4] = arguments[_key4]; - } - - _Opcode2.call.apply(_Opcode2, [this].concat(args)); + _Opcode2.apply(this, arguments); this.type = "close-block"; } CloseBlockOpcode.prototype.evaluate = function evaluate(vm) { vm.popScope(); @@ -21343,17 +21904,15 @@ return CloseBlockOpcode; })(_glimmerRuntimeLibOpcodes.Opcode); exports.CloseBlockOpcode = CloseBlockOpcode; - var Value = (function (_ExpressionSyntax2) { - _inherits(Value, _ExpressionSyntax2); + var Value = (function (_ExpressionSyntax) { + babelHelpers.inherits(Value, _ExpressionSyntax); function Value(value) { - _classCallCheck(this, Value); - - _ExpressionSyntax2.call(this); + _ExpressionSyntax.call(this); this.type = "value"; this.value = value; } Value.fromSpec = function fromSpec(value) { @@ -21375,163 +21934,151 @@ return Value; })(_glimmerRuntimeLibSyntax.Expression); exports.Value = Value; - var Get = (function (_ExpressionSyntax3) { - _inherits(Get, _ExpressionSyntax3); + var GetArgument = (function (_ExpressionSyntax2) { + babelHelpers.inherits(GetArgument, _ExpressionSyntax2); - function Get(options) { - _classCallCheck(this, Get); - - _ExpressionSyntax3.call(this); - this.type = "get"; - this.ref = options.ref; - } - - Get.fromSpec = function fromSpec(sexp) { - var parts = sexp[1]; - - return new Get({ ref: new Ref({ parts: parts }) }); - }; - - Get.build = function build(path) { - return new this({ ref: Ref.build(path) }); - }; - - Get.prototype.compile = function compile(compiler) { - return this.ref.compile(compiler); - }; - - return Get; - })(_glimmerRuntimeLibSyntax.Expression); - - exports.Get = Get; - - var SelfGet = (function (_ExpressionSyntax4) { - _inherits(SelfGet, _ExpressionSyntax4); - - function SelfGet(options) { - _classCallCheck(this, SelfGet); - - _ExpressionSyntax4.call(this); - this.type = "self-get"; - this.ref = options.ref; - } - - SelfGet.fromSpec = function fromSpec(sexp) { - var parts = sexp[1]; - - return new SelfGet({ ref: new Ref({ parts: parts }) }); - }; - - SelfGet.prototype.compile = function compile(compiler) { - return this.ref.compile(compiler); - }; - - return SelfGet; - })(_glimmerRuntimeLibSyntax.Expression); - - exports.SelfGet = SelfGet; - - var GetArgument = (function (_ExpressionSyntax5) { - _inherits(GetArgument, _ExpressionSyntax5); - function GetArgument(options) { - _classCallCheck(this, GetArgument); - - _ExpressionSyntax5.call(this); + _ExpressionSyntax2.call(this); this.type = "get-argument"; this.parts = options.parts; } - // intern paths because they will be used as keys + // this is separated out from Get because Unknown also has a ref, but it + // may turn out to be a helper GetArgument.fromSpec = function fromSpec(sexp) { var parts = sexp[1]; return new GetArgument({ parts: parts }); }; GetArgument.build = function build(path) { - return new this({ parts: path.split('.').map(_glimmerUtil.intern) }); + return new this({ parts: path.split('.') }); }; GetArgument.prototype.compile = function compile(lookup) { var parts = this.parts; var head = parts[0]; var symbol = lookup.getNamedSymbol(head); var path = parts.slice(1); - return new _glimmerRuntimeLibCompiledExpressionsRef.CompiledLocalRef({ debug: head, symbol: symbol, path: path }); + return new _glimmerRuntimeLibCompiledExpressionsLookups.CompiledLocalLookup(symbol, path, head); }; return GetArgument; })(_glimmerRuntimeLibSyntax.Expression); exports.GetArgument = GetArgument; - function internPath(path) { - return path.split('.').map(_glimmerUtil.intern); - } - // this is separated out from Get because Unknown also has a ref, but it - // may turn out to be a helper - var Ref = (function (_ExpressionSyntax6) { - _inherits(Ref, _ExpressionSyntax6); + var Ref = (function (_ExpressionSyntax3) { + babelHelpers.inherits(Ref, _ExpressionSyntax3); - function Ref(_ref9) { - var parts = _ref9.parts; - - _classCallCheck(this, Ref); - - _ExpressionSyntax6.call(this); + function Ref(parts) { + _ExpressionSyntax3.call(this); + this.parts = parts; this.type = "ref"; this.parts = parts; } Ref.build = function build(path) { - return new this({ parts: internPath(path) }); + var parts = path.split('.'); + if (parts[0] === 'this') { + parts[0] = null; + } + return new this(parts); }; Ref.prototype.compile = function compile(lookup) { var parts = this.parts; var head = parts[0]; var path = parts.slice(1); - if (lookup.hasKeyword(head)) { - return new _glimmerRuntimeLibCompiledExpressionsRef.CompiledKeywordRef({ name: head, path: path }); - } - if (lookup.hasLocalSymbol(head)) { + if (head === null) { + return new _glimmerRuntimeLibCompiledExpressionsLookups.CompiledSelfLookup(path); + } else if (lookup.hasLocalSymbol(head)) { var symbol = lookup.getLocalSymbol(head); - return new _glimmerRuntimeLibCompiledExpressionsRef.CompiledLocalRef({ debug: head, symbol: symbol, path: path }); + return new _glimmerRuntimeLibCompiledExpressionsLookups.CompiledLocalLookup(symbol, path, head); } else { - return new _glimmerRuntimeLibCompiledExpressionsRef.CompiledSelfRef({ parts: parts }); + return new _glimmerRuntimeLibCompiledExpressionsLookups.CompiledSelfLookup(parts); } }; - Ref.prototype.path = function path() { - return this.parts; + return Ref; + })(_glimmerRuntimeLibSyntax.Expression); + + exports.Ref = Ref; + + var Get = (function (_ExpressionSyntax4) { + babelHelpers.inherits(Get, _ExpressionSyntax4); + + function Get(ref) { + _ExpressionSyntax4.call(this); + this.ref = ref; + this.type = "get"; + } + + Get.fromSpec = function fromSpec(sexp) { + var parts = sexp[1]; + + return new this(new Ref(parts)); }; - Ref.prototype.simplePath = function simplePath() { - if (this.parts.length === 1) { - return this.parts[0]; + Get.build = function build(path) { + return new this(Ref.build(path)); + }; + + Get.prototype.compile = function compile(compiler) { + return this.ref.compile(compiler); + }; + + return Get; + })(_glimmerRuntimeLibSyntax.Expression); + + exports.Get = Get; + + var Unknown = (function (_ExpressionSyntax5) { + babelHelpers.inherits(Unknown, _ExpressionSyntax5); + + function Unknown(ref) { + _ExpressionSyntax5.call(this); + this.ref = ref; + this.type = "unknown"; + } + + Unknown.fromSpec = function fromSpec(sexp) { + var path = sexp[1]; + + return new this(new Ref(path)); + }; + + Unknown.build = function build(path) { + return new this(Ref.build(path)); + }; + + Unknown.prototype.compile = function compile(compiler, env, symbolTable) { + var ref = this.ref; + + if (env.hasHelper(ref.parts, symbolTable)) { + return new _glimmerRuntimeLibCompiledExpressionsHelper.default(ref.parts, env.lookupHelper(ref.parts, symbolTable), _glimmerRuntimeLibCompiledExpressionsArgs.CompiledArgs.empty(), symbolTable); + } else { + return this.ref.compile(compiler); } }; - return Ref; + return Unknown; })(_glimmerRuntimeLibSyntax.Expression); - exports.Ref = Ref; + exports.Unknown = Unknown; - var Helper = (function (_ExpressionSyntax7) { - _inherits(Helper, _ExpressionSyntax7); + var Helper = (function (_ExpressionSyntax6) { + babelHelpers.inherits(Helper, _ExpressionSyntax6); function Helper(options) { - _classCallCheck(this, Helper); - - _ExpressionSyntax7.call(this); + _ExpressionSyntax6.call(this); this.type = "helper"; this.isStatic = false; this.ref = options.ref; this.args = options.args; } @@ -21540,58 +22087,50 @@ var path = sexp[1]; var params = sexp[2]; var hash = sexp[3]; return new Helper({ - ref: new Ref({ parts: path }), + ref: new Ref(path), args: Args.fromSpec(params, hash) }); }; Helper.build = function build(path, positional, named) { - return new this({ ref: Ref.build(path), args: new Args({ positional: positional, named: named }) }); + return new this({ ref: Ref.build(path), args: Args.build(positional, named) }); }; - Helper.prototype.compile = function compile(compiler, env, parentMeta) { - if (env.hasHelper(this.ref.parts, parentMeta)) { + Helper.prototype.compile = function compile(compiler, env, symbolTable) { + if (env.hasHelper(this.ref.parts, symbolTable)) { var args = this.args; var ref = this.ref; - return new _glimmerRuntimeLibCompiledExpressionsHelper.default({ name: ref.parts, helper: env.lookupHelper(ref.parts, parentMeta), args: args.compile(compiler, env) }); + return new _glimmerRuntimeLibCompiledExpressionsHelper.default(ref.parts, env.lookupHelper(ref.parts, symbolTable), args.compile(compiler, env, symbolTable), symbolTable); } else { - throw new Error('Compile Error: ' + this.ref.path().join('.') + ' is not a helper'); + throw new Error('Compile Error: ' + this.ref.parts.join('.') + ' is not a helper'); } }; - Helper.prototype.simplePath = function simplePath() { - return this.ref.simplePath(); - }; - return Helper; })(_glimmerRuntimeLibSyntax.Expression); exports.Helper = Helper; - var HasBlock = (function (_ExpressionSyntax8) { - _inherits(HasBlock, _ExpressionSyntax8); + var HasBlock = (function (_ExpressionSyntax7) { + babelHelpers.inherits(HasBlock, _ExpressionSyntax7); - function HasBlock(_ref10) { - var blockName = _ref10.blockName; + function HasBlock(_ref8) { + var blockName = _ref8.blockName; - _classCallCheck(this, HasBlock); - - _ExpressionSyntax8.call(this); + _ExpressionSyntax7.call(this); this.type = "has-block"; this.blockName = blockName; } HasBlock.fromSpec = function fromSpec(sexp) { var blockName = sexp[1]; - return new HasBlock({ - blockName: blockName - }); + return new HasBlock({ blockName: blockName }); }; HasBlock.build = function build(blockName) { return new this({ blockName: blockName }); }; @@ -21606,29 +22145,25 @@ return HasBlock; })(_glimmerRuntimeLibSyntax.Expression); exports.HasBlock = HasBlock; - var HasBlockParams = (function (_ExpressionSyntax9) { - _inherits(HasBlockParams, _ExpressionSyntax9); + var HasBlockParams = (function (_ExpressionSyntax8) { + babelHelpers.inherits(HasBlockParams, _ExpressionSyntax8); - function HasBlockParams(_ref11) { - var blockName = _ref11.blockName; + function HasBlockParams(_ref9) { + var blockName = _ref9.blockName; - _classCallCheck(this, HasBlockParams); - - _ExpressionSyntax9.call(this); + _ExpressionSyntax8.call(this); this.type = "has-block-params"; this.blockName = blockName; } HasBlockParams.fromSpec = function fromSpec(sexp) { var blockName = sexp[1]; - return new HasBlockParams({ - blockName: blockName - }); + return new HasBlockParams({ blockName: blockName }); }; HasBlockParams.build = function build(blockName) { return new this({ blockName: blockName }); }; @@ -21644,15 +22179,13 @@ })(_glimmerRuntimeLibSyntax.Expression); exports.HasBlockParams = HasBlockParams; var Concat = (function () { - function Concat(_ref12) { - var parts = _ref12.parts; + function Concat(_ref10) { + var parts = _ref10.parts; - _classCallCheck(this, Concat); - this.type = "concat"; this.isStatic = false; this.parts = parts; } @@ -21664,333 +22197,377 @@ Concat.build = function build(parts) { return new this({ parts: parts }); }; - Concat.prototype.compile = function compile(compiler, env) { + Concat.prototype.compile = function compile(compiler, env, symbolTable) { return new _glimmerRuntimeLibCompiledExpressionsConcat.default({ parts: this.parts.map(function (p) { - return p.compile(compiler, env); + return p.compile(compiler, env, symbolTable); }) }); }; return Concat; })(); exports.Concat = Concat; var Args = (function () { - function Args(options) { - _classCallCheck(this, Args); - + function Args(positional, named) { + this.positional = positional; + this.named = named; this.type = "args"; - this.isStatic = false; - this.positional = options.positional; - this.named = options.named; } - Args.fromSpec = function fromSpec(positional, named) { - return new Args({ positional: PositionalArgs.fromSpec(positional), named: NamedArgs.fromSpec(named) }); + Args.empty = function empty() { + return EMPTY_ARGS; }; - Args.empty = function empty() { - return this._empty = this._empty || new Args({ positional: PositionalArgs.empty(), named: NamedArgs.empty() }); + Args.fromSpec = function fromSpec(positional, named) { + return new Args(PositionalArgs.fromSpec(positional), NamedArgs.fromSpec(named)); }; Args.fromPositionalArgs = function fromPositionalArgs(positional) { - return new Args({ positional: positional, named: NamedArgs.empty() }); + return new Args(positional, EMPTY_NAMED_ARGS); }; Args.fromNamedArgs = function fromNamedArgs(named) { - return new Args({ positional: PositionalArgs.empty(), named: named }); + return new Args(EMPTY_POSITIONAL_ARGS, named); }; Args.build = function build(positional, named) { - return new this({ positional: positional, named: named }); + if (positional === EMPTY_POSITIONAL_ARGS && named === EMPTY_NAMED_ARGS) { + return EMPTY_ARGS; + } else { + return new this(positional, named); + } }; - Args.prototype.compile = function compile(compiler, env) { + Args.prototype.compile = function compile(compiler, env, symbolTable) { var positional = this.positional; var named = this.named; - return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledArgs.create({ positional: positional.compile(compiler, env), named: named.compile(compiler, env) }); + return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledArgs.create(positional.compile(compiler, env, symbolTable), named.compile(compiler, env, symbolTable)); }; return Args; })(); exports.Args = Args; var PositionalArgs = (function () { - function PositionalArgs(exprs) { - _classCallCheck(this, PositionalArgs); - + function PositionalArgs(values) { + this.values = values; this.type = "positional"; - this.isStatic = false; - this.values = exprs; - this.length = exprs.length; + this.length = values.length; } + PositionalArgs.empty = function empty() { + return EMPTY_POSITIONAL_ARGS; + }; + PositionalArgs.fromSpec = function fromSpec(sexp) { - if (!sexp || sexp.length === 0) return PositionalArgs.empty(); + if (!sexp || sexp.length === 0) return EMPTY_POSITIONAL_ARGS; return new PositionalArgs(sexp.map(_glimmerRuntimeLibSyntaxExpressions.default)); }; PositionalArgs.build = function build(exprs) { - return new this(exprs); + if (exprs.length === 0) { + return EMPTY_POSITIONAL_ARGS; + } else { + return new this(exprs); + } }; - PositionalArgs.empty = function empty() { - return this._empty = this._empty || new PositionalArgs([]); - }; - PositionalArgs.prototype.slice = function slice(start, end) { return PositionalArgs.build(this.values.slice(start, end)); }; PositionalArgs.prototype.at = function at(index) { return this.values[index]; }; - PositionalArgs.prototype.compile = function compile(compiler, env) { - return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledPositionalArgs.create({ values: this.values.map(function (v) { - return v.compile(compiler, env); - }) }); + PositionalArgs.prototype.compile = function compile(compiler, env, symbolTable) { + return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledPositionalArgs.create(this.values.map(function (v) { + return v.compile(compiler, env, symbolTable); + })); }; return PositionalArgs; })(); exports.PositionalArgs = PositionalArgs; - var NamedArgs = (function () { - function NamedArgs(_ref13) { - var map = _ref13.map; + var EMPTY_POSITIONAL_ARGS = new ((function (_PositionalArgs) { + babelHelpers.inherits(_class, _PositionalArgs); - _classCallCheck(this, NamedArgs); + function _class() { + _PositionalArgs.call(this, _glimmerRuntimeLibUtils.EMPTY_ARRAY); + } + _class.prototype.slice = function slice(start, end) { + return this; + }; + + _class.prototype.at = function at(index) { + return undefined; // ??! + }; + + _class.prototype.compile = function compile(compiler, env) { + return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledPositionalArgs.empty(); + }; + + return _class; + })(PositionalArgs))(); + + var NamedArgs = (function () { + function NamedArgs(keys, values) { + this.keys = keys; + this.values = values; this.type = "named"; - this.isStatic = false; - this.map = map; + this.length = keys.length; } + NamedArgs.empty = function empty() { + return EMPTY_NAMED_ARGS; + }; + NamedArgs.fromSpec = function fromSpec(sexp) { if (sexp === null || sexp === undefined) { - return NamedArgs.empty(); + return EMPTY_NAMED_ARGS; } - var keys = []; - var values = []; - var map = _glimmerUtil.dict(); - Object.keys(sexp).forEach(function (key) { - keys.push(key); - var value = map[key] = _glimmerRuntimeLibSyntaxExpressions.default(sexp[key]); - values.push(value); - }); - return new this({ map: map }); - }; + var keys = sexp[0]; + var exprs = sexp[1]; - NamedArgs.build = function build(map) { - var keys = []; - var values = []; - Object.keys(map).forEach(function (k) { - var value = map[k]; - keys.push(k); - values.push(value); - }); - return new NamedArgs({ map: map }); + if (keys.length === 0) { + return EMPTY_NAMED_ARGS; + } + return new this(keys, exprs.map(function (expr) { + return _glimmerRuntimeLibSyntaxExpressions.default(expr); + })); }; - NamedArgs.empty = function empty() { - return this._empty = this._empty || new NamedArgs({ map: _glimmerUtil.dict() }); + NamedArgs.build = function build(keys, values) { + if (keys.length === 0) { + return EMPTY_NAMED_ARGS; + } else { + return new this(keys, values); + } }; - NamedArgs.prototype.add = function add(key, value) { - this.map[key] = value; - }; - NamedArgs.prototype.at = function at(key) { - return this.map[key]; + var keys = this.keys; + var values = this.values; + + var index = keys.indexOf(key); + return values[index]; }; NamedArgs.prototype.has = function has(key) { - return !!this.map[key]; + return this.keys.indexOf(key) !== -1; }; - NamedArgs.prototype.compile = function compile(compiler, env) { - var map = this.map; + NamedArgs.prototype.compile = function compile(compiler, env, symbolTable) { + var keys = this.keys; + var values = this.values; - var compiledMap = _glimmerUtil.dict(); - Object.keys(map).forEach(function (key) { - compiledMap[key] = map[key].compile(compiler, env); - }); - return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledNamedArgs.create({ map: compiledMap }); + return new _glimmerRuntimeLibCompiledExpressionsArgs.CompiledNamedArgs(keys, values.map(function (value) { + return value.compile(compiler, env, symbolTable); + })); }; return NamedArgs; })(); exports.NamedArgs = NamedArgs; - var Templates = (function () { - function Templates(options) { - _classCallCheck(this, Templates); + var EMPTY_NAMED_ARGS = new ((function (_NamedArgs) { + babelHelpers.inherits(_class2, _NamedArgs); - this.type = "templates"; - this.default = options.template; - this.inverse = options.inverse; + function _class2() { + _NamedArgs.call(this, _glimmerRuntimeLibUtils.EMPTY_ARRAY, _glimmerRuntimeLibUtils.EMPTY_ARRAY); } - Templates.fromSpec = function fromSpec(_ref14, children) { - var templateId = _ref14[0]; - var inverseId = _ref14[1]; + _class2.prototype.at = function at(key) { + return undefined; // ??! + }; - return new Templates({ - template: templateId === null ? null : children[templateId], - inverse: inverseId === null ? null : children[inverseId] - }); + _class2.prototype.has = function has(key) { + return false; }; - Templates.empty = function empty() { - return new Templates({ template: null, inverse: null }); + _class2.prototype.compile = function compile(compiler, env) { + return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledNamedArgs.empty(); }; - Templates.build = function build(template) { + return _class2; + })(NamedArgs))(); + var EMPTY_ARGS = new ((function (_Args) { + babelHelpers.inherits(_class3, _Args); + + function _class3() { + _Args.call(this, EMPTY_POSITIONAL_ARGS, EMPTY_NAMED_ARGS); + } + + _class3.prototype.compile = function compile(compiler, env) { + return _glimmerRuntimeLibCompiledExpressionsArgs.CompiledArgs.empty(); + }; + + return _class3; + })(Args))(); + + var Templates = (function () { + function Templates(_default) { var inverse = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1]; - return new this({ template: template, inverse: inverse }); + this.type = "templates"; + this.default = _default; + this.inverse = inverse; + } + + Templates.fromSpec = function fromSpec(_default) { + var inverse = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1]; + + return new Templates(_default, inverse); }; + Templates.empty = function empty() { + return new Templates(null, null); + }; + return Templates; })(); exports.Templates = Templates; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/syntax/core.ts"],"names":[],"mappings":"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","file":"core.js","sourcesContent":["import { VM } from '../vm';\n\nimport {\n  BlockScanner\n} from '../scanner';\n\nimport {\n  ATTRIBUTE as ATTRIBUTE_SYNTAX,\n  ARGUMENT as ARGUMENT_SYNTAX,\n  CompileInto,\n  Parameter as ParameterSyntax,\n  Attribute as AttributeSyntax,\n  Argument as ArgumentSyntax,\n  Expression as ExpressionSyntax,\n  Statement as StatementSyntax,\n  SymbolLookup\n} from '../syntax';\n\nimport {\n  InlineBlock,\n  Block as CompiledBlock\n} from '../compiled/blocks';\n\nimport {\n  Opcode\n} from '../opcodes';\n\nimport OpcodeBuilderDSL from '../compiled/opcodes/builder';\n\nimport {\n  PutValueOpcode\n} from '../compiled/opcodes/vm';\n\nimport {\n  PutComponentDefinitionOpcode,\n  OpenComponentOpcode,\n  CloseComponentOpcode\n} from '../compiled/opcodes/component';\n\nimport {\n  ModifierOpcode\n} from '../compiled/opcodes/dom';\n\nimport buildExpression from './expressions';\n\nimport {\n  CompiledArgs,\n  CompiledNamedArgs,\n  CompiledPositionalArgs,\n} from '../compiled/expressions/args';\n\nimport CompiledValue from '../compiled/expressions/value';\n\nimport {\n  CompiledLocalRef,\n  CompiledKeywordRef,\n  CompiledSelfRef\n} from '../compiled/expressions/ref';\n\nimport CompiledHasBlock from '../compiled/expressions/has-block';\n\nimport CompiledHasBlockParams from '../compiled/expressions/has-block-params';\n\nimport CompiledHelper from '../compiled/expressions/helper';\n\nimport CompiledConcat from '../compiled/expressions/concat';\n\nimport {\n  CompiledExpression\n} from '../compiled/expressions';\n\nimport { Environment } from '../environment';\n\nimport {\n  Opaque,\n  InternedString,\n  Dict,\n  dict,\n  intern,\n} from 'glimmer-util';\n\nimport {\n  OpenPrimitiveElementOpcode,\n  CloseElementOpcode,\n  StaticAttrOpcode,\n  DynamicAttrOpcode,\n  DynamicAttrNSOpcode\n} from '../compiled/opcodes/dom';\n\nimport {\n  OptimizedCautiousAppendOpcode,\n  OptimizedTrustingAppendOpcode,\n  GuardedCautiousAppendOpcode,\n  GuardedTrustingAppendOpcode\n} from '../compiled/opcodes/content';\n\nimport {\n  Statements as SerializedStatements,\n  Expressions as SerializedExpressions,\n  Core as SerializedCore,\n  BlockMeta\n} from 'glimmer-wire-format';\n\nexport interface BlockOptions {\n\n}\n\nexport class Block extends StatementSyntax {\n  public type = \"block\";\n\n  static fromSpec(sexp: SerializedStatements.Block, children: InlineBlock[]): Block {\n    let [, path, params, hash, templateId, inverseId] = sexp;\n\n    return new Block({\n      path: path as InternedString[],\n      args: Args.fromSpec(params as InternedString[], hash),\n      templates: Templates.fromSpec([templateId, inverseId], children)\n    });\n  }\n\n  static build(options): Block {\n    return new this(options);\n  }\n\n  path: InternedString[];\n  args: Args;\n  templates: Templates;\n\n  constructor(options: { path: InternedString[], args: Args, templates: Templates }) {\n    super();\n    this.path = options.path;\n    this.args = options.args;\n    this.templates = options.templates;\n  }\n\n  scan(scanner: BlockScanner): StatementSyntax {\n    let { default: _default, inverse } = this.templates;\n\n    if (_default) scanner.addChild(_default);\n    if (inverse)  scanner.addChild(inverse);\n\n    return this;\n  }\n\n  compile(ops: CompileInto) {\n    throw new Error(\"SyntaxError\");\n  }\n}\n\nexport class Unknown extends ExpressionSyntax<any> {\n  public type = \"unknown\";\n\n  static fromSpec(sexp: SerializedExpressions.Unknown): Unknown {\n    let [, path] = sexp;\n\n    return new Unknown({ ref: new Ref({ parts: path as InternedString[] }) });\n  }\n\n  static build(path: string, unsafe: boolean): Unknown {\n    return new this({ ref: Ref.build(path), unsafe });\n  }\n\n  ref: Ref;\n  trustingMorph: boolean;\n\n  constructor(options) {\n    super();\n    this.ref = options.ref;\n    this.trustingMorph = !!options.unsafe;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, parentMeta: BlockMeta): CompiledExpression<Opaque> {\n    let { ref } = this;\n\n    if (env.hasHelper(ref.parts, parentMeta)) {\n      return new CompiledHelper({ name: ref.parts, helper: env.lookupHelper(ref.parts, parentMeta), args: CompiledArgs.empty() });\n    } else {\n      return this.ref.compile(compiler);\n    }\n  }\n\n  simplePath(): InternedString {\n    return this.ref.simplePath();\n  }\n}\n\ninterface AppendOpcode {\n  new(): Opcode;\n}\n\nabstract class Append extends StatementSyntax {\n  static fromSpec(sexp: SerializedStatements.Append): Append {\n    let [, value, trustingMorph] = sexp;\n    return new OptimizedAppend({ value: buildExpression(value), trustingMorph });\n  }\n\n  value: ExpressionSyntax<any>;\n  trustingMorph: boolean;\n\n  constructor({ value, trustingMorph }: { value: ExpressionSyntax<any>, trustingMorph: boolean }) {\n    super();\n    this.value = value;\n    this.trustingMorph = trustingMorph;\n  }\n}\n\nexport class OptimizedAppend extends Append {\n  public type = \"optimized-append\";\n\n  deopt(): UnoptimizedAppend {\n    return new UnoptimizedAppend(this);\n  }\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment, block: CompiledBlock) {\n    compiler.append(new PutValueOpcode({ expression: this.value.compile(compiler, env, block.meta) }));\n\n    if (this.trustingMorph) {\n      compiler.append(new OptimizedTrustingAppendOpcode());\n    } else {\n      compiler.append(new OptimizedCautiousAppendOpcode());\n    }\n  }\n}\n\nexport class UnoptimizedAppend extends Append {\n  public type = \"unoptimized-append\";\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment, block: CompiledBlock) {\n    let expression = this.value.compile(compiler, env, block.meta);\n\n    if (this.trustingMorph) {\n      compiler.append(new GuardedTrustingAppendOpcode(expression));\n    } else {\n      compiler.append(new GuardedCautiousAppendOpcode(expression));\n    }\n  }\n}\n\nexport const MODIFIER_SYNTAX = \"c0420397-8ff1-4241-882b-4b7a107c9632\";\n\nexport class Modifier extends StatementSyntax {\n  \"c0420397-8ff1-4241-882b-4b7a107c9632\" = true;\n\n  public type: string = \"modifier\";\n  public path: InternedString[];\n  public args: Args;\n\n  static fromSpec(node) {\n    let [, path, params, hash] = node;\n\n    return new Modifier({\n      path,\n      args: Args.fromSpec(params, hash)\n    });\n  }\n\n  static build(path, options) {\n    return new Modifier({\n      path,\n      params: options.params,\n      hash: options.hash\n    });\n  }\n\n  constructor(options) {\n    super();\n    this.path = options.path;\n    this.args = options.args;\n  }\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment) {\n    let args = this.args.compile(compiler, env);\n\n    if (env.hasModifier(this.path)) {\n      compiler.append(new ModifierOpcode({\n        name: this.path[0],\n        manager: env.lookupModifier(this.path),\n        args\n      }));\n    } else {\n      throw new Error(`Compile Error: ${this.path.join('.')} is not a modifier`);\n    }\n  }\n}\n\nexport class StaticArg extends ArgumentSyntax<string> {\n  public type = \"static-arg\";\n  name: InternedString;\n  value: InternedString;\n\n  static fromSpec(node: SerializedStatements.StaticArg): StaticArg {\n    let [, name, value] = node;\n\n    return new StaticArg({ name: name as InternedString, value: value as InternedString });\n  }\n\n  static build(name: string, value: string, namespace: string=null): StaticArg {\n    return new this({ name: intern(name), value: intern(value) });\n  }\n\n  constructor({ name, value }) {\n    super();\n    this.name = name;\n    this.value = value;\n  }\n\n  compile() {\n    throw new Error(`Cannot compiler StaticArg \"${this.name}\" as it is a delegate for ValueSyntax<string>.`);\n  }\n\n  valueSyntax(): ExpressionSyntax<string> {\n    return Value.build(this.value as string);\n  }\n}\n\nexport class DynamicArg extends ArgumentSyntax<Opaque> {\n  public type = 'dynamic-arg';\n  static fromSpec(sexp: SerializedStatements.DynamicArg): DynamicArg {\n    let [, name, value] = sexp;\n\n    return new DynamicArg({\n      name: name as InternedString,\n      value: buildExpression(value)\n    });\n  }\n\n  static build(_name: string, value: ExpressionSyntax<string>): DynamicArg {\n    let name = intern(_name);\n    return new this({ name, value });\n  }\n\n  name: InternedString;\n  value: ExpressionSyntax<Opaque>;\n  namespace: InternedString;\n\n  constructor({ name, value, namespace = null }: { name: InternedString, value: ExpressionSyntax<Opaque>, namespace?: InternedString }) {\n    super();\n    this.name = name;\n    this.value = value;\n    this.namespace = namespace;\n  }\n\n  compile() {\n    throw new Error(`Cannot compile DynamicArg for \"${this.name}\" as it is delegate for ExpressionSyntax<Opaque>.`);\n  }\n\n  valueSyntax() {\n    return this.value;\n  }\n}\n\nexport class TrustingAttr {\n  static fromSpec(sexp: SerializedStatements.TrustingAttr): DynamicAttr {\n    let [, name, value, namespace] = sexp;\n    return new DynamicAttr({\n      name: name as InternedString,\n      namespace: namespace as InternedString,\n      isTrusting: true,\n      value: buildExpression(value)\n    });\n  }\n\n  static build(_name: string, value: ExpressionSyntax<string>, isTrusting: boolean, _namespace: string=null): DynamicAttr {\n    let name = intern(_name);\n    let namespace = _namespace ? intern(_namespace) : null;\n    return new DynamicAttr({ name, value, namespace, isTrusting });\n  }\n\n  compile() { throw new Error('Attempting to compile a TrustingAttr which is just a delegate for DynamicAttr.'); }\n}\n\nexport class StaticAttr extends AttributeSyntax<string> {\n  \"e1185d30-7cac-4b12-b26a-35327d905d92\" = true;\n  type = \"static-attr\";\n\n  static fromSpec(node: SerializedStatements.StaticAttr): StaticAttr {\n    let [, name, value, namespace] = node;\n    return new StaticAttr({ name: name as InternedString, value: value as InternedString, namespace: namespace as InternedString });\n  }\n\n  static build(name: string, value: string, namespace: string=null): StaticAttr {\n    return new this({ name: intern(name), value: intern(value), namespace: namespace && intern(namespace) });\n  }\n\n  name: InternedString;\n  value: InternedString;\n  namespace: InternedString;\n  isTrusting = false;\n\n  constructor({ name, value, namespace = null }: { name: InternedString, value: InternedString, namespace?: InternedString }) {\n    super();\n    this.name = name;\n    this.value = value;\n    this.namespace = namespace;\n  }\n\n  compile(compiler: CompileInto) {\n    compiler.append(new StaticAttrOpcode(this));\n  }\n\n  valueSyntax(): ExpressionSyntax<string> {\n    return Value.build(this.value as string);\n  }\n}\n\nexport class DynamicAttr extends AttributeSyntax<string> {\n  \"e1185d30-7cac-4b12-b26a-35327d905d92\" = true;\n  type = \"dynamic-attr\";\n\n  static fromSpec(sexp: SerializedStatements.DynamicAttr): DynamicAttr {\n    let [, name, value, namespace] = sexp;\n    return new DynamicAttr({\n      name: name as InternedString,\n      namespace: namespace as InternedString,\n      value: buildExpression(value)\n    });\n  }\n\n  static build(_name: string, value: ExpressionSyntax<string>, isTrusting = false, _namespace: string=null): DynamicAttr {\n    let name = intern(_name);\n    let namespace = _namespace ? intern(_namespace) : null;\n    return new this({ name, value, namespace, isTrusting });\n  }\n\n  name: InternedString;\n  value: ExpressionSyntax<string>;\n  namespace: InternedString;\n  isTrusting: boolean;\n\n  constructor({ name, value, isTrusting = false, namespace = null }: { name: InternedString, isTrusting?: boolean, value: ExpressionSyntax<string>, namespace?: InternedString }) {\n    super();\n    this.name = name;\n    this.value = value;\n    this.namespace = namespace;\n    this.isTrusting = isTrusting;\n  }\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment) {\n    let {namespace, value} = this;\n    compiler.append(new PutValueOpcode({ expression: value.compile(compiler, env) }));\n    if (namespace) {\n      compiler.append(new DynamicAttrNSOpcode(this));\n    } else {\n      compiler.append(new DynamicAttrOpcode(this));\n    }\n  }\n\n  valueSyntax(): ExpressionSyntax<string> {\n    return this.value;\n  }\n}\n\nexport class CloseElement extends StatementSyntax {\n  type = \"close-element\";\n\n  static fromSpec() {\n    return new CloseElement();\n  }\n\n  static build() {\n    return new this();\n  }\n\n  compile(compiler: CompileInto) {\n    compiler.append(new CloseElementOpcode());\n  }\n}\n\nexport class Text extends StatementSyntax {\n  type = \"text\";\n\n  static fromSpec(node: SerializedStatements.Text): Text {\n    let [, content] = node;\n\n    return new Text({ content: content as InternedString });\n  }\n\n  static build(content): Text {\n    return new this({ content });\n  }\n\n  public content: InternedString;\n\n  constructor(options: { content: InternedString }) {\n    super();\n    this.content = options.content;\n  }\n\n  compile(dsl: OpcodeBuilderDSL) {\n    dsl.text(this.content);\n  }\n}\n\nexport class Comment extends StatementSyntax {\n  type = \"comment\";\n\n  static fromSpec(sexp: SerializedStatements.Comment): Comment {\n    let [, value] = sexp;\n\n    return new Comment({ value });\n  }\n\n  static build(value: string): Comment {\n    return new this({ value: intern(value) });\n  }\n\n  public comment: InternedString;\n\n  constructor(options) {\n    super();\n    this.comment = options.value;\n  }\n\n  compile(dsl: OpcodeBuilderDSL) {\n    dsl.comment(this.comment);\n  }\n}\n\nexport class OpenElement extends StatementSyntax {\n  type = \"open-element\";\n\n  static fromSpec(sexp: SerializedStatements.OpenElement): OpenElement {\n    let [, tag, blockParams] = sexp;\n\n    return new OpenElement({\n      tag: tag as InternedString,\n      blockParams: blockParams as InternedString[]\n    });\n  }\n\n  static build(tag: string, blockParams: string[]): OpenElement {\n    return new this({ tag: intern(tag), blockParams: blockParams && blockParams.map(intern) });\n  }\n\n  public tag: InternedString;\n  public blockParams: InternedString[];\n\n  constructor(options: { tag: InternedString, blockParams: InternedString[] }) {\n    super();\n    this.tag = options.tag;\n    this.blockParams = options.blockParams;\n  }\n\n  scan(scanner: BlockScanner): StatementSyntax {\n    let { tag } = this;\n\n    if (scanner.env.hasComponentDefinition([tag])) {\n      let { args, attrs } = this.parameters(scanner);\n      scanner.startBlock();\n      this.tagContents(scanner);\n      let template = scanner.endBlock();\n      return new Component({ tag, args, attrs, template });\n    } else {\n      return new OpenPrimitiveElement({ tag });\n    }\n  }\n\n  compile(list: CompileInto, env: Environment) {\n    list.append(new OpenPrimitiveElementOpcode(this));\n  }\n\n  toIdentity(): OpenPrimitiveElement {\n    let { tag } = this;\n    return new OpenPrimitiveElement({ tag });\n  }\n\n  private parameters(scanner: BlockScanner): { args: Args, attrs: InternedString[] } {\n    let current = scanner.next();\n    let args = dict<ExpressionSyntax<Opaque>>();\n    let attrs: InternedString[] = [];\n\n    while (current[ATTRIBUTE_SYNTAX] || current[MODIFIER_SYNTAX] || current[ARGUMENT_SYNTAX]) {\n      if (current[MODIFIER_SYNTAX]) {\n        throw new Error(`Compile Error: Element modifiers are not allowed in components`);\n      }\n\n      let param = <ParameterSyntax<Opaque>>current;\n\n      if (current[ATTRIBUTE_SYNTAX]) {\n        attrs.push(param.name);\n      }\n\n      args[param.name] = param.valueSyntax();\n\n      current = scanner.next();\n    }\n\n    scanner.unput(current);\n\n    return { args: Args.fromNamedArgs(NamedArgs.build(args)), attrs };\n  }\n\n  private tagContents(scanner: BlockScanner) {\n    let nesting = 1;\n\n    while (true) {\n      let current = scanner.next();\n      if (current instanceof CloseElement && --nesting === 0) {\n        break;\n      }\n\n      scanner.addStatement(current);\n\n      if (current instanceof OpenElement || current instanceof OpenPrimitiveElement) {\n        nesting++;\n      }\n    }\n  }\n}\n\ninterface ComponentOptions {\n  tag: InternedString;\n  attrs: InternedString[];\n  args: Args;\n  template: InlineBlock;\n}\n\nexport class Component extends StatementSyntax {\n  public type = 'component';\n  public tag: InternedString;\n  public attrs: InternedString[];\n  public args: Args;\n  public template: InlineBlock;\n\n  constructor({ tag, args, attrs, template }: ComponentOptions) {\n    super();\n    this.tag = tag;\n    this.args = args;\n    this.attrs = attrs;\n    this.template = template;\n  }\n\n  compile(list: CompileInto & SymbolLookup, env: Environment) {\n    let definition = env.getComponentDefinition([this.tag]);\n    let args = this.args.compile(list as SymbolLookup, env);\n    let shadow = this.attrs;\n    let templates = new Templates({ template: this.template, inverse: null });\n\n    list.append(new PutComponentDefinitionOpcode({ args, definition }));\n    list.append(new OpenComponentOpcode({ shadow, templates }));\n    list.append(new CloseComponentOpcode());\n  }\n}\n\nexport class OpenPrimitiveElement extends StatementSyntax {\n  type = \"open-primitive-element\";\n\n  public tag: InternedString;\n\n  static build(tag: string): OpenPrimitiveElement {\n    return new this({ tag: intern(tag) });\n  }\n\n  constructor(options: { tag: InternedString }) {\n    super();\n    this.tag = options.tag;\n  }\n\n  compile(compiler: CompileInto) {\n    compiler.append(new OpenPrimitiveElementOpcode({ tag: this.tag }));\n  }\n}\n\nexport class Yield extends StatementSyntax {\n  static fromSpec(sexp: SerializedStatements.Yield): Yield {\n    let [, to, params] = sexp;\n\n    let args = Args.fromSpec(params, null);\n\n    return new Yield({ to: to as InternedString, args });\n  }\n\n  static build(params: ExpressionSyntax<Opaque>[], to: string): Yield {\n    let args = Args.fromPositionalArgs(PositionalArgs.build(params));\n    return new this({ to: intern(to), args });\n  }\n\n  type = \"yield\";\n  public to: InternedString;\n  public args: Args;\n\n  constructor({ to, args }: { to: InternedString, args: Args }) {\n    super();\n    this.to = to;\n    this.args = args;\n  }\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment) {\n    let to = compiler.getBlockSymbol(this.to);\n    let args = this.args.compile(compiler, env);\n    compiler.append(new OpenBlockOpcode({ to, label: this.to, args }));\n    compiler.append(new CloseBlockOpcode());\n  }\n}\n\nclass OpenBlockOpcode extends Opcode {\n  type = \"open-block\";\n  public to: number;\n  public label: InternedString;\n  public args: CompiledArgs;\n\n  constructor({ to, label, args }: { to: number, label: InternedString, args: CompiledArgs }) {\n    super();\n    this.to = to;\n    this.label = label;\n    this.args = args;\n  }\n\n  evaluate(vm: VM) {\n    let block = vm.scope().getBlock(this.to);\n    let args;\n\n    if (block) {\n      args = this.args.evaluate(vm);\n    }\n\n    // FIXME: can we avoid doing this when we don't have a block?\n    vm.pushCallerScope();\n\n    if (block) {\n      vm.invokeBlock(block, args);\n    }\n  }\n}\n\nexport class CloseBlockOpcode extends Opcode {\n  public type = \"close-block\";\n\n  evaluate(vm: VM) {\n    vm.popScope();\n  }\n}\n\nexport class Value<T extends SerializedExpressions.Value> extends ExpressionSyntax<T> {\n  type = \"value\";\n\n  static fromSpec<U extends SerializedExpressions.Value>(value: U): Value<U> {\n    return new Value(value);\n  }\n\n  static build<U extends SerializedExpressions.Value>(value: U): Value<U> {\n    return new this(value);\n  }\n\n  public value: T;\n\n  constructor(value: T) {\n    super();\n    this.value = value;\n  }\n\n  inner(): T {\n    return this.value;\n  }\n\n  compile(compiler: SymbolLookup): CompiledExpression<T> {\n    return new CompiledValue<T>(this);\n  }\n}\n\nexport class Get extends ExpressionSyntax<Opaque> {\n  type = \"get\";\n\n  static fromSpec(sexp: SerializedExpressions.Get): Get {\n    let [, parts] = sexp;\n\n    return new Get({ ref: new Ref({ parts: parts as InternedString[] }) });\n  }\n\n  static build(path: string): Get {\n    return new this({ ref: Ref.build(path) });\n  }\n\n  public ref: Ref;\n\n  constructor(options) {\n    super();\n    this.ref = options.ref;\n  }\n\n  compile(compiler: SymbolLookup): CompiledExpression<Opaque> {\n    return this.ref.compile(compiler);\n  }\n}\n\nexport class SelfGet extends ExpressionSyntax<Opaque> {\n  type = \"self-get\";\n\n  static fromSpec(sexp: SerializedExpressions.SelfGet): SelfGet {\n    let [, parts] = sexp;\n\n    return new SelfGet({ ref: new Ref({ parts: parts as InternedString[] }) });\n  }\n\n  public ref: Ref;\n\n  constructor(options) {\n    super();\n    this.ref = options.ref;\n  }\n\n  compile(compiler: SymbolLookup): CompiledExpression<Opaque> {\n    return this.ref.compile(compiler);\n  }\n}\n\nexport class GetArgument<T> extends ExpressionSyntax<T> {\n  type = \"get-argument\";\n\n  static fromSpec(sexp: SerializedExpressions.Arg): GetArgument<Opaque> {\n    let [, parts] = sexp;\n\n    return new GetArgument<Opaque>({ parts: parts as InternedString[] });\n  }\n\n  static build(path: string): GetArgument<Opaque> {\n    return new this<Opaque>({ parts: path.split('.').map(intern) });\n  }\n\n  public parts: InternedString[];\n\n  constructor(options: { parts: InternedString[] }) {\n    super();\n    this.parts = options.parts;\n  }\n\n  compile(lookup: SymbolLookup): CompiledExpression<T> {\n    let { parts } = this;\n    let head = parts[0];\n    let symbol = lookup.getNamedSymbol(head);\n\n    let path = parts.slice(1);\n    return new CompiledLocalRef({ debug: head, symbol, path });\n  }\n}\n\n// intern paths because they will be used as keys\nfunction internPath(path: string): InternedString[] {\n  return path.split('.').map(intern);\n}\n\n// this is separated out from Get because Unknown also has a ref, but it\n// may turn out to be a helper\nexport class Ref extends ExpressionSyntax<Opaque> {\n  type = \"ref\";\n\n  static build(path: string): Ref {\n    return new this({ parts: internPath(path) });\n  }\n\n  public parts: InternedString[];\n\n  constructor({ parts }: { parts: InternedString[] }) {\n    super();\n    this.parts = parts;\n  }\n\n  compile(lookup: SymbolLookup): CompiledExpression<Opaque> {\n    let { parts } = this;\n    let head = parts[0];\n    let path = parts.slice(1);\n\n    if (lookup.hasKeyword(head)) {\n      return new CompiledKeywordRef({ name: head, path });\n    } if (lookup.hasLocalSymbol(head)) {\n      let symbol = lookup.getLocalSymbol(head);\n      return new CompiledLocalRef({ debug: head, symbol, path });\n    } else {\n      return new CompiledSelfRef({ parts });\n    }\n  }\n\n  path(): InternedString[] {\n    return this.parts;\n  }\n\n  simplePath(): InternedString {\n    if (this.parts.length === 1) {\n      return this.parts[0];\n    }\n  }\n}\n\nexport class Helper extends ExpressionSyntax<Opaque> {\n  type = \"helper\";\n\n  static fromSpec(sexp: SerializedExpressions.Helper): Helper {\n    let [, path, params, hash] = sexp;\n\n    return new Helper({\n      ref: new Ref({ parts: path as InternedString[] }),\n      args: Args.fromSpec(params, hash)\n    });\n  }\n\n  static build(path: string, positional: PositionalArgs, named: NamedArgs): Helper {\n    return new this({ ref: Ref.build(path), args: new Args({ positional, named }) });\n  }\n\n  isStatic = false;\n  ref: Ref;\n  args: Args;\n\n  constructor(options: { ref: Ref, args: Args }) {\n    super();\n    this.ref = options.ref;\n    this.args = options.args;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, parentMeta: BlockMeta): CompiledExpression<Opaque> {\n    if (env.hasHelper(this.ref.parts, parentMeta)) {\n      let { args, ref } = this;\n      return new CompiledHelper({ name: ref.parts, helper: env.lookupHelper(ref.parts, parentMeta), args: args.compile(compiler, env) });\n    } else {\n      throw new Error(`Compile Error: ${this.ref.path().join('.')} is not a helper`);\n    }\n  }\n\n  simplePath(): InternedString {\n    return this.ref.simplePath();\n  }\n}\n\nexport class HasBlock extends ExpressionSyntax<boolean> {\n  type = \"has-block\";\n\n  static fromSpec(sexp: SerializedExpressions.HasBlock): HasBlock {\n    let [, blockName] = sexp;\n\n    return new HasBlock({\n      blockName: blockName as InternedString\n    });\n  }\n\n  static build(blockName: InternedString): HasBlock {\n    return new this({ blockName });\n  }\n\n  blockName: InternedString;\n\n  constructor({ blockName }: { blockName: InternedString }) {\n    super();\n    this.blockName = blockName;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledHasBlock {\n    return new CompiledHasBlock({\n      blockName: this.blockName,\n      blockSymbol: compiler.getBlockSymbol(this.blockName)\n    });\n  }\n}\n\nexport class HasBlockParams extends ExpressionSyntax<boolean> {\n  type = \"has-block-params\";\n\n  static fromSpec(sexp: SerializedExpressions.HasBlockParams): HasBlockParams {\n    let [, blockName] = sexp;\n\n    return new HasBlockParams({\n      blockName: blockName as InternedString\n    });\n  }\n\n  static build(blockName: InternedString): HasBlockParams {\n    return new this({ blockName });\n  }\n\n  blockName: InternedString;\n\n  constructor({ blockName }: { blockName: InternedString }) {\n    super();\n    this.blockName = blockName;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledHasBlockParams {\n    return new CompiledHasBlockParams({\n      blockName: this.blockName,\n      blockSymbol: compiler.getBlockSymbol(this.blockName)\n    });\n  }\n}\n\nexport class Concat {\n  type = \"concat\";\n\n  static fromSpec(sexp: SerializedExpressions.Concat): Concat {\n    let [, params] = sexp;\n\n    return new Concat({ parts: params.map(buildExpression) });\n  }\n\n  static build(parts): Concat {\n    return new this({ parts });\n  }\n\n  isStatic = false;\n  parts: ExpressionSyntax<Opaque>[];\n\n  constructor({ parts }: { parts: ExpressionSyntax<Opaque>[] }) {\n    this.parts = parts;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledConcat {\n    return new CompiledConcat({ parts: this.parts.map(p => p.compile(compiler, env)) });\n  }\n}\n\nexport class Args {\n  public type = \"args\";\n\n  static fromSpec(positional: SerializedCore.Params, named: SerializedCore.Hash): Args {\n    return new Args({ positional: PositionalArgs.fromSpec(positional), named: NamedArgs.fromSpec(named) });\n  }\n\n  static _empty: Args;\n\n  static empty(): Args {\n    return (this._empty = this._empty || new Args({ positional: PositionalArgs.empty(), named: NamedArgs.empty() }));\n  }\n\n  static fromPositionalArgs(positional: PositionalArgs): Args {\n    return new Args({ positional, named: NamedArgs.empty() });\n  }\n\n  static fromNamedArgs(named: NamedArgs): Args {\n    return new Args({ positional: PositionalArgs.empty(), named });\n  }\n\n  static build(positional: PositionalArgs, named: NamedArgs): Args {\n    return new this({ positional, named });\n  }\n\n  public positional: PositionalArgs;\n  public named: NamedArgs;\n  public isStatic = false;\n\n  constructor(options: { positional: PositionalArgs, named: NamedArgs }) {\n    this.positional = options.positional;\n    this.named = options.named;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledArgs {\n    let { positional, named } = this;\n    return CompiledArgs.create({ positional: positional.compile(compiler, env), named: named.compile(compiler, env) });\n  }\n}\n\nexport class PositionalArgs {\n  public type = \"positional\";\n\n  static fromSpec(sexp: SerializedCore.Params): PositionalArgs {\n    if (!sexp || sexp.length === 0) return PositionalArgs.empty();\n    return new PositionalArgs(sexp.map(buildExpression));\n  }\n\n  static build(exprs: ExpressionSyntax<Opaque>[]): PositionalArgs {\n    return new this(exprs);\n  }\n\n  static _empty: PositionalArgs;\n\n  static empty(): PositionalArgs {\n    return (this._empty = this._empty || new PositionalArgs([]));\n  }\n\n  values: ExpressionSyntax<Opaque>[];\n  length: number;\n  isStatic = false;\n\n  constructor(exprs: ExpressionSyntax<Opaque>[]) {\n    this.values = exprs;\n    this.length = exprs.length;\n  }\n\n  slice(start?: number, end?: number): PositionalArgs {\n    return PositionalArgs.build(this.values.slice(start, end));\n  }\n\n  at(index: number): ExpressionSyntax<Opaque> {\n    return this.values[index];\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledPositionalArgs {\n    return CompiledPositionalArgs.create({ values: this.values.map(v => v.compile(compiler, env)) });\n  }\n}\n\nexport class NamedArgs {\n  public type = \"named\";\n\n  static fromSpec(sexp: SerializedCore.Hash): NamedArgs {\n    if (sexp === null || sexp === undefined) { return NamedArgs.empty(); }\n    let keys: InternedString[] = [];\n    let values = [];\n    let map = dict<ExpressionSyntax<Opaque>>();\n\n    Object.keys(sexp).forEach(key => {\n      keys.push(key as InternedString);\n      let value = map[key] = buildExpression(sexp[key]);\n      values.push(value);\n    });\n\n    return new this({ map });\n  }\n\n  static build(map: Dict<ExpressionSyntax<Opaque>>): NamedArgs {\n    let keys = [];\n    let values = [];\n\n    Object.keys(map).forEach(k => {\n      let value = map[k];\n      keys.push(k as InternedString);\n      values.push(value);\n    });\n\n    return new NamedArgs({ map });\n  }\n\n  static _empty;\n\n  static empty(): NamedArgs {\n    return (this._empty = this._empty || new NamedArgs({ map: dict<ExpressionSyntax<Opaque>>() }));\n  }\n\n  public map: Dict<ExpressionSyntax<Opaque>>;\n  public isStatic = false;\n\n  constructor({ map }: { map: Dict<ExpressionSyntax<Opaque>> }) {\n    this.map = map;\n  }\n\n  add(key: InternedString, value: ExpressionSyntax<Opaque>) {\n    this.map[<string>key] = value;\n  }\n\n  at(key: InternedString): ExpressionSyntax<Opaque> {\n    return this.map[<string>key];\n  }\n\n  has(key: InternedString): boolean {\n    return !!this.map[<string>key];\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledNamedArgs {\n    let { map } = this;\n\n    let compiledMap = dict<CompiledExpression<Opaque>>();\n\n    Object.keys(map).forEach(key => {\n      compiledMap[key] = map[key].compile(compiler, env);\n    });\n\n    return CompiledNamedArgs.create({ map: compiledMap });\n  }\n}\n\nexport class Templates {\n  public type = \"templates\";\n\n  static fromSpec([templateId, inverseId]: [number, number], children: InlineBlock[]): Templates {\n    return new Templates({\n      template: templateId === null ? null : children[templateId],\n      inverse: inverseId === null ? null : children[inverseId],\n    });\n  }\n\n  static empty(): Templates {\n    return new Templates({ template: null, inverse: null });\n  }\n\n  static build(template: InlineBlock, inverse: InlineBlock=null): Templates {\n    return new this({ template, inverse });\n  }\n\n  public default: InlineBlock;\n  public inverse: InlineBlock;\n\n  constructor(options: { template: InlineBlock, inverse: InlineBlock }) {\n    this.default = options.template;\n    this.inverse = options.inverse;\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/syntax/core.ts"],"names":[],"mappings":"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","file":"core.js","sourcesContent":["import { VM } from '../vm';\n\nimport {\n  BlockScanner\n} from '../scanner';\n\nimport SymbolTable from '../symbol-table';\n\nimport {\n  ATTRIBUTE as ATTRIBUTE_SYNTAX,\n  ARGUMENT as ARGUMENT_SYNTAX,\n  CompileInto,\n  Parameter as ParameterSyntax,\n  Attribute as AttributeSyntax,\n  Argument as ArgumentSyntax,\n  Expression as ExpressionSyntax,\n  Statement as StatementSyntax,\n  SymbolLookup\n} from '../syntax';\n\nimport {\n  InlineBlock\n} from '../compiled/blocks';\n\nimport {\n  Opcode\n} from '../opcodes';\n\nimport OpcodeBuilderDSL from '../compiled/opcodes/builder';\n\nimport {\n  PutValueOpcode\n} from '../compiled/opcodes/vm';\n\nimport {\n  PutComponentDefinitionOpcode,\n  OpenComponentOpcode,\n  CloseComponentOpcode\n} from '../compiled/opcodes/component';\n\nimport {\n  ModifierOpcode\n} from '../compiled/opcodes/dom';\n\nimport buildExpression from './expressions';\n\nimport {\n  CompiledArgs,\n  CompiledNamedArgs,\n  CompiledPositionalArgs,\n} from '../compiled/expressions/args';\n\nimport CompiledValue from '../compiled/expressions/value';\n\nimport {\n  CompiledLocalLookup,\n  CompiledSelfLookup\n} from '../compiled/expressions/lookups';\n\nimport CompiledHasBlock from '../compiled/expressions/has-block';\n\nimport CompiledHasBlockParams from '../compiled/expressions/has-block-params';\n\nimport CompiledHelper from '../compiled/expressions/helper';\n\nimport CompiledConcat from '../compiled/expressions/concat';\n\nimport {\n  CompiledExpression\n} from '../compiled/expressions';\n\nimport { Environment } from '../environment';\n\nimport { EMPTY_ARRAY } from '../utils';\n\nimport { Opaque } from 'glimmer-util';\n\nimport {\n  OpenPrimitiveElementOpcode,\n  FlushElementOpcode,\n  CloseElementOpcode,\n  StaticAttrOpcode,\n  DynamicAttrOpcode,\n  DynamicAttrNSOpcode\n} from '../compiled/opcodes/dom';\n\nimport {\n  OptimizedCautiousAppendOpcode,\n  OptimizedTrustingAppendOpcode,\n  GuardedCautiousAppendOpcode,\n  GuardedTrustingAppendOpcode\n} from '../compiled/opcodes/content';\n\nimport {\n  Statements as SerializedStatements,\n  Expressions as SerializedExpressions,\n  Core as SerializedCore\n} from 'glimmer-wire-format';\n\nexport class Block extends StatementSyntax {\n  public type = \"block\";\n\n  static fromSpec(sexp: SerializedStatements.Block, symbolTable: SymbolTable, scanner: BlockScanner): Block {\n    let [, path, params, hash, templateId, inverseId] = sexp;\n\n    let template = scanner.blockFor(symbolTable, templateId);\n    let inverse = (typeof inverseId === 'number') ? scanner.blockFor(symbolTable, inverseId) : null;\n\n    return new Block({\n      path,\n      args: Args.fromSpec(params, hash),\n      templates: Templates.fromSpec(template, inverse)\n    });\n  }\n\n  static build(options): Block {\n    return new this(options);\n  }\n\n  path: string[];\n  args: Args;\n  templates: Templates;\n\n  constructor(options: { path: string[], args: Args, templates: Templates }) {\n    super();\n    this.path = options.path;\n    this.args = options.args;\n    this.templates = options.templates;\n  }\n\n  scan(scanner: BlockScanner): StatementSyntax {\n    let { default: _default, inverse } = this.templates;\n\n    if (_default) scanner.addChild(_default);\n    if (inverse)  scanner.addChild(inverse);\n\n    return this;\n  }\n\n  compile(ops: CompileInto) {\n    throw new Error(\"SyntaxError\");\n  }\n}\n\ninterface AppendOpcode {\n  new(): Opcode;\n}\n\nabstract class Append extends StatementSyntax {\n  static fromSpec(sexp: SerializedStatements.Append): Append {\n    let [, value, trustingMorph] = sexp;\n    return new OptimizedAppend({ value: buildExpression(value), trustingMorph });\n  }\n\n  value: ExpressionSyntax<any>;\n  trustingMorph: boolean;\n\n  constructor({ value, trustingMorph }: { value: ExpressionSyntax<any>, trustingMorph: boolean }) {\n    super();\n    this.value = value;\n    this.trustingMorph = trustingMorph;\n  }\n}\n\nexport class OptimizedAppend extends Append {\n  public type = \"optimized-append\";\n\n  deopt(): UnoptimizedAppend {\n    return new UnoptimizedAppend(this);\n  }\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment, symbolTable: SymbolTable) {\n    compiler.append(new PutValueOpcode({ expression: this.value.compile(compiler, env, symbolTable) }));\n\n    if (this.trustingMorph) {\n      compiler.append(new OptimizedTrustingAppendOpcode());\n    } else {\n      compiler.append(new OptimizedCautiousAppendOpcode());\n    }\n  }\n}\n\nexport class UnoptimizedAppend extends Append {\n  public type = \"unoptimized-append\";\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment, symbolTable: SymbolTable) {\n    let expression = this.value.compile(compiler, env, symbolTable);\n\n    if (this.trustingMorph) {\n      compiler.append(new GuardedTrustingAppendOpcode(expression, symbolTable));\n    } else {\n      compiler.append(new GuardedCautiousAppendOpcode(expression, symbolTable));\n    }\n  }\n}\n\nexport const MODIFIER_SYNTAX = \"c0420397-8ff1-4241-882b-4b7a107c9632\";\n\nexport class Modifier extends StatementSyntax {\n  \"c0420397-8ff1-4241-882b-4b7a107c9632\" = true;\n\n  public type: string = \"modifier\";\n  public path: string[];\n  public args: Args;\n\n  static fromSpec(node) {\n    let [, path, params, hash] = node;\n\n    return new Modifier({\n      path,\n      args: Args.fromSpec(params, hash)\n    });\n  }\n\n  static build(path, options) {\n    return new Modifier({\n      path,\n      params: options.params,\n      hash: options.hash\n    });\n  }\n\n  constructor(options) {\n    super();\n    this.path = options.path;\n    this.args = options.args;\n  }\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment, symbolTable: SymbolTable) {\n    let args = this.args.compile(compiler, env, symbolTable);\n\n    if (env.hasModifier(this.path, symbolTable)) {\n      compiler.append(new ModifierOpcode(\n        this.path[0],\n        env.lookupModifier(this.path, symbolTable),\n        args\n      ));\n    } else {\n      throw new Error(`Compile Error: ${this.path.join('.')} is not a modifier`);\n    }\n  }\n}\n\nexport class StaticArg extends ArgumentSyntax<string> {\n  public type = \"static-arg\";\n  name: string;\n  value: string;\n\n  static fromSpec(node: SerializedStatements.StaticArg): StaticArg {\n    let [, name, value] = node;\n    return new StaticArg({ name, value });\n  }\n\n  static build(name: string, value: string, namespace: string=null): StaticArg {\n    return new this({ name, value });\n  }\n\n  constructor({ name, value }) {\n    super();\n    this.name = name;\n    this.value = value;\n  }\n\n  compile() {\n    throw new Error(`Cannot compiler StaticArg \"${this.name}\" as it is a delegate for ValueSyntax<string>.`);\n  }\n\n  valueSyntax(): ExpressionSyntax<string> {\n    return Value.build(this.value);\n  }\n}\n\nexport class DynamicArg extends ArgumentSyntax<Opaque> {\n  public type = 'dynamic-arg';\n  static fromSpec(sexp: SerializedStatements.DynamicArg): DynamicArg {\n    let [, name, value] = sexp;\n\n    return new DynamicArg({\n      name,\n      value: buildExpression(value)\n    });\n  }\n\n  static build(name: string, value: ExpressionSyntax<string>): DynamicArg {\n    return new this({ name, value });\n  }\n\n  name: string;\n  value: ExpressionSyntax<Opaque>;\n  namespace: string;\n\n  constructor({ name, value, namespace = null }: { name: string, value: ExpressionSyntax<Opaque>, namespace?: string }) {\n    super();\n    this.name = name;\n    this.value = value;\n    this.namespace = namespace;\n  }\n\n  compile() {\n    throw new Error(`Cannot compile DynamicArg for \"${this.name}\" as it is delegate for ExpressionSyntax<Opaque>.`);\n  }\n\n  valueSyntax() {\n    return this.value;\n  }\n}\n\nexport class TrustingAttr {\n  static fromSpec(sexp: SerializedStatements.TrustingAttr): DynamicAttr {\n    let [, name, value, namespace] = sexp;\n    return new DynamicAttr({\n      name,\n      namespace,\n      isTrusting: true,\n      value: buildExpression(value)\n    });\n  }\n\n  static build(name: string, value: ExpressionSyntax<string>, isTrusting: boolean, namespace: string=null): DynamicAttr {\n    return new DynamicAttr({ name, value, namespace, isTrusting });\n  }\n\n  compile() { throw new Error('Attempting to compile a TrustingAttr which is just a delegate for DynamicAttr.'); }\n}\n\nexport class StaticAttr extends AttributeSyntax<string> {\n  \"e1185d30-7cac-4b12-b26a-35327d905d92\" = true;\n  type = \"static-attr\";\n\n  static fromSpec(node: SerializedStatements.StaticAttr): StaticAttr {\n    let [, name, value, namespace] = node;\n    return new StaticAttr({ name, value: value as string, namespace });\n  }\n\n  static build(name: string, value: string, namespace: string=null): StaticAttr {\n    return new this({ name, value, namespace });\n  }\n\n  name: string;\n  value: string;\n  namespace: string;\n  isTrusting = false;\n\n  constructor({ name, value, namespace = null }: { name: string, value: string, namespace?: string }) {\n    super();\n    this.name = name;\n    this.value = value;\n    this.namespace = namespace;\n  }\n\n  compile(compiler: CompileInto) {\n    compiler.append(new StaticAttrOpcode(this));\n  }\n\n  valueSyntax(): ExpressionSyntax<string> {\n    return Value.build(this.value);\n  }\n}\n\nexport class DynamicAttr extends AttributeSyntax<string> {\n  \"e1185d30-7cac-4b12-b26a-35327d905d92\" = true;\n  type = \"dynamic-attr\";\n\n  static fromSpec(sexp: SerializedStatements.DynamicAttr): DynamicAttr {\n    let [, name, value, namespace] = sexp;\n    return new DynamicAttr({\n      name,\n      namespace,\n      value: buildExpression(value)\n    });\n  }\n\n  static build(name: string, value: ExpressionSyntax<string>, isTrusting = false, namespace: string=null): DynamicAttr {\n    return new this({ name, value, namespace, isTrusting });\n  }\n\n  name: string;\n  value: ExpressionSyntax<string>;\n  namespace: string;\n  isTrusting: boolean;\n\n  constructor({ name, value, isTrusting = false, namespace = null }: { name: string, isTrusting?: boolean, value: ExpressionSyntax<string>, namespace?: string }) {\n    super();\n    this.name = name;\n    this.value = value;\n    this.namespace = namespace;\n    this.isTrusting = isTrusting;\n  }\n\n  compile(compiler: CompileInto & SymbolLookup, env: Environment, symbolTable: SymbolTable) {\n    let {namespace, value} = this;\n    compiler.append(new PutValueOpcode({ expression: value.compile(compiler, env, symbolTable) }));\n    if (namespace) {\n      compiler.append(new DynamicAttrNSOpcode(this));\n    } else {\n      compiler.append(new DynamicAttrOpcode(this));\n    }\n  }\n\n  valueSyntax(): ExpressionSyntax<string> {\n    return this.value;\n  }\n}\n\nexport class FlushElement extends StatementSyntax {\n  type = \"flush-element\";\n\n  static fromSpec() {\n    return new FlushElement();\n  }\n\n  static build() {\n    return new this();\n  }\n\n  compile(compiler: CompileInto) {\n    compiler.append(new FlushElementOpcode());\n  }\n}\n\nexport class CloseElement extends StatementSyntax {\n  type = \"close-element\";\n\n  static fromSpec() {\n    return new CloseElement();\n  }\n\n  static build() {\n    return new this();\n  }\n\n  compile(compiler: CompileInto) {\n    compiler.append(new CloseElementOpcode());\n  }\n}\n\nexport class Text extends StatementSyntax {\n  type = \"text\";\n\n  static fromSpec(node: SerializedStatements.Text): Text {\n    let [, content] = node;\n    return new Text({ content });\n  }\n\n  static build(content): Text {\n    return new this({ content });\n  }\n\n  public content: string;\n\n  constructor(options: { content: string }) {\n    super();\n    this.content = options.content;\n  }\n\n  compile(dsl: OpcodeBuilderDSL) {\n    dsl.text(this.content);\n  }\n}\n\nexport class Comment extends StatementSyntax {\n  type = \"comment\";\n\n  static fromSpec(sexp: SerializedStatements.Comment): Comment {\n    let [, value] = sexp;\n\n    return new Comment({ value });\n  }\n\n  static build(value: string): Comment {\n    return new this({ value: value });\n  }\n\n  public comment: string;\n\n  constructor(options) {\n    super();\n    this.comment = options.value;\n  }\n\n  compile(dsl: OpcodeBuilderDSL) {\n    dsl.comment(this.comment);\n  }\n}\n\nexport class OpenElement extends StatementSyntax {\n  type = \"open-element\";\n\n  static fromSpec(sexp: SerializedStatements.OpenElement, symbolTable: SymbolTable): OpenElement {\n    let [, tag, blockParams] = sexp;\n\n    return new OpenElement({\n      tag,\n      blockParams,\n      symbolTable\n    });\n  }\n\n  static build(tag: string, blockParams: string[], symbolTable: SymbolTable): OpenElement {\n    return new this({ tag, blockParams, symbolTable });\n  }\n\n  public tag: string;\n  public blockParams: string[];\n  public symbolTable: SymbolTable;\n\n  constructor(options: { tag: string, blockParams: string[], symbolTable: SymbolTable }) {\n    super();\n    this.tag = options.tag;\n    this.blockParams = options.blockParams;\n    this.symbolTable = options.symbolTable;\n  }\n\n  scan(scanner: BlockScanner): StatementSyntax {\n    let { tag } = this;\n\n    if (scanner.env.hasComponentDefinition([tag], this.symbolTable)) {\n      let { args, attrs } = this.parameters(scanner);\n      scanner.startBlock(this.blockParams);\n      this.tagContents(scanner);\n      let template = scanner.endBlock(this.blockParams);\n      return new Component(tag, attrs, args, template);\n    } else {\n      return new OpenPrimitiveElement({ tag });\n    }\n  }\n\n  compile(list: CompileInto, env: Environment) {\n    list.append(new OpenPrimitiveElementOpcode(this.tag));\n  }\n\n  toIdentity(): OpenPrimitiveElement {\n    let { tag } = this;\n    return new OpenPrimitiveElement({ tag });\n  }\n\n  private parameters(scanner: BlockScanner): { args: Args, attrs: string[] } {\n    let current = scanner.next();\n    let attrs: string[] = [];\n    let argKeys: string[] = [];\n    let argValues: ExpressionSyntax<Opaque>[] = [];\n\n    while (!(current instanceof FlushElement)) {\n      if (current[MODIFIER_SYNTAX]) {\n        throw new Error(`Compile Error: Element modifiers are not allowed in components`);\n      }\n\n      let param = <ParameterSyntax<Opaque>>current;\n\n      if (current[ATTRIBUTE_SYNTAX]) {\n        attrs.push(param.name);\n\n        // REMOVE ME: attributes should not be treated as args\n        argKeys.push(param.name);\n        argValues.push(param.valueSyntax());\n      } else if (current[ARGUMENT_SYNTAX]) {\n        argKeys.push(param.name);\n        argValues.push(param.valueSyntax());\n      } else {\n        throw new Error(\"Expected FlushElement, but got ${current}\");\n      }\n\n      current = scanner.next();\n    }\n\n    return { args: Args.fromNamedArgs(NamedArgs.build(argKeys, argValues)), attrs };\n  }\n\n  private tagContents(scanner: BlockScanner) {\n    let nesting = 1;\n\n    while (true) {\n      let current = scanner.next();\n      if (current instanceof CloseElement && --nesting === 0) {\n        break;\n      }\n\n      scanner.addStatement(current);\n\n      if (current instanceof OpenElement || current instanceof OpenPrimitiveElement) {\n        nesting++;\n      }\n    }\n  }\n}\n\nexport class Component extends StatementSyntax {\n  public type = 'component';\n\n  constructor(\n    public tag: string,\n    public attrs: string[],\n    public args: Args,\n    public template: InlineBlock\n  ) {\n    super();\n  }\n\n  compile(list: CompileInto & SymbolLookup, env: Environment, symbolTable: SymbolTable) {\n    let definition = env.getComponentDefinition([this.tag], symbolTable);\n    let args = this.args.compile(list as SymbolLookup, env, symbolTable);\n    let shadow = this.attrs;\n    let templates = new Templates(this.template);\n\n    list.append(new PutComponentDefinitionOpcode(definition));\n    list.append(new OpenComponentOpcode(args, shadow, templates));\n    list.append(new CloseComponentOpcode());\n  }\n}\n\nexport class OpenPrimitiveElement extends StatementSyntax {\n  type = \"open-primitive-element\";\n\n  public tag: string;\n\n  static build(tag: string): OpenPrimitiveElement {\n    return new this({ tag });\n  }\n\n  constructor(options: { tag: string }) {\n    super();\n    this.tag = options.tag;\n  }\n\n  compile(compiler: CompileInto) {\n    compiler.append(new OpenPrimitiveElementOpcode(this.tag));\n  }\n}\n\nexport class Yield extends StatementSyntax {\n  static fromSpec(sexp: SerializedStatements.Yield): Yield {\n    let [, to, params] = sexp;\n\n    let args = Args.fromSpec(params, null);\n\n    return new Yield({ to, args });\n  }\n\n  static build(params: ExpressionSyntax<Opaque>[], to: string): Yield {\n    let args = Args.fromPositionalArgs(PositionalArgs.build(params));\n    return new this({ to, args });\n  }\n\n  type = \"yield\";\n  public to: string;\n  public args: Args;\n\n  constructor({ to, args }: { to: string, args: Args }) {\n    super();\n    this.to = to;\n    this.args = args;\n  }\n\n  compile(dsl: OpcodeBuilderDSL, env: Environment, symbolTable: SymbolTable) {\n    let to = dsl.getBlockSymbol(this.to);\n    let args = this.args.compile(dsl, env, symbolTable);\n    dsl.append(new OpenBlockOpcode({ to, label: this.to, args }));\n    dsl.append(new CloseBlockOpcode());\n  }\n}\n\nclass OpenBlockOpcode extends Opcode {\n  type = \"open-block\";\n  public to: number;\n  public label: string;\n  public args: CompiledArgs;\n\n  constructor({ to, label, args }: { to: number, label: string, args: CompiledArgs }) {\n    super();\n    this.to = to;\n    this.label = label;\n    this.args = args;\n  }\n\n  evaluate(vm: VM) {\n    let block = vm.scope().getBlock(this.to);\n    let args;\n\n    if (block) {\n      args = this.args.evaluate(vm);\n    }\n\n    // FIXME: can we avoid doing this when we don't have a block?\n    vm.pushCallerScope();\n\n    if (block) {\n      vm.invokeBlock(block, args);\n    }\n  }\n}\n\nexport class CloseBlockOpcode extends Opcode {\n  public type = \"close-block\";\n\n  evaluate(vm: VM) {\n    vm.popScope();\n  }\n}\n\nexport class Value<T extends SerializedExpressions.Value> extends ExpressionSyntax<T> {\n  type = \"value\";\n\n  static fromSpec<U extends SerializedExpressions.Value>(value: U): Value<U> {\n    return new Value(value);\n  }\n\n  static build<U extends SerializedExpressions.Value>(value: U): Value<U> {\n    return new this(value);\n  }\n\n  public value: T;\n\n  constructor(value: T) {\n    super();\n    this.value = value;\n  }\n\n  inner(): T {\n    return this.value;\n  }\n\n  compile(compiler: SymbolLookup): CompiledExpression<T> {\n    return new CompiledValue<T>(this);\n  }\n}\n\nexport class GetArgument<T> extends ExpressionSyntax<T> {\n  type = \"get-argument\";\n\n  static fromSpec(sexp: SerializedExpressions.Arg): GetArgument<Opaque> {\n    let [, parts] = sexp;\n\n    return new GetArgument<Opaque>({ parts });\n  }\n\n  static build(path: string): GetArgument<Opaque> {\n    return new this<Opaque>({ parts: path.split('.') });\n  }\n\n  public parts: string[];\n\n  constructor(options: { parts: string[] }) {\n    super();\n    this.parts = options.parts;\n  }\n\n  compile(lookup: SymbolLookup): CompiledExpression<T> {\n    let { parts } = this;\n    let head = parts[0];\n    let symbol = lookup.getNamedSymbol(head);\n\n    let path = parts.slice(1);\n    return new CompiledLocalLookup(symbol, path, head);\n  }\n}\n\n// this is separated out from Get because Unknown also has a ref, but it\n// may turn out to be a helper\nexport class Ref extends ExpressionSyntax<Opaque> {\n  type = \"ref\";\n\n  static build(path: string): Ref {\n    let parts = path.split('.');\n\n    if (parts[0] === 'this') {\n      parts[0] = null;\n    }\n\n    return new this(parts);\n  }\n\n  constructor(public parts: string[]) {\n    super();\n    this.parts = parts;\n  }\n\n  compile(lookup: SymbolLookup): CompiledExpression<Opaque> {\n    let { parts } = this;\n    let head = parts[0];\n    let path = parts.slice(1);\n\n    if (head === null) { // {{this.foo}}\n      return new CompiledSelfLookup(path);\n    } else if (lookup.hasLocalSymbol(head)) {\n      let symbol = lookup.getLocalSymbol(head);\n      return new CompiledLocalLookup(symbol, path, head);\n    } else {\n      return new CompiledSelfLookup(parts);\n    }\n  }\n}\n\nexport class Get extends ExpressionSyntax<Opaque> {\n  type = \"get\";\n\n  static fromSpec(sexp: SerializedExpressions.Get): Get {\n    let [, parts] = sexp;\n    return new this(new Ref(parts));\n  }\n\n  static build(path: string): Get {\n    return new this(Ref.build(path));\n  }\n\n  constructor(public ref: Ref) {\n    super();\n  }\n\n  compile(compiler: SymbolLookup): CompiledExpression<Opaque> {\n    return this.ref.compile(compiler);\n  }\n}\n\nexport class Unknown extends ExpressionSyntax<any> {\n  public type = \"unknown\";\n\n  static fromSpec(sexp: SerializedExpressions.Unknown): Unknown {\n    let [, path] = sexp;\n\n    return new this(new Ref(path));\n  }\n\n  static build(path: string): Unknown {\n    return new this(Ref.build(path));\n  }\n\n  constructor(public ref: Ref) {\n    super();\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, symbolTable: SymbolTable): CompiledExpression<Opaque> {\n    let { ref } = this;\n\n    if (env.hasHelper(ref.parts, symbolTable)) {\n      return new CompiledHelper(ref.parts, env.lookupHelper(ref.parts, symbolTable), CompiledArgs.empty(), symbolTable);\n    } else {\n      return this.ref.compile(compiler);\n    }\n  }\n}\n\nexport class Helper extends ExpressionSyntax<Opaque> {\n  type = \"helper\";\n\n  static fromSpec(sexp: SerializedExpressions.Helper): Helper {\n    let [, path, params, hash] = sexp;\n\n    return new Helper({\n      ref: new Ref(path),\n      args: Args.fromSpec(params, hash)\n    });\n  }\n\n  static build(path: string, positional: PositionalArgs, named: NamedArgs): Helper {\n    return new this({ ref: Ref.build(path), args: Args.build(positional, named) });\n  }\n\n  isStatic = false;\n  ref: Ref;\n  args: Args;\n\n  constructor(options: { ref: Ref, args: Args }) {\n    super();\n    this.ref = options.ref;\n    this.args = options.args;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, symbolTable: SymbolTable): CompiledExpression<Opaque> {\n    if (env.hasHelper(this.ref.parts, symbolTable)) {\n      let { args, ref } = this;\n      return new CompiledHelper(ref.parts, env.lookupHelper(ref.parts, symbolTable), args.compile(compiler, env, symbolTable), symbolTable);\n    } else {\n      throw new Error(`Compile Error: ${this.ref.parts.join('.')} is not a helper`);\n    }\n  }\n}\n\nexport class HasBlock extends ExpressionSyntax<boolean> {\n  type = \"has-block\";\n\n  static fromSpec(sexp: SerializedExpressions.HasBlock): HasBlock {\n    let [, blockName] = sexp;\n    return new HasBlock({ blockName });\n  }\n\n  static build(blockName: string): HasBlock {\n    return new this({ blockName });\n  }\n\n  blockName: string;\n\n  constructor({ blockName }: { blockName: string }) {\n    super();\n    this.blockName = blockName;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledHasBlock {\n    return new CompiledHasBlock({\n      blockName: this.blockName,\n      blockSymbol: compiler.getBlockSymbol(this.blockName)\n    });\n  }\n}\n\nexport class HasBlockParams extends ExpressionSyntax<boolean> {\n  type = \"has-block-params\";\n\n  static fromSpec(sexp: SerializedExpressions.HasBlockParams): HasBlockParams {\n    let [, blockName] = sexp;\n    return new HasBlockParams({ blockName });\n  }\n\n  static build(blockName: string): HasBlockParams {\n    return new this({ blockName });\n  }\n\n  blockName: string;\n\n  constructor({ blockName }: { blockName: string }) {\n    super();\n    this.blockName = blockName;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledHasBlockParams {\n    return new CompiledHasBlockParams({\n      blockName: this.blockName,\n      blockSymbol: compiler.getBlockSymbol(this.blockName)\n    });\n  }\n}\n\nexport class Concat {\n  type = \"concat\";\n\n  static fromSpec(sexp: SerializedExpressions.Concat): Concat {\n    let [, params] = sexp;\n\n    return new Concat({ parts: params.map(buildExpression) });\n  }\n\n  static build(parts): Concat {\n    return new this({ parts });\n  }\n\n  isStatic = false;\n  parts: ExpressionSyntax<Opaque>[];\n\n  constructor({ parts }: { parts: ExpressionSyntax<Opaque>[] }) {\n    this.parts = parts;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, symbolTable: SymbolTable): CompiledConcat {\n    return new CompiledConcat({ parts: this.parts.map(p => p.compile(compiler, env, symbolTable)) });\n  }\n}\n\nexport class Args {\n  public type = \"args\";\n\n  static empty(): Args {\n    return EMPTY_ARGS;\n  }\n\n  static fromSpec(positional: SerializedCore.Params, named: SerializedCore.Hash): Args {\n    return new Args(PositionalArgs.fromSpec(positional), NamedArgs.fromSpec(named));\n  }\n\n  static fromPositionalArgs(positional: PositionalArgs): Args {\n    return new Args(positional, EMPTY_NAMED_ARGS);\n  }\n\n  static fromNamedArgs(named: NamedArgs): Args {\n    return new Args(EMPTY_POSITIONAL_ARGS, named);\n  }\n\n  static build(positional: PositionalArgs, named: NamedArgs): Args {\n    if (positional === EMPTY_POSITIONAL_ARGS && named === EMPTY_NAMED_ARGS) {\n      return EMPTY_ARGS;\n    } else {\n      return new this(positional, named);\n    }\n  }\n\n  constructor(\n    public positional: PositionalArgs,\n    public named: NamedArgs\n  ) {\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, symbolTable: SymbolTable): CompiledArgs {\n    let { positional, named } = this;\n    return CompiledArgs.create(positional.compile(compiler, env, symbolTable), named.compile(compiler, env, symbolTable));\n  }\n}\n\nexport class PositionalArgs {\n  public type = \"positional\";\n\n  static empty(): PositionalArgs {\n    return EMPTY_POSITIONAL_ARGS;\n  }\n\n  static fromSpec(sexp: SerializedCore.Params): PositionalArgs {\n    if (!sexp || sexp.length === 0) return EMPTY_POSITIONAL_ARGS;\n    return new PositionalArgs(sexp.map(buildExpression));\n  }\n\n  static build(exprs: ExpressionSyntax<Opaque>[]): PositionalArgs {\n    if (exprs.length === 0) {\n      return EMPTY_POSITIONAL_ARGS;\n    } else {\n      return new this(exprs);\n    }\n  }\n\n  public length: number;\n\n  constructor(public values: ExpressionSyntax<Opaque>[]) {\n    this.length = values.length;\n  }\n\n  slice(start?: number, end?: number): PositionalArgs {\n    return PositionalArgs.build(this.values.slice(start, end));\n  }\n\n  at(index: number): ExpressionSyntax<Opaque> {\n    return this.values[index];\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, symbolTable: SymbolTable): CompiledPositionalArgs {\n    return CompiledPositionalArgs.create(this.values.map(v => v.compile(compiler, env, symbolTable)));\n  }\n}\n\nconst EMPTY_POSITIONAL_ARGS = new (class extends PositionalArgs {\n  constructor() {\n    super(EMPTY_ARRAY);\n  }\n\n  slice(start?: number, end?: number): PositionalArgs {\n    return this;\n  }\n\n  at(index: number): ExpressionSyntax<Opaque> {\n    return undefined; // ??!\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledPositionalArgs {\n    return CompiledPositionalArgs.empty();\n  }\n});\n\nexport class NamedArgs {\n  public type = \"named\";\n\n  static empty(): NamedArgs {\n    return EMPTY_NAMED_ARGS;\n  }\n\n  static fromSpec(sexp: SerializedCore.Hash): NamedArgs {\n    if (sexp === null || sexp === undefined) { return EMPTY_NAMED_ARGS; }\n\n    let [keys, exprs] = sexp;\n\n    if (keys.length === 0) { return EMPTY_NAMED_ARGS; }\n\n    return new this(keys, exprs.map(expr => buildExpression(expr)));\n  }\n\n  static build(keys: string[], values: ExpressionSyntax<Opaque>[]): NamedArgs {\n    if (keys.length === 0) {\n      return EMPTY_NAMED_ARGS;\n    } else {\n      return new this(keys, values);\n    }\n  }\n\n  public length: number;\n\n  constructor(\n    public keys: string[],\n    public values: ExpressionSyntax<Opaque>[]\n  ) {\n    this.length = keys.length;\n  }\n\n  at(key: string): ExpressionSyntax<Opaque> {\n    let { keys, values } = this;\n    let index = keys.indexOf(key);\n    return values[index];\n  }\n\n  has(key: string): boolean {\n    return this.keys.indexOf(key) !== -1;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment, symbolTable: SymbolTable): CompiledNamedArgs {\n    let { keys, values } = this;\n    return new CompiledNamedArgs(keys, values.map(value => value.compile(compiler, env, symbolTable)));\n  }\n}\n\nconst EMPTY_NAMED_ARGS = new (class extends NamedArgs {\n  constructor() {\n    super(EMPTY_ARRAY, EMPTY_ARRAY);\n  }\n\n  at(key: string): ExpressionSyntax<Opaque> {\n    return undefined; // ??!\n  }\n\n  has(key: string): boolean {\n    return false;\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledNamedArgs {\n    return CompiledNamedArgs.empty();\n  }\n});\n\nconst EMPTY_ARGS: Args = new (class extends Args {\n  constructor() {\n    super(EMPTY_POSITIONAL_ARGS, EMPTY_NAMED_ARGS);\n  }\n\n  compile(compiler: SymbolLookup, env: Environment): CompiledArgs {\n    return CompiledArgs.empty();\n  }\n});\n\nexport class Templates {\n  public type = \"templates\";\n\n  static fromSpec(_default: InlineBlock, inverse: InlineBlock = null): Templates {\n    return new Templates(_default, inverse);\n  }\n\n  static empty(): Templates {\n    return new Templates(null, null);\n  }\n\n  public default: InlineBlock;\n  public inverse: InlineBlock;\n\n  constructor(_default: InlineBlock, inverse: InlineBlock = null) {\n    this.default = _default;\n    this.inverse = inverse;\n  }\n}\n","import { ATTRIBUTE as ATTRIBUTE_SYNTAX, ARGUMENT as ARGUMENT_SYNTAX, Attribute as AttributeSyntax, Argument as ArgumentSyntax, Expression as ExpressionSyntax, Statement as StatementSyntax } from '../syntax';\nimport { Opcode } from '../opcodes';\nimport { PutValueOpcode } from '../compiled/opcodes/vm';\nimport { PutComponentDefinitionOpcode, OpenComponentOpcode, CloseComponentOpcode } from '../compiled/opcodes/component';\nimport { ModifierOpcode } from '../compiled/opcodes/dom';\nimport buildExpression from './expressions';\nimport { CompiledArgs, CompiledNamedArgs, CompiledPositionalArgs, } from '../compiled/expressions/args';\nimport CompiledValue from '../compiled/expressions/value';\nimport { CompiledLocalLookup, CompiledSelfLookup } from '../compiled/expressions/lookups';\nimport CompiledHasBlock from '../compiled/expressions/has-block';\nimport CompiledHasBlockParams from '../compiled/expressions/has-block-params';\nimport CompiledHelper from '../compiled/expressions/helper';\nimport CompiledConcat from '../compiled/expressions/concat';\nimport { EMPTY_ARRAY } from '../utils';\nimport { OpenPrimitiveElementOpcode, FlushElementOpcode, CloseElementOpcode, StaticAttrOpcode, DynamicAttrOpcode, DynamicAttrNSOpcode } from '../compiled/opcodes/dom';\nimport { OptimizedCautiousAppendOpcode, OptimizedTrustingAppendOpcode, GuardedCautiousAppendOpcode, GuardedTrustingAppendOpcode } from '../compiled/opcodes/content';\nexport class Block extends StatementSyntax {\n    constructor(options) {\n        super();\n        this.type = \"block\";\n        this.path = options.path;\n        this.args = options.args;\n        this.templates = options.templates;\n    }\n    static fromSpec(sexp, symbolTable, scanner) {\n        let [, path, params, hash, templateId, inverseId] = sexp;\n        let template = scanner.blockFor(symbolTable, templateId);\n        let inverse = (typeof inverseId === 'number') ? scanner.blockFor(symbolTable, inverseId) : null;\n        return new Block({\n            path,\n            args: Args.fromSpec(params, hash),\n            templates: Templates.fromSpec(template, inverse)\n        });\n    }\n    static build(options) {\n        return new this(options);\n    }\n    scan(scanner) {\n        let { default: _default, inverse } = this.templates;\n        if (_default)\n            scanner.addChild(_default);\n        if (inverse)\n            scanner.addChild(inverse);\n        return this;\n    }\n    compile(ops) {\n        throw new Error(\"SyntaxError\");\n    }\n}\nclass Append extends StatementSyntax {\n    static fromSpec(sexp) {\n        let [, value, trustingMorph] = sexp;\n        return new OptimizedAppend({ value: buildExpression(value), trustingMorph });\n    }\n    constructor({ value, trustingMorph }) {\n        super();\n        this.value = value;\n        this.trustingMorph = trustingMorph;\n    }\n}\nexport class OptimizedAppend extends Append {\n    constructor() {\n        super(...arguments);\n        this.type = \"optimized-append\";\n    }\n    deopt() {\n        return new UnoptimizedAppend(this);\n    }\n    compile(compiler, env, symbolTable) {\n        compiler.append(new PutValueOpcode({ expression: this.value.compile(compiler, env, symbolTable) }));\n        if (this.trustingMorph) {\n            compiler.append(new OptimizedTrustingAppendOpcode());\n        }\n        else {\n            compiler.append(new OptimizedCautiousAppendOpcode());\n        }\n    }\n}\nexport class UnoptimizedAppend extends Append {\n    constructor() {\n        super(...arguments);\n        this.type = \"unoptimized-append\";\n    }\n    compile(compiler, env, symbolTable) {\n        let expression = this.value.compile(compiler, env, symbolTable);\n        if (this.trustingMorph) {\n            compiler.append(new GuardedTrustingAppendOpcode(expression, symbolTable));\n        }\n        else {\n            compiler.append(new GuardedCautiousAppendOpcode(expression, symbolTable));\n        }\n    }\n}\nexport const MODIFIER_SYNTAX = \"c0420397-8ff1-4241-882b-4b7a107c9632\";\nexport class Modifier extends StatementSyntax {\n    constructor(options) {\n        super();\n        this[\"c0420397-8ff1-4241-882b-4b7a107c9632\"] = true;\n        this.type = \"modifier\";\n        this.path = options.path;\n        this.args = options.args;\n    }\n    static fromSpec(node) {\n        let [, path, params, hash] = node;\n        return new Modifier({\n            path,\n            args: Args.fromSpec(params, hash)\n        });\n    }\n    static build(path, options) {\n        return new Modifier({\n            path,\n            params: options.params,\n            hash: options.hash\n        });\n    }\n    compile(compiler, env, symbolTable) {\n        let args = this.args.compile(compiler, env, symbolTable);\n        if (env.hasModifier(this.path, symbolTable)) {\n            compiler.append(new ModifierOpcode(this.path[0], env.lookupModifier(this.path, symbolTable), args));\n        }\n        else {\n            throw new Error(`Compile Error: ${this.path.join('.')} is not a modifier`);\n        }\n    }\n}\nexport class StaticArg extends ArgumentSyntax {\n    constructor({ name, value }) {\n        super();\n        this.type = \"static-arg\";\n        this.name = name;\n        this.value = value;\n    }\n    static fromSpec(node) {\n        let [, name, value] = node;\n        return new StaticArg({ name, value });\n    }\n    static build(name, value, namespace = null) {\n        return new this({ name, value });\n    }\n    compile() {\n        throw new Error(`Cannot compiler StaticArg \"${this.name}\" as it is a delegate for ValueSyntax<string>.`);\n    }\n    valueSyntax() {\n        return Value.build(this.value);\n    }\n}\nexport class DynamicArg extends ArgumentSyntax {\n    constructor({ name, value, namespace = null }) {\n        super();\n        this.type = 'dynamic-arg';\n        this.name = name;\n        this.value = value;\n        this.namespace = namespace;\n    }\n    static fromSpec(sexp) {\n        let [, name, value] = sexp;\n        return new DynamicArg({\n            name,\n            value: buildExpression(value)\n        });\n    }\n    static build(name, value) {\n        return new this({ name, value });\n    }\n    compile() {\n        throw new Error(`Cannot compile DynamicArg for \"${this.name}\" as it is delegate for ExpressionSyntax<Opaque>.`);\n    }\n    valueSyntax() {\n        return this.value;\n    }\n}\nexport class TrustingAttr {\n    static fromSpec(sexp) {\n        let [, name, value, namespace] = sexp;\n        return new DynamicAttr({\n            name,\n            namespace,\n            isTrusting: true,\n            value: buildExpression(value)\n        });\n    }\n    static build(name, value, isTrusting, namespace = null) {\n        return new DynamicAttr({ name, value, namespace, isTrusting });\n    }\n    compile() { throw new Error('Attempting to compile a TrustingAttr which is just a delegate for DynamicAttr.'); }\n}\nexport class StaticAttr extends AttributeSyntax {\n    constructor({ name, value, namespace = null }) {\n        super();\n        this[\"e1185d30-7cac-4b12-b26a-35327d905d92\"] = true;\n        this.type = \"static-attr\";\n        this.isTrusting = false;\n        this.name = name;\n        this.value = value;\n        this.namespace = namespace;\n    }\n    static fromSpec(node) {\n        let [, name, value, namespace] = node;\n        return new StaticAttr({ name, value: value, namespace });\n    }\n    static build(name, value, namespace = null) {\n        return new this({ name, value, namespace });\n    }\n    compile(compiler) {\n        compiler.append(new StaticAttrOpcode(this));\n    }\n    valueSyntax() {\n        return Value.build(this.value);\n    }\n}\nexport class DynamicAttr extends AttributeSyntax {\n    constructor({ name, value, isTrusting = false, namespace = null }) {\n        super();\n        this[\"e1185d30-7cac-4b12-b26a-35327d905d92\"] = true;\n        this.type = \"dynamic-attr\";\n        this.name = name;\n        this.value = value;\n        this.namespace = namespace;\n        this.isTrusting = isTrusting;\n    }\n    static fromSpec(sexp) {\n        let [, name, value, namespace] = sexp;\n        return new DynamicAttr({\n            name,\n            namespace,\n            value: buildExpression(value)\n        });\n    }\n    static build(name, value, isTrusting = false, namespace = null) {\n        return new this({ name, value, namespace, isTrusting });\n    }\n    compile(compiler, env, symbolTable) {\n        let { namespace, value } = this;\n        compiler.append(new PutValueOpcode({ expression: value.compile(compiler, env, symbolTable) }));\n        if (namespace) {\n            compiler.append(new DynamicAttrNSOpcode(this));\n        }\n        else {\n            compiler.append(new DynamicAttrOpcode(this));\n        }\n    }\n    valueSyntax() {\n        return this.value;\n    }\n}\nexport class FlushElement extends StatementSyntax {\n    constructor() {\n        super(...arguments);\n        this.type = \"flush-element\";\n    }\n    static fromSpec() {\n        return new FlushElement();\n    }\n    static build() {\n        return new this();\n    }\n    compile(compiler) {\n        compiler.append(new FlushElementOpcode());\n    }\n}\nexport class CloseElement extends StatementSyntax {\n    constructor() {\n        super(...arguments);\n        this.type = \"close-element\";\n    }\n    static fromSpec() {\n        return new CloseElement();\n    }\n    static build() {\n        return new this();\n    }\n    compile(compiler) {\n        compiler.append(new CloseElementOpcode());\n    }\n}\nexport class Text extends StatementSyntax {\n    constructor(options) {\n        super();\n        this.type = \"text\";\n        this.content = options.content;\n    }\n    static fromSpec(node) {\n        let [, content] = node;\n        return new Text({ content });\n    }\n    static build(content) {\n        return new this({ content });\n    }\n    compile(dsl) {\n        dsl.text(this.content);\n    }\n}\nexport class Comment extends StatementSyntax {\n    constructor(options) {\n        super();\n        this.type = \"comment\";\n        this.comment = options.value;\n    }\n    static fromSpec(sexp) {\n        let [, value] = sexp;\n        return new Comment({ value });\n    }\n    static build(value) {\n        return new this({ value: value });\n    }\n    compile(dsl) {\n        dsl.comment(this.comment);\n    }\n}\nexport class OpenElement extends StatementSyntax {\n    constructor(options) {\n        super();\n        this.type = \"open-element\";\n        this.tag = options.tag;\n        this.blockParams = options.blockParams;\n        this.symbolTable = options.symbolTable;\n    }\n    static fromSpec(sexp, symbolTable) {\n        let [, tag, blockParams] = sexp;\n        return new OpenElement({\n            tag,\n            blockParams,\n            symbolTable\n        });\n    }\n    static build(tag, blockParams, symbolTable) {\n        return new this({ tag, blockParams, symbolTable });\n    }\n    scan(scanner) {\n        let { tag } = this;\n        if (scanner.env.hasComponentDefinition([tag], this.symbolTable)) {\n            let { args, attrs } = this.parameters(scanner);\n            scanner.startBlock(this.blockParams);\n            this.tagContents(scanner);\n            let template = scanner.endBlock(this.blockParams);\n            return new Component(tag, attrs, args, template);\n        }\n        else {\n            return new OpenPrimitiveElement({ tag });\n        }\n    }\n    compile(list, env) {\n        list.append(new OpenPrimitiveElementOpcode(this.tag));\n    }\n    toIdentity() {\n        let { tag } = this;\n        return new OpenPrimitiveElement({ tag });\n    }\n    parameters(scanner) {\n        let current = scanner.next();\n        let attrs = [];\n        let argKeys = [];\n        let argValues = [];\n        while (!(current instanceof FlushElement)) {\n            if (current[MODIFIER_SYNTAX]) {\n                throw new Error(`Compile Error: Element modifiers are not allowed in components`);\n            }\n            let param = current;\n            if (current[ATTRIBUTE_SYNTAX]) {\n                attrs.push(param.name);\n                // REMOVE ME: attributes should not be treated as args\n                argKeys.push(param.name);\n                argValues.push(param.valueSyntax());\n            }\n            else if (current[ARGUMENT_SYNTAX]) {\n                argKeys.push(param.name);\n                argValues.push(param.valueSyntax());\n            }\n            else {\n                throw new Error(\"Expected FlushElement, but got ${current}\");\n            }\n            current = scanner.next();\n        }\n        return { args: Args.fromNamedArgs(NamedArgs.build(argKeys, argValues)), attrs };\n    }\n    tagContents(scanner) {\n        let nesting = 1;\n        while (true) {\n            let current = scanner.next();\n            if (current instanceof CloseElement && --nesting === 0) {\n                break;\n            }\n            scanner.addStatement(current);\n            if (current instanceof OpenElement || current instanceof OpenPrimitiveElement) {\n                nesting++;\n            }\n        }\n    }\n}\nexport class Component extends StatementSyntax {\n    constructor(tag, attrs, args, template) {\n        super();\n        this.tag = tag;\n        this.attrs = attrs;\n        this.args = args;\n        this.template = template;\n        this.type = 'component';\n    }\n    compile(list, env, symbolTable) {\n        let definition = env.getComponentDefinition([this.tag], symbolTable);\n        let args = this.args.compile(list, env, symbolTable);\n        let shadow = this.attrs;\n        let templates = new Templates(this.template);\n        list.append(new PutComponentDefinitionOpcode(definition));\n        list.append(new OpenComponentOpcode(args, shadow, templates));\n        list.append(new CloseComponentOpcode());\n    }\n}\nexport class OpenPrimitiveElement extends StatementSyntax {\n    constructor(options) {\n        super();\n        this.type = \"open-primitive-element\";\n        this.tag = options.tag;\n    }\n    static build(tag) {\n        return new this({ tag });\n    }\n    compile(compiler) {\n        compiler.append(new OpenPrimitiveElementOpcode(this.tag));\n    }\n}\nexport class Yield extends StatementSyntax {\n    constructor({ to, args }) {\n        super();\n        this.type = \"yield\";\n        this.to = to;\n        this.args = args;\n    }\n    static fromSpec(sexp) {\n        let [, to, params] = sexp;\n        let args = Args.fromSpec(params, null);\n        return new Yield({ to, args });\n    }\n    static build(params, to) {\n        let args = Args.fromPositionalArgs(PositionalArgs.build(params));\n        return new this({ to, args });\n    }\n    compile(dsl, env, symbolTable) {\n        let to = dsl.getBlockSymbol(this.to);\n        let args = this.args.compile(dsl, env, symbolTable);\n        dsl.append(new OpenBlockOpcode({ to, label: this.to, args }));\n        dsl.append(new CloseBlockOpcode());\n    }\n}\nclass OpenBlockOpcode extends Opcode {\n    constructor({ to, label, args }) {\n        super();\n        this.type = \"open-block\";\n        this.to = to;\n        this.label = label;\n        this.args = args;\n    }\n    evaluate(vm) {\n        let block = vm.scope().getBlock(this.to);\n        let args;\n        if (block) {\n            args = this.args.evaluate(vm);\n        }\n        // FIXME: can we avoid doing this when we don't have a block?\n        vm.pushCallerScope();\n        if (block) {\n            vm.invokeBlock(block, args);\n        }\n    }\n}\nexport class CloseBlockOpcode extends Opcode {\n    constructor() {\n        super(...arguments);\n        this.type = \"close-block\";\n    }\n    evaluate(vm) {\n        vm.popScope();\n    }\n}\nexport class Value extends ExpressionSyntax {\n    constructor(value) {\n        super();\n        this.type = \"value\";\n        this.value = value;\n    }\n    static fromSpec(value) {\n        return new Value(value);\n    }\n    static build(value) {\n        return new this(value);\n    }\n    inner() {\n        return this.value;\n    }\n    compile(compiler) {\n        return new CompiledValue(this);\n    }\n}\nexport class GetArgument extends ExpressionSyntax {\n    constructor(options) {\n        super();\n        this.type = \"get-argument\";\n        this.parts = options.parts;\n    }\n    static fromSpec(sexp) {\n        let [, parts] = sexp;\n        return new GetArgument({ parts });\n    }\n    static build(path) {\n        return new this({ parts: path.split('.') });\n    }\n    compile(lookup) {\n        let { parts } = this;\n        let head = parts[0];\n        let symbol = lookup.getNamedSymbol(head);\n        let path = parts.slice(1);\n        return new CompiledLocalLookup(symbol, path, head);\n    }\n}\n// this is separated out from Get because Unknown also has a ref, but it\n// may turn out to be a helper\nexport class Ref extends ExpressionSyntax {\n    constructor(parts) {\n        super();\n        this.parts = parts;\n        this.type = \"ref\";\n        this.parts = parts;\n    }\n    static build(path) {\n        let parts = path.split('.');\n        if (parts[0] === 'this') {\n            parts[0] = null;\n        }\n        return new this(parts);\n    }\n    compile(lookup) {\n        let { parts } = this;\n        let head = parts[0];\n        let path = parts.slice(1);\n        if (head === null) {\n            return new CompiledSelfLookup(path);\n        }\n        else if (lookup.hasLocalSymbol(head)) {\n            let symbol = lookup.getLocalSymbol(head);\n            return new CompiledLocalLookup(symbol, path, head);\n        }\n        else {\n            return new CompiledSelfLookup(parts);\n        }\n    }\n}\nexport class Get extends ExpressionSyntax {\n    constructor(ref) {\n        super();\n        this.ref = ref;\n        this.type = \"get\";\n    }\n    static fromSpec(sexp) {\n        let [, parts] = sexp;\n        return new this(new Ref(parts));\n    }\n    static build(path) {\n        return new this(Ref.build(path));\n    }\n    compile(compiler) {\n        return this.ref.compile(compiler);\n    }\n}\nexport class Unknown extends ExpressionSyntax {\n    constructor(ref) {\n        super();\n        this.ref = ref;\n        this.type = \"unknown\";\n    }\n    static fromSpec(sexp) {\n        let [, path] = sexp;\n        return new this(new Ref(path));\n    }\n    static build(path) {\n        return new this(Ref.build(path));\n    }\n    compile(compiler, env, symbolTable) {\n        let { ref } = this;\n        if (env.hasHelper(ref.parts, symbolTable)) {\n            return new CompiledHelper(ref.parts, env.lookupHelper(ref.parts, symbolTable), CompiledArgs.empty(), symbolTable);\n        }\n        else {\n            return this.ref.compile(compiler);\n        }\n    }\n}\nexport class Helper extends ExpressionSyntax {\n    constructor(options) {\n        super();\n        this.type = \"helper\";\n        this.isStatic = false;\n        this.ref = options.ref;\n        this.args = options.args;\n    }\n    static fromSpec(sexp) {\n        let [, path, params, hash] = sexp;\n        return new Helper({\n            ref: new Ref(path),\n            args: Args.fromSpec(params, hash)\n        });\n    }\n    static build(path, positional, named) {\n        return new this({ ref: Ref.build(path), args: Args.build(positional, named) });\n    }\n    compile(compiler, env, symbolTable) {\n        if (env.hasHelper(this.ref.parts, symbolTable)) {\n            let { args, ref } = this;\n            return new CompiledHelper(ref.parts, env.lookupHelper(ref.parts, symbolTable), args.compile(compiler, env, symbolTable), symbolTable);\n        }\n        else {\n            throw new Error(`Compile Error: ${this.ref.parts.join('.')} is not a helper`);\n        }\n    }\n}\nexport class HasBlock extends ExpressionSyntax {\n    constructor({ blockName }) {\n        super();\n        this.type = \"has-block\";\n        this.blockName = blockName;\n    }\n    static fromSpec(sexp) {\n        let [, blockName] = sexp;\n        return new HasBlock({ blockName });\n    }\n    static build(blockName) {\n        return new this({ blockName });\n    }\n    compile(compiler, env) {\n        return new CompiledHasBlock({\n            blockName: this.blockName,\n            blockSymbol: compiler.getBlockSymbol(this.blockName)\n        });\n    }\n}\nexport class HasBlockParams extends ExpressionSyntax {\n    constructor({ blockName }) {\n        super();\n        this.type = \"has-block-params\";\n        this.blockName = blockName;\n    }\n    static fromSpec(sexp) {\n        let [, blockName] = sexp;\n        return new HasBlockParams({ blockName });\n    }\n    static build(blockName) {\n        return new this({ blockName });\n    }\n    compile(compiler, env) {\n        return new CompiledHasBlockParams({\n            blockName: this.blockName,\n            blockSymbol: compiler.getBlockSymbol(this.blockName)\n        });\n    }\n}\nexport class Concat {\n    constructor({ parts }) {\n        this.type = \"concat\";\n        this.isStatic = false;\n        this.parts = parts;\n    }\n    static fromSpec(sexp) {\n        let [, params] = sexp;\n        return new Concat({ parts: params.map(buildExpression) });\n    }\n    static build(parts) {\n        return new this({ parts });\n    }\n    compile(compiler, env, symbolTable) {\n        return new CompiledConcat({ parts: this.parts.map(p => p.compile(compiler, env, symbolTable)) });\n    }\n}\nexport class Args {\n    constructor(positional, named) {\n        this.positional = positional;\n        this.named = named;\n        this.type = \"args\";\n    }\n    static empty() {\n        return EMPTY_ARGS;\n    }\n    static fromSpec(positional, named) {\n        return new Args(PositionalArgs.fromSpec(positional), NamedArgs.fromSpec(named));\n    }\n    static fromPositionalArgs(positional) {\n        return new Args(positional, EMPTY_NAMED_ARGS);\n    }\n    static fromNamedArgs(named) {\n        return new Args(EMPTY_POSITIONAL_ARGS, named);\n    }\n    static build(positional, named) {\n        if (positional === EMPTY_POSITIONAL_ARGS && named === EMPTY_NAMED_ARGS) {\n            return EMPTY_ARGS;\n        }\n        else {\n            return new this(positional, named);\n        }\n    }\n    compile(compiler, env, symbolTable) {\n        let { positional, named } = this;\n        return CompiledArgs.create(positional.compile(compiler, env, symbolTable), named.compile(compiler, env, symbolTable));\n    }\n}\nexport class PositionalArgs {\n    constructor(values) {\n        this.values = values;\n        this.type = \"positional\";\n        this.length = values.length;\n    }\n    static empty() {\n        return EMPTY_POSITIONAL_ARGS;\n    }\n    static fromSpec(sexp) {\n        if (!sexp || sexp.length === 0)\n            return EMPTY_POSITIONAL_ARGS;\n        return new PositionalArgs(sexp.map(buildExpression));\n    }\n    static build(exprs) {\n        if (exprs.length === 0) {\n            return EMPTY_POSITIONAL_ARGS;\n        }\n        else {\n            return new this(exprs);\n        }\n    }\n    slice(start, end) {\n        return PositionalArgs.build(this.values.slice(start, end));\n    }\n    at(index) {\n        return this.values[index];\n    }\n    compile(compiler, env, symbolTable) {\n        return CompiledPositionalArgs.create(this.values.map(v => v.compile(compiler, env, symbolTable)));\n    }\n}\nconst EMPTY_POSITIONAL_ARGS = new (class extends PositionalArgs {\n    constructor() {\n        super(EMPTY_ARRAY);\n    }\n    slice(start, end) {\n        return this;\n    }\n    at(index) {\n        return undefined; // ??!\n    }\n    compile(compiler, env) {\n        return CompiledPositionalArgs.empty();\n    }\n});\nexport class NamedArgs {\n    constructor(keys, values) {\n        this.keys = keys;\n        this.values = values;\n        this.type = \"named\";\n        this.length = keys.length;\n    }\n    static empty() {\n        return EMPTY_NAMED_ARGS;\n    }\n    static fromSpec(sexp) {\n        if (sexp === null || sexp === undefined) {\n            return EMPTY_NAMED_ARGS;\n        }\n        let [keys, exprs] = sexp;\n        if (keys.length === 0) {\n            return EMPTY_NAMED_ARGS;\n        }\n        return new this(keys, exprs.map(expr => buildExpression(expr)));\n    }\n    static build(keys, values) {\n        if (keys.length === 0) {\n            return EMPTY_NAMED_ARGS;\n        }\n        else {\n            return new this(keys, values);\n        }\n    }\n    at(key) {\n        let { keys, values } = this;\n        let index = keys.indexOf(key);\n        return values[index];\n    }\n    has(key) {\n        return this.keys.indexOf(key) !== -1;\n    }\n    compile(compiler, env, symbolTable) {\n        let { keys, values } = this;\n        return new CompiledNamedArgs(keys, values.map(value => value.compile(compiler, env, symbolTable)));\n    }\n}\nconst EMPTY_NAMED_ARGS = new (class extends NamedArgs {\n    constructor() {\n        super(EMPTY_ARRAY, EMPTY_ARRAY);\n    }\n    at(key) {\n        return undefined; // ??!\n    }\n    has(key) {\n        return false;\n    }\n    compile(compiler, env) {\n        return CompiledNamedArgs.empty();\n    }\n});\nconst EMPTY_ARGS = new (class extends Args {\n    constructor() {\n        super(EMPTY_POSITIONAL_ARGS, EMPTY_NAMED_ARGS);\n    }\n    compile(compiler, env) {\n        return CompiledArgs.empty();\n    }\n});\nexport class Templates {\n    constructor(_default, inverse = null) {\n        this.type = \"templates\";\n        this.default = _default;\n        this.inverse = inverse;\n    }\n    static fromSpec(_default, inverse = null) {\n        return new Templates(_default, inverse);\n    }\n    static empty() {\n        return new Templates(null, null);\n    }\n}\n"]} enifed('glimmer-runtime/lib/syntax/expressions', ['exports', 'glimmer-runtime/lib/syntax/core', 'glimmer-wire-format'], function (exports, _glimmerRuntimeLibSyntaxCore, _glimmerWireFormat) { 'use strict'; var isArg = _glimmerWireFormat.Expressions.isArg; var isConcat = _glimmerWireFormat.Expressions.isConcat; var isGet = _glimmerWireFormat.Expressions.isGet; - var isSelfGet = _glimmerWireFormat.Expressions.isSelfGet; var isHasBlock = _glimmerWireFormat.Expressions.isHasBlock; var isHasBlockParams = _glimmerWireFormat.Expressions.isHasBlockParams; var isHelper = _glimmerWireFormat.Expressions.isHelper; var isUnknown = _glimmerWireFormat.Expressions.isUnknown; - var isValue = _glimmerWireFormat.Expressions.isValue; + var isPrimitiveValue = _glimmerWireFormat.Expressions.isPrimitiveValue; + var isUndefined = _glimmerWireFormat.Expressions.isUndefined; exports.default = function (sexp) { - if (isValue(sexp)) { - return _glimmerRuntimeLibSyntaxCore.Value.fromSpec(sexp); - } else { - if (isArg(sexp)) return _glimmerRuntimeLibSyntaxCore.GetArgument.fromSpec(sexp); - if (isConcat(sexp)) return _glimmerRuntimeLibSyntaxCore.Concat.fromSpec(sexp); - if (isGet(sexp)) return _glimmerRuntimeLibSyntaxCore.Get.fromSpec(sexp); - if (isSelfGet(sexp)) return _glimmerRuntimeLibSyntaxCore.SelfGet.fromSpec(sexp); - if (isHelper(sexp)) return _glimmerRuntimeLibSyntaxCore.Helper.fromSpec(sexp); - if (isUnknown(sexp)) return _glimmerRuntimeLibSyntaxCore.Unknown.fromSpec(sexp); - if (isHasBlock(sexp)) return _glimmerRuntimeLibSyntaxCore.HasBlock.fromSpec(sexp); - if (isHasBlockParams(sexp)) return _glimmerRuntimeLibSyntaxCore.HasBlockParams.fromSpec(sexp); - } + if (isPrimitiveValue(sexp)) return _glimmerRuntimeLibSyntaxCore.Value.fromSpec(sexp); + if (isUndefined(sexp)) return _glimmerRuntimeLibSyntaxCore.Value.build(undefined); + if (isArg(sexp)) return _glimmerRuntimeLibSyntaxCore.GetArgument.fromSpec(sexp); + if (isConcat(sexp)) return _glimmerRuntimeLibSyntaxCore.Concat.fromSpec(sexp); + if (isGet(sexp)) return _glimmerRuntimeLibSyntaxCore.Get.fromSpec(sexp); + if (isHelper(sexp)) return _glimmerRuntimeLibSyntaxCore.Helper.fromSpec(sexp); + if (isUnknown(sexp)) return _glimmerRuntimeLibSyntaxCore.Unknown.fromSpec(sexp); + if (isHasBlock(sexp)) return _glimmerRuntimeLibSyntaxCore.HasBlock.fromSpec(sexp); + if (isHasBlockParams(sexp)) return _glimmerRuntimeLibSyntaxCore.HasBlockParams.fromSpec(sexp); + throw new Error('Unexpected wire format: ' + JSON.stringify(sexp)); }; ; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvc3ludGF4L2V4cHJlc3Npb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztRQWlCRSxLQUFLLHNCQUxMLFdBQVcsQ0FLWCxLQUFLO1FBQ0wsUUFBUSxzQkFOUixXQUFXLENBTVgsUUFBUTtRQUNSLEtBQUssc0JBUEwsV0FBVyxDQU9YLEtBQUs7UUFDTCxVQUFVLHNCQVJWLFdBQVcsQ0FRWCxVQUFVO1FBQ1YsZ0JBQWdCLHNCQVRoQixXQUFXLENBU1gsZ0JBQWdCO1FBQ2hCLFFBQVEsc0JBVlIsV0FBVyxDQVVYLFFBQVE7UUFDUixTQUFTLHNCQVhULFdBQVcsQ0FXWCxTQUFTO1FBQ1QsZ0JBQWdCLHNCQVpoQixXQUFXLENBWVgsZ0JBQWdCO1FBQ2hCLFdBQVcsc0JBYlgsV0FBVyxDQWFYLFdBQVc7O3NCQUdDLFVBQVUsSUFBMEIsRUFBQTtBQUNoRCxZQUFJLGdCQUFnQixDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBNUJuQyxLQUFLLENBNEIwQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDOUQsWUFBSSxXQUFXLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkE3QjlCLEtBQUssQ0E2QnFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUMzRCxZQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLDZCQTdCeEIsV0FBVyxDQTZCdUIsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ2pELFlBQUksUUFBUSxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBN0IzQixNQUFNLENBNkJrQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDdkQsWUFBSSxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkE3QnhCLEdBQUcsQ0E2QitCLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUNqRCxZQUFJLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLDZCQTNCM0IsTUFBTSxDQTJCa0MsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3ZELFlBQUksU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBM0I1QixPQUFPLENBMkJtQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDekQsWUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkEvQjdCLFFBQVEsQ0ErQm9DLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUMzRCxZQUFJLGdCQUFnQixDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBL0JuQyxjQUFjLENBK0IwQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7QUFFdkUsY0FBTSxJQUFJLEtBQUssOEJBQTRCLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUcsQ0FBQztLQUNwRTs7QUFBQSxLQUFDIiwiZmlsZSI6ImV4cHJlc3Npb25zLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgVmFsdWUgYXMgVmFsdWVTeW50YXgsXG4gIEdldEFyZ3VtZW50IGFzIEFyZ1N5bnRheCxcbiAgQ29uY2F0IGFzIENvbmNhdFN5bnRheCxcbiAgR2V0IGFzIEdldFN5bnRheCxcbiAgSGFzQmxvY2sgYXMgSGFzQmxvY2tTeW50YXgsXG4gIEhhc0Jsb2NrUGFyYW1zIGFzIEhhc0Jsb2NrUGFyYW1zU3ludGF4LFxuICBIZWxwZXIgYXMgSGVscGVyU3ludGF4LFxuICBVbmtub3duIGFzIFVua25vd25TeW50YXhcbn0gZnJvbSAnLi9jb3JlJztcblxuaW1wb3J0IHtcbiAgRXhwcmVzc2lvbnMgYXMgU2VyaWFsaXplZEV4cHJlc3Npb25zLFxuICBFeHByZXNzaW9uIGFzIFNlcmlhbGl6ZWRFeHByZXNzaW9uXG59IGZyb20gJ2dsaW1tZXItd2lyZS1mb3JtYXQnO1xuXG5jb25zdCB7XG4gIGlzQXJnLFxuICBpc0NvbmNhdCxcbiAgaXNHZXQsXG4gIGlzSGFzQmxvY2ssXG4gIGlzSGFzQmxvY2tQYXJhbXMsXG4gIGlzSGVscGVyLFxuICBpc1Vua25vd24sXG4gIGlzUHJpbWl0aXZlVmFsdWUsXG4gIGlzVW5kZWZpbmVkXG59ID0gU2VyaWFsaXplZEV4cHJlc3Npb25zO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbihzZXhwOiBTZXJpYWxpemVkRXhwcmVzc2lvbik6IGFueSB7XG4gIGlmIChpc1ByaW1pdGl2ZVZhbHVlKHNleHApKSByZXR1cm4gVmFsdWVTeW50YXguZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc1VuZGVmaW5lZChzZXhwKSkgcmV0dXJuIFZhbHVlU3ludGF4LmJ1aWxkKHVuZGVmaW5lZCk7XG4gIGlmIChpc0FyZyhzZXhwKSkgcmV0dXJuIEFyZ1N5bnRheC5mcm9tU3BlYyhzZXhwKTtcbiAgaWYgKGlzQ29uY2F0KHNleHApKSByZXR1cm4gQ29uY2F0U3ludGF4LmZyb21TcGVjKHNleHApO1xuICBpZiAoaXNHZXQoc2V4cCkpIHJldHVybiBHZXRTeW50YXguZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc0hlbHBlcihzZXhwKSkgcmV0dXJuIEhlbHBlclN5bnRheC5mcm9tU3BlYyhzZXhwKTtcbiAgaWYgKGlzVW5rbm93bihzZXhwKSkgcmV0dXJuIFVua25vd25TeW50YXguZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc0hhc0Jsb2NrKHNleHApKSByZXR1cm4gSGFzQmxvY2tTeW50YXguZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc0hhc0Jsb2NrUGFyYW1zKHNleHApKSByZXR1cm4gSGFzQmxvY2tQYXJhbXNTeW50YXguZnJvbVNwZWMoc2V4cCk7XG5cbiAgdGhyb3cgbmV3IEVycm9yKGBVbmV4cGVjdGVkIHdpcmUgZm9ybWF0OiAke0pTT04uc3RyaW5naWZ5KHNleHApfWApO1xufTtcbiJdfQ== enifed('glimmer-runtime/lib/syntax/statements', ['exports', 'glimmer-runtime/lib/syntax/core', 'glimmer-wire-format'], function (exports, _glimmerRuntimeLibSyntaxCore, _glimmerWireFormat) { 'use strict'; var isYield = _glimmerWireFormat.Statements.isYield; var isBlock = _glimmerWireFormat.Statements.isBlock; var isAppend = _glimmerWireFormat.Statements.isAppend; var isDynamicAttr = _glimmerWireFormat.Statements.isDynamicAttr; var isText = _glimmerWireFormat.Statements.isText; var isComment = _glimmerWireFormat.Statements.isComment; var isOpenElement = _glimmerWireFormat.Statements.isOpenElement; + var isFlushElement = _glimmerWireFormat.Statements.isFlushElement; var isCloseElement = _glimmerWireFormat.Statements.isCloseElement; var isStaticAttr = _glimmerWireFormat.Statements.isStaticAttr; var isModifier = _glimmerWireFormat.Statements.isModifier; var isDynamicArg = _glimmerWireFormat.Statements.isDynamicArg; var isStaticArg = _glimmerWireFormat.Statements.isStaticArg; var isTrustingAttr = _glimmerWireFormat.Statements.isTrustingAttr; - exports.default = function (sexp, blocks) { + exports.default = function (sexp, symbolTable, scanner) { if (isYield(sexp)) return _glimmerRuntimeLibSyntaxCore.Yield.fromSpec(sexp); - if (isBlock(sexp)) return _glimmerRuntimeLibSyntaxCore.Block.fromSpec(sexp, blocks); + if (isBlock(sexp)) return _glimmerRuntimeLibSyntaxCore.Block.fromSpec(sexp, symbolTable, scanner); if (isAppend(sexp)) return _glimmerRuntimeLibSyntaxCore.OptimizedAppend.fromSpec(sexp); if (isDynamicAttr(sexp)) return _glimmerRuntimeLibSyntaxCore.DynamicAttr.fromSpec(sexp); if (isDynamicArg(sexp)) return _glimmerRuntimeLibSyntaxCore.DynamicArg.fromSpec(sexp); if (isTrustingAttr(sexp)) return _glimmerRuntimeLibSyntaxCore.TrustingAttr.fromSpec(sexp); if (isText(sexp)) return _glimmerRuntimeLibSyntaxCore.Text.fromSpec(sexp); if (isComment(sexp)) return _glimmerRuntimeLibSyntaxCore.Comment.fromSpec(sexp); - if (isOpenElement(sexp)) return _glimmerRuntimeLibSyntaxCore.OpenElement.fromSpec(sexp); + if (isOpenElement(sexp)) return _glimmerRuntimeLibSyntaxCore.OpenElement.fromSpec(sexp, symbolTable); + if (isFlushElement(sexp)) return _glimmerRuntimeLibSyntaxCore.FlushElement.fromSpec(); if (isCloseElement(sexp)) return _glimmerRuntimeLibSyntaxCore.CloseElement.fromSpec(); if (isStaticAttr(sexp)) return _glimmerRuntimeLibSyntaxCore.StaticAttr.fromSpec(sexp); if (isStaticArg(sexp)) return _glimmerRuntimeLibSyntaxCore.StaticArg.fromSpec(sexp); if (isModifier(sexp)) return _glimmerRuntimeLibSyntaxCore.Modifier.fromSpec(sexp); }; ; }); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-runtime/lib/template', ['exports', 'glimmer-runtime/lib/builder', 'glimmer-runtime/lib/vm', 'glimmer-runtime/lib/scanner'], function (exports, _glimmerRuntimeLibBuilder, _glimmerRuntimeLibVm, _glimmerRuntimeLibScanner) { +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvc3ludGF4L3N0YXRlbWVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O1FBMEJFLE9BQU8sc0JBTlAsVUFBVSxDQU1WLE9BQU87UUFDUCxPQUFPLHNCQVBQLFVBQVUsQ0FPVixPQUFPO1FBQ1AsUUFBUSxzQkFSUixVQUFVLENBUVYsUUFBUTtRQUNSLGFBQWEsc0JBVGIsVUFBVSxDQVNWLGFBQWE7UUFDYixNQUFNLHNCQVZOLFVBQVUsQ0FVVixNQUFNO1FBQ04sU0FBUyxzQkFYVCxVQUFVLENBV1YsU0FBUztRQUNULGFBQWEsc0JBWmIsVUFBVSxDQVlWLGFBQWE7UUFDYixjQUFjLHNCQWJkLFVBQVUsQ0FhVixjQUFjO1FBQ2QsY0FBYyxzQkFkZCxVQUFVLENBY1YsY0FBYztRQUNkLFlBQVksc0JBZlosVUFBVSxDQWVWLFlBQVk7UUFDWixVQUFVLHNCQWhCVixVQUFVLENBZ0JWLFVBQVU7UUFDVixZQUFZLHNCQWpCWixVQUFVLENBaUJWLFlBQVk7UUFDWixXQUFXLHNCQWxCWCxVQUFVLENBa0JWLFdBQVc7UUFDWCxjQUFjLHNCQW5CZCxVQUFVLENBbUJWLGNBQWM7O3NCQUdGLFVBQVUsSUFBeUIsRUFBRSxXQUF3QixFQUFFLE9BQXFCLEVBQUE7QUFDaEcsWUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkExQzFCLEtBQUssQ0EwQzJCLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUMvQyxZQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLDZCQTFDMUIsS0FBSyxDQTBDMkIsUUFBUSxDQUFDLElBQUksRUFBRSxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDckUsWUFBSSxRQUFRLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkExQzNCLGVBQWUsQ0EwQzRCLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUMxRCxZQUFJLGFBQWEsQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLDZCQTFDaEMsV0FBVyxDQTBDaUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQzNELFlBQUksWUFBWSxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBbkMvQixVQUFVLENBbUNnQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDekQsWUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkFsQ2pDLFlBQVksQ0FrQ2tDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUM3RCxZQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLDZCQTVDekIsSUFBSSxDQTRDMEIsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQzdDLFlBQUksU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBNUM1QixPQUFPLENBNEM2QixRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDbkQsWUFBSSxhQUFhLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkE1Q2hDLFdBQVcsQ0E0Q2lDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsV0FBVyxDQUFDLENBQUM7QUFDeEUsWUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkE1Q2pDLFlBQVksQ0E0Q2tDLFFBQVEsRUFBRSxDQUFDO0FBQ3pELFlBQUksY0FBYyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBNUNqQyxZQUFZLENBNENrQyxRQUFRLEVBQUUsQ0FBQztBQUN6RCxZQUFJLFlBQVksQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLDZCQTVDL0IsVUFBVSxDQTRDZ0MsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3pELFlBQUksV0FBVyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sNkJBMUM5QixTQUFTLENBMEMrQixRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDdkQsWUFBSSxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsT0FBTyw2QkE3QzdCLFFBQVEsQ0E2QzhCLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztLQUN0RDs7QUFBQSxLQUFDIiwiZmlsZSI6InN0YXRlbWVudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBZaWVsZCxcbiAgQmxvY2ssXG4gIE9wdGltaXplZEFwcGVuZCxcbiAgRHluYW1pY0F0dHIsXG4gIFRleHQsXG4gIENvbW1lbnQsXG4gIE9wZW5FbGVtZW50LFxuICBGbHVzaEVsZW1lbnQsXG4gIENsb3NlRWxlbWVudCxcbiAgU3RhdGljQXR0cixcbiAgTW9kaWZpZXIsXG4gIER5bmFtaWNBcmcsXG4gIFN0YXRpY0FyZyxcbiAgVHJ1c3RpbmdBdHRyXG59IGZyb20gJy4vY29yZSc7XG5cbmltcG9ydCBTeW1ib2xUYWJsZSBmcm9tICcuLi9zeW1ib2wtdGFibGUnO1xuaW1wb3J0IHsgU3RhdGVtZW50IGFzIFN0YXRlbWVudFN5bnRheCB9IGZyb20gJy4uL3N5bnRheCc7XG5pbXBvcnQge1xuICBTdGF0ZW1lbnRzIGFzIFNlcmlhbGl6ZWRTdGF0ZW1lbnRzLFxuICBTdGF0ZW1lbnQgYXMgU2VyaWFsaXplZFN0YXRlbWVudFxufSBmcm9tICdnbGltbWVyLXdpcmUtZm9ybWF0JztcbmltcG9ydCB7IEJsb2NrU2Nhbm5lciAgfSBmcm9tICcuLi9zY2FubmVyJztcblxuY29uc3Qge1xuICBpc1lpZWxkLFxuICBpc0Jsb2NrLFxuICBpc0FwcGVuZCxcbiAgaXNEeW5hbWljQXR0cixcbiAgaXNUZXh0LFxuICBpc0NvbW1lbnQsXG4gIGlzT3BlbkVsZW1lbnQsXG4gIGlzRmx1c2hFbGVtZW50LFxuICBpc0Nsb3NlRWxlbWVudCxcbiAgaXNTdGF0aWNBdHRyLFxuICBpc01vZGlmaWVyLFxuICBpc0R5bmFtaWNBcmcsXG4gIGlzU3RhdGljQXJnLFxuICBpc1RydXN0aW5nQXR0clxufSA9IFNlcmlhbGl6ZWRTdGF0ZW1lbnRzO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbihzZXhwOiBTZXJpYWxpemVkU3RhdGVtZW50LCBzeW1ib2xUYWJsZTogU3ltYm9sVGFibGUsIHNjYW5uZXI6IEJsb2NrU2Nhbm5lcik6IFN0YXRlbWVudFN5bnRheCB7XG4gIGlmIChpc1lpZWxkKHNleHApKSByZXR1cm4gWWllbGQuZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc0Jsb2NrKHNleHApKSByZXR1cm4gQmxvY2suZnJvbVNwZWMoc2V4cCwgc3ltYm9sVGFibGUsIHNjYW5uZXIpO1xuICBpZiAoaXNBcHBlbmQoc2V4cCkpIHJldHVybiBPcHRpbWl6ZWRBcHBlbmQuZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc0R5bmFtaWNBdHRyKHNleHApKSByZXR1cm4gRHluYW1pY0F0dHIuZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc0R5bmFtaWNBcmcoc2V4cCkpIHJldHVybiBEeW5hbWljQXJnLmZyb21TcGVjKHNleHApO1xuICBpZiAoaXNUcnVzdGluZ0F0dHIoc2V4cCkpIHJldHVybiBUcnVzdGluZ0F0dHIuZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc1RleHQoc2V4cCkpIHJldHVybiBUZXh0LmZyb21TcGVjKHNleHApO1xuICBpZiAoaXNDb21tZW50KHNleHApKSByZXR1cm4gQ29tbWVudC5mcm9tU3BlYyhzZXhwKTtcbiAgaWYgKGlzT3BlbkVsZW1lbnQoc2V4cCkpIHJldHVybiBPcGVuRWxlbWVudC5mcm9tU3BlYyhzZXhwLCBzeW1ib2xUYWJsZSk7XG4gIGlmIChpc0ZsdXNoRWxlbWVudChzZXhwKSkgcmV0dXJuIEZsdXNoRWxlbWVudC5mcm9tU3BlYygpO1xuICBpZiAoaXNDbG9zZUVsZW1lbnQoc2V4cCkpIHJldHVybiBDbG9zZUVsZW1lbnQuZnJvbVNwZWMoKTtcbiAgaWYgKGlzU3RhdGljQXR0cihzZXhwKSkgcmV0dXJuIFN0YXRpY0F0dHIuZnJvbVNwZWMoc2V4cCk7XG4gIGlmIChpc1N0YXRpY0FyZyhzZXhwKSkgcmV0dXJuIFN0YXRpY0FyZy5mcm9tU3BlYyhzZXhwKTtcbiAgaWYgKGlzTW9kaWZpZXIoc2V4cCkpIHJldHVybiBNb2RpZmllci5mcm9tU3BlYyhzZXhwKTtcbn07XG4iXX0= +enifed('glimmer-runtime/lib/template', ['exports', 'glimmer-util', 'glimmer-runtime/lib/builder', 'glimmer-runtime/lib/vm', 'glimmer-runtime/lib/scanner'], function (exports, _glimmerUtil, _glimmerRuntimeLibBuilder, _glimmerRuntimeLibVm, _glimmerRuntimeLibScanner) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + exports.default = templateFactory; - var Template = (function () { - function Template(_ref) { - var raw = _ref.raw; + var clientId = 0; - _classCallCheck(this, Template); + function templateFactory(_ref) { + var id = _ref.id; + var meta = _ref.meta; + var block = _ref.block; - this.raw = raw; + var parsedBlock = undefined; + if (!id) { + id = 'client-' + clientId++; } - - Template.fromSpec = function fromSpec(spec, env) { - var scanner = new _glimmerRuntimeLibScanner.default(spec, env); - return new Template({ - raw: scanner.scanEntryPoint() - }); + var create = function (env, envMeta) { + var newMeta = envMeta ? _glimmerUtil.assign({}, envMeta, meta) : meta; + if (!parsedBlock) { + parsedBlock = JSON.parse(block); + } + return template(parsedBlock, id, newMeta, env); }; + return { id: id, meta: meta, create: create }; + } - Template.layoutFromSpec = function layoutFromSpec(spec, env) { - var scanner = new _glimmerRuntimeLibScanner.default(spec, env); - return scanner.scanLayout(); + function template(block, id, meta, env) { + var scanner = new _glimmerRuntimeLibScanner.default(block, meta, env); + var entryPoint = undefined; + var asEntryPoint = function () { + if (!entryPoint) entryPoint = scanner.scanEntryPoint(); + return entryPoint; }; - - Template.prototype.render = function render(self, env, _ref2) { - var dynamicScope = _ref2.dynamicScope; - var appendTo = _ref2.appendTo; - var blockArguments = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3]; - + var layout = undefined; + var asLayout = function () { + if (!layout) layout = scanner.scanLayout(); + return layout; + }; + var asPartial = function (symbols) { + return scanner.scanPartial(symbols); + }; + var render = function (self, appendTo, dynamicScope) { var elementStack = _glimmerRuntimeLibBuilder.ElementStack.forInitialRender(env, appendTo, null); - var compiled = this.raw.compile(env); + var compiled = asEntryPoint().compile(env); var vm = _glimmerRuntimeLibVm.VM.initial(env, { self: self, dynamicScope: dynamicScope, elementStack: elementStack, size: compiled.symbols }); return vm.execute(compiled.ops); }; - - return Template; - })(); - - exports.default = Template; + return { id: id, meta: meta, _block: block, asEntryPoint: asEntryPoint, asLayout: asLayout, asPartial: asPartial, render: render }; + } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvdGVtcGxhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7UUFxQkEsUUFBQTtBQWdCRSxpQkFoQkYsUUFBQSxDQWdCYyxJQUF3QixFQUFBO2dCQUF0QixHQUFHLEdBQUwsSUFBd0IsQ0FBdEIsR0FBRzs7a0NBaEJuQixRQUFBOztBQWlCSSxnQkFBSSxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUM7U0FDaEI7O0FBbEJILGdCQUFBLENBQ1MsUUFBUSxHQUFBLGtCQUFDLElBQXdCLEVBQUUsR0FBZ0IsRUFBQTtBQUN4RCxnQkFBSSxPQUFPLEdBQUcsc0NBQVksSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0FBQ3JDLG1CQUFPLElBQUksUUFBUSxDQUFDO0FBQ2xCLG1CQUFHLEVBQUUsT0FBTyxDQUFDLGNBQWMsRUFBRTthQUM5QixDQUFDLENBQUM7U0FDSjs7QUFOSCxnQkFBQSxDQVFTLGNBQWMsR0FBQSx3QkFBQyxJQUF3QixFQUFFLEdBQWdCLEVBQUE7QUFDOUQsZ0JBQUksT0FBTyxHQUFHLHNDQUFZLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQztBQUNyQyxtQkFBTyxPQUFPLENBQUMsVUFBVSxFQUFFLENBQUM7U0FDN0I7O0FBWEgsZ0JBQUEsV0FvQkUsTUFBTSxHQUFBLGdCQUFDLElBQXdCLEVBQUUsR0FBZ0IsRUFBRSxLQUF5QyxFQUE0QjtnQkFBbkUsWUFBWSxHQUFkLEtBQXlDLENBQXZDLFlBQVk7Z0JBQUUsUUFBUSxHQUF4QixLQUF5QyxDQUF6QixRQUFRO2dCQUFtQixjQUFjLHlEQUFRLElBQUk7O0FBQ3RILGdCQUFJLFlBQVksR0FBRywwQkF0Q2QsWUFBWSxDQXNDZSxnQkFBZ0IsQ0FBQyxHQUFHLEVBQUUsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO0FBQ3RFLGdCQUFJLFFBQVEsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNyQyxnQkFBSSxFQUFFLEdBQUcscUJBdkNKLEVBQUUsQ0F1Q0ssT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLElBQUksRUFBSixJQUFJLEVBQUUsWUFBWSxFQUFaLFlBQVksRUFBRSxZQUFZLEVBQVosWUFBWSxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztBQUV2RixtQkFBTyxFQUFFLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztTQUNqQzs7ZUExQkgsUUFBQTs7O3NCQUFBLFFBQUEiLCJmaWxlIjoidGVtcGxhdGUuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZXJpYWxpemVkVGVtcGxhdGUgfSBmcm9tICdnbGltbWVyLXdpcmUtZm9ybWF0JztcbmltcG9ydCB7IFBhdGhSZWZlcmVuY2UgfSBmcm9tICdnbGltbWVyLXJlZmVyZW5jZSc7XG5pbXBvcnQgeyBFbnRyeVBvaW50LCBMYXlvdXQgfSBmcm9tICcuL2NvbXBpbGVkL2Jsb2Nrcyc7XG5pbXBvcnQgeyBFbnZpcm9ubWVudCwgRHluYW1pY1Njb3BlIH0gZnJvbSAnLi9lbnZpcm9ubWVudCc7XG5pbXBvcnQgeyBFbGVtZW50U3RhY2sgfSBmcm9tICcuL2J1aWxkZXInO1xuaW1wb3J0IHsgVk0gfSBmcm9tICcuL3ZtJztcbmltcG9ydCBTY2FubmVyIGZyb20gJy4vc2Nhbm5lcic7XG5cbmludGVyZmFjZSBUZW1wbGF0ZU9wdGlvbnMge1xuICByYXc6IEVudHJ5UG9pbnQ7XG59XG5cbmludGVyZmFjZSBSZW5kZXJPcHRpb25zIHtcbiAgZHluYW1pY1Njb3BlOiBEeW5hbWljU2NvcGU7XG4gIGFwcGVuZFRvOiBFbGVtZW50O1xufVxuXG5pbnRlcmZhY2UgRXZhbHVhdGVPcHRpb25zIHtcbiAgbmV4dFNpYmxpbmc/OiBOb2RlO1xufVxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBUZW1wbGF0ZSB7XG4gIHN0YXRpYyBmcm9tU3BlYyhzcGVjOiBTZXJpYWxpemVkVGVtcGxhdGUsIGVudjogRW52aXJvbm1lbnQpOiBUZW1wbGF0ZSB7XG4gICAgbGV0IHNjYW5uZXIgPSBuZXcgU2Nhbm5lcihzcGVjLCBlbnYpO1xuICAgIHJldHVybiBuZXcgVGVtcGxhdGUoe1xuICAgICAgcmF3OiBzY2FubmVyLnNjYW5FbnRyeVBvaW50KClcbiAgICB9KTtcbiAgfVxuXG4gIHN0YXRpYyBsYXlvdXRGcm9tU3BlYyhzcGVjOiBTZXJpYWxpemVkVGVtcGxhdGUsIGVudjogRW52aXJvbm1lbnQpOiBMYXlvdXQge1xuICAgIGxldCBzY2FubmVyID0gbmV3IFNjYW5uZXIoc3BlYywgZW52KTtcbiAgICByZXR1cm4gc2Nhbm5lci5zY2FuTGF5b3V0KCk7XG4gIH1cblxuICByYXc6IEVudHJ5UG9pbnQ7XG4gIG1ldGE6IE9iamVjdDtcblxuICBjb25zdHJ1Y3Rvcih7IHJhdyB9OiBUZW1wbGF0ZU9wdGlvbnMpIHtcbiAgICB0aGlzLnJhdyA9IHJhdztcbiAgfVxuXG4gIHJlbmRlcihzZWxmOiBQYXRoUmVmZXJlbmNlPGFueT4sIGVudjogRW52aXJvbm1lbnQsIHsgZHluYW1pY1Njb3BlLCBhcHBlbmRUbyB9OiBSZW5kZXJPcHRpb25zLCBibG9ja0FyZ3VtZW50czogYW55W109bnVsbCkge1xuICAgIGxldCBlbGVtZW50U3RhY2sgPSBFbGVtZW50U3RhY2suZm9ySW5pdGlhbFJlbmRlcihlbnYsIGFwcGVuZFRvLCBudWxsKTtcbiAgICBsZXQgY29tcGlsZWQgPSB0aGlzLnJhdy5jb21waWxlKGVudik7XG4gICAgbGV0IHZtID0gVk0uaW5pdGlhbChlbnYsIHsgc2VsZiwgZHluYW1pY1Njb3BlLCBlbGVtZW50U3RhY2ssIHNpemU6IGNvbXBpbGVkLnN5bWJvbHMgfSk7XG5cbiAgICByZXR1cm4gdm0uZXhlY3V0ZShjb21waWxlZC5vcHMpO1xuICB9XG59XG4iXX0= +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/upsert', ['exports', 'glimmer-runtime/lib/bounds'], function (exports, _glimmerRuntimeLibBounds) { 'use strict'; exports.isSafeString = isSafeString; exports.isNode = isNode; exports.isString = isString; exports.cautiousInsert = cautiousInsert; exports.trustingInsert = trustingInsert; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - function isSafeString(value) { return value && typeof value['toHTML'] === 'function'; } function isNode(value) { @@ -22000,12 +22577,10 @@ function isString(value) { return typeof value === 'string'; } var Upsert = function Upsert(bounds) { - _classCallCheck(this, Upsert); - this.bounds = bounds; }; exports.default = Upsert; @@ -22029,25 +22604,24 @@ return NodeUpsert.insert(dom, cursor, value); } } var TextUpsert = (function (_Upsert) { - _inherits(TextUpsert, _Upsert); + babelHelpers.inherits(TextUpsert, _Upsert); - function TextUpsert(bounds, textNode) { - _classCallCheck(this, TextUpsert); - - _Upsert.call(this, bounds); - this.textNode = textNode; - } - TextUpsert.insert = function insert(dom, cursor, value) { - var textNode = dom.insertTextBefore(cursor.element, cursor.nextSibling, value); + var textNode = dom.createTextNode(value); + dom.insertBefore(cursor.element, textNode, cursor.nextSibling); var bounds = new _glimmerRuntimeLibBounds.SingleNodeBounds(cursor.element, textNode); return new TextUpsert(bounds, textNode); }; + function TextUpsert(bounds, textNode) { + _Upsert.call(this, bounds); + this.textNode = textNode; + } + TextUpsert.prototype.update = function update(dom, value) { if (isString(value)) { var textNode = this.textNode; textNode.nodeValue = value; @@ -22059,20 +22633,18 @@ return TextUpsert; })(Upsert); var HTMLUpsert = (function (_Upsert2) { - _inherits(HTMLUpsert, _Upsert2); + babelHelpers.inherits(HTMLUpsert, _Upsert2); function HTMLUpsert() { - _classCallCheck(this, HTMLUpsert); - _Upsert2.apply(this, arguments); } HTMLUpsert.insert = function insert(dom, cursor, value) { - var bounds = dom.insertHTMLBefore(cursor.element, cursor.nextSibling, value); + var bounds = dom.insertHTMLBefore(cursor.element, value, cursor.nextSibling); return new HTMLUpsert(bounds); }; HTMLUpsert.prototype.update = function update(dom, value) { if (isString(value)) { @@ -22089,22 +22661,20 @@ return HTMLUpsert; })(Upsert); var SafeStringUpsert = (function (_Upsert3) { - _inherits(SafeStringUpsert, _Upsert3); + babelHelpers.inherits(SafeStringUpsert, _Upsert3); function SafeStringUpsert(bounds, lastStringValue) { - _classCallCheck(this, SafeStringUpsert); - _Upsert3.call(this, bounds); this.lastStringValue = lastStringValue; } SafeStringUpsert.insert = function insert(dom, cursor, value) { var stringValue = value.toHTML(); - var bounds = dom.insertHTMLBefore(cursor.element, cursor.nextSibling, stringValue); + var bounds = dom.insertHTMLBefore(cursor.element, stringValue, cursor.nextSibling); return new SafeStringUpsert(bounds, stringValue); }; SafeStringUpsert.prototype.update = function update(dom, value) { if (isSafeString(value)) { @@ -22125,21 +22695,19 @@ return SafeStringUpsert; })(Upsert); var NodeUpsert = (function (_Upsert4) { - _inherits(NodeUpsert, _Upsert4); + babelHelpers.inherits(NodeUpsert, _Upsert4); function NodeUpsert() { - _classCallCheck(this, NodeUpsert); - _Upsert4.apply(this, arguments); } NodeUpsert.insert = function insert(dom, cursor, node) { - var bounds = dom.insertNodeBefore(cursor.element, node, cursor.nextSibling); - return new NodeUpsert(bounds); + dom.insertBefore(cursor.element, node, cursor.nextSibling); + return new NodeUpsert(_glimmerRuntimeLibBounds.single(cursor.element, node)); }; NodeUpsert.prototype.update = function update(dom, value) { if (isNode(value)) { var bounds = this.bounds; @@ -22154,40 +22722,28 @@ }; return NodeUpsert; })(Upsert); }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/upsert.ts"],"names":[],"mappings":"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","file":"upsert.js","sourcesContent":["import { Opaque } from 'glimmer-util';\nimport { DOMHelper } from './dom/helper';\nimport { Bounds, Cursor, SingleNodeBounds, clear } from './bounds';\n\nexport interface SafeString {\n  toHTML(): string;\n}\n\nexport function isSafeString(value: Opaque): value is SafeString {\n  return value && typeof value['toHTML'] === 'function';\n}\n\nexport function isNode(value: Opaque): value is Node {\n  return value !== null && typeof value === 'object' && typeof value['nodeType'] === 'number';\n}\n\nexport function isString(value: Opaque): value is string {\n  return typeof value === 'string';\n}\n\nexport type Insertion = CautiousInsertion | TrustingInsertion;\nexport type CautiousInsertion = string | SafeString | Node;\nexport type TrustingInsertion = string | Node;\n\nabstract class Upsert {\n  constructor(public bounds: Bounds) {\n  }\n\n  abstract update(dom: DOMHelper, value: Insertion): boolean;\n}\n\nexport default Upsert;\n\nexport function cautiousInsert(dom: DOMHelper, cursor: Cursor, value: CautiousInsertion): Upsert {\n  if (isString(value)) {\n    return TextUpsert.insert(dom, cursor, value);\n  }\n  if (isSafeString(value)) {\n    return SafeStringUpsert.insert(dom, cursor, value);\n  }\n  if (isNode(value)) {\n    return NodeUpsert.insert(dom, cursor, value);\n  }\n}\n\nexport function trustingInsert(dom: DOMHelper, cursor: Cursor, value: TrustingInsertion): Upsert {\n  if (isString(value)) {\n    return HTMLUpsert.insert(dom, cursor, value);\n  }\n  if (isNode(value)) {\n    return NodeUpsert.insert(dom, cursor, value);\n  }\n}\n\nclass TextUpsert extends Upsert {\n  static insert(dom: DOMHelper, cursor: Cursor, value: string): Upsert {\n    let textNode = dom.insertTextBefore(cursor.element, cursor.nextSibling, value);\n    let bounds = new SingleNodeBounds(cursor.element, textNode);\n    return new TextUpsert(bounds, textNode);\n  }\n\n  constructor(bounds: Bounds, private textNode: Text) {\n    super(bounds);\n  }\n\n  update(dom: DOMHelper, value: Insertion): boolean {\n    if (isString(value)) {\n      let { textNode } = this;\n      textNode.nodeValue = value;\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nclass HTMLUpsert extends Upsert {\n  static insert(dom: DOMHelper, cursor: Cursor, value: string): Upsert {\n    let bounds = dom.insertHTMLBefore(cursor.element, cursor.nextSibling, value);\n    return new HTMLUpsert(bounds);\n  }\n\n  update(dom: DOMHelper, value: Insertion): boolean {\n    if (isString(value)) {\n      let { bounds } = this;\n\n      let parentElement = bounds.parentElement();\n      let nextSibling = clear(bounds);\n\n      this.bounds = dom.insertHTMLBefore(parentElement, nextSibling, value);\n\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nclass SafeStringUpsert extends Upsert {\n  static insert(dom: DOMHelper, cursor: Cursor, value: SafeString): Upsert {\n    let stringValue = value.toHTML();\n    let bounds = dom.insertHTMLBefore(cursor.element, cursor.nextSibling, stringValue);\n    return new SafeStringUpsert(bounds, stringValue);\n  }\n\n  constructor(bounds: Bounds, private lastStringValue: string) {\n    super(bounds);\n  }\n\n  update(dom: DOMHelper, value: Insertion): boolean {\n    if (isSafeString(value)) {\n      let stringValue = value.toHTML();\n\n      if (stringValue !== this.lastStringValue) {\n        let { bounds } = this;\n\n        let parentElement = bounds.parentElement();\n        let nextSibling = clear(bounds);\n\n        this.bounds = dom.insertHTMLBefore(parentElement, nextSibling, stringValue);\n        this.lastStringValue = stringValue;\n      }\n\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nclass NodeUpsert extends Upsert {\n  static insert(dom: DOMHelper, cursor: Cursor, node: Node): Upsert {\n    let bounds = dom.insertNodeBefore(cursor.element, node, cursor.nextSibling);\n    return new NodeUpsert(bounds);\n  }\n\n  update(dom: DOMHelper, value: Insertion): boolean {\n    if (isNode(value)) {\n      let { bounds } = this;\n\n      let parentElement = bounds.parentElement();\n      let nextSibling = clear(bounds);\n\n      this.bounds = dom.insertNodeBefore(parentElement, value, nextSibling);\n\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/upsert.ts"],"names":[],"mappings":"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","file":"upsert.js","sourcesContent":["import { Opaque } from 'glimmer-util';\nimport { DOMChanges, DOMTreeConstruction } from './dom/helper';\nimport * as Simple from './dom/interfaces';\nimport { FIX_REIFICATION } from './dom/interfaces';\nimport { Bounds, Cursor, SingleNodeBounds, single, clear } from './bounds';\n\nexport interface SafeString {\n  toHTML(): string;\n}\n\nexport function isSafeString(value: Opaque): value is SafeString {\n  return value && typeof value['toHTML'] === 'function';\n}\n\nexport function isNode(value: Opaque): value is Node {\n  return value !== null && typeof value === 'object' && typeof value['nodeType'] === 'number';\n}\n\nexport function isString(value: Opaque): value is string {\n  return typeof value === 'string';\n}\n\nexport type Insertion = CautiousInsertion | TrustingInsertion;\nexport type CautiousInsertion = string | SafeString | Node;\nexport type TrustingInsertion = string | Node;\n\nabstract class Upsert {\n  constructor(public bounds: Bounds) {\n  }\n\n  abstract update(dom: DOMChanges, value: Insertion): boolean;\n}\n\nexport default Upsert;\n\nexport function cautiousInsert(dom: DOMTreeConstruction, cursor: Cursor, value: CautiousInsertion): Upsert {\n  if (isString(value)) {\n    return TextUpsert.insert(dom, cursor, value);\n  }\n  if (isSafeString(value)) {\n    return SafeStringUpsert.insert(dom, cursor, value);\n  }\n  if (isNode(value)) {\n    return NodeUpsert.insert(dom, cursor, value);\n  }\n}\n\nexport function trustingInsert(dom: DOMTreeConstruction, cursor: Cursor, value: TrustingInsertion): Upsert {\n  if (isString(value)) {\n    return HTMLUpsert.insert(dom, cursor, value);\n  }\n  if (isNode(value)) {\n    return NodeUpsert.insert(dom, cursor, value);\n  }\n}\n\nclass TextUpsert extends Upsert {\n  static insert(dom: DOMTreeConstruction, cursor: Cursor, value: string): Upsert {\n    let textNode = dom.createTextNode(value);\n    dom.insertBefore(cursor.element, textNode, cursor.nextSibling);\n    let bounds = new SingleNodeBounds(cursor.element, textNode);\n    return new TextUpsert(bounds, textNode);\n  }\n\n  private textNode: Text;\n\n  constructor(bounds: Bounds, textNode: Simple.Text) {\n    super(bounds);\n    this.textNode = textNode as Text;\n  }\n\n  update(dom: DOMChanges, value: Insertion): boolean {\n    if (isString(value)) {\n      let { textNode } = this;\n      textNode.nodeValue = value;\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nclass HTMLUpsert extends Upsert {\n  static insert(dom: DOMTreeConstruction, cursor: Cursor, value: string): Upsert {\n    let bounds = dom.insertHTMLBefore(cursor.element, value, cursor.nextSibling);\n    return new HTMLUpsert(bounds);\n  }\n\n  update(dom: DOMChanges, value: Insertion): boolean {\n    if (isString(value)) {\n      let { bounds } = this;\n\n      let parentElement = bounds.parentElement();\n      let nextSibling = clear(bounds);\n\n      this.bounds = dom.insertHTMLBefore(parentElement as FIX_REIFICATION<Element>, nextSibling as FIX_REIFICATION<Node>, value);\n\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nclass SafeStringUpsert extends Upsert {\n  static insert(dom: DOMTreeConstruction, cursor: Cursor, value: SafeString): Upsert {\n    let stringValue = value.toHTML();\n    let bounds = dom.insertHTMLBefore(cursor.element, stringValue, cursor.nextSibling);\n    return new SafeStringUpsert(bounds, stringValue);\n  }\n\n  constructor(bounds: Bounds, private lastStringValue: string) {\n    super(bounds);\n  }\n\n  update(dom: DOMChanges, value: Insertion): boolean {\n    if (isSafeString(value)) {\n      let stringValue = value.toHTML();\n\n      if (stringValue !== this.lastStringValue) {\n        let { bounds } = this;\n\n        let parentElement = bounds.parentElement();\n        let nextSibling = clear(bounds);\n\n        this.bounds = dom.insertHTMLBefore(parentElement as FIX_REIFICATION<Element>, nextSibling as FIX_REIFICATION<Node>, stringValue);\n        this.lastStringValue = stringValue;\n      }\n\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nclass NodeUpsert extends Upsert {\n  static insert(dom: DOMTreeConstruction, cursor: Cursor, node: Simple.Node): Upsert {\n    dom.insertBefore(cursor.element, node, cursor.nextSibling);\n    return new NodeUpsert(single(cursor.element, node));\n  }\n\n  update(dom: DOMChanges, value: Insertion): boolean {\n    if (isNode(value)) {\n      let { bounds } = this;\n\n      let parentElement = bounds.parentElement();\n      let nextSibling = clear(bounds);\n\n      this.bounds = dom.insertNodeBefore(parentElement as FIX_REIFICATION<Element>, value, nextSibling as FIX_REIFICATION<Node>);\n\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n"]} enifed('glimmer-runtime/lib/utils', ['exports', 'glimmer-util'], function (exports, _glimmerUtil) { 'use strict'; - exports.symbol = symbol; exports.turbocharge = turbocharge; - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - - var EMPTY_ARRAY = []; + var EMPTY_ARRAY = Object.freeze([]); exports.EMPTY_ARRAY = EMPTY_ARRAY; - var EMPTY_OBJECT = {}; - exports.EMPTY_OBJECT = EMPTY_OBJECT; - var KEY = _glimmerUtil.intern('__glimmer' + +new Date()); + var EMPTY_DICT = Object.freeze(_glimmerUtil.dict()); + exports.EMPTY_DICT = EMPTY_DICT; - function symbol(debugName) { - var num = Math.floor(Math.random() * +new Date()); - return _glimmerUtil.intern(debugName + ' [id=' + KEY + num + ']'); - } - function turbocharge(object) { // function Constructor() {} // Constructor.prototype = object; return object; } var ListRange = (function () { function ListRange(list, start, end) { - _classCallCheck(this, ListRange); - this.list = list; this.start = start; this.end = end; } @@ -22207,35 +22763,30 @@ return ListRange; })(); exports.ListRange = ListRange; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/vm', ['exports', 'glimmer-runtime/lib/vm/append', 'glimmer-runtime/lib/vm/update', 'glimmer-runtime/lib/vm/render-result'], function (exports, _glimmerRuntimeLibVmAppend, _glimmerRuntimeLibVmUpdate, _glimmerRuntimeLibVmRenderResult) { 'use strict'; exports.VM = _glimmerRuntimeLibVmAppend.default; exports.PublicVM = _glimmerRuntimeLibVmAppend.PublicVM; - exports.BindDynamicScopeCallback = _glimmerRuntimeLibVmAppend.BindDynamicScopeCallback; exports.UpdatingVM = _glimmerRuntimeLibVmUpdate.default; exports.RenderResult = _glimmerRuntimeLibVmRenderResult.default; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvdm0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O1VBQW9CLEVBQUUsOEJBQWIsT0FBTztVQUFRLFFBQVEsOEJBQVIsUUFBUTtVQUFFLHdCQUF3Qiw4QkFBeEIsd0JBQXdCO1VBQ3RDLFVBQVUsOEJBQXJCLE9BQU87VUFDSSxZQUFZLG9DQUF2QixPQUFPIiwiZmlsZSI6InZtLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZGVmYXVsdCBhcyBWTSwgUHVibGljVk0sIEJpbmREeW5hbWljU2NvcGVDYWxsYmFjayB9IGZyb20gJy4vdm0vYXBwZW5kJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgVXBkYXRpbmdWTSB9IGZyb20gJy4vdm0vdXBkYXRlJztcbmV4cG9ydCB7IGRlZmF1bHQgYXMgUmVuZGVyUmVzdWx0IH0gZnJvbSAnLi92bS9yZW5kZXItcmVzdWx0JztcbiJdfQ== +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItcnVudGltZS9saWIvdm0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O1VBQW9CLEVBQUUsOEJBQWIsT0FBTztVQUFRLFFBQVEsOEJBQVIsUUFBUTtVQUNaLFVBQVUsOEJBQXJCLE9BQU87VUFDSSxZQUFZLG9DQUF2QixPQUFPIiwiZmlsZSI6InZtLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZGVmYXVsdCBhcyBWTSwgUHVibGljVk0gfSBmcm9tICcuL3ZtL2FwcGVuZCc7XG5leHBvcnQgeyBkZWZhdWx0IGFzIFVwZGF0aW5nVk0gfSBmcm9tICcuL3ZtL3VwZGF0ZSc7XG5leHBvcnQgeyBkZWZhdWx0IGFzIFJlbmRlclJlc3VsdCB9IGZyb20gJy4vdm0vcmVuZGVyLXJlc3VsdCc7XG4iXX0= enifed('glimmer-runtime/lib/vm/append', ['exports', 'glimmer-runtime/lib/environment', 'glimmer-util', 'glimmer-reference', 'glimmer-runtime/lib/compiled/opcodes/vm', 'glimmer-runtime/lib/vm/update', 'glimmer-runtime/lib/vm/render-result', 'glimmer-runtime/lib/vm/frame'], function (exports, _glimmerRuntimeLibEnvironment, _glimmerUtil, _glimmerReference, _glimmerRuntimeLibCompiledOpcodesVm, _glimmerRuntimeLibVmUpdate, _glimmerRuntimeLibVmRenderResult, _glimmerRuntimeLibVmFrame) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var VM = (function () { function VM(_ref) { var env = _ref.env; var scope = _ref.scope; var dynamicScope = _ref.dynamicScope; var elementStack = _ref.elementStack; - _classCallCheck(this, VM); - this.dynamicScopeStack = new _glimmerUtil.Stack(); this.scopeStack = new _glimmerUtil.Stack(); this.updatingOpcodeStack = new _glimmerUtil.Stack(); this.cacheGroups = new _glimmerUtil.Stack(); this.listBlockStack = new _glimmerUtil.Stack(); @@ -22258,12 +22809,11 @@ VM.prototype.capture = function capture() { return { env: this.env, scope: this.scope(), - dynamicScope: this.dynamicScope(), - block: this.stack().block() + dynamicScope: this.dynamicScope() }; }; VM.prototype.goto = function goto(op) { // assert(this.frame.getOps().contains(op), `Illegal jump to ${op.label}`); @@ -22293,31 +22843,31 @@ opcodes.append(END); }; VM.prototype.enter = function enter(ops) { var updating = new _glimmerUtil.LinkedList(); - this.stack().pushBlock(); + var tracker = this.stack().pushUpdatableBlock(); var state = this.capture(); - var tryOpcode = new _glimmerRuntimeLibVmUpdate.TryOpcode({ ops: ops, state: state, children: updating }); + var tryOpcode = new _glimmerRuntimeLibVmUpdate.TryOpcode(ops, state, tracker, updating); this.didEnter(tryOpcode, updating); }; VM.prototype.enterWithKey = function enterWithKey(key, ops) { var updating = new _glimmerUtil.LinkedList(); - this.stack().pushBlock(); + var tracker = this.stack().pushUpdatableBlock(); var state = this.capture(); - var tryOpcode = new _glimmerRuntimeLibVmUpdate.TryOpcode({ ops: ops, state: state, children: updating }); + var tryOpcode = new _glimmerRuntimeLibVmUpdate.TryOpcode(ops, state, tracker, updating); this.listBlockStack.current.map[key] = tryOpcode; this.didEnter(tryOpcode, updating); }; VM.prototype.enterList = function enterList(ops) { var updating = new _glimmerUtil.LinkedList(); - this.stack().pushBlockList(updating); + var tracker = this.stack().pushBlockList(updating); var state = this.capture(); var artifacts = this.frame.getIterator().artifacts; - var opcode = new _glimmerRuntimeLibVmUpdate.ListBlockOpcode({ ops: ops, state: state, children: updating, artifacts: artifacts }); + var opcode = new _glimmerRuntimeLibVmUpdate.ListBlockOpcode(ops, state, tracker, updating, artifacts); this.listBlockStack.push(opcode); this.didEnter(opcode, updating); }; VM.prototype.didEnter = function didEnter(opcode, updating) { @@ -22363,10 +22913,17 @@ if (args) this.frame.setArgs(args); if (blocks) this.frame.setBlocks(blocks); if (callerScope) this.frame.setCallerScope(callerScope); }; + VM.prototype.pushComponentFrame = function pushComponentFrame(layout, args, blocks, callerScope, component, manager, shadow) { + this.frame.push(layout.ops, component, manager, shadow); + if (args) this.frame.setArgs(args); + if (blocks) this.frame.setBlocks(blocks); + if (callerScope) this.frame.setCallerScope(callerScope); + }; + VM.prototype.pushEvalFrame = function pushEvalFrame(ops) { this.frame.push(ops); }; VM.prototype.popFrame = function popFrame() { @@ -22384,11 +22941,13 @@ VM.prototype.pushCallerScope = function pushCallerScope() { this.scopeStack.push(this.scope().getCallerScope()); }; VM.prototype.pushDynamicScope = function pushDynamicScope() { - this.dynamicScopeStack.push(this.dynamicScopeStack.current.child()); + var child = this.dynamicScopeStack.current.child(); + this.dynamicScopeStack.push(child); + return child; }; VM.prototype.pushRootScope = function pushRootScope(self, size) { var scope = _glimmerRuntimeLibEnvironment.Scope.root(self, size); this.scopeStack.push(scope); @@ -22428,11 +22987,11 @@ var elementStack = this.elementStack; var frame = this.frame; var updatingOpcodeStack = this.updatingOpcodeStack; var env = this.env; - elementStack.pushBlock(); + elementStack.pushSimpleBlock(); updatingOpcodeStack.push(new _glimmerUtil.LinkedList()); frame.push(opcodes); if (initialize) initialize(this); var opcode = undefined; while (frame.hasOpcodes()) { @@ -22460,17 +23019,12 @@ VM.prototype.invokeBlock = function invokeBlock(block, args) { var compiled = block.compile(this.env); this.pushFrame({ block: compiled, args: args }); }; - VM.prototype.invokeLayout = function invokeLayout(_ref4) { - var args = _ref4.args; - var layout = _ref4.layout; - var templates = _ref4.templates; - var callerScope = _ref4.callerScope; - - this.pushFrame({ block: layout, blocks: templates, callerScope: callerScope, args: args }); + VM.prototype.invokeLayout = function invokeLayout(args, layout, templates, callerScope, component, manager, shadow) { + this.pushComponentFrame(layout, args, templates, callerScope, component, manager, shadow); }; VM.prototype.evaluateOperand = function evaluateOperand(expr) { this.frame.setOperand(expr.evaluate(this)); }; @@ -22478,86 +23032,96 @@ VM.prototype.evaluateArgs = function evaluateArgs(args) { var evaledArgs = this.frame.setArgs(args.evaluate(this)); this.frame.setOperand(evaledArgs.positional.at(0)); }; - VM.prototype.bindPositionalArgs = function bindPositionalArgs(entries) { + VM.prototype.bindPositionalArgs = function bindPositionalArgs(symbols) { var args = this.frame.getArgs(); - if (!args) return; + _glimmerUtil.assert(args, "Cannot bind positional args"); var positional = args.positional; var scope = this.scope(); - for (var i = 0; i < entries.length; i++) { - scope.bindSymbol(entries[i], positional.at(i)); + for (var i = 0; i < symbols.length; i++) { + scope.bindSymbol(symbols[i], positional.at(i)); } }; - VM.prototype.bindNamedArgs = function bindNamedArgs(entries) { + VM.prototype.bindNamedArgs = function bindNamedArgs(names, symbols) { var args = this.frame.getArgs(); - if (!args) return; + _glimmerUtil.assert(args, "Cannot bind named args"); var named = args.named; - var keys = Object.keys(entries); var scope = this.scope(); - for (var i = 0; i < keys.length; i++) { - scope.bindSymbol(entries[keys[i]], named.get(keys[i])); + for (var i = 0; i < names.length; i++) { + scope.bindSymbol(symbols[i], named.get(names[i])); } }; - VM.prototype.bindBlocks = function bindBlocks(entries) { + VM.prototype.bindBlocks = function bindBlocks(names, symbols) { var blocks = this.frame.getBlocks(); var callerScope = this.frame.getCallerScope(); var scope = this.scope(); scope.bindCallerScope(callerScope); - Object.keys(entries).forEach(function (name) { - scope.bindBlock(entries[name], blocks && blocks[name] || null); - }); + for (var i = 0; i < names.length; i++) { + scope.bindBlock(symbols[i], blocks && blocks[names[i]] || null); + } }; - VM.prototype.bindDynamicScope = function bindDynamicScope(callback) { - callback(this, this.dynamicScope()); + VM.prototype.bindDynamicScope = function bindDynamicScope(names) { + var args = this.frame.getArgs(); + _glimmerUtil.assert(args, "Cannot bind dynamic scope"); + var scope = this.dynamicScope(); + for (var i = 0; i < names.length; i++) { + scope.set(names[i], args.named.get(names[i])); + } }; return VM; })(); exports.default = VM; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/vm/append.ts"],"names":[],"mappings":"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","file":"append.js","sourcesContent":["import { Scope, DynamicScope, Environment } from '../environment';\nimport { ElementStack } from '../builder';\nimport { Destroyable, Dict, Stack, LinkedList, ListSlice, LOGGER, InternedString, Opaque } from 'glimmer-util';\nimport { PathReference, ReferenceIterator, combineSlice } from 'glimmer-reference';\nimport Template from '../template';\nimport { Templates } from '../syntax/core';\nimport { InlineBlock, CompiledBlock } from '../compiled/blocks';\nimport { CompiledExpression } from '../compiled/expressions';\nimport { CompiledArgs, EvaluatedArgs } from '../compiled/expressions/args';\nimport { Opcode, OpSeq, UpdatingOpcode } from '../opcodes';\nimport { LabelOpcode, JumpIfNotModifiedOpcode, DidModifyOpcode } from '../compiled/opcodes/vm';\nimport { Range } from '../utils';\n\nimport { VMState, ListBlockOpcode, TryOpcode, BlockOpcode } from './update';\nimport RenderResult from './render-result';\nimport { FrameStack, Blocks } from './frame';\n\ninterface VMInitialOptions {\n  self: PathReference<Opaque>;\n  dynamicScope: DynamicScope;\n  elementStack: ElementStack;\n  size: number;\n}\n\ninterface VMConstructorOptions {\n  env: Environment;\n  scope: Scope;\n  dynamicScope: DynamicScope;\n  elementStack: ElementStack;\n}\n\ninterface Registers {\n  operand: PathReference<any>;\n  args: EvaluatedArgs;\n  condition: PathReference<boolean>;\n  iterator: ReferenceIterator;\n  key: InternedString;\n  templates: Dict<Template>;\n}\n\ninterface InvokeLayoutOptions {\n  args: EvaluatedArgs;\n  shadow: InternedString[];\n  layout: CompiledBlock;\n  templates: Templates;\n  callerScope: Scope;\n}\n\ninterface PushFrameOptions {\n  block: CompiledBlock;\n  args?: EvaluatedArgs;\n  blocks?: Blocks;\n  callerScope?: Scope;\n}\n\nexport interface PublicVM {\n  env: Environment;\n  getArgs(): EvaluatedArgs;\n  dynamicScope(): DynamicScope;\n  getSelf(): PathReference<Opaque>;\n  newDestroyable(d: Destroyable);\n}\n\ntype OpList = Range<Opcode>;\n\nexport default class VM implements PublicVM {\n  public env: Environment;\n  private dynamicScopeStack = new Stack<DynamicScope>();\n  private scopeStack = new Stack<Scope>();\n  private elementStack: ElementStack;\n  public updatingOpcodeStack = new Stack<LinkedList<UpdatingOpcode>>();\n  public cacheGroups = new Stack<UpdatingOpcode>();\n  public listBlockStack = new Stack<ListBlockOpcode>();\n  public frame = new FrameStack();\n\n  static initial(env: Environment, { elementStack, self, dynamicScope, size }: VMInitialOptions) {\n    let scope = Scope.root(self, size);\n    return new VM({ env, scope, dynamicScope, elementStack });\n  }\n\n  constructor({ env, scope, dynamicScope, elementStack }: VMConstructorOptions) {\n    this.env = env;\n    this.elementStack = elementStack;\n    this.scopeStack.push(scope);\n    this.dynamicScopeStack.push(dynamicScope);\n  }\n\n  capture(): VMState {\n    return {\n      env: this.env,\n      scope: this.scope(),\n      dynamicScope: this.dynamicScope(),\n      block: this.stack().block()\n    };\n  }\n\n  goto(op: LabelOpcode) {\n    // assert(this.frame.getOps().contains(op), `Illegal jump to ${op.label}`);\n    this.frame.goto(op);\n  }\n\n  beginCacheGroup() {\n    this.cacheGroups.push(this.updatingOpcodeStack.current.tail());\n  }\n\n  commitCacheGroup() {\n    //        JumpIfNotModified(END)\n    //        (head)\n    //        (....)\n    //        (tail)\n    //        DidModify\n    // END:   Noop\n\n    let END = new LabelOpcode(\"END\");\n\n    let opcodes = this.updatingOpcodeStack.current;\n    let marker = this.cacheGroups.pop();\n    let head = marker ? opcodes.nextNode(marker) : opcodes.head();\n    let tail = opcodes.tail();\n    let tag = combineSlice(new ListSlice(head, tail));\n\n    let guard = new JumpIfNotModifiedOpcode({ tag, target: END });\n\n    opcodes.insertBefore(guard, head);\n    opcodes.append(new DidModifyOpcode({ target: guard }));\n    opcodes.append(END);\n  }\n\n  enter(ops: OpSeq) {\n    let updating = new LinkedList<UpdatingOpcode>();\n\n    this.stack().pushBlock();\n    let state = this.capture();\n\n    let tryOpcode = new TryOpcode({ ops, state, children: updating });\n\n    this.didEnter(tryOpcode, updating);\n  }\n\n  enterWithKey(key: InternedString, ops: OpSeq) {\n    let updating = new LinkedList<UpdatingOpcode>();\n\n    this.stack().pushBlock();\n    let state = this.capture();\n\n    let tryOpcode = new TryOpcode({ ops, state, children: updating });\n\n    this.listBlockStack.current.map[<string>key] = tryOpcode;\n\n    this.didEnter(tryOpcode, updating);\n  }\n\n  enterList(ops: OpSeq) {\n    let updating = new LinkedList<BlockOpcode>();\n\n    this.stack().pushBlockList(updating);\n    let state = this.capture();\n    let artifacts = this.frame.getIterator().artifacts;\n\n    let opcode = new ListBlockOpcode({ ops, state, children: updating, artifacts });\n\n    this.listBlockStack.push(opcode);\n\n    this.didEnter(opcode, updating);\n  }\n\n  private didEnter(opcode: BlockOpcode, updating: LinkedList<UpdatingOpcode>) {\n    this.updateWith(opcode);\n    this.updatingOpcodeStack.push(updating);\n  }\n\n  exit() {\n    this.stack().popBlock();\n    this.updatingOpcodeStack.pop();\n\n    let parent = this.updatingOpcodeStack.current.tail() as BlockOpcode;\n\n    parent.didInitializeChildren();\n  }\n\n  exitList() {\n    this.exit();\n    this.listBlockStack.pop();\n  }\n\n  updateWith(opcode: UpdatingOpcode) {\n    this.updatingOpcodeStack.current.append(opcode);\n  }\n\n  stack(): ElementStack {\n    return this.elementStack;\n  }\n\n  scope(): Scope {\n    return this.scopeStack.current;\n  }\n\n  dynamicScope(): DynamicScope {\n    return this.dynamicScopeStack.current;\n  }\n\n  pushFrame({ block, args, blocks, callerScope }: PushFrameOptions) {\n    this.frame.push(block.ops);\n\n    if (args) this.frame.setArgs(args);\n    if (blocks) this.frame.setBlocks(blocks);\n    if (callerScope) this.frame.setCallerScope(callerScope);\n  }\n\n  pushEvalFrame(ops: OpSeq) {\n    this.frame.push(ops);\n  }\n\n  popFrame() {\n    let { frame } = this;\n\n    frame.pop();\n    let current = frame.getCurrent();\n\n    if (current === null) return;\n  }\n\n  pushChildScope() {\n    this.scopeStack.push(this.scopeStack.current.child());\n  }\n\n  pushCallerScope() {\n    this.scopeStack.push(this.scope().getCallerScope());\n  }\n\n  pushDynamicScope() {\n    this.dynamicScopeStack.push(this.dynamicScopeStack.current.child());\n  }\n\n  pushRootScope(self: PathReference<any>, size: number): Scope {\n    let scope = Scope.root(self, size);\n    this.scopeStack.push(scope);\n    return scope;\n  }\n\n  popScope() {\n    this.scopeStack.pop();\n  }\n\n  popDynamicScope() {\n    this.dynamicScopeStack.pop();\n  }\n\n  newDestroyable(d: Destroyable) {\n    this.stack().newDestroyable(d);\n  }\n\n  /// SCOPE HELPERS\n\n  getSelf(): PathReference<any> {\n    return this.scope().getSelf();\n  }\n\n  referenceForSymbol(symbol: number): PathReference<any> {\n    return this.scope().getSymbol(symbol);\n  }\n\n  getArgs(): EvaluatedArgs {\n    return this.frame.getArgs();\n  }\n\n  /// EXECUTION\n\n  execute(opcodes: OpSeq, initialize?: (vm: VM) => void): RenderResult {\n    LOGGER.debug(\"[VM] Begin program execution\");\n\n    let { elementStack, frame, updatingOpcodeStack, env } = this;\n\n    elementStack.pushBlock();\n\n    updatingOpcodeStack.push(new LinkedList<UpdatingOpcode>());\n    frame.push(opcodes);\n\n    if (initialize) initialize(this);\n\n    let opcode: Opcode;\n\n    while (frame.hasOpcodes()) {\n      if (opcode = frame.nextStatement()) {\n        LOGGER.debug(`[VM] OP ${opcode.type}`);\n        LOGGER.trace(opcode);\n        opcode.evaluate(this);\n      }\n    }\n\n    LOGGER.debug(\"[VM] Completed program execution\");\n\n    return new RenderResult({\n      env,\n      updating: updatingOpcodeStack.pop(),\n      bounds: elementStack.popBlock()\n    });\n  }\n\n  evaluateOpcode(opcode: Opcode) {\n    opcode.evaluate(this);\n  }\n\n  // Make sure you have opcodes that push and pop a scope around this opcode\n  // if you need to change the scope.\n  invokeBlock(block: InlineBlock, args: EvaluatedArgs) {\n    let compiled = block.compile(this.env);\n    this.pushFrame({ block: compiled, args });\n  }\n\n  invokeLayout({ args, layout, templates, callerScope }: InvokeLayoutOptions) {\n    this.pushFrame({ block: layout, blocks: templates, callerScope, args });\n  }\n\n  evaluateOperand(expr: CompiledExpression<any>) {\n    this.frame.setOperand(expr.evaluate(this));\n  }\n\n  evaluateArgs(args: CompiledArgs) {\n    let evaledArgs = this.frame.setArgs(args.evaluate(this));\n    this.frame.setOperand(evaledArgs.positional.at(0));\n  }\n\n  bindPositionalArgs(entries: number[]) {\n    let args = this.frame.getArgs();\n    if (!args) return;\n\n    let { positional } = args;\n\n    let scope = this.scope();\n\n    for(let i=0; i < entries.length; i++) {\n      scope.bindSymbol(entries[i], positional.at(i));\n    }\n  }\n\n  bindNamedArgs(entries: Dict<number>) {\n    let args = this.frame.getArgs();\n    if (!args) return;\n\n    let { named } = args;\n\n    let keys = Object.keys(entries);\n    let scope = this.scope();\n\n    for(let i=0; i < keys.length; i++) {\n      scope.bindSymbol(entries[keys[i]], named.get(<InternedString>keys[i]));\n    }\n  }\n\n  bindBlocks(entries: Dict<number>) {\n    let blocks = this.frame.getBlocks();\n    let callerScope = this.frame.getCallerScope();\n\n    let scope = this.scope();\n\n    scope.bindCallerScope(callerScope);\n\n    Object.keys(entries).forEach(name => {\n      scope.bindBlock(entries[name], (blocks && blocks[name]) || null);\n    });\n  }\n\n  bindDynamicScope(callback: BindDynamicScopeCallback) {\n    callback(this, this.dynamicScope());\n  }\n}\n\nexport type BindDynamicScopeCallback = (vm: PublicVM, dynamicScope: DynamicScope) => void;\n\ninterface ExceptionHandler {\n  handleException(initialize?: (vm: VM) => void);\n}\n\ninterface ReturnHandler {\n  setRenderResult(renderResult: RenderResult);\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/vm/append.ts"],"names":[],"mappings":";;;QA+Cc,EAAA;AAeZ,iBAfY,EAAA,CAeA,IAAgE,EAAA;gBAA9D,GAAG,GAAL,IAAgE,CAA9D,GAAG;gBAAE,KAAK,GAAZ,IAAgE,CAAzD,KAAK;gBAAE,YAAY,GAA1B,IAAgE,CAAlD,YAAY;gBAAE,YAAY,GAAxC,IAAgE,CAApC,YAAY;;AAb5C,gBAAA,CAAA,iBAAiB,GAAG,iBA/CR,KAAK,EA+C4B,CAAC;AAC9C,gBAAA,CAAA,UAAU,GAAG,iBAhDD,KAAK,EAgDc,CAAC;AAEjC,gBAAA,CAAA,mBAAmB,GAAG,iBAlDT,KAAK,EAkD2C,CAAC;AAC9D,gBAAA,CAAA,WAAW,GAAG,iBAnDD,KAAK,EAmDuB,CAAC;AAC1C,gBAAA,CAAA,cAAc,GAAG,iBApDJ,KAAK,EAoD2B,CAAC;AAC9C,gBAAA,CAAA,KAAK,GAAG,8BAzCR,UAAU,EAyCc,CAAC;AAQ9B,gBAAI,CAAC,GAAG,GAAG,GAAG,CAAC;AACf,gBAAI,CAAC,YAAY,GAAG,YAAY,CAAC;AACjC,gBAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC5B,gBAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAC3C;;AApBW,UAAA,CAUL,OAAO,GAAA,iBAAC,GAAgB,EAAE,KAA4D,EAAA;gBAA1D,YAAY,GAAd,KAA4D,CAA1D,YAAY;gBAAE,IAAI,GAApB,KAA4D,CAA5C,IAAI;gBAAE,YAAY,GAAlC,KAA4D,CAAtC,YAAY;gBAAE,IAAI,GAAxC,KAA4D,CAAxB,IAAI;;AACvE,gBAAI,KAAK,GAAG,8BA1DP,KAAK,CA0DQ,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACnC,mBAAO,IAAI,EAAE,CAAC,EAAE,GAAG,EAAH,GAAG,EAAE,KAAK,EAAL,KAAK,EAAE,YAAY,EAAZ,YAAY,EAAE,YAAY,EAAZ,YAAY,EAAE,CAAC,CAAC;SAC3D;;AAbW,UAAA,WAsBZ,OAAO,GAAA,mBAAA;AACL,mBAAO;AACL,mBAAG,EAAE,IAAI,CAAC,GAAG;AACb,qBAAK,EAAE,IAAI,CAAC,KAAK,EAAE;AACnB,4BAAY,EAAE,IAAI,CAAC,YAAY,EAAE;aAClC,CAAC;SACH;;AA5BW,UAAA,WA8BZ,IAAI,GAAA,cAAC,EAAe,EAAA;;AAElB,gBAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACrB;;AAjCW,UAAA,WAmCZ,eAAe,GAAA,2BAAA;AACb,gBAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;SAChE;;AArCW,UAAA,WAuCZ,gBAAgB,GAAA,4BAAA;;;;;;;AAQd,gBAAI,GAAG,GAAG,wCArFL,WAAW,CAqFU,KAAK,CAAC,CAAC;AAEjC,gBAAI,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC;AAC/C,gBAAI,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC;AACpC,gBAAI,IAAI,GAAG,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;AAC9D,gBAAI,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;AAC1B,gBAAI,GAAG,GAAG,kBAjGU,YAAY,CAiGT,iBAlGc,SAAS,CAkGT,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAElD,gBAAI,KAAK,GAAG,wCA7FM,uBAAuB,CA6FD,EAAE,GAAG,EAAH,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;AAE9D,mBAAO,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AAClC,mBAAO,CAAC,MAAM,CAAC,wCAhG4B,eAAe,CAgGvB,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AACvD,mBAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SACrB;;AA5DW,UAAA,WA8DZ,KAAK,GAAA,eAAC,GAAU,EAAA;AACd,gBAAI,QAAQ,GAAG,iBA5GU,UAAU,EA4GY,CAAC;AAEhD,gBAAI,OAAO,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,kBAAkB,EAAE,CAAC;AAChD,gBAAI,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;AAE3B,gBAAI,SAAS,GAAG,+BAvGe,SAAS,CAuGV,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;AAE7D,gBAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SACpC;;AAvEW,UAAA,WAyEZ,YAAY,GAAA,sBAAC,GAAW,EAAE,GAAU,EAAA;AAClC,gBAAI,QAAQ,GAAG,iBAvHU,UAAU,EAuHY,CAAC;AAEhD,gBAAI,OAAO,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,kBAAkB,EAAE,CAAC;AAChD,gBAAI,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;AAE3B,gBAAI,SAAS,GAAG,+BAlHe,SAAS,CAkHV,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;AAE7D,gBAAI,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;AAEjD,gBAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SACpC;;AApFW,UAAA,WAsFZ,SAAS,GAAA,mBAAC,GAAU,EAAA;AAClB,gBAAI,QAAQ,GAAG,iBApIU,UAAU,EAoIS,CAAC;AAE7C,gBAAI,OAAO,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;AACnD,gBAAI,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;AAC3B,gBAAI,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC;AAEnD,gBAAI,MAAM,GAAG,+BAhIC,eAAe,CAgII,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;AAE3E,gBAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAEjC,gBAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;SACjC;;AAlGW,UAAA,WAoGJ,QAAQ,GAAA,kBAAC,MAAmB,EAAE,QAAoC,EAAA;AACxE,gBAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;AACxB,gBAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACzC;;AAvGW,UAAA,WAyGZ,IAAI,GAAA,gBAAA;AACF,gBAAI,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC;AACxB,gBAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC;AAE/B,gBAAI,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,IAAI,EAAiB,CAAC;AAEpE,kBAAM,CAAC,qBAAqB,EAAE,CAAC;SAChC;;AAhHW,UAAA,WAkHZ,QAAQ,GAAA,oBAAA;AACN,gBAAI,CAAC,IAAI,EAAE,CAAC;AACZ,gBAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC;SAC3B;;AArHW,UAAA,WAuHZ,UAAU,GAAA,oBAAC,MAAsB,EAAA;AAC/B,gBAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SACjD;;AAzHW,UAAA,WA2HZ,KAAK,GAAA,iBAAA;AACH,mBAAO,IAAI,CAAC,YAAY,CAAC;SAC1B;;AA7HW,UAAA,WA+HZ,KAAK,GAAA,iBAAA;AACH,mBAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;SAChC;;AAjIW,UAAA,WAmIZ,YAAY,GAAA,wBAAA;AACV,mBAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC;SACvC;;AArIW,UAAA,WAuIZ,SAAS,GAAA,mBAAC,KAAsD,EAAA;gBAApD,KAAK,GAAP,KAAsD,CAApD,KAAK;gBAAE,IAAI,GAAb,KAAsD,CAA7C,IAAI;gBAAE,MAAM,GAArB,KAAsD,CAAvC,MAAM;gBAAE,WAAW,GAAlC,KAAsD,CAA/B,WAAW;;AAC1C,gBAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAE3B,gBAAI,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACnC,gBAAI,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,gBAAI,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;SACzD;;AA7IW,UAAA,WA+IZ,kBAAkB,GAAA,4BAChB,MAAqB,EACrB,IAAmB,EACnB,MAAc,EACd,WAAkB,EAClB,SAAoB,EACpB,OAAoC,EACpC,MAAgB,EAAA;AAEhB,gBAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAExD,gBAAI,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACnC,gBAAI,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AACzC,gBAAI,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;SACzD;;AA7JW,UAAA,WA+JZ,aAAa,GAAA,uBAAC,GAAU,EAAA;AACtB,gBAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACtB;;AAjKW,UAAA,WAmKZ,QAAQ,GAAA,oBAAA;gBACA,KAAK,GAAK,IAAI,CAAd,KAAK;;AAEX,iBAAK,CAAC,GAAG,EAAE,CAAC;AACZ,gBAAI,OAAO,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;AAEjC,gBAAI,OAAO,KAAK,IAAI,EAAE,OAAO;SAC9B;;AA1KW,UAAA,WA4KZ,cAAc,GAAA,0BAAA;AACZ,gBAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;SACvD;;AA9KW,UAAA,WAgLZ,eAAe,GAAA,2BAAA;AACb,gBAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;SACrD;;AAlLW,UAAA,WAoLZ,gBAAgB,GAAA,4BAAA;AACd,gBAAI,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;AACnD,gBAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,mBAAO,KAAK,CAAC;SACd;;AAxLW,UAAA,WA0LZ,aAAa,GAAA,uBAAC,IAAwB,EAAE,IAAY,EAAA;AAClD,gBAAI,KAAK,GAAG,8BA1OP,KAAK,CA0OQ,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACnC,gBAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC5B,mBAAO,KAAK,CAAC;SACd;;AA9LW,UAAA,WAgMZ,QAAQ,GAAA,oBAAA;AACN,gBAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;SACvB;;AAlMW,UAAA,WAoMZ,eAAe,GAAA,2BAAA;AACb,gBAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC;SAC9B;;AAtMW,UAAA,WAwMZ,cAAc,GAAA,wBAAC,CAAc,EAAA;AAC3B,gBAAI,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;SAChC;;;;AA1MW,UAAA,WA8MZ,OAAO,GAAA,mBAAA;AACL,mBAAO,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC;SAC/B;;AAhNW,UAAA,WAkNZ,kBAAkB,GAAA,4BAAC,MAAc,EAAA;AAC/B,mBAAO,IAAI,CAAC,KAAK,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;SACvC;;AApNW,UAAA,WAsNZ,OAAO,GAAA,mBAAA;AACL,mBAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;SAC7B;;;;AAxNW,UAAA,WA4NZ,OAAO,GAAA,iBAAC,OAAc,EAAE,UAA6B,EAAA;AACnD,yBA1QgD,MAAM,CA0Q/C,KAAK,CAAC,8BAA8B,CAAC,CAAC;gBAEvC,YAAY,GAAsC,IAAI,CAAtD,YAAY;gBAAE,KAAK,GAA+B,IAAI,CAAxC,KAAK;gBAAE,mBAAmB,GAAU,IAAI,CAAjC,mBAAmB;gBAAE,GAAG,GAAK,IAAI,CAAZ,GAAG;;AAEnD,wBAAY,CAAC,eAAe,EAAE,CAAC;AAE/B,+BAAmB,CAAC,IAAI,CAAC,iBAhRA,UAAU,EAgRsB,CAAC,CAAC;AAC3D,iBAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAEpB,gBAAI,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;AAEjC,gBAAI,MAAc,YAAA,CAAC;AAEnB,mBAAO,KAAK,CAAC,UAAU,EAAE,EAAE;AACzB,oBAAI,MAAM,GAAG,KAAK,CAAC,aAAa,EAAE,EAAE;AAClC,iCAzR4C,MAAM,CAyR3C,KAAK,cAAY,MAAM,CAAC,IAAI,CAAG,CAAC;AACvC,iCA1R4C,MAAM,CA0R3C,KAAK,CAAC,MAAM,CAAC,CAAC;AACrB,0BAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;iBACvB;aACF;AAED,yBA/RgD,MAAM,CA+R/C,KAAK,CAAC,kCAAkC,CAAC,CAAC;AAEjD,mBAAO,6CAAiB;AACtB,mBAAG,EAAH,GAAG;AACH,wBAAQ,EAAE,mBAAmB,CAAC,GAAG,EAAE;AACnC,sBAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;aAChC,CAAC,CAAC;SACJ;;AAzPW,UAAA,WA2PZ,cAAc,GAAA,wBAAC,MAAc,EAAA;AAC3B,kBAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;SACvB;;;;;AA7PW,UAAA,WAiQZ,WAAW,GAAA,qBAAC,KAAkB,EAAE,IAAmB,EAAA;AACjD,gBAAI,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACvC,gBAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAC,CAAC;SAC3C;;AApQW,UAAA,WAsQZ,YAAY,GAAA,sBACV,IAAmB,EACnB,MAAqB,EACrB,SAAoB,EACpB,WAAkB,EAClB,SAAoB,EACpB,OAAoC,EACpC,MAAgB,EAAA;AAEhB,gBAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;SAC3F;;AAhRW,UAAA,WAkRZ,eAAe,GAAA,yBAAC,IAA6B,EAAA;AAC3C,gBAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;SAC5C;;AApRW,UAAA,WAsRZ,YAAY,GAAA,sBAAC,IAAkB,EAAA;AAC7B,gBAAI,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACzD,gBAAI,CAAC,KAAK,CAAC,UAAU,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;SACpD;;AAzRW,UAAA,WA2RZ,kBAAkB,GAAA,4BAAC,OAAiB,EAAA;AAClC,gBAAI,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;AAEhC,yBA3UgE,MAAM,CA2U/D,IAAI,EAAE,6BAA6B,CAAC,CAAC;gBAEtC,UAAU,GAAK,IAAI,CAAnB,UAAU;;AAEhB,gBAAI,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;AAEzB,iBAAI,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACpC,qBAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAChD;SACF;;AAvSW,UAAA,WAySZ,aAAa,GAAA,uBAAC,KAAe,EAAE,OAAiB,EAAA;AAC9C,gBAAI,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;AAEhC,yBAzVgE,MAAM,CAyV/D,IAAI,EAAE,wBAAwB,CAAC,CAAC;gBAEjC,KAAK,GAAK,IAAI,CAAd,KAAK;;AAEX,gBAAI,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;AAEzB,iBAAI,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAClC,qBAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aACnD;SACF;;AArTW,UAAA,WAuTZ,UAAU,GAAA,oBAAC,KAAe,EAAE,OAAiB,EAAA;AAC3C,gBAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;AACpC,gBAAI,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;AAE9C,gBAAI,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;AAEzB,iBAAK,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;AAEnC,iBAAI,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAClC,qBAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,AAAC,MAAM,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAK,IAAI,CAAC,CAAC;aACnE;SACF;;AAlUW,UAAA,WAoUZ,gBAAgB,GAAA,0BAAC,KAAe,EAAA;AAC9B,gBAAI,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;AAEhC,yBApXgE,MAAM,CAoX/D,IAAI,EAAE,2BAA2B,CAAC,CAAC;AAE1C,gBAAI,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;AAEhC,iBAAI,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAClC,qBAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aAC/C;SACF;;eA9UW,EAAA;;;sBAAA,EAAA","file":"append.js","sourcesContent":["import { Scope, DynamicScope, Environment } from '../environment';\nimport { ElementStack } from '../builder';\nimport { Destroyable, Stack, LinkedList, ListSlice, LOGGER, Opaque, assert } from 'glimmer-util';\nimport { PathReference, combineSlice } from 'glimmer-reference';\nimport { Templates } from '../syntax/core';\nimport { InlineBlock, CompiledBlock } from '../compiled/blocks';\nimport { CompiledExpression } from '../compiled/expressions';\nimport { CompiledArgs, EvaluatedArgs } from '../compiled/expressions/args';\nimport { Opcode, OpSeq, UpdatingOpcode } from '../opcodes';\nimport { LabelOpcode, JumpIfNotModifiedOpcode, DidModifyOpcode } from '../compiled/opcodes/vm';\nimport { Range } from '../utils';\nimport { Component, ComponentManager } from '../component/interfaces';\nimport { VMState, ListBlockOpcode, TryOpcode, BlockOpcode } from './update';\nimport RenderResult from './render-result';\nimport { FrameStack, Blocks } from './frame';\n\ninterface VMInitialOptions {\n  self: PathReference<Opaque>;\n  dynamicScope: DynamicScope;\n  elementStack: ElementStack;\n  size: number;\n}\n\ninterface VMConstructorOptions {\n  env: Environment;\n  scope: Scope;\n  dynamicScope: DynamicScope;\n  elementStack: ElementStack;\n}\n\ninterface PushFrameOptions {\n  block: CompiledBlock;\n  args?: EvaluatedArgs;\n  blocks?: Blocks;\n  callerScope?: Scope;\n}\n\nexport interface PublicVM {\n  env: Environment;\n  getArgs(): EvaluatedArgs;\n  dynamicScope(): DynamicScope;\n  getSelf(): PathReference<Opaque>;\n  newDestroyable(d: Destroyable);\n}\n\ntype OpList = Range<Opcode>;\n\nexport default class VM implements PublicVM {\n  public env: Environment;\n  private dynamicScopeStack = new Stack<DynamicScope>();\n  private scopeStack = new Stack<Scope>();\n  private elementStack: ElementStack;\n  public updatingOpcodeStack = new Stack<LinkedList<UpdatingOpcode>>();\n  public cacheGroups = new Stack<UpdatingOpcode>();\n  public listBlockStack = new Stack<ListBlockOpcode>();\n  public frame = new FrameStack();\n\n  static initial(env: Environment, { elementStack, self, dynamicScope, size }: VMInitialOptions) {\n    let scope = Scope.root(self, size);\n    return new VM({ env, scope, dynamicScope, elementStack });\n  }\n\n  constructor({ env, scope, dynamicScope, elementStack }: VMConstructorOptions) {\n    this.env = env;\n    this.elementStack = elementStack;\n    this.scopeStack.push(scope);\n    this.dynamicScopeStack.push(dynamicScope);\n  }\n\n  capture(): VMState {\n    return {\n      env: this.env,\n      scope: this.scope(),\n      dynamicScope: this.dynamicScope()\n    };\n  }\n\n  goto(op: LabelOpcode) {\n    // assert(this.frame.getOps().contains(op), `Illegal jump to ${op.label}`);\n    this.frame.goto(op);\n  }\n\n  beginCacheGroup() {\n    this.cacheGroups.push(this.updatingOpcodeStack.current.tail());\n  }\n\n  commitCacheGroup() {\n    //        JumpIfNotModified(END)\n    //        (head)\n    //        (....)\n    //        (tail)\n    //        DidModify\n    // END:   Noop\n\n    let END = new LabelOpcode(\"END\");\n\n    let opcodes = this.updatingOpcodeStack.current;\n    let marker = this.cacheGroups.pop();\n    let head = marker ? opcodes.nextNode(marker) : opcodes.head();\n    let tail = opcodes.tail();\n    let tag = combineSlice(new ListSlice(head, tail));\n\n    let guard = new JumpIfNotModifiedOpcode({ tag, target: END });\n\n    opcodes.insertBefore(guard, head);\n    opcodes.append(new DidModifyOpcode({ target: guard }));\n    opcodes.append(END);\n  }\n\n  enter(ops: OpSeq) {\n    let updating = new LinkedList<UpdatingOpcode>();\n\n    let tracker = this.stack().pushUpdatableBlock();\n    let state = this.capture();\n\n    let tryOpcode = new TryOpcode(ops, state, tracker, updating);\n\n    this.didEnter(tryOpcode, updating);\n  }\n\n  enterWithKey(key: string, ops: OpSeq) {\n    let updating = new LinkedList<UpdatingOpcode>();\n\n    let tracker = this.stack().pushUpdatableBlock();\n    let state = this.capture();\n\n    let tryOpcode = new TryOpcode(ops, state, tracker, updating);\n\n    this.listBlockStack.current.map[key] = tryOpcode;\n\n    this.didEnter(tryOpcode, updating);\n  }\n\n  enterList(ops: OpSeq) {\n    let updating = new LinkedList<BlockOpcode>();\n\n    let tracker = this.stack().pushBlockList(updating);\n    let state = this.capture();\n    let artifacts = this.frame.getIterator().artifacts;\n\n    let opcode = new ListBlockOpcode(ops, state, tracker, updating, artifacts);\n\n    this.listBlockStack.push(opcode);\n\n    this.didEnter(opcode, updating);\n  }\n\n  private didEnter(opcode: BlockOpcode, updating: LinkedList<UpdatingOpcode>) {\n    this.updateWith(opcode);\n    this.updatingOpcodeStack.push(updating);\n  }\n\n  exit() {\n    this.stack().popBlock();\n    this.updatingOpcodeStack.pop();\n\n    let parent = this.updatingOpcodeStack.current.tail() as BlockOpcode;\n\n    parent.didInitializeChildren();\n  }\n\n  exitList() {\n    this.exit();\n    this.listBlockStack.pop();\n  }\n\n  updateWith(opcode: UpdatingOpcode) {\n    this.updatingOpcodeStack.current.append(opcode);\n  }\n\n  stack(): ElementStack {\n    return this.elementStack;\n  }\n\n  scope(): Scope {\n    return this.scopeStack.current;\n  }\n\n  dynamicScope(): DynamicScope {\n    return this.dynamicScopeStack.current;\n  }\n\n  pushFrame({ block, args, blocks, callerScope }: PushFrameOptions) {\n    this.frame.push(block.ops);\n\n    if (args) this.frame.setArgs(args);\n    if (blocks) this.frame.setBlocks(blocks);\n    if (callerScope) this.frame.setCallerScope(callerScope);\n  }\n\n  pushComponentFrame(\n    layout: CompiledBlock,\n    args: EvaluatedArgs,\n    blocks: Blocks,\n    callerScope: Scope,\n    component: Component,\n    manager: ComponentManager<Component>,\n    shadow: string[]\n  ) {\n    this.frame.push(layout.ops, component, manager, shadow);\n\n    if (args) this.frame.setArgs(args);\n    if (blocks) this.frame.setBlocks(blocks);\n    if (callerScope) this.frame.setCallerScope(callerScope);\n  }\n\n  pushEvalFrame(ops: OpSeq) {\n    this.frame.push(ops);\n  }\n\n  popFrame() {\n    let { frame } = this;\n\n    frame.pop();\n    let current = frame.getCurrent();\n\n    if (current === null) return;\n  }\n\n  pushChildScope() {\n    this.scopeStack.push(this.scopeStack.current.child());\n  }\n\n  pushCallerScope() {\n    this.scopeStack.push(this.scope().getCallerScope());\n  }\n\n  pushDynamicScope(): DynamicScope {\n    let child = this.dynamicScopeStack.current.child();\n    this.dynamicScopeStack.push(child);\n    return child;\n  }\n\n  pushRootScope(self: PathReference<any>, size: number): Scope {\n    let scope = Scope.root(self, size);\n    this.scopeStack.push(scope);\n    return scope;\n  }\n\n  popScope() {\n    this.scopeStack.pop();\n  }\n\n  popDynamicScope() {\n    this.dynamicScopeStack.pop();\n  }\n\n  newDestroyable(d: Destroyable) {\n    this.stack().newDestroyable(d);\n  }\n\n  /// SCOPE HELPERS\n\n  getSelf(): PathReference<any> {\n    return this.scope().getSelf();\n  }\n\n  referenceForSymbol(symbol: number): PathReference<any> {\n    return this.scope().getSymbol(symbol);\n  }\n\n  getArgs(): EvaluatedArgs {\n    return this.frame.getArgs();\n  }\n\n  /// EXECUTION\n\n  execute(opcodes: OpSeq, initialize?: (vm: VM) => void): RenderResult {\n    LOGGER.debug(\"[VM] Begin program execution\");\n\n    let { elementStack, frame, updatingOpcodeStack, env } = this;\n\n    elementStack.pushSimpleBlock();\n\n    updatingOpcodeStack.push(new LinkedList<UpdatingOpcode>());\n    frame.push(opcodes);\n\n    if (initialize) initialize(this);\n\n    let opcode: Opcode;\n\n    while (frame.hasOpcodes()) {\n      if (opcode = frame.nextStatement()) {\n        LOGGER.debug(`[VM] OP ${opcode.type}`);\n        LOGGER.trace(opcode);\n        opcode.evaluate(this);\n      }\n    }\n\n    LOGGER.debug(\"[VM] Completed program execution\");\n\n    return new RenderResult({\n      env,\n      updating: updatingOpcodeStack.pop(),\n      bounds: elementStack.popBlock()\n    });\n  }\n\n  evaluateOpcode(opcode: Opcode) {\n    opcode.evaluate(this);\n  }\n\n  // Make sure you have opcodes that push and pop a scope around this opcode\n  // if you need to change the scope.\n  invokeBlock(block: InlineBlock, args: EvaluatedArgs) {\n    let compiled = block.compile(this.env);\n    this.pushFrame({ block: compiled, args });\n  }\n\n  invokeLayout(\n    args: EvaluatedArgs,\n    layout: CompiledBlock,\n    templates: Templates,\n    callerScope: Scope,\n    component: Component,\n    manager: ComponentManager<Component>,\n    shadow: string[]\n  ) {\n    this.pushComponentFrame(layout, args, templates, callerScope, component, manager, shadow);\n  }\n\n  evaluateOperand(expr: CompiledExpression<any>) {\n    this.frame.setOperand(expr.evaluate(this));\n  }\n\n  evaluateArgs(args: CompiledArgs) {\n    let evaledArgs = this.frame.setArgs(args.evaluate(this));\n    this.frame.setOperand(evaledArgs.positional.at(0));\n  }\n\n  bindPositionalArgs(symbols: number[]) {\n    let args = this.frame.getArgs();\n\n    assert(args, \"Cannot bind positional args\");\n\n    let { positional } = args;\n\n    let scope = this.scope();\n\n    for(let i=0; i < symbols.length; i++) {\n      scope.bindSymbol(symbols[i], positional.at(i));\n    }\n  }\n\n  bindNamedArgs(names: string[], symbols: number[]) {\n    let args = this.frame.getArgs();\n\n    assert(args, \"Cannot bind named args\");\n\n    let { named } = args;\n\n    let scope = this.scope();\n\n    for(let i=0; i < names.length; i++) {\n      scope.bindSymbol(symbols[i], named.get(names[i]));\n    }\n  }\n\n  bindBlocks(names: string[], symbols: number[]) {\n    let blocks = this.frame.getBlocks();\n    let callerScope = this.frame.getCallerScope();\n\n    let scope = this.scope();\n\n    scope.bindCallerScope(callerScope);\n\n    for(let i=0; i < names.length; i++) {\n      scope.bindBlock(symbols[i], (blocks && blocks[names[i]]) || null);\n    }\n  }\n\n  bindDynamicScope(names: string[]) {\n    let args = this.frame.getArgs();\n\n    assert(args, \"Cannot bind dynamic scope\");\n\n    let scope = this.dynamicScope();\n\n    for(let i=0; i < names.length; i++) {\n      scope.set(names[i], args.named.get(names[i]));\n    }\n  }\n}\n\ninterface ExceptionHandler {\n  handleException(initialize?: (vm: VM) => void);\n}\n\ninterface ReturnHandler {\n  setRenderResult(renderResult: RenderResult);\n}\n"]} enifed("glimmer-runtime/lib/vm/frame", ["exports"], function (exports) { "use strict"; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var Frame = function Frame(ops) { - _classCallCheck(this, Frame); + var component = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1]; + var manager = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2]; + var shadow = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3]; + this.component = component; + this.manager = manager; + this.shadow = shadow; this.operand = null; this.args = null; this.callerScope = null; this.blocks = null; this.condition = null; this.iterator = null; this.key = null; + this.componentDefinition = null; this.ops = ops; this.op = ops.head(); }; var FrameStack = (function () { function FrameStack() { - _classCallCheck(this, FrameStack); - this.frames = []; this.frame = undefined; } FrameStack.prototype.push = function push(ops) { + var component = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1]; + var manager = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2]; + var shadow = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3]; + var frame = this.frame === undefined ? this.frame = 0 : ++this.frame; if (this.frames.length <= frame) { this.frames.push(null); } - this.frames[frame] = new Frame(ops); + this.frames[frame] = new Frame(ops, component, manager, shadow); }; FrameStack.prototype.pop = function pop() { var frames = this.frames; var frame = this.frame; @@ -22617,10 +23181,18 @@ FrameStack.prototype.setKey = function setKey(key) { return this.frames[this.frame].key = key; }; + FrameStack.prototype.getComponentDefinition = function getComponentDefinition() { + return this.frames[this.frame].componentDefinition; + }; + + FrameStack.prototype.setComponentDefinition = function setComponentDefinition(definition) { + return this.frames[this.frame].componentDefinition = definition; + }; + FrameStack.prototype.getBlocks = function getBlocks() { return this.frames[this.frame].blocks; }; FrameStack.prototype.setBlocks = function setBlocks(blocks) { @@ -22633,10 +23205,22 @@ FrameStack.prototype.setCallerScope = function setCallerScope(callerScope) { return this.frames[this.frame].callerScope = callerScope; }; + FrameStack.prototype.getComponent = function getComponent() { + return this.frames[this.frame].component; + }; + + FrameStack.prototype.getManager = function getManager() { + return this.frames[this.frame].manager; + }; + + FrameStack.prototype.getShadow = function getShadow() { + return this.frames[this.frame].shadow; + }; + FrameStack.prototype.goto = function goto(op) { this.setCurrent(op); }; FrameStack.prototype.hasOpcodes = function hasOpcodes() { @@ -22658,24 +23242,20 @@ return FrameStack; })(); exports.FrameStack = FrameStack; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/vm/frame.ts"],"names":[],"mappings":"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","file":"frame.js","sourcesContent":["import { Scope } from '../environment';\nimport { InternedString } from 'glimmer-util';\nimport { Reference, PathReference, ReferenceIterator } from 'glimmer-reference';\nimport { InlineBlock } from '../compiled/blocks';\nimport { EvaluatedArgs } from '../compiled/expressions/args';\nimport { Opcode, OpSeq } from '../opcodes';\nimport { LabelOpcode } from '../compiled/opcodes/vm';\n\nclass Frame {\n  ops: OpSeq;\n  op: Opcode;\n  operand: PathReference<any> = null;\n  args: EvaluatedArgs = null;\n  callerScope: Scope = null;\n  blocks: Blocks = null;\n  condition: Reference<boolean> = null;\n  iterator: ReferenceIterator = null;\n  key: InternedString = null;\n\n  constructor(ops: OpSeq) {\n    this.ops = ops;\n    this.op = ops.head();\n  }\n}\n\nexport interface Blocks {\n  default: InlineBlock;\n  inverse: InlineBlock;\n}\n\nexport class FrameStack {\n  private frames: Frame[] = [];\n  private frame: number = undefined;\n\n  push(ops: OpSeq) {\n    let frame = (this.frame === undefined) ? (this.frame = 0) : ++this.frame;\n\n    if (this.frames.length <= frame) {\n      this.frames.push(null);\n    }\n\n    this.frames[frame] = new Frame(ops);\n  }\n\n  pop() {\n    let { frames, frame } = this;\n    frames[frame] = null;\n    this.frame = frame === 0 ? undefined : frame - 1;\n  }\n\n  getOps(): OpSeq {\n    return this.frames[this.frame].ops;\n  }\n\n  getCurrent(): Opcode {\n    return this.frames[this.frame].op;\n  }\n\n  setCurrent(op: Opcode): Opcode {\n    return this.frames[this.frame].op = op;\n  }\n\n  getOperand(): PathReference<any> {\n    return this.frames[this.frame].operand;\n  }\n\n  setOperand<T>(operand: PathReference<T>): PathReference<T> {\n    return this.frames[this.frame].operand = operand;\n  }\n\n  getArgs(): EvaluatedArgs {\n    return this.frames[this.frame].args;\n  }\n\n  setArgs(args: EvaluatedArgs): EvaluatedArgs {\n    let frame = this.frames[this.frame];\n    return frame.args = args;\n  }\n\n  getCondition(): Reference<boolean> {\n    return this.frames[this.frame].condition;\n  }\n\n  setCondition(condition: Reference<boolean>): Reference<boolean> {\n    return this.frames[this.frame].condition = condition;\n  }\n\n  getIterator(): ReferenceIterator {\n    return this.frames[this.frame].iterator;\n  }\n\n  setIterator(iterator: ReferenceIterator): ReferenceIterator {\n    return this.frames[this.frame].iterator = iterator;\n  }\n\n  getKey(): InternedString {\n    return this.frames[this.frame].key;\n  }\n\n  setKey(key: InternedString): InternedString {\n    return this.frames[this.frame].key = key;\n  }\n\n  getBlocks(): Blocks {\n    return this.frames[this.frame].blocks;\n  }\n\n  setBlocks(blocks: Blocks): Blocks {\n    return this.frames[this.frame].blocks = blocks;\n  }\n\n  getCallerScope(): Scope {\n    return this.frames[this.frame].callerScope;\n  }\n\n  setCallerScope(callerScope: Scope): Scope {\n    return this.frames[this.frame].callerScope = callerScope;\n  }\n\n  goto(op: LabelOpcode) {\n    this.setCurrent(op);\n  }\n\n  hasOpcodes(): boolean {\n    return this.frame !== undefined;\n  }\n\n  nextStatement(): Opcode {\n    let op = this.frames[this.frame].op;\n    let ops = this.getOps();\n\n    if (op) {\n      this.setCurrent(ops.nextNode(op));\n      return op;\n    } else {\n      this.pop();\n      return null;\n    }\n  }\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/vm/frame.ts"],"names":[],"mappings":"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","file":"frame.js","sourcesContent":["import { Scope } from '../environment';\nimport { Reference, PathReference, ReferenceIterator } from 'glimmer-reference';\nimport { InlineBlock } from '../compiled/blocks';\nimport { EvaluatedArgs } from '../compiled/expressions/args';\nimport { Opcode, OpSeq } from '../opcodes';\nimport { LabelOpcode } from '../compiled/opcodes/vm';\nimport { Component, ComponentManager, ComponentDefinition } from '../component/interfaces';\n\nclass Frame {\n  ops: OpSeq;\n  op: Opcode;\n  operand: PathReference<any> = null;\n  args: EvaluatedArgs = null;\n  callerScope: Scope = null;\n  blocks: Blocks = null;\n  condition: Reference<boolean> = null;\n  iterator: ReferenceIterator = null;\n  key: string = null;\n  componentDefinition: ComponentDefinition<Component> = null;\n\n  constructor(\n    ops: OpSeq,\n    public component: Component = null,\n    public manager: ComponentManager<Component> = null,\n    public shadow: string[] = null\n  ) {\n    this.ops = ops;\n    this.op = ops.head();\n  }\n}\n\nexport interface Blocks {\n  default: InlineBlock;\n  inverse: InlineBlock;\n}\n\nexport class FrameStack {\n  private frames: Frame[] = [];\n  private frame: number = undefined;\n\n  push(ops: OpSeq, component: Component = null, manager: ComponentManager<Component> = null, shadow: string[] = null) {\n    let frame = (this.frame === undefined) ? (this.frame = 0) : ++this.frame;\n\n    if (this.frames.length <= frame) {\n      this.frames.push(null);\n    }\n\n    this.frames[frame] = new Frame(ops, component, manager, shadow);\n  }\n\n  pop() {\n    let { frames, frame } = this;\n    frames[frame] = null;\n    this.frame = frame === 0 ? undefined : frame - 1;\n  }\n\n  getOps(): OpSeq {\n    return this.frames[this.frame].ops;\n  }\n\n  getCurrent(): Opcode {\n    return this.frames[this.frame].op;\n  }\n\n  setCurrent(op: Opcode): Opcode {\n    return this.frames[this.frame].op = op;\n  }\n\n  getOperand(): PathReference<any> {\n    return this.frames[this.frame].operand;\n  }\n\n  setOperand<T>(operand: PathReference<T>): PathReference<T> {\n    return this.frames[this.frame].operand = operand;\n  }\n\n  getArgs(): EvaluatedArgs {\n    return this.frames[this.frame].args;\n  }\n\n  setArgs(args: EvaluatedArgs): EvaluatedArgs {\n    let frame = this.frames[this.frame];\n    return frame.args = args;\n  }\n\n  getCondition(): Reference<boolean> {\n    return this.frames[this.frame].condition;\n  }\n\n  setCondition(condition: Reference<boolean>): Reference<boolean> {\n    return this.frames[this.frame].condition = condition;\n  }\n\n  getIterator(): ReferenceIterator {\n    return this.frames[this.frame].iterator;\n  }\n\n  setIterator(iterator: ReferenceIterator): ReferenceIterator {\n    return this.frames[this.frame].iterator = iterator;\n  }\n\n  getKey(): string {\n    return this.frames[this.frame].key;\n  }\n\n  setKey(key: string): string {\n    return this.frames[this.frame].key = key;\n  }\n\n  getComponentDefinition(): ComponentDefinition<Component> {\n    return this.frames[this.frame].componentDefinition;\n  }\n\n  setComponentDefinition(definition: ComponentDefinition<Component>): ComponentDefinition<Component> {\n    return this.frames[this.frame].componentDefinition = definition;\n  }\n\n  getBlocks(): Blocks {\n    return this.frames[this.frame].blocks;\n  }\n\n  setBlocks(blocks: Blocks): Blocks {\n    return this.frames[this.frame].blocks = blocks;\n  }\n\n  getCallerScope(): Scope {\n    return this.frames[this.frame].callerScope;\n  }\n\n  setCallerScope(callerScope: Scope): Scope {\n    return this.frames[this.frame].callerScope = callerScope;\n  }\n\n  getComponent(): Component {\n    return this.frames[this.frame].component;\n  }\n\n  getManager(): ComponentManager<Component> {\n    return this.frames[this.frame].manager;\n  }\n\n  getShadow(): string[] {\n    return this.frames[this.frame].shadow;\n  }\n\n  goto(op: LabelOpcode) {\n    this.setCurrent(op);\n  }\n\n  hasOpcodes(): boolean {\n    return this.frame !== undefined;\n  }\n\n  nextStatement(): Opcode {\n    let op = this.frames[this.frame].op;\n    let ops = this.getOps();\n\n    if (op) {\n      this.setCurrent(ops.nextNode(op));\n      return op;\n    } else {\n      this.pop();\n      return null;\n    }\n  }\n}\n"]} enifed('glimmer-runtime/lib/vm/render-result', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/vm/update'], function (exports, _glimmerRuntimeLibBounds, _glimmerRuntimeLibVmUpdate) { 'use strict'; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var RenderResult = (function () { function RenderResult(_ref) { var env = _ref.env; var updating = _ref.updating; var bounds = _ref.bounds; - _classCallCheck(this, RenderResult); - this.env = env; this.updating = updating; this.bounds = bounds; } @@ -22719,27 +23299,19 @@ return RenderResult; })(); exports.default = RenderResult; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-runtime/lib/vm/update', ['exports', 'glimmer-runtime/lib/bounds', 'glimmer-runtime/lib/builder', 'glimmer-util', 'glimmer-reference', 'glimmer-runtime/lib/compiled/expressions/args', 'glimmer-runtime/lib/opcodes', 'glimmer-runtime/lib/vm/append'], function (exports, _glimmerRuntimeLibBounds, _glimmerRuntimeLibBuilder, _glimmerUtil, _glimmerReference, _glimmerRuntimeLibCompiledExpressionsArgs, _glimmerRuntimeLibOpcodes, _glimmerRuntimeLibVmAppend) { 'use strict'; - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass); } - - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var UpdatingVM = (function () { function UpdatingVM(env, _ref) { var _ref$alwaysRevalidate = _ref.alwaysRevalidate; var alwaysRevalidate = _ref$alwaysRevalidate === undefined ? false : _ref$alwaysRevalidate; - _classCallCheck(this, UpdatingVM); - this.frameStack = new _glimmerUtil.Stack(); this.env = env; this.dom = env.getDOM(); this.alwaysRevalidate = alwaysRevalidate; } @@ -22782,34 +23354,27 @@ })(); exports.default = UpdatingVM; var BlockOpcode = (function (_UpdatingOpcode) { - _inherits(BlockOpcode, _UpdatingOpcode); + babelHelpers.inherits(BlockOpcode, _UpdatingOpcode); - function BlockOpcode(_ref2) { - var ops = _ref2.ops; - var children = _ref2.children; - var state = _ref2.state; - - _classCallCheck(this, BlockOpcode); - + function BlockOpcode(ops, state, bounds, children) { _UpdatingOpcode.call(this); this.type = "block"; this.next = null; this.prev = null; var env = state.env; var scope = state.scope; var dynamicScope = state.dynamicScope; - var block = state.block; this.ops = ops; this.children = children; this.env = env; this.scope = scope; this.dynamicScope = dynamicScope; - this.bounds = block; + this.bounds = bounds; } BlockOpcode.prototype.parentElement = function parentElement() { return this.bounds.parentElement(); }; @@ -22855,16 +23420,14 @@ })(_glimmerRuntimeLibOpcodes.UpdatingOpcode); exports.BlockOpcode = BlockOpcode; var TryOpcode = (function (_BlockOpcode) { - _inherits(TryOpcode, _BlockOpcode); + babelHelpers.inherits(TryOpcode, _BlockOpcode); - function TryOpcode(options) { - _classCallCheck(this, TryOpcode); - - _BlockOpcode.call(this, options); + function TryOpcode(ops, state, bounds, children) { + _BlockOpcode.call(this, ops, state, bounds, children); this.type = "try"; this.tag = this._tag = new _glimmerReference.UpdatableTag(_glimmerReference.CONSTANT_TAG); } TryOpcode.prototype.didInitializeChildren = function didInitializeChildren() { @@ -22901,18 +23464,16 @@ exports.TryOpcode = TryOpcode; var ListRevalidationDelegate = (function () { function ListRevalidationDelegate(opcode, marker) { - _classCallCheck(this, ListRevalidationDelegate); - + this.opcode = opcode; + this.marker = marker; this.didInsert = false; this.didDelete = false; - this.opcode = opcode; this.map = opcode.map; this.updating = opcode['children']; - this.marker = marker; } ListRevalidationDelegate.prototype.insert = function insert(key, item, memo, before) { var map = this.map; var opcode = this.opcode; @@ -22932,16 +23493,14 @@ vm.frame.setArgs(_glimmerRuntimeLibCompiledExpressionsArgs.EvaluatedArgs.positional([item, memo])); vm.frame.setOperand(item); vm.frame.setCondition(new _glimmerReference.ConstReference(true)); vm.frame.setKey(key); var state = vm.capture(); - tryOpcode = new TryOpcode({ - state: state, - ops: opcode.ops, - children: vm.updatingOpcodeStack.current - }); + var tracker = vm.stack().pushUpdatableBlock(); + tryOpcode = new TryOpcode(opcode.ops, state, tracker, vm.updatingOpcodeStack.current); }); + tryOpcode.didInitializeChildren(); updating.insertBefore(tryOpcode, reference); map[key] = tryOpcode; this.didInsert = true; }; @@ -22983,37 +23542,42 @@ })(); exports.ListRevalidationDelegate = ListRevalidationDelegate; var ListBlockOpcode = (function (_BlockOpcode2) { - _inherits(ListBlockOpcode, _BlockOpcode2); + babelHelpers.inherits(ListBlockOpcode, _BlockOpcode2); - function ListBlockOpcode(options) { - _classCallCheck(this, ListBlockOpcode); - - _BlockOpcode2.call(this, options); + function ListBlockOpcode(ops, state, bounds, children, artifacts) { + _BlockOpcode2.call(this, ops, state, bounds, children); this.type = "list-block"; this.map = _glimmerUtil.dict(); - this.artifacts = options.artifacts; - this.tag = this._tag = new _glimmerReference.UpdatableTag(_glimmerReference.CONSTANT_TAG); + this.lastIterated = _glimmerReference.INITIAL; + this.artifacts = artifacts; + var _tag = this._tag = new _glimmerReference.UpdatableTag(_glimmerReference.CONSTANT_TAG); + this.tag = _glimmerReference.combine([artifacts.tag, _tag]); } ListBlockOpcode.prototype.didInitializeChildren = function didInitializeChildren() { + this.lastIterated = this.artifacts.tag.value(); this._tag.update(_glimmerReference.combineSlice(this.children)); }; ListBlockOpcode.prototype.evaluate = function evaluate(vm) { var artifacts = this.artifacts; - var bounds = this.bounds; - var dom = vm.dom; + var lastIterated = this.lastIterated; - var marker = dom.createComment(''); - dom.insertAfter(bounds.parentElement(), marker, bounds.lastNode()); - var target = new ListRevalidationDelegate(this, marker); - var synchronizer = new _glimmerReference.IteratorSynchronizer({ target: target, artifacts: artifacts }); - synchronizer.sync(); - this.parentElement().removeChild(marker); + if (!artifacts.tag.validate(lastIterated)) { + var bounds = this.bounds; + var dom = vm.dom; + + var marker = dom.createComment(''); + dom.insertAfter(bounds.parentElement(), marker, bounds.lastNode()); + var target = new ListRevalidationDelegate(this, marker); + var synchronizer = new _glimmerReference.IteratorSynchronizer({ target: target, artifacts: artifacts }); + synchronizer.sync(); + this.parentElement().removeChild(marker); + } // Run now-updated updating opcodes _BlockOpcode2.prototype.evaluate.call(this, vm); }; ListBlockOpcode.prototype.vmForInsertion = function vmForInsertion(nextSibling) { @@ -23040,12 +23604,10 @@ exports.ListBlockOpcode = ListBlockOpcode; var UpdatingVMFrame = (function () { function UpdatingVMFrame(vm, ops, handler) { - _classCallCheck(this, UpdatingVMFrame); - this.vm = vm; this.ops = ops; this.current = ops.head(); this.exceptionHandler = handler; } @@ -23069,27 +23631,24 @@ return UpdatingVMFrame; })(); exports.UpdatingVMFrame = UpdatingVMFrame; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/vm/update.ts"],"names":[],"mappings":"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","file":"update.js","sourcesContent":["import { Scope, DynamicScope, Environment } from '../environment';\nimport { Bounds, clear, move as moveBounds } from '../bounds';\nimport { ElementStack, Tracker } from '../builder';\nimport { LOGGER, Destroyable, Opaque, Stack, LinkedList, InternedString, Dict, dict } from 'glimmer-util';\nimport {\n  ConstReference,\n  PathReference,\n  IterationArtifacts,\n  IteratorSynchronizer,\n  IteratorSynchronizerDelegate,\n\n  // Tags\n  UpdatableTag,\n  combineSlice,\n  CONSTANT_TAG\n} from 'glimmer-reference';\nimport { EvaluatedArgs } from '../compiled/expressions/args';\nimport { OpcodeJSON, OpSeq, UpdatingOpcode, UpdatingOpSeq } from '../opcodes';\nimport { LabelOpcode } from '../compiled/opcodes/vm';\nimport { DOMHelper } from '../dom/helper';\n\nimport VM from './append';\n\nexport default class UpdatingVM {\n  public env: Environment;\n  public dom: DOMHelper;\n  public alwaysRevalidate: boolean;\n  private frameStack: Stack<UpdatingVMFrame> = new Stack<UpdatingVMFrame>();\n\n  constructor(env: Environment, { alwaysRevalidate = false }) {\n    this.env = env;\n    this.dom = env.getDOM();\n    this.alwaysRevalidate = alwaysRevalidate;\n  }\n\n  execute(opcodes: UpdatingOpSeq, handler: ExceptionHandler) {\n    let { frameStack } = this;\n\n    this.try(opcodes, handler);\n\n    while (true) {\n      if (frameStack.isEmpty()) break;\n\n      let opcode = this.frameStack.current.nextStatement();\n\n      if (opcode === null) {\n        this.frameStack.pop();\n        continue;\n      }\n\n      LOGGER.debug(`[VM] OP ${opcode.type}`);\n      LOGGER.trace(opcode);\n\n      opcode.evaluate(this);\n    }\n  }\n\n  goto(op: UpdatingOpcode) {\n    this.frameStack.current.goto(op);\n  }\n\n  try(ops: UpdatingOpSeq, handler: ExceptionHandler) {\n    this.frameStack.push(new UpdatingVMFrame(this, ops, handler));\n  }\n\n  throw() {\n    this.frameStack.current.handleException();\n    this.frameStack.pop();\n  }\n\n  evaluateOpcode(opcode: UpdatingOpcode) {\n    opcode.evaluate(this);\n  }\n}\n\nexport interface ExceptionHandler {\n  handleException();\n}\n\nexport interface VMState {\n  env: Environment;\n  scope: Scope;\n  dynamicScope: DynamicScope;\n  block: Tracker;\n}\n\nexport interface BlockOpcodeOptions {\n  ops: OpSeq;\n  state: VMState;\n  children: LinkedList<UpdatingOpcode>;\n}\n\nexport abstract class BlockOpcode extends UpdatingOpcode implements Bounds, Destroyable {\n  public type = \"block\";\n  public next = null;\n  public prev = null;\n\n  protected env: Environment;\n  protected scope: Scope;\n  protected dynamicScope: DynamicScope;\n  protected children: LinkedList<UpdatingOpcode>;\n  protected bounds: Tracker;\n  public ops: OpSeq;\n\n  constructor({ ops, children, state }: BlockOpcodeOptions) {\n    super();\n    let { env, scope, dynamicScope, block } = state;\n    this.ops = ops;\n    this.children = children;\n    this.env = env;\n    this.scope = scope;\n    this.dynamicScope = dynamicScope;\n    this.bounds = block;\n  }\n\n  abstract didInitializeChildren();\n\n  parentElement() {\n    return this.bounds.parentElement();\n  }\n\n  firstNode() {\n    return this.bounds.firstNode();\n  }\n\n  lastNode() {\n    return this.bounds.lastNode();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    vm.try(this.children, null);\n  }\n\n  destroy() {\n    this.bounds.destroy();\n  }\n\n  didDestroy() {\n    this.env.didDestroy(this.bounds);\n  }\n\n  toJSON() : OpcodeJSON {\n    let begin = this.ops.head() as LabelOpcode;\n    let end = this.ops.tail() as LabelOpcode;\n    let details = dict<string>();\n\n    details[\"guid\"] = `${this._guid}`;\n    details[\"begin\"] = begin.inspect();\n    details[\"end\"] = end.inspect();\n\n    return {\n      guid: this._guid,\n      type: this.type,\n      details,\n      children: this.children.toArray().map(op => op.toJSON())\n    };\n  }\n}\n\nexport class TryOpcode extends BlockOpcode implements ExceptionHandler {\n  public type = \"try\";\n\n  private _tag: UpdatableTag;\n\n  constructor(options: BlockOpcodeOptions) {\n    super(options);\n    this.tag = this._tag = new UpdatableTag(CONSTANT_TAG);\n  }\n\n  didInitializeChildren() {\n    this._tag.update(combineSlice(this.children));\n  }\n\n  evaluate(vm: UpdatingVM) {\n    vm.try(this.children, this);\n  }\n\n  handleException() {\n    let { env, scope, dynamicScope } = this;\n\n    let elementStack = ElementStack.resume(\n      this.env,\n      this.bounds,\n      this.bounds.reset(env)\n    );\n\n    let vm = new VM({ env, scope, dynamicScope, elementStack });\n    let result = vm.execute(this.ops);\n\n    this.children = result.opcodes();\n    this.didInitializeChildren();\n  }\n\n  toJSON() : OpcodeJSON {\n    let json = super.toJSON();\n    let begin = this.ops.head() as LabelOpcode;\n    let end = this.ops.tail() as LabelOpcode;\n\n    json[\"details\"][\"begin\"] = JSON.stringify(begin.inspect());\n    json[\"details\"][\"end\"] = JSON.stringify(end.inspect());\n\n    return super.toJSON();\n  }\n}\n\nexport class ListRevalidationDelegate implements IteratorSynchronizerDelegate {\n  private opcode: ListBlockOpcode;\n  private map: Dict<BlockOpcode>;\n  private updating: LinkedList<UpdatingOpcode>;\n  private marker: Comment;\n\n  private didInsert = false;\n  private didDelete = false;\n\n  constructor(opcode: ListBlockOpcode, marker: Comment) {\n    this.opcode = opcode;\n    this.map = opcode.map;\n    this.updating = opcode['children'];\n    this.marker = marker;\n  }\n\n  insert(key: InternedString, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: InternedString) {\n    let { map, opcode, updating } = this;\n    let nextSibling: Node = null;\n    let reference = null;\n\n    if (before) {\n      reference = map[<string>before];\n      nextSibling = reference.bounds.firstNode();\n    } else {\n      nextSibling = this.marker;\n    }\n\n    let vm = opcode.vmForInsertion(nextSibling);\n    let tryOpcode;\n\n    vm.execute(opcode.ops, vm => {\n      vm.frame.setArgs(EvaluatedArgs.positional([item, memo]));\n      vm.frame.setOperand(item);\n      vm.frame.setCondition(new ConstReference(true));\n      vm.frame.setKey(key);\n\n      let state = vm.capture();\n\n      tryOpcode = new TryOpcode({\n        state,\n        ops: opcode.ops,\n        children: vm.updatingOpcodeStack.current\n      });\n    });\n\n    updating.insertBefore(tryOpcode, reference);\n\n    map[<string>key] = tryOpcode;\n\n    this.didInsert = true;\n  }\n\n  retain(key: InternedString, item: PathReference<Opaque>, memo: PathReference<Opaque>) {\n  }\n\n  move(key: InternedString, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: InternedString) {\n    let { map, updating } = this;\n\n    let entry = map[<string>key];\n    let reference = map[<string>before] || null;\n\n    if (before) {\n      moveBounds(entry, reference.firstNode());\n    } else {\n      moveBounds(entry, this.marker);\n    }\n\n    updating.remove(entry);\n    updating.insertBefore(entry, reference);\n  }\n\n  delete(key: InternedString) {\n    let { map } = this;\n    let opcode = map[<string>key];\n    clear(opcode);\n    opcode.didDestroy();\n    this.updating.remove(opcode);\n    delete map[<string>key];\n\n    this.didDelete = true;\n  }\n\n  done() {\n    if (this.didInsert || this.didDelete) {\n      this.opcode.didInitializeChildren();\n    }\n  }\n}\n\nexport interface ListBlockOpcodeOptions extends BlockOpcodeOptions {\n  artifacts: IterationArtifacts;\n}\n\nexport class ListBlockOpcode extends BlockOpcode {\n  public type = \"list-block\";\n  public map = dict<BlockOpcode>();\n  public artifacts: IterationArtifacts;\n\n  private _tag: UpdatableTag;\n\n  constructor(options: ListBlockOpcodeOptions) {\n    super(options);\n    this.artifacts = options.artifacts;\n    this.tag = this._tag = new UpdatableTag(CONSTANT_TAG);\n  }\n\n  didInitializeChildren() {\n    this._tag.update(combineSlice(this.children));\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { artifacts, bounds } = this;\n    let { dom } = vm;\n\n    let marker = dom.createComment('');\n    dom.insertAfter(bounds.parentElement(), marker, bounds.lastNode());\n\n    let target = new ListRevalidationDelegate(this, marker);\n    let synchronizer = new IteratorSynchronizer({ target, artifacts });\n\n    synchronizer.sync();\n\n    this.parentElement().removeChild(marker);\n\n    // Run now-updated updating opcodes\n    super.evaluate(vm);\n  }\n\n  vmForInsertion(nextSibling: Node) {\n    let { env, scope, dynamicScope } = this;\n\n    let elementStack = ElementStack.forInitialRender(\n      this.env,\n      this.bounds.parentElement(),\n      nextSibling\n    );\n\n    return new VM({ env, scope, dynamicScope, elementStack });\n  }\n\n  toJSON() : OpcodeJSON {\n    let json = super.toJSON();\n    let map = this.map;\n\n    let inner = Object.keys(map).map(key => {\n      return `${JSON.stringify(key)}: ${map[key]._guid}`;\n    }).join(\", \");\n\n    json[\"details\"][\"map\"] = `{${inner}}`;\n\n    return json;\n  }\n}\n\nexport class UpdatingVMFrame {\n  private vm: UpdatingVM;\n  private ops: UpdatingOpSeq;\n  private current: UpdatingOpcode;\n  private exceptionHandler: ExceptionHandler;\n\n  constructor(vm: UpdatingVM, ops: UpdatingOpSeq, handler: ExceptionHandler) {\n    this.vm = vm;\n    this.ops = ops;\n    this.current = ops.head();\n    this.exceptionHandler = handler;\n  }\n\n  goto(op: UpdatingOpcode) {\n    this.current = op;\n  }\n\n  nextStatement(): UpdatingOpcode {\n    let { current, ops } = this;\n    if (current) this.current = ops.nextNode(current);\n    return current;\n  }\n\n  handleException() {\n    this.exceptionHandler.handleException();\n  }\n}\n"]} + +// Tags +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-runtime/lib/vm/update.ts"],"names":[],"mappings":"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","file":"update.js","sourcesContent":["import { Scope, DynamicScope, Environment } from '../environment';\nimport { DestroyableBounds, clear, move as moveBounds } from '../bounds';\nimport { ElementStack, Tracker, UpdatableTracker } from '../builder';\nimport { LOGGER, Opaque, Stack, LinkedList, Dict, dict } from 'glimmer-util';\nimport {\n  ConstReference,\n  PathReference,\n  IterationArtifacts,\n  IteratorSynchronizer,\n  IteratorSynchronizerDelegate,\n\n  // Tags\n  combine,\n  Revision,\n  UpdatableTag,\n  combineSlice,\n  CONSTANT_TAG,\n  INITIAL\n} from 'glimmer-reference';\nimport { EvaluatedArgs } from '../compiled/expressions/args';\nimport { OpcodeJSON, OpSeq, UpdatingOpcode, UpdatingOpSeq } from '../opcodes';\nimport { LabelOpcode } from '../compiled/opcodes/vm';\nimport { DOMChanges } from '../dom/helper';\nimport * as Simple from '../dom/interfaces';\n\nimport VM from './append';\n\nexport default class UpdatingVM {\n  public env: Environment;\n  public dom: DOMChanges;\n  public alwaysRevalidate: boolean;\n  private frameStack: Stack<UpdatingVMFrame> = new Stack<UpdatingVMFrame>();\n\n  constructor(env: Environment, { alwaysRevalidate = false }) {\n    this.env = env;\n    this.dom = env.getDOM();\n    this.alwaysRevalidate = alwaysRevalidate;\n  }\n\n  execute(opcodes: UpdatingOpSeq, handler: ExceptionHandler) {\n    let { frameStack } = this;\n\n    this.try(opcodes, handler);\n\n    while (true) {\n      if (frameStack.isEmpty()) break;\n\n      let opcode = this.frameStack.current.nextStatement();\n\n      if (opcode === null) {\n        this.frameStack.pop();\n        continue;\n      }\n\n      LOGGER.debug(`[VM] OP ${opcode.type}`);\n      LOGGER.trace(opcode);\n\n      opcode.evaluate(this);\n    }\n  }\n\n  goto(op: UpdatingOpcode) {\n    this.frameStack.current.goto(op);\n  }\n\n  try(ops: UpdatingOpSeq, handler: ExceptionHandler) {\n    this.frameStack.push(new UpdatingVMFrame(this, ops, handler));\n  }\n\n  throw() {\n    this.frameStack.current.handleException();\n    this.frameStack.pop();\n  }\n\n  evaluateOpcode(opcode: UpdatingOpcode) {\n    opcode.evaluate(this);\n  }\n}\n\nexport interface ExceptionHandler {\n  handleException();\n}\n\nexport interface VMState {\n  env: Environment;\n  scope: Scope;\n  dynamicScope: DynamicScope;\n}\n\nexport abstract class BlockOpcode extends UpdatingOpcode implements DestroyableBounds {\n  public type = \"block\";\n  public next = null;\n  public prev = null;\n\n  protected env: Environment;\n  protected scope: Scope;\n  protected dynamicScope: DynamicScope;\n  protected children: LinkedList<UpdatingOpcode>;\n  protected bounds: DestroyableBounds;\n  public ops: OpSeq;\n\n  constructor(ops: OpSeq, state: VMState, bounds: DestroyableBounds, children: LinkedList<UpdatingOpcode>) {\n    super();\n    let { env, scope, dynamicScope } = state;\n    this.ops = ops;\n    this.children = children;\n    this.env = env;\n    this.scope = scope;\n    this.dynamicScope = dynamicScope;\n    this.bounds = bounds;\n  }\n\n  abstract didInitializeChildren();\n\n  parentElement() {\n    return this.bounds.parentElement();\n  }\n\n  firstNode() {\n    return this.bounds.firstNode();\n  }\n\n  lastNode() {\n    return this.bounds.lastNode();\n  }\n\n  evaluate(vm: UpdatingVM) {\n    vm.try(this.children, null);\n  }\n\n  destroy() {\n    this.bounds.destroy();\n  }\n\n  didDestroy() {\n    this.env.didDestroy(this.bounds);\n  }\n\n  toJSON() : OpcodeJSON {\n    let begin = this.ops.head() as LabelOpcode;\n    let end = this.ops.tail() as LabelOpcode;\n    let details = dict<string>();\n\n    details[\"guid\"] = `${this._guid}`;\n    details[\"begin\"] = begin.inspect();\n    details[\"end\"] = end.inspect();\n\n    return {\n      guid: this._guid,\n      type: this.type,\n      details,\n      children: this.children.toArray().map(op => op.toJSON())\n    };\n  }\n}\n\nexport class TryOpcode extends BlockOpcode implements ExceptionHandler {\n  public type = \"try\";\n\n  private _tag: UpdatableTag;\n\n  protected bounds: UpdatableTracker;\n\n  constructor(ops: OpSeq, state: VMState, bounds: UpdatableTracker, children: LinkedList<UpdatingOpcode>) {\n    super(ops, state, bounds, children);\n    this.tag = this._tag = new UpdatableTag(CONSTANT_TAG);\n  }\n\n  didInitializeChildren() {\n    this._tag.update(combineSlice(this.children));\n  }\n\n  evaluate(vm: UpdatingVM) {\n    vm.try(this.children, this);\n  }\n\n  handleException() {\n    let { env, scope, dynamicScope } = this;\n\n    let elementStack = ElementStack.resume(\n      this.env,\n      this.bounds,\n      this.bounds.reset(env)\n    );\n\n    let vm = new VM({ env, scope, dynamicScope, elementStack });\n    let result = vm.execute(this.ops);\n\n    this.children = result.opcodes();\n    this.didInitializeChildren();\n  }\n\n  toJSON() : OpcodeJSON {\n    let json = super.toJSON();\n    let begin = this.ops.head() as LabelOpcode;\n    let end = this.ops.tail() as LabelOpcode;\n\n    json[\"details\"][\"begin\"] = JSON.stringify(begin.inspect());\n    json[\"details\"][\"end\"] = JSON.stringify(end.inspect());\n\n    return super.toJSON();\n  }\n}\n\nexport class ListRevalidationDelegate implements IteratorSynchronizerDelegate {\n  private map: Dict<BlockOpcode>;\n  private updating: LinkedList<UpdatingOpcode>;\n\n  private didInsert = false;\n  private didDelete = false;\n\n  constructor(private opcode: ListBlockOpcode, private marker: Simple.Comment) {\n    this.map = opcode.map;\n    this.updating = opcode['children'];\n  }\n\n  insert(key: string, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: string) {\n    let { map, opcode, updating } = this;\n    let nextSibling: Simple.Node = null;\n    let reference = null;\n\n    if (before) {\n      reference = map[before];\n      nextSibling = reference.bounds.firstNode();\n    } else {\n      nextSibling = this.marker;\n    }\n\n    let vm = opcode.vmForInsertion(nextSibling);\n    let tryOpcode: TryOpcode;\n\n    vm.execute(opcode.ops, vm => {\n      vm.frame.setArgs(EvaluatedArgs.positional([item, memo]));\n      vm.frame.setOperand(item);\n      vm.frame.setCondition(new ConstReference(true));\n      vm.frame.setKey(key);\n\n      let state = vm.capture();\n      let tracker = vm.stack().pushUpdatableBlock();\n\n      tryOpcode = new TryOpcode(opcode.ops, state, tracker, vm.updatingOpcodeStack.current);\n    });\n\n    tryOpcode.didInitializeChildren();\n\n    updating.insertBefore(tryOpcode, reference);\n\n    map[key] = tryOpcode;\n\n    this.didInsert = true;\n  }\n\n  retain(key: string, item: PathReference<Opaque>, memo: PathReference<Opaque>) {\n  }\n\n  move(key: string, item: PathReference<Opaque>, memo: PathReference<Opaque>, before: string) {\n    let { map, updating } = this;\n\n    let entry = map[key];\n    let reference = map[before] || null;\n\n    if (before) {\n      moveBounds(entry, reference.firstNode());\n    } else {\n      moveBounds(entry, this.marker);\n    }\n\n    updating.remove(entry);\n    updating.insertBefore(entry, reference);\n  }\n\n  delete(key: string) {\n    let { map } = this;\n    let opcode = map[key];\n    clear(opcode);\n    opcode.didDestroy();\n    this.updating.remove(opcode);\n    delete map[key];\n\n    this.didDelete = true;\n  }\n\n  done() {\n    if (this.didInsert || this.didDelete) {\n      this.opcode.didInitializeChildren();\n    }\n  }\n}\n\nexport class ListBlockOpcode extends BlockOpcode {\n  public type = \"list-block\";\n  public map = dict<BlockOpcode>();\n  public artifacts: IterationArtifacts;\n\n  private lastIterated: Revision = INITIAL;\n  private _tag: UpdatableTag;\n\n  constructor(ops: OpSeq, state: VMState, bounds: Tracker, children: LinkedList<UpdatingOpcode>, artifacts: IterationArtifacts) {\n    super(ops, state, bounds, children);\n    this.artifacts = artifacts;\n    let _tag = this._tag = new UpdatableTag(CONSTANT_TAG);\n    this.tag = combine([artifacts.tag, _tag]);\n  }\n\n  didInitializeChildren() {\n    this.lastIterated = this.artifacts.tag.value();\n    this._tag.update(combineSlice(this.children));\n  }\n\n  evaluate(vm: UpdatingVM) {\n    let { artifacts, lastIterated } = this;\n\n    if (!artifacts.tag.validate(lastIterated)) {\n      let { bounds } = this;\n      let { dom } = vm;\n\n      let marker = dom.createComment('');\n      dom.insertAfter(bounds.parentElement(), marker, bounds.lastNode());\n\n      let target = new ListRevalidationDelegate(this, marker);\n      let synchronizer = new IteratorSynchronizer({ target, artifacts });\n\n      synchronizer.sync();\n\n      this.parentElement().removeChild(marker);\n    }\n\n    // Run now-updated updating opcodes\n    super.evaluate(vm);\n  }\n\n  vmForInsertion(nextSibling: Simple.Node) {\n    let { env, scope, dynamicScope } = this;\n\n    let elementStack = ElementStack.forInitialRender(\n      this.env,\n      this.bounds.parentElement(),\n      nextSibling\n    );\n\n    return new VM({ env, scope, dynamicScope, elementStack });\n  }\n\n  toJSON() : OpcodeJSON {\n    let json = super.toJSON();\n    let map = this.map;\n\n    let inner = Object.keys(map).map(key => {\n      return `${JSON.stringify(key)}: ${map[key]._guid}`;\n    }).join(\", \");\n\n    json[\"details\"][\"map\"] = `{${inner}}`;\n\n    return json;\n  }\n}\n\nexport class UpdatingVMFrame {\n  private vm: UpdatingVM;\n  private ops: UpdatingOpSeq;\n  private current: UpdatingOpcode;\n  private exceptionHandler: ExceptionHandler;\n\n  constructor(vm: UpdatingVM, ops: UpdatingOpSeq, handler: ExceptionHandler) {\n    this.vm = vm;\n    this.ops = ops;\n    this.current = ops.head();\n    this.exceptionHandler = handler;\n  }\n\n  goto(op: UpdatingOpcode) {\n    this.current = op;\n  }\n\n  nextStatement(): UpdatingOpcode {\n    let { current, ops } = this;\n    if (current) this.current = ops.nextNode(current);\n    return current;\n  }\n\n  handleException() {\n    this.exceptionHandler.handleException();\n  }\n}\n"]} enifed('glimmer-syntax/index', ['exports', 'glimmer-syntax/lib/syntax', 'glimmer-syntax/lib/utils', 'glimmer-syntax/lib/parser'], function (exports, _glimmerSyntaxLibSyntax, _glimmerSyntaxLibUtils, _glimmerSyntaxLibParser) { 'use strict'; - function _interopExportWildcard(obj, defaults) { var newObj = defaults({}, obj); delete newObj['default']; return newObj; } - - function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; } - - _defaults(exports, _interopExportWildcard(_glimmerSyntaxLibSyntax, _defaults)); - + babelHelpers.defaults(exports, babelHelpers.interopExportWildcard(_glimmerSyntaxLibSyntax, babelHelpers.defaults)); exports.isHelper = _glimmerSyntaxLibUtils.isHelper; - exports.isSelfGet = _glimmerSyntaxLibUtils.isSelfGet; exports.preprocess = _glimmerSyntaxLibParser.preprocess; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItc3ludGF4L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztVQUNTLFFBQVEsMEJBQVIsUUFBUTtVQUFFLFNBQVMsMEJBQVQsU0FBUztVQUNuQixVQUFVLDJCQUFWLFVBQVUiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9zeW50YXgnO1xuZXhwb3J0IHsgaXNIZWxwZXIsIGlzU2VsZkdldCB9IGZyb20gJy4vbGliL3V0aWxzJztcbmV4cG9ydCB7IHByZXByb2Nlc3MgfSBmcm9tICcuL2xpYi9wYXJzZXInO1xuIl19 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItc3ludGF4L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7VUFDUyxRQUFRLDBCQUFSLFFBQVE7VUFDUixVQUFVLDJCQUFWLFVBQVUiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9zeW50YXgnO1xuZXhwb3J0IHsgaXNIZWxwZXIgfSBmcm9tICcuL2xpYi91dGlscyc7XG5leHBvcnQgeyBwcmVwcm9jZXNzIH0gZnJvbSAnLi9saWIvcGFyc2VyJztcbiJdfQ== enifed("glimmer-syntax/lib/builders", ["exports"], function (exports) { // Statements + // Statements "use strict"; exports.buildMustache = buildMustache; exports.buildBlock = buildBlock; exports.buildElementModifier = buildElementModifier; @@ -23351,11 +23910,11 @@ program: buildProgram, loc: buildLoc, pos: buildPosition }; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/builders.ts"],"names":[],"mappings":"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","file":"builders.js","sourcesContent":["// Statements\n\nexport function buildMustache(path, params?, hash?, raw?, loc?) {\n  return {\n    type: \"MustacheStatement\",\n    path: buildPath(path),\n    params: params || [],\n    hash: hash || buildHash([]),\n    escaped: !raw,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildBlock(path, params?, hash?, program?, inverse?, loc?) {\n  return {\n    type: \"BlockStatement\",\n    path: buildPath(path),\n    params: params ? params.map(buildPath) : [],\n    hash: hash || buildHash([]),\n    program: program || null,\n    inverse: inverse || null,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildElementModifier(path, params?, hash?, loc?) {\n  return {\n    type: \"ElementModifierStatement\",\n    path: buildPath(path),\n    params: params || [],\n    hash: hash || buildHash([]),\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildPartial(name, params, hash, indent) {\n  return {\n    type: \"PartialStatement\",\n    name: name,\n    params: params || [],\n    hash: hash || buildHash([]),\n    indent: indent\n  };\n}\n\nexport function buildComment(value) {\n  return {\n    type: \"CommentStatement\",\n    value: value\n  };\n}\n\nexport function buildConcat(parts) {\n  return {\n    type: \"ConcatStatement\",\n    parts: parts || []\n  };\n}\n\n// Nodes\n\nexport function buildElement(tag, attributes?, modifiers?, children?, loc?) {\n  return {\n    type: \"ElementNode\",\n    tag: tag || \"\",\n    attributes: attributes || [],\n    blockParams: [],\n    modifiers: modifiers || [],\n    children: children || [],\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildAttr(name, value, loc?) {\n  return {\n    type: \"AttrNode\",\n    name: name,\n    value: value,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildText(chars?, loc?) {\n  return {\n    type: \"TextNode\",\n    chars: chars || \"\",\n    loc: buildLoc(loc)\n  };\n}\n\n// Expressions\n\nexport function buildSexpr(path, params?, hash?, loc?) {\n  return {\n    type: \"SubExpression\",\n    path: buildPath(path),\n    params: params || [],\n    hash: hash || buildHash([]),\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildPath(original, loc?) {\n  if (typeof original !== 'string') return original;\n\n  return {\n    type: \"PathExpression\",\n    original: original,\n    parts: original.split('.'),\n    data: false,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildString(value) {\n  return {\n    type: \"StringLiteral\",\n    value: value,\n    original: value\n  };\n}\n\nexport function buildBoolean(value) {\n  return {\n    type: \"BooleanLiteral\",\n    value: value,\n    original: value\n  };\n}\n\nexport function buildNumber(value) {\n  return {\n    type: \"NumberLiteral\",\n    value: value,\n    original: value\n  };\n}\n\nexport function buildNull() {\n  return {\n    type: \"NullLiteral\",\n    value: null,\n    original: null\n  };\n}\n\nexport function buildUndefined() {\n  return {\n    type: \"UndefinedLiteral\",\n    value: undefined,\n    original: undefined\n  };\n}\n\n// Miscellaneous\n\nexport function buildHash(pairs?) {\n  return {\n    type: \"Hash\",\n    pairs: pairs || []\n  };\n}\n\nexport function buildPair(key, value) {\n  return {\n    type: \"HashPair\",\n    key: key,\n    value: value\n  };\n}\n\nexport function buildProgram(body?, blockParams?, loc?) {\n  return {\n    type: \"Program\",\n    body: body || [],\n    blockParams: blockParams || [],\n    loc: buildLoc(loc)\n  };\n}\n\nfunction buildSource(source?) {\n  return source || null;\n}\n\nexport function buildPosition(line, column) {\n  return {\n    line: (typeof line === 'number') ? line : null,\n    column: (typeof column === 'number') ? column : null\n  };\n}\n\nfunction buildLoc(loc: { source: any, start: any, end: any }): { source: any, start: any, end: any };\nfunction buildLoc(startLine, startColumn, endLine?, endColumn?, source?): { source: any, start: any, end: any };\n\nfunction buildLoc(...args) {\n  if (args.length === 1) {\n    let loc = args[0];\n\n    if (typeof loc === 'object') {\n      return {\n        source: buildSource(loc.source),\n        start: buildPosition(loc.start.line, loc.start.column),\n        end: buildPosition(loc.end.line, loc.end.column)\n      };\n    } else {\n      return null;\n    }\n  } else {\n    let [ startLine, startColumn, endLine, endColumn, source ] = args;\n    return {\n      source: buildSource(source),\n      start: buildPosition(startLine, startColumn),\n      end: buildPosition(endLine, endColumn)\n    };\n  }\n}\n\nexport default {\n  mustache: buildMustache,\n  block: buildBlock,\n  partial: buildPartial,\n  comment: buildComment,\n  element: buildElement,\n  elementModifier: buildElementModifier,\n  attr: buildAttr,\n  text: buildText,\n  sexpr: buildSexpr,\n  path: buildPath,\n  string: buildString,\n  boolean: buildBoolean,\n  number: buildNumber,\n  undefined: buildUndefined,\n  null: buildNull,\n  concat: buildConcat,\n  hash: buildHash,\n  pair: buildPair,\n  program: buildProgram,\n  loc: buildLoc,\n  pos: buildPosition\n};\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/builders.ts"],"names":[],"mappings":"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","file":"builders.js","sourcesContent":["// Statements\n\nexport function buildMustache(path, params?, hash?, raw?, loc?) {\n  return {\n    type: \"MustacheStatement\",\n    path: buildPath(path),\n    params: params || [],\n    hash: hash || buildHash([]),\n    escaped: !raw,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildBlock(path, params?, hash?, program?, inverse?, loc?) {\n  return {\n    type: \"BlockStatement\",\n    path: buildPath(path),\n    params: params ? params.map(buildPath) : [],\n    hash: hash || buildHash([]),\n    program: program || null,\n    inverse: inverse || null,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildElementModifier(path, params?, hash?, loc?) {\n  return {\n    type: \"ElementModifierStatement\",\n    path: buildPath(path),\n    params: params || [],\n    hash: hash || buildHash([]),\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildPartial(name, params, hash, indent) {\n  return {\n    type: \"PartialStatement\",\n    name: name,\n    params: params || [],\n    hash: hash || buildHash([]),\n    indent: indent\n  };\n}\n\nexport function buildComment(value) {\n  return {\n    type: \"CommentStatement\",\n    value: value\n  };\n}\n\nexport function buildConcat(parts) {\n  return {\n    type: \"ConcatStatement\",\n    parts: parts || []\n  };\n}\n\n// Nodes\n\nexport function buildElement(tag, attributes?, modifiers?, children?, loc?) {\n  return {\n    type: \"ElementNode\",\n    tag: tag || \"\",\n    attributes: attributes || [],\n    blockParams: [],\n    modifiers: modifiers || [],\n    children: children || [],\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildAttr(name, value, loc?) {\n  return {\n    type: \"AttrNode\",\n    name: name,\n    value: value,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildText(chars?, loc?) {\n  return {\n    type: \"TextNode\",\n    chars: chars || \"\",\n    loc: buildLoc(loc)\n  };\n}\n\n// Expressions\n\nexport function buildSexpr(path, params?, hash?, loc?) {\n  return {\n    type: \"SubExpression\",\n    path: buildPath(path),\n    params: params || [],\n    hash: hash || buildHash([]),\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildPath(original, loc?) {\n  if (typeof original !== 'string') return original;\n\n  return {\n    type: \"PathExpression\",\n    original: original,\n    parts: original.split('.'),\n    data: false,\n    loc: buildLoc(loc)\n  };\n}\n\nexport function buildString(value) {\n  return {\n    type: \"StringLiteral\",\n    value: value,\n    original: value\n  };\n}\n\nexport function buildBoolean(value) {\n  return {\n    type: \"BooleanLiteral\",\n    value: value,\n    original: value\n  };\n}\n\nexport function buildNumber(value) {\n  return {\n    type: \"NumberLiteral\",\n    value: value,\n    original: value\n  };\n}\n\nexport function buildNull() {\n  return {\n    type: \"NullLiteral\",\n    value: null,\n    original: null\n  };\n}\n\nexport function buildUndefined() {\n  return {\n    type: \"UndefinedLiteral\",\n    value: undefined,\n    original: undefined\n  };\n}\n\n// Miscellaneous\n\nexport function buildHash(pairs?) {\n  return {\n    type: \"Hash\",\n    pairs: pairs || []\n  };\n}\n\nexport function buildPair(key, value) {\n  return {\n    type: \"HashPair\",\n    key: key,\n    value: value\n  };\n}\n\nexport function buildProgram(body?, blockParams?, loc?) {\n  return {\n    type: \"Program\",\n    body: body || [],\n    blockParams: blockParams || [],\n    loc: buildLoc(loc)\n  };\n}\n\nfunction buildSource(source?) {\n  return source || null;\n}\n\nexport function buildPosition(line, column) {\n  return {\n    line: (typeof line === 'number') ? line : null,\n    column: (typeof column === 'number') ? column : null\n  };\n}\n\nfunction buildLoc(loc: { source: any, start: any, end: any }): { source: any, start: any, end: any };\nfunction buildLoc(startLine, startColumn, endLine?, endColumn?, source?): { source: any, start: any, end: any };\n\nfunction buildLoc(...args) {\n  if (args.length === 1) {\n    let loc = args[0];\n\n    if (typeof loc === 'object') {\n      return {\n        source: buildSource(loc.source),\n        start: buildPosition(loc.start.line, loc.start.column),\n        end: buildPosition(loc.end.line, loc.end.column)\n      };\n    } else {\n      return null;\n    }\n  } else {\n    let [ startLine, startColumn, endLine, endColumn, source ] = args;\n    return {\n      source: buildSource(source),\n      start: buildPosition(startLine, startColumn),\n      end: buildPosition(endLine, endColumn)\n    };\n  }\n}\n\nexport default {\n  mustache: buildMustache,\n  block: buildBlock,\n  partial: buildPartial,\n  comment: buildComment,\n  element: buildElement,\n  elementModifier: buildElementModifier,\n  attr: buildAttr,\n  text: buildText,\n  sexpr: buildSexpr,\n  path: buildPath,\n  string: buildString,\n  boolean: buildBoolean,\n  number: buildNumber,\n  undefined: buildUndefined,\n  null: buildNull,\n  concat: buildConcat,\n  hash: buildHash,\n  pair: buildPair,\n  program: buildProgram,\n  loc: buildLoc,\n  pos: buildPosition\n};\n"]} enifed('glimmer-syntax/lib/generation/print', ['exports'], function (exports) { 'use strict'; exports.default = build; @@ -23535,11 +24094,11 @@ } function closeBlock(block) { return ['{{/', build(block.path), '}}'].join(''); } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/generation/print.ts"],"names":[],"mappings":"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","file":"print.js","sourcesContent":["export default function build(ast) {\n  if(!ast) {\n    return '';\n  }\n  const output = [];\n\n  switch(ast.type) {\n    case 'Program': {\n      const chainBlock = ast.chained && ast.body[0];\n      if(chainBlock) {\n        chainBlock.chained = true;\n      }\n      const body = buildEach(ast.body).join('');\n      output.push(body);\n    }\n    break;\n    case 'ElementNode':\n      output.push('<', ast.tag);\n      if(ast.attributes.length) {\n        output.push(' ', buildEach(ast.attributes).join(' '));\n      }\n      if(ast.modifiers.length) {\n        output.push(' ', buildEach(ast.modifiers).join(' '));\n      }\n      output.push('>');\n      output.push.apply(output, buildEach(ast.children));\n      output.push('</', ast.tag, '>');\n    break;\n    case 'AttrNode':\n      output.push(ast.name, '=');\n      const value = build(ast.value);\n      if(ast.value.type === 'TextNode') {\n        output.push('\"', value, '\"');\n      } else {\n        output.push(value);\n      }\n    break;\n    case 'ConcatStatement':\n      output.push('\"');\n      ast.parts.forEach(function(node) {\n        if(node.type === 'StringLiteral') {\n          output.push(node.original);\n        } else {\n          output.push(build(node));\n        }\n      });\n      output.push('\"');\n    break;\n    case 'TextNode':\n      output.push(ast.chars);\n    break;\n    case 'MustacheStatement': {\n      output.push(compactJoin(['{{', pathParams(ast), '}}']));\n    }\n    break;\n    case 'ElementModifierStatement': {\n      output.push(compactJoin(['{{', pathParams(ast), '}}']));\n    }\n    break;\n    case 'PathExpression':\n      output.push(ast.original);\n    break;\n    case 'SubExpression': {\n      output.push('(', pathParams(ast), ')');\n    }\n    break;\n    case 'BooleanLiteral':\n      output.push(ast.value ? 'true' : false);\n    break;\n    case 'BlockStatement': {\n      const lines = [];\n\n      if(ast.chained){\n        lines.push(['{{else ', pathParams(ast), '}}'].join(''));\n      }else{\n        lines.push(openBlock(ast));\n      }\n\n      lines.push(build(ast.program));\n\n      if(ast.inverse) {\n        if(!ast.inverse.chained){\n          lines.push('{{else}}');\n        }\n        lines.push(build(ast.inverse));\n      }\n\n      if(!ast.chained){\n        lines.push(closeBlock(ast));\n      }\n\n      output.push(lines.join(''));\n    }\n    break;\n    case 'PartialStatement': {\n      output.push(compactJoin(['{{>', pathParams(ast), '}}']));\n    }\n    break;\n    case 'CommentStatement': {\n      output.push(compactJoin(['<!--', ast.value, '-->']));\n    }\n    break;\n    case 'StringLiteral': {\n      output.push(`\"${ast.value}\"`);\n    }\n    break;\n    case 'NumberLiteral': {\n      output.push(ast.value);\n    }\n    break;\n    case 'UndefinedLiteral': {\n      output.push('undefined');\n    }\n    break;\n    case 'NullLiteral': {\n      output.push('null');\n    }\n    break;\n    case 'Hash': {\n      output.push(ast.pairs.map(function(pair) {\n        return build(pair);\n      }).join(' '));\n    }\n    break;\n    case 'HashPair': {\n      output.push(`${ast.key}=${build(ast.value)}`);\n    }\n    break;\n  }\n  return output.join('');\n}\n\nfunction compact(array) {\n  const newArray = [];\n  array.forEach(function(a) {\n    if(typeof(a) !== 'undefined' && a !== null && a !== '') {\n      newArray.push(a);\n    }\n  });\n  return newArray;\n}\n\nfunction buildEach(asts) {\n  const output = [];\n  asts.forEach(function(node) {\n    output.push(build(node));\n  });\n  return output;\n}\n\nfunction pathParams(ast) {\n  const name = build(ast.name);\n  const path = build(ast.path);\n  const params = buildEach(ast.params).join(' ');\n  const hash = build(ast.hash);\n  return compactJoin([name, path, params, hash], ' ');\n}\n\nfunction compactJoin(array, delimiter?) {\n  return compact(array).join(delimiter || '');\n}\n\nfunction blockParams(block) {\n  const params = block.program.blockParams;\n  if(params.length) {\n    return ` as |${params.join(',')}|`;\n  }\n}\n\nfunction openBlock(block) {\n  return ['{{#', pathParams(block), blockParams(block), '}}'].join('');\n}\n\nfunction closeBlock(block) {\n  return ['{{/', build(block.path), '}}'].join('');\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/generation/print.ts"],"names":[],"mappings":"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","file":"print.js","sourcesContent":["export default function build(ast) {\n  if(!ast) {\n    return '';\n  }\n  const output = [];\n\n  switch(ast.type) {\n    case 'Program': {\n      const chainBlock = ast.chained && ast.body[0];\n      if(chainBlock) {\n        chainBlock.chained = true;\n      }\n      const body = buildEach(ast.body).join('');\n      output.push(body);\n    }\n    break;\n    case 'ElementNode':\n      output.push('<', ast.tag);\n      if(ast.attributes.length) {\n        output.push(' ', buildEach(ast.attributes).join(' '));\n      }\n      if(ast.modifiers.length) {\n        output.push(' ', buildEach(ast.modifiers).join(' '));\n      }\n      output.push('>');\n      output.push.apply(output, buildEach(ast.children));\n      output.push('</', ast.tag, '>');\n    break;\n    case 'AttrNode':\n      output.push(ast.name, '=');\n      const value = build(ast.value);\n      if(ast.value.type === 'TextNode') {\n        output.push('\"', value, '\"');\n      } else {\n        output.push(value);\n      }\n    break;\n    case 'ConcatStatement':\n      output.push('\"');\n      ast.parts.forEach(function(node) {\n        if(node.type === 'StringLiteral') {\n          output.push(node.original);\n        } else {\n          output.push(build(node));\n        }\n      });\n      output.push('\"');\n    break;\n    case 'TextNode':\n      output.push(ast.chars);\n    break;\n    case 'MustacheStatement': {\n      output.push(compactJoin(['{{', pathParams(ast), '}}']));\n    }\n    break;\n    case 'ElementModifierStatement': {\n      output.push(compactJoin(['{{', pathParams(ast), '}}']));\n    }\n    break;\n    case 'PathExpression':\n      output.push(ast.original);\n    break;\n    case 'SubExpression': {\n      output.push('(', pathParams(ast), ')');\n    }\n    break;\n    case 'BooleanLiteral':\n      output.push(ast.value ? 'true' : false);\n    break;\n    case 'BlockStatement': {\n      const lines = [];\n\n      if(ast.chained){\n        lines.push(['{{else ', pathParams(ast), '}}'].join(''));\n      }else{\n        lines.push(openBlock(ast));\n      }\n\n      lines.push(build(ast.program));\n\n      if(ast.inverse) {\n        if(!ast.inverse.chained){\n          lines.push('{{else}}');\n        }\n        lines.push(build(ast.inverse));\n      }\n\n      if(!ast.chained){\n        lines.push(closeBlock(ast));\n      }\n\n      output.push(lines.join(''));\n    }\n    break;\n    case 'PartialStatement': {\n      output.push(compactJoin(['{{>', pathParams(ast), '}}']));\n    }\n    break;\n    case 'CommentStatement': {\n      output.push(compactJoin(['<!--', ast.value, '-->']));\n    }\n    break;\n    case 'StringLiteral': {\n      output.push(`\"${ast.value}\"`);\n    }\n    break;\n    case 'NumberLiteral': {\n      output.push(ast.value);\n    }\n    break;\n    case 'UndefinedLiteral': {\n      output.push('undefined');\n    }\n    break;\n    case 'NullLiteral': {\n      output.push('null');\n    }\n    break;\n    case 'Hash': {\n      output.push(ast.pairs.map(function(pair) {\n        return build(pair);\n      }).join(' '));\n    }\n    break;\n    case 'HashPair': {\n      output.push(`${ast.key}=${build(ast.value)}`);\n    }\n    break;\n  }\n  return output.join('');\n}\n\nfunction compact(array) {\n  const newArray = [];\n  array.forEach(function(a) {\n    if(typeof(a) !== 'undefined' && a !== null && a !== '') {\n      newArray.push(a);\n    }\n  });\n  return newArray;\n}\n\nfunction buildEach(asts) {\n  const output = [];\n  asts.forEach(function(node) {\n    output.push(build(node));\n  });\n  return output;\n}\n\nfunction pathParams(ast) {\n  const name = build(ast.name);\n  const path = build(ast.path);\n  const params = buildEach(ast.params).join(' ');\n  const hash = build(ast.hash);\n  return compactJoin([name, path, params, hash], ' ');\n}\n\nfunction compactJoin(array, delimiter?) {\n  return compact(array).join(delimiter || '');\n}\n\nfunction blockParams(block) {\n  const params = block.program.blockParams;\n  if(params.length) {\n    return ` as |${params.join(',')}|`;\n  }\n}\n\nfunction openBlock(block) {\n  return ['{{#', pathParams(block), blockParams(block), '}}'].join('');\n}\n\nfunction closeBlock(block) {\n  return ['{{/', build(block.path), '}}'].join('');\n}\n"]} enifed("glimmer-syntax/lib/parser", ["exports", "handlebars/compiler/base", "glimmer-syntax/lib/syntax", "simple-html-tokenizer/evented-tokenizer", "simple-html-tokenizer/entity-parser", "simple-html-tokenizer/html5-named-char-refs", "glimmer-syntax/lib/parser/handlebars-node-visitors", "glimmer-syntax/lib/parser/tokenizer-event-handlers"], function (exports, _handlebarsCompilerBase, _glimmerSyntaxLibSyntax, _simpleHtmlTokenizerEventedTokenizer, _simpleHtmlTokenizerEntityParser, _simpleHtmlTokenizerHtml5NamedCharRefs, _glimmerSyntaxLibParserHandlebarsNodeVisitors, _glimmerSyntaxLibParserTokenizerEventHandlers) { "use strict"; exports.preprocess = preprocess; exports.Parser = Parser; @@ -23611,11 +24170,11 @@ } } return string.join('\n'); }; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed("glimmer-syntax/lib/parser/handlebars-node-visitors", ["exports", "glimmer-syntax/lib/builders", "glimmer-syntax/lib/utils"], function (exports, _glimmerSyntaxLibBuilders, _glimmerSyntaxLibUtils) { "use strict"; exports.default = { Program: function (program) { @@ -23737,10 +24296,23 @@ throw new Error("Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths: \"" + path.original + "\" on line " + loc.start.line + "."); } path.parts = [path.parts.join('/')]; } delete path.depth; + // This is to fix a bug in the Handlebars AST where the path expressions in + // `{{this.foo}}` (and similarly `{{foo-bar this.foo named=this.foo}}` etc) + // are simply turned into `{{foo}}`. The fix is to push it back onto the + // parts array and let the runtime see the difference. However, we cannot + // simply use the string `this` as it means literally the property called + // "this" in the current context (it can be expressed in the syntax as + // `{{[this]}}`, where the square bracket are generally for this kind of + // escaping – such as `{{foo.["bar.baz"]}}` would mean lookup a property + // named literally "bar.baz" on `this.foo`). By convention, we use `null` + // for this purpose. + if (original.match(/^this(\..+)?$/)) { + path.parts.unshift(null); + } return path; }, Hash: function (hash) { for (var i = 0; i < hash.pairs.length; i++) { this.acceptNode(hash.pairs[i].value); @@ -23816,11 +24388,11 @@ function appendDynamicAttributeValuePart(attribute, part) { attribute.isDynamic = true; attribute.parts.push(part); } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/parser/handlebars-node-visitors.ts"],"names":[],"mappings":"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","file":"handlebars-node-visitors.js","sourcesContent":["import b from \"../builders\";\nimport { appendChild } from \"../utils\";\n\nexport default {\n\n  Program: function(program) {\n    let body = [];\n    let node = b.program(body, program.blockParams, program.loc);\n    let i, l = program.body.length;\n\n    this.elementStack.push(node);\n\n    if (l === 0) { return this.elementStack.pop(); }\n\n    for (i = 0; i < l; i++) {\n      this.acceptNode(program.body[i]);\n    }\n\n    // Ensure that that the element stack is balanced properly.\n    let poppedNode = this.elementStack.pop();\n    if (poppedNode !== node) {\n      throw new Error(\"Unclosed element `\" + poppedNode.tag + \"` (on line \" + poppedNode.loc.start.line + \").\");\n    }\n\n    return node;\n  },\n\n  BlockStatement: function(block) {\n    delete block.inverseStrip;\n    delete block.openString;\n    delete block.closeStrip;\n\n    if (this.tokenizer.state === 'comment') {\n      this.appendToCommentData('{{' + this.sourceForMustache(block) + '}}');\n      return;\n    }\n\n    if (this.tokenizer.state !== 'comment' && this.tokenizer.state !== 'data' && this.tokenizer.state !== 'beforeData') {\n      throw new Error(\"A block may only be used inside an HTML element or another block.\");\n    }\n\n    block = acceptCommonNodes(this, block);\n    let program = block.program ? this.acceptNode(block.program) : null;\n    let inverse = block.inverse ? this.acceptNode(block.inverse) : null;\n\n    let node = b.block(block.path, block.params, block.hash, program, inverse, block.loc);\n    let parentProgram = this.currentElement();\n    appendChild(parentProgram, node);\n  },\n\n  MustacheStatement: function(rawMustache) {\n    let tokenizer = this.tokenizer;\n    let { path, params, hash, escaped, loc } = rawMustache;\n    let mustache = b.mustache(path, params, hash, !escaped, loc);\n\n    if (tokenizer.state === 'comment') {\n      this.appendToCommentData('{{' + this.sourceForMustache(mustache) + '}}');\n      return;\n    }\n\n    acceptCommonNodes(this, mustache);\n\n    switch (tokenizer.state) {\n      // Tag helpers\n      case \"tagName\":\n        addElementModifier(this.currentNode, mustache);\n        tokenizer.state = \"beforeAttributeName\";\n        break;\n      case \"beforeAttributeName\":\n        addElementModifier(this.currentNode, mustache);\n        break;\n      case \"attributeName\":\n      case \"afterAttributeName\":\n        this.beginAttributeValue(false);\n        this.finishAttributeValue();\n        addElementModifier(this.currentNode, mustache);\n        tokenizer.state = \"beforeAttributeName\";\n        break;\n      case \"afterAttributeValueQuoted\":\n        addElementModifier(this.currentNode, mustache);\n        tokenizer.state = \"beforeAttributeName\";\n        break;\n\n      // Attribute values\n      case \"beforeAttributeValue\":\n        appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n        tokenizer.state = 'attributeValueUnquoted';\n        break;\n      case \"attributeValueDoubleQuoted\":\n      case \"attributeValueSingleQuoted\":\n      case \"attributeValueUnquoted\":\n        appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n        break;\n\n      // TODO: Only append child when the tokenizer state makes\n      // sense to do so, otherwise throw an error.\n      default:\n        appendChild(this.currentElement(), mustache);\n    }\n\n    return mustache;\n  },\n\n  ContentStatement: function(content) {\n    updateTokenizerLocation(this.tokenizer, content);\n\n    this.tokenizer.tokenizePart(content.value);\n    this.tokenizer.flushData();\n  },\n\n  CommentStatement: function(comment) {\n    return comment;\n  },\n\n  PartialStatement: function(partial) {\n    appendChild(this.currentElement(), partial);\n    return partial;\n  },\n\n  SubExpression: function(sexpr) {\n    return acceptCommonNodes(this, sexpr);\n  },\n\n  PathExpression: function(path) {\n    let { original, loc } = path;\n\n    if (original.indexOf('/') !== -1) {\n      // TODO add a SyntaxError with loc info\n      if (original.slice(0, 2) === './') {\n        throw new Error(`Using \"./\" is not supported in Glimmer and unnecessary: \"${path.original}\" on line ${loc.start.line}.`);\n      }\n      if (original.slice(0, 3) === '../') {\n        throw new Error(`Changing context using \"../\" is not supported in Glimmer: \"${path.original}\" on line ${loc.start.line}.`);\n      }\n      if (original.indexOf('.') !== -1) {\n        throw new Error(`Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths: \"${path.original}\" on line ${loc.start.line}.`);\n      }\n      path.parts = [ path.parts.join('/') ];\n    }\n\n    delete path.depth;\n\n    return path;\n  },\n\n  Hash: function(hash) {\n    for (let i = 0; i < hash.pairs.length; i++) {\n      this.acceptNode(hash.pairs[i].value);\n    }\n\n    return hash;\n  },\n\n  StringLiteral: function() {},\n  BooleanLiteral: function() {},\n  NumberLiteral: function() {},\n  UndefinedLiteral: function() {},\n  NullLiteral: function() {}\n};\n\nfunction calculateRightStrippedOffsets(original, value) {\n  if (value === '') {\n    // if it is empty, just return the count of newlines\n    // in original\n    return {\n      lines: original.split(\"\\n\").length - 1,\n      columns: 0\n    };\n  }\n\n  // otherwise, return the number of newlines prior to\n  // `value`\n  let difference = original.split(value)[0];\n  let lines = difference.split(/\\n/);\n  let lineCount = lines.length - 1;\n\n  return {\n    lines: lineCount,\n    columns: lines[lineCount].length\n  };\n}\n\nfunction updateTokenizerLocation(tokenizer, content) {\n  let line = content.loc.start.line;\n  let column = content.loc.start.column;\n\n  if (content.rightStripped) {\n    let offsets = calculateRightStrippedOffsets(content.original, content.value);\n\n    line = line + offsets.lines;\n    if (offsets.lines) {\n      column = offsets.columns;\n    } else {\n      column = column + offsets.columns;\n    }\n  }\n\n  tokenizer.line = line;\n  tokenizer.column = column;\n}\nfunction acceptCommonNodes(compiler, node) {\n  compiler.acceptNode(node.path);\n\n  if (node.params) {\n    for (let i = 0; i < node.params.length; i++) {\n      compiler.acceptNode(node.params[i]);\n    }\n  } else {\n    node.params = [];\n  }\n\n  if (node.hash) {\n    compiler.acceptNode(node.hash);\n  } else {\n    node.hash = b.hash();\n  }\n\n  return node;\n}\n\nfunction addElementModifier(element, mustache) {\n  let { path, params, hash, loc } = mustache;\n  let modifier = b.elementModifier(path, params, hash, loc);\n  element.modifiers.push(modifier);\n}\n\nfunction appendDynamicAttributeValuePart(attribute, part) {\n  attribute.isDynamic = true;\n  attribute.parts.push(part);\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/parser/handlebars-node-visitors.ts"],"names":[],"mappings":"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","file":"handlebars-node-visitors.js","sourcesContent":["import b from \"../builders\";\nimport { appendChild } from \"../utils\";\n\nexport default {\n\n  Program: function(program) {\n    let body = [];\n    let node = b.program(body, program.blockParams, program.loc);\n    let i, l = program.body.length;\n\n    this.elementStack.push(node);\n\n    if (l === 0) { return this.elementStack.pop(); }\n\n    for (i = 0; i < l; i++) {\n      this.acceptNode(program.body[i]);\n    }\n\n    // Ensure that that the element stack is balanced properly.\n    let poppedNode = this.elementStack.pop();\n    if (poppedNode !== node) {\n      throw new Error(\"Unclosed element `\" + poppedNode.tag + \"` (on line \" + poppedNode.loc.start.line + \").\");\n    }\n\n    return node;\n  },\n\n  BlockStatement: function(block) {\n    delete block.inverseStrip;\n    delete block.openString;\n    delete block.closeStrip;\n\n    if (this.tokenizer.state === 'comment') {\n      this.appendToCommentData('{{' + this.sourceForMustache(block) + '}}');\n      return;\n    }\n\n    if (this.tokenizer.state !== 'comment' && this.tokenizer.state !== 'data' && this.tokenizer.state !== 'beforeData') {\n      throw new Error(\"A block may only be used inside an HTML element or another block.\");\n    }\n\n    block = acceptCommonNodes(this, block);\n    let program = block.program ? this.acceptNode(block.program) : null;\n    let inverse = block.inverse ? this.acceptNode(block.inverse) : null;\n\n    let node = b.block(block.path, block.params, block.hash, program, inverse, block.loc);\n    let parentProgram = this.currentElement();\n    appendChild(parentProgram, node);\n  },\n\n  MustacheStatement: function(rawMustache) {\n    let tokenizer = this.tokenizer;\n    let { path, params, hash, escaped, loc } = rawMustache;\n    let mustache = b.mustache(path, params, hash, !escaped, loc);\n\n    if (tokenizer.state === 'comment') {\n      this.appendToCommentData('{{' + this.sourceForMustache(mustache) + '}}');\n      return;\n    }\n\n    acceptCommonNodes(this, mustache);\n\n    switch (tokenizer.state) {\n      // Tag helpers\n      case \"tagName\":\n        addElementModifier(this.currentNode, mustache);\n        tokenizer.state = \"beforeAttributeName\";\n        break;\n      case \"beforeAttributeName\":\n        addElementModifier(this.currentNode, mustache);\n        break;\n      case \"attributeName\":\n      case \"afterAttributeName\":\n        this.beginAttributeValue(false);\n        this.finishAttributeValue();\n        addElementModifier(this.currentNode, mustache);\n        tokenizer.state = \"beforeAttributeName\";\n        break;\n      case \"afterAttributeValueQuoted\":\n        addElementModifier(this.currentNode, mustache);\n        tokenizer.state = \"beforeAttributeName\";\n        break;\n\n      // Attribute values\n      case \"beforeAttributeValue\":\n        appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n        tokenizer.state = 'attributeValueUnquoted';\n        break;\n      case \"attributeValueDoubleQuoted\":\n      case \"attributeValueSingleQuoted\":\n      case \"attributeValueUnquoted\":\n        appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n        break;\n\n      // TODO: Only append child when the tokenizer state makes\n      // sense to do so, otherwise throw an error.\n      default:\n        appendChild(this.currentElement(), mustache);\n    }\n\n    return mustache;\n  },\n\n  ContentStatement: function(content) {\n    updateTokenizerLocation(this.tokenizer, content);\n\n    this.tokenizer.tokenizePart(content.value);\n    this.tokenizer.flushData();\n  },\n\n  CommentStatement: function(comment) {\n    return comment;\n  },\n\n  PartialStatement: function(partial) {\n    appendChild(this.currentElement(), partial);\n    return partial;\n  },\n\n  SubExpression: function(sexpr) {\n    return acceptCommonNodes(this, sexpr);\n  },\n\n  PathExpression: function(path) {\n    let { original, loc } = path;\n\n    if (original.indexOf('/') !== -1) {\n      // TODO add a SyntaxError with loc info\n      if (original.slice(0, 2) === './') {\n        throw new Error(`Using \"./\" is not supported in Glimmer and unnecessary: \"${path.original}\" on line ${loc.start.line}.`);\n      }\n      if (original.slice(0, 3) === '../') {\n        throw new Error(`Changing context using \"../\" is not supported in Glimmer: \"${path.original}\" on line ${loc.start.line}.`);\n      }\n      if (original.indexOf('.') !== -1) {\n        throw new Error(`Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths: \"${path.original}\" on line ${loc.start.line}.`);\n      }\n      path.parts = [ path.parts.join('/') ];\n    }\n\n    delete path.depth;\n\n    // This is to fix a bug in the Handlebars AST where the path expressions in\n    // `{{this.foo}}` (and similarly `{{foo-bar this.foo named=this.foo}}` etc)\n    // are simply turned into `{{foo}}`. The fix is to push it back onto the\n    // parts array and let the runtime see the difference. However, we cannot\n    // simply use the string `this` as it means literally the property called\n    // \"this\" in the current context (it can be expressed in the syntax as\n    // `{{[this]}}`, where the square bracket are generally for this kind of\n    // escaping – such as `{{foo.[\"bar.baz\"]}}` would mean lookup a property\n    // named literally \"bar.baz\" on `this.foo`). By convention, we use `null`\n    // for this purpose.\n    if (original.match(/^this(\\..+)?$/)) {\n      path.parts.unshift(null);\n    }\n\n    return path;\n  },\n\n  Hash: function(hash) {\n    for (let i = 0; i < hash.pairs.length; i++) {\n      this.acceptNode(hash.pairs[i].value);\n    }\n\n    return hash;\n  },\n\n  StringLiteral: function() {},\n  BooleanLiteral: function() {},\n  NumberLiteral: function() {},\n  UndefinedLiteral: function() {},\n  NullLiteral: function() {}\n};\n\nfunction calculateRightStrippedOffsets(original, value) {\n  if (value === '') {\n    // if it is empty, just return the count of newlines\n    // in original\n    return {\n      lines: original.split(\"\\n\").length - 1,\n      columns: 0\n    };\n  }\n\n  // otherwise, return the number of newlines prior to\n  // `value`\n  let difference = original.split(value)[0];\n  let lines = difference.split(/\\n/);\n  let lineCount = lines.length - 1;\n\n  return {\n    lines: lineCount,\n    columns: lines[lineCount].length\n  };\n}\n\nfunction updateTokenizerLocation(tokenizer, content) {\n  let line = content.loc.start.line;\n  let column = content.loc.start.column;\n\n  if (content.rightStripped) {\n    let offsets = calculateRightStrippedOffsets(content.original, content.value);\n\n    line = line + offsets.lines;\n    if (offsets.lines) {\n      column = offsets.columns;\n    } else {\n      column = column + offsets.columns;\n    }\n  }\n\n  tokenizer.line = line;\n  tokenizer.column = column;\n}\nfunction acceptCommonNodes(compiler, node) {\n  compiler.acceptNode(node.path);\n\n  if (node.params) {\n    for (let i = 0; i < node.params.length; i++) {\n      compiler.acceptNode(node.params[i]);\n    }\n  } else {\n    node.params = [];\n  }\n\n  if (node.hash) {\n    compiler.acceptNode(node.hash);\n  } else {\n    node.hash = b.hash();\n  }\n\n  return node;\n}\n\nfunction addElementModifier(element, mustache) {\n  let { path, params, hash, loc } = mustache;\n  let modifier = b.elementModifier(path, params, hash, loc);\n  element.modifiers.push(modifier);\n}\n\nfunction appendDynamicAttributeValuePart(attribute, part) {\n  attribute.isDynamic = true;\n  attribute.parts.push(part);\n}\n"]} enifed("glimmer-syntax/lib/parser/tokenizer-event-handlers", ["exports", "glimmer-util", "glimmer-syntax/lib/builders", "glimmer-syntax/lib/utils"], function (exports, _glimmerUtil, _glimmerSyntaxLibBuilders, _glimmerSyntaxLibUtils) { "use strict"; exports.default = { reset: function () { @@ -23978,14 +24550,14 @@ function assembleAttributeValue(parts, isQuoted, isDynamic, line) { if (isDynamic) { if (isQuoted) { return assembleConcatenatedValue(parts); } else { - if (parts.length === 1) { + if (parts.length === 1 || parts.length === 2 && parts[1] === '/') { return parts[0]; } else { - throw new Error("An unquoted attribute value must be a string or a mustache, " + "preceeded by whitespace or a '=' character, and " + ("followed by whitespace or a '>' character (on line " + line + ")")); + throw new Error("An unquoted attribute value must be a string or a mustache, " + "preceeded by whitespace or a '=' character, and " + ("followed by whitespace, a '>' character, or '/>' (on line " + line + ")")); } } } else { return _glimmerSyntaxLibBuilders.default.text(parts.length > 0 ? parts[0] : ""); } @@ -24021,11 +24593,11 @@ } function formatEndTagInfo(tag) { return "`" + tag.name + "` (on line " + tag.loc.end.line + ")"; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/parser/tokenizer-event-handlers.ts"],"names":[],"mappings":";;;sBAIe;AACb,aAAK,EAAE,YAAA;AACL,gBAAI,CAAC,WAAW,GAAG,IAAI,CAAC;SACzB;;AAID,oBAAY,EAAE,YAAA;AACZ,gBAAI,CAAC,WAAW,GAAG,kCAAE,OAAO,CAAC,EAAE,CAAC,CAAC;AACjC,gBAAI,CAAC,WAAW,CAAC,GAAG,GAAG;AACrB,sBAAM,EAAE,IAAI;AACZ,qBAAK,EAAE,kCAAE,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC;AAClD,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,2BAAmB,EAAE,UAAS,IAAI,EAAA;AAChC,gBAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC;SAChC;AAED,qBAAa,EAAE,YAAA;AACb,gBAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAE7E,mCAzBK,WAAW,CAyBJ,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SACtD;;AAID,iBAAS,EAAE,YAAA;AACT,gBAAI,CAAC,WAAW,GAAG,kCAAE,IAAI,EAAE,CAAC;AAC5B,gBAAI,CAAC,WAAW,CAAC,GAAG,GAAG;AACrB,sBAAM,EAAE,IAAI;AACZ,qBAAK,EAAE,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AACxD,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,oBAAY,EAAE,UAAS,IAAI,EAAA;AACzB,gBAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC;SAChC;AAED,kBAAU,EAAE,YAAA;AACV,gBAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAE7E,mCA9CK,WAAW,CA8CJ,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SACtD;;AAID,eAAO,EAAE,YAAA;AACP,gBAAI,CAAC,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AACvC,gBAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;SAC5C;AAED,qBAAa,EAAE,YAAA;AACb,gBAAI,CAAC,WAAW,GAAG;AACjB,oBAAI,EAAE,UAAU;AAChB,oBAAI,EAAE,EAAE;AACR,0BAAU,EAAE,EAAE;AACd,yBAAS,EAAE,EAAE;AACb,2BAAW,EAAE,KAAK;AAClB,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,mBAAW,EAAE,YAAA;AACX,gBAAI,CAAC,WAAW,GAAG;AACjB,oBAAI,EAAE,QAAQ;AACd,oBAAI,EAAE,EAAE;AACR,0BAAU,EAAE,EAAE;AACd,yBAAS,EAAE,EAAE;AACb,2BAAW,EAAE,KAAK;AAClB,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,iBAAS,EAAE,YAAA;6BACc,IAAI,CAAC,SAAS;gBAA/B,IAAI,cAAJ,IAAI;gBAAE,MAAM,cAAN,MAAM;;AAElB,gBAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;AAC3B,eAAG,CAAC,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEpE,gBAAI,GAAG,CAAC,IAAI,KAAK,UAAU,EAAE;AAC3B,oBAAI,CAAC,cAAc,EAAE,CAAC;AAEtB,oBAAI,aAzFD,OAAO,CAyFE,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,WAAW,EAAE;AACvD,wBAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;iBACzB;aACF,MAAM,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE;AAChC,oBAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;aAC1B;SACF;AAED,sBAAc,EAAE,YAAA;+BACwB,IAAI,CAAC,WAAW;gBAAhD,IAAI,gBAAJ,IAAI;gBAAE,UAAU,gBAAV,UAAU;gBAAE,SAAS,gBAAT,SAAS;;AAEjC,gBAAI,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;AACtD,gBAAI,OAAO,GAAG,kCAAE,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC;AAC9D,gBAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACjC;AAED,oBAAY,EAAE,UAAS,MAAM,EAAA;AAC3B,gBAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;AAE3B,gBAAI,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;AACtC,gBAAI,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;AAEnC,0BAAc,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAErC,mBAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AAC3C,mBAAO,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AAE/C,mCAlHkB,uBAAuB,CAkHjB,OAAO,CAAC,CAAC;AACjC,mCAnHK,WAAW,CAmHJ,MAAM,EAAE,OAAO,CAAC,CAAC;SAC9B;AAED,4BAAoB,EAAE,YAAA;AACpB,gBAAI,CAAC,WAAW,CAAC,WAAW,GAAG,IAAI,CAAC;SACrC;;AAID,uBAAe,EAAE,UAAS,IAAI,EAAA;AAC5B,gBAAI,CAAC,WAAW,CAAC,IAAI,IAAI,IAAI,CAAC;SAC/B;;AAID,sBAAc,EAAE,YAAA;AACd,gBAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;AAC3B,gBAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE;AACxB,sBAAM,IAAI,KAAK,CACd,sEACQ,GAAG,CAAC,IAAI,mBAAe,IAAI,CAAC,SAAS,CAAC,IAAI,QAAI,CACvD,CAAC;aACH;AAED,gBAAI,CAAC,gBAAgB,GAAG;AACtB,oBAAI,EAAE,EAAE;AACR,qBAAK,EAAE,EAAE;AACT,wBAAQ,EAAE,KAAK;AACf,yBAAS,EAAE,KAAK;AAChB,qBAAK,EAAE,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AACxD,8BAAc,EAAE,IAAI;AACpB,gCAAgB,EAAE,IAAI;aACvB,CAAC;SACH;AAED,6BAAqB,EAAE,UAAS,IAAI,EAAA;AAClC,gBAAI,CAAC,gBAAgB,CAAC,IAAI,IAAI,IAAI,CAAC;SACpC;AAED,2BAAmB,EAAE,UAAS,QAAQ,EAAA;AACpC,gBAAI,CAAC,gBAAgB,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAC1C,gBAAI,CAAC,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AAC3D,gBAAI,CAAC,gBAAgB,CAAC,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;SAChE;AAED,8BAAsB,EAAE,UAAS,IAAI,EAAA;AACnC,gBAAI,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;AAExC,gBAAI,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,QAAQ,EAAE;AAC/C,qBAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC;aACjC,MAAM;AACL,qBAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAClB;SACF;AAED,4BAAoB,EAAE,YAAA;oCACyD,IAAI,CAAC,gBAAgB;gBAA5F,IAAI,qBAAJ,IAAI;gBAAE,KAAK,qBAAL,KAAK;gBAAE,QAAQ,qBAAR,QAAQ;gBAAE,SAAS,qBAAT,SAAS;gBAAE,cAAc,qBAAd,cAAc;gBAAE,gBAAgB,qBAAhB,gBAAgB;;AACxE,gBAAI,KAAK,GAAG,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AACpF,iBAAK,CAAC,GAAG,GAAG,kCAAE,GAAG,CACf,cAAc,EAAE,gBAAgB,EAChC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAC3C,CAAC;AAEF,gBAAI,GAAG,GAAG,kCAAE,GAAG,CACb,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAM,EACpE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAC3C,CAAC;AAEF,gBAAI,SAAS,GAAG,kCAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;AAEzC,gBAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAC7C;KACF;;AAED,aAAA,sBAAA,CAAgC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAA;AAC9D,YAAI,SAAS,EAAE;AACb,gBAAI,QAAQ,EAAE;AACZ,uBAAO,yBAAyB,CAAC,KAAK,CAAC,CAAC;aACzC,MAAM;AACL,oBAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACtB,2BAAO,KAAK,CAAC,CAAC,CAAC,CAAC;iBACjB,MAAM;AACL,0BAAM,IAAI,KAAK,CACb,mHACkD,4DACI,IAAI,OAAG,CAC9D,CAAC;iBACH;aACF;SACF,MAAM;AACL,mBAAO,kCAAE,IAAI,CAAC,AAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAI,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;SACnD;KACF;AAED,aAAA,yBAAA,CAAmC,KAAK,EAAA;AACtC,aAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACrC,gBAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAEpB,gBAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;AAC5B,qBAAK,CAAC,CAAC,CAAC,GAAG,kCAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;aAC7B,MAAM;AACL,oBAAI,IAAI,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACrC,0BAAM,IAAI,KAAK,CAAC,8CAA8C,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC7E;aACF;SACF;AAED,eAAO,kCAAE,MAAM,CAAC,KAAK,CAAC,CAAC;KACxB;AAED,aAAA,cAAA,CAAwB,GAAG,EAAE,OAAO,EAAE,WAAW,EAAA;AAC/C,YAAI,KAAK,YAAA,CAAC;AAEV,YAAI,aAtOG,OAAO,CAsOF,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;;;;AAIrC,iBAAK,GAAG,kBAAkB,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,wCAAwC,CAAC;SAC/F,MAAM,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS,EAAE;AACpC,iBAAK,GAAG,cAAc,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,uBAAuB,CAAC;SAC1E,MAAM,IAAI,OAAO,CAAC,GAAG,KAAK,GAAG,CAAC,IAAI,EAAE;AACnC,iBAAK,GAAG,cAAc,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,gCAAgC,GAAG,OAAO,CAAC,GAAG,GAAG,aAAa,GACvG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;SACvC;AAED,YAAI,KAAK,EAAE;AAAE,kBAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;SAAE;KACvC;AAED,aAAA,gBAAA,CAA0B,GAAG,EAAA;AAC3B,eAAO,GAAG,GAAG,GAAG,CAAC,IAAI,GAAG,aAAa,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC;KAChE","file":"tokenizer-event-handlers.js","sourcesContent":["import { voidMap } from 'glimmer-util';\nimport b from \"../builders\";\nimport { appendChild, parseElementBlockParams } from \"../utils\";\n\nexport default {\n  reset: function() {\n    this.currentNode = null;\n  },\n\n  // Comment\n\n  beginComment: function() {\n    this.currentNode = b.comment(\"\");\n    this.currentNode.loc = {\n      source: null,\n      start: b.pos(this.tagOpenLine, this.tagOpenColumn),\n      end: null\n    };\n  },\n\n  appendToCommentData: function(char) {\n    this.currentNode.value += char;\n  },\n\n  finishComment: function() {\n    this.currentNode.loc.end = b.pos(this.tokenizer.line, this.tokenizer.column);\n\n    appendChild(this.currentElement(), this.currentNode);\n  },\n\n  // Data\n\n  beginData: function() {\n    this.currentNode = b.text();\n    this.currentNode.loc = {\n      source: null,\n      start: b.pos(this.tokenizer.line, this.tokenizer.column),\n      end: null\n    };\n  },\n\n  appendToData: function(char) {\n    this.currentNode.chars += char;\n  },\n\n  finishData: function() {\n    this.currentNode.loc.end = b.pos(this.tokenizer.line, this.tokenizer.column);\n\n    appendChild(this.currentElement(), this.currentNode);\n  },\n\n  // Tags - basic\n\n  tagOpen: function() {\n    this.tagOpenLine = this.tokenizer.line;\n    this.tagOpenColumn = this.tokenizer.column;\n  },\n\n  beginStartTag: function() {\n    this.currentNode = {\n      type: 'StartTag',\n      name: \"\",\n      attributes: [],\n      modifiers: [],\n      selfClosing: false,\n      loc: null\n    };\n  },\n\n  beginEndTag: function() {\n    this.currentNode = {\n      type: 'EndTag',\n      name: \"\",\n      attributes: [],\n      modifiers: [],\n      selfClosing: false,\n      loc: null\n    };\n  },\n\n  finishTag: function() {\n    let { line, column } = this.tokenizer;\n\n    let tag = this.currentNode;\n    tag.loc = b.loc(this.tagOpenLine, this.tagOpenColumn, line, column);\n\n    if (tag.type === 'StartTag') {\n      this.finishStartTag();\n\n      if (voidMap.hasOwnProperty(tag.name) || tag.selfClosing) {\n        this.finishEndTag(true);\n      }\n    } else if (tag.type === 'EndTag') {\n      this.finishEndTag(false);\n    }\n  },\n\n  finishStartTag: function() {\n    let { name, attributes, modifiers } = this.currentNode;\n\n    let loc = b.loc(this.tagOpenLine, this.tagOpenColumn);\n    let element = b.element(name, attributes, modifiers, [], loc);\n    this.elementStack.push(element);\n  },\n\n  finishEndTag: function(isVoid) {\n    let tag = this.currentNode;\n\n    let element = this.elementStack.pop();\n    let parent = this.currentElement();\n\n    validateEndTag(tag, element, isVoid);\n\n    element.loc.end.line = this.tokenizer.line;\n    element.loc.end.column = this.tokenizer.column;\n\n    parseElementBlockParams(element);\n    appendChild(parent, element);\n  },\n\n  markTagAsSelfClosing: function() {\n    this.currentNode.selfClosing = true;\n  },\n\n  // Tags - name\n\n  appendToTagName: function(char) {\n    this.currentNode.name += char;\n  },\n\n  // Tags - attributes\n\n  beginAttribute: function() {\n    let tag = this.currentNode;\n    if (tag.type === 'EndTag') {\n       throw new Error(\n        `Invalid end tag: closing tag must not have attributes, ` +\n        `in \\`${tag.name}\\` (on line ${this.tokenizer.line}).`\n      );\n    }\n\n    this.currentAttribute = {\n      name: \"\",\n      parts: [],\n      isQuoted: false,\n      isDynamic: false,\n      start: b.pos(this.tokenizer.line, this.tokenizer.column),\n      valueStartLine: null,\n      valueStartColumn: null\n    };\n  },\n\n  appendToAttributeName: function(char) {\n    this.currentAttribute.name += char;\n  },\n\n  beginAttributeValue: function(isQuoted) {\n    this.currentAttribute.isQuoted = isQuoted;\n    this.currentAttribute.valueStartLine = this.tokenizer.line;\n    this.currentAttribute.valueStartColumn = this.tokenizer.column;\n  },\n\n  appendToAttributeValue: function(char) {\n    let parts = this.currentAttribute.parts;\n\n    if (typeof parts[parts.length - 1] === 'string') {\n      parts[parts.length - 1] += char;\n    } else {\n      parts.push(char);\n    }\n  },\n\n  finishAttributeValue: function() {\n    let { name, parts, isQuoted, isDynamic, valueStartLine, valueStartColumn } = this.currentAttribute;\n    let value = assembleAttributeValue(parts, isQuoted, isDynamic, this.tokenizer.line);\n    value.loc = b.loc(\n      valueStartLine, valueStartColumn,\n      this.tokenizer.line, this.tokenizer.column\n    );\n\n    let loc = b.loc(\n      this.currentAttribute.start.line, this.currentAttribute.start.column,\n      this.tokenizer.line, this.tokenizer.column\n    );\n\n    let attribute = b.attr(name, value, loc);\n\n    this.currentNode.attributes.push(attribute);\n  }\n};\n\nfunction assembleAttributeValue(parts, isQuoted, isDynamic, line) {\n  if (isDynamic) {\n    if (isQuoted) {\n      return assembleConcatenatedValue(parts);\n    } else {\n      if (parts.length === 1) {\n        return parts[0];\n      } else {\n        throw new Error(\n          `An unquoted attribute value must be a string or a mustache, ` +\n          `preceeded by whitespace or a '=' character, and ` +\n          `followed by whitespace or a '>' character (on line ${line})`\n        );\n      }\n    }\n  } else {\n    return b.text((parts.length > 0) ? parts[0] : \"\");\n  }\n}\n\nfunction assembleConcatenatedValue(parts) {\n  for (let i = 0; i < parts.length; i++) {\n    let part = parts[i];\n\n    if (typeof part === 'string') {\n      parts[i] = b.text(parts[i]);\n    } else {\n      if (part.type !== 'MustacheStatement') {\n        throw new Error(\"Unsupported node in quoted attribute value: \" + part.type);\n      }\n    }\n  }\n\n  return b.concat(parts);\n}\n\nfunction validateEndTag(tag, element, selfClosing) {\n  let error;\n\n  if (voidMap[tag.name] && !selfClosing) {\n    // EngTag is also called by StartTag for void and self-closing tags (i.e.\n    // <input> or <br />, so we need to check for that here. Otherwise, we would\n    // throw an error for those cases.\n    error = \"Invalid end tag \" + formatEndTagInfo(tag) + \" (void elements cannot have end tags).\";\n  } else if (element.tag === undefined) {\n    error = \"Closing tag \" + formatEndTagInfo(tag) + \" without an open tag.\";\n  } else if (element.tag !== tag.name) {\n    error = \"Closing tag \" + formatEndTagInfo(tag) + \" did not match last open tag `\" + element.tag + \"` (on line \" +\n            element.loc.start.line + \").\";\n  }\n\n  if (error) { throw new Error(error); }\n}\n\nfunction formatEndTagInfo(tag) {\n  return \"`\" + tag.name + \"` (on line \" + tag.loc.end.line + \")\";\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/parser/tokenizer-event-handlers.ts"],"names":[],"mappings":";;;sBAIe;AACb,aAAK,EAAE,YAAA;AACL,gBAAI,CAAC,WAAW,GAAG,IAAI,CAAC;SACzB;;AAID,oBAAY,EAAE,YAAA;AACZ,gBAAI,CAAC,WAAW,GAAG,kCAAE,OAAO,CAAC,EAAE,CAAC,CAAC;AACjC,gBAAI,CAAC,WAAW,CAAC,GAAG,GAAG;AACrB,sBAAM,EAAE,IAAI;AACZ,qBAAK,EAAE,kCAAE,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC;AAClD,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,2BAAmB,EAAE,UAAS,IAAI,EAAA;AAChC,gBAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC;SAChC;AAED,qBAAa,EAAE,YAAA;AACb,gBAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAE7E,mCAzBK,WAAW,CAyBJ,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SACtD;;AAID,iBAAS,EAAE,YAAA;AACT,gBAAI,CAAC,WAAW,GAAG,kCAAE,IAAI,EAAE,CAAC;AAC5B,gBAAI,CAAC,WAAW,CAAC,GAAG,GAAG;AACrB,sBAAM,EAAE,IAAI;AACZ,qBAAK,EAAE,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AACxD,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,oBAAY,EAAE,UAAS,IAAI,EAAA;AACzB,gBAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC;SAChC;AAED,kBAAU,EAAE,YAAA;AACV,gBAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAE7E,mCA9CK,WAAW,CA8CJ,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SACtD;;AAID,eAAO,EAAE,YAAA;AACP,gBAAI,CAAC,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AACvC,gBAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;SAC5C;AAED,qBAAa,EAAE,YAAA;AACb,gBAAI,CAAC,WAAW,GAAG;AACjB,oBAAI,EAAE,UAAU;AAChB,oBAAI,EAAE,EAAE;AACR,0BAAU,EAAE,EAAE;AACd,yBAAS,EAAE,EAAE;AACb,2BAAW,EAAE,KAAK;AAClB,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,mBAAW,EAAE,YAAA;AACX,gBAAI,CAAC,WAAW,GAAG;AACjB,oBAAI,EAAE,QAAQ;AACd,oBAAI,EAAE,EAAE;AACR,0BAAU,EAAE,EAAE;AACd,yBAAS,EAAE,EAAE;AACb,2BAAW,EAAE,KAAK;AAClB,mBAAG,EAAE,IAAI;aACV,CAAC;SACH;AAED,iBAAS,EAAE,YAAA;6BACc,IAAI,CAAC,SAAS;gBAA/B,IAAI,cAAJ,IAAI;gBAAE,MAAM,cAAN,MAAM;;AAElB,gBAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;AAC3B,eAAG,CAAC,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAEpE,gBAAI,GAAG,CAAC,IAAI,KAAK,UAAU,EAAE;AAC3B,oBAAI,CAAC,cAAc,EAAE,CAAC;AAEtB,oBAAI,aAzFD,OAAO,CAyFE,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,WAAW,EAAE;AACvD,wBAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;iBACzB;aACF,MAAM,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE;AAChC,oBAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;aAC1B;SACF;AAED,sBAAc,EAAE,YAAA;+BACwB,IAAI,CAAC,WAAW;gBAAhD,IAAI,gBAAJ,IAAI;gBAAE,UAAU,gBAAV,UAAU;gBAAE,SAAS,gBAAT,SAAS;;AAEjC,gBAAI,GAAG,GAAG,kCAAE,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;AACtD,gBAAI,OAAO,GAAG,kCAAE,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC;AAC9D,gBAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACjC;AAED,oBAAY,EAAE,UAAS,MAAM,EAAA;AAC3B,gBAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;AAE3B,gBAAI,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;AACtC,gBAAI,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;AAEnC,0BAAc,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAErC,mBAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AAC3C,mBAAO,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AAE/C,mCAlHkB,uBAAuB,CAkHjB,OAAO,CAAC,CAAC;AACjC,mCAnHK,WAAW,CAmHJ,MAAM,EAAE,OAAO,CAAC,CAAC;SAC9B;AAED,4BAAoB,EAAE,YAAA;AACpB,gBAAI,CAAC,WAAW,CAAC,WAAW,GAAG,IAAI,CAAC;SACrC;;AAID,uBAAe,EAAE,UAAS,IAAI,EAAA;AAC5B,gBAAI,CAAC,WAAW,CAAC,IAAI,IAAI,IAAI,CAAC;SAC/B;;AAID,sBAAc,EAAE,YAAA;AACd,gBAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;AAC3B,gBAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE;AACxB,sBAAM,IAAI,KAAK,CACd,sEACQ,GAAG,CAAC,IAAI,mBAAe,IAAI,CAAC,SAAS,CAAC,IAAI,QAAI,CACvD,CAAC;aACH;AAED,gBAAI,CAAC,gBAAgB,GAAG;AACtB,oBAAI,EAAE,EAAE;AACR,qBAAK,EAAE,EAAE;AACT,wBAAQ,EAAE,KAAK;AACf,yBAAS,EAAE,KAAK;AAChB,qBAAK,EAAE,kCAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;AACxD,8BAAc,EAAE,IAAI;AACpB,gCAAgB,EAAE,IAAI;aACvB,CAAC;SACH;AAED,6BAAqB,EAAE,UAAS,IAAI,EAAA;AAClC,gBAAI,CAAC,gBAAgB,CAAC,IAAI,IAAI,IAAI,CAAC;SACpC;AAED,2BAAmB,EAAE,UAAS,QAAQ,EAAA;AACpC,gBAAI,CAAC,gBAAgB,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAC1C,gBAAI,CAAC,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AAC3D,gBAAI,CAAC,gBAAgB,CAAC,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;SAChE;AAED,8BAAsB,EAAE,UAAS,IAAI,EAAA;AACnC,gBAAI,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;AAExC,gBAAI,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,QAAQ,EAAE;AAC/C,qBAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC;aACjC,MAAM;AACL,qBAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAClB;SACF;AAED,4BAAoB,EAAE,YAAA;oCACyD,IAAI,CAAC,gBAAgB;gBAA5F,IAAI,qBAAJ,IAAI;gBAAE,KAAK,qBAAL,KAAK;gBAAE,QAAQ,qBAAR,QAAQ;gBAAE,SAAS,qBAAT,SAAS;gBAAE,cAAc,qBAAd,cAAc;gBAAE,gBAAgB,qBAAhB,gBAAgB;;AACxE,gBAAI,KAAK,GAAG,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AACpF,iBAAK,CAAC,GAAG,GAAG,kCAAE,GAAG,CACf,cAAc,EAAE,gBAAgB,EAChC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAC3C,CAAC;AAEF,gBAAI,GAAG,GAAG,kCAAE,GAAG,CACb,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,MAAM,EACpE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAC3C,CAAC;AAEF,gBAAI,SAAS,GAAG,kCAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;AAEzC,gBAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAC7C;KACF;;AAED,aAAA,sBAAA,CAAgC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAA;AAC9D,YAAI,SAAS,EAAE;AACb,gBAAI,QAAQ,EAAE;AACZ,uBAAO,yBAAyB,CAAC,KAAK,CAAC,CAAC;aACzC,MAAM;AACL,oBAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAK,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,AAAC,EAAE;AAClE,2BAAO,KAAK,CAAC,CAAC,CAAC,CAAC;iBACjB,MAAM;AACL,0BAAM,IAAI,KAAK,CACb,mHACkD,mEACW,IAAI,OAAG,CACrE,CAAC;iBACH;aACF;SACF,MAAM;AACL,mBAAO,kCAAE,IAAI,CAAC,AAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAI,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC;SACnD;KACF;AAED,aAAA,yBAAA,CAAmC,KAAK,EAAA;AACtC,aAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACrC,gBAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAEpB,gBAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;AAC5B,qBAAK,CAAC,CAAC,CAAC,GAAG,kCAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;aAC7B,MAAM;AACL,oBAAI,IAAI,CAAC,IAAI,KAAK,mBAAmB,EAAE;AACrC,0BAAM,IAAI,KAAK,CAAC,8CAA8C,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC7E;aACF;SACF;AAED,eAAO,kCAAE,MAAM,CAAC,KAAK,CAAC,CAAC;KACxB;AAED,aAAA,cAAA,CAAwB,GAAG,EAAE,OAAO,EAAE,WAAW,EAAA;AAC/C,YAAI,KAAK,YAAA,CAAC;AAEV,YAAI,aAtOG,OAAO,CAsOF,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;;;;AAIrC,iBAAK,GAAG,kBAAkB,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,wCAAwC,CAAC;SAC/F,MAAM,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS,EAAE;AACpC,iBAAK,GAAG,cAAc,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,uBAAuB,CAAC;SAC1E,MAAM,IAAI,OAAO,CAAC,GAAG,KAAK,GAAG,CAAC,IAAI,EAAE;AACnC,iBAAK,GAAG,cAAc,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,gCAAgC,GAAG,OAAO,CAAC,GAAG,GAAG,aAAa,GACvG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;SACvC;AAED,YAAI,KAAK,EAAE;AAAE,kBAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;SAAE;KACvC;AAED,aAAA,gBAAA,CAA0B,GAAG,EAAA;AAC3B,eAAO,GAAG,GAAG,GAAG,CAAC,IAAI,GAAG,aAAa,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC;KAChE","file":"tokenizer-event-handlers.js","sourcesContent":["import { voidMap } from 'glimmer-util';\nimport b from \"../builders\";\nimport { appendChild, parseElementBlockParams } from \"../utils\";\n\nexport default {\n  reset: function() {\n    this.currentNode = null;\n  },\n\n  // Comment\n\n  beginComment: function() {\n    this.currentNode = b.comment(\"\");\n    this.currentNode.loc = {\n      source: null,\n      start: b.pos(this.tagOpenLine, this.tagOpenColumn),\n      end: null\n    };\n  },\n\n  appendToCommentData: function(char) {\n    this.currentNode.value += char;\n  },\n\n  finishComment: function() {\n    this.currentNode.loc.end = b.pos(this.tokenizer.line, this.tokenizer.column);\n\n    appendChild(this.currentElement(), this.currentNode);\n  },\n\n  // Data\n\n  beginData: function() {\n    this.currentNode = b.text();\n    this.currentNode.loc = {\n      source: null,\n      start: b.pos(this.tokenizer.line, this.tokenizer.column),\n      end: null\n    };\n  },\n\n  appendToData: function(char) {\n    this.currentNode.chars += char;\n  },\n\n  finishData: function() {\n    this.currentNode.loc.end = b.pos(this.tokenizer.line, this.tokenizer.column);\n\n    appendChild(this.currentElement(), this.currentNode);\n  },\n\n  // Tags - basic\n\n  tagOpen: function() {\n    this.tagOpenLine = this.tokenizer.line;\n    this.tagOpenColumn = this.tokenizer.column;\n  },\n\n  beginStartTag: function() {\n    this.currentNode = {\n      type: 'StartTag',\n      name: \"\",\n      attributes: [],\n      modifiers: [],\n      selfClosing: false,\n      loc: null\n    };\n  },\n\n  beginEndTag: function() {\n    this.currentNode = {\n      type: 'EndTag',\n      name: \"\",\n      attributes: [],\n      modifiers: [],\n      selfClosing: false,\n      loc: null\n    };\n  },\n\n  finishTag: function() {\n    let { line, column } = this.tokenizer;\n\n    let tag = this.currentNode;\n    tag.loc = b.loc(this.tagOpenLine, this.tagOpenColumn, line, column);\n\n    if (tag.type === 'StartTag') {\n      this.finishStartTag();\n\n      if (voidMap.hasOwnProperty(tag.name) || tag.selfClosing) {\n        this.finishEndTag(true);\n      }\n    } else if (tag.type === 'EndTag') {\n      this.finishEndTag(false);\n    }\n  },\n\n  finishStartTag: function() {\n    let { name, attributes, modifiers } = this.currentNode;\n\n    let loc = b.loc(this.tagOpenLine, this.tagOpenColumn);\n    let element = b.element(name, attributes, modifiers, [], loc);\n    this.elementStack.push(element);\n  },\n\n  finishEndTag: function(isVoid) {\n    let tag = this.currentNode;\n\n    let element = this.elementStack.pop();\n    let parent = this.currentElement();\n\n    validateEndTag(tag, element, isVoid);\n\n    element.loc.end.line = this.tokenizer.line;\n    element.loc.end.column = this.tokenizer.column;\n\n    parseElementBlockParams(element);\n    appendChild(parent, element);\n  },\n\n  markTagAsSelfClosing: function() {\n    this.currentNode.selfClosing = true;\n  },\n\n  // Tags - name\n\n  appendToTagName: function(char) {\n    this.currentNode.name += char;\n  },\n\n  // Tags - attributes\n\n  beginAttribute: function() {\n    let tag = this.currentNode;\n    if (tag.type === 'EndTag') {\n       throw new Error(\n        `Invalid end tag: closing tag must not have attributes, ` +\n        `in \\`${tag.name}\\` (on line ${this.tokenizer.line}).`\n      );\n    }\n\n    this.currentAttribute = {\n      name: \"\",\n      parts: [],\n      isQuoted: false,\n      isDynamic: false,\n      start: b.pos(this.tokenizer.line, this.tokenizer.column),\n      valueStartLine: null,\n      valueStartColumn: null\n    };\n  },\n\n  appendToAttributeName: function(char) {\n    this.currentAttribute.name += char;\n  },\n\n  beginAttributeValue: function(isQuoted) {\n    this.currentAttribute.isQuoted = isQuoted;\n    this.currentAttribute.valueStartLine = this.tokenizer.line;\n    this.currentAttribute.valueStartColumn = this.tokenizer.column;\n  },\n\n  appendToAttributeValue: function(char) {\n    let parts = this.currentAttribute.parts;\n\n    if (typeof parts[parts.length - 1] === 'string') {\n      parts[parts.length - 1] += char;\n    } else {\n      parts.push(char);\n    }\n  },\n\n  finishAttributeValue: function() {\n    let { name, parts, isQuoted, isDynamic, valueStartLine, valueStartColumn } = this.currentAttribute;\n    let value = assembleAttributeValue(parts, isQuoted, isDynamic, this.tokenizer.line);\n    value.loc = b.loc(\n      valueStartLine, valueStartColumn,\n      this.tokenizer.line, this.tokenizer.column\n    );\n\n    let loc = b.loc(\n      this.currentAttribute.start.line, this.currentAttribute.start.column,\n      this.tokenizer.line, this.tokenizer.column\n    );\n\n    let attribute = b.attr(name, value, loc);\n\n    this.currentNode.attributes.push(attribute);\n  }\n};\n\nfunction assembleAttributeValue(parts, isQuoted, isDynamic, line) {\n  if (isDynamic) {\n    if (isQuoted) {\n      return assembleConcatenatedValue(parts);\n    } else {\n      if (parts.length === 1 || (parts.length === 2 && parts[1] === '/')) {\n        return parts[0];\n      } else {\n        throw new Error(\n          `An unquoted attribute value must be a string or a mustache, ` +\n          `preceeded by whitespace or a '=' character, and ` +\n          `followed by whitespace, a '>' character, or '/>' (on line ${line})`\n        );\n      }\n    }\n  } else {\n    return b.text((parts.length > 0) ? parts[0] : \"\");\n  }\n}\n\nfunction assembleConcatenatedValue(parts) {\n  for (let i = 0; i < parts.length; i++) {\n    let part = parts[i];\n\n    if (typeof part === 'string') {\n      parts[i] = b.text(parts[i]);\n    } else {\n      if (part.type !== 'MustacheStatement') {\n        throw new Error(\"Unsupported node in quoted attribute value: \" + part.type);\n      }\n    }\n  }\n\n  return b.concat(parts);\n}\n\nfunction validateEndTag(tag, element, selfClosing) {\n  let error;\n\n  if (voidMap[tag.name] && !selfClosing) {\n    // EngTag is also called by StartTag for void and self-closing tags (i.e.\n    // <input> or <br />, so we need to check for that here. Otherwise, we would\n    // throw an error for those cases.\n    error = \"Invalid end tag \" + formatEndTagInfo(tag) + \" (void elements cannot have end tags).\";\n  } else if (element.tag === undefined) {\n    error = \"Closing tag \" + formatEndTagInfo(tag) + \" without an open tag.\";\n  } else if (element.tag !== tag.name) {\n    error = \"Closing tag \" + formatEndTagInfo(tag) + \" did not match last open tag `\" + element.tag + \"` (on line \" +\n            element.loc.start.line + \").\";\n  }\n\n  if (error) { throw new Error(error); }\n}\n\nfunction formatEndTagInfo(tag) {\n  return \"`\" + tag.name + \"` (on line \" + tag.loc.end.line + \")\";\n}\n"]} enifed("glimmer-syntax/lib/syntax", ["exports", "glimmer-syntax/lib/builders", "glimmer-syntax/lib/parser", "glimmer-syntax/lib/generation/print", "glimmer-syntax/lib/traversal/traverse", "glimmer-syntax/lib/traversal/walker"], function (exports, _glimmerSyntaxLibBuilders, _glimmerSyntaxLibParser, _glimmerSyntaxLibGenerationPrint, _glimmerSyntaxLibTraversalTraverse, _glimmerSyntaxLibTraversalWalker) { "use strict"; exports.builders = _glimmerSyntaxLibBuilders.default; exports.parse = _glimmerSyntaxLibParser.default; @@ -24061,11 +24633,11 @@ function cannotReplaceOrRemoveInKeyHandlerYet(node, key) { return new TraversalError("Replacing and removing in key handlers is not yet supported.", node, null, key); } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-syntax/lib/traversal/traverse', ['exports', 'glimmer-syntax/lib/types/visitor-keys', 'glimmer-syntax/lib/traversal/errors'], function (exports, _glimmerSyntaxLibTypesVisitorKeys, _glimmerSyntaxLibTraversalErrors) { 'use strict'; exports.default = traverse; exports.normalizeVisitor = normalizeVisitor; @@ -24074,10 +24646,19 @@ var handler = visitor[node.type] || visitor.All; var result = undefined; if (handler && handler.enter) { result = handler.enter.call(null, node); } + if (result !== undefined && result !== null) { + if (JSON.stringify(node) === JSON.stringify(result)) { + result = undefined; + } else if (Array.isArray(result)) { + return visitArray(visitor, result) || result; + } else { + return visitNode(visitor, result) || result; + } + } if (result === undefined) { var keys = _glimmerSyntaxLibTypesVisitorKeys.default[node.type]; for (var i = 0; i < keys.length; i++) { visitKey(visitor, handler, node, keys[i]); } @@ -24194,11 +24775,11 @@ } } return normalizedVisitor; } }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/traversal/traverse.ts"],"names":[],"mappings":"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","file":"traverse.js","sourcesContent":["import visitorKeys from '../types/visitor-keys';\nimport {\n  cannotRemoveNode,\n  cannotReplaceNode,\n  cannotReplaceOrRemoveInKeyHandlerYet\n} from './errors';\n\nfunction visitNode(visitor, node) {\n  let handler = visitor[node.type] || visitor.All;\n  let result;\n\n  if (handler && handler.enter) {\n    result = handler.enter.call(null, node);\n  }\n\n  if (result === undefined) {\n    let keys = visitorKeys[node.type];\n\n    for (let i = 0; i < keys.length; i++) {\n      visitKey(visitor, handler, node, keys[i]);\n    }\n\n    if (handler && handler.exit) {\n      result = handler.exit.call(null, node);\n    }\n  }\n\n  return result;\n}\n\nfunction visitKey(visitor, handler, node, key) {\n  let value = node[key];\n  if (!value) { return; }\n\n  let keyHandler = handler && (handler.keys[key] || handler.keys.All);\n  let result;\n\n  if (keyHandler && keyHandler.enter) {\n    result = keyHandler.enter.call(null, node, key);\n    if (result !== undefined) {\n      throw cannotReplaceOrRemoveInKeyHandlerYet(node, key);\n    }\n  }\n\n  if (Array.isArray(value)) {\n    visitArray(visitor, value);\n  } else {\n    let result = visitNode(visitor, value);\n    if (result !== undefined) {\n      assignKey(node, key, result);\n    }\n  }\n\n  if (keyHandler && keyHandler.exit) {\n    result = keyHandler.exit.call(null, node, key);\n    if (result !== undefined) {\n      throw cannotReplaceOrRemoveInKeyHandlerYet(node, key);\n    }\n  }\n}\n\nfunction visitArray(visitor, array) {\n  for (let i = 0; i < array.length; i++) {\n    let result = visitNode(visitor, array[i]);\n    if (result !== undefined) {\n      i += spliceArray(array, i, result) - 1;\n    }\n  }\n}\n\nfunction assignKey(node, key, result) {\n  if (result === null) {\n    throw cannotRemoveNode(node[key], node, key);\n  } else if (Array.isArray(result)) {\n    if (result.length === 1) {\n      node[key] = result[0];\n    } else {\n      if (result.length === 0) {\n        throw cannotRemoveNode(node[key], node, key);\n      } else {\n        throw cannotReplaceNode(node[key], node, key);\n      }\n    }\n  } else {\n    node[key] = result;\n  }\n}\n\nfunction spliceArray(array, index, result) {\n  if (result === null) {\n    array.splice(index, 1);\n    return 0;\n  } else if (Array.isArray(result)) {\n    array.splice(index, 1, ...result);\n    return result.length;\n  } else {\n    array.splice(index, 1, result);\n    return 1;\n  }\n}\n\nexport default function traverse(node, visitor) {\n  visitNode(normalizeVisitor(visitor), node);\n}\n\nexport function normalizeVisitor(visitor) {\n  let normalizedVisitor = {};\n\n  for (let type in visitor) {\n    let handler = visitor[type] || visitor.All;\n    let normalizedKeys = {};\n\n    if (typeof handler === 'object') {\n      let keys = handler.keys;\n      if (keys) {\n        for (let key in keys) {\n          let keyHandler = keys[key];\n          if (typeof keyHandler === 'object') {\n            normalizedKeys[key] = {\n              enter: (typeof keyHandler.enter === 'function') ? keyHandler.enter : null,\n              exit: (typeof keyHandler.exit === 'function') ? keyHandler.exit : null\n            };\n          } else if (typeof keyHandler === 'function') {\n            normalizedKeys[key] = {\n              enter: keyHandler,\n              exit: null\n            };\n          }\n        }\n      }\n\n      normalizedVisitor[type] = {\n        enter: (typeof handler.enter === 'function') ? handler.enter : null,\n        exit: (typeof handler.exit === 'function') ? handler.exit : null,\n        keys: normalizedKeys\n      };\n    } else if (typeof handler === 'function') {\n      normalizedVisitor[type] = {\n        enter: handler,\n        exit: null,\n        keys: normalizedKeys\n      };\n    }\n  }\n\n  return normalizedVisitor;\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-syntax/lib/traversal/traverse.ts"],"names":[],"mappings":"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","file":"traverse.js","sourcesContent":["import visitorKeys from '../types/visitor-keys';\nimport {\n  cannotRemoveNode,\n  cannotReplaceNode,\n  cannotReplaceOrRemoveInKeyHandlerYet\n} from './errors';\n\nfunction visitNode(visitor, node) {\n  let handler = visitor[node.type] || visitor.All;\n  let result;\n\n  if (handler && handler.enter) {\n    result = handler.enter.call(null, node);\n  }\n\n  if (result !== undefined && result !== null) {\n    if (JSON.stringify(node) === JSON.stringify(result)) {\n      result = undefined;\n    } else if (Array.isArray(result)) {\n      return visitArray(visitor, result) || result;\n    } else {\n      return visitNode(visitor, result) || result;\n    }\n  }\n\n  if (result === undefined) {\n    let keys = visitorKeys[node.type];\n\n    for (let i = 0; i < keys.length; i++) {\n      visitKey(visitor, handler, node, keys[i]);\n    }\n\n    if (handler && handler.exit) {\n      result = handler.exit.call(null, node);\n    }\n  }\n\n  return result;\n}\n\nfunction visitKey(visitor, handler, node, key) {\n  let value = node[key];\n  if (!value) { return; }\n\n  let keyHandler = handler && (handler.keys[key] || handler.keys.All);\n  let result;\n\n  if (keyHandler && keyHandler.enter) {\n    result = keyHandler.enter.call(null, node, key);\n    if (result !== undefined) {\n      throw cannotReplaceOrRemoveInKeyHandlerYet(node, key);\n    }\n  }\n\n  if (Array.isArray(value)) {\n    visitArray(visitor, value);\n  } else {\n    let result = visitNode(visitor, value);\n    if (result !== undefined) {\n      assignKey(node, key, result);\n    }\n  }\n\n  if (keyHandler && keyHandler.exit) {\n    result = keyHandler.exit.call(null, node, key);\n    if (result !== undefined) {\n      throw cannotReplaceOrRemoveInKeyHandlerYet(node, key);\n    }\n  }\n}\n\nfunction visitArray(visitor, array) {\n  for (let i = 0; i < array.length; i++) {\n    let result = visitNode(visitor, array[i]);\n    if (result !== undefined) {\n      i += spliceArray(array, i, result) - 1;\n    }\n  }\n}\n\nfunction assignKey(node, key, result) {\n  if (result === null) {\n    throw cannotRemoveNode(node[key], node, key);\n  } else if (Array.isArray(result)) {\n    if (result.length === 1) {\n      node[key] = result[0];\n    } else {\n      if (result.length === 0) {\n        throw cannotRemoveNode(node[key], node, key);\n      } else {\n        throw cannotReplaceNode(node[key], node, key);\n      }\n    }\n  } else {\n    node[key] = result;\n  }\n}\n\nfunction spliceArray(array, index, result) {\n  if (result === null) {\n    array.splice(index, 1);\n    return 0;\n  } else if (Array.isArray(result)) {\n    array.splice(index, 1, ...result);\n    return result.length;\n  } else {\n    array.splice(index, 1, result);\n    return 1;\n  }\n}\n\nexport default function traverse(node, visitor) {\n  visitNode(normalizeVisitor(visitor), node);\n}\n\nexport function normalizeVisitor(visitor) {\n  let normalizedVisitor = {};\n\n  for (let type in visitor) {\n    let handler = visitor[type] || visitor.All;\n    let normalizedKeys = {};\n\n    if (typeof handler === 'object') {\n      let keys = handler.keys;\n      if (keys) {\n        for (let key in keys) {\n          let keyHandler = keys[key];\n          if (typeof keyHandler === 'object') {\n            normalizedKeys[key] = {\n              enter: (typeof keyHandler.enter === 'function') ? keyHandler.enter : null,\n              exit: (typeof keyHandler.exit === 'function') ? keyHandler.exit : null\n            };\n          } else if (typeof keyHandler === 'function') {\n            normalizedKeys[key] = {\n              enter: keyHandler,\n              exit: null\n            };\n          }\n        }\n      }\n\n      normalizedVisitor[type] = {\n        enter: (typeof handler.enter === 'function') ? handler.enter : null,\n        exit: (typeof handler.exit === 'function') ? handler.exit : null,\n        keys: normalizedKeys\n      };\n    } else if (typeof handler === 'function') {\n      normalizedVisitor[type] = {\n        enter: handler,\n        exit: null,\n        keys: normalizedKeys\n      };\n    }\n  }\n\n  return normalizedVisitor;\n}\n"]} enifed('glimmer-syntax/lib/traversal/walker', ['exports'], function (exports) { 'use strict'; function Walker() { var order = arguments.length <= 0 || arguments[0] === undefined ? undefined : arguments[0]; @@ -24277,11 +24858,10 @@ exports.parseElementBlockParams = parseElementBlockParams; exports.childrenFor = childrenFor; exports.appendChild = appendChild; exports.isHelper = isHelper; - exports.isSelfGet = isSelfGet; exports.unwrapMustache = unwrapMustache; // Regex to validate the identifier for block parameters. // Based on the ID validation regex in Handlebars. var ID_INVERSE_PATTERN = /[!"#%-,\.\/;->@\[-\^`\{-~]/; @@ -24340,46 +24920,41 @@ function isHelper(mustache) { return mustache.params && mustache.params.length > 0 || mustache.hash && mustache.hash.pairs.length > 0; } - function isSelfGet(mustache) { - var isSimple = (!mustache.params || mustache.params.length === 0) && (!mustache.hash || mustache.hash.pairs.length === 0); - return isSimple && mustache.path.original.match(/^this./); - } - function unwrapMustache(mustache) { if (isHelper(mustache)) { return mustache; } else { return mustache.path; } } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-util/index', ['exports', 'glimmer-util/lib/object-utils', 'glimmer-util/lib/namespaces', 'glimmer-util/lib/platform-utils', 'glimmer-util/lib/assert', 'glimmer-util/lib/array-utils', 'glimmer-util/lib/void-tag-names', 'glimmer-util/lib/logger', 'glimmer-util/lib/guid', 'glimmer-util/lib/collections', 'glimmer-util/lib/list-utils'], function (exports, _glimmerUtilLibObjectUtils, _glimmerUtilLibNamespaces, _glimmerUtilLibPlatformUtils, _glimmerUtilLibAssert, _glimmerUtilLibArrayUtils, _glimmerUtilLibVoidTagNames, _glimmerUtilLibLogger, _glimmerUtilLibGuid, _glimmerUtilLibCollections, _glimmerUtilLibListUtils) { /*globals console*/ 'use strict'; exports.getAttrNamespace = _glimmerUtilLibNamespaces.getAttrNamespace; - exports.LITERAL = _glimmerUtilLibPlatformUtils.LITERAL; - exports.InternedString = _glimmerUtilLibPlatformUtils.InternedString; + exports.Option = _glimmerUtilLibPlatformUtils.Option; + exports.Maybe = _glimmerUtilLibPlatformUtils.Maybe; exports.Opaque = _glimmerUtilLibPlatformUtils.Opaque; exports.opaque = _glimmerUtilLibPlatformUtils.opaque; - exports.symbol = _glimmerUtilLibPlatformUtils.symbol; - exports.intern = _glimmerUtilLibPlatformUtils.intern; - exports.numberKey = _glimmerUtilLibPlatformUtils.numberKey; + exports.unwrap = _glimmerUtilLibPlatformUtils.unwrap; exports.assert = _glimmerUtilLibAssert.default; exports.forEach = _glimmerUtilLibArrayUtils.forEach; exports.map = _glimmerUtilLibArrayUtils.map; exports.isArray = _glimmerUtilLibArrayUtils.isArray; exports.indexOfArray = _glimmerUtilLibArrayUtils.indexOfArray; exports.voidMap = _glimmerUtilLibVoidTagNames.default; exports.LOGGER = _glimmerUtilLibLogger.default; exports.Logger = _glimmerUtilLibLogger.Logger; exports.LogLevel = _glimmerUtilLibLogger.LogLevel; + /* tslint:disable:no-unused-variable */ + /* tslint:enable:no-unused-variable */ exports.merge = _glimmerUtilLibObjectUtils.merge; exports.assign = _glimmerUtilLibObjectUtils.assign; exports.ensureGuid = _glimmerUtilLibGuid.ensureGuid; exports.initializeGuid = _glimmerUtilLibGuid.initializeGuid; @@ -24397,11 +24972,11 @@ exports.ListNode = _glimmerUtilLibListUtils.ListNode; exports.CloneableListNode = _glimmerUtilLibListUtils.CloneableListNode; exports.ListSlice = _glimmerUtilLibListUtils.ListSlice; exports.Slice = _glimmerUtilLibListUtils.Slice; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-util/lib/array-utils', ['exports'], function (exports) { 'use strict'; exports.forEach = forEach; exports.map = map; @@ -24457,14 +25032,15 @@ }; exports.isArray = isArray; var indexOfArray = getIdx; exports.indexOfArray = indexOfArray; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed("glimmer-util/lib/assert", ["exports"], function (exports) { // import Logger from './logger'; // let alreadyWarned = false; + // import Logger from './logger'; "use strict"; exports.debugAssert = debugAssert; exports.prodAssert = prodAssert; @@ -24480,18 +25056,16 @@ function prodAssert() {} exports.default = debugAssert; }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvYXNzZXJ0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBSUEsYUFBQSxXQUFBLENBQTRCLElBQUksRUFBRSxHQUFHLEVBQUE7Ozs7O0FBTW5DLFlBQUksQ0FBQyxJQUFJLEVBQUU7QUFDVCxrQkFBTSxJQUFJLEtBQUssQ0FBQyxHQUFHLElBQUksbUJBQW1CLENBQUMsQ0FBQztTQUM3QztLQUNGOztBQUVELGFBQUEsVUFBQSxHQUFBLEVBQStCOztzQkFFaEIsV0FBVyIsImZpbGUiOiJhc3NlcnQuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBpbXBvcnQgTG9nZ2VyIGZyb20gJy4vbG9nZ2VyJztcblxuLy8gbGV0IGFscmVhZHlXYXJuZWQgPSBmYWxzZTtcblxuZXhwb3J0IGZ1bmN0aW9uIGRlYnVnQXNzZXJ0KHRlc3QsIG1zZykge1xuICAvLyBpZiAoIWFscmVhZHlXYXJuZWQpIHtcbiAgLy8gICBhbHJlYWR5V2FybmVkID0gdHJ1ZTtcbiAgLy8gICBMb2dnZXIud2FybihcIkRvbid0IGxlYXZlIGRlYnVnIGFzc2VydGlvbnMgb24gaW4gcHVibGljIGJ1aWxkc1wiKTtcbiAgLy8gfVxuXG4gIGlmICghdGVzdCkge1xuICAgIHRocm93IG5ldyBFcnJvcihtc2cgfHwgXCJhc3NlcnRpb24gZmFpbHVyZVwiKTtcbiAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gcHJvZEFzc2VydCgpIHt9XG5cbmV4cG9ydCBkZWZhdWx0IGRlYnVnQXNzZXJ0O1xuIl19 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvYXNzZXJ0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUlNLGFBQUEsV0FBQSxDQUFzQixJQUFJLEVBQUUsR0FBRyxFQUFBOzs7OztBQU1uQyxZQUFJLENBQUMsSUFBSSxFQUFFO0FBQ1Qsa0JBQU0sSUFBSSxLQUFLLENBQUMsR0FBRyxJQUFJLG1CQUFtQixDQUFDLENBQUM7U0FDN0M7S0FDRjs7QUFFSyxhQUFBLFVBQUEsR0FBQSxFQUF5Qjs7c0JBRWhCLFdBQVciLCJmaWxlIjoiYXNzZXJ0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaW1wb3J0IExvZ2dlciBmcm9tICcuL2xvZ2dlcic7XG5cbi8vIGxldCBhbHJlYWR5V2FybmVkID0gZmFsc2U7XG5cbmV4cG9ydCBmdW5jdGlvbiBkZWJ1Z0Fzc2VydCh0ZXN0LCBtc2cpIHtcbiAgLy8gaWYgKCFhbHJlYWR5V2FybmVkKSB7XG4gIC8vICAgYWxyZWFkeVdhcm5lZCA9IHRydWU7XG4gIC8vICAgTG9nZ2VyLndhcm4oXCJEb24ndCBsZWF2ZSBkZWJ1ZyBhc3NlcnRpb25zIG9uIGluIHB1YmxpYyBidWlsZHNcIik7XG4gIC8vIH1cblxuICBpZiAoIXRlc3QpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IobXNnIHx8IFwiYXNzZXJ0aW9uIGZhaWx1cmVcIik7XG4gIH1cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHByb2RBc3NlcnQoKSB7fVxuXG5leHBvcnQgZGVmYXVsdCBkZWJ1Z0Fzc2VydDtcbiJdfQ== enifed('glimmer-util/lib/collections', ['exports', 'glimmer-util/lib/guid'], function (exports, _glimmerUtilLibGuid) { 'use strict'; exports.dict = dict; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } - var proto = Object.create(null, { // without this, we will always still end up with (new // EmptyObject()).constructor === Object constructor: { value: undefined, @@ -24510,12 +25084,10 @@ return new EmptyObject(); } var DictSet = (function () { function DictSet() { - _classCallCheck(this, DictSet); - this.dict = dict(); } DictSet.prototype.add = function add(obj) { if (typeof obj === 'string') this.dict[obj] = obj;else this.dict[_glimmerUtilLibGuid.ensureGuid(obj)] = obj; @@ -24543,12 +25115,10 @@ exports.DictSet = DictSet; var Stack = (function () { function Stack() { - _classCallCheck(this, Stack); - this.stack = []; this.current = null; } Stack.prototype.push = function push(item) { @@ -24570,11 +25140,11 @@ return Stack; })(); exports.Stack = Stack; }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed("glimmer-util/lib/guid", ["exports"], function (exports) { "use strict"; exports.initializeGuid = initializeGuid; exports.ensureGuid = ensureGuid; @@ -24586,30 +25156,24 @@ function ensureGuid(object) { return object._guid || initializeGuid(object); } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvZ3VpZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLFFBQUksSUFBSSxHQUFHLENBQUMsQ0FBQzs7QUFNYixhQUFBLGNBQUEsQ0FBK0IsTUFBZSxFQUFBO0FBQzVDLGVBQVEsTUFBTSxDQUFDLEtBQUssR0FBRyxFQUFFLElBQUksQ0FBRTtLQUNoQzs7QUFFRCxhQUFBLFVBQUEsQ0FBMkIsTUFBZSxFQUFBO0FBQ3hDLGVBQU8sTUFBTSxDQUFDLEtBQUssSUFBSSxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUM7S0FDL0MiLCJmaWxlIjoiZ3VpZC5qcyIsInNvdXJjZXNDb250ZW50IjpbImxldCBHVUlEID0gMDtcblxuZXhwb3J0IGludGVyZmFjZSBIYXNHdWlkIHtcbiAgX2d1aWQ6IG51bWJlcjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGluaXRpYWxpemVHdWlkKG9iamVjdDogSGFzR3VpZCk6IG51bWJlciB7XG4gIHJldHVybiAob2JqZWN0Ll9ndWlkID0gKytHVUlEKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGVuc3VyZUd1aWQob2JqZWN0OiBIYXNHdWlkKTogbnVtYmVyIHtcbiAgcmV0dXJuIG9iamVjdC5fZ3VpZCB8fCBpbml0aWFsaXplR3VpZChvYmplY3QpO1xufSJdfQ== +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvZ3VpZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLFFBQUksSUFBSSxHQUFHLENBQUMsQ0FBQzs7QUFNUCxhQUFBLGNBQUEsQ0FBeUIsTUFBZSxFQUFBO0FBQzVDLGVBQVEsTUFBTSxDQUFDLEtBQUssR0FBRyxFQUFFLElBQUksQ0FBRTtLQUNoQzs7QUFFSyxhQUFBLFVBQUEsQ0FBcUIsTUFBZSxFQUFBO0FBQ3hDLGVBQU8sTUFBTSxDQUFDLEtBQUssSUFBSSxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUM7S0FDL0MiLCJmaWxlIjoiZ3VpZC5qcyIsInNvdXJjZXNDb250ZW50IjpbImxldCBHVUlEID0gMDtcblxuZXhwb3J0IGludGVyZmFjZSBIYXNHdWlkIHtcbiAgX2d1aWQ6IG51bWJlcjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGluaXRpYWxpemVHdWlkKG9iamVjdDogSGFzR3VpZCk6IG51bWJlciB7XG4gIHJldHVybiAob2JqZWN0Ll9ndWlkID0gKytHVUlEKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGVuc3VyZUd1aWQob2JqZWN0OiBIYXNHdWlkKTogbnVtYmVyIHtcbiAgcmV0dXJuIG9iamVjdC5fZ3VpZCB8fCBpbml0aWFsaXplR3VpZChvYmplY3QpO1xufSJdfQ== enifed("glimmer-util/lib/list-utils", ["exports"], function (exports) { "use strict"; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var ListNode = function ListNode(value) { - _classCallCheck(this, ListNode); - this.next = null; this.prev = null; this.value = value; }; exports.ListNode = ListNode; var LinkedList = (function () { function LinkedList() { - _classCallCheck(this, LinkedList); - this.clear(); } LinkedList.fromSlice = function fromSlice(slice) { var list = new LinkedList(); @@ -24733,12 +25297,10 @@ exports.LinkedList = LinkedList; var LinkedListRemover = (function () { function LinkedListRemover(node) { - _classCallCheck(this, LinkedListRemover); - this.node = node; } LinkedListRemover.prototype.destroy = function destroy() { var _node = this.node; @@ -24752,12 +25314,10 @@ return LinkedListRemover; })(); var ListSlice = (function () { function ListSlice(head, tail) { - _classCallCheck(this, ListSlice); - this._head = head; this._tail = tail; } ListSlice.toList = function toList(slice) { @@ -24820,29 +25380,25 @@ exports.ListSlice = ListSlice; var EMPTY_SLICE = new ListSlice(null, null); exports.EMPTY_SLICE = EMPTY_SLICE; }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-util/lib/list-utils.ts"],"names":[],"mappings":"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","file":"list-utils.js","sourcesContent":["export interface Destroyable {\n  destroy();\n}\n\nexport interface LinkedListNode {\n  next: LinkedListNode;\n  prev: LinkedListNode;\n}\n\nexport class ListNode<T> implements LinkedListNode {\n  public next: ListNode<T> = null;\n  public prev: ListNode<T> = null;\n  public value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n}\n\n// we are unable to express the constraint that T's .prev and .next are\n// themselves T. However, it will always be true, so trust us.\ntype trust = any;\n\nexport class LinkedList<T extends LinkedListNode> implements Slice<T> {\n  static fromSlice<U extends CloneableListNode>(slice: Slice<U>): LinkedList<U> {\n    let list = new LinkedList<U>();\n    slice.forEachNode(n => list.append(n.clone()));\n    return list;\n  }\n\n  private _head: T;\n  private _tail: T;\n\n  constructor() {\n    this.clear();\n  }\n\n  head(): T {\n    return this._head;\n  }\n\n  tail(): T {\n    return this._tail;\n  }\n\n  clear() {\n    this._head = this._tail = null;\n  }\n\n  isEmpty(): boolean {\n    return this._head === null;\n  }\n\n  toArray(): T[] {\n    let out = [];\n    this.forEachNode(n => out.push(n));\n    return out;\n  }\n\n  splice(start: T, end: T, reference: T) {\n    let before: T;\n\n    if (reference === null) {\n      before = this._tail;\n      this._tail = end;\n    } else {\n      before = <T>reference.prev;\n      end.next = reference;\n      reference.prev = end;\n    }\n\n    if (before) {\n      before.next = start;\n      start.prev = before;\n    }\n  }\n\n  spliceList(list: LinkedList<T>, reference: T) {\n    if (list.isEmpty()) return;\n    this.splice(list.head(), list.tail(), reference);\n  }\n\n  nextNode(node: T): T {\n    return <trust>node.next;\n  }\n\n  prevNode(node: T): T {\n    return <trust>node.prev;\n  }\n\n  forEachNode(callback: (node: T) => void) {\n    let node = this._head;\n\n    while (node !== null) {\n      callback(<trust>node);\n      node = <trust>node.next;\n    }\n  }\n\n  contains(needle: T): boolean {\n    let node = this._head;\n\n    while (node !== null) {\n      if (node === needle) return true;\n      node = <trust>node.next;\n    }\n\n    return false;\n  }\n\n  insertBefore(node: T, reference: T = null): T {\n    if (reference === null) return this.append(node);\n\n    if (reference.prev) reference.prev.next = node;\n    else this._head = node;\n\n    node.prev = reference.prev;\n    node.next = reference;\n    reference.prev = node;\n\n    return node;\n  }\n\n  append(node: T): T {\n    let tail = this._tail;\n\n    if (tail) {\n      tail.next = node;\n      node.prev = tail;\n      node.next = null;\n    } else {\n      this._head = node;\n    }\n\n    return (this._tail = node);\n  }\n\n  pop(): T {\n    if (this._tail) return this.remove(this._tail);\n    return null;\n  }\n\n  prepend(node: T): T {\n    if (this._head) return this.insertBefore(node, this._head);\n    return (this._head = this._tail = node);\n  }\n\n  remove(node: T): T {\n    if (node.prev) node.prev.next = node.next;\n    else this._head = <trust>node.next;\n\n    if (node.next) node.next.prev = node.prev;\n    else this._tail = <trust>node.prev;\n\n    return node;\n  }\n}\n\nclass LinkedListRemover implements Destroyable {\n  private node: LinkedListNode;\n\n  constructor(node: LinkedListNode) {\n    this.node = node;\n  }\n\n  destroy() {\n    let { prev, next } = this.node;\n    prev.next = next;\n    next.prev = prev;\n  }\n}\n\nexport interface Slice<T extends LinkedListNode> {\n  head(): T;\n  tail(): T;\n  nextNode(node: T): T;\n  prevNode(node: T): T;\n  forEachNode(callback: (node: T) => void);\n  toArray(): T[];\n  isEmpty(): boolean;\n  contains(needle: T): boolean;\n}\n\nexport interface CloneableListNode extends LinkedListNode {\n  clone(): this;\n}\n\nexport class ListSlice<T extends LinkedListNode> implements Slice<T> {\n  static toList<U extends CloneableListNode>(slice: Slice<U>): LinkedList<U> {\n    let list = new LinkedList<U>();\n    slice.forEachNode(n => list.append(n.clone()));\n    return list;\n  }\n\n  private _head: T;\n  private _tail: T;\n\n  constructor(head: T, tail: T) {\n    this._head = head;\n    this._tail = tail;\n  }\n\n  forEachNode(callback: (node: T) => void) {\n    let node = this._head;\n\n    while (node !== null) {\n      callback(node);\n      node = this.nextNode(node);\n    }\n  }\n\n  contains(needle: T): boolean {\n    let node = this._head;\n\n    while (node !== null) {\n      if (node === needle) return true;\n      node = <trust>node.next;\n    }\n\n    return false;\n  }\n\n  head(): T {\n    return this._head;\n  }\n\n  tail(): T {\n    return this._tail;\n  }\n\n  toArray(): T[] {\n    let out = [];\n    this.forEachNode(n => out.push(n));\n    return out;\n  }\n\n  nextNode(node: T): T {\n    if (node === this._tail) return null;\n    return <T>node.next;\n  }\n\n  prevNode(node: T): T {\n    if (node === this._head) return null;\n    return <T>node.prev;\n  }\n\n  isEmpty() {\n    return false;\n  }\n}\n\nexport const EMPTY_SLICE = new ListSlice(null, null);"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-util/lib/list-utils.ts"],"names":[],"mappings":"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","file":"list-utils.js","sourcesContent":["export interface Destroyable {\n  destroy();\n}\n\nexport interface LinkedListNode {\n  next: LinkedListNode;\n  prev: LinkedListNode;\n}\n\nexport class ListNode<T> implements LinkedListNode {\n  public next: ListNode<T> = null;\n  public prev: ListNode<T> = null;\n  public value: T;\n\n  constructor(value: T) {\n    this.value = value;\n  }\n}\n\n// we are unable to express the constraint that T's .prev and .next are\n// themselves T. However, it will always be true, so trust us.\ntype trust = any;\n\nexport class LinkedList<T extends LinkedListNode> implements Slice<T> {\n  static fromSlice<U extends CloneableListNode>(slice: Slice<U>): LinkedList<U> {\n    let list = new LinkedList<U>();\n    slice.forEachNode(n => list.append(n.clone()));\n    return list;\n  }\n\n  private _head: T;\n  private _tail: T;\n\n  constructor() {\n    this.clear();\n  }\n\n  head(): T {\n    return this._head;\n  }\n\n  tail(): T {\n    return this._tail;\n  }\n\n  clear() {\n    this._head = this._tail = null;\n  }\n\n  isEmpty(): boolean {\n    return this._head === null;\n  }\n\n  toArray(): T[] {\n    let out = [];\n    this.forEachNode(n => out.push(n));\n    return out;\n  }\n\n  splice(start: T, end: T, reference: T) {\n    let before: T;\n\n    if (reference === null) {\n      before = this._tail;\n      this._tail = end;\n    } else {\n      before = <T>reference.prev;\n      end.next = reference;\n      reference.prev = end;\n    }\n\n    if (before) {\n      before.next = start;\n      start.prev = before;\n    }\n  }\n\n  spliceList(list: LinkedList<T>, reference: T) {\n    if (list.isEmpty()) return;\n    this.splice(list.head(), list.tail(), reference);\n  }\n\n  nextNode(node: T): T {\n    return <trust>node.next;\n  }\n\n  prevNode(node: T): T {\n    return <trust>node.prev;\n  }\n\n  forEachNode(callback: (node: T) => void) {\n    let node = this._head;\n\n    while (node !== null) {\n      callback(<trust>node);\n      node = <trust>node.next;\n    }\n  }\n\n  contains(needle: T): boolean {\n    let node = this._head;\n\n    while (node !== null) {\n      if (node === needle) return true;\n      node = <trust>node.next;\n    }\n\n    return false;\n  }\n\n  insertBefore(node: T, reference: T = null): T {\n    if (reference === null) return this.append(node);\n\n    if (reference.prev) reference.prev.next = node;\n    else this._head = node;\n\n    node.prev = reference.prev;\n    node.next = reference;\n    reference.prev = node;\n\n    return node;\n  }\n\n  append(node: T): T {\n    let tail = this._tail;\n\n    if (tail) {\n      tail.next = node;\n      node.prev = tail;\n      node.next = null;\n    } else {\n      this._head = node;\n    }\n\n    return (this._tail = node);\n  }\n\n  pop(): T {\n    if (this._tail) return this.remove(this._tail);\n    return null;\n  }\n\n  prepend(node: T): T {\n    if (this._head) return this.insertBefore(node, this._head);\n    return (this._head = this._tail = node);\n  }\n\n  remove(node: T): T {\n    if (node.prev) node.prev.next = node.next;\n    else this._head = <trust>node.next;\n\n    if (node.next) node.next.prev = node.prev;\n    else this._tail = <trust>node.prev;\n\n    return node;\n  }\n}\n\nclass LinkedListRemover implements Destroyable {\n  private node: LinkedListNode;\n\n  constructor(node: LinkedListNode) {\n    this.node = node;\n  }\n\n  destroy() {\n    let { prev, next } = this.node;\n    prev.next = next;\n    next.prev = prev;\n  }\n}\n\nexport interface Slice<T extends LinkedListNode> {\n  head(): T;\n  tail(): T;\n  nextNode(node: T): T;\n  prevNode(node: T): T;\n  forEachNode(callback: (node: T) => void);\n  toArray(): T[];\n  isEmpty(): boolean;\n  contains(needle: T): boolean;\n}\n\nexport interface CloneableListNode extends LinkedListNode {\n  clone(): this;\n}\n\nexport class ListSlice<T extends LinkedListNode> implements Slice<T> {\n  static toList<U extends CloneableListNode>(slice: Slice<U>): LinkedList<U> {\n    let list = new LinkedList<U>();\n    slice.forEachNode(n => list.append(n.clone()));\n    return list;\n  }\n\n  private _head: T;\n  private _tail: T;\n\n  constructor(head: T, tail: T) {\n    this._head = head;\n    this._tail = tail;\n  }\n\n  forEachNode(callback: (node: T) => void) {\n    let node = this._head;\n\n    while (node !== null) {\n      callback(node);\n      node = this.nextNode(node);\n    }\n  }\n\n  contains(needle: T): boolean {\n    let node = this._head;\n\n    while (node !== null) {\n      if (node === needle) return true;\n      node = <trust>node.next;\n    }\n\n    return false;\n  }\n\n  head(): T {\n    return this._head;\n  }\n\n  tail(): T {\n    return this._tail;\n  }\n\n  toArray(): T[] {\n    let out = [];\n    this.forEachNode(n => out.push(n));\n    return out;\n  }\n\n  nextNode(node: T): T {\n    if (node === this._tail) return null;\n    return <T>node.next;\n  }\n\n  prevNode(node: T): T {\n    if (node === this._head) return null;\n    return <T>node.prev;\n  }\n\n  isEmpty() {\n    return false;\n  }\n}\n\nexport const EMPTY_SLICE = new ListSlice(null, null);"]} enifed("glimmer-util/lib/logger", ["exports"], function (exports) { "use strict"; - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - var LogLevel; exports.LogLevel = LogLevel; (function (LogLevel) { LogLevel[LogLevel["Trace"] = 0] = "Trace"; LogLevel[LogLevel["Debug"] = 1] = "Debug"; LogLevel[LogLevel["Warn"] = 2] = "Warn"; LogLevel[LogLevel["Error"] = 3] = "Error"; })(LogLevel || (exports.LogLevel = LogLevel = {})); var NullConsole = (function () { - function NullConsole() { - _classCallCheck(this, NullConsole); - } + function NullConsole() {} NullConsole.prototype.log = function log(message) {}; NullConsole.prototype.warn = function warn(message) {}; @@ -24856,12 +25412,10 @@ var Logger = (function () { function Logger(_ref) { var console = _ref.console; var level = _ref.level; - _classCallCheck(this, Logger); - this.f = ALWAYS; this.force = ALWAYS; this.console = console; this.level = level; } @@ -24916,11 +25470,11 @@ var _console = typeof console === 'undefined' ? new NullConsole() : console; var ALWAYS = new Logger({ console: _console, level: LogLevel.Trace }); var LOG_LEVEL = LogLevel.Warn; exports.default = new Logger({ console: _console, level: LOG_LEVEL }); }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,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 enifed('glimmer-util/lib/namespaces', ['exports'], function (exports) { // There is a small whitelist of namespaced attributes specially // enumerated in // https://www.w3.org/TR/html/syntax.html#attributes-0 // @@ -24956,14 +25510,14 @@ function getAttrNamespace(attrName) { return WHITELIST[attrName] || null; } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvbmFtZXNwYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQWNBLFFBQU0sS0FBSyxHQUFHLDhCQUE4QixDQUFDO0FBQzdDLFFBQU0sR0FBRyxHQUFHLHNDQUFzQyxDQUFDO0FBQ25ELFFBQU0sS0FBSyxHQUFHLCtCQUErQixDQUFDO0FBRTlDLFFBQU0sU0FBUyxHQUFHO0FBQ2hCLHVCQUFlLEVBQUUsS0FBSztBQUN0Qix1QkFBZSxFQUFFLEtBQUs7QUFDdEIsb0JBQVksRUFBRSxLQUFLO0FBQ25CLG9CQUFZLEVBQUUsS0FBSztBQUNuQixvQkFBWSxFQUFFLEtBQUs7QUFDbkIscUJBQWEsRUFBRSxLQUFLO0FBQ3BCLG9CQUFZLEVBQUUsS0FBSztBQUNuQixrQkFBVSxFQUFFLEdBQUc7QUFDZixrQkFBVSxFQUFFLEdBQUc7QUFDZixtQkFBVyxFQUFFLEdBQUc7QUFDaEIsZUFBTyxFQUFFLEtBQUs7QUFDZCxxQkFBYSxFQUFFLEtBQUs7S0FDckIsQ0FBQzs7QUFFRixhQUFBLGdCQUFBLENBQWlDLFFBQVEsRUFBQTtBQUN2QyxlQUFPLFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxJQUFJLENBQUM7S0FDcEMiLCJmaWxlIjoibmFtZXNwYWNlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vIFRoZXJlIGlzIGEgc21hbGwgd2hpdGVsaXN0IG9mIG5hbWVzcGFjZWQgYXR0cmlidXRlcyBzcGVjaWFsbHlcbi8vIGVudW1lcmF0ZWQgaW5cbi8vIGh0dHBzOi8vd3d3LnczLm9yZy9UUi9odG1sL3N5bnRheC5odG1sI2F0dHJpYnV0ZXMtMFxuLy9cbi8vID4gV2hlbiBhIGZvcmVpZ24gZWxlbWVudCBoYXMgb25lIG9mIHRoZSBuYW1lc3BhY2VkIGF0dHJpYnV0ZXMgZ2l2ZW4gYnlcbi8vID4gdGhlIGxvY2FsIG5hbWUgYW5kIG5hbWVzcGFjZSBvZiB0aGUgZmlyc3QgYW5kIHNlY29uZCBjZWxscyBvZiBhIHJvd1xuLy8gPiBmcm9tIHRoZSBmb2xsb3dpbmcgdGFibGUsIGl0IG11c3QgYmUgd3JpdHRlbiB1c2luZyB0aGUgbmFtZSBnaXZlbiBieVxuLy8gPiB0aGUgdGhpcmQgY2VsbCBmcm9tIHRoZSBzYW1lIHJvdy5cbi8vXG4vLyBJbiBhbGwgb3RoZXIgY2FzZXMsIGNvbG9ucyBhcmUgaW50ZXJwcmV0ZWQgYXMgYSByZWd1bGFyIGNoYXJhY3RlclxuLy8gd2l0aCBubyBzcGVjaWFsIG1lYW5pbmc6XG4vL1xuLy8gPiBObyBvdGhlciBuYW1lc3BhY2VkIGF0dHJpYnV0ZSBjYW4gYmUgZXhwcmVzc2VkIGluIHRoZSBIVE1MIHN5bnRheC5cblxuY29uc3QgWExJTksgPSAnaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayc7XG5jb25zdCBYTUwgPSAnaHR0cDovL3d3dy53My5vcmcvWE1MLzE5OTgvbmFtZXNwYWNlJztcbmNvbnN0IFhNTE5TID0gJ2h0dHA6Ly93d3cudzMub3JnLzIwMDAveG1sbnMvJztcblxuY29uc3QgV0hJVEVMSVNUID0ge1xuICAneGxpbms6YWN0dWF0ZSc6IFhMSU5LLFxuICAneGxpbms6YXJjcm9sZSc6IFhMSU5LLFxuICAneGxpbms6aHJlZic6IFhMSU5LLFxuICAneGxpbms6cm9sZSc6IFhMSU5LLFxuICAneGxpbms6c2hvdyc6IFhMSU5LLFxuICAneGxpbms6dGl0bGUnOiBYTElOSyxcbiAgJ3hsaW5rOnR5cGUnOiBYTElOSyxcbiAgJ3htbDpiYXNlJzogWE1MLFxuICAneG1sOmxhbmcnOiBYTUwsXG4gICd4bWw6c3BhY2UnOiBYTUwsXG4gICd4bWxucyc6IFhNTE5TLFxuICAneG1sbnM6eGxpbmsnOiBYTUxOU1xufTtcblxuZXhwb3J0IGZ1bmN0aW9uIGdldEF0dHJOYW1lc3BhY2UoYXR0ck5hbWUpIHtcbiAgcmV0dXJuIFdISVRFTElTVFthdHRyTmFtZV0gfHwgbnVsbDtcbn0iXX0= -enifed("glimmer-util/lib/object-utils", ["exports"], function (exports) { +//# sourceMappingURL=data:application/json;base64,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 +enifed('glimmer-util/lib/object-utils', ['exports'], function (exports) { /*globals console*/ - "use strict"; + /*globals console*/'use strict'; exports.merge = merge; exports.assign = assign; exports.shallowCopy = shallowCopy; exports.keySet = keySet; @@ -24983,10 +25537,13 @@ for (var _len = arguments.length, assignments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { assignments[_key - 1] = arguments[_key]; } return assignments.reduce(function (obj, extensions) { + if (typeof extensions !== 'object' || extensions === null) { + return obj; + } Object.keys(extensions).forEach(function (key) { return obj[key] = extensions[key]; }); return obj; }, obj); @@ -25014,47 +25571,29 @@ } } return count; } }); -//# sourceMappingURL=data:application/json;base64,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 -enifed('glimmer-util/lib/platform-utils', ['exports'], function (exports) { - 'use strict'; +//# sourceMappingURL=data:application/json;base64,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 +enifed("glimmer-util/lib/platform-utils", ["exports"], function (exports) { + "use strict"; - exports.intern = intern; exports.opaque = opaque; - exports.numberKey = numberKey; - exports.LITERAL = LITERAL; - exports.symbol = symbol; + exports.unwrap = unwrap; - function intern(str) { - return str; - // let obj = {}; - // obj[str] = 1; - // for (let key in obj) return <InternedString>key; - } - function opaque(value) { return value; } - function numberKey(num) { - return String(num); - } + // tslint:disable-line - function LITERAL(str) { - return str; + function unwrap(val) { + if (val === null || val === undefined) throw new Error("Expected value to be present"); + return val; } - - var BASE_KEY = intern('__glimmer{+ new Date()}'); - - function symbol(debugName) { - var number = +new Date(); - return intern(debugName + ' [id=' + BASE_KEY + Math.floor(Math.random() * number) + ']'); - } }); -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvcGxhdGZvcm0tdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBRU0sYUFBQSxNQUFBLENBQWlCLEtBQWEsRUFBQTtBQUNsQyxlQUFPLEtBQUssQ0FBQztLQUNkOzs7O0FBS0ssYUFBQSxNQUFBLENBQW9CLEdBQWEsRUFBQTtBQUNyQyxZQUFJLEdBQUcsS0FBSyxJQUFJLElBQUksR0FBRyxLQUFLLFNBQVMsRUFBRSxNQUFNLElBQUksS0FBSyxnQ0FBZ0MsQ0FBQztBQUN2RixlQUFPLEdBQUcsQ0FBQztLQUNaIiwiZmlsZSI6InBsYXRmb3JtLXV0aWxzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgT3BhcXVlID0ge30gfCB2b2lkO1xuXG5leHBvcnQgZnVuY3Rpb24gb3BhcXVlKHZhbHVlOiBPcGFxdWUpOiBPcGFxdWUge1xuICByZXR1cm4gdmFsdWU7XG59XG5cbmV4cG9ydCB0eXBlIE9wdGlvbjxUPiA9IFQgfCBudWxsOyAvLyB0c2xpbnQ6ZGlzYWJsZS1saW5lXG5leHBvcnQgdHlwZSBNYXliZTxUPiA9IE9wdGlvbjxUPiB8IHVuZGVmaW5lZDsgLy8gdHNsaW50OmRpc2FibGUtbGluZVxuXG5leHBvcnQgZnVuY3Rpb24gdW53cmFwPFQ+KHZhbDogTWF5YmU8VD4pOiBUIHtcbiAgaWYgKHZhbCA9PT0gbnVsbCB8fCB2YWwgPT09IHVuZGVmaW5lZCkgdGhyb3cgbmV3IEVycm9yKGBFeHBlY3RlZCB2YWx1ZSB0byBiZSBwcmVzZW50YCk7XG4gIHJldHVybiB2YWw7XG59XG4iXX0= enifed("glimmer-util/lib/quoting", ["exports"], function (exports) { "use strict"; exports.hash = hash; exports.repeat = repeat; @@ -25086,11 +25625,11 @@ str += chars; } return str; } }); -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvcXVvdGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLGFBQUEsWUFBQSxDQUFzQixHQUFHLEVBQUE7QUFDdkIsV0FBRyxHQUFHLEdBQUcsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQ2pDLFdBQUcsR0FBRyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztBQUMvQixXQUFHLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUM7QUFDaEMsZUFBTyxHQUFHLENBQUM7S0FDWjtZQUVRLFlBQVksR0FBWixZQUFZOztBQUVyQixhQUFBLE1BQUEsQ0FBZ0IsR0FBRyxFQUFBO0FBQ2pCLGVBQU8sR0FBRyxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUMsR0FBRyxHQUFHLENBQUM7S0FDdEM7WUFFUSxNQUFNLEdBQU4sTUFBTTs7QUFFZixhQUFBLEtBQUEsQ0FBZSxDQUFDLEVBQUE7QUFDZCxlQUFPLEdBQUcsR0FBRyxDQUFDLEdBQUcsR0FBRyxDQUFDO0tBQ3RCO1lBRVEsS0FBSyxHQUFMLEtBQUs7O0FBRWQsYUFBQSxJQUFBLENBQXFCLEtBQUssRUFBQTtBQUN4QixlQUFPLEdBQUcsR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEdBQUcsQ0FBQztLQUNyQzs7QUFFRCxhQUFBLE1BQUEsQ0FBdUIsS0FBSyxFQUFFLEtBQUssRUFBQTtBQUNqQyxZQUFJLEdBQUcsR0FBRyxFQUFFLENBQUM7QUFDYixlQUFPLEtBQUssRUFBRSxFQUFFO0FBQ2QsZUFBRyxJQUFJLEtBQUssQ0FBQztTQUNkO0FBQ0QsZUFBTyxHQUFHLENBQUM7S0FDWiIsImZpbGUiOiJxdW90aW5nLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZnVuY3Rpb24gZXNjYXBlU3RyaW5nKHN0cikge1xuICBzdHIgPSBzdHIucmVwbGFjZSgvXFxcXC9nLCBcIlxcXFxcXFxcXCIpO1xuICBzdHIgPSBzdHIucmVwbGFjZSgvXCIvZywgJ1xcXFxcIicpO1xuICBzdHIgPSBzdHIucmVwbGFjZSgvXFxuL2csIFwiXFxcXG5cIik7XG4gIHJldHVybiBzdHI7XG59XG5cbmV4cG9ydCB7IGVzY2FwZVN0cmluZyB9O1xuXG5mdW5jdGlvbiBzdHJpbmcoc3RyKSB7XG4gIHJldHVybiAnXCInICsgZXNjYXBlU3RyaW5nKHN0cikgKyAnXCInO1xufVxuXG5leHBvcnQgeyBzdHJpbmcgfTtcblxuZnVuY3Rpb24gYXJyYXkoYSkge1xuICByZXR1cm4gXCJbXCIgKyBhICsgXCJdXCI7XG59XG5cbmV4cG9ydCB7IGFycmF5IH07XG5cbmV4cG9ydCBmdW5jdGlvbiBoYXNoKHBhaXJzKSB7XG4gIHJldHVybiBcIntcIiArIHBhaXJzLmpvaW4oXCIsIFwiKSArIFwifVwiO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gcmVwZWF0KGNoYXJzLCB0aW1lcykge1xuICBsZXQgc3RyID0gXCJcIjtcbiAgd2hpbGUgKHRpbWVzLS0pIHtcbiAgICBzdHIgKz0gY2hhcnM7XG4gIH1cbiAgcmV0dXJuIHN0cjtcbn1cbiJdfQ== +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImdsaW1tZXItdXRpbC9saWIvcXVvdGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLGFBQUEsWUFBQSxDQUFzQixHQUFHLEVBQUE7QUFDdkIsV0FBRyxHQUFHLEdBQUcsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQ2pDLFdBQUcsR0FBRyxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztBQUMvQixXQUFHLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUM7QUFDaEMsZUFBTyxHQUFHLENBQUM7S0FDWjtZQUVRLFlBQVksR0FBWixZQUFZOztBQUVyQixhQUFBLE1BQUEsQ0FBZ0IsR0FBRyxFQUFBO0FBQ2pCLGVBQU8sR0FBRyxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUMsR0FBRyxHQUFHLENBQUM7S0FDdEM7WUFFUSxNQUFNLEdBQU4sTUFBTTs7QUFFZixhQUFBLEtBQUEsQ0FBZSxDQUFDLEVBQUE7QUFDZCxlQUFPLEdBQUcsR0FBRyxDQUFDLEdBQUcsR0FBRyxDQUFDO0tBQ3RCO1lBRVEsS0FBSyxHQUFMLEtBQUs7O0FBRVIsYUFBQSxJQUFBLENBQWUsS0FBSyxFQUFBO0FBQ3hCLGVBQU8sR0FBRyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsR0FBRyxDQUFDO0tBQ3JDOztBQUVLLGFBQUEsTUFBQSxDQUFpQixLQUFLLEVBQUUsS0FBSyxFQUFBO0FBQ2pDLFlBQUksR0FBRyxHQUFHLEVBQUUsQ0FBQztBQUNiLGVBQU8sS0FBSyxFQUFFLEVBQUU7QUFDZCxlQUFHLElBQUksS0FBSyxDQUFDO1NBQ2Q7QUFDRCxlQUFPLEdBQUcsQ0FBQztLQUNaIiwiZmlsZSI6InF1b3RpbmcuanMiLCJzb3VyY2VzQ29udGVudCI6WyJmdW5jdGlvbiBlc2NhcGVTdHJpbmcoc3RyKSB7XG4gIHN0ciA9IHN0ci5yZXBsYWNlKC9cXFxcL2csIFwiXFxcXFxcXFxcIik7XG4gIHN0ciA9IHN0ci5yZXBsYWNlKC9cIi9nLCAnXFxcXFwiJyk7XG4gIHN0ciA9IHN0ci5yZXBsYWNlKC9cXG4vZywgXCJcXFxcblwiKTtcbiAgcmV0dXJuIHN0cjtcbn1cblxuZXhwb3J0IHsgZXNjYXBlU3RyaW5nIH07XG5cbmZ1bmN0aW9uIHN0cmluZyhzdHIpIHtcbiAgcmV0dXJuICdcIicgKyBlc2NhcGVTdHJpbmcoc3RyKSArICdcIic7XG59XG5cbmV4cG9ydCB7IHN0cmluZyB9O1xuXG5mdW5jdGlvbiBhcnJheShhKSB7XG4gIHJldHVybiBcIltcIiArIGEgKyBcIl1cIjtcbn1cblxuZXhwb3J0IHsgYXJyYXkgfTtcblxuZXhwb3J0IGZ1bmN0aW9uIGhhc2gocGFpcnMpIHtcbiAgcmV0dXJuIFwie1wiICsgcGFpcnMuam9pbihcIiwgXCIpICsgXCJ9XCI7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiByZXBlYXQoY2hhcnMsIHRpbWVzKSB7XG4gIGxldCBzdHIgPSBcIlwiO1xuICB3aGlsZSAodGltZXMtLSkge1xuICAgIHN0ciArPSBjaGFycztcbiAgfVxuICByZXR1cm4gc3RyO1xufVxuIl19 enifed("glimmer-util/lib/void-tag-names", ["exports", "glimmer-util/lib/array-utils"], function (exports, _glimmerUtilLibArrayUtils) { "use strict"; // The HTML elements in this list are speced by // http://www.w3.org/TR/html-markup/syntax.html#syntax-elements, @@ -25116,38 +25655,42 @@ exports.Expressions = Expressions; (function (Expressions) { Expressions.isUnknown = is('unknown'); Expressions.isArg = is('arg'); Expressions.isGet = is('get'); - Expressions.isSelfGet = is('self-get'); Expressions.isConcat = is('concat'); Expressions.isHelper = is('helper'); - Expressions.isHasBlock = is('hasBlock'); - Expressions.isHasBlockParams = is('hasBlockParams'); - function isValue(value) { - return value !== null && typeof value !== 'object'; + Expressions.isHasBlock = is('has-block'); + Expressions.isHasBlockParams = is('has-block-params'); + Expressions.isUndefined = is('undefined'); + function isPrimitiveValue(value) { + if (value === null) { + return true; + } + return typeof value !== 'object'; } - Expressions.isValue = isValue; + Expressions.isPrimitiveValue = isPrimitiveValue; })(Expressions || (exports.Expressions = Expressions = {})); var Statements; exports.Statements = Statements; (function (Statements) { Statements.isText = is('text'); Statements.isAppend = is('append'); Statements.isComment = is('comment'); Statements.isModifier = is('modifier'); Statements.isBlock = is('block'); - Statements.isOpenElement = is('openElement'); - Statements.isCloseElement = is('closeElement'); - Statements.isStaticAttr = is('staticAttr'); - Statements.isDynamicAttr = is('dynamicAttr'); + Statements.isOpenElement = is('open-element'); + Statements.isFlushElement = is('flush-element'); + Statements.isCloseElement = is('close-element'); + Statements.isStaticAttr = is('static-attr'); + Statements.isDynamicAttr = is('dynamic-attr'); Statements.isYield = is('yield'); - Statements.isDynamicArg = is('dynamicArg'); - Statements.isStaticArg = is('staticArg'); - Statements.isTrustingAttr = is('trustingAttr'); + Statements.isDynamicArg = is('dynamic-arg'); + Statements.isStaticArg = is('static-arg'); + Statements.isTrustingAttr = is('trusting-attr'); })(Statements || (exports.Statements = Statements = {})); }); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-wire-format/index.ts"],"names":[],"mappings":";;;AAmBA,aAAA,EAAA,CAA6B,OAAe,EAAA;AAC1C,eAAO,UAAS,KAAY,EAAA;AAC1B,mBAAO,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC;SAC7B,CAAC;KACH;AAUD,QAAiB,WAAW,CAiD3B;;AAjDD,KAAA,UAAiB,WAAW,EAAC;AAqCd,mBAAA,CAAA,SAAS,GAAU,EAAE,CAAU,SAAS,CAAC,CAAC;AAC1C,mBAAA,CAAA,KAAK,GAAc,EAAE,CAAM,KAAK,CAAC,CAAC;AAClC,mBAAA,CAAA,KAAK,GAAc,EAAE,CAAM,KAAK,CAAC,CAAC;AAClC,mBAAA,CAAA,SAAS,GAAU,EAAE,CAAU,UAAU,CAAC,CAAC;AAC3C,mBAAA,CAAA,QAAQ,GAAW,EAAE,CAAS,QAAQ,CAAC,CAAC;AACxC,mBAAA,CAAA,QAAQ,GAAW,EAAE,CAAS,QAAQ,CAAC,CAAC;AACxC,mBAAA,CAAA,UAAU,GAAS,EAAE,CAAW,UAAU,CAAC,CAAC;AAC5C,mBAAA,CAAA,gBAAgB,GAAG,EAAE,CAAiB,gBAAgB,CAAC,CAAC;AAErE,iBAAA,OAAA,CAAwB,KAAU,EAAA;AAChC,mBAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC;SACpD;AAFe,mBAAA,CAAA,OAAO,GAAA,OAEtB,CAAA;KACF,CAAA,CAjDgB,WAAW,aAAX,WAAW,GAAX,WAAW,GAAA,EAAA,CAAA,CAAA,CAiD3B;AAID,QAAiB,UAAU,CAiD1B;;AAjDD,KAAA,UAAiB,UAAU,EAAC;AAoBb,kBAAA,CAAA,MAAM,GAAW,EAAE,CAAO,MAAM,CAAC,CAAC;AAClC,kBAAA,CAAA,QAAQ,GAAS,EAAE,CAAS,QAAQ,CAAC,CAAC;AACtC,kBAAA,CAAA,SAAS,GAAQ,EAAE,CAAU,SAAS,CAAC,CAAC;AACxC,kBAAA,CAAA,UAAU,GAAO,EAAE,CAAW,UAAU,CAAC,CAAC;AAC1C,kBAAA,CAAA,OAAO,GAAU,EAAE,CAAQ,OAAO,CAAC,CAAC;AACpC,kBAAA,CAAA,aAAa,GAAI,EAAE,CAAc,aAAa,CAAC,CAAC;AAChD,kBAAA,CAAA,cAAc,GAAG,EAAE,CAAe,cAAc,CAAC,CAAC;AAClD,kBAAA,CAAA,YAAY,GAAK,EAAE,CAAa,YAAY,CAAC,CAAC;AAC9C,kBAAA,CAAA,aAAa,GAAI,EAAE,CAAc,aAAa,CAAC,CAAC;AAChD,kBAAA,CAAA,OAAO,GAAU,EAAE,CAAQ,OAAO,CAAC,CAAC;AACpC,kBAAA,CAAA,YAAY,GAAK,EAAE,CAAa,YAAY,CAAC,CAAC;AAC9C,kBAAA,CAAA,WAAW,GAAM,EAAE,CAAY,WAAW,CAAC,CAAC;AAC5C,kBAAA,CAAA,cAAc,GAAG,EAAE,CAAe,cAAc,CAAC,CAAC;KAiBhE,CAAA,CAjDgB,UAAU,aAAV,UAAU,GAAV,UAAU,GAAA,EAAA,CAAA,CAAA,CAiD1B","file":"index.js","sourcesContent":["import { Dict, InternedString } from 'glimmer-util';\n\ntype JsonValue =\n    string\n  | number\n  | boolean\n  | JsonObject\n  | JsonArray\n  ;\n\ninterface JsonObject extends Dict<JsonValue> {}\ninterface JsonArray extends Array<JsonValue> {}\n\n// This entire file is serialized to disk, so all strings\n// end up being interned.\nexport type str = string;\nexport type TemplateReference = number;\nexport type YieldTo = str;\n\nfunction is<T extends any[]>(variant: string): (value: any[]) => value is T {\n  return function(value: any[]): value is T {\n    return value[0] === variant;\n  };\n}\n\nexport namespace Core {\n  type Expression = Expressions.Expression;\n\n  export type Path          = str[];\n  export type Params        = Expression[];\n  export type Hash          = Dict<Expression>;\n}\n\nexport namespace Expressions {\n  type Path = Core.Path;\n  type Params = Core.Params;\n  type Hash = Core.Hash;\n\n  export type Unknown        = ['unknown', Path];\n  export type Arg            = ['arg', Path];\n  export type Get            = ['get', Path];\n  export type SelfGet        = ['self-get', Path];\n  export type Value          = str | number | boolean;\n  export type HasBlock       = ['hasBlock', str];\n  export type HasBlockParams = ['hasBlockParams', str];\n\n  export type Expression =\n      Unknown\n    | Arg\n    | Get\n    | SelfGet\n    | Concat\n    | HasBlock\n    | HasBlockParams\n    | Helper\n    | Value\n    ;\n\n  export interface Concat extends Array<any> {\n    [0]: 'concat';\n    [1]: Params;\n  }\n\n  export interface Helper extends Array<any> {\n    [0]: 'helper';\n    [1]: Path;\n    [2]: Params;\n    [3]: Hash;\n  }\n\n  export const isUnknown        = is<Unknown>('unknown');\n  export const isArg            = is<Arg>('arg');\n  export const isGet            = is<Get>('get');\n  export const isSelfGet        = is<SelfGet>('self-get');\n  export const isConcat         = is<Concat>('concat');\n  export const isHelper         = is<Helper>('helper');\n  export const isHasBlock       = is<HasBlock>('hasBlock');\n  export const isHasBlockParams = is<HasBlockParams>('hasBlockParams');\n\n  export function isValue(value: any): value is Value {\n    return value !== null && typeof value !== 'object';\n  }\n}\n\nexport type Expression = Expressions.Expression;\n\nexport namespace Statements {\n  type Expression = Expressions.Expression;\n  type Params = Core.Params;\n  type Hash = Core.Hash;\n  type Path = Core.Path;\n\n  export type Text          = ['text', str];\n  export type Append        = ['append', Expression, boolean];\n  export type Comment       = ['comment', str];\n  export type Modifier      = ['modifier', Path, Params, Hash];\n  export type Block         = ['block', Path, Params, Hash, TemplateReference, TemplateReference];\n  export type OpenElement   = ['openElement', str, str[]];\n  export type CloseElement  = ['closeElement'];\n  export type StaticAttr    = ['staticAttr', str, Expression, str];\n  export type DynamicAttr   = ['dynamicAttr', str, Expression, str];\n  export type Yield         = ['yield', YieldTo, Params];\n  export type DynamicArg    = ['dynamicArg', str, Expression];\n  export type StaticArg     = ['staticArg', str, Expression];\n  export type TrustingAttr  = ['trustingAttr', str, Expression, str];\n\n  export const isText         = is<Text>('text');\n  export const isAppend       = is<Append>('append');\n  export const isComment      = is<Comment>('comment');\n  export const isModifier     = is<Modifier>('modifier');\n  export const isBlock        = is<Block>('block');\n  export const isOpenElement  = is<OpenElement>('openElement');\n  export const isCloseElement = is<CloseElement>('closeElement');\n  export const isStaticAttr   = is<StaticAttr>('staticAttr');\n  export const isDynamicAttr  = is<DynamicAttr>('dynamicAttr');\n  export const isYield        = is<Yield>('yield');\n  export const isDynamicArg   = is<DynamicArg>('dynamicArg');\n  export const isStaticArg    = is<StaticArg>('staticArg');\n  export const isTrustingAttr = is<TrustingAttr>('trustingAttr');\n\n  export type Statement =\n      Text\n    | Append\n    | Comment\n    | Modifier\n    | Block\n    | OpenElement\n    | CloseElement\n    | StaticAttr\n    | DynamicAttr\n    | Yield\n    | StaticArg\n    | DynamicArg\n    | TrustingAttr\n    ;\n}\n\nexport type Statement = Statements.Statement;\n\nexport interface BlockMeta {\n  moduleName?: string;\n}\n\nexport interface SerializedTemplate {\n  statements: Statements.Statement[];\n  locals: InternedString[];\n  named: InternedString[];\n  yields: InternedString[];\n  blocks: SerializedBlock[];\n  meta: BlockMeta;\n}\n\nexport interface SerializedBlock {\n  statements: Statements.Statement[];\n  locals: InternedString[];\n}\n"]} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["glimmer-wire-format/index.ts"],"names":[],"mappings":";;;AAmBA,aAAA,EAAA,CAA6B,OAAe,EAAA;AAC1C,eAAO,UAAS,KAAY,EAAA;AAC1B,mBAAO,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC;SAC7B,CAAC;KACH;AAUK,QAAW,WAAW,CAoD3B;;AApDD,KAAA,UAAiB,WAAW,EAAA;AAqCb,mBAAA,CAAA,SAAS,GAAU,EAAE,CAAU,SAAS,CAAC,CAAC;AAC1C,mBAAA,CAAA,KAAK,GAAc,EAAE,CAAM,KAAK,CAAC,CAAC;AAClC,mBAAA,CAAA,KAAK,GAAc,EAAE,CAAM,KAAK,CAAC,CAAC;AAClC,mBAAA,CAAA,QAAQ,GAAW,EAAE,CAAS,QAAQ,CAAC,CAAC;AACxC,mBAAA,CAAA,QAAQ,GAAW,EAAE,CAAS,QAAQ,CAAC,CAAC;AACxC,mBAAA,CAAA,UAAU,GAAS,EAAE,CAAW,WAAW,CAAC,CAAC;AAC7C,mBAAA,CAAA,gBAAgB,GAAG,EAAE,CAAiB,kBAAkB,CAAC,CAAC;AAC1D,mBAAA,CAAA,WAAW,GAAQ,EAAE,CAAY,WAAW,CAAC,CAAC;AAE3D,iBAAA,gBAAA,CAAiC,KAAU,EAAA;AACzC,gBAAI,KAAK,KAAK,IAAI,EAAE;AAClB,uBAAO,IAAI,CAAC;aACb;AACD,mBAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;SAClC;AALe,mBAAA,CAAA,gBAAgB,GAAA,gBAK/B,CAAA;KACF,CAAA,CApDgB,WAAW,aAAX,WAAW,GAAX,WAAW,GAAA,EAAA,CAAA,CAAA,CAoD3B;AAIK,QAAW,UAAU,CAoD1B;;AApDD,KAAA,UAAiB,UAAU,EAAA;AAqBZ,kBAAA,CAAA,MAAM,GAAW,EAAE,CAAO,MAAM,CAAC,CAAC;AAClC,kBAAA,CAAA,QAAQ,GAAS,EAAE,CAAS,QAAQ,CAAC,CAAC;AACtC,kBAAA,CAAA,SAAS,GAAQ,EAAE,CAAU,SAAS,CAAC,CAAC;AACxC,kBAAA,CAAA,UAAU,GAAO,EAAE,CAAW,UAAU,CAAC,CAAC;AAC1C,kBAAA,CAAA,OAAO,GAAU,EAAE,CAAQ,OAAO,CAAC,CAAC;AACpC,kBAAA,CAAA,aAAa,GAAI,EAAE,CAAc,cAAc,CAAC,CAAC;AACjD,kBAAA,CAAA,cAAc,GAAG,EAAE,CAAe,eAAe,CAAC,CAAC;AACnD,kBAAA,CAAA,cAAc,GAAG,EAAE,CAAe,eAAe,CAAC,CAAC;AACnD,kBAAA,CAAA,YAAY,GAAK,EAAE,CAAa,aAAa,CAAC,CAAC;AAC/C,kBAAA,CAAA,aAAa,GAAI,EAAE,CAAc,cAAc,CAAC,CAAC;AACjD,kBAAA,CAAA,OAAO,GAAU,EAAE,CAAQ,OAAO,CAAC,CAAC;AACpC,kBAAA,CAAA,YAAY,GAAK,EAAE,CAAa,aAAa,CAAC,CAAC;AAC/C,kBAAA,CAAA,WAAW,GAAM,EAAE,CAAY,YAAY,CAAC,CAAC;AAC7C,kBAAA,CAAA,cAAc,GAAG,EAAE,CAAe,eAAe,CAAC,CAAC;KAkBjE,CAAA,CApDgB,UAAU,aAAV,UAAU,GAAV,UAAU,GAAA,EAAA,CAAA,CAAA,CAoD1B","file":"index.js","sourcesContent":["import { Dict } from 'glimmer-util';\n\ntype JsonValue =\n    string\n  | number\n  | boolean\n  | JsonObject\n  | JsonArray\n  ;\n\ninterface JsonObject extends Dict<JsonValue> {}\ninterface JsonArray extends Array<JsonValue> {}\n\n// This entire file is serialized to disk, so all strings\n// end up being interned.\nexport type str = string;\nexport type TemplateReference = number;\nexport type YieldTo = str;\n\nfunction is<T extends any[]>(variant: string): (value: any[]) => value is T {\n  return function(value: any[]): value is T {\n    return value[0] === variant;\n  };\n}\n\nexport namespace Core {\n  type Expression = Expressions.Expression;\n\n  export type Path          = str[];\n  export type Params        = Expression[];\n  export type Hash          = [str[], Expression[]];\n}\n\nexport namespace Expressions {\n  type Path = Core.Path;\n  type Params = Core.Params;\n  type Hash = Core.Hash;\n\n  export type Unknown        = ['unknown', Path];\n  export type Arg            = ['arg', Path];\n  export type Get            = ['get', Path];\n  export type Value          = str | number | boolean | null; // tslint:disable-line\n  export type HasBlock       = ['has-block', str];\n  export type HasBlockParams = ['has-block-params', str];\n  export type Undefined      = ['undefined'];\n\n  export type Expression =\n      Unknown\n    | Arg\n    | Get\n    | Concat\n    | HasBlock\n    | HasBlockParams\n    | Helper\n    | Undefined\n    | Value\n    ;\n\n  export interface Concat extends Array<any> {\n    [0]: 'concat';\n    [1]: Params;\n  }\n\n  export interface Helper extends Array<any> {\n    [0]: 'helper';\n    [1]: Path;\n    [2]: Params;\n    [3]: Hash;\n  }\n\n  export const isUnknown        = is<Unknown>('unknown');\n  export const isArg            = is<Arg>('arg');\n  export const isGet            = is<Get>('get');\n  export const isConcat         = is<Concat>('concat');\n  export const isHelper         = is<Helper>('helper');\n  export const isHasBlock       = is<HasBlock>('has-block');\n  export const isHasBlockParams = is<HasBlockParams>('has-block-params');\n  export const isUndefined      = is<Undefined>('undefined');\n\n  export function isPrimitiveValue(value: any): value is Value {\n    if (value === null) {\n      return true;\n    }\n    return typeof value !== 'object';\n  }\n}\n\nexport type Expression = Expressions.Expression;\n\nexport namespace Statements {\n  type Expression = Expressions.Expression;\n  type Params = Core.Params;\n  type Hash = Core.Hash;\n  type Path = Core.Path;\n\n  export type Text          = ['text', str];\n  export type Append        = ['append', Expression, boolean];\n  export type Comment       = ['comment', str];\n  export type Modifier      = ['modifier', Path, Params, Hash];\n  export type Block         = ['block', Path, Params, Hash, TemplateReference, TemplateReference];\n  export type OpenElement   = ['open-element', str, str[]];\n  export type FlushElement  = ['flush-element'];\n  export type CloseElement  = ['close-element'];\n  export type StaticAttr    = ['static-attr', str, Expression, str];\n  export type DynamicAttr   = ['dynamic-attr', str, Expression, str];\n  export type Yield         = ['yield', YieldTo, Params];\n  export type DynamicArg    = ['dynamic-arg', str, Expression];\n  export type StaticArg     = ['static-arg', str, Expression];\n  export type TrustingAttr  = ['trusting-attr', str, Expression, str];\n\n  export const isText         = is<Text>('text');\n  export const isAppend       = is<Append>('append');\n  export const isComment      = is<Comment>('comment');\n  export const isModifier     = is<Modifier>('modifier');\n  export const isBlock        = is<Block>('block');\n  export const isOpenElement  = is<OpenElement>('open-element');\n  export const isFlushElement = is<FlushElement>('flush-element');\n  export const isCloseElement = is<CloseElement>('close-element');\n  export const isStaticAttr   = is<StaticAttr>('static-attr');\n  export const isDynamicAttr  = is<DynamicAttr>('dynamic-attr');\n  export const isYield        = is<Yield>('yield');\n  export const isDynamicArg   = is<DynamicArg>('dynamic-arg');\n  export const isStaticArg    = is<StaticArg>('static-arg');\n  export const isTrustingAttr = is<TrustingAttr>('trusting-attr');\n\n  export type Statement =\n      Text\n    | Append\n    | Comment\n    | Modifier\n    | Block\n    | OpenElement\n    | FlushElement\n    | CloseElement\n    | StaticAttr\n    | DynamicAttr\n    | Yield\n    | StaticArg\n    | DynamicArg\n    | TrustingAttr\n    ;\n}\n\nexport type Statement = Statements.Statement;\n\n/**\n * A JSON object of static compile time meta for the template.\n */\nexport interface TemplateMeta {\n  moduleName?: string;\n}\n\n/**\n * A JSON object that the Block was serialized into.\n */\nexport interface SerializedBlock {\n  statements: Statements.Statement[];\n  locals: string[];\n}\n\n/**\n * A JSON object that the compiled TemplateBlock was serialized into.\n */\nexport interface SerializedTemplateBlock extends SerializedBlock {\n  named: string[];\n  yields: string[];\n  blocks: SerializedBlock[];\n}\n\n/**\n * A JSON object that the compiled Template was serialized into.\n */\nexport interface SerializedTemplate<T extends TemplateMeta> {\n  block: SerializedTemplateBlock;\n  meta: T;\n}\n\n/**\n * A string of JSON containing a SerializedTemplateBlock\n * @typedef {string} SerializedTemplateBlockJSON\n */\nexport type SerializedTemplateBlockJSON = string;\n\n/**\n * A JSON object containing the SerializedTemplateBlock as JSON and TemplateMeta.\n */\nexport interface SerializedTemplateWithLazyBlock<T extends TemplateMeta> {\n  id?: string;\n  block: SerializedTemplateBlockJSON;\n  meta: T;\n}\n\n/**\n * A string of Javascript containing a SerializedTemplateWithLazyBlock to be\n * concatenated into a Javascript module.\n * @typedef {string} TemplateJavascript\n */\nexport type TemplateJavascript = string;\n"]} enifed('handlebars/compiler/ast', ['exports'], function (exports) { 'use strict'; var AST = { Program: function (statements, blockParams, strip, locInfo) {