@terascope/data-mate 2.0.0-dev.6 → 2.0.0-dev.7

package/dist/src/validations/field-validator.js

@@ -1,7 +1,13 @@
-import * as ts from '@terascope/utils';
+import { isNil, isNotNil, isMACAddressFP, isArrayLike, inNumberRangeFP, isDeepEqual, includes, isBoolean as utilsIsBoolean, isBooleanLike as utilsIsBooleanLike, isEmail as utilsIsEmail, inNumberRange as utilsInNumberRange, isNumber as utilsIsNumber, isMACAddress as utilsIsMacAddress, isInteger as utilsIsInteger, isString as utilsIsString, isEmpty as utilsIsEmpty, isValidDate as utilsIsValidDate } from '@terascope/core-utils';
+import { parseGeoPoint, isGeoJSON as utilsIsGeoJSON, isGeoShapePoint as utilsIsGeoShapePoint, isGeoShapePolygon as utilsIsGeoShapePolygon, isGeoShapeMultiPolygon as utilsIsGeoShapeMultiPolygon, } from '@terascope/geo-utils';
+import { isIPv6, isNonZeroCidr, isIP as utilsIsIP } from '@terascope/ip-utils';
+// TODO: should this be comming from ip utils?
 import ipaddr from 'ipaddr.js';
+// TODO: should this be comming from ip utils?
 import ip6addr from 'ip6addr';
+// TODO: should this be comming from utils?
 import { parsePhoneNumber } from 'awesome-phonenumber';
+// TODO: should this be comming from utils?
 import validator from 'validator';
 import url from 'valid-url';
 import { FieldType } from '@terascope/types';
@@ -159,7 +165,7 @@ export const repository = {
     },
 };
 function _lift(fn, input, parentContext, args) {
-    const sanitized = input.filter(ts.isNotNil);
+    const sanitized = input.filter(isNotNil);
     if (sanitized.length === 0)
         return false;
     return sanitized.every((data) => fn(data, parentContext, args));
@@ -182,11 +188,11 @@ function handleArgs(fn) {
  * @returns {boolean} boolean
  */
 export function isBoolean(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isBoolean), input, _parentContext);
-    return ts.isBoolean(input);
+        return _lift(handleArgs(utilsIsBoolean), input, _parentContext);
+    return utilsIsBoolean(input);
 }
 /**
  * Checks to see if input is a boolean-like value. If an given an array, it will check
@@ -206,8 +212,8 @@ export function isBoolean(input, _parentContext) {
  */
 export function isBooleanLike(input, _parentContext) {
     if (isArray(input))
-        return input.every(ts.isBooleanLike);
-    return ts.isBooleanLike(input);
+        return input.every(utilsIsBooleanLike);
+    return utilsIsBooleanLike(input);
 }
 /**
  * Return true if value is a valid email, or a list of valid emails
@@ -223,11 +229,11 @@ export function isBooleanLike(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isEmail(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isEmail), input, _parentContext);
-    return ts.isEmail(input);
+        return _lift(handleArgs(utilsIsEmail), input, _parentContext);
+    return utilsIsEmail(input);
 }
 /**
  * Checks to see if input is a valid geo-point, or a list of valid geo-points
@@ -245,13 +251,13 @@ export function isEmail(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isGeoPoint(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input) && !isNumberTuple(input)) {
-        return _lift(handleArgs(ts.parseGeoPoint), input, _parentContext, false);
+        return _lift(handleArgs(parseGeoPoint), input, _parentContext, false);
     }
     // TODO: check for tuple vs an array of numbers
-    const results = ts.parseGeoPoint(input, false);
+    const results = parseGeoPoint(input, false);
     return results != null;
 }
 /**
@@ -273,18 +279,18 @@ export function isGeoPoint(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isGeoJSON(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isGeoJSON), input, _parentContext);
-    return ts.isGeoJSON(input);
+        return _lift(handleArgs(utilsIsGeoJSON), input, _parentContext);
+    return utilsIsGeoJSON(input);
 }
 export function isGeoShapePoint(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isGeoShapePoint), input, _parentContext);
-    return ts.isGeoShapePoint(input);
+        return _lift(handleArgs(utilsIsGeoShapePoint), input, _parentContext);
+    return utilsIsGeoShapePoint(input);
 }
 /**
  * Checks to see if input is a valid geo-json polygon or a list of geo-json polygons
@@ -312,11 +318,11 @@ export function isGeoShapePoint(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isGeoShapePolygon(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isGeoShapePolygon), input, _parentContext);
-    return ts.isGeoShapePolygon(input);
+        return _lift(handleArgs(utilsIsGeoShapePolygon), input, _parentContext);
+    return utilsIsGeoShapePolygon(input);
 }
 /**
  * Checks to see if input is a valid geo-json multi-polygon or a list of geo-json multi-polygons
@@ -356,11 +362,12 @@ export function isGeoShapePolygon(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isGeoShapeMultiPolygon(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
-    if (isArray(input))
-        return _lift(handleArgs(ts.isGeoShapeMultiPolygon), input, _parentContext);
-    return ts.isGeoShapeMultiPolygon(input);
+    if (isArray(input)) {
+        return _lift(handleArgs(utilsIsGeoShapeMultiPolygon), input, _parentContext);
+    }
+    return utilsIsGeoShapeMultiPolygon(input);
 }
 /**
  * Validates that the input is an IP address, or a list of IP addresses
@@ -380,16 +387,16 @@ export function isGeoShapeMultiPolygon(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isIP(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
         return _lift(isValidIP, input, _parentContext);
     return isValidIP(input);
 }
 function isValidIP(input, _parentContext) {
-    if (!ts.isString(input))
+    if (!isString(input))
         return false;
-    if (!ts.isIP(input))
+    if (!utilsIsIP(input))
         return false;
     return true;
 }
@@ -414,7 +421,7 @@ function isValidIP(input, _parentContext) {
  *  for ip range details
  */
 export function isRoutableIP(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
         return _lift(_isRoutableIP, input, _parentContext);
@@ -446,7 +453,7 @@ function _isRoutableIP(input, _parentContext) {
  *  for ip range details
  */
 export function isNonRoutableIP(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
         return _lift(_isNonRoutableIP, input, _parentContext);
@@ -520,16 +527,16 @@ function _inRestrictedIPRange(parsedIp) {
  * @returns {boolean} boolean
  */
 export function isCIDR(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
         return _lift(_isCidr, input, _parentContext);
     return _isCidr(input);
 }
 function _isCidr(input, _parentContext) {
-    if (!ts.isString(input))
+    if (!isString(input))
         return false;
-    return ts.isNonZeroCidr(input);
+    return isNonZeroCidr(input);
 }
 /**
  * Validates if the input is within a given range of IP's
@@ -546,7 +553,7 @@ function _isCidr(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function inIPRange(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
         return _lift(_inIPRange, input, _parentContext, args);
@@ -568,11 +575,11 @@ function _inIPRange(input, args) {
     // assign upper/lower bound even if min or max is missing
     let { min, max } = args;
     if (!min)
-        min = ts.isIPv6(input) ? MIN_IPV6_IP : MIN_IPV4_IP;
+        min = isIPv6(input) ? MIN_IPV6_IP : MIN_IPV4_IP;
     if (!max)
-        max = ts.isIPv6(input) ? MAX_IPV6_IP : MAX_IPV4_IP;
+        max = isIPv6(input) ? MAX_IPV6_IP : MAX_IPV4_IP;
     // min and max must be valid ips, same IP type, and min < max
-    if (!isIP(min) || !isIP(max) || ts.isIPv6(min) !== ts.isIPv6(max)
+    if (!isIP(min) || !isIP(max) || isIPv6(min) !== isIPv6(max)
         || ip6addr.compare(max, min) === -1) {
         return false;
     }
@@ -592,7 +599,7 @@ function _inIPRange(input, args) {
  * @returns {boolean} boolean
  */
 export function isISDN(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
         const fn = (data) => {
@@ -626,12 +633,12 @@ export function isISDN(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isMACAddress(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        return _lift(ts.isMACAddressFP(args?.delimiter), input, _parentContext);
+        return _lift(isMACAddressFP(args?.delimiter), input, _parentContext);
     }
-    return ts.isMACAddress(input, args?.delimiter);
+    return utilsIsMacAddress(input, args?.delimiter);
 }
 /**
  * Will return true if number is between args provided, or that the list
@@ -650,12 +657,12 @@ export function isMACAddress(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function inNumberRange(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        return _lift(ts.inNumberRangeFP(args), input, _parentContext);
+        return _lift(inNumberRangeFP(args), input, _parentContext);
     }
-    return ts.inNumberRange(input, args);
+    return utilsInNumberRange(input, args);
 }
 /**
  * Validates that input is a number or a list of numbers
@@ -671,11 +678,11 @@ export function inNumberRange(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isNumber(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isNumber), input, _parentContext);
-    return ts.isNumber(input);
+        return _lift(handleArgs(utilsIsNumber), input, _parentContext);
+    return utilsIsNumber(input);
 }
 /**
  * Validates that input is a integer or a list of integers
@@ -693,11 +700,11 @@ export function isNumber(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isInteger(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isInteger), input, _parentContext);
-    return ts.isInteger(input);
+        return _lift(handleArgs(utilsIsInteger), input, _parentContext);
+    return utilsIsInteger(input);
 }
 /**
  * Validates that input is a string or a list of strings
@@ -712,11 +719,11 @@ export function isInteger(input, _parentContext) {
  * @param {*} input
  */
 export function isString(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input))
-        return _lift(handleArgs(ts.isString), input, _parentContext);
-    return ts.isString(input);
+        return _lift(handleArgs(utilsIsString), input, _parentContext);
+    return utilsIsString(input);
 }
 /**
  * Validates that the input is a url or a list of urls
@@ -733,13 +740,13 @@ export function isString(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isURL(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && url.isUri(data) !== null;
+        const fn = (data) => utilsIsString(data) && url.isUri(data) !== null;
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && url.isUri(input) != null;
+    return utilsIsString(input) && url.isUri(input) != null;
 }
 /**
  * Validates that input is a UUID or a list of UUID's
@@ -756,13 +763,13 @@ export function isURL(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isUUID(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isUUID(data);
+        const fn = (data) => utilsIsString(data) && validator.isUUID(data);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isUUID(input);
+    return utilsIsString(input) && validator.isUUID(input);
 }
 /**
  * Validates the input contains the values specified in args,
@@ -780,15 +787,15 @@ export function isUUID(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function contains(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (!args.value)
         throw new Error('Parameter value must provided');
     if (isArray(input)) {
-        const fn = (data) => ts.includes(data, args.value);
+        const fn = (data) => includes(data, args.value);
         return _lift(fn, input, _parentContext);
     }
-    return ts.includes(input, args.value);
+    return includes(input, args.value);
 }
 /**
  * Validates that the input matches the value, of that the input array matches the value provided
@@ -803,15 +810,15 @@ export function contains(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function equals(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (!args.value)
         throw new Error('A value must provided with the input');
     if (isArray(input)) {
-        const fn = (data) => ts.isDeepEqual(data, args.value);
+        const fn = (data) => isDeepEqual(data, args.value);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isDeepEqual(input, args.value);
+    return isDeepEqual(input, args.value);
 }
 /**
  * Validates that the input is alpha or a list of alpha values
@@ -827,14 +834,14 @@ export function equals(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isAlpha(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     const locale = args && args.locale ? args.locale : 'en-US';
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isAlpha(data, locale);
+        const fn = (data) => utilsIsString(data) && validator.isAlpha(data, locale);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isAlpha(input, locale);
+    return utilsIsString(input) && validator.isAlpha(input, locale);
 }
 /**
  * Validates that the input is alphanumeric or a list of alphanumeric values
@@ -851,14 +858,14 @@ export function isAlpha(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isAlphanumeric(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     const locale = args && args.locale ? args.locale : 'en-US';
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isAlphanumeric(data, locale);
+        const fn = (data) => isString(data) && validator.isAlphanumeric(data, locale);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isAlphanumeric(input, locale);
+    return isString(input) && validator.isAlphanumeric(input, locale);
 }
 /**
  * Validates that the input is ascii chars or a list of ascii chars
@@ -873,13 +880,13 @@ export function isAlphanumeric(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isASCII(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isAscii(data);
+        const fn = (data) => utilsIsString(data) && validator.isAscii(data);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isAscii(input);
+    return utilsIsString(input) && validator.isAscii(input);
 }
 /**
  * Validates that the input is a base64 encoded string or a list of base64
@@ -895,7 +902,7 @@ export function isASCII(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isBase64(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
         const fn = (data) => _validBase64(data);
@@ -904,7 +911,7 @@ export function isBase64(input, _parentContext) {
     return _validBase64(input);
 }
 function _validBase64(input) {
-    if (ts.isString(input)) {
+    if (utilsIsString(input)) {
         const validatorValid = validator.isBase64(input);
         const validatorValidUrl = validator.isBase64(input, { urlSafe: true });
         // validator does not include pad char(=)
@@ -935,10 +942,10 @@ function _validBase64(input) {
  */
 export function isEmpty(input, _parentContext, args) {
     let value = input;
-    if (!isArray(value) && ts.isString(value) && args && args.ignoreWhitespace) {
+    if (!isArray(value) && utilsIsString(value) && args && args.ignoreWhitespace) {
         value = value.trim();
     }
-    return ts.isEmpty(value);
+    return utilsIsEmpty(value);
 }
 /**
  * Validate that the input is a valid domain name, or a list of domain names
@@ -954,7 +961,7 @@ export function isEmpty(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isFQDN(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     const config = {
         require_tld: args?.requireTld || true,
@@ -962,10 +969,10 @@ export function isFQDN(input, _parentContext, args) {
         allow_trailing_dot: args?.allowTrailingDot || false
     };
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isFQDN(data, config);
+        const fn = (data) => utilsIsString(data) && validator.isFQDN(data, config);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isFQDN(input, config);
+    return utilsIsString(input) && validator.isFQDN(input, config);
 }
 /**
  * Validates that the input is a hash, or a list of hashes
@@ -993,15 +1000,15 @@ export function isFQDN(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isHash(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (args?.algo === undefined)
         throw new Error('Parameter property algo was not provided');
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isHash(data, args.algo);
+        const fn = (data) => utilsIsString(data) && validator.isHash(data, args.algo);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isHash(input, args.algo);
+    return utilsIsString(input) && validator.isHash(input, args.algo);
 }
 /**
  * Validates that input is a valid country code or a list of country codes
@@ -1017,13 +1024,13 @@ export function isHash(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isCountryCode(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isISO31661Alpha2(data);
+        const fn = (data) => utilsIsString(data) && validator.isISO31661Alpha2(data);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isISO31661Alpha2(input);
+    return utilsIsString(input) && validator.isISO31661Alpha2(input);
 }
 /**
  * Checks to see if input is a valid ISO8601 string dates or a list of valid dates
@@ -1036,13 +1043,13 @@ export function isCountryCode(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isISO8601(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isISO8601(data);
+        const fn = (data) => utilsIsString(data) && validator.isISO8601(data);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isISO8601(input);
+    return utilsIsString(input) && validator.isISO8601(input);
 }
 /**
  * Validates that input is a valid ISSN or a list of valid ISSN
@@ -1059,17 +1066,17 @@ export function isISO8601(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isISSN(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     const config = {
         case_sensitive: args?.caseSensitive || false,
         require_hyphen: args?.requireHyphen || false
     };
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isISSN(data, config);
+        const fn = (data) => utilsIsString(data) && validator.isISSN(data, config);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isISSN(input, config);
+    return utilsIsString(input) && validator.isISSN(input, config);
 }
 /**
  * Validates that input is a valid RFC3339 dates or a list of valid RFC3339 dates
@@ -1084,13 +1091,13 @@ export function isISSN(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isRFC3339(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isRFC3339(data);
+        const fn = (data) => utilsIsString(data) && validator.isRFC3339(data);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isRFC3339(input);
+    return utilsIsString(input) && validator.isRFC3339(input);
 }
 /**
  * Validates that input is a valid JSON string or a list of valid JSON
@@ -1106,13 +1113,13 @@ export function isRFC3339(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isJSON(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isJSON(data);
+        const fn = (data) => utilsIsString(data) && validator.isJSON(data);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isJSON(input);
+    return utilsIsString(input) && validator.isJSON(input);
 }
 /**
  * Check to see if input is a string with given length ranges, or a list of valid string lengths
@@ -1128,12 +1135,12 @@ export function isJSON(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isLength(input, _parentContext, { size, min, max }) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
         const fn = (data) => {
             if (size)
-                return ts.isString(data) && data.length === size;
+                return utilsIsString(data) && data.length === size;
             if (min || max)
                 return validator.isLength(data, { min, max });
             return false;
@@ -1162,13 +1169,13 @@ export function isLength(input, _parentContext, { size, min, max }) {
  * @returns {boolean} boolean
  */
 export function isMIMEType(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isMimeType(data);
+        const fn = (data) => utilsIsString(data) && validator.isMimeType(data);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isMimeType(input);
+    return utilsIsString(input) && validator.isMimeType(input);
 }
 /**
  * Validates that input is a valid postal code or a list of postal codes
@@ -1188,15 +1195,15 @@ export function isMIMEType(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isPostalCode(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (!args?.locale)
         throw new Error('Invalid parameter locale, must provide an object with locale');
     if (isArray(input)) {
-        const fn = (data) => ts.isString(data) && validator.isPostalCode(data, args.locale);
+        const fn = (data) => utilsIsString(data) && validator.isPostalCode(data, args.locale);
         return _lift(fn, input, _parentContext);
     }
-    return ts.isString(input) && validator.isPostalCode(input, args.locale);
+    return utilsIsString(input) && validator.isPostalCode(input, args.locale);
 }
 /**
  * Validates that the input is a valid date or a list of valid dates
@@ -1217,12 +1224,12 @@ export function isPostalCode(input, _parentContext, args) {
  * @returns {boolean} boolean
  */
 export function isValidDate(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return false;
     if (isArray(input)) {
-        return _lift(handleArgs(ts.isValidDate), input, _parentContext);
+        return _lift(handleArgs(utilsIsValidDate), input, _parentContext);
     }
-    return !ts.isBoolean(input) && ts.isValidDate(input);
+    return !utilsIsBoolean(input) && utilsIsValidDate(input);
 }
 /**
  * Will throw if input is null or undefined
@@ -1236,7 +1243,7 @@ export function isValidDate(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function guard(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         throw new Error('Expected value not to be empty');
     return true;
 }
@@ -1252,7 +1259,7 @@ export function guard(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function exists(input, _parentContext) {
-    return ts.isNotNil(input);
+    return isNotNil(input);
 }
 /**
  * Validates that the input is an array
@@ -1265,7 +1272,7 @@ export function exists(input, _parentContext) {
  * @returns {boolean} boolean
  */
 export function isArray(input, _parentContext) {
-    return ts.isArrayLike(input);
+    return isArrayLike(input);
 }
 /**
  * Validates that the function specified returns true at least once on the list of values
@@ -1314,7 +1321,7 @@ export function every(input, _parentContext, { fn, options }) {
 }
 export function isNumberTuple(input, _parentContext) {
     if (Array.isArray(input) && input.length === 2) {
-        return input.every(isNumber);
+        return input.every(utilsIsNumber);
     }
     return false;
 }