{"version":3,"sources":["webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/index.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/initilization-context.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/condition.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/globalization.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/rule-invocation-type.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/entity-serializer.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/resource.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/entity.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/object-meta.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/calculated-property-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/string-format-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/condition-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/allowed-values-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/required-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/condition-target.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/functor.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/range-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/string-length-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/list-length-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/event-scope.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/helpers.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/property-path.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/condition-type-set.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/property.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/resource-en.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/observable-array.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/validation-rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/events.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/type.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/condition-type.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/format-error.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/format.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/property-chain.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/rule.js","webpack:///C:/a/2/s/Cognito.Web.Client/libs/model.js/lib/model.js"],"names":["__createBinding","this","Object","create","o","m","k","k2","undefined","defineProperty","enumerable","get","__exportStar","exports","p","hasOwnProperty","value","InitializationContext","newDocument","tasks","Set","waiting","prototype","execute","action","marker","Promise","add","result","delete","processWaitingQueue","wait","task","_this","then","resolve","size","configurable","canProcessQueue","length","shift","done","whenReady","callback","push","tryResolveValue","instance","property","serializer","resolveValue","Condition","format_error_1","condition_target_1","observable_array_1","type","message","target","source","properties","_message","targets","ObservableArray","_loop_1","path","targetInfos","each","entity","lastProperty","targetInfo","find","t","includes","apply","map","i","ConditionTarget","FormatError","ConditionType","conditionType","objectType","meta","baseType","conditions","sets","s","set","val","destroy","idx_1","indexOf","splice","idx","conditionTarget","clearCondition","condition","toString","extendStatics","__extends","d","b","setPrototypeOf","__proto__","Array","__","constructor","CultureInfo","formatNumber","_parseNumber","parseNumber","getNumberStyle","formatDate","parseDate","expandDateFormat","helpers_1","Res","StringBuilder","initialText","_parts","_value","_len","append","text","appendLine","clear","isEmpty","separator","parts","join","_super","displayMessage","call","name","Error","date$appendPreOrPostMatch","preMatch","strBuilder","quoteCount","escaped","il","c","charAt","dtf","format","len","expandYear","year","now","Date","era","getEra","curr","getEraYear","Calendar","TwoDigitYearMax","date","eras","start","ticks","getTime","l","sortable","getFullYear","Eras","parseDateExact","cultureInfo","trim","dateTimeFormat","parseInfo","cache","_parseRegExp","expFormat","replace","match","regexp","groups","index","tokenRegExp","exec","slice","lastIndex","DateSeparator","parseRegExp","regExp","getDateParseRegExp","RegExp","hourOffset","month","weekDay","hour","min","sec","msec","tzMinOffset","pmHour","j","jl","matchGroup","parseInt","_getMonthIndex","upperToken","toUpperCase","PMDesignator","AMDesignator","_getDayIndex","offsets","split","minOffset","startsWith","eraName","toLowerCase","defaultYear","convert","fromGregorian","toGregorian","setFullYear","getDate","getDay","setHours","adjustedMin","getMinutes","getTimezoneOffset","getHours","addLeadingZero","num","addLeadingZeros","parseFloat","exponent","intAndFraction","numFormat","numberFormat","signInfo","parseNumberNegativePattern","NumberNegativePattern","sign","integer","fraction","exponentPos","substr","decimalPos","NumberDecimalSeparator","NumberGroupSeparator","altNumGroupSeparator","expSignInfo","Number","NaN","numberFormatInfo","numberNegativePattern","neg","NegativeSign","pos","PositiveSign","endsWith","zeroPad","str","count","left","expandNumber","number","precision","groupSizes","sep","decimalChar","curSize","curGroupIndex","factor","Math","pow","rounded","round","isFinite","numberString","right","stringIndex","ret","toUpper","toUpperArray","arr","formats","formatsSpecified","_getDateTimeFormats","FullDateTimePattern","eraDate","toLocaleString","foundDay","checkedDay","converted","dayPartRegExp","hasDay","test","ar","getDatePart","part","getMonth","DayNames","AbbreviatedDayNames","MonthGenitiveNames","MonthNames","AbbreviatedMonthGenitiveNames","AbbreviatedMonthNames","getSeconds","getMilliseconds","floor","abs","style","obj","substring","resultvalue","CurrencySymbol","CurrencyDecimalDigits","PercentSymbol","isNaN","nf","pattern","CurrencyNegativePattern","CurrencyPositivePattern","CurrencyGroupSizes","CurrencyGroupSeparator","CurrencyDecimalSeparator","NumberDecimalDigits","NumberGroupSizes","PercentNegativePattern","PercentPositivePattern","PercentDecimalDigits","PercentGroupSizes","PercentGroupSeparator","PercentDecimalSeparator","regex","invariantCultureInfo","NaNSymbol","NegativeInfinitySymbol","PositiveInfinitySymbol","PerMilleSymbol","NativeDigits","DigitSubstitution","MinSupportedDateTime","MaxSupportedDateTime","AlgorithmType","CalendarType","FirstDayOfWeek","CalendarWeekRule","LongDatePattern","LongTimePattern","MonthDayPattern","RFC1123Pattern","ShortDatePattern","ShortTimePattern","SortableDateTimePattern","TimeSeparator","UniversalSortableDateTimePattern","YearMonthPattern","ShortestDayNames","NativeCalendarName","parse","setup","CurrentCulture","defaultCulture","_defaultCulture","cultureInfoObject","clone","_dateTimeFormats","abbr","upperMonths","_upperAbbrMonths","_upperMonths","upperMonthsGenitive","_upperAbbrMonthsGenitive","_upperMonthsGenitive","upperDays","_upperAbbrDays","_upperDays","InvariantCulture","RuleInvocationType","EntitySerializer","DefaultSerializationSettings","PropertyConverter","IgnoreProperty","type_1","key","shouldConvert","context","prop","serialize","settings","isEntityType","propertyType","isList","isArray","ent","deserialize","force","useAliases","_propertyConverters","_propertyInjectors","Map","_propertyAliases","_valueResolvers","registerPropertyConverter","converter","unshift","registerPropertyInjector","injector","injectors","registerPropertyAlias","alias","propertyName","aliases","registerValueResolver","resolver","getInjectorsOrDefault","concat","fullName","getPropertyInjectors","serializePropertyValue","converters","filter","_i","converters_1","res","defaultPropertyConverter","getPropertyAliases","containingType","flatMap","inject","isCalculated","isConstant","forEach","pair","data","constructEntity","resolveEntity","state","id","identifier","ChildEntity_1","convertFromString","assign","resolveProperty","propName","getProperty","_a","resourceExists","getResource","defineResources","setDefaultLocale","Resources","mapContainsResource","resources","locale","defaultLocale","globalResources","merge","arg2","arg3","customResources","arguments","__spreadArrays","r","a","isEntity","Entity","events_1","initilization_context_1","object_meta_1","property_1","entity_serializer_1","ctorDepth","writable","Event","isNew_1","assertValidId","newId","isNewDocument","ObjectMeta","register","init","initialized","updateWithContext","initNew","publish","initExisting","getSortedPropertyData","entries","sort","initializedProps","this_1","valueResolution","asyncState","initProp","_b","_c","_d","_e","has","value_1","Property$init","hadContext","_context","ready","update","createOrUpdate","getIdFromState","isNew","Ctor","jstype","wasNew_1","context_1","markPersistedWhenIdAssigned","markPersisted","_loop_2","this_2","setProp","currentValue","console","warn","listItem","Property$pendingInit","newState","Property$setter","e","formatEval","formatter","model","getFormat","visited","_persist","item","condition_type_1","getCondition","setCondition","isAllowed","codes","code","PermissionConditionType","CalculatedPropertyRule","rule_1","rule_invocation_type_1","rootType","options","calculateFn","defaultIfError","returns","calculate","isDefaultValue","rules","invocationTypes","PropertyGet","subscribe","args","__fields__","_calculateFn","String","calculateExpr","calculateCompiledFn","Function","newValue","newList_1","isInited","curList","noChanges","batchUpdate","array","updateArray","calculated","Rule","StringFormatRule","message_1","description","expression_1","expression","reformat_1","reformat","isValid","ValidationRule","ConditionRule","onInit","assert","Rule$ensureConditionType","category","when","AllowedValuesRule","validation_rule_1","property_chain_1","Property","PropertyChain","sourcePath_1","onChangeOf","ignoreValidation","allowed","every","preventInvalidValues","values","RequiredRule","messageFn_1","isValidFn_1","FunctorItem$new","fn","once","Functor$add","_funcs","Functor$remove","Functor$isEmpty","some","applied","Functor$clear","Functor$create","funcs","f","returnsArray","returnValue","remove","RangeRule","model_1","normalize","range","max","hasMin","hasMax","Property$format","StringLengthRule","ListLengthRule","EventScope","EVENT_SCOPE_DEFAULT_SETTINGS","maxExitingTransferCount","maxDepth","__lastEventScopeId","parent","isActive","current","onError","_uid","_depth","_onExit","perform","scope","isDisposing","dispose","abort","errorEvent","error","isDefaultPrevented","onExit","handler","exitSubscriptions","getEventSubscriptions","receiveExitEventSubscribers","_exitEventVersion","subscriptions","maxNesting","sub","getGlobalObject","window","global","getValue","getter","getTypeName","mixin","toTitleCase","randomText","randomInt","isType","getDefaultValue","isNumber","getConstructorName","parseFunctionName","replaceTokens","evalPath","navigateAttribute","ensureNamespace","parentNamespace","nsTokens","token","attr","thisPtr","nullValue","undefinedValue","steps","template","params","fnRegex","fnMatch","typeNameExpr","rand","random","ctor","Boolean","includeLetters","includeDigits","charCode","fromCharCode","input","lowers","uppers","txt","obj1","objs","arg","event","func","isExecuted","isOnce","methods","reduce","ownProps","keys","resArray","ConditionTypeSet","allConditionTypeSets","types","all","__assign","n","Property$generateOwnProperty","Property$generatePrototypeProperty","Property$generateStaticProperty","Property$generateShortcuts","evaluateLabel","getLabelSourceType","getLabelFormat","isPropertyOptions","isPropertyBooleanFunction","isPropertyBooleanFunctionAndOptions","isPropertyValueFunction","format_1","calculated_property_rule_1","string_format_rule_1","allowed_values_rule_1","required_rule_1","range_rule_1","string_length_rule_1","list_length_rule_1","isIdentifier","required","Property$getter","additionalArgs","setter","skipTypeCheck","Property$makeSetter","changed","accessed","extend","constant","Format","hasTokens","label","helptext","getLastTarget","_defaultValue","targetType","resolveDependsOn","rule","dependsOn","getPaths","prepare","autogeneratePropertyLabels","labelSource","getPath","format_2","function","getOptions_1","initFn","initializer","default","isValue","isValueArray","defaultConstant_1","defaultOptionTypeName","propertyTypeName","defaultOptions_1","defaultFn_1","allowedValues","originalAllowedValues_1","allowedValuesOptions_1","min_1","max_1","minConstant_1","maxConstant_1","min_2","max_2","minConstant_2","maxConstant_2","requiredFn_1","requiredMessage_1","requiredDependsOn_1","requiredOptions","errorOptions","errorFn","resource","errorDependsOn","ErrorConditionType","equals","canSetValue","valType","valObjectType","child","childType","itemObjectType","check","labelIsFormat","labelSourceType","pendingInit","__pendingInit__","changes","eventArgs","collectionChanged","listChanged","Property$subArrayEvents","ensureObservable","Property$ensureInited","setPendingInit","defaultValue","Property$getInitialValue","old","oldValue","valueOf","Property$shouldSetValue","changeObjectId","afterPropertySet","Property$setValue","labelFormat","labelFormatInstance","overwrite","shortcutName","ArrayObserver","ObservableArray$unshift","ObservableArray$splice","ObservableArray$sort","ObservableArray$shift","ObservableArray$reverse","ObservableArray$push","ObservableArray$pop","ObservableArray$fill","ObservableArray$copyWithin","ObservableArray$batchUpdate","ObservableArray$overrideNativeMethods","ObservableArrayImplementation","ArrayChangeType","isObservableArray","__aob__","items","bind","copyWithin","end","fill","pop","elements","reverse","compareFunction","deleteCount","startQueueingChanges","stopQueueingChanges","_isQueuingChanges","raiseEvents","startIndex","endIndex","originalLength","removed","removedIndex","newLength","reorder","changeEvents","_queuedChanges","callSplice","removeCount","addItems","addItemsArgs","pointer","srcSeek","tgtSeek","condition_rule_1","labelSourceType_1","paths","labelTokenProp","messageFunction_1","messageTemplate_1","messageFunction_2","createEventObject","EventObjectImpl","functor_1","preventDefault","eventObject","subscriptionChanged","thisObject","subscribeOne","hasSubscribers","functorItems","unsubscribe","Type$generateConstructor","Type$generateMethod","isValueType","Type","Type$newIdPrefix","entity_1","useGlobalObject","derivedTypes","_identifier","createIfNotExists","existing","createSync","lastId","_lastId","nextId","__pool__","__known__","createOwnProperties","__properties__","entityRegistered","oldId","oldKey","newKey","exactTypeOnly","known","list","_chains","parent_1","stack","seg","propertiesObject","addRule","optionsOrFunction","hasModelProperty","isSubclassOf","name_1","member","dependsOn_1","typeName","lastIndexOf","getJsType","property_2","valueType","disableConstruction","nameTokens","namespaceObj","$namespace","namespacePrefix","globalObj","BaseConstructor","finalName","ctorFactory","from","namespaceKey","globalKey","WarningConditionType","condition_1","allConditionTypes","invalidValue","messageTemplate","createCondition","createFormat","ModelFormat","CustomFormat","getFormatTemplateParser","globalization_1","metaPathParser","specifier","nullString","undefinedString","convertToString","convertBack","fromTemplate","customConvert","customConvertBack","err","compile","enqueueWhileProcessing","tokens","formatTemplateParser","propertyPath","propertyDefaultFormat","isMetaPath","allowFormat","prefix","convertTokens","$culture","timeFormat","startDate","isCurrencyFormat","isPercentageFormat","isIntegerFormat","trueFormat_1","falseFormat_1","nullFormat_1","isFormatMatch_1","formatValue","log","previousStepType","currentType","step","parsed","stepAccessed","props","priorProp","testConnection","stepChanged","toPropertyArray","lastProp","isLastProperty","canSkipRemainingProps","enableCallback","targetValue","fromRoot","toObj","viaProperty","connected","lastTarget","Rule$customRuleIndex","predicates","returnValues","onInitNew","onInitExisting","_execute","eventScope","_registered","InitNew","InitExisting","PropertyChanged","executeRule","predicate","canExecuteRule","pendingInvocation","__pendingInvocation__","indexOfRule","ruleName","typeOrProp","DesiredConditionType","generatedCode","counter","ModelSettings","createModel","Model","resource_1","event_scope_1","valueTypes","string","boolean","config","_readyProcessing","eventScopeSettings","$resources","$locale","typesToCreate","typesToInitialize","typeNameIdx","typeNamespace","typeNamespaceIdx","typeOptions","$extends","$format","typesToInitialize_1","_readyCallbacks","_formats","modelType","maxExitingEventScopeTransferCount","maxEventScopeDepth","dateFormat","newDate","setMonth","setDate"],"mappings":"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","file":"159.b427de4969cb1ec05550.js","sourcesContent":["\"use strict\";\r\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}));\r\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n// Core model\r\n__exportStar(require(\"./model\"), exports);\r\n__exportStar(require(\"./type\"), exports);\r\n__exportStar(require(\"./property\"), exports);\r\n__exportStar(require(\"./property-chain\"), exports);\r\n__exportStar(require(\"./property-path\"), exports);\r\n__exportStar(require(\"./entity\"), exports);\r\n__exportStar(require(\"./object-meta\"), exports);\r\n__exportStar(require(\"./format\"), exports);\r\n__exportStar(require(\"./observable-array\"), exports);\r\n// Conditions, etc.\r\n__exportStar(require(\"./condition-target\"), exports);\r\n__exportStar(require(\"./condition-type-set\"), exports);\r\n__exportStar(require(\"./condition-type\"), exports);\r\n__exportStar(require(\"./condition\"), exports);\r\n__exportStar(require(\"./format-error\"), exports);\r\n__exportStar(require(\"./string-format-rule\"), exports);\r\n// Rules engine and various rule types\r\n__exportStar(require(\"./rule\"), exports);\r\n__exportStar(require(\"./rule-invocation-type\"), exports);\r\n__exportStar(require(\"./condition-rule\"), exports);\r\n__exportStar(require(\"./validation-rule\"), exports);\r\n__exportStar(require(\"./allowed-values-rule\"), exports);\r\n__exportStar(require(\"./calculated-property-rule\"), exports);\r\n__exportStar(require(\"./required-rule\"), exports);\r\n// Serialization\r\n__exportStar(require(\"./entity-serializer\"), exports);\r\n__exportStar(require(\"./initilization-context\"), exports);\r\n// Globalization & Localization\r\n__exportStar(require(\"./globalization\"), exports);\r\n__exportStar(require(\"./resource\"), exports);\r\n// Internal helpers, etc.\r\n// export * from \"./event-scope\";\r\n// export * from \"./events\";\r\n// export * from \"./functor\";\r\n// export * from \"./helpers\";\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.InitializationContext = void 0;\r\nvar InitializationContext = /** @class */ (function () {\r\n    function InitializationContext(newDocument) {\r\n        this.newDocument = false;\r\n        this.tasks = new Set();\r\n        this.waiting = [];\r\n        this.newDocument = newDocument;\r\n    }\r\n    /**\r\n     * Prevents any waiting callbacks from being executed before the specified action completes.\r\n     * @returns The return value of `action`.\r\n     */\r\n    InitializationContext.prototype.execute = function (action) {\r\n        // create a promise which will never actually be resolved, but it will prevent the waiting queue from being processed\r\n        var marker = new Promise(function () { });\r\n        this.tasks.add(marker);\r\n        var result = action();\r\n        this.tasks.delete(marker);\r\n        this.processWaitingQueue();\r\n        return result;\r\n    };\r\n    InitializationContext.prototype.wait = function (task) {\r\n        var _this = this;\r\n        this.tasks.add(task);\r\n        task.then(function () {\r\n            // process the queue asynchronously to allow additional tasks to be queued as a result of this one\r\n            Promise.resolve().then(function () {\r\n                _this.tasks.delete(task);\r\n                _this.processWaitingQueue();\r\n            });\r\n        });\r\n    };\r\n    Object.defineProperty(InitializationContext.prototype, \"canProcessQueue\", {\r\n        get: function () {\r\n            return this.tasks.size === 0;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    InitializationContext.prototype.processWaitingQueue = function () {\r\n        if (this.canProcessQueue) {\r\n            while (this.waiting.length > 0 && this.canProcessQueue) {\r\n                var done = this.waiting.shift();\r\n                done();\r\n            }\r\n        }\r\n    };\r\n    InitializationContext.prototype.whenReady = function (callback) {\r\n        if (this.canProcessQueue)\r\n            callback();\r\n        else\r\n            this.waiting.push(callback);\r\n    };\r\n    InitializationContext.prototype.tryResolveValue = function (instance, property, value) {\r\n        var task = instance.serializer.resolveValue(instance, property, value);\r\n        if (task)\r\n            this.wait(task);\r\n        return task;\r\n    };\r\n    Object.defineProperty(InitializationContext.prototype, \"isNewDocument\", {\r\n        get: function () {\r\n            return this.newDocument;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(InitializationContext.prototype, \"ready\", {\r\n        get: function () {\r\n            var _this = this;\r\n            return new Promise(function (resolve) { return _this.whenReady(resolve); });\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    return InitializationContext;\r\n}());\r\nexports.InitializationContext = InitializationContext;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.Condition = void 0;\r\nvar format_error_1 = require(\"./format-error\");\r\nvar condition_target_1 = require(\"./condition-target\");\r\nvar observable_array_1 = require(\"./observable-array\");\r\nvar Condition = /** @class */ (function () {\r\n    /**\r\n        * Creates a condition of a specific type associated with one or more entities in a model.\r\n        * @param type The type of condition, which usually is an instance of a subclass like Error, Warning or Permission.\r\n        * @param message The optional message to use for the condition, which will default to the condition type message if not specified.\r\n        * @param target The root target entity the condition is associated with.\r\n        * @param properties The set of property paths specifying which properties and entities the condition should be attached to.\r\n        */\r\n    function Condition(type, message, target, source, properties) {\r\n        var _this = this;\r\n        if (properties === void 0) { properties = []; }\r\n        this.type = type;\r\n        this._message = message || (type ? type.message : undefined);\r\n        var targets = this.targets = observable_array_1.ObservableArray.create();\r\n        this.source = source;\r\n        // create targets if a root was specified\r\n        if (target) {\r\n            var _loop_1 = function (p) {\r\n                var path = properties[p];\r\n                var targetInfos = [];\r\n                // build list of objects containing ConditionTarget information\r\n                // we don't want to construct ConditionTargets as we're processing the path because we may not have gathered all targeted properties,\r\n                // and the constructor triggers change on the entity meta's conditions list, which should be in a correct state before publishing the event\r\n                path.each(target, function (entity, property) {\r\n                    if (property !== path.lastProperty)\r\n                        return;\r\n                    // see if a target already exists for the current instance\r\n                    var targetInfo = targetInfos.find(function (t) { return t.entity === entity; });\r\n                    // create the condition target if it does not already exist\r\n                    if (!targetInfo) {\r\n                        targetInfo = { entity: entity, properties: [property] };\r\n                        targetInfos.push(targetInfo);\r\n                    }\r\n                    // otherwise, just ensure it references the current step\r\n                    else if (!targetInfo.properties.includes(property))\r\n                        targetInfo.properties.push(property);\r\n                });\r\n                // construct the ConditionTargets here now that we've gathered all information\r\n                targets.push.apply(targets, targetInfos.map(function (i) { return new condition_target_1.ConditionTarget(_this, i.entity, i.properties); }));\r\n            };\r\n            // process each property path to build up the condition sources\r\n            for (var p = properties.length - 1; p >= 0; p--) {\r\n                _loop_1(p);\r\n            }\r\n        }\r\n        // raise events for the new condition\r\n        if (type !== format_error_1.FormatError.ConditionType) {\r\n            var conditionType = type;\r\n            // raise events on condition targets\r\n            for (var t = targets.length - 1; t >= 0; t--) {\r\n                var conditionTarget = targets[t];\r\n                // type events\r\n                for (var objectType = conditionTarget.target.meta.type; objectType != null; objectType = objectType.baseType) {\r\n                    // (objectType.conditionsChanged as Event<Type, ConditionTargetsChangedEventArgs>).publish(objectType, { conditionTarget: conditionTarget, add: true });\r\n                }\r\n            }\r\n            // Add the condition to the corresponding condition type\r\n            conditionType.conditions.push(this);\r\n            // Add the condition to relevant condition type sets\r\n            if (this.type.sets) {\r\n                for (var s = this.type.sets.length - 1; s >= 0; s--) {\r\n                    this.type.sets[s].conditions.push(this);\r\n                }\r\n            }\r\n        }\r\n    }\r\n    Object.defineProperty(Condition.prototype, \"message\", {\r\n        get: function () {\r\n            if (typeof (this._message) === \"string\")\r\n                return this._message;\r\n            else\r\n                return this._message();\r\n        },\r\n        set: function (val) {\r\n            this._message = val;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Condition.prototype.destroy = function () {\r\n        /// <summary>Removes the condition targets from all target instances and raises condition change events.</summary>\r\n        // raise events on condition type sets\r\n        if (this.type.sets) {\r\n            for (var s = this.type.sets.length - 1; s >= 0; s--) {\r\n                var set = this.type.sets[s];\r\n                var idx_1 = set.conditions.indexOf(this);\r\n                if (idx_1 >= 0) {\r\n                    set.conditions.splice(idx_1, 1);\r\n                }\r\n            }\r\n        }\r\n        // raise events on condition types\r\n        var idx = this.type.conditions.indexOf(this);\r\n        if (idx >= 0) {\r\n            this.type.conditions.splice(idx, 1);\r\n        }\r\n        for (var t = this.targets.length - 1; t >= 0; t--) {\r\n            var conditionTarget = this.targets[t];\r\n            var objectMeta = conditionTarget.target.meta;\r\n            objectMeta.clearCondition(conditionTarget.condition.type);\r\n            // type events\r\n            for (var objectType = conditionTarget.target.meta.type; objectType != null; objectType = objectType.baseType) {\r\n                // (objectType.conditionsChanged as Event<Type, ConditionTargetsChangedEventArgs>).publish(objectType, { conditionTarget: conditionTarget, add: false, remove: true });\r\n            }\r\n        }\r\n        // remove references to all condition targets\r\n        this.targets.splice(0);\r\n    };\r\n    Condition.prototype.toString = function () {\r\n        return this.message;\r\n    };\r\n    return Condition;\r\n}());\r\nexports.Condition = Condition;\r\n","\"use strict\";\r\n/*!\r\n * Based on portions of MicrosoftAjax.debug.js (v3.0.31106.1) from System.Web.Extensions.\r\n */\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.CultureInfo = exports.formatNumber = exports._parseNumber = exports.parseNumber = exports.getNumberStyle = exports.formatDate = exports.parseDate = exports.expandDateFormat = void 0;\r\nvar helpers_1 = require(\"./helpers\");\r\n/**\r\n * Internally used resource strings\r\n * TODO: Make these localizable resources?\r\n */\r\nvar Res = {\r\n    \"format\": \"One of the identified items was in an invalid format.\",\r\n    \"formatBadFormatSpecifier\": \"Format specifier was invalid.\",\r\n    \"formatInvalidString\": \"Input string was not in a correct format.\"\r\n};\r\n/**\r\n * A class for building a string programmatically\r\n */\r\nvar StringBuilder = /** @class */ (function () {\r\n    function StringBuilder(initialText) {\r\n        this._parts = (typeof (initialText) !== \"undefined\" && initialText !== null && initialText !== \"\") ? [initialText.toString()] : [];\r\n        this._value = {};\r\n        this._len = 0;\r\n    }\r\n    StringBuilder.prototype.append = function (text) {\r\n        this._parts.push(text);\r\n        return this;\r\n    };\r\n    StringBuilder.prototype.appendLine = function (text) {\r\n        this._parts.push(((typeof (text) === \"undefined\") || (text === null) || (text === \"\")) ? \"\\r\\n\" : (text + \"\\r\\n\"));\r\n        return this;\r\n    };\r\n    StringBuilder.prototype.clear = function () {\r\n        this._parts = [];\r\n        this._value = {};\r\n        this._len = 0;\r\n    };\r\n    StringBuilder.prototype.isEmpty = function () {\r\n        if (this._parts.length === 0)\r\n            return true;\r\n        return this.toString() === \"\";\r\n    };\r\n    StringBuilder.prototype.toString = function (separator) {\r\n        separator = separator || \"\";\r\n        var parts = this._parts;\r\n        if (this._len !== parts.length) {\r\n            this._value = {};\r\n            this._len = parts.length;\r\n        }\r\n        var val = this._value;\r\n        if (typeof (val[separator]) === \"undefined\") {\r\n            if (separator !== \"\") {\r\n                for (var i = 0; i < parts.length;) {\r\n                    if ((typeof (parts[i]) === \"undefined\") || (parts[i] === \"\") || (parts[i] === null)) {\r\n                        parts.splice(i, 1);\r\n                    }\r\n                    else {\r\n                        i++;\r\n                    }\r\n                }\r\n            }\r\n            val[separator] = this._parts.join(separator);\r\n        }\r\n        return val[separator];\r\n    };\r\n    return StringBuilder;\r\n}());\r\n/**\r\n * Subclass of error for invalid format strings\r\n */\r\nvar FormatError = /** @class */ (function (_super) {\r\n    __extends(FormatError, _super);\r\n    function FormatError(message) {\r\n        var _this = this;\r\n        var displayMessage = \"Sys.FormatException: \" + (message || Res.format);\r\n        _this = _super.call(this, displayMessage) || this;\r\n        _this.name = \"Sys.FormatException\";\r\n        return _this;\r\n    }\r\n    return FormatError;\r\n}(Error));\r\nfunction date$appendPreOrPostMatch(preMatch, strBuilder) {\r\n    var quoteCount = 0;\r\n    var escaped = false;\r\n    for (var i = 0, il = preMatch.length; i < il; i++) {\r\n        var c = preMatch.charAt(i);\r\n        switch (c) {\r\n            case \"'\":\r\n                if (escaped)\r\n                    strBuilder.append(\"'\");\r\n                else\r\n                    quoteCount++;\r\n                escaped = false;\r\n                break;\r\n            case \"\\\\\":\r\n                if (escaped)\r\n                    strBuilder.append(\"\\\\\");\r\n                escaped = !escaped;\r\n                break;\r\n            default:\r\n                strBuilder.append(c);\r\n                escaped = false;\r\n                break;\r\n        }\r\n    }\r\n    return quoteCount;\r\n}\r\nfunction expandDateFormat(dtf, format) {\r\n    if (!format) {\r\n        format = \"F\";\r\n    }\r\n    var len = format.length;\r\n    if (len === 1) {\r\n        switch (format) {\r\n            case \"d\":\r\n                return dtf[\"ShortDatePattern\"];\r\n            case \"D\":\r\n                return dtf[\"LongDatePattern\"];\r\n            case \"t\":\r\n                return dtf[\"ShortTimePattern\"];\r\n            case \"T\":\r\n                return dtf[\"LongTimePattern\"];\r\n            case \"f\":\r\n                return dtf[\"LongDatePattern\"] + \" \" + dtf[\"ShortTimePattern\"];\r\n            case \"F\":\r\n                return dtf[\"FullDateTimePattern\"];\r\n            case \"g\":\r\n                return dtf[\"ShortDatePattern\"] + \" \" + dtf[\"ShortTimePattern\"];\r\n            case \"G\":\r\n                return dtf[\"ShortDatePattern\"] + \" \" + dtf[\"LongTimePattern\"];\r\n            case \"M\":\r\n            case \"m\":\r\n                return dtf[\"MonthDayPattern\"];\r\n            case \"s\":\r\n                return dtf[\"SortableDateTimePattern\"];\r\n            case \"Y\":\r\n            case \"y\":\r\n                return dtf[\"YearMonthPattern\"];\r\n            default:\r\n                throw new FormatError(Res.formatInvalidString);\r\n        }\r\n    }\r\n    else if ((len === 2) && (format.charAt(0) === \"%\")) {\r\n        format = format.charAt(1);\r\n    }\r\n    return format;\r\n}\r\nexports.expandDateFormat = expandDateFormat;\r\nfunction expandYear(dtf, year) {\r\n    var now = new Date();\r\n    var era = getEra(now);\r\n    if (year < 100) {\r\n        var curr = getEraYear(now, dtf, era);\r\n        year += curr - (curr % 100);\r\n        if (year > dtf.Calendar.TwoDigitYearMax) {\r\n            year -= 100;\r\n        }\r\n    }\r\n    return year;\r\n}\r\nfunction getEra(date, eras) {\r\n    if (!eras)\r\n        return 0;\r\n    var start;\r\n    var ticks = date.getTime();\r\n    for (var i = 0, l = eras.length; i < l; i += 4) {\r\n        start = eras[i + 2];\r\n        if ((start === null) || (ticks >= start)) {\r\n            return i;\r\n        }\r\n    }\r\n    return 0;\r\n}\r\nfunction getEraYear(date, dtf, era, sortable) {\r\n    var year = date.getFullYear();\r\n    if (!sortable && dtf.Eras) {\r\n        year -= dtf.Eras[era + 3];\r\n    }\r\n    return year;\r\n}\r\nfunction getDateParseRegExp(dtf, format) {\r\n    // Get or initialize the regex cache\r\n    var cache;\r\n    if (!(cache = dtf._parseRegExp)) {\r\n        cache = dtf._parseRegExp = {};\r\n    }\r\n    // Return a cached format if available\r\n    if (cache[format]) {\r\n        return cache[format];\r\n    }\r\n    var expFormat = expandDateFormat(dtf, format);\r\n    // eslint-disable-next-line no-useless-escape\r\n    expFormat = expFormat.replace(/([\\^\\$\\.\\*\\+\\?\\|\\[\\]\\(\\)\\{\\}])/g, \"\\\\\\\\$1\");\r\n    var regexp = new StringBuilder(\"^\");\r\n    var groups = [];\r\n    var index = 0;\r\n    var quoteCount = 0;\r\n    var tokenRegExp = getDateTokenRegExp();\r\n    var match;\r\n    while ((match = tokenRegExp.exec(expFormat)) !== null) {\r\n        var preMatch = expFormat.slice(index, match.index);\r\n        index = tokenRegExp.lastIndex;\r\n        quoteCount += date$appendPreOrPostMatch(preMatch, regexp);\r\n        if ((quoteCount % 2) === 1) {\r\n            regexp.append(match[0]);\r\n            continue;\r\n        }\r\n        switch (match[0]) {\r\n            case \"dddd\":\r\n            case \"ddd\":\r\n            case \"MMMM\":\r\n            case \"MMM\":\r\n            case \"gg\":\r\n            case \"g\":\r\n                regexp.append(\"(\\\\D+)\");\r\n                break;\r\n            case \"tt\":\r\n            case \"t\":\r\n                regexp.append(\"(\\\\D*)\");\r\n                break;\r\n            case \"yyyy\":\r\n                regexp.append(\"(\\\\d{4})\");\r\n                break;\r\n            case \"fff\":\r\n                regexp.append(\"(\\\\d{3})\");\r\n                break;\r\n            case \"ff\":\r\n                regexp.append(\"(\\\\d{2})\");\r\n                break;\r\n            case \"f\":\r\n                regexp.append(\"(\\\\d)\");\r\n                break;\r\n            case \"dd\":\r\n            case \"d\":\r\n            case \"MM\":\r\n            case \"M\":\r\n            case \"yy\":\r\n            case \"y\":\r\n            case \"HH\":\r\n            case \"H\":\r\n            case \"hh\":\r\n            case \"h\":\r\n            case \"mm\":\r\n            case \"m\":\r\n            case \"ss\":\r\n            case \"s\":\r\n                regexp.append(\"(\\\\d\\\\d?)\");\r\n                break;\r\n            case \"zzz\":\r\n                regexp.append(\"([+-]?\\\\d\\\\d?:\\\\d{2})\");\r\n                break;\r\n            case \"zz\":\r\n            case \"z\":\r\n                regexp.append(\"([+-]?\\\\d\\\\d?)\");\r\n                break;\r\n            case \"/\":\r\n                regexp.append(\"(\\\\\" + dtf.DateSeparator + \")\");\r\n                break;\r\n        }\r\n        groups.push(match[0]);\r\n    }\r\n    date$appendPreOrPostMatch(expFormat.slice(index), regexp);\r\n    regexp.append(\"$\");\r\n    var regexpStr = regexp.toString().replace(/\\s+/g, \"\\\\s+\");\r\n    var parseRegExp = { regExp: regexpStr, groups: groups };\r\n    cache[format] = parseRegExp;\r\n    return parseRegExp;\r\n}\r\n;\r\nfunction getDateTokenRegExp() {\r\n    return /\\/|dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z|gg|g/g;\r\n}\r\n/**\r\n * Parses the given text as a date\r\n * @param value The text to parse\r\n * @param cultureInfo The culture\r\n * @param formats An optional list of formats to use\r\n */\r\nfunction parseDate(value, cultureInfo, formats) {\r\n    var formatsSpecified = false;\r\n    // Try to parse using format strings if specified\r\n    if (formats) {\r\n        for (var i = 0; i < formats.length; i++) {\r\n            var format = formats[i];\r\n            if (format) {\r\n                formatsSpecified = true;\r\n                var date = parseDateExact(value, format, cultureInfo);\r\n                if (date)\r\n                    return date;\r\n            }\r\n        }\r\n    }\r\n    // Use the culture's date/time formats if formats were not specified\r\n    if (!formatsSpecified) {\r\n        formats = cultureInfo._getDateTimeFormats();\r\n        for (var i = 0; i < formats.length; i++) {\r\n            var date = parseDateExact(value, formats[i], cultureInfo);\r\n            if (date)\r\n                return date;\r\n        }\r\n    }\r\n    return null;\r\n}\r\nexports.parseDate = parseDate;\r\nfunction parseDateExact(value, format, cultureInfo) {\r\n    value = value.trim();\r\n    var dtf = cultureInfo.dateTimeFormat;\r\n    var parseInfo = getDateParseRegExp(dtf, format);\r\n    var match = new RegExp(parseInfo.regExp).exec(value);\r\n    if (match === null)\r\n        return null;\r\n    var groups = parseInfo.groups;\r\n    var era = null;\r\n    var year = null;\r\n    var month = null;\r\n    var date = null;\r\n    var weekDay = null;\r\n    var hour = 0;\r\n    var hourOffset;\r\n    var min = 0;\r\n    var sec = 0;\r\n    var msec = 0;\r\n    var tzMinOffset = null;\r\n    var pmHour = false;\r\n    for (var j = 0, jl = groups.length; j < jl; j++) {\r\n        var matchGroup = match[j + 1];\r\n        if (matchGroup) {\r\n            switch (groups[j]) {\r\n                case \"dd\":\r\n                case \"d\":\r\n                    date = parseInt(matchGroup, 10);\r\n                    if ((date < 1) || (date > 31))\r\n                        return null;\r\n                    break;\r\n                case \"MMMM\":\r\n                    month = cultureInfo._getMonthIndex(matchGroup);\r\n                    if ((month < 0) || (month > 11))\r\n                        return null;\r\n                    break;\r\n                case \"MMM\":\r\n                    month = cultureInfo._getMonthIndex(matchGroup, true);\r\n                    if ((month < 0) || (month > 11))\r\n                        return null;\r\n                    break;\r\n                case \"M\":\r\n                case \"MM\":\r\n                    month = parseInt(matchGroup, 10) - 1;\r\n                    if ((month < 0) || (month > 11))\r\n                        return null;\r\n                    break;\r\n                case \"y\":\r\n                case \"yy\":\r\n                    year = expandYear(dtf, parseInt(matchGroup, 10));\r\n                    if ((year < 0) || (year > 9999))\r\n                        return null;\r\n                    break;\r\n                case \"yyyy\":\r\n                    year = parseInt(matchGroup, 10);\r\n                    if ((year < 0) || (year > 9999))\r\n                        return null;\r\n                    break;\r\n                case \"h\":\r\n                case \"hh\":\r\n                    hour = parseInt(matchGroup, 10);\r\n                    if (hour === 12)\r\n                        hour = 0;\r\n                    if ((hour < 0) || (hour > 11))\r\n                        return null;\r\n                    break;\r\n                case \"H\":\r\n                case \"HH\":\r\n                    hour = parseInt(matchGroup, 10);\r\n                    if ((hour < 0) || (hour > 23))\r\n                        return null;\r\n                    break;\r\n                case \"m\":\r\n                case \"mm\":\r\n                    min = parseInt(matchGroup, 10);\r\n                    if ((min < 0) || (min > 59))\r\n                        return null;\r\n                    break;\r\n                case \"s\":\r\n                case \"ss\":\r\n                    sec = parseInt(matchGroup, 10);\r\n                    if ((sec < 0) || (sec > 59))\r\n                        return null;\r\n                    break;\r\n                case \"tt\":\r\n                case \"t\":\r\n                    var upperToken = matchGroup.toUpperCase();\r\n                    pmHour = (upperToken === dtf.PMDesignator.toUpperCase());\r\n                    if (!pmHour && (upperToken !== dtf.AMDesignator.toUpperCase()))\r\n                        return null;\r\n                    break;\r\n                case \"f\":\r\n                    msec = parseInt(matchGroup, 10) * 100;\r\n                    if ((msec < 0) || (msec > 999))\r\n                        return null;\r\n                    break;\r\n                case \"ff\":\r\n                    msec = parseInt(matchGroup, 10) * 10;\r\n                    if ((msec < 0) || (msec > 999))\r\n                        return null;\r\n                    break;\r\n                case \"fff\":\r\n                    msec = parseInt(matchGroup, 10);\r\n                    if ((msec < 0) || (msec > 999))\r\n                        return null;\r\n                    break;\r\n                case \"dddd\":\r\n                    weekDay = cultureInfo._getDayIndex(matchGroup);\r\n                    if ((weekDay < 0) || (weekDay > 6))\r\n                        return null;\r\n                    break;\r\n                case \"ddd\":\r\n                    weekDay = cultureInfo._getDayIndex(matchGroup, true);\r\n                    if ((weekDay < 0) || (weekDay > 6))\r\n                        return null;\r\n                    break;\r\n                case \"zzz\":\r\n                    var offsets = matchGroup.split(/:/);\r\n                    if (offsets.length !== 2)\r\n                        return null;\r\n                    hourOffset = parseInt(offsets[0], 10);\r\n                    if ((hourOffset < -12) || (hourOffset > 13))\r\n                        return null;\r\n                    var minOffset = parseInt(offsets[1], 10);\r\n                    if ((minOffset < 0) || (minOffset > 59))\r\n                        return null;\r\n                    tzMinOffset = (hourOffset * 60) + (matchGroup.startsWith(\"-\") ? -minOffset : minOffset);\r\n                    break;\r\n                case \"z\":\r\n                case \"zz\":\r\n                    hourOffset = parseInt(matchGroup, 10);\r\n                    if ((hourOffset < -12) || (hourOffset > 13))\r\n                        return null;\r\n                    tzMinOffset = hourOffset * 60;\r\n                    break;\r\n                case \"g\":\r\n                case \"gg\":\r\n                    var eraName = matchGroup;\r\n                    if (!eraName || !dtf.Eras)\r\n                        return null;\r\n                    eraName = eraName.toLowerCase().trim();\r\n                    for (var i = 0, l = dtf.Eras.length; i < l; i += 4) {\r\n                        if (eraName === dtf.Eras[i + 1].toLowerCase()) {\r\n                            era = i;\r\n                            break;\r\n                        }\r\n                    }\r\n                    if (era === null)\r\n                        return null;\r\n                    break;\r\n            }\r\n        }\r\n    }\r\n    var result = new Date();\r\n    var defaultYear;\r\n    var convert = dtf.Calendar.convert;\r\n    // If none are specified, set to todays date to 1/1/1970\r\n    if (year == null && month == null && date == null) {\r\n        year = 1970;\r\n        month = 0;\r\n        date = 1;\r\n    }\r\n    else {\r\n        if (convert) {\r\n            defaultYear = convert.fromGregorian(result)[0];\r\n        }\r\n        else {\r\n            defaultYear = result.getFullYear();\r\n        }\r\n        if (year === null) {\r\n            year = defaultYear;\r\n        }\r\n        else if (dtf.Eras) {\r\n            year += dtf.Eras[(era || 0) + 3];\r\n        }\r\n        if (month === null) {\r\n            month = 0;\r\n        }\r\n        if (date === null) {\r\n            date = 1;\r\n        }\r\n    }\r\n    if (convert) {\r\n        result = convert.toGregorian(year, month, date);\r\n        if (result === null)\r\n            return null;\r\n    }\r\n    else {\r\n        result.setFullYear(year, month, date);\r\n        if (result.getDate() !== date)\r\n            return null;\r\n        if ((weekDay !== null) && (result.getDay() !== weekDay)) {\r\n            return null;\r\n        }\r\n    }\r\n    if (pmHour && (hour < 12)) {\r\n        hour += 12;\r\n    }\r\n    result.setHours(hour, min, sec, msec);\r\n    if (tzMinOffset !== null) {\r\n        var adjustedMin = result.getMinutes() - (tzMinOffset + result.getTimezoneOffset());\r\n        result.setHours(result.getHours() + parseInt((adjustedMin / 60).toString(), 10), adjustedMin % 60);\r\n    }\r\n    return result;\r\n}\r\nfunction addLeadingZero(num) {\r\n    if (num < 10) {\r\n        return \"0\" + num;\r\n    }\r\n    return num.toString();\r\n}\r\nfunction addLeadingZeros(num) {\r\n    if (num < 10) {\r\n        return \"00\" + num;\r\n    }\r\n    if (num < 100) {\r\n        return \"0\" + num;\r\n    }\r\n    return num.toString();\r\n}\r\nfunction padYear(year) {\r\n    if (year < 10) {\r\n        return \"000\" + year;\r\n    }\r\n    else if (year < 100) {\r\n        return \"00\" + year;\r\n    }\r\n    else if (year < 1000) {\r\n        return \"0\" + year;\r\n    }\r\n    return year.toString();\r\n}\r\n/**\r\n * Formats a date as text using the given format string and culture\r\n * @param date The date to format\r\n * @param format The format specifier\r\n * @param cultureInfo The culture\r\n */\r\nfunction formatDate(date, format, cultureInfo) {\r\n    if (!date)\r\n        return null;\r\n    var dtf = cultureInfo.dateTimeFormat;\r\n    var convert = dtf.Calendar.convert;\r\n    if (!format || !format.length || (format === \"i\")) {\r\n        if (cultureInfo && cultureInfo.name.length) {\r\n            if (convert) {\r\n                return formatDate(date, dtf.FullDateTimePattern, cultureInfo);\r\n            }\r\n            else {\r\n                var eraDate = new Date(date.getTime());\r\n                var era = getEra(date, dtf.Eras);\r\n                eraDate.setFullYear(getEraYear(date, dtf, era));\r\n                return eraDate.toLocaleString();\r\n            }\r\n        }\r\n        else {\r\n            return date.toString();\r\n        }\r\n    }\r\n    var eras = dtf.Eras;\r\n    var sortable = (format === \"s\");\r\n    format = expandDateFormat(dtf, format);\r\n    var ret = new StringBuilder();\r\n    var hour;\r\n    var foundDay;\r\n    var checkedDay;\r\n    var dayPartRegExp = /([^d]|^)(d|dd)([^d]|$)/g;\r\n    var hasDay = function hasDay() {\r\n        if (foundDay || checkedDay) {\r\n            return foundDay;\r\n        }\r\n        foundDay = dayPartRegExp.test(format);\r\n        checkedDay = true;\r\n        return foundDay;\r\n    };\r\n    var quoteCount = 0;\r\n    var tokenRegExp = getDateTokenRegExp();\r\n    var converted;\r\n    if (!sortable && convert) {\r\n        converted = convert.fromGregorian(date);\r\n    }\r\n    for (;;) {\r\n        var index = tokenRegExp.lastIndex;\r\n        var ar = tokenRegExp.exec(format);\r\n        var preMatch = format.slice(index, ar ? ar.index : format.length);\r\n        quoteCount += date$appendPreOrPostMatch(preMatch, ret);\r\n        if (!ar)\r\n            break;\r\n        if ((quoteCount % 2) === 1) {\r\n            ret.append(ar[0]);\r\n            continue;\r\n        }\r\n        var getDatePart = function getDatePart(date, part) {\r\n            if (converted) {\r\n                return converted[part];\r\n            }\r\n            switch (part) {\r\n                case 0: return date.getFullYear();\r\n                case 1: return date.getMonth();\r\n                case 2: return date.getDate();\r\n            }\r\n        };\r\n        switch (ar[0]) {\r\n            case \"dddd\":\r\n                ret.append(dtf.DayNames[date.getDay()]);\r\n                break;\r\n            case \"ddd\":\r\n                ret.append(dtf.AbbreviatedDayNames[date.getDay()]);\r\n                break;\r\n            case \"dd\":\r\n                foundDay = true;\r\n                ret.append(addLeadingZero(getDatePart(date, 2)));\r\n                break;\r\n            case \"d\":\r\n                foundDay = true;\r\n                ret.append(getDatePart(date, 2).toString());\r\n                break;\r\n            case \"MMMM\":\r\n                ret.append((dtf.MonthGenitiveNames && hasDay())\r\n                    ? dtf.MonthGenitiveNames[getDatePart(date, 1)]\r\n                    : dtf.MonthNames[getDatePart(date, 1)]);\r\n                break;\r\n            case \"MMM\":\r\n                ret.append((dtf.AbbreviatedMonthGenitiveNames && hasDay())\r\n                    ? dtf.AbbreviatedMonthGenitiveNames[getDatePart(date, 1)]\r\n                    : dtf.AbbreviatedMonthNames[getDatePart(date, 1)]);\r\n                break;\r\n            case \"MM\":\r\n                ret.append(addLeadingZero(getDatePart(date, 1) + 1));\r\n                break;\r\n            case \"M\":\r\n                ret.append((getDatePart(date, 1) + 1).toString());\r\n                break;\r\n            case \"yyyy\":\r\n                ret.append(padYear(converted ? converted[0] : getEraYear(date, dtf, getEra(date, eras), sortable)));\r\n                break;\r\n            case \"yy\":\r\n                ret.append(addLeadingZero((converted ? converted[0] : getEraYear(date, dtf, getEra(date, eras), sortable)) % 100));\r\n                break;\r\n            case \"y\":\r\n                ret.append(((converted ? converted[0] : getEraYear(date, dtf, getEra(date, eras), sortable)) % 100).toString());\r\n                break;\r\n            case \"hh\":\r\n                hour = date.getHours() % 12;\r\n                if (hour === 0)\r\n                    hour = 12;\r\n                ret.append(addLeadingZero(hour));\r\n                break;\r\n            case \"h\":\r\n                hour = date.getHours() % 12;\r\n                if (hour === 0)\r\n                    hour = 12;\r\n                ret.append(hour.toString());\r\n                break;\r\n            case \"HH\":\r\n                ret.append(addLeadingZero(date.getHours()));\r\n                break;\r\n            case \"H\":\r\n                ret.append(date.getHours().toString());\r\n                break;\r\n            case \"mm\":\r\n                ret.append(addLeadingZero(date.getMinutes()));\r\n                break;\r\n            case \"m\":\r\n                ret.append(date.getMinutes().toString());\r\n                break;\r\n            case \"ss\":\r\n                ret.append(addLeadingZero(date.getSeconds()));\r\n                break;\r\n            case \"s\":\r\n                ret.append(date.getSeconds().toString());\r\n                break;\r\n            case \"tt\":\r\n                ret.append((date.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator);\r\n                break;\r\n            case \"t\":\r\n                ret.append(((date.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator).charAt(0));\r\n                break;\r\n            case \"f\":\r\n                ret.append(addLeadingZeros(date.getMilliseconds()).charAt(0));\r\n                break;\r\n            case \"ff\":\r\n                ret.append(addLeadingZeros(date.getMilliseconds()).substr(0, 2));\r\n                break;\r\n            case \"fff\":\r\n                ret.append(addLeadingZeros(date.getMilliseconds()));\r\n                break;\r\n            case \"z\":\r\n                hour = date.getTimezoneOffset() / 60;\r\n                ret.append(((hour <= 0) ? \"+\" : \"-\") + Math.floor(Math.abs(hour)));\r\n                break;\r\n            case \"zz\":\r\n                hour = date.getTimezoneOffset() / 60;\r\n                ret.append(((hour <= 0) ? \"+\" : \"-\") + addLeadingZero(Math.floor(Math.abs(hour))));\r\n                break;\r\n            case \"zzz\":\r\n                hour = date.getTimezoneOffset() / 60;\r\n                ret.append(((hour <= 0) ? \"+\" : \"-\") + addLeadingZero(Math.floor(Math.abs(hour))) +\r\n                    \":\" + addLeadingZero(Math.abs(date.getTimezoneOffset() % 60)));\r\n                break;\r\n            case \"g\":\r\n            case \"gg\":\r\n                if (dtf.Eras) {\r\n                    ret.append(dtf.Eras[getEra(date, eras) + 1]);\r\n                }\r\n                break;\r\n            case \"/\":\r\n                ret.append(dtf.DateSeparator);\r\n                break;\r\n        }\r\n    }\r\n    return ret.toString();\r\n}\r\nexports.formatDate = formatDate;\r\nfunction getNumberStyle(format) {\r\n    format = format || \"\";\r\n    if (format.match(/[$c]+/i))\r\n        return \"Currency\";\r\n    if (format.match(/[%p]+/i))\r\n        return \"Percent\";\r\n    if (format.match(/[dnfg]0/i))\r\n        return \"Integer\";\r\n    return \"Number\";\r\n}\r\nexports.getNumberStyle = getNumberStyle;\r\nfunction parseNumber(value, style, cultureInfo) {\r\n    // Handle use of () to denote negative numbers\r\n    var sign = 1;\r\n    if (value.match(/^\\(.*\\)$/)) {\r\n        value = value.substring(1, value.length - 1);\r\n        sign = -1;\r\n    }\r\n    var result;\r\n    // Remove currency symbols before parsing\r\n    if (style === \"Currency\") {\r\n        result = _parseNumber(value.replace(cultureInfo.numberFormat.CurrencySymbol, \"\"), cultureInfo) * sign;\r\n        // if there is a decimal place, check the precision isnt greater than allowed for currency.\r\n        // Floating points in js can be skewed under certain circumstances, we are just checking the decimals instead of multiplying results.\r\n        var resultvalue = result.toString();\r\n        if (resultvalue.indexOf(\".\") > -1 && (resultvalue.length - (resultvalue.indexOf(\".\") + 1)) > cultureInfo.numberFormat.CurrencyDecimalDigits) {\r\n            result = NaN;\r\n        }\r\n    }\r\n    // Remove percentage symbols before parsing and divide by 100\r\n    else if (style === \"Percent\")\r\n        result = _parseNumber(value.replace(cultureInfo.numberFormat.PercentSymbol, \"\"), cultureInfo) / 100 * sign;\r\n    // Ensure integers are actual whole numbers\r\n    else if (style === \"Integer\" && !isInteger(_parseNumber(value, cultureInfo)))\r\n        result = NaN;\r\n    // Just parse a simple number\r\n    else\r\n        result = _parseNumber(value, cultureInfo) * sign;\r\n    return result;\r\n}\r\nexports.parseNumber = parseNumber;\r\nfunction isInteger(obj) {\r\n    return typeof (obj) === \"number\" && !isNaN(obj) && /^-?[0-9]{1,10}$/.test(obj.toString()) && (obj >= -2147483648 && obj <= 2147483647);\r\n}\r\n/**\r\n * Parses the given text as a number\r\n * @param value The text to parse\r\n * @param cultureInfo The culture\r\n */\r\nfunction _parseNumber(value, cultureInfo) {\r\n    value = value.trim();\r\n    if (value.match(/^[+-]?infinity$/i)) {\r\n        return parseFloat(value);\r\n    }\r\n    if (value.match(/^0x[a-f0-9]+$/i)) {\r\n        return parseInt(value);\r\n    }\r\n    var numFormat = cultureInfo.numberFormat;\r\n    var signInfo = parseNumberNegativePattern(value, numFormat, numFormat.NumberNegativePattern);\r\n    var sign = signInfo[0];\r\n    var num = signInfo[1];\r\n    if ((sign === \"\") && (numFormat.NumberNegativePattern !== 1)) {\r\n        signInfo = parseNumberNegativePattern(value, numFormat, 1);\r\n        sign = signInfo[0];\r\n        num = signInfo[1];\r\n    }\r\n    if (sign === \"\")\r\n        sign = \"+\";\r\n    var exponent;\r\n    var intAndFraction;\r\n    var exponentPos = num.indexOf(\"e\");\r\n    if (exponentPos < 0)\r\n        exponentPos = num.indexOf(\"E\");\r\n    if (exponentPos < 0) {\r\n        intAndFraction = num;\r\n        exponent = null;\r\n    }\r\n    else {\r\n        intAndFraction = num.substr(0, exponentPos);\r\n        exponent = num.substr(exponentPos + 1);\r\n    }\r\n    var integer;\r\n    var fraction;\r\n    var decimalPos = intAndFraction.indexOf(numFormat.NumberDecimalSeparator);\r\n    if (decimalPos < 0) {\r\n        integer = intAndFraction;\r\n        fraction = null;\r\n    }\r\n    else {\r\n        integer = intAndFraction.substr(0, decimalPos);\r\n        fraction = intAndFraction.substr(decimalPos + numFormat.NumberDecimalSeparator.length);\r\n    }\r\n    integer = integer.split(numFormat.NumberGroupSeparator).join(\"\");\r\n    var altNumGroupSeparator = numFormat.NumberGroupSeparator.replace(/\\u00A0/g, \" \");\r\n    if (numFormat.NumberGroupSeparator !== altNumGroupSeparator) {\r\n        integer = integer.split(altNumGroupSeparator).join(\"\");\r\n    }\r\n    var p = sign + integer;\r\n    if (fraction !== null) {\r\n        p += \".\" + fraction;\r\n    }\r\n    if (exponent !== null) {\r\n        var expSignInfo = parseNumberNegativePattern(exponent, numFormat, 1);\r\n        if (expSignInfo[0] === \"\") {\r\n            expSignInfo[0] = \"+\";\r\n        }\r\n        p += \"e\" + expSignInfo[0] + expSignInfo[1];\r\n    }\r\n    if (p.match(/^[+-]?\\d*\\.?\\d*(e[+-]?\\d+)?$/)) {\r\n        return parseFloat(p);\r\n    }\r\n    return Number.NaN;\r\n}\r\nexports._parseNumber = _parseNumber;\r\n;\r\nfunction parseNumberNegativePattern(value, numberFormatInfo, numberNegativePattern) {\r\n    var neg = numberFormatInfo.NegativeSign;\r\n    var pos = numberFormatInfo.PositiveSign;\r\n    switch (numberNegativePattern) {\r\n        case 4:\r\n            neg = \" \" + neg;\r\n            pos = \" \" + pos;\r\n        // eslint-disable-next-line no-fallthrough\r\n        case 3:\r\n            if (value.endsWith(neg)) {\r\n                return [\"-\", value.substr(0, value.length - neg.length)];\r\n            }\r\n            else if (value.endsWith(pos)) {\r\n                return [\"+\", value.substr(0, value.length - pos.length)];\r\n            }\r\n            break;\r\n        case 2:\r\n            neg += \" \";\r\n            pos += \" \";\r\n        // eslint-disable-next-line no-fallthrough\r\n        case 1:\r\n            if (value.startsWith(neg)) {\r\n                return [\"-\", value.substr(neg.length)];\r\n            }\r\n            else if (value.startsWith(pos)) {\r\n                return [\"+\", value.substr(pos.length)];\r\n            }\r\n            break;\r\n        case 0:\r\n            if (value.startsWith(\"(\") && value.endsWith(\")\")) {\r\n                return [\"-\", value.substr(1, value.length - 2)];\r\n            }\r\n            break;\r\n    }\r\n    return [\"\", value];\r\n}\r\n;\r\nfunction zeroPad(str, count, left) {\r\n    for (var l = str.length; l < count; l++) {\r\n        str = (left ? (\"0\" + str) : (str + \"0\"));\r\n    }\r\n    return str;\r\n}\r\nfunction expandNumber(number, precision, groupSizes, sep, decimalChar) {\r\n    var curSize = groupSizes[0];\r\n    var curGroupIndex = 1;\r\n    var factor = Math.pow(10, precision);\r\n    var rounded = (Math.round(number * factor) / factor);\r\n    if (!isFinite(rounded)) {\r\n        rounded = number;\r\n    }\r\n    number = rounded;\r\n    var numberString = number.toString();\r\n    var right = \"\";\r\n    var exponent;\r\n    var split = numberString.split(/e/i);\r\n    numberString = split[0];\r\n    exponent = (split.length > 1 ? parseInt(split[1]) : 0);\r\n    split = numberString.split(\".\");\r\n    numberString = split[0];\r\n    right = split.length > 1 ? split[1] : \"\";\r\n    if (exponent > 0) {\r\n        right = zeroPad(right, exponent, false);\r\n        numberString += right.slice(0, exponent);\r\n        right = right.substr(exponent);\r\n    }\r\n    else if (exponent < 0) {\r\n        exponent = -exponent;\r\n        numberString = zeroPad(numberString, exponent + 1, true);\r\n        right = numberString.slice(-exponent, numberString.length) + right;\r\n        numberString = numberString.slice(0, -exponent);\r\n    }\r\n    if (precision > 0) {\r\n        if (right.length > precision) {\r\n            right = right.slice(0, precision);\r\n        }\r\n        else {\r\n            right = zeroPad(right, precision, false);\r\n        }\r\n        right = decimalChar + right;\r\n    }\r\n    else {\r\n        right = \"\";\r\n    }\r\n    var stringIndex = numberString.length - 1;\r\n    var ret = \"\";\r\n    while (stringIndex >= 0) {\r\n        if (curSize === 0 || curSize > stringIndex) {\r\n            if (ret.length > 0)\r\n                return numberString.slice(0, stringIndex + 1) + sep + ret + right;\r\n            else\r\n                return numberString.slice(0, stringIndex + 1) + right;\r\n        }\r\n        if (ret.length > 0)\r\n            ret = numberString.slice(stringIndex - curSize + 1, stringIndex + 1) + sep + ret;\r\n        else\r\n            ret = numberString.slice(stringIndex - curSize + 1, stringIndex + 1);\r\n        stringIndex -= curSize;\r\n        if (curGroupIndex < groupSizes.length) {\r\n            curSize = groupSizes[curGroupIndex];\r\n            curGroupIndex++;\r\n        }\r\n    }\r\n    return numberString.slice(0, stringIndex + 1) + sep + ret + right;\r\n}\r\n/**\r\n * Formats a number as text using the given format string and culture\r\n * @param number The number to format\r\n * @param format The format specifier\r\n * @param cultureInfo The culture\r\n */\r\nfunction formatNumber(number, format, cultureInfo) {\r\n    if (typeof number !== \"number\" || isNaN(number))\r\n        return null;\r\n    if (!format || (format.length === 0) || (format === \"i\")) {\r\n        if (cultureInfo && (cultureInfo.name.length > 0)) {\r\n            return number.toLocaleString();\r\n        }\r\n        else {\r\n            return number.toString();\r\n        }\r\n    }\r\n    var _percentPositivePattern = [\"n %\", \"n%\", \"%n\"];\r\n    var _percentNegativePattern = [\"-n %\", \"-n%\", \"-%n\"];\r\n    var _numberNegativePattern = [\"(n)\", \"-n\", \"- n\", \"n-\", \"n -\"];\r\n    var _currencyPositivePattern = [\"$n\", \"n$\", \"$ n\", \"n $\"];\r\n    var _currencyNegativePattern = [\"($n)\", \"-$n\", \"$-n\", \"$n-\", \"(n$)\", \"-n$\", \"n-$\", \"n$-\", \"-n $\", \"-$ n\", \"n $-\", \"$ n-\", \"$ -n\", \"n- $\", \"($ n)\", \"(n $)\"];\r\n    var nf = cultureInfo.numberFormat;\r\n    var num = Math.abs(number);\r\n    if (!format)\r\n        format = \"D\";\r\n    var precision = -1;\r\n    if (format.length > 1)\r\n        precision = parseInt(format.slice(1), 10);\r\n    var pattern;\r\n    switch (format.charAt(0)) {\r\n        case \"d\":\r\n        case \"D\":\r\n            pattern = \"n\";\r\n            if (precision !== -1) {\r\n                num = zeroPad(\"\" + num, precision, true);\r\n            }\r\n            if (number < 0)\r\n                num = -num;\r\n            break;\r\n        case \"c\":\r\n        case \"C\":\r\n            if (number < 0)\r\n                pattern = _currencyNegativePattern[nf.CurrencyNegativePattern];\r\n            else\r\n                pattern = _currencyPositivePattern[nf.CurrencyPositivePattern];\r\n            if (precision === -1)\r\n                precision = nf.CurrencyDecimalDigits;\r\n            num = expandNumber(Math.abs(number), precision, nf.CurrencyGroupSizes, nf.CurrencyGroupSeparator, nf.CurrencyDecimalSeparator);\r\n            break;\r\n        case \"n\":\r\n        case \"N\":\r\n            if (number < 0)\r\n                pattern = _numberNegativePattern[nf.NumberNegativePattern];\r\n            else\r\n                pattern = \"n\";\r\n            if (precision === -1)\r\n                precision = nf.NumberDecimalDigits;\r\n            num = expandNumber(Math.abs(number), precision, nf.NumberGroupSizes, nf.NumberGroupSeparator, nf.NumberDecimalSeparator);\r\n            break;\r\n        case \"p\":\r\n        case \"P\":\r\n            if (number < 0)\r\n                pattern = _percentNegativePattern[nf.PercentNegativePattern];\r\n            else\r\n                pattern = _percentPositivePattern[nf.PercentPositivePattern];\r\n            if (precision === -1)\r\n                precision = nf.PercentDecimalDigits;\r\n            num = expandNumber(Math.abs(number) * 100, precision, nf.PercentGroupSizes, nf.PercentGroupSeparator, nf.PercentDecimalSeparator);\r\n            break;\r\n        default:\r\n            throw new FormatError(Res.formatBadFormatSpecifier);\r\n    }\r\n    var regex = /n|\\$|-|%/g;\r\n    var ret = \"\";\r\n    for (;;) {\r\n        var index = regex.lastIndex;\r\n        var ar = regex.exec(pattern);\r\n        ret += pattern.slice(index, ar ? ar.index : pattern.length);\r\n        if (!ar)\r\n            break;\r\n        switch (ar[0]) {\r\n            case \"n\":\r\n                ret += num;\r\n                break;\r\n            case \"$\":\r\n                ret += nf.CurrencySymbol;\r\n                break;\r\n            case \"-\":\r\n                if (/[1-9]/.test(num.toString())) {\r\n                    ret += nf.NegativeSign;\r\n                }\r\n                break;\r\n            case \"%\":\r\n                ret += nf.PercentSymbol;\r\n                break;\r\n        }\r\n    }\r\n    return ret;\r\n}\r\nexports.formatNumber = formatNumber;\r\nfunction toUpper(value) {\r\n    return value.split(\"\\u00A0\").join(\" \").toUpperCase();\r\n}\r\nfunction toUpperArray(arr) {\r\n    var result = [];\r\n    for (var i = 0; i < arr.length; i++) {\r\n        var value = arr[i];\r\n        result[i] = toUpper(value);\r\n    }\r\n    return result;\r\n}\r\nvar invariantCultureInfo = {\r\n    name: \"\",\r\n    numberFormat: {\r\n        CurrencyDecimalDigits: 2,\r\n        CurrencyDecimalSeparator: \".\",\r\n        CurrencyGroupSizes: [3],\r\n        NumberGroupSizes: [3],\r\n        PercentGroupSizes: [3],\r\n        CurrencyGroupSeparator: \",\",\r\n        CurrencySymbol: \"\\u00A4\",\r\n        NaNSymbol: \"NaN\",\r\n        CurrencyNegativePattern: 0,\r\n        NumberNegativePattern: 1,\r\n        PercentPositivePattern: 0,\r\n        PercentNegativePattern: 0,\r\n        NegativeInfinitySymbol: \"-Infinity\",\r\n        NegativeSign: \"-\",\r\n        NumberDecimalDigits: 2,\r\n        NumberDecimalSeparator: \".\",\r\n        NumberGroupSeparator: \",\",\r\n        CurrencyPositivePattern: 0,\r\n        PositiveInfinitySymbol: \"Infinity\",\r\n        PositiveSign: \"+\",\r\n        PercentDecimalDigits: 2,\r\n        PercentDecimalSeparator: \".\",\r\n        PercentGroupSeparator: \",\",\r\n        PercentSymbol: \"%\",\r\n        PerMilleSymbol: \"\\u2030\",\r\n        NativeDigits: [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"],\r\n        DigitSubstitution: 1\r\n    },\r\n    dateTimeFormat: {\r\n        AMDesignator: \"AM\",\r\n        Calendar: { MinSupportedDateTime: \"@-62135568000000@\", MaxSupportedDateTime: \"@253402300799999@\", AlgorithmType: 1, CalendarType: 1, Eras: [1], TwoDigitYearMax: 2029 },\r\n        DateSeparator: \"/\",\r\n        FirstDayOfWeek: 0,\r\n        CalendarWeekRule: 0,\r\n        FullDateTimePattern: \"dddd, dd MMMM yyyy HH:mm:ss\",\r\n        LongDatePattern: \"dddd, dd MMMM yyyy\",\r\n        LongTimePattern: \"HH:mm:ss\",\r\n        MonthDayPattern: \"MMMM dd\",\r\n        PMDesignator: \"PM\",\r\n        RFC1123Pattern: \"ddd, dd MMM yyyy HH':'mm':'ss 'GMT'\",\r\n        ShortDatePattern: \"MM/dd/yyyy\",\r\n        ShortTimePattern: \"h:mm tt\",\r\n        SortableDateTimePattern: \"yyyy'-'MM'-'dd'T'HH':'mm':'ss\",\r\n        TimeSeparator: \":\",\r\n        UniversalSortableDateTimePattern: \"yyyy'-'MM'-'dd HH':'mm':'ss'Z'\",\r\n        YearMonthPattern: \"yyyy MMMM\",\r\n        AbbreviatedDayNames: [\"Sun\", \"Mon\", \"Tue\", \"Wed\", \"Thu\", \"Fri\", \"Sat\"],\r\n        ShortestDayNames: [\"Su\", \"Mo\", \"Tu\", \"We\", \"Th\", \"Fr\", \"Sa\"],\r\n        DayNames: [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"],\r\n        AbbreviatedMonthNames: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\", \"\"],\r\n        MonthNames: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\", \"\"],\r\n        NativeCalendarName: \"Gregorian Calendar\",\r\n        AbbreviatedMonthGenitiveNames: [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"Jun\", \"Jul\", \"Aug\", \"Sep\", \"Oct\", \"Nov\", \"Dec\", \"\"],\r\n        MonthGenitiveNames: [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\", \"\"]\r\n    },\r\n    eras: [1, \"A.D.\", null, 0]\r\n};\r\nvar CultureInfo = /** @class */ (function () {\r\n    function CultureInfo(name, numberFormat, dateTimeFormat) {\r\n        this.name = name;\r\n        this.numberFormat = numberFormat;\r\n        this.dateTimeFormat = dateTimeFormat;\r\n    }\r\n    CultureInfo.parse = function (value) {\r\n        var dtf = value.dateTimeFormat;\r\n        if (dtf && !dtf.Eras) {\r\n            dtf.Eras = value.eras;\r\n        }\r\n        return new CultureInfo(value.name, value.numberFormat, dtf);\r\n    };\r\n    CultureInfo.setup = function (cultureInfo) {\r\n        if (cultureInfo === void 0) { cultureInfo = null; }\r\n        if (cultureInfo != null && typeof cultureInfo === \"object\") {\r\n            CultureInfo.CurrentCulture = CultureInfo.parse(cultureInfo);\r\n        }\r\n        else if (!CultureInfo.CurrentCulture) {\r\n            // Set up default culture\r\n            var defaultCulture = CultureInfo._defaultCulture;\r\n            if (!CultureInfo._defaultCulture) {\r\n                var cultureInfoObject = helpers_1.clone(invariantCultureInfo);\r\n                cultureInfoObject.name = \"en-US\";\r\n                cultureInfoObject.numberFormat.CurrencySymbol = \"$\";\r\n                var dtf = cultureInfoObject.dateTimeFormat;\r\n                dtf.FullDateTimePattern = \"dddd, MMMM dd, yyyy h:mm:ss tt\";\r\n                dtf.LongDatePattern = \"dddd, MMMM dd, yyyy\";\r\n                dtf.LongTimePattern = \"h:mm:ss tt\";\r\n                dtf.ShortDatePattern = \"M/d/yyyy\";\r\n                dtf.ShortTimePattern = \"h:mm tt\";\r\n                dtf.YearMonthPattern = \"MMMM, yyyy\";\r\n                defaultCulture = CultureInfo.parse(cultureInfoObject);\r\n                CultureInfo._defaultCulture = defaultCulture;\r\n            }\r\n            CultureInfo.CurrentCulture = defaultCulture;\r\n        }\r\n    };\r\n    CultureInfo.prototype._getDateTimeFormats = function () {\r\n        var formats = this._dateTimeFormats;\r\n        if (!formats) {\r\n            var dtf = this.dateTimeFormat;\r\n            this._dateTimeFormats = formats = [\r\n                dtf[\"MonthDayPattern\"],\r\n                dtf[\"YearMonthPattern\"],\r\n                dtf[\"ShortDatePattern\"],\r\n                dtf[\"ShortTimePattern\"],\r\n                dtf[\"LongDatePattern\"],\r\n                dtf[\"LongTimePattern\"],\r\n                dtf[\"FullDateTimePattern\"],\r\n                dtf[\"RFC1123Pattern\"],\r\n                dtf[\"SortableDateTimePattern\"],\r\n                dtf[\"UniversalSortableDateTimePattern\"]\r\n            ];\r\n        }\r\n        return formats;\r\n    };\r\n    CultureInfo.prototype._getMonthIndex = function (value, abbr) {\r\n        // Get or create the cache of upper-case month names\r\n        var upperMonths = abbr ? this._upperAbbrMonths : this._upperMonths;\r\n        if (!upperMonths) {\r\n            if (abbr)\r\n                upperMonths = this._upperAbbrMonths = toUpperArray(this.dateTimeFormat.AbbreviatedMonthNames);\r\n            else\r\n                upperMonths = this._upperMonths = toUpperArray(this.dateTimeFormat.MonthNames);\r\n        }\r\n        // Convert the month name to upper-case and get its index in the list\r\n        value = toUpper(value);\r\n        var i = upperMonths.indexOf(value);\r\n        if (i < 0) {\r\n            // Get or create the cache of upper-case genitive month names\r\n            var upperMonthsGenitive = abbr ? this._upperAbbrMonthsGenitive : this._upperMonthsGenitive;\r\n            if (!upperMonthsGenitive) {\r\n                if (abbr)\r\n                    upperMonthsGenitive = this._upperAbbrMonthsGenitive = toUpperArray(this.dateTimeFormat.AbbreviatedMonthGenitiveNames);\r\n                else\r\n                    upperMonthsGenitive = this._upperMonthsGenitive = toUpperArray(this.dateTimeFormat.MonthGenitiveNames);\r\n            }\r\n            // Check the list of genitive month names\r\n            i = upperMonthsGenitive.indexOf(value);\r\n        }\r\n        return i;\r\n    };\r\n    CultureInfo.prototype._getDayIndex = function (value, abbr) {\r\n        // Get or create the cache of upper-case day names\r\n        var upperDays = abbr ? this._upperAbbrDays : this._upperDays;\r\n        if (!upperDays) {\r\n            if (abbr)\r\n                upperDays = this._upperAbbrDays = toUpperArray(this.dateTimeFormat.AbbreviatedDayNames);\r\n            else\r\n                upperDays = this._upperDays = toUpperArray(this.dateTimeFormat.DayNames);\r\n        }\r\n        // Convert the day name to upper-case and get its index in the list\r\n        value = toUpper(value);\r\n        return upperDays.indexOf(value);\r\n    };\r\n    return CultureInfo;\r\n}());\r\nexports.CultureInfo = CultureInfo;\r\nCultureInfo.InvariantCulture = CultureInfo.parse(invariantCultureInfo);\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.RuleInvocationType = void 0;\r\nvar RuleInvocationType;\r\n(function (RuleInvocationType) {\r\n    /** Occurs when an existing instance is initialized. */\r\n    RuleInvocationType[RuleInvocationType[\"InitExisting\"] = 2] = \"InitExisting\";\r\n    /** Occurs when a new instance is initialized. */\r\n    RuleInvocationType[RuleInvocationType[\"InitNew\"] = 4] = \"InitNew\";\r\n    /** Occurs when a property value is retrieved. */\r\n    RuleInvocationType[RuleInvocationType[\"PropertyGet\"] = 8] = \"PropertyGet\";\r\n    /** Occurs when a property value is changed. */\r\n    RuleInvocationType[RuleInvocationType[\"PropertyChanged\"] = 16] = \"PropertyChanged\";\r\n})(RuleInvocationType = exports.RuleInvocationType || (exports.RuleInvocationType = {}));\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.EntitySerializer = exports.DefaultSerializationSettings = exports.PropertyConverter = exports.IgnoreProperty = void 0;\r\nvar type_1 = require(\"./type\");\r\nvar helpers_1 = require(\"./helpers\");\r\nexports.IgnoreProperty = {\r\n    key: \"ignore\",\r\n    value: \"ignore\"\r\n};\r\n/**\r\n * Allows transformation of the serialized name and value of a model property.\r\n */\r\nvar PropertyConverter = /** @class */ (function () {\r\n    function PropertyConverter() {\r\n    }\r\n    /**\r\n     * @param context The `Entity` containing the specified property.\r\n     * @param prop The property being serialized/deserialized.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    PropertyConverter.prototype.shouldConvert = function (context, prop) {\r\n        return true;\r\n    };\r\n    /**\r\n     * Return `IgnoreProperty` to prevent serialization of the property.\r\n     * @param context The `Entity` containing the specified property.\r\n     * @param prop The current property being serialized.\r\n     * @param value The value of the property on the entity currently being serialized.\r\n     */\r\n    PropertyConverter.prototype.serialize = function (context, value, property, settings) {\r\n        var result = { key: property.name, value: value };\r\n        if (value) {\r\n            if (type_1.isEntityType(property.propertyType)) {\r\n                if (property.isList && Array.isArray(value))\r\n                    result.value = value.map(function (ent) { return ent.serialize(settings); });\r\n                else\r\n                    result.value = value.serialize(settings);\r\n            }\r\n            else if (property.isList)\r\n                result.value = value.slice();\r\n        }\r\n        return result;\r\n    };\r\n    /**\r\n     * Return `IgnoreProperty` to prevent deserialization of the property.\r\n     * @param context The `Entity` containing the specified property.\r\n     * @param prop The current property being deserialized.\r\n     * @param value The value to deserialize.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    PropertyConverter.prototype.deserialize = function (context, value, property) {\r\n        return value;\r\n    };\r\n    return PropertyConverter;\r\n}());\r\nexports.PropertyConverter = PropertyConverter;\r\nexports.DefaultSerializationSettings = {\r\n    force: false,\r\n    useAliases: false\r\n};\r\nvar EntitySerializer = /** @class */ (function () {\r\n    function EntitySerializer() {\r\n        this._propertyConverters = [];\r\n        this._propertyInjectors = new Map();\r\n        this._propertyAliases = new Map();\r\n        this._valueResolvers = [];\r\n    }\r\n    /**\r\n     * Property converters should be registered in order of increasing specificity.\r\n     * If two converters would convert a property, only the one registered last will apply.\r\n     */\r\n    EntitySerializer.prototype.registerPropertyConverter = function (converter) {\r\n        this._propertyConverters.unshift(converter);\r\n    };\r\n    /**\r\n     * Property injections will occur when serializing entities of the specified type, or entities which\r\n     * inherit from the specified type. Injected properties will appear before model properties in the serialized\r\n     * output.\r\n     * @param type Either a Type or the fullName of a Type\r\n     * @param injector\r\n     */\r\n    EntitySerializer.prototype.registerPropertyInjector = function (type, injector) {\r\n        var injectors = this._propertyInjectors.get(type) || [];\r\n        injectors.push(injector);\r\n        this._propertyInjectors.set(type, injectors);\r\n    };\r\n    EntitySerializer.prototype.registerPropertyAlias = function (type, alias, propertyName) {\r\n        var aliases = this._propertyAliases.get(type) || {};\r\n        aliases[alias] = propertyName;\r\n        aliases[propertyName] = alias;\r\n        this._propertyAliases.set(type, aliases);\r\n    };\r\n    EntitySerializer.prototype.registerValueResolver = function (resolver) {\r\n        this._valueResolvers.push(resolver);\r\n    };\r\n    /**\r\n     * Returns the property injectors registered for a specific type, including name-based registrations.\r\n     * @param type\r\n     */\r\n    EntitySerializer.prototype.getInjectorsOrDefault = function (type) {\r\n        return (this._propertyInjectors.get(type) || []).concat(this._propertyInjectors.get(type.fullName) || []);\r\n    };\r\n    /**\r\n     * Returns property injectors registered for a type and its base types.\r\n     * @param type\r\n     */\r\n    EntitySerializer.prototype.getPropertyInjectors = function (type) {\r\n        var injectors = [];\r\n        do {\r\n            injectors.push.apply(injectors, this.getInjectorsOrDefault(type));\r\n            type = type.baseType;\r\n        } while (type);\r\n        return injectors;\r\n    };\r\n    EntitySerializer.prototype.serializePropertyValue = function (entity, property, value, settings) {\r\n        var converters = this._propertyConverters.filter(function (c) { return c.shouldConvert(entity, property); });\r\n        var result = (function () {\r\n            if (converters) {\r\n                for (var _i = 0, converters_1 = converters; _i < converters_1.length; _i++) {\r\n                    var converter = converters_1[_i];\r\n                    var res = converter.serialize(entity, value, property, settings);\r\n                    if (!settings.force || res !== exports.IgnoreProperty)\r\n                        return res;\r\n                }\r\n            }\r\n            return EntitySerializer.defaultPropertyConverter.serialize(entity, value, property, settings);\r\n        })();\r\n        if (result && result !== exports.IgnoreProperty && settings.useAliases)\r\n            result.key = this.getPropertyAliases(property.containingType)[property.name] || result.key;\r\n        return result;\r\n    };\r\n    /**\r\n     * Produces a JSON-valid object representation of the entity.\r\n     * @param entity\r\n     */\r\n    EntitySerializer.prototype.serialize = function (entity, settings) {\r\n        var _this = this;\r\n        if (settings === void 0) { settings = exports.DefaultSerializationSettings; }\r\n        var result = {};\r\n        var type = entity.meta.type;\r\n        helpers_1.flatMap(this.getPropertyInjectors(type), function (i) { return i.inject(entity); })\r\n            .concat(type.properties\r\n            .filter(function (p) { return !p.isCalculated && !p.isConstant; })\r\n            .map(function (prop) { return _this.serializePropertyValue(entity, prop, prop.value(entity), settings); }))\r\n            .forEach(function (pair) {\r\n            if (pair && pair !== exports.IgnoreProperty) {\r\n                if (result.hasOwnProperty(pair.key))\r\n                    throw new Error(\"Property '\" + pair.key + \"' was encountered twice during serialization. Make sure injected properties do not collide with model properties.\");\r\n                result[pair.key] = pair.value;\r\n            }\r\n        });\r\n        return result;\r\n    };\r\n    EntitySerializer.prototype.deserialize = function (instance, data, property, context, constructEntity) {\r\n        var _this = this;\r\n        if (constructEntity === void 0) { constructEntity = true; }\r\n        // Apply custom converters before deserializing\r\n        var converter = this._propertyConverters.find(function (c) { return c.shouldConvert(instance, property); });\r\n        if (converter)\r\n            data = converter.deserialize(instance, data, property);\r\n        if (data === exports.IgnoreProperty)\r\n            return;\r\n        var value;\r\n        var resolveEntity = function (type, state) {\r\n            var entity;\r\n            var id = type.meta.identifier ? state[type.meta.identifier.name] : null;\r\n            if (id)\r\n                entity = type.meta.get(id);\r\n            if (!entity)\r\n                entity = new type(id, state, context);\r\n            return entity;\r\n        };\r\n        // Entities\r\n        if (type_1.isEntityType(property.propertyType)) {\r\n            var ChildEntity_1 = property.propertyType;\r\n            if (!constructEntity)\r\n                value = data;\r\n            // Entity List\r\n            else if (property.isList && Array.isArray(data))\r\n                value = data.map(function (s) { return s instanceof ChildEntity_1 ? s : resolveEntity(ChildEntity_1, s); });\r\n            // Entity\r\n            else if (data instanceof ChildEntity_1)\r\n                value = data;\r\n            else if (data instanceof Object)\r\n                value = resolveEntity(ChildEntity_1, data);\r\n            else if (data === null)\r\n                value = data;\r\n        }\r\n        // Value List\r\n        else if (property.isList && Array.isArray(data))\r\n            value = data.map(function (i) { return _this.deserialize(instance, i, property, context); });\r\n        // Value\r\n        else if (property.format && data && typeof (data) === \"string\" && data.constructor !== property.propertyType)\r\n            value = property.format.convertFromString(data);\r\n        else\r\n            value = data;\r\n        return value;\r\n    };\r\n    EntitySerializer.prototype.getPropertyAliases = function (type) {\r\n        return Object.assign({}, this._propertyAliases.get(type), this._propertyAliases.get(type.fullName));\r\n    };\r\n    EntitySerializer.prototype.resolveProperty = function (context, propName) {\r\n        var prop = context.meta.type.getProperty(propName);\r\n        if (prop)\r\n            return prop;\r\n        propName = this.getPropertyAliases(context.meta.type)[propName];\r\n        return context.meta.type.getProperty(propName);\r\n    };\r\n    EntitySerializer.prototype.resolveValue = function (context, property, value) {\r\n        for (var _i = 0, _a = this._valueResolvers; _i < _a.length; _i++) {\r\n            var resolve = _a[_i];\r\n            var result = resolve(context, property, value);\r\n            if (result)\r\n                return result;\r\n        }\r\n    };\r\n    EntitySerializer.defaultPropertyConverter = new PropertyConverter();\r\n    return EntitySerializer;\r\n}());\r\nexports.EntitySerializer = EntitySerializer;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.resourceExists = exports.getResource = exports.defineResources = exports.setDefaultLocale = exports.Resources = void 0;\r\nvar helpers_1 = require(\"./helpers\");\r\n/**\r\n * The dictionary of localized resource messages\r\n */\r\nexports.Resources = {};\r\nfunction mapContainsResource(resources, locale, name) {\r\n    return helpers_1.hasOwnProperty(resources, locale) && helpers_1.hasOwnProperty(resources[locale], name);\r\n}\r\n/**\r\n * The default locale, can be changed via `setDefaultLocale(locale)`.\r\n */\r\nvar defaultLocale = null;\r\n/**\r\n * Sets the default locale\r\n * @param locale The default locale\r\n */\r\nfunction setDefaultLocale(locale) {\r\n    defaultLocale = locale;\r\n}\r\nexports.setDefaultLocale = setDefaultLocale;\r\n/**\r\n * Globally defined resources\r\n */\r\nvar globalResources = {};\r\n/**\r\n * Globally define localized resource messages for the given locale\r\n * @param locale The locale to set messages for\r\n * @param resources The resources messages\r\n */\r\nfunction defineResources(locale, resources) {\r\n    globalResources[locale] = helpers_1.hasOwnProperty(globalResources, locale) ? helpers_1.merge(globalResources[locale], resources) : resources;\r\n}\r\nexports.defineResources = defineResources;\r\n// eslint-disable-next-line no-redeclare\r\nfunction getResource(name, arg2, arg3) {\r\n    var customResources;\r\n    var locale;\r\n    if (arguments.length === 2) {\r\n        if (typeof arg2 === \"object\") {\r\n            customResources = arg2;\r\n            locale = null;\r\n        }\r\n        else if (typeof arg2 === \"string\") {\r\n            customResources = null;\r\n            locale = arg2;\r\n        }\r\n    }\r\n    else if (arguments.length >= 3) {\r\n        customResources = arg2;\r\n        locale = arg3;\r\n    }\r\n    if (!locale)\r\n        locale = defaultLocale || \"en\";\r\n    var res;\r\n    if (customResources && mapContainsResource(customResources, locale, name))\r\n        res = customResources[locale][name];\r\n    else if (mapContainsResource(globalResources, locale, name))\r\n        res = globalResources[locale][name];\r\n    else\r\n        throw new Error(\"Resource '\" + name + \"' is not defined for locale '\" + locale + \"'.\");\r\n    return res;\r\n}\r\nexports.getResource = getResource;\r\nfunction resourceExists(name, customResources, locale) {\r\n    if (!locale)\r\n        locale = defaultLocale || \"en\";\r\n    return mapContainsResource(globalResources, locale, name) || (customResources && mapContainsResource(customResources, locale, name));\r\n}\r\nexports.resourceExists = resourceExists;\r\n","\"use strict\";\r\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\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};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.isEntity = exports.Entity = void 0;\r\nvar events_1 = require(\"./events\");\r\nvar type_1 = require(\"./type\");\r\nvar initilization_context_1 = require(\"./initilization-context\");\r\nvar object_meta_1 = require(\"./object-meta\");\r\nvar property_1 = require(\"./property\");\r\nvar helpers_1 = require(\"./helpers\");\r\nvar entity_serializer_1 = require(\"./entity-serializer\");\r\nvar Entity = /** @class */ (function () {\r\n    function Entity(type, id, properties, context) {\r\n        var _this = this;\r\n        if (arguments.length === 0) {\r\n            // TODO: Warn about direct call in dev build?\r\n        }\r\n        else if (Entity.ctorDepth === 0)\r\n            throw new Error(\"Entity constructor should not be called directly.\");\r\n        else {\r\n            Object.defineProperty(this, \"_context\", { enumerable: false, configurable: false, writable: true, value: null });\r\n            Object.defineProperty(this, \"accessed\", { enumerable: false, configurable: false, writable: false, value: new events_1.Event() });\r\n            Object.defineProperty(this, \"changed\", { enumerable: false, configurable: false, writable: false, value: new events_1.Event() });\r\n            var isNew_1 = false;\r\n            if (typeof id === \"string\")\r\n                type.assertValidId(id);\r\n            else {\r\n                // Was id provided as undefined, or not provided at all?\r\n                if (id !== null && typeof id === \"object\")\r\n                    properties = id;\r\n                id = type.newId();\r\n                isNew_1 = context ? context.isNewDocument : true;\r\n            }\r\n            // If context was provided, it should be the last argument\r\n            context = arguments[arguments.length - 1];\r\n            if (!(context instanceof initilization_context_1.InitializationContext))\r\n                context = new initilization_context_1.InitializationContext(isNew_1);\r\n            Object.defineProperty(this, \"meta\", { enumerable: true, configurable: false, writable: false, value: new object_meta_1.ObjectMeta(type, this, id, isNew_1) });\r\n            Object.defineProperty(this, \"__fields__\", { enumerable: false, configurable: false, writable: false, value: {} });\r\n            Object.defineProperty(this, \"__pendingInit__\", { enumerable: false, configurable: false, writable: false, value: {} });\r\n            // Register the newly constructed instance\r\n            type.register(this);\r\n            // Initialize existing entity with provided property values\r\n            if (!isNew_1 && properties) {\r\n                // We need to pause processing of callbacks to prevent publishing entity events while still processing the state graph\r\n                context.execute(function () { return _this.init(properties, context); });\r\n            }\r\n            // Raise the initNew or initExisting event on this type and all base types\r\n            this.initialized = new Promise(function (resolve) {\r\n                context.whenReady(function () {\r\n                    // Set values of new entity for provided properties\r\n                    if (isNew_1 && properties)\r\n                        _this.updateWithContext(context, properties);\r\n                    for (var t = type; t; t = t.baseType) {\r\n                        if (isNew_1)\r\n                            t.initNew.publish(t, { entity: _this });\r\n                        else\r\n                            t.initExisting.publish(t, { entity: _this });\r\n                    }\r\n                    context.whenReady(resolve);\r\n                });\r\n            });\r\n        }\r\n    }\r\n    Entity.getSortedPropertyData = function (properties) {\r\n        return helpers_1.entries(properties).sort(function (a, b) {\r\n            return Number(b[1] instanceof Entity) - Number(a[1] instanceof Entity);\r\n        });\r\n    };\r\n    Entity.prototype.init = function (property, context, value) {\r\n        var _a;\r\n        var _this = this;\r\n        if (Entity.ctorDepth === 0) {\r\n            throw new Error(\"Entity.init() should not be called directly.\");\r\n        }\r\n        var properties;\r\n        // Convert property/value pair to a property dictionary\r\n        if (typeof property === \"string\")\r\n            properties = (_a = {}, _a[property] = value, _a);\r\n        else\r\n            properties = property;\r\n        var initializedProps = new Set();\r\n        var _loop_1 = function (propName, state) {\r\n            var prop = this_1.serializer.resolveProperty(this_1, propName);\r\n            if (prop && !prop.isCalculated && !prop.isConstant) {\r\n                initializedProps.add(prop);\r\n                var valueResolution = context.tryResolveValue(this_1, prop, state);\r\n                if (valueResolution)\r\n                    valueResolution.then(function (asyncState) { return _this.initProp(prop, asyncState, context); });\r\n                else\r\n                    this_1.initProp(prop, state, context);\r\n            }\r\n        };\r\n        var this_1 = this;\r\n        // Initialize the specified properties\r\n        for (var _i = 0, _b = Entity.getSortedPropertyData(properties); _i < _b.length; _i++) {\r\n            var _c = _b[_i], propName = _c[0], state = _c[1];\r\n            _loop_1(propName, state);\r\n        }\r\n        // Pass all unspecified properties through the deserializer to allow initialization logic via converters\r\n        for (var _d = 0, _e = this.meta.type.properties.filter(function (p) { return !initializedProps.has(p); }); _d < _e.length; _d++) {\r\n            var prop = _e[_d];\r\n            var value_1 = this.serializer.deserialize(this, undefined, prop, context);\r\n            if (value_1 !== undefined)\r\n                property_1.Property$init(prop, this, value_1);\r\n        }\r\n    };\r\n    Entity.prototype.initProp = function (prop, state, context) {\r\n        var value;\r\n        value = this.serializer.deserialize(this, state, prop, context);\r\n        if (value !== undefined)\r\n            property_1.Property$init(prop, this, value);\r\n    };\r\n    Entity.prototype.updateWithContext = function (context, state) {\r\n        var _this = this;\r\n        var hadContext = !!this._context;\r\n        // Do not allow reentrant updates of the same entity for a given context\r\n        if (this._context === context)\r\n            return;\r\n        // Don't overwrite existing context\r\n        if (!this._context)\r\n            this._context = context;\r\n        // Ensure provided context waits on the existing context to be ready\r\n        else if (this._context !== context)\r\n            context.wait(this._context.ready);\r\n        this.update(state);\r\n        if (context !== null && !hadContext) {\r\n            context.whenReady(function () {\r\n                _this._context = null;\r\n            });\r\n        }\r\n    };\r\n    Entity.createOrUpdate = function (type, state, context) {\r\n        var id = type_1.getIdFromState(type, state);\r\n        var isNew = !id;\r\n        if (!context)\r\n            context = new initilization_context_1.InitializationContext(isNew);\r\n        // We need to pause processing of callbacks to prevent publishing entity events while still processing\r\n        // the state graph\r\n        var instance = context.execute(function () {\r\n            var instance = id && type.get(id);\r\n            if (instance) {\r\n                // Assign state to the existing object\r\n                instance.updateWithContext(context, state);\r\n            }\r\n            else {\r\n                // Cast the jstype to any so we can call the internal constructor signature that takes a context\r\n                // We don't want to put the context on the public constructor interface\r\n                var Ctor = type.jstype;\r\n                // Construct an instance using the known id if it is present\r\n                instance = (id ? new Ctor(id, state, context) : new Ctor(state, context));\r\n            }\r\n            return instance;\r\n        });\r\n        return instance;\r\n    };\r\n    Entity.prototype.update = function (property, value) {\r\n        var _a;\r\n        var _this = this;\r\n        var properties;\r\n        // Convert property/value pair to a property dictionary\r\n        if (typeof property === \"string\")\r\n            properties = (_a = {}, _a[property] = value, _a);\r\n        else\r\n            properties = property;\r\n        if (!this._context) {\r\n            var wasNew_1 = this.meta.isNew;\r\n            var context_1 = new initilization_context_1.InitializationContext(true);\r\n            context_1.execute(function () { return _this.updateWithContext(context_1, properties); });\r\n            var markPersistedWhenIdAssigned = function () {\r\n                if (wasNew_1 && !_this.meta.isNew)\r\n                    _this.markPersisted();\r\n            };\r\n            // call markPersistedWhenIdAssigned using whenReady and after the promise resolves to ensure models with no async\r\n            // behavior produce the correct outcome upon returning from update()\r\n            context_1.whenReady(markPersistedWhenIdAssigned);\r\n            return context_1.ready.then(markPersistedWhenIdAssigned);\r\n        }\r\n        var context = this._context;\r\n        var _loop_2 = function (propName, state) {\r\n            var prop = this_2.serializer.resolveProperty(this_2, propName);\r\n            if (prop && !prop.isCalculated && !prop.isConstant) {\r\n                var valueResolution = context.tryResolveValue(this_2, prop, state);\r\n                if (valueResolution)\r\n                    valueResolution.then(function (asyncState) { return _this.setProp(prop, asyncState); });\r\n                else\r\n                    this_2.setProp(prop, state);\r\n            }\r\n        };\r\n        var this_2 = this;\r\n        // Set the specified properties\r\n        for (var _i = 0, _b = Entity.getSortedPropertyData(properties); _i < _b.length; _i++) {\r\n            var _c = _b[_i], propName = _c[0], state = _c[1];\r\n            _loop_2(propName, state);\r\n        }\r\n        return context.ready;\r\n    };\r\n    Entity.prototype.setProp = function (prop, state) {\r\n        var _this = this;\r\n        var value;\r\n        var currentValue = prop.value(this);\r\n        if (type_1.isEntityType(prop.propertyType)) {\r\n            var ChildEntity_1 = prop.propertyType;\r\n            if (prop.isList && Array.isArray(state) && Array.isArray(currentValue)) {\r\n                if (!state.length)\r\n                    currentValue.splice(0);\r\n                else {\r\n                    state.forEach(function (s, idx) {\r\n                        if (!(s instanceof ChildEntity_1))\r\n                            s = _this.serializer.deserialize(_this, s, prop, _this._context, false);\r\n                        // Undefined(IgnoreProperty) got assigned, so do not set the property\r\n                        if (s === undefined)\r\n                            return;\r\n                        // Modifying/replacing existing list item\r\n                        if (idx < currentValue.length) {\r\n                            // If the item is a state object, create/update the entity using the state\r\n                            if (!(s instanceof ChildEntity_1) && typeof s === \"object\") {\r\n                                var listItem = currentValue[idx];\r\n                                // If the entity is a non-pooled type, update in place\r\n                                // If the entity id matches the id in the state, update in place\r\n                                if (!ChildEntity_1.meta.identifier || type_1.getIdFromState(ChildEntity_1.meta, s) === listItem.meta.id)\r\n                                    listItem.updateWithContext(_this._context, s);\r\n                                else\r\n                                    currentValue.splice(idx, 1, Entity.createOrUpdate(ChildEntity_1.meta, s, _this._context));\r\n                            }\r\n                            else if (s instanceof ChildEntity_1)\r\n                                currentValue.splice(idx, 1, s);\r\n                            else\r\n                                console.warn(\"Provided state,\", s, \", is not valid for type \" + ChildEntity_1.meta.fullName + \"[].\");\r\n                        }\r\n                        // Add a list item\r\n                        else if (s instanceof ChildEntity_1)\r\n                            currentValue.push(s);\r\n                        else\r\n                            currentValue.push(Entity.createOrUpdate(ChildEntity_1.meta, s, _this._context));\r\n                    });\r\n                    // Remove excess items from the list\r\n                    currentValue.splice(state.length);\r\n                }\r\n                // Mark property pendingInit = false, since value is not assigned so the setter is not called\r\n                property_1.Property$pendingInit(this, prop, false);\r\n            }\r\n            else if (state instanceof ChildEntity_1)\r\n                value = state;\r\n            else if (state == null)\r\n                value = null;\r\n            else {\r\n                // Attempt to deserialize the state\r\n                var newState = this.serializer.deserialize(this, state, prop, this._context, false);\r\n                // Undefined(IgnoreProperty) got assigned, so do not set the property\r\n                if (newState === undefined)\r\n                    return;\r\n                if (typeof newState !== \"undefined\")\r\n                    state = newState;\r\n                // Got null, so assign null to the property\r\n                if (state == null)\r\n                    value = null;\r\n                // Got a valid instance, so use it\r\n                else if (state instanceof ChildEntity_1)\r\n                    value = state;\r\n                // Got something other than an object, so just use it and expect to get a down-stream error\r\n                else if (typeof state !== \"object\")\r\n                    value = state;\r\n                else if (currentValue && !type_1.getIdFromState(ChildEntity_1.meta, state))\r\n                    currentValue.updateWithContext(this._context, state);\r\n                // Got an object, so attempt to fetch or create and assign the state\r\n                else\r\n                    value = Entity.createOrUpdate(ChildEntity_1.meta, state, this._context);\r\n            }\r\n        }\r\n        else if (prop.isList && Array.isArray(state) && Array.isArray(currentValue)) {\r\n            currentValue.splice.apply(currentValue, __spreadArrays([0, currentValue.length], state.map(function (s) { return _this.serializer.deserialize(_this, s, prop, _this._context); })));\r\n            // Mark property pendingInit = false, since value is not assigned so the setter is not called\r\n            property_1.Property$pendingInit(this, prop, false);\r\n        }\r\n        else\r\n            value = this.serializer.deserialize(this, state, prop, this._context);\r\n        if (value !== undefined)\r\n            try {\r\n                property_1.Property$setter(prop, this, value);\r\n            }\r\n            catch (e) {\r\n                console.warn(e);\r\n            }\r\n    };\r\n    Entity.prototype.get = function (property) {\r\n        return this.meta.type.getProperty(property).value(this);\r\n    };\r\n    Entity.prototype.toString = function (format, formatEval) {\r\n        // Get the entity format to use\r\n        var formatter = null;\r\n        if (format) {\r\n            formatter = this.meta.type.model.getFormat(this.constructor, format, formatEval);\r\n        }\r\n        else {\r\n            formatter = this.meta.type.format;\r\n        }\r\n        // Use the formatter, if available, to create the string representation\r\n        if (formatter) {\r\n            return formatter.convert(this);\r\n        }\r\n        else {\r\n            return this.meta.type.fullName + \"|\" + this.meta.id;\r\n        }\r\n    };\r\n    Object.defineProperty(Entity.prototype, \"serializer\", {\r\n        get: function () {\r\n            return this.meta.type.model.serializer;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    /**\r\n     * Produces a JSON-valid object representation of the entity.\r\n     * @param entity\r\n     */\r\n    Entity.prototype.serialize = function (settings) {\r\n        if (settings === void 0) { settings = entity_serializer_1.DefaultSerializationSettings; }\r\n        return this.serializer.serialize(this, settings);\r\n    };\r\n    Entity.prototype.markPersisted = function () {\r\n        if (!this.meta.type.identifier || !this.meta.type.identifier.value(this))\r\n            return;\r\n        var visited = new Set();\r\n        var _persist = function (entity) {\r\n            if (visited.has(entity))\r\n                return;\r\n            visited.add(entity);\r\n            entity.meta.isNew = false;\r\n            // visit reference properties with non-identifying types\r\n            for (var _i = 0, _a = entity.meta.type.properties.filter(function (p) { return type_1.isEntityType(p.propertyType) && !p.propertyType.meta.identifier; }); _i < _a.length; _i++) {\r\n                var property = _a[_i];\r\n                var value = property.value(entity);\r\n                if (Array.isArray(value))\r\n                    value.forEach(function (item) { return _persist(item); });\r\n                else if (value)\r\n                    _persist(value);\r\n            }\r\n        };\r\n        _persist(this);\r\n    };\r\n    Entity.ctorDepth = 0;\r\n    return Entity;\r\n}());\r\nexports.Entity = Entity;\r\nfunction isEntity(obj) {\r\n    return obj && obj.meta && obj.meta.type && obj.meta.type.jstype && type_1.isEntityType(obj.meta.type.jstype);\r\n}\r\nexports.isEntity = isEntity;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.ObjectMeta = void 0;\r\nvar condition_type_1 = require(\"./condition-type\");\r\nvar observable_array_1 = require(\"./observable-array\");\r\nvar format_error_1 = require(\"./format-error\");\r\nvar ObjectMeta = /** @class */ (function () {\r\n    function ObjectMeta(type, entity, id, isNew) {\r\n        Object.defineProperty(this, \"type\", { enumerable: true, configurable: false, writable: false, value: type });\r\n        Object.defineProperty(this, \"entity\", { enumerable: true, configurable: false, writable: false, value: entity });\r\n        Object.defineProperty(this, \"id\", { enumerable: true, configurable: false, writable: true, value: id });\r\n        Object.defineProperty(this, \"isNew\", { enumerable: true, configurable: false, writable: true, value: isNew });\r\n        Object.defineProperty(this, \"conditions\", { enumerable: true, configurable: false, writable: true, value: observable_array_1.ObservableArray.create() });\r\n        Object.defineProperty(this, \"__pendingInvocation__\", { enumerable: false, configurable: false, writable: false, value: [] });\r\n    }\r\n    /**\r\n     * Gets the condition target with the specified condition type\r\n     * @param conditionType The type of condition to retrieve\r\n     */\r\n    ObjectMeta.prototype.getCondition = function (conditionType) {\r\n        return this.conditions.filter(function (c) { return c.condition.type === conditionType; })[0];\r\n    };\r\n    /**\r\n     * Stores the condition target for the current instance\r\n     * @param conditionTarget The condition target to store\r\n     */\r\n    ObjectMeta.prototype.setCondition = function (conditionTarget) {\r\n        if (conditionTarget.condition.type !== format_error_1.FormatError.ConditionType) {\r\n            this.conditions.push(conditionTarget);\r\n        }\r\n    };\r\n    /**\r\n     * Clears the condition for the current instance with the specified condition type\r\n     * @param conditionType The type of condition to clear\r\n     */\r\n    ObjectMeta.prototype.clearCondition = function (conditionType) {\r\n        for (var i = 0; i < this.conditions.length; i++) {\r\n            var conditionTarget = this.conditions[i];\r\n            if (conditionTarget.condition.type === conditionType) {\r\n                this.conditions.splice(i--, 1);\r\n            }\r\n        }\r\n    };\r\n    /**\r\n     * Determines if the set of permissions are allowed for the current instance\r\n     * @param codes The permission condition type code(s)\r\n     */\r\n    ObjectMeta.prototype.isAllowed = function () {\r\n        var codes = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            codes[_i] = arguments[_i];\r\n        }\r\n        // ensure each condition type is allowed for the current instance\r\n        for (var c = codes.length - 1; c >= 0; c--) {\r\n            var code = codes[c];\r\n            var conditionType = condition_type_1.ConditionType.get(code);\r\n            // return undefined if the condition type does not exist\r\n            if (conditionType === undefined) {\r\n                return undefined;\r\n            }\r\n            // throw an exception if the condition type is not a permission\r\n            if (!(conditionType instanceof condition_type_1.PermissionConditionType)) {\r\n                throw new Error(\"Condition type \\\"\" + code + \"\\\" should be a Permission.\");\r\n            }\r\n            // return false if a condition of the current type exists and is a deny permission or does not exist and is a grant permission\r\n            if (this.getCondition(conditionType) ? !conditionType.isAllowed : conditionType.isAllowed) {\r\n                return false;\r\n            }\r\n        }\r\n        return true;\r\n    };\r\n    return ObjectMeta;\r\n}());\r\nexports.ObjectMeta = ObjectMeta;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.CalculatedPropertyRule = void 0;\r\nvar rule_1 = require(\"./rule\");\r\nvar property_1 = require(\"./property\");\r\nvar observable_array_1 = require(\"./observable-array\");\r\nvar rule_invocation_type_1 = require(\"./rule-invocation-type\");\r\nvar calculationErrorDefault = null;\r\nvar CalculatedPropertyRule = /** @class */ (function (_super) {\r\n    __extends(CalculatedPropertyRule, _super);\r\n    function CalculatedPropertyRule(rootType, name, options) {\r\n        var _this = this;\r\n        var property;\r\n        var defaultIfError = calculationErrorDefault;\r\n        var calculateFn;\r\n        if (!name) {\r\n            name = options.name;\r\n        }\r\n        if (options) {\r\n            if (options.property) {\r\n                property = typeof options.property === \"string\" ? rootType.getProperty(options.property) : options.property;\r\n                // indicate that the rule is responsible for returning the value of the calculated property\r\n                options.returns = [property];\r\n            }\r\n            if (!name) {\r\n                // Generate a reasonable default rule name if not specified\r\n                name = options.name = (rootType.fullName + \".\" + (typeof property === \"string\" ? property : property.name) + \".Calculated\");\r\n            }\r\n            if (options.hasOwnProperty(\"defaultIfError\"))\r\n                defaultIfError = options.defaultIfError;\r\n            calculateFn = options.calculate;\r\n        }\r\n        // Call the base rule constructor\r\n        _this = _super.call(this, rootType, name, options) || this;\r\n        // Public read-only properties\r\n        Object.defineProperty(_this, \"property\", { enumerable: true, value: property });\r\n        // Public settable properties\r\n        _this.defaultIfError = defaultIfError;\r\n        _this.isDefaultValue = !!options.isDefaultValue;\r\n        // Backing fields for properties\r\n        if (calculateFn)\r\n            Object.defineProperty(_this, \"_calculateFn\", { enumerable: false, value: calculateFn, writable: true });\r\n        // register the rule with the target property\r\n        _this.property.rules.push(_this);\r\n        // mark the property as calculated if the rule runs on property access and is not a default value calculation\r\n        if (!options.isDefaultValue && _this.invocationTypes & rule_invocation_type_1.RuleInvocationType.PropertyGet)\r\n            _this.property.isCalculated = true;\r\n        return _this;\r\n    }\r\n    CalculatedPropertyRule.prototype.register = function () {\r\n        var _this = this;\r\n        _super.prototype.register.call(this);\r\n        if (this.isDefaultValue) {\r\n            // Ensure that a default value rule will run if a calculation that it depends on is changed.\r\n            // A property with a default value rule may have a persisted value, in which case it will\r\n            // not run unless one of its predicates fires a change event. A calculation will not fire\r\n            // a change event the first time it runs if it didn't previously have a value, which may\r\n            // be the case for existing instances if the calculation is never accessed (ex: a hidden field).\r\n            // So, in order to ensure that the default rule's calculated predicates fire a change event,\r\n            // we must ensure that the calculation is accessed when the object is initialized.\r\n            this.rootType.initExisting.subscribe(function (args) {\r\n                // If the property is initialized (i.e. it has an initial persisted value),\r\n                // run the calculation and throw away the result.\r\n                var initialValue = args.entity.__fields__[_this.property.name];\r\n                if (initialValue !== undefined) {\r\n                    try {\r\n                        _this.calculateFn.call(args.entity);\r\n                    }\r\n                    catch (e) {\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    };\r\n    Object.defineProperty(CalculatedPropertyRule.prototype, \"calculateFn\", {\r\n        get: function () {\r\n            var calculateFn;\r\n            // Convert string functions into compiled functions on first execution\r\n            if (this._calculateFn.constructor === String) {\r\n                // TODO: Calculation expression support\r\n                var calculateExpr = this._calculateFn;\r\n                var calculateCompiledFn = new Function(\"return \" + calculateExpr + \";\");\r\n                calculateFn = this._calculateFn = calculateCompiledFn;\r\n            }\r\n            else {\r\n                calculateFn = this._calculateFn;\r\n            }\r\n            return calculateFn;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    CalculatedPropertyRule.prototype.execute = function (obj) {\r\n        // Calculate the new property value\r\n        var newValue;\r\n        if (this.defaultIfError === undefined) {\r\n            newValue = this.calculateFn.call(obj);\r\n        }\r\n        else {\r\n            try {\r\n                newValue = this.calculateFn.call(obj);\r\n            }\r\n            catch (e) {\r\n                newValue = this.defaultIfError;\r\n            }\r\n        }\r\n        // Exit immediately if the calculated result was undefined\r\n        if (newValue === undefined) {\r\n            return;\r\n        }\r\n        // modify list properties to match the calculated value instead of overwriting the property\r\n        if (this.property.isList) {\r\n            var newList_1 = newValue;\r\n            // ensure the initial calculation of the list does not raise change events\r\n            // defaulting a list property should raise change events\r\n            if (!this.isDefaultValue && !this.property.isInited(obj))\r\n                property_1.Property$init(this.property, obj, newList_1);\r\n            else {\r\n                // compare the new list to the old one to see if changes were made\r\n                var curList = this.property.value(obj);\r\n                if (newList_1.length === curList.length) {\r\n                    var noChanges = true;\r\n                    for (var i = 0; i < newList_1.length; ++i) {\r\n                        if (newList_1[i] !== curList[i]) {\r\n                            noChanges = false;\r\n                            break;\r\n                        }\r\n                    }\r\n                    if (noChanges) {\r\n                        return;\r\n                    }\r\n                }\r\n                // update the current list so observers will receive the change events\r\n                // events will not be raised if this is the initial calculation of the list\r\n                curList.batchUpdate(function (array) {\r\n                    observable_array_1.updateArray(array, newList_1);\r\n                });\r\n            }\r\n        }\r\n        else {\r\n            // Otherwise, just set the property to the new value\r\n            this.property.value(obj, newValue, { calculated: true });\r\n        }\r\n    };\r\n    CalculatedPropertyRule.prototype.toString = function () {\r\n        return \"calculation of \" + this.property.name;\r\n    };\r\n    return CalculatedPropertyRule;\r\n}(rule_1.Rule));\r\nexports.CalculatedPropertyRule = CalculatedPropertyRule;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.StringFormatRule = void 0;\r\nvar validation_rule_1 = require(\"./validation-rule\");\r\nvar StringFormatRule = /** @class */ (function (_super) {\r\n    __extends(StringFormatRule, _super);\r\n    /**\r\n     * Creates a rule that validates that a string property value is correctly formatted.\r\n     * @param rootType The model type the rule is for.\r\n     * @param options The options for the rules.\r\n     */\r\n    function StringFormatRule(rootType, options) {\r\n        var _this = this;\r\n        // exit immediately if called with no arguments\r\n        if (arguments.length > 0) {\r\n            // ensure the rule name is specified\r\n            options.name = options.name || \"StringFormat\";\r\n            // see if the error message is a valid resource: {resource-name}\r\n            if (typeof options.message === \"string\" && rootType.model.resourceExists(options.message)) {\r\n                var message_1 = options.message;\r\n                options.message = function () { return rootType.model.getResource(message_1); };\r\n            }\r\n            // get the default validation message if not specified\r\n            if (!options.message) {\r\n                options.message = function () { return rootType.model.getResource(\"string-format\").replace(\"{formatDescription}\", options.description); };\r\n            }\r\n            var expression_1 = options.expression instanceof RegExp ? options.expression : RegExp(options.expression);\r\n            var reformat_1 = options.reformat;\r\n            // create the string format validation function\r\n            options.isValid = function (prop, val) {\r\n                var isValid = true;\r\n                if (val && val !== \"\") {\r\n                    expression_1.lastIndex = 0;\r\n                    isValid = expression_1.test(val);\r\n                    if (isValid && options.reformat) {\r\n                        if (reformat_1 instanceof Function) {\r\n                            val = reformat_1(val);\r\n                        }\r\n                        else {\r\n                            expression_1.lastIndex = 0;\r\n                            val = val.replace(expression_1, reformat_1);\r\n                        }\r\n                        prop.value(this, val);\r\n                    }\r\n                }\r\n                return isValid;\r\n            };\r\n        }\r\n        // call the base type constructor\r\n        _this = _super.call(this, rootType, options) || this;\r\n        // define properties for the rule\r\n        _this.description = options.description;\r\n        return _this;\r\n    }\r\n    // get the string representation of the rule\r\n    StringFormatRule.prototype.toString = function () {\r\n        return this.property.containingType.fullName + \".\" + this.property.name + \" formatted as \" + this.description;\r\n    };\r\n    return StringFormatRule;\r\n}(validation_rule_1.ValidationRule));\r\nexports.StringFormatRule = StringFormatRule;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.ConditionRule = void 0;\r\nvar rule_1 = require(\"./rule\");\r\nvar condition_type_1 = require(\"./condition-type\");\r\nvar ConditionRule = /** @class */ (function (_super) {\r\n    __extends(ConditionRule, _super);\r\n    /**\r\n     * Creates a rule that asserts a condition based on a predicate\r\n     * @param rootType The model type the rule is for\r\n     * @param options The options for the rule, of type ConditionRuleOptions\r\n     */\r\n    function ConditionRule(rootType, options) {\r\n        var _this = this;\r\n        // automatically run the condition rule during initialization of new and existing instances\r\n        options.onInit = true;\r\n        // call the base rule constructor\r\n        _this = _super.call(this, rootType, options.name, options) || this;\r\n        // assertion function\r\n        _this.assert = options.assert;\r\n        // message\r\n        _this.message = options.message;\r\n        // condition type\r\n        _this.conditionType = options.conditionType ? (typeof options.conditionType === \"string\" ?\r\n            condition_type_1.ConditionType.get(options.conditionType) :\r\n            options.conditionType) :\r\n            rule_1.Rule$ensureConditionType(options.name, rootType, options.category || \"Error\");\r\n        // properties\r\n        _this.properties = options.properties;\r\n        return _this;\r\n    }\r\n    // asserts the condition and adds or removes it from the model if necessary\r\n    ConditionRule.prototype.execute = function (entity) {\r\n        var assert;\r\n        var message;\r\n        if (this.assert) {\r\n            // If an assert function is defined, then use it to determine whether to attach a condition\r\n            assert = this.assert.call(entity);\r\n            message = typeof this.message === \"string\" ? this.message : this.message.call(entity);\r\n        }\r\n        else if (this.message instanceof Function) {\r\n            message = this.message.call(entity);\r\n            assert = typeof message === \"string\" && message.trim().length > 0;\r\n        }\r\n        // create or remove the condition if necessary\r\n        if (typeof assert !== \"undefined\") {\r\n            // pass through \"this\" so it can add the source when the rule is constructed\r\n            // Add the source to the condition instead of the condition type\r\n            this.conditionType.when(this, assert, entity, message);\r\n        }\r\n    };\r\n    // gets the string representation of the condition rule\r\n    ConditionRule.prototype.toString = function () {\r\n        return typeof this.message === \"string\" ? this.message : this.conditionType.message;\r\n    };\r\n    return ConditionRule;\r\n}(rule_1.Rule));\r\nexports.ConditionRule = ConditionRule;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.AllowedValuesRule = void 0;\r\nvar validation_rule_1 = require(\"./validation-rule\");\r\nvar property_1 = require(\"./property\");\r\nvar property_chain_1 = require(\"./property-chain\");\r\nvar AllowedValuesRule = /** @class */ (function (_super) {\r\n    __extends(AllowedValuesRule, _super);\r\n    /**\r\n     * Creates a rule that validates whether a selected value or values is in a list of allowed values.\r\n     * @param rootType The root type to bind the rule to\r\n     * @param options The rule configuration options\r\n     */\r\n    function AllowedValuesRule(rootType, options) {\r\n        var _this = this;\r\n        // ensure the rule name is specified\r\n        options.name = options.name || \"AllowedValues\";\r\n        // ensure the error message is specified\r\n        options.message = options.message || function () { return rootType.model.getResource(\"allowed-values\"); };\r\n        // convert property path sources into a source function\r\n        var source;\r\n        if (options.source instanceof property_1.Property || options.source instanceof property_chain_1.PropertyChain) {\r\n            var sourcePath_1 = options.source;\r\n            options.onChangeOf = [sourcePath_1];\r\n            options.source = source = function () { return sourcePath_1.value(this); };\r\n        }\r\n        else\r\n            source = options.source;\r\n        // create the validation function\r\n        options.isValid = function (prop, value) {\r\n            if (options.ignoreValidation) {\r\n                return true;\r\n            }\r\n            // return true if no value is currently selected\r\n            if (!value) {\r\n                return true;\r\n            }\r\n            // get the list of allowed values of the property for the given object\r\n            var allowed = source.call(this);\r\n            // ensure that the value or list of values is in the allowed values list (single and multi-select)\r\n            if (value instanceof Array) {\r\n                return value.every(function (item) { return allowed.indexOf(item) >= 0; });\r\n            }\r\n            else {\r\n                return allowed.indexOf(value) >= 0;\r\n            }\r\n        };\r\n        // call the base type constructor\r\n        _this = _super.call(this, rootType, options) || this;\r\n        // store the allowed values source\r\n        _this.source = source;\r\n        _this.ignoreValidation = !!options.ignoreValidation;\r\n        _this.preventInvalidValues = !!options.preventInvalidValues;\r\n        return _this;\r\n    }\r\n    AllowedValuesRule.prototype.values = function (obj) {\r\n        return this.source.call(obj);\r\n    };\r\n    AllowedValuesRule.prototype.toString = function () {\r\n        return this.property.containingType.fullName + \".\" + this.property.name + \" allowed values\";\r\n    };\r\n    return AllowedValuesRule;\r\n}(validation_rule_1.ValidationRule));\r\nexports.AllowedValuesRule = AllowedValuesRule;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.RequiredRule = void 0;\r\nvar validation_rule_1 = require(\"./validation-rule\");\r\n/**\r\n * A rule that validates that a property has a value\r\n */\r\nvar RequiredRule = /** @class */ (function (_super) {\r\n    __extends(RequiredRule, _super);\r\n    /**\r\n     * Creates a rule that validates that a property has a value.\r\n     * @param rootType The model type the rule is for\r\n     * @param options The options for the rule\r\n     */\r\n    function RequiredRule(rootType, options) {\r\n        var _this = this;\r\n        // ensure the rule name is specified\r\n        options.name = options.name || \"Required\";\r\n        if (typeof options.message === \"function\") {\r\n            if (options.when) {\r\n                var messageFn_1 = options.message;\r\n                options.message = function () {\r\n                    if (options.when && !options.when.call(this))\r\n                        return null;\r\n                    return messageFn_1.call(this);\r\n                };\r\n            }\r\n        }\r\n        else {\r\n            // ensure the error message is specified\r\n            options.message = options.message || function () { return rootType.model.getResource(\"required\"); };\r\n            if (options.isValid) {\r\n                if (options.when) {\r\n                    var isValidFn_1 = options.isValid;\r\n                    options.isValid = function () {\r\n                        if (options.when && !options.when.call(this)) {\r\n                            // Valid whether or not there is a value, since requiredness is not in effect\r\n                            return true;\r\n                        }\r\n                        return isValidFn_1.apply(this, arguments);\r\n                    };\r\n                }\r\n            }\r\n            else if (options.message) {\r\n                // create the validation function based on the rule options\r\n                options.isValid = function (prop, val) {\r\n                    if (options.when && !options.when.call(this)) {\r\n                        // Valid whether or not there is a value, since requiredness is not in effect\r\n                        return true;\r\n                    }\r\n                    if (val === undefined || val === null)\r\n                        return false;\r\n                    // Blank string does not pass required check\r\n                    if (typeof val === \"string\" && val.trim() === \"\")\r\n                        return false;\r\n                    // Empty array does not pass required check\r\n                    if (Array.isArray(val) && val.length === 0)\r\n                        return false;\r\n                    // False does not pass required check\r\n                    if (typeof val === \"boolean\" && val === false)\r\n                        return false;\r\n                    return true;\r\n                };\r\n            }\r\n        }\r\n        // call the base type constructor\r\n        _this = _super.call(this, rootType, options) || this;\r\n        return _this;\r\n    }\r\n    // get the string representation of the rule\r\n    RequiredRule.prototype.toString = function () {\r\n        return this.property.containingType.fullName + \".\" + this.property.name + \" is required\";\r\n    };\r\n    return RequiredRule;\r\n}(validation_rule_1.ValidationRule));\r\nexports.RequiredRule = RequiredRule;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.ConditionTarget = void 0;\r\nvar format_error_1 = require(\"./format-error\");\r\n/** Represents the association of a condition to a specific target entity. */\r\nvar ConditionTarget = /** @class */ (function () {\r\n    /**\r\n    * Creates the association of a condition to a specific target entity.\r\n    * @param condition The condition the target is for.\r\n    * @param target The target entity the condition is associated with.\r\n    * @param properties The set of properties on the target entity the condition is related to.\r\n    */\r\n    function ConditionTarget(condition, target, properties) {\r\n        this.condition = condition;\r\n        this.target = target;\r\n        this.properties = properties;\r\n        // Attach the condition target to the target entity.\r\n        if (this.condition.type !== format_error_1.FormatError.ConditionType) {\r\n            target.meta.setCondition(this);\r\n        }\r\n    }\r\n    return ConditionTarget;\r\n}());\r\nexports.ConditionTarget = ConditionTarget;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.Functor$clear = exports.Functor$isEmpty = exports.Functor$remove = exports.Functor$add = exports.FunctorItem$new = exports.Functor$create = void 0;\r\nfunction Functor$create(returns) {\r\n    if (returns === void 0) { returns = false; }\r\n    var funcs = [];\r\n    // TODO: Detect functor invocation resulting in continually adding subscribers\r\n    function Functor$fn() {\r\n        var returnsArray;\r\n        if (returns) {\r\n            returnsArray = [];\r\n        }\r\n        for (var i = 0; i < funcs.length; ++i) {\r\n            var item = funcs[i];\r\n            // Don't re-run one-time subscriptions that have already been applied.\r\n            if (item.applied === true) {\r\n                continue;\r\n            }\r\n            // Ensure that there is either no filter or the filter passes.\r\n            if (!item.filter || item.filter.apply(this, arguments) === true) {\r\n                // If handler is set to execute once,\r\n                // remove the handler before calling.\r\n                if (item.once === true) {\r\n                    // Mark as applied but leave item in array to avoid potential\r\n                    // problems due to re-entry into event invalidating iteration\r\n                    // index. In some cases re-entry would be a red-flag, but for\r\n                    // \"global\" events, where the context of the event is derived\r\n                    // from the arguments, the event could easily be re-entered\r\n                    // in a different context with different arguments.\r\n                    item.applied = true;\r\n                }\r\n                // Call the handler function.\r\n                var returnValue = item.fn.apply(this, arguments);\r\n                if (returns) {\r\n                    returnsArray.push(returnValue);\r\n                }\r\n            }\r\n        }\r\n        if (returns) {\r\n            return returnsArray;\r\n        }\r\n    }\r\n    ;\r\n    var f = Functor$fn;\r\n    f._funcs = funcs;\r\n    f.add = Functor$add;\r\n    f.remove = Functor$remove;\r\n    f.isEmpty = Functor$isEmpty;\r\n    f.clear = Functor$clear;\r\n    return f;\r\n}\r\nexports.Functor$create = Functor$create;\r\nfunction FunctorItem$new(fn, filter, once) {\r\n    if (filter === void 0) { filter = null; }\r\n    if (once === void 0) { once = false; }\r\n    var item = { fn: fn };\r\n    if (filter != null) {\r\n        item.filter = filter;\r\n    }\r\n    if (once != null) {\r\n        item.once = once;\r\n    }\r\n    return item;\r\n}\r\nexports.FunctorItem$new = FunctorItem$new;\r\nfunction Functor$add(fn, filter, once) {\r\n    if (filter === void 0) { filter = null; }\r\n    if (once === void 0) { once = false; }\r\n    var item = FunctorItem$new(fn, filter, once);\r\n    this._funcs.push(item);\r\n}\r\nexports.Functor$add = Functor$add;\r\nfunction Functor$remove(fn) {\r\n    for (var i = this._funcs.length - 1; i >= 0; --i) {\r\n        if (this._funcs[i].fn === fn) {\r\n            this._funcs.splice(i, 1);\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\nexports.Functor$remove = Functor$remove;\r\nfunction Functor$isEmpty(args) {\r\n    if (args === void 0) { args = null; }\r\n    return !this._funcs.some(function (item) { return item.applied !== true && (!args || !item.filter || item.filter.apply(this, args)); }, this);\r\n}\r\nexports.Functor$isEmpty = Functor$isEmpty;\r\nfunction Functor$clear() {\r\n    this._funcs.length = 0;\r\n}\r\nexports.Functor$clear = Functor$clear;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.RangeRule = void 0;\r\nvar validation_rule_1 = require(\"./validation-rule\");\r\nvar property_1 = require(\"./property\");\r\nvar model_1 = require(\"./model\");\r\n/**\r\n * A rule that validates that a property value is within a specific range\r\n */\r\nvar RangeRule = /** @class */ (function (_super) {\r\n    __extends(RangeRule, _super);\r\n    /**\r\n     * Creates a rule that validates a property value is within a specific range\r\n     * @param rootType The model type the rule is for\r\n     * @param options The options for the rule\r\n     */\r\n    function RangeRule(rootType, options) {\r\n        var _this = this;\r\n        // ensure the rule name is specified\r\n        options.name = options.name || \"Range\";\r\n        options.message = function () {\r\n            var format = options.property.format;\r\n            var val = model_1.normalize(options.property.value(this), format);\r\n            if (val == null) {\r\n                return null;\r\n            }\r\n            var range = {};\r\n            if (options.min && options.min instanceof Function) {\r\n                try {\r\n                    range.min = model_1.normalize(options.min.call(this), format);\r\n                }\r\n                catch (e) {\r\n                    // Silently ignore min errors\r\n                }\r\n            }\r\n            if (options.max && options.max instanceof Function) {\r\n                try {\r\n                    range.max = model_1.normalize(options.max.call(this), format);\r\n                }\r\n                catch (e) {\r\n                    // Silently ignore max errors\r\n                }\r\n            }\r\n            if ((range.min == null || val >= range.min) && (range.max == null || val <= range.max)) {\r\n                // Value is within range\r\n                return null;\r\n            }\r\n            var hasMin = range.min || range.min === 0;\r\n            var hasMax = range.max || range.max === 0;\r\n            if (hasMin && hasMax)\r\n                return rootType.model.getResource(\"range-between\").replace(\"{min}\", property_1.Property$format(options.property, range.min) || range.min).replace(\"{max}\", property_1.Property$format(options.property, range.max) || range.max);\r\n            if (options.property.propertyType === Date) {\r\n                if (hasMin)\r\n                    return rootType.model.getResource(\"range-on-or-after\").replace(\"{min}\", property_1.Property$format(options.property, range.min) || range.min);\r\n                else\r\n                    return rootType.model.getResource(\"range-on-or-before\").replace(\"{max}\", property_1.Property$format(options.property, range.max) || range.max);\r\n            }\r\n            if (hasMin)\r\n                return rootType.model.getResource(\"range-at-least\").replace(\"{min}\", property_1.Property$format(options.property, range.min) || range.min);\r\n            else\r\n                return rootType.model.getResource(\"range-at-most\").replace(\"{max}\", property_1.Property$format(options.property, range.max) || range.max);\r\n        };\r\n        // call the base type constructor\r\n        _this = _super.call(this, rootType, options) || this;\r\n        return _this;\r\n    }\r\n    // get the string representation of the rule\r\n    RangeRule.prototype.toString = function () {\r\n        return this.property.containingType.fullName + \".\" + this.property.name + \" in range, min: , max: \";\r\n    };\r\n    return RangeRule;\r\n}(validation_rule_1.ValidationRule));\r\nexports.RangeRule = RangeRule;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.StringLengthRule = void 0;\r\nvar validation_rule_1 = require(\"./validation-rule\");\r\n/**\r\n * A rule that validates that validates that the length of a string property is within a specific range\r\n */\r\nvar StringLengthRule = /** @class */ (function (_super) {\r\n    __extends(StringLengthRule, _super);\r\n    /**\r\n     * Creates a rule that validates that the length of a string property is within a specific range\r\n     * @param rootType The model type the rule is for\r\n     * @param options The options for the rule\r\n     */\r\n    function StringLengthRule(rootType, options) {\r\n        var _this = this;\r\n        // ensure the rule name is specified\r\n        options.name = options.name || \"StringLength\";\r\n        options.message = function () {\r\n            var range = {};\r\n            if (options.min && options.min instanceof Function) {\r\n                try {\r\n                    range.min = options.min.call(this);\r\n                }\r\n                catch (e) {\r\n                    // Silently ignore min errors\r\n                }\r\n            }\r\n            if (options.max && options.max instanceof Function) {\r\n                try {\r\n                    range.max = options.max.call(this);\r\n                }\r\n                catch (e) {\r\n                    // Silently ignore max errors\r\n                }\r\n            }\r\n            var val = options.property.value(this);\r\n            if (val == null || typeof val !== \"string\" || val.length === 0) {\r\n                return null;\r\n            }\r\n            if ((range.min == null || val.length >= range.min) && (range.max == null || val.length <= range.max)) {\r\n                // Value is within range\r\n                return null;\r\n            }\r\n            if (range.min != null && range.max != null)\r\n                return rootType.model.getResource(\"string-length-between\").replace(\"{min}\", range.min.toString()).replace(\"{max}\", range.max.toString());\r\n            if (range.min != null)\r\n                return rootType.model.getResource(\"string-length-at-least\").replace(\"{min}\", range.min.toString());\r\n            else\r\n                return rootType.model.getResource(\"string-length-at-most\").replace(\"{max}\", range.max.toString());\r\n        };\r\n        // call the base type constructor\r\n        _this = _super.call(this, rootType, options) || this;\r\n        return _this;\r\n    }\r\n    // get the string representation of the rule\r\n    StringLengthRule.prototype.toString = function () {\r\n        return this.property.containingType.fullName + \".\" + this.property.name + \" string length, min: , max: \";\r\n    };\r\n    return StringLengthRule;\r\n}(validation_rule_1.ValidationRule));\r\nexports.StringLengthRule = StringLengthRule;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.ListLengthRule = void 0;\r\nvar validation_rule_1 = require(\"./validation-rule\");\r\nvar ListLengthRule = /** @class */ (function (_super) {\r\n    __extends(ListLengthRule, _super);\r\n    function ListLengthRule(rootType, options) {\r\n        var _this = this;\r\n        // ensure the rule name is specified\r\n        options.name = options.name || \"ListLength\";\r\n        options.message = function () {\r\n            var range = {};\r\n            if (options.min && options.min instanceof Function) {\r\n                try {\r\n                    range.min = options.min.call(this);\r\n                }\r\n                catch (e) {\r\n                    // Silently ignore min errors\r\n                }\r\n            }\r\n            else if (typeof (options.min) === \"number\") {\r\n                range.min = options.min;\r\n            }\r\n            if (options.max && options.max instanceof Function) {\r\n                try {\r\n                    range.max = options.max.call(this);\r\n                }\r\n                catch (e) {\r\n                    // Silently ignore max errors\r\n                }\r\n            }\r\n            else if (typeof (options.min) === \"number\") {\r\n                range.min = options.min;\r\n            }\r\n            var val = options.property.value(this);\r\n            if (!val) {\r\n                return null;\r\n            }\r\n            if ((range.min == null || val.length >= range.min) && (range.max == null || val.length <= range.max)) {\r\n                // Value is within range\r\n                return null;\r\n            }\r\n            if (range.min != null && range.max != null)\r\n                return rootType.model.getResource(\"listlength-between\").replace(\"{min}\", range.min.toString()).replace(\"{max}\", range.max.toString());\r\n            if (range.min != null)\r\n                return rootType.model.getResource(\"listlength-at-least\").replace(\"{min}\", range.min.toString());\r\n            else\r\n                return rootType.model.getResource(\"listlength-at-most\").replace(\"{max}\", range.max.toString());\r\n        };\r\n        // call the base type constructor\r\n        _this = _super.call(this, rootType, options) || this;\r\n        return _this;\r\n    }\r\n    return ListLengthRule;\r\n}(validation_rule_1.ValidationRule));\r\nexports.ListLengthRule = ListLengthRule;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.EventScope = exports.EVENT_SCOPE_DEFAULT_SETTINGS = void 0;\r\nvar events_1 = require(\"./events\");\r\nvar helpers_1 = require(\"./helpers\");\r\nexports.EVENT_SCOPE_DEFAULT_SETTINGS = {\r\n    maxExitingTransferCount: 100,\r\n    maxDepth: 1000\r\n};\r\nvar __lastEventScopeId = 0;\r\nvar EventScope = /** @class */ (function () {\r\n    function EventScope(parent, maxExitingTransferCount, maxDepth, isActive) {\r\n        if (isActive === void 0) { isActive = false; }\r\n        this.current = null;\r\n        this.parent = parent;\r\n        this.current = null;\r\n        this.isActive = isActive;\r\n        this.settings = { maxExitingTransferCount: maxExitingTransferCount, maxDepth: maxDepth };\r\n        this.onError = new events_1.Event();\r\n        this._uid = ++__lastEventScopeId;\r\n        this._depth = parent === null ? 1 : parent._depth + 1;\r\n        this._onExit = new events_1.Event();\r\n    }\r\n    EventScope.create = function (_a) {\r\n        var _b = _a.maxExitingTransferCount, maxExitingTransferCount = _b === void 0 ? exports.EVENT_SCOPE_DEFAULT_SETTINGS.maxExitingTransferCount : _b, _c = _a.maxDepth, maxDepth = _c === void 0 ? exports.EVENT_SCOPE_DEFAULT_SETTINGS.maxDepth : _c;\r\n        return new EventScope(null, maxExitingTransferCount, maxDepth, false);\r\n    };\r\n    /**\r\n     * Creates a new event scope, performs the action, then exits the scope\r\n     * @param callback The action to perform within the new scope\r\n     */\r\n    EventScope.prototype.perform = function (callback) {\r\n        var scope = new EventScope(this.current, this.settings.maxExitingTransferCount, this.settings.maxDepth, true);\r\n        var isDisposing = false;\r\n        try {\r\n            this.current = scope;\r\n            if (scope._depth >= this.settings.maxDepth)\r\n                throw new Error(\"Exceeded max scope depth.\");\r\n            // Invoke the callback\r\n            callback();\r\n            // Dispose of the event scope\r\n            isDisposing = true;\r\n            this.current.dispose({ abort: false });\r\n        }\r\n        catch (e) {\r\n            if (!isDisposing)\r\n                this.current.dispose({ abort: true });\r\n            var errorEvent = this.onError.publish(this, { error: e });\r\n            if (errorEvent === undefined || !errorEvent.isDefaultPrevented)\r\n                throw e;\r\n        }\r\n        finally {\r\n            // Roll back to the closest active scope\r\n            while (this.current && !this.current.isActive) {\r\n                this.current = this.current.parent;\r\n            }\r\n        }\r\n    };\r\n    /**\r\n     * Subscribes to the \"exit\" event of the current scope, or invokes immediately if there is not a current scope\r\n     * @param handler The event handler to invoke when exited\r\n     */\r\n    EventScope.prototype.onExit = function (handler) {\r\n        if (this.current === null) {\r\n            // Immediately invoke the callback\r\n            handler({ abort: false });\r\n        }\r\n        else if (!this.current.isActive) {\r\n            throw new Error(\"The current event scope cannot be inactive.\");\r\n        }\r\n        else {\r\n            // Subscribe to the exit event\r\n            this.current._onExit.subscribe(handler);\r\n        }\r\n    };\r\n    EventScope.prototype.dispose = function (_a) {\r\n        var _b = _a.abort, abort = _b === void 0 ? false : _b;\r\n        if (!this.isActive) {\r\n            throw new Error(\"The event scope cannot be exited because it is not active.\");\r\n        }\r\n        try {\r\n            if (abort) {\r\n                this._onExit.publish(this, { abort: true });\r\n            }\r\n            else {\r\n                var exitSubscriptions = helpers_1.getEventSubscriptions(this._onExit);\r\n                if (exitSubscriptions && exitSubscriptions.length > 0) {\r\n                    // If there is no parent scope, then go ahead and execute the 'exit' event\r\n                    if (this.parent === null || !this.parent.isActive) {\r\n                        // Record the initial \"version\" before starting to call subscribers\r\n                        this._exitEventVersion = 0;\r\n                        // Invoke all subscribers\r\n                        this._onExit.publish(this, { abort: false });\r\n                        // Delete the field to indicate that raising the exit event suceeded\r\n                        delete this._exitEventVersion;\r\n                    }\r\n                    else {\r\n                        try {\r\n                            // Attempt to move subscribers to the parent scope\r\n                            this.parent.receiveExitEventSubscribers(exitSubscriptions);\r\n                        }\r\n                        catch (e) {\r\n                            this.dispose({ abort: true });\r\n                            throw e;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Clear the events to ensure that they aren't inadvertantly raised again through this scope\r\n            this._onExit.clear();\r\n        }\r\n        finally {\r\n            // The event scope is no longer active\r\n            this.isActive = false;\r\n        }\r\n    };\r\n    EventScope.prototype.receiveExitEventSubscribers = function (subscriptions) {\r\n        var _this = this;\r\n        var maxNesting = this.settings.maxExitingTransferCount - 1;\r\n        if (this._exitEventVersion >= maxNesting) {\r\n            throw new Error(\"Exceeded max scope event transfer.\");\r\n        }\r\n        // Move subscribers to the parent scope\r\n        subscriptions.forEach(function (sub) { return _this._onExit.subscribe(sub.handler); });\r\n        if (this._exitEventVersion !== undefined) {\r\n            this._exitEventVersion++;\r\n        }\r\n    };\r\n    EventScope.prototype.toString = function () {\r\n        return \"\" + (this.parent ? this.parent.toString() + \"->\" : \"\") + this._uid;\r\n    };\r\n    return EventScope;\r\n}());\r\nexports.EventScope = EventScope;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.entries = exports.flatMap = exports.clone = exports.mixin = exports.getEventSubscriptions = exports.merge = exports.hasOwnProperty = exports.toTitleCase = exports.randomText = exports.randomInt = exports.isType = exports.getDefaultValue = exports.isNumber = exports.getConstructorName = exports.getTypeName = exports.parseFunctionName = exports.replaceTokens = exports.evalPath = exports.navigateAttribute = exports.ensureNamespace = exports.getGlobalObject = void 0;\r\nfunction getGlobalObject() {\r\n    if (typeof window === \"object\" && Object.prototype.toString.call(window) === \"[object Window]\") {\r\n        return window;\r\n    }\r\n    else if (typeof global === \"object\") {\r\n        return global;\r\n    }\r\n    else {\r\n        return null;\r\n    }\r\n}\r\nexports.getGlobalObject = getGlobalObject;\r\nfunction ensureNamespace(name, parentNamespace) {\r\n    var result;\r\n    var nsTokens;\r\n    var target = parentNamespace;\r\n    if (typeof target === \"string\") {\r\n        nsTokens = target.split(\".\");\r\n        target = getGlobalObject();\r\n        nsTokens.forEach(function (token) {\r\n            target = target[token];\r\n            if (target === undefined) {\r\n                throw new Error(\"Parent namespace \\\"\" + parentNamespace + \"\\\" could not be found.\");\r\n            }\r\n        });\r\n    }\r\n    else if (target === undefined || target === null) {\r\n        target = getGlobalObject();\r\n    }\r\n    // create the namespace object if it doesn't exist, otherwise return the existing namespace\r\n    if (!(name in target)) {\r\n        result = target[name] = {};\r\n        return result;\r\n    }\r\n    else {\r\n        return target[name];\r\n    }\r\n}\r\nexports.ensureNamespace = ensureNamespace;\r\nfunction navigateAttribute(obj, attr, callback, thisPtr) {\r\n    if (thisPtr === void 0) { thisPtr = null; }\r\n    for (var val = obj[attr]; val != null; val = val[attr]) {\r\n        if (callback.call(thisPtr || obj, val) === false) {\r\n            return;\r\n        }\r\n    }\r\n}\r\nexports.navigateAttribute = navigateAttribute;\r\nfunction isObject(obj) {\r\n    return getTypeName(obj) === \"object\" || (obj && obj instanceof Object);\r\n}\r\n// If a getter method matching the given property name is found on the target it is invoked and returns the\r\n// value, unless the the value is undefined, in which case null is returned instead.  This is done so that\r\n// calling code can interpret a return value of undefined to mean that the property it requested does not exist.\r\nfunction getValue(target, property) {\r\n    var value;\r\n    // the see if there is an explicit getter function for the property\r\n    var getter = target[\"get_\" + property];\r\n    if (getter) {\r\n        value = getter.call(target);\r\n        if (value === undefined) {\r\n            value = null;\r\n        }\r\n    }\r\n    // otherwise search for the property\r\n    else {\r\n        if ((isObject(target) && property in target) ||\r\n            Object.prototype.hasOwnProperty.call(target, property) ||\r\n            (target.constructor === String && /^[0-9]+$/.test(property) && parseInt(property, 10) < target.length)) {\r\n            value = target[property];\r\n            if (value === undefined) {\r\n                value = null;\r\n            }\r\n        }\r\n        else if (/\\./.test(property)) {\r\n            // TODO: Warn about passing multi-hop path to `getValue()`\r\n            // logWarning(\"Possible incorrect usage of \\\"getValue()\\\", the path \\\"\" + property + \"\\\" does not exist on the target and appears to represent a multi-hop path.\");\r\n        }\r\n    }\r\n    return value;\r\n}\r\nfunction evalPath(obj, path, nullValue, undefinedValue) {\r\n    if (nullValue === void 0) { nullValue = null; }\r\n    if (undefinedValue === void 0) { undefinedValue = undefined; }\r\n    var value = obj;\r\n    var steps = path.split(\".\");\r\n    for (var i = 0; i < steps.length; ++i) {\r\n        var name_1 = steps[i];\r\n        var source = value;\r\n        value = getValue(source, name_1);\r\n        if (value === null) {\r\n            return nullValue;\r\n        }\r\n        if (value === undefined) {\r\n            return undefinedValue;\r\n        }\r\n    }\r\n    return value;\r\n}\r\nexports.evalPath = evalPath;\r\n/**\r\n * Replace tokens (ex: {0}) in the given string\r\n * @param template The template string\r\n * @param params The replacement parameters\r\n */\r\nfunction replaceTokens(template, params) {\r\n    if (params) {\r\n        return template.replace(/{([^}]+)}/g, function (match, key) {\r\n            return hasOwnProperty(params, key) ? params[key] : match;\r\n        });\r\n    }\r\n    return template;\r\n}\r\nexports.replaceTokens = replaceTokens;\r\nvar fnRegex = /function\\s*([\\w_$]*)/i;\r\nfunction parseFunctionName(fn) {\r\n    var fnMatch = fnRegex.exec(fn.toString());\r\n    return fnMatch ? (fnMatch[1] || \"{anonymous}\") : \"{anonymous}\";\r\n}\r\nexports.parseFunctionName = parseFunctionName;\r\nvar typeNameExpr = /\\s([a-z|A-Z]+)/;\r\nfunction getTypeName(obj) {\r\n    if (obj === undefined)\r\n        return \"undefined\";\r\n    if (obj === null)\r\n        return \"null\";\r\n    return Object.prototype.toString.call(obj).match(typeNameExpr)[1].toLowerCase();\r\n}\r\nexports.getTypeName = getTypeName;\r\nfunction getConstructorName(ctor) {\r\n    // Handle value types explicitly\r\n    if (ctor === String)\r\n        return \"String\";\r\n    if (ctor === Number)\r\n        return \"Number\";\r\n    if (ctor === Date)\r\n        return \"Date\";\r\n    if (ctor === Boolean)\r\n        return \"Boolean\";\r\n    // Try to use function name\r\n    if (typeof ctor === \"function\" && ctor.name) {\r\n        return ctor.name;\r\n    }\r\n    // Fall back to the low-level 'toString' on the prototype\r\n    return getTypeName(ctor.prototype);\r\n}\r\nexports.getConstructorName = getConstructorName;\r\nfunction isNumber(obj) {\r\n    return getTypeName(obj) === \"number\" && !isNaN(obj);\r\n}\r\nexports.isNumber = isNumber;\r\nfunction getDefaultValue(isList, jstype) {\r\n    if (isList)\r\n        return [];\r\n    if (jstype === Boolean)\r\n        return false;\r\n    if (jstype === Number)\r\n        return 0;\r\n    return null;\r\n}\r\nexports.getDefaultValue = getDefaultValue;\r\nfunction isType(obj, test) {\r\n    if (test === void 0) { test = null; }\r\n    if (test) {\r\n        return test(obj);\r\n    }\r\n    else {\r\n        // Do nothing, assume object is of the type\r\n        return true;\r\n    }\r\n}\r\nexports.isType = isType;\r\nfunction randomInt(min, max) {\r\n    if (min === void 0) { min = 0; }\r\n    if (max === void 0) { max = 9; }\r\n    var rand = Math.random();\r\n    return rand === 1 ? max : Math.floor(rand * (max - min + 1)) + min;\r\n}\r\nexports.randomInt = randomInt;\r\nfunction randomText(len, includeLetters, includeDigits) {\r\n    if (includeLetters === void 0) { includeLetters = true; }\r\n    if (includeDigits === void 0) { includeDigits = true; }\r\n    if (!includeLetters && !includeDigits) {\r\n        return;\r\n    }\r\n    var result = \"\";\r\n    for (var i = 0; i < len; i++) {\r\n        var min = includeLetters ? 0 : 26;\r\n        var max = includeDigits ? 35 : 25;\r\n        var rand = randomInt(min, max);\r\n        var charCode;\r\n        if (rand <= 25) {\r\n            // Alpha: add 97 for 'a'\r\n            charCode = rand + 97;\r\n        }\r\n        else {\r\n            // Num: start at 0 and add 48 for 0\r\n            charCode = (rand - 26) + 48;\r\n        }\r\n        result += String.fromCharCode(charCode);\r\n    }\r\n    return result;\r\n}\r\nexports.randomText = randomText;\r\nfunction toTitleCase(input) {\r\n    // https://stackoverflow.com/questions/196972/convert-string-to-title-case-with-javascript/6475125#6475125\r\n    var i, j, str, lowers, uppers;\r\n    str = input.replace(/([^\\W_]+[^\\s-]*) */g, function (txt) {\r\n        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();\r\n    });\r\n    // Certain minor words should be left lowercase unless\r\n    // they are the first or last words in the string\r\n    lowers = [\"A\", \"An\", \"The\", \"And\", \"But\", \"Or\", \"For\", \"Nor\", \"As\", \"At\",\r\n        \"By\", \"For\", \"From\", \"In\", \"Into\", \"Near\", \"Of\", \"On\", \"Onto\",\r\n        \"To\", \"With\"];\r\n    for (i = 0, j = lowers.length; i < j; i++) {\r\n        str = str.replace(new RegExp(\"\\\\s\" + lowers[i] + \"\\\\s\", \"g\"), function (txt) {\r\n            return txt.toLowerCase();\r\n        });\r\n    }\r\n    // Certain words such as initialisms or acronyms should be left uppercase\r\n    uppers = [\"Id\", \"Tv\"];\r\n    for (i = 0, j = uppers.length; i < j; i++) {\r\n        str = str.replace(new RegExp(\"\\\\b\" + uppers[i] + \"\\\\b\", \"g\"), uppers[i].toUpperCase());\r\n    }\r\n    return str;\r\n}\r\nexports.toTitleCase = toTitleCase;\r\nfunction hasOwnProperty(obj, prop) {\r\n    return Object.prototype.hasOwnProperty.call(obj, prop);\r\n}\r\nexports.hasOwnProperty = hasOwnProperty;\r\nfunction merge(obj1) {\r\n    var objs = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        objs[_i - 1] = arguments[_i];\r\n    }\r\n    var target = {};\r\n    for (var arg in obj1) {\r\n        if (hasOwnProperty(obj1, arg)) {\r\n            target[arg] = obj1[arg];\r\n        }\r\n    }\r\n    for (var i = 0; i < objs.length; i++) {\r\n        var obj = objs[i];\r\n        for (var arg in obj) {\r\n            if (hasOwnProperty(obj, arg)) {\r\n                target[arg] = obj[arg];\r\n            }\r\n        }\r\n    }\r\n    return target;\r\n}\r\nexports.merge = merge;\r\nfunction getEventSubscriptions(event) {\r\n    var func = event.func;\r\n    if (func) {\r\n        var funcs = func._funcs;\r\n        if (funcs.length > 0) {\r\n            var subs = funcs.map(function (f) { return { handler: f.fn, isExecuted: f.applied, isOnce: f.once }; });\r\n            return subs;\r\n        }\r\n        else {\r\n            return null;\r\n        }\r\n    }\r\n}\r\nexports.getEventSubscriptions = getEventSubscriptions;\r\nfunction mixin(ctor, methods) {\r\n    for (var key in methods) {\r\n        if (hasOwnProperty(methods, key) && methods[key] instanceof Function) {\r\n            ctor.prototype[key] = methods[key];\r\n        }\r\n    }\r\n}\r\nexports.mixin = mixin;\r\n/**\r\n * Recursively clone an object and its children\r\n * @param value The object to clone\r\n */\r\nfunction clone(obj) {\r\n    var result = {};\r\n    for (var prop in obj) {\r\n        if (hasOwnProperty(obj, prop)) {\r\n            var value = obj[prop];\r\n            result[prop] = value instanceof Array ? (value.length === 1 ? [value[0]] : Array.apply(null, value)) : typeof value === \"object\" ? clone(value) : value;\r\n        }\r\n    }\r\n    return result;\r\n}\r\nexports.clone = clone;\r\n/**\r\n * Helper alternative to Array.prototype.flatMap\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap#Alternative\r\n * @param input The input array\r\n * @param callback A function that returns an array of outputs for each input\r\n */\r\nfunction flatMap(input, callback) {\r\n    return input.reduce(function (arr, i) { return arr.concat(callback(i)); }, []);\r\n}\r\nexports.flatMap = flatMap;\r\n/**\r\n * Helper alternative to Object.entries\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries#Polyfill\r\n * @param input The input array\r\n */\r\nfunction entries(obj) {\r\n    // eslint-disable-next-line one-var\r\n    var ownProps = Object.keys(obj), i = ownProps.length, resArray = new Array(i); // preallocate the Array\r\n    while (i--)\r\n        resArray[i] = [ownProps[i], obj[ownProps[i]]];\r\n    return resArray;\r\n}\r\nexports.entries = entries;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.ConditionTypeSet = void 0;\r\nvar observable_array_1 = require(\"./observable-array\");\r\nvar allConditionTypeSets = {};\r\n/** Groups condition types into a set in order to be notified conditions for these types change. */\r\nvar ConditionTypeSet = /** @class */ (function () {\r\n    /**\r\n    * Creates a set of condition types.\r\n    * @param name The name of the set\r\n    */\r\n    function ConditionTypeSet(name) {\r\n        if (allConditionTypeSets[name])\r\n            throw new Error(\"A set with the name '\" + name + \"' has already been created.\");\r\n        this.name = name;\r\n        this.types = observable_array_1.ObservableArray.create();\r\n        this.conditions = observable_array_1.ObservableArray.create();\r\n        allConditionTypeSets[name] = this;\r\n    }\r\n    /**\r\n    * Gets all condition type sets that have been created.\r\n    * @returns Array of all condition type sets.\r\n    * */\r\n    ConditionTypeSet.all = function () {\r\n        var all = [];\r\n        for (var type in allConditionTypeSets.keys) {\r\n            all.push(allConditionTypeSets[type]);\r\n        }\r\n        return all;\r\n    };\r\n    /**\r\n    * Gets the condition type set with the specified name.\r\n    * @param name\r\n    */\r\n    ConditionTypeSet.get = function (name) {\r\n        return allConditionTypeSets[name];\r\n    };\r\n    return ConditionTypeSet;\r\n}());\r\nexports.ConditionTypeSet = ConditionTypeSet;\r\n","\"use strict\";\r\nvar __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.Property$setter = exports.Property$init = exports.Property$pendingInit = exports.Property$generateOwnProperty = exports.Property$generatePrototypeProperty = exports.Property$generateStaticProperty = exports.Property$generateShortcuts = exports.Property$format = exports.evaluateLabel = exports.getLabelSourceType = exports.getLabelFormat = exports.isPropertyOptions = exports.isPropertyBooleanFunction = exports.isPropertyBooleanFunctionAndOptions = exports.isPropertyValueFunction = exports.Property = void 0;\r\nvar events_1 = require(\"./events\");\r\nvar format_1 = require(\"./format\");\r\nvar type_1 = require(\"./type\");\r\nvar property_chain_1 = require(\"./property-chain\");\r\nvar helpers_1 = require(\"./helpers\");\r\nvar observable_array_1 = require(\"./observable-array\");\r\nvar rule_1 = require(\"./rule\");\r\nvar calculated_property_rule_1 = require(\"./calculated-property-rule\");\r\nvar string_format_rule_1 = require(\"./string-format-rule\");\r\nvar validation_rule_1 = require(\"./validation-rule\");\r\nvar allowed_values_rule_1 = require(\"./allowed-values-rule\");\r\nvar required_rule_1 = require(\"./required-rule\");\r\nvar range_rule_1 = require(\"./range-rule\");\r\nvar string_length_rule_1 = require(\"./string-length-rule\");\r\nvar list_length_rule_1 = require(\"./list-length-rule\");\r\nvar initilization_context_1 = require(\"./initilization-context\");\r\nvar condition_type_1 = require(\"./condition-type\");\r\nvar Property = /** @class */ (function () {\r\n    function Property(containingType, name, propertyType, isIdentifier, isList, options) {\r\n        this.containingType = containingType;\r\n        this.name = name;\r\n        this.propertyType = propertyType;\r\n        this.isIdentifier = isIdentifier;\r\n        this.isList = isList;\r\n        this.required = false;\r\n        this.rules = [];\r\n        this.getter = Property$makeGetter(this, Property$getter);\r\n        this.setter = Property$makeSetter(this, Property$setter);\r\n        this.changed = new events_1.Event();\r\n        this.accessed = new events_1.Event();\r\n        // Apply property options\r\n        if (options)\r\n            this.extend(options);\r\n    }\r\n    Object.defineProperty(Property.prototype, \"isConstant\", {\r\n        get: function () {\r\n            return this.constant !== null && this.constant !== undefined;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(Property.prototype, \"labelIsFormat\", {\r\n        get: function () {\r\n            return format_1.Format.hasTokens(this.label);\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(Property.prototype, \"helptextIsFormat\", {\r\n        get: function () {\r\n            return format_1.Format.hasTokens(this.helptext);\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(Property.prototype, \"path\", {\r\n        get: function () {\r\n            return this.name;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(Property.prototype, \"firstProperty\", {\r\n        get: function () {\r\n            return this;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(Property.prototype, \"lastProperty\", {\r\n        get: function () {\r\n            return this;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Property.prototype.getLastTarget = function (obj) {\r\n        return obj;\r\n    };\r\n    Object.defineProperty(Property.prototype, \"defaultValue\", {\r\n        get: function () {\r\n            if (this._defaultValue !== undefined) {\r\n                // clone array and date defaults since they are mutable javascript types\r\n                return this._defaultValue instanceof Array ? this._defaultValue.slice() :\r\n                    this._defaultValue instanceof Date ? new Date(+this._defaultValue) :\r\n                        // TODO: Implement TimeSpan class/type?\r\n                        // this._defaultValue instanceof TimeSpan ? new TimeSpan(this._defaultValue.totalMilliseconds) :\r\n                        this._defaultValue;\r\n            }\r\n            else\r\n                return helpers_1.getDefaultValue(this.isList, this.propertyType);\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Property.prototype.extend = function (options, targetType) {\r\n        var _this = this;\r\n        if (!targetType)\r\n            targetType = this.containingType;\r\n        // Utility function to convert a path string into a resolved array of Property and PropertyChain instances\r\n        function resolveDependsOn(property, rule, dependsOn) {\r\n            // return an empty dependency array if no path was specified\r\n            if (!dependsOn)\r\n                return [];\r\n            // throw an exception if dependsOn is not a string\r\n            if (typeof (dependsOn) !== \"string\")\r\n                throw new Error(\"Invalid dependsOn property for '\" + rule + \"' rule on '\" + property + \".\");\r\n            // get the property paths for the specified dependency string\r\n            return targetType.getPaths(dependsOn);\r\n        }\r\n        // Use prepare() to defer property path resolution while the model is being extended\r\n        targetType.model.prepare(function () {\r\n            options = __assign({}, options);\r\n            // Label\r\n            if (options.label)\r\n                _this.label = options.label;\r\n            else if (targetType.model.settings.autogeneratePropertyLabels && !_this.label)\r\n                _this.label = _this.name.replace(/(^[a-z]+|[A-Z]{2,}(?=[A-Z][a-z]|$)|[A-Z][a-z]*)/g, \" $1\").trim();\r\n            // Label Source\r\n            if (options.labelSource) {\r\n                if (typeof (options.labelSource) !== \"string\")\r\n                    throw new Error(\"Invalid labelSource property for '\" + _this + \".\");\r\n                targetType.model.ready(function () {\r\n                    _this.labelSource = targetType.getPath(options.labelSource);\r\n                });\r\n            }\r\n            // Helptext\r\n            _this.helptext = options.helptext;\r\n            // Format\r\n            if (options.format) {\r\n                // Specifier\r\n                if (typeof (options.format) === \"string\") {\r\n                    var format = options.format;\r\n                    _this.format = targetType.model.getFormat(_this.propertyType, format);\r\n                }\r\n                // Format\r\n                else if (options.format instanceof format_1.Format) {\r\n                    // TODO: convert description/expression/reformat into a Format object\r\n                    _this.format = options.format;\r\n                }\r\n                // String Format\r\n                else if (helpers_1.isType(options.format, function (f) { return helpers_1.getTypeName(f) === \"object\" && f.expression; })) {\r\n                    var format_2 = options.format;\r\n                    targetType.model.ready(function () {\r\n                        new string_format_rule_1.StringFormatRule(targetType, {\r\n                            property: _this,\r\n                            description: format_2.description,\r\n                            message: format_2.message,\r\n                            expression: format_2.expression,\r\n                            reformat: format_2.reformat\r\n                        })\r\n                            .register();\r\n                    });\r\n                }\r\n                // Error\r\n                else {\r\n                    throw new Error(\"Invalid 'format' option for '\" + _this + \"'.\");\r\n                }\r\n            }\r\n            // Constant\r\n            if (options.constant !== null && options.constant !== undefined) {\r\n                targetType.model.ready(function () {\r\n                    // Lazily obtain the constant to ensure all types/rules associated with the constant value have been loaded and initialized\r\n                    _this.constant = function () { return targetType.model.serializer.deserialize(null, options.constant, _this, new initilization_context_1.InitializationContext(true)); };\r\n                });\r\n            }\r\n            // Get\r\n            if (options.get) {\r\n                if (typeof (options.get) === \"function\") {\r\n                    options.get = { function: options.get, dependsOn: \"\" };\r\n                }\r\n                if (isPropertyOptions(options.get)) {\r\n                    var getOptions_1 = options.get;\r\n                    if (typeof (getOptions_1.function) !== \"function\") {\r\n                        throw new Error(\"Invalid property 'get' function of type '\" + helpers_1.getTypeName(getOptions_1.function) + \"'.\");\r\n                    }\r\n                    targetType.model.ready(function () {\r\n                        new calculated_property_rule_1.CalculatedPropertyRule(targetType, null, {\r\n                            property: _this,\r\n                            calculate: getOptions_1.function,\r\n                            onChangeOf: resolveDependsOn(_this, \"get\", getOptions_1.dependsOn)\r\n                        }).register();\r\n                    });\r\n                }\r\n                else {\r\n                    throw new Error(\"Invalid property 'get' option of type '\" + helpers_1.getTypeName(options.get) + \"'.\");\r\n                }\r\n            }\r\n            // Set\r\n            if (typeof options.set === \"function\") {\r\n                var property_1 = _this;\r\n                new rule_1.Rule(targetType, null, {\r\n                    onInit: true,\r\n                    onChangeOf: [_this],\r\n                    execute: function () {\r\n                        options.set.call(this, property_1.value(this));\r\n                    }\r\n                }).register();\r\n            }\r\n            // Init\r\n            if (options.init !== undefined) {\r\n                var initFn = void 0;\r\n                if (isPropertyValueFunction(options.init))\r\n                    initFn = options.init;\r\n                else\r\n                    throw new Error(\"Invalid property 'init' option of type '\" + helpers_1.getTypeName(options.init) + \"'.\");\r\n                _this.initializer = initFn;\r\n            }\r\n            // Default\r\n            if (options.default !== undefined) {\r\n                if (isPropertyValueFunction(options.default)) {\r\n                    // Always generate a rule for default function\r\n                    options.default = { function: options.default, dependsOn: \"\" };\r\n                }\r\n                else if (isPropertyOptions(options.default)) {\r\n                    // Use default object as specified\r\n                }\r\n                else if (options.default === null || type_1.isValue(options.default) || type_1.isValueArray(options.default)) {\r\n                    // Constant\r\n                    var defaultConstant_1 = options.default;\r\n                    // Cannot set default constant value for entity-typed property\r\n                    if (type_1.isEntityType(_this.propertyType)) {\r\n                        throw new Error(\"Cannot set a constant default value for a property of type '\" + _this.propertyType.meta.fullName + \"'.\");\r\n                    }\r\n                    // Verify that the constant value is of the proper built-in type\r\n                    if (options.default !== null && type_1.isValue(options.default)) {\r\n                        var defaultOptionTypeName = helpers_1.getTypeName(defaultConstant_1);\r\n                        var propertyTypeName = helpers_1.getConstructorName(_this.propertyType).toLowerCase();\r\n                        if (defaultOptionTypeName !== propertyTypeName) {\r\n                            throw new Error(\"Cannot set a default value of type '\" + defaultOptionTypeName + \"' for a property of type '\" + propertyTypeName + \"'.\");\r\n                        }\r\n                    }\r\n                    // If extending baseType property specifically for a child type, use a rule\r\n                    if (_this.containingType === targetType)\r\n                        _this._defaultValue = defaultConstant_1;\r\n                    else\r\n                        options.default = { function: function () { return defaultConstant_1; }, dependsOn: \"\" };\r\n                }\r\n                else {\r\n                    throw new Error(\"Invalid property 'default' option of type '\" + helpers_1.getTypeName(options.default) + \"'.\");\r\n                }\r\n                if (isPropertyOptions(options.default)) {\r\n                    var defaultOptions_1 = options.default;\r\n                    if (typeof (options.default.function) !== \"function\") {\r\n                        throw new Error(\"Invalid property 'default' function of type '\" + helpers_1.getTypeName(options.default.function) + \"'.\");\r\n                    }\r\n                    var defaultFn_1 = options.default.function;\r\n                    targetType.model.ready(function () {\r\n                        new calculated_property_rule_1.CalculatedPropertyRule(targetType, null, {\r\n                            property: _this,\r\n                            calculate: defaultFn_1,\r\n                            onChangeOf: resolveDependsOn(_this, \"default\", defaultOptions_1.dependsOn),\r\n                            isDefaultValue: true\r\n                        }).register();\r\n                    });\r\n                }\r\n            }\r\n            // Allowed Values\r\n            if (options.allowedValues) {\r\n                if (typeof (options.allowedValues) === \"function\") {\r\n                    var originalAllowedValues_1 = options.allowedValues;\r\n                    var allowedValuesFunction = function () { return originalAllowedValues_1.call(this); };\r\n                    options.get = { function: allowedValuesFunction, dependsOn: \"\" };\r\n                }\r\n                if (isPropertyOptions(options.allowedValues)) {\r\n                    var allowedValuesOptions_1 = options.allowedValues;\r\n                    if (typeof (options.allowedValues.function) !== \"function\") {\r\n                        throw new Error(\"Invalid property 'allowedValues' function of type '\" + helpers_1.getTypeName(options.allowedValues.function) + \"'.\");\r\n                    }\r\n                    targetType.model.ready(function () {\r\n                        (new allowed_values_rule_1.AllowedValuesRule(targetType, {\r\n                            property: _this,\r\n                            source: allowedValuesOptions_1.function,\r\n                            ignoreValidation: allowedValuesOptions_1.ignoreValidation,\r\n                            preventInvalidValues: allowedValuesOptions_1.preventInvalidValues,\r\n                            onChangeOf: resolveDependsOn(_this, \"allowedValues\", allowedValuesOptions_1.dependsOn)\r\n                        })).register();\r\n                    });\r\n                }\r\n                else {\r\n                    throw new Error(\"Invalid property 'get' option of type '\" + helpers_1.getTypeName(options.get) + \"'.\");\r\n                }\r\n            }\r\n            // Range\r\n            if (options.range) {\r\n                var min_1;\r\n                if (options.range.min != null) {\r\n                    if (isPropertyValueFunction(options.range.min)) {\r\n                        min_1 = options.range.min;\r\n                    }\r\n                    else if (type_1.isValue(options.range.min)) {\r\n                        var minConstant_1 = options.range.min;\r\n                        min_1 = function () { return minConstant_1; };\r\n                    }\r\n                    else {\r\n                        throw new Error(\"Invalid property 'range.min' option of type '\" + helpers_1.getTypeName(options.range.min) + \"'.\");\r\n                    }\r\n                }\r\n                var max_1;\r\n                if (options.range.max != null) {\r\n                    if (isPropertyValueFunction(options.range.max)) {\r\n                        max_1 = options.range.max;\r\n                    }\r\n                    else if (type_1.isValue(options.range.max)) {\r\n                        var maxConstant_1 = options.range.max;\r\n                        max_1 = function () { return maxConstant_1; };\r\n                    }\r\n                    else {\r\n                        throw new Error(\"Invalid property 'range.max' option of type '\" + helpers_1.getTypeName(options.range.max) + \"'.\");\r\n                    }\r\n                }\r\n                targetType.model.ready(function () {\r\n                    var onChangeOf = resolveDependsOn(_this, \"range\", options.range.dependsOn);\r\n                    new range_rule_1.RangeRule(targetType, { property: _this, onChangeOf: onChangeOf, min: min_1, max: max_1 }).register();\r\n                });\r\n            }\r\n            // Length\r\n            if (options.length) {\r\n                var min_2;\r\n                if (options.length.min != null) {\r\n                    if (isPropertyValueFunction(options.length.min)) {\r\n                        min_2 = options.length.min;\r\n                    }\r\n                    else if (type_1.isValue(options.length.min, Number)) {\r\n                        var minConstant_2 = options.length.min;\r\n                        min_2 = function () { return minConstant_2; };\r\n                    }\r\n                    else {\r\n                        throw new Error(\"Invalid property 'length.min' option of type '\" + helpers_1.getTypeName(options.length.min) + \"'.\");\r\n                    }\r\n                }\r\n                var max_2;\r\n                if (options.length.max != null) {\r\n                    if (isPropertyValueFunction(options.length.max)) {\r\n                        max_2 = options.length.max;\r\n                    }\r\n                    else if (type_1.isValue(options.length.max, Number)) {\r\n                        var maxConstant_2 = options.length.max;\r\n                        max_2 = function () { return maxConstant_2; };\r\n                    }\r\n                    else {\r\n                        throw new Error(\"Invalid property 'length.max' option of type '\" + helpers_1.getTypeName(options.length.max) + \"'.\");\r\n                    }\r\n                }\r\n                targetType.model.ready(function () {\r\n                    var onChangeOf = resolveDependsOn(_this, \"length\", options.length.dependsOn);\r\n                    if (_this.isList) {\r\n                        new list_length_rule_1.ListLengthRule(targetType, { property: _this, onChangeOf: onChangeOf, min: min_2, max: max_2 }).register();\r\n                    }\r\n                    else {\r\n                        new string_length_rule_1.StringLengthRule(targetType, { property: _this, onChangeOf: onChangeOf, min: min_2, max: max_2 }).register();\r\n                    }\r\n                });\r\n            }\r\n            // Required\r\n            if (options.required) {\r\n                var requiredOptions = options.required;\r\n                // Store required options on property so that they can be referenced externally\r\n                _this.required = requiredOptions;\r\n                // Always Required\r\n                if (typeof (options.required) === \"boolean\") {\r\n                    if (options.required) {\r\n                        targetType.model.ready(function () {\r\n                            var requiredRule = new required_rule_1.RequiredRule(targetType, { property: _this });\r\n                            requiredRule.register();\r\n                        });\r\n                    }\r\n                }\r\n                // Conditionally Required\r\n                else {\r\n                    var requiredFn_1;\r\n                    var requiredMessage_1;\r\n                    var requiredDependsOn_1;\r\n                    if (isPropertyOptions(options.required)) {\r\n                        requiredFn_1 = options.required.function;\r\n                        requiredMessage_1 = options.required.message;\r\n                        requiredDependsOn_1 = options.required.dependsOn;\r\n                    }\r\n                    else {\r\n                        requiredFn_1 = options.required;\r\n                    }\r\n                    targetType.model.ready(function () {\r\n                        (new required_rule_1.RequiredRule(targetType, {\r\n                            property: _this,\r\n                            when: requiredFn_1,\r\n                            message: requiredMessage_1,\r\n                            onChangeOf: requiredDependsOn_1 ? resolveDependsOn(_this, \"required\", requiredDependsOn_1) : null\r\n                        })).register();\r\n                    });\r\n                }\r\n            }\r\n            // Error\r\n            if (options.error) {\r\n                (Array.isArray(options.error) ? options.error : [options.error]).forEach(function (errorOptions) {\r\n                    var errorFn = errorOptions.function;\r\n                    if (errorOptions.resource)\r\n                        errorFn = function () {\r\n                            return errorOptions.function.call(this) ? targetType.model.getResource(errorOptions.resource) : null;\r\n                        };\r\n                    var errorDependsOn = errorOptions.dependsOn;\r\n                    if (typeof (errorFn) !== \"function\") {\r\n                        throw new Error(\"Invalid property 'error' function of type '\" + helpers_1.getTypeName(errorOptions.function) + \"'.\");\r\n                    }\r\n                    var conditionType;\r\n                    if (errorOptions.code)\r\n                        conditionType = condition_type_1.ConditionType.get(errorOptions.code) || new condition_type_1.ErrorConditionType(errorOptions.code, \"error\");\r\n                    targetType.model.ready(function () {\r\n                        (new validation_rule_1.ValidationRule(targetType, {\r\n                            property: _this,\r\n                            properties: errorOptions.properties ? helpers_1.flatMap(errorOptions.properties, function (p) { return targetType.getPaths(p); }) : null,\r\n                            onChangeOf: resolveDependsOn(_this, \"\", errorDependsOn),\r\n                            message: errorFn,\r\n                            conditionType: conditionType\r\n                        })).register();\r\n                    });\r\n                });\r\n            }\r\n        });\r\n    };\r\n    Property.prototype.equals = function (prop) {\r\n        if (prop === null || prop === undefined) {\r\n            return;\r\n        }\r\n        if (prop instanceof property_chain_1.PropertyChain) {\r\n            return prop.equals(this);\r\n        }\r\n        if (prop instanceof Property) {\r\n            return this === prop;\r\n        }\r\n    };\r\n    Property.prototype.each = function (obj, callback, filter) {\r\n        if (filter === void 0) { filter = null; }\r\n        if (!filter || filter === this)\r\n            callback(obj, this);\r\n    };\r\n    Property.prototype.toString = function () {\r\n        return \"this<\" + this.containingType + \">.\" + this.name;\r\n    };\r\n    Property.prototype.canSetValue = function (obj, val) {\r\n        // NOTE: only allow values of the correct data type to be set in the model\r\n        if (val === undefined) {\r\n            // TODO: Warn about setting value to undefined?\r\n            // logWarning(\"You should not set property values to undefined, use null instead: property = .\" + this._name + \".\");\r\n            // console.warn(`You should not set property values to undefined, use null instead: property = ${this.name}.`);\r\n            return true;\r\n        }\r\n        if (val === null) {\r\n            return true;\r\n        }\r\n        // for entities check base types as well\r\n        if (val.constructor && val.constructor.meta) {\r\n            for (var valType = val.constructor.meta; valType; valType = valType.baseType) {\r\n                if (valType.jstype === this.propertyType) {\r\n                    return true;\r\n                }\r\n            }\r\n            return false;\r\n        }\r\n        // Data types\r\n        else {\r\n            var valObjectType = val.constructor;\r\n            // \"Normalize\" data type in case it came from another frame as well as ensure that the types are the same\r\n            switch (helpers_1.getTypeName(val)) {\r\n                case \"string\":\r\n                    valObjectType = String;\r\n                    break;\r\n                case \"number\":\r\n                    valObjectType = Number;\r\n                    break;\r\n                case \"boolean\":\r\n                    valObjectType = Boolean;\r\n                    break;\r\n                case \"date\":\r\n                    valObjectType = Date;\r\n                    break;\r\n                case \"array\":\r\n                    valObjectType = Array;\r\n                    break;\r\n            }\r\n            // value property type check\r\n            return valObjectType === this.propertyType ||\r\n                // entity array type check\r\n                (valObjectType === Array && this.isList && (!this.propertyType || val.every(function (child) {\r\n                    if (type_1.isEntityType(this.propertyType)) {\r\n                        if (child.constructor && child.constructor.meta) {\r\n                            for (var childType = child.constructor.meta; childType; childType = childType.baseType) {\r\n                                if (childType.jstype === this.propertyType) {\r\n                                    return true;\r\n                                }\r\n                            }\r\n                        }\r\n                        return false;\r\n                    }\r\n                    else {\r\n                        var itemObjectType = child.constructor;\r\n                        // \"Normalize\" data type in case it came from another frame as well as ensure that the types are the same\r\n                        switch (helpers_1.getTypeName(child)) {\r\n                            case \"string\":\r\n                                itemObjectType = String;\r\n                                break;\r\n                            case \"number\":\r\n                                itemObjectType = Number;\r\n                                break;\r\n                            case \"boolean\":\r\n                                itemObjectType = Boolean;\r\n                                break;\r\n                            case \"date\":\r\n                                itemObjectType = Date;\r\n                                break;\r\n                            case \"array\":\r\n                                itemObjectType = Array;\r\n                                break;\r\n                        }\r\n                        return itemObjectType === this.propertyType;\r\n                    }\r\n                }, this)));\r\n        }\r\n    };\r\n    Property.prototype.value = function (obj, val, additionalArgs) {\r\n        if (obj === void 0) { obj = null; }\r\n        if (val === void 0) { val = null; }\r\n        if (additionalArgs === void 0) { additionalArgs = null; }\r\n        if (obj === undefined || obj === null) {\r\n            throw new Error(\"Cannot \" + (arguments.length > 1 ? \"set\" : \"get\") + \" value for property \\\"\" + this.name + \"\\\" on type \\\"\" + this.containingType + \"\\\": target is null or undefined.\");\r\n        }\r\n        if (arguments.length > 1) {\r\n            Property$setter(this, obj, val, additionalArgs);\r\n        }\r\n        else {\r\n            return Property$getter(this, obj);\r\n        }\r\n    };\r\n    Property.prototype.isInited = function (obj) {\r\n        // If the backing field has been created, the property is initialized\r\n        return obj.__fields__.hasOwnProperty(this.name);\r\n    };\r\n    return Property;\r\n}());\r\nexports.Property = Property;\r\nfunction isPropertyValueFunction(obj) {\r\n    return typeof (obj) === \"function\";\r\n}\r\nexports.isPropertyValueFunction = isPropertyValueFunction;\r\nfunction isPropertyBooleanFunctionAndOptions(obj) {\r\n    return typeof (obj) === \"object\";\r\n}\r\nexports.isPropertyBooleanFunctionAndOptions = isPropertyBooleanFunctionAndOptions;\r\nfunction isPropertyBooleanFunction(obj) {\r\n    return typeof (obj) === \"function\";\r\n}\r\nexports.isPropertyBooleanFunction = isPropertyBooleanFunction;\r\nfunction isPropertyOptions(obj, check) {\r\n    if (check === void 0) { check = null; }\r\n    return helpers_1.isType(obj, function (d) { return helpers_1.getTypeName(d) === \"object\" && (!check || check(d)); });\r\n}\r\nexports.isPropertyOptions = isPropertyOptions;\r\n/**\r\n * Gets a format object for the given property's label, if it is dynamic (i.e. contains format tokens)\r\n */\r\nfunction getLabelFormat(property) {\r\n    if (property.label && property.labelIsFormat) {\r\n        var labelSourceType = getLabelSourceType(property);\r\n        return labelSourceType.model.getFormat(labelSourceType.jstype, property.label);\r\n    }\r\n}\r\nexports.getLabelFormat = getLabelFormat;\r\n/**\r\n * Gets the model type of the source object that should be used to evaluate the\r\n * property's label, if it is dynamic (i.e. contains format tokens)\r\n */\r\nfunction getLabelSourceType(property) {\r\n    // If a label source is specified, then determine it's model type\r\n    if (property.labelSource) {\r\n        var labelSourceType = property.labelSource.propertyType;\r\n        if (type_1.isEntityType(labelSourceType))\r\n            return labelSourceType.meta;\r\n    }\r\n    return property.containingType;\r\n}\r\nexports.getLabelSourceType = getLabelSourceType;\r\n/**\r\n * Evaluates the given property's label, using the given entity as context if the label is dynamic (i.e. contains format tokens)\r\n */\r\nfunction evaluateLabel(property, entity) {\r\n    if (property.labelIsFormat) {\r\n        var labelFormat = getLabelFormat(property);\r\n        var labelFormatInstance = entity;\r\n        if (property.labelSource) {\r\n            labelFormatInstance = property.labelSource.value(entity);\r\n        }\r\n        return labelFormat.convert(labelFormatInstance);\r\n    }\r\n    else {\r\n        return property.label;\r\n    }\r\n}\r\nexports.evaluateLabel = evaluateLabel;\r\nfunction Property$format(prop, val) {\r\n    if (prop.format) {\r\n        return prop.format.convert(val);\r\n    }\r\n}\r\nexports.Property$format = Property$format;\r\n// export function Property$equals(prop1: Property | IPropertyChain, prop2: Property | IPropertyChain): boolean {\r\n// \tif (prop1 === null || prop1 === undefined || prop2 === null || prop2 === undefined) {\r\n// \t\treturn;\r\n// \t}\r\n// \tif (PropertyChain$isPropertyChain(prop1)) {\r\n// \t\treturn (prop1 as PropertyChain).equals(prop2);\r\n// \t}\r\n// \tif (PropertyChain$isPropertyChain(prop2)) {\r\n// \t\treturn (prop2 as PropertyChain).equals(prop1);\r\n// \t}\r\n// \tif (Property$isProperty(prop1) && Property$isProperty(prop2)) {\r\n// \t\treturn prop1 === prop2;\r\n// \t}\r\n// }\r\nfunction Property$generateShortcuts(property, target, overwrite) {\r\n    if (overwrite === void 0) { overwrite = null; }\r\n    var shortcutName = \"$\" + property.name;\r\n    if (!(Object.prototype.hasOwnProperty.call(target, shortcutName)) || overwrite) {\r\n        target[shortcutName] = property;\r\n    }\r\n}\r\nexports.Property$generateShortcuts = Property$generateShortcuts;\r\nfunction Property$generateStaticProperty(property, target) {\r\n    Object.defineProperty(target, property.name, {\r\n        configurable: false,\r\n        enumerable: true,\r\n        get: property.getter,\r\n        set: property.setter\r\n    });\r\n}\r\nexports.Property$generateStaticProperty = Property$generateStaticProperty;\r\nfunction Property$generatePrototypeProperty(property, target) {\r\n    Object.defineProperty(target, property.name, {\r\n        configurable: false,\r\n        enumerable: true,\r\n        get: property.getter,\r\n        set: property.setter\r\n    });\r\n}\r\nexports.Property$generatePrototypeProperty = Property$generatePrototypeProperty;\r\nfunction Property$generateOwnProperty(property, obj) {\r\n    Object.defineProperty(obj, property.name, {\r\n        configurable: false,\r\n        enumerable: true,\r\n        get: property.getter,\r\n        set: property.setter\r\n    });\r\n}\r\nexports.Property$generateOwnProperty = Property$generateOwnProperty;\r\nfunction Property$pendingInit(obj, prop, value) {\r\n    if (value === void 0) { value = null; }\r\n    var pendingInit;\r\n    if (Object.prototype.hasOwnProperty.call(obj, \"__pendingInit__\")) {\r\n        pendingInit = obj.__pendingInit__;\r\n    }\r\n    else {\r\n        Object.defineProperty(obj, \"__pendingInit__\", { enumerable: false, value: (pendingInit = {}), writable: true });\r\n    }\r\n    if (arguments.length > 2) {\r\n        if (value === false) {\r\n            delete pendingInit[prop.name];\r\n        }\r\n        else {\r\n            pendingInit[prop.name] = value;\r\n        }\r\n    }\r\n    else {\r\n        var currentValue = obj.__fields__[prop.name];\r\n        return currentValue === undefined || pendingInit[prop.name] === true;\r\n    }\r\n}\r\nexports.Property$pendingInit = Property$pendingInit;\r\nfunction Property$subArrayEvents(obj, property, array) {\r\n    array.changed.subscribe(function (args) {\r\n        Property$pendingInit(obj, property, false);\r\n        // Don't raise a no-op list change event\r\n        if (!args.changes.length)\r\n            return;\r\n        // NOTE: oldValue is not currently implemented for lists\r\n        var eventArgs = { entity: obj, property: property, newValue: array };\r\n        // Assign additional collection change event arguments to the property change event\r\n        var additionalArgs = __assign({ changes: args.changes, collectionChanged: true }, args.additionalArgs);\r\n        property.containingType.model.listChanged.publish(obj, helpers_1.merge(eventArgs, additionalArgs));\r\n        property.changed.publish(obj, helpers_1.merge(eventArgs, additionalArgs));\r\n        obj.changed.publish(obj, helpers_1.merge(eventArgs, additionalArgs));\r\n    });\r\n}\r\nfunction Property$getInitialValue(property) {\r\n    // Constant\r\n    if (property.isConstant)\r\n        return typeof property.constant === \"function\" ? (property.constant = property.constant()) : property.constant;\r\n    var val = property.defaultValue;\r\n    if (Array.isArray(val)) {\r\n        val = observable_array_1.ObservableArray.ensureObservable(val);\r\n        // Override the default toString on arrays so that we get a comma-delimited list\r\n        // TODO: Implement toString on observable list?\r\n        // val.toString = Property$_arrayToString.bind(val);\r\n    }\r\n    return val;\r\n}\r\nfunction Property$init(property, obj, val) {\r\n    Property$pendingInit(obj, property, false);\r\n    Object.defineProperty(obj.__fields__, property.name, { value: val, writable: true });\r\n    if (Array.isArray(val)) {\r\n        Property$subArrayEvents(obj, property, observable_array_1.ObservableArray.ensureObservable(val));\r\n    }\r\n    // TODO: Implement observable?\r\n    obj.changed.publish(obj, { entity: obj, property: property, newValue: val });\r\n}\r\nexports.Property$init = Property$init;\r\nfunction Property$ensureInited(property, obj) {\r\n    // Determine if the property has been initialized with a value and initialize the property if necessary\r\n    if (!obj.__fields__.hasOwnProperty(property.name)) {\r\n        Property$pendingInit(obj, property, true);\r\n        // Do not initialize calculated properties. Calculated properties should be initialized using a property get rule.\r\n        if (!property.isCalculated) {\r\n            var setPendingInit = !property.isConstant;\r\n            Property$init(property, obj, Property$getInitialValue(property));\r\n            if (property.initializer) {\r\n                obj.update(property.name, property.initializer.call(obj));\r\n                setPendingInit = false;\r\n            }\r\n            // Mark the property as pending initialization if the property value may need to\r\n            // be established by a default calculation rule, or some other external logic.\r\n            // This is not relevant if it is a constant or its value is established via an initilizer.\r\n            if (setPendingInit)\r\n                Property$pendingInit(obj, property, true);\r\n        }\r\n    }\r\n}\r\nfunction Property$getter(property, obj) {\r\n    // Ensure that the property has an initial (possibly default) value\r\n    Property$ensureInited(property, obj);\r\n    // Raise access events\r\n    property.accessed.publish(obj, { entity: obj, property: property, value: obj.__fields__[property.name] });\r\n    obj.accessed.publish(obj, { entity: obj, property: property });\r\n    // Return the property value\r\n    return obj.__fields__[property.name];\r\n}\r\nfunction Property$setter(property, obj, val, additionalArgs) {\r\n    if (additionalArgs === void 0) { additionalArgs = null; }\r\n    // Ensure that the property has an initial (possibly default) value\r\n    Property$ensureInited(property, obj);\r\n    var old = obj.__fields__[property.name];\r\n    if (Property$shouldSetValue(property, obj, old, val)) {\r\n        Property$setValue(property, obj, old, val, additionalArgs);\r\n    }\r\n    else {\r\n        // Set pendingInit to false here, since the setter is not called since the value is not changing\r\n        Property$pendingInit(obj, property, false);\r\n    }\r\n}\r\nexports.Property$setter = Property$setter;\r\nfunction Property$shouldSetValue(property, obj, old, val) {\r\n    if (!property.canSetValue(obj, val)) {\r\n        throw new Error(\"Cannot set \" + property.name + \"=\" + (val === undefined ? \"<undefined>\" : val) + \" for instance \" + obj.meta.type.fullName + \"|\" + obj.meta.id + \": a value of type \" + (type_1.isEntityType(property.propertyType) ? property.propertyType.meta.fullName : helpers_1.parseFunctionName(property.propertyType)) + \" was expected.\");\r\n    }\r\n    for (var _i = 0, _a = property.rules; _i < _a.length; _i++) {\r\n        var rule = _a[_i];\r\n        if (rule instanceof allowed_values_rule_1.AllowedValuesRule && rule.preventInvalidValues && !rule.values(obj).includes(val) && val !== null && val !== undefined) {\r\n            throw new Error(\"Cannot set \" + property.name + \", \\\"\" + val + \"\\\" is not an allowed value.\");\r\n        }\r\n    }\r\n    // Update lists as batch remove/add operations\r\n    if (property.isConstant) {\r\n        throw new Error(\"Constant properties cannot be modified.\");\r\n    }\r\n    else {\r\n        // compare values so that this check is accurate for primitives\r\n        var oldValue = (old === undefined || old === null) ? old : old.valueOf();\r\n        var newValue = (val === undefined || val === null) ? val : val.valueOf();\r\n        // Do nothing if the new value is the same as the old value. Account for NaN numbers, which are\r\n        // not equivalent (even to themselves). Although isNaN returns true for non-Number values, we won't\r\n        // get this far for Number properties unless the value is actually of type Number (a number or NaN).\r\n        return (oldValue !== newValue && !(property.propertyType === Number && isNaN(oldValue) && isNaN(newValue)));\r\n    }\r\n}\r\nfunction Property$setValue(property, obj, currentValue, newValue, additionalArgs) {\r\n    if (additionalArgs === void 0) { additionalArgs = null; }\r\n    // Update lists as batch remove/add operations\r\n    if (property.isList) {\r\n        var currentArray = currentValue;\r\n        currentArray.batchUpdate(function (array) {\r\n            observable_array_1.updateArray(array, newValue);\r\n        }, additionalArgs);\r\n        // Set pendingInit to false here, since an array change event will not be raised if there are no changes\r\n        // (ex: array was previously an empty array and newValue is also an empty array).\r\n        Property$pendingInit(obj, property, false);\r\n    }\r\n    else {\r\n        var oldValue = currentValue;\r\n        // Set or create the backing field value\r\n        if (Object.prototype.hasOwnProperty.call(obj.__fields__, property.name)) {\r\n            obj.__fields__[property.name] = newValue;\r\n        }\r\n        else {\r\n            Object.defineProperty(obj.__fields__, property.name, { value: newValue, writable: true });\r\n        }\r\n        if (property.isIdentifier && newValue && newValue !== obj.meta.id) {\r\n            // If the identifier property is set or changed, then change the object's id and re-pool with the new id\r\n            obj.meta.type.changeObjectId(obj.meta.id, newValue);\r\n        }\r\n        Property$pendingInit(obj, property, false);\r\n        // Do not raise change if the property has not been initialized.\r\n        if (oldValue !== undefined) {\r\n            var eventArgs = { entity: obj, property: property, newValue: newValue, oldValue: oldValue };\r\n            property.containingType.model.afterPropertySet.publish(obj, helpers_1.merge(eventArgs, additionalArgs));\r\n            property.changed.publish(obj, helpers_1.merge(eventArgs, additionalArgs));\r\n            obj.changed.publish(obj, helpers_1.merge(eventArgs, additionalArgs));\r\n        }\r\n    }\r\n}\r\nfunction Property$makeGetter(property, getter) {\r\n    return function (additionalArgs) {\r\n        if (additionalArgs === void 0) { additionalArgs = null; }\r\n        // ensure the property is initialized\r\n        return getter(property, this, additionalArgs);\r\n    };\r\n}\r\nfunction Property$makeSetter(prop, setter, skipTypeCheck) {\r\n    // TODO: Is setter \"__notifies\" needed?\r\n    // setter.__notifies = true;\r\n    if (skipTypeCheck === void 0) { skipTypeCheck = false; }\r\n    return function (val, additionalArgs) {\r\n        if (additionalArgs === void 0) { additionalArgs = null; }\r\n        setter(prop, this, val, additionalArgs, skipTypeCheck);\r\n    };\r\n}\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nvar resource_1 = require(\"./resource\");\r\nresource_1.defineResources(\"en\", {\r\n    \"allowed-values\": \"{property} is not in the list of allowed values.\",\r\n    \"listlength-at-least\": \"Please specify at least {min} {property}.\",\r\n    \"listlength-at-most\": \"Please specify no more than {max} {property}.\",\r\n    \"listlength-between\": \"Please specify between {min} and {max} {property}.\",\r\n    \"range-at-least\": \"{property} must be at least {min}.\",\r\n    \"range-at-most\": \"{property} must be at most {max}.\",\r\n    \"range-between\": \"{property} must be between {min} and {max}.\",\r\n    \"range-on-or-after\": \"{property} must be on or after {min}.\",\r\n    \"range-on-or-before\": \"{property} must be on or before {max}.\",\r\n    \"required\": \"{property} is required.\",\r\n    \"string-format\": \"{property} must be formatted as {formatDescription}.\",\r\n    \"string-length-at-least\": \"{property} must be at least {min} characters.\",\r\n    \"string-length-at-most\": \"{property} must be at most {max} characters.\",\r\n    \"string-length-between\": \"{property} must be between {min} and {max} characters.\",\r\n    \"format-with-description\": \"{property} must be formatted as {description}.\",\r\n    \"format-without-description\": \"{property} is not properly formatted.\",\r\n    \"format-currency\": \"$#,###.##\",\r\n    \"format-percentage\": \"#.##%\",\r\n    \"format-integer\": \"#,###\",\r\n    \"format-decimal\": \"#,###.##\"\r\n});\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\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};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.updateArray = exports.ArrayObserver = exports.ObservableArray$unshift = exports.ObservableArray$splice = exports.ObservableArray$sort = exports.ObservableArray$shift = exports.ObservableArray$reverse = exports.ObservableArray$push = exports.ObservableArray$pop = exports.ObservableArray$fill = exports.ObservableArray$copyWithin = exports.ObservableArray$batchUpdate = exports.ObservableArray$overrideNativeMethods = exports.ObservableArrayImplementation = exports.ArrayChangeType = exports.ObservableArray = void 0;\r\nvar events_1 = require(\"./events\");\r\nvar helpers_1 = require(\"./helpers\");\r\n// eslint-disable-next-line import/export, no-redeclare, @typescript-eslint/no-unused-vars\r\nvar ObservableArray = /** @class */ (function () {\r\n    function ObservableArray() {\r\n    }\r\n    /**\r\n     * Returns a value indicating whether the given array is observable\r\n     * @param array The array to check for observability\r\n     */\r\n    ObservableArray.isObservableArray = function (array) {\r\n        return helpers_1.hasOwnProperty(array, \"__aob__\") && array.__aob__.constructor === ArrayObserver;\r\n    };\r\n    /**\r\n     * Makes the given array observable, if not already\r\n     * @param array The array to make observable\r\n     */\r\n    ObservableArray.ensureObservable = function (array) {\r\n        // Check to see if the array is already an observable list\r\n        if (ObservableArray.isObservableArray(array)) {\r\n            return array;\r\n        }\r\n        if (helpers_1.hasOwnProperty(array, \"__aob__\")) {\r\n            // TODO: Warn about invalid '__aob__' property?\r\n            return;\r\n        }\r\n        Object.defineProperty(array, \"__aob__\", {\r\n            configurable: false,\r\n            enumerable: false,\r\n            value: new ArrayObserver(array),\r\n            writable: false\r\n        });\r\n        Object.defineProperty(array, \"changed\", {\r\n            configurable: false,\r\n            enumerable: true,\r\n            get: function () {\r\n                return this.__aob__.changed;\r\n            }\r\n        });\r\n        array[\"batchUpdate\"] = ObservableArray$batchUpdate;\r\n        ObservableArray$overrideNativeMethods.call(array);\r\n        return array;\r\n    };\r\n    /**\r\n     * Creates a new observable array\r\n     * @param items The initial array items\r\n     */\r\n    ObservableArray.create = function (items) {\r\n        if (items === void 0) { items = []; }\r\n        var array;\r\n        if (items instanceof ObservableArray)\r\n            array = items;\r\n        else\r\n            array = new (ObservableArrayImplementation.bind.apply(ObservableArrayImplementation, __spreadArrays([void 0], items)))();\r\n        ObservableArray.ensureObservable(array);\r\n        return array;\r\n    };\r\n    return ObservableArray;\r\n}());\r\nexports.ObservableArray = ObservableArray;\r\nvar ArrayChangeType;\r\n(function (ArrayChangeType) {\r\n    ArrayChangeType[ArrayChangeType[\"add\"] = 1] = \"add\";\r\n    ArrayChangeType[ArrayChangeType[\"remove\"] = 2] = \"remove\";\r\n    ArrayChangeType[ArrayChangeType[\"replace\"] = 4] = \"replace\";\r\n    ArrayChangeType[ArrayChangeType[\"reorder\"] = 8] = \"reorder\";\r\n})(ArrayChangeType = exports.ArrayChangeType || (exports.ArrayChangeType = {}));\r\nvar ObservableArrayImplementation = /** @class */ (function (_super) {\r\n    __extends(ObservableArrayImplementation, _super);\r\n    /**\r\n     * Creates a new observable array\r\n     * @param items The array of initial items\r\n     */\r\n    function ObservableArrayImplementation() {\r\n        var items = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            items[_i] = arguments[_i];\r\n        }\r\n        var _this = _super.apply(this, items) || this;\r\n        Object.defineProperty(_this, \"__aob__\", {\r\n            configurable: false,\r\n            enumerable: false,\r\n            value: new ArrayObserver(_this),\r\n            writable: false\r\n        });\r\n        Object.defineProperty(_this, \"changed\", {\r\n            get: function () {\r\n                return this.__aob__.changed;\r\n            }\r\n        });\r\n        if (_this.constructor !== ObservableArrayImplementation) {\r\n            _this[\"batchUpdate\"] = (function (fn) { ObservableArray$batchUpdate.call(this, fn); });\r\n            ObservableArray$overrideNativeMethods.call(_this);\r\n        }\r\n        return _this;\r\n    }\r\n    Object.defineProperty(ObservableArrayImplementation.prototype, \"changed\", {\r\n        /** Expose the changed event */\r\n        get: function () {\r\n            return this.__aob__.changed;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    /**\r\n     * Begin queueing changes to the array, make changes in the given callback function, then stop queueing and raise events\r\n     */\r\n    ObservableArrayImplementation.prototype.batchUpdate = function (fn, additionalArgs) {\r\n        if (additionalArgs === void 0) { additionalArgs = null; }\r\n        ObservableArray$batchUpdate.call(this, fn, additionalArgs);\r\n    };\r\n    /**\r\n     * The copyWithin() method shallow copies part of an array to another location in the same array and returns it, without modifying its size.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin\r\n     * @param target Zero based index at which to copy the sequence to. If negative, target will be counted from the end. If target is at or greater than arr.length, nothing will be copied. If target is positioned after start, the copied sequence will be trimmed to fit arr.length.\r\n     * @param start Zero based index at which to start copying elements from. If negative, start will be counted from the end. If start is omitted, copyWithin will copy from the start (defaults to 0).\r\n     * @param end Zero based index at which to end copying elements from. copyWithin copies up to but not including end. If negative, end will be counted from the end. If end is omitted, copyWithin will copy until the end (default to arr.length).\r\n     * @returns The modified array.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    ObservableArrayImplementation.prototype.copyWithin = function (target, start, end) {\r\n        return ObservableArray$copyWithin.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The fill() method fills all the elements of an array from a start index to an end index with a static value. The end index is not included.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill\r\n     * @param value Value to fill an array.\r\n     * @param start Start index, defaults to 0.\r\n     * @param end End index, defaults to this.length.\r\n     * @returns The modified array.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    ObservableArrayImplementation.prototype.fill = function (value, start, end) {\r\n        return ObservableArray$fill.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The pop() method removes the last element from an array and returns that element. This method changes the length of the array.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop\r\n     * @returns The removed element from the array; undefined if the array is empty.\r\n     */\r\n    ObservableArrayImplementation.prototype.pop = function () {\r\n        return ObservableArray$pop.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The push() method adds one or more elements to the end of an array and returns the new length of the array.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push\r\n     * @param items The elements to add to the end of the array.\r\n     * @returns The new length property of the object upon which the method was called.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    ObservableArrayImplementation.prototype.push = function () {\r\n        var elements = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            elements[_i] = arguments[_i];\r\n        }\r\n        return ObservableArray$push.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse\r\n     * @returns The reversed array.\r\n     */\r\n    ObservableArrayImplementation.prototype.reverse = function () {\r\n        return ObservableArray$reverse.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The shift() method removes the first element from an array and returns that removed element. This method changes the length of the array.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift\r\n     * @returns The removed element from the array; undefined if the array is empty.\r\n     */\r\n    ObservableArrayImplementation.prototype.shift = function () {\r\n        return ObservableArray$shift.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The sort() method sorts the elements of an array in place and returns the array. Javascript sort algorithm on V8 is now stable. The default sort order is according to string Unicode code points.\r\n     * The time and space complexity of the sort cannot be guaranteed as it is implementation dependent.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort\r\n     * @param compareFunction Specifies a function that defines the sort order. If omitted, the array is sorted according to each character's Unicode code point value, according to the string conversion of each element.\r\n     * @returns The sorted array. Note that the array is sorted in place, and no copy is made.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    ObservableArrayImplementation.prototype.sort = function (compareFunction) {\r\n        return ObservableArray$sort.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The splice() method changes the contents of an array by removing existing elements and/or adding new elements.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice\r\n     * @param start  Index at which to start changing the array (with origin 0). If greater than the length of the array, actual starting index will be set to the length of the array. If negative, will begin that many elements from the end of the array (with origin -1) and will be set to 0 if absolute value is greater than the length of the array.\r\n     * @param deleteCount An integer indicating the number of old array elements to remove. If deleteCount is omitted, or if its value is larger than array.length - start (that is, if it is greater than the number of elements left in the array, starting at start), then all of the elements from start through the end of the array will be deleted. If deleteCount is 0 or negative, no elements are removed. In this case, you should specify at least one new element (see below).\r\n     * @param items The elements to add to the array, beginning at the start index. If you don't specify any elements, splice() will only remove elements from the array.\r\n     * @returns An array containing the deleted elements. If only one element is removed, an array of one element is returned. If no elements are removed, an empty array is returned.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    ObservableArrayImplementation.prototype.splice = function (start, deleteCount) {\r\n        var items = [];\r\n        for (var _i = 2; _i < arguments.length; _i++) {\r\n            items[_i - 2] = arguments[_i];\r\n        }\r\n        return ObservableArray$splice.apply(this, arguments);\r\n    };\r\n    /**\r\n     * The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.\r\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift\r\n     * @param items The elements to add to the front of the array.\r\n     * @returns The new length property of the object upon which the method was called.\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    ObservableArrayImplementation.prototype.unshift = function () {\r\n        var items = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            items[_i] = arguments[_i];\r\n        }\r\n        return ObservableArray$unshift.apply(this, arguments);\r\n    };\r\n    return ObservableArrayImplementation;\r\n}(Array));\r\nexports.ObservableArrayImplementation = ObservableArrayImplementation;\r\n/**\r\n * Override's native Array methods that manipulate the array\r\n * @param array The array to extend\r\n */\r\nfunction ObservableArray$overrideNativeMethods() {\r\n    this[\"copyWithin\"] = ObservableArray$copyWithin;\r\n    this[\"fill\"] = ObservableArray$fill;\r\n    this[\"pop\"] = ObservableArray$pop;\r\n    this[\"push\"] = ObservableArray$push;\r\n    this[\"reverse\"] = ObservableArray$reverse;\r\n    this[\"shift\"] = ObservableArray$shift;\r\n    this[\"sort\"] = ObservableArray$sort;\r\n    this[\"splice\"] = ObservableArray$splice;\r\n    this[\"unshift\"] = ObservableArray$unshift;\r\n}\r\nexports.ObservableArray$overrideNativeMethods = ObservableArray$overrideNativeMethods;\r\n/**\r\n * Begin queueing changes to the array, make changes in the given callback function, then stop queueing and raise events\r\n */\r\nfunction ObservableArray$batchUpdate(fn, additionalArgs) {\r\n    if (additionalArgs === void 0) { additionalArgs = null; }\r\n    this.__aob__.startQueueingChanges();\r\n    try {\r\n        fn(this);\r\n        this.__aob__.stopQueueingChanges(true, additionalArgs);\r\n    }\r\n    finally {\r\n        if (this.__aob__._isQueuingChanges) {\r\n            this.__aob__.stopQueueingChanges(false, additionalArgs);\r\n        }\r\n    }\r\n}\r\nexports.ObservableArray$batchUpdate = ObservableArray$batchUpdate;\r\n/**\r\n * The copyWithin() method shallow copies part of an array to another location in the same array and returns it, without modifying its size.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin\r\n * @param array The observable array\r\n * @param target Zero based index at which to copy the sequence to. If negative, target will be counted from the end. If target is at or greater than arr.length, nothing will be copied. If target is positioned after start, the copied sequence will be trimmed to fit arr.length.\r\n * @param start Zero based index at which to start copying elements from. If negative, start will be counted from the end. If start is omitted, copyWithin will copy from the start (defaults to 0).\r\n * @param end Zero based index at which to end copying elements from. copyWithin copies up to but not including end. If negative, end will be counted from the end. If end is omitted, copyWithin will copy until the end (default to arr.length).\r\n */\r\nfunction ObservableArray$copyWithin(target, start, end) {\r\n    Array.prototype.copyWithin.apply(this, arguments);\r\n    // TODO: Warn about non-observable manipulation of observable array?\r\n    this.__aob__.raiseEvents({ type: ArrayChangeType.replace, startIndex: start, endIndex: end });\r\n    return this;\r\n}\r\nexports.ObservableArray$copyWithin = ObservableArray$copyWithin;\r\n/**\r\n * The fill() method fills all the elements of an array from a start index to an end index with a static value. The end index is not included.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill\r\n * @param array The observable array\r\n * @param value Value to fill an array.\r\n * @param start Start index, defaults to 0.\r\n * @param end End index, defaults to this.length.\r\n */\r\nfunction ObservableArray$fill(value, start, end) {\r\n    Array.prototype.fill.apply(this, arguments);\r\n    // TODO: Warn about non-observable manipulation of observable array?\r\n    this.__aob__.raiseEvents({ type: ArrayChangeType.replace, startIndex: start, endIndex: end });\r\n    return this;\r\n}\r\nexports.ObservableArray$fill = ObservableArray$fill;\r\n/**\r\n * The pop() method removes the last element from an array and returns that element. This method changes the length of the array.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop\r\n * @param array The observable array\r\n * @returns The removed element from the array; undefined if the array is empty.\r\n */\r\nfunction ObservableArray$pop() {\r\n    var originalLength = this.length;\r\n    var removed = Array.prototype.pop.apply(this, arguments);\r\n    if (this.length !== originalLength) {\r\n        var removedIndex = originalLength - 1;\r\n        this.__aob__.raiseEvents({ type: ArrayChangeType.remove, startIndex: removedIndex, endIndex: removedIndex, items: [removed] });\r\n    }\r\n    return removed;\r\n}\r\nexports.ObservableArray$pop = ObservableArray$pop;\r\n/**\r\n * The push() method adds one or more elements to the end of an array and returns the new length of the array.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push\r\n * @param array The observable array\r\n * @param items The elements to add to the end of the array.\r\n * @returns The new length property of the object upon which the method was called.\r\n */\r\nfunction ObservableArray$push() {\r\n    var items = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        items[_i] = arguments[_i];\r\n    }\r\n    // BUG: Babel's handling of rest arguments seems to be thrown off by 1 (due to the \"this\" argument?) - cognitoforms/model.js:#5\r\n    items = Array.prototype.slice.call(arguments);\r\n    var originalLength = this.length;\r\n    var newLength = Array.prototype.push.apply(this, arguments);\r\n    if (newLength > 0) {\r\n        this.__aob__.raiseEvents({ type: ArrayChangeType.add, startIndex: originalLength, endIndex: originalLength + (newLength - originalLength) - 1, items: items });\r\n    }\r\n    return newLength;\r\n}\r\nexports.ObservableArray$push = ObservableArray$push;\r\n/**\r\n * The reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse\r\n * @param array The observable array\r\n * @returns The reversed array.\r\n */\r\nfunction ObservableArray$reverse() {\r\n    Array.prototype.reverse.apply(this, arguments);\r\n    // TODO: Warn about non-observable manipulation of observable array?\r\n    this.__aob__.raiseEvents({ type: ArrayChangeType.reorder, startIndex: 0, endIndex: this.length - 1 });\r\n    return this;\r\n}\r\nexports.ObservableArray$reverse = ObservableArray$reverse;\r\n/**\r\n * The shift() method removes the first element from an array and returns that removed element. This method changes the length of the array.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift\r\n * @param array The observable array\r\n * @returns The removed element from the array; undefined if the array is empty.\r\n */\r\nfunction ObservableArray$shift() {\r\n    var originalLength = this.length;\r\n    var removed = Array.prototype.shift.apply(this, arguments);\r\n    if (this.length !== originalLength) {\r\n        this.__aob__.raiseEvents({ type: ArrayChangeType.remove, startIndex: 0, endIndex: 0, items: [removed] });\r\n    }\r\n    return removed;\r\n}\r\nexports.ObservableArray$shift = ObservableArray$shift;\r\n/**\r\n * The sort() method sorts the elements of an array in place and returns the array. Javascript sort algorithm on V8 is now stable. The default sort order is according to string Unicode code points.\r\n * The time and space complexity of the sort cannot be guaranteed as it is implementation dependent.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort\r\n * @param array The observable array\r\n * @param compareFunction Specifies a function that defines the sort order. If omitted, the array is sorted according to each character's Unicode code point value, according to the string conversion of each element.\r\n * @returns The sorted array. Note that the array is sorted in place, and no copy is made.\r\n */\r\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\r\nfunction ObservableArray$sort(compareFunction) {\r\n    Array.prototype.sort.apply(this, arguments);\r\n    // TODO: Warn about non-observable manipulation of observable array?\r\n    this.__aob__.raiseEvents({ type: ArrayChangeType.reorder, startIndex: 0, endIndex: this.length - 1 });\r\n    return this;\r\n}\r\nexports.ObservableArray$sort = ObservableArray$sort;\r\n/**\r\n * The splice() method changes the contents of an array by removing existing elements and/or adding new elements.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice\r\n * @param array The observable array\r\n * @param start  Index at which to start changing the array (with origin 0). If greater than the length of the array, actual starting index will be set to the length of the array. If negative, will begin that many elements from the end of the array (with origin -1) and will be set to 0 if absolute value is greater than the length of the array.\r\n * @param deleteCount An integer indicating the number of old array elements to remove. If deleteCount is omitted, or if its value is larger than array.length - start (that is, if it is greater than the number of elements left in the array, starting at start), then all of the elements from start through the end of the array will be deleted. If deleteCount is 0 or negative, no elements are removed. In this case, you should specify at least one new element (see below).\r\n * @param items The elements to add to the array, beginning at the start index. If you don't specify any elements, splice() will only remove elements from the array.\r\n * @returns An array containing the deleted elements. If only one element is removed, an array of one element is returned. If no elements are removed, an empty array is returned.\r\n */\r\nfunction ObservableArray$splice(start, deleteCount) {\r\n    var items = [];\r\n    for (var _i = 2; _i < arguments.length; _i++) {\r\n        items[_i - 2] = arguments[_i];\r\n    }\r\n    // BUG: Babel's handling of rest arguments seems to be thrown off by 1 (due to the \"this\" argument?) - cognitoforms/model.js:#5\r\n    items = Array.prototype.slice.call(arguments, 2);\r\n    var removed = Array.prototype.splice.apply(this, arguments);\r\n    if (removed.length > 0 || items.length > 0) {\r\n        var changeEvents = [];\r\n        if (removed.length > 0) {\r\n            changeEvents.push({ type: ArrayChangeType.remove, startIndex: start, endIndex: start + removed.length - 1, items: removed });\r\n        }\r\n        if (items.length > 0) {\r\n            changeEvents.push({ type: ArrayChangeType.add, startIndex: start, endIndex: start + items.length - 1, items: items });\r\n        }\r\n        this.__aob__.raiseEvents(changeEvents);\r\n    }\r\n    return removed;\r\n}\r\nexports.ObservableArray$splice = ObservableArray$splice;\r\n/**\r\n * The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.\r\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift\r\n * @param array The observable array\r\n * @param items The elements to add to the front of the array.\r\n * @returns The new length property of the object upon which the method was called.\r\n */\r\nfunction ObservableArray$unshift() {\r\n    var items = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        items[_i] = arguments[_i];\r\n    }\r\n    // BUG: Babel's handling of rest arguments seems to be thrown off by 1 (due to the \"this\" argument?) - cognitoforms/model.js:#5\r\n    items = Array.prototype.slice.call(arguments);\r\n    var originalLength = this.length;\r\n    var newLength = Array.prototype.unshift.apply(this, arguments);\r\n    if (newLength !== originalLength) {\r\n        this.__aob__.raiseEvents({ type: ArrayChangeType.add, startIndex: 0, endIndex: items.length - 1, items: items });\r\n    }\r\n    return newLength;\r\n}\r\nexports.ObservableArray$unshift = ObservableArray$unshift;\r\nvar ArrayObserver = /** @class */ (function () {\r\n    function ArrayObserver(array) {\r\n        this.array = array;\r\n        this.changed = new events_1.Event();\r\n        this._isQueuingChanges = false;\r\n    }\r\n    ArrayObserver.prototype.raiseEvents = function (changes, additionalArgs) {\r\n        if (this._isQueuingChanges) {\r\n            if (!this._queuedChanges) {\r\n                this._queuedChanges = [];\r\n            }\r\n            if (Array.isArray(changes)) {\r\n                Array.prototype.push.apply(this._queuedChanges, changes);\r\n            }\r\n            else {\r\n                this._queuedChanges.push(changes);\r\n            }\r\n        }\r\n        else if (Array.isArray(changes)) {\r\n            if (changes.length)\r\n                this.changed.publish(this.array, { changes: changes, additionalArgs: additionalArgs });\r\n        }\r\n        else {\r\n            this.changed.publish(this.array, { changes: [changes], additionalArgs: additionalArgs });\r\n        }\r\n    };\r\n    ArrayObserver.prototype.startQueueingChanges = function () {\r\n        this._isQueuingChanges = true;\r\n        if (!this._queuedChanges) {\r\n            this._queuedChanges = [];\r\n        }\r\n    };\r\n    ArrayObserver.prototype.stopQueueingChanges = function (raiseEvents, additionalArgs) {\r\n        if (additionalArgs === void 0) { additionalArgs = null; }\r\n        this._isQueuingChanges = false;\r\n        if (raiseEvents) {\r\n            this.raiseEvents(this._queuedChanges, additionalArgs);\r\n            delete this._queuedChanges;\r\n        }\r\n    };\r\n    return ArrayObserver;\r\n}());\r\nexports.ArrayObserver = ArrayObserver;\r\nfunction callSplice(arr, index, removeCount, addItems) {\r\n    if (removeCount || addItems.length > 0) {\r\n        var addItemsArgs = [index, removeCount].concat(addItems);\r\n        arr.splice.apply(arr, addItemsArgs);\r\n    }\r\n}\r\nfunction updateArray(array, values) {\r\n    var pointer = 0;\r\n    var srcSeek = 0;\r\n    var tgtSeek = 0;\r\n    while (srcSeek < array.length) {\r\n        if (array[srcSeek] === values[tgtSeek]) {\r\n            if (pointer === srcSeek && pointer === tgtSeek) {\r\n                // items match, so advance\r\n                pointer = srcSeek = tgtSeek = pointer + 1;\r\n            }\r\n            else {\r\n                // remove range from source and add range from target\r\n                callSplice(array, pointer, srcSeek - pointer, values.slice(pointer, tgtSeek));\r\n                // reset to index follow target seek location since arrays match up to that point\r\n                pointer = srcSeek = tgtSeek = tgtSeek + 1;\r\n            }\r\n        }\r\n        else if (tgtSeek >= values.length) {\r\n            // reached the end of the target array, so advance the src pointer and test again\r\n            tgtSeek = pointer;\r\n            srcSeek += 1;\r\n        }\r\n        else {\r\n            // advance to the next target item to test\r\n            tgtSeek += 1;\r\n        }\r\n    }\r\n    callSplice(array, pointer, srcSeek - pointer, values.slice(pointer, Math.max(tgtSeek, values.length)));\r\n}\r\nexports.updateArray = updateArray;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.ValidationRule = void 0;\r\nvar condition_rule_1 = require(\"./condition-rule\");\r\nvar property_1 = require(\"./property\");\r\nvar ValidationRule = /** @class */ (function (_super) {\r\n    __extends(ValidationRule, _super);\r\n    function ValidationRule(rootType, options) {\r\n        var _this = this;\r\n        // ensure the rule name is specified\r\n        options.name = options.name || \"ValidatedProperty\";\r\n        // store the property being validated\r\n        var property = options.property;\r\n        // ensure the properties and predicates to include the target property\r\n        if (!options.properties)\r\n            options.properties = [];\r\n        if (!options.properties.includes(property))\r\n            options.properties.push(property);\r\n        if (!options.onChangeOf) {\r\n            options.onChangeOf = [property];\r\n        }\r\n        else if (options.onChangeOf.indexOf(property) < 0) {\r\n            options.onChangeOf.push(property);\r\n        }\r\n        // default condition category to Error if a condition category was not specified\r\n        if (!options.conditionType) {\r\n            options.category = \"Error\";\r\n        }\r\n        // replace the property label token in the validation message if present\r\n        if (options.message && (typeof options.message === \"function\" || (typeof options.message === \"string\" && options.message.indexOf(\"{property}\") >= 0))) {\r\n            // Property label with dynamic format tokens\r\n            if (property.labelIsFormat) {\r\n                var labelSourceType_1 = property_1.getLabelSourceType(property);\r\n                var labelFormat = property_1.getLabelFormat(property);\r\n                // ensure tokens included in the format trigger rule execution\r\n                labelFormat.paths.forEach(function (p) {\r\n                    labelSourceType_1.getPaths(p).forEach(function (prop) {\r\n                        var labelTokenProp = prop;\r\n                        if (property.labelSource) {\r\n                            labelTokenProp = rootType.getPath(property.labelSource.path + \".\" + prop.path);\r\n                        }\r\n                        if (!options.onChangeOf) {\r\n                            options.onChangeOf = [labelTokenProp];\r\n                        }\r\n                        else if (options.onChangeOf.indexOf(labelTokenProp) < 0) {\r\n                            options.onChangeOf.push(labelTokenProp);\r\n                        }\r\n                    });\r\n                });\r\n                if (typeof options.message === \"function\") {\r\n                    var messageFunction_1 = options.message;\r\n                    // Create a function to apply the format to the property label when generating the message\r\n                    options.message = function () {\r\n                        var message = \"\";\r\n                        try {\r\n                            message = messageFunction_1.call(this);\r\n                            if (typeof message === \"string\") {\r\n                                if (message.trim().length > 0 && message.indexOf(\"{property}\") >= 0) {\r\n                                    message = message.replace(\"{property}\", property_1.evaluateLabel(property, this));\r\n                                }\r\n                            }\r\n                            else if (message != null) {\r\n                                console.warn(\"Converting message of type '\" + (typeof message) + \"' for rule '\" + options.name + \"' to a string.\");\r\n                                message = message.toString();\r\n                            }\r\n                        }\r\n                        catch (e) {\r\n                            console.warn(e);\r\n                        }\r\n                        return message;\r\n                    };\r\n                }\r\n                else if (typeof options.message === \"string\") {\r\n                    var messageTemplate_1 = options.message;\r\n                    // Create a function to apply the format to the property label when generating the message\r\n                    options.message = function () {\r\n                        return messageTemplate_1.replace(\"{property}\", property_1.evaluateLabel(property, this));\r\n                    };\r\n                }\r\n            }\r\n            // Static property label\r\n            else if (typeof options.message === \"string\") {\r\n                options.message = options.message.replace(\"{property}\", property.label);\r\n            }\r\n            // Use static property label in function return value\r\n            else if (typeof options.message === \"function\") {\r\n                var messageFunction_2 = options.message;\r\n                // Create a function to apply the format to the property label when generating the message\r\n                options.message = function () {\r\n                    var message = \"\";\r\n                    try {\r\n                        message = messageFunction_2.call(this);\r\n                        if (typeof message === \"string\") {\r\n                            if (message.trim().length > 0 && message.indexOf(\"{property}\") >= 0) {\r\n                                message = message.replace(\"{property}\", property.label);\r\n                            }\r\n                        }\r\n                        else if (message != null) {\r\n                            console.warn(\"Converting message of type '\" + (typeof message) + \"' for rule '\" + options.name + \"' to a string.\");\r\n                            message = message.toString();\r\n                        }\r\n                    }\r\n                    catch (e) {\r\n                        console.warn(e);\r\n                    }\r\n                    return message;\r\n                };\r\n            }\r\n        }\r\n        if (options.isValid) {\r\n            options.assert = function () {\r\n                var isValid;\r\n                try {\r\n                    isValid = options.isValid.call(this, options.property, options.property.value(this));\r\n                }\r\n                catch (e) {\r\n                    console.warn(e);\r\n                }\r\n                return isValid === undefined ? isValid : !isValid;\r\n            };\r\n        }\r\n        // call the base rule constructor\r\n        _this = _super.call(this, rootType, options) || this;\r\n        Object.defineProperty(_this, \"property\", { value: property });\r\n        // register the rule with the target property\r\n        _this.property.rules.push(_this);\r\n        return _this;\r\n    }\r\n    return ValidationRule;\r\n}(condition_rule_1.ConditionRule));\r\nexports.ValidationRule = ValidationRule;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.Event = exports.createEventObject = exports.EventObjectImpl = void 0;\r\nvar functor_1 = require(\"./functor\");\r\nvar helpers_1 = require(\"./helpers\");\r\nvar EventObjectImpl = /** @class */ (function () {\r\n    function EventObjectImpl() {\r\n        this.isDefaultPrevented = false;\r\n    }\r\n    EventObjectImpl.prototype.preventDefault = function () {\r\n        this.isDefaultPrevented = true;\r\n    };\r\n    return EventObjectImpl;\r\n}());\r\nexports.EventObjectImpl = EventObjectImpl;\r\nfunction createEventObject(args) {\r\n    var eventObject = new EventObjectImpl();\r\n    for (var prop in args) {\r\n        if (helpers_1.hasOwnProperty(args, prop)) {\r\n            eventObject[prop] = args[prop];\r\n        }\r\n    }\r\n    return eventObject;\r\n}\r\nexports.createEventObject = createEventObject;\r\nvar Event = /** @class */ (function () {\r\n    function Event(subscriptionChanged) {\r\n        if (subscriptionChanged) {\r\n            this.subscriptionChanged = subscriptionChanged;\r\n        }\r\n    }\r\n    Event.prototype.publish = function (thisObject, args) {\r\n        if (!this.func) {\r\n            // No subscribers\r\n            return;\r\n        }\r\n        var eventObject = createEventObject(args);\r\n        this.func.call(thisObject, eventObject);\r\n        return eventObject;\r\n    };\r\n    Event.prototype.subscribe = function (handler) {\r\n        if (!this.func) {\r\n            Object.defineProperty(this, \"func\", { value: functor_1.Functor$create() });\r\n        }\r\n        this.func.add(handler);\r\n        if (this.subscriptionChanged)\r\n            this.subscriptionChanged(this);\r\n    };\r\n    Event.prototype.subscribeOne = function (handler) {\r\n        if (!this.func) {\r\n            Object.defineProperty(this, \"func\", { value: functor_1.Functor$create() });\r\n        }\r\n        this.func.add(handler, null, true);\r\n        if (this.subscriptionChanged)\r\n            this.subscriptionChanged(this);\r\n    };\r\n    Event.prototype.hasSubscribers = function (handler) {\r\n        if (!this.func) {\r\n            return false;\r\n        }\r\n        var functorItems = (this.func._funcs);\r\n        return handler ? functorItems.some(function (i) { return i.fn === handler; }) : functorItems.length > 0;\r\n    };\r\n    Event.prototype.unsubscribe = function (handler) {\r\n        if (!this.func) {\r\n            // No subscribers\r\n            return;\r\n        }\r\n        this.func.remove(handler);\r\n        if (this.subscriptionChanged)\r\n            this.subscriptionChanged(this);\r\n    };\r\n    Event.prototype.clear = function () {\r\n        if (!this.func) {\r\n            // No subscribers\r\n            return;\r\n        }\r\n        this.func.clear();\r\n        if (this.subscriptionChanged)\r\n            this.subscriptionChanged(this);\r\n    };\r\n    return Event;\r\n}());\r\nexports.Event = Event;\r\n","\"use strict\";\r\nvar __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.Type$generateConstructor = exports.Type$generateMethod = exports.getIdFromState = exports.isEntityType = exports.isValueArray = exports.isValue = exports.isValueType = exports.Type = exports.Type$newIdPrefix = void 0;\r\nvar entity_1 = require(\"./entity\");\r\nvar property_1 = require(\"./property\");\r\nvar helpers_1 = require(\"./helpers\");\r\nvar events_1 = require(\"./events\");\r\nvar observable_array_1 = require(\"./observable-array\");\r\nvar rule_1 = require(\"./rule\");\r\nvar format_1 = require(\"./format\");\r\nvar property_chain_1 = require(\"./property-chain\");\r\nexports.Type$newIdPrefix = \"+c\";\r\nvar Type = /** @class */ (function () {\r\n    // readonly conditionsChanged: EventSubscriber<Type, ConditionTargetsChangedEventArgs>;\r\n    function Type(model, fullName, baseType, format, options) {\r\n        if (baseType === void 0) { baseType = null; }\r\n        this.model = model;\r\n        this.fullName = fullName;\r\n        this.jstype = Type$generateConstructor(this, fullName, baseType, model.settings.useGlobalObject ? helpers_1.getGlobalObject() : null);\r\n        this.baseType = baseType;\r\n        this.derivedTypes = [];\r\n        this._identifier = null;\r\n        Object.defineProperty(this, \"__pool__\", { enumerable: false, configurable: false, writable: false, value: {} });\r\n        Object.defineProperty(this, \"__properties__\", { enumerable: false, configurable: false, writable: false, value: {} });\r\n        Object.defineProperty(this, \"_lastId\", { enumerable: false, configurable: false, writable: true, value: 0 });\r\n        Object.defineProperty(this, \"_formats\", { enumerable: false, configurable: false, writable: true, value: {} });\r\n        Object.defineProperty(this, \"_chains\", { enumerable: false, configurable: false, writable: true, value: {} });\r\n        if (baseType) {\r\n            baseType.derivedTypes.push(this);\r\n        }\r\n        this.initNew = new events_1.Event();\r\n        this.initExisting = new events_1.Event();\r\n        // this.conditionsChanged = new Event<Type, ConditionTargetsChangedEventArgs>();\r\n        // Set Format\r\n        if (format) {\r\n            if (typeof (format) === \"string\") {\r\n                this.format = this.model.getFormat(this.jstype, format);\r\n            }\r\n            else\r\n                this.format = format;\r\n        }\r\n        // Apply type options\r\n        if (options)\r\n            this.extend(options);\r\n    }\r\n    Object.defineProperty(Type.prototype, \"identifier\", {\r\n        get: function () {\r\n            if (this._identifier)\r\n                return this._identifier;\r\n            return this.baseType ? this.baseType.identifier : null;\r\n        },\r\n        set: function (val) {\r\n            this._identifier = val;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Type.prototype.createIfNotExists = function (state) {\r\n        var id = getIdFromState(this, state);\r\n        if (id) {\r\n            var existing = this.get(id);\r\n            if (existing)\r\n                return existing;\r\n        }\r\n        var Ctor = this.jstype;\r\n        // Construct an instance using the known id if it is present\r\n        var instance = (id ? new Ctor(id, state) : new Ctor(state));\r\n        return instance;\r\n    };\r\n    Type.prototype.createSync = function (state) {\r\n        var id = getIdFromState(this, state);\r\n        if (id && this.get(id))\r\n            throw new Error(\"Could not create instance of type '\" + this.fullName + \"' with identifier '\" + id + \"' because this object already exists.\");\r\n        var Ctor = this.jstype;\r\n        // Construct an instance using the known id if it is present\r\n        var instance = (id ? new Ctor(id, state) : new Ctor(state));\r\n        return instance;\r\n    };\r\n    Type.prototype.create = function (state) {\r\n        var instance = this.createSync(state);\r\n        return instance.initialized.then(function () { return instance; });\r\n    };\r\n    /** Generates a unique id suitable for an instance in the current type hierarchy. */\r\n    Type.prototype.newId = function () {\r\n        var lastId;\r\n        for (var type = this; type; type = type.baseType) {\r\n            lastId = Math.max(lastId || 0, type._lastId);\r\n        }\r\n        var nextId = lastId + 1;\r\n        // Update the last id for each type in the heirarchy.\r\n        for (var type = this; type; type = type.baseType) {\r\n            type._lastId = nextId;\r\n        }\r\n        // Return the new id.\r\n        return exports.Type$newIdPrefix + nextId;\r\n    };\r\n    Type.prototype.assertValidId = function (id) {\r\n        if (id === null || id === undefined) {\r\n            throw new Error(\"Id cannot be \" + (id === null ? \"null\" : \"undefined\") + \" (entity = \" + this.fullName + \").\");\r\n        }\r\n        else if (helpers_1.getTypeName(id) !== \"string\") {\r\n            throw new Error(\"Id must be a string:  encountered id \" + id + \" of type \\\"\" + helpers_1.parseFunctionName(id.constructor) + \"\\\" (entity = \" + this.fullName + \").\");\r\n        }\r\n        else if (id === \"\") {\r\n            throw new Error(\"Id cannot be a blank string (entity = \" + this.fullName + \").\");\r\n        }\r\n    };\r\n    Type.prototype.register = function (obj) {\r\n        this.assertValidId(obj.meta.id);\r\n        var key = obj.meta.id.toLowerCase();\r\n        for (var t = this; t; t = t.baseType) {\r\n            if (t.__pool__.hasOwnProperty(key)) {\r\n                throw new Error(\"Object \\\"\" + this.fullName + \"|\" + obj.meta.id + \"\\\" has already been registered.\");\r\n            }\r\n            t.__pool__[key] = obj;\r\n            if (t.__known__) {\r\n                t.__known__.push(obj);\r\n            }\r\n        }\r\n        if (this.model.settings.createOwnProperties === true) {\r\n            for (var prop in this.__properties__) {\r\n                if (Object.prototype.hasOwnProperty.call(this.__properties__, prop)) {\r\n                    var property = this.__properties__[prop];\r\n                    property_1.Property$generateOwnProperty(property, obj);\r\n                }\r\n            }\r\n        }\r\n        this.model.entityRegistered.publish(this.model, { entity: obj });\r\n    };\r\n    Type.prototype.changeObjectId = function (oldId, newId) {\r\n        this.assertValidId(oldId);\r\n        this.assertValidId(newId);\r\n        var oldKey = oldId.toLowerCase();\r\n        var newKey = newId.toLowerCase();\r\n        if (this.__pool__[newKey]) {\r\n            throw new Error(\"Entity '\" + this.fullName + \"|\" + newKey + \"' is already registered.\");\r\n        }\r\n        var obj = this.__pool__[oldKey];\r\n        if (!obj) {\r\n            // TODO: Throw error or warn when attempting to change an object Id that is unknown?\r\n            return;\r\n        }\r\n        for (var t = this; t; t = t.baseType) {\r\n            t.__pool__[newKey] = obj;\r\n        }\r\n        obj.meta.id = newId;\r\n        obj.markPersisted();\r\n        return obj;\r\n    };\r\n    Type.prototype.get = function (id, exactTypeOnly) {\r\n        if (exactTypeOnly === void 0) { exactTypeOnly = false; }\r\n        if (!id) {\r\n            throw new Error(\"Method \\\"\" + this.fullName + \".meta.get()\\\" was called without a valid id argument.\");\r\n        }\r\n        var key = id.toLowerCase();\r\n        var obj = this.__pool__[key];\r\n        // If exactTypeOnly is specified, don't return sub-types.\r\n        if (obj && exactTypeOnly === true && obj.meta.type !== this) {\r\n            throw new Error(\"The entity with id='\" + id + \"' is expected to be of type '\" + this.fullName + \"' but found type '\" + obj.meta.type.fullName + \"'.\");\r\n        }\r\n        return obj;\r\n    };\r\n    // Gets an array of all objects of this type that have been registered.\r\n    // The returned array is observable and collection changed events will be raised\r\n    // when new objects are registered.\r\n    // The array is in no particular order.\r\n    Type.prototype.known = function () {\r\n        var known = this.__known__;\r\n        if (!known) {\r\n            var list = [];\r\n            for (var id in this.__pool__) {\r\n                if (Object.prototype.hasOwnProperty.call(this.__pool__, id)) {\r\n                    list.push(this.__pool__[id]);\r\n                }\r\n            }\r\n            known = observable_array_1.ObservableArray.ensureObservable(list);\r\n            Object.defineProperty(this, \"__known__\", { enumerable: false, configurable: false, writable: false, value: known });\r\n        }\r\n        return known;\r\n    };\r\n    Type.prototype.getProperty = function (name) {\r\n        var prop;\r\n        for (var t = this; t && !prop; t = t.baseType) {\r\n            prop = t.__properties__[name];\r\n            if (prop) {\r\n                return prop;\r\n            }\r\n        }\r\n        return null;\r\n    };\r\n    /** Gets the {Property} or {PropertyChain} for the specified simple path {string}. */\r\n    Type.prototype.getPath = function (path) {\r\n        // Get single property\r\n        var property = this.getProperty(path);\r\n        // Get cached property chain\r\n        if (!property)\r\n            property = this._chains[path];\r\n        // Create and cache property chain\r\n        if (!property) {\r\n            property = this._chains[path] = new property_chain_1.PropertyChain(this, path);\r\n        }\r\n        // Return the property path\r\n        return property;\r\n    };\r\n    /** Gets and array of {Property} or {PropertyChain} instances for the specified complex graph path {string}. */\r\n    Type.prototype.getPaths = function (path) {\r\n        var start = 0;\r\n        var paths = [];\r\n        // Process the path\r\n        if (/{|,|}/g.test(path)) {\r\n            var stack = [];\r\n            var parent_1;\r\n            for (var i = 0, len = path.length; i < len; ++i) {\r\n                var c = path.charAt(i);\r\n                if (c === \"{\" || c === \",\" || c === \"}\") {\r\n                    var seg = path.substring(start, i).trim();\r\n                    start = i + 1;\r\n                    if (c === \"{\") {\r\n                        if (parent_1) {\r\n                            stack.push(parent_1);\r\n                            parent_1 += \".\" + seg;\r\n                        }\r\n                        else {\r\n                            parent_1 = seg;\r\n                        }\r\n                    }\r\n                    else { // ',' or '}'\r\n                        if (seg.length > 0) {\r\n                            paths.push(this.getPath(parent_1 ? parent_1 + \".\" + seg : seg));\r\n                        }\r\n                        if (c === \"}\") {\r\n                            parent_1 = (stack.length === 0) ? undefined : stack.pop();\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            if (stack.length > 0 || parent_1) {\r\n                throw new Error(\"Unclosed '{' in path: \" + path);\r\n            }\r\n            if (start < path.length) {\r\n                var seg = path.substring(start).trim();\r\n                if (seg.length > 0) {\r\n                    paths.push(this.getPath(seg));\r\n                }\r\n                // Set start to past the end of the list to indicate that the entire string was processed\r\n                start = path.length;\r\n            }\r\n        }\r\n        // If the input is a simple property or path, then add the single property or chain\r\n        if (start === 0) {\r\n            paths.push(this.getPath(path.trim()));\r\n        }\r\n        return paths;\r\n    };\r\n    Object.defineProperty(Type.prototype, \"properties\", {\r\n        get: function () {\r\n            var propertiesObject = __assign({}, this.__properties__);\r\n            for (var type = this.baseType; type != null; type = type.baseType) {\r\n                for (var propertyName in type.__properties__) {\r\n                    if (!propertiesObject.hasOwnProperty(propertyName)) {\r\n                        propertiesObject[propertyName] = type.__properties__[propertyName];\r\n                    }\r\n                }\r\n            }\r\n            return Object.values(propertiesObject);\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Type.prototype.addRule = function (optionsOrFunction) {\r\n        var options;\r\n        if (optionsOrFunction) {\r\n            // The options are the function to execute\r\n            if (optionsOrFunction instanceof Function) {\r\n                options = { execute: optionsOrFunction };\r\n            }\r\n            else {\r\n                options = optionsOrFunction;\r\n            }\r\n        }\r\n        var rule = new rule_1.Rule(this, options.name, options);\r\n        // TODO: Track rules on the type?\r\n        return rule;\r\n    };\r\n    Type.prototype.hasModelProperty = function (prop) {\r\n        return prop.containingType === this || this.isSubclassOf(prop.containingType);\r\n    };\r\n    Type.prototype.isSubclassOf = function (type) {\r\n        var result = false;\r\n        helpers_1.navigateAttribute(this, \"baseType\", function (baseType) {\r\n            if (baseType === type) {\r\n                result = true;\r\n                return false;\r\n            }\r\n        });\r\n        return result;\r\n    };\r\n    Type.prototype.toString = function () {\r\n        return this.fullName;\r\n    };\r\n    /**\r\n     * Extends the current type with the specified format, properties and methods\r\n     * @param options The options specifying how to extend the type\r\n     */\r\n    Type.prototype.extend = function (options) {\r\n        var _this = this;\r\n        var type = this;\r\n        // Utility function to convert a path string into a resolved array of Property and PropertyChain instances\r\n        function resolveDependsOn(rule, dependsOn) {\r\n            // return an empty dependency array if no path was specified\r\n            if (!dependsOn)\r\n                return [];\r\n            // throw an exception if dependsOn is not a string\r\n            if (typeof (dependsOn) !== \"string\")\r\n                throw new Error(\"Invalid dependsOn property for '\" + rule + \"' rule on '\" + type + \".\");\r\n            // get the property paths for the specified dependency string\r\n            return type.getPaths(dependsOn);\r\n        }\r\n        // Use prepare() to defer property path resolution while the model is being extended\r\n        this.model.prepare(function () {\r\n            var isRuleMethod = function (value) { return value.hasOwnProperty(\"function\"); };\r\n            var _loop_1 = function (name_1, member) {\r\n                if (name_1.startsWith(\"$\"))\r\n                    return \"continue\";\r\n                // Ignore Type and Format values, which do not represent type members\r\n                if (member instanceof Type || member instanceof format_1.Format)\r\n                    return \"continue\";\r\n                // Property Type Name\r\n                if (typeof (member) === \"string\")\r\n                    member = { type: member };\r\n                // Property Type\r\n                else if (isValueType(member))\r\n                    member = { type: member };\r\n                // Non-Rule Method/Function\r\n                if (typeof (member) === \"function\") {\r\n                    Type$generateMethod(_this, _this.jstype.prototype, name_1, member);\r\n                }\r\n                // Rule Method\r\n                else if (isRuleMethod(member)) {\r\n                    var func = member.function, dependsOn_1 = member.dependsOn;\r\n                    Type$generateMethod(_this, _this.jstype.prototype, name_1, func);\r\n                    _this.model.ready(function () {\r\n                        new rule_1.Rule(_this, _this.fullName + \".\" + name_1 + \"Rule\", {\r\n                            execute: (new Function(\"return this.\" + name_1 + \"();\")),\r\n                            onChangeOf: resolveDependsOn(\"get\", dependsOn_1)\r\n                        }).register();\r\n                    });\r\n                }\r\n                // Property\r\n                else {\r\n                    member = __assign({}, member);\r\n                    // Get Property\r\n                    var property = _this.getProperty(name_1);\r\n                    // Add Property\r\n                    if (!property\r\n                        || (member.type && isEntityType(property.propertyType) && property.propertyType.meta.fullName !== member.type)\r\n                        || (member.type && isValueType(member.type) && isValueType(property.propertyType) && property.propertyType !== member.type)) {\r\n                        // Type & IsList\r\n                        var isList = false;\r\n                        if (typeof (member.type) === \"string\") {\r\n                            var typeName = member.type;\r\n                            // Type names ending in [] are lists\r\n                            if (typeName.lastIndexOf(\"[]\") === (typeName.length - 2)) {\r\n                                isList = true;\r\n                                typeName = typeName.substr(0, typeName.length - 2);\r\n                            }\r\n                            // Convert type names to javascript types\r\n                            member.type = _this.model.getJsType(typeName);\r\n                            // Warn if the type couldn't be found\r\n                            if (!member.type && window.console && console.warn) {\r\n                                console.warn(\"Could not resolve type '\" + typeName + \".\");\r\n                            }\r\n                        }\r\n                        var isIdentifier = member.identifier === true;\r\n                        // Add Property\r\n                        var property_2 = new property_1.Property(_this, name_1, member.type, isIdentifier, isList, member);\r\n                        if (isIdentifier) {\r\n                            _this.identifier = property_2;\r\n                        }\r\n                        _this.__properties__[name_1] = property_2;\r\n                        property_1.Property$generateShortcuts(property_2, _this.jstype);\r\n                        if (!_this.model.settings.createOwnProperties) {\r\n                            property_1.Property$generatePrototypeProperty(property_2, _this.jstype.prototype);\r\n                        }\r\n                    }\r\n                    else {\r\n                        property.extend(member, _this);\r\n                    }\r\n                }\r\n            };\r\n            // Type Members\r\n            for (var _i = 0, _a = helpers_1.entries(options); _i < _a.length; _i++) {\r\n                var _b = _a[_i], name_1 = _b[0], member = _b[1];\r\n                _loop_1(name_1, member);\r\n            }\r\n        });\r\n    };\r\n    return Type;\r\n}());\r\nexports.Type = Type;\r\nfunction isValueType(type) {\r\n    return type === String || type === Number || type === Date || type === Boolean;\r\n}\r\nexports.isValueType = isValueType;\r\nfunction isValue(value, type) {\r\n    if (type === void 0) { type = null; }\r\n    if (value == null)\r\n        return false;\r\n    var valueType = value.constructor;\r\n    if (type != null)\r\n        return valueType === type;\r\n    return isValueType(valueType);\r\n}\r\nexports.isValue = isValue;\r\nfunction isValueArray(value) {\r\n    if (value == null)\r\n        return false;\r\n    if (!Array.isArray(value))\r\n        return false;\r\n    if (value.length === 0)\r\n        return true;\r\n    var item = value[0];\r\n    if (item == null)\r\n        return false;\r\n    var itemType = item.constructor;\r\n    return isValueType(itemType);\r\n}\r\nexports.isValueArray = isValueArray;\r\nfunction isEntityType(type) {\r\n    return type.meta && type.meta instanceof Type;\r\n}\r\nexports.isEntityType = isEntityType;\r\nfunction getIdFromState(type, state) {\r\n    if (type.identifier && typeof state === \"object\") {\r\n        var id = state[type.identifier.name];\r\n        if (id && typeof id === \"string\" && id.length > 0)\r\n            return id;\r\n    }\r\n}\r\nexports.getIdFromState = getIdFromState;\r\nfunction Type$generateMethod(type, target, name, fn) {\r\n    target[name] = fn;\r\n}\r\nexports.Type$generateMethod = Type$generateMethod;\r\n// TODO: Get rid of disableConstruction?\r\nvar disableConstruction = false;\r\nfunction Type$generateConstructor(type, fullName, baseType, global) {\r\n    if (baseType === void 0) { baseType = null; }\r\n    if (global === void 0) { global = null; }\r\n    // Create namespaces as needed\r\n    var nameTokens = fullName.split(\".\");\r\n    var token = nameTokens.shift();\r\n    var namespaceObj = type.model.$namespace || type.model;\r\n    var namespacePrefix = \"\";\r\n    var globalObj = global;\r\n    while (nameTokens.length > 0) {\r\n        namespacePrefix = namespacePrefix + token + \".\";\r\n        namespaceObj = helpers_1.ensureNamespace(token, namespaceObj);\r\n        if (global) {\r\n            globalObj = helpers_1.ensureNamespace(token, globalObj);\r\n        }\r\n        token = nameTokens.shift();\r\n    }\r\n    // The final name to use is the last token\r\n    var finalName = token;\r\n    var BaseConstructor;\r\n    if (baseType) {\r\n        BaseConstructor = baseType.jstype;\r\n        // // TODO: Implement `inheritBaseTypePropShortcuts`\r\n        // // inherit all shortcut properties that have aleady been defined\r\n        // inheritBaseTypePropShortcuts(ctor, baseType);\r\n    }\r\n    else {\r\n        BaseConstructor = entity_1.Entity;\r\n    }\r\n    var ctorFactory = new Function(\"construct\", \"return function \" + finalName + \" () { construct.apply(this, arguments); }\");\r\n    function construct() {\r\n        if (!disableConstruction) {\r\n            try {\r\n                entity_1.Entity.ctorDepth++;\r\n                var args = Array.from(arguments);\r\n                if (!(args[0] instanceof Type))\r\n                    args.unshift(type);\r\n                BaseConstructor.apply(this, args);\r\n            }\r\n            finally {\r\n                entity_1.Entity.ctorDepth--;\r\n            }\r\n        }\r\n    }\r\n    var ctor = ctorFactory(construct);\r\n    var namespaceKey = finalName;\r\n    // If the namespace already contains a type with this name, prepend a '$' to the name\r\n    while (namespaceObj[namespaceKey]) {\r\n        if (process.env.NODE_ENV === \"development\") {\r\n            console.warn(\"Namespace path '\" + namespacePrefix + namespaceKey + \"' is already assigned.\");\r\n        }\r\n        namespaceKey = \"$\" + namespaceKey;\r\n    }\r\n    namespaceObj[namespaceKey] = ctor;\r\n    if (global) {\r\n        var globalKey = finalName;\r\n        // If the global object already contains a type with this name, append a '$' to the name\r\n        while (globalObj[globalKey]) {\r\n            if (process.env.NODE_ENV === \"development\") {\r\n                console.warn(\"Global path '\" + namespacePrefix + globalKey + \"' is already assigned.\");\r\n            }\r\n            globalKey = \"$\" + globalKey;\r\n        }\r\n        globalObj[globalKey] = ctor;\r\n    }\r\n    // Setup inheritance\r\n    disableConstruction = true;\r\n    ctor.prototype = new BaseConstructor();\r\n    disableConstruction = false;\r\n    ctor.prototype.constructor = ctor;\r\n    // Add the 'meta' helper\r\n    Object.defineProperty(ctor, \"meta\", { enumerable: false, value: type, configurable: false, writable: false });\r\n    return ctor;\r\n}\r\nexports.Type$generateConstructor = Type$generateConstructor;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.PermissionConditionType = exports.WarningConditionType = exports.ErrorConditionType = exports.ConditionType = void 0;\r\nvar condition_1 = require(\"./condition\");\r\nvar observable_array_1 = require(\"./observable-array\");\r\nvar allConditionTypes = {};\r\nvar ConditionType = /** @class */ (function () {\r\n    /**\r\n    * Creates a unique type of model condition.\r\n    * @param code The unique condition type code.\r\n    * @param category The category of the condition type, such as \"Error\", \"Warning\", or \"Permission\".\r\n    * @param message The default message to use when the condition is present.\r\n    * @param sets One or more sets the condition type belongs to.\r\n    */\r\n    function ConditionType(code, category, message, sets) {\r\n        // Ensure unique condition type codes\r\n        if (allConditionTypes[code])\r\n            throw new Error(\"A condition type with the code \\\"\" + code + \"\\\" has already been created.\");\r\n        this.code = code;\r\n        this.category = category;\r\n        this.message = message;\r\n        // this.rules = [];\r\n        this.conditions = observable_array_1.ObservableArray.create();\r\n        this.sets = observable_array_1.ObservableArray.ensureObservable(sets || []);\r\n        // Register with the static dictionary of all condition types\r\n        allConditionTypes[code] = this;\r\n    }\r\n    /**\r\n    * Adds or removes a condition from the model for the specified target if necessary.\r\n    * @param condition Whether or not the condition should be present\r\n    * @param target The target instance\r\n    * @param properties The properties to attach the condition to\r\n    * @param message The condition message (or a function to generate the message)\r\n    */\r\n    ConditionType.prototype.when = function (source, condition, target, message) {\r\n        // get the current condition if it exists\r\n        var conditionTarget = target.meta.getCondition(this);\r\n        // add the condition on the target if it does not exist yet\r\n        if (condition) {\r\n            // if the message is a function, invoke to get the actual message\r\n            message = message instanceof Function ? message(target) : message;\r\n            // create a new condition if one does not exist\r\n            if (!conditionTarget) {\r\n                return new condition_1.Condition(this, message, target, source, source.properties);\r\n            }\r\n            // replace the condition if the message has changed\r\n            else if (message && message !== conditionTarget.condition.message) {\r\n                // destroy the existing condition\r\n                conditionTarget.condition.destroy();\r\n                // create a new condition with the updated message\r\n                return new condition_1.Condition(this, message, target, source, source.properties);\r\n            }\r\n            // otherwise, just return the existing condition\r\n            else {\r\n                return conditionTarget.condition;\r\n            }\r\n        }\r\n        // Destroy the condition if it exists on the target and is no longer valid\r\n        if (conditionTarget != null)\r\n            conditionTarget.condition.destroy();\r\n        // Return null to indicate that no condition was created\r\n        return null;\r\n    };\r\n    /**\r\n        * Gets all condition types that have been created.\r\n        * @returns Array of all condition types.\r\n        * */\r\n    ConditionType.all = function () {\r\n        var all = [];\r\n        for (var type in allConditionTypes.keys) {\r\n            all.push(allConditionTypes[type]);\r\n        }\r\n        return all;\r\n    };\r\n    /**\r\n        * Returns the condition type with the given code, if it exists.\r\n        * @param code The unique code of the condition type to find.\r\n        */\r\n    ConditionType.get = function (code) {\r\n        return allConditionTypes[code];\r\n    };\r\n    ;\r\n    return ConditionType;\r\n}());\r\nexports.ConditionType = ConditionType;\r\nvar ErrorConditionType = /** @class */ (function (_super) {\r\n    __extends(ErrorConditionType, _super);\r\n    function ErrorConditionType(code, message, sets) {\r\n        return _super.call(this, code, \"Error\", message, sets) || this;\r\n    }\r\n    return ErrorConditionType;\r\n}(ConditionType));\r\nexports.ErrorConditionType = ErrorConditionType;\r\nvar WarningConditionType = /** @class */ (function (_super) {\r\n    __extends(WarningConditionType, _super);\r\n    function WarningConditionType(code, message, sets) {\r\n        return _super.call(this, code, \"Warning\", message, sets) || this;\r\n    }\r\n    return WarningConditionType;\r\n}(ConditionType));\r\nexports.WarningConditionType = WarningConditionType;\r\nvar PermissionConditionType = /** @class */ (function (_super) {\r\n    __extends(PermissionConditionType, _super);\r\n    function PermissionConditionType(code, message, sets, isAllowed) {\r\n        if (isAllowed === void 0) { isAllowed = true; }\r\n        var _this = _super.call(this, code, \"Warning\", message, sets) || this;\r\n        _this.isAllowed = !(isAllowed === false);\r\n        return _this;\r\n    }\r\n    return PermissionConditionType;\r\n}(ConditionType));\r\nexports.PermissionConditionType = PermissionConditionType;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.FormatError = void 0;\r\nvar condition_type_1 = require(\"./condition-type\");\r\nvar property_1 = require(\"./property\");\r\nvar condition_1 = require(\"./condition\");\r\nvar FormatError = /** @class */ (function () {\r\n    function FormatError(format, message, invalidValue) {\r\n        if (FormatError.ConditionType === null) {\r\n            FormatError.ConditionType = new condition_type_1.ErrorConditionType(\"FormatError\", \"The value is not properly formatted.\");\r\n        }\r\n        this.format = format;\r\n        this.messageTemplate = message;\r\n        this.invalidValue = invalidValue;\r\n    }\r\n    FormatError.prototype.createCondition = function (target, prop) {\r\n        var _this = this;\r\n        return new condition_1.Condition(FormatError.ConditionType, function () { return _this.messageTemplate.replace(\"{property}\", property_1.evaluateLabel(prop, target)); }, target, this.format, [prop]);\r\n    };\r\n    FormatError.prototype.toString = function () {\r\n        return this.invalidValue;\r\n    };\r\n    FormatError.ConditionType = null;\r\n    return FormatError;\r\n}());\r\nexports.FormatError = FormatError;\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var 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    return function (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\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.createFormat = exports.ModelFormat = exports.CustomFormat = exports.Format = exports.getFormatTemplateParser = void 0;\r\nvar format_error_1 = require(\"./format-error\");\r\nvar property_1 = require(\"./property\");\r\nvar property_chain_1 = require(\"./property-chain\");\r\nvar helpers_1 = require(\"./helpers\");\r\nvar model_1 = require(\"./model\");\r\nvar globalization_1 = require(\"./globalization\");\r\nexports.getFormatTemplateParser = function () { return /\\[([_a-zA-Z\\u00aa\\u00b5\\u00ba\\u00c0-\\u00d6\\u00d8-\\u00f6\\u00f8-\\u02b8\\u02bb-\\u02c1\\u02d0-\\u02d1\\u02e0-\\u02e4\\u02ee\\u0370-\\u0373\\u0376-\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0621-\\u064a\\u0660-\\u0669\\u066e-\\u066f\\u0671-\\u06d3\\u06d5\\u06e5-\\u06e6\\u06ee-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07c0-\\u07ea\\u07f4-\\u07f5\\u07fa\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0966-\\u096f\\u0971-\\u0972\\u097b-\\u097f\\u0985-\\u098c\\u098f-\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc-\\u09dd\\u09df-\\u09e1\\u09e6-\\u09f1\\u0a05-\\u0a0a\\u0a0f-\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32-\\u0a33\\u0a35-\\u0a36\\u0a38-\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a66-\\u0a6f\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2-\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0-\\u0ae1\\u0ae6-\\u0aef\\u0b05-\\u0b0c\\u0b0f-\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32-\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c-\\u0b5d\\u0b5f-\\u0b61\\u0b66-\\u0b6f\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99-\\u0b9a\\u0b9c\\u0b9e-\\u0b9f\\u0ba3-\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0be6-\\u0bef\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58-\\u0c59\\u0c60-\\u0c61\\u0c66-\\u0c6f\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0-\\u0ce1\\u0ce6-\\u0cef\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d28\\u0d2a-\\u0d39\\u0d3d\\u0d60-\\u0d61\\u0d66-\\u0d6f\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32-\\u0e33\\u0e40-\\u0e46\\u0e50-\\u0e59\\u0e81-\\u0e82\\u0e84\\u0e87-\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa-\\u0eab\\u0ead-\\u0eb0\\u0eb2-\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0ed0-\\u0ed9\\u0edc-\\u0edd\\u0f00\\u0f20-\\u0f29\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8b\\u1000-\\u102a\\u103f-\\u1049\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065-\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u1090-\\u1099\\u10a0-\\u10c5\\u10d0-\\u10fa\\u10fc\\u1100-\\u1159\\u115f-\\u11a2\\u11a8-\\u11f9\\u1200-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u1676\\u1681-\\u169a\\u16a0-\\u16ea\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u17e0-\\u17e9\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u1900-\\u191c\\u1946-\\u196d\\u1970-\\u1974\\u1980-\\u19a9\\u19c1-\\u19c7\\u19d0-\\u19d9\\u1a00-\\u1a16\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b50-\\u1b59\\u1b83-\\u1ba0\\u1bae-\\u1bb9\\u1c00-\\u1c23\\u1c40-\\u1c49\\u1c4d-\\u1c7d\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u2094\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2183-\\u2184\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2c6f\\u2c71-\\u2c7d\\u2c80-\\u2ce4\\u2d00-\\u2d25\\u2d30-\\u2d65\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3006\\u3031-\\u3035\\u303b-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31b7\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fc3\\ua000-\\ua48c\\ua500-\\ua60c\\ua610-\\ua62b\\ua640-\\ua65f\\ua662-\\ua66e\\ua680-\\ua697\\ua722-\\ua788\\ua78b-\\ua78c\\ua7fb-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8d0-\\ua8d9\\ua900-\\ua925\\ua930-\\ua946\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa50-\\uaa59\\uac00-\\ud7a3\\uf900-\\ufa2d\\ufa30-\\ufa6a\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40-\\ufb41\\ufb43-\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff10-\\uff19\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc][_.0-9a-zA-Z\\u00aa\\u00b5\\u00ba\\u00c0-\\u00d6\\u00d8-\\u00f6\\u00f8-\\u02b8\\u02bb-\\u02c1\\u02d0-\\u02d1\\u02e0-\\u02e4\\u02ee\\u0370-\\u0373\\u0376-\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0621-\\u064a\\u0660-\\u0669\\u066e-\\u066f\\u0671-\\u06d3\\u06d5\\u06e5-\\u06e6\\u06ee-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07c0-\\u07ea\\u07f4-\\u07f5\\u07fa\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0966-\\u096f\\u0971-\\u0972\\u097b-\\u097f\\u0985-\\u098c\\u098f-\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc-\\u09dd\\u09df-\\u09e1\\u09e6-\\u09f1\\u0a05-\\u0a0a\\u0a0f-\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32-\\u0a33\\u0a35-\\u0a36\\u0a38-\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a66-\\u0a6f\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2-\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0-\\u0ae1\\u0ae6-\\u0aef\\u0b05-\\u0b0c\\u0b0f-\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32-\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c-\\u0b5d\\u0b5f-\\u0b61\\u0b66-\\u0b6f\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99-\\u0b9a\\u0b9c\\u0b9e-\\u0b9f\\u0ba3-\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0be6-\\u0bef\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58-\\u0c59\\u0c60-\\u0c61\\u0c66-\\u0c6f\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0-\\u0ce1\\u0ce6-\\u0cef\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d28\\u0d2a-\\u0d39\\u0d3d\\u0d60-\\u0d61\\u0d66-\\u0d6f\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32-\\u0e33\\u0e40-\\u0e46\\u0e50-\\u0e59\\u0e81-\\u0e82\\u0e84\\u0e87-\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa-\\u0eab\\u0ead-\\u0eb0\\u0eb2-\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0ed0-\\u0ed9\\u0edc-\\u0edd\\u0f00\\u0f20-\\u0f29\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8b\\u1000-\\u102a\\u103f-\\u1049\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065-\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u1090-\\u1099\\u10a0-\\u10c5\\u10d0-\\u10fa\\u10fc\\u1100-\\u1159\\u115f-\\u11a2\\u11a8-\\u11f9\\u1200-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u1676\\u1681-\\u169a\\u16a0-\\u16ea\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u17e0-\\u17e9\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u1900-\\u191c\\u1946-\\u196d\\u1970-\\u1974\\u1980-\\u19a9\\u19c1-\\u19c7\\u19d0-\\u19d9\\u1a00-\\u1a16\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b50-\\u1b59\\u1b83-\\u1ba0\\u1bae-\\u1bb9\\u1c00-\\u1c23\\u1c40-\\u1c49\\u1c4d-\\u1c7d\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u2094\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2183-\\u2184\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2c6f\\u2c71-\\u2c7d\\u2c80-\\u2ce4\\u2d00-\\u2d25\\u2d30-\\u2d65\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3006\\u3031-\\u3035\\u303b-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31b7\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fc3\\ua000-\\ua48c\\ua500-\\ua60c\\ua610-\\ua62b\\ua640-\\ua65f\\ua662-\\ua66e\\ua680-\\ua697\\ua722-\\ua788\\ua78b-\\ua78c\\ua7fb-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8d0-\\ua8d9\\ua900-\\ua925\\ua930-\\ua946\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa50-\\uaa59\\uac00-\\ud7a3\\uf900-\\ufa2d\\ufa30-\\ufa6a\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40-\\ufb41\\ufb43-\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff10-\\uff19\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]*)(:(.+?))?\\]/ig; };\r\nvar metaPathParser = /^(.*\\.|)meta(\\..*|)$/;\r\nvar Format = /** @class */ (function () {\r\n    function Format(model, specifier, description, nullString, undefinedString) {\r\n        if (description === void 0) { description = null; }\r\n        if (nullString === void 0) { nullString = null; }\r\n        if (undefinedString === void 0) { undefinedString = undefined; }\r\n        if (process.env.NODE_ENV === \"development\") {\r\n            if (!model || !(model instanceof model_1.Model))\r\n                throw new Error(\"Model must be provided.\");\r\n            if (!specifier || typeof specifier !== \"string\")\r\n                throw new Error(\"Format specifier string must be provided.\");\r\n        }\r\n        this.model = model;\r\n        this.specifier = specifier;\r\n        this.description = description;\r\n        this.nullString = nullString || \"\";\r\n        this.undefinedString = undefinedString || \"\";\r\n    }\r\n    Format.prototype.convert = function (val) {\r\n        if (val === undefined) {\r\n            return this.undefinedString;\r\n        }\r\n        if (val === null) {\r\n            return this.nullString;\r\n        }\r\n        if (val instanceof format_error_1.FormatError) {\r\n            return val.invalidValue;\r\n        }\r\n        return this.convertToString(val);\r\n    };\r\n    Format.prototype.convertBack = function (text) {\r\n        if (text === null || text === this.nullString) {\r\n            return null;\r\n        }\r\n        if (text === undefined || text === this.undefinedString) {\r\n            return;\r\n        }\r\n        if (typeof text === \"string\") {\r\n            text = text.trim();\r\n            if (text.length === 0) {\r\n                return null;\r\n            }\r\n        }\r\n        return this.convertFromString(text);\r\n    };\r\n    Format.prototype.toString = function () {\r\n        return this.specifier;\r\n    };\r\n    Format.create = function (model, options) {\r\n        return new CustomFormat(model, options);\r\n    };\r\n    Format.fromTemplate = function (type, template, formatEval) {\r\n        return new ModelFormat(type, template, formatEval);\r\n    };\r\n    Format.hasTokens = function (template) {\r\n        return exports.getFormatTemplateParser().test(template);\r\n    };\r\n    return Format;\r\n}());\r\nexports.Format = Format;\r\nvar CustomFormat = /** @class */ (function (_super) {\r\n    __extends(CustomFormat, _super);\r\n    function CustomFormat(model, options) {\r\n        var _this = _super.call(this, model, options.specifier, options.description, options.nullString, options.undefinedString) || this;\r\n        _this.customConvert = options.convert;\r\n        _this.customConvertBack = options.convertBack;\r\n        _this.paths = options.paths;\r\n        return _this;\r\n    }\r\n    CustomFormat.prototype.convertToString = function (val) {\r\n        if (!this.customConvert) {\r\n            return val;\r\n        }\r\n        return this.customConvert(val);\r\n    };\r\n    CustomFormat.prototype.convertFromString = function (text) {\r\n        if (!this.customConvertBack) {\r\n            return text;\r\n        }\r\n        try {\r\n            return this.customConvertBack(text);\r\n        }\r\n        catch (err) {\r\n            if (err instanceof format_error_1.FormatError) {\r\n                return err;\r\n            }\r\n            var formatError = new format_error_1.FormatError(this, this.description ?\r\n                this.model.getResource(\"format-with-description\").replace(\"{description}\", this.description) :\r\n                this.model.getResource(\"format-without-description\"), text);\r\n            return formatError;\r\n        }\r\n    };\r\n    return CustomFormat;\r\n}(Format));\r\nexports.CustomFormat = CustomFormat;\r\nvar ModelFormat = /** @class */ (function (_super) {\r\n    __extends(ModelFormat, _super);\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    function ModelFormat(type, specifier, formatEval) {\r\n        var _this = _super.call(this, type.model, specifier) || this;\r\n        _this.type = type;\r\n        _this.formatEval = formatEval;\r\n        // Compile the model format when the model is ready\r\n        _this.model.ready(function () { return _this.compile(); }, { enqueueWhileProcessing: false });\r\n        return _this;\r\n    }\r\n    ModelFormat.prototype.compile = function () {\r\n        if (!this.tokens) {\r\n            this.paths = [];\r\n            this.tokens = [];\r\n            this.template = this.specifier;\r\n            // Replace escaped \\, [ or ] characters with placeholders\r\n            var template = this.template.replace(/\\\\\\\\/g, \"\\u0000\").replace(/\\\\\\[/g, \"\\u0001\").replace(/\\\\\\]/g, \"\\u0002\");\r\n            var index = 0;\r\n            var formatTemplateParser = exports.getFormatTemplateParser();\r\n            var match = formatTemplateParser.exec(template);\r\n            // Process each token match\r\n            while (match) {\r\n                var path = match[1];\r\n                var propertyPath = path;\r\n                // See if the path represents a property path in the model\r\n                var propertyDefaultFormat = null;\r\n                try {\r\n                    // Detect property path followed by \".meta...\"\r\n                    propertyPath = propertyPath.replace(metaPathParser, \"$1\");\r\n                    var isMetaPath = propertyPath.length > 0 && propertyPath.length < path.length;\r\n                    var allowFormat = !isMetaPath;\r\n                    if (isMetaPath) {\r\n                        propertyPath = propertyPath.substring(0, propertyPath.length - 1);\r\n                    }\r\n                    // If a property path remains, then attempt to find a default format and paths for the format\r\n                    if (propertyPath) {\r\n                        var property = this.type.getPath(propertyPath);\r\n                        if (property) {\r\n                            // Only allow formats for a property path that is not followed by \".meta...\"\r\n                            if (allowFormat) {\r\n                                // Determine the default property format\r\n                                if (property instanceof property_1.Property) {\r\n                                    propertyDefaultFormat = property.format;\r\n                                }\r\n                                else if (property instanceof property_chain_1.PropertyChain) {\r\n                                    var lastProperty = property.lastProperty;\r\n                                    propertyDefaultFormat = lastProperty.format;\r\n                                }\r\n                                // Ensure the target format is compiled so we can collect its paths\r\n                                if (propertyDefaultFormat instanceof ModelFormat)\r\n                                    propertyDefaultFormat.compile();\r\n                                // If the path references one or more entity properties, include paths for the property format. Otherwise, just add the path.\r\n                                if (propertyDefaultFormat && propertyDefaultFormat instanceof Format && propertyDefaultFormat !== this && propertyDefaultFormat.paths.length > 0)\r\n                                    Array.prototype.push.apply(this.paths, propertyDefaultFormat.paths.map(function (p) { return propertyPath + \".\" + p; }));\r\n                                else\r\n                                    this.paths.push(propertyPath);\r\n                            }\r\n                            // Formats are not allowed, so just add the path\r\n                            else {\r\n                                this.paths.push(propertyPath);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                catch (e) {\r\n                    //\r\n                }\r\n                // Create a token for the current match, including the prefix, path and format\r\n                this.tokens.push({\r\n                    prefix: template.substring(index, formatTemplateParser.lastIndex - match[0].length).replace(/\\u0000/g, \"\\\\\").replace(/\\u0001/g, \"[\").replace(/\\u0002/g, \"]\"),\r\n                    path: path,\r\n                    format: match[3] ? match[3].replace(/\\u0000/g, \"\\\\\").replace(/\\u0001/g, \"[\").replace(/\\u0002/g, \"]\") : propertyDefaultFormat\r\n                });\r\n                // Track the last index and find the next match\r\n                index = formatTemplateParser.lastIndex;\r\n                match = formatTemplateParser.exec(template);\r\n            }\r\n            // Capture any trailing literal text as a token without a path\r\n            if (index < template.length) {\r\n                this.tokens.push({\r\n                    prefix: template.substring(index).replace(/\\u0000/g, \"\\\\\").replace(/\\u0001/g, \"[\").replace(/\\u0002/g, \"]\")\r\n                });\r\n            }\r\n        }\r\n    };\r\n    ModelFormat.prototype.convertToString = function (obj) {\r\n        var _this = this;\r\n        if (obj === null || obj === undefined) {\r\n            return \"\";\r\n        }\r\n        var convertTokens = function (obj) {\r\n            var result = \"\";\r\n            for (var index = 0; index < _this.tokens.length; index++) {\r\n                var token = _this.tokens[index];\r\n                if (token.prefix)\r\n                    result = result + token.prefix;\r\n                if (token.path) {\r\n                    var value = helpers_1.evalPath(obj, token.path);\r\n                    if (value === undefined || value === null) {\r\n                        value = \"\";\r\n                    }\r\n                    else if (token.format) {\r\n                        var format = void 0;\r\n                        if (token.format instanceof Format) {\r\n                            format = token.format;\r\n                        }\r\n                        else if (typeof token.format === \"string\") {\r\n                            format = token.format = obj.meta.type.model.getFormat(value.constructor, token.format);\r\n                        }\r\n                        value = format.convert(value);\r\n                    }\r\n                    if (_this.formatEval)\r\n                        value = _this.formatEval(value);\r\n                    if (Array.isArray(value))\r\n                        value = value.join(\", \");\r\n                    result = result + value;\r\n                }\r\n            }\r\n            return result;\r\n        };\r\n        if (Array.isArray(obj))\r\n            return obj.map(function (item) { return convertTokens(item); }).join(\", \");\r\n        else\r\n            return convertTokens(obj);\r\n    };\r\n    ModelFormat.prototype.convertFromString = function () {\r\n        throw new Error(\"Cannot convert from a format string back to an entity.\");\r\n    };\r\n    return ModelFormat;\r\n}(Format));\r\nexports.ModelFormat = ModelFormat;\r\nfunction createFormat(model, type, format) {\r\n    if (type === Date) {\r\n        // Add support for g and G that are not natively supported by the format and parse methods\r\n        if (format === \"g\")\r\n            format = globalization_1.expandDateFormat(model.$culture.dateTimeFormat, \"d\") + \" \" + globalization_1.expandDateFormat(model.$culture.dateTimeFormat, \"t\");\r\n        else if (format === \"G\")\r\n            format = globalization_1.expandDateFormat(model.$culture.dateTimeFormat, \"d\") + \" \" + globalization_1.expandDateFormat(model.$culture.dateTimeFormat, \"T\");\r\n        return Format.create(model, {\r\n            specifier: format,\r\n            description: \"\",\r\n            paths: [],\r\n            convert: function (value) {\r\n                return globalization_1.formatDate(value, format, model.$culture);\r\n            },\r\n            convertBack: function (str) {\r\n                var date;\r\n                // Time value, set default date to 1/1/1970 to easily compare time values\r\n                if (format === \"t\") {\r\n                    var timeFormat = globalization_1.expandDateFormat(model.$culture.dateTimeFormat, \"d\") + \" \" + globalization_1.expandDateFormat(model.$culture.dateTimeFormat, \"t\");\r\n                    var startDate = globalization_1.formatDate(new Date(1970, 0, 1), \"d\", model.$culture);\r\n                    date = globalization_1.parseDate(startDate + \" \" + str, model.$culture, [timeFormat]);\r\n                }\r\n                else\r\n                    date = globalization_1.parseDate(str, model.$culture, [format]);\r\n                if (date === null)\r\n                    throw new Error(\"Invalid date format\");\r\n                return date;\r\n            }\r\n        });\r\n    }\r\n    else if (type === Number) {\r\n        var isCurrencyFormat = format.match(/[$c]+/i);\r\n        var isPercentageFormat = format.match(/[%p]+/i);\r\n        var isIntegerFormat = format.match(/[dnfg]0/i);\r\n        return Format.create(model, {\r\n            specifier: format,\r\n            description: isCurrencyFormat ? model.getResource(\"format-currency\") : isPercentageFormat ? model.getResource(\"format-percentage\") : isIntegerFormat ? model.getResource(\"format-integer\") : model.getResource(\"format-decimal\"),\r\n            convert: function (val) {\r\n                // Default to browser formatting for general format\r\n                if (format.toLowerCase() === \"g\")\r\n                    return val.toString();\r\n                // Otherwise, use the localized format\r\n                return globalization_1.formatNumber(val, format, model.$culture);\r\n            },\r\n            convertBack: function (str) {\r\n                var result = globalization_1.parseNumber(str, globalization_1.getNumberStyle(format), model.$culture);\r\n                if (isNaN(result))\r\n                    throw new Error(\"Invalid format\");\r\n                return result;\r\n            }\r\n        });\r\n    }\r\n    else if (type === Boolean) {\r\n        // Format strings used for true, false, and null (or undefined) values\r\n        var trueFormat_1, falseFormat_1, nullFormat_1;\r\n        if (format && format.toLowerCase() === \"g\") {\r\n            trueFormat_1 = \"True\";\r\n            falseFormat_1 = \"False\";\r\n            nullFormat_1 = \"\";\r\n        }\r\n        else {\r\n            var formats = format.split(\";\");\r\n            trueFormat_1 = formats.length > 0 ? formats[0] : \"\";\r\n            falseFormat_1 = formats.length > 1 ? formats[1] : \"\";\r\n            nullFormat_1 = formats.length > 2 ? formats[2] : \"\";\r\n        }\r\n        /**\r\n         * Determines if the given string matches the given format option\r\n         * @param str The text to check\r\n         * @param formatValue The true or false format option\r\n         */\r\n        var isFormatMatch_1 = function (str, formatValue) {\r\n            return str.trim().toLowerCase() === formatValue.trim().toLowerCase();\r\n        };\r\n        return Format.create(model, {\r\n            specifier: format,\r\n            convert: function (val) {\r\n                if (val === true) {\r\n                    return trueFormat_1;\r\n                }\r\n                else if (val === false) {\r\n                    return falseFormat_1;\r\n                }\r\n                else {\r\n                    return nullFormat_1;\r\n                }\r\n            },\r\n            convertBack: function (str) {\r\n                if (isFormatMatch_1(str, trueFormat_1))\r\n                    return true;\r\n                else if (isFormatMatch_1(str, falseFormat_1))\r\n                    return false;\r\n                else\r\n                    return null;\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        console.log(\"WARN: Unable to create format for type '\" + helpers_1.getConstructorName(type) + \"'.\");\r\n    }\r\n}\r\nexports.createFormat = createFormat;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.PropertyChain = void 0;\r\nvar property_1 = require(\"./property\");\r\nvar events_1 = require(\"./events\");\r\nvar format_1 = require(\"./format\");\r\n/**\r\n * Encapsulates the logic required to work with a chain of properties and\r\n * a root object, allowing interaction with the chain as if it were a\r\n * single property of the root object.\r\n */\r\nvar PropertyChain = /** @class */ (function () {\r\n    function PropertyChain(rootType, path) {\r\n        var _this = this;\r\n        this.rootType = rootType;\r\n        // replace \".\" in type casts so that they do not interfere with splitting path\r\n        path = path.replace(/<[^>]*>/ig, function (e) { return e.replace(/\\./ig, function () { return \"$_$\"; }); });\r\n        var currentType = rootType;\r\n        this.properties = path.split(\".\").map(function (step) {\r\n            var property;\r\n            // Regex pattern matches all letters and digits that are valid for javascript identifiers, including  \"_\"\r\n            var parsed = step.match(/^([_0-9a-zA-Z\\u00aa\\u00b5\\u00ba\\u00c0-\\u00d6\\u00d8-\\u00f6\\u00f8-\\u02b8\\u02bb-\\u02c1\\u02d0-\\u02d1\\u02e0-\\u02e4\\u02ee\\u0370-\\u0373\\u0376-\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0621-\\u064a\\u0660-\\u0669\\u066e-\\u066f\\u0671-\\u06d3\\u06d5\\u06e5-\\u06e6\\u06ee-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07c0-\\u07ea\\u07f4-\\u07f5\\u07fa\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0966-\\u096f\\u0971-\\u0972\\u097b-\\u097f\\u0985-\\u098c\\u098f-\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc-\\u09dd\\u09df-\\u09e1\\u09e6-\\u09f1\\u0a05-\\u0a0a\\u0a0f-\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32-\\u0a33\\u0a35-\\u0a36\\u0a38-\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a66-\\u0a6f\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2-\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0-\\u0ae1\\u0ae6-\\u0aef\\u0b05-\\u0b0c\\u0b0f-\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32-\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c-\\u0b5d\\u0b5f-\\u0b61\\u0b66-\\u0b6f\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99-\\u0b9a\\u0b9c\\u0b9e-\\u0b9f\\u0ba3-\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0be6-\\u0bef\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58-\\u0c59\\u0c60-\\u0c61\\u0c66-\\u0c6f\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0-\\u0ce1\\u0ce6-\\u0cef\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d28\\u0d2a-\\u0d39\\u0d3d\\u0d60-\\u0d61\\u0d66-\\u0d6f\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32-\\u0e33\\u0e40-\\u0e46\\u0e50-\\u0e59\\u0e81-\\u0e82\\u0e84\\u0e87-\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa-\\u0eab\\u0ead-\\u0eb0\\u0eb2-\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0ed0-\\u0ed9\\u0edc-\\u0edd\\u0f00\\u0f20-\\u0f29\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8b\\u1000-\\u102a\\u103f-\\u1049\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065-\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u1090-\\u1099\\u10a0-\\u10c5\\u10d0-\\u10fa\\u10fc\\u1100-\\u1159\\u115f-\\u11a2\\u11a8-\\u11f9\\u1200-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u1676\\u1681-\\u169a\\u16a0-\\u16ea\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u17e0-\\u17e9\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u1900-\\u191c\\u1946-\\u196d\\u1970-\\u1974\\u1980-\\u19a9\\u19c1-\\u19c7\\u19d0-\\u19d9\\u1a00-\\u1a16\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b50-\\u1b59\\u1b83-\\u1ba0\\u1bae-\\u1bb9\\u1c00-\\u1c23\\u1c40-\\u1c49\\u1c4d-\\u1c7d\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u2094\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2183-\\u2184\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2c6f\\u2c71-\\u2c7d\\u2c80-\\u2ce4\\u2d00-\\u2d25\\u2d30-\\u2d65\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3006\\u3031-\\u3035\\u303b-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31b7\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fc3\\ua000-\\ua48c\\ua500-\\ua60c\\ua610-\\ua62b\\ua640-\\ua65f\\ua662-\\ua66e\\ua680-\\ua697\\ua722-\\ua788\\ua78b-\\ua78c\\ua7fb-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8d0-\\ua8d9\\ua900-\\ua925\\ua930-\\ua946\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa50-\\uaa59\\uac00-\\ud7a3\\uf900-\\ufa2d\\ufa30-\\ufa6a\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40-\\ufb41\\ufb43-\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff10-\\uff19\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc]+)(<([_$0-9a-zA-Z\\u00aa\\u00b5\\u00ba\\u00c0-\\u00d6\\u00d8-\\u00f6\\u00f8-\\u02b8\\u02bb-\\u02c1\\u02d0-\\u02d1\\u02e0-\\u02e4\\u02ee\\u0370-\\u0373\\u0376-\\u0377\\u037a-\\u037d\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05d0-\\u05ea\\u05f0-\\u05f2\\u0621-\\u064a\\u0660-\\u0669\\u066e-\\u066f\\u0671-\\u06d3\\u06d5\\u06e5-\\u06e6\\u06ee-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07c0-\\u07ea\\u07f4-\\u07f5\\u07fa\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0966-\\u096f\\u0971-\\u0972\\u097b-\\u097f\\u0985-\\u098c\\u098f-\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc-\\u09dd\\u09df-\\u09e1\\u09e6-\\u09f1\\u0a05-\\u0a0a\\u0a0f-\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32-\\u0a33\\u0a35-\\u0a36\\u0a38-\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a66-\\u0a6f\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2-\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0-\\u0ae1\\u0ae6-\\u0aef\\u0b05-\\u0b0c\\u0b0f-\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32-\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c-\\u0b5d\\u0b5f-\\u0b61\\u0b66-\\u0b6f\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99-\\u0b9a\\u0b9c\\u0b9e-\\u0b9f\\u0ba3-\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0be6-\\u0bef\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c33\\u0c35-\\u0c39\\u0c3d\\u0c58-\\u0c59\\u0c60-\\u0c61\\u0c66-\\u0c6f\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0-\\u0ce1\\u0ce6-\\u0cef\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d28\\u0d2a-\\u0d39\\u0d3d\\u0d60-\\u0d61\\u0d66-\\u0d6f\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32-\\u0e33\\u0e40-\\u0e46\\u0e50-\\u0e59\\u0e81-\\u0e82\\u0e84\\u0e87-\\u0e88\\u0e8a\\u0e8d\\u0e94-\\u0e97\\u0e99-\\u0e9f\\u0ea1-\\u0ea3\\u0ea5\\u0ea7\\u0eaa-\\u0eab\\u0ead-\\u0eb0\\u0eb2-\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0ed0-\\u0ed9\\u0edc-\\u0edd\\u0f00\\u0f20-\\u0f29\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8b\\u1000-\\u102a\\u103f-\\u1049\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065-\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u1090-\\u1099\\u10a0-\\u10c5\\u10d0-\\u10fa\\u10fc\\u1100-\\u1159\\u115f-\\u11a2\\u11a8-\\u11f9\\u1200-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f4\\u1401-\\u166c\\u166f-\\u1676\\u1681-\\u169a\\u16a0-\\u16ea\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u17e0-\\u17e9\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18a8\\u18aa\\u1900-\\u191c\\u1946-\\u196d\\u1970-\\u1974\\u1980-\\u19a9\\u19c1-\\u19c7\\u19d0-\\u19d9\\u1a00-\\u1a16\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b50-\\u1b59\\u1b83-\\u1ba0\\u1bae-\\u1bb9\\u1c00-\\u1c23\\u1c40-\\u1c49\\u1c4d-\\u1c7d\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u2094\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2119-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u212d\\u212f-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2183-\\u2184\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2c6f\\u2c71-\\u2c7d\\u2c80-\\u2ce4\\u2d00-\\u2d25\\u2d30-\\u2d65\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3006\\u3031-\\u3035\\u303b-\\u303c\\u3041-\\u3096\\u309d-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312d\\u3131-\\u318e\\u31a0-\\u31b7\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fc3\\ua000-\\ua48c\\ua500-\\ua60c\\ua610-\\ua62b\\ua640-\\ua65f\\ua662-\\ua66e\\ua680-\\ua697\\ua722-\\ua788\\ua78b-\\ua78c\\ua7fb-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8d0-\\ua8d9\\ua900-\\ua925\\ua930-\\ua946\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa50-\\uaa59\\uac00-\\ud7a3\\uf900-\\ufa2d\\ufa30-\\ufa6a\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40-\\ufb41\\ufb43-\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff10-\\uff19\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc$]+)>)?$/i);\r\n            if (parsed) {\r\n                property = currentType.getProperty(parsed[1]);\r\n            }\r\n            // Invalid property\r\n            if (!property) {\r\n                throw new Error(\"Path '\" + path + \"' references unknown property '\" + step + \"' on type '\" + currentType + \"'.\");\r\n            }\r\n            // Get the current type of the step\r\n            currentType = property.propertyType.meta;\r\n            if (parsed[3]) {\r\n                currentType = rootType.model.types[parsed[3]];\r\n            }\r\n            // Return the property\r\n            return property;\r\n        });\r\n        // create the accessed event and automatically subscribe to property accesses along the path when the event is used\r\n        this.accessed = new events_1.Event(function (event) {\r\n            if (event.hasSubscribers() && !_this.stepAccessed) {\r\n                _this.stepAccessed = [];\r\n                _this.properties.forEach(function (property, index, props) {\r\n                    var handler;\r\n                    var priorProp = index > 0 ? props[index - 1] : null;\r\n                    handler = function (args) {\r\n                        _this.rootType.known().forEach(function (known) {\r\n                            if (_this.testConnection(known, args.entity, priorProp)) {\r\n                                _this.accessed.publish(known, {\r\n                                    entity: known,\r\n                                    property: args.property,\r\n                                    value: args.value\r\n                                });\r\n                            }\r\n                        });\r\n                    };\r\n                    _this.stepAccessed[index] = handler;\r\n                    property.accessed.subscribe(handler);\r\n                });\r\n            }\r\n            else if (!event.hasSubscribers() && _this.stepAccessed) {\r\n                _this.properties.forEach(function (property, index) { return property.accessed.unsubscribe(_this.stepAccessed[index]); });\r\n                _this.stepAccessed = null;\r\n            }\r\n        });\r\n        // create the changed event and automatically subscribe to property changes along the path when the event is used\r\n        this.changed = new events_1.Event(function (event) {\r\n            if (event.hasSubscribers() && !_this.stepChanged) {\r\n                _this.stepChanged = [];\r\n                _this.properties.forEach(function (property, index, props) {\r\n                    var handler;\r\n                    var priorProp = index > 0 ? props[index - 1] : null;\r\n                    handler = function (args) {\r\n                        if (priorProp) {\r\n                            _this.rootType.known().forEach(function (known) {\r\n                                if (_this.testConnection(known, args.entity, priorProp)) {\r\n                                    _this.changed.publish(known, {\r\n                                        entity: known,\r\n                                        property: args.property,\r\n                                        oldValue: args.oldValue,\r\n                                        newValue: args.newValue\r\n                                    });\r\n                                }\r\n                            });\r\n                        }\r\n                        else {\r\n                            _this.changed.publish(args.entity, {\r\n                                entity: args.entity,\r\n                                property: args.property,\r\n                                oldValue: args.oldValue,\r\n                                newValue: args.newValue\r\n                            });\r\n                        }\r\n                    };\r\n                    _this.stepChanged[index] = handler;\r\n                    property.changed.subscribe(handler);\r\n                });\r\n            }\r\n            else if (!event.hasSubscribers() && _this.stepChanged) {\r\n                _this.properties.forEach(function (property, index) { return property.changed.unsubscribe(_this.stepChanged[index]); });\r\n                _this.stepChanged = null;\r\n            }\r\n        });\r\n        // calculate the path\r\n        this.path = getPropertyChainPathFromIndex(this, 0);\r\n    }\r\n    PropertyChain.prototype.equals = function (prop) {\r\n        if (prop === null || prop === undefined) {\r\n            return;\r\n        }\r\n        if (prop instanceof property_1.Property) {\r\n            return this.properties.length === 1 && this.properties[0] === prop;\r\n        }\r\n        if (prop instanceof PropertyChain) {\r\n            if (prop.properties.length !== this.properties.length) {\r\n                return false;\r\n            }\r\n            for (var i = 0; i < this.properties.length; i++) {\r\n                if (!this.properties[i].equals(prop.properties[i])) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n    };\r\n    /**\r\n     * Iterates over all objects along a property chain starting with the root object (obj).\r\n     * This is analogous to the Array forEach function. The callback may return a Boolean\r\n     * value to indicate whether or not to continue iterating.\r\n     * @param obj The root object (of type `IEntity`) to use in iterating over the chain.\r\n     * @param callback The function to invoke at each iteration step.  May return a Boolean value to indicate whether or not to continue iterating.\r\n     * @param filter An optional property filter, if specified, only iterates over the results of this property.\r\n     */\r\n    PropertyChain.prototype.each = function (obj, callback, filter /*, target: IEntity, p: number, lastProp: IProperty */) {\r\n        if (filter === void 0) { filter = null; }\r\n        if (obj == null)\r\n            throw new Error(\"Argument 'obj' cannot be null or undefined.\");\r\n        if (callback == null)\r\n            throw new Error(\"Argument 'callback' cannot be null or undefined.\");\r\n        if (typeof (callback) !== \"function\")\r\n            throw new Error(\"Argument 'callback' must be of type function: \" + callback + \".\");\r\n        // invoke callback on obj first\r\n        var target = arguments[3] || obj;\r\n        var lastProp = arguments[5] || null;\r\n        for (var p = arguments[4] || 0; p < this.properties.length; p++) {\r\n            var prop = this.properties[p];\r\n            var isLastProperty = p === this.properties.length - 1;\r\n            var canSkipRemainingProps = isLastProperty || (filter && lastProp === filter);\r\n            var enableCallback = (!filter || lastProp === filter);\r\n            // if the target is a list, invoke the callback once per item in the list\r\n            if (target instanceof Array) {\r\n                for (var i = 0; i < target.length; ++i) {\r\n                    if (enableCallback && callback(target[i], prop) === false) {\r\n                        return false;\r\n                    }\r\n                    if (!canSkipRemainingProps) {\r\n                        var targetValue = prop.value(target[i]);\r\n                        // continue along the chain for this list item\r\n                        if (!targetValue || PropertyChain.prototype.each.call(this, obj, callback, filter, targetValue, p + 1, prop) === false) {\r\n                            return false;\r\n                        }\r\n                    }\r\n                }\r\n                // subsequent properties already visited in preceding loop\r\n                return true;\r\n            }\r\n            else {\r\n                // take into account any chain filters along the way\r\n                if (enableCallback && callback(target, prop) === false) {\r\n                    return false;\r\n                }\r\n            }\r\n            // if a property filter is used and was just evaluated, stop early\r\n            if (canSkipRemainingProps) {\r\n                break;\r\n            }\r\n            // move to next property in the chain\r\n            target = target.__fields__[prop.name];\r\n            // break early if the target is undefined\r\n            if (target === undefined || target === null) {\r\n                break;\r\n            }\r\n            lastProp = prop;\r\n        }\r\n        return true;\r\n    };\r\n    Object.defineProperty(PropertyChain.prototype, \"containingType\", {\r\n        get: function () {\r\n            return this.rootType;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"firstProperty\", {\r\n        get: function () {\r\n            return this.properties[0];\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"lastProperty\", {\r\n        get: function () {\r\n            return this.properties[this.properties.length - 1];\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    PropertyChain.prototype.toPropertyArray = function () {\r\n        return this.properties.slice();\r\n    };\r\n    PropertyChain.prototype.getLastTarget = function (obj) {\r\n        for (var p = 0; p < this.properties.length - 1; p++) {\r\n            var prop = this.properties[p];\r\n            // exit early on null or undefined\r\n            if (!obj === undefined || obj === null)\r\n                return obj;\r\n            obj = prop.value(obj);\r\n        }\r\n        return obj;\r\n    };\r\n    PropertyChain.prototype.canSetValue = function (obj, value) {\r\n        return this.lastProperty.canSetValue(this.getLastTarget(obj), value);\r\n    };\r\n    // Determines if this property chain connects two objects.\r\n    PropertyChain.prototype.testConnection = function (fromRoot, toObj, viaProperty) {\r\n        var connected = false;\r\n        // perform simple comparison if no property is defined\r\n        if (!viaProperty) {\r\n            return fromRoot === toObj;\r\n        }\r\n        this.each(fromRoot, function (target) {\r\n            if (target === toObj) {\r\n                connected = true;\r\n                return false;\r\n            }\r\n        }, viaProperty);\r\n        return connected;\r\n    };\r\n    Object.defineProperty(PropertyChain.prototype, \"propertyType\", {\r\n        get: function () {\r\n            return this.lastProperty.propertyType;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"format\", {\r\n        get: function () {\r\n            return this.lastProperty.format;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"isList\", {\r\n        get: function () {\r\n            return this.lastProperty.isList;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"isCalculated\", {\r\n        get: function () {\r\n            return this.lastProperty.isCalculated;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"label\", {\r\n        get: function () {\r\n            return this.lastProperty.label;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"labelSource\", {\r\n        get: function () {\r\n            return this.lastProperty.labelSource;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"labelIsFormat\", {\r\n        get: function () {\r\n            return format_1.Format.hasTokens(this.label);\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"helptext\", {\r\n        get: function () {\r\n            return this.lastProperty.helptext;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"helptextIsFormat\", {\r\n        get: function () {\r\n            return format_1.Format.hasTokens(this.helptext);\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(PropertyChain.prototype, \"name\", {\r\n        get: function () {\r\n            return this.lastProperty.name;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    PropertyChain.prototype.value = function (obj, val, additionalArgs) {\r\n        if (obj === void 0) { obj = null; }\r\n        if (val === void 0) { val = null; }\r\n        if (additionalArgs === void 0) { additionalArgs = null; }\r\n        var lastTarget = this.getLastTarget(obj);\r\n        var lastProp = this.lastProperty;\r\n        if (arguments.length > 1) {\r\n            lastProp.value(lastTarget, val, additionalArgs);\r\n        }\r\n        else if (lastTarget) {\r\n            return lastProp.value(lastTarget);\r\n        }\r\n    };\r\n    PropertyChain.prototype.toString = function () {\r\n        var path = this.properties.map(function (e) { return e.name; }).join(\".\");\r\n        return \"this<\" + this.rootType + \">.\" + path;\r\n    };\r\n    return PropertyChain;\r\n}());\r\nexports.PropertyChain = PropertyChain;\r\nfunction getPropertyChainPathFromIndex(chain, startIndex) {\r\n    var steps = [];\r\n    var props = chain.toPropertyArray();\r\n    var previousStepType;\r\n    props.slice(startIndex).forEach(function (p, i) {\r\n        if (i !== 0) {\r\n            if (p.containingType !== previousStepType && p.containingType.isSubclassOf(previousStepType)) {\r\n                steps[steps.length - 1] = steps[steps.length - 1] + \"<\" + p.containingType.fullName + \">\";\r\n            }\r\n        }\r\n        steps.push(p.name);\r\n        previousStepType = p.propertyType.meta;\r\n    });\r\n    return steps.join(\".\");\r\n}\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.Rule$ensureConditionType = exports.Rule = void 0;\r\nvar property_1 = require(\"./property\");\r\nvar type_1 = require(\"./type\");\r\nvar rule_invocation_type_1 = require(\"./rule-invocation-type\");\r\nvar condition_type_1 = require(\"./condition-type\");\r\nvar Rule$customRuleIndex = 0;\r\nvar Rule = /** @class */ (function () {\r\n    /**\r\n     * Creates a rule that executes a delegate when specified model events occur.\r\n     * @param rootType The model type the rule is for.\r\n     * @param options The options for the rule.\r\n     */\r\n    function Rule(rootType, name, options) {\r\n        this.invocationTypes = 0;\r\n        this.predicates = [];\r\n        this.returnValues = [];\r\n        // Track the root type\r\n        this.rootType = rootType;\r\n        this.name = name || (options ? options.name : null) || (rootType.fullName + \".Custom.\" + (++Rule$customRuleIndex));\r\n        // Configure the rule based on the specified options\r\n        if (options) {\r\n            if (options.onInit)\r\n                this.onInit();\r\n            if (options.onInitNew)\r\n                this.onInitNew();\r\n            if (options.onInitExisting)\r\n                this.onInitExisting();\r\n            if (options.onChangeOf)\r\n                this.onChangeOf(options.onChangeOf);\r\n            if (options.returns)\r\n                this.returns(options.returns);\r\n            if (options.execute instanceof Function)\r\n                this._execute = options.execute;\r\n        }\r\n    }\r\n    Object.defineProperty(Rule.prototype, \"model\", {\r\n        get: function () {\r\n            return this.rootType.model;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(Rule.prototype, \"eventScope\", {\r\n        get: function () {\r\n            return this.rootType.model.eventScope;\r\n        },\r\n        enumerable: false,\r\n        configurable: true\r\n    });\r\n    Rule.prototype.execute = function (entity) {\r\n        if (this._execute) {\r\n            this._execute.call(entity);\r\n        }\r\n        else {\r\n            // TODO: Warn about execute function not implemented?\r\n        }\r\n    };\r\n    // Indicates that the rule should run only for new instances when initialized\r\n    Rule.prototype.onInitNew = function () {\r\n        // ensure the rule has not already been registered\r\n        if (this._registered)\r\n            throw new Error(\"Rules cannot be configured once they have been registered: \" + this.name);\r\n        // configure the rule to run on init new\r\n        this.invocationTypes |= rule_invocation_type_1.RuleInvocationType.InitNew;\r\n        return this;\r\n    };\r\n    // indicates that the rule should run only for existing instances when initialized\r\n    Rule.prototype.onInitExisting = function () {\r\n        // ensure the rule has not already been registered\r\n        if (this._registered)\r\n            throw new Error(\"Rules cannot be configured once they have been registered: \" + this.name);\r\n        // configure the rule to run on init existingh\r\n        this.invocationTypes |= rule_invocation_type_1.RuleInvocationType.InitExisting;\r\n        return this;\r\n    };\r\n    // indicates that the rule should run for both new and existing instances when initialized\r\n    Rule.prototype.onInit = function () {\r\n        // ensure the rule has not already been registered\r\n        if (this._registered)\r\n            throw new Error(\"Rules cannot be configured once they have been registered: \" + this.name);\r\n        // configure the rule to run on both init new and init existing\r\n        this.invocationTypes |= rule_invocation_type_1.RuleInvocationType.InitNew | rule_invocation_type_1.RuleInvocationType.InitExisting;\r\n        return this;\r\n    };\r\n    Rule.prototype.onChangeOf = function (predicates) {\r\n        // ensure the rule has not already been registered\r\n        if (this._registered)\r\n            throw new Error(\"Rules cannot be configured once they have been registered: \" + this.name);\r\n        // allow change of predicates to be specified as a parameter array without []'s\r\n        if (!(predicates instanceof Array)) {\r\n            predicates = Array.prototype.slice.call(arguments);\r\n        }\r\n        // add to the set of existing change predicates\r\n        this.predicates = this.predicates.length > 0 ? this.predicates.concat(predicates) : predicates;\r\n        // also configure the rule to run on property change unless it has already been configured to run on property get\r\n        if ((this.invocationTypes & rule_invocation_type_1.RuleInvocationType.PropertyGet) === 0)\r\n            this.invocationTypes |= rule_invocation_type_1.RuleInvocationType.PropertyChanged;\r\n        return this;\r\n    };\r\n    Rule.prototype.returns = function (properties) {\r\n        // Ensure the rule has not already been registered\r\n        if (this._registered)\r\n            throw new Error(\"Rules cannot be configured once they have been registered: \" + this.name);\r\n        // Allow return properties to be specified as a parameter array without []'s\r\n        if (properties && properties.constructor === String)\r\n            properties = Array.prototype.slice.call(arguments);\r\n        if (!properties)\r\n            throw new Error(\"Rule must specify at least one property for returns.\");\r\n        // Add to the set of existing return value properties\r\n        this.returnValues = this.returnValues.length > 0 ? this.returnValues.concat(properties) : properties;\r\n        // Configure the rule to run on property get and not on property change\r\n        this.invocationTypes |= rule_invocation_type_1.RuleInvocationType.PropertyGet;\r\n        this.invocationTypes &= ~rule_invocation_type_1.RuleInvocationType.PropertyChanged;\r\n        return this;\r\n    };\r\n    // registers the rule based on the configured invocation types, predicates, and return values\r\n    Rule.prototype.register = function () {\r\n        var rule = this;\r\n        if (rule._registered) {\r\n            throw new Error(\"Rules cannot be registered more than once: \" + rule.name);\r\n        }\r\n        // Indicate that the rule should now be considered registered and cannot be reconfigured\r\n        Object.defineProperty(this, \"_registered\", { enumerable: false, value: true, writable: false });\r\n        // register for init new\r\n        if (rule.invocationTypes & rule_invocation_type_1.RuleInvocationType.InitNew) {\r\n            rule.rootType.initNew.subscribe(function (args) { executeRule(rule, args.entity); });\r\n        }\r\n        // register for init existing\r\n        if (rule.invocationTypes & rule_invocation_type_1.RuleInvocationType.InitExisting) {\r\n            rule.rootType.initExisting.subscribe(function (args) { executeRule(rule, args.entity); });\r\n        }\r\n        // register for property change\r\n        if (rule.invocationTypes & rule_invocation_type_1.RuleInvocationType.PropertyChanged) {\r\n            rule.predicates.forEach(function (predicate) {\r\n                predicate.changed.subscribe(function (args) {\r\n                    if (canExecuteRule(rule, args.entity) && !pendingInvocation(args.entity.meta, rule)) {\r\n                        pendingInvocation(args.entity.meta, rule, true);\r\n                        rule.eventScope.onExit(function (e) {\r\n                            pendingInvocation(args.entity.meta, rule, false);\r\n                            if (!e.abort)\r\n                                executeRule(rule, args.entity);\r\n                        });\r\n                    }\r\n                });\r\n            });\r\n        }\r\n        // register for property get\r\n        if (rule.invocationTypes & rule_invocation_type_1.RuleInvocationType.PropertyGet && rule.returnValues) {\r\n            // register for property get events for each return value to calculate the property when accessed\r\n            rule.returnValues.forEach(function (returnValue) {\r\n                returnValue.accessed.subscribe(function (args) {\r\n                    // run the rule to initialize the property if it is pending initialization\r\n                    if (canExecuteRule(rule, args.entity) && property_1.Property$pendingInit(args.entity, returnValue)) {\r\n                        property_1.Property$pendingInit(args.entity, returnValue, false);\r\n                        executeRule(rule, args.entity);\r\n                    }\r\n                });\r\n            });\r\n            // register for property change events for each predicate to invalidate the property value when inputs change\r\n            rule.predicates.forEach(function (predicate) {\r\n                predicate.changed.subscribe(function (args) {\r\n                    if (rule.returnValues.some(function (returnValue) { return returnValue.changed.hasSubscribers(); })) {\r\n                        // Immediately execute the rule if there are explicit event subscriptions for the property\r\n                        if (canExecuteRule(rule, args.entity) && !pendingInvocation(args.entity.meta, rule)) {\r\n                            pendingInvocation(args.entity.meta, rule, true);\r\n                            rule.eventScope.onExit(function (e) {\r\n                                pendingInvocation(args.entity.meta, rule, false);\r\n                                if (!e.abort)\r\n                                    executeRule(rule, args.entity);\r\n                            });\r\n                        }\r\n                    }\r\n                    else {\r\n                        // Otherwise, just mark the property as pending initialization and raise property change for UI subscribers\r\n                        rule.returnValues.forEach(function (returnValue) {\r\n                            property_1.Property$pendingInit(args.entity, returnValue, true);\r\n                        });\r\n                        // Defer change notification until the scope of work has completed\r\n                        rule.eventScope.onExit(function (e) {\r\n                            if (!e.abort) {\r\n                                rule.returnValues.forEach(function (returnValue) {\r\n                                    args.entity.changed.publish(args.entity, { entity: args.entity, property: returnValue, newValue: returnValue.value(args.entity) });\r\n                                });\r\n                            }\r\n                        });\r\n                    }\r\n                });\r\n            });\r\n        }\r\n    };\r\n    return Rule;\r\n}());\r\nexports.Rule = Rule;\r\nfunction pendingInvocation(target, rule, value) {\r\n    if (value === void 0) { value = null; }\r\n    var pendingInvocation;\r\n    if (Object.prototype.hasOwnProperty.call(target, \"__pendingInvocation__\")) {\r\n        pendingInvocation = target.__pendingInvocation__;\r\n    }\r\n    else {\r\n        Object.defineProperty(target, \"__pendingInvocation__\", { enumerable: false, value: (pendingInvocation = []), writable: true });\r\n    }\r\n    var indexOfRule = pendingInvocation.indexOf(rule);\r\n    if (arguments.length > 2) {\r\n        if (value && indexOfRule < 0) {\r\n            pendingInvocation.push(rule);\r\n        }\r\n        else if (!value && indexOfRule >= 0) {\r\n            pendingInvocation.splice(indexOfRule, 1);\r\n        }\r\n    }\r\n    else {\r\n        return indexOfRule >= 0;\r\n    }\r\n}\r\nfunction canExecuteRule(rule, obj) {\r\n    // ensure the rule target is a valid rule root type\r\n    return obj instanceof rule.rootType.jstype;\r\n}\r\nfunction executeRule(rule, obj) {\r\n    // Ensure that the rule can be executed.\r\n    if (!canExecuteRule(rule, obj)) {\r\n        // TODO: Warn that rule can't be executed?\r\n        return;\r\n    }\r\n    try {\r\n        rule.eventScope.perform(function () {\r\n            rule.execute(obj);\r\n        });\r\n    }\r\n    catch (e) {\r\n        console.warn(\"Error encountered while running rule \\\"\" + rule.name + \"\\\".\");\r\n        if (e)\r\n            console.warn(e);\r\n    }\r\n}\r\n;\r\nfunction Rule$ensureConditionType(ruleName, typeOrProp, category) {\r\n    var generatedCode = typeOrProp instanceof property_1.Property ? typeOrProp.containingType.fullName + \".\" + typeOrProp.name + \".\" + ruleName :\r\n        typeOrProp instanceof type_1.Type ? typeOrProp + \".\" + ruleName :\r\n            ruleName;\r\n    var counter = \"\";\r\n    while (condition_type_1.ConditionType.get(generatedCode + counter))\r\n        counter = (typeof counter === \"string\" ? 0 : counter) + 1;\r\n    var DesiredConditionType;\r\n    if (category === \"Error\") {\r\n        DesiredConditionType = condition_type_1.ErrorConditionType;\r\n    }\r\n    else if (category === \"Warning\") {\r\n        DesiredConditionType = condition_type_1.WarningConditionType;\r\n    }\r\n    else {\r\n        throw new Error(\"Cannot create condition type for unsupported category '\" + category + \"'.\");\r\n    }\r\n    // return a new client condition type of the specified category\r\n    return new DesiredConditionType(generatedCode + counter, \"Generated condition type for \" + ruleName + \" rule.\");\r\n}\r\nexports.Rule$ensureConditionType = Rule$ensureConditionType;\r\n","\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.normalize = exports.ModelSettings = exports.createModel = exports.Model = void 0;\r\nvar events_1 = require(\"./events\");\r\nvar helpers_1 = require(\"./helpers\");\r\nvar type_1 = require(\"./type\");\r\nvar format_1 = require(\"./format\");\r\nvar entity_serializer_1 = require(\"./entity-serializer\");\r\nvar resource_1 = require(\"./resource\");\r\nvar globalization_1 = require(\"./globalization\");\r\nvar event_scope_1 = require(\"./event-scope\");\r\nvar valueTypes = { string: String, number: Number, date: Date, boolean: Boolean };\r\nvar Model = /** @class */ (function () {\r\n    function Model(options, config) {\r\n        this._readyProcessing = false;\r\n        this.serializer = new entity_serializer_1.EntitySerializer();\r\n        this.types = {};\r\n        this.settings = new ModelSettings(config);\r\n        this.entityRegistered = new events_1.Event();\r\n        this.afterPropertySet = new events_1.Event();\r\n        this.listChanged = new events_1.Event();\r\n        this.eventScope = event_scope_1.EventScope.create(this.settings.eventScopeSettings);\r\n        Object.defineProperty(this, \"_formats\", { enumerable: false, configurable: false, writable: true, value: {} });\r\n        if (options) {\r\n            this.extend(options);\r\n        }\r\n    }\r\n    /**\r\n     * Sets the default locale to use when a model's locale is not explicitly set\r\n     * @param locale The default locale\r\n     */\r\n    Model.setDefaultLocale = function (locale) {\r\n        resource_1.setDefaultLocale(locale);\r\n    };\r\n    /**\r\n     * Defines global resource messages for the given locale\r\n     * @param locale The locale to set messages for\r\n     * @param resources The resources messages\r\n     */\r\n    Model.defineResources = function (locale, resources) {\r\n        resource_1.defineResources(locale, resources);\r\n    };\r\n    Model.getResource = function (name, arg2, arg3) {\r\n        var locale;\r\n        var params;\r\n        if (arguments.length === 2) {\r\n            if (typeof arg2 === \"string\") {\r\n                locale = arg2;\r\n                params = null;\r\n            }\r\n            else if (typeof arg2 === \"object\") {\r\n                locale = null;\r\n                params = arg2;\r\n            }\r\n        }\r\n        else if (arguments.length >= 3) {\r\n            locale = arg2;\r\n            params = arg3;\r\n        }\r\n        var resource = resource_1.getResource(name, locale);\r\n        if (params)\r\n            return helpers_1.replaceTokens(resource, params);\r\n        return resource;\r\n    };\r\n    /**\r\n     * Gets the resource with the specified name\r\n     * @param name The resource name/key\r\n     * @param params The parameters to use for string format substitution\r\n     */\r\n    Model.prototype.getResource = function (name, params) {\r\n        if (params === void 0) { params = null; }\r\n        var resource = resource_1.getResource(name, this.$resources, this.$locale);\r\n        if (params)\r\n            return helpers_1.replaceTokens(resource, params);\r\n        return resource;\r\n    };\r\n    Model.prototype.resourceExists = function (name) {\r\n        return resource_1.resourceExists(name, this.$resources, this.$locale);\r\n    };\r\n    /**\r\n     * Formats a date as text using the given format string\r\n     * @param date The date to format\r\n     * @param format The format specifier\r\n     */\r\n    Model.prototype.formatDate = function (date, format) {\r\n        return globalization_1.formatDate(date, format, this.$culture);\r\n    };\r\n    /**\r\n     * Parses a date from text\r\n     * @param text The text to parse\r\n     */\r\n    Model.prototype.parseDate = function (text, formats) {\r\n        return globalization_1.parseDate(text, this.$culture, formats);\r\n    };\r\n    /**\r\n     * Expands a date/time format string, which may be a predefined short format, into the equivalent full format strin\r\n     * @param format The format string\r\n     */\r\n    Model.prototype.expandDateFormat = function (format) {\r\n        return globalization_1.expandDateFormat(this.$culture.dateTimeFormat, format);\r\n    };\r\n    /**\r\n     * Formats a number as text using the given format string\r\n     * @param number The number to format\r\n     * @param format The format specifier\r\n     */\r\n    Model.prototype.formatNumber = function (number, format) {\r\n        return globalization_1.formatNumber(number, format, this.$culture);\r\n    };\r\n    /**\r\n     * Parses a number from text\r\n     * @param text The text to parse\r\n     */\r\n    Model.prototype.parseNumber = function (text, format) {\r\n        return globalization_1.parseNumber(text, globalization_1.getNumberStyle(format), this.$culture);\r\n    };\r\n    /**\r\n     * Extends the model with the specified type information.\r\n     * @param options The set of model types to add and/or extend.\r\n     */\r\n    Model.prototype.extend = function (options) {\r\n        var _this = this;\r\n        // Use prepare() to defer property path resolution while the model is being extended\r\n        this.prepare(function () {\r\n            // Namespace\r\n            if (options.$namespace) {\r\n                // TODO: Guard against namespace being set after types have been created\r\n                var $namespace = options.$namespace;\r\n                if (!_this.$namespace) {\r\n                    Object.defineProperty(_this, \"$namespace\", { configurable: false, enumerable: true, value: $namespace, writable: false });\r\n                }\r\n                else if ($namespace !== _this.$namespace) {\r\n                    throw new Error(\"Cannot redefine namespace for model.\");\r\n                }\r\n            }\r\n            // Locale\r\n            if (options.$locale && typeof options.$locale === \"string\") {\r\n                // TODO: Guard against locale being set after types have been created\r\n                var $locale = options.$locale;\r\n                if (!_this.$locale) {\r\n                    Object.defineProperty(_this, \"$locale\", { configurable: false, enumerable: true, value: $locale, writable: false });\r\n                }\r\n                else if ($locale !== _this.$locale) {\r\n                    throw new Error(\"Cannot redefine locale for model.\");\r\n                }\r\n            }\r\n            // Resources\r\n            if (options.$resources && typeof options.$resources === \"object\") {\r\n                // TODO: Guard against resources being set after types have been created\r\n                var $resources = options.$resources;\r\n                if (!_this.$resources) {\r\n                    Object.defineProperty(_this, \"$resources\", { configurable: false, enumerable: true, value: $resources, writable: false });\r\n                }\r\n                else if ($resources !== _this.$resources) {\r\n                    throw new Error(\"Cannot redefine resources for model.\");\r\n                }\r\n            }\r\n            // Culture\r\n            if (options.$culture) {\r\n                var $culture = void 0;\r\n                // TODO: Guard against culture being set after types have been created\r\n                if (typeof options.$culture === \"object\") {\r\n                    $culture = options.$culture;\r\n                }\r\n                else if (typeof options.$culture === \"string\") {\r\n                    globalization_1.CultureInfo.setup();\r\n                    if (globalization_1.CultureInfo.CurrentCulture.name === options.$culture) {\r\n                        $culture = globalization_1.CultureInfo.CurrentCulture;\r\n                    }\r\n                    if (!$culture) {\r\n                        throw new Error(\"Could not find culture '\" + options.$culture + \"'.\");\r\n                    }\r\n                }\r\n                if ($culture) {\r\n                    if (!_this.$culture) {\r\n                        Object.defineProperty(_this, \"$culture\", { configurable: false, enumerable: true, value: $culture, writable: false });\r\n                    }\r\n                    else if ($culture !== _this.$culture) {\r\n                        throw new Error(\"Cannot redefine culture for model.\");\r\n                    }\r\n                }\r\n            }\r\n            var typesToCreate = Object.keys(options).filter(function (typeName) { return !typeName.startsWith(\"$\"); });\r\n            var typesToInitialize = [];\r\n            // Create New Types\r\n            while (typesToCreate.length > 0) {\r\n                var typeName = typesToCreate.splice(0, 1)[0];\r\n                for (var typeNameIdx = -1, pos = typeName.length - 1, i = typeName.lastIndexOf(\".\", pos); i > 0; pos = i - 1, i = typeName.lastIndexOf(\".\", pos)) {\r\n                    var typeNamespace = typeName.substring(0, i);\r\n                    var typeNamespaceIdx = typesToCreate.indexOf(typeNamespace);\r\n                    if (typeNamespaceIdx > typeNameIdx) {\r\n                        if (process.env.NODE_ENV === \"development\") {\r\n                            console.warn(\"Type '\" + typeNamespace + \"' should be created before type '\" + typeName + \"'.\");\r\n                        }\r\n                        // Remove the current  type's \"namespace\" type and re-add the current type to the list\r\n                        typesToCreate.splice(typeNamespaceIdx, 1);\r\n                        typesToCreate.splice(0, 0, typeName);\r\n                        typeNameIdx++;\r\n                        // Resume the loop using the new namespace type (resetting index variables isn't necessary)\r\n                        typeName = typeNamespace;\r\n                    }\r\n                }\r\n                var typeOptions = options[typeName];\r\n                var type = _this.types[typeName];\r\n                typesToInitialize.push(typeName);\r\n                if (!type) {\r\n                    var baseType = null;\r\n                    if (typeOptions.$extends) {\r\n                        baseType = _this.types[typeOptions.$extends];\r\n                        if (!baseType) {\r\n                            throw new Error(\"Base type '\" + typeOptions.$extends + \"' for type '\" + typeName + \"' wasn't found.\");\r\n                        }\r\n                    }\r\n                    var format = typeOptions.$format;\r\n                    type = new type_1.Type(_this, typeName, baseType, format);\r\n                    _this.types[typeName] = type;\r\n                }\r\n            }\r\n            // Extend Types\r\n            for (var _i = 0, typesToInitialize_1 = typesToInitialize; _i < typesToInitialize_1.length; _i++) {\r\n                var typeName = typesToInitialize_1[_i];\r\n                var typeOptions = options[typeName];\r\n                _this.types[typeName].extend(typeOptions);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Prepares the model by invoking and extension function, which tracking the model\r\n     * ready state to allow use of the @ready promise to defer property path resolution.\r\n     * @param extend The function extending the model\r\n     */\r\n    Model.prototype.prepare = function (extend) {\r\n        // Create a model initialization scope\r\n        if (!this._readyCallbacks) {\r\n            this._readyProcessing = false;\r\n            // Create an array to track model initialization callbacks\r\n            Object.defineProperty(this, \"_readyCallbacks\", { enumerable: false, configurable: true, writable: true, value: [] });\r\n            // Extend the model\r\n            extend();\r\n            // Complete pending model initialization steps\r\n            this._readyProcessing = true;\r\n            for (var _i = 0, _a = this._readyCallbacks; _i < _a.length; _i++) {\r\n                var init = _a[_i];\r\n                init();\r\n            }\r\n            this._readyProcessing = false;\r\n            delete this._readyCallbacks;\r\n        }\r\n        // Leverage the current model initialization scope\r\n        else\r\n            extend();\r\n    };\r\n    /**\r\n     * Execute a function when the model is ready.\r\n     * @param init The function to invoke when the model is ready.\r\n     * @param enqueueWhileProcessing Determines whether the callback should be added to the queue while the queue is being processed.\r\n     */\r\n    Model.prototype.ready = function (callback, _a) {\r\n        var _b = (_a === void 0 ? {} : _a).enqueueWhileProcessing, enqueueWhileProcessing = _b === void 0 ? true : _b;\r\n        if (this._readyCallbacks && (!this._readyProcessing || enqueueWhileProcessing))\r\n            this._readyCallbacks.push(callback);\r\n        else\r\n            callback();\r\n    };\r\n    /**\r\n     * Gets the format for the specified property type and format string.\r\n     * @param type The type the format is for\r\n     * @param format The format template or specifier\r\n     */\r\n    Model.prototype.getFormat = function (type, format, formatEval) {\r\n        // Return null if a format specifier was not provided\r\n        if (!format) {\r\n            return null;\r\n        }\r\n        // Get the format cache for the type\r\n        var formats;\r\n        if (type_1.isEntityType(type)) {\r\n            formats = type.meta._formats;\r\n        }\r\n        else {\r\n            formats = this._formats[type.name];\r\n            if (!formats)\r\n                formats = this._formats[type.name] = {};\r\n        }\r\n        // First see if the requested format is cached\r\n        var f = formats[format];\r\n        if (f) {\r\n            return f;\r\n        }\r\n        // Otherwise, create and cache the format\r\n        if (type_1.isEntityType(type)) {\r\n            return (formats[format] = format_1.Format.fromTemplate(type.meta, format, formatEval));\r\n        }\r\n        else {\r\n            // otherwise, call the format provider to create a new format\r\n            return (formats[format] = format_1.createFormat(this, type, format));\r\n        }\r\n    };\r\n    /**\r\n     * Gets the javascript property type with the specified name.\r\n     * @param type\r\n     */\r\n    Model.prototype.getJsType = function (type) {\r\n        var jstype = type.toLowerCase() === \"object\" ? Object : valueTypes[type.toLowerCase()];\r\n        if (!jstype) {\r\n            var modelType = this.types[type];\r\n            return modelType ? modelType.jstype : null;\r\n        }\r\n        return jstype;\r\n    };\r\n    return Model;\r\n}());\r\nexports.Model = Model;\r\n// eslint-disable-next-line no-redeclare\r\nfunction createModel(options, config) {\r\n    return new Promise(function (resolve) {\r\n        var model = new Model(options, config);\r\n        model.ready(function () {\r\n            resolve(model);\r\n        });\r\n    });\r\n}\r\nexports.createModel = createModel;\r\nvar ModelSettings = /** @class */ (function () {\r\n    function ModelSettings(config) {\r\n        // There is a slight speed cost to creating own properties,\r\n        // which may be noticeable with very large object counts.\r\n        this.createOwnProperties = false;\r\n        this.autogeneratePropertyLabels = true;\r\n        // Don't pollute the window object by default\r\n        this.useGlobalObject = false;\r\n        // Use sane defaults for event scope settings, i.e. \"non-exiting\" scope detection\r\n        this.eventScopeSettings = event_scope_1.EVENT_SCOPE_DEFAULT_SETTINGS;\r\n        this.createOwnProperties = config && !!config.createOwnProperties;\r\n        if (config && config.autogeneratePropertyLabels === false)\r\n            this.autogeneratePropertyLabels = false;\r\n        this.useGlobalObject = config && !!config.useGlobalObject;\r\n        this.eventScopeSettings = {\r\n            maxExitingTransferCount: (config && typeof config.maxExitingEventScopeTransferCount === \"number\" ? config.maxExitingEventScopeTransferCount : null) || event_scope_1.EVENT_SCOPE_DEFAULT_SETTINGS.maxExitingTransferCount,\r\n            maxDepth: (config && typeof config.maxEventScopeDepth === \"number\" ? config.maxEventScopeDepth : null) || event_scope_1.EVENT_SCOPE_DEFAULT_SETTINGS.maxDepth\r\n        };\r\n    }\r\n    return ModelSettings;\r\n}());\r\nexports.ModelSettings = ModelSettings;\r\n// eslint-disable-next-line no-redeclare\r\nfunction normalize(val, format) {\r\n    if (!val && val !== false)\r\n        return val;\r\n    if (val.constructor.name === \"Date\") {\r\n        var dateFormat = typeof format === \"string\" ? format : format.specifier;\r\n        if (dateFormat === \"t\") {\r\n            // Set the date of the dateTime to January 1st, 1970\r\n            var newDate = new Date(val.valueOf());\r\n            newDate.setFullYear(1970);\r\n            newDate.setMonth(0);\r\n            newDate.setDate(1);\r\n            return newDate;\r\n        }\r\n        else if (dateFormat === \"d\") {\r\n            // Set the time of the dateTime to 12AM\r\n            return new Date(val.getFullYear(), val.getMonth(), val.getDate());\r\n        }\r\n    }\r\n    return val;\r\n}\r\nexports.normalize = normalize;\r\n"],"sourceRoot":""}