<--------------- currentCursor.element\n * \n *
<--------------- currentCursor.candidate -> cursor.element\n * <- currentCursor.candidate.firstChild -> cursor.candidate\n * Foo\n * \n *
\n * <-- becomes currentCursor.candidate\n */\n // where to rehydrate from if we are in rehydration mode\n cursor.candidate = element.firstChild;\n // where to continue when we pop\n currentCursor.candidate = element.nextSibling;\n }\n }\n this.cursorStack.push(cursor);\n };\n\n RehydrateBuilder.prototype.clearMismatch = function clearMismatch(candidate) {\n var current = candidate;\n var currentCursor = this.currentCursor;\n if (currentCursor !== null) {\n var openBlockDepth = currentCursor.openBlockDepth;\n if (openBlockDepth >= currentCursor.startingBlockDepth) {\n while (current && !(isComment(current) && getCloseBlockDepth(current) === openBlockDepth)) {\n current = this.remove(current);\n }\n } else {\n while (current !== null) {\n current = this.remove(current);\n }\n }\n // current cursor parentNode should be openCandidate if element\n // or openCandidate.parentNode if comment\n currentCursor.nextSibling = current;\n // disable rehydration until we popElement or closeBlock for openBlockDepth\n currentCursor.candidate = null;\n }\n };\n\n RehydrateBuilder.prototype.__openBlock = function __openBlock() {\n var currentCursor = this.currentCursor;\n\n if (currentCursor === null) return;\n var blockDepth = this.blockDepth;\n this.blockDepth++;\n var candidate = currentCursor.candidate;\n\n if (candidate === null) return;\n if (isComment(candidate) && getOpenBlockDepth(candidate) === blockDepth) {\n currentCursor.candidate = this.remove(candidate);\n currentCursor.openBlockDepth = blockDepth;\n } else {\n this.clearMismatch(candidate);\n }\n };\n\n RehydrateBuilder.prototype.__closeBlock = function __closeBlock() {\n var currentCursor = this.currentCursor;\n\n if (currentCursor === null) return;\n // openBlock is the last rehydrated open block\n var openBlockDepth = currentCursor.openBlockDepth;\n // this currently is the expected next open block depth\n this.blockDepth--;\n var candidate = currentCursor.candidate;\n // rehydrating\n\n if (candidate !== null) {\n\n if (isComment(candidate) && getCloseBlockDepth(candidate) === openBlockDepth) {\n currentCursor.candidate = this.remove(candidate);\n currentCursor.openBlockDepth--;\n } else {\n this.clearMismatch(candidate);\n }\n // if the openBlockDepth matches the blockDepth we just closed to\n // then restore rehydration\n }\n if (currentCursor.openBlockDepth === this.blockDepth) {\n\n currentCursor.candidate = this.remove(currentCursor.nextSibling);\n currentCursor.openBlockDepth--;\n }\n };\n\n RehydrateBuilder.prototype.__appendNode = function __appendNode(node) {\n var candidate = this.candidate;\n // This code path is only used when inserting precisely one node. It needs more\n // comparison logic, but we can probably lean on the cases where this code path\n // is actually used.\n\n if (candidate) {\n return candidate;\n } else {\n return _NewElementBuilder.prototype.__appendNode.call(this, node);\n }\n };\n\n RehydrateBuilder.prototype.__appendHTML = function __appendHTML(html) {\n var candidateBounds = this.markerBounds();\n if (candidateBounds) {\n var first = candidateBounds.firstNode();\n var last = candidateBounds.lastNode();\n var newBounds = bounds(this.element, first.nextSibling, last.previousSibling);\n var possibleEmptyMarker = this.remove(first);\n this.remove(last);\n if (possibleEmptyMarker !== null && isEmpty$1(possibleEmptyMarker)) {\n this.candidate = this.remove(possibleEmptyMarker);\n if (this.candidate !== null) {\n this.clearMismatch(this.candidate);\n }\n }\n return newBounds;\n } else {\n return _NewElementBuilder.prototype.__appendHTML.call(this, html);\n }\n };\n\n RehydrateBuilder.prototype.remove = function remove(node) {\n var element = node.parentNode;\n var next = node.nextSibling;\n element.removeChild(node);\n return next;\n };\n\n RehydrateBuilder.prototype.markerBounds = function markerBounds() {\n var _candidate = this.candidate;\n if (_candidate && isMarker(_candidate)) {\n var first = _candidate;\n var last = first.nextSibling;\n while (last && !isMarker(last)) {\n last = last.nextSibling;\n }\n return bounds(this.element, first, last);\n } else {\n return null;\n }\n };\n\n RehydrateBuilder.prototype.__appendText = function __appendText(string) {\n var candidate = this.candidate;\n\n if (candidate) {\n if (isTextNode(candidate)) {\n if (candidate.nodeValue !== string) {\n candidate.nodeValue = string;\n }\n this.candidate = candidate.nextSibling;\n return candidate;\n } else if (candidate && (isSeparator(candidate) || isEmpty$1(candidate))) {\n this.candidate = candidate.nextSibling;\n this.remove(candidate);\n return this.__appendText(string);\n } else if (isEmpty$1(candidate)) {\n var next = this.remove(candidate);\n this.candidate = next;\n var text = this.dom.createTextNode(string);\n this.dom.insertBefore(this.element, text, next);\n return text;\n } else {\n this.clearMismatch(candidate);\n return _NewElementBuilder.prototype.__appendText.call(this, string);\n }\n } else {\n return _NewElementBuilder.prototype.__appendText.call(this, string);\n }\n };\n\n RehydrateBuilder.prototype.__appendComment = function __appendComment(string) {\n var _candidate = this.candidate;\n if (_candidate && isComment(_candidate)) {\n if (_candidate.nodeValue !== string) {\n _candidate.nodeValue = string;\n }\n this.candidate = _candidate.nextSibling;\n return _candidate;\n } else if (_candidate) {\n this.clearMismatch(_candidate);\n }\n return _NewElementBuilder.prototype.__appendComment.call(this, string);\n };\n\n RehydrateBuilder.prototype.__openElement = function __openElement(tag) {\n var _candidate = this.candidate;\n if (_candidate && isElement(_candidate) && isSameNodeType(_candidate, tag)) {\n this.unmatchedAttributes = [].slice.call(_candidate.attributes);\n return _candidate;\n } else if (_candidate) {\n if (isElement(_candidate) && _candidate.tagName === 'TBODY') {\n this.pushElement(_candidate, null);\n this.currentCursor.injectedOmittedNode = true;\n return this.__openElement(tag);\n }\n this.clearMismatch(_candidate);\n }\n return _NewElementBuilder.prototype.__openElement.call(this, tag);\n };\n\n RehydrateBuilder.prototype.__setAttribute = function __setAttribute(name, value, namespace) {\n var unmatched = this.unmatchedAttributes;\n if (unmatched) {\n var attr = findByName(unmatched, name);\n if (attr) {\n if (attr.value !== value) {\n attr.value = value;\n }\n unmatched.splice(unmatched.indexOf(attr), 1);\n return;\n }\n }\n return _NewElementBuilder.prototype.__setAttribute.call(this, name, value, namespace);\n };\n\n RehydrateBuilder.prototype.__setProperty = function __setProperty(name, value) {\n var unmatched = this.unmatchedAttributes;\n if (unmatched) {\n var attr = findByName(unmatched, name);\n if (attr) {\n if (attr.value !== value) {\n attr.value = value;\n }\n unmatched.splice(unmatched.indexOf(attr), 1);\n return;\n }\n }\n return _NewElementBuilder.prototype.__setProperty.call(this, name, value);\n };\n\n RehydrateBuilder.prototype.__flushElement = function __flushElement(parent, constructing) {\n var unmatched = this.unmatchedAttributes;\n\n if (unmatched) {\n for (var i = 0; i < unmatched.length; i++) {\n this.constructing.removeAttribute(unmatched[i].name);\n }\n this.unmatchedAttributes = null;\n } else {\n _NewElementBuilder.prototype.__flushElement.call(this, parent, constructing);\n }\n };\n\n RehydrateBuilder.prototype.willCloseElement = function willCloseElement() {\n var candidate = this.candidate,\n currentCursor = this.currentCursor;\n\n if (candidate !== null) {\n this.clearMismatch(candidate);\n }\n if (currentCursor && currentCursor.injectedOmittedNode) {\n this.popElement();\n }\n _NewElementBuilder.prototype.willCloseElement.call(this);\n };\n\n RehydrateBuilder.prototype.getMarker = function getMarker(element, guid) {\n var marker = element.querySelector('script[glmr=\"' + guid + '\"]');\n if (marker) {\n return marker;\n }\n throw new Error('Cannot find serialized cursor for `in-element`');\n };\n\n RehydrateBuilder.prototype.__pushRemoteElement = function __pushRemoteElement(element, cursorId) {\n var nextSibling = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n var marker = this.getMarker(element, cursorId);\n if (marker.parentNode === element) {\n var currentCursor = this.currentCursor;\n var candidate = currentCursor.candidate;\n this.pushElement(element, nextSibling);\n currentCursor.candidate = candidate;\n this.candidate = this.remove(marker);\n var tracker = new RemoteBlockTracker(element);\n this.pushBlockTracker(tracker, true);\n }\n };\n\n RehydrateBuilder.prototype.didAppendBounds = function didAppendBounds(bounds$$1) {\n _NewElementBuilder.prototype.didAppendBounds.call(this, bounds$$1);\n if (this.candidate) {\n var last = bounds$$1.lastNode();\n this.candidate = last && last.nextSibling;\n }\n return bounds$$1;\n };\n\n (0, _emberBabel.createClass)(RehydrateBuilder, [{\n key: 'currentCursor',\n get: function () {\n return this.cursorStack.current;\n }\n }, {\n key: 'candidate',\n get: function () {\n if (this.currentCursor) {\n return this.currentCursor.candidate;\n }\n return null;\n },\n set: function (node) {\n this.currentCursor.candidate = node;\n }\n }]);\n\n return RehydrateBuilder;\n }(NewElementBuilder);\n\n function isTextNode(node) {\n return node.nodeType === 3;\n }\n function isComment(node) {\n return node.nodeType === 8;\n }\n function getOpenBlockDepth(node) {\n var boundsDepth = node.nodeValue.match(/^%\\+b:(\\d+)%$/);\n if (boundsDepth && boundsDepth[1]) {\n return Number(boundsDepth[1]);\n } else {\n return null;\n }\n }\n function getCloseBlockDepth(node) {\n var boundsDepth = node.nodeValue.match(/^%\\-b:(\\d+)%$/);\n if (boundsDepth && boundsDepth[1]) {\n return Number(boundsDepth[1]);\n } else {\n return null;\n }\n }\n function isElement(node) {\n return node.nodeType === 1;\n }\n function isMarker(node) {\n return node.nodeType === 8 && node.nodeValue === '%glmr%';\n }\n function isSeparator(node) {\n return node.nodeType === 8 && node.nodeValue === '%|%';\n }\n function isEmpty$1(node) {\n return node.nodeType === 8 && node.nodeValue === '% %';\n }\n function isSameNodeType(candidate, tag) {\n if (candidate.namespaceURI === SVG_NAMESPACE$1) {\n return candidate.tagName === tag;\n }\n return candidate.tagName === tag.toUpperCase();\n }\n function findByName(array, name) {\n for (var i = 0; i < array.length; i++) {\n var attr = array[i];\n if (attr.name === name) return attr;\n }\n return undefined;\n }\n function rehydrationBuilder(env, cursor) {\n return RehydrateBuilder.forInitialRender(env, cursor);\n }\n\n exports.renderMain = render;\n exports.NULL_REFERENCE = NULL_REFERENCE;\n exports.UNDEFINED_REFERENCE = UNDEFINED_REFERENCE;\n exports.PrimitiveReference = PrimitiveReference;\n exports.ConditionalReference = ConditionalReference;\n exports.setDebuggerCallback = setDebuggerCallback;\n exports.resetDebuggerCallback = resetDebuggerCallback;\n exports.getDynamicVar = getDynamicVar;\n exports.LowLevelVM = VM;\n exports.UpdatingVM = UpdatingVM;\n exports.RenderResult = RenderResult;\n exports.SimpleDynamicAttribute = SimpleDynamicAttribute;\n exports.DynamicAttribute = DynamicAttribute;\n exports.EMPTY_ARGS = EMPTY_ARGS;\n exports.Scope = Scope;\n exports.Environment = Environment;\n exports.DefaultEnvironment = DefaultEnvironment;\n exports.DEFAULT_CAPABILITIES = DEFAULT_CAPABILITIES;\n exports.MINIMAL_CAPABILITIES = MINIMAL_CAPABILITIES;\n exports.CurriedComponentDefinition = CurriedComponentDefinition;\n exports.isCurriedComponentDefinition = isCurriedComponentDefinition;\n exports.curry = curry;\n exports.DOMChanges = helper$1;\n exports.SVG_NAMESPACE = SVG_NAMESPACE$1;\n exports.IDOMChanges = DOMChanges;\n exports.DOMTreeConstruction = DOMTreeConstruction;\n exports.isWhitespace = isWhitespace;\n exports.insertHTMLBefore = _insertHTMLBefore;\n exports.normalizeProperty = normalizeProperty;\n exports.NewElementBuilder = NewElementBuilder;\n exports.clientBuilder = clientBuilder;\n exports.rehydrationBuilder = rehydrationBuilder;\n exports.RehydrateBuilder = RehydrateBuilder;\n exports.ConcreteBounds = ConcreteBounds;\n exports.Cursor = Cursor;\n exports.capabilityFlagsFrom = capabilityFlagsFrom;\n exports.hasCapability = hasCapability;\n});","enifed('@glimmer/util', ['exports', 'ember-babel'], function (exports, _emberBabel) {\n 'use strict';\n\n exports.unreachable = exports.expect = exports.unwrap = exports.EMPTY_ARRAY = exports.ListSlice = exports.ListNode = exports.LinkedList = exports.EMPTY_SLICE = exports.dict = exports.DictSet = exports.Stack = exports.SERIALIZATION_FIRST_NODE_STRING = exports.isSerializationFirstNode = exports.initializeGuid = exports.ensureGuid = exports.fillNulls = exports.assign = exports.assert = undefined;\n\n\n function unwrap(val) {\n if (val === null || val === undefined) throw new Error('Expected value to be present');\n return val;\n }\n function expect(val, message) {\n if (val === null || val === undefined) throw new Error(message);\n return val;\n }\n function unreachable() {\n var message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'unreachable';\n\n return new Error(message);\n }\n\n // import Logger from './logger';\n // let alreadyWarned = false;\n function debugAssert(test, msg) {\n // if (!alreadyWarned) {\n // alreadyWarned = true;\n // Logger.warn(\"Don't leave debug assertions on in public builds\");\n // }\n if (!test) {\n throw new Error(msg || 'assertion failure');\n }\n }\n\n var objKeys = Object.keys;\n\n function assign(obj) {\n for (var i = 1; i < arguments.length; i++) {\n var assignment = arguments[i];\n if (assignment === null || typeof assignment !== 'object') continue;\n var keys = objKeys(assignment);\n for (var j = 0; j < keys.length; j++) {\n var key = keys[j];\n obj[key] = assignment[key];\n }\n }\n return obj;\n }\n function fillNulls(count) {\n var arr = new Array(count);\n for (var i = 0; i < count; i++) {\n arr[i] = null;\n }\n return arr;\n }\n\n var GUID = 0;\n function initializeGuid(object) {\n return object._guid = ++GUID;\n }\n function ensureGuid(object) {\n return object._guid || initializeGuid(object);\n }\n\n var SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';\n function isSerializationFirstNode(node) {\n return node.nodeValue === SERIALIZATION_FIRST_NODE_STRING;\n }\n\n function dict() {\n return Object.create(null);\n }\n\n var DictSet = function () {\n function DictSet() {\n\n this.dict = dict();\n }\n\n DictSet.prototype.add = function add(obj) {\n if (typeof obj === 'string') this.dict[obj] = obj;else this.dict[ensureGuid(obj)] = obj;\n return this;\n };\n\n DictSet.prototype.delete = function _delete(obj) {\n if (typeof obj === 'string') delete this.dict[obj];else if (obj._guid) delete this.dict[obj._guid];\n };\n\n return DictSet;\n }();\n\n var Stack = function () {\n function Stack() {\n\n this.stack = [];\n this.current = null;\n }\n\n Stack.prototype.push = function push(item) {\n this.current = item;\n this.stack.push(item);\n };\n\n Stack.prototype.pop = function pop() {\n var item = this.stack.pop();\n var len = this.stack.length;\n this.current = len === 0 ? null : this.stack[len - 1];\n return item === undefined ? null : item;\n };\n\n Stack.prototype.isEmpty = function isEmpty() {\n return this.stack.length === 0;\n };\n\n (0, _emberBabel.createClass)(Stack, [{\n key: 'size',\n get: function () {\n return this.stack.length;\n }\n }]);\n\n return Stack;\n }();\n\n var ListNode = function ListNode(value) {\n\n this.next = null;\n this.prev = null;\n this.value = value;\n };\n\n var LinkedList = function () {\n function LinkedList() {\n\n this.clear();\n }\n\n LinkedList.prototype.head = function head() {\n return this._head;\n };\n\n LinkedList.prototype.tail = function tail() {\n return this._tail;\n };\n\n LinkedList.prototype.clear = function clear() {\n this._head = this._tail = null;\n };\n\n LinkedList.prototype.toArray = function toArray() {\n var out = [];\n this.forEachNode(function (n) {\n return out.push(n);\n });\n return out;\n };\n\n LinkedList.prototype.nextNode = function nextNode(node) {\n return node.next;\n };\n\n LinkedList.prototype.forEachNode = function forEachNode(callback) {\n var node = this._head;\n while (node !== null) {\n callback(node);\n node = node.next;\n }\n };\n\n LinkedList.prototype.insertBefore = function insertBefore(node) {\n var reference = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n\n if (reference === null) return this.append(node);\n if (reference.prev) reference.prev.next = node;else this._head = node;\n node.prev = reference.prev;\n node.next = reference;\n reference.prev = node;\n return node;\n };\n\n LinkedList.prototype.append = function append(node) {\n var tail = this._tail;\n if (tail) {\n tail.next = node;\n node.prev = tail;\n node.next = null;\n } else {\n this._head = node;\n }\n return this._tail = node;\n };\n\n LinkedList.prototype.remove = function remove(node) {\n if (node.prev) node.prev.next = node.next;else this._head = node.next;\n if (node.next) node.next.prev = node.prev;else this._tail = node.prev;\n return node;\n };\n\n return LinkedList;\n }();\n\n var ListSlice = function () {\n function ListSlice(head, tail) {\n\n this._head = head;\n this._tail = tail;\n }\n\n ListSlice.prototype.forEachNode = function forEachNode(callback) {\n var node = this._head;\n while (node !== null) {\n callback(node);\n node = this.nextNode(node);\n }\n };\n\n ListSlice.prototype.head = function head() {\n return this._head;\n };\n\n ListSlice.prototype.tail = function tail() {\n return this._tail;\n };\n\n ListSlice.prototype.toArray = function toArray() {\n var out = [];\n this.forEachNode(function (n) {\n return out.push(n);\n });\n return out;\n };\n\n ListSlice.prototype.nextNode = function nextNode(node) {\n if (node === this._tail) return null;\n return node.next;\n };\n\n return ListSlice;\n }();\n\n var EMPTY_SLICE = new ListSlice(null, null);\n\n var EMPTY_ARRAY = Object.freeze([]);\n\n exports.assert = debugAssert;\n exports.assign = assign;\n exports.fillNulls = fillNulls;\n exports.ensureGuid = ensureGuid;\n exports.initializeGuid = initializeGuid;\n exports.isSerializationFirstNode = isSerializationFirstNode;\n exports.SERIALIZATION_FIRST_NODE_STRING = SERIALIZATION_FIRST_NODE_STRING;\n exports.Stack = Stack;\n exports.DictSet = DictSet;\n exports.dict = dict;\n exports.EMPTY_SLICE = EMPTY_SLICE;\n exports.LinkedList = LinkedList;\n exports.ListNode = ListNode;\n exports.ListSlice = ListSlice;\n exports.EMPTY_ARRAY = EMPTY_ARRAY;\n exports.unwrap = unwrap;\n exports.expect = expect;\n exports.unreachable = unreachable;\n});","enifed(\"@glimmer/vm\", [\"exports\"], function (exports) {\n \"use strict\";\n\n /**\n * Registers\n *\n * For the most part, these follows MIPS naming conventions, however the\n * register numbers are different.\n */\n var Register;\n (function (Register) {\n // $0 or $pc (program counter): pointer into `program` for the next insturction; -1 means exit\n Register[Register[\"pc\"] = 0] = \"pc\";\n // $1 or $ra (return address): pointer into `program` for the return\n Register[Register[\"ra\"] = 1] = \"ra\";\n // $2 or $fp (frame pointer): pointer into the `evalStack` for the base of the stack\n Register[Register[\"fp\"] = 2] = \"fp\";\n // $3 or $sp (stack pointer): pointer into the `evalStack` for the top of the stack\n Register[Register[\"sp\"] = 3] = \"sp\";\n // $4-$5 or $s0-$s1 (saved): callee saved general-purpose registers\n Register[Register[\"s0\"] = 4] = \"s0\";\n Register[Register[\"s1\"] = 5] = \"s1\";\n // $6-$7 or $t0-$t1 (temporaries): caller saved general-purpose registers\n Register[Register[\"t0\"] = 6] = \"t0\";\n Register[Register[\"t1\"] = 7] = \"t1\";\n // $8 or $v0 (return value)\n Register[Register[\"v0\"] = 8] = \"v0\";\n })(Register || (exports.Register = Register = {}));\n\n exports.Register = Register;\n});","enifed(\"@glimmer/wire-format\", [\"exports\"], function (exports) {\n \"use strict\";\n\n var Opcodes;\n (function (Opcodes) {\n // Statements\n Opcodes[Opcodes[\"Text\"] = 0] = \"Text\";\n Opcodes[Opcodes[\"Append\"] = 1] = \"Append\";\n Opcodes[Opcodes[\"Comment\"] = 2] = \"Comment\";\n Opcodes[Opcodes[\"Modifier\"] = 3] = \"Modifier\";\n Opcodes[Opcodes[\"Block\"] = 4] = \"Block\";\n Opcodes[Opcodes[\"Component\"] = 5] = \"Component\";\n Opcodes[Opcodes[\"DynamicComponent\"] = 6] = \"DynamicComponent\";\n Opcodes[Opcodes[\"OpenElement\"] = 7] = \"OpenElement\";\n Opcodes[Opcodes[\"OpenSplattedElement\"] = 8] = \"OpenSplattedElement\";\n Opcodes[Opcodes[\"FlushElement\"] = 9] = \"FlushElement\";\n Opcodes[Opcodes[\"CloseElement\"] = 10] = \"CloseElement\";\n Opcodes[Opcodes[\"StaticAttr\"] = 11] = \"StaticAttr\";\n Opcodes[Opcodes[\"DynamicAttr\"] = 12] = \"DynamicAttr\";\n Opcodes[Opcodes[\"AttrSplat\"] = 13] = \"AttrSplat\";\n Opcodes[Opcodes[\"Yield\"] = 14] = \"Yield\";\n Opcodes[Opcodes[\"Partial\"] = 15] = \"Partial\";\n Opcodes[Opcodes[\"DynamicArg\"] = 16] = \"DynamicArg\";\n Opcodes[Opcodes[\"StaticArg\"] = 17] = \"StaticArg\";\n Opcodes[Opcodes[\"TrustingAttr\"] = 18] = \"TrustingAttr\";\n Opcodes[Opcodes[\"Debugger\"] = 19] = \"Debugger\";\n Opcodes[Opcodes[\"ClientSideStatement\"] = 20] = \"ClientSideStatement\";\n // Expressions\n Opcodes[Opcodes[\"Unknown\"] = 21] = \"Unknown\";\n Opcodes[Opcodes[\"Get\"] = 22] = \"Get\";\n Opcodes[Opcodes[\"MaybeLocal\"] = 23] = \"MaybeLocal\";\n Opcodes[Opcodes[\"HasBlock\"] = 24] = \"HasBlock\";\n Opcodes[Opcodes[\"HasBlockParams\"] = 25] = \"HasBlockParams\";\n Opcodes[Opcodes[\"Undefined\"] = 26] = \"Undefined\";\n Opcodes[Opcodes[\"Helper\"] = 27] = \"Helper\";\n Opcodes[Opcodes[\"Concat\"] = 28] = \"Concat\";\n Opcodes[Opcodes[\"ClientSideExpression\"] = 29] = \"ClientSideExpression\";\n })(Opcodes || (exports.Ops = Opcodes = {}));\n\n function is(variant) {\n return function (value) {\n return Array.isArray(value) && value[0] === variant;\n };\n }\n // Statements\n var isFlushElement = is(Opcodes.FlushElement);\n var isAttrSplat = is(Opcodes.AttrSplat);\n function isAttribute(val) {\n return val[0] === Opcodes.StaticAttr || val[0] === Opcodes.DynamicAttr || val[0] === Opcodes.TrustingAttr;\n }\n function isArgument(val) {\n return val[0] === Opcodes.StaticArg || val[0] === Opcodes.DynamicArg;\n }\n // Expressions\n var isGet = is(Opcodes.Get);\n var isMaybeLocal = is(Opcodes.MaybeLocal);\n\n exports.is = is;\n exports.isFlushElement = isFlushElement;\n exports.isAttrSplat = isAttrSplat;\n exports.isAttribute = isAttribute;\n exports.isArgument = isArgument;\n exports.isGet = isGet;\n exports.isMaybeLocal = isMaybeLocal;\n exports.Ops = Opcodes;\n});","enifed('backburner', ['exports', 'ember-babel'], function (exports, _emberBabel) {\n 'use strict';\n\n exports.buildPlatform = undefined;\n\n\n var SET_TIMEOUT = setTimeout;\n var NOOP = function () {};\n function buildPlatform(flush) {\n var next = void 0;\n var clearNext = NOOP;\n if (typeof MutationObserver === 'function') {\n var iterations = 0;\n var observer = new MutationObserver(flush);\n var node = document.createTextNode('');\n observer.observe(node, { characterData: true });\n next = function () {\n iterations = ++iterations % 2;\n node.data = '' + iterations;\n return iterations;\n };\n } else if (typeof Promise === 'function') {\n var autorunPromise = Promise.resolve();\n next = function () {\n return autorunPromise.then(flush);\n };\n } else {\n next = function () {\n return SET_TIMEOUT(flush, 0);\n };\n }\n return {\n setTimeout: function (fn, ms) {\n return setTimeout(fn, ms);\n },\n clearTimeout: function (timerId) {\n return clearTimeout(timerId);\n },\n now: function () {\n return Date.now();\n },\n\n next: next,\n clearNext: clearNext\n };\n }\n\n var NUMBER = /\\d+/;\n var TIMERS_OFFSET = 6;\n function isCoercableNumber(suspect) {\n var type = typeof suspect;\n return type === 'number' && suspect === suspect || type === 'string' && NUMBER.test(suspect);\n }\n function getOnError(options) {\n return options.onError || options.onErrorTarget && options.onErrorTarget[options.onErrorMethod];\n }\n function findItem(target, method, collection) {\n var index = -1;\n for (var i = 0, l = collection.length; i < l; i += 4) {\n if (collection[i] === target && collection[i + 1] === method) {\n index = i;\n break;\n }\n }\n return index;\n }\n function findTimerItem(target, method, collection) {\n var index = -1;\n for (var i = 2, l = collection.length; i < l; i += 6) {\n if (collection[i] === target && collection[i + 1] === method) {\n index = i - 2;\n break;\n }\n }\n return index;\n }\n function getQueueItems(items, queueItemLength) {\n var queueItemPositionOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n\n var queueItems = [];\n for (var i = 0; i < items.length; i += queueItemLength) {\n var maybeError = items[i + 3 /* stack */ + queueItemPositionOffset];\n var queueItem = {\n target: items[i + 0 /* target */ + queueItemPositionOffset],\n method: items[i + 1 /* method */ + queueItemPositionOffset],\n args: items[i + 2 /* args */ + queueItemPositionOffset],\n stack: maybeError !== undefined && 'stack' in maybeError ? maybeError.stack : ''\n };\n queueItems.push(queueItem);\n }\n return queueItems;\n }\n\n function binarySearch(time, timers) {\n var start = 0;\n var end = timers.length - TIMERS_OFFSET;\n var middle = void 0;\n var l = void 0;\n while (start < end) {\n // since timers is an array of pairs 'l' will always\n // be an integer\n l = (end - start) / TIMERS_OFFSET;\n // compensate for the index in case even number\n // of pairs inside timers\n middle = start + l - l % TIMERS_OFFSET;\n if (time >= timers[middle]) {\n start = middle + TIMERS_OFFSET;\n } else {\n end = middle;\n }\n }\n return time >= timers[start] ? start + TIMERS_OFFSET : start;\n }\n\n var QUEUE_ITEM_LENGTH = 4;\n\n var Queue = function () {\n function Queue(name) {\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n var globalOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n this._queueBeingFlushed = [];\n this.targetQueues = new Map();\n this.index = 0;\n this._queue = [];\n this.name = name;\n this.options = options;\n this.globalOptions = globalOptions;\n }\n\n Queue.prototype.stackFor = function stackFor(index) {\n if (index < this._queue.length) {\n var entry = this._queue[index * 3 + QUEUE_ITEM_LENGTH];\n if (entry) {\n return entry.stack;\n } else {\n return null;\n }\n }\n };\n\n Queue.prototype.flush = function flush(sync) {\n var _options = this.options,\n before = _options.before,\n after = _options.after;\n\n var target = void 0;\n var method = void 0;\n var args = void 0;\n var errorRecordedForStack = void 0;\n this.targetQueues.clear();\n if (this._queueBeingFlushed.length === 0) {\n this._queueBeingFlushed = this._queue;\n this._queue = [];\n }\n if (before !== undefined) {\n before();\n }\n var invoke = void 0;\n var queueItems = this._queueBeingFlushed;\n if (queueItems.length > 0) {\n var onError = getOnError(this.globalOptions);\n invoke = onError ? this.invokeWithOnError : this.invoke;\n for (var i = this.index; i < queueItems.length; i += QUEUE_ITEM_LENGTH) {\n this.index += QUEUE_ITEM_LENGTH;\n method = queueItems[i + 1];\n // method could have been nullified / canceled during flush\n if (method !== null) {\n //\n // ** Attention intrepid developer **\n //\n // To find out the stack of this task when it was scheduled onto\n // the run loop, add the following to your app.js:\n //\n // Ember.run.backburner.DEBUG = true; // NOTE: This slows your app, don't leave it on in production.\n //\n // Once that is in place, when you are at a breakpoint and navigate\n // here in the stack explorer, you can look at `errorRecordedForStack.stack`,\n // which will be the captured stack when this job was scheduled.\n //\n // One possible long-term solution is the following Chrome issue:\n // https://bugs.chromium.org/p/chromium/issues/detail?id=332624\n //\n target = queueItems[i];\n args = queueItems[i + 2];\n errorRecordedForStack = queueItems[i + 3]; // Debugging assistance\n invoke(target, method, args, onError, errorRecordedForStack);\n }\n if (this.index !== this._queueBeingFlushed.length && this.globalOptions.mustYield && this.globalOptions.mustYield()) {\n return 1 /* Pause */;\n }\n }\n }\n if (after !== undefined) {\n after();\n }\n this._queueBeingFlushed.length = 0;\n this.index = 0;\n if (sync !== false && this._queue.length > 0) {\n // check if new items have been added\n this.flush(true);\n }\n };\n\n Queue.prototype.hasWork = function hasWork() {\n return this._queueBeingFlushed.length > 0 || this._queue.length > 0;\n };\n\n Queue.prototype.cancel = function cancel(_ref) {\n var target = _ref.target,\n method = _ref.method;\n\n var queue = this._queue;\n var targetQueueMap = this.targetQueues.get(target);\n if (targetQueueMap !== undefined) {\n targetQueueMap.delete(method);\n }\n var index = findItem(target, method, queue);\n if (index > -1) {\n queue.splice(index, QUEUE_ITEM_LENGTH);\n return true;\n }\n // if not found in current queue\n // could be in the queue that is being flushed\n queue = this._queueBeingFlushed;\n index = findItem(target, method, queue);\n if (index > -1) {\n queue[index + 1] = null;\n return true;\n }\n return false;\n };\n\n Queue.prototype.push = function push(target, method, args, stack) {\n this._queue.push(target, method, args, stack);\n return {\n queue: this,\n target: target,\n method: method\n };\n };\n\n Queue.prototype.pushUnique = function pushUnique(target, method, args, stack) {\n var localQueueMap = this.targetQueues.get(target);\n if (localQueueMap === undefined) {\n localQueueMap = new Map();\n this.targetQueues.set(target, localQueueMap);\n }\n var index = localQueueMap.get(method);\n if (index === undefined) {\n var queueIndex = this._queue.push(target, method, args, stack) - QUEUE_ITEM_LENGTH;\n localQueueMap.set(method, queueIndex);\n } else {\n var queue = this._queue;\n queue[index + 2] = args; // replace args\n queue[index + 3] = stack; // replace stack\n }\n return {\n queue: this,\n target: target,\n method: method\n };\n };\n\n Queue.prototype._getDebugInfo = function _getDebugInfo(debugEnabled) {\n if (debugEnabled) {\n var debugInfo = getQueueItems(this._queue, QUEUE_ITEM_LENGTH);\n return debugInfo;\n }\n return undefined;\n };\n\n Queue.prototype.invoke = function invoke(target, method, args /*, onError, errorRecordedForStack */) {\n if (args === undefined) {\n method.call(target);\n } else {\n method.apply(target, args);\n }\n };\n\n Queue.prototype.invokeWithOnError = function invokeWithOnError(target, method, args, onError, errorRecordedForStack) {\n try {\n if (args === undefined) {\n method.call(target);\n } else {\n method.apply(target, args);\n }\n } catch (error) {\n onError(error, errorRecordedForStack);\n }\n };\n\n return Queue;\n }();\n\n var DeferredActionQueues = function () {\n function DeferredActionQueues() {\n var queueNames = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n var options = arguments[1];\n\n this.queues = {};\n this.queueNameIndex = 0;\n this.queueNames = queueNames;\n queueNames.reduce(function (queues, queueName) {\n queues[queueName] = new Queue(queueName, options[queueName], options);\n return queues;\n }, this.queues);\n }\n /**\n * @method schedule\n * @param {String} queueName\n * @param {Any} target\n * @param {Any} method\n * @param {Any} args\n * @param {Boolean} onceFlag\n * @param {Any} stack\n * @return queue\n */\n\n DeferredActionQueues.prototype.schedule = function schedule(queueName, target, method, args, onceFlag, stack) {\n var queues = this.queues;\n var queue = queues[queueName];\n if (queue === undefined) {\n throw new Error('You attempted to schedule an action in a queue (' + queueName + ') that doesn\\'t exist');\n }\n if (method === undefined || method === null) {\n throw new Error('You attempted to schedule an action in a queue (' + queueName + ') for a method that doesn\\'t exist');\n }\n this.queueNameIndex = 0;\n if (onceFlag) {\n return queue.pushUnique(target, method, args, stack);\n } else {\n return queue.push(target, method, args, stack);\n }\n };\n /**\n * DeferredActionQueues.flush() calls Queue.flush()\n *\n * @method flush\n * @param {Boolean} fromAutorun\n */\n\n DeferredActionQueues.prototype.flush = function flush() {\n var fromAutorun = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n var queue = void 0;\n var queueName = void 0;\n var numberOfQueues = this.queueNames.length;\n while (this.queueNameIndex < numberOfQueues) {\n queueName = this.queueNames[this.queueNameIndex];\n queue = this.queues[queueName];\n if (queue.hasWork() === false) {\n this.queueNameIndex++;\n if (fromAutorun && this.queueNameIndex < numberOfQueues) {\n return 1 /* Pause */;\n }\n } else {\n if (queue.flush(false /* async */) === 1 /* Pause */) {\n return 1 /* Pause */;\n }\n }\n }\n };\n /**\n * Returns debug information for the current queues.\n *\n * @method _getDebugInfo\n * @param {Boolean} debugEnabled\n * @returns {IDebugInfo | undefined}\n */\n\n DeferredActionQueues.prototype._getDebugInfo = function _getDebugInfo(debugEnabled) {\n if (debugEnabled) {\n var debugInfo = {};\n var queue = void 0;\n var queueName = void 0;\n var numberOfQueues = this.queueNames.length;\n var i = 0;\n while (i < numberOfQueues) {\n queueName = this.queueNames[i];\n queue = this.queues[queueName];\n debugInfo[queueName] = queue._getDebugInfo(debugEnabled);\n i++;\n }\n return debugInfo;\n }\n return;\n };\n\n return DeferredActionQueues;\n }();\n\n function iteratorDrain(fn) {\n var iterator = fn();\n var result = iterator.next();\n while (result.done === false) {\n result.value();\n result = iterator.next();\n }\n }\n\n var noop = function () {};\n var DISABLE_SCHEDULE = Object.freeze([]);\n function parseArgs() {\n var length = arguments.length;\n var args = void 0;\n var method = void 0;\n var target = void 0;\n if (length === 0) {} else if (length === 1) {\n target = null;\n method = arguments[0];\n } else {\n var argsIndex = 2;\n var methodOrTarget = arguments[0];\n var methodOrArgs = arguments[1];\n var type = typeof methodOrArgs;\n if (type === 'function') {\n target = methodOrTarget;\n method = methodOrArgs;\n } else if (methodOrTarget !== null && type === 'string' && methodOrArgs in methodOrTarget) {\n target = methodOrTarget;\n method = target[methodOrArgs];\n } else if (typeof methodOrTarget === 'function') {\n argsIndex = 1;\n target = null;\n method = methodOrTarget;\n }\n if (length > argsIndex) {\n var len = length - argsIndex;\n args = new Array(len);\n for (var i = 0; i < len; i++) {\n args[i] = arguments[i + argsIndex];\n }\n }\n }\n return [target, method, args];\n }\n function parseTimerArgs() {\n var _parseArgs = parseArgs.apply(undefined, arguments),\n target = _parseArgs[0],\n method = _parseArgs[1],\n args = _parseArgs[2];\n\n var wait = 0;\n var length = args !== undefined ? args.length : 0;\n if (length > 0) {\n var last = args[length - 1];\n if (isCoercableNumber(last)) {\n wait = parseInt(args.pop(), 10);\n }\n }\n return [target, method, args, wait];\n }\n function parseDebounceArgs() {\n var target = void 0;\n var method = void 0;\n var isImmediate = void 0;\n var args = void 0;\n var wait = void 0;\n if (arguments.length === 2) {\n method = arguments[0];\n wait = arguments[1];\n target = null;\n } else {\n var _parseArgs2 = parseArgs.apply(undefined, arguments);\n\n target = _parseArgs2[0];\n method = _parseArgs2[1];\n args = _parseArgs2[2];\n\n if (args === undefined) {\n wait = 0;\n } else {\n wait = args.pop();\n if (!isCoercableNumber(wait)) {\n isImmediate = wait === true;\n wait = args.pop();\n }\n }\n }\n wait = parseInt(wait, 10);\n return [target, method, args, wait, isImmediate];\n }\n var UUID = 0;\n var beginCount = 0;\n var endCount = 0;\n var beginEventCount = 0;\n var endEventCount = 0;\n var runCount = 0;\n var joinCount = 0;\n var deferCount = 0;\n var scheduleCount = 0;\n var scheduleIterableCount = 0;\n var deferOnceCount = 0;\n var scheduleOnceCount = 0;\n var setTimeoutCount = 0;\n var laterCount = 0;\n var throttleCount = 0;\n var debounceCount = 0;\n var cancelTimersCount = 0;\n var cancelCount = 0;\n var autorunsCreatedCount = 0;\n var autorunsCompletedCount = 0;\n var deferredActionQueuesCreatedCount = 0;\n var nestedDeferredActionQueuesCreated = 0;\n\n var Backburner = function () {\n function Backburner(queueNames, options) {\n var _this = this;\n\n this.DEBUG = false;\n this.currentInstance = null;\n this.instanceStack = [];\n this._eventCallbacks = {\n end: [],\n begin: []\n };\n this._timerTimeoutId = null;\n this._timers = [];\n this._autorun = null;\n this._autorunStack = null;\n this.queueNames = queueNames;\n this.options = options || {};\n if (typeof this.options.defaultQueue === 'string') {\n this._defaultQueue = this.options.defaultQueue;\n } else {\n this._defaultQueue = this.queueNames[0];\n }\n this._onBegin = this.options.onBegin || noop;\n this._onEnd = this.options.onEnd || noop;\n this._boundRunExpiredTimers = this._runExpiredTimers.bind(this);\n this._boundAutorunEnd = function () {\n autorunsCompletedCount++;\n // if the autorun was already flushed, do nothing\n if (_this._autorun === null) {\n return;\n }\n _this._autorun = null;\n _this._autorunStack = null;\n _this._end(true /* fromAutorun */);\n };\n var builder = this.options._buildPlatform || buildPlatform;\n this._platform = builder(this._boundAutorunEnd);\n }\n\n /*\n @method begin\n @return instantiated class DeferredActionQueues\n */\n Backburner.prototype.begin = function begin() {\n beginCount++;\n var options = this.options;\n var previousInstance = this.currentInstance;\n var current = void 0;\n if (this._autorun !== null) {\n current = previousInstance;\n this._cancelAutorun();\n } else {\n if (previousInstance !== null) {\n nestedDeferredActionQueuesCreated++;\n this.instanceStack.push(previousInstance);\n }\n deferredActionQueuesCreatedCount++;\n current = this.currentInstance = new DeferredActionQueues(this.queueNames, options);\n beginEventCount++;\n this._trigger('begin', current, previousInstance);\n }\n this._onBegin(current, previousInstance);\n return current;\n };\n\n Backburner.prototype.end = function end() {\n endCount++;\n this._end(false);\n };\n\n Backburner.prototype.on = function on(eventName, callback) {\n if (typeof callback !== 'function') {\n throw new TypeError('Callback must be a function');\n }\n var callbacks = this._eventCallbacks[eventName];\n if (callbacks !== undefined) {\n callbacks.push(callback);\n } else {\n throw new TypeError('Cannot on() event ' + eventName + ' because it does not exist');\n }\n };\n\n Backburner.prototype.off = function off(eventName, callback) {\n var callbacks = this._eventCallbacks[eventName];\n if (!eventName || callbacks === undefined) {\n throw new TypeError('Cannot off() event ' + eventName + ' because it does not exist');\n }\n var callbackFound = false;\n if (callback) {\n for (var i = 0; i < callbacks.length; i++) {\n if (callbacks[i] === callback) {\n callbackFound = true;\n callbacks.splice(i, 1);\n i--;\n }\n }\n }\n if (!callbackFound) {\n throw new TypeError('Cannot off() callback that does not exist');\n }\n };\n\n Backburner.prototype.run = function run() {\n runCount++;\n\n var _parseArgs3 = parseArgs.apply(undefined, arguments),\n target = _parseArgs3[0],\n method = _parseArgs3[1],\n args = _parseArgs3[2];\n\n return this._run(target, method, args);\n };\n\n Backburner.prototype.join = function join() {\n joinCount++;\n\n var _parseArgs4 = parseArgs.apply(undefined, arguments),\n target = _parseArgs4[0],\n method = _parseArgs4[1],\n args = _parseArgs4[2];\n\n return this._join(target, method, args);\n };\n /**\n * @deprecated please use schedule instead.\n */\n\n Backburner.prototype.defer = function defer(queueName, target, method) {\n deferCount++;\n\n for (var _len = arguments.length, args = Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {\n args[_key - 3] = arguments[_key];\n }\n\n return this.schedule.apply(this, [queueName, target, method].concat(args));\n };\n\n Backburner.prototype.schedule = function schedule(queueName) {\n scheduleCount++;\n\n for (var _len2 = arguments.length, _args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n _args[_key2 - 1] = arguments[_key2];\n }\n\n var _parseArgs5 = parseArgs.apply(undefined, _args),\n target = _parseArgs5[0],\n method = _parseArgs5[1],\n args = _parseArgs5[2];\n\n var stack = this.DEBUG ? new Error() : undefined;\n return this._ensureInstance().schedule(queueName, target, method, args, false, stack);\n };\n /*\n Defer the passed iterable of functions to run inside the specified queue.\n @method scheduleIterable\n @param {String} queueName\n @param {Iterable} an iterable of functions to execute\n @return method result\n */\n\n Backburner.prototype.scheduleIterable = function scheduleIterable(queueName, iterable) {\n scheduleIterableCount++;\n var stack = this.DEBUG ? new Error() : undefined;\n return this._ensureInstance().schedule(queueName, null, iteratorDrain, [iterable], false, stack);\n };\n /**\n * @deprecated please use scheduleOnce instead.\n */\n\n Backburner.prototype.deferOnce = function deferOnce(queueName, target, method) {\n deferOnceCount++;\n\n for (var _len3 = arguments.length, args = Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {\n args[_key3 - 3] = arguments[_key3];\n }\n\n return this.scheduleOnce.apply(this, [queueName, target, method].concat(args));\n };\n\n Backburner.prototype.scheduleOnce = function scheduleOnce(queueName) {\n scheduleOnceCount++;\n\n for (var _len4 = arguments.length, _args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n _args[_key4 - 1] = arguments[_key4];\n }\n\n var _parseArgs6 = parseArgs.apply(undefined, _args),\n target = _parseArgs6[0],\n method = _parseArgs6[1],\n args = _parseArgs6[2];\n\n var stack = this.DEBUG ? new Error() : undefined;\n return this._ensureInstance().schedule(queueName, target, method, args, true, stack);\n };\n\n Backburner.prototype.setTimeout = function setTimeout() {\n setTimeoutCount++;\n return this.later.apply(this, arguments);\n };\n\n Backburner.prototype.later = function later() {\n laterCount++;\n\n var _parseTimerArgs = parseTimerArgs.apply(undefined, arguments),\n target = _parseTimerArgs[0],\n method = _parseTimerArgs[1],\n args = _parseTimerArgs[2],\n wait = _parseTimerArgs[3];\n\n return this._later(target, method, args, wait);\n };\n\n Backburner.prototype.throttle = function throttle() {\n throttleCount++;\n\n var _parseDebounceArgs = parseDebounceArgs.apply(undefined, arguments),\n target = _parseDebounceArgs[0],\n method = _parseDebounceArgs[1],\n args = _parseDebounceArgs[2],\n wait = _parseDebounceArgs[3],\n _parseDebounceArgs$ = _parseDebounceArgs[4],\n isImmediate = _parseDebounceArgs$ === undefined ? true : _parseDebounceArgs$;\n\n var index = findTimerItem(target, method, this._timers);\n var timerId = void 0;\n if (index === -1) {\n timerId = this._later(target, method, isImmediate ? DISABLE_SCHEDULE : args, wait);\n if (isImmediate) {\n this._join(target, method, args);\n }\n } else {\n timerId = this._timers[index + 1];\n var argIndex = index + 4;\n if (this._timers[argIndex] !== DISABLE_SCHEDULE) {\n this._timers[argIndex] = args;\n }\n }\n return timerId;\n };\n\n Backburner.prototype.debounce = function debounce() {\n debounceCount++;\n\n var _parseDebounceArgs2 = parseDebounceArgs.apply(undefined, arguments),\n target = _parseDebounceArgs2[0],\n method = _parseDebounceArgs2[1],\n args = _parseDebounceArgs2[2],\n wait = _parseDebounceArgs2[3],\n _parseDebounceArgs2$ = _parseDebounceArgs2[4],\n isImmediate = _parseDebounceArgs2$ === undefined ? false : _parseDebounceArgs2$;\n\n var _timers = this._timers;\n var index = findTimerItem(target, method, _timers);\n var timerId = void 0;\n if (index === -1) {\n timerId = this._later(target, method, isImmediate ? DISABLE_SCHEDULE : args, wait);\n if (isImmediate) {\n this._join(target, method, args);\n }\n } else {\n var executeAt = this._platform.now() + wait;\n var argIndex = index + 4;\n if (_timers[argIndex] === DISABLE_SCHEDULE) {\n args = DISABLE_SCHEDULE;\n }\n timerId = _timers[index + 1];\n var i = binarySearch(executeAt, _timers);\n if (index + TIMERS_OFFSET === i) {\n _timers[index] = executeAt;\n _timers[argIndex] = args;\n } else {\n var stack = this._timers[index + 5];\n this._timers.splice(i, 0, executeAt, timerId, target, method, args, stack);\n this._timers.splice(index, TIMERS_OFFSET);\n }\n if (index === 0) {\n this._reinstallTimerTimeout();\n }\n }\n return timerId;\n };\n\n Backburner.prototype.cancelTimers = function cancelTimers() {\n cancelTimersCount++;\n this._clearTimerTimeout();\n this._timers = [];\n this._cancelAutorun();\n };\n\n Backburner.prototype.hasTimers = function hasTimers() {\n return this._timers.length > 0 || this._autorun !== null;\n };\n\n Backburner.prototype.cancel = function cancel(timer) {\n cancelCount++;\n if (timer === null || timer === undefined) {\n return false;\n }\n var timerType = typeof timer;\n if (timerType === 'number') {\n // we're cancelling a setTimeout or throttle or debounce\n return this._cancelLaterTimer(timer);\n } else if (timerType === 'object' && timer.queue && timer.method) {\n // we're cancelling a deferOnce\n return timer.queue.cancel(timer);\n }\n return false;\n };\n\n Backburner.prototype.ensureInstance = function ensureInstance() {\n this._ensureInstance();\n };\n /**\n * Returns debug information related to the current instance of Backburner\n *\n * @method getDebugInfo\n * @returns {Object | undefined} Will return and Object containing debug information if\n * the DEBUG flag is set to true on the current instance of Backburner, else undefined.\n */\n\n Backburner.prototype.getDebugInfo = function getDebugInfo() {\n var _this2 = this;\n\n if (this.DEBUG) {\n return {\n autorun: this._autorunStack,\n counters: this.counters,\n timers: getQueueItems(this._timers, TIMERS_OFFSET, 2),\n instanceStack: [this.currentInstance].concat(this.instanceStack).map(function (deferredActionQueue) {\n return deferredActionQueue && deferredActionQueue._getDebugInfo(_this2.DEBUG);\n })\n };\n }\n return undefined;\n };\n\n Backburner.prototype._end = function _end(fromAutorun) {\n var currentInstance = this.currentInstance;\n var nextInstance = null;\n if (currentInstance === null) {\n throw new Error('end called without begin');\n }\n // Prevent double-finally bug in Safari 6.0.2 and iOS 6\n // This bug appears to be resolved in Safari 6.0.5 and iOS 7\n var finallyAlreadyCalled = false;\n var result = void 0;\n try {\n result = currentInstance.flush(fromAutorun);\n } finally {\n if (!finallyAlreadyCalled) {\n finallyAlreadyCalled = true;\n if (result === 1 /* Pause */) {\n this._scheduleAutorun();\n } else {\n this.currentInstance = null;\n if (this.instanceStack.length > 0) {\n nextInstance = this.instanceStack.pop();\n this.currentInstance = nextInstance;\n }\n this._trigger('end', currentInstance, nextInstance);\n this._onEnd(currentInstance, nextInstance);\n }\n }\n }\n };\n\n Backburner.prototype._join = function _join(target, method, args) {\n if (this.currentInstance === null) {\n return this._run(target, method, args);\n }\n if (target === undefined && args === undefined) {\n return method();\n } else {\n return method.apply(target, args);\n }\n };\n\n Backburner.prototype._run = function _run(target, method, args) {\n var onError = getOnError(this.options);\n this.begin();\n if (onError) {\n try {\n return method.apply(target, args);\n } catch (error) {\n onError(error);\n } finally {\n this.end();\n }\n } else {\n try {\n return method.apply(target, args);\n } finally {\n this.end();\n }\n }\n };\n\n Backburner.prototype._cancelAutorun = function _cancelAutorun() {\n if (this._autorun !== null) {\n this._platform.clearNext(this._autorun);\n this._autorun = null;\n this._autorunStack = null;\n }\n };\n\n Backburner.prototype._later = function _later(target, method, args, wait) {\n var stack = this.DEBUG ? new Error() : undefined;\n var executeAt = this._platform.now() + wait;\n var id = UUID++;\n if (this._timers.length === 0) {\n this._timers.push(executeAt, id, target, method, args, stack);\n this._installTimerTimeout();\n } else {\n // find position to insert\n var i = binarySearch(executeAt, this._timers);\n this._timers.splice(i, 0, executeAt, id, target, method, args, stack);\n // always reinstall since it could be out of sync\n this._reinstallTimerTimeout();\n }\n return id;\n };\n\n Backburner.prototype._cancelLaterTimer = function _cancelLaterTimer(timer) {\n for (var i = 1; i < this._timers.length; i += TIMERS_OFFSET) {\n if (this._timers[i] === timer) {\n this._timers.splice(i - 1, TIMERS_OFFSET);\n if (i === 1) {\n this._reinstallTimerTimeout();\n }\n return true;\n }\n }\n return false;\n };\n /**\n Trigger an event. Supports up to two arguments. Designed around\n triggering transition events from one run loop instance to the\n next, which requires an argument for the instance and then\n an argument for the next instance.\n @private\n @method _trigger\n @param {String} eventName\n @param {any} arg1\n @param {any} arg2\n */\n\n Backburner.prototype._trigger = function _trigger(eventName, arg1, arg2) {\n var callbacks = this._eventCallbacks[eventName];\n if (callbacks !== undefined) {\n for (var i = 0; i < callbacks.length; i++) {\n callbacks[i](arg1, arg2);\n }\n }\n };\n\n Backburner.prototype._runExpiredTimers = function _runExpiredTimers() {\n this._timerTimeoutId = null;\n if (this._timers.length > 0) {\n this.begin();\n this._scheduleExpiredTimers();\n this.end();\n }\n };\n\n Backburner.prototype._scheduleExpiredTimers = function _scheduleExpiredTimers() {\n var timers = this._timers;\n var i = 0;\n var l = timers.length;\n var defaultQueue = this._defaultQueue;\n var n = this._platform.now();\n for (; i < l; i += TIMERS_OFFSET) {\n var executeAt = timers[i];\n if (executeAt > n) {\n break;\n }\n var _args2 = timers[i + 4];\n if (_args2 !== DISABLE_SCHEDULE) {\n var target = timers[i + 2];\n var method = timers[i + 3];\n var stack = timers[i + 5];\n this.currentInstance.schedule(defaultQueue, target, method, _args2, false, stack);\n }\n }\n timers.splice(0, i);\n this._installTimerTimeout();\n };\n\n Backburner.prototype._reinstallTimerTimeout = function _reinstallTimerTimeout() {\n this._clearTimerTimeout();\n this._installTimerTimeout();\n };\n\n Backburner.prototype._clearTimerTimeout = function _clearTimerTimeout() {\n if (this._timerTimeoutId === null) {\n return;\n }\n this._platform.clearTimeout(this._timerTimeoutId);\n this._timerTimeoutId = null;\n };\n\n Backburner.prototype._installTimerTimeout = function _installTimerTimeout() {\n if (this._timers.length === 0) {\n return;\n }\n var minExpiresAt = this._timers[0];\n var n = this._platform.now();\n var wait = Math.max(0, minExpiresAt - n);\n this._timerTimeoutId = this._platform.setTimeout(this._boundRunExpiredTimers, wait);\n };\n\n Backburner.prototype._ensureInstance = function _ensureInstance() {\n var currentInstance = this.currentInstance;\n if (currentInstance === null) {\n this._autorunStack = this.DEBUG ? new Error() : undefined;\n currentInstance = this.begin();\n this._scheduleAutorun();\n }\n return currentInstance;\n };\n\n Backburner.prototype._scheduleAutorun = function _scheduleAutorun() {\n autorunsCreatedCount++;\n var next = this._platform.next;\n this._autorun = next();\n };\n\n (0, _emberBabel.createClass)(Backburner, [{\n key: 'counters',\n get: function () {\n return {\n begin: beginCount,\n end: endCount,\n events: {\n begin: beginEventCount,\n end: endEventCount\n },\n autoruns: {\n created: autorunsCreatedCount,\n completed: autorunsCompletedCount\n },\n run: runCount,\n join: joinCount,\n defer: deferCount,\n schedule: scheduleCount,\n scheduleIterable: scheduleIterableCount,\n deferOnce: deferOnceCount,\n scheduleOnce: scheduleOnceCount,\n setTimeout: setTimeoutCount,\n later: laterCount,\n throttle: throttleCount,\n debounce: debounceCount,\n cancelTimers: cancelTimersCount,\n cancel: cancelCount,\n loops: {\n total: deferredActionQueuesCreatedCount,\n nested: nestedDeferredActionQueuesCreated\n }\n };\n }\n }, {\n key: 'defaultQueue',\n get: function () {\n return this._defaultQueue;\n }\n }]);\n\n return Backburner;\n }();\n\n Backburner.Queue = Queue;\n\n exports.default = Backburner;\n exports.buildPlatform = buildPlatform;\n});","enifed(\"dag-map\", [\"exports\"], function (exports) {\n \"use strict\";\n\n /**\n * A topologically ordered map of key/value pairs with a simple API for adding constraints.\n *\n * Edges can forward reference keys that have not been added yet (the forward reference will\n * map the key to undefined).\n */\n var DAG = function () {\n function DAG() {\n this._vertices = new Vertices();\n }\n /**\n * Adds a key/value pair with dependencies on other key/value pairs.\n *\n * @public\n * @param key The key of the vertex to be added.\n * @param value The value of that vertex.\n * @param before A key or array of keys of the vertices that must\n * be visited before this vertex.\n * @param after An string or array of strings with the keys of the\n * vertices that must be after this vertex is visited.\n */\n DAG.prototype.add = function (key, value, before, after) {\n if (!key) throw new Error('argument `key` is required');\n var vertices = this._vertices;\n var v = vertices.add(key);\n v.val = value;\n if (before) {\n if (typeof before === \"string\") {\n vertices.addEdge(v, vertices.add(before));\n } else {\n for (var i = 0; i < before.length; i++) {\n vertices.addEdge(v, vertices.add(before[i]));\n }\n }\n }\n if (after) {\n if (typeof after === \"string\") {\n vertices.addEdge(vertices.add(after), v);\n } else {\n for (var i = 0; i < after.length; i++) {\n vertices.addEdge(vertices.add(after[i]), v);\n }\n }\n }\n };\n /**\n * @deprecated please use add.\n */\n DAG.prototype.addEdges = function (key, value, before, after) {\n this.add(key, value, before, after);\n };\n /**\n * Visits key/value pairs in topological order.\n *\n * @public\n * @param callback The function to be invoked with each key/value.\n */\n DAG.prototype.each = function (callback) {\n this._vertices.walk(callback);\n };\n /**\n * @deprecated please use each.\n */\n DAG.prototype.topsort = function (callback) {\n this.each(callback);\n };\n return DAG;\n }();\n exports.default = DAG;\n\n /** @private */\n var Vertices = function () {\n function Vertices() {\n this.length = 0;\n this.stack = new IntStack();\n this.path = new IntStack();\n this.result = new IntStack();\n }\n Vertices.prototype.add = function (key) {\n if (!key) throw new Error(\"missing key\");\n var l = this.length | 0;\n var vertex;\n for (var i = 0; i < l; i++) {\n vertex = this[i];\n if (vertex.key === key) return vertex;\n }\n this.length = l + 1;\n return this[l] = {\n idx: l,\n key: key,\n val: undefined,\n out: false,\n flag: false,\n length: 0\n };\n };\n Vertices.prototype.addEdge = function (v, w) {\n this.check(v, w.key);\n var l = w.length | 0;\n for (var i = 0; i < l; i++) {\n if (w[i] === v.idx) return;\n }\n w.length = l + 1;\n w[l] = v.idx;\n v.out = true;\n };\n Vertices.prototype.walk = function (cb) {\n this.reset();\n for (var i = 0; i < this.length; i++) {\n var vertex = this[i];\n if (vertex.out) continue;\n this.visit(vertex, \"\");\n }\n this.each(this.result, cb);\n };\n Vertices.prototype.check = function (v, w) {\n if (v.key === w) {\n throw new Error(\"cycle detected: \" + w + \" <- \" + w);\n }\n // quick check\n if (v.length === 0) return;\n // shallow check\n for (var i = 0; i < v.length; i++) {\n var key = this[v[i]].key;\n if (key === w) {\n throw new Error(\"cycle detected: \" + w + \" <- \" + v.key + \" <- \" + w);\n }\n }\n // deep check\n this.reset();\n this.visit(v, w);\n if (this.path.length > 0) {\n var msg_1 = \"cycle detected: \" + w;\n this.each(this.path, function (key) {\n msg_1 += \" <- \" + key;\n });\n throw new Error(msg_1);\n }\n };\n Vertices.prototype.reset = function () {\n this.stack.length = 0;\n this.path.length = 0;\n this.result.length = 0;\n for (var i = 0, l = this.length; i < l; i++) {\n this[i].flag = false;\n }\n };\n Vertices.prototype.visit = function (start, search) {\n var _a = this,\n stack = _a.stack,\n path = _a.path,\n result = _a.result;\n stack.push(start.idx);\n while (stack.length) {\n var index = stack.pop() | 0;\n if (index >= 0) {\n // enter\n var vertex = this[index];\n if (vertex.flag) continue;\n vertex.flag = true;\n path.push(index);\n if (search === vertex.key) break;\n // push exit\n stack.push(~index);\n this.pushIncoming(vertex);\n } else {\n // exit\n path.pop();\n result.push(~index);\n }\n }\n };\n Vertices.prototype.pushIncoming = function (incomming) {\n var stack = this.stack;\n for (var i = incomming.length - 1; i >= 0; i--) {\n var index = incomming[i];\n if (!this[index].flag) {\n stack.push(index);\n }\n }\n };\n Vertices.prototype.each = function (indices, cb) {\n for (var i = 0, l = indices.length; i < l; i++) {\n var vertex = this[indices[i]];\n cb(vertex.key, vertex.val);\n }\n };\n return Vertices;\n }();\n /** @private */\n var IntStack = function () {\n function IntStack() {\n this.length = 0;\n }\n IntStack.prototype.push = function (n) {\n this[this.length++] = n | 0;\n };\n IntStack.prototype.pop = function () {\n return this[--this.length] | 0;\n };\n return IntStack;\n }();\n});","enifed('ember-babel', ['exports'], function (exports) {\n 'use strict';\n\n exports.classCallCheck = classCallCheck;\n exports.inherits = inherits;\n exports.taggedTemplateLiteralLoose = taggedTemplateLiteralLoose;\n exports.createClass = createClass;\n\n\n var create = Object.create;\n var setPrototypeOf = Object.setPrototypeOf;\n var defineProperty = Object.defineProperty;\n\n function classCallCheck(instance, Constructor) {\n if (false /* DEBUG */) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError('Cannot call a class as a function');\n }\n }\n }\n\n function inherits(subClass, superClass) {\n if (false /* DEBUG */) {\n if (typeof superClass !== 'function' && superClass !== null) {\n throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);\n }\n }\n subClass.prototype = create(superClass === null ? null : superClass.prototype, {\n constructor: {\n value: subClass,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n if (superClass !== null) setPrototypeOf(subClass, superClass);\n }\n\n function taggedTemplateLiteralLoose(strings, raw) {\n strings.raw = raw;\n return strings;\n }\n\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if ('value' in descriptor) descriptor.writable = true;\n defineProperty(target, descriptor.key, descriptor);\n }\n }\n\n function createClass(Constructor, protoProps, staticProps) {\n if (protoProps !== undefined) defineProperties(Constructor.prototype, protoProps);\n if (staticProps !== undefined) defineProperties(Constructor, staticProps);\n return Constructor;\n }\n\n var possibleConstructorReturn = exports.possibleConstructorReturn = function (self, call) {\n if (false /* DEBUG */) {\n if (!self) {\n throw new ReferenceError('this hasn\\'t been initialized - super() hasn\\'t been called');\n }\n }\n return call !== null && typeof call === 'object' || typeof call === 'function' ? call : self;\n };\n});","enifed('ember/index', ['exports', 'require', '@ember/-internals/environment', 'node-module', '@ember/-internals/utils', '@ember/-internals/container', '@ember/instrumentation', '@ember/-internals/meta', '@ember/-internals/metal', '@ember/canary-features', '@ember/debug', 'backburner', '@ember/-internals/console', '@ember/controller', '@ember/controller/lib/controller_mixin', '@ember/string', '@ember/service', '@ember/object/computed', '@ember/-internals/runtime', '@ember/-internals/glimmer', 'ember/version', '@ember/-internals/views', '@ember/-internals/routing', '@ember/-internals/extension-support', '@ember/error', '@ember/runloop', '@ember/-internals/error-handling', '@ember/-internals/owner', '@ember/application', '@ember/application/globals-resolver', '@ember/application/instance', '@ember/engine', '@ember/engine/instance', '@ember/map', '@ember/map/with-default', '@ember/map/lib/ordered-set', '@ember/polyfills', '@ember/deprecated-features'], function (exports, _require2, _environment, _nodeModule, _utils, _container, _instrumentation, _meta, _metal, _canaryFeatures, _debug, _backburner, _console, _controller, _controller_mixin, _string, _service, _computed, _runtime, _glimmer, _version, _views, _routing, _extensionSupport, _error, _runloop, _errorHandling, _owner, _application, _globalsResolver, _instance, _engine, _instance2, _map, _withDefault, _orderedSet, _polyfills, _deprecatedFeatures) {\n 'use strict';\n\n // ****@ember/-internals/environment****\n\n // eslint-disable-next-line import/no-unresolved\n var Ember = typeof _environment.context.imports.Ember === 'object' && _environment.context.imports.Ember || {};\n\n Ember.isNamespace = true;\n Ember.toString = function () {\n return 'Ember';\n };\n\n Object.defineProperty(Ember, 'ENV', {\n get: _environment.getENV,\n enumerable: false\n });\n\n Object.defineProperty(Ember, 'lookup', {\n get: _environment.getLookup,\n set: _environment.setLookup,\n enumerable: false\n });\n\n if (_deprecatedFeatures.EMBER_EXTEND_PROTOTYPES) {\n Object.defineProperty(Ember, 'EXTEND_PROTOTYPES', {\n enumerable: false,\n get: function () {\n false && !false && (0, _debug.deprecate)('Accessing Ember.EXTEND_PROTOTYPES is deprecated, please migrate to Ember.ENV.EXTEND_PROTOTYPES', false, {\n id: 'ember-env.old-extend-prototypes',\n until: '4.0.0'\n });\n\n return _environment.ENV.EXTEND_PROTOTYPES;\n }\n });\n }\n\n // ****@ember/application****\n Ember.getOwner = _owner.getOwner;\n Ember.setOwner = _owner.setOwner;\n Ember.Application = _application.default;\n Ember.DefaultResolver = Ember.Resolver = _globalsResolver.default;\n Ember.ApplicationInstance = _instance.default;\n\n // ****@ember/engine****\n Ember.Engine = _engine.default;\n Ember.EngineInstance = _instance2.default;\n\n // ****@ember/map****\n Ember.OrderedSet = _orderedSet.default;\n Ember.__OrderedSet__ = _orderedSet.__OrderedSet__;\n Ember.Map = _map.default;\n Ember.MapWithDefault = _withDefault.default;\n\n // ****@ember/polyfills****\n Ember.assign = _polyfills.assign;\n Ember.merge = _polyfills.merge;\n\n // ****@ember/-internals/utils****\n Ember.generateGuid = _utils.generateGuid;\n Ember.GUID_KEY = _utils.GUID_KEY;\n Ember.guidFor = _utils.guidFor;\n Ember.inspect = _utils.inspect;\n Ember.makeArray = _utils.makeArray;\n Ember.canInvoke = _utils.canInvoke;\n Ember.tryInvoke = _utils.tryInvoke;\n Ember.wrap = _utils.wrap;\n Ember.uuid = _utils.uuid;\n Ember.NAME_KEY = _utils.NAME_KEY;\n Ember._Cache = _utils.Cache;\n\n // ****@ember/-internals/container****\n Ember.Container = _container.Container;\n Ember.Registry = _container.Registry;\n\n // ****@ember/debug****\n Ember.assert = _debug.assert;\n Ember.warn = _debug.warn;\n Ember.debug = _debug.debug;\n Ember.deprecate = _debug.deprecate;\n Ember.deprecateFunc = _debug.deprecateFunc;\n Ember.runInDebug = _debug.runInDebug;\n\n // ****@ember/error****\n Ember.Error = _error.default;\n\n /**\n @public\n @class Ember.Debug\n */\n Ember.Debug = {\n registerDeprecationHandler: _debug.registerDeprecationHandler,\n registerWarnHandler: _debug.registerWarnHandler\n };\n\n // ****@ember/instrumentation****\n Ember.instrument = _instrumentation.instrument;\n Ember.subscribe = _instrumentation.subscribe;\n Ember.Instrumentation = {\n instrument: _instrumentation.instrument,\n subscribe: _instrumentation.subscribe,\n unsubscribe: _instrumentation.unsubscribe,\n reset: _instrumentation.reset\n };\n\n // ****@ember/runloop****\n\n // Using _globalsRun here so that mutating the function (adding\n // `next`, `later`, etc to it) is only available in globals builds\n Ember.run = _runloop._globalsRun;\n Ember.run.backburner = _runloop.backburner;\n Ember.run.begin = _runloop.begin;\n Ember.run.bind = _runloop.bind;\n Ember.run.cancel = _runloop.cancel;\n Ember.run.debounce = _runloop.debounce;\n Ember.run.end = _runloop.end;\n Ember.run.hasScheduledTimers = _runloop.hasScheduledTimers;\n Ember.run.join = _runloop.join;\n Ember.run.later = _runloop.later;\n Ember.run.next = _runloop.next;\n Ember.run.once = _runloop.once;\n Ember.run.schedule = _runloop.schedule;\n Ember.run.scheduleOnce = _runloop.scheduleOnce;\n Ember.run.throttle = _runloop.throttle;\n Ember.run.cancelTimers = _runloop.cancelTimers;\n Object.defineProperty(Ember.run, 'currentRunLoop', {\n get: _runloop.getCurrentRunLoop,\n enumerable: false\n });\n\n // ****@ember/-internals/metal****\n\n // Using _globalsComputed here so that mutating the function is only available\n // in globals builds\n var computed = _metal._globalsComputed;\n Ember.computed = computed;\n computed.alias = _metal.alias;\n Ember.ComputedProperty = _metal.ComputedProperty;\n Ember.cacheFor = _metal.getCachedValueFor;\n Ember.meta = _meta.meta;\n Ember.get = _metal.get;\n Ember.getWithDefault = _metal.getWithDefault;\n Ember._getPath = _metal._getPath;\n Ember.set = _metal.set;\n Ember.trySet = _metal.trySet;\n Ember.FEATURES = (0, _polyfills.assign)({ isEnabled: _canaryFeatures.isEnabled }, _canaryFeatures.FEATURES);\n Ember._Cache = _utils.Cache;\n Ember.on = _metal.on;\n Ember.addListener = _metal.addListener;\n Ember.removeListener = _metal.removeListener;\n Ember.sendEvent = _metal.sendEvent;\n Ember.hasListeners = _metal.hasListeners;\n Ember.isNone = _metal.isNone;\n Ember.isEmpty = _metal.isEmpty;\n Ember.isBlank = _metal.isBlank;\n Ember.isPresent = _metal.isPresent;\n Ember.notifyPropertyChange = _metal.notifyPropertyChange;\n Ember.overrideChains = _metal.overrideChains;\n Ember.beginPropertyChanges = _metal.beginPropertyChanges;\n Ember.endPropertyChanges = _metal.endPropertyChanges;\n Ember.changeProperties = _metal.changeProperties;\n Ember.platform = {\n defineProperty: true,\n hasPropertyAccessors: true\n };\n Ember.defineProperty = _metal.defineProperty;\n Ember.watchKey = _metal.watchKey;\n Ember.unwatchKey = _metal.unwatchKey;\n Ember.removeChainWatcher = _metal.removeChainWatcher;\n Ember._ChainNode = _metal.ChainNode;\n Ember.finishChains = _metal.finishChains;\n Ember.watchPath = _metal.watchPath;\n Ember.unwatchPath = _metal.unwatchPath;\n Ember.watch = _metal.watch;\n Ember.isWatching = _metal.isWatching;\n Ember.unwatch = _metal.unwatch;\n Ember.destroy = _meta.deleteMeta;\n Ember.libraries = _metal.libraries;\n Ember.getProperties = _metal.getProperties;\n Ember.setProperties = _metal.setProperties;\n Ember.expandProperties = _metal.expandProperties;\n Ember.addObserver = _metal.addObserver;\n Ember.removeObserver = _metal.removeObserver;\n Ember.aliasMethod = _metal.aliasMethod;\n Ember.observer = _metal.observer;\n Ember.mixin = _metal.mixin;\n Ember.Mixin = _metal.Mixin;\n\n /**\n A function may be assigned to `Ember.onerror` to be called when Ember\n internals encounter an error. This is useful for specialized error handling\n and reporting code.\n \n ```javascript\n import $ from 'jquery';\n \n Ember.onerror = function(error) {\n $.ajax('/report-error', 'POST', {\n stack: error.stack,\n otherInformation: 'whatever app state you want to provide'\n });\n };\n ```\n \n Internally, `Ember.onerror` is used as Backburner's error handler.\n \n @event onerror\n @for Ember\n @param {Exception} error the error object\n @public\n */\n Object.defineProperty(Ember, 'onerror', {\n get: _errorHandling.getOnerror,\n set: _errorHandling.setOnerror,\n enumerable: false\n });\n\n Object.defineProperty(Ember, 'testing', {\n get: _debug.isTesting,\n set: _debug.setTesting,\n enumerable: false\n });\n\n Ember._Backburner = _backburner.default;\n\n // ****@ember/-internals/console****\n if (_deprecatedFeatures.LOGGER) {\n Ember.Logger = _console.default;\n }\n\n // ****@ember/-internals/runtime****\n Ember.A = _runtime.A;\n Ember.String = {\n loc: _string.loc,\n w: _string.w,\n dasherize: _string.dasherize,\n decamelize: _string.decamelize,\n camelize: _string.camelize,\n classify: _string.classify,\n underscore: _string.underscore,\n capitalize: _string.capitalize\n };\n Ember.Object = _runtime.Object;\n Ember._RegistryProxyMixin = _runtime.RegistryProxyMixin;\n Ember._ContainerProxyMixin = _runtime.ContainerProxyMixin;\n Ember.compare = _runtime.compare;\n Ember.copy = _runtime.copy;\n Ember.isEqual = _runtime.isEqual;\n\n /**\n @module ember\n */\n\n /**\n Namespace for injection helper methods.\n \n @class inject\n @namespace Ember\n @static\n @public\n */\n Ember.inject = function inject() {\n false && !false && (0, _debug.assert)('Injected properties must be created through helpers, see \\'' + Object.keys(inject).map(function (k) {\n return '\\'inject.' + k + '\\'';\n }).join(' or ') + '\\'');\n };\n Ember.inject.service = _service.inject;\n Ember.inject.controller = _controller.inject;\n\n Ember.Array = _runtime.Array;\n Ember.Comparable = _runtime.Comparable;\n Ember.Enumerable = _runtime.Enumerable;\n Ember.ArrayProxy = _runtime.ArrayProxy;\n Ember.ObjectProxy = _runtime.ObjectProxy;\n Ember.ActionHandler = _runtime.ActionHandler;\n Ember.CoreObject = _runtime.CoreObject;\n Ember.NativeArray = _runtime.NativeArray;\n Ember.Copyable = _runtime.Copyable;\n Ember.MutableEnumerable = _runtime.MutableEnumerable;\n Ember.MutableArray = _runtime.MutableArray;\n Ember.TargetActionSupport = _runtime.TargetActionSupport;\n Ember.Evented = _runtime.Evented;\n Ember.PromiseProxyMixin = _runtime.PromiseProxyMixin;\n Ember.Observable = _runtime.Observable;\n Ember.typeOf = _runtime.typeOf;\n Ember.isArray = _runtime.isArray;\n Ember.Object = _runtime.Object;\n Ember.onLoad = _application.onLoad;\n Ember.runLoadHooks = _application.runLoadHooks;\n Ember.Controller = _controller.default;\n Ember.ControllerMixin = _controller_mixin.default;\n Ember.Service = _service.default;\n Ember._ProxyMixin = _runtime._ProxyMixin;\n Ember.RSVP = _runtime.RSVP;\n Ember.Namespace = _runtime.Namespace;\n\n computed.empty = _computed.empty;\n computed.notEmpty = _computed.notEmpty;\n computed.none = _computed.none;\n computed.not = _computed.not;\n computed.bool = _computed.bool;\n computed.match = _computed.match;\n computed.equal = _computed.equal;\n computed.gt = _computed.gt;\n computed.gte = _computed.gte;\n computed.lt = _computed.lt;\n computed.lte = _computed.lte;\n computed.oneWay = _computed.oneWay;\n computed.reads = _computed.oneWay;\n computed.readOnly = _computed.readOnly;\n computed.deprecatingAlias = _computed.deprecatingAlias;\n computed.and = _computed.and;\n computed.or = _computed.or;\n\n computed.sum = _computed.sum;\n computed.min = _computed.min;\n computed.max = _computed.max;\n computed.map = _computed.map;\n computed.sort = _computed.sort;\n computed.setDiff = _computed.setDiff;\n computed.mapBy = _computed.mapBy;\n computed.filter = _computed.filter;\n computed.filterBy = _computed.filterBy;\n computed.uniq = _computed.uniq;\n\n computed.uniqBy = _computed.uniqBy;\n computed.union = _computed.union;\n computed.intersect = _computed.intersect;\n computed.collect = _computed.collect;\n\n /**\n Defines the hash of localized strings for the current language. Used by\n the `String.loc` helper. To localize, add string values to this\n hash.\n \n @property STRINGS\n @for Ember\n @type Object\n @private\n */\n Object.defineProperty(Ember, 'STRINGS', {\n configurable: false,\n get: _string._getStrings,\n set: _string._setStrings\n });\n\n /**\n Whether searching on the global for new Namespace instances is enabled.\n \n This is only exported here as to not break any addons. Given the new\n visit API, you will have issues if you treat this as a indicator of\n booted.\n \n Internally this is only exposing a flag in Namespace.\n \n @property BOOTED\n @for Ember\n @type Boolean\n @private\n */\n Object.defineProperty(Ember, 'BOOTED', {\n configurable: false,\n enumerable: false,\n get: _metal.isNamespaceSearchDisabled,\n set: _metal.setNamespaceSearchDisabled\n });\n\n // ****@ember/-internals/glimmer****\n Ember.Component = _glimmer.Component;\n _glimmer.Helper.helper = _glimmer.helper;\n Ember.Helper = _glimmer.Helper;\n Ember.Checkbox = _glimmer.Checkbox;\n Ember.TextField = _glimmer.TextField;\n Ember.TextArea = _glimmer.TextArea;\n Ember.LinkComponent = _glimmer.LinkComponent;\n Ember._setComponentManager = _glimmer.setComponentManager;\n Ember._componentManagerCapabilities = _glimmer.capabilities;\n Ember._setModifierManager = _glimmer.setModifierManager;\n Ember._modifierManagerCapabilties = _glimmer.modifierCapabilties;\n Ember.Handlebars = {\n template: _glimmer.template,\n Utils: {\n escapeExpression: _glimmer.escapeExpression\n }\n };\n Ember.HTMLBars = {\n template: _glimmer.template\n };\n\n if (_environment.ENV.EXTEND_PROTOTYPES.String) {\n String.prototype.htmlSafe = function () {\n return (0, _glimmer.htmlSafe)(this);\n };\n }\n Ember.String.htmlSafe = _glimmer.htmlSafe;\n Ember.String.isHTMLSafe = _glimmer.isHTMLSafe;\n\n /**\n Global hash of shared templates. This will automatically be populated\n by the build tools so that you can store your Handlebars templates in\n separate files that get loaded into JavaScript at buildtime.\n \n @property TEMPLATES\n @for Ember\n @type Object\n @private\n */\n Object.defineProperty(Ember, 'TEMPLATES', {\n get: _glimmer.getTemplates,\n set: _glimmer.setTemplates,\n configurable: false,\n enumerable: false\n });\n\n /**\n The semantic version\n \n @property VERSION\n @type String\n @public\n */\n Ember.VERSION = _version.default;\n\n // ****@ember/-internals/views****\n if (!_views.jQueryDisabled) {\n Ember.$ = _views.jQuery;\n }\n Ember.ViewUtils = {\n isSimpleClick: _views.isSimpleClick,\n getViewElement: _views.getViewElement,\n getViewBounds: _views.getViewBounds,\n getViewClientRects: _views.getViewClientRects,\n getViewBoundingClientRect: _views.getViewBoundingClientRect,\n getRootViews: _views.getRootViews,\n getChildViews: _views.getChildViews,\n isSerializationFirstNode: _glimmer.isSerializationFirstNode\n };\n Ember.TextSupport = _views.TextSupport;\n Ember.ComponentLookup = _views.ComponentLookup;\n Ember.EventDispatcher = _views.EventDispatcher;\n\n // ****@ember/-internals/routing****\n Ember.Location = _routing.Location;\n Ember.AutoLocation = _routing.AutoLocation;\n Ember.HashLocation = _routing.HashLocation;\n Ember.HistoryLocation = _routing.HistoryLocation;\n Ember.NoneLocation = _routing.NoneLocation;\n Ember.controllerFor = _routing.controllerFor;\n Ember.generateControllerFactory = _routing.generateControllerFactory;\n Ember.generateController = _routing.generateController;\n Ember.RouterDSL = _routing.RouterDSL;\n Ember.Router = _routing.Router;\n Ember.Route = _routing.Route;\n\n (0, _application.runLoadHooks)('Ember.Application', _application.default);\n\n Ember.DataAdapter = _extensionSupport.DataAdapter;\n Ember.ContainerDebugAdapter = _extensionSupport.ContainerDebugAdapter;\n\n if ((0, _require2.has)('ember-template-compiler')) {\n (0, _require2.default)('ember-template-compiler');\n }\n\n // do this to ensure that Ember.Test is defined properly on the global\n // if it is present.\n if ((0, _require2.has)('ember-testing')) {\n var testing = (0, _require2.default)('ember-testing');\n\n Ember.Test = testing.Test;\n Ember.Test.Adapter = testing.Adapter;\n Ember.Test.QUnitAdapter = testing.QUnitAdapter;\n Ember.setupForTesting = testing.setupForTesting;\n }\n\n (0, _application.runLoadHooks)('Ember');\n\n exports.default = Ember;\n\n\n if (_nodeModule.IS_NODE) {\n _nodeModule.module.exports = Ember;\n } else {\n _environment.context.exports.Ember = _environment.context.exports.Em = Ember;\n }\n\n /**\n @module jquery\n @public\n */\n\n /**\n @class jquery\n @public\n @static\n */\n\n /**\n Alias for jQuery\n \n @for jquery\n @method $\n @static\n @public\n */\n});","enifed(\"ember/version\", [\"exports\"], function (exports) {\n \"use strict\";\n\n exports.default = \"3.7.0\";\n});","/*global enifed, module */\nenifed('node-module', ['exports'], function(_exports) {\n var IS_NODE = typeof module === 'object' && typeof module.require === 'function';\n if (IS_NODE) {\n _exports.require = module.require;\n _exports.module = module;\n _exports.IS_NODE = IS_NODE;\n } else {\n _exports.require = null;\n _exports.module = null;\n _exports.IS_NODE = IS_NODE;\n }\n});\n","enifed(\"route-recognizer\", [\"exports\"], function (exports) {\n \"use strict\";\n\n var createObject = Object.create;\n function createMap() {\n var map = createObject(null);\n map[\"__\"] = undefined;\n delete map[\"__\"];\n return map;\n }\n\n var Target = function Target(path, matcher, delegate) {\n this.path = path;\n this.matcher = matcher;\n this.delegate = delegate;\n };\n Target.prototype.to = function to(target, callback) {\n var delegate = this.delegate;\n if (delegate && delegate.willAddRoute) {\n target = delegate.willAddRoute(this.matcher.target, target);\n }\n this.matcher.add(this.path, target);\n if (callback) {\n if (callback.length === 0) {\n throw new Error(\"You must have an argument in the function passed to `to`\");\n }\n this.matcher.addChild(this.path, target, callback, this.delegate);\n }\n };\n var Matcher = function Matcher(target) {\n this.routes = createMap();\n this.children = createMap();\n this.target = target;\n };\n Matcher.prototype.add = function add(path, target) {\n this.routes[path] = target;\n };\n Matcher.prototype.addChild = function addChild(path, target, callback, delegate) {\n var matcher = new Matcher(target);\n this.children[path] = matcher;\n var match = generateMatch(path, matcher, delegate);\n if (delegate && delegate.contextEntered) {\n delegate.contextEntered(target, match);\n }\n callback(match);\n };\n function generateMatch(startingPath, matcher, delegate) {\n function match(path, callback) {\n var fullPath = startingPath + path;\n if (callback) {\n callback(generateMatch(fullPath, matcher, delegate));\n } else {\n return new Target(fullPath, matcher, delegate);\n }\n }\n\n return match;\n }\n function addRoute(routeArray, path, handler) {\n var len = 0;\n for (var i = 0; i < routeArray.length; i++) {\n len += routeArray[i].path.length;\n }\n path = path.substr(len);\n var route = { path: path, handler: handler };\n routeArray.push(route);\n }\n function eachRoute(baseRoute, matcher, callback, binding) {\n var routes = matcher.routes;\n var paths = Object.keys(routes);\n for (var i = 0; i < paths.length; i++) {\n var path = paths[i];\n var routeArray = baseRoute.slice();\n addRoute(routeArray, path, routes[path]);\n var nested = matcher.children[path];\n if (nested) {\n eachRoute(routeArray, nested, callback, binding);\n } else {\n callback.call(binding, routeArray);\n }\n }\n }\n var map = function (callback, addRouteCallback) {\n var matcher = new Matcher();\n callback(generateMatch(\"\", matcher, this.delegate));\n eachRoute([], matcher, function (routes) {\n if (addRouteCallback) {\n addRouteCallback(this, routes);\n } else {\n this.add(routes);\n }\n }, this);\n };\n\n // Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded\n // values that are not reserved (i.e., unicode characters, emoji, etc). The reserved\n // chars are \"/\" and \"%\".\n // Safe to call multiple times on the same path.\n // Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded\n function normalizePath(path) {\n return path.split(\"/\").map(normalizeSegment).join(\"/\");\n }\n // We want to ensure the characters \"%\" and \"/\" remain in percent-encoded\n // form when normalizing paths, so replace them with their encoded form after\n // decoding the rest of the path\n var SEGMENT_RESERVED_CHARS = /%|\\//g;\n function normalizeSegment(segment) {\n if (segment.length < 3 || segment.indexOf(\"%\") === -1) {\n return segment;\n }\n return decodeURIComponent(segment).replace(SEGMENT_RESERVED_CHARS, encodeURIComponent);\n }\n // We do not want to encode these characters when generating dynamic path segments\n // See https://tools.ietf.org/html/rfc3986#section-3.3\n // sub-delims: \"!\", \"$\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \",\", \";\", \"=\"\n // others allowed by RFC 3986: \":\", \"@\"\n //\n // First encode the entire path segment, then decode any of the encoded special chars.\n //\n // The chars \"!\", \"'\", \"(\", \")\", \"*\" do not get changed by `encodeURIComponent`,\n // so the possible encoded chars are:\n // ['%24', '%26', '%2B', '%2C', '%3B', '%3D', '%3A', '%40'].\n var PATH_SEGMENT_ENCODINGS = /%(?:2(?:4|6|B|C)|3(?:B|D|A)|40)/g;\n function encodePathSegment(str) {\n return encodeURIComponent(str).replace(PATH_SEGMENT_ENCODINGS, decodeURIComponent);\n }\n\n var escapeRegex = /(\\/|\\.|\\*|\\+|\\?|\\||\\(|\\)|\\[|\\]|\\{|\\}|\\\\)/g;\n var isArray = Array.isArray;\n var hasOwnProperty = Object.prototype.hasOwnProperty;\n function getParam(params, key) {\n if (typeof params !== \"object\" || params === null) {\n throw new Error(\"You must pass an object as the second argument to `generate`.\");\n }\n if (!hasOwnProperty.call(params, key)) {\n throw new Error(\"You must provide param `\" + key + \"` to `generate`.\");\n }\n var value = params[key];\n var str = typeof value === \"string\" ? value : \"\" + value;\n if (str.length === 0) {\n throw new Error(\"You must provide a param `\" + key + \"`.\");\n }\n return str;\n }\n var eachChar = [];\n eachChar[0 /* Static */] = function (segment, currentState) {\n var state = currentState;\n var value = segment.value;\n for (var i = 0; i < value.length; i++) {\n var ch = value.charCodeAt(i);\n state = state.put(ch, false, false);\n }\n return state;\n };\n eachChar[1 /* Dynamic */] = function (_, currentState) {\n return currentState.put(47 /* SLASH */, true, true);\n };\n eachChar[2 /* Star */] = function (_, currentState) {\n return currentState.put(-1 /* ANY */, false, true);\n };\n eachChar[4 /* Epsilon */] = function (_, currentState) {\n return currentState;\n };\n var regex = [];\n regex[0 /* Static */] = function (segment) {\n return segment.value.replace(escapeRegex, \"\\\\$1\");\n };\n regex[1 /* Dynamic */] = function () {\n return \"([^/]+)\";\n };\n regex[2 /* Star */] = function () {\n return \"(.+)\";\n };\n regex[4 /* Epsilon */] = function () {\n return \"\";\n };\n var generate = [];\n generate[0 /* Static */] = function (segment) {\n return segment.value;\n };\n generate[1 /* Dynamic */] = function (segment, params) {\n var value = getParam(params, segment.value);\n if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {\n return encodePathSegment(value);\n } else {\n return value;\n }\n };\n generate[2 /* Star */] = function (segment, params) {\n return getParam(params, segment.value);\n };\n generate[4 /* Epsilon */] = function () {\n return \"\";\n };\n var EmptyObject = Object.freeze({});\n var EmptyArray = Object.freeze([]);\n // The `names` will be populated with the paramter name for each dynamic/star\n // segment. `shouldDecodes` will be populated with a boolean for each dyanamic/star\n // segment, indicating whether it should be decoded during recognition.\n function parse(segments, route, types) {\n // normalize route as not starting with a \"/\". Recognition will\n // also normalize.\n if (route.length > 0 && route.charCodeAt(0) === 47 /* SLASH */) {\n route = route.substr(1);\n }\n var parts = route.split(\"/\");\n var names = undefined;\n var shouldDecodes = undefined;\n for (var i = 0; i < parts.length; i++) {\n var part = parts[i];\n var flags = 0;\n var type = 0;\n if (part === \"\") {\n type = 4 /* Epsilon */;\n } else if (part.charCodeAt(0) === 58 /* COLON */) {\n type = 1 /* Dynamic */;\n } else if (part.charCodeAt(0) === 42 /* STAR */) {\n type = 2 /* Star */;\n } else {\n type = 0 /* Static */;\n }\n flags = 2 << type;\n if (flags & 12 /* Named */) {\n part = part.slice(1);\n names = names || [];\n names.push(part);\n shouldDecodes = shouldDecodes || [];\n shouldDecodes.push((flags & 4 /* Decoded */) !== 0);\n }\n if (flags & 14 /* Counted */) {\n types[type]++;\n }\n segments.push({\n type: type,\n value: normalizeSegment(part)\n });\n }\n return {\n names: names || EmptyArray,\n shouldDecodes: shouldDecodes || EmptyArray\n };\n }\n function isEqualCharSpec(spec, char, negate) {\n return spec.char === char && spec.negate === negate;\n }\n // A State has a character specification and (`charSpec`) and a list of possible\n // subsequent states (`nextStates`).\n //\n // If a State is an accepting state, it will also have several additional\n // properties:\n //\n // * `regex`: A regular expression that is used to extract parameters from paths\n // that reached this accepting state.\n // * `handlers`: Information on how to convert the list of captures into calls\n // to registered handlers with the specified parameters\n // * `types`: How many static, dynamic or star segments in this route. Used to\n // decide which route to use if multiple registered routes match a path.\n //\n // Currently, State is implemented naively by looping over `nextStates` and\n // comparing a character specification against a character. A more efficient\n // implementation would use a hash of keys pointing at one or more next states.\n var State = function State(states, id, char, negate, repeat) {\n this.states = states;\n this.id = id;\n this.char = char;\n this.negate = negate;\n this.nextStates = repeat ? id : null;\n this.pattern = \"\";\n this._regex = undefined;\n this.handlers = undefined;\n this.types = undefined;\n };\n State.prototype.regex = function regex$1() {\n if (!this._regex) {\n this._regex = new RegExp(this.pattern);\n }\n return this._regex;\n };\n State.prototype.get = function get(char, negate) {\n var this$1 = this;\n\n var nextStates = this.nextStates;\n if (nextStates === null) {\n return;\n }\n if (isArray(nextStates)) {\n for (var i = 0; i < nextStates.length; i++) {\n var child = this$1.states[nextStates[i]];\n if (isEqualCharSpec(child, char, negate)) {\n return child;\n }\n }\n } else {\n var child$1 = this.states[nextStates];\n if (isEqualCharSpec(child$1, char, negate)) {\n return child$1;\n }\n }\n };\n State.prototype.put = function put(char, negate, repeat) {\n var state;\n // If the character specification already exists in a child of the current\n // state, just return that state.\n if (state = this.get(char, negate)) {\n return state;\n }\n // Make a new state for the character spec\n var states = this.states;\n state = new State(states, states.length, char, negate, repeat);\n states[states.length] = state;\n // Insert the new state as a child of the current state\n if (this.nextStates == null) {\n this.nextStates = state.id;\n } else if (isArray(this.nextStates)) {\n this.nextStates.push(state.id);\n } else {\n this.nextStates = [this.nextStates, state.id];\n }\n // Return the new state\n return state;\n };\n // Find a list of child states matching the next character\n State.prototype.match = function match(ch) {\n var this$1 = this;\n\n var nextStates = this.nextStates;\n if (!nextStates) {\n return [];\n }\n var returned = [];\n if (isArray(nextStates)) {\n for (var i = 0; i < nextStates.length; i++) {\n var child = this$1.states[nextStates[i]];\n if (isMatch(child, ch)) {\n returned.push(child);\n }\n }\n } else {\n var child$1 = this.states[nextStates];\n if (isMatch(child$1, ch)) {\n returned.push(child$1);\n }\n }\n return returned;\n };\n function isMatch(spec, char) {\n return spec.negate ? spec.char !== char && spec.char !== -1 /* ANY */ : spec.char === char || spec.char === -1 /* ANY */;\n }\n // This is a somewhat naive strategy, but should work in a lot of cases\n // A better strategy would properly resolve /posts/:id/new and /posts/edit/:id.\n //\n // This strategy generally prefers more static and less dynamic matching.\n // Specifically, it\n //\n // * prefers fewer stars to more, then\n // * prefers using stars for less of the match to more, then\n // * prefers fewer dynamic segments to more, then\n // * prefers more static segments to more\n function sortSolutions(states) {\n return states.sort(function (a, b) {\n var ref = a.types || [0, 0, 0];\n var astatics = ref[0];\n var adynamics = ref[1];\n var astars = ref[2];\n var ref$1 = b.types || [0, 0, 0];\n var bstatics = ref$1[0];\n var bdynamics = ref$1[1];\n var bstars = ref$1[2];\n if (astars !== bstars) {\n return astars - bstars;\n }\n if (astars) {\n if (astatics !== bstatics) {\n return bstatics - astatics;\n }\n if (adynamics !== bdynamics) {\n return bdynamics - adynamics;\n }\n }\n if (adynamics !== bdynamics) {\n return adynamics - bdynamics;\n }\n if (astatics !== bstatics) {\n return bstatics - astatics;\n }\n return 0;\n });\n }\n function recognizeChar(states, ch) {\n var nextStates = [];\n for (var i = 0, l = states.length; i < l; i++) {\n var state = states[i];\n nextStates = nextStates.concat(state.match(ch));\n }\n return nextStates;\n }\n var RecognizeResults = function RecognizeResults(queryParams) {\n this.length = 0;\n this.queryParams = queryParams || {};\n };\n\n RecognizeResults.prototype.splice = Array.prototype.splice;\n RecognizeResults.prototype.slice = Array.prototype.slice;\n RecognizeResults.prototype.push = Array.prototype.push;\n function findHandler(state, originalPath, queryParams) {\n var handlers = state.handlers;\n var regex = state.regex();\n if (!regex || !handlers) {\n throw new Error(\"state not initialized\");\n }\n var captures = originalPath.match(regex);\n var currentCapture = 1;\n var result = new RecognizeResults(queryParams);\n result.length = handlers.length;\n for (var i = 0; i < handlers.length; i++) {\n var handler = handlers[i];\n var names = handler.names;\n var shouldDecodes = handler.shouldDecodes;\n var params = EmptyObject;\n var isDynamic = false;\n if (names !== EmptyArray && shouldDecodes !== EmptyArray) {\n for (var j = 0; j < names.length; j++) {\n isDynamic = true;\n var name = names[j];\n var capture = captures && captures[currentCapture++];\n if (params === EmptyObject) {\n params = {};\n }\n if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS && shouldDecodes[j]) {\n params[name] = capture && decodeURIComponent(capture);\n } else {\n params[name] = capture;\n }\n }\n }\n result[i] = {\n handler: handler.handler,\n params: params,\n isDynamic: isDynamic\n };\n }\n return result;\n }\n function decodeQueryParamPart(part) {\n // http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1\n part = part.replace(/\\+/gm, \"%20\");\n var result;\n try {\n result = decodeURIComponent(part);\n } catch (error) {\n result = \"\";\n }\n return result;\n }\n var RouteRecognizer = function RouteRecognizer() {\n this.names = createMap();\n var states = [];\n var state = new State(states, 0, -1 /* ANY */, true, false);\n states[0] = state;\n this.states = states;\n this.rootState = state;\n };\n RouteRecognizer.prototype.add = function add(routes, options) {\n var currentState = this.rootState;\n var pattern = \"^\";\n var types = [0, 0, 0];\n var handlers = new Array(routes.length);\n var allSegments = [];\n var isEmpty = true;\n var j = 0;\n for (var i = 0; i < routes.length; i++) {\n var route = routes[i];\n var ref = parse(allSegments, route.path, types);\n var names = ref.names;\n var shouldDecodes = ref.shouldDecodes;\n // preserve j so it points to the start of newly added segments\n for (; j < allSegments.length; j++) {\n var segment = allSegments[j];\n if (segment.type === 4 /* Epsilon */) {\n continue;\n }\n isEmpty = false;\n // Add a \"/\" for the new segment\n currentState = currentState.put(47 /* SLASH */, false, false);\n pattern += \"/\";\n // Add a representation of the segment to the NFA and regex\n currentState = eachChar[segment.type](segment, currentState);\n pattern += regex[segment.type](segment);\n }\n handlers[i] = {\n handler: route.handler,\n names: names,\n shouldDecodes: shouldDecodes\n };\n }\n if (isEmpty) {\n currentState = currentState.put(47 /* SLASH */, false, false);\n pattern += \"/\";\n }\n currentState.handlers = handlers;\n currentState.pattern = pattern + \"$\";\n currentState.types = types;\n var name;\n if (typeof options === \"object\" && options !== null && options.as) {\n name = options.as;\n }\n if (name) {\n // if (this.names[name]) {\n // throw new Error(\"You may not add a duplicate route named `\" + name + \"`.\");\n // }\n this.names[name] = {\n segments: allSegments,\n handlers: handlers\n };\n }\n };\n RouteRecognizer.prototype.handlersFor = function handlersFor(name) {\n var route = this.names[name];\n if (!route) {\n throw new Error(\"There is no route named \" + name);\n }\n var result = new Array(route.handlers.length);\n for (var i = 0; i < route.handlers.length; i++) {\n var handler = route.handlers[i];\n result[i] = handler;\n }\n return result;\n };\n RouteRecognizer.prototype.hasRoute = function hasRoute(name) {\n return !!this.names[name];\n };\n RouteRecognizer.prototype.generate = function generate$1(name, params) {\n var route = this.names[name];\n var output = \"\";\n if (!route) {\n throw new Error(\"There is no route named \" + name);\n }\n var segments = route.segments;\n for (var i = 0; i < segments.length; i++) {\n var segment = segments[i];\n if (segment.type === 4 /* Epsilon */) {\n continue;\n }\n output += \"/\";\n output += generate[segment.type](segment, params);\n }\n if (output.charAt(0) !== \"/\") {\n output = \"/\" + output;\n }\n if (params && params.queryParams) {\n output += this.generateQueryString(params.queryParams);\n }\n return output;\n };\n RouteRecognizer.prototype.generateQueryString = function generateQueryString(params) {\n var pairs = [];\n var keys = Object.keys(params);\n keys.sort();\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n var value = params[key];\n if (value == null) {\n continue;\n }\n var pair = encodeURIComponent(key);\n if (isArray(value)) {\n for (var j = 0; j < value.length; j++) {\n var arrayPair = key + \"[]\" + \"=\" + encodeURIComponent(value[j]);\n pairs.push(arrayPair);\n }\n } else {\n pair += \"=\" + encodeURIComponent(value);\n pairs.push(pair);\n }\n }\n if (pairs.length === 0) {\n return \"\";\n }\n return \"?\" + pairs.join(\"&\");\n };\n RouteRecognizer.prototype.parseQueryString = function parseQueryString(queryString) {\n var pairs = queryString.split(\"&\");\n var queryParams = {};\n for (var i = 0; i < pairs.length; i++) {\n var pair = pairs[i].split(\"=\"),\n key = decodeQueryParamPart(pair[0]),\n keyLength = key.length,\n isArray = false,\n value = void 0;\n if (pair.length === 1) {\n value = \"true\";\n } else {\n // Handle arrays\n if (keyLength > 2 && key.slice(keyLength - 2) === \"[]\") {\n isArray = true;\n key = key.slice(0, keyLength - 2);\n if (!queryParams[key]) {\n queryParams[key] = [];\n }\n }\n value = pair[1] ? decodeQueryParamPart(pair[1]) : \"\";\n }\n if (isArray) {\n queryParams[key].push(value);\n } else {\n queryParams[key] = value;\n }\n }\n return queryParams;\n };\n RouteRecognizer.prototype.recognize = function recognize(path) {\n var results;\n var states = [this.rootState];\n var queryParams = {};\n var isSlashDropped = false;\n var hashStart = path.indexOf(\"#\");\n if (hashStart !== -1) {\n path = path.substr(0, hashStart);\n }\n var queryStart = path.indexOf(\"?\");\n if (queryStart !== -1) {\n var queryString = path.substr(queryStart + 1, path.length);\n path = path.substr(0, queryStart);\n queryParams = this.parseQueryString(queryString);\n }\n if (path.charAt(0) !== \"/\") {\n path = \"/\" + path;\n }\n var originalPath = path;\n if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {\n path = normalizePath(path);\n } else {\n path = decodeURI(path);\n originalPath = decodeURI(originalPath);\n }\n var pathLen = path.length;\n if (pathLen > 1 && path.charAt(pathLen - 1) === \"/\") {\n path = path.substr(0, pathLen - 1);\n originalPath = originalPath.substr(0, originalPath.length - 1);\n isSlashDropped = true;\n }\n for (var i = 0; i < path.length; i++) {\n states = recognizeChar(states, path.charCodeAt(i));\n if (!states.length) {\n break;\n }\n }\n var solutions = [];\n for (var i$1 = 0; i$1 < states.length; i$1++) {\n if (states[i$1].handlers) {\n solutions.push(states[i$1]);\n }\n }\n states = sortSolutions(solutions);\n var state = solutions[0];\n if (state && state.handlers) {\n // if a trailing slash was dropped and a star segment is the last segment\n // specified, put the trailing slash back\n if (isSlashDropped && state.pattern && state.pattern.slice(-5) === \"(.+)$\") {\n originalPath = originalPath + \"/\";\n }\n results = findHandler(state, originalPath, queryParams);\n }\n return results;\n };\n RouteRecognizer.VERSION = \"0.3.4\";\n // Set to false to opt-out of encoding and decoding path segments.\n // See https://github.com/tildeio/route-recognizer/pull/55\n RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS = true;\n RouteRecognizer.Normalizer = {\n normalizeSegment: normalizeSegment, normalizePath: normalizePath, encodePathSegment: encodePathSegment\n };\n RouteRecognizer.prototype.map = map;\n\n exports.default = RouteRecognizer;\n});","enifed('router_js', ['exports', 'ember-babel', '@ember/polyfills', 'rsvp', 'route-recognizer'], function (exports, _emberBabel, _polyfills, _rsvp, _routeRecognizer) {\n 'use strict';\n\n exports.InternalRouteInfo = exports.TransitionError = exports.TransitionState = exports.QUERY_PARAMS_SYMBOL = exports.PARAMS_SYMBOL = exports.STATE_SYMBOL = exports.logAbort = exports.InternalTransition = undefined;\n\n\n var TransitionAbortedError = function () {\n TransitionAbortedError.prototype = Object.create(Error.prototype);\n TransitionAbortedError.prototype.constructor = TransitionAbortedError;\n function TransitionAbortedError(message) {\n var error = Error.call(this, message);\n this.name = 'TransitionAborted';\n this.message = message || 'TransitionAborted';\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, TransitionAbortedError);\n } else {\n this.stack = error.stack;\n }\n }\n return TransitionAbortedError;\n }();\n\n var slice = Array.prototype.slice;\n var hasOwnProperty = Object.prototype.hasOwnProperty;\n /**\n Determines if an object is Promise by checking if it is \"thenable\".\n **/\n function isPromise(p) {\n return p !== null && typeof p === 'object' && typeof p.then === 'function';\n }\n function merge(hash, other) {\n for (var prop in other) {\n if (hasOwnProperty.call(other, prop)) {\n hash[prop] = other[prop];\n }\n }\n }\n /**\n @private\n \n Extracts query params from the end of an array\n **/\n function extractQueryParams(array) {\n var len = array && array.length,\n head = void 0,\n queryParams = void 0;\n if (len && len > 0) {\n var obj = array[len - 1];\n if (isQueryParams(obj)) {\n queryParams = obj.queryParams;\n head = slice.call(array, 0, len - 1);\n return [head, queryParams];\n }\n }\n return [array, null];\n }\n function isQueryParams(obj) {\n return obj && hasOwnProperty.call(obj, 'queryParams');\n }\n /**\n @private\n \n Coerces query param properties and array elements into strings.\n **/\n function coerceQueryParamsToString(queryParams) {\n for (var key in queryParams) {\n var val = queryParams[key];\n if (typeof val === 'number') {\n queryParams[key] = '' + val;\n } else if (Array.isArray(val)) {\n for (var i = 0, l = val.length; i < l; i++) {\n val[i] = '' + val[i];\n }\n }\n }\n }\n /**\n @private\n */\n function _log(router) {\n for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n if (!router.log) {\n return;\n }\n if (arguments.length === 2) {\n var sequence = args[0],\n msg = args[1];\n\n router.log('Transition #' + sequence + ': ' + msg);\n } else {\n var _msg = args[0];\n\n router.log(_msg);\n }\n }\n function isParam(object) {\n return typeof object === 'string' || object instanceof String || typeof object === 'number' || object instanceof Number;\n }\n function forEach(array, callback) {\n for (var i = 0, l = array.length; i < l && callback(array[i]) !== false; i++) {\n // empty intentionally\n }\n }\n function getChangelist(oldObject, newObject) {\n var key = void 0;\n var results = {\n all: {},\n changed: {},\n removed: {}\n };\n merge(results.all, newObject);\n var didChange = false;\n coerceQueryParamsToString(oldObject);\n coerceQueryParamsToString(newObject);\n // Calculate removals\n for (key in oldObject) {\n if (hasOwnProperty.call(oldObject, key)) {\n if (!hasOwnProperty.call(newObject, key)) {\n didChange = true;\n results.removed[key] = oldObject[key];\n }\n }\n }\n // Calculate changes\n for (key in newObject) {\n if (hasOwnProperty.call(newObject, key)) {\n var oldElement = oldObject[key];\n var newElement = newObject[key];\n if (isArray(oldElement) && isArray(newElement)) {\n if (oldElement.length !== newElement.length) {\n results.changed[key] = newObject[key];\n didChange = true;\n } else {\n for (var i = 0, l = oldElement.length; i < l; i++) {\n if (oldElement[i] !== newElement[i]) {\n results.changed[key] = newObject[key];\n didChange = true;\n }\n }\n }\n } else if (oldObject[key] !== newObject[key]) {\n results.changed[key] = newObject[key];\n didChange = true;\n }\n }\n }\n return didChange ? results : undefined;\n }\n function isArray(obj) {\n return Array.isArray(obj);\n }\n function _promiseLabel(label) {\n return 'Router: ' + label;\n }\n\n var STATE_SYMBOL = '__STATE__-2619860001345920-3322w3';\n var PARAMS_SYMBOL = '__PARAMS__-261986232992830203-23323';\n var QUERY_PARAMS_SYMBOL = '__QPS__-2619863929824844-32323';\n /**\n A Transition is a thennable (a promise-like object) that represents\n an attempt to transition to another route. It can be aborted, either\n explicitly via `abort` or by attempting another transition while a\n previous one is still underway. An aborted transition can also\n be `retry()`d later.\n \n @class Transition\n @constructor\n @param {Object} router\n @param {Object} intent\n @param {Object} state\n @param {Object} error\n @private\n */\n\n var Transition = function () {\n function Transition(router, intent, state) {\n var _this = this;\n\n var error = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;\n var previousTransition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : undefined;\n\n this.from = null;\n this.to = undefined;\n this.isAborted = false;\n this.isActive = true;\n this.urlMethod = 'update';\n this.resolveIndex = 0;\n this.queryParamsOnly = false;\n this.isTransition = true;\n this.isCausedByAbortingTransition = false;\n this.isCausedByInitialTransition = false;\n this.isCausedByAbortingReplaceTransition = false;\n this._visibleQueryParams = {};\n this[STATE_SYMBOL] = state || router.state;\n this.intent = intent;\n this.router = router;\n this.data = intent && intent.data || {};\n this.resolvedModels = {};\n this[QUERY_PARAMS_SYMBOL] = {};\n this.promise = undefined;\n this.error = undefined;\n this[PARAMS_SYMBOL] = {};\n this.routeInfos = [];\n this.targetName = undefined;\n this.pivotHandler = undefined;\n this.sequence = -1;\n if (error) {\n this.promise = _rsvp.Promise.reject(error);\n this.error = error;\n return;\n }\n // if you're doing multiple redirects, need the new transition to know if it\n // is actually part of the first transition or not. Any further redirects\n // in the initial transition also need to know if they are part of the\n // initial transition\n this.isCausedByAbortingTransition = !!previousTransition;\n this.isCausedByInitialTransition = !!previousTransition && (previousTransition.isCausedByInitialTransition || previousTransition.sequence === 0);\n // Every transition in the chain is a replace\n this.isCausedByAbortingReplaceTransition = !!previousTransition && previousTransition.urlMethod === 'replace' && (!previousTransition.isCausedByAbortingTransition || previousTransition.isCausedByAbortingReplaceTransition);\n if (state) {\n this[PARAMS_SYMBOL] = state.params;\n this[QUERY_PARAMS_SYMBOL] = state.queryParams;\n this.routeInfos = state.routeInfos;\n var len = state.routeInfos.length;\n if (len) {\n this.targetName = state.routeInfos[len - 1].name;\n }\n for (var i = 0; i < len; ++i) {\n var handlerInfo = state.routeInfos[i];\n // TODO: this all seems hacky\n if (!handlerInfo.isResolved) {\n break;\n }\n this.pivotHandler = handlerInfo.route;\n }\n this.sequence = router.currentSequence++;\n this.promise = state.resolve(function () {\n if (_this.isAborted) {\n return _rsvp.Promise.reject(false, _promiseLabel('Transition aborted - reject'));\n }\n return _rsvp.Promise.resolve(true);\n }, this).catch(function (result) {\n return _rsvp.Promise.reject(_this.router.transitionDidError(result, _this));\n }, _promiseLabel('Handle Abort'));\n } else {\n this.promise = _rsvp.Promise.resolve(this[STATE_SYMBOL]);\n this[PARAMS_SYMBOL] = {};\n }\n }\n /**\n The Transition's internal promise. Calling `.then` on this property\n is that same as calling `.then` on the Transition object itself, but\n this property is exposed for when you want to pass around a\n Transition's promise, but not the Transition object itself, since\n Transition object can be externally `abort`ed, while the promise\n cannot.\n @property promise\n @type {Object}\n @public\n */\n /**\n Custom state can be stored on a Transition's `data` object.\n This can be useful for decorating a Transition within an earlier\n hook and shared with a later hook. Properties set on `data` will\n be copied to new transitions generated by calling `retry` on this\n transition.\n @property data\n @type {Object}\n @public\n */\n /**\n A standard promise hook that resolves if the transition\n succeeds and rejects if it fails/redirects/aborts.\n Forwards to the internal `promise` property which you can\n use in situations where you want to pass around a thennable,\n but not the Transition itself.\n @method then\n @param {Function} onFulfilled\n @param {Function} onRejected\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise}\n @public\n */\n\n Transition.prototype.then = function then(onFulfilled, onRejected, label) {\n return this.promise.then(onFulfilled, onRejected, label);\n };\n /**\n Forwards to the internal `promise` property which you can\n use in situations where you want to pass around a thennable,\n but not the Transition itself.\n @method catch\n @param {Function} onRejection\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise}\n @public\n */\n\n Transition.prototype.catch = function _catch(onRejection, label) {\n return this.promise.catch(onRejection, label);\n };\n /**\n Forwards to the internal `promise` property which you can\n use in situations where you want to pass around a thennable,\n but not the Transition itself.\n @method finally\n @param {Function} callback\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise}\n @public\n */\n\n Transition.prototype.finally = function _finally(callback, label) {\n return this.promise.finally(callback, label);\n };\n /**\n Aborts the Transition. Note you can also implicitly abort a transition\n by initiating another transition while a previous one is underway.\n @method abort\n @return {Transition} this transition\n @public\n */\n\n Transition.prototype.abort = function abort() {\n this.rollback();\n var transition = new Transition(this.router, undefined, undefined, undefined);\n transition.to = this.from;\n transition.from = this.from;\n transition.isAborted = true;\n this.router.routeWillChange(transition);\n this.router.routeDidChange(transition);\n return this;\n };\n\n Transition.prototype.rollback = function rollback() {\n if (!this.isAborted) {\n _log(this.router, this.sequence, this.targetName + ': transition was aborted');\n if (this.intent !== undefined && this.intent !== null) {\n this.intent.preTransitionState = this.router.state;\n }\n this.isAborted = true;\n this.isActive = false;\n this.router.activeTransition = undefined;\n }\n };\n\n Transition.prototype.redirect = function redirect(newTransition) {\n this.rollback();\n this.router.routeWillChange(newTransition);\n };\n /**\n Retries a previously-aborted transition (making sure to abort the\n transition if it's still active). Returns a new transition that\n represents the new attempt to transition.\n @method retry\n @return {Transition} new transition\n @public\n */\n\n Transition.prototype.retry = function retry() {\n // TODO: add tests for merged state retry()s\n this.abort();\n var newTransition = this.router.transitionByIntent(this.intent, false);\n // inheriting a `null` urlMethod is not valid\n // the urlMethod is only set to `null` when\n // the transition is initiated *after* the url\n // has been updated (i.e. `router.handleURL`)\n //\n // in that scenario, the url method cannot be\n // inherited for a new transition because then\n // the url would not update even though it should\n if (this.urlMethod !== null) {\n newTransition.method(this.urlMethod);\n }\n return newTransition;\n };\n /**\n Sets the URL-changing method to be employed at the end of a\n successful transition. By default, a new Transition will just\n use `updateURL`, but passing 'replace' to this method will\n cause the URL to update using 'replaceWith' instead. Omitting\n a parameter will disable the URL change, allowing for transitions\n that don't update the URL at completion (this is also used for\n handleURL, since the URL has already changed before the\n transition took place).\n @method method\n @param {String} method the type of URL-changing method to use\n at the end of a transition. Accepted values are 'replace',\n falsy values, or any other non-falsy value (which is\n interpreted as an updateURL transition).\n @return {Transition} this transition\n @public\n */\n\n Transition.prototype.method = function method(_method) {\n this.urlMethod = _method;\n return this;\n };\n // Alias 'trigger' as 'send'\n\n\n Transition.prototype.send = function send(ignoreFailure, _name, err, transition, handler) {\n this.trigger(ignoreFailure, _name, err, transition, handler);\n };\n /**\n Fires an event on the current list of resolved/resolving\n handlers within this transition. Useful for firing events\n on route hierarchies that haven't fully been entered yet.\n Note: This method is also aliased as `send`\n @method trigger\n @param {Boolean} [ignoreFailure=false] a boolean specifying whether unhandled events throw an error\n @param {String} name the name of the event to fire\n @public\n */\n\n Transition.prototype.trigger = function trigger(ignoreFailure, name) {\n for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n args[_key2 - 2] = arguments[_key2];\n }\n\n this.router.triggerEvent(this[STATE_SYMBOL].routeInfos.slice(0, this.resolveIndex + 1), ignoreFailure, name, args);\n };\n /**\n Transitions are aborted and their promises rejected\n when redirects occur; this method returns a promise\n that will follow any redirects that occur and fulfill\n with the value fulfilled by any redirecting transitions\n that occur.\n @method followRedirects\n @return {Promise} a promise that fulfills with the same\n value that the final redirecting transition fulfills with\n @public\n */\n\n Transition.prototype.followRedirects = function followRedirects() {\n var router = this.router;\n return this.promise.catch(function (reason) {\n if (router.activeTransition) {\n return router.activeTransition.followRedirects();\n }\n return _rsvp.Promise.reject(reason);\n });\n };\n\n Transition.prototype.toString = function toString() {\n return 'Transition (sequence ' + this.sequence + ')';\n };\n /**\n @private\n */\n\n Transition.prototype.log = function log(message) {\n _log(this.router, this.sequence, message);\n };\n\n return Transition;\n }();\n /**\n @private\n \n Logs and returns an instance of TransitionAborted.\n */\n\n function logAbort(transition) {\n _log(transition.router, transition.sequence, 'detected abort.');\n return new TransitionAbortedError();\n }\n function isTransition(obj) {\n return typeof obj === 'object' && obj instanceof Transition && obj.isTransition;\n }\n function prepareResult(obj) {\n if (isTransition(obj)) {\n return null;\n }\n return obj;\n }\n\n var ROUTE_INFOS = new WeakMap();\n function toReadOnlyRouteInfo(routeInfos) {\n var queryParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n var includeAttributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n return routeInfos.map(function (info, i) {\n var name = info.name,\n params = info.params,\n paramNames = info.paramNames,\n context = info.context,\n route = info.route;\n\n if (ROUTE_INFOS.has(info) && includeAttributes) {\n var _routeInfo = ROUTE_INFOS.get(info);\n _routeInfo = attachMetadata(route, _routeInfo);\n var routeInfoWithAttribute = createRouteInfoWithAttributes(_routeInfo, context);\n ROUTE_INFOS.set(info, routeInfoWithAttribute);\n return routeInfoWithAttribute;\n }\n var routeInfo = {\n find: function (predicate, thisArg) {\n var publicInfo = void 0;\n var arr = [];\n if (predicate.length === 3) {\n arr = routeInfos.map(function (info) {\n return ROUTE_INFOS.get(info);\n });\n }\n for (var _i = 0; routeInfos.length > _i; _i++) {\n publicInfo = ROUTE_INFOS.get(routeInfos[_i]);\n if (predicate.call(thisArg, publicInfo, _i, arr)) {\n return publicInfo;\n }\n }\n return undefined;\n },\n\n get name() {\n return name;\n },\n get paramNames() {\n return paramNames;\n },\n get metadata() {\n return buildRouteInfoMetadata(route);\n },\n get parent() {\n var parent = routeInfos[i - 1];\n if (parent === undefined) {\n return null;\n }\n return ROUTE_INFOS.get(parent);\n },\n get child() {\n var child = routeInfos[i + 1];\n if (child === undefined) {\n return null;\n }\n return ROUTE_INFOS.get(child);\n },\n get localName() {\n var parts = this.name.split('.');\n return parts[parts.length - 1];\n },\n get params() {\n return params;\n },\n get queryParams() {\n return queryParams;\n }\n };\n if (includeAttributes) {\n routeInfo = createRouteInfoWithAttributes(routeInfo, context);\n }\n ROUTE_INFOS.set(info, routeInfo);\n return routeInfo;\n });\n }\n function createRouteInfoWithAttributes(routeInfo, context) {\n var attributes = {\n get attributes() {\n return context;\n }\n };\n if (Object.isFrozen(routeInfo) || routeInfo.hasOwnProperty('attributes')) {\n return Object.freeze((0, _polyfills.assign)({}, routeInfo, attributes));\n }\n return (0, _polyfills.assign)(routeInfo, attributes);\n }\n function buildRouteInfoMetadata(route) {\n if (route !== undefined && route !== null && route.buildRouteInfoMetadata !== undefined) {\n return route.buildRouteInfoMetadata();\n }\n return null;\n }\n function attachMetadata(route, routeInfo) {\n var metadata = {\n get metadata() {\n return buildRouteInfoMetadata(route);\n }\n };\n if (Object.isFrozen(routeInfo) || routeInfo.hasOwnProperty('metadata')) {\n return Object.freeze((0, _polyfills.assign)({}, routeInfo, metadata));\n }\n return (0, _polyfills.assign)(routeInfo, metadata);\n }\n\n var InternalRouteInfo = function () {\n function InternalRouteInfo(router, name, paramNames, route) {\n\n this._routePromise = undefined;\n this._route = null;\n this.params = {};\n this.isResolved = false;\n this.name = name;\n this.paramNames = paramNames;\n this.router = router;\n if (route) {\n this._processRoute(route);\n }\n }\n\n InternalRouteInfo.prototype.getModel = function getModel(_transition) {\n return _rsvp.Promise.resolve(this.context);\n };\n\n InternalRouteInfo.prototype.serialize = function serialize(_context) {\n return this.params || {};\n };\n\n InternalRouteInfo.prototype.resolve = function resolve(shouldContinue, transition) {\n var _this2 = this;\n\n return _rsvp.Promise.resolve(this.routePromise).then(function (route) {\n return _this2.checkForAbort(shouldContinue, route);\n }).then(function () {\n return _this2.runBeforeModelHook(transition);\n }).then(function () {\n return _this2.checkForAbort(shouldContinue, null);\n }).then(function () {\n return _this2.getModel(transition);\n }).then(function (resolvedModel) {\n return _this2.checkForAbort(shouldContinue, resolvedModel);\n }).then(function (resolvedModel) {\n return _this2.runAfterModelHook(transition, resolvedModel);\n }).then(function (resolvedModel) {\n return _this2.becomeResolved(transition, resolvedModel);\n });\n };\n\n InternalRouteInfo.prototype.becomeResolved = function becomeResolved(transition, resolvedContext) {\n var params = this.serialize(resolvedContext);\n if (transition) {\n this.stashResolvedModel(transition, resolvedContext);\n transition[PARAMS_SYMBOL] = transition[PARAMS_SYMBOL] || {};\n transition[PARAMS_SYMBOL][this.name] = params;\n }\n var context = void 0;\n var contextsMatch = resolvedContext === this.context;\n if ('context' in this || !contextsMatch) {\n context = resolvedContext;\n }\n var cached = ROUTE_INFOS.get(this);\n var resolved = new ResolvedRouteInfo(this.router, this.name, this.paramNames, params, this.route, context);\n if (cached !== undefined) {\n ROUTE_INFOS.set(resolved, cached);\n }\n return resolved;\n };\n\n InternalRouteInfo.prototype.shouldSupercede = function shouldSupercede(routeInfo) {\n // Prefer this newer routeInfo over `other` if:\n // 1) The other one doesn't exist\n // 2) The names don't match\n // 3) This route has a context that doesn't match\n // the other one (or the other one doesn't have one).\n // 4) This route has parameters that don't match the other.\n if (!routeInfo) {\n return true;\n }\n var contextsMatch = routeInfo.context === this.context;\n return routeInfo.name !== this.name || 'context' in this && !contextsMatch || this.hasOwnProperty('params') && !paramsMatch(this.params, routeInfo.params);\n };\n\n InternalRouteInfo.prototype.log = function log(transition, message) {\n if (transition.log) {\n transition.log(this.name + ': ' + message);\n }\n };\n\n InternalRouteInfo.prototype.updateRoute = function updateRoute(route) {\n return this.route = route;\n };\n\n InternalRouteInfo.prototype.runBeforeModelHook = function runBeforeModelHook(transition) {\n if (transition.trigger) {\n transition.trigger(true, 'willResolveModel', transition, this.route);\n }\n var result = void 0;\n if (this.route) {\n if (this.route.beforeModel !== undefined) {\n result = this.route.beforeModel(transition);\n }\n }\n if (isTransition(result)) {\n result = null;\n }\n return _rsvp.Promise.resolve(result);\n };\n\n InternalRouteInfo.prototype.runAfterModelHook = function runAfterModelHook(transition, resolvedModel) {\n // Stash the resolved model on the payload.\n // This makes it possible for users to swap out\n // the resolved model in afterModel.\n var name = this.name;\n this.stashResolvedModel(transition, resolvedModel);\n var result = void 0;\n if (this.route !== undefined) {\n if (this.route.afterModel !== undefined) {\n result = this.route.afterModel(resolvedModel, transition);\n }\n }\n result = prepareResult(result);\n return _rsvp.Promise.resolve(result).then(function () {\n // Ignore the fulfilled value returned from afterModel.\n // Return the value stashed in resolvedModels, which\n // might have been swapped out in afterModel.\n return transition.resolvedModels[name];\n });\n };\n\n InternalRouteInfo.prototype.checkForAbort = function checkForAbort(shouldContinue, value) {\n return _rsvp.Promise.resolve(shouldContinue()).then(function () {\n // We don't care about shouldContinue's resolve value;\n // pass along the original value passed to this fn.\n return value;\n }, null);\n };\n\n InternalRouteInfo.prototype.stashResolvedModel = function stashResolvedModel(transition, resolvedModel) {\n transition.resolvedModels = transition.resolvedModels || {};\n transition.resolvedModels[this.name] = resolvedModel;\n };\n\n InternalRouteInfo.prototype.fetchRoute = function fetchRoute() {\n var route = this.router.getRoute(this.name);\n return this._processRoute(route);\n };\n\n InternalRouteInfo.prototype._processRoute = function _processRoute(route) {\n var _this3 = this;\n\n // Setup a routePromise so that we can wait for asynchronously loaded routes\n this.routePromise = _rsvp.Promise.resolve(route);\n // Wait until the 'route' property has been updated when chaining to a route\n // that is a promise\n if (isPromise(route)) {\n this.routePromise = this.routePromise.then(function (r) {\n return _this3.updateRoute(r);\n });\n // set to undefined to avoid recursive loop in the route getter\n return this.route = undefined;\n } else if (route) {\n return this.updateRoute(route);\n }\n return undefined;\n };\n\n (0, _emberBabel.createClass)(InternalRouteInfo, [{\n key: 'route',\n get: function () {\n // _route could be set to either a route object or undefined, so we\n // compare against null to know when it's been set\n if (this._route !== null) {\n return this._route;\n }\n return this.fetchRoute();\n },\n set: function (route) {\n this._route = route;\n }\n }, {\n key: 'routePromise',\n get: function () {\n if (this._routePromise) {\n return this._routePromise;\n }\n this.fetchRoute();\n return this._routePromise;\n },\n set: function (routePromise) {\n this._routePromise = routePromise;\n }\n }]);\n\n return InternalRouteInfo;\n }();\n\n var ResolvedRouteInfo = function (_InternalRouteInfo) {\n (0, _emberBabel.inherits)(ResolvedRouteInfo, _InternalRouteInfo);\n\n function ResolvedRouteInfo(router, name, paramNames, params, route, context) {\n\n var _this4 = (0, _emberBabel.possibleConstructorReturn)(this, _InternalRouteInfo.call(this, router, name, paramNames, route));\n\n _this4.params = params;\n _this4.isResolved = true;\n _this4.context = context;\n return _this4;\n }\n\n ResolvedRouteInfo.prototype.resolve = function resolve(_shouldContinue, transition) {\n // A ResolvedRouteInfo just resolved with itself.\n if (transition && transition.resolvedModels) {\n transition.resolvedModels[this.name] = this.context;\n }\n return _rsvp.Promise.resolve(this);\n };\n\n return ResolvedRouteInfo;\n }(InternalRouteInfo);\n\n var UnresolvedRouteInfoByParam = function (_InternalRouteInfo2) {\n (0, _emberBabel.inherits)(UnresolvedRouteInfoByParam, _InternalRouteInfo2);\n\n function UnresolvedRouteInfoByParam(router, name, paramNames, params, route) {\n\n var _this5 = (0, _emberBabel.possibleConstructorReturn)(this, _InternalRouteInfo2.call(this, router, name, paramNames, route));\n\n _this5.params = {};\n _this5.params = params;\n return _this5;\n }\n\n UnresolvedRouteInfoByParam.prototype.getModel = function getModel(transition) {\n var fullParams = this.params;\n if (transition && transition[QUERY_PARAMS_SYMBOL]) {\n fullParams = {};\n merge(fullParams, this.params);\n fullParams.queryParams = transition[QUERY_PARAMS_SYMBOL];\n }\n var route = this.route;\n var result = undefined;\n if (route.deserialize) {\n result = route.deserialize(fullParams, transition);\n } else if (route.model) {\n result = route.model(fullParams, transition);\n }\n if (result && isTransition(result)) {\n result = undefined;\n }\n return _rsvp.Promise.resolve(result);\n };\n\n return UnresolvedRouteInfoByParam;\n }(InternalRouteInfo);\n\n var UnresolvedRouteInfoByObject = function (_InternalRouteInfo3) {\n (0, _emberBabel.inherits)(UnresolvedRouteInfoByObject, _InternalRouteInfo3);\n\n function UnresolvedRouteInfoByObject(router, name, paramNames, context) {\n\n var _this6 = (0, _emberBabel.possibleConstructorReturn)(this, _InternalRouteInfo3.call(this, router, name, paramNames));\n\n _this6.context = context;\n _this6.serializer = _this6.router.getSerializer(name);\n return _this6;\n }\n\n UnresolvedRouteInfoByObject.prototype.getModel = function getModel(transition) {\n if (this.router.log !== undefined) {\n this.router.log(this.name + ': resolving provided model');\n }\n return _InternalRouteInfo3.prototype.getModel.call(this, transition);\n };\n /**\n @private\n Serializes a route using its custom `serialize` method or\n by a default that looks up the expected property name from\n the dynamic segment.\n @param {Object} model the model to be serialized for this route\n */\n\n UnresolvedRouteInfoByObject.prototype.serialize = function serialize(model) {\n var paramNames = this.paramNames,\n context = this.context;\n\n if (!model) {\n model = context;\n }\n var object = {};\n if (isParam(model)) {\n object[paramNames[0]] = model;\n return object;\n }\n // Use custom serialize if it exists.\n if (this.serializer) {\n // invoke this.serializer unbound (getSerializer returns a stateless function)\n return this.serializer.call(null, model, paramNames);\n } else if (this.route !== undefined) {\n if (this.route.serialize) {\n return this.route.serialize(model, paramNames);\n }\n }\n if (paramNames.length !== 1) {\n return;\n }\n var name = paramNames[0];\n if (/_id$/.test(name)) {\n object[name] = model.id;\n } else {\n object[name] = model;\n }\n return object;\n };\n\n return UnresolvedRouteInfoByObject;\n }(InternalRouteInfo);\n\n function paramsMatch(a, b) {\n if (!a !== !b) {\n // Only one is null.\n return false;\n }\n if (!a) {\n // Both must be null.\n return true;\n }\n // Note: this assumes that both params have the same\n // number of keys, but since we're comparing the\n // same routes, they should.\n for (var k in a) {\n if (a.hasOwnProperty(k) && a[k] !== b[k]) {\n return false;\n }\n }\n return true;\n }\n\n var TransitionIntent = function TransitionIntent(router) {\n var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n this.router = router;\n this.data = data;\n };\n\n var TransitionState = function () {\n function TransitionState() {\n\n this.routeInfos = [];\n this.queryParams = {};\n this.params = {};\n }\n\n TransitionState.prototype.promiseLabel = function promiseLabel(label) {\n var targetName = '';\n forEach(this.routeInfos, function (routeInfo) {\n if (targetName !== '') {\n targetName += '.';\n }\n targetName += routeInfo.name;\n return true;\n });\n return _promiseLabel(\"'\" + targetName + \"': \" + label);\n };\n\n TransitionState.prototype.resolve = function resolve(shouldContinue, transition) {\n // First, calculate params for this state. This is useful\n // information to provide to the various route hooks.\n var params = this.params;\n forEach(this.routeInfos, function (routeInfo) {\n params[routeInfo.name] = routeInfo.params || {};\n return true;\n });\n transition.resolveIndex = 0;\n var currentState = this;\n var wasAborted = false;\n // The prelude RSVP.resolve() asyncs us into the promise land.\n return _rsvp.Promise.resolve(null, this.promiseLabel('Start transition')).then(resolveOneRouteInfo, null, this.promiseLabel('Resolve route')).catch(handleError, this.promiseLabel('Handle error'));\n function innerShouldContinue() {\n return _rsvp.Promise.resolve(shouldContinue(), currentState.promiseLabel('Check if should continue')).catch(function (reason) {\n // We distinguish between errors that occurred\n // during resolution (e.g. before\"Model/model/afterModel),\n // and aborts due to a rejecting promise from shouldContinue().\n wasAborted = true;\n return _rsvp.Promise.reject(reason);\n }, currentState.promiseLabel('Handle abort'));\n }\n function handleError(error) {\n // This is the only possible\n // reject value of TransitionState#resolve\n var routeInfos = currentState.routeInfos;\n var errorHandlerIndex = transition.resolveIndex >= routeInfos.length ? routeInfos.length - 1 : transition.resolveIndex;\n return _rsvp.Promise.reject(new TransitionError(error, currentState.routeInfos[errorHandlerIndex].route, wasAborted, currentState));\n }\n function proceed(resolvedRouteInfo) {\n var wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved;\n // Swap the previously unresolved routeInfo with\n // the resolved routeInfo\n currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;\n if (!wasAlreadyResolved) {\n // Call the redirect hook. The reason we call it here\n // vs. afterModel is so that redirects into child\n // routes don't re-run the model hooks for this\n // already-resolved route.\n var route = resolvedRouteInfo.route;\n\n if (route !== undefined) {\n if (route.redirect) {\n route.redirect(resolvedRouteInfo.context, transition);\n }\n }\n }\n // Proceed after ensuring that the redirect hook\n // didn't abort this transition by transitioning elsewhere.\n return innerShouldContinue().then(resolveOneRouteInfo, null, currentState.promiseLabel('Resolve route'));\n }\n function resolveOneRouteInfo() {\n if (transition.resolveIndex === currentState.routeInfos.length) {\n // This is is the only possible\n // fulfill value of TransitionState#resolve\n return currentState;\n }\n var routeInfo = currentState.routeInfos[transition.resolveIndex];\n return routeInfo.resolve(innerShouldContinue, transition).then(proceed, null, currentState.promiseLabel('Proceed'));\n }\n };\n\n return TransitionState;\n }();\n\n var TransitionError = function TransitionError(error, route, wasAborted, state) {\n\n this.error = error;\n this.route = route;\n this.wasAborted = wasAborted;\n this.state = state;\n };\n\n var NamedTransitionIntent = function (_TransitionIntent) {\n (0, _emberBabel.inherits)(NamedTransitionIntent, _TransitionIntent);\n\n function NamedTransitionIntent(router, name, pivotHandler) {\n var contexts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];\n var queryParams = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};\n var data = arguments[5];\n\n var _this7 = (0, _emberBabel.possibleConstructorReturn)(this, _TransitionIntent.call(this, router, data));\n\n _this7.preTransitionState = undefined;\n _this7.name = name;\n _this7.pivotHandler = pivotHandler;\n _this7.contexts = contexts;\n _this7.queryParams = queryParams;\n return _this7;\n }\n\n NamedTransitionIntent.prototype.applyToState = function applyToState(oldState, isIntermediate) {\n // TODO: WTF fix me\n var partitionedArgs = extractQueryParams([this.name].concat(this.contexts)),\n pureArgs = partitionedArgs[0],\n handlers = this.router.recognizer.handlersFor(pureArgs[0]);\n var targetRouteName = handlers[handlers.length - 1].handler;\n return this.applyToHandlers(oldState, handlers, targetRouteName, isIntermediate, false);\n };\n\n NamedTransitionIntent.prototype.applyToHandlers = function applyToHandlers(oldState, parsedHandlers, targetRouteName, isIntermediate, checkingIfActive) {\n var i = void 0,\n len = void 0;\n var newState = new TransitionState();\n var objects = this.contexts.slice(0);\n var invalidateIndex = parsedHandlers.length;\n // Pivot handlers are provided for refresh transitions\n if (this.pivotHandler) {\n for (i = 0, len = parsedHandlers.length; i < len; ++i) {\n if (parsedHandlers[i].handler === this.pivotHandler.routeName) {\n invalidateIndex = i;\n break;\n }\n }\n }\n for (i = parsedHandlers.length - 1; i >= 0; --i) {\n var result = parsedHandlers[i];\n var name = result.handler;\n var oldHandlerInfo = oldState.routeInfos[i];\n var newHandlerInfo = null;\n if (result.names.length > 0) {\n if (i >= invalidateIndex) {\n newHandlerInfo = this.createParamHandlerInfo(name, result.names, objects, oldHandlerInfo);\n } else {\n newHandlerInfo = this.getHandlerInfoForDynamicSegment(name, result.names, objects, oldHandlerInfo, targetRouteName, i);\n }\n } else {\n // This route has no dynamic segment.\n // Therefore treat as a param-based handlerInfo\n // with empty params. This will cause the `model`\n // hook to be called with empty params, which is desirable.\n newHandlerInfo = this.createParamHandlerInfo(name, result.names, objects, oldHandlerInfo);\n }\n if (checkingIfActive) {\n // If we're performing an isActive check, we want to\n // serialize URL params with the provided context, but\n // ignore mismatches between old and new context.\n newHandlerInfo = newHandlerInfo.becomeResolved(null, newHandlerInfo.context);\n var oldContext = oldHandlerInfo && oldHandlerInfo.context;\n if (result.names.length > 0 && oldHandlerInfo.context !== undefined && newHandlerInfo.context === oldContext) {\n // If contexts match in isActive test, assume params also match.\n // This allows for flexibility in not requiring that every last\n // handler provide a `serialize` method\n newHandlerInfo.params = oldHandlerInfo && oldHandlerInfo.params;\n }\n newHandlerInfo.context = oldContext;\n }\n var handlerToUse = oldHandlerInfo;\n if (i >= invalidateIndex || newHandlerInfo.shouldSupercede(oldHandlerInfo)) {\n invalidateIndex = Math.min(i, invalidateIndex);\n handlerToUse = newHandlerInfo;\n }\n if (isIntermediate && !checkingIfActive) {\n handlerToUse = handlerToUse.becomeResolved(null, handlerToUse.context);\n }\n newState.routeInfos.unshift(handlerToUse);\n }\n if (objects.length > 0) {\n throw new Error('More context objects were passed than there are dynamic segments for the route: ' + targetRouteName);\n }\n if (!isIntermediate) {\n this.invalidateChildren(newState.routeInfos, invalidateIndex);\n }\n merge(newState.queryParams, this.queryParams || {});\n return newState;\n };\n\n NamedTransitionIntent.prototype.invalidateChildren = function invalidateChildren(handlerInfos, invalidateIndex) {\n for (var i = invalidateIndex, l = handlerInfos.length; i < l; ++i) {\n var handlerInfo = handlerInfos[i];\n if (handlerInfo.isResolved) {\n var _handlerInfos$i = handlerInfos[i],\n name = _handlerInfos$i.name,\n params = _handlerInfos$i.params,\n route = _handlerInfos$i.route,\n paramNames = _handlerInfos$i.paramNames;\n\n handlerInfos[i] = new UnresolvedRouteInfoByParam(this.router, name, paramNames, params, route);\n }\n }\n };\n\n NamedTransitionIntent.prototype.getHandlerInfoForDynamicSegment = function getHandlerInfoForDynamicSegment(name, names, objects, oldHandlerInfo, _targetRouteName, i) {\n var objectToUse = void 0;\n if (objects.length > 0) {\n // Use the objects provided for this transition.\n objectToUse = objects[objects.length - 1];\n if (isParam(objectToUse)) {\n return this.createParamHandlerInfo(name, names, objects, oldHandlerInfo);\n } else {\n objects.pop();\n }\n } else if (oldHandlerInfo && oldHandlerInfo.name === name) {\n // Reuse the matching oldHandlerInfo\n return oldHandlerInfo;\n } else {\n if (this.preTransitionState) {\n var preTransitionHandlerInfo = this.preTransitionState.routeInfos[i];\n objectToUse = preTransitionHandlerInfo && preTransitionHandlerInfo.context;\n } else {\n // Ideally we should throw this error to provide maximal\n // information to the user that not enough context objects\n // were provided, but this proves too cumbersome in Ember\n // in cases where inner template helpers are evaluated\n // before parent helpers un-render, in which cases this\n // error somewhat prematurely fires.\n //throw new Error(\"Not enough context objects were provided to complete a transition to \" + targetRouteName + \". Specifically, the \" + name + \" route needs an object that can be serialized into its dynamic URL segments [\" + names.join(', ') + \"]\");\n return oldHandlerInfo;\n }\n }\n return new UnresolvedRouteInfoByObject(this.router, name, names, objectToUse);\n };\n\n NamedTransitionIntent.prototype.createParamHandlerInfo = function createParamHandlerInfo(name, names, objects, oldHandlerInfo) {\n var params = {};\n // Soak up all the provided string/numbers\n var numNames = names.length;\n while (numNames--) {\n // Only use old params if the names match with the new handler\n var oldParams = oldHandlerInfo && name === oldHandlerInfo.name && oldHandlerInfo.params || {};\n var peek = objects[objects.length - 1];\n var paramName = names[numNames];\n if (isParam(peek)) {\n params[paramName] = '' + objects.pop();\n } else {\n // If we're here, this means only some of the params\n // were string/number params, so try and use a param\n // value from a previous handler.\n if (oldParams.hasOwnProperty(paramName)) {\n params[paramName] = oldParams[paramName];\n } else {\n throw new Error(\"You didn't provide enough string/numeric parameters to satisfy all of the dynamic segments for route \" + name);\n }\n }\n }\n return new UnresolvedRouteInfoByParam(this.router, name, names, params);\n };\n\n return NamedTransitionIntent;\n }(TransitionIntent);\n\n var UnrecognizedURLError = function () {\n UnrecognizedURLError.prototype = Object.create(Error.prototype);\n UnrecognizedURLError.prototype.constructor = UnrecognizedURLError;\n function UnrecognizedURLError(message) {\n var error = Error.call(this, message);\n this.name = 'UnrecognizedURLError';\n this.message = message || 'UnrecognizedURL';\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, UnrecognizedURLError);\n } else {\n this.stack = error.stack;\n }\n }\n return UnrecognizedURLError;\n }();\n\n var URLTransitionIntent = function (_TransitionIntent2) {\n (0, _emberBabel.inherits)(URLTransitionIntent, _TransitionIntent2);\n\n function URLTransitionIntent(router, url, data) {\n\n var _this8 = (0, _emberBabel.possibleConstructorReturn)(this, _TransitionIntent2.call(this, router, data));\n\n _this8.url = url;\n _this8.preTransitionState = undefined;\n return _this8;\n }\n\n URLTransitionIntent.prototype.applyToState = function applyToState(oldState) {\n var newState = new TransitionState();\n var results = this.router.recognizer.recognize(this.url),\n i = void 0,\n len = void 0;\n if (!results) {\n throw new UnrecognizedURLError(this.url);\n }\n var statesDiffer = false;\n var _url = this.url;\n // Checks if a handler is accessible by URL. If it is not, an error is thrown.\n // For the case where the handler is loaded asynchronously, the error will be\n // thrown once it is loaded.\n function checkHandlerAccessibility(handler) {\n if (handler && handler.inaccessibleByURL) {\n throw new UnrecognizedURLError(_url);\n }\n return handler;\n }\n for (i = 0, len = results.length; i < len; ++i) {\n var result = results[i];\n var name = result.handler;\n var paramNames = [];\n if (this.router.recognizer.hasRoute(name)) {\n paramNames = this.router.recognizer.handlersFor(name)[i].names;\n }\n var newRouteInfo = new UnresolvedRouteInfoByParam(this.router, name, paramNames, result.params);\n var route = newRouteInfo.route;\n if (route) {\n checkHandlerAccessibility(route);\n } else {\n // If the hanlder is being loaded asynchronously, check if we can\n // access it after it has resolved\n newRouteInfo.routePromise = newRouteInfo.routePromise.then(checkHandlerAccessibility);\n }\n var oldRouteInfo = oldState.routeInfos[i];\n if (statesDiffer || newRouteInfo.shouldSupercede(oldRouteInfo)) {\n statesDiffer = true;\n newState.routeInfos[i] = newRouteInfo;\n } else {\n newState.routeInfos[i] = oldRouteInfo;\n }\n }\n merge(newState.queryParams, results.queryParams);\n return newState;\n };\n\n return URLTransitionIntent;\n }(TransitionIntent);\n\n var Router = function () {\n function Router(logger) {\n\n this._lastQueryParams = {};\n this.state = undefined;\n this.oldState = undefined;\n this.activeTransition = undefined;\n this.currentRouteInfos = undefined;\n this._changedQueryParams = undefined;\n this.currentSequence = 0;\n this.log = logger;\n this.recognizer = new _routeRecognizer.default();\n this.reset();\n }\n /**\n The main entry point into the router. The API is essentially\n the same as the `map` method in `route-recognizer`.\n This method extracts the String handler at the last `.to()`\n call and uses it as the name of the whole route.\n @param {Function} callback\n */\n\n Router.prototype.map = function map(callback) {\n this.recognizer.map(callback, function (recognizer, routes) {\n for (var i = routes.length - 1, proceed = true; i >= 0 && proceed; --i) {\n var route = routes[i];\n var handler = route.handler;\n recognizer.add(routes, { as: handler });\n proceed = route.path === '/' || route.path === '' || handler.slice(-6) === '.index';\n }\n });\n };\n\n Router.prototype.hasRoute = function hasRoute(route) {\n return this.recognizer.hasRoute(route);\n };\n\n Router.prototype.queryParamsTransition = function queryParamsTransition(changelist, wasTransitioning, oldState, newState) {\n var _this9 = this;\n\n this.fireQueryParamDidChange(newState, changelist);\n if (!wasTransitioning && this.activeTransition) {\n // One of the routes in queryParamsDidChange\n // caused a transition. Just return that transition.\n return this.activeTransition;\n } else {\n // Running queryParamsDidChange didn't change anything.\n // Just update query params and be on our way.\n // We have to return a noop transition that will\n // perform a URL update at the end. This gives\n // the user the ability to set the url update\n // method (default is replaceState).\n var newTransition = new Transition(this, undefined, undefined);\n newTransition.queryParamsOnly = true;\n oldState.queryParams = this.finalizeQueryParamChange(newState.routeInfos, newState.queryParams, newTransition);\n newTransition[QUERY_PARAMS_SYMBOL] = newState.queryParams;\n this.toReadOnlyInfos(newTransition, newState);\n this.routeWillChange(newTransition);\n newTransition.promise = newTransition.promise.then(function (result) {\n _this9._updateURL(newTransition, oldState);\n _this9.didTransition(_this9.currentRouteInfos);\n _this9.toInfos(newTransition, newState.routeInfos, true);\n _this9.routeDidChange(newTransition);\n return result;\n }, null, _promiseLabel('Transition complete'));\n return newTransition;\n }\n };\n\n Router.prototype.transitionByIntent = function transitionByIntent(intent, isIntermediate) {\n try {\n return this.getTransitionByIntent(intent, isIntermediate);\n } catch (e) {\n return new Transition(this, intent, undefined, e, undefined);\n }\n };\n\n Router.prototype.recognize = function recognize(url) {\n var intent = new URLTransitionIntent(this, url);\n var newState = this.generateNewState(intent);\n if (newState === null) {\n return newState;\n }\n var readonlyInfos = toReadOnlyRouteInfo(newState.routeInfos, newState.queryParams);\n return readonlyInfos[readonlyInfos.length - 1];\n };\n\n Router.prototype.recognizeAndLoad = function recognizeAndLoad(url) {\n var intent = new URLTransitionIntent(this, url);\n var newState = this.generateNewState(intent);\n if (newState === null) {\n return _rsvp.Promise.reject('URL ' + url + ' was not recognized');\n }\n var newTransition = new Transition(this, intent, newState, undefined);\n return newTransition.then(function () {\n var routeInfosWithAttributes = toReadOnlyRouteInfo(newState.routeInfos, newTransition[QUERY_PARAMS_SYMBOL], true);\n return routeInfosWithAttributes[routeInfosWithAttributes.length - 1];\n });\n };\n\n Router.prototype.generateNewState = function generateNewState(intent) {\n try {\n return intent.applyToState(this.state, false);\n } catch (e) {\n return null;\n }\n };\n\n Router.prototype.getTransitionByIntent = function getTransitionByIntent(intent, isIntermediate) {\n var _this10 = this;\n\n var wasTransitioning = !!this.activeTransition;\n var oldState = wasTransitioning ? this.activeTransition[STATE_SYMBOL] : this.state;\n var newTransition = void 0;\n var newState = intent.applyToState(oldState, isIntermediate);\n var queryParamChangelist = getChangelist(oldState.queryParams, newState.queryParams);\n if (routeInfosEqual(newState.routeInfos, oldState.routeInfos)) {\n // This is a no-op transition. See if query params changed.\n if (queryParamChangelist) {\n var _newTransition = this.queryParamsTransition(queryParamChangelist, wasTransitioning, oldState, newState);\n _newTransition.queryParamsOnly = true;\n return _newTransition;\n }\n // No-op. No need to create a new transition.\n return this.activeTransition || new Transition(this, undefined, undefined);\n }\n if (isIntermediate) {\n this.setupContexts(newState);\n var transition = this.activeTransition;\n if (transition !== undefined && !transition.isCausedByAbortingTransition) {\n transition = new Transition(this, undefined, undefined);\n transition.from = transition.from;\n }\n this.toInfos(transition, newState.routeInfos);\n this.routeWillChange(transition);\n return this.activeTransition;\n }\n // Create a new transition to the destination route.\n newTransition = new Transition(this, intent, newState, undefined, this.activeTransition);\n // transition is to same route with same params, only query params differ.\n // not caught above probably because refresh() has been used\n if (routeInfosSameExceptQueryParams(newState.routeInfos, oldState.routeInfos)) {\n newTransition.queryParamsOnly = true;\n }\n this.toReadOnlyInfos(newTransition, newState);\n // Abort and usurp any previously active transition.\n if (this.activeTransition) {\n this.activeTransition.redirect(newTransition);\n }\n this.activeTransition = newTransition;\n // Transition promises by default resolve with resolved state.\n // For our purposes, swap out the promise to resolve\n // after the transition has been finalized.\n newTransition.promise = newTransition.promise.then(function (result) {\n return _this10.finalizeTransition(newTransition, result);\n }, null, _promiseLabel('Settle transition promise when transition is finalized'));\n if (!wasTransitioning) {\n this.notifyExistingHandlers(newState, newTransition);\n }\n this.fireQueryParamDidChange(newState, queryParamChangelist);\n return newTransition;\n };\n /**\n @private\n Begins and returns a Transition based on the provided\n arguments. Accepts arguments in the form of both URL\n transitions and named transitions.\n @param {Router} router\n @param {Array[Object]} args arguments passed to transitionTo,\n replaceWith, or handleURL\n */\n\n Router.prototype.doTransition = function doTransition(name) {\n var modelsArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n var isIntermediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n var lastArg = modelsArray[modelsArray.length - 1];\n var queryParams = {};\n if (lastArg !== undefined && lastArg.hasOwnProperty('queryParams')) {\n queryParams = modelsArray.pop().queryParams;\n }\n var intent = void 0;\n if (name === undefined) {\n _log(this, 'Updating query params');\n // A query param update is really just a transition\n // into the route you're already on.\n var routeInfos = this.state.routeInfos;\n\n intent = new NamedTransitionIntent(this, routeInfos[routeInfos.length - 1].name, undefined, [], queryParams);\n } else if (name.charAt(0) === '/') {\n _log(this, 'Attempting URL transition to ' + name);\n intent = new URLTransitionIntent(this, name);\n } else {\n _log(this, 'Attempting transition to ' + name);\n intent = new NamedTransitionIntent(this, name, undefined, modelsArray, queryParams);\n }\n return this.transitionByIntent(intent, isIntermediate);\n };\n /**\n @private\n Updates the URL (if necessary) and calls `setupContexts`\n to update the router's array of `currentRouteInfos`.\n */\n\n Router.prototype.finalizeTransition = function finalizeTransition(transition, newState) {\n try {\n _log(transition.router, transition.sequence, 'Resolved all models on destination route; finalizing transition.');\n var routeInfos = newState.routeInfos;\n // Run all the necessary enter/setup/exit hooks\n this.setupContexts(newState, transition);\n // Check if a redirect occurred in enter/setup\n if (transition.isAborted) {\n // TODO: cleaner way? distinguish b/w targetRouteInfos?\n this.state.routeInfos = this.currentRouteInfos;\n return _rsvp.Promise.reject(logAbort(transition));\n }\n this._updateURL(transition, newState);\n transition.isActive = false;\n this.activeTransition = undefined;\n this.triggerEvent(this.currentRouteInfos, true, 'didTransition', []);\n this.didTransition(this.currentRouteInfos);\n this.toInfos(transition, newState.routeInfos, true);\n this.routeDidChange(transition);\n _log(this, transition.sequence, 'TRANSITION COMPLETE.');\n // Resolve with the final route.\n return routeInfos[routeInfos.length - 1].route;\n } catch (e) {\n if (!(e instanceof TransitionAbortedError)) {\n var infos = transition[STATE_SYMBOL].routeInfos;\n transition.trigger(true, 'error', e, transition, infos[infos.length - 1].route);\n transition.abort();\n }\n throw e;\n }\n };\n /**\n @private\n Takes an Array of `RouteInfo`s, figures out which ones are\n exiting, entering, or changing contexts, and calls the\n proper route hooks.\n For example, consider the following tree of routes. Each route is\n followed by the URL segment it handles.\n ```\n |~index (\"/\")\n | |~posts (\"/posts\")\n | | |-showPost (\"/:id\")\n | | |-newPost (\"/new\")\n | | |-editPost (\"/edit\")\n | |~about (\"/about/:id\")\n ```\n Consider the following transitions:\n 1. A URL transition to `/posts/1`.\n 1. Triggers the `*model` callbacks on the\n `index`, `posts`, and `showPost` routes\n 2. Triggers the `enter` callback on the same\n 3. Triggers the `setup` callback on the same\n 2. A direct transition to `newPost`\n 1. Triggers the `exit` callback on `showPost`\n 2. Triggers the `enter` callback on `newPost`\n 3. Triggers the `setup` callback on `newPost`\n 3. A direct transition to `about` with a specified\n context object\n 1. Triggers the `exit` callback on `newPost`\n and `posts`\n 2. Triggers the `serialize` callback on `about`\n 3. Triggers the `enter` callback on `about`\n 4. Triggers the `setup` callback on `about`\n @param {Router} transition\n @param {TransitionState} newState\n */\n\n Router.prototype.setupContexts = function setupContexts(newState, transition) {\n var partition = this.partitionRoutes(this.state, newState);\n var i = void 0,\n l = void 0,\n route = void 0;\n for (i = 0, l = partition.exited.length; i < l; i++) {\n route = partition.exited[i].route;\n delete route.context;\n if (route !== undefined) {\n if (route._internalReset !== undefined) {\n route._internalReset(true, transition);\n }\n if (route.exit !== undefined) {\n route.exit(transition);\n }\n }\n }\n var oldState = this.oldState = this.state;\n this.state = newState;\n var currentRouteInfos = this.currentRouteInfos = partition.unchanged.slice();\n try {\n for (i = 0, l = partition.reset.length; i < l; i++) {\n route = partition.reset[i].route;\n if (route !== undefined) {\n if (route._internalReset !== undefined) {\n route._internalReset(false, transition);\n }\n }\n }\n for (i = 0, l = partition.updatedContext.length; i < l; i++) {\n this.routeEnteredOrUpdated(currentRouteInfos, partition.updatedContext[i], false, transition);\n }\n for (i = 0, l = partition.entered.length; i < l; i++) {\n this.routeEnteredOrUpdated(currentRouteInfos, partition.entered[i], true, transition);\n }\n } catch (e) {\n this.state = oldState;\n this.currentRouteInfos = oldState.routeInfos;\n throw e;\n }\n this.state.queryParams = this.finalizeQueryParamChange(currentRouteInfos, newState.queryParams, transition);\n };\n /**\n @private\n Fires queryParamsDidChange event\n */\n\n Router.prototype.fireQueryParamDidChange = function fireQueryParamDidChange(newState, queryParamChangelist) {\n // If queryParams changed trigger event\n if (queryParamChangelist) {\n // This is a little hacky but we need some way of storing\n // changed query params given that no activeTransition\n // is guaranteed to have occurred.\n this._changedQueryParams = queryParamChangelist.all;\n this.triggerEvent(newState.routeInfos, true, 'queryParamsDidChange', [queryParamChangelist.changed, queryParamChangelist.all, queryParamChangelist.removed]);\n this._changedQueryParams = undefined;\n }\n };\n /**\n @private\n Helper method used by setupContexts. Handles errors or redirects\n that may happen in enter/setup.\n */\n\n Router.prototype.routeEnteredOrUpdated = function routeEnteredOrUpdated(currentRouteInfos, routeInfo, enter, transition) {\n var route = routeInfo.route,\n context = routeInfo.context;\n function _routeEnteredOrUpdated(route) {\n if (enter) {\n if (route.enter !== undefined) {\n route.enter(transition);\n }\n }\n if (transition && transition.isAborted) {\n throw new TransitionAbortedError();\n }\n route.context = context;\n if (route.contextDidChange !== undefined) {\n route.contextDidChange();\n }\n if (route.setup !== undefined) {\n route.setup(context, transition);\n }\n if (transition && transition.isAborted) {\n throw new TransitionAbortedError();\n }\n currentRouteInfos.push(routeInfo);\n return route;\n }\n // If the route doesn't exist, it means we haven't resolved the route promise yet\n if (route === undefined) {\n routeInfo.routePromise = routeInfo.routePromise.then(_routeEnteredOrUpdated);\n } else {\n _routeEnteredOrUpdated(route);\n }\n return true;\n };\n /**\n @private\n This function is called when transitioning from one URL to\n another to determine which routes are no longer active,\n which routes are newly active, and which routes remain\n active but have their context changed.\n Take a list of old routes and new routes and partition\n them into four buckets:\n * unchanged: the route was active in both the old and\n new URL, and its context remains the same\n * updated context: the route was active in both the\n old and new URL, but its context changed. The route's\n `setup` method, if any, will be called with the new\n context.\n * exited: the route was active in the old URL, but is\n no longer active.\n * entered: the route was not active in the old URL, but\n is now active.\n The PartitionedRoutes structure has four fields:\n * `updatedContext`: a list of `RouteInfo` objects that\n represent routes that remain active but have a changed\n context\n * `entered`: a list of `RouteInfo` objects that represent\n routes that are newly active\n * `exited`: a list of `RouteInfo` objects that are no\n longer active.\n * `unchanged`: a list of `RouteInfo` objects that remain active.\n @param {Array[InternalRouteInfo]} oldRoutes a list of the route\n information for the previous URL (or `[]` if this is the\n first handled transition)\n @param {Array[InternalRouteInfo]} newRoutes a list of the route\n information for the new URL\n @return {Partition}\n */\n\n Router.prototype.partitionRoutes = function partitionRoutes(oldState, newState) {\n var oldRouteInfos = oldState.routeInfos;\n var newRouteInfos = newState.routeInfos;\n var routes = {\n updatedContext: [],\n exited: [],\n entered: [],\n unchanged: [],\n reset: []\n };\n var routeChanged = void 0,\n contextChanged = false,\n i = void 0,\n l = void 0;\n for (i = 0, l = newRouteInfos.length; i < l; i++) {\n var oldRouteInfo = oldRouteInfos[i],\n newRouteInfo = newRouteInfos[i];\n if (!oldRouteInfo || oldRouteInfo.route !== newRouteInfo.route) {\n routeChanged = true;\n }\n if (routeChanged) {\n routes.entered.push(newRouteInfo);\n if (oldRouteInfo) {\n routes.exited.unshift(oldRouteInfo);\n }\n } else if (contextChanged || oldRouteInfo.context !== newRouteInfo.context) {\n contextChanged = true;\n routes.updatedContext.push(newRouteInfo);\n } else {\n routes.unchanged.push(oldRouteInfo);\n }\n }\n for (i = newRouteInfos.length, l = oldRouteInfos.length; i < l; i++) {\n routes.exited.unshift(oldRouteInfos[i]);\n }\n routes.reset = routes.updatedContext.slice();\n routes.reset.reverse();\n return routes;\n };\n\n Router.prototype._updateURL = function _updateURL(transition, state) {\n var urlMethod = transition.urlMethod;\n if (!urlMethod) {\n return;\n }\n var routeInfos = state.routeInfos;\n var routeName = routeInfos[routeInfos.length - 1].name;\n\n var params = {};\n for (var i = routeInfos.length - 1; i >= 0; --i) {\n var routeInfo = routeInfos[i];\n merge(params, routeInfo.params);\n if (routeInfo.route.inaccessibleByURL) {\n urlMethod = null;\n }\n }\n if (urlMethod) {\n params.queryParams = transition._visibleQueryParams || state.queryParams;\n var url = this.recognizer.generate(routeName, params);\n // transitions during the initial transition must always use replaceURL.\n // When the app boots, you are at a url, e.g. /foo. If some route\n // redirects to bar as part of the initial transition, you don't want to\n // add a history entry for /foo. If you do, pressing back will immediately\n // hit the redirect again and take you back to /bar, thus killing the back\n // button\n var initial = transition.isCausedByInitialTransition;\n // say you are at / and you click a link to route /foo. In /foo's\n // route, the transition is aborted using replacewith('/bar').\n // Because the current url is still /, the history entry for / is\n // removed from the history. Clicking back will take you to the page\n // you were on before /, which is often not even the app, thus killing\n // the back button. That's why updateURL is always correct for an\n // aborting transition that's not the initial transition\n var replaceAndNotAborting = urlMethod === 'replace' && !transition.isCausedByAbortingTransition;\n // because calling refresh causes an aborted transition, this needs to be\n // special cased - if the initial transition is a replace transition, the\n // urlMethod should be honored here.\n var isQueryParamsRefreshTransition = transition.queryParamsOnly && urlMethod === 'replace';\n // say you are at / and you a `replaceWith(/foo)` is called. Then, that\n // transition is aborted with `replaceWith(/bar)`. At the end, we should\n // end up with /bar replacing /. We are replacing the replace. We only\n // will replace the initial route if all subsequent aborts are also\n // replaces. However, there is some ambiguity around the correct behavior\n // here.\n var replacingReplace = urlMethod === 'replace' && transition.isCausedByAbortingReplaceTransition;\n if (initial || replaceAndNotAborting || isQueryParamsRefreshTransition || replacingReplace) {\n this.replaceURL(url);\n } else {\n this.updateURL(url);\n }\n }\n };\n\n Router.prototype.finalizeQueryParamChange = function finalizeQueryParamChange(resolvedHandlers, newQueryParams, transition) {\n // We fire a finalizeQueryParamChange event which\n // gives the new route hierarchy a chance to tell\n // us which query params it's consuming and what\n // their final values are. If a query param is\n // no longer consumed in the final route hierarchy,\n // its serialized segment will be removed\n // from the URL.\n for (var k in newQueryParams) {\n if (newQueryParams.hasOwnProperty(k) && newQueryParams[k] === null) {\n delete newQueryParams[k];\n }\n }\n var finalQueryParamsArray = [];\n this.triggerEvent(resolvedHandlers, true, 'finalizeQueryParamChange', [newQueryParams, finalQueryParamsArray, transition]);\n if (transition) {\n transition._visibleQueryParams = {};\n }\n var finalQueryParams = {};\n for (var i = 0, len = finalQueryParamsArray.length; i < len; ++i) {\n var qp = finalQueryParamsArray[i];\n finalQueryParams[qp.key] = qp.value;\n if (transition && qp.visible !== false) {\n transition._visibleQueryParams[qp.key] = qp.value;\n }\n }\n return finalQueryParams;\n };\n\n Router.prototype.toReadOnlyInfos = function toReadOnlyInfos(newTransition, newState) {\n var oldRouteInfos = this.state.routeInfos;\n this.fromInfos(newTransition, oldRouteInfos);\n this.toInfos(newTransition, newState.routeInfos);\n this._lastQueryParams = newState.queryParams;\n };\n\n Router.prototype.fromInfos = function fromInfos(newTransition, oldRouteInfos) {\n if (newTransition !== undefined && oldRouteInfos.length > 0) {\n var fromInfos = toReadOnlyRouteInfo(oldRouteInfos, (0, _polyfills.assign)({}, this._lastQueryParams), true);\n newTransition.from = fromInfos[fromInfos.length - 1] || null;\n }\n };\n\n Router.prototype.toInfos = function toInfos(newTransition, newRouteInfos) {\n var includeAttributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n if (newTransition !== undefined && newRouteInfos.length > 0) {\n var toInfos = toReadOnlyRouteInfo(newRouteInfos, (0, _polyfills.assign)({}, newTransition[QUERY_PARAMS_SYMBOL]), includeAttributes);\n newTransition.to = toInfos[toInfos.length - 1] || null;\n }\n };\n\n Router.prototype.notifyExistingHandlers = function notifyExistingHandlers(newState, newTransition) {\n var oldRouteInfos = this.state.routeInfos,\n i = void 0,\n oldRouteInfoLen = void 0,\n oldHandler = void 0,\n newRouteInfo = void 0;\n oldRouteInfoLen = oldRouteInfos.length;\n for (i = 0; i < oldRouteInfoLen; i++) {\n oldHandler = oldRouteInfos[i];\n newRouteInfo = newState.routeInfos[i];\n if (!newRouteInfo || oldHandler.name !== newRouteInfo.name) {\n break;\n }\n if (!newRouteInfo.isResolved) {}\n }\n this.triggerEvent(oldRouteInfos, true, 'willTransition', [newTransition]);\n this.routeWillChange(newTransition);\n this.willTransition(oldRouteInfos, newState.routeInfos, newTransition);\n };\n /**\n Clears the current and target route routes and triggers exit\n on each of them starting at the leaf and traversing up through\n its ancestors.\n */\n\n Router.prototype.reset = function reset() {\n if (this.state) {\n forEach(this.state.routeInfos.slice().reverse(), function (routeInfo) {\n var route = routeInfo.route;\n if (route !== undefined) {\n if (route.exit !== undefined) {\n route.exit();\n }\n }\n return true;\n });\n }\n this.oldState = undefined;\n this.state = new TransitionState();\n this.currentRouteInfos = undefined;\n };\n /**\n let handler = routeInfo.handler;\n The entry point for handling a change to the URL (usually\n via the back and forward button).\n Returns an Array of handlers and the parameters associated\n with those parameters.\n @param {String} url a URL to process\n @return {Array} an Array of `[handler, parameter]` tuples\n */\n\n Router.prototype.handleURL = function handleURL(url) {\n // Perform a URL-based transition, but don't change\n // the URL afterward, since it already happened.\n if (url.charAt(0) !== '/') {\n url = '/' + url;\n }\n return this.doTransition(url).method(null);\n };\n /**\n Transition into the specified named route.\n If necessary, trigger the exit callback on any routes\n that are no longer represented by the target route.\n @param {String} name the name of the route\n */\n\n Router.prototype.transitionTo = function transitionTo(name) {\n for (var _len3 = arguments.length, contexts = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n contexts[_key3 - 1] = arguments[_key3];\n }\n\n if (typeof name === 'object') {\n contexts.push(name);\n return this.doTransition(undefined, contexts, false);\n }\n return this.doTransition(name, contexts);\n };\n\n Router.prototype.intermediateTransitionTo = function intermediateTransitionTo(name) {\n for (var _len4 = arguments.length, args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n args[_key4 - 1] = arguments[_key4];\n }\n\n return this.doTransition(name, args, true);\n };\n\n Router.prototype.refresh = function refresh(pivotRoute) {\n var previousTransition = this.activeTransition;\n var state = previousTransition ? previousTransition[STATE_SYMBOL] : this.state;\n var routeInfos = state.routeInfos;\n if (pivotRoute === undefined) {\n pivotRoute = routeInfos[0].route;\n }\n _log(this, 'Starting a refresh transition');\n var name = routeInfos[routeInfos.length - 1].name;\n var intent = new NamedTransitionIntent(this, name, pivotRoute, [], this._changedQueryParams || state.queryParams);\n var newTransition = this.transitionByIntent(intent, false);\n // if the previous transition is a replace transition, that needs to be preserved\n if (previousTransition && previousTransition.urlMethod === 'replace') {\n newTransition.method(previousTransition.urlMethod);\n }\n return newTransition;\n };\n /**\n Identical to `transitionTo` except that the current URL will be replaced\n if possible.\n This method is intended primarily for use with `replaceState`.\n @param {String} name the name of the route\n */\n\n Router.prototype.replaceWith = function replaceWith(name) {\n return this.doTransition(name).method('replace');\n };\n /**\n Take a named route and context objects and generate a\n URL.\n @param {String} name the name of the route to generate\n a URL for\n @param {...Object} objects a list of objects to serialize\n @return {String} a URL\n */\n\n Router.prototype.generate = function generate(routeName) {\n for (var _len5 = arguments.length, args = Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {\n args[_key5 - 1] = arguments[_key5];\n }\n\n var partitionedArgs = extractQueryParams(args),\n suppliedParams = partitionedArgs[0],\n queryParams = partitionedArgs[1];\n // Construct a TransitionIntent with the provided params\n // and apply it to the present state of the router.\n var intent = new NamedTransitionIntent(this, routeName, undefined, suppliedParams);\n var state = intent.applyToState(this.state, false);\n var params = {};\n for (var i = 0, len = state.routeInfos.length; i < len; ++i) {\n var routeInfo = state.routeInfos[i];\n var routeParams = routeInfo.serialize();\n merge(params, routeParams);\n }\n params.queryParams = queryParams;\n return this.recognizer.generate(routeName, params);\n };\n\n Router.prototype.applyIntent = function applyIntent(routeName, contexts) {\n var intent = new NamedTransitionIntent(this, routeName, undefined, contexts);\n var state = this.activeTransition && this.activeTransition[STATE_SYMBOL] || this.state;\n return intent.applyToState(state, false);\n };\n\n Router.prototype.isActiveIntent = function isActiveIntent(routeName, contexts, queryParams, _state) {\n var state = _state || this.state,\n targetRouteInfos = state.routeInfos,\n routeInfo = void 0,\n len = void 0;\n if (!targetRouteInfos.length) {\n return false;\n }\n var targetHandler = targetRouteInfos[targetRouteInfos.length - 1].name;\n var recogHandlers = this.recognizer.handlersFor(targetHandler);\n var index = 0;\n for (len = recogHandlers.length; index < len; ++index) {\n routeInfo = targetRouteInfos[index];\n if (routeInfo.name === routeName) {\n break;\n }\n }\n if (index === recogHandlers.length) {\n // The provided route name isn't even in the route hierarchy.\n return false;\n }\n var testState = new TransitionState();\n testState.routeInfos = targetRouteInfos.slice(0, index + 1);\n recogHandlers = recogHandlers.slice(0, index + 1);\n var intent = new NamedTransitionIntent(this, targetHandler, undefined, contexts);\n var newState = intent.applyToHandlers(testState, recogHandlers, targetHandler, true, true);\n var routesEqual = routeInfosEqual(newState.routeInfos, testState.routeInfos);\n if (!queryParams || !routesEqual) {\n return routesEqual;\n }\n // Get a hash of QPs that will still be active on new route\n var activeQPsOnNewHandler = {};\n merge(activeQPsOnNewHandler, queryParams);\n var activeQueryParams = state.queryParams;\n for (var key in activeQueryParams) {\n if (activeQueryParams.hasOwnProperty(key) && activeQPsOnNewHandler.hasOwnProperty(key)) {\n activeQPsOnNewHandler[key] = activeQueryParams[key];\n }\n }\n return routesEqual && !getChangelist(activeQPsOnNewHandler, queryParams);\n };\n\n Router.prototype.isActive = function isActive(routeName) {\n for (var _len6 = arguments.length, args = Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {\n args[_key6 - 1] = arguments[_key6];\n }\n\n var partitionedArgs = extractQueryParams(args);\n return this.isActiveIntent(routeName, partitionedArgs[0], partitionedArgs[1]);\n };\n\n Router.prototype.trigger = function trigger(name) {\n for (var _len7 = arguments.length, args = Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {\n args[_key7 - 1] = arguments[_key7];\n }\n\n this.triggerEvent(this.currentRouteInfos, false, name, args);\n };\n\n return Router;\n }();\n\n function routeInfosEqual(routeInfos, otherRouteInfos) {\n if (routeInfos.length !== otherRouteInfos.length) {\n return false;\n }\n for (var i = 0, len = routeInfos.length; i < len; ++i) {\n if (routeInfos[i] !== otherRouteInfos[i]) {\n return false;\n }\n }\n return true;\n }\n function routeInfosSameExceptQueryParams(routeInfos, otherRouteInfos) {\n if (routeInfos.length !== otherRouteInfos.length) {\n return false;\n }\n for (var i = 0, len = routeInfos.length; i < len; ++i) {\n if (routeInfos[i].name !== otherRouteInfos[i].name) {\n return false;\n }\n if (!paramsEqual(routeInfos[i].params, otherRouteInfos[i].params)) {\n return false;\n }\n }\n return true;\n }\n function paramsEqual(params, otherParams) {\n if (!params && !otherParams) {\n return true;\n } else if (!params && !!otherParams || !!params && !otherParams) {\n // one is falsy but other is not;\n return false;\n }\n var keys = Object.keys(params);\n var otherKeys = Object.keys(otherParams);\n if (keys.length !== otherKeys.length) {\n return false;\n }\n for (var i = 0, len = keys.length; i < len; ++i) {\n var key = keys[i];\n if (params[key] !== otherParams[key]) {\n return false;\n }\n }\n return true;\n }\n\n exports.default = Router;\n exports.InternalTransition = Transition;\n exports.logAbort = logAbort;\n exports.STATE_SYMBOL = STATE_SYMBOL;\n exports.PARAMS_SYMBOL = PARAMS_SYMBOL;\n exports.QUERY_PARAMS_SYMBOL = QUERY_PARAMS_SYMBOL;\n exports.TransitionState = TransitionState;\n exports.TransitionError = TransitionError;\n exports.InternalRouteInfo = InternalRouteInfo;\n});","enifed('rsvp', ['exports', 'node-module', 'ember-babel'], function (exports, _nodeModule, _emberBabel) {\n 'use strict';\n\n exports.filter = exports.async = exports.map = exports.reject = exports.resolve = exports.off = exports.on = exports.configure = exports.denodeify = exports.defer = exports.rethrow = exports.hashSettled = exports.hash = exports.race = exports.allSettled = exports.all = exports.EventTarget = exports.Promise = exports.cast = exports.asap = undefined;\n\n\n function callbacksFor(object) {\n var callbacks = object._promiseCallbacks;\n\n if (!callbacks) {\n callbacks = object._promiseCallbacks = {};\n }\n\n return callbacks;\n }\n\n /**\n @class EventTarget\n @for rsvp\n @public\n */\n var EventTarget = {\n\n /**\n `EventTarget.mixin` extends an object with EventTarget methods. For\n Example:\n ```javascript\n import EventTarget from 'rsvp';\n let object = {};\n EventTarget.mixin(object);\n object.on('finished', function(event) {\n // handle event\n });\n object.trigger('finished', { detail: value });\n ```\n `EventTarget.mixin` also works with prototypes:\n ```javascript\n import EventTarget from 'rsvp';\n let Person = function() {};\n EventTarget.mixin(Person.prototype);\n let yehuda = new Person();\n let tom = new Person();\n yehuda.on('poke', function(event) {\n console.log('Yehuda says OW');\n });\n tom.on('poke', function(event) {\n console.log('Tom says OW');\n });\n yehuda.trigger('poke');\n tom.trigger('poke');\n ```\n @method mixin\n @for rsvp\n @private\n @param {Object} object object to extend with EventTarget methods\n */\n mixin: function (object) {\n object.on = this.on;\n object.off = this.off;\n object.trigger = this.trigger;\n object._promiseCallbacks = undefined;\n return object;\n },\n\n /**\n Registers a callback to be executed when `eventName` is triggered\n ```javascript\n object.on('event', function(eventInfo){\n // handle the event\n });\n object.trigger('event');\n ```\n @method on\n @for EventTarget\n @private\n @param {String} eventName name of the event to listen for\n @param {Function} callback function to be called when the event is triggered.\n */\n on: function (eventName, callback) {\n if (typeof callback !== 'function') {\n throw new TypeError('Callback must be a function');\n }\n\n var allCallbacks = callbacksFor(this);\n var callbacks = allCallbacks[eventName];\n\n if (!callbacks) {\n callbacks = allCallbacks[eventName] = [];\n }\n\n if (callbacks.indexOf(callback) === -1) {\n callbacks.push(callback);\n }\n },\n\n /**\n You can use `off` to stop firing a particular callback for an event:\n ```javascript\n function doStuff() { // do stuff! }\n object.on('stuff', doStuff);\n object.trigger('stuff'); // doStuff will be called\n // Unregister ONLY the doStuff callback\n object.off('stuff', doStuff);\n object.trigger('stuff'); // doStuff will NOT be called\n ```\n If you don't pass a `callback` argument to `off`, ALL callbacks for the\n event will not be executed when the event fires. For example:\n ```javascript\n let callback1 = function(){};\n let callback2 = function(){};\n object.on('stuff', callback1);\n object.on('stuff', callback2);\n object.trigger('stuff'); // callback1 and callback2 will be executed.\n object.off('stuff');\n object.trigger('stuff'); // callback1 and callback2 will not be executed!\n ```\n @method off\n @for rsvp\n @private\n @param {String} eventName event to stop listening to\n @param {Function} callback optional argument. If given, only the function\n given will be removed from the event's callback queue. If no `callback`\n argument is given, all callbacks will be removed from the event's callback\n queue.\n */\n off: function (eventName, callback) {\n var allCallbacks = callbacksFor(this);\n\n if (!callback) {\n allCallbacks[eventName] = [];\n return;\n }\n\n var callbacks = allCallbacks[eventName];\n var index = callbacks.indexOf(callback);\n\n if (index !== -1) {\n callbacks.splice(index, 1);\n }\n },\n\n /**\n Use `trigger` to fire custom events. For example:\n ```javascript\n object.on('foo', function(){\n console.log('foo event happened!');\n });\n object.trigger('foo');\n // 'foo event happened!' logged to the console\n ```\n You can also pass a value as a second argument to `trigger` that will be\n passed as an argument to all event listeners for the event:\n ```javascript\n object.on('foo', function(value){\n console.log(value.name);\n });\n object.trigger('foo', { name: 'bar' });\n // 'bar' logged to the console\n ```\n @method trigger\n @for rsvp\n @private\n @param {String} eventName name of the event to be triggered\n @param {*} options optional value to be passed to any event handlers for\n the given `eventName`\n */\n trigger: function (eventName, options, label) {\n var allCallbacks = callbacksFor(this);\n\n var callbacks = allCallbacks[eventName];\n if (callbacks) {\n // Don't cache the callbacks.length since it may grow\n var callback = void 0;\n for (var i = 0; i < callbacks.length; i++) {\n callback = callbacks[i];\n callback(options, label);\n }\n }\n }\n };\n\n var config = {\n instrument: false\n };\n\n EventTarget['mixin'](config);\n\n function configure(name, value) {\n if (arguments.length === 2) {\n config[name] = value;\n } else {\n return config[name];\n }\n }\n\n var queue = [];\n\n function scheduleFlush() {\n setTimeout(function () {\n for (var i = 0; i < queue.length; i++) {\n var entry = queue[i];\n\n var payload = entry.payload;\n\n payload.guid = payload.key + payload.id;\n payload.childGuid = payload.key + payload.childId;\n if (payload.error) {\n payload.stack = payload.error.stack;\n }\n\n config['trigger'](entry.name, entry.payload);\n }\n queue.length = 0;\n }, 50);\n }\n\n function instrument(eventName, promise, child) {\n if (1 === queue.push({\n name: eventName,\n payload: {\n key: promise._guidKey,\n id: promise._id,\n eventName: eventName,\n detail: promise._result,\n childId: child && child._id,\n label: promise._label,\n timeStamp: Date.now(),\n error: config[\"instrument-with-stack\"] ? new Error(promise._label) : null\n } })) {\n scheduleFlush();\n }\n }\n\n /**\n `Promise.resolve` returns a promise that will become resolved with the\n passed `value`. It is shorthand for the following:\n \n ```javascript\n import Promise from 'rsvp';\n \n let promise = new Promise(function(resolve, reject){\n resolve(1);\n });\n \n promise.then(function(value){\n // value === 1\n });\n ```\n \n Instead of writing the above, your code now simply becomes the following:\n \n ```javascript\n import Promise from 'rsvp';\n \n let promise = RSVP.Promise.resolve(1);\n \n promise.then(function(value){\n // value === 1\n });\n ```\n \n @method resolve\n @for Promise\n @static\n @param {*} object value that the returned promise will be resolved with\n @param {String} label optional string for identifying the returned promise.\n Useful for tooling.\n @return {Promise} a promise that will become fulfilled with the given\n `value`\n */\n function resolve$$1(object, label) {\n /*jshint validthis:true */\n var Constructor = this;\n\n if (object && typeof object === 'object' && object.constructor === Constructor) {\n return object;\n }\n\n var promise = new Constructor(noop, label);\n resolve$1(promise, object);\n return promise;\n }\n\n function withOwnPromise() {\n return new TypeError('A promises callback cannot return that same promise.');\n }\n\n function objectOrFunction(x) {\n var type = typeof x;\n return x !== null && (type === 'object' || type === 'function');\n }\n\n function noop() {}\n\n var PENDING = void 0;\n var FULFILLED = 1;\n var REJECTED = 2;\n\n var TRY_CATCH_ERROR = { error: null };\n\n function getThen(promise) {\n try {\n return promise.then;\n } catch (error) {\n TRY_CATCH_ERROR.error = error;\n return TRY_CATCH_ERROR;\n }\n }\n\n var tryCatchCallback = void 0;\n function tryCatcher() {\n try {\n var target = tryCatchCallback;\n tryCatchCallback = null;\n return target.apply(this, arguments);\n } catch (e) {\n TRY_CATCH_ERROR.error = e;\n return TRY_CATCH_ERROR;\n }\n }\n\n function tryCatch(fn) {\n tryCatchCallback = fn;\n return tryCatcher;\n }\n\n function handleForeignThenable(promise, thenable, then$$1) {\n config.async(function (promise) {\n var sealed = false;\n var result = tryCatch(then$$1).call(thenable, function (value) {\n if (sealed) {\n return;\n }\n sealed = true;\n if (thenable === value) {\n fulfill(promise, value);\n } else {\n resolve$1(promise, value);\n }\n }, function (reason) {\n if (sealed) {\n return;\n }\n sealed = true;\n\n reject(promise, reason);\n }, 'Settle: ' + (promise._label || ' unknown promise'));\n\n if (!sealed && result === TRY_CATCH_ERROR) {\n sealed = true;\n var error = TRY_CATCH_ERROR.error;\n TRY_CATCH_ERROR.error = null;\n reject(promise, error);\n }\n }, promise);\n }\n\n function handleOwnThenable(promise, thenable) {\n if (thenable._state === FULFILLED) {\n fulfill(promise, thenable._result);\n } else if (thenable._state === REJECTED) {\n thenable._onError = null;\n reject(promise, thenable._result);\n } else {\n subscribe(thenable, undefined, function (value) {\n if (thenable === value) {\n fulfill(promise, value);\n } else {\n resolve$1(promise, value);\n }\n }, function (reason) {\n return reject(promise, reason);\n });\n }\n }\n\n function handleMaybeThenable(promise, maybeThenable, then$$1) {\n var isOwnThenable = maybeThenable.constructor === promise.constructor && then$$1 === then && promise.constructor.resolve === resolve$$1;\n\n if (isOwnThenable) {\n handleOwnThenable(promise, maybeThenable);\n } else if (then$$1 === TRY_CATCH_ERROR) {\n var error = TRY_CATCH_ERROR.error;\n TRY_CATCH_ERROR.error = null;\n reject(promise, error);\n } else if (typeof then$$1 === 'function') {\n handleForeignThenable(promise, maybeThenable, then$$1);\n } else {\n fulfill(promise, maybeThenable);\n }\n }\n\n function resolve$1(promise, value) {\n if (promise === value) {\n fulfill(promise, value);\n } else if (objectOrFunction(value)) {\n handleMaybeThenable(promise, value, getThen(value));\n } else {\n fulfill(promise, value);\n }\n }\n\n function publishRejection(promise) {\n if (promise._onError) {\n promise._onError(promise._result);\n }\n\n publish(promise);\n }\n\n function fulfill(promise, value) {\n if (promise._state !== PENDING) {\n return;\n }\n\n promise._result = value;\n promise._state = FULFILLED;\n\n if (promise._subscribers.length === 0) {\n if (config.instrument) {\n instrument('fulfilled', promise);\n }\n } else {\n config.async(publish, promise);\n }\n }\n\n function reject(promise, reason) {\n if (promise._state !== PENDING) {\n return;\n }\n promise._state = REJECTED;\n promise._result = reason;\n config.async(publishRejection, promise);\n }\n\n function subscribe(parent, child, onFulfillment, onRejection) {\n var subscribers = parent._subscribers;\n var length = subscribers.length;\n\n parent._onError = null;\n\n subscribers[length] = child;\n subscribers[length + FULFILLED] = onFulfillment;\n subscribers[length + REJECTED] = onRejection;\n\n if (length === 0 && parent._state) {\n config.async(publish, parent);\n }\n }\n\n function publish(promise) {\n var subscribers = promise._subscribers;\n var settled = promise._state;\n\n if (config.instrument) {\n instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);\n }\n\n if (subscribers.length === 0) {\n return;\n }\n\n var child = void 0,\n callback = void 0,\n result = promise._result;\n\n for (var i = 0; i < subscribers.length; i += 3) {\n child = subscribers[i];\n callback = subscribers[i + settled];\n\n if (child) {\n invokeCallback(settled, child, callback, result);\n } else {\n callback(result);\n }\n }\n\n promise._subscribers.length = 0;\n }\n\n function invokeCallback(state, promise, callback, result) {\n var hasCallback = typeof callback === 'function';\n var value = void 0;\n\n if (hasCallback) {\n value = tryCatch(callback)(result);\n } else {\n value = result;\n }\n\n if (promise._state !== PENDING) {\n // noop\n } else if (value === promise) {\n reject(promise, withOwnPromise());\n } else if (value === TRY_CATCH_ERROR) {\n var error = TRY_CATCH_ERROR.error;\n TRY_CATCH_ERROR.error = null; // release\n reject(promise, error);\n } else if (hasCallback) {\n resolve$1(promise, value);\n } else if (state === FULFILLED) {\n fulfill(promise, value);\n } else if (state === REJECTED) {\n reject(promise, value);\n }\n }\n\n function initializePromise(promise, resolver) {\n var resolved = false;\n try {\n resolver(function (value) {\n if (resolved) {\n return;\n }\n resolved = true;\n resolve$1(promise, value);\n }, function (reason) {\n if (resolved) {\n return;\n }\n resolved = true;\n reject(promise, reason);\n });\n } catch (e) {\n reject(promise, e);\n }\n }\n\n function then(onFulfillment, onRejection, label) {\n var parent = this;\n var state = parent._state;\n\n if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {\n config.instrument && instrument('chained', parent, parent);\n return parent;\n }\n\n parent._onError = null;\n\n var child = new parent.constructor(noop, label);\n var result = parent._result;\n\n config.instrument && instrument('chained', parent, child);\n\n if (state === PENDING) {\n subscribe(parent, child, onFulfillment, onRejection);\n } else {\n var callback = state === FULFILLED ? onFulfillment : onRejection;\n config.async(function () {\n return invokeCallback(state, child, callback, result);\n });\n }\n\n return child;\n }\n\n var Enumerator = function () {\n function Enumerator(Constructor, input, abortOnReject, label) {\n\n this._instanceConstructor = Constructor;\n this.promise = new Constructor(noop, label);\n this._abortOnReject = abortOnReject;\n this._isUsingOwnPromise = Constructor === Promise;\n this._isUsingOwnResolve = Constructor.resolve === resolve$$1;\n\n this._init.apply(this, arguments);\n }\n\n Enumerator.prototype._init = function _init(Constructor, input) {\n var len = input.length || 0;\n this.length = len;\n this._remaining = len;\n this._result = new Array(len);\n\n this._enumerate(input);\n };\n\n Enumerator.prototype._enumerate = function _enumerate(input) {\n var length = this.length;\n var promise = this.promise;\n\n for (var i = 0; promise._state === PENDING && i < length; i++) {\n this._eachEntry(input[i], i, true);\n }\n this._checkFullfillment();\n };\n\n Enumerator.prototype._checkFullfillment = function _checkFullfillment() {\n if (this._remaining === 0) {\n var result = this._result;\n fulfill(this.promise, result);\n this._result = null;\n }\n };\n\n Enumerator.prototype._settleMaybeThenable = function _settleMaybeThenable(entry, i, firstPass) {\n var c = this._instanceConstructor;\n\n if (this._isUsingOwnResolve) {\n var then$$1 = getThen(entry);\n\n if (then$$1 === then && entry._state !== PENDING) {\n entry._onError = null;\n this._settledAt(entry._state, i, entry._result, firstPass);\n } else if (typeof then$$1 !== 'function') {\n this._settledAt(FULFILLED, i, entry, firstPass);\n } else if (this._isUsingOwnPromise) {\n var promise = new c(noop);\n handleMaybeThenable(promise, entry, then$$1);\n this._willSettleAt(promise, i, firstPass);\n } else {\n this._willSettleAt(new c(function (resolve) {\n return resolve(entry);\n }), i, firstPass);\n }\n } else {\n this._willSettleAt(c.resolve(entry), i, firstPass);\n }\n };\n\n Enumerator.prototype._eachEntry = function _eachEntry(entry, i, firstPass) {\n if (entry !== null && typeof entry === 'object') {\n this._settleMaybeThenable(entry, i, firstPass);\n } else {\n this._setResultAt(FULFILLED, i, entry, firstPass);\n }\n };\n\n Enumerator.prototype._settledAt = function _settledAt(state, i, value, firstPass) {\n var promise = this.promise;\n\n if (promise._state === PENDING) {\n if (this._abortOnReject && state === REJECTED) {\n reject(promise, value);\n } else {\n this._setResultAt(state, i, value, firstPass);\n this._checkFullfillment();\n }\n }\n };\n\n Enumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {\n this._remaining--;\n this._result[i] = value;\n };\n\n Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i, firstPass) {\n var _this = this;\n\n subscribe(promise, undefined, function (value) {\n return _this._settledAt(FULFILLED, i, value, firstPass);\n }, function (reason) {\n return _this._settledAt(REJECTED, i, reason, firstPass);\n });\n };\n\n return Enumerator;\n }();\n\n function setSettledResult(state, i, value) {\n this._remaining--;\n if (state === FULFILLED) {\n this._result[i] = {\n state: 'fulfilled',\n value: value\n };\n } else {\n this._result[i] = {\n state: 'rejected',\n reason: value\n };\n }\n }\n\n /**\n `Promise.all` accepts an array of promises, and returns a new promise which\n is fulfilled with an array of fulfillment values for the passed promises, or\n rejected with the reason of the first passed promise to be rejected. It casts all\n elements of the passed iterable to promises as it runs this algorithm.\n \n Example:\n \n ```javascript\n import Promise, { resolve } from 'rsvp';\n \n let promise1 = resolve(1);\n let promise2 = resolve(2);\n let promise3 = resolve(3);\n let promises = [ promise1, promise2, promise3 ];\n \n Promise.all(promises).then(function(array){\n // The array here would be [ 1, 2, 3 ];\n });\n ```\n \n If any of the `promises` given to `RSVP.all` are rejected, the first promise\n that is rejected will be given as an argument to the returned promises's\n rejection handler. For example:\n \n Example:\n \n ```javascript\n import Promise, { resolve, reject } from 'rsvp';\n \n let promise1 = resolve(1);\n let promise2 = reject(new Error(\"2\"));\n let promise3 = reject(new Error(\"3\"));\n let promises = [ promise1, promise2, promise3 ];\n \n Promise.all(promises).then(function(array){\n // Code here never runs because there are rejected promises!\n }, function(error) {\n // error.message === \"2\"\n });\n ```\n \n @method all\n @for Promise\n @param {Array} entries array of promises\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise} promise that is fulfilled when all `promises` have been\n fulfilled, or rejected if any of them become rejected.\n @static\n */\n function all(entries, label) {\n if (!Array.isArray(entries)) {\n return this.reject(new TypeError(\"Promise.all must be called with an array\"), label);\n }\n return new Enumerator(this, entries, true /* abort on reject */, label).promise;\n }\n\n /**\n `Promise.race` returns a new promise which is settled in the same way as the\n first passed promise to settle.\n \n Example:\n \n ```javascript\n import Promise from 'rsvp';\n \n let promise1 = new Promise(function(resolve, reject){\n setTimeout(function(){\n resolve('promise 1');\n }, 200);\n });\n \n let promise2 = new Promise(function(resolve, reject){\n setTimeout(function(){\n resolve('promise 2');\n }, 100);\n });\n \n Promise.race([promise1, promise2]).then(function(result){\n // result === 'promise 2' because it was resolved before promise1\n // was resolved.\n });\n ```\n \n `Promise.race` is deterministic in that only the state of the first\n settled promise matters. For example, even if other promises given to the\n `promises` array argument are resolved, but the first settled promise has\n become rejected before the other promises became fulfilled, the returned\n promise will become rejected:\n \n ```javascript\n import Promise from 'rsvp';\n \n let promise1 = new Promise(function(resolve, reject){\n setTimeout(function(){\n resolve('promise 1');\n }, 200);\n });\n \n let promise2 = new Promise(function(resolve, reject){\n setTimeout(function(){\n reject(new Error('promise 2'));\n }, 100);\n });\n \n Promise.race([promise1, promise2]).then(function(result){\n // Code here never runs\n }, function(reason){\n // reason.message === 'promise 2' because promise 2 became rejected before\n // promise 1 became fulfilled\n });\n ```\n \n An example real-world use case is implementing timeouts:\n \n ```javascript\n import Promise from 'rsvp';\n \n Promise.race([ajax('foo.json'), timeout(5000)])\n ```\n \n @method race\n @for Promise\n @static\n @param {Array} entries array of promises to observe\n @param {String} label optional string for describing the promise returned.\n Useful for tooling.\n @return {Promise} a promise which settles in the same way as the first passed\n promise to settle.\n */\n function race(entries, label) {\n /*jshint validthis:true */\n var Constructor = this;\n\n var promise = new Constructor(noop, label);\n\n if (!Array.isArray(entries)) {\n reject(promise, new TypeError('Promise.race must be called with an array'));\n return promise;\n }\n\n for (var i = 0; promise._state === PENDING && i < entries.length; i++) {\n subscribe(Constructor.resolve(entries[i]), undefined, function (value) {\n return resolve$1(promise, value);\n }, function (reason) {\n return reject(promise, reason);\n });\n }\n\n return promise;\n }\n\n /**\n `Promise.reject` returns a promise rejected with the passed `reason`.\n It is shorthand for the following:\n \n ```javascript\n import Promise from 'rsvp';\n \n let promise = new Promise(function(resolve, reject){\n reject(new Error('WHOOPS'));\n });\n \n promise.then(function(value){\n // Code here doesn't run because the promise is rejected!\n }, function(reason){\n // reason.message === 'WHOOPS'\n });\n ```\n \n Instead of writing the above, your code now simply becomes the following:\n \n ```javascript\n import Promise from 'rsvp';\n \n let promise = Promise.reject(new Error('WHOOPS'));\n \n promise.then(function(value){\n // Code here doesn't run because the promise is rejected!\n }, function(reason){\n // reason.message === 'WHOOPS'\n });\n ```\n \n @method reject\n @for Promise\n @static\n @param {*} reason value that the returned promise will be rejected with.\n @param {String} label optional string for identifying the returned promise.\n Useful for tooling.\n @return {Promise} a promise rejected with the given `reason`.\n */\n function reject$1(reason, label) {\n /*jshint validthis:true */\n var Constructor = this;\n var promise = new Constructor(noop, label);\n reject(promise, reason);\n return promise;\n }\n\n var guidKey = 'rsvp_' + Date.now() + '-';\n var counter = 0;\n\n function needsResolver() {\n throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');\n }\n\n function needsNew() {\n throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\");\n }\n\n /**\n Promise objects represent the eventual result of an asynchronous operation. The\n primary way of interacting with a promise is through its `then` method, which\n registers callbacks to receive either a promise’s eventual value or the reason\n why the promise cannot be fulfilled.\n \n Terminology\n -----------\n \n - `promise` is an object or function with a `then` method whose behavior conforms to this specification.\n - `thenable` is an object or function that defines a `then` method.\n - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).\n - `exception` is a value that is thrown using the throw statement.\n - `reason` is a value that indicates why a promise was rejected.\n - `settled` the final resting state of a promise, fulfilled or rejected.\n \n A promise can be in one of three states: pending, fulfilled, or rejected.\n \n Promises that are fulfilled have a fulfillment value and are in the fulfilled\n state. Promises that are rejected have a rejection reason and are in the\n rejected state. A fulfillment value is never a thenable.\n \n Promises can also be said to *resolve* a value. If this value is also a\n promise, then the original promise's settled state will match the value's\n settled state. So a promise that *resolves* a promise that rejects will\n itself reject, and a promise that *resolves* a promise that fulfills will\n itself fulfill.\n \n \n Basic Usage:\n ------------\n \n ```js\n let promise = new Promise(function(resolve, reject) {\n // on success\n resolve(value);\n \n // on failure\n reject(reason);\n });\n \n promise.then(function(value) {\n // on fulfillment\n }, function(reason) {\n // on rejection\n });\n ```\n \n Advanced Usage:\n ---------------\n \n Promises shine when abstracting away asynchronous interactions such as\n `XMLHttpRequest`s.\n \n ```js\n function getJSON(url) {\n return new Promise(function(resolve, reject){\n let xhr = new XMLHttpRequest();\n \n xhr.open('GET', url);\n xhr.onreadystatechange = handler;\n xhr.responseType = 'json';\n xhr.setRequestHeader('Accept', 'application/json');\n xhr.send();\n \n function handler() {\n if (this.readyState === this.DONE) {\n if (this.status === 200) {\n resolve(this.response);\n } else {\n reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));\n }\n }\n };\n });\n }\n \n getJSON('/posts.json').then(function(json) {\n // on fulfillment\n }, function(reason) {\n // on rejection\n });\n ```\n \n Unlike callbacks, promises are great composable primitives.\n \n ```js\n Promise.all([\n getJSON('/posts'),\n getJSON('/comments')\n ]).then(function(values){\n values[0] // => postsJSON\n values[1] // => commentsJSON\n \n return values;\n });\n ```\n \n @class Promise\n @public\n @param {function} resolver\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @constructor\n */\n\n var Promise = function () {\n function Promise(resolver, label) {\n\n this._id = counter++;\n this._label = label;\n this._state = undefined;\n this._result = undefined;\n this._subscribers = [];\n\n config.instrument && instrument('created', this);\n\n if (noop !== resolver) {\n typeof resolver !== 'function' && needsResolver();\n this instanceof Promise ? initializePromise(this, resolver) : needsNew();\n }\n }\n\n Promise.prototype._onError = function _onError(reason) {\n var _this2 = this;\n\n config.after(function () {\n if (_this2._onError) {\n config.trigger('error', reason, _this2._label);\n }\n });\n };\n\n /**\n `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same\n as the catch block of a try/catch statement.\n \n ```js\n function findAuthor(){\n throw new Error('couldn\\'t find that author');\n }\n \n // synchronous\n try {\n findAuthor();\n } catch(reason) {\n // something went wrong\n }\n \n // async with promises\n findAuthor().catch(function(reason){\n // something went wrong\n });\n ```\n \n @method catch\n @param {Function} onRejection\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise}\n */\n\n Promise.prototype.catch = function _catch(onRejection, label) {\n return this.then(undefined, onRejection, label);\n };\n\n /**\n `finally` will be invoked regardless of the promise's fate just as native\n try/catch/finally behaves\n \n Synchronous example:\n \n ```js\n findAuthor() {\n if (Math.random() > 0.5) {\n throw new Error();\n }\n return new Author();\n }\n \n try {\n return findAuthor(); // succeed or fail\n } catch(error) {\n return findOtherAuthor();\n } finally {\n // always runs\n // doesn't affect the return value\n }\n ```\n \n Asynchronous example:\n \n ```js\n findAuthor().catch(function(reason){\n return findOtherAuthor();\n }).finally(function(){\n // author was either found, or not\n });\n ```\n \n @method finally\n @param {Function} callback\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise}\n */\n\n Promise.prototype.finally = function _finally(callback, label) {\n var promise = this;\n var constructor = promise.constructor;\n\n if (typeof callback === 'function') {\n return promise.then(function (value) {\n return constructor.resolve(callback()).then(function () {\n return value;\n });\n }, function (reason) {\n return constructor.resolve(callback()).then(function () {\n throw reason;\n });\n });\n }\n\n return promise.then(callback, callback);\n };\n\n return Promise;\n }();\n\n Promise.cast = resolve$$1; // deprecated\n Promise.all = all;\n Promise.race = race;\n Promise.resolve = resolve$$1;\n Promise.reject = reject$1;\n\n Promise.prototype._guidKey = guidKey;\n\n /**\n The primary way of interacting with a promise is through its `then` method,\n which registers callbacks to receive either a promise's eventual value or the\n reason why the promise cannot be fulfilled.\n \n ```js\n findUser().then(function(user){\n // user is available\n }, function(reason){\n // user is unavailable, and you are given the reason why\n });\n ```\n \n Chaining\n --------\n \n The return value of `then` is itself a promise. This second, 'downstream'\n promise is resolved with the return value of the first promise's fulfillment\n or rejection handler, or rejected if the handler throws an exception.\n \n ```js\n findUser().then(function (user) {\n return user.name;\n }, function (reason) {\n return 'default name';\n }).then(function (userName) {\n // If `findUser` fulfilled, `userName` will be the user's name, otherwise it\n // will be `'default name'`\n });\n \n findUser().then(function (user) {\n throw new Error('Found user, but still unhappy');\n }, function (reason) {\n throw new Error('`findUser` rejected and we\\'re unhappy');\n }).then(function (value) {\n // never reached\n }, function (reason) {\n // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.\n // If `findUser` rejected, `reason` will be '`findUser` rejected and we\\'re unhappy'.\n });\n ```\n If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.\n \n ```js\n findUser().then(function (user) {\n throw new PedagogicalException('Upstream error');\n }).then(function (value) {\n // never reached\n }).then(function (value) {\n // never reached\n }, function (reason) {\n // The `PedgagocialException` is propagated all the way down to here\n });\n ```\n \n Assimilation\n ------------\n \n Sometimes the value you want to propagate to a downstream promise can only be\n retrieved asynchronously. This can be achieved by returning a promise in the\n fulfillment or rejection handler. The downstream promise will then be pending\n until the returned promise is settled. This is called *assimilation*.\n \n ```js\n findUser().then(function (user) {\n return findCommentsByAuthor(user);\n }).then(function (comments) {\n // The user's comments are now available\n });\n ```\n \n If the assimliated promise rejects, then the downstream promise will also reject.\n \n ```js\n findUser().then(function (user) {\n return findCommentsByAuthor(user);\n }).then(function (comments) {\n // If `findCommentsByAuthor` fulfills, we'll have the value here\n }, function (reason) {\n // If `findCommentsByAuthor` rejects, we'll have the reason here\n });\n ```\n \n Simple Example\n --------------\n \n Synchronous Example\n \n ```javascript\n let result;\n \n try {\n result = findResult();\n // success\n } catch(reason) {\n // failure\n }\n ```\n \n Errback Example\n \n ```js\n findResult(function(result, err){\n if (err) {\n // failure\n } else {\n // success\n }\n });\n ```\n \n Promise Example;\n \n ```javascript\n findResult().then(function(result){\n // success\n }, function(reason){\n // failure\n });\n ```\n \n Advanced Example\n --------------\n \n Synchronous Example\n \n ```javascript\n let author, books;\n \n try {\n author = findAuthor();\n books = findBooksByAuthor(author);\n // success\n } catch(reason) {\n // failure\n }\n ```\n \n Errback Example\n \n ```js\n \n function foundBooks(books) {\n \n }\n \n function failure(reason) {\n \n }\n \n findAuthor(function(author, err){\n if (err) {\n failure(err);\n // failure\n } else {\n try {\n findBoooksByAuthor(author, function(books, err) {\n if (err) {\n failure(err);\n } else {\n try {\n foundBooks(books);\n } catch(reason) {\n failure(reason);\n }\n }\n });\n } catch(error) {\n failure(err);\n }\n // success\n }\n });\n ```\n \n Promise Example;\n \n ```javascript\n findAuthor().\n then(findBooksByAuthor).\n then(function(books){\n // found books\n }).catch(function(reason){\n // something went wrong\n });\n ```\n \n @method then\n @param {Function} onFulfillment\n @param {Function} onRejection\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise}\n */\n Promise.prototype.then = then;\n\n function makeObject(_, argumentNames) {\n var obj = {};\n var length = _.length;\n var args = new Array(length);\n\n for (var x = 0; x < length; x++) {\n args[x] = _[x];\n }\n\n for (var i = 0; i < argumentNames.length; i++) {\n var name = argumentNames[i];\n obj[name] = args[i + 1];\n }\n\n return obj;\n }\n\n function arrayResult(_) {\n var length = _.length;\n var args = new Array(length - 1);\n\n for (var i = 1; i < length; i++) {\n args[i - 1] = _[i];\n }\n\n return args;\n }\n\n function wrapThenable(then, promise) {\n return {\n then: function (onFulFillment, onRejection) {\n return then.call(promise, onFulFillment, onRejection);\n }\n };\n }\n\n /**\n `denodeify` takes a 'node-style' function and returns a function that\n will return an `Promise`. You can use `denodeify` in Node.js or the\n browser when you'd prefer to use promises over using callbacks. For example,\n `denodeify` transforms the following:\n \n ```javascript\n let fs = require('fs');\n \n fs.readFile('myfile.txt', function(err, data){\n if (err) return handleError(err);\n handleData(data);\n });\n ```\n \n into:\n \n ```javascript\n let fs = require('fs');\n let readFile = denodeify(fs.readFile);\n \n readFile('myfile.txt').then(handleData, handleError);\n ```\n \n If the node function has multiple success parameters, then `denodeify`\n just returns the first one:\n \n ```javascript\n let request = denodeify(require('request'));\n \n request('http://example.com').then(function(res) {\n // ...\n });\n ```\n \n However, if you need all success parameters, setting `denodeify`'s\n second parameter to `true` causes it to return all success parameters\n as an array:\n \n ```javascript\n let request = denodeify(require('request'), true);\n \n request('http://example.com').then(function(result) {\n // result[0] -> res\n // result[1] -> body\n });\n ```\n \n Or if you pass it an array with names it returns the parameters as a hash:\n \n ```javascript\n let request = denodeify(require('request'), ['res', 'body']);\n \n request('http://example.com').then(function(result) {\n // result.res\n // result.body\n });\n ```\n \n Sometimes you need to retain the `this`:\n \n ```javascript\n let app = require('express')();\n let render = denodeify(app.render.bind(app));\n ```\n \n The denodified function inherits from the original function. It works in all\n environments, except IE 10 and below. Consequently all properties of the original\n function are available to you. However, any properties you change on the\n denodeified function won't be changed on the original function. Example:\n \n ```javascript\n let request = denodeify(require('request')),\n cookieJar = request.jar(); // <- Inheritance is used here\n \n request('http://example.com', {jar: cookieJar}).then(function(res) {\n // cookieJar.cookies holds now the cookies returned by example.com\n });\n ```\n \n Using `denodeify` makes it easier to compose asynchronous operations instead\n of using callbacks. For example, instead of:\n \n ```javascript\n let fs = require('fs');\n \n fs.readFile('myfile.txt', function(err, data){\n if (err) { ... } // Handle error\n fs.writeFile('myfile2.txt', data, function(err){\n if (err) { ... } // Handle error\n console.log('done')\n });\n });\n ```\n \n you can chain the operations together using `then` from the returned promise:\n \n ```javascript\n let fs = require('fs');\n let readFile = denodeify(fs.readFile);\n let writeFile = denodeify(fs.writeFile);\n \n readFile('myfile.txt').then(function(data){\n return writeFile('myfile2.txt', data);\n }).then(function(){\n console.log('done')\n }).catch(function(error){\n // Handle error\n });\n ```\n \n @method denodeify\n @public\n @static\n @for rsvp\n @param {Function} nodeFunc a 'node-style' function that takes a callback as\n its last argument. The callback expects an error to be passed as its first\n argument (if an error occurred, otherwise null), and the value from the\n operation as its second argument ('function(err, value){ }').\n @param {Boolean|Array} [options] An optional paramter that if set\n to `true` causes the promise to fulfill with the callback's success arguments\n as an array. This is useful if the node function has multiple success\n paramters. If you set this paramter to an array with names, the promise will\n fulfill with a hash with these names as keys and the success parameters as\n values.\n @return {Function} a function that wraps `nodeFunc` to return a `Promise`\n */\n function denodeify(nodeFunc, options) {\n var fn = function () {\n var l = arguments.length;\n var args = new Array(l + 1);\n var promiseInput = false;\n\n for (var i = 0; i < l; ++i) {\n var arg = arguments[i];\n\n if (!promiseInput) {\n // TODO: clean this up\n promiseInput = needsPromiseInput(arg);\n if (promiseInput === TRY_CATCH_ERROR) {\n var error = TRY_CATCH_ERROR.error;\n TRY_CATCH_ERROR.error = null;\n var p = new Promise(noop);\n reject(p, error);\n return p;\n } else if (promiseInput && promiseInput !== true) {\n arg = wrapThenable(promiseInput, arg);\n }\n }\n args[i] = arg;\n }\n\n var promise = new Promise(noop);\n\n args[l] = function (err, val) {\n if (err) {\n reject(promise, err);\n } else if (options === undefined) {\n resolve$1(promise, val);\n } else if (options === true) {\n resolve$1(promise, arrayResult(arguments));\n } else if (Array.isArray(options)) {\n resolve$1(promise, makeObject(arguments, options));\n } else {\n resolve$1(promise, val);\n }\n };\n\n if (promiseInput) {\n return handlePromiseInput(promise, args, nodeFunc, this);\n } else {\n return handleValueInput(promise, args, nodeFunc, this);\n }\n };\n\n fn.__proto__ = nodeFunc;\n\n return fn;\n }\n\n function handleValueInput(promise, args, nodeFunc, self) {\n var result = tryCatch(nodeFunc).apply(self, args);\n if (result === TRY_CATCH_ERROR) {\n var error = TRY_CATCH_ERROR.error;\n TRY_CATCH_ERROR.error = null;\n reject(promise, error);\n }\n return promise;\n }\n\n function handlePromiseInput(promise, args, nodeFunc, self) {\n return Promise.all(args).then(function (args) {\n return handleValueInput(promise, args, nodeFunc, self);\n });\n }\n\n function needsPromiseInput(arg) {\n if (arg !== null && typeof arg === 'object') {\n if (arg.constructor === Promise) {\n return true;\n } else {\n return getThen(arg);\n }\n } else {\n return false;\n }\n }\n\n /**\n This is a convenient alias for `Promise.all`.\n \n @method all\n @public\n @static\n @for rsvp\n @param {Array} array Array of promises.\n @param {String} label An optional label. This is useful\n for tooling.\n */\n function all$1(array, label) {\n return Promise.all(array, label);\n }\n\n /**\n @module rsvp\n @public\n **/\n\n var AllSettled = function (_Enumerator) {\n (0, _emberBabel.inherits)(AllSettled, _Enumerator);\n\n function AllSettled(Constructor, entries, label) {\n\n return (0, _emberBabel.possibleConstructorReturn)(this, _Enumerator.call(this, Constructor, entries, false /* don't abort on reject */, label));\n }\n\n return AllSettled;\n }(Enumerator);\n\n AllSettled.prototype._setResultAt = setSettledResult;\n\n /**\n `RSVP.allSettled` is similar to `RSVP.all`, but instead of implementing\n a fail-fast method, it waits until all the promises have returned and\n shows you all the results. This is useful if you want to handle multiple\n promises' failure states together as a set.\n Returns a promise that is fulfilled when all the given promises have been\n settled. The return promise is fulfilled with an array of the states of\n the promises passed into the `promises` array argument.\n Each state object will either indicate fulfillment or rejection, and\n provide the corresponding value or reason. The states will take one of\n the following formats:\n ```javascript\n { state: 'fulfilled', value: value }\n or\n { state: 'rejected', reason: reason }\n ```\n Example:\n ```javascript\n let promise1 = RSVP.Promise.resolve(1);\n let promise2 = RSVP.Promise.reject(new Error('2'));\n let promise3 = RSVP.Promise.reject(new Error('3'));\n let promises = [ promise1, promise2, promise3 ];\n RSVP.allSettled(promises).then(function(array){\n // array == [\n // { state: 'fulfilled', value: 1 },\n // { state: 'rejected', reason: Error },\n // { state: 'rejected', reason: Error }\n // ]\n // Note that for the second item, reason.message will be '2', and for the\n // third item, reason.message will be '3'.\n }, function(error) {\n // Not run. (This block would only be called if allSettled had failed,\n // for instance if passed an incorrect argument type.)\n });\n ```\n @method allSettled\n @public\n @static\n @for rsvp\n @param {Array} entries\n @param {String} label - optional string that describes the promise.\n Useful for tooling.\n @return {Promise} promise that is fulfilled with an array of the settled\n states of the constituent promises.\n */\n\n function allSettled(entries, label) {\n if (!Array.isArray(entries)) {\n return Promise.reject(new TypeError(\"Promise.allSettled must be called with an array\"), label);\n }\n\n return new AllSettled(Promise, entries, label).promise;\n }\n\n /**\n This is a convenient alias for `Promise.race`.\n \n @method race\n @public\n @static\n @for rsvp\n @param {Array} array Array of promises.\n @param {String} label An optional label. This is useful\n for tooling.\n */\n function race$1(array, label) {\n return Promise.race(array, label);\n }\n\n var PromiseHash = function (_Enumerator2) {\n (0, _emberBabel.inherits)(PromiseHash, _Enumerator2);\n\n function PromiseHash(Constructor, object) {\n var abortOnReject = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n var label = arguments[3];\n\n return (0, _emberBabel.possibleConstructorReturn)(this, _Enumerator2.call(this, Constructor, object, abortOnReject, label));\n }\n\n PromiseHash.prototype._init = function _init(Constructor, object) {\n this._result = {};\n this._enumerate(object);\n };\n\n PromiseHash.prototype._enumerate = function _enumerate(input) {\n var keys = Object.keys(input);\n\n var length = keys.length;\n var promise = this.promise;\n this._remaining = length;\n\n var key = void 0,\n val = void 0;\n for (var i = 0; promise._state === PENDING && i < length; i++) {\n key = keys[i];\n val = input[key];\n this._eachEntry(val, key, true);\n }\n\n this._checkFullfillment();\n };\n\n return PromiseHash;\n }(Enumerator);\n\n /**\n `hash` is similar to `all`, but takes an object instead of an array\n for its `promises` argument.\n \n Returns a promise that is fulfilled when all the given promises have been\n fulfilled, or rejected if any of them become rejected. The returned promise\n is fulfilled with a hash that has the same key names as the `promises` object\n argument. If any of the values in the object are not promises, they will\n simply be copied over to the fulfilled object.\n \n Example:\n \n ```javascript\n let promises = {\n myPromise: resolve(1),\n yourPromise: resolve(2),\n theirPromise: resolve(3),\n notAPromise: 4\n };\n \n hash(promises).then(function(hash){\n // hash here is an object that looks like:\n // {\n // myPromise: 1,\n // yourPromise: 2,\n // theirPromise: 3,\n // notAPromise: 4\n // }\n });\n ```\n \n If any of the `promises` given to `hash` are rejected, the first promise\n that is rejected will be given as the reason to the rejection handler.\n \n Example:\n \n ```javascript\n let promises = {\n myPromise: resolve(1),\n rejectedPromise: reject(new Error('rejectedPromise')),\n anotherRejectedPromise: reject(new Error('anotherRejectedPromise')),\n };\n \n hash(promises).then(function(hash){\n // Code here never runs because there are rejected promises!\n }, function(reason) {\n // reason.message === 'rejectedPromise'\n });\n ```\n \n An important note: `hash` is intended for plain JavaScript objects that\n are just a set of keys and values. `hash` will NOT preserve prototype\n chains.\n \n Example:\n \n ```javascript\n import { hash, resolve } from 'rsvp';\n function MyConstructor(){\n this.example = resolve('Example');\n }\n \n MyConstructor.prototype = {\n protoProperty: resolve('Proto Property')\n };\n \n let myObject = new MyConstructor();\n \n hash(myObject).then(function(hash){\n // protoProperty will not be present, instead you will just have an\n // object that looks like:\n // {\n // example: 'Example'\n // }\n //\n // hash.hasOwnProperty('protoProperty'); // false\n // 'undefined' === typeof hash.protoProperty\n });\n ```\n \n @method hash\n @public\n @static\n @for rsvp\n @param {Object} object\n @param {String} label optional string that describes the promise.\n Useful for tooling.\n @return {Promise} promise that is fulfilled when all properties of `promises`\n have been fulfilled, or rejected if any of them become rejected.\n */\n\n function hash(object, label) {\n return Promise.resolve(object, label).then(function (object) {\n if (object === null || typeof object !== 'object') {\n throw new TypeError(\"Promise.hash must be called with an object\");\n }\n return new PromiseHash(Promise, object, label).promise;\n });\n }\n\n var HashSettled = function (_PromiseHash) {\n (0, _emberBabel.inherits)(HashSettled, _PromiseHash);\n\n function HashSettled(Constructor, object, label) {\n\n return (0, _emberBabel.possibleConstructorReturn)(this, _PromiseHash.call(this, Constructor, object, false, label));\n }\n\n return HashSettled;\n }(PromiseHash);\n\n HashSettled.prototype._setResultAt = setSettledResult;\n\n /**\n `hashSettled` is similar to `allSettled`, but takes an object\n instead of an array for its `promises` argument.\n \n Unlike `all` or `hash`, which implement a fail-fast method,\n but like `allSettled`, `hashSettled` waits until all the\n constituent promises have returned and then shows you all the results\n with their states and values/reasons. This is useful if you want to\n handle multiple promises' failure states together as a set.\n \n Returns a promise that is fulfilled when all the given promises have been\n settled, or rejected if the passed parameters are invalid.\n \n The returned promise is fulfilled with a hash that has the same key names as\n the `promises` object argument. If any of the values in the object are not\n promises, they will be copied over to the fulfilled object and marked with state\n 'fulfilled'.\n \n Example:\n \n ```javascript\n import { hashSettled, resolve } from 'rsvp';\n \n let promises = {\n myPromise: resolve(1),\n yourPromise: resolve(2),\n theirPromise: resolve(3),\n notAPromise: 4\n };\n \n hashSettled(promises).then(function(hash){\n // hash here is an object that looks like:\n // {\n // myPromise: { state: 'fulfilled', value: 1 },\n // yourPromise: { state: 'fulfilled', value: 2 },\n // theirPromise: { state: 'fulfilled', value: 3 },\n // notAPromise: { state: 'fulfilled', value: 4 }\n // }\n });\n ```\n \n If any of the `promises` given to `hash` are rejected, the state will\n be set to 'rejected' and the reason for rejection provided.\n \n Example:\n \n ```javascript\n import { hashSettled, reject, resolve } from 'rsvp';\n \n let promises = {\n myPromise: resolve(1),\n rejectedPromise: reject(new Error('rejection')),\n anotherRejectedPromise: reject(new Error('more rejection')),\n };\n \n hashSettled(promises).then(function(hash){\n // hash here is an object that looks like:\n // {\n // myPromise: { state: 'fulfilled', value: 1 },\n // rejectedPromise: { state: 'rejected', reason: Error },\n // anotherRejectedPromise: { state: 'rejected', reason: Error },\n // }\n // Note that for rejectedPromise, reason.message == 'rejection',\n // and for anotherRejectedPromise, reason.message == 'more rejection'.\n });\n ```\n \n An important note: `hashSettled` is intended for plain JavaScript objects that\n are just a set of keys and values. `hashSettled` will NOT preserve prototype\n chains.\n \n Example:\n \n ```javascript\n import Promise, { hashSettled, resolve } from 'rsvp';\n \n function MyConstructor(){\n this.example = resolve('Example');\n }\n \n MyConstructor.prototype = {\n protoProperty: Promise.resolve('Proto Property')\n };\n \n let myObject = new MyConstructor();\n \n hashSettled(myObject).then(function(hash){\n // protoProperty will not be present, instead you will just have an\n // object that looks like:\n // {\n // example: { state: 'fulfilled', value: 'Example' }\n // }\n //\n // hash.hasOwnProperty('protoProperty'); // false\n // 'undefined' === typeof hash.protoProperty\n });\n ```\n \n @method hashSettled\n @public\n @for rsvp\n @param {Object} object\n @param {String} label optional string that describes the promise.\n Useful for tooling.\n @return {Promise} promise that is fulfilled when when all properties of `promises`\n have been settled.\n @static\n */\n\n function hashSettled(object, label) {\n return Promise.resolve(object, label).then(function (object) {\n if (object === null || typeof object !== 'object') {\n throw new TypeError(\"hashSettled must be called with an object\");\n }\n\n return new HashSettled(Promise, object, false, label).promise;\n });\n }\n\n /**\n `rethrow` will rethrow an error on the next turn of the JavaScript event\n loop in order to aid debugging.\n \n Promises A+ specifies that any exceptions that occur with a promise must be\n caught by the promises implementation and bubbled to the last handler. For\n this reason, it is recommended that you always specify a second rejection\n handler function to `then`. However, `rethrow` will throw the exception\n outside of the promise, so it bubbles up to your console if in the browser,\n or domain/cause uncaught exception in Node. `rethrow` will also throw the\n error again so the error can be handled by the promise per the spec.\n \n ```javascript\n import { rethrow } from 'rsvp';\n \n function throws(){\n throw new Error('Whoops!');\n }\n \n let promise = new Promise(function(resolve, reject){\n throws();\n });\n \n promise.catch(rethrow).then(function(){\n // Code here doesn't run because the promise became rejected due to an\n // error!\n }, function (err){\n // handle the error here\n });\n ```\n \n The 'Whoops' error will be thrown on the next turn of the event loop\n and you can watch for it in your console. You can also handle it using a\n rejection handler given to `.then` or `.catch` on the returned promise.\n \n @method rethrow\n @public\n @static\n @for rsvp\n @param {Error} reason reason the promise became rejected.\n @throws Error\n @static\n */\n function rethrow(reason) {\n setTimeout(function () {\n throw reason;\n });\n throw reason;\n }\n\n /**\n `defer` returns an object similar to jQuery's `$.Deferred`.\n `defer` should be used when porting over code reliant on `$.Deferred`'s\n interface. New code should use the `Promise` constructor instead.\n \n The object returned from `defer` is a plain object with three properties:\n \n * promise - an `Promise`.\n * reject - a function that causes the `promise` property on this object to\n become rejected\n * resolve - a function that causes the `promise` property on this object to\n become fulfilled.\n \n Example:\n \n ```javascript\n let deferred = defer();\n \n deferred.resolve(\"Success!\");\n \n deferred.promise.then(function(value){\n // value here is \"Success!\"\n });\n ```\n \n @method defer\n @public\n @static\n @for rsvp\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Object}\n */\n\n function defer(label) {\n var deferred = { resolve: undefined, reject: undefined };\n\n deferred.promise = new Promise(function (resolve, reject) {\n deferred.resolve = resolve;\n deferred.reject = reject;\n }, label);\n\n return deferred;\n }\n\n var MapEnumerator = function (_Enumerator3) {\n (0, _emberBabel.inherits)(MapEnumerator, _Enumerator3);\n\n function MapEnumerator(Constructor, entries, mapFn, label) {\n\n return (0, _emberBabel.possibleConstructorReturn)(this, _Enumerator3.call(this, Constructor, entries, true, label, mapFn));\n }\n\n MapEnumerator.prototype._init = function _init(Constructor, input, bool, label, mapFn) {\n var len = input.length || 0;\n this.length = len;\n this._remaining = len;\n this._result = new Array(len);\n this._mapFn = mapFn;\n\n this._enumerate(input);\n };\n\n MapEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {\n if (firstPass) {\n var val = tryCatch(this._mapFn)(value, i);\n if (val === TRY_CATCH_ERROR) {\n this._settledAt(REJECTED, i, val.error, false);\n } else {\n this._eachEntry(val, i, false);\n }\n } else {\n this._remaining--;\n this._result[i] = value;\n }\n };\n\n return MapEnumerator;\n }(Enumerator);\n\n /**\n `map` is similar to JavaScript's native `map` method. `mapFn` is eagerly called\n meaning that as soon as any promise resolves its value will be passed to `mapFn`.\n `map` returns a promise that will become fulfilled with the result of running\n `mapFn` on the values the promises become fulfilled with.\n \n For example:\n \n ```javascript\n import { map, resolve } from 'rsvp';\n \n let promise1 = resolve(1);\n let promise2 = resolve(2);\n let promise3 = resolve(3);\n let promises = [ promise1, promise2, promise3 ];\n \n let mapFn = function(item){\n return item + 1;\n };\n \n map(promises, mapFn).then(function(result){\n // result is [ 2, 3, 4 ]\n });\n ```\n \n If any of the `promises` given to `map` are rejected, the first promise\n that is rejected will be given as an argument to the returned promise's\n rejection handler. For example:\n \n ```javascript\n import { map, reject, resolve } from 'rsvp';\n \n let promise1 = resolve(1);\n let promise2 = reject(new Error('2'));\n let promise3 = reject(new Error('3'));\n let promises = [ promise1, promise2, promise3 ];\n \n let mapFn = function(item){\n return item + 1;\n };\n \n map(promises, mapFn).then(function(array){\n // Code here never runs because there are rejected promises!\n }, function(reason) {\n // reason.message === '2'\n });\n ```\n \n `map` will also wait if a promise is returned from `mapFn`. For example,\n say you want to get all comments from a set of blog posts, but you need\n the blog posts first because they contain a url to those comments.\n \n ```javscript\n import { map } from 'rsvp';\n \n let mapFn = function(blogPost){\n // getComments does some ajax and returns an Promise that is fulfilled\n // with some comments data\n return getComments(blogPost.comments_url);\n };\n \n // getBlogPosts does some ajax and returns an Promise that is fulfilled\n // with some blog post data\n map(getBlogPosts(), mapFn).then(function(comments){\n // comments is the result of asking the server for the comments\n // of all blog posts returned from getBlogPosts()\n });\n ```\n \n @method map\n @public\n @static\n @for rsvp\n @param {Array} promises\n @param {Function} mapFn function to be called on each fulfilled promise.\n @param {String} label optional string for labeling the promise.\n Useful for tooling.\n @return {Promise} promise that is fulfilled with the result of calling\n `mapFn` on each fulfilled promise or value when they become fulfilled.\n The promise will be rejected if any of the given `promises` become rejected.\n */\n\n function map(promises, mapFn, label) {\n if (typeof mapFn !== 'function') {\n return Promise.reject(new TypeError(\"map expects a function as a second argument\"), label);\n }\n\n return Promise.resolve(promises, label).then(function (promises) {\n if (!Array.isArray(promises)) {\n throw new TypeError(\"map must be called with an array\");\n }\n return new MapEnumerator(Promise, promises, mapFn, label).promise;\n });\n }\n\n /**\n This is a convenient alias for `Promise.resolve`.\n \n @method resolve\n @public\n @static\n @for rsvp\n @param {*} value value that the returned promise will be resolved with\n @param {String} label optional string for identifying the returned promise.\n Useful for tooling.\n @return {Promise} a promise that will become fulfilled with the given\n `value`\n */\n function resolve$2(value, label) {\n return Promise.resolve(value, label);\n }\n\n /**\n This is a convenient alias for `Promise.reject`.\n \n @method reject\n @public\n @static\n @for rsvp\n @param {*} reason value that the returned promise will be rejected with.\n @param {String} label optional string for identifying the returned promise.\n Useful for tooling.\n @return {Promise} a promise rejected with the given `reason`.\n */\n function reject$2(reason, label) {\n return Promise.reject(reason, label);\n }\n\n var EMPTY_OBJECT = {};\n\n var FilterEnumerator = function (_MapEnumerator) {\n (0, _emberBabel.inherits)(FilterEnumerator, _MapEnumerator);\n\n function FilterEnumerator() {\n\n return (0, _emberBabel.possibleConstructorReturn)(this, _MapEnumerator.apply(this, arguments));\n }\n\n FilterEnumerator.prototype._checkFullfillment = function _checkFullfillment() {\n if (this._remaining === 0 && this._result !== null) {\n var result = this._result.filter(function (val) {\n return val !== EMPTY_OBJECT;\n });\n fulfill(this.promise, result);\n this._result = null;\n }\n };\n\n FilterEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {\n if (firstPass) {\n this._result[i] = value;\n var val = tryCatch(this._mapFn)(value, i);\n if (val === TRY_CATCH_ERROR) {\n this._settledAt(REJECTED, i, val.error, false);\n } else {\n this._eachEntry(val, i, false);\n }\n } else {\n this._remaining--;\n if (!value) {\n this._result[i] = EMPTY_OBJECT;\n }\n }\n };\n\n return FilterEnumerator;\n }(MapEnumerator);\n\n /**\n `filter` is similar to JavaScript's native `filter` method.\n `filterFn` is eagerly called meaning that as soon as any promise\n resolves its value will be passed to `filterFn`. `filter` returns\n a promise that will become fulfilled with the result of running\n `filterFn` on the values the promises become fulfilled with.\n \n For example:\n \n ```javascript\n import { filter, resolve } from 'rsvp';\n \n let promise1 = resolve(1);\n let promise2 = resolve(2);\n let promise3 = resolve(3);\n \n let promises = [promise1, promise2, promise3];\n \n let filterFn = function(item){\n return item > 1;\n };\n \n filter(promises, filterFn).then(function(result){\n // result is [ 2, 3 ]\n });\n ```\n \n If any of the `promises` given to `filter` are rejected, the first promise\n that is rejected will be given as an argument to the returned promise's\n rejection handler. For example:\n \n ```javascript\n import { filter, reject, resolve } from 'rsvp';\n \n let promise1 = resolve(1);\n let promise2 = reject(new Error('2'));\n let promise3 = reject(new Error('3'));\n let promises = [ promise1, promise2, promise3 ];\n \n let filterFn = function(item){\n return item > 1;\n };\n \n filter(promises, filterFn).then(function(array){\n // Code here never runs because there are rejected promises!\n }, function(reason) {\n // reason.message === '2'\n });\n ```\n \n `filter` will also wait for any promises returned from `filterFn`.\n For instance, you may want to fetch a list of users then return a subset\n of those users based on some asynchronous operation:\n \n ```javascript\n import { filter, resolve } from 'rsvp';\n \n let alice = { name: 'alice' };\n let bob = { name: 'bob' };\n let users = [ alice, bob ];\n \n let promises = users.map(function(user){\n return resolve(user);\n });\n \n let filterFn = function(user){\n // Here, Alice has permissions to create a blog post, but Bob does not.\n return getPrivilegesForUser(user).then(function(privs){\n return privs.can_create_blog_post === true;\n });\n };\n filter(promises, filterFn).then(function(users){\n // true, because the server told us only Alice can create a blog post.\n users.length === 1;\n // false, because Alice is the only user present in `users`\n users[0] === bob;\n });\n ```\n \n @method filter\n @public\n @static\n @for rsvp\n @param {Array} promises\n @param {Function} filterFn - function to be called on each resolved value to\n filter the final results.\n @param {String} label optional string describing the promise. Useful for\n tooling.\n @return {Promise}\n */\n\n function filter(promises, filterFn, label) {\n if (typeof filterFn !== 'function') {\n return Promise.reject(new TypeError(\"filter expects function as a second argument\"), label);\n }\n\n return Promise.resolve(promises, label).then(function (promises) {\n if (!Array.isArray(promises)) {\n throw new TypeError(\"filter must be called with an array\");\n }\n return new FilterEnumerator(Promise, promises, filterFn, label).promise;\n });\n }\n\n var len = 0;\n var vertxNext = void 0;\n function asap(callback, arg) {\n queue$1[len] = callback;\n queue$1[len + 1] = arg;\n len += 2;\n if (len === 2) {\n // If len is 1, that means that we need to schedule an async flush.\n // If additional callbacks are queued before the queue is flushed, they\n // will be processed by this flush that we are scheduling.\n scheduleFlush$1();\n }\n }\n\n var browserWindow = typeof window !== 'undefined' ? window : undefined;\n var browserGlobal = browserWindow || {};\n var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;\n var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';\n\n // test for web worker but not in IE10\n var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';\n\n // node\n function useNextTick() {\n var nextTick = process.nextTick;\n // node version 0.10.x displays a deprecation warning when nextTick is used recursively\n // setImmediate should be used instead instead\n var version = process.versions.node.match(/^(?:(\\d+)\\.)?(?:(\\d+)\\.)?(\\*|\\d+)$/);\n if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {\n nextTick = setImmediate;\n }\n return function () {\n return nextTick(flush);\n };\n }\n\n // vertx\n function useVertxTimer() {\n if (typeof vertxNext !== 'undefined') {\n return function () {\n vertxNext(flush);\n };\n }\n return useSetTimeout();\n }\n\n function useMutationObserver() {\n var iterations = 0;\n var observer = new BrowserMutationObserver(flush);\n var node = document.createTextNode('');\n observer.observe(node, { characterData: true });\n\n return function () {\n return node.data = iterations = ++iterations % 2;\n };\n }\n\n // web worker\n function useMessageChannel() {\n var channel = new MessageChannel();\n channel.port1.onmessage = flush;\n return function () {\n return channel.port2.postMessage(0);\n };\n }\n\n function useSetTimeout() {\n return function () {\n return setTimeout(flush, 1);\n };\n }\n\n var queue$1 = new Array(1000);\n\n function flush() {\n for (var i = 0; i < len; i += 2) {\n var callback = queue$1[i];\n var arg = queue$1[i + 1];\n\n callback(arg);\n\n queue$1[i] = undefined;\n queue$1[i + 1] = undefined;\n }\n\n len = 0;\n }\n\n function attemptVertex() {\n try {\n var vertx = Function('return this')().require('vertx');\n vertxNext = vertx.runOnLoop || vertx.runOnContext;\n return useVertxTimer();\n } catch (e) {\n return useSetTimeout();\n }\n }\n\n var scheduleFlush$1 = void 0;\n // Decide what async method to use to triggering processing of queued callbacks:\n if (isNode) {\n scheduleFlush$1 = useNextTick();\n } else if (BrowserMutationObserver) {\n scheduleFlush$1 = useMutationObserver();\n } else if (isWorker) {\n scheduleFlush$1 = useMessageChannel();\n } else if (browserWindow === undefined && typeof _nodeModule.require === 'function') {\n scheduleFlush$1 = attemptVertex();\n } else {\n scheduleFlush$1 = useSetTimeout();\n }\n\n // defaults\n config.async = asap;\n config.after = function (cb) {\n return setTimeout(cb, 0);\n };\n var cast = resolve$2;\n\n var async = function (callback, arg) {\n return config.async(callback, arg);\n };\n\n function on() {\n config.on.apply(config, arguments);\n }\n\n function off() {\n config.off.apply(config, arguments);\n }\n\n // Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`\n if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'] === 'object') {\n var callbacks = window['__PROMISE_INSTRUMENTATION__'];\n configure('instrument', true);\n for (var eventName in callbacks) {\n if (callbacks.hasOwnProperty(eventName)) {\n on(eventName, callbacks[eventName]);\n }\n }\n }\n\n // the default export here is for backwards compat:\n // https://github.com/tildeio/rsvp.js/issues/434\n var rsvp = {\n asap: asap,\n cast: cast,\n Promise: Promise,\n EventTarget: EventTarget,\n all: all$1,\n allSettled: allSettled,\n race: race$1,\n hash: hash,\n hashSettled: hashSettled,\n rethrow: rethrow,\n defer: defer,\n denodeify: denodeify,\n configure: configure,\n on: on,\n off: off,\n resolve: resolve$2,\n reject: reject$2,\n map: map,\n async: async,\n filter: filter\n };\n\n exports.default = rsvp;\n exports.asap = asap;\n exports.cast = cast;\n exports.Promise = Promise;\n exports.EventTarget = EventTarget;\n exports.all = all$1;\n exports.allSettled = allSettled;\n exports.race = race$1;\n exports.hash = hash;\n exports.hashSettled = hashSettled;\n exports.rethrow = rethrow;\n exports.defer = defer;\n exports.denodeify = denodeify;\n exports.configure = configure;\n exports.on = on;\n exports.off = off;\n exports.resolve = resolve$2;\n exports.reject = reject$2;\n exports.map = map;\n exports.async = async;\n exports.filter = filter;\n});","requireModule('ember')"]}