@ptolemy2002/regex-utils 1.2.0 → 2.0.0

package/README.md

@@ -2,13 +2,26 @@
 This library contains utilities that are useful when working with JavaScript regular expressions.
 
 The functions are not exported as default, so you can import them in one of the following ways:
-```
+```javascript
 // ES6
 import { functionName } from '@ptolemy2002/regex-utils';
 // CommonJS
 const { functionName } = require('@ptolemy2002/regex-utils');
 ```
 
+## Type Reference
+```typescript
+type RegexInput = string | RegExp;
+type TransformRegexOptions = {
+    flags?: string;
+    caseInsensitive?: boolean;
+    accentInsensitive?: boolean;
+    matchWhole?: boolean;
+};
+export type ZodValidator<O> = (v: O) => boolean;
+export type ZodValidatorWithErrors<O> = (v: O) => true | string | string[];
+```
+
 ## Functions
 The following functions are available in the library:
 
@@ -17,18 +30,18 @@ The following functions are available in the library:
 Combines two sets of flags into one string. If a flag is present in both sets, it will only appear once in the result.
 
 #### Parameters
-- `...flags` (`String[]`): The sets of flags to be combined. Falsey values will be ignored.
+- `...flags` (`string[]`): The sets of flags to be combined. Falsey values will be ignored.
 
 #### Returns
-`String` - The combined flags.
+`string` - The combined flags.
 
 ### escapeRegex
 #### Description
-Escapes a string so that it can be used as a literal in a regular expression. If spefifying a `RegExp` object, the flags are added after transforming the source to a literal.
+Escapes a value so that it can be used as a literal in a regular expression. If spefifying a `RegExp` object, the flags are added after transforming the source to a literal.
 
 #### Parameters
-- `value` (`String | RegExp`): The value to be escaped.
-- `flags` (`String`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
+- `value` (`RegexInput`): The value to be escaped.
+- `flags` (`string`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
 
 #### Returns
 `RegExp` - The escaped regular expression.
@@ -38,8 +51,8 @@ Escapes a string so that it can be used as a literal in a regular expression. If
 Attempts to transform a `RegExp` object to be accent insensitive. Note that this is done using a static list of common characters and their accented versions, so it is not perfect.
 
 #### Parameters
-- `value` (`String | RegExp`): The value to be transformed to be accent insensitive.
-- `flags` (`String`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
+- `value` (`RegexInput`): The value to be transformed to be accent insensitive.
+- `flags` (`string`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
 
 #### Returns
 `RegExp` - The accent insensitive regular expression.
@@ -49,18 +62,18 @@ Attempts to transform a `RegExp` object to be accent insensitive. Note that this
 Attempts to remove accents from a string. Note that this is done using a static list of common characters and their accented versions, so it is not perfect.
 
 #### Parameters
-- `value` (`String`): The value to be transformed to remove accents.
+- `value` (`string`): The value to be transformed to remove accents.
 
 #### Returns
-`String` - The string with accents removed.
+`string` - The string with accents removed.
 
 ### regexCaseInsensitive
 #### Description
 Transforms a `RegExp` object to be case insensitive by adding the `i` flag.
 
 #### Parameters
-- `value` (`String | RegExp`): The value to be transformed to be case insensitive.
-- `flags` (`String`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
+- `value` (`RegexInput`): The value to be transformed to be case insensitive.
+- `flags` (`string`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
 
 #### Returns
 `RegExp` - The case insensitive regular expression.
@@ -70,8 +83,11 @@ Transforms a `RegExp` object to be case insensitive by adding the `i` flag.
 Transforms a `RegExp` object to match the whole string by adding `^` and `$` to the beginning and end of the source, respectively.
 
 #### Parameters
-- `value` (`String | RegExp`): The value to be transformed to match the whole string.
-- `flags` (`String`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
+- `value` (`RegexInput`): The value to be transformed to match the whole string.
+- `flags` (`string`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
+
+#### Returns
+`RegExp` - The regular expression that matches the whole string.
 
 ### transformRegex
 #### Description
@@ -79,11 +95,11 @@ This function is a quick way to apply multiple supported transformations to a re
 
 #### Parameters
 - `value` (`String | RegExp`): The value to be transformed.
-- `args` (`Object`): Used to specify optional arguments.
-    - `accentInsensitive` (`Boolean`): Whether to make the regular expression accent insensitive. Default is `false`.
-    - `caseInsensitive` (`Boolean`): Whether to make the regular expression case insensitive. Default is `false`.
-    - `matchWhole` (`Boolean`): Whether to make the regular expression match the whole string. Default is `false`.
-    - `flags` (`String`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
+- `args` (`TransformRegexOptions`): Used to specify optional arguments.
+    - `accentInsensitive` (`boolean`): Whether to make the regular expression accent insensitive. Default is `false`.
+    - `caseInsensitive` (`boolean`): Whether to make the regular expression case insensitive. Default is `false`.
+    - `matchWhole` (`boolean`): Whether to make the regular expression match the whole string. Default is `false`.
+    - `flags` (`string`): The flags to be used in the regular expression. If a `RegExp` object is passed, these flags will be added to the existing flags.
 
 #### Returns
 `RegExp` - The transformed regular expression.
@@ -93,99 +109,102 @@ This function is a quick way to apply multiple supported transformations to a re
 Checks if a string is a valid regular expression by attempting to create a `RegExp` object with it.
 
 #### Parameters
-- `value` (`String`): The value to be checked.
-- `flags` (`String`): The flags to be used in the regular expression.
+- `value` (`string`): The value to be checked.
+- `flags` (`string`): The flags to be used in the regular expression.
 
 #### Returns
-`Boolean` - `true` if the string is a valid regular expression, `false` otherwise.
+`boolean` - `true` if the string is a valid regular expression, `false` otherwise.
 
 ### isValidRegexFlags
 #### Description
 Checks if a string is a valid set of regular expression flags.
 
 #### Parameters
-- `value` (`String`): The value to be checked.
+- `value` (`string`): The value to be checked.
 
 #### Returns
-`Boolean` - `true` if the string is a valid set of regular expression flags, `false` otherwise.
+`boolean` - `true` if the string is a valid set of regular expression flags, `false` otherwise.
 
-### zodValidate
+### zodValidate<O>
 #### Description
-This is a simple function that takes a zod schema, returning a function that takes a value. If the value matches, the function returns `true`. Otherwise, it returns whatever error message the zod schema provides by default, or `false` if the `returnError` flag is disabled.
+This is a simple function that takes a zod schema, returning a function that takes a value. If the value matches, the function returns `true`. Otherwise, it returns `false`. `O` refers to the output type of the zod schema, which should be the same as its input type.
 
 #### Parameters
-- `p` (`ZodSchema`): The zod schema to be used for validation.
-- `returnError` (`Boolean`): Whether to return the error message if the value does not match the schema. Default is `true`. If `false`, the function will return `false` on failure instead.
+- `p` (`ZodSchema<O>`): The zod schema to be used for validation.
 
 #### Returns
-`Function` - A function that takes a value and returns `true` if the value matches the schema, an error message if the value does not match the schema and `returnError` is `true`, or `false` if the value does not match the schema and `returnError` is `false`.
+`ZodValidator<O>` - A function that takes a value and returns `true` if the value matches the schema, `false` otherwise.
+
+### zodValidateWithErrors<O>
+#### Description
+This is a simple function that takes a zod schema, returning a function that takes a value. If the value matches, the function returns `true`. Otherwise, it returns a single error message or an array of error messages if there are multiple errors. `O` refers to the output type of the zod schema, which should be the same as its input type.
+
+#### Parameters
+- `p` (`ZodSchema<O>`): The zod schema to be used for validation.
 
 #### Returns
-`Function` - A function that takes a value and returns `true` if the value matches the schema, or an error message otherwise.
+`ZodValidatorWithErrors<O>` - A function that takes a value and returns `true` if the value matches the schema, an error message if there is a single error, or an array of error messages if there are multiple errors.
 
 ### isAlphanumeric
 #### Description
 Uses `zodValidate` to check if a string is alphanumeric, that is, if it only contains letters, numbers, dashes, and underscores. Empty strings are not considered alphanumeric.
 
 #### Parameters
-- `str` (`String`): The value to be checked.
+- `str` (`string`): The value to be checked.
 
 #### Returns
-`Boolean` - `true` if the string is alphanumeric, `false` otherwise.
+`boolean` - `true` if the string is alphanumeric, `false` otherwise.
 
 ### toAlphanumeric
 #### Description
 Transforms a string to be alphanumeric by removing accents, separating it by non-alphanumeric segments, and then joining the words with the specified `separator`.
 
 #### Parameters
-- `str` (`String`): The value to be transformed.
-- `separator` (`String`): The separator to be used between words. Default is `'-'`.
+- `str` (`string`): The value to be transformed.
+- `separator` (`string`): The separator to be used between words. Default is `'-'`.
 
 #### Returns
-`String` - The transformed string.
+`string` - The transformed string.
 
 ### isValidEmail
 #### Description
 Uses `zodValidate` to check if a string is a valid email address. Note that this is a simple check and may not cover all cases, but it should be good enough for most purposes.
 
 #### Parameters
-- `value` (`String`): The value to be checked.
+- `value` (`string`): The value to be checked.
 
 #### Returns
-`Boolean` - `true` if the string is a valid email address, `false` otherwise.
+`boolean` - `true` if the string is a valid email address, `false` otherwise.
 
 ### isValidPhoneNumber
 #### Description
 Uses `zodValidate` to check if a string is a valid phone number. Note that this is a simple check and may not cover all cases, but it should be good enough for most purposes.
 
 #### Parameters
-- `value` (`String`): The value to be checked.
+- `value` (`string`): The value to be checked.
 
 #### Returns
-`Boolean` - `true` if the string is a valid phone number, `false` otherwise.
+`boolean` - `true` if the string is a valid phone number, `false` otherwise.
 
 ### isValidURL
 #### Description
 Uses `zodValidate` to check if a string is a valid URL. Note that this is a simple check and may not cover all cases, but it should be good enough for most purposes.
 
 #### Parameters
-- `value` (`String`): The value to be checked.
+- `value` (`string`): The value to be checked.
 
 #### Returns
-`Boolean` - `true` if the string is a valid URL, `false` otherwise.
+`boolean` - `true` if the string is a valid URL, `false` otherwise.
 
 ### isValidSSN
 #### Description
 Uses `zodValidate` to check if a string is a valid Social Security Number (SSN). Note that this is a simple check and may not cover all cases, but it should be good enough for most purposes.
 
 #### Parameters
-- `value` (`String`): The value to be checked.
+- `value` (`string`): The value to be checked.
 
 #### Returns
-`Boolean` - `true` if the string is a valid SSN, `false` otherwise.
-
-## Meta
-This is a React Library Created by Ptolemy2002's [cra-template-react-library](https://www.npmjs.com/package/@ptolemy2002/cra-template-react-library) template in combination with [create-react-app](https://www.npmjs.com/package/create-react-app). However, it does not actually depend on React - it has been modified to work out of the box. It contains methods of building and publishing your library to npm.
+`boolean` - `true` if the string is a valid SSN, `false` otherwise.
 
 ## Peer Dependencies
 These should be installed in order to use the library, as npm does not automatically add peer dependencies to your project.

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { ZodSchema } from "zod";
+export type RegexInput = string | RegExp;
+export declare function combineFlags(...flags: string[]): string;
+export declare function escapeRegex(value: RegexInput, flags?: string): RegExp;
+export declare function regexAccentInsensitive(value: RegexInput, flags?: string): RegExp;
+export declare function removeAccents(value: string): string;
+export declare function regexCaseInsensitive(value: RegexInput, flags?: string): RegExp;
+export declare function regexMatchWhole(value: RegexInput, flags?: string): RegExp;
+export type TransformRegexOptions = {
+    flags?: string;
+    caseInsensitive?: boolean;
+    accentInsensitive?: boolean;
+    matchWhole?: boolean;
+};
+export declare function transformRegex(value: RegexInput, { flags, accentInsensitive, caseInsensitive, matchWhole }: TransformRegexOptions): RegExp;
+export declare function isValidRegex(value: string, flags?: string): boolean;
+export declare function isValidRegexFlags(value: string): boolean;
+export type ZodValidator<O> = (v: O) => boolean;
+export type ZodValidatorWithErrors<O> = (v: O) => true | string | string[];
+export declare function zodValidate<O>(p: ZodSchema<O>): ZodValidator<O>;
+export declare function zodValidateWithErrors<O>(p: ZodSchema<O>): ZodValidatorWithErrors<O>;
+export declare function isAlphanumeric(str: string): boolean;
+export declare function toAlphanumeric(str: string, separator?: string): string;
+export declare function isValidEmail(v: string): boolean;
+export declare function isValidURL(v: string): boolean;
+export declare function isValidPhoneNumber(v: string): boolean;
+export declare function isValidSSN(v: string): boolean;

package/dist/index.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineFlags = combineFlags;
+exports.escapeRegex = escapeRegex;
+exports.regexAccentInsensitive = regexAccentInsensitive;
+exports.removeAccents = removeAccents;
+exports.regexCaseInsensitive = regexCaseInsensitive;
+exports.regexMatchWhole = regexMatchWhole;
+exports.transformRegex = transformRegex;
+exports.isValidRegex = isValidRegex;
+exports.isValidRegexFlags = isValidRegexFlags;
+exports.zodValidate = zodValidate;
+exports.zodValidateWithErrors = zodValidateWithErrors;
+exports.isAlphanumeric = isAlphanumeric;
+exports.toAlphanumeric = toAlphanumeric;
+exports.isValidEmail = isValidEmail;
+exports.isValidURL = isValidURL;
+exports.isValidPhoneNumber = isValidPhoneNumber;
+exports.isValidSSN = isValidSSN;
+const zod_1 = require("zod");
+const accentPatterns = [
+    "(a|á|à|ä|â|ã)", "(A|Á|À|Ä|Â|Ã)",
+    "(e|é|è|ë|ê)", "(E|É|È|Ë|Ê)",
+    "(i|í|ì|ï|î)", "(I|Í|Ì|Ï|Î)",
+    "(o|ó|ò|ö|ô|õ)", "(O|Ó|Ò|Ö|Ô|Õ)",
+    "(u|ú|ù|ü|û)", "(U|Ú|Ù|Ü|Û)"
+];
+function combineFlags(...flags) {
+    const result = new Set();
+    flags.forEach((flag) => {
+        if (flag) {
+            flag.split("").forEach((c) => {
+                if (!result.has(c))
+                    result.add(c);
+            });
+        }
+    });
+    return [...result].join("");
+}
+function escapeRegex(value, flags = "") {
+    if (typeof value === 'string') {
+        return new RegExp(value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, '\\$&'), flags);
+    }
+    else {
+        return escapeRegex(value.source, combineFlags(value.flags, flags));
+    }
+}
+function regexAccentInsensitive(value, flags = "") {
+    if (typeof value === 'string') {
+        let stringValue = value;
+        accentPatterns.forEach((pattern) => {
+            stringValue = stringValue.replaceAll(new RegExp(pattern, "g"), pattern);
+        });
+        return new RegExp(stringValue, flags);
+    }
+    else {
+        return regexAccentInsensitive(value.source, combineFlags(value.flags, flags));
+    }
+}
+function removeAccents(value) {
+    accentPatterns.forEach((pattern) => {
+        value = value.replaceAll(new RegExp(pattern, "g"), pattern[1]);
+    });
+    return value;
+}
+function regexCaseInsensitive(value, flags = "") {
+    if (typeof value === 'string') {
+        if (!flags.includes("i")) {
+            flags += "i";
+        }
+        return new RegExp(value, flags);
+    }
+    else {
+        return regexCaseInsensitive(value.source, combineFlags(value.flags, flags));
+    }
+}
+function regexMatchWhole(value, flags = "") {
+    if (typeof value === 'string') {
+        return new RegExp(`^${value}$`, flags);
+    }
+    else {
+        return regexMatchWhole(value.source, combineFlags(value.flags, flags));
+    }
+}
+function transformRegex(value, { flags = "", accentInsensitive = false, caseInsensitive = false, matchWhole = false }) {
+    if (accentInsensitive)
+        value = regexAccentInsensitive(value, flags);
+    if (caseInsensitive)
+        value = regexCaseInsensitive(value, flags);
+    if (matchWhole)
+        value = regexMatchWhole(value, flags);
+    if (typeof value === 'string') {
+        value = new RegExp(value, flags);
+    }
+    else {
+        value = new RegExp(value.source, combineFlags(value.flags, flags));
+    }
+    return value;
+}
+function isValidRegex(value, flags = "") {
+    try {
+        new RegExp(value, flags);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isValidRegexFlags(value) {
+    return /^[gimsuy]*$/.test(value);
+}
+function zodValidate(p) {
+    return (v) => {
+        const result = p.safeParse(v);
+        return result.success;
+    };
+}
+function zodValidateWithErrors(p) {
+    return (v) => {
+        const result = p.safeParse(v);
+        if (result.success)
+            return true;
+        if (result.error.errors.length === 1)
+            return result.error.errors[0].message;
+        return result.error.errors.map((e) => e.message);
+    };
+}
+const alphanumericPattern = /[\w_-]+/i;
+const nonAlphanumericPattern = /[^\w_-]+/i;
+function isAlphanumeric(str) {
+    return zodValidate(zod_1.z.string().regex(transformRegex(alphanumericPattern, { matchWhole: true })))(str);
+}
+function toAlphanumeric(str, separator = "-") {
+    const globalNonAlphanumericPattern = transformRegex(nonAlphanumericPattern, { flags: "g" });
+    str = removeAccents(str);
+    const words = str.split(globalNonAlphanumericPattern);
+    return words.map((word) => {
+        return word.replaceAll(globalNonAlphanumericPattern, "");
+    }).filter((word) => word).join(separator);
+}
+function isValidEmail(v) {
+    return zodValidate(zod_1.z.string().email())(v);
+}
+function isValidURL(v) {
+    return zodValidate(zod_1.z.string().url())(v);
+}
+function isValidPhoneNumber(v) {
+    return zodValidate(zod_1.z.coerce.string().regex(/^\+?\d?\s*(\(\d{3}\)|\d{3})(\s*|-)\d{3}(\s*|-)\d{4}$/))(v);
+}
+function isValidSSN(v) {
+    return zodValidate(zod_1.z.coerce.string().regex(/^\d{3}-?\d{2}-?\d{4}$/))(v);
+}

package/package.json

@@ -1,12 +1,19 @@
 {
     "name": "@ptolemy2002/regex-utils",
-    "version": "1.2.0",
-    "main": "index.js",
+    "version": "2.0.0",
+    "private": false,
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
     "files": [
-        "index.js"
+        "/dist"
     ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Ptolemy2002/regex-utils",
+        "directory": "lib"
+    },
     "scripts": {
-        "build": "esbuild src/index.js --bundle --format=cjs --outfile=index.js --loader:.js=jsx --external:zod",
+        "build": "tsc --project ./tsconfig.json",
         "postinstall": "npx typesync",
         "uninstall": "bash ./scripts/uninstall.sh",
         "reinstall": "bash ./scripts/reinstall.sh",
@@ -19,17 +26,10 @@
         "release-minor": "bash ./scripts/release.sh minor",
         "release-major": "bash ./scripts/release.sh major"
     },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Ptolemy2002/regex-utils",
-        "directory": "lib"
+    "peerDependencies": {
+        "zod": "^3.23.8"
     },
-    "description": "Utilities for working with regular expressions",
-    "license": "ISC",
     "devDependencies": {
-        "esbuild": "^0.23.0"
-    },
-    "peerDependencies": {
         "zod": "^3.23.8"
     }
 }

package/index.js

@@ -1,171 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.js
-var src_exports = {};
-__export(src_exports, {
-  combineFlags: () => combineFlags,
-  escapeRegex: () => escapeRegex,
-  isAlphanumeric: () => isAlphanumeric,
-  isValidEmail: () => isValidEmail,
-  isValidPhoneNumber: () => isValidPhoneNumber,
-  isValidRegex: () => isValidRegex,
-  isValidRegexFlags: () => isValidRegexFlags,
-  isValidSSN: () => isValidSSN,
-  isValidURL: () => isValidURL,
-  regexAccentInsensitive: () => regexAccentInsensitive,
-  regexCaseInsensitive: () => regexCaseInsensitive,
-  regexMatchWhole: () => regexMatchWhole,
-  removeAccents: () => removeAccents,
-  toAlphanumeric: () => toAlphanumeric,
-  transformRegex: () => transformRegex,
-  zodValidate: () => zodValidate
-});
-module.exports = __toCommonJS(src_exports);
-var import_zod = require("zod");
-var accentPatterns = [
-  "(a|\xE1|\xE0|\xE4|\xE2|\xE3)",
-  "(A|\xC1|\xC0|\xC4|\xC2|\xC3)",
-  "(e|\xE9|\xE8|\xEB|\xEA)",
-  "(E|\xC9|\xC8|\xCB|\xCA)",
-  "(i|\xED|\xEC|\xEF|\xEE)",
-  "(I|\xCD|\xCC|\xCF|\xCE)",
-  "(o|\xF3|\xF2|\xF6|\xF4|\xF5)",
-  "(O|\xD3|\xD2|\xD6|\xD4|\xD5)",
-  "(u|\xFA|\xF9|\xFC|\xFB)",
-  "(U|\xDA|\xD9|\xDC|\xDB)"
-];
-function combineFlags(...flags) {
-  const result = /* @__PURE__ */ new Set();
-  flags.forEach((flag) => {
-    if (flag) {
-      flag.split("").forEach((c) => {
-        if (!result.has(c)) result.add(c);
-      });
-    }
-  });
-  return [...result].join("");
-}
-function escapeRegex(value, flags = "") {
-  if (typeof value === "string") {
-    return new RegExp(value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, "\\$&"), flags);
-  } else if (value instanceof RegExp) {
-    return escapeRegex(value.source, combineFlags(value.flags, flags));
-  } else {
-    throw new TypeError("Expected string or RegExp, got " + typeof value);
-  }
-}
-function regexAccentInsensitive(value, flags = "") {
-  if (typeof value === "string") {
-    accentPatterns.forEach((pattern) => {
-      value = value.replaceAll(new RegExp(pattern, "g"), pattern);
-    });
-    return new RegExp(value, flags);
-  } else if (value instanceof RegExp) {
-    return regexAccentInsensitive(value.source, combineFlags(value.flags, flags));
-  } else {
-    throw new TypeError("Expected string or RegExp, got " + typeof value);
-  }
-}
-function removeAccents(value) {
-  if (typeof value === "string") {
-    accentPatterns.forEach((pattern) => {
-      value = value.replaceAll(new RegExp(pattern, "g"), pattern[1]);
-    });
-    return value;
-  } else {
-    throw new TypeError("Expected string, got " + typeof value);
-  }
-}
-function regexCaseInsensitive(value, flags = "") {
-  if (typeof value === "string") {
-    if (!flags.includes("i")) {
-      flags += "i";
-    }
-    return new RegExp(value, flags);
-  } else if (value instanceof RegExp) {
-    return regexCaseInsensitive(value.source, combineFlags(value.flags, flags));
-  } else {
-    throw new TypeError("Expected string or RegExp, got " + typeof value);
-  }
-}
-function regexMatchWhole(value, flags = "") {
-  if (typeof value === "string") {
-    return new RegExp(`^${value}$`, flags);
-  } else if (value instanceof RegExp) {
-    return regexMatchWhole(value.source, combineFlags(value.flags, flags));
-  } else {
-    throw new TypeError("Expected string or RegExp, got " + typeof value);
-  }
-}
-function transformRegex(value, { flags = "", accentInsensitive = false, caseInsensitive = false, matchWhole = false }) {
-  if (accentInsensitive) value = regexAccentInsensitive(value, flags);
-  if (caseInsensitive) value = regexCaseInsensitive(value, flags);
-  if (matchWhole) value = regexMatchWhole(value, flags);
-  if (value instanceof RegExp) {
-    value = new RegExp(value.source, combineFlags(value.flags, flags));
-  } else {
-    value = new RegExp(value, flags);
-  }
-  return value;
-}
-function isValidRegex(value, flags = "") {
-  try {
-    new RegExp(value, flags);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isValidRegexFlags(value) {
-  return /^[gimsuy]*$/.test(value);
-}
-function zodValidate(p, returnError = true) {
-  return (v) => {
-    const result = p.safeParse(v);
-    if (result.success) return true;
-    if (!returnError) return false;
-    if (result.error.errors.length === 1) return result.error.errors[0].message;
-    return result.error.errors.map((e) => e.message);
-  };
-}
-var alphanumericPattern = /[\w_-]+/i;
-var nonAlphanumericPattern = /[^\w_-]+/i;
-function isAlphanumeric(str) {
-  return zodValidate(import_zod.z.string().regex(transformRegex(alphanumericPattern, { matchWhole: true })), false)(str);
-}
-function toAlphanumeric(str, separator = "-") {
-  const globalNonAlphanumericPattern = transformRegex(nonAlphanumericPattern, { flags: "g" });
-  str = removeAccents(str);
-  const words = str.split(globalNonAlphanumericPattern);
-  return words.map((word) => {
-    return word.replaceAll(globalNonAlphanumericPattern, "");
-  }).filter((word) => word).join(separator);
-}
-function isValidEmail(v) {
-  return zodValidate(import_zod.z.string().email(), false)(v);
-}
-function isValidURL(v) {
-  return zodValidate(import_zod.z.string().url(), false)(v);
-}
-function isValidPhoneNumber(v) {
-  return zodValidate(import_zod.z.coerce.string().regex(/^\+?\d?\s*(\(\d{3}\)|\d{3})(\s*|-)\d{3}(\s*|-)\d{4}$/), false)(v);
-}
-function isValidSSN(v) {
-  return zodValidate(import_zod.z.coerce.string().regex(/^\d{3}-?\d{2}-?\d{4}$/), false)(v);
-}