{{@person.signature}}
\n ```\n \n You will be able to use `![](\"https://emberjs.com/tomster.jpg\")
\n Out of office this week
\n ```\n \n ## File System Nesting\n \n Components can be nested inside sub-folders for logical groupping. For\n example, if we placed our template in\n `app/templates/components/person/short-profile.hbs`, we can invoke it as\n `Admin mode
\n {{! Executed in the current context. }}\nAdmin mode
\n {{! Executed in the current context. }}\n {{/person-profile}}\n ```\n \n ```app/templates/components/person-profile.hbs\nWelcome, {{@firstName}} {{@lastName}}!
\n * ```\n */\n\n\n get isDestroying() {\n return this[DESTROYING];\n }\n\n get isDestroyed() {\n return this[DESTROYED];\n }\n /**\n * Called before the component has been removed from the DOM.\n */\n\n\n willDestroy() {}\n\n }\n\n _exports.default = GlimmerComponent;\n});","define(\"@glimmer/component/-private/owner\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.setOwner = void 0;\n var setOwner = Ember.setOwner;\n _exports.setOwner = setOwner;\n});","define(\"@glimmer/component/index\", [\"exports\", \"@glimmer/component/-private/component-manager\", \"@glimmer/component/-private/component\"], function (_exports, _componentManager, _component) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n if (true) {\n Ember._setComponentManager(owner => {\n return new _componentManager.default(owner);\n }, _component.default);\n } else {\n Ember._setComponentManager('glimmer', _component.default);\n }\n\n var _default = _component.default;\n _exports.default = _default;\n});","define('ember-cli-head/components/head-layout', ['exports', 'ember-cli-head/templates/components/head-layout'], function (exports, _headLayout) {\n 'use strict';\n\n Object.defineProperty(exports, \"__esModule\", {\n value: true\n });\n exports.default = Ember.Component.extend({\n tagName: '',\n layout: _headLayout.default,\n\n /**\n * If true, this will tear down any existing head on init of this component.\n * This is useful if there is a head built with fastboot - it will then be torn down when this is initialized in the browser.\n * If you do not want this behavior, you can set this to false.\n * @public\n */\n shouldTearDownOnInit: true,\n\n headElement: Ember.computed(function () {\n let documentService = Ember.getOwner(this).lookup('service:-document');\n return documentService.head;\n }),\n\n init() {\n this._super(...arguments);\n\n if (Ember.get(this, 'shouldTearDownOnInit')) {\n this._tearDownHead();\n }\n },\n\n /**\n * Tear down any previous head, if there was one.\n * @private\n */\n _tearDownHead() {\n if (this._isFastboot()) {\n return;\n }\n\n // clear fast booted head (if any)\n let startMeta = document.querySelector('meta[name=\"ember-cli-head-start\"]');\n let endMeta = document.querySelector('meta[name=\"ember-cli-head-end\"]');\n if (startMeta && endMeta) {\n let el = startMeta.nextSibling;\n while (el && el !== endMeta) {\n document.head.removeChild(el);\n el = startMeta.nextSibling;\n }\n document.head.removeChild(startMeta);\n document.head.removeChild(endMeta);\n }\n },\n\n _isFastboot() {\n return typeof FastBoot !== 'undefined';\n }\n\n });\n});","define('ember-cli-head/services/head-data', ['exports'], function (exports) {\n 'use strict';\n\n Object.defineProperty(exports, \"__esModule\", {\n value: true\n });\n exports.default = Ember.Service.extend({});\n});","define(\"ember-cli-head/templates/components/head-layout\", [\"exports\"], function (exports) {\n \"use strict\";\n\n Object.defineProperty(exports, \"__esModule\", {\n value: true\n });\n exports.default = Ember.HTMLBars.template({ \"id\": \"+o+owTmf\", \"block\": \"{\\\"symbols\\\":[],\\\"statements\\\":[[4,\\\"in-element\\\",[[24,[\\\"headElement\\\"]]],[[\\\"guid\\\",\\\"nextSibling\\\"],[\\\"%cursor:0%\\\",null]],{\\\"statements\\\":[[0,\\\" \\\"],[7,\\\"meta\\\",true],[10,\\\"name\\\",\\\"ember-cli-head-start\\\"],[10,\\\"content\\\",\\\"\\\"],[8],[9],[1,[22,\\\"head-content\\\"],false],[7,\\\"meta\\\",true],[10,\\\"name\\\",\\\"ember-cli-head-end\\\"],[10,\\\"content\\\",\\\"\\\"],[8],[9],[0,\\\"\\\\n\\\"]],\\\"parameters\\\":[]},null]],\\\"hasEval\\\":false}\", \"meta\": { \"moduleName\": \"ember-cli-head/templates/components/head-layout.hbs\" } });\n});","define(\"ember-concurrency-decorators/index\", [\"exports\", \"@ember-decorators/utils/decorator\", \"ember-concurrency\", \"ember-concurrency-decorators/last-value\"], function (_exports, _decorator, _emberConcurrency, _lastValue) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n Object.defineProperty(_exports, \"lastValue\", {\n enumerable: true,\n get: function () {\n return _lastValue.default;\n }\n });\n _exports.enqueueTaskGroup = _exports.keepLatestTaskGroup = _exports.dropTaskGroup = _exports.restartableTaskGroup = _exports.taskGroup = _exports.enqueueTask = _exports.keepLatestTask = _exports.dropTask = _exports.restartableTask = _exports.task = void 0;\n\n /**\n * This utility function assures compatibility with the Ember object model style\n * and initializer syntax required by Babel 6.\n *\n * For native classes using the method shorthand style (TypeScript & Babel 7),\n * this function will access the `value`. For legacy code it will get the value\n * from the initializer.\n *\n * // Ember object model\n * export default EmberObject.extend({\n * @task\n * someTask: function*() {}\n * });\n *\n * // Class syntax with initializers\n * export default class extends EmberObject {\n * @task\n * someTask = function*() {}\n * }\n *\n * @param desc\n * @returns {object|null}\n * @private\n */\n function extractValue(desc) {\n if (typeof desc.initializer === 'function') {\n return desc.initializer.call(null);\n }\n\n if (typeof desc.get === 'function') {\n return desc.get.call(null);\n }\n\n if (desc.value) {\n return desc.value;\n }\n }\n /**\n * Takes a `PropertyDescriptor` and turns it into an ember-concurrency\n * `TaskProperty`.\n *\n * @param desc\n * @returns {TaskProperty}\n * @private\n */\n\n\n function createTaskFromDescriptor(desc) {\n const value = extractValue(desc);\n (false && !(typeof value === 'function' || typeof value === 'object' && typeof value.perform === 'function') && Ember.assert('ember-concurrency-decorators: Can only decorate a generator function as a task or an object with a generator method `perform` as an encapsulated task.', typeof value === 'function' || typeof value === 'object' && typeof value.perform === 'function'));\n return (0, _emberConcurrency.task)(value);\n }\n /**\n * Takes a `PropertyDescriptor` and turns it into an ember-concurrency\n * `TaskGroupProperty`.\n *\n * @param desc\n * @returns {TaskGroupProperty}\n * @private\n */\n\n\n function createTaskGroupFromDescriptor(_desc) {\n return (0, _emberConcurrency.taskGroup)();\n }\n /**\n * Applies the `options` provided using the chaining API on the given `task`.\n *\n * @param options\n * @param {TaskProperty|TaskGroupProperty} task\n * @private\n */\n\n\n function applyOptions(options, task) {\n return Object.entries(options).reduce((taskProperty, [key, value]) => {\n (false && !(typeof taskProperty[key] === 'function') && Ember.assert(`ember-concurrency-decorators: Option '${key}' is not a valid function`, typeof taskProperty[key] === 'function'));\n\n if (value === true) {\n return taskProperty[key]();\n }\n\n return taskProperty[key](value);\n }, task // The CP decorator gets executed in `createDecorator`\n );\n }\n /**\n * Creates a decorator function that transforms the decorated property using the\n * given `propertyCreator` and accepts an optional user provided options hash,\n * that that will be merged with the `baseOptions`.\n *\n * @param {function} propertyCreator\n * @param {object} [baseOptions={}]\n * @private\n */\n\n\n const createDecorator = (propertyCreator, baseOptions = {}) => (0, _decorator.decoratorWithParams)((target, key, desc, [userOptions] = []) => {\n const {\n initializer,\n value\n } = desc;\n delete desc.initializer;\n delete desc.value;\n return applyOptions({ ...baseOptions,\n ...userOptions\n }, propertyCreator({ ...desc,\n initializer,\n value\n }))(target, key, desc);\n });\n /**\n * Turns the decorated generator function into a task.\n *\n * Optionally takes a hash of options that will be applied as modifiers to the\n * task. For instance `maxConcurrency`, `on`, `group` or `keepLatest`.\n *\n * ```js\n * import EmberObject from '@ember/object';\n * import { task } from 'ember-concurrency-decorators';\n *\n * class extends EmberObject {\n * @task\n * *plainTask() {}\n *\n * @task({ maxConcurrency: 5, keepLatest: true, cancelOn: 'click' })\n * *taskWithModifiers() {}\n * }\n * ```\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskProperty}\n */\n\n\n const task = createDecorator(createTaskFromDescriptor);\n /**\n * Turns the decorated generator function into a task and applies the\n * `restartable` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskProperty}\n */\n\n _exports.task = task;\n const restartableTask = createDecorator(createTaskFromDescriptor, {\n restartable: true\n });\n /**\n * Turns the decorated generator function into a task and applies the\n * `drop` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskProperty}\n */\n\n _exports.restartableTask = restartableTask;\n const dropTask = createDecorator(createTaskFromDescriptor, {\n drop: true\n });\n /**\n * Turns the decorated generator function into a task and applies the\n * `keepLatest` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskProperty}\n */\n\n _exports.dropTask = dropTask;\n const keepLatestTask = createDecorator(createTaskFromDescriptor, {\n keepLatest: true\n });\n /**\n * Turns the decorated generator function into a task and applies the\n * `enqueue` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskProperty}\n */\n\n _exports.keepLatestTask = keepLatestTask;\n const enqueueTask = createDecorator(createTaskFromDescriptor, {\n enqueue: true\n });\n /**\n * Turns the decorated property into a task group.\n *\n * Optionally takes a hash of options that will be applied as modifiers to the\n * task group. For instance `maxConcurrency` or `keepLatest`.\n *\n * ```js\n * import EmberObject from '@ember/object';\n * import { task taskGroup } from 'ember-concurrency-decorators';\n *\n * class extends EmberObject {\n * @taskGroup({ maxConcurrency: 5 }) someTaskGroup;\n *\n * @task({ group: 'someTaskGroup' })\n * *someTask() {}\n *\n * @task({ group: 'someTaskGroup' })\n * *anotherTask() {}\n * }\n * ```\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskGroupProperty}\n */\n\n _exports.enqueueTask = enqueueTask;\n const taskGroup = createDecorator(createTaskGroupFromDescriptor);\n /**\n * Turns the decorated property into a task group and applies the\n * `restartable` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task group.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskGroupProperty}\n */\n\n _exports.taskGroup = taskGroup;\n const restartableTaskGroup = createDecorator(createTaskGroupFromDescriptor, {\n restartable: true\n });\n /**\n * Turns the decorated property into a task group and applies the\n * `drop` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task group.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskGroupProperty}\n */\n\n _exports.restartableTaskGroup = restartableTaskGroup;\n const dropTaskGroup = createDecorator(createTaskGroupFromDescriptor, {\n drop: true\n });\n /**\n * Turns the decorated property into a task group and applies the\n * `keepLatest` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task group.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskGroupProperty}\n */\n\n _exports.dropTaskGroup = dropTaskGroup;\n const keepLatestTaskGroup = createDecorator(createTaskGroupFromDescriptor, {\n keepLatest: true\n });\n /**\n * Turns the decorated property into a task group and applies the\n * `enqueue` modifier.\n *\n * Optionally takes a hash of further options that will be applied as modifiers\n * to the task group.\n *\n * @function\n * @param {object?} [options={}]\n * @return {TaskGroupProperty}\n */\n\n _exports.keepLatestTaskGroup = keepLatestTaskGroup;\n const enqueueTaskGroup = createDecorator(createTaskGroupFromDescriptor, {\n enqueue: true\n });\n _exports.enqueueTaskGroup = enqueueTaskGroup;\n});","define(\"ember-concurrency-decorators/last-value\", [\"exports\", \"@ember-decorators/utils/decorator\"], function (_exports, _decorator) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n /**\n * This decorator allows you to alias a property to the result of a task. You can also provide a default value to use before the task has completed.\n *\n * ```js\n * import Component from '@ember/component';\n * import { task } from 'ember-concurrency-decorators';\n * import { lastValue } from 'ember-concurrency-decorators';\n *\n * export default class ExampleComponent extends Component {\n * @task\n * someTask = function*() {\n * // ...\n * };\n *\n * @lastValue('someTask')\n * someTaskValue;\n *\n * @lastValue('someTask')\n * someTaskValueWithDefault = 'A default value';\n * }\n * ```\n *\n * @function\n * @param {string} taskName the name of the task to read a value from\n */\n // eslint-disable-next-line func-names\n var _default = (0, _decorator.decoratorWithRequiredParams)(function lastValue(target, key, desc, [taskName]) {\n (false && !(typeof taskName === 'string') && Ember.assert(`ember-concurrency-decorators: @lastValue expects a task name as the first parameter.`, typeof taskName === 'string'));\n const {\n initializer\n } = desc;\n delete desc.initializer;\n const cp = Ember.computed(`${taskName}.lastSuccessful`, function () {\n const lastInstance = Ember.get(this, `${taskName}.lastSuccessful`);\n\n if (lastInstance) {\n return Ember.get(lastInstance, 'value');\n }\n\n if (initializer) {\n return initializer.call(this);\n }\n }); // @ts-ignore\n\n return cp(target, key, desc);\n });\n\n _exports.default = _default;\n});","define(\"ember-concurrency/-buffer-policy\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.dropButKeepLatestPolicy = _exports.cancelOngoingTasksPolicy = _exports.dropQueuedTasksPolicy = _exports.enqueueTasksPolicy = void 0;\n\n const saturateActiveQueue = scheduler => {\n while (scheduler.activeTaskInstances.length < scheduler.maxConcurrency) {\n let taskInstance = scheduler.queuedTaskInstances.shift();\n\n if (!taskInstance) {\n break;\n }\n\n scheduler.activeTaskInstances.push(taskInstance);\n }\n };\n\n function numPerformSlots(scheduler) {\n return scheduler.maxConcurrency - scheduler.queuedTaskInstances.length - scheduler.activeTaskInstances.length;\n }\n\n const enqueueTasksPolicy = {\n requiresUnboundedConcurrency: true,\n\n schedule(scheduler) {\n // [a,b,_] [c,d,e,f] becomes\n // [a,b,c] [d,e,f]\n saturateActiveQueue(scheduler);\n },\n\n getNextPerformStatus(scheduler) {\n return numPerformSlots(scheduler) > 0 ? 'succeed' : 'enqueue';\n }\n\n };\n _exports.enqueueTasksPolicy = enqueueTasksPolicy;\n const dropQueuedTasksPolicy = {\n cancelReason: `it belongs to a 'drop' Task that was already running`,\n\n schedule(scheduler) {\n // [a,b,_] [c,d,e,f] becomes\n // [a,b,c] []\n saturateActiveQueue(scheduler);\n scheduler.spliceTaskInstances(this.cancelReason, scheduler.queuedTaskInstances, 0, scheduler.queuedTaskInstances.length);\n },\n\n getNextPerformStatus(scheduler) {\n return numPerformSlots(scheduler) > 0 ? 'succeed' : 'drop';\n }\n\n };\n _exports.dropQueuedTasksPolicy = dropQueuedTasksPolicy;\n const cancelOngoingTasksPolicy = {\n cancelReason: `it belongs to a 'restartable' Task that was .perform()ed again`,\n\n schedule(scheduler) {\n // [a,b,_] [c,d,e,f] becomes\n // [d,e,f] []\n let activeTaskInstances = scheduler.activeTaskInstances;\n let queuedTaskInstances = scheduler.queuedTaskInstances;\n activeTaskInstances.push(...queuedTaskInstances);\n queuedTaskInstances.length = 0;\n let numToShift = Math.max(0, activeTaskInstances.length - scheduler.maxConcurrency);\n scheduler.spliceTaskInstances(this.cancelReason, activeTaskInstances, 0, numToShift);\n },\n\n getNextPerformStatus(scheduler) {\n return numPerformSlots(scheduler) > 0 ? 'succeed' : 'cancel_previous';\n }\n\n };\n _exports.cancelOngoingTasksPolicy = cancelOngoingTasksPolicy;\n const dropButKeepLatestPolicy = {\n cancelReason: `it belongs to a 'keepLatest' Task that was already running`,\n\n schedule(scheduler) {\n // [a,b,_] [c,d,e,f] becomes\n // [d,e,f] []\n saturateActiveQueue(scheduler);\n scheduler.spliceTaskInstances(this.cancelReason, scheduler.queuedTaskInstances, 0, scheduler.queuedTaskInstances.length - 1);\n }\n\n };\n _exports.dropButKeepLatestPolicy = dropButKeepLatestPolicy;\n});","define(\"ember-concurrency/-cancelable-promise-helpers\", [\"exports\", \"ember-concurrency/-task-instance\", \"ember-concurrency/utils\"], function (_exports, _taskInstance, _utils) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.hash = _exports.race = _exports.allSettled = _exports.all = void 0;\n const asyncAll = taskAwareVariantOf(Ember.RSVP.Promise, 'all', identity);\n\n function* resolver(value) {\n return value;\n }\n /**\n * A cancelation-aware variant of [Promise.all](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all).\n * The normal version of a `Promise.all` just returns a regular, uncancelable\n * Promise. The `ember-concurrency` variant of `all()` has the following\n * additional behavior:\n *\n * - if the task that `yield`ed `all()` is canceled, any of the\n * {@linkcode TaskInstance}s passed in to `all` will be canceled\n * - if any of the {@linkcode TaskInstance}s (or regular promises) passed in reject (or\n * are canceled), all of the other unfinished `TaskInstance`s will\n * be automatically canceled.\n *\n * [Check out the \"Awaiting Multiple Child Tasks example\"](/docs/examples/joining-tasks)\n */\n\n\n const all = things => {\n // Extra assertion here to circumvent the `things.length` short circuit.\n (false && !(Array.isArray(things)) && Ember.assert(`'all' expects an array.`, Array.isArray(things)));\n\n if (things.length === 0) {\n return things;\n }\n\n for (let i = 0; i < things.length; ++i) {\n let t = things[i];\n\n if (!(t && t[_utils.yieldableSymbol])) {\n return asyncAll(things);\n }\n }\n\n let isAsync = false;\n let taskInstances = things.map(thing => {\n let ti = _taskInstance.default.create({\n // TODO: consider simpler iterator than full on generator fn?\n fn: resolver,\n args: [thing]\n })._start();\n\n if (ti._completionState !== 1) {\n isAsync = true;\n }\n\n return ti;\n });\n\n if (isAsync) {\n return asyncAll(taskInstances);\n } else {\n return taskInstances.map(ti => ti.value);\n }\n };\n /**\n * A cancelation-aware variant of [RSVP.allSettled](http://emberjs.com/api/classes/RSVP.html#method_allSettled).\n * The normal version of a `RSVP.allSettled` just returns a regular, uncancelable\n * Promise. The `ember-concurrency` variant of `allSettled()` has the following\n * additional behavior:\n *\n * - if the task that `yield`ed `allSettled()` is canceled, any of the\n * {@linkcode TaskInstance}s passed in to `allSettled` will be canceled\n */\n\n\n _exports.all = all;\n const allSettled = taskAwareVariantOf(Ember.RSVP, 'allSettled', identity);\n /**\n * A cancelation-aware variant of [Promise.race](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race).\n * The normal version of a `Promise.race` just returns a regular, uncancelable\n * Promise. The `ember-concurrency` variant of `race()` has the following\n * additional behavior:\n *\n * - if the task that `yield`ed `race()` is canceled, any of the\n * {@linkcode TaskInstance}s passed in to `race` will be canceled\n * - once any of the tasks/promises passed in complete (either success, failure,\n * or cancelation), any of the {@linkcode TaskInstance}s passed in will be canceled\n *\n * [Check out the \"Awaiting Multiple Child Tasks example\"](/docs/examples/joining-tasks)\n */\n\n _exports.allSettled = allSettled;\n const race = taskAwareVariantOf(Ember.RSVP.Promise, 'race', identity);\n /**\n * A cancelation-aware variant of [RSVP.hash](http://emberjs.com/api/classes/RSVP.html#hash).\n * The normal version of a `RSVP.hash` just returns a regular, uncancelable\n * Promise. The `ember-concurrency` variant of `hash()` has the following\n * additional behavior:\n *\n * - if the task that `yield`ed `hash()` is canceled, any of the\n * {@linkcode TaskInstance}s passed in to `allSettled` will be canceled\n * - if any of the items rejects/cancels, all other cancelable items\n * (e.g. {@linkcode TaskInstance}s) will be canceled\n */\n\n _exports.race = race;\n const hash = taskAwareVariantOf(Ember.RSVP, 'hash', getValues);\n _exports.hash = hash;\n\n function identity(obj) {\n return obj;\n }\n\n function getValues(obj) {\n return Object.keys(obj).map(k => obj[k]);\n }\n\n function taskAwareVariantOf(obj, method, getItems) {\n return function (thing) {\n let items = getItems(thing);\n (false && !(Array.isArray(items)) && Ember.assert(`'${method}' expects an array.`, Array.isArray(items)));\n let defer = Ember.RSVP.defer();\n obj[method](thing).then(defer.resolve, defer.reject);\n let hasCancelled = false;\n\n let cancelAll = () => {\n if (hasCancelled) {\n return;\n }\n\n hasCancelled = true;\n items.forEach(it => {\n if (it) {\n if (it instanceof _taskInstance.default) {\n it.cancel();\n } else if (typeof it.__ec_cancel__ === 'function') {\n it.__ec_cancel__();\n }\n }\n });\n };\n\n let promise = defer.promise.finally(cancelAll);\n promise.__ec_cancel__ = cancelAll;\n return promise;\n };\n }\n});","define(\"ember-concurrency/-encapsulated-task\", [\"exports\", \"ember-concurrency/-task-instance\"], function (_exports, _taskInstance) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n\n var _default = _taskInstance.default.extend({\n _makeIterator() {\n let perform = this.get('perform');\n (false && !(typeof perform === 'function') && Ember.assert(\"The object passed to `task()` must define a `perform` generator function, e.g. `perform: function * (a,b,c) {...}`, or better yet `*perform(a,b,c) {...}`\", typeof perform === 'function'));\n return perform.apply(this, this.args);\n },\n\n perform: null\n });\n\n _exports.default = _default;\n});","define(\"ember-concurrency/-helpers\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.taskHelperClosure = taskHelperClosure;\n\n function taskHelperClosure(helperName, taskMethod, _args, hash) {\n let task = _args[0];\n\n let outerArgs = _args.slice(1);\n\n return Ember.run.bind(null, function (...innerArgs) {\n if (!task || typeof task[taskMethod] !== 'function') {\n (false && !(false) && Ember.assert(`The first argument passed to the \\`${helperName}\\` helper should be a Task object (without quotes); you passed ${task}`, false));\n return;\n }\n\n if (hash && hash.value) {\n let event = innerArgs.pop();\n innerArgs.push(Ember.get(event, hash.value));\n }\n\n return task[taskMethod](...outerArgs, ...innerArgs);\n });\n }\n});","define(\"ember-concurrency/-property-modifiers-mixin\", [\"exports\", \"ember-concurrency/-scheduler\", \"ember-concurrency/-buffer-policy\"], function (_exports, _scheduler, _bufferPolicy) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.resolveScheduler = resolveScheduler;\n _exports.propertyModifiers = void 0;\n const propertyModifiers = {\n // by default, task(...) expands to task(...).enqueue().maxConcurrency(Infinity)\n _bufferPolicy: _bufferPolicy.enqueueTasksPolicy,\n _maxConcurrency: Infinity,\n _taskGroupPath: null,\n _hasUsedModifier: false,\n _hasSetBufferPolicy: false,\n _hasEnabledEvents: false,\n\n restartable() {\n return setBufferPolicy(this, _bufferPolicy.cancelOngoingTasksPolicy);\n },\n\n enqueue() {\n return setBufferPolicy(this, _bufferPolicy.enqueueTasksPolicy);\n },\n\n drop() {\n return setBufferPolicy(this, _bufferPolicy.dropQueuedTasksPolicy);\n },\n\n keepLatest() {\n return setBufferPolicy(this, _bufferPolicy.dropButKeepLatestPolicy);\n },\n\n maxConcurrency(n) {\n this._hasUsedModifier = true;\n this._maxConcurrency = n;\n assertModifiersNotMixedWithGroup(this);\n return this;\n },\n\n group(taskGroupPath) {\n this._taskGroupPath = taskGroupPath;\n assertModifiersNotMixedWithGroup(this);\n return this;\n },\n\n evented() {\n this._hasEnabledEvents = true;\n return this;\n },\n\n debug() {\n this._debug = true;\n return this;\n }\n\n };\n _exports.propertyModifiers = propertyModifiers;\n\n function setBufferPolicy(obj, policy) {\n obj._hasSetBufferPolicy = true;\n obj._hasUsedModifier = true;\n obj._bufferPolicy = policy;\n assertModifiersNotMixedWithGroup(obj);\n\n if (obj._maxConcurrency === Infinity) {\n obj._maxConcurrency = 1;\n }\n\n return obj;\n }\n\n function assertModifiersNotMixedWithGroup(obj) {\n (false && !(!obj._hasUsedModifier || !obj._taskGroupPath) && Ember.assert(`ember-concurrency does not currently support using both .group() with other task modifiers (e.g. drop(), enqueue(), restartable())`, !obj._hasUsedModifier || !obj._taskGroupPath));\n }\n\n function resolveScheduler(propertyObj, obj, TaskGroup) {\n if (propertyObj._taskGroupPath) {\n let taskGroup = obj.get(propertyObj._taskGroupPath);\n (false && !(taskGroup instanceof TaskGroup) && Ember.assert(`Expected path '${propertyObj._taskGroupPath}' to resolve to a TaskGroup object, but instead was ${taskGroup}`, taskGroup instanceof TaskGroup));\n return taskGroup._scheduler;\n } else {\n return _scheduler.default.create({\n bufferPolicy: propertyObj._bufferPolicy,\n maxConcurrency: propertyObj._maxConcurrency\n });\n }\n }\n});","define(\"ember-concurrency/-scheduler\", [\"exports\"], function (_exports) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.default = void 0;\n let SEEN_INDEX = 0;\n const Scheduler = Ember.Object.extend({\n lastPerformed: null,\n lastStarted: null,\n lastRunning: null,\n lastSuccessful: null,\n lastComplete: null,\n lastErrored: null,\n lastCanceled: null,\n lastIncomplete: null,\n performCount: 0,\n boundHandleFulfill: null,\n boundHandleReject: null,\n\n init() {\n this._super(...arguments);\n\n this.activeTaskInstances = [];\n this.queuedTaskInstances = [];\n },\n\n cancelAll(reason) {\n let seen = [];\n this.spliceTaskInstances(reason, this.activeTaskInstances, 0, this.activeTaskInstances.length, seen);\n this.spliceTaskInstances(reason, this.queuedTaskInstances, 0, this.queuedTaskInstances.length, seen);\n flushTaskCounts(seen);\n },\n\n spliceTaskInstances(cancelReason, taskInstances, index, count, seen) {\n for (let i = index; i < index + count; ++i) {\n let taskInstance = taskInstances[i];\n\n if (!taskInstance.hasStarted) {\n // This tracking logic is kinda spread all over the place...\n // maybe TaskInstances themselves could notify\n // some delegate of queued state changes upon cancelation?\n taskInstance.task.decrementProperty('numQueued');\n }\n\n taskInstance.cancel(cancelReason);\n\n if (seen) {\n seen.push(taskInstance.task);\n }\n }\n\n taskInstances.splice(index, count);\n },\n\n schedule(taskInstance) {\n Ember.set(this, 'lastPerformed', taskInstance);\n this.incrementProperty('performCount');\n taskInstance.task.incrementProperty('numQueued');\n this.queuedTaskInstances.push(taskInstance);\n\n this._flushQueues();\n },\n\n _flushQueues() {\n let seen = [];\n\n for (let i = 0; i < this.activeTaskInstances.length; ++i) {\n seen.push(this.activeTaskInstances[i].task);\n }\n\n this.activeTaskInstances = filterFinished(this.activeTaskInstances);\n this.bufferPolicy.schedule(this);\n var lastStarted = null;\n\n for (let i = 0; i < this.activeTaskInstances.length; ++i) {\n let taskInstance = this.activeTaskInstances[i];\n\n if (!taskInstance.hasStarted) {\n this._startTaskInstance(taskInstance);\n\n lastStarted = taskInstance;\n }\n\n seen.push(taskInstance.task);\n }\n\n if (lastStarted) {\n Ember.set(this, 'lastStarted', lastStarted);\n }\n\n Ember.set(this, 'lastRunning', lastStarted);\n\n for (let i = 0; i < this.queuedTaskInstances.length; ++i) {\n seen.push(this.queuedTaskInstances[i].task);\n }\n\n flushTaskCounts(seen);\n Ember.set(this, 'concurrency', this.activeTaskInstances.length);\n },\n\n _startTaskInstance(taskInstance) {\n let task = taskInstance.task;\n task.decrementProperty('numQueued');\n task.incrementProperty('numRunning');\n\n taskInstance._start()._onFinalize(() => {\n task.decrementProperty('numRunning');\n var state = taskInstance._completionState;\n Ember.set(this, 'lastComplete', taskInstance);\n\n if (state === 1) {\n Ember.set(this, 'lastSuccessful', taskInstance);\n } else {\n if (state === 2) {\n Ember.set(this, 'lastErrored', taskInstance);\n } else if (state === 3) {\n Ember.set(this, 'lastCanceled', taskInstance);\n }\n\n Ember.set(this, 'lastIncomplete', taskInstance);\n }\n\n Ember.run.once(this, this._flushQueues);\n });\n }\n\n });\n\n function flushTaskCounts(tasks) {\n SEEN_INDEX++;\n\n for (let i = 0, l = tasks.length; i < l; ++i) {\n let task = tasks[i];\n\n if (task._seenIndex < SEEN_INDEX) {\n task._seenIndex = SEEN_INDEX;\n updateTaskChainCounts(task);\n }\n }\n }\n\n function updateTaskChainCounts(task) {\n let numRunning = task.numRunning;\n let numQueued = task.numQueued;\n let taskGroup = task.get('group');\n\n while (taskGroup) {\n Ember.set(taskGroup, 'numRunning', numRunning);\n Ember.set(taskGroup, 'numQueued', numQueued);\n taskGroup = taskGroup.get('group');\n }\n }\n\n function filterFinished(taskInstances) {\n let ret = [];\n\n for (let i = 0, l = taskInstances.length; i < l; ++i) {\n let taskInstance = taskInstances[i];\n\n if (Ember.get(taskInstance, 'isFinished') === false) {\n ret.push(taskInstance);\n }\n }\n\n return ret;\n }\n\n var _default = Scheduler;\n _exports.default = _default;\n});","define(\"ember-concurrency/-task-group\", [\"exports\", \"ember-concurrency/utils\", \"ember-concurrency/-task-state-mixin\", \"ember-concurrency/-property-modifiers-mixin\"], function (_exports, _utils, _taskStateMixin, _propertyModifiersMixin) {\n \"use strict\";\n\n Object.defineProperty(_exports, \"__esModule\", {\n value: true\n });\n _exports.TaskGroupProperty = _exports.TaskGroup = void 0;\n const TaskGroup = Ember.Object.extend(_taskStateMixin.default, {\n isTaskGroup: true,\n\n toString() {\n return `