{"version":3,"sources":["webpack:///./node_modules/aurelia-webpack-plugin/runtime/pal-loader-entry.js","webpack:///./node_modules/aurelia-typed-observable-plugin/dist/native-modules/index.js","webpack:///./node_modules/aurelia-validation/dist/native-modules/aurelia-validation.js"],"names":["Loader","Object","defineProperty","get","WebpackLoader","set","value","coerceFunctions","none","a","number","Number","string","boolean","booleanAttr","val","date","d","Date","isNaN","getTime","coerceFunctionMap","Map","Boolean","String","prototype","setCoerce","coerce","this","undefined","warn","concat","keys","setValue","newValue","oldValue","currentValue","coercedValue","publishing","notqueued","taskQueue","flushing","call","queueMicroTask","createObserver","viewModel","initialValue","selfSubscriber","defaultValue","changeHandlerName","changeHandler","name","hasOptions","propertyChanged","Error","observer","owner","_createDynamicProperty","observerLookup","behaviorHandlesBind","attribute","boundProperties","info","configurable","enumerable","getValue","bind","binding","createBinding","push","_usePropertyType$1","bindable","nameOrTargetOrConfig","key","descriptor","deco","target","key2","descriptor2","propType","actualTarget","constructor","r","getOrCreateOwn","resource","getOwn","propertyType","coerceType","registerWith","forEach","type","observableLogger","_usePropertyType","observable","config","coerceFunction","isClassDecorator","innerPropertyName","innerPropertyDescriptor","writable","initValue","callbackName","initializer","Reflect","dependencies","t","k","Validator","extendStatics","b","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__extends","__","create","__decorate","decorators","desc","c","arguments","length","getOwnPropertyDescriptor","decorate","i","__spreadArrays","s","il","j","jl","validateTrigger","ValidateResult","rule","object","propertyName","valid","message","id","nextId","toString","Rules","rules","Function","unset","ExpressionVisitor","visitChain","chain","visitArgs","expressions","visitBindingBehavior","behavior","expression","accept","args","visitValueConverter","converter","visitAssign","assign","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","_this","visitor","indexOf","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","resources","lookupFunctions","validateProperty","validateObject","ruleExists","messageKey","_a","property","overrideContext","$displayName","$propertyName","$value","$object","$config","$getDisplayName","evaluate","bindingContext","validateRuleSequence","ruleSequence","sequence","results","validateAllProperties","allValid","promises","_loop_1","when","promiseOrBoolean","Promise","resolve","then","all","GlobalValidationConfiguration","validatorType","validationTrigger","DEFAULT_VALIDATION_TRIGGER","customValidator","defaultValidationTrigger","trigger","getDefaultValidationTrigger","apply","container","validator","registerInstance","blur","getTargetDOMElement","view","Element","ii","controllers","controller","element","sourceExpression","getObject","objectExpression","source","getPropertyInfo","originalExpression","isString","PropertyAccessorParser","accessorText","getAccessorExpression","accessor","fn","match","exec","ValidateEvent","errors","instruction","controllerValidateResult","ValidationController","propertyParser","bindings","renderers","validating","objects","finishValidating","eventCallbacks","subscribe","callback","dispose","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","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","unbind","revalidateErrors","event","ValidateBindingBehaviorBase","rulesOrController","of","validationController","getValidateTrigger","focusout","hasChangeTrigger","change","isDirty","validatedOnce","vbbUpdateSource","updateSource","focusLossHandler","validationTriggerEvent","validateTarget","addEventListener","validationSubscription","e","manual","standardUpdateTarget","updateTarget","removeEventListener","ValidateBindingBehavior","ValidateManuallyBindingBehavior","ValidateOnBlurBindingBehavior","ValidateOnChangeBindingBehavior","ValidateOnChangeOrBlurBindingBehavior","changeOrBlur","ValidateOnFocusoutBindingBehavior","ValidateOnChangeOrFocusoutBindingBehavior","changeOrFocusout","ValidationControllerFactory","createForCurrentScope","ValidationErrorsCustomAttribute","boundaryElement","controllerAccessor","errorsInternal","sort","targets","compareDocumentPosition","interestingElements","contains","error","defaultBindingMode","oneWay","primaryProperty","twoWay","ValidationRendererCustomAttribute","created","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","configure","frameworkConfig","globalResources"],"mappings":"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","file":"vendors~5ea1390f.776cf4f13a5c878e5e22.chunk.js","sourcesContent":["// With default aurelia-loader-webpack config, this module is added as an extra entry\n// before any other code executes so that PAL.Loader is properly configured.\n// There are several tricky points worth noticing.\n// \n// We don't add aurelia-loader-webpack itself as an entry point (used to until 2.0 RC2)\n// because it (transitively) brings too much bagage with itself, most notably polyfills.\n// This made it super-hard to add other polyfills before Aurelia's and led to various bugs.\n//\n// We don't add custom code in aurelia-pal or aurelia-loader or aurelia-bootstrapper to detect\n// the Webpack environment and configure the loader because they might live in a DLL.\n// If they do, they would bring aurelia-loader-webpack along in the DLL and this is a special \n// library that *has to be in the main chunk.*\n//\n// The over-complicated design I've settled upon in the end is to use this special module\n// as an entry point that configures aurelia-loader-webpack. It has minimal static imports:\n// just aurelia-pal, which itself has no other dependencies and doesn't run much code.\n// It hacks the loader field into a getter so that it can synchronously load aurelia-loader-webpack\n// just in time when it is demanded by aurelia-bootstrapper.\n// This enables users to load polyfills before aurelia-loader-webpack is actually loaded.\n\nimport { PLATFORM } from \"aurelia-pal\";\n\nvar Loader;\n\nObject.defineProperty(PLATFORM, \"Loader\", {\n  get: function() {\n    return Loader || (Loader = require(\"aurelia-loader-webpack\").WebpackLoader);\n  },\n  set: function(value) {\n    Loader = value;\n  }\n});\n","import * as LogManager from 'aurelia-logging';\nimport { metadata } from 'aurelia-metadata';\nimport { BehaviorPropertyObserver, BindableProperty, HtmlBehaviorResource } from 'aurelia-templating';\n\nvar coerceFunctions = {\r\n    none: function (a) {\r\n        return a;\r\n    },\r\n    number: function (a) {\r\n        return Number(a);\r\n    },\r\n    string: function (a) {\r\n        return '' + a;\r\n    },\r\n    boolean: function (a) {\r\n        return !!a;\r\n    },\r\n    booleanAttr: function (val) {\r\n        return val || val === '' ? true : false;\r\n    },\r\n    date: function (val) {\r\n        if (val === null || val === undefined) {\r\n            return null;\r\n        }\r\n        var d = new Date(val);\r\n        return isNaN(d.getTime()) ? null : d;\r\n    }\r\n};\r\nvar coerceFunctionMap = new Map([\r\n    [Boolean, 'boolean'],\r\n    [String, 'string'],\r\n    [Date, 'date'],\r\n    [Number, 'number'],\r\n]);\r\nfunction mapCoerceFunction(type, strType, coerceFunction) {\r\n    coerceFunction = coerceFunction || type.coerce;\r\n    if (typeof strType !== 'string' || typeof coerceFunction !== 'function') {\r\n        LogManager\r\n            .getLogger('map-coerce-function')\r\n            .warn(\"Bad attempt at mapping coerce function for type: \".concat(type.name, \" to: \").concat(strType));\r\n        return;\r\n    }\r\n    coerceFunctions[strType] = coerceFunction;\r\n    coerceFunctionMap.set(type, strType);\r\n}\n\nBehaviorPropertyObserver.prototype.setCoerce = function (coerce) {\r\n    this.coerce = typeof coerce === 'function' ? coerce : coerceFunctions[coerce];\r\n    if (this.coerce === undefined) {\r\n        LogManager\r\n            .getLogger('behavior-property-observer')\r\n            .warn(\"Invalid coerce instruction. Should be either one of \".concat(Object.keys(coerceFunctions), \" or a function.\"));\r\n    }\r\n};\r\nBehaviorPropertyObserver.prototype.setValue = function (newValue) {\r\n    var oldValue = this.currentValue;\r\n    var coercedValue = this.coerce === undefined ? newValue : this.coerce(newValue);\r\n    if (oldValue !== coercedValue) {\r\n        this.oldValue = oldValue;\r\n        this.currentValue = coercedValue;\r\n        if (this.publishing && this.notqueued) {\r\n            if (this.taskQueue.flushing) {\r\n                this.call();\r\n            }\r\n            else {\r\n                this.notqueued = false;\r\n                this.taskQueue.queueMicroTask(this);\r\n            }\r\n        }\r\n    }\r\n};\r\nBindableProperty.prototype.createObserver = function (viewModel) {\r\n    var selfSubscriber = null;\r\n    var defaultValue = this.defaultValue;\r\n    var changeHandlerName = this.changeHandler;\r\n    var name = this.name;\r\n    var initialValue;\r\n    if (this.hasOptions) {\r\n        return undefined;\r\n    }\r\n    if (changeHandlerName in viewModel) {\r\n        if ('propertyChanged' in viewModel) {\r\n            selfSubscriber = function (newValue, oldValue) {\r\n                viewModel[changeHandlerName](newValue, oldValue);\r\n                viewModel.propertyChanged(name, newValue, oldValue);\r\n            };\r\n        }\r\n        else {\r\n            selfSubscriber = function (newValue, oldValue) { return viewModel[changeHandlerName](newValue, oldValue); };\r\n        }\r\n    }\r\n    else if ('propertyChanged' in viewModel) {\r\n        selfSubscriber = function (newValue, oldValue) { return viewModel.propertyChanged(name, newValue, oldValue); };\r\n    }\r\n    else if (changeHandlerName !== null) {\r\n        throw new Error(\"Change handler \".concat(changeHandlerName, \" was specified but not declared on the class.\"));\r\n    }\r\n    if (defaultValue !== undefined) {\r\n        initialValue = typeof defaultValue === 'function' ? defaultValue.call(viewModel) : defaultValue;\r\n    }\r\n    var observer = new BehaviorPropertyObserver(this.owner.taskQueue, viewModel, this.name, selfSubscriber, initialValue);\r\n    if (this.coerce !== undefined) {\r\n        observer.setCoerce(this.coerce);\r\n        observer.currentValue = observer.oldValue = observer.coerce === undefined ? observer.currentValue : observer.coerce(initialValue);\r\n    }\r\n    return observer;\r\n};\r\nBindableProperty.prototype._createDynamicProperty = function (viewModel, observerLookup, behaviorHandlesBind, name, attribute, boundProperties) {\r\n    var changeHandlerName = \"\".concat(name, \"Changed\");\r\n    var selfSubscriber = null;\r\n    var observer;\r\n    var info;\r\n    if (changeHandlerName in viewModel) {\r\n        if ('propertyChanged' in viewModel) {\r\n            selfSubscriber = function (newValue, oldValue) {\r\n                viewModel[changeHandlerName](newValue, oldValue);\r\n                viewModel.propertyChanged(name, newValue, oldValue);\r\n            };\r\n        }\r\n        else {\r\n            selfSubscriber = function (newValue, oldValue) { return viewModel[changeHandlerName](newValue, oldValue); };\r\n        }\r\n    }\r\n    else if ('propertyChanged' in viewModel) {\r\n        selfSubscriber = function (newValue, oldValue) { return viewModel.propertyChanged(name, newValue, oldValue); };\r\n    }\r\n    observer = observerLookup[name] = new BehaviorPropertyObserver(this.owner.taskQueue, viewModel, name, selfSubscriber, undefined);\r\n    observer.setCoerce(this.coerce);\r\n    observer.currentValue = observer.oldValue = observer.coerce === undefined ? observer.currentValue : observer.coerce(undefined);\r\n    Object.defineProperty(viewModel, name, {\r\n        configurable: true,\r\n        enumerable: true,\r\n        get: observer.getValue.bind(observer),\r\n        set: observer.setValue.bind(observer)\r\n    });\r\n    if (behaviorHandlesBind) {\r\n        observer.selfSubscriber = null;\r\n    }\r\n    if (typeof attribute === 'string') {\r\n        viewModel[name] = attribute;\r\n        observer.call();\r\n    }\r\n    else if (attribute) {\r\n        info = { observer: observer, binding: attribute.createBinding(viewModel) };\r\n        boundProperties.push(info);\r\n    }\r\n    observer.publishing = true;\r\n    observer.selfSubscriber = selfSubscriber;\r\n};\n\nvar _usePropertyType$1 = false;\r\nvar bindable = function bindable(nameOrTargetOrConfig, key, descriptor) {\r\n    var deco = function (target, key2, descriptor2) {\r\n        var actualTarget = key2 ? target.constructor : target;\r\n        var r = metadata.getOrCreateOwn(metadata.resource, HtmlBehaviorResource, actualTarget);\r\n        var prop;\r\n        var propType;\r\n        if (key2) {\r\n            nameOrTargetOrConfig = nameOrTargetOrConfig || {};\r\n            nameOrTargetOrConfig.name = key2;\r\n            if (nameOrTargetOrConfig.coerce === undefined && _usePropertyType$1) {\r\n                propType = metadata.getOwn(metadata.propertyType, target, key2);\r\n                if (propType) {\r\n                    var coerceType = coerceFunctionMap.get(propType);\r\n                    if (coerceType === undefined) {\r\n                        LogManager\r\n                            .getLogger('@bindable decorator')\r\n                            .warn(\"Invalid coerce instruction. Should be either one of \".concat(Object.keys(coerceFunctions), \" or a function.\"));\r\n                    }\r\n                    nameOrTargetOrConfig.coerce = coerceType || 'none';\r\n                }\r\n            }\r\n        }\r\n        prop = new BindableProperty(nameOrTargetOrConfig);\r\n        return prop.registerWith(actualTarget, r, descriptor2);\r\n    };\r\n    if (!nameOrTargetOrConfig) {\r\n        return deco;\r\n    }\r\n    if (key) {\r\n        var target = nameOrTargetOrConfig;\r\n        nameOrTargetOrConfig = undefined;\r\n        return deco(target, key, descriptor);\r\n    }\r\n    return deco;\r\n};\r\n['string', 'number', 'boolean', 'booleanAttr', 'date'].forEach(createTypedBindable);\r\nfunction usePropertyType$1(shouldUsePropertyType) {\r\n    _usePropertyType$1 = shouldUsePropertyType;\r\n}\r\nfunction createTypedBindable(type) {\r\n    return bindable[type] = function (nameOrTargetOrConfig, key, descriptor) {\r\n        if (nameOrTargetOrConfig === undefined) {\r\n            return bindable({ coerce: type });\r\n        }\r\n        if (key === undefined) {\r\n            nameOrTargetOrConfig = typeof nameOrTargetOrConfig === 'string' ? { name: nameOrTargetOrConfig } : nameOrTargetOrConfig;\r\n            nameOrTargetOrConfig.coerce = type;\r\n            return bindable(nameOrTargetOrConfig);\r\n        }\r\n        return bindable({ coerce: type })(nameOrTargetOrConfig, key, descriptor);\r\n    };\r\n}\n\nvar observableLogger = LogManager.getLogger('aurelia-observable-decorator');\r\nvar _usePropertyType = false;\r\nvar observable = function observable(nameOrTargetOrConfig, key, descriptor) {\r\n    function deco(target, key, descriptor, config) {\r\n        var coerce = config === undefined || typeof config === 'string' ? undefined : config.coerce;\r\n        var propType;\r\n        var coerceFunction;\r\n        if (coerce) {\r\n            switch (typeof coerce) {\r\n                case 'string':\r\n                    coerceFunction = coerceFunctions[coerce];\r\n                    break;\r\n                case 'function':\r\n                    coerceFunction = coerce;\r\n                    break;\r\n            }\r\n            if (coerceFunction === undefined) {\r\n                observableLogger.warn(\"Invalid coerce instruction. Should be either one of \".concat(Object.keys(coerceFunctions), \" or a function.\"));\r\n            }\r\n        }\r\n        else if (_usePropertyType) {\r\n            propType = metadata.getOwn(metadata.propertyType, target, key);\r\n            if (propType) {\r\n                coerceFunction = coerceFunctions[coerceFunctionMap.get(propType)];\r\n                if (coerceFunction === undefined) {\r\n                    observableLogger.warn(\"Unable to find coerce function for type \".concat(propType.name, \".\"));\r\n                }\r\n            }\r\n        }\r\n        var isClassDecorator = key === undefined;\r\n        if (isClassDecorator) {\r\n            target = target.prototype;\r\n            key = typeof config === 'string' ? config : config.name;\r\n        }\r\n        var innerPropertyName = \"_\".concat(key);\r\n        var innerPropertyDescriptor = {\r\n            configurable: true,\r\n            enumerable: false,\r\n            writable: true\r\n        };\r\n        if (config && 'defaultValue' in config) {\r\n            var initValue = config.defaultValue;\r\n            innerPropertyDescriptor.value = coerceFunction === undefined ? initValue : coerceFunction(initValue);\r\n        }\r\n        var callbackName = (config && config.changeHandler) || \"\".concat(key, \"Changed\");\r\n        if (descriptor) {\r\n            if (typeof descriptor.initializer === 'function') {\r\n                var initValue = descriptor.initializer();\r\n                innerPropertyDescriptor.value = coerceFunction === undefined ? initValue : coerceFunction(initValue);\r\n            }\r\n        }\r\n        else {\r\n            descriptor = {};\r\n        }\r\n        if (!('enumerable' in descriptor)) {\r\n            descriptor.enumerable = true;\r\n        }\r\n        delete descriptor.value;\r\n        delete descriptor.writable;\r\n        delete descriptor.initializer;\r\n        Reflect.defineProperty(target, innerPropertyName, innerPropertyDescriptor);\r\n        descriptor.get = function () { return this[innerPropertyName]; };\r\n        descriptor.set = function (newValue) {\r\n            var oldValue = this[innerPropertyName];\r\n            var coercedValue = coerceFunction === undefined ? newValue : coerceFunction(newValue);\r\n            if (coercedValue === oldValue) {\r\n                return;\r\n            }\r\n            this[innerPropertyName] = coercedValue;\r\n            Reflect.defineProperty(this, innerPropertyName, { enumerable: false });\r\n            if (this[callbackName]) {\r\n                this[callbackName](coercedValue, oldValue, key);\r\n            }\r\n        };\r\n        descriptor.get.dependencies = [innerPropertyName];\r\n        if (isClassDecorator) {\r\n            Reflect.defineProperty(target, key, descriptor);\r\n        }\r\n        else {\r\n            return descriptor;\r\n        }\r\n    }\r\n    if (key === undefined) {\r\n        return function (t, k, d) { return deco(t, k, d, nameOrTargetOrConfig); };\r\n    }\r\n    return deco(nameOrTargetOrConfig, key, descriptor);\r\n};\r\n['string', 'number', 'boolean', 'date'].forEach(createTypedObservable);\r\nfunction usePropertyType(shouldUsePropType) {\r\n    _usePropertyType = !!shouldUsePropType;\r\n}\r\nfunction createTypedObservable(type) {\r\n    return observable[type] = function (nameOrTargetOrConfig, key, descriptor) {\r\n        if (nameOrTargetOrConfig === undefined) {\r\n            return observable({ coerce: type });\r\n        }\r\n        if (key === undefined) {\r\n            nameOrTargetOrConfig = typeof nameOrTargetOrConfig === 'string' ? { name: nameOrTargetOrConfig } : nameOrTargetOrConfig;\r\n            nameOrTargetOrConfig.coerce = type;\r\n            return observable(nameOrTargetOrConfig);\r\n        }\r\n        return observable({ coerce: type })(nameOrTargetOrConfig, key, descriptor);\r\n    };\r\n}\n\nexport { bindable, coerceFunctionMap, coerceFunctions, createTypedBindable, createTypedObservable, mapCoerceFunction, observable, usePropertyType$1 as usePropertyTypeForBindable, usePropertyType as usePropertyTypeForObservable };\n//# sourceMappingURL=index.js.map\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    /**\r\n     * Validate the binding when the binding's target element fires a DOM \"focusout\" event.\r\n     * Unlike \"blur\", this event bubbles.\r\n     */\r\n    validateTrigger[validateTrigger[\"focusout\"] = 4] = \"focusout\";\r\n    /**\r\n     * Validate the binding when the binding's target element fires a DOM \"focusout\" event or\r\n     * when it updates the model due to a change in the view.\r\n     */\r\n    validateTrigger[validateTrigger[\"changeOrFocusout\"] = 6] = \"changeOrFocusout\";\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// tslint:disable:no-bitwise\r\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        var event = (trigger & validateTrigger.blur) === validateTrigger.blur ? 'blur'\r\n            : (trigger & validateTrigger.focusout) === validateTrigger.focusout ? 'focusout'\r\n                : null;\r\n        var hasChangeTrigger = (trigger & validateTrigger.change) === validateTrigger.change;\r\n        binding.isDirty = !hasChangeTrigger;\r\n        // validatedOnce is used to control whether controller should validate upon user input\r\n        //\r\n        // always true when validation trigger doesn't include \"blur\" event (blur/focusout)\r\n        // else it will be set to true after (a) the first user input & loss of focus or (b) validation\r\n        binding.validatedOnce = hasChangeTrigger && event === null;\r\n        if (hasChangeTrigger) {\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.isDirty = true;\r\n                if (this.validatedOnce) {\r\n                    this.validationController.validateBinding(this);\r\n                }\r\n            };\r\n        }\r\n        if (event !== null) {\r\n            binding.focusLossHandler = function () {\r\n                _this.taskQueue.queueMicroTask(function () {\r\n                    if (binding.isDirty) {\r\n                        controller.validateBinding(binding);\r\n                        binding.validatedOnce = true;\r\n                    }\r\n                });\r\n            };\r\n            binding.validationTriggerEvent = event;\r\n            binding.validateTarget = target;\r\n            target.addEventListener(event, binding.focusLossHandler);\r\n            if (hasChangeTrigger) {\r\n                var propertyName_1 = getPropertyInfo(binding.sourceExpression, binding.source).propertyName;\r\n                binding.validationSubscription = controller.subscribe(function (event) {\r\n                    if (!binding.validatedOnce && event.type === 'validate') {\r\n                        binding.validatedOnce = event.errors.findIndex(function (e) { return e.propertyName === propertyName_1; }) > -1;\r\n                    }\r\n                });\r\n            }\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.focusLossHandler) {\r\n            binding.validateTarget.removeEventListener(binding.validationTriggerEvent, binding.focusLossHandler);\r\n            binding.focusLossHandler = null;\r\n            binding.validateTarget = null;\r\n        }\r\n        if (binding.validationSubscription) {\r\n            binding.validationSubscription.dispose();\r\n            binding.validationSubscription = null;\r\n        }\r\n        binding.validationController.unregisterBinding(binding);\r\n        binding.validationController = null;\r\n        binding.isDirty = null;\r\n        binding.validatedOnce = 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));\r\nvar ValidateOnFocusoutBindingBehavior = /** @class */ (function (_super) {\r\n    __extends(ValidateOnFocusoutBindingBehavior, _super);\r\n    function ValidateOnFocusoutBindingBehavior() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    ValidateOnFocusoutBindingBehavior.prototype.getValidateTrigger = function () {\r\n        return validateTrigger.focusout;\r\n    };\r\n    ValidateOnFocusoutBindingBehavior.inject = [TaskQueue];\r\n    ValidateOnFocusoutBindingBehavior = __decorate([\r\n        bindingBehavior('validateOnFocusout')\r\n    ], ValidateOnFocusoutBindingBehavior);\r\n    return ValidateOnFocusoutBindingBehavior;\r\n}(ValidateBindingBehaviorBase));\r\nvar ValidateOnChangeOrFocusoutBindingBehavior = /** @class */ (function (_super) {\r\n    __extends(ValidateOnChangeOrFocusoutBindingBehavior, _super);\r\n    function ValidateOnChangeOrFocusoutBindingBehavior() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    ValidateOnChangeOrFocusoutBindingBehavior.prototype.getValidateTrigger = function () {\r\n        return validateTrigger.changeOrFocusout;\r\n    };\r\n    ValidateOnChangeOrFocusoutBindingBehavior.inject = [TaskQueue];\r\n    ValidateOnChangeOrFocusoutBindingBehavior = __decorate([\r\n        bindingBehavior('validateOnChangeOrFocusout')\r\n    ], ValidateOnChangeOrFocusoutBindingBehavior);\r\n    return ValidateOnChangeOrFocusoutBindingBehavior;\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, ValidateOnFocusoutBindingBehavior, ValidateOnChangeBindingBehavior, ValidateOnChangeOrBlurBindingBehavior, ValidateOnChangeOrFocusoutBindingBehavior, ValidationErrorsCustomAttribute, ValidationRendererCustomAttribute);\r\n    }\r\n}\n\nexport { configure, GlobalValidationConfiguration, getTargetDOMElement, getPropertyInfo, PropertyAccessorParser, getAccessorExpression, ValidateBindingBehavior, ValidateManuallyBindingBehavior, ValidateOnBlurBindingBehavior, ValidateOnChangeBindingBehavior, ValidateOnChangeOrBlurBindingBehavior, ValidateOnFocusoutBindingBehavior, ValidateOnChangeOrFocusoutBindingBehavior, ValidateEvent, ValidateResult, validateTrigger, ValidationController, ValidationControllerFactory, ValidationErrorsCustomAttribute, ValidationRendererCustomAttribute, Validator, Rules, StandardValidator, validationMessages, ValidationMessageProvider, ValidationMessageParser, MessageExpressionValidator, FluentRuleCustomizer, FluentRules, FluentEnsure, ValidationRules };\n"],"sourceRoot":""}