{"version":3,"file":"vendors-da7e83e9.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/aurelia-testing/dist/native-modules/aurelia-testing.js","webpack://iadviser/./node_modules/aurelia-typed-observable-plugin/dist/native-modules/index.js","webpack://iadviser/./node_modules/aurelia-validation/dist/native-modules/aurelia-validation.js","webpack://iadviser/./node_modules/aurelia-webpack-plugin/runtime/pal-loader-entry.js"],"sourcesContent":["import { TargetInstruction, View } from 'aurelia-templating';\nimport { getLogger } from 'aurelia-logging';\nimport { DOM } from 'aurelia-pal';\n\nvar CompileSpy = (function () {\r\n    function CompileSpy(element, instruction) {\r\n        getLogger('compile-spy').info(element.toString(), instruction);\r\n    }\r\n    Object.defineProperty(CompileSpy, \"inject\", {\r\n        get: function () { return [DOM.Element, TargetInstruction]; },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    CompileSpy.$resource = {\r\n        type: 'attribute',\r\n        name: 'compile-spy'\r\n    };\r\n    return CompileSpy;\r\n}());\n\nvar ViewSpy = (function () {\r\n    function ViewSpy() {\r\n        this.logger = getLogger('view-spy');\r\n    }\r\n    ViewSpy.prototype._log = function (lifecycleName, context) {\r\n        if (!this.value && lifecycleName === 'created') {\r\n            this.logger.info(lifecycleName, this.view);\r\n        }\r\n        else if (this.value && this.value.indexOf(lifecycleName) !== -1) {\r\n            this.logger.info(lifecycleName, this.view, context);\r\n        }\r\n    };\r\n    ViewSpy.prototype.created = function (view) {\r\n        this.view = view;\r\n        this._log('created');\r\n    };\r\n    ViewSpy.prototype.bind = function (bindingContext) {\r\n        this._log('bind', bindingContext);\r\n    };\r\n    ViewSpy.prototype.attached = function () {\r\n        this._log('attached');\r\n    };\r\n    ViewSpy.prototype.detached = function () {\r\n        this._log('detached');\r\n    };\r\n    ViewSpy.prototype.unbind = function () {\r\n        this._log('unbind');\r\n    };\r\n    ViewSpy.$resource = {\r\n        type: 'attribute',\r\n        name: 'view-spy'\r\n    };\r\n    return ViewSpy;\r\n}());\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\n\nfunction waitFor(getter, options) {\r\n    if (options === void 0) { options = { present: true, interval: 50, timeout: 5000 }; }\r\n    var timedOut = false;\r\n    options = __assign({ present: true, interval: 50, timeout: 5000 }, options);\r\n    function wait() {\r\n        var element = getter();\r\n        var found = element !== null && (!(element instanceof NodeList) &&\r\n            !element.jquery || element.length > 0);\r\n        if (!options.present === !found || timedOut) {\r\n            return Promise.resolve(element);\r\n        }\r\n        return new Promise(function (rs) { return setTimeout(rs, options.interval); }).then(wait);\r\n    }\r\n    return Promise.race([\r\n        new Promise(function (_, rj) { return setTimeout(function () {\r\n            timedOut = true;\r\n            rj(new Error(options.present ? 'Element not found' : 'Element not removed'));\r\n        }, options.timeout); }),\r\n        wait()\r\n    ]);\r\n}\r\nfunction waitForDocumentElement(selector, options) {\r\n    return waitFor(function () { return document.querySelector(selector); }, options);\r\n}\r\nfunction waitForDocumentElements(selector, options) {\r\n    return waitFor(function () { return document.querySelectorAll(selector); }, options);\r\n}\n\nvar StageComponent = (function () {\r\n    function StageComponent() {\r\n    }\r\n    StageComponent.withResources = function (resources) {\r\n        if (resources === void 0) { resources = []; }\r\n        return new ComponentTester().withResources(resources);\r\n    };\r\n    return StageComponent;\r\n}());\r\nvar ComponentTester = (function () {\r\n    function ComponentTester() {\r\n        this.resources = [];\r\n    }\r\n    ComponentTester.prototype.configure = function (aurelia) {\r\n        return aurelia.use.standardConfiguration();\r\n    };\r\n    ComponentTester.prototype.bootstrap = function (configure) {\r\n        this.configure = configure;\r\n    };\r\n    ComponentTester.prototype.withResources = function (resources) {\r\n        this.resources = resources;\r\n        return this;\r\n    };\r\n    ComponentTester.prototype.inView = function (html) {\r\n        this.html = html;\r\n        return this;\r\n    };\r\n    ComponentTester.prototype.boundTo = function (bindingContext) {\r\n        this.bindingContext = bindingContext;\r\n        return this;\r\n    };\r\n    ComponentTester.prototype.manuallyHandleLifecycle = function () {\r\n        this._prepareLifecycle();\r\n        return this;\r\n    };\r\n    ComponentTester.prototype.create = function (bootstrap) {\r\n        var _this = this;\r\n        return bootstrap(function (aurelia) {\r\n            return Promise.resolve(_this.configure(aurelia)).then(function () {\r\n                if (_this.resources) {\r\n                    aurelia.use.globalResources(_this.resources);\r\n                }\r\n                return aurelia.start().then(function () {\r\n                    _this.host = document.createElement('div');\r\n                    _this.host.innerHTML = _this.html;\r\n                    document.body.appendChild(_this.host);\r\n                    return aurelia.enhance(_this.bindingContext, _this.host).then(function () {\r\n                        _this.rootView = aurelia.root;\r\n                        _this.element = _this.host.firstElementChild;\r\n                        if (aurelia.root.controllers.length) {\r\n                            _this.viewModel = aurelia.root.controllers[0].viewModel;\r\n                        }\r\n                        return new Promise(function (resolve) { return setTimeout(function () { return resolve(); }, 0); });\r\n                    });\r\n                });\r\n            });\r\n        });\r\n    };\r\n    ComponentTester.prototype.dispose = function () {\r\n        if (this.host === undefined || this.rootView === undefined) {\r\n            throw new Error('Cannot call ComponentTester.dispose() before ComponentTester.create()');\r\n        }\r\n        this.rootView.detached();\r\n        this.rootView.unbind();\r\n        return this.host.parentNode.removeChild(this.host);\r\n    };\r\n    ComponentTester.prototype._prepareLifecycle = function () {\r\n        var _this = this;\r\n        var bindPrototype = View.prototype.bind;\r\n        View.prototype.bind = function () { };\r\n        this.bind = function (bindingContext) { return new Promise(function (resolve) {\r\n            View.prototype.bind = bindPrototype;\r\n            if (bindingContext !== undefined) {\r\n                _this.bindingContext = bindingContext;\r\n            }\r\n            _this.rootView.bind(_this.bindingContext);\r\n            setTimeout(function () { return resolve(); }, 0);\r\n        }); };\r\n        var attachedPrototype = View.prototype.attached;\r\n        View.prototype.attached = function () { };\r\n        this.attached = function () { return new Promise(function (resolve) {\r\n            View.prototype.attached = attachedPrototype;\r\n            _this.rootView.attached();\r\n            setTimeout(function () { return resolve(); }, 0);\r\n        }); };\r\n        this.detached = function () { return new Promise(function (resolve) {\r\n            _this.rootView.detached();\r\n            setTimeout(function () { return resolve(); }, 0);\r\n        }); };\r\n        this.unbind = function () { return new Promise(function (resolve) {\r\n            _this.rootView.unbind();\r\n            setTimeout(function () { return resolve(); }, 0);\r\n        }); };\r\n    };\r\n    ComponentTester.prototype.waitForElement = function (selector, options) {\r\n        var _this = this;\r\n        return waitFor(function () { return _this.element.querySelector(selector); }, options);\r\n    };\r\n    ComponentTester.prototype.waitForElements = function (selector, options) {\r\n        var _this = this;\r\n        return waitFor(function () { return _this.element.querySelectorAll(selector); }, options);\r\n    };\r\n    return ComponentTester;\r\n}());\n\nfunction configure(config) {\r\n    config.globalResources([CompileSpy, ViewSpy]);\r\n}\n\nexport { CompileSpy, ComponentTester, StageComponent, ViewSpy, configure, waitFor, waitForDocumentElement, waitForDocumentElements };\n//# sourceMappingURL=aurelia-testing.js.map\n","import { getLogger } from 'aurelia-logging';\nimport { BehaviorPropertyObserver, BindableProperty, HtmlBehaviorResource } from 'aurelia-templating';\nimport { metadata } from 'aurelia-metadata';\n\nvar coerceFunctions = {\n    none: function (a) {\n        return a;\n    },\n    number: function (a) {\n        return Number(a);\n    },\n    string: function (a) {\n        return '' + a;\n    },\n    boolean: function (a) {\n        return !!a;\n    },\n    booleanAttr: function (val) {\n        return val || val === '' ? true : false;\n    },\n    date: function (val) {\n        // Invalid date instances are quite problematic\n        // so we need to deal with it properly by default\n        if (val === null || val === undefined) {\n            return null;\n        }\n        var d = new Date(val);\n        return isNaN(d.getTime()) ? null : d;\n    }\n};\nvar coerceFunctionMap = new Map([\n    [Boolean, 'boolean'],\n    [String, 'string'],\n    [Date, 'date'],\n    [Number, 'number'],\n]);\n/**\n * Map a class to a string for typescript property coerce\n * @param type the property class to register\n * @param strType the string that represents class in the lookup\n * @param coerceFunction coerce function to register with param strType\n */\nfunction mapCoerceFunction(type, strType, coerceFunction) {\n    coerceFunction = coerceFunction || type.coerce;\n    if (typeof strType !== 'string' || typeof coerceFunction !== 'function') {\n        getLogger('map-coerce-function')\n            .warn(\"Bad attempt at mapping coerce function for type: \" + type.name + \" to: \" + strType);\n        return;\n    }\n    coerceFunctions[strType] = coerceFunction;\n    coerceFunctionMap.set(type, strType);\n}\n\n// tslint:disable: interface-name no-invalid-this no-non-null-assertion\nBehaviorPropertyObserver.prototype.setCoerce = function (coerce) {\n    this.coerce = typeof coerce === 'function' ? coerce : coerceFunctions[coerce];\n    if (this.coerce === undefined) {\n        getLogger('behavior-property-observer')\n            .warn(\"Invalid coerce instruction. Should be either one of \" + Object.keys(coerceFunctions) + \" or a function.\");\n    }\n};\n/**\n * Slightly override the builtin implementation that will handle coercion\n */\nBehaviorPropertyObserver.prototype.setValue = function (newValue) {\n    var oldValue = this.currentValue;\n    var coercedValue = this.coerce === undefined ? newValue : this.coerce(newValue);\n    if (oldValue !== coercedValue) {\n        this.oldValue = oldValue;\n        this.currentValue = coercedValue;\n        if (this.publishing && this.notqueued) {\n            if (this.taskQueue.flushing) {\n                this.call();\n            }\n            else {\n                this.notqueued = false;\n                this.taskQueue.queueMicroTask(this);\n            }\n        }\n    }\n};\nBindableProperty.prototype.createObserver = function (viewModel) {\n    var selfSubscriber = null;\n    var defaultValue = this.defaultValue;\n    var changeHandlerName = this.changeHandler;\n    var name = this.name;\n    var initialValue;\n    if (this.hasOptions) {\n        return undefined;\n    }\n    if (changeHandlerName in viewModel) {\n        if ('propertyChanged' in viewModel) {\n            selfSubscriber = function (newValue, oldValue) {\n                viewModel[changeHandlerName](newValue, oldValue);\n                viewModel.propertyChanged(name, newValue, oldValue);\n            };\n        }\n        else {\n            selfSubscriber = function (newValue, oldValue) { return viewModel[changeHandlerName](newValue, oldValue); };\n        }\n    }\n    else if ('propertyChanged' in viewModel) {\n        selfSubscriber = function (newValue, oldValue) { return viewModel.propertyChanged(name, newValue, oldValue); };\n    }\n    else if (changeHandlerName !== null) {\n        throw new Error(\"Change handler \" + changeHandlerName + \" was specified but not declared on the class.\");\n    }\n    if (defaultValue !== undefined) {\n        initialValue = typeof defaultValue === 'function' ? defaultValue.call(viewModel) : defaultValue;\n    }\n    var observer = new BehaviorPropertyObserver(this.owner.taskQueue, viewModel, this.name, selfSubscriber, initialValue);\n    if (this.coerce !== undefined) {\n        observer.setCoerce(this.coerce);\n        observer.currentValue = observer.oldValue = observer.coerce === undefined ? observer.currentValue : observer.coerce(initialValue);\n    }\n    return observer;\n};\nBindableProperty.prototype._createDynamicProperty = function (viewModel, observerLookup, behaviorHandlesBind, name, attribute, boundProperties) {\n    var changeHandlerName = name + \"Changed\";\n    var selfSubscriber = null;\n    var observer;\n    var info;\n    if (changeHandlerName in viewModel) {\n        if ('propertyChanged' in viewModel) {\n            selfSubscriber = function (newValue, oldValue) {\n                viewModel[changeHandlerName](newValue, oldValue);\n                viewModel.propertyChanged(name, newValue, oldValue);\n            };\n        }\n        else {\n            selfSubscriber = function (newValue, oldValue) { return viewModel[changeHandlerName](newValue, oldValue); };\n        }\n    }\n    else if ('propertyChanged' in viewModel) {\n        selfSubscriber = function (newValue, oldValue) { return viewModel.propertyChanged(name, newValue, oldValue); };\n    }\n    observer = observerLookup[name] = new BehaviorPropertyObserver(this.owner.taskQueue, viewModel, name, selfSubscriber, undefined);\n    observer.setCoerce(this.coerce);\n    observer.currentValue = observer.oldValue = observer.coerce === undefined ? observer.currentValue : observer.coerce(undefined);\n    Object.defineProperty(viewModel, name, {\n        configurable: true,\n        enumerable: true,\n        get: observer.getValue.bind(observer),\n        set: observer.setValue.bind(observer)\n    });\n    if (behaviorHandlesBind) {\n        observer.selfSubscriber = null;\n    }\n    if (typeof attribute === 'string') {\n        viewModel[name] = attribute;\n        observer.call();\n    }\n    else if (attribute) {\n        info = { observer: observer, binding: attribute.createBinding(viewModel) };\n        boundProperties.push(info);\n    }\n    observer.publishing = true;\n    observer.selfSubscriber = selfSubscriber;\n};\n\nvar _usePropertyType = false;\n/**\n * Decorator: Specifies that a property is bindable through HTML.\n * @param nameOrTargetOrConfig The name of the property, or a configuration object.\n * This has Object in its type to avoid breaking change.\n * Idealy it should be `string | BindablePropertyConfig`\n */\n// tslint:disable-next-line:no-shadowed-variable\nvar bindable = function bindable(nameOrTargetOrConfig, key, descriptor) {\n    var deco = function (target, key2, descriptor2) {\n        /**\n         * key2 = truthy => decorated on a class field\n         * key2 = falsy => decorated on a class\n         */\n        var actualTarget = key2 ? target.constructor : target;\n        var r = metadata.getOrCreateOwn(metadata.resource, HtmlBehaviorResource, actualTarget);\n        var prop;\n        var propType;\n        if (key2) { //is it on a property or a class?\n            nameOrTargetOrConfig = nameOrTargetOrConfig || {};\n            nameOrTargetOrConfig.name = key2;\n            /**\n             * Support for Typescript decorator, with metadata on property type.\n             * Will check for typing only when user didn't explicitly set coerce + turn on the options\n             *\n             * If key 2 is truthy, it's a decorator on class field, which means target is prototype\n             */\n            if (nameOrTargetOrConfig.coerce === undefined && _usePropertyType) {\n                propType = metadata.getOwn(metadata.propertyType, target, key2);\n                if (propType) {\n                    var coerceType = coerceFunctionMap.get(propType);\n                    if (coerceType === undefined) {\n                        getLogger('@bindable decorator')\n                            .warn(\"Invalid coerce instruction. Should be either one of \" + Object.keys(coerceFunctions) + \" or a function.\");\n                    }\n                    nameOrTargetOrConfig.coerce = coerceType || 'none';\n                }\n            }\n        }\n        prop = new BindableProperty(nameOrTargetOrConfig);\n        return prop.registerWith(actualTarget, r, descriptor2);\n    };\n    if (!nameOrTargetOrConfig) {\n        /**\n         * placed on property initializer with parens, without any params\n         * @example:\n         * class ViewModel {\n         *   @bindable() property\n         * }\n         * @bindable() class ViewModel {}\n         */\n        return deco;\n    }\n    if (key) {\n        /**\n         * placed on a property initializer without parens\n         * @example\n         * class ViewModel {\n         *   @bindable property\n         * }\n         *\n         */\n        var target = nameOrTargetOrConfig;\n        nameOrTargetOrConfig = undefined;\n        return deco(target, key, descriptor);\n    }\n    /**\n     * placed on a class with parens and config\n     * @example\n     * @bindable({ ... })\n     * class MyViewModel {}\n     */\n    return deco;\n};\n['string', 'number', 'boolean', 'booleanAttr', 'date'].forEach(createTypedBindable);\n/**\n * Used to allow user to automatically pickup property type\n * Can be used with typescript emit metadata in compiler settings, or with `Reflect.metadata('design:type', PropertyTypeClass)` decorator\n */\nfunction usePropertyType(shouldUsePropertyType) {\n    _usePropertyType = shouldUsePropertyType;\n}\n/**\n * Create a new fluent syntax bindable decorator  ex: builtin: `@bindable.string`, custom: `@bindable.customType`\n * Need to use together with setting the type in `coerceFunctions`:\n *\n * ```js\n * import {\n *  createTypedBindable,\n *  coerceFunctions\n * } from 'aurelia-framework'\n *\n * // create the typed bindable\n * createTypedBindable('point'); // => enable `@bindable.point`\n * // Set the instruction\n * coerceFunctions.point = function(value: string) {\n *   // convert to point from value\n * }\n * ```\n *\n * @param type The type to added to bindable for fluent syntax.\n */\nfunction createTypedBindable(type) {\n    /**\n     * There no attempts to protect user from mis-using the decorators.\n     * ex. @observable({}, accidentParam) class SomeClass {}\n     * If we have some flag to use in if block, which can be remove at build time, it would be great.\n     */\n    return bindable[type] = function (nameOrTargetOrConfig, key, descriptor) {\n        if (nameOrTargetOrConfig === undefined) {\n            /**\n             * MyClass {\n             *   @bindable.number() num\n             * }\n             */\n            return bindable({ coerce: type });\n        }\n        if (key === undefined) {\n            /**\n             * @bindable.number('num')\n             * class MyClass {}\n             *\n             * @bindable.number({...})\n             * class MyClass\n             *\n             * class MyClass {\n             *   @bindable.number({...})\n             *   num\n             * }\n             */\n            nameOrTargetOrConfig = typeof nameOrTargetOrConfig === 'string' ? { name: nameOrTargetOrConfig } : nameOrTargetOrConfig;\n            nameOrTargetOrConfig.coerce = type;\n            return bindable(nameOrTargetOrConfig);\n        }\n        /**\n         * class MyClass {\n         *   @bindable.number num\n         * }\n         */\n        return bindable({ coerce: type })(nameOrTargetOrConfig, key, descriptor);\n    };\n}\n\nvar observableLogger = getLogger('aurelia-observable-decorator');\n/**\n * Internal flag to turn on / off auto pickup property type from metadata\n */\nvar _usePropertyType$1 = false;\nvar observable = function observable(nameOrTargetOrConfig, key, descriptor) {\n    /**\n     * @param target The class decorated\n     * @param key The target class field of the decorator\n     * @param descriptor class field descriptor\n     * @param config user's config\n     */\n    function deco(target, key, descriptor, config) {\n        // Used to check if we should pickup the type from metadata\n        var coerce = config === undefined || typeof config === 'string' ? undefined : config.coerce;\n        var propType;\n        var coerceFunction;\n        if (coerce) {\n            switch (typeof coerce) {\n                case 'string':\n                    coerceFunction = coerceFunctions[coerce];\n                    break;\n                case 'function':\n                    coerceFunction = coerce;\n                    break;\n                default: break;\n            }\n            if (coerceFunction === undefined) {\n                observableLogger.warn(\"Invalid coerce instruction. Should be either one of \" + Object.keys(coerceFunctions) + \" or a function.\");\n            }\n        }\n        else if (_usePropertyType$1) {\n            propType = metadata.getOwn(metadata.propertyType, target, key);\n            if (propType) {\n                coerceFunction = coerceFunctions[coerceFunctionMap.get(propType)];\n                if (coerceFunction === undefined) {\n                    observableLogger.warn(\"Unable to find coerce function for type \" + propType.name + \".\");\n                }\n            }\n        }\n        /**\n         * class decorator?\n         * @example\n         * @observable('firstName') MyClass {}\n         * @observable({ name: 'firstName' }) MyClass {}\n         */\n        var isClassDecorator = key === undefined;\n        if (isClassDecorator) {\n            target = target.prototype;\n            key = typeof config === 'string' ? config : config.name;\n        }\n        // use a convention to compute the inner property name\n        var innerPropertyName = \"_\" + key;\n        var innerPropertyDescriptor = {\n            configurable: true,\n            enumerable: false,\n            writable: true\n        };\n        if (config && 'defaultValue' in config) {\n            var initValue = config.defaultValue;\n            innerPropertyDescriptor.value = coerceFunction === undefined ? initValue : coerceFunction(initValue);\n        }\n        // determine callback name based on config or convention.\n        var callbackName = (config && config.changeHandler) || key + \"Changed\";\n        if (descriptor) {\n            // babel passes in the property descriptor with a method to get the initial value.\n            // set the initial value of the property if it is defined.\n            // also make sure it's coerced\n            if (typeof descriptor.initializer === 'function') {\n                var initValue = descriptor.initializer();\n                innerPropertyDescriptor.value = coerceFunction === undefined ? initValue : coerceFunction(initValue);\n            }\n        }\n        else {\n            // there is no descriptor if the target was a field in TS (although Babel provides one),\n            // or if the decorator was applied to a class.\n            descriptor = {};\n        }\n        // make the accessor enumerable by default, as fields are enumerable\n        if (!('enumerable' in descriptor)) {\n            descriptor.enumerable = true;\n        }\n        // we're adding a getter and setter which means the property descriptor\n        // cannot have a \"value\" or \"writable\" attribute\n        delete descriptor.value;\n        delete descriptor.writable;\n        delete descriptor.initializer;\n        // Add the inner property on the prototype.\n        Reflect.defineProperty(target, innerPropertyName, innerPropertyDescriptor);\n        // add the getter and setter to the property descriptor.\n        descriptor.get = function () { return this[innerPropertyName]; };\n        descriptor.set = function (newValue) {\n            var oldValue = this[innerPropertyName];\n            var coercedValue = coerceFunction === undefined ? newValue : coerceFunction(newValue);\n            if (coercedValue === oldValue) {\n                return;\n            }\n            // Add the inner property on the instance and make it nonenumerable.\n            this[innerPropertyName] = coercedValue;\n            Reflect.defineProperty(this, innerPropertyName, { enumerable: false });\n            if (this[callbackName]) {\n                this[callbackName](coercedValue, oldValue, key);\n            }\n        };\n        // make sure Aurelia doesn't use dirty-checking by declaring the property's\n        // dependencies. This is the equivalent of \"@computedFrom(...)\".\n        descriptor.get.dependencies = [innerPropertyName];\n        if (isClassDecorator) {\n            Reflect.defineProperty(target, key, descriptor);\n        }\n        else {\n            return descriptor;\n        }\n    }\n    /**\n     * Decorating with parens\n     * @example\n     * @observable MyClass {} <----- this breaks, but will go into this condition\n     * @observable('firstName') MyClass {}\n     * @observable({ name: 'firstName' }) MyClass {}\n     * class MyClass {\n     *   @observable() prop\n     * }\n     */\n    if (key === undefined) {\n        return function (t, k, d) { return deco(t, k, d, nameOrTargetOrConfig); };\n    }\n    /**\n     * Decorating on class field\n     * @example\n     * class MyClass {\n     *   @observable prop\n     * }\n     */\n    return deco(nameOrTargetOrConfig, key, descriptor);\n};\n['string', 'number', 'boolean', 'date'].forEach(createTypedObservable);\n/*\n          | typescript       | babel\n----------|------------------|-------------------------\nproperty  | config           | config\nw/parens  | target, key      | target, key, descriptor\n----------|------------------|-------------------------\nproperty  | target, key      | target, key, descriptor\nno parens | n/a              | n/a\n----------|------------------|-------------------------\nclass     | config           | config\n          | target           | target\n*/\n/**\n * Toggle the flag for observable to auto pickup property type from metadata\n * The reason is sometimes we may want to use prop type on bindable, but not observable\n * and vice versa\n */\nfunction usePropertyType$1(shouldUsePropType) {\n    _usePropertyType$1 = !!shouldUsePropType;\n}\n/**\n * Decorator: Creates a new observable decorator that can be used for fluent syntax purpose\n * @param type the type name that will be assign to observable decorator. `createTypedObservable('point') -> observable.point`\n */\nfunction createTypedObservable(type) {\n    return observable[type] = function (nameOrTargetOrConfig, key, descriptor) {\n        if (nameOrTargetOrConfig === undefined) {\n            /**\n             * MyClass {\n             *   @observable.number() num\n             * }\n             *\n             * This will breaks so need to check for proper error\n             * @observable.number()\n             * class MyClass {}\n             */\n            return observable({ coerce: type });\n        }\n        if (key === undefined) {\n            /**\n             * @observable.number('num')\n             * class MyClass {}\n             *\n             * @observable.number({...})\n             * class MyClass\n             *\n             * class MyClass {\n             *   @observable.number({...})\n             *   num\n             * }\n             */\n            nameOrTargetOrConfig = typeof nameOrTargetOrConfig === 'string' ? { name: nameOrTargetOrConfig } : nameOrTargetOrConfig;\n            nameOrTargetOrConfig.coerce = type;\n            return observable(nameOrTargetOrConfig);\n        }\n        /**\n         * class MyClass {\n         *   @observable.number num\n         * }\n         */\n        return observable({ coerce: type })(nameOrTargetOrConfig, key, descriptor);\n    };\n}\n\nexport { bindable, usePropertyType as usePropertyTypeForBindable, createTypedBindable, observable, usePropertyType$1 as usePropertyTypeForObservable, createTypedObservable, coerceFunctions, coerceFunctionMap, mapCoerceFunction };\n","import { LiteralString, Binary, Conditional, LiteralPrimitive, CallMember, AccessMember, AccessScope, AccessKeyed, BindingBehavior, ValueConverter, getContextFor, Parser, bindingBehavior, bindingMode } from 'aurelia-binding';\nimport { BindingLanguage, ViewResources, customAttribute, bindable } from 'aurelia-templating';\nimport { getLogger } from 'aurelia-logging';\nimport { DOM } from 'aurelia-pal';\nimport { Optional, Lazy } from 'aurelia-dependency-injection';\nimport { TaskQueue } from 'aurelia-task-queue';\n\n/**\r\n * Validates objects and properties.\r\n */\r\nvar Validator = /** @class */ (function () {\r\n    function Validator() {\r\n    }\r\n    return Validator;\r\n}());\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nfunction __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nfunction __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nfunction __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\n\n/**\r\n * The result of validating an individual validation rule.\r\n */\r\nvar ValidateResult = /** @class */ (function () {\r\n    /**\r\n     * @param rule The rule associated with the result. Validator implementation specific.\r\n     * @param object The object that was validated.\r\n     * @param propertyName The name of the property that was validated.\r\n     * @param error The error, if the result is a validation error.\r\n     */\r\n    function ValidateResult(rule, object, propertyName, valid, message) {\r\n        if (message === void 0) { message = null; }\r\n        this.rule = rule;\r\n        this.object = object;\r\n        this.propertyName = propertyName;\r\n        this.valid = valid;\r\n        this.message = message;\r\n        this.id = ValidateResult.nextId++;\r\n    }\r\n    ValidateResult.prototype.toString = function () {\r\n        return this.valid ? 'Valid.' : this.message;\r\n    };\r\n    ValidateResult.nextId = 0;\r\n    return ValidateResult;\r\n}());\n\n/**\r\n * Sets, unsets and retrieves rules on an object or constructor function.\r\n */\r\nvar Rules = /** @class */ (function () {\r\n    function Rules() {\r\n    }\r\n    /**\r\n     * Applies the rules to a target.\r\n     */\r\n    Rules.set = function (target, rules) {\r\n        if (target instanceof Function) {\r\n            target = target.prototype;\r\n        }\r\n        Object.defineProperty(target, Rules.key, { enumerable: false, configurable: false, writable: true, value: rules });\r\n    };\r\n    /**\r\n     * Removes rules from a target.\r\n     */\r\n    Rules.unset = function (target) {\r\n        if (target instanceof Function) {\r\n            target = target.prototype;\r\n        }\r\n        target[Rules.key] = null;\r\n    };\r\n    /**\r\n     * Retrieves the target's rules.\r\n     */\r\n    Rules.get = function (target) {\r\n        return target[Rules.key] || null;\r\n    };\r\n    /**\r\n     * The name of the property that stores the rules.\r\n     */\r\n    Rules.key = '__rules__';\r\n    return Rules;\r\n}());\n\n// tslint:disable:no-empty\r\nvar ExpressionVisitor = /** @class */ (function () {\r\n    function ExpressionVisitor() {\r\n    }\r\n    ExpressionVisitor.prototype.visitChain = function (chain) {\r\n        this.visitArgs(chain.expressions);\r\n    };\r\n    ExpressionVisitor.prototype.visitBindingBehavior = function (behavior) {\r\n        behavior.expression.accept(this);\r\n        this.visitArgs(behavior.args);\r\n    };\r\n    ExpressionVisitor.prototype.visitValueConverter = function (converter) {\r\n        converter.expression.accept(this);\r\n        this.visitArgs(converter.args);\r\n    };\r\n    ExpressionVisitor.prototype.visitAssign = function (assign) {\r\n        assign.target.accept(this);\r\n        assign.value.accept(this);\r\n    };\r\n    ExpressionVisitor.prototype.visitConditional = function (conditional) {\r\n        conditional.condition.accept(this);\r\n        conditional.yes.accept(this);\r\n        conditional.no.accept(this);\r\n    };\r\n    ExpressionVisitor.prototype.visitAccessThis = function (access) {\r\n        access.ancestor = access.ancestor;\r\n    };\r\n    ExpressionVisitor.prototype.visitAccessScope = function (access) {\r\n        access.name = access.name;\r\n    };\r\n    ExpressionVisitor.prototype.visitAccessMember = function (access) {\r\n        access.object.accept(this);\r\n    };\r\n    ExpressionVisitor.prototype.visitAccessKeyed = function (access) {\r\n        access.object.accept(this);\r\n        access.key.accept(this);\r\n    };\r\n    ExpressionVisitor.prototype.visitCallScope = function (call) {\r\n        this.visitArgs(call.args);\r\n    };\r\n    ExpressionVisitor.prototype.visitCallFunction = function (call) {\r\n        call.func.accept(this);\r\n        this.visitArgs(call.args);\r\n    };\r\n    ExpressionVisitor.prototype.visitCallMember = function (call) {\r\n        call.object.accept(this);\r\n        this.visitArgs(call.args);\r\n    };\r\n    ExpressionVisitor.prototype.visitPrefix = function (prefix) {\r\n        prefix.expression.accept(this);\r\n    };\r\n    ExpressionVisitor.prototype.visitBinary = function (binary) {\r\n        binary.left.accept(this);\r\n        binary.right.accept(this);\r\n    };\r\n    ExpressionVisitor.prototype.visitLiteralPrimitive = function (literal) {\r\n        literal.value = literal.value;\r\n    };\r\n    ExpressionVisitor.prototype.visitLiteralArray = function (literal) {\r\n        this.visitArgs(literal.elements);\r\n    };\r\n    ExpressionVisitor.prototype.visitLiteralObject = function (literal) {\r\n        this.visitArgs(literal.values);\r\n    };\r\n    ExpressionVisitor.prototype.visitLiteralString = function (literal) {\r\n        literal.value = literal.value;\r\n    };\r\n    ExpressionVisitor.prototype.visitArgs = function (args) {\r\n        for (var i = 0; i < args.length; i++) {\r\n            args[i].accept(this);\r\n        }\r\n    };\r\n    return ExpressionVisitor;\r\n}());\n\nvar ValidationMessageParser = /** @class */ (function () {\r\n    function ValidationMessageParser(bindinqLanguage) {\r\n        this.bindinqLanguage = bindinqLanguage;\r\n        this.emptyStringExpression = new LiteralString('');\r\n        this.nullExpression = new LiteralPrimitive(null);\r\n        this.undefinedExpression = new LiteralPrimitive(undefined);\r\n        this.cache = {};\r\n    }\r\n    ValidationMessageParser.prototype.parse = function (message) {\r\n        if (this.cache[message] !== undefined) {\r\n            return this.cache[message];\r\n        }\r\n        var parts = this.bindinqLanguage.parseInterpolation(null, message);\r\n        if (parts === null) {\r\n            return new LiteralString(message);\r\n        }\r\n        var expression = new LiteralString(parts[0]);\r\n        for (var i = 1; i < parts.length; i += 2) {\r\n            expression = new Binary('+', expression, new Binary('+', this.coalesce(parts[i]), new LiteralString(parts[i + 1])));\r\n        }\r\n        MessageExpressionValidator.validate(expression, message);\r\n        this.cache[message] = expression;\r\n        return expression;\r\n    };\r\n    ValidationMessageParser.prototype.coalesce = function (part) {\r\n        // part === null || part === undefined ? '' : part\r\n        return new Conditional(new Binary('||', new Binary('===', part, this.nullExpression), new Binary('===', part, this.undefinedExpression)), this.emptyStringExpression, new CallMember(part, 'toString', []));\r\n    };\r\n    ValidationMessageParser.inject = [BindingLanguage];\r\n    return ValidationMessageParser;\r\n}());\r\nvar MessageExpressionValidator = /** @class */ (function (_super) {\r\n    __extends(MessageExpressionValidator, _super);\r\n    function MessageExpressionValidator(originalMessage) {\r\n        var _this = _super.call(this) || this;\r\n        _this.originalMessage = originalMessage;\r\n        return _this;\r\n    }\r\n    MessageExpressionValidator.validate = function (expression, originalMessage) {\r\n        var visitor = new MessageExpressionValidator(originalMessage);\r\n        expression.accept(visitor);\r\n    };\r\n    MessageExpressionValidator.prototype.visitAccessScope = function (access) {\r\n        if (access.ancestor !== 0) {\r\n            throw new Error('$parent is not permitted in validation message expressions.');\r\n        }\r\n        if (['displayName', 'propertyName', 'value', 'object', 'config', 'getDisplayName'].indexOf(access.name) !== -1) {\r\n            getLogger('aurelia-validation')\r\n                // tslint:disable-next-line:max-line-length\r\n                .warn(\"Did you mean to use \\\"$\" + access.name + \"\\\" instead of \\\"\" + access.name + \"\\\" in this validation message template: \\\"\" + this.originalMessage + \"\\\"?\");\r\n        }\r\n    };\r\n    return MessageExpressionValidator;\r\n}(ExpressionVisitor));\n\n/**\r\n * Dictionary of validation messages. [messageKey]: messageExpression\r\n */\r\nvar validationMessages = {\r\n    /**\r\n     * The default validation message. Used with rules that have no standard message.\r\n     */\r\n    default: \"${$displayName} is invalid.\",\r\n    required: \"${$displayName} is required.\",\r\n    matches: \"${$displayName} is not correctly formatted.\",\r\n    email: \"${$displayName} is not a valid email.\",\r\n    minLength: \"${$displayName} must be at least ${$config.length} character${$config.length === 1 ? '' : 's'}.\",\r\n    maxLength: \"${$displayName} cannot be longer than ${$config.length} character${$config.length === 1 ? '' : 's'}.\",\r\n    minItems: \"${$displayName} must contain at least ${$config.count} item${$config.count === 1 ? '' : 's'}.\",\r\n    maxItems: \"${$displayName} cannot contain more than ${$config.count} item${$config.count === 1 ? '' : 's'}.\",\r\n    min: \"${$displayName} must be at least ${$config.constraint}.\",\r\n    max: \"${$displayName} must be at most ${$config.constraint}.\",\r\n    range: \"${$displayName} must be between or equal to ${$config.min} and ${$config.max}.\",\r\n    between: \"${$displayName} must be between but not equal to ${$config.min} and ${$config.max}.\",\r\n    equals: \"${$displayName} must be ${$config.expectedValue}.\",\r\n};\r\n/**\r\n * Retrieves validation messages and property display names.\r\n */\r\nvar ValidationMessageProvider = /** @class */ (function () {\r\n    function ValidationMessageProvider(parser) {\r\n        this.parser = parser;\r\n    }\r\n    /**\r\n     * Returns a message binding expression that corresponds to the key.\r\n     * @param key The message key.\r\n     */\r\n    ValidationMessageProvider.prototype.getMessage = function (key) {\r\n        var message;\r\n        if (key in validationMessages) {\r\n            message = validationMessages[key];\r\n        }\r\n        else {\r\n            message = validationMessages['default'];\r\n        }\r\n        return this.parser.parse(message);\r\n    };\r\n    /**\r\n     * Formulates a property display name using the property name and the configured\r\n     * displayName (if provided).\r\n     * Override this with your own custom logic.\r\n     * @param propertyName The property name.\r\n     */\r\n    ValidationMessageProvider.prototype.getDisplayName = function (propertyName, displayName) {\r\n        if (displayName !== null && displayName !== undefined) {\r\n            return (displayName instanceof Function) ? displayName() : displayName;\r\n        }\r\n        // split on upper-case letters.\r\n        var words = propertyName.toString().split(/(?=[A-Z])/).join(' ');\r\n        // capitalize first letter.\r\n        return words.charAt(0).toUpperCase() + words.slice(1);\r\n    };\r\n    ValidationMessageProvider.inject = [ValidationMessageParser];\r\n    return ValidationMessageProvider;\r\n}());\n\n/**\r\n * Validates.\r\n * Responsible for validating objects and properties.\r\n */\r\nvar StandardValidator = /** @class */ (function (_super) {\r\n    __extends(StandardValidator, _super);\r\n    function StandardValidator(messageProvider, resources) {\r\n        var _this = _super.call(this) || this;\r\n        _this.messageProvider = messageProvider;\r\n        _this.lookupFunctions = resources.lookupFunctions;\r\n        _this.getDisplayName = messageProvider.getDisplayName.bind(messageProvider);\r\n        return _this;\r\n    }\r\n    /**\r\n     * Validates the specified property.\r\n     * @param object The object to validate.\r\n     * @param propertyName The name of the property to validate.\r\n     * @param rules Optional. If unspecified, the rules will be looked up using the metadata\r\n     * for the object created by ValidationRules....on(class/object)\r\n     */\r\n    StandardValidator.prototype.validateProperty = function (object, propertyName, rules) {\r\n        return this.validate(object, propertyName, rules || null);\r\n    };\r\n    /**\r\n     * Validates all rules for specified object and it's properties.\r\n     * @param object The object to validate.\r\n     * @param rules Optional. If unspecified, the rules will be looked up using the metadata\r\n     * for the object created by ValidationRules....on(class/object)\r\n     */\r\n    StandardValidator.prototype.validateObject = function (object, rules) {\r\n        return this.validate(object, null, rules || null);\r\n    };\r\n    /**\r\n     * Determines whether a rule exists in a set of rules.\r\n     * @param rules The rules to search.\r\n     * @parem rule The rule to find.\r\n     */\r\n    StandardValidator.prototype.ruleExists = function (rules, rule) {\r\n        var i = rules.length;\r\n        while (i--) {\r\n            if (rules[i].indexOf(rule) !== -1) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    };\r\n    StandardValidator.prototype.getMessage = function (rule, object, value) {\r\n        var expression = rule.message || this.messageProvider.getMessage(rule.messageKey);\r\n        // tslint:disable-next-line:prefer-const\r\n        var _a = rule.property, propertyName = _a.name, displayName = _a.displayName;\r\n        if (propertyName !== null) {\r\n            displayName = this.messageProvider.getDisplayName(propertyName, displayName);\r\n        }\r\n        var overrideContext = {\r\n            $displayName: displayName,\r\n            $propertyName: propertyName,\r\n            $value: value,\r\n            $object: object,\r\n            $config: rule.config,\r\n            // returns the name of a given property, given just the property name (irrespective of the property's displayName)\r\n            // split on capital letters, first letter ensured to be capitalized\r\n            $getDisplayName: this.getDisplayName\r\n        };\r\n        return expression.evaluate({ bindingContext: object, overrideContext: overrideContext }, this.lookupFunctions);\r\n    };\r\n    StandardValidator.prototype.validateRuleSequence = function (object, propertyName, ruleSequence, sequence, results) {\r\n        var _this = this;\r\n        // are we validating all properties or a single property?\r\n        var validateAllProperties = propertyName === null || propertyName === undefined;\r\n        var rules = ruleSequence[sequence];\r\n        var allValid = true;\r\n        // validate each rule.\r\n        var promises = [];\r\n        var _loop_1 = function (i) {\r\n            var rule = rules[i];\r\n            // is the rule related to the property we're validating.\r\n            // tslint:disable-next-line:triple-equals | Use loose equality for property keys\r\n            if (!validateAllProperties && rule.property.name != propertyName) {\r\n                return \"continue\";\r\n            }\r\n            // is this a conditional rule? is the condition met?\r\n            if (rule.when && !rule.when(object)) {\r\n                return \"continue\";\r\n            }\r\n            // validate.\r\n            var value = rule.property.name === null ? object : object[rule.property.name];\r\n            var promiseOrBoolean = rule.condition(value, object);\r\n            if (!(promiseOrBoolean instanceof Promise)) {\r\n                promiseOrBoolean = Promise.resolve(promiseOrBoolean);\r\n            }\r\n            promises.push(promiseOrBoolean.then(function (valid) {\r\n                var message = valid ? null : _this.getMessage(rule, object, value);\r\n                results.push(new ValidateResult(rule, object, rule.property.name, valid, message));\r\n                allValid = allValid && valid;\r\n                return valid;\r\n            }));\r\n        };\r\n        for (var i = 0; i < rules.length; i++) {\r\n            _loop_1(i);\r\n        }\r\n        return Promise.all(promises)\r\n            .then(function () {\r\n            sequence++;\r\n            if (allValid && sequence < ruleSequence.length) {\r\n                return _this.validateRuleSequence(object, propertyName, ruleSequence, sequence, results);\r\n            }\r\n            return results;\r\n        });\r\n    };\r\n    StandardValidator.prototype.validate = function (object, propertyName, rules) {\r\n        // rules specified?\r\n        if (!rules) {\r\n            // no. attempt to locate the rules.\r\n            rules = Rules.get(object);\r\n        }\r\n        // any rules?\r\n        if (!rules || rules.length === 0) {\r\n            return Promise.resolve([]);\r\n        }\r\n        return this.validateRuleSequence(object, propertyName, rules, 0, []);\r\n    };\r\n    StandardValidator.inject = [ValidationMessageProvider, ViewResources];\r\n    return StandardValidator;\r\n}(Validator));\n\n/**\r\n * Validation triggers.\r\n */\r\nvar validateTrigger;\r\n(function (validateTrigger) {\r\n    /**\r\n     * Manual validation.  Use the controller's `validate()` and  `reset()` methods\r\n     * to validate all bindings.\r\n     */\r\n    validateTrigger[validateTrigger[\"manual\"] = 0] = \"manual\";\r\n    /**\r\n     * Validate the binding when the binding's target element fires a DOM \"blur\" event.\r\n     */\r\n    validateTrigger[validateTrigger[\"blur\"] = 1] = \"blur\";\r\n    /**\r\n     * Validate the binding when it updates the model due to a change in the view.\r\n     */\r\n    validateTrigger[validateTrigger[\"change\"] = 2] = \"change\";\r\n    /**\r\n     * Validate the binding when the binding's target element fires a DOM \"blur\" event and\r\n     * when it updates the model due to a change in the view.\r\n     */\r\n    validateTrigger[validateTrigger[\"changeOrBlur\"] = 3] = \"changeOrBlur\";\r\n})(validateTrigger || (validateTrigger = {}));\n\n/**\r\n * Aurelia Validation Configuration API\r\n */\r\nvar GlobalValidationConfiguration = /** @class */ (function () {\r\n    function GlobalValidationConfiguration() {\r\n        this.validatorType = StandardValidator;\r\n        this.validationTrigger = GlobalValidationConfiguration.DEFAULT_VALIDATION_TRIGGER;\r\n    }\r\n    /**\r\n     * Use a custom Validator implementation.\r\n     */\r\n    GlobalValidationConfiguration.prototype.customValidator = function (type) {\r\n        this.validatorType = type;\r\n        return this;\r\n    };\r\n    GlobalValidationConfiguration.prototype.defaultValidationTrigger = function (trigger) {\r\n        this.validationTrigger = trigger;\r\n        return this;\r\n    };\r\n    GlobalValidationConfiguration.prototype.getDefaultValidationTrigger = function () {\r\n        return this.validationTrigger;\r\n    };\r\n    /**\r\n     * Applies the configuration.\r\n     */\r\n    GlobalValidationConfiguration.prototype.apply = function (container) {\r\n        var validator = container.get(this.validatorType);\r\n        container.registerInstance(Validator, validator);\r\n        container.registerInstance(GlobalValidationConfiguration, this);\r\n    };\r\n    GlobalValidationConfiguration.DEFAULT_VALIDATION_TRIGGER = validateTrigger.blur;\r\n    return GlobalValidationConfiguration;\r\n}());\n\n/**\r\n * Gets the DOM element associated with the data-binding. Most of the time it's\r\n * the binding.target but sometimes binding.target is an aurelia custom element,\r\n * or custom attribute which is a javascript \"class\" instance, so we need to use\r\n * the controller's container to retrieve the actual DOM element.\r\n */\r\nfunction getTargetDOMElement(binding, view) {\r\n    var target = binding.target;\r\n    // DOM element\r\n    if (target instanceof Element) {\r\n        return target;\r\n    }\r\n    // custom element or custom attribute\r\n    // tslint:disable-next-line:prefer-const\r\n    for (var i = 0, ii = view.controllers.length; i < ii; i++) {\r\n        var controller = view.controllers[i];\r\n        if (controller.viewModel === target) {\r\n            var element = controller.container.get(DOM.Element);\r\n            if (element) {\r\n                return element;\r\n            }\r\n            throw new Error(\"Unable to locate target element for \\\"\" + binding.sourceExpression + \"\\\".\");\r\n        }\r\n    }\r\n    throw new Error(\"Unable to locate target element for \\\"\" + binding.sourceExpression + \"\\\".\");\r\n}\n\nfunction getObject(expression, objectExpression, source) {\r\n    var value = objectExpression.evaluate(source, null);\r\n    if (value === null || value === undefined || value instanceof Object) {\r\n        return value;\r\n    }\r\n    // tslint:disable-next-line:max-line-length\r\n    throw new Error(\"The '\" + objectExpression + \"' part of '\" + expression + \"' evaluates to \" + value + \" instead of an object, null or undefined.\");\r\n}\r\n/**\r\n * Retrieves the object and property name for the specified expression.\r\n * @param expression The expression\r\n * @param source The scope\r\n */\r\nfunction getPropertyInfo(expression, source) {\r\n    var originalExpression = expression;\r\n    while (expression instanceof BindingBehavior || expression instanceof ValueConverter) {\r\n        expression = expression.expression;\r\n    }\r\n    var object;\r\n    var propertyName;\r\n    if (expression instanceof AccessScope) {\r\n        object = getContextFor(expression.name, source, expression.ancestor);\r\n        propertyName = expression.name;\r\n    }\r\n    else if (expression instanceof AccessMember) {\r\n        object = getObject(originalExpression, expression.object, source);\r\n        propertyName = expression.name;\r\n    }\r\n    else if (expression instanceof AccessKeyed) {\r\n        object = getObject(originalExpression, expression.object, source);\r\n        propertyName = expression.key.evaluate(source);\r\n    }\r\n    else {\r\n        throw new Error(\"Expression '\" + originalExpression + \"' is not compatible with the validate binding-behavior.\");\r\n    }\r\n    if (object === null || object === undefined) {\r\n        return null;\r\n    }\r\n    return { object: object, propertyName: propertyName };\r\n}\n\nfunction isString(value) {\r\n    return Object.prototype.toString.call(value) === '[object String]';\r\n}\r\nfunction isNumber(value) {\r\n    return Object.prototype.toString.call(value) === '[object Number]';\r\n}\n\nvar PropertyAccessorParser = /** @class */ (function () {\r\n    function PropertyAccessorParser(parser) {\r\n        this.parser = parser;\r\n    }\r\n    PropertyAccessorParser.prototype.parse = function (property) {\r\n        if (isString(property) || isNumber(property)) {\r\n            return property;\r\n        }\r\n        var accessorText = getAccessorExpression(property.toString());\r\n        var accessor = this.parser.parse(accessorText);\r\n        if (accessor instanceof AccessScope\r\n            || accessor instanceof AccessMember && accessor.object instanceof AccessScope) {\r\n            return accessor.name;\r\n        }\r\n        throw new Error(\"Invalid property expression: \\\"\" + accessor + \"\\\"\");\r\n    };\r\n    PropertyAccessorParser.inject = [Parser];\r\n    return PropertyAccessorParser;\r\n}());\r\nfunction getAccessorExpression(fn) {\r\n    /* tslint:disable:max-line-length */\r\n    var classic = /^function\\s*\\([$_\\w\\d]+\\)\\s*\\{(?:\\s*\"use strict\";)?\\s*(?:[$_\\w\\d.['\"\\]+;]+)?\\s*return\\s+[$_\\w\\d]+\\.([$_\\w\\d]+)\\s*;?\\s*\\}$/;\r\n    /* tslint:enable:max-line-length */\r\n    var arrow = /^\\(?[$_\\w\\d]+\\)?\\s*=>\\s*[$_\\w\\d]+\\.([$_\\w\\d]+)$/;\r\n    var match = classic.exec(fn) || arrow.exec(fn);\r\n    if (match === null) {\r\n        throw new Error(\"Unable to parse accessor function:\\n\" + fn);\r\n    }\r\n    return match[1];\r\n}\n\nvar ValidateEvent = /** @class */ (function () {\r\n    function ValidateEvent(\r\n    /**\r\n     * The type of validate event. Either \"validate\" or \"reset\".\r\n     */\r\n    type, \r\n    /**\r\n     * The controller's current array of errors. For an array containing both\r\n     * failed rules and passed rules, use the \"results\" property.\r\n     */\r\n    errors, \r\n    /**\r\n     * The controller's current array of validate results. This\r\n     * includes both passed rules and failed rules. For an array of only failed rules,\r\n     * use the \"errors\" property.\r\n     */\r\n    results, \r\n    /**\r\n     * The instruction passed to the \"validate\" or \"reset\" event. Will be null when\r\n     * the controller's validate/reset method was called with no instruction argument.\r\n     */\r\n    instruction, \r\n    /**\r\n     * In events with type === \"validate\", this property will contain the result\r\n     * of validating the instruction (see \"instruction\" property). Use the controllerValidateResult\r\n     * to access the validate results specific to the call to \"validate\"\r\n     * (as opposed to using the \"results\" and \"errors\" properties to access the controller's entire\r\n     * set of results/errors).\r\n     */\r\n    controllerValidateResult) {\r\n        this.type = type;\r\n        this.errors = errors;\r\n        this.results = results;\r\n        this.instruction = instruction;\r\n        this.controllerValidateResult = controllerValidateResult;\r\n    }\r\n    return ValidateEvent;\r\n}());\n\n/**\r\n * Orchestrates validation.\r\n * Manages a set of bindings, renderers and objects.\r\n * Exposes the current list of validation results for binding purposes.\r\n */\r\nvar ValidationController = /** @class */ (function () {\r\n    function ValidationController(validator, propertyParser, config) {\r\n        this.validator = validator;\r\n        this.propertyParser = propertyParser;\r\n        // Registered bindings (via the validate binding behavior)\r\n        this.bindings = new Map();\r\n        // Renderers that have been added to the controller instance.\r\n        this.renderers = [];\r\n        /**\r\n         * Validation results that have been rendered by the controller.\r\n         */\r\n        this.results = [];\r\n        /**\r\n         * Validation errors that have been rendered by the controller.\r\n         */\r\n        this.errors = [];\r\n        /**\r\n         *  Whether the controller is currently validating.\r\n         */\r\n        this.validating = false;\r\n        // Elements related to validation results that have been rendered.\r\n        this.elements = new Map();\r\n        // Objects that have been added to the controller instance (entity-style validation).\r\n        this.objects = new Map();\r\n        // Promise that resolves when validation has completed.\r\n        this.finishValidating = Promise.resolve();\r\n        this.eventCallbacks = [];\r\n        this.validateTrigger = config instanceof GlobalValidationConfiguration\r\n            ? config.getDefaultValidationTrigger()\r\n            : GlobalValidationConfiguration.DEFAULT_VALIDATION_TRIGGER;\r\n    }\r\n    /**\r\n     * Subscribe to controller validate and reset events. These events occur when the\r\n     * controller's \"validate\"\" and \"reset\" methods are called.\r\n     * @param callback The callback to be invoked when the controller validates or resets.\r\n     */\r\n    ValidationController.prototype.subscribe = function (callback) {\r\n        var _this = this;\r\n        this.eventCallbacks.push(callback);\r\n        return {\r\n            dispose: function () {\r\n                var index = _this.eventCallbacks.indexOf(callback);\r\n                if (index === -1) {\r\n                    return;\r\n                }\r\n                _this.eventCallbacks.splice(index, 1);\r\n            }\r\n        };\r\n    };\r\n    /**\r\n     * Adds an object to the set of objects that should be validated when validate is called.\r\n     * @param object The object.\r\n     * @param rules Optional. The rules. If rules aren't supplied the Validator implementation will lookup the rules.\r\n     */\r\n    ValidationController.prototype.addObject = function (object, rules) {\r\n        this.objects.set(object, rules);\r\n    };\r\n    /**\r\n     * Removes an object from the set of objects that should be validated when validate is called.\r\n     * @param object The object.\r\n     */\r\n    ValidationController.prototype.removeObject = function (object) {\r\n        this.objects.delete(object);\r\n        this.processResultDelta('reset', this.results.filter(function (result) { return result.object === object; }), []);\r\n    };\r\n    /**\r\n     * Adds and renders an error.\r\n     */\r\n    ValidationController.prototype.addError = function (message, object, propertyName) {\r\n        if (propertyName === void 0) { propertyName = null; }\r\n        var resolvedPropertyName;\r\n        if (propertyName === null) {\r\n            resolvedPropertyName = propertyName;\r\n        }\r\n        else {\r\n            resolvedPropertyName = this.propertyParser.parse(propertyName);\r\n        }\r\n        var result = new ValidateResult({ __manuallyAdded__: true }, object, resolvedPropertyName, false, message);\r\n        this.processResultDelta('validate', [], [result]);\r\n        return result;\r\n    };\r\n    /**\r\n     * Removes and unrenders an error.\r\n     */\r\n    ValidationController.prototype.removeError = function (result) {\r\n        if (this.results.indexOf(result) !== -1) {\r\n            this.processResultDelta('reset', [result], []);\r\n        }\r\n    };\r\n    /**\r\n     * Adds a renderer.\r\n     * @param renderer The renderer.\r\n     */\r\n    ValidationController.prototype.addRenderer = function (renderer) {\r\n        var _this = this;\r\n        this.renderers.push(renderer);\r\n        renderer.render({\r\n            kind: 'validate',\r\n            render: this.results.map(function (result) { return ({ result: result, elements: _this.elements.get(result) }); }),\r\n            unrender: []\r\n        });\r\n    };\r\n    /**\r\n     * Removes a renderer.\r\n     * @param renderer The renderer.\r\n     */\r\n    ValidationController.prototype.removeRenderer = function (renderer) {\r\n        var _this = this;\r\n        this.renderers.splice(this.renderers.indexOf(renderer), 1);\r\n        renderer.render({\r\n            kind: 'reset',\r\n            render: [],\r\n            unrender: this.results.map(function (result) { return ({ result: result, elements: _this.elements.get(result) }); })\r\n        });\r\n    };\r\n    /**\r\n     * Registers a binding with the controller.\r\n     * @param binding The binding instance.\r\n     * @param target The DOM element.\r\n     * @param rules (optional) rules associated with the binding. Validator implementation specific.\r\n     */\r\n    ValidationController.prototype.registerBinding = function (binding, target, rules) {\r\n        this.bindings.set(binding, { target: target, rules: rules, propertyInfo: null });\r\n    };\r\n    /**\r\n     * Unregisters a binding with the controller.\r\n     * @param binding The binding instance.\r\n     */\r\n    ValidationController.prototype.unregisterBinding = function (binding) {\r\n        this.resetBinding(binding);\r\n        this.bindings.delete(binding);\r\n    };\r\n    /**\r\n     * Interprets the instruction and returns a predicate that will identify\r\n     * relevant results in the list of rendered validation results.\r\n     */\r\n    ValidationController.prototype.getInstructionPredicate = function (instruction) {\r\n        var _this = this;\r\n        if (instruction) {\r\n            var object_1 = instruction.object, propertyName_1 = instruction.propertyName, rules_1 = instruction.rules;\r\n            var predicate_1;\r\n            if (instruction.propertyName) {\r\n                predicate_1 = function (x) { return x.object === object_1 && x.propertyName === propertyName_1; };\r\n            }\r\n            else {\r\n                predicate_1 = function (x) { return x.object === object_1; };\r\n            }\r\n            if (rules_1) {\r\n                return function (x) { return predicate_1(x) && _this.validator.ruleExists(rules_1, x.rule); };\r\n            }\r\n            return predicate_1;\r\n        }\r\n        else {\r\n            return function () { return true; };\r\n        }\r\n    };\r\n    /**\r\n     * Validates and renders results.\r\n     * @param instruction Optional. Instructions on what to validate. If undefined, all\r\n     * objects and bindings will be validated.\r\n     */\r\n    ValidationController.prototype.validate = function (instruction) {\r\n        var _this = this;\r\n        // Get a function that will process the validation instruction.\r\n        var execute;\r\n        if (instruction) {\r\n            // tslint:disable-next-line:prefer-const\r\n            var object_2 = instruction.object, propertyName_2 = instruction.propertyName, rules_2 = instruction.rules;\r\n            // if rules were not specified, check the object map.\r\n            rules_2 = rules_2 || this.objects.get(object_2);\r\n            // property specified?\r\n            if (instruction.propertyName === undefined) {\r\n                // validate the specified object.\r\n                execute = function () { return _this.validator.validateObject(object_2, rules_2); };\r\n            }\r\n            else {\r\n                // validate the specified property.\r\n                execute = function () { return _this.validator.validateProperty(object_2, propertyName_2, rules_2); };\r\n            }\r\n        }\r\n        else {\r\n            // validate all objects and bindings.\r\n            execute = function () {\r\n                var promises = [];\r\n                for (var _i = 0, _a = Array.from(_this.objects); _i < _a.length; _i++) {\r\n                    var _b = _a[_i], object = _b[0], rules = _b[1];\r\n                    promises.push(_this.validator.validateObject(object, rules));\r\n                }\r\n                for (var _c = 0, _d = Array.from(_this.bindings); _c < _d.length; _c++) {\r\n                    var _e = _d[_c], binding = _e[0], rules = _e[1].rules;\r\n                    var propertyInfo = getPropertyInfo(binding.sourceExpression, binding.source);\r\n                    if (!propertyInfo || _this.objects.has(propertyInfo.object)) {\r\n                        continue;\r\n                    }\r\n                    promises.push(_this.validator.validateProperty(propertyInfo.object, propertyInfo.propertyName, rules));\r\n                }\r\n                return Promise.all(promises).then(function (resultSets) { return resultSets.reduce(function (a, b) { return a.concat(b); }, []); });\r\n            };\r\n        }\r\n        // Wait for any existing validation to finish, execute the instruction, render the results.\r\n        this.validating = true;\r\n        var returnPromise = this.finishValidating\r\n            .then(execute)\r\n            .then(function (newResults) {\r\n            var predicate = _this.getInstructionPredicate(instruction);\r\n            var oldResults = _this.results.filter(predicate);\r\n            _this.processResultDelta('validate', oldResults, newResults);\r\n            if (returnPromise === _this.finishValidating) {\r\n                _this.validating = false;\r\n            }\r\n            var result = {\r\n                instruction: instruction,\r\n                valid: newResults.find(function (x) { return !x.valid; }) === undefined,\r\n                results: newResults\r\n            };\r\n            _this.invokeCallbacks(instruction, result);\r\n            return result;\r\n        })\r\n            .catch(function (exception) {\r\n            // recover, to enable subsequent calls to validate()\r\n            _this.validating = false;\r\n            _this.finishValidating = Promise.resolve();\r\n            return Promise.reject(exception);\r\n        });\r\n        this.finishValidating = returnPromise;\r\n        return returnPromise;\r\n    };\r\n    /**\r\n     * Resets any rendered validation results (unrenders).\r\n     * @param instruction Optional. Instructions on what to reset. If unspecified all rendered results\r\n     * will be unrendered.\r\n     */\r\n    ValidationController.prototype.reset = function (instruction) {\r\n        var predicate = this.getInstructionPredicate(instruction);\r\n        var oldResults = this.results.filter(predicate);\r\n        this.processResultDelta('reset', oldResults, []);\r\n        this.invokeCallbacks(instruction, null);\r\n    };\r\n    /**\r\n     * Gets the elements associated with an object and propertyName (if any).\r\n     */\r\n    ValidationController.prototype.getAssociatedElements = function (_a) {\r\n        var object = _a.object, propertyName = _a.propertyName;\r\n        var elements = [];\r\n        for (var _i = 0, _b = Array.from(this.bindings); _i < _b.length; _i++) {\r\n            var _c = _b[_i], binding = _c[0], target = _c[1].target;\r\n            var propertyInfo = getPropertyInfo(binding.sourceExpression, binding.source);\r\n            if (propertyInfo && propertyInfo.object === object && propertyInfo.propertyName === propertyName) {\r\n                elements.push(target);\r\n            }\r\n        }\r\n        return elements;\r\n    };\r\n    ValidationController.prototype.processResultDelta = function (kind, oldResults, newResults) {\r\n        // prepare the instruction.\r\n        var instruction = {\r\n            kind: kind,\r\n            render: [],\r\n            unrender: []\r\n        };\r\n        // create a shallow copy of newResults so we can mutate it without causing side-effects.\r\n        newResults = newResults.slice(0);\r\n        var _loop_1 = function (oldResult) {\r\n            // get the elements associated with the old result.\r\n            var elements = this_1.elements.get(oldResult);\r\n            // remove the old result from the element map.\r\n            this_1.elements.delete(oldResult);\r\n            // create the unrender instruction.\r\n            instruction.unrender.push({ result: oldResult, elements: elements });\r\n            // determine if there's a corresponding new result for the old result we are unrendering.\r\n            var newResultIndex = newResults.findIndex(function (x) { return x.rule === oldResult.rule && x.object === oldResult.object && x.propertyName === oldResult.propertyName; });\r\n            if (newResultIndex === -1) {\r\n                // no corresponding new result... simple remove.\r\n                this_1.results.splice(this_1.results.indexOf(oldResult), 1);\r\n                if (!oldResult.valid) {\r\n                    this_1.errors.splice(this_1.errors.indexOf(oldResult), 1);\r\n                }\r\n            }\r\n            else {\r\n                // there is a corresponding new result...\r\n                var newResult = newResults.splice(newResultIndex, 1)[0];\r\n                // get the elements that are associated with the new result.\r\n                var elements_1 = this_1.getAssociatedElements(newResult);\r\n                this_1.elements.set(newResult, elements_1);\r\n                // create a render instruction for the new result.\r\n                instruction.render.push({ result: newResult, elements: elements_1 });\r\n                // do an in-place replacement of the old result with the new result.\r\n                // this ensures any repeats bound to this.results will not thrash.\r\n                this_1.results.splice(this_1.results.indexOf(oldResult), 1, newResult);\r\n                if (!oldResult.valid && newResult.valid) {\r\n                    this_1.errors.splice(this_1.errors.indexOf(oldResult), 1);\r\n                }\r\n                else if (!oldResult.valid && !newResult.valid) {\r\n                    this_1.errors.splice(this_1.errors.indexOf(oldResult), 1, newResult);\r\n                }\r\n                else if (!newResult.valid) {\r\n                    this_1.errors.push(newResult);\r\n                }\r\n            }\r\n        };\r\n        var this_1 = this;\r\n        // create unrender instructions from the old results.\r\n        for (var _i = 0, oldResults_1 = oldResults; _i < oldResults_1.length; _i++) {\r\n            var oldResult = oldResults_1[_i];\r\n            _loop_1(oldResult);\r\n        }\r\n        // create render instructions from the remaining new results.\r\n        for (var _a = 0, newResults_1 = newResults; _a < newResults_1.length; _a++) {\r\n            var result = newResults_1[_a];\r\n            var elements = this.getAssociatedElements(result);\r\n            instruction.render.push({ result: result, elements: elements });\r\n            this.elements.set(result, elements);\r\n            this.results.push(result);\r\n            if (!result.valid) {\r\n                this.errors.push(result);\r\n            }\r\n        }\r\n        // render.\r\n        for (var _b = 0, _c = this.renderers; _b < _c.length; _b++) {\r\n            var renderer = _c[_b];\r\n            renderer.render(instruction);\r\n        }\r\n    };\r\n    /**\r\n     * Validates the property associated with a binding.\r\n     */\r\n    ValidationController.prototype.validateBinding = function (binding) {\r\n        if (!binding.isBound) {\r\n            return;\r\n        }\r\n        var propertyInfo = getPropertyInfo(binding.sourceExpression, binding.source);\r\n        var rules;\r\n        var registeredBinding = this.bindings.get(binding);\r\n        if (registeredBinding) {\r\n            rules = registeredBinding.rules;\r\n            registeredBinding.propertyInfo = propertyInfo;\r\n        }\r\n        if (!propertyInfo) {\r\n            return;\r\n        }\r\n        var object = propertyInfo.object, propertyName = propertyInfo.propertyName;\r\n        this.validate({ object: object, propertyName: propertyName, rules: rules });\r\n    };\r\n    /**\r\n     * Resets the results for a property associated with a binding.\r\n     */\r\n    ValidationController.prototype.resetBinding = function (binding) {\r\n        var registeredBinding = this.bindings.get(binding);\r\n        var propertyInfo = getPropertyInfo(binding.sourceExpression, binding.source);\r\n        if (!propertyInfo && registeredBinding) {\r\n            propertyInfo = registeredBinding.propertyInfo;\r\n        }\r\n        if (registeredBinding) {\r\n            registeredBinding.propertyInfo = null;\r\n        }\r\n        if (!propertyInfo) {\r\n            return;\r\n        }\r\n        var object = propertyInfo.object, propertyName = propertyInfo.propertyName;\r\n        this.reset({ object: object, propertyName: propertyName });\r\n    };\r\n    /**\r\n     * Changes the controller's validateTrigger.\r\n     * @param newTrigger The new validateTrigger\r\n     */\r\n    ValidationController.prototype.changeTrigger = function (newTrigger) {\r\n        this.validateTrigger = newTrigger;\r\n        var bindings = Array.from(this.bindings.keys());\r\n        for (var _i = 0, bindings_1 = bindings; _i < bindings_1.length; _i++) {\r\n            var binding = bindings_1[_i];\r\n            var source = binding.source;\r\n            binding.unbind();\r\n            binding.bind(source);\r\n        }\r\n    };\r\n    /**\r\n     * Revalidates the controller's current set of errors.\r\n     */\r\n    ValidationController.prototype.revalidateErrors = function () {\r\n        for (var _i = 0, _a = this.errors; _i < _a.length; _i++) {\r\n            var _b = _a[_i], object = _b.object, propertyName = _b.propertyName, rule = _b.rule;\r\n            if (rule.__manuallyAdded__) {\r\n                continue;\r\n            }\r\n            var rules = [[rule]];\r\n            this.validate({ object: object, propertyName: propertyName, rules: rules });\r\n        }\r\n    };\r\n    ValidationController.prototype.invokeCallbacks = function (instruction, result) {\r\n        if (this.eventCallbacks.length === 0) {\r\n            return;\r\n        }\r\n        var event = new ValidateEvent(result ? 'validate' : 'reset', this.errors, this.results, instruction || null, result);\r\n        for (var i = 0; i < this.eventCallbacks.length; i++) {\r\n            this.eventCallbacks[i](event);\r\n        }\r\n    };\r\n    ValidationController.inject = [Validator, PropertyAccessorParser, GlobalValidationConfiguration];\r\n    return ValidationController;\r\n}());\n\n/**\r\n * Binding behavior. Indicates the bound property should be validated.\r\n */\r\nvar ValidateBindingBehaviorBase = /** @class */ (function () {\r\n    function ValidateBindingBehaviorBase(taskQueue) {\r\n        this.taskQueue = taskQueue;\r\n    }\r\n    ValidateBindingBehaviorBase.prototype.bind = function (binding, source, rulesOrController, rules) {\r\n        var _this = this;\r\n        // identify the target element.\r\n        var target = getTargetDOMElement(binding, source);\r\n        // locate the controller.\r\n        var controller;\r\n        if (rulesOrController instanceof ValidationController) {\r\n            controller = rulesOrController;\r\n        }\r\n        else {\r\n            controller = source.container.get(Optional.of(ValidationController));\r\n            rules = rulesOrController;\r\n        }\r\n        if (controller === null) {\r\n            throw new Error(\"A ValidationController has not been registered.\");\r\n        }\r\n        controller.registerBinding(binding, target, rules);\r\n        binding.validationController = controller;\r\n        var trigger = this.getValidateTrigger(controller);\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (trigger & validateTrigger.change) {\r\n            binding.vbbUpdateSource = binding.updateSource;\r\n            // tslint:disable-next-line:only-arrow-functions\r\n            // tslint:disable-next-line:space-before-function-paren\r\n            binding.updateSource = function (value) {\r\n                this.vbbUpdateSource(value);\r\n                this.validationController.validateBinding(this);\r\n            };\r\n        }\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (trigger & validateTrigger.blur) {\r\n            binding.validateBlurHandler = function () {\r\n                _this.taskQueue.queueMicroTask(function () { return controller.validateBinding(binding); });\r\n            };\r\n            binding.validateTarget = target;\r\n            target.addEventListener('blur', binding.validateBlurHandler);\r\n        }\r\n        if (trigger !== validateTrigger.manual) {\r\n            binding.standardUpdateTarget = binding.updateTarget;\r\n            // tslint:disable-next-line:only-arrow-functions\r\n            // tslint:disable-next-line:space-before-function-paren\r\n            binding.updateTarget = function (value) {\r\n                this.standardUpdateTarget(value);\r\n                this.validationController.resetBinding(this);\r\n            };\r\n        }\r\n    };\r\n    ValidateBindingBehaviorBase.prototype.unbind = function (binding) {\r\n        // reset the binding to it's original state.\r\n        if (binding.vbbUpdateSource) {\r\n            binding.updateSource = binding.vbbUpdateSource;\r\n            binding.vbbUpdateSource = null;\r\n        }\r\n        if (binding.standardUpdateTarget) {\r\n            binding.updateTarget = binding.standardUpdateTarget;\r\n            binding.standardUpdateTarget = null;\r\n        }\r\n        if (binding.validateBlurHandler) {\r\n            binding.validateTarget.removeEventListener('blur', binding.validateBlurHandler);\r\n            binding.validateBlurHandler = null;\r\n            binding.validateTarget = null;\r\n        }\r\n        binding.validationController.unregisterBinding(binding);\r\n        binding.validationController = null;\r\n    };\r\n    return ValidateBindingBehaviorBase;\r\n}());\n\n/**\r\n * Binding behavior. Indicates the bound property should be validated\r\n * when the validate trigger specified by the associated controller's\r\n * validateTrigger property occurs.\r\n */\r\nvar ValidateBindingBehavior = /** @class */ (function (_super) {\r\n    __extends(ValidateBindingBehavior, _super);\r\n    function ValidateBindingBehavior() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    ValidateBindingBehavior.prototype.getValidateTrigger = function (controller) {\r\n        return controller.validateTrigger;\r\n    };\r\n    ValidateBindingBehavior.inject = [TaskQueue];\r\n    ValidateBindingBehavior = __decorate([\r\n        bindingBehavior('validate')\r\n    ], ValidateBindingBehavior);\r\n    return ValidateBindingBehavior;\r\n}(ValidateBindingBehaviorBase));\r\n/**\r\n * Binding behavior. Indicates the bound property will be validated\r\n * manually, by calling controller.validate(). No automatic validation\r\n * triggered by data-entry or blur will occur.\r\n */\r\nvar ValidateManuallyBindingBehavior = /** @class */ (function (_super) {\r\n    __extends(ValidateManuallyBindingBehavior, _super);\r\n    function ValidateManuallyBindingBehavior() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    ValidateManuallyBindingBehavior.prototype.getValidateTrigger = function () {\r\n        return validateTrigger.manual;\r\n    };\r\n    ValidateManuallyBindingBehavior.inject = [TaskQueue];\r\n    ValidateManuallyBindingBehavior = __decorate([\r\n        bindingBehavior('validateManually')\r\n    ], ValidateManuallyBindingBehavior);\r\n    return ValidateManuallyBindingBehavior;\r\n}(ValidateBindingBehaviorBase));\r\n/**\r\n * Binding behavior. Indicates the bound property should be validated\r\n * when the associated element blurs.\r\n */\r\nvar ValidateOnBlurBindingBehavior = /** @class */ (function (_super) {\r\n    __extends(ValidateOnBlurBindingBehavior, _super);\r\n    function ValidateOnBlurBindingBehavior() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    ValidateOnBlurBindingBehavior.prototype.getValidateTrigger = function () {\r\n        return validateTrigger.blur;\r\n    };\r\n    ValidateOnBlurBindingBehavior.inject = [TaskQueue];\r\n    ValidateOnBlurBindingBehavior = __decorate([\r\n        bindingBehavior('validateOnBlur')\r\n    ], ValidateOnBlurBindingBehavior);\r\n    return ValidateOnBlurBindingBehavior;\r\n}(ValidateBindingBehaviorBase));\r\n/**\r\n * Binding behavior. Indicates the bound property should be validated\r\n * when the associated element is changed by the user, causing a change\r\n * to the model.\r\n */\r\nvar ValidateOnChangeBindingBehavior = /** @class */ (function (_super) {\r\n    __extends(ValidateOnChangeBindingBehavior, _super);\r\n    function ValidateOnChangeBindingBehavior() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    ValidateOnChangeBindingBehavior.prototype.getValidateTrigger = function () {\r\n        return validateTrigger.change;\r\n    };\r\n    ValidateOnChangeBindingBehavior.inject = [TaskQueue];\r\n    ValidateOnChangeBindingBehavior = __decorate([\r\n        bindingBehavior('validateOnChange')\r\n    ], ValidateOnChangeBindingBehavior);\r\n    return ValidateOnChangeBindingBehavior;\r\n}(ValidateBindingBehaviorBase));\r\n/**\r\n * Binding behavior. Indicates the bound property should be validated\r\n * when the associated element blurs or is changed by the user, causing\r\n * a change to the model.\r\n */\r\nvar ValidateOnChangeOrBlurBindingBehavior = /** @class */ (function (_super) {\r\n    __extends(ValidateOnChangeOrBlurBindingBehavior, _super);\r\n    function ValidateOnChangeOrBlurBindingBehavior() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    ValidateOnChangeOrBlurBindingBehavior.prototype.getValidateTrigger = function () {\r\n        return validateTrigger.changeOrBlur;\r\n    };\r\n    ValidateOnChangeOrBlurBindingBehavior.inject = [TaskQueue];\r\n    ValidateOnChangeOrBlurBindingBehavior = __decorate([\r\n        bindingBehavior('validateOnChangeOrBlur')\r\n    ], ValidateOnChangeOrBlurBindingBehavior);\r\n    return ValidateOnChangeOrBlurBindingBehavior;\r\n}(ValidateBindingBehaviorBase));\n\n/**\r\n * Creates ValidationController instances.\r\n */\r\nvar ValidationControllerFactory = /** @class */ (function () {\r\n    function ValidationControllerFactory(container) {\r\n        this.container = container;\r\n    }\r\n    ValidationControllerFactory.get = function (container) {\r\n        return new ValidationControllerFactory(container);\r\n    };\r\n    /**\r\n     * Creates a new controller instance.\r\n     */\r\n    ValidationControllerFactory.prototype.create = function (validator) {\r\n        if (!validator) {\r\n            validator = this.container.get(Validator);\r\n        }\r\n        var propertyParser = this.container.get(PropertyAccessorParser);\r\n        var config = this.container.get(GlobalValidationConfiguration);\r\n        return new ValidationController(validator, propertyParser, config);\r\n    };\r\n    /**\r\n     * Creates a new controller and registers it in the current element's container so that it's\r\n     * available to the validate binding behavior and renderers.\r\n     */\r\n    ValidationControllerFactory.prototype.createForCurrentScope = function (validator) {\r\n        var controller = this.create(validator);\r\n        this.container.registerInstance(ValidationController, controller);\r\n        return controller;\r\n    };\r\n    return ValidationControllerFactory;\r\n}());\r\nValidationControllerFactory['protocol:aurelia:resolver'] = true;\n\nvar ValidationErrorsCustomAttribute = /** @class */ (function () {\r\n    function ValidationErrorsCustomAttribute(boundaryElement, controllerAccessor) {\r\n        this.boundaryElement = boundaryElement;\r\n        this.controllerAccessor = controllerAccessor;\r\n        this.controller = null;\r\n        this.errors = [];\r\n        this.errorsInternal = [];\r\n    }\r\n    ValidationErrorsCustomAttribute.inject = function () {\r\n        return [DOM.Element, Lazy.of(ValidationController)];\r\n    };\r\n    ValidationErrorsCustomAttribute.prototype.sort = function () {\r\n        this.errorsInternal.sort(function (a, b) {\r\n            if (a.targets[0] === b.targets[0]) {\r\n                return 0;\r\n            }\r\n            // tslint:disable-next-line:no-bitwise\r\n            return a.targets[0].compareDocumentPosition(b.targets[0]) & 2 ? 1 : -1;\r\n        });\r\n    };\r\n    ValidationErrorsCustomAttribute.prototype.interestingElements = function (elements) {\r\n        var _this = this;\r\n        return elements.filter(function (e) { return _this.boundaryElement.contains(e); });\r\n    };\r\n    ValidationErrorsCustomAttribute.prototype.render = function (instruction) {\r\n        var _loop_1 = function (result) {\r\n            var index = this_1.errorsInternal.findIndex(function (x) { return x.error === result; });\r\n            if (index !== -1) {\r\n                this_1.errorsInternal.splice(index, 1);\r\n            }\r\n        };\r\n        var this_1 = this;\r\n        for (var _i = 0, _a = instruction.unrender; _i < _a.length; _i++) {\r\n            var result = _a[_i].result;\r\n            _loop_1(result);\r\n        }\r\n        for (var _b = 0, _c = instruction.render; _b < _c.length; _b++) {\r\n            var _d = _c[_b], result = _d.result, elements = _d.elements;\r\n            if (result.valid) {\r\n                continue;\r\n            }\r\n            var targets = this.interestingElements(elements);\r\n            if (targets.length) {\r\n                this.errorsInternal.push({ error: result, targets: targets });\r\n            }\r\n        }\r\n        this.sort();\r\n        this.errors = this.errorsInternal;\r\n    };\r\n    ValidationErrorsCustomAttribute.prototype.bind = function () {\r\n        if (!this.controller) {\r\n            this.controller = this.controllerAccessor();\r\n        }\r\n        // this will call render() with the side-effect of updating this.errors\r\n        this.controller.addRenderer(this);\r\n    };\r\n    ValidationErrorsCustomAttribute.prototype.unbind = function () {\r\n        if (this.controller) {\r\n            this.controller.removeRenderer(this);\r\n        }\r\n    };\r\n    __decorate([\r\n        bindable({ defaultBindingMode: bindingMode.oneWay })\r\n    ], ValidationErrorsCustomAttribute.prototype, \"controller\", void 0);\r\n    __decorate([\r\n        bindable({ primaryProperty: true, defaultBindingMode: bindingMode.twoWay })\r\n    ], ValidationErrorsCustomAttribute.prototype, \"errors\", void 0);\r\n    ValidationErrorsCustomAttribute = __decorate([\r\n        customAttribute('validation-errors')\r\n    ], ValidationErrorsCustomAttribute);\r\n    return ValidationErrorsCustomAttribute;\r\n}());\n\nvar ValidationRendererCustomAttribute = /** @class */ (function () {\r\n    function ValidationRendererCustomAttribute() {\r\n    }\r\n    ValidationRendererCustomAttribute.prototype.created = function (view) {\r\n        this.container = view.container;\r\n    };\r\n    ValidationRendererCustomAttribute.prototype.bind = function () {\r\n        this.controller = this.container.get(ValidationController);\r\n        this.renderer = this.container.get(this.value);\r\n        this.controller.addRenderer(this.renderer);\r\n    };\r\n    ValidationRendererCustomAttribute.prototype.unbind = function () {\r\n        this.controller.removeRenderer(this.renderer);\r\n        this.controller = null;\r\n        this.renderer = null;\r\n    };\r\n    ValidationRendererCustomAttribute = __decorate([\r\n        customAttribute('validation-renderer')\r\n    ], ValidationRendererCustomAttribute);\r\n    return ValidationRendererCustomAttribute;\r\n}());\n\n/**\r\n * Part of the fluent rule API. Enables customizing property rules.\r\n */\r\nvar FluentRuleCustomizer = /** @class */ (function () {\r\n    function FluentRuleCustomizer(property, condition, config, fluentEnsure, fluentRules, parsers) {\r\n        if (config === void 0) { config = {}; }\r\n        this.fluentEnsure = fluentEnsure;\r\n        this.fluentRules = fluentRules;\r\n        this.parsers = parsers;\r\n        this.rule = {\r\n            property: property,\r\n            condition: condition,\r\n            config: config,\r\n            when: null,\r\n            messageKey: 'default',\r\n            message: null,\r\n            sequence: fluentRules.sequence\r\n        };\r\n        this.fluentEnsure._addRule(this.rule);\r\n    }\r\n    /**\r\n     * Validate subsequent rules after previously declared rules have\r\n     * been validated successfully. Use to postpone validation of costly\r\n     * rules until less expensive rules pass validation.\r\n     */\r\n    FluentRuleCustomizer.prototype.then = function () {\r\n        this.fluentRules.sequence++;\r\n        return this;\r\n    };\r\n    /**\r\n     * Specifies the key to use when looking up the rule's validation message.\r\n     */\r\n    FluentRuleCustomizer.prototype.withMessageKey = function (key) {\r\n        this.rule.messageKey = key;\r\n        this.rule.message = null;\r\n        return this;\r\n    };\r\n    /**\r\n     * Specifies rule's validation message.\r\n     */\r\n    FluentRuleCustomizer.prototype.withMessage = function (message) {\r\n        this.rule.messageKey = 'custom';\r\n        this.rule.message = this.parsers.message.parse(message);\r\n        return this;\r\n    };\r\n    /**\r\n     * Specifies a condition that must be met before attempting to validate the rule.\r\n     * @param condition A function that accepts the object as a parameter and returns true\r\n     * or false whether the rule should be evaluated.\r\n     */\r\n    FluentRuleCustomizer.prototype.when = function (condition) {\r\n        this.rule.when = condition;\r\n        return this;\r\n    };\r\n    /**\r\n     * Tags the rule instance, enabling the rule to be found easily\r\n     * using ValidationRules.taggedRules(rules, tag)\r\n     */\r\n    FluentRuleCustomizer.prototype.tag = function (tag) {\r\n        this.rule.tag = tag;\r\n        return this;\r\n    };\r\n    ///// FluentEnsure APIs /////\r\n    /**\r\n     * Target a property with validation rules.\r\n     * @param property The property to target. Can be the property name or a property accessor function.\r\n     */\r\n    FluentRuleCustomizer.prototype.ensure = function (subject) {\r\n        return this.fluentEnsure.ensure(subject);\r\n    };\r\n    /**\r\n     * Targets an object with validation rules.\r\n     */\r\n    FluentRuleCustomizer.prototype.ensureObject = function () {\r\n        return this.fluentEnsure.ensureObject();\r\n    };\r\n    Object.defineProperty(FluentRuleCustomizer.prototype, \"rules\", {\r\n        /**\r\n         * Rules that have been defined using the fluent API.\r\n         */\r\n        get: function () {\r\n            return this.fluentEnsure.rules;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    /**\r\n     * Applies the rules to a class or object, making them discoverable by the StandardValidator.\r\n     * @param target A class or object.\r\n     */\r\n    FluentRuleCustomizer.prototype.on = function (target) {\r\n        return this.fluentEnsure.on(target);\r\n    };\r\n    ///////// FluentRules APIs /////////\r\n    /**\r\n     * Applies an ad-hoc rule function to the ensured property or object.\r\n     * @param condition The function to validate the rule.\r\n     * Will be called with two arguments, the property value and the object.\r\n     * Should return a boolean or a Promise that resolves to a boolean.\r\n     */\r\n    FluentRuleCustomizer.prototype.satisfies = function (condition, config) {\r\n        return this.fluentRules.satisfies(condition, config);\r\n    };\r\n    /**\r\n     * Applies a rule by name.\r\n     * @param name The name of the custom or standard rule.\r\n     * @param args The rule's arguments.\r\n     */\r\n    FluentRuleCustomizer.prototype.satisfiesRule = function (name) {\r\n        var _a;\r\n        var args = [];\r\n        for (var _i = 1; _i < arguments.length; _i++) {\r\n            args[_i - 1] = arguments[_i];\r\n        }\r\n        return (_a = this.fluentRules).satisfiesRule.apply(_a, __spreadArrays([name], args));\r\n    };\r\n    /**\r\n     * Applies the \"required\" rule to the property.\r\n     * The value cannot be null, undefined or whitespace.\r\n     */\r\n    FluentRuleCustomizer.prototype.required = function () {\r\n        return this.fluentRules.required();\r\n    };\r\n    /**\r\n     * Applies the \"matches\" rule to the property.\r\n     * Value must match the specified regular expression.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.matches = function (regex) {\r\n        return this.fluentRules.matches(regex);\r\n    };\r\n    /**\r\n     * Applies the \"email\" rule to the property.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.email = function () {\r\n        return this.fluentRules.email();\r\n    };\r\n    /**\r\n     * Applies the \"minLength\" STRING validation rule to the property.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.minLength = function (length) {\r\n        return this.fluentRules.minLength(length);\r\n    };\r\n    /**\r\n     * Applies the \"maxLength\" STRING validation rule to the property.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.maxLength = function (length) {\r\n        return this.fluentRules.maxLength(length);\r\n    };\r\n    /**\r\n     * Applies the \"minItems\" ARRAY validation rule to the property.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.minItems = function (count) {\r\n        return this.fluentRules.minItems(count);\r\n    };\r\n    /**\r\n     * Applies the \"maxItems\" ARRAY validation rule to the property.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.maxItems = function (count) {\r\n        return this.fluentRules.maxItems(count);\r\n    };\r\n    /**\r\n     * Applies the \"min\" NUMBER validation rule to the property.\r\n     * Value must be greater than or equal to the specified constraint.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.min = function (value) {\r\n        return this.fluentRules.min(value);\r\n    };\r\n    /**\r\n     * Applies the \"max\" NUMBER validation rule to the property.\r\n     * Value must be less than or equal to the specified constraint.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.max = function (value) {\r\n        return this.fluentRules.max(value);\r\n    };\r\n    /**\r\n     * Applies the \"range\" NUMBER validation rule to the property.\r\n     * Value must be between or equal to the specified min and max.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.range = function (min, max) {\r\n        return this.fluentRules.range(min, max);\r\n    };\r\n    /**\r\n     * Applies the \"between\" NUMBER validation rule to the property.\r\n     * Value must be between but not equal to the specified min and max.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.between = function (min, max) {\r\n        return this.fluentRules.between(min, max);\r\n    };\r\n    /**\r\n     * Applies the \"equals\" validation rule to the property.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRuleCustomizer.prototype.equals = function (expectedValue) {\r\n        return this.fluentRules.equals(expectedValue);\r\n    };\r\n    return FluentRuleCustomizer;\r\n}());\r\n/**\r\n * Part of the fluent rule API. Enables applying rules to properties and objects.\r\n */\r\nvar FluentRules = /** @class */ (function () {\r\n    function FluentRules(fluentEnsure, parsers, property) {\r\n        this.fluentEnsure = fluentEnsure;\r\n        this.parsers = parsers;\r\n        this.property = property;\r\n        /**\r\n         * Current rule sequence number. Used to postpone evaluation of rules until rules\r\n         * with lower sequence number have successfully validated. The \"then\" fluent API method\r\n         * manages this property, there's usually no need to set it directly.\r\n         */\r\n        this.sequence = 0;\r\n    }\r\n    /**\r\n     * Sets the display name of the ensured property.\r\n     */\r\n    FluentRules.prototype.displayName = function (name) {\r\n        this.property.displayName = name;\r\n        return this;\r\n    };\r\n    /**\r\n     * Applies an ad-hoc rule function to the ensured property or object.\r\n     * @param condition The function to validate the rule.\r\n     * Will be called with two arguments, the property value and the object.\r\n     * Should return a boolean or a Promise that resolves to a boolean.\r\n     */\r\n    FluentRules.prototype.satisfies = function (condition, config) {\r\n        return new FluentRuleCustomizer(this.property, condition, config, this.fluentEnsure, this, this.parsers);\r\n    };\r\n    /**\r\n     * Applies a rule by name.\r\n     * @param name The name of the custom or standard rule.\r\n     * @param args The rule's arguments.\r\n     */\r\n    FluentRules.prototype.satisfiesRule = function (name) {\r\n        var _this = this;\r\n        var args = [];\r\n        for (var _i = 1; _i < arguments.length; _i++) {\r\n            args[_i - 1] = arguments[_i];\r\n        }\r\n        var rule = FluentRules.customRules[name];\r\n        if (!rule) {\r\n            // standard rule?\r\n            rule = this[name];\r\n            if (rule instanceof Function) {\r\n                return rule.call.apply(rule, __spreadArrays([this], args));\r\n            }\r\n            throw new Error(\"Rule with name \\\"\" + name + \"\\\" does not exist.\");\r\n        }\r\n        var config = rule.argsToConfig ? rule.argsToConfig.apply(rule, args) : undefined;\r\n        return this.satisfies(function (value, obj) {\r\n            var _a;\r\n            return (_a = rule.condition).call.apply(_a, __spreadArrays([_this, value, obj], args));\r\n        }, config)\r\n            .withMessageKey(name);\r\n    };\r\n    /**\r\n     * Applies the \"required\" rule to the property.\r\n     * The value cannot be null, undefined or whitespace.\r\n     */\r\n    FluentRules.prototype.required = function () {\r\n        return this.satisfies(function (value) {\r\n            return value !== null\r\n                && value !== undefined\r\n                && !(isString(value) && !/\\S/.test(value));\r\n        }).withMessageKey('required');\r\n    };\r\n    /**\r\n     * Applies the \"matches\" rule to the property.\r\n     * Value must match the specified regular expression.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRules.prototype.matches = function (regex) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value.length === 0 || regex.test(value); })\r\n            .withMessageKey('matches');\r\n    };\r\n    /**\r\n     * Applies the \"email\" rule to the property.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRules.prototype.email = function () {\r\n        // regex from https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address\r\n        /* tslint:disable:max-line-length */\r\n        return this.matches(/^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/)\r\n            /* tslint:enable:max-line-length */\r\n            .withMessageKey('email');\r\n    };\r\n    /**\r\n     * Applies the \"minLength\" STRING validation rule to the property.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRules.prototype.minLength = function (length) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value.length === 0 || value.length >= length; }, { length: length })\r\n            .withMessageKey('minLength');\r\n    };\r\n    /**\r\n     * Applies the \"maxLength\" STRING validation rule to the property.\r\n     * null, undefined and empty-string values are considered valid.\r\n     */\r\n    FluentRules.prototype.maxLength = function (length) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value.length === 0 || value.length <= length; }, { length: length })\r\n            .withMessageKey('maxLength');\r\n    };\r\n    /**\r\n     * Applies the \"minItems\" ARRAY validation rule to the property.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRules.prototype.minItems = function (count) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value.length >= count; }, { count: count })\r\n            .withMessageKey('minItems');\r\n    };\r\n    /**\r\n     * Applies the \"maxItems\" ARRAY validation rule to the property.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRules.prototype.maxItems = function (count) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value.length <= count; }, { count: count })\r\n            .withMessageKey('maxItems');\r\n    };\r\n    /**\r\n     * Applies the \"min\" NUMBER validation rule to the property.\r\n     * Value must be greater than or equal to the specified constraint.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRules.prototype.min = function (constraint) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value >= constraint; }, { constraint: constraint })\r\n            .withMessageKey('min');\r\n    };\r\n    /**\r\n     * Applies the \"max\" NUMBER validation rule to the property.\r\n     * Value must be less than or equal to the specified constraint.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRules.prototype.max = function (constraint) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value <= constraint; }, { constraint: constraint })\r\n            .withMessageKey('max');\r\n    };\r\n    /**\r\n     * Applies the \"range\" NUMBER validation rule to the property.\r\n     * Value must be between or equal to the specified min and max.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRules.prototype.range = function (min, max) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || (value >= min && value <= max); }, { min: min, max: max })\r\n            .withMessageKey('range');\r\n    };\r\n    /**\r\n     * Applies the \"between\" NUMBER validation rule to the property.\r\n     * Value must be between but not equal to the specified min and max.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRules.prototype.between = function (min, max) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || (value > min && value < max); }, { min: min, max: max })\r\n            .withMessageKey('between');\r\n    };\r\n    /**\r\n     * Applies the \"equals\" validation rule to the property.\r\n     * null and undefined values are considered valid.\r\n     */\r\n    FluentRules.prototype.equals = function (expectedValue) {\r\n        return this.satisfies(function (value) { return value === null || value === undefined || value === '' || value === expectedValue; }, { expectedValue: expectedValue })\r\n            .withMessageKey('equals');\r\n    };\r\n    FluentRules.customRules = {};\r\n    return FluentRules;\r\n}());\r\n/**\r\n * Part of the fluent rule API. Enables targeting properties and objects with rules.\r\n */\r\nvar FluentEnsure = /** @class */ (function () {\r\n    function FluentEnsure(parsers) {\r\n        this.parsers = parsers;\r\n        /**\r\n         * Rules that have been defined using the fluent API.\r\n         */\r\n        this.rules = [];\r\n    }\r\n    /**\r\n     * Target a property with validation rules.\r\n     * @param property The property to target. Can be the property name or a property accessor\r\n     * function.\r\n     */\r\n    FluentEnsure.prototype.ensure = function (property) {\r\n        this.assertInitialized();\r\n        var name = this.parsers.property.parse(property);\r\n        var fluentRules = new FluentRules(this, this.parsers, { name: name, displayName: null });\r\n        return this.mergeRules(fluentRules, name);\r\n    };\r\n    /**\r\n     * Targets an object with validation rules.\r\n     */\r\n    FluentEnsure.prototype.ensureObject = function () {\r\n        this.assertInitialized();\r\n        var fluentRules = new FluentRules(this, this.parsers, { name: null, displayName: null });\r\n        return this.mergeRules(fluentRules, null);\r\n    };\r\n    /**\r\n     * Applies the rules to a class or object, making them discoverable by the StandardValidator.\r\n     * @param target A class or object.\r\n     */\r\n    FluentEnsure.prototype.on = function (target) {\r\n        Rules.set(target, this.rules);\r\n        return this;\r\n    };\r\n    /**\r\n     * Adds a rule definition to the sequenced ruleset.\r\n     * @internal\r\n     */\r\n    FluentEnsure.prototype._addRule = function (rule) {\r\n        while (this.rules.length < rule.sequence + 1) {\r\n            this.rules.push([]);\r\n        }\r\n        this.rules[rule.sequence].push(rule);\r\n    };\r\n    FluentEnsure.prototype.assertInitialized = function () {\r\n        if (this.parsers) {\r\n            return;\r\n        }\r\n        throw new Error(\"Did you forget to add \\\".plugin('aurelia-validation')\\\" to your main.js?\");\r\n    };\r\n    FluentEnsure.prototype.mergeRules = function (fluentRules, propertyName) {\r\n        // tslint:disable-next-line:triple-equals | Use loose equality for property keys\r\n        var existingRules = this.rules.find(function (r) { return r.length > 0 && r[0].property.name == propertyName; });\r\n        if (existingRules) {\r\n            var rule = existingRules[existingRules.length - 1];\r\n            fluentRules.sequence = rule.sequence;\r\n            if (rule.property.displayName !== null) {\r\n                fluentRules = fluentRules.displayName(rule.property.displayName);\r\n            }\r\n        }\r\n        return fluentRules;\r\n    };\r\n    return FluentEnsure;\r\n}());\r\n/**\r\n * Fluent rule definition API.\r\n */\r\nvar ValidationRules = /** @class */ (function () {\r\n    function ValidationRules() {\r\n    }\r\n    ValidationRules.initialize = function (messageParser, propertyParser) {\r\n        this.parsers = {\r\n            message: messageParser,\r\n            property: propertyParser\r\n        };\r\n    };\r\n    /**\r\n     * Target a property with validation rules.\r\n     * @param property The property to target. Can be the property name or a property accessor function.\r\n     */\r\n    ValidationRules.ensure = function (property) {\r\n        return new FluentEnsure(ValidationRules.parsers).ensure(property);\r\n    };\r\n    /**\r\n     * Targets an object with validation rules.\r\n     */\r\n    ValidationRules.ensureObject = function () {\r\n        return new FluentEnsure(ValidationRules.parsers).ensureObject();\r\n    };\r\n    /**\r\n     * Defines a custom rule.\r\n     * @param name The name of the custom rule. Also serves as the message key.\r\n     * @param condition The rule function.\r\n     * @param message The message expression\r\n     * @param argsToConfig A function that maps the rule's arguments to a \"config\"\r\n     * object that can be used when evaluating the message expression.\r\n     */\r\n    ValidationRules.customRule = function (name, condition, message, argsToConfig) {\r\n        validationMessages[name] = message;\r\n        FluentRules.customRules[name] = { condition: condition, argsToConfig: argsToConfig };\r\n    };\r\n    /**\r\n     * Returns rules with the matching tag.\r\n     * @param rules The rules to search.\r\n     * @param tag The tag to search for.\r\n     */\r\n    ValidationRules.taggedRules = function (rules, tag) {\r\n        return rules.map(function (x) { return x.filter(function (r) { return r.tag === tag; }); });\r\n    };\r\n    /**\r\n     * Returns rules that have no tag.\r\n     * @param rules The rules to search.\r\n     */\r\n    ValidationRules.untaggedRules = function (rules) {\r\n        return rules.map(function (x) { return x.filter(function (r) { return r.tag === undefined; }); });\r\n    };\r\n    /**\r\n     * Removes the rules from a class or object.\r\n     * @param target A class or object.\r\n     */\r\n    ValidationRules.off = function (target) {\r\n        Rules.unset(target);\r\n    };\r\n    return ValidationRules;\r\n}());\n\n// Exports\r\n/**\r\n * Configures the plugin.\r\n */\r\nfunction configure(\r\n// tslint:disable-next-line:ban-types\r\nframeworkConfig, callback) {\r\n    // the fluent rule definition API needs the parser to translate messages\r\n    // to interpolation expressions.\r\n    var messageParser = frameworkConfig.container.get(ValidationMessageParser);\r\n    var propertyParser = frameworkConfig.container.get(PropertyAccessorParser);\r\n    ValidationRules.initialize(messageParser, propertyParser);\r\n    // configure...\r\n    var config = new GlobalValidationConfiguration();\r\n    if (callback instanceof Function) {\r\n        callback(config);\r\n    }\r\n    config.apply(frameworkConfig.container);\r\n    // globalize the behaviors.\r\n    if (frameworkConfig.globalResources) {\r\n        frameworkConfig.globalResources(ValidateBindingBehavior, ValidateManuallyBindingBehavior, ValidateOnBlurBindingBehavior, ValidateOnChangeBindingBehavior, ValidateOnChangeOrBlurBindingBehavior, ValidationErrorsCustomAttribute, ValidationRendererCustomAttribute);\r\n    }\r\n}\n\nexport { configure, GlobalValidationConfiguration, getTargetDOMElement, getPropertyInfo, PropertyAccessorParser, getAccessorExpression, ValidateBindingBehavior, ValidateManuallyBindingBehavior, ValidateOnBlurBindingBehavior, ValidateOnChangeBindingBehavior, ValidateOnChangeOrBlurBindingBehavior, ValidateEvent, ValidateResult, validateTrigger, ValidationController, ValidationControllerFactory, ValidationErrorsCustomAttribute, ValidationRendererCustomAttribute, Validator, Rules, StandardValidator, validationMessages, ValidationMessageProvider, ValidationMessageParser, MessageExpressionValidator, FluentRuleCustomizer, FluentRules, FluentEnsure, ValidationRules };\n","// With default aurelia-loader-webpack config, this module is added as an extra entry\r\n// before any other code executes so that PAL.Loader is properly configured.\r\n// There are several tricky points worth noticing.\r\n// \r\n// We don't add aurelia-loader-webpack itself as an entry point (used to until 2.0 RC2)\r\n// because it (transitively) brings too much bagage with itself, most notably polyfills.\r\n// This made it super-hard to add other polyfills before Aurelia's and led to various bugs.\r\n//\r\n// We don't add custom code in aurelia-pal or aurelia-loader or aurelia-bootstrapper to detect\r\n// the Webpack environment and configure the loader because they might live in a DLL.\r\n// If they do, they would bring aurelia-loader-webpack along in the DLL and this is a special \r\n// library that *has to be in the main chunk.*\r\n//\r\n// The over-complicated design I've settled upon in the end is to use this special module\r\n// as an entry point that configures aurelia-loader-webpack. It has minimal static imports:\r\n// just aurelia-pal, which itself has no other dependencies and doesn't run much code.\r\n// It hacks the loader field into a getter so that it can synchronously load aurelia-loader-webpack\r\n// just in time when it is demanded by aurelia-bootstrapper.\r\n// This enables users to load polyfills before aurelia-loader-webpack is actually loaded.\r\n\r\nimport { PLATFORM } from \"aurelia-pal\";\r\n\r\nvar Loader;\r\n\r\nObject.defineProperty(PLATFORM, \"Loader\", {\r\n  get: function() {\r\n    return Loader || (Loader = require(\"aurelia-loader-webpack\").WebpackLoader);\r\n  },\r\n  set: function(value) {\r\n    Loader = value;\r\n  }\r\n});\r\n"],"names":["CompileSpy","element","instruction","getLogger","info","toString","Object","defineProperty","get","enumerable","configurable","$resource","type","name","ViewSpy","this","logger","prototype","_log","lifecycleName","context","value","indexOf","view","created","bind","bindingContext","attached","detached","unbind","__assign","assign","t","s","i","n","arguments","length","p","hasOwnProperty","call","apply","waitFor","getter","options","present","interval","timeout","timedOut","Promise","race","_","rj","setTimeout","Error","wait","found","NodeList","jquery","resolve","rs","then","waitForDocumentElement","selector","document","querySelector","waitForDocumentElements","querySelectorAll","StageComponent","withResources","resources","ComponentTester","configure","aurelia","use","standardConfiguration","bootstrap","inView","html","boundTo","manuallyHandleLifecycle","_prepareLifecycle","create","_this","globalResources","start","host","createElement","innerHTML","body","appendChild","enhance","rootView","root","firstElementChild","controllers","viewModel","dispose","undefined","parentNode","removeChild","bindPrototype","attachedPrototype","waitForElement","waitForElements","config","coerceFunctions","none","a","number","Number","string","boolean","booleanAttr","val","date","d","Date","isNaN","getTime","coerceFunctionMap","Map","Boolean","String","coerce","warn","keys","newValue","oldValue","currentValue","coercedValue","publishing","notqueued","taskQueue","flushing","queueMicroTask","initialValue","selfSubscriber","defaultValue","changeHandlerName","changeHandler","hasOptions","propertyChanged","observer","owner","setCoerce","observerLookup","behaviorHandlesBind","attribute","boundProperties","getValue","set","setValue","binding","createBinding","push","bindable","nameOrTargetOrConfig","key","descriptor","deco","target","key2","descriptor2","propType","actualTarget","constructor","r","coerceType","registerWith","forEach","observableLogger","_usePropertyType$1","observable","coerceFunction","isClassDecorator","innerPropertyName","innerPropertyDescriptor","writable","initValue","callbackName","initializer","Reflect","dependencies","k","Validator","extendStatics","b","setPrototypeOf","__proto__","Array","__extends","__","__decorate","decorators","desc","c","getOwnPropertyDescriptor","decorate","__spreadArrays","il","j","jl","validateTrigger","ValidateResult","rule","object","propertyName","valid","message","id","nextId","Rules","rules","Function","unset","ExpressionVisitor","visitChain","chain","visitArgs","expressions","visitBindingBehavior","behavior","expression","accept","args","visitValueConverter","converter","visitAssign","visitConditional","conditional","condition","yes","no","visitAccessThis","access","ancestor","visitAccessScope","visitAccessMember","visitAccessKeyed","visitCallScope","visitCallFunction","func","visitCallMember","visitPrefix","prefix","visitBinary","binary","left","right","visitLiteralPrimitive","literal","visitLiteralArray","elements","visitLiteralObject","values","visitLiteralString","ValidationMessageParser","bindinqLanguage","emptyStringExpression","nullExpression","undefinedExpression","cache","parse","parts","parseInterpolation","coalesce","MessageExpressionValidator","validate","part","inject","_super","originalMessage","visitor","validationMessages","default","required","matches","email","minLength","maxLength","minItems","maxItems","min","max","range","between","equals","ValidationMessageProvider","parser","getMessage","getDisplayName","displayName","words","split","join","charAt","toUpperCase","slice","StandardValidator","messageProvider","lookupFunctions","validateProperty","validateObject","ruleExists","messageKey","_a","property","overrideContext","$displayName","$propertyName","$value","$object","$config","$getDisplayName","evaluate","validateRuleSequence","ruleSequence","sequence","results","validateAllProperties","allValid","promises","_loop_1","when","promiseOrBoolean","all","GlobalValidationConfiguration","validatorType","validationTrigger","DEFAULT_VALIDATION_TRIGGER","customValidator","defaultValidationTrigger","trigger","getDefaultValidationTrigger","container","validator","registerInstance","blur","getTargetDOMElement","Element","ii","controller","sourceExpression","getObject","objectExpression","source","getPropertyInfo","originalExpression","isString","PropertyAccessorParser","accessorText","getAccessorExpression","accessor","fn","match","exec","ValidateEvent","errors","controllerValidateResult","ValidationController","propertyParser","bindings","renderers","validating","objects","finishValidating","eventCallbacks","subscribe","callback","index","splice","addObject","removeObject","delete","processResultDelta","filter","result","addError","resolvedPropertyName","__manuallyAdded__","removeError","addRenderer","renderer","render","kind","map","unrender","removeRenderer","registerBinding","propertyInfo","unregisterBinding","resetBinding","getInstructionPredicate","predicate_1","object_1","propertyName_1","rules_1","x","execute","object_2","propertyName_2","rules_2","_i","from","_b","_c","_d","_e","has","resultSets","reduce","concat","returnPromise","newResults","predicate","oldResults","find","invokeCallbacks","catch","exception","reject","reset","getAssociatedElements","oldResult","this_1","newResultIndex","findIndex","newResult","elements_1","oldResults_1","newResults_1","validateBinding","isBound","registeredBinding","changeTrigger","newTrigger","bindings_1","revalidateErrors","event","ValidateBindingBehaviorBase","rulesOrController","Optional","validationController","getValidateTrigger","change","vbbUpdateSource","updateSource","validateBlurHandler","validateTarget","addEventListener","manual","standardUpdateTarget","updateTarget","removeEventListener","ValidateBindingBehavior","ValidateManuallyBindingBehavior","ValidateOnBlurBindingBehavior","ValidateOnChangeBindingBehavior","ValidateOnChangeOrBlurBindingBehavior","changeOrBlur","ValidationControllerFactory","createForCurrentScope","ValidationErrorsCustomAttribute","boundaryElement","controllerAccessor","errorsInternal","Lazy","sort","targets","compareDocumentPosition","interestingElements","e","contains","error","defaultBindingMode","primaryProperty","ValidationRendererCustomAttribute","FluentRuleCustomizer","fluentEnsure","fluentRules","parsers","_addRule","withMessageKey","withMessage","tag","ensure","subject","ensureObject","on","satisfies","satisfiesRule","regex","count","expectedValue","FluentRules","customRules","argsToConfig","obj","test","constraint","FluentEnsure","assertInitialized","mergeRules","existingRules","ValidationRules","initialize","messageParser","customRule","taggedRules","untaggedRules","off","frameworkConfig","Loader"],"sourceRoot":""}