@bccampus/utils 0.1.1 → 0.2.1

package/dist/path/normalize.js

@@ -0,0 +1,32 @@
+import { fileURLToPath } from "./file-url-to-path.js";
+const defaultOptions = {
+  leadingSlash: "always",
+  trailingSlash: "never"
+};
+const windowsPathSepRegExp = /[\\]+/g;
+const unixPathSepRegExp = /[/]+/g;
+const windowsDriveRegExp = /^[a-zA-Z1-9_-]+:\//;
+const fileProtocolRegExp = /^file:\/\//;
+const leadingSlashRegExp = /^\//g;
+const trailingSlashRegExp = /\/$/g;
+function normalize(path, options) {
+  const conf = { ...defaultOptions, ...options };
+  const sep = "\\";
+  let normalPath = path.trim();
+  if (fileProtocolRegExp.test(normalPath))
+    normalPath = fileURLToPath(normalPath);
+  normalPath = normalPath.replace(windowsPathSepRegExp, sep).replace(unixPathSepRegExp, sep);
+  if (conf.leadingSlash !== "as-is") {
+    normalPath = normalPath.replace(leadingSlashRegExp, "");
+    if (conf.leadingSlash === "always" && !windowsDriveRegExp.test(normalPath))
+      normalPath = `${sep}${normalPath}`;
+  }
+  if (conf.trailingSlash !== "as-is") {
+    normalPath = normalPath.replace(trailingSlashRegExp, "");
+    if (conf.trailingSlash === "always") normalPath = `${normalPath}${sep}`;
+  }
+  return normalPath;
+}
+export {
+  normalize
+};

package/dist/set/difference.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function difference(setA, setB) {
+  const _difference = new Set(setA);
+  for (const elem of setB) {
+    _difference.delete(elem);
+  }
+  return _difference;
+}
+exports.difference = difference;

package/dist/set/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const set_union = require("./union.cjs");
+const set_intersection = require("./intersection.cjs");
+const set_isSuperset = require("./is-superset.cjs");
+const set_difference = require("./difference.cjs");
+const set_symmetricDifference = require("./symmetric-difference.cjs");
+exports.union = set_union.union;
+exports.intersection = set_intersection.intersection;
+exports.isSuperset = set_isSuperset.isSuperset;
+exports.difference = set_difference.difference;
+exports.symmetricDifference = set_symmetricDifference.symmetricDifference;

package/dist/set/intersection.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function intersection(setA, setB) {
+  const _setA = setA instanceof Set ? setA : new Set(setA);
+  const _intersection = /* @__PURE__ */ new Set();
+  for (const elem of setB) {
+    if (_setA.has(elem)) {
+      _intersection.add(elem);
+    }
+  }
+  return _intersection;
+}
+exports.intersection = intersection;

package/dist/set/is-superset.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isSuperset(set, subset) {
+  const _set = set instanceof Set ? set : new Set(set);
+  for (const elem of subset) {
+    if (!_set.has(elem)) {
+      return false;
+    }
+  }
+  return true;
+}
+exports.isSuperset = isSuperset;

package/dist/set/symmetric-difference.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function symmetricDifference(setA, setB) {
+  const _difference = new Set(setA);
+  for (const elem of setB) {
+    if (_difference.has(elem)) {
+      _difference.delete(elem);
+    } else {
+      _difference.add(elem);
+    }
+  }
+  return _difference;
+}
+exports.symmetricDifference = symmetricDifference;

package/dist/set/union.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function union(setA, setB) {
+  const _union = new Set(setA);
+  for (const elem of setB) {
+    _union.add(elem);
+  }
+  return _union;
+}
+exports.union = union;

package/dist/string/capitalize.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const capitalize = (s) => s[0].toUpperCase() + s.slice(1);
+exports.capitalize = capitalize;

package/dist/string/index.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const string_truncate = require("./truncate.cjs");
+const string_trim = require("./trim.cjs");
+const string_stripHtmlTags = require("./strip-html-tags.cjs");
+const string_capitalize = require("./capitalize.cjs");
+const string_toSentenceCase = require("./to-sentence-case.cjs");
+const string_toInt = require("./to-int.cjs");
+exports.truncate = string_truncate.truncate;
+exports.trim = string_trim.trim;
+exports.stripHtmlTags = string_stripHtmlTags.stripHtmlTags;
+exports.capitalize = string_capitalize.capitalize;
+exports.toSentenceCase = string_toSentenceCase.toSentenceCase;
+exports.stringToInt = string_toInt.stringToInt;

package/dist/string/normalize.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function normalize(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+exports.normalize = normalize;

package/dist/string/normalize.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Trims white spaces and
+ * replaces multiple white space characters with a single space
+ */
+export declare function normalize(text: string): string;

package/dist/string/normalize.js

@@ -0,0 +1,6 @@
+function normalize(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+export {
+  normalize
+};

package/dist/string/pluralize/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const string_pluralize_pluralize = require("./pluralize.cjs");
+const pluralize = new string_pluralize_pluralize.Pluralize();
+exports.Pluralize = string_pluralize_pluralize.Pluralize;
+exports.pluralize = pluralize;

package/dist/string/pluralize/pluralize.cjs

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const string_pluralize_rules_irregular = require("./rules/irregular.cjs");
+const string_pluralize_rules_pluralization = require("./rules/pluralization.cjs");
+const string_pluralize_rules_singularization = require("./rules/singularization.cjs");
+const string_pluralize_rules_uncountable = require("./rules/uncountable.cjs");
+const TagIndexRegExp = /\$(\d{1,2})/g;
+class Pluralize {
+  // Rule storage - pluralize and singularize need to be run sequentially,
+  // while other rules can be optimized using an object for instant lookups.
+  pluralRules = [];
+  singularRules = [];
+  uncountables = {};
+  irregularPlurals = {};
+  irregularSingles = {};
+  constructor() {
+    for (let index = 0; index < string_pluralize_rules_irregular.IRREGULAR_WORDS.length; index += 1) {
+      this.addIrregularRule(
+        string_pluralize_rules_irregular.IRREGULAR_WORDS[index][0],
+        string_pluralize_rules_irregular.IRREGULAR_WORDS[index][1]
+      );
+    }
+    for (let index = 0; index < string_pluralize_rules_pluralization.PLURALIZATION_RULES.length; index += 1) {
+      this.addPluralRule(
+        string_pluralize_rules_pluralization.PLURALIZATION_RULES[index][0],
+        string_pluralize_rules_pluralization.PLURALIZATION_RULES[index][1]
+      );
+    }
+    for (let index = 0; index < string_pluralize_rules_singularization.SINGULARIZATION_RULES.length; index += 1) {
+      this.addSingularRule(
+        string_pluralize_rules_singularization.SINGULARIZATION_RULES[index][0],
+        string_pluralize_rules_singularization.SINGULARIZATION_RULES[index][1]
+      );
+    }
+    for (let index = 0; index < string_pluralize_rules_uncountable.UNCOUNTABLE_WORDS.length; index += 1) {
+      this.addUncountableRule(string_pluralize_rules_uncountable.UNCOUNTABLE_WORDS[index]);
+    }
+  }
+  /**
+   * Add a pluralization rule to the collection.
+   */
+  addPluralRule(rule, replacement) {
+    this.pluralRules.push([this.sanitizeRule(rule), replacement]);
+  }
+  /**
+   * Add a singularization rule to the collection.
+   */
+  addSingularRule(rule, replacement) {
+    this.singularRules.push([this.sanitizeRule(rule), replacement]);
+  }
+  /**
+   * Add an uncountable word rule.
+   */
+  addUncountableRule(word) {
+    if (typeof word === "string") {
+      this.uncountables[word.toLowerCase()] = true;
+      return;
+    }
+    this.addPluralRule(word, "$0");
+    this.addSingularRule(word, "$0");
+  }
+  /**
+   * Add an irregular word definition.
+   *
+   * @param {string} single
+   * @param {string} plural
+   */
+  addIrregularRule(single, plural) {
+    plural = plural.toLowerCase();
+    single = single.toLowerCase();
+    this.irregularSingles[single] = plural;
+    this.irregularPlurals[plural] = single;
+  }
+  /**
+   * Sanitize a pluralization rule to a usable regular expression.
+   */
+  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.
+   */
+  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}
+   */
+  interpolate(str, args) {
+    return str.replace(TagIndexRegExp, (match, index) => {
+      return args[index] || "";
+    });
+  }
+  /**
+   * Replace a word using a rule.
+   */
+  replace(word, rule) {
+    return word.replace(rule[0], (match, index, ...args) => {
+      const result = this.interpolate(rule[1], args);
+      if (match === "") {
+        return this.restoreCase(word[index - 1], result);
+      }
+      return this.restoreCase(match, result);
+    });
+  }
+  /**
+   * Sanitize a word by passing in the word and sanitization rules.
+   */
+  sanitizeWord(token, word, rules) {
+    if (!token.length || this.uncountables[token]) {
+      return word;
+    }
+    let len = rules.length;
+    while (len--) {
+      const rule = rules[len];
+      if (typeof rule[0] === "string" || rule[0].test(word))
+        return this.replace(word, rule);
+    }
+    return word;
+  }
+  /**
+   * Replace a word with the updated word.
+   */
+  old_replaceWord(replaceMap, keepMap, rules) {
+    return (word) => {
+      const token = word.toLowerCase();
+      if (keepMap[token]) {
+        return this.restoreCase(word, token);
+      }
+      if (replaceMap[token]) {
+        return this.restoreCase(word, replaceMap[token]);
+      }
+      return this.sanitizeWord(token, word, rules);
+    };
+  }
+  /**
+   * Replace a word with the updated word.
+   */
+  replaceWord(word, direction) {
+    const replaceMap = direction === "SingularToPlural" ? this.irregularSingles : this.irregularPlurals;
+    const keepMap = direction === "SingularToPlural" ? this.irregularPlurals : this.irregularSingles;
+    const rules = direction === "SingularToPlural" ? this.pluralRules : this.singularRules;
+    const token = word.toLowerCase();
+    if (keepMap[token]) {
+      return this.restoreCase(word, token);
+    }
+    if (replaceMap[token]) {
+      return this.restoreCase(word, replaceMap[token]);
+    }
+    return this.sanitizeWord(token, word, rules);
+  }
+  /**
+   * Check if a word is part of the map.
+   */
+  checkWord(word, reason) {
+    const replaceMap = reason === "Plurality" ? this.irregularSingles : this.irregularPlurals;
+    const keepMap = reason === "Plurality" ? this.irregularPlurals : this.irregularSingles;
+    const rules = reason === "Singularity" ? this.pluralRules : this.singularRules;
+    const token = word.toLowerCase();
+    if (keepMap[token]) return true;
+    if (replaceMap[token]) return false;
+    return this.sanitizeWord(token, token, rules) === token;
+  }
+  /**
+   * Pluralize or singularize a word based on the passed in count.
+   */
+  pluralize(word, count, inclusive) {
+    const pluralized = count === 1 ? this.singular(word) : this.plural(word);
+    return (inclusive ? `${count} ` : "") + pluralized;
+  }
+  /**
+   * Pluralize a word.
+   */
+  plural(singularWord) {
+    return this.replaceWord(singularWord, "SingularToPlural");
+  }
+  /**
+   * Check if a word is plural.
+   */
+  isPlural(word) {
+    this.checkWord(word, "Plurality");
+  }
+  /**
+   * Singularize a word.
+   */
+  singular(pluralWord) {
+    return this.replaceWord(pluralWord, "PluralToSingular");
+  }
+  /**
+   * Check if a word is singular.
+   */
+  isSingular(word) {
+    this.checkWord(word, "Singularity");
+  }
+}
+exports.Pluralize = Pluralize;

package/dist/string/pluralize/rules/index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const string_pluralize_rules_irregular = require("./irregular.cjs");
+const string_pluralize_rules_pluralization = require("./pluralization.cjs");
+const string_pluralize_rules_singularization = require("./singularization.cjs");
+const string_pluralize_rules_uncountable = require("./uncountable.cjs");
+exports.IRREGULAR_WORDS = string_pluralize_rules_irregular.IRREGULAR_WORDS;
+exports.PLURALIZATION_RULES = string_pluralize_rules_pluralization.PLURALIZATION_RULES;
+exports.SINGULARIZATION_RULES = string_pluralize_rules_singularization.SINGULARIZATION_RULES;
+exports.UNCOUNTABLE_WORDS = string_pluralize_rules_uncountable.UNCOUNTABLE_WORDS;

package/dist/string/pluralize/rules/irregular.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const IRREGULAR_WORDS = [
+  // 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"],
+  ["my", "our"],
+  ["its", "their"],
+  ["his", "their"],
+  ["her", "their"],
+  // 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"],
+  ["canvas", "canvases"]
+];
+exports.IRREGULAR_WORDS = IRREGULAR_WORDS;

package/dist/string/pluralize/rules/pluralization.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const PLURALIZATION_RULES = [
+  [/s?$/i, "s"],
+  [/[^\u0000-\u007F]$/, "$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"]
+];
+exports.PLURALIZATION_RULES = PLURALIZATION_RULES;

package/dist/string/pluralize/rules/singularization.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const 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"],
+  [/(dg|ss|ois|lk|ok|wn|mb|th|ch|ec|oal|is|ck|ix|sser|ts|wb)ies$/i, "$1ie"],
+  [
+    /\b(l|(?:neck|cross|hog|aun)?t|coll|faer|food|gen|goon|group|hipp|junk|vegg|(?:pork)?p|charl|calor|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"]
+];
+exports.SINGULARIZATION_RULES = SINGULARIZATION_RULES;

package/dist/string/pluralize/rules/uncountable.cjs

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const UNCOUNTABLE_WORDS = [
+  // 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",
+  "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
+];
+exports.UNCOUNTABLE_WORDS = UNCOUNTABLE_WORDS;

package/dist/string/pluralize/types.cjs

@@ -0,0 +1 @@
+"use strict";