@art-suite/art-core-ts-string-lib 0.2.12 → 0.3.0

package/dist/index.cjs

@@ -1,487 +1,544 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 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;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// ../../node_modules/pluralize/pluralize.js
-var require_pluralize = __commonJS({
-  "../../node_modules/pluralize/pluralize.js"(exports2, module2) {
-    "use strict";
-    (function(root, pluralize2) {
-      if (typeof require === "function" && typeof exports2 === "object" && typeof module2 === "object") {
-        module2.exports = pluralize2();
-      } else if (typeof define === "function" && define.amd) {
-        define(function() {
-          return pluralize2();
-        });
-      } else {
-        root.pluralize = pluralize2();
-      }
-    })(exports2, function() {
-      var pluralRules = [];
-      var singularRules = [];
-      var uncountables = {};
-      var irregularPlurals = {};
-      var irregularSingles = {};
-      function sanitizeRule(rule) {
-        if (typeof rule === "string") {
-          return new RegExp("^" + rule + "$", "i");
-        }
-        return rule;
-      }
-      function restoreCase(word, token) {
-        if (word === token) return token;
-        if (word === word.toLowerCase()) return token.toLowerCase();
-        if (word === word.toUpperCase()) return token.toUpperCase();
-        if (word[0] === word[0].toUpperCase()) {
-          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
-        }
-        return token.toLowerCase();
-      }
-      function interpolate(str, args) {
-        return str.replace(/\$(\d{1,2})/g, function(match, index) {
-          return args[index] || "";
-        });
-      }
-      function replace(word, rule) {
-        return word.replace(rule[0], function(match, index) {
-          var result = interpolate(rule[1], arguments);
-          if (match === "") {
-            return restoreCase(word[index - 1], result);
-          }
-          return restoreCase(match, result);
-        });
-      }
-      function sanitizeWord(token, word, rules) {
-        if (!token.length || uncountables.hasOwnProperty(token)) {
-          return word;
-        }
-        var len = rules.length;
-        while (len--) {
-          var rule = rules[len];
-          if (rule[0].test(word)) return replace(word, rule);
-        }
-        return word;
-      }
-      function replaceWord(replaceMap, keepMap, rules) {
-        return function(word) {
-          var token = word.toLowerCase();
-          if (keepMap.hasOwnProperty(token)) {
-            return restoreCase(word, token);
-          }
-          if (replaceMap.hasOwnProperty(token)) {
-            return restoreCase(word, replaceMap[token]);
-          }
-          return sanitizeWord(token, word, rules);
-        };
-      }
-      function checkWord(replaceMap, keepMap, rules, bool) {
-        return function(word) {
-          var token = word.toLowerCase();
-          if (keepMap.hasOwnProperty(token)) return true;
-          if (replaceMap.hasOwnProperty(token)) return false;
-          return sanitizeWord(token, token, rules) === token;
-        };
-      }
-      function pluralize2(word, count, inclusive) {
-        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
-        return (inclusive ? count + " " : "") + pluralized;
-      }
-      pluralize2.plural = replaceWord(
-        irregularSingles,
-        irregularPlurals,
-        pluralRules
-      );
-      pluralize2.isPlural = checkWord(
-        irregularSingles,
-        irregularPlurals,
-        pluralRules
-      );
-      pluralize2.singular = replaceWord(
-        irregularPlurals,
-        irregularSingles,
-        singularRules
-      );
-      pluralize2.isSingular = checkWord(
-        irregularPlurals,
-        irregularSingles,
-        singularRules
-      );
-      pluralize2.addPluralRule = function(rule, replacement) {
-        pluralRules.push([sanitizeRule(rule), replacement]);
-      };
-      pluralize2.addSingularRule = function(rule, replacement) {
-        singularRules.push([sanitizeRule(rule), replacement]);
-      };
-      pluralize2.addUncountableRule = function(word) {
-        if (typeof word === "string") {
-          uncountables[word.toLowerCase()] = true;
-          return;
-        }
-        pluralize2.addPluralRule(word, "$0");
-        pluralize2.addSingularRule(word, "$0");
-      };
-      pluralize2.addIrregularRule = function(single, plural2) {
-        plural2 = plural2.toLowerCase();
-        single = single.toLowerCase();
-        irregularSingles[single] = plural2;
-        irregularPlurals[plural2] = single;
-      };
-      [
-        // Pronouns.
-        ["I", "we"],
-        ["me", "us"],
-        ["he", "they"],
-        ["she", "they"],
-        ["them", "them"],
-        ["myself", "ourselves"],
-        ["yourself", "yourselves"],
-        ["itself", "themselves"],
-        ["herself", "themselves"],
-        ["himself", "themselves"],
-        ["themself", "themselves"],
-        ["is", "are"],
-        ["was", "were"],
-        ["has", "have"],
-        ["this", "these"],
-        ["that", "those"],
-        // Words ending in with a consonant and `o`.
-        ["echo", "echoes"],
-        ["dingo", "dingoes"],
-        ["volcano", "volcanoes"],
-        ["tornado", "tornadoes"],
-        ["torpedo", "torpedoes"],
-        // Ends with `us`.
-        ["genus", "genera"],
-        ["viscus", "viscera"],
-        // Ends with `ma`.
-        ["stigma", "stigmata"],
-        ["stoma", "stomata"],
-        ["dogma", "dogmata"],
-        ["lemma", "lemmata"],
-        ["schema", "schemata"],
-        ["anathema", "anathemata"],
-        // Other irregular rules.
-        ["ox", "oxen"],
-        ["axe", "axes"],
-        ["die", "dice"],
-        ["yes", "yeses"],
-        ["foot", "feet"],
-        ["eave", "eaves"],
-        ["goose", "geese"],
-        ["tooth", "teeth"],
-        ["quiz", "quizzes"],
-        ["human", "humans"],
-        ["proof", "proofs"],
-        ["carve", "carves"],
-        ["valve", "valves"],
-        ["looey", "looies"],
-        ["thief", "thieves"],
-        ["groove", "grooves"],
-        ["pickaxe", "pickaxes"],
-        ["passerby", "passersby"]
-      ].forEach(function(rule) {
-        return pluralize2.addIrregularRule(rule[0], rule[1]);
-      });
-      [
-        [/s?$/i, "s"],
-        [/[^\u0000-\u007F]$/i, "$0"],
-        [/([^aeiou]ese)$/i, "$1"],
-        [/(ax|test)is$/i, "$1es"],
-        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
-        [/(e[mn]u)s?$/i, "$1s"],
-        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
-        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
-        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
-        [/(seraph|cherub)(?:im)?$/i, "$1im"],
-        [/(her|at|gr)o$/i, "$1oes"],
-        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
-        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
-        [/sis$/i, "ses"],
-        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
-        [/([^aeiouy]|qu)y$/i, "$1ies"],
-        [/([^ch][ieo][ln])ey$/i, "$1ies"],
-        [/(x|ch|ss|sh|zz)$/i, "$1es"],
-        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
-        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
-        [/(pe)(?:rson|ople)$/i, "$1ople"],
-        [/(child)(?:ren)?$/i, "$1ren"],
-        [/eaux$/i, "$0"],
-        [/m[ae]n$/i, "men"],
-        ["thou", "you"]
-      ].forEach(function(rule) {
-        return pluralize2.addPluralRule(rule[0], rule[1]);
-      });
-      [
-        [/s$/i, ""],
-        [/(ss)$/i, "$1"],
-        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
-        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
-        [/ies$/i, "y"],
-        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
-        [/\b(mon|smil)ies$/i, "$1ey"],
-        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
-        [/(seraph|cherub)im$/i, "$1"],
-        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
-        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
-        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
-        [/(test)(?:is|es)$/i, "$1is"],
-        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
-        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
-        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
-        [/(alumn|alg|vertebr)ae$/i, "$1a"],
-        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
-        [/(matr|append)ices$/i, "$1ix"],
-        [/(pe)(rson|ople)$/i, "$1rson"],
-        [/(child)ren$/i, "$1"],
-        [/(eau)x?$/i, "$1"],
-        [/men$/i, "man"]
-      ].forEach(function(rule) {
-        return pluralize2.addSingularRule(rule[0], rule[1]);
-      });
-      [
-        // Singular words with no plurals.
-        "adulthood",
-        "advice",
-        "agenda",
-        "aid",
-        "aircraft",
-        "alcohol",
-        "ammo",
-        "analytics",
-        "anime",
-        "athletics",
-        "audio",
-        "bison",
-        "blood",
-        "bream",
-        "buffalo",
-        "butter",
-        "carp",
-        "cash",
-        "chassis",
-        "chess",
-        "clothing",
-        "cod",
-        "commerce",
-        "cooperation",
-        "corps",
-        "debris",
-        "diabetes",
-        "digestion",
-        "elk",
-        "energy",
-        "equipment",
-        "excretion",
-        "expertise",
-        "firmware",
-        "flounder",
-        "fun",
-        "gallows",
-        "garbage",
-        "graffiti",
-        "hardware",
-        "headquarters",
-        "health",
-        "herpes",
-        "highjinks",
-        "homework",
-        "housework",
-        "information",
-        "jeans",
-        "justice",
-        "kudos",
-        "labour",
-        "literature",
-        "machinery",
-        "mackerel",
-        "mail",
-        "media",
-        "mews",
-        "moose",
-        "music",
-        "mud",
-        "manga",
-        "news",
-        "only",
-        "personnel",
-        "pike",
-        "plankton",
-        "pliers",
-        "police",
-        "pollution",
-        "premises",
-        "rain",
-        "research",
-        "rice",
-        "salmon",
-        "scissors",
-        "series",
-        "sewage",
-        "shambles",
-        "shrimp",
-        "software",
-        "species",
-        "staff",
-        "swine",
-        "tennis",
-        "traffic",
-        "transportation",
-        "trout",
-        "tuna",
-        "wealth",
-        "welfare",
-        "whiting",
-        "wildebeest",
-        "wildlife",
-        "you",
-        /pok[eé]mon$/i,
-        // Regexes.
-        /[^aeiou]ese$/i,
-        // "chinese", "japanese"
-        /deer$/i,
-        // "deer", "reindeer"
-        /fish$/i,
-        // "fish", "blowfish", "angelfish"
-        /measles$/i,
-        /o[iu]s$/i,
-        // "carnivorous"
-        /pox$/i,
-        // "chickpox", "smallpox"
-        /sheep$/i
-      ].forEach(pluralize2.addUncountableRule);
-      return pluralize2;
-    });
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  addIrregularRule: () => addIrregularRule,
-  addPluralRule: () => addPluralRule,
-  addSingularRule: () => addSingularRule,
-  addUncountableRule: () => addUncountableRule,
-  base62Characters: () => base62Characters,
-  commaize: () => commaize,
-  cryptoRandomString: () => cryptoRandomString,
-  isPlural: () => isPlural,
-  isSingular: () => isSingular,
-  plural: () => plural,
-  pluralize: () => pluralize,
-  randomString: () => randomString,
-  singular: () => singular
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/commaize.ts
-var commaize = (x) => x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-
-// src/pluralize.ts
-var import_pluralize = __toESM(require_pluralize(), 1);
-var import_art_core_ts_types = require("@art-suite/art-core-ts-types");
-var patchedNpmPluralize = (noun, count, inclusive) => {
-  const match = /^(.*?)([_\W]+)$/.exec(noun);
-  if (match) {
-    const [__, mainNoun, append] = match;
-    const out = (0, import_pluralize.default)(mainNoun, count, inclusive);
-    return out + append;
-  }
-  return (0, import_pluralize.default)(noun, count, inclusive);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _art_suite_art_core_ts_types = require("@art-suite/art-core-ts-types");
+//#region src/commaize.ts
+/**
+* Adds commas to a number or string
+* @param x - The number or string to commaize
+* @returns The commaized number or string
+*/
+const commaize = (x) => x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+//#endregion
+//#region src/pluralize.ts
+var import_pluralize = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, pluralize) {
+		/* istanbul ignore else */
+		if (typeof require === "function" && typeof exports === "object" && typeof module === "object") module.exports = pluralize();
+		else if (typeof define === "function" && define.amd) define(function() {
+			return pluralize();
+		});
+		else root.pluralize = pluralize();
+	})(exports, function() {
+		var pluralRules = [];
+		var singularRules = [];
+		var uncountables = {};
+		var irregularPlurals = {};
+		var irregularSingles = {};
+		/**
+		* Sanitize a pluralization rule to a usable regular expression.
+		*
+		* @param  {(RegExp|string)} rule
+		* @return {RegExp}
+		*/
+		function sanitizeRule(rule) {
+			if (typeof rule === "string") return new RegExp("^" + rule + "$", "i");
+			return rule;
+		}
+		/**
+		* Pass in a word token to produce a function that can replicate the case on
+		* another word.
+		*
+		* @param  {string}   word
+		* @param  {string}   token
+		* @return {Function}
+		*/
+		function restoreCase(word, token) {
+			if (word === token) return token;
+			if (word === word.toLowerCase()) return token.toLowerCase();
+			if (word === word.toUpperCase()) return token.toUpperCase();
+			if (word[0] === word[0].toUpperCase()) return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+			return token.toLowerCase();
+		}
+		/**
+		* Interpolate a regexp string.
+		*
+		* @param  {string} str
+		* @param  {Array}  args
+		* @return {string}
+		*/
+		function interpolate(str, args) {
+			return str.replace(/\$(\d{1,2})/g, function(match, index) {
+				return args[index] || "";
+			});
+		}
+		/**
+		* Replace a word using a rule.
+		*
+		* @param  {string} word
+		* @param  {Array}  rule
+		* @return {string}
+		*/
+		function replace(word, rule) {
+			return word.replace(rule[0], function(match, index) {
+				var result = interpolate(rule[1], arguments);
+				if (match === "") return restoreCase(word[index - 1], result);
+				return restoreCase(match, result);
+			});
+		}
+		/**
+		* Sanitize a word by passing in the word and sanitization rules.
+		*
+		* @param  {string}   token
+		* @param  {string}   word
+		* @param  {Array}    rules
+		* @return {string}
+		*/
+		function sanitizeWord(token, word, rules) {
+			if (!token.length || uncountables.hasOwnProperty(token)) return word;
+			var len = rules.length;
+			while (len--) {
+				var rule = rules[len];
+				if (rule[0].test(word)) return replace(word, rule);
+			}
+			return word;
+		}
+		/**
+		* Replace a word with the updated word.
+		*
+		* @param  {Object}   replaceMap
+		* @param  {Object}   keepMap
+		* @param  {Array}    rules
+		* @return {Function}
+		*/
+		function replaceWord(replaceMap, keepMap, rules) {
+			return function(word) {
+				var token = word.toLowerCase();
+				if (keepMap.hasOwnProperty(token)) return restoreCase(word, token);
+				if (replaceMap.hasOwnProperty(token)) return restoreCase(word, replaceMap[token]);
+				return sanitizeWord(token, word, rules);
+			};
+		}
+		/**
+		* Check if a word is part of the map.
+		*/
+		function checkWord(replaceMap, keepMap, rules, bool) {
+			return function(word) {
+				var token = word.toLowerCase();
+				if (keepMap.hasOwnProperty(token)) return true;
+				if (replaceMap.hasOwnProperty(token)) return false;
+				return sanitizeWord(token, token, rules) === token;
+			};
+		}
+		/**
+		* Pluralize or singularize a word based on the passed in count.
+		*
+		* @param  {string}  word      The word to pluralize
+		* @param  {number}  count     How many of the word exist
+		* @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
+		* @return {string}
+		*/
+		function pluralize(word, count, inclusive) {
+			var pluralized = count === 1 ? pluralize.singular(word) : pluralize.plural(word);
+			return (inclusive ? count + " " : "") + pluralized;
+		}
+		/**
+		* Pluralize a word.
+		*
+		* @type {Function}
+		*/
+		pluralize.plural = replaceWord(irregularSingles, irregularPlurals, pluralRules);
+		/**
+		* Check if a word is plural.
+		*
+		* @type {Function}
+		*/
+		pluralize.isPlural = checkWord(irregularSingles, irregularPlurals, pluralRules);
+		/**
+		* Singularize a word.
+		*
+		* @type {Function}
+		*/
+		pluralize.singular = replaceWord(irregularPlurals, irregularSingles, singularRules);
+		/**
+		* Check if a word is singular.
+		*
+		* @type {Function}
+		*/
+		pluralize.isSingular = checkWord(irregularPlurals, irregularSingles, singularRules);
+		/**
+		* Add a pluralization rule to the collection.
+		*
+		* @param {(string|RegExp)} rule
+		* @param {string}          replacement
+		*/
+		pluralize.addPluralRule = function(rule, replacement) {
+			pluralRules.push([sanitizeRule(rule), replacement]);
+		};
+		/**
+		* Add a singularization rule to the collection.
+		*
+		* @param {(string|RegExp)} rule
+		* @param {string}          replacement
+		*/
+		pluralize.addSingularRule = function(rule, replacement) {
+			singularRules.push([sanitizeRule(rule), replacement]);
+		};
+		/**
+		* Add an uncountable word rule.
+		*
+		* @param {(string|RegExp)} word
+		*/
+		pluralize.addUncountableRule = function(word) {
+			if (typeof word === "string") {
+				uncountables[word.toLowerCase()] = true;
+				return;
+			}
+			pluralize.addPluralRule(word, "$0");
+			pluralize.addSingularRule(word, "$0");
+		};
+		/**
+		* Add an irregular word definition.
+		*
+		* @param {string} single
+		* @param {string} plural
+		*/
+		pluralize.addIrregularRule = function(single, plural) {
+			plural = plural.toLowerCase();
+			single = single.toLowerCase();
+			irregularSingles[single] = plural;
+			irregularPlurals[plural] = single;
+		};
+		/**
+		* Irregular rules.
+		*/
+		[
+			["I", "we"],
+			["me", "us"],
+			["he", "they"],
+			["she", "they"],
+			["them", "them"],
+			["myself", "ourselves"],
+			["yourself", "yourselves"],
+			["itself", "themselves"],
+			["herself", "themselves"],
+			["himself", "themselves"],
+			["themself", "themselves"],
+			["is", "are"],
+			["was", "were"],
+			["has", "have"],
+			["this", "these"],
+			["that", "those"],
+			["echo", "echoes"],
+			["dingo", "dingoes"],
+			["volcano", "volcanoes"],
+			["tornado", "tornadoes"],
+			["torpedo", "torpedoes"],
+			["genus", "genera"],
+			["viscus", "viscera"],
+			["stigma", "stigmata"],
+			["stoma", "stomata"],
+			["dogma", "dogmata"],
+			["lemma", "lemmata"],
+			["schema", "schemata"],
+			["anathema", "anathemata"],
+			["ox", "oxen"],
+			["axe", "axes"],
+			["die", "dice"],
+			["yes", "yeses"],
+			["foot", "feet"],
+			["eave", "eaves"],
+			["goose", "geese"],
+			["tooth", "teeth"],
+			["quiz", "quizzes"],
+			["human", "humans"],
+			["proof", "proofs"],
+			["carve", "carves"],
+			["valve", "valves"],
+			["looey", "looies"],
+			["thief", "thieves"],
+			["groove", "grooves"],
+			["pickaxe", "pickaxes"],
+			["passerby", "passersby"]
+		].forEach(function(rule) {
+			return pluralize.addIrregularRule(rule[0], rule[1]);
+		});
+		/**
+		* Pluralization rules.
+		*/
+		[
+			[/s?$/i, "s"],
+			[/[^\u0000-\u007F]$/i, "$0"],
+			[/([^aeiou]ese)$/i, "$1"],
+			[/(ax|test)is$/i, "$1es"],
+			[/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+			[/(e[mn]u)s?$/i, "$1s"],
+			[/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+			[/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+			[/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+			[/(seraph|cherub)(?:im)?$/i, "$1im"],
+			[/(her|at|gr)o$/i, "$1oes"],
+			[/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+			[/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+			[/sis$/i, "ses"],
+			[/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+			[/([^aeiouy]|qu)y$/i, "$1ies"],
+			[/([^ch][ieo][ln])ey$/i, "$1ies"],
+			[/(x|ch|ss|sh|zz)$/i, "$1es"],
+			[/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+			[/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+			[/(pe)(?:rson|ople)$/i, "$1ople"],
+			[/(child)(?:ren)?$/i, "$1ren"],
+			[/eaux$/i, "$0"],
+			[/m[ae]n$/i, "men"],
+			["thou", "you"]
+		].forEach(function(rule) {
+			return pluralize.addPluralRule(rule[0], rule[1]);
+		});
+		/**
+		* Singularization rules.
+		*/
+		[
+			[/s$/i, ""],
+			[/(ss)$/i, "$1"],
+			[/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+			[/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+			[/ies$/i, "y"],
+			[/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+			[/\b(mon|smil)ies$/i, "$1ey"],
+			[/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+			[/(seraph|cherub)im$/i, "$1"],
+			[/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+			[/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+			[/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+			[/(test)(?:is|es)$/i, "$1is"],
+			[/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+			[/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+			[/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+			[/(alumn|alg|vertebr)ae$/i, "$1a"],
+			[/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+			[/(matr|append)ices$/i, "$1ix"],
+			[/(pe)(rson|ople)$/i, "$1rson"],
+			[/(child)ren$/i, "$1"],
+			[/(eau)x?$/i, "$1"],
+			[/men$/i, "man"]
+		].forEach(function(rule) {
+			return pluralize.addSingularRule(rule[0], rule[1]);
+		});
+		/**
+		* Uncountable rules.
+		*/
+		[
+			"adulthood",
+			"advice",
+			"agenda",
+			"aid",
+			"aircraft",
+			"alcohol",
+			"ammo",
+			"analytics",
+			"anime",
+			"athletics",
+			"audio",
+			"bison",
+			"blood",
+			"bream",
+			"buffalo",
+			"butter",
+			"carp",
+			"cash",
+			"chassis",
+			"chess",
+			"clothing",
+			"cod",
+			"commerce",
+			"cooperation",
+			"corps",
+			"debris",
+			"diabetes",
+			"digestion",
+			"elk",
+			"energy",
+			"equipment",
+			"excretion",
+			"expertise",
+			"firmware",
+			"flounder",
+			"fun",
+			"gallows",
+			"garbage",
+			"graffiti",
+			"hardware",
+			"headquarters",
+			"health",
+			"herpes",
+			"highjinks",
+			"homework",
+			"housework",
+			"information",
+			"jeans",
+			"justice",
+			"kudos",
+			"labour",
+			"literature",
+			"machinery",
+			"mackerel",
+			"mail",
+			"media",
+			"mews",
+			"moose",
+			"music",
+			"mud",
+			"manga",
+			"news",
+			"only",
+			"personnel",
+			"pike",
+			"plankton",
+			"pliers",
+			"police",
+			"pollution",
+			"premises",
+			"rain",
+			"research",
+			"rice",
+			"salmon",
+			"scissors",
+			"series",
+			"sewage",
+			"shambles",
+			"shrimp",
+			"software",
+			"species",
+			"staff",
+			"swine",
+			"tennis",
+			"traffic",
+			"transportation",
+			"trout",
+			"tuna",
+			"wealth",
+			"welfare",
+			"whiting",
+			"wildebeest",
+			"wildlife",
+			"you",
+			/pok[eé]mon$/i,
+			/[^aeiou]ese$/i,
+			/deer$/i,
+			/fish$/i,
+			/measles$/i,
+			/o[iu]s$/i,
+			/pox$/i,
+			/sheep$/i
+		].forEach(pluralize.addUncountableRule);
+		return pluralize;
+	});
+})))(), 1);
+const patchedNpmPluralize = (noun, count, inclusive) => {
+	const match = /^(.*?)([_\W]+)$/.exec(noun);
+	if (match) {
+		const [__, mainNoun, append] = match;
+		return (0, import_pluralize.default)(mainNoun, count, inclusive) + append;
+	}
+	return (0, import_pluralize.default)(noun, count, inclusive);
 };
-var {
-  plural,
-  singular,
-  isSingular,
-  isPlural,
-  addPluralRule,
-  addSingularRule,
-  addIrregularRule,
-  addUncountableRule
-} = import_pluralize.default;
-var pluralize = (a, b, pluralForm) => {
-  let singleForm;
-  let number = null;
-  if ((0, import_art_core_ts_types.isNumber)(b)) {
-    if (!(0, import_art_core_ts_types.isString)(a)) {
-      throw new Error(`singleForm and pluralForm(optional) should be non-empty strings (inputs: ${JSON.stringify({ a, b, pluralForm })}`);
-    }
-    singleForm = a;
-    number = b;
-  } else if ((0, import_art_core_ts_types.isNumber)(a)) {
-    if (!(0, import_art_core_ts_types.isString)(b)) {
-      throw new Error(`singleForm and pluralForm(optional) should be non-empty strings (inputs: ${JSON.stringify({ a, b, pluralForm })}`);
-    }
-    singleForm = b;
-    number = a;
-  } else {
-    if (!(0, import_art_core_ts_types.isString)(a)) throw new Error(`singleForm and pluralForm(optional) should be non-empty strings (inputs: ${JSON.stringify({ a, b, pluralForm })}`);
-    singleForm = a;
-    number = null;
-  }
-  if (pluralForm) return `${number} ${number == 1 ? singleForm : pluralForm}`;
-  if (number != null) return patchedNpmPluralize(singleForm, number, true);
-  return patchedNpmPluralize(singleForm);
+const { plural, singular, isSingular, isPlural, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule } = import_pluralize.default;
+/**
+* Pluralize a word based on the passed in count. Call signatures:
+*
+* 1 input:
+* pluralize(singleForm: string)
+*
+* 2 inputS:
+* pluralize(singleForm: string, count: number)
+* pluralize(count: number, singleForm: string)
+*
+* 3 inputs:
+* pluralize(singleForm: string, count: number, pluralForm: string)
+* pluralize(count: number, singleForm: string, pluralForm: string)
+*
+* @param a: string | number - The word to pluralize if a string, or the count if a number
+* @param b: string | number - The count to pluralize the word by if a number, or the singleForm if a string
+* @param pluralForm: string - Explicitly provide the plural form of the word (optional)
+* @returns The pluralized word
+*/
+const pluralize = (a, b, pluralForm) => {
+	let singleForm;
+	let number = null;
+	if ((0, _art_suite_art_core_ts_types.isNumber)(b)) {
+		if (!(0, _art_suite_art_core_ts_types.isString)(a)) throw new Error(`singleForm and pluralForm(optional) should be non-empty strings (inputs: ${JSON.stringify({
+			a,
+			b,
+			pluralForm
+		})}`);
+		singleForm = a;
+		number = b;
+	} else if ((0, _art_suite_art_core_ts_types.isNumber)(a)) {
+		if (!(0, _art_suite_art_core_ts_types.isString)(b)) throw new Error(`singleForm and pluralForm(optional) should be non-empty strings (inputs: ${JSON.stringify({
+			a,
+			b,
+			pluralForm
+		})}`);
+		singleForm = b;
+		number = a;
+	} else {
+		if (!(0, _art_suite_art_core_ts_types.isString)(a)) throw new Error(`singleForm and pluralForm(optional) should be non-empty strings (inputs: ${JSON.stringify({
+			a,
+			b,
+			pluralForm
+		})}`);
+		singleForm = a;
+		number = null;
+	}
+	if (pluralForm) return `${number} ${number == 1 ? singleForm : pluralForm}`;
+	if (number != null) return patchedNpmPluralize(singleForm, number, true);
+	return patchedNpmPluralize(singleForm);
 };
-
-// src/randomString.ts
-var base62Characters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-var intRand = (max) => {
-  return Math.floor(Math.random() * max);
+//#endregion
+//#region src/randomString.ts
+const base62Characters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const intRand = (max) => {
+	return Math.floor(Math.random() * max);
 };
-var generateRandomBytes = (size) => typeof crypto?.getRandomValues === "function" ? crypto.getRandomValues(new Uint8Array(size)) : require("crypto").randomFillSync(new Uint8Array(size));
-var randomString = (length = 32, chars = base62Characters, randomNumbers) => {
-  const charsLength = chars.length;
-  let result = "";
-  if (randomNumbers) {
-    for (let i = 0; i < length; i++) result += chars[randomNumbers[i] % charsLength];
-  } else {
-    for (let i = 0; i < length; i++) result += chars[intRand(charsLength)];
-  }
-  return result;
+/**
+* Generates a Uint8Array of cryptographically secure random bytes.
+* @param size Number of bytes to generate.
+* @returns A Uint8Array filled with random bytes.
+*/
+const generateRandomBytes = (size) => typeof crypto?.getRandomValues === "function" ? crypto.getRandomValues(new Uint8Array(size)) : require("crypto").randomFillSync(new Uint8Array(size));
+const randomString = (length = 32, chars = base62Characters, randomNumbers) => {
+	const charsLength = chars.length;
+	let result = "";
+	if (randomNumbers) for (let i = 0; i < length; i++) result += chars[randomNumbers[i] % charsLength];
+	else for (let i = 0; i < length; i++) result += chars[intRand(charsLength)];
+	return result;
 };
-var cryptoRandomString = (length = 32, chars = base62Characters) => randomString(length, chars, generateRandomBytes(length).map((b) => b % chars.length));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  addIrregularRule,
-  addPluralRule,
-  addSingularRule,
-  addUncountableRule,
-  base62Characters,
-  commaize,
-  cryptoRandomString,
-  isPlural,
-  isSingular,
-  plural,
-  pluralize,
-  randomString,
-  singular
-});
+const cryptoRandomString = (length = 32, chars = base62Characters) => randomString(length, chars, generateRandomBytes(length).map((b) => b % chars.length));
+//#endregion
+exports.addIrregularRule = addIrregularRule;
+exports.addPluralRule = addPluralRule;
+exports.addSingularRule = addSingularRule;
+exports.addUncountableRule = addUncountableRule;
+exports.base62Characters = base62Characters;
+exports.commaize = commaize;
+exports.cryptoRandomString = cryptoRandomString;
+exports.isPlural = isPlural;
+exports.isSingular = isSingular;
+exports.plural = plural;
+exports.pluralize = pluralize;
+exports.randomString = randomString;
+exports.singular = singular;
+
 //# sourceMappingURL=index.cjs.map