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

package/dist/index.cjs

@@ -1,487 +1,131 @@
-"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 __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 pluralize_esm = require("pluralize-esm");
+pluralize_esm = __toESM(pluralize_esm);
+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
+const patchedNpmPluralize = (noun, count, inclusive) => {
+	const match = /^(.*?)([_\W]+)$/.exec(noun);
+	if (match) {
+		const [__, mainNoun, append] = match;
+		return (0, pluralize_esm.default)(mainNoun, count, inclusive) + append;
+	}
+	return (0, pluralize_esm.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 } = pluralize_esm.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) => crypto.getRandomValues(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