{"version":3,"sources":["jsdelivr-header.js","/npm/projects/fs-is/src/lib/ValidationConstraintEnum.ts","/npm/projects/fs-is/src/lib/types.ts","/npm/projects/fs-is/src/lib/IsArray.ts","/npm/projects/fs-is/src/lib/IsArrayContainerOf.ts","/npm/projects/fs-is/src/lib/IsArrayEmpty.ts","/npm/node_modules/tslib/tslib.es6.js","/npm/projects/fs-is/src/lib/IsError.ts","/npm/projects/fs-is/src/lib/IsBoolean.ts","/npm/projects/fs-is/src/lib/IsDefined.ts","/npm/projects/fs-is/src/lib/IsNumber.ts","/npm/projects/fs-is/src/lib/IsGreaterThan.ts","/npm/projects/fs-is/src/lib/IsGreaterThanOrEqualTo.ts","/npm/projects/fs-is/src/lib/IsObject.ts","/npm/projects/fs-is/src/lib/IsIn.ts","/npm/projects/fs-is/src/lib/IsString.ts","/npm/projects/fs-is/src/lib/IsLengthInRange.ts","/npm/projects/fs-is/src/lib/IsMatch.ts","/npm/projects/fs-is/src/lib/IsMobilePhone.ts","/npm/projects/fs-is/src/lib/IsPositive.ts","/npm/projects/fs-is/src/lib/IsNotNegative.ts","/npm/projects/fs-is/src/lib/IsNumberInRange.ts","/npm/projects/fs-is/src/lib/IsAfterInstant.ts","/npm/projects/fs-is/src/lib/IsAlpha.ts","/npm/projects/fs-is/src/lib/IsAlphaNumeric.ts","/npm/projects/fs-is/src/lib/IsArrayNotContainerOf.ts","/npm/projects/fs-is/src/lib/IsArrayNotEmpty.ts","/npm/projects/fs-is/src/lib/IsArraySizeGreaterThan.ts","/npm/projects/fs-is/src/lib/IsArraySizeLessThan.ts","/npm/projects/fs-is/src/lib/IsArrayUnique.ts","/npm/projects/fs-is/src/lib/IsAscii.ts","/npm/projects/fs-is/src/lib/IsBase64.ts","/npm/projects/fs-is/src/lib/IsBeforeInstant.ts","/npm/projects/fs-is/src/lib/IsBooleanString.ts","/npm/projects/fs-is/src/lib/IsByteLength.ts","/npm/projects/fs-is/src/lib/IsCreditCard.ts","/npm/projects/fs-is/src/lib/IsCurrency.ts","/npm/projects/fs-is/src/lib/IsDate.ts","/npm/projects/fs-is/src/lib/IsDivisibleBy.ts","/npm/projects/fs-is/src/lib/IsEmail.ts","/npm/projects/fs-is/src/lib/IsEmpty.ts","/npm/projects/fs-is/src/lib/IsEnum.ts","/npm/projects/fs-is/src/lib/IsEqualTo.ts","/npm/projects/fs-is/src/lib/IsFQDN.ts","/npm/projects/fs-is/src/lib/IsFullWidth.ts","/npm/projects/fs-is/src/lib/IsHalfWidth.ts","/npm/projects/fs-is/src/lib/IsHexColor.ts","/npm/projects/fs-is/src/lib/IsHexaDecimal.ts","/npm/projects/fs-is/src/lib/IsIP.ts","/npm/projects/fs-is/src/lib/IsISBN.ts","/npm/projects/fs-is/src/lib/IsISIN.ts","/npm/projects/fs-is/src/lib/IsISO8601.ts","/npm/projects/fs-is/src/lib/IsISODateString.ts","/npm/projects/fs-is/src/lib/IsInstanceOf.ts","/npm/projects/fs-is/src/lib/IsInt.ts","/npm/projects/fs-is/src/lib/IsJSON.ts","/npm/projects/fs-is/src/lib/IsLengthGreaterThan.ts","/npm/projects/fs-is/src/lib/IsLengthLessThan.ts","/npm/projects/fs-is/src/lib/IsLessThan.ts","/npm/projects/fs-is/src/lib/IsLowercase.ts","/npm/projects/fs-is/src/lib/IsMillitaryTime.ts","/npm/projects/fs-is/src/lib/IsMongoID.ts","/npm/projects/fs-is/src/lib/IsMultiByte.ts","/npm/projects/fs-is/src/lib/IsNegative.ts","/npm/projects/fs-is/src/lib/IsNotEmpty.ts","/npm/projects/fs-is/src/lib/IsNotEqualTo.ts","/npm/projects/fs-is/src/lib/IsNotIn.ts","/npm/projects/fs-is/src/lib/IsNotSubstring.ts","/npm/projects/fs-is/src/lib/IsNotSuperString.ts","/npm/projects/fs-is/src/lib/IsNumberString.ts","/npm/projects/fs-is/src/lib/IsSameInstant.ts","/npm/projects/fs-is/src/lib/IsSubString.ts","/npm/projects/fs-is/src/lib/IsSuperString.ts","/npm/projects/fs-is/src/lib/IsSurrogatePair.ts","/npm/projects/fs-is/src/lib/IsURL.ts","/npm/projects/fs-is/src/lib/IsUUID.ts","/npm/projects/fs-is/src/lib/IsUndefined.ts","/npm/projects/fs-is/src/lib/IsUppercase.ts","/npm/projects/fs-is/src/lib/IsVariableWidth.ts"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,uZCNA,IAAY,ECAA,E,SCKI,EAAQ,GACpB,OAAO,aAAiB,KAC5B,C,SCSgB,EAAmB,EAAc,GAC7C,OAAM,aAAiB,SAEf,GAAS,EAAO,OAAM,SAAA,GAAK,OAAsB,IAAtB,EAAM,QAAQ,EAAS,IAC9D,C,SCbgB,EAAa,GACzB,QAAK,EAAQ,IAEU,GAAhB,EAAM,MACjB,CJXY,6FAAwB,KAChC,yBACA,EAAA,qBACA,EAAA,uBACA,EAAA,qCACA,EAAA,gCACA,EAAA,gCACA,EAAA,qDCPQ,oCAAK,KACb,gBACA,EAAA;;;;;;;;;;;;;;;AIcJ,IAAI,EAAgB,SAAS,EAAG,GAI5B,OAHA,EAAgB,OAAO,gBAClB,CAAE,UAAW,cAAgB,OAAS,SAAU,EAAG,GAAK,EAAE,UAAY,CAAE,GACzE,SAAU,EAAG,GAAK,IAAK,IAAI,KAAK,EAAO,OAAO,UAAU,eAAe,KAAK,EAAG,KAAI,EAAE,GAAK,EAAE,GAAG,EAC5F,EAAc,EAAG,EAC5B,EAsF6B,OAAO,OAsGX,OAAO,O,kBCrM5B,SAAA,EACS,EACA,EACA,EACA,EACA,EACA,GANT,IAAA,EAOI,EAAA,KAAA,KAAM,IAAQ,K,OANT,EAAA,UACA,EAAA,QACA,EAAA,QACA,EAAA,aACA,EAAA,OACA,EAAA,OAEL,EAAK,KAAO,UACZ,OAAO,eAAe,EAAM,EAAQ,W,kBDElB,EAAG,GACzB,GAAiB,mBAAN,GAA0B,OAAN,EAC3B,MAAM,IAAI,UAAU,uBAAyB,OAAO,GAAK,iCAE7D,SAAS,IAAO,KAAK,YAAc,CAAE,CADrC,EAAc,EAAG,GAEjB,EAAE,UAAkB,OAAN,EAAa,OAAO,OAAO,IAAM,EAAG,UAAY,EAAE,UAAW,IAAI,EACnF,CClB6B,CAAA,EAAA,G,GAAA,O,SCFb,EAAU,GACtB,OAAO,aAAiB,SAA4B,kBAAV,CAC9C,C,SCJgB,EAAa,GACzB,OAAgB,MAAT,CACX,C,ICOa,EAA6C,CACrD,UAAU,EACV,eAAe,G,SAaJ,EAAS,EACrB,GACA,YADA,IAAA,MAAA,GACI,IAAW,KAAY,KAAY,MAC5B,EAAQ,cAGf,OAAO,MAAM,KACN,EAAQ,SAEZ,OAAO,SAAS,EACzB,C,SAYc,EAAc,EAAgB,EAAe,EAAe,GACxE,IAAM,EAAI,GAAoB,EAE9B,IAAK,EAAS,GAAS,CACrB,IAAM,EACA,aAAa,EAAK,gFAC4B,KAAK,UAAU,GAAE,IACrE,MAAM,IAAI,EAAQ,EAAS,EAAQ,EAAO,2BAAyB,UAAW,QAAM,OAAS,E,CAE/F,OAAO,CACX,C,SCrDgB,EAAc,EAAe,GACzC,MAAwB,iBAAV,GAAwC,iBAAX,GAAuB,EAAQ,CAC5E,C,SCFc,EAAuB,EAAe,GAClD,MAAwB,iBAAV,GAAwC,iBAAX,GAAuB,GAAS,CAC7E,C,SCHc,EAAS,GACvB,OAAI,EAAQ,OAGL,EAAU,IAA0B,iBAAV,EACnC,C,SCSgB,EAAK,EAAY,GAC7B,OAAI,EAAS,KAGR,EAAQ,IAIwD,GAA3D,KAAK,UAAU,GAAS,QAAQ,KAAK,UAAU,KAH/C,EAAQ,IAAW,EAAO,QAAQ,IAAU,EAKxD,C,SC1Bc,EAAS,GACrB,OAAO,aAAiB,QAA2B,iBAAV,CAC7C,C,SCEgB,EAAgB,EAAe,EAAa,GAC1D,MACmB,iBAAV,GAAsB,WAAS,EAAO,CAAE,IAAG,EAAE,IAAG,GAE3D,C,SCHgB,EACZ,EACA,EACA,GAEA,MACmB,iBAAV,GACP,UAAQ,EAAO,EAAS,EAE5B,C,ICAW,EAAuB,uB,SCbpB,EAAW,GACvB,cAAc,IAAU,QAAM,QAAU,EAAQ,CACpD,C,SCDgB,EAAc,GAC1B,MAAwB,iBAAV,GAAsB,GAAS,CACjD,C,SCGgB,EAAgB,EAAY,EAAa,GAGrD,OAFA,EAAc,EAAK,OACnB,EAAc,EAAK,OACX,GAAS,GAAO,GAAS,CACnC,C,8FCX6B,EAAc,GAC3C,OAAO,GAAU,EAAO,UAAY,EAAI,SAC1C,E,mBCAwB,GACpB,MAAwB,iBAAV,GAAsB,UAAW,EACnD,E,0BCF+B,GAC3B,MAAwB,iBAAV,GAAsB,iBAAkB,EAC1D,E,qFCCsC,EAAc,GAClD,OAAM,aAAiB,QAEf,EAAmB,EAAO,EACpC,E,2BCPgC,GAC9B,OAAQ,EAAa,EACvB,E,kCCDuC,EAAc,GACjD,QAAO,EAAQ,IAAS,EAAM,OAAS,CACzC,E,+BCFkC,EAAc,GAC9C,QAAO,EAAQ,IAAS,EAAM,OAAS,CACzC,E,yBCL4B,GAC1B,KAAM,aAAiB,OAAQ,OAAO,EAEtC,IAAM,EAAc,EAAM,QAAO,SAAC,EAAG,EAAG,GAAM,OAAA,EAAE,QAAQ,KAAO,CAAC,IAChE,OAAO,EAAM,SAAW,EAAY,MACtC,E,mBCHsB,GACpB,MAAwB,iBAAV,GAAsB,UAAW,EACnD,E,oBCFyB,GACvB,MAAwB,iBAAV,GAAsB,WAAY,EAClD,E,2BCJgC,EAAa,GACzC,OAAO,GAAS,EAAM,UAAY,EAAO,SAC3C,E,wCxBY6B,EAAY,EAAe,GACtD,IAAK,EAAU,GAGX,MAAM,IAAI,EADN,OAAO,EAAK,iBAAiB,EAAK,wBAGlC,EACA,EACA,2BAAyB,WACzB,QAAM,QACN,GAER,OAAO,CACX,E,2ByBxBgC,GAC5B,MAAwB,iBAAV,GAAsB,YAAU,EAChD,E,wBCD2B,EAAe,EAAa,GACvD,MAAwB,iBAAV,GAAsB,eAAgB,EAAO,CAAE,IAAG,EAAE,IAAG,GACvE,E,wBCJ6B,GAC3B,MAAwB,iBAAV,GAAsB,eAAgB,EACtD,E,sBCAI,EACA,GAEA,MAAwB,iBAAV,GAAsB,aAAc,EAAO,EAC7D,E,kBCVuB,GACnB,OAAO,aAAiB,OAAS,MAAM,EAAM,UACjD,E,uCCG8B,EAAgB,GAG5C,OAFE,EAAc,EAAQ,UACtB,EAAc,EAAK,OAEnB,gBAAiB,OAAO,GAAS,OAAO,GAE5C,E,mBCNwB,EAAe,GACnC,MAAwB,iBAAV,GAAsB,UAAW,EAAO,EAC1D,E,mBCPwB,GACpB,MAAiB,KAAV,SAAgB,CAC3B,E,kBCAuB,EAAY,GAC/B,OAAO,OAAO,OAAO,GAAQ,QAAQ,IAAU,CACnD,E,qBCH0B,EAAY,GAClC,OAAO,IAAU,CACrB,E,kBCEuB,EAAe,GAClC,MAAwB,iBAAV,GAAsB,SAAU,EAAO,EACzD,E,uBCH4B,GAC1B,MAAwB,iBAAV,GAAsB,cAAe,EACrD,E,gDjCGqC,EAAe,EAAgB,EAAe,GAC/E,IAAK,EAAc,EAAO,GAExB,MAAM,IAAI,EADc,cAAc,EAAK,kBAAkB,EAAK,sBAAsB,EAAM,IACnE,EAAO,EAAO,2BAAyB,gBAAiB,QAAM,OAAQ,EAErG,E,kECL4C,EAAe,EAAgB,EAAe,GAGxF,IAAK,EAAuB,EAAO,GAEjC,MAAM,IAAI,EADc,cAAc,EAAK,kBAAkB,EAAK,uCAAuC,EAAM,IACpF,EAAO,EAAO,2BAAyB,4BAA6B,QAAM,OAAQ,EAEjH,E,uBiCZ0B,GACxB,MAAwB,iBAAV,GAAsB,cAAe,EACrD,E,sBCFyB,GACzB,MAAwB,iBAAV,GAAsB,aAAc,EACpD,E,yBCF8B,GAC1B,MAAwB,iBAAV,GAAsB,gBAAiB,EACzD,E,gBCFqB,EAAe,GAClC,MAAwB,iBAAV,GAAsB,OAAQ,EAAO,EACrD,E,kBCFuB,EAAe,GAClC,MAAwB,iBAAV,GAAsB,SAAU,EAAO,EACzD,E,kBCFuB,GACnB,MAAwB,iBAAV,GAAsB,SAAU,EAClD,E,qBCF0B,GACxB,MAAwB,iBAAV,GAAsB,YAAa,EACnD,E,2BCGgC,GAE5B,OAAO,EAAS,IADF,wFACkB,KAAK,EACzC,E,iCCTI,EACA,GAEA,OACE,GACkB,mBAAX,GACP,aAAiB,CAErB,E,iBCXoB,GAClB,OAAO,OAAO,UAAU,EAC5B,E,kBCDuB,GACnB,MAAwB,iBAAV,GAAsB,SAAU,EAChD,E,+BCGkC,EAAe,GACjD,MAAwB,iBAAV,GAAsB,EAAgB,EAAO,EAC7D,E,gDCFiC,EAAe,GAC5C,MAAwB,iBAAV,GAAsB,EAAmB,EAAO,EAAG,EACrE,E,sBCP2B,EAAe,GACtC,MAAwB,iBAAV,GAAwC,iBAAX,GAAuB,EAAQ,CAC5E,E,uBCC0B,GACxB,MAAwB,iBAAV,GAAsB,cAAe,EACrD,E,sCCF6B,GAC3B,OAAO,EAAQ,EAAO,+BAC1B,E,yB1CC8B,EAAe,EAAgB,GACzD,MAA0B,iBAAV,GAAsB,gBAAiB,EAAO,EAAQ,EAC1E,E,qB2CL0B,GACtB,MAAwB,iBAAV,GAAsB,YAAa,EACnD,E,uBCF0B,GACxB,MAAwB,iBAAV,GAAsB,cAAe,EACrD,E,sBCJyB,GACvB,OAAQ,EAAW,EACvB,E,sBCJ2B,GACvB,MAAiB,KAAV,SAAgB,CAC3B,E,wBCD6B,EAAY,GACrC,OAAO,IAAU,CACnB,E,mBCEsB,EAAY,GAChC,OAAQ,EAAQ,KAAY,EAAK,EAAO,EAC1C,E,gD9CQiC,EAAY,EAAe,GAE1D,IAAK,EAAc,GAEf,MAAM,IAAI,EADc,aAAa,EAAK,0CAA0C,EAAK,KAGrF,EACA,EACA,2BAAyB,gBACzB,QAAM,OACN,EAEZ,E,0B+CtB+B,EAAe,GAC1C,MAAwB,iBAAV,IAAuB,WAAS,EAAQ,EAC1D,E,4BCFiC,EAAe,GAC5C,MAAwB,iBAAV,IAAuB,WAAS,EAAO,EACvD,E,mF/CSqC,EAAe,EAAa,EAAa,EAAe,GAE3F,IAAK,EAAgB,EAAO,EAAK,GAE/B,MAAM,IAAI,EADc,aAAa,EAAK,qBAAqB,EAAG,KAAK,EAAG,oBAAoB,EAAK,KACxE,EAAO,EAAO,2BAAyB,mBAAoB,QAAM,OAAQ,EAExG,E,0BgDhB6B,EAAe,GAC1C,YAD0C,IAAA,MAAA,IACjC,aAAL,GAAoC,cAAV,IACnB,EAAQ,cAGV,QAAL,IACO,EAAQ,SAEK,iBAAV,GAAsB,YAAU,EAAO,EACvD,E,uDlDA8B,EAAY,EAAe,GAEvD,IAAK,EAAW,GAEZ,MAAM,IAAI,EADc,aAAa,EAAK,sCAAsC,EAAK,KAGjF,EACA,EACA,2BAAyB,YACzB,QAAM,OACN,EAEZ,E,yBmDxB8B,EAAa,GACvC,OAAO,GAAS,EAAM,YAAc,EAAO,SAC7C,E,oCCA0B,EAAe,GACvC,MAAwB,iBAAV,GAAsB,WAAS,EAAQ,EACvD,E,yBCF4B,EAAe,GACzC,MAAwB,iBAAV,GAAsB,WAAS,EAAO,EACtD,E,2BCH8B,GAC5B,MAAwB,iBAAV,GAAsB,kBAAmB,EACzD,E,iBCDoB,EAAe,GACjC,MAAwB,iBAAV,GAAsB,QAAS,EAAO,EACxD,E,kBCFuB,EAAe,GAClC,MAAwB,iBAAV,GAAsB,SAAU,EAAO,aAAO,EAAP,EAAS,WAClE,E,uBCP+B,GAC3B,OAAQ,EAAU,EACtB,E,uBCE4B,GACxB,MAAwB,iBAAV,GAAsB,cAAe,EACrD,E,2BCF8B,GAC5B,MAAwB,iBAAV,GAAsB,kBAAmB,EAC3D,E","file":"/npm/@fireflysemantics/is@2.0.32/bundles/fireflysemantics-is.umd.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.19.2.\n * Original file: /npm/@fireflysemantics/is@2.0.32/bundles/fireflysemantics-is.umd.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","export enum ValidationConstraintEnum {\n    IS_POSITIVE = 'IsPositive',\n    IS_NUMBER = 'IsNumber',\n    IS_BOOLEAN =  'IsBoolean',\n    IS_NUMBER_IN_RANGE = 'IsNumberInRange',\n    IS_NOT_NEGATIVE = 'IsNotNegative',\n    IS_GREATER_THAN = 'IsGreaterThan',\n    IS_GREATER_THAN_OR_EQUAL_TO = 'IsGreaterThanOrEqualTo'\n}","export enum Types {\n    NUMBER =  'number',\n    BOOLEAN = 'boolean'\n}\n  ","/**\n * Checks if a argument is an array\n * @param value The value being checked.\n * @return True if the value is an instance of an array, false otherwise.\n */\nexport function isArray(value: any): boolean {\n    return value instanceof Array;\n}","/**\n * Checks if value array contains all values from the given target array.\n * If value is null, undefined, or not an array instance\n * then this function returns false.\n * \n * The values check should be primitive javascript types (String, number, boolean, null, undefined, etc.).\n * and not Object instances.\n * \n * Note that the check is value based.  For example the values \n * in the array [2,3,4,2] are contained by [2,3,4] even though the latter\n * is shorter. \n * \n * @param value The value container array being checked.\n * @param target The array of target values\n * @returns True if array contains all values from the given target array, false otherwise.\n */\nexport function isArrayContainerOf(value: any[], target: any[]) {\n    if (!(value instanceof Array)) return false;\n\n    return !value || target.every(v => value.indexOf(v) !== -1);\n}","import { isArray } from './IsArray'\n\n/**\n * Checks if an array contains any items.\n * @param value The array being checked\n * @return True if the array is empty and false otherwise.\n */\nexport function isArrayEmpty(value: any[]) {\n    if (!isArray(value)) return false;\n\n    return value.length == 0 ? true : false;\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __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\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","import { ValidationConstraintEnum } from \"./ValidationConstraintEnum\";\nimport { Types } from \"./types\";\n\n/**\n * @param message The error message\n * @param value The value that violates the constraint\n * @param field The name of the field that triggered the constraint violation\n * @param constraint The name of the constraint violated\n * @param type The expected type for the field\n * @param code The application or module code for the error\n */\nexport class IsError extends Error {\n    constructor(\n      public message:string,\n      public value: any, \n      public field?:string, \n      public constraint?: ValidationConstraintEnum,\n      public type?: Types,\n      public code?:string) {\n        super(message);\n        this.name = 'IsError';\n        Object.setPrototypeOf(this, IsError.prototype);      \n    }\n}\n  ","import { IsError } from './IsError'\nimport { Types } from './types'\nimport { ValidationConstraintEnum } from './ValidationConstraintEnum'\n\n/**\n * Checks if the argument is a real boolean.\n * @param value The value being checked.\n * @returns True if the argument is an instance of Boolean.\n */\nexport function isBoolean(value: any): boolean {\n    return value instanceof Boolean || typeof value === \"boolean\";\n}\n\n/**\n * Throws an `IsError` if the value does not pass the `isBoolean` check.\n * @param value The value being checked.\n * @param field The name of the field being checked.\n * @param code The application / module code assigned to this error.\n * @throws IsError if the value is not a Boolean instance.\n * @returns false if an {@link IsError} is not thrown\n */\nexport function isBooleanError(value: any, field: string, code?: string): boolean {\n    if (!isBoolean(value)) {\n        const message: string =\n            `The ${value} valued field ${field} should be a boolean.`\n        throw new IsError(\n            message, \n            value, \n            field, \n            ValidationConstraintEnum.IS_BOOLEAN, \n            Types.BOOLEAN, \n            code)\n    }\n    return false\n}","/**\n * @param value The value being checked.\n * @returns True if the value is strictly `undefined`.not null or undefined, false otherwise.\n *\n * See https://stackoverflow.com/questions/51003292/exporting-utility-functions-in-typescript/51004236#51004236\n * for an implementation reference.\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value != null; //This checks for undefined automatically.\n}\n","import { IsError } from './IsError'\nimport { Types } from './types'\nimport { ValidationConstraintEnum } from './ValidationConstraintEnum'\n\n//TODO - This should probably be moved to @fireflysemantics/validatorts\n/**\n * IsNumberOptions.\n */\nexport interface IsNumberOptions {\n    allowNaN?: boolean;\n    allowInfinity?: boolean;\n}\n\n/**\n * Default options for IsNumber\n */\nexport const IS_NUMBER_OPTIONS_DEFAULTS:IsNumberOptions = {\n     allowNaN: false, \n     allowInfinity: true \n}\n\n/**\n * Check if a given value is a number.\n * \n * Default `IsNumberOptions` allow \n * `-Infinity, Infinity` but disallow `NaN`.\n * \n * @param target The value being checked.\n * @param options The optional configuration {@link IsNumberOptions}.\n * @return True if the value is a number, false otherwise.\n */\nexport function isNumber(target: any,\n    options: IsNumberOptions = IS_NUMBER_OPTIONS_DEFAULTS): boolean {\n    if (target === Infinity || target === -Infinity) {\n      return !!options.allowInfinity;\n    }\n  \n    if (Number.isNaN(target)) {\n      return !!options.allowNaN;\n    }\n    return Number.isFinite(target);\n  }\n\n/**\n * Utility method for throwing an error if the {@link isNumber} test fails.\n * \n * @param target The target value being checked\n * @param field The name of the field containing the number\n * @param code Optional nervous system code\n * @param options Optional {@link IsNumberOptions} instance.\n * @throws IsError if the target is not a number\n * @returns false if an {@link IsError} is not thrown\n */\nexport function isNumberError(target: number, field: string, code?: string, options?:IsNumberOptions): boolean {\n    const o = options ? options : IS_NUMBER_OPTIONS_DEFAULTS\n  \n    if (!isNumber(target)) {\n      const message: string = \n            `The field ${field} is not a number.  \n             The options used to perform the check were ${JSON.stringify(o)}.`\n      throw new IsError(message, target, field, ValidationConstraintEnum.IS_NUMBER, Types.NUMBER,  code)\n    }\n    return false\n}","import { IsError } from \"./IsError\";\nimport { ValidationConstraintEnum } from \"./ValidationConstraintEnum\";\nimport { Types } from \"./types\";\n\n/**\n * Checks if value > target.\n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is greater than the target, false otherwise.\n */\nexport function isGreaterThan(value: number, target: number): boolean {\n    return typeof value === \"number\" && typeof target === \"number\" && value > target;\n  }\n  \n  export function isGreaterThanError(value: number, target: number, field: string, code?: string): void {  \n    if (!isGreaterThan(value, target)) {\n      const message: string = `The value (${value}) of the field ${field} should be greater ${target}.`;\n      throw new IsError(message, value, field, ValidationConstraintEnum.IS_GREATER_THAN, Types.NUMBER, code);\n    }\n  }\n  ","import { ValidationConstraintEnum } from \"./ValidationConstraintEnum\";\nimport { Types } from \"./types\";\nimport { IsError } from \"./IsError\";\n\n/**\n * Checks if value >= target.\n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is greater or equal to the target, false otherwise.\n */\nexport function isGreaterThanOrEqualTo(value: number, target: number): boolean {\n    return typeof value === \"number\" && typeof target === \"number\" && value >= target;\n  }\n  \n  export function isGreaterThanOrEqualToError(value: number, target: number, field: string, code?: string): void {\n    const CONSTRAINT = \"IsGreaterThanOrEqualTo\";\n  \n    if (!isGreaterThanOrEqualTo(value, target)) {\n      const message: string = `The value (${value}) of the field ${field} should be greater than or equal to ${target}.`;\n      throw new IsError(message, value, field, ValidationConstraintEnum.IS_GREATER_THAN_OR_EQUAL_TO, Types.NUMBER, code);\n    }\n  }\n  \n  ","import { isArray } from './IsArray'\nimport { isDefined } from './IsDefined'\n\n/**\n * Checks if the instance is defined, is not an array, and\n * an object (typeof value === 'object').  \n * @param value The value being checked.\n * @return True if the value is an instance of the enum, false otherwise.\n */\nexport function isObject(value: any): boolean {\n  if (isArray(value)) {\n    return false;\n  }\n  return isDefined(value) ? typeof value === 'object' : false;\n}\n\n\n","import { isObject } from \"./IsObject\";\nimport { isArray } from \"./IsArray\";\n\n/**\n * Checks if given value is in the target array of allowed values.\n * \n * The value being checked should not be an object (isObject(value) != true).  It must\n * be a primitive javascript type, like a string, number,\n * or boolean.\n * \n * If the target is not an array false is returned.\n * \n * Note that when the value is an array, JSON.stringify is used\n * to perform the check.  It has a few quirks that are discussed\n * here.  These could affect the output in certain edge cases:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify\n * \n * For example Infinity is considered null by JSON.stringify.\n * \n * @param value The value being checked.\n * @param target The target array to perform the check against.\n * @return True if the value is in the target array, false otherwise.\n */\nexport function isIn(value: any, target: any[]): boolean {\n    if (isObject(value)) {\n      return false;\n    }\n    if (!isArray(value)) {\n      return !isArray(target) || target.indexOf(value) > -1;\n    }\n    else {\n      return (JSON.stringify(target)).indexOf(JSON.stringify(value)) != -1;\n    }\n  }\n  ","\n/**\n * Checks if argument is a real string.\n * @param value The value being checked.\n * @return True if the value is a string, false otherwise.\n * \n */\nexport function isString(value: any): boolean {\n    return value instanceof String || typeof value === \"string\";\n}\n","import { isLength } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string's length falls in a range. Note: this function takes into account surrogate pairs.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param min The min value to perform the check against.\n * @param max The max value to perform the check against.\n * @return True if the check passes, false otherwise.\n */\nexport function isLengthInRange(value: string, min: number, max?: number): boolean {\n  return (\n    typeof value === \"string\" && isLength(value, { min, max })\n  );\n}\n","import { matches } from '@fireflysemantics/validatorts'\n\n/**\n * Checks if string matches the pattern. \n * Either matches('foo', /foo/i) or matches('foo', 'foo', 'i').\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param pattern The match pattern\n * @param modifiers The modifiers\n * @returns True if string matches the pattern, false otherwise.\n */\nexport function isMatch(\n    value: string,\n    pattern: RegExp,\n    modifiers?: string\n  ): boolean {\n    return (\n      typeof value === \"string\" &&\n      matches(value, pattern, modifiers)\n    );\n  }\n  ","import { isMobilePhoneLocales as vtsIsMobilePhoneLocales, IsMobilePhoneOptions as vtsIsMobilePhoneOptions, isMobilePhone as vtsIsMobilePhone } from \"@fireflysemantics/validatorts\"\nexport { MobilePhoneLocale } from \"@fireflysemantics/validatorts\"\n\n/**\n * Checks if the string is a mobile phone number (locale is one of ['zh-CN', 'zh-TW', 'en-ZA', 'en-AU', 'en-HK',\n * 'pt-PT', 'fr-FR', 'el-GR', 'en-GB', 'en-US', 'en-ZM', 'ru-RU', 'nb-NO', 'nn-NO', 'vi-VN', 'en-NZ']).\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param options The optional configuration {@link MobilePhoneLocale}.\n * @return True if the string is a mobile phone number, false otherwise.\n */\nexport function isMobilePhone(value: string, locale: string, options?: IsMobilePhoneOptions): boolean {\n    return ( typeof value === \"string\" && vtsIsMobilePhone(value, locale, options));\n}\n\n/**\n * Rexport the options\n */\nexport type IsMobilePhoneOptions = vtsIsMobilePhoneOptions\n\nexport const IsMobilePhoneLocales = vtsIsMobilePhoneLocales","import { IsError } from \"./IsError\";\nimport { ValidationConstraintEnum } from \"./ValidationConstraintEnum\";\nimport { Types } from \"./types\";\n\n/**\n * @param value The value being checked.\n * @return True if the value is a number and is positive, false otherwise.\n */\nexport function isPositive(value: number): boolean {\n    return typeof value === Types.NUMBER && value > 0;\n}\n\n/**\n * Throws an `IsError` if the value is not positive.\n * \n * @param value The value being checked.\n * @param field The name of the field being checked.\n * @param code The application / module code assigned to this error.\n * @throws {@link IsError} if the value is not a number instance.\n */\nexport function isPositiveError(value: any, field: string, code?: string): void {\n\n    if (!isPositive(value)) {\n        const message: string = `The field ${field} should be positive.  It is set to ${value}. `;\n        throw new IsError(\n            message, \n            value, \n            field, \n            ValidationConstraintEnum.IS_POSITIVE, \n            Types.NUMBER, \n            code);\n    }\n}\n","import { IsError } from \"./IsError\";\nimport { ValidationConstraintEnum } from \"./ValidationConstraintEnum\";\nimport { Types } from \"./types\";\n\n/**\n * Checks if the value is >= 0.\n * @param value The value being checked.\n * @return True if the value is a number not negative, false otherwise.\n */\nexport function isNotNegative(value: number): boolean {\n    return typeof value === \"number\" && value >= 0;\n}\n\n/**\n * Throws an `IsError` if the value is negative.\n * @param value The value being checked.\n * @param field The name of the field being checked.\n * @param code The application / module code assigned to this error.\n * @throws IsError if the value is not a Boolean instance.\n */\nexport function isNotNegativeError(value: any, field: string, code?: string): void {\n\n    if (!isNotNegative(value)) {\n        const message: string = `The field ${field} should not be negative.  It is set to ${value}. `;\n        throw new IsError(\n            message,\n            value,\n            field,\n            ValidationConstraintEnum.IS_NOT_NEGATIVE,\n            Types.NUMBER,\n            code);\n    }\n}","import { isNumberError } from \"./IsNumber\";\nimport { IsError } from \"./IsError\";\nimport { ValidationConstraintEnum } from \"./ValidationConstraintEnum\";\nimport { Types } from \"./types\";\n\n/**\n * Checks if the argument is in the range of the min max parameters.\n * @param value The value being checked.\n * @param min The min parameter\n * @param max The max parameter\n * @throws {@link IsError} if min is not a number\n * @throws {@link IsError} if max is not a number\n * @returns True if the argument is in range.\n */\nexport function isNumberInRange(value: any, min: number, max: number): boolean {\n    isNumberError(min, 'min')\n    isNumberError(max, 'max')\n    return (value >= min && value <= max);\n  }\n  \n  \n  export function isNumberInRangeError(value: number, min: number, max: number, field: string, code?: string): void {\n  \n    if (!isNumberInRange(value, min, max)) {\n      const message: string = `The field ${field} is not in range [${min}, ${max}].  It is set to ${value}. `;\n      throw new IsError(message, value, field, ValidationConstraintEnum.IS_NUMBER_IN_RANGE, Types.NUMBER, code);\n    }\n  }\n  ","/**\n * Checks if the value is a date that's after the specified date.\n * \n * @param target The value being checked.\n * @param arg The target value to perform the check against.\n * @return True if the value date is after the target, false otherwise.\n */\nexport function isAfterInstant(target: Date, arg: Date): boolean {\n  return target && target.getTime() > arg.getTime();\n}\n","import { isAlpha as vtsIsAlpha } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string contains only letters (a-zA-Z).\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @return True if the value contains only letters (a-zA-Z), false otherwise.\n */\nexport function isAlpha(value: string): boolean {\n    return typeof value === \"string\" && vtsIsAlpha(value);\n}\n  ","import { isAlphaNumeric as vtsIsAlphaNumeric} from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string contains only letters and numbers.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @return True if the value contains only letters and numbers, false otherwise.\n */\nexport function isAlphaNumeric(value: string): boolean {\n    return typeof value === \"string\" && vtsIsAlphaNumeric(value);\n}  ","import { isArrayContainerOf } from \"./IsArrayContainerOf\";\n\n\n/**\n * Checks if value array does not contain any of the given target values.\n * If null or undefined is given then this function returns false.\n * \n * @param value The value container array being checked.\n * @param target The array of target values\n * @returns True if value array does not contain any of the given target values, false otherwise.\n */\n\nexport function isArrayNotContainerOf(value: any[], target: any[]) {\n  if (!(value instanceof Array)) return false;\n\n  return !isArrayContainerOf(value, target);\n}\n","import { isArrayEmpty } from \"./IsArrayEmpty\";\n\n/**\n * Checks if given array is not empty.\n * If null or undefined is given then this function returns false.\n * \n * @param value The array being checked.\n * @returns True if given array is not empty, false otherwise.\n */\nexport function isArrayNotEmpty(value: any[]) {\n  return !isArrayEmpty(value);\n}\n","import { isArray } from \"./IsArray\";\n\n/**\n * Checks if array's length is greater than the target number.\n * If null or undefined is given then this function returns false.\n * \n * @param value The value array being checked.\n * @param target The minimum size of the array\n * @returns True if array's length is greater than the target number, false otherwise.\n */\nexport function isArraySizeGreaterThan(value: any[], target: number) {\n    return isArray(value) ? value.length > target : false;\n  }\n  ","import { isArray } from \"./IsArray\";\n\n/**\n * Checks if array's length is less than the target number.\n * If null or undefined is given then this function returns false.\n * \n * @param value The value array being checked.\n * @param target The maximum size of the array\n * @returns True if array's length is less than the target number, false otherwise.\n */\nexport function isArraySizeLessThan(value: any[], target: number) {\n    return isArray(value) ? value.length < target : false;\n  }\n  ","/**\n * Checks if all array's values are unique. Comparison for objects is reference-based.\n * If null or undefined is given then this function returns false.\n * \n * @param value The array being checked.\n * @returns True if all array's values are unique, false otherwise.\n */\nexport function isArrayUnique(array: any[]) {\n    if (!(array instanceof Array)) return false;\n  \n    const uniqueItems = array.filter((a, b, c) => c.indexOf(a) === b);\n    return array.length === uniqueItems.length;\n  }\n  ","import { isAscii as vtsIsAscii } from '@fireflysemantics/validatorts'\n/**\n * Checks if the string contains ASCII chars only.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value contains only letters and numbers, false otherwise.\n */\nexport function isAscii(value: string): boolean {\n    return typeof value === \"string\" && vtsIsAscii(value);\n}\n","import { isBase64 as vtsIsBase64 } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if a string is base64 encoded.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @return True a the value string is base64 encoded, false otherwise.\n */\nexport function isBase64(value: string): boolean {\n  return typeof value === \"string\" && vtsIsBase64(value);\n}","/**\n * Checks if the value is a date that's before the target date.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value date comes before the target date, false otherwise.\n */\nexport function isBeforeInstant(value: Date, target: Date): boolean {\n    return value && value.getTime() < target.getTime();\n  }\n  ","import { isBoolean } from '@fireflysemantics/validatorts'\n\n/**\n * Checks if a string is a boolean.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the type of the value is the same as string and `isBoolean` passes.\n */\nexport function isBooleanString(value: string): boolean {\n    return typeof value === \"string\" && isBoolean(value);\n  }\n  ","import { isByteLength as vtsIsByteLength } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string's length (in bytes) falls in a range.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param min The min value to perform the check against.\n * @param max The max value to perform the check against.\n * @return True if the check passes, false otherwise.\n */\nexport function isByteLength(value: string, min: number, max?: number): boolean {\n  return typeof value === \"string\" && vtsIsByteLength(value, { min, max });\n}\n","import { isCreditCard as vtsIsCreditCard } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is a credit card.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @return True if the string is a credit card, false otherwise.\n */\nexport function isCreditCard(value: string): boolean {\n  return typeof value === \"string\" && vtsIsCreditCard(value);\n}\n\n","import { IsCurrencyOptions as vtsIsCurrencyOptions, isCurrency as vtsIsCurrency } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is a valid currency amount.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param options The options configuration {@link IsCurrencyOptions}\n * @return True if the string is a valid currency amount, false otherwise.\n */\nexport function isCurrency(\n    value: string,\n    options?: vtsIsCurrencyOptions\n): boolean {\n    return typeof value === \"string\" && vtsIsCurrency(value, options);\n}\n\n/**\n * Rexport IsCurrencyOptions\n */\nexport type IsCurrencyOptions = vtsIsCurrencyOptions","/**\n * Checks if argument is date.\n * @param value The date being checked.\n * @return True if the date value is a real date, false otherwise.\n */\nexport function isDate(value: any): boolean {\n    return value instanceof Date && !isNaN(value.getTime());\n}\n\n","import { isDivisibleBy as vjsIsDivisibleBy } from '@fireflysemantics/validatorts'\nimport { isNumberError } from './IsNumber';\n/**\n * Checks if the value is the value that is divisible by the target\n * without producing a remainder.\n * \n * @param target The value being checked.\n * @param arg The target value to perform the check against.\n * @return True if the value is divisible by the target, false otherwise.\n */\nexport function isDivisibleBy(target: number, arg: number): boolean {\n    isNumberError(target, 'target')\n    isNumberError(arg, 'arg')\n  return (\n    vjsIsDivisibleBy(String(target), String(arg))\n  );\n}","import { IsEmailOptions as vtsIsEmailOptions, isEmail as vtsIsEmail } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is an email.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param options The options configuration {@link IsEmailOptions}\n * @return True if the string is an email, false otherwise.\n */\nexport function isEmail(value: string, options?: vtsIsEmailOptions): boolean {\n    return typeof value === \"string\" && vtsIsEmail(value, options);\n}\n\n/**\n * Reexport IsEmailOptions\n */\nexport type IsEmailOptions = vtsIsEmailOptions","/**\n * Checks if given value is empty (=== '', === null, === undefined).\n * @param value The value being checked.\n * @return True if the value is empty, false otherwise.\n */\nexport function isEmpty(value: any): boolean {\n    return value === \"\" || value === null || value === undefined;\n}\n","/**\n * Checks if a given value is an enum \n * (The value is contained in a property on the target object).\n * @param value The value being checked.\n * @param target The enum instance\n * @return True if the value is an instance of the enum, false otherwise.\n */\nexport function isEnum(value: any, target: any): boolean {\n    return Object.values(target).indexOf(value) >= 0;  \n}\n  ","/**\n * Checks if value using a (\"===\") the comparison.\n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value equals the target, false otherwise.\n */\nexport function isEqualTo(value: any, target: any): boolean {\n    return value === target;\n}\n","import { IsFQDNOptions as vtsIsFQDNOptions, isFQDN as vtsIsFQDN } from '@fireflysemantics/validatorts'\n\n/**\n * Checks if the string is a fully qualified domain name (e.g. domain.com).\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param options The options configuration {@link IsFQDNOptions}\n * @return True if the string is a fully qualified domain name, false otherwise.\n */\nexport function isFQDN(value: string, options?: vtsIsFQDNOptions): boolean {\n    return typeof value === \"string\" && vtsIsFQDN(value, options);\n}\n\n/**\n * Reexport the options\n */\nexport type IsFQDNOptions = vtsIsFQDNOptions","import { isFullWidth as vtsIsFullWidth } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string contains any full-width chars.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string contains full-width characters, false otherwise.\n */\nexport function isFullWidth(value: string): boolean {\n  return typeof value === \"string\" && vtsIsFullWidth(value);\n}","import { isHalfWidth as vtsIsHalfWidth } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string contains any half-width chars.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string contains any half-width chars, false otherwise.\n */\nexport function isHalfWidth(value: string): boolean {\n    return typeof value === \"string\" && vtsIsHalfWidth(value);\n  }\n  ","import { isHexColor as vtsIsHexColor } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is a hexadecimal color.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string is a hexadecimal color, false otherwise.\n */\nexport function isHexColor(value: string): boolean {\n  return typeof value === \"string\" && vtsIsHexColor(value)\n}\n\n","import { isHexadecimal as vtsIsHexadecimal } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is a hexadecimal number.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string is a hexadecimal number, false otherwise.\n */\nexport function isHexadecimal(value: string): boolean {\n    return typeof value === \"string\" && vtsIsHexadecimal(value)\n}\n  ","import { isIP as vtsIsIP } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is an IP (version 4 or 6).\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string is an IP (version 4 or 6), false otherwise.\n */\nexport function isIP(value: string, version?: \"4\" | \"6\" ): boolean {\n  return typeof value === \"string\" && vtsIsIP(value, version);\n}\n","import { isISBN as vtsIsISBN } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is an ISBN (version 10 or 13).\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string is an ISBN, false otherwise.\n */\nexport function isISBN(value: string, version?: \"10\" | \"13\"): boolean {\n    return typeof value === \"string\" && vtsIsISBN(value, version);\n}\n  ","import { isISIN as vtsIsISIN } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is an ISIN (stock/security identifier).\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string is an ISIN, false otherwise.\n */\nexport function isISIN(value: string): boolean {\n    return typeof value === \"string\" && vtsIsISIN(value);\n}","import { isISO8601 as vtsIsISO8601 } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is a valid ISO 8601 date.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string a valid ISO 8601, false otherwise.\n */\nexport function isISO8601(value: string): boolean {\n  return typeof value === \"string\" && vtsIsISO8601(value);\n}\n","import { isString } from \"./IsString\"\n\n/**\n * Checks if argument is a ISO 8601 Date String.\n * \n * Such a string is 24 ((YYYY-MM-DDTHH:mm:ss.sssZ) \n * or \n * 27 (±YYYYYY-MM-DDTHH:mm:ss.sssZ) \n * \n * characters long.\n * \n * @param value The value being checked.\n * @return True if the value is an instance of an ISOString date.\n */\nexport function isISODateString(value: any): boolean {\n    const regex = /\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|\\+[0-2]\\d(?:\\:[0-5]\\d)?)?/g;\n    return isString(value) && regex.test(value)\n}\n  ","/**\n * Checks if the value is an instance of the specified object.\n * \n * @param value The value array being checked.\n * @param target The target type constructor\n * @returns True if the value is an instance of the specified object, false otherwise.\n */\nexport function isInstanceOf(\n    value: any,\n    target: new (...args: any[]) => any\n  ) {\n    return (\n      target &&\n      typeof target === \"function\" &&\n      value instanceof target\n    );\n  }\n  ","/**\n * Checks if value is an integer.\n * @param value The value being checked.\n * @return True if the value is an integer, false otherwise.\n */\nexport function isInt(val: number): boolean {\n    return Number.isInteger(val);\n}\n","import { isJSON as vtsIsJSON} from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is valid JSON (note: uses JSON.parse).\n * If given value is not a string, then it returns false.\n */\nexport function isJSON(value: string): boolean {\n    return typeof value === \"string\" && vtsIsJSON(value);\n  }\n  ","import { isLengthInRange } from \"./IsLengthInRange\";\n\n/**\n * Checks if the string's length is not less than given target number. \n * Note: this function takes into account surrogate pairs.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The minimum target length\n * @returns True if the string's length is not less than given target number, false otherwise.\n */\nexport function isLengthGreaterThan(value: string, target: number) {\n  return typeof value === \"string\" && isLengthInRange(value, target);\n}","import { isLengthInRange as vtsIsLengthInRange } from \"./IsLengthInRange\";\n\n/**\n * Checks if the string's length is not more than target number. \n * Note: this function takes into account surrogate pairs.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The maximum target length\n * @returns True if the string's length is not less than given target number, false otherwise.\n */\nexport function isLengthLessThan(value: string, target: number) {\n    return typeof value === \"string\" && vtsIsLengthInRange(value, 0, target);\n}","/**\n * Checks if the first number is value < target.\n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is less than the target, false otherwise.\n */\nexport function isLessThan(value: number, target: number): boolean {\n    return typeof value === \"number\" && typeof target === \"number\" && value < target;\n  }\n  ","import { isLowercase as vtsIsLowerCase } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is lowercase.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string is lowercase, false otherwise.\n */\nexport function isLowercase(value: string): boolean {\n    return typeof value === \"string\" && vtsIsLowerCase(value);\n  }\n  ","import { isMatch } from \"./IsMatch\";\n\n/**\n * Checks if the string represents a time without a given timezone in the format HH:MM (military)\n * If the given value does not match the pattern HH:MM, then it returns false.\n * \n * @param value The value being checked.\n * @returns True if the string represents a time without a given timezone in the format HH:MM (military), false otherwise.\n */\nexport function isMilitaryTime(value: string): boolean {\n    return isMatch(value, /^([01]\\d|2[0-3]):?([0-5]\\d)$/);\n}\n","import { isMongoId as vtsIsMongoId} from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is a valid hex-encoded representation of a MongoDB ObjectId.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns True if the string is a valid hex-encoded representation of a MongoDB ObjectId, false otherwise.\n */\nexport function isMongoId(value: string): boolean {\n    return typeof value === \"string\" && vtsIsMongoId(value);\n  }\n  \n  ","import { isMultibyte as vtsIsMultibyte} from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string contains one or more multibyte chars.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns True if the string contains one or more multibyte chars, false otherwise.\n */\nexport function isMultibyte(value: string): boolean {\n    return typeof value === \"string\" && vtsIsMultibyte(value);\n  }\n  ","import { isPositive } from \"./IsPositive\";\n\n/**\n * Checks if the value is a negative number.\n * @param value The value being checked.\n * @return True if the value is < 0, false otherwise.\n */\nexport function isNegative(value: number): boolean {\n    return !isPositive(value);\n}\n","/**\n * Checks if given value is not empty (!== '', !== null, !== undefined).\n * @param value The value being checked.\n * @return True if the value is not empty, false otherwise.\n */\nexport function isNotEmpty(value: any): boolean {\n    return value !== \"\" && value !== null && value !== undefined;\n}\n","/**\n * Checks if value does not match (\"!==\") the comparison.\n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value does not equal the target, false otherwise.\n */\nexport function isNotEqualTo(value: any, target: any): boolean {\n    return value !== target;\n  }\n  ","import { isArray } from \"./IsArray\";\nimport { isIn } from \"./IsIn\";\n\n/**\n * Checks if given value is in the target array of allowed values.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is not in the target array, false otherwise.\n */\nexport function isNotIn(value: any, target: any[]): boolean {\n    return !isArray(target) || !isIn(value, target);\n  }\n  ","import { contains } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the value is not a substring of the target.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is a not a substring of the target, false otherwise.\n */\nexport function isNotSubString(value: string, target: string): boolean {\n    return typeof value === \"string\" && !contains(target, value);\n}","import { contains } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string value does not contain the target.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is a not super string of the target, false otherwise.\n */\nexport function isNotSuperString(value: string, target: string): boolean {\n    return typeof value === \"string\" && !contains(value, target);\n  }\n  ","import { isNumeric } from \"@fireflysemantics/validatorts\";\nimport { IsNumberOptions } from \"./IsNumber\";\n\n\n/**\n * Checks if the string is numeric.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @return True if the value is numeric, false otherwise.\n */\nexport function isNumberString(value: string, options: IsNumberOptions = {}): boolean {\n    if (value === ('Infinity') || value === '-Infinity') {\n      return !!options.allowInfinity;\n    }\n  \n    if (value === ('NaN')) {\n      return !!options.allowNaN;\n    }\n    return typeof value === \"string\" && isNumeric(value, options);\n  }\n  ","/**\n * Checks if the value is a date occurs at the exact same time\n * as the target date.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value date occurs at the exact same time as the target date, false otherwise.\n */\nexport function isSameInstant(value: Date, target: Date): boolean {\n    return value && value.getTime() === target.getTime();\n  }\n  ","import { contains } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the value is a substring of the seed.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is a substring of the target, false otherwise.\n */\nexport function isSubString(value: string, target: string): boolean {\n    return typeof value === \"string\" && contains(target, value);\n  }\n  ","import { contains } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string value contains the target.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param target The target value to perform the check against.\n * @return True if the value is a super string of the target, false otherwise.\n */\nexport function isSuperString(value: string, target: string): boolean {\n    return typeof value === \"string\" && contains(value, target);\n  }\n  \n  ","import { isSurrogatePair as vtsIsSurrogatePair } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string contains any surrogate pairs chars.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns True if the string contains any surrogate pairs chars, false otherwise.\n */\nexport function isSurrogatePair(value: string): boolean {\n    return typeof value === \"string\" && vtsIsSurrogatePair(value);\n  }\n  ","import { IsURLOptions as vtsIsURLOptions, isURL as vtsIsURL } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is an url.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param options The optional configuration options {@link ValidatorJS.IsURLOptions}\n * @returns True if the string is an url, false otherwise.\n */\nexport function isURL(value: string, options?: vtsIsURLOptions): boolean {\n    return typeof value === \"string\" && vtsIsURL(value, options);\n}\n\nexport type IsURLOptions = vtsIsURLOptions\n","import { isUUID as vtsIsUUID } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is a UUID (version 3, 4 or 5).\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @param version The UUID version (3, 4 or 5)\n * @returns True if the string is a UUID, false otherwise.\n */\nexport function isUUID(value: string, version?: 3 | 4 | 5): boolean {\n    return typeof value === \"string\" && vtsIsUUID(value, version?.toString());\n}\n  ","import { isDefined } from './IsDefined'\n/**\n * @param value The value being checked.\n * @returns True if the value is null or undefined, false otherwise.\n */\nexport function isUndefined<T>(value: T | null | undefined): value is T {\n    return !isDefined(value);\n}","import { isUppercase as vtsIsUppercase } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string is uppercase.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns True if the string is uppercase, false otherwise. \n */\nexport function isUppercase(value: string): boolean {\n    return typeof value === \"string\" && vtsIsUppercase(value);\n  }\n  ","import { isVariableWidth as vtsIsVariableWidth } from \"@fireflysemantics/validatorts\";\n\n/**\n * Checks if the string contains variable-width chars.\n * If given value is not a string, then it returns false.\n * \n * @param value The value being checked.\n * @returns  True if the string contains variable-width chars, false otherwise.\n */\nexport function isVariableWidth(value: string): boolean {\n    return typeof value === \"string\" && vtsIsVariableWidth(value);\n}\n  "]}