@fibery/pluralize 1.0.1 → 1.0.2

package/lib/src/pluralize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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}
+ */
+export declare function pluralize(word: string, count?: number, inclusive?: boolean): string;
+export declare namespace pluralize {
+    var plural: (word: string) => string;
+    var isPlural: (word: string) => boolean;
+    var singular: (word: string) => string;
+    var isSingular: (word: string) => boolean;
+    var addPluralRule: (rule: string | RegExp, replacement: string) => void;
+    var addSingularRule: (rule: string | RegExp, replacement: string) => void;
+    var addUncountableRule: (word: string | RegExp) => void;
+    var addIrregularRule: (single: string, plural: string) => void;
+}

package/{src/pluralize.ts → lib/src/pluralize.js}

@@ -1,26 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluralize = pluralize;
 /* eslint-disable max-lines */
 // Rule storage - pluralize and singularize need to be run sequentially,
 // while other rules can be optimized using an object for instant lookups.
-const pluralRules: [RegExp, string][] = [];
-const singularRules: [RegExp, string][] = [];
-const uncountables: Record<string, boolean> = {};
-const irregularPlurals: Record<string, string> = {};
-const irregularSingles: Record<string, string> = {};
-
+const pluralRules = [];
+const singularRules = [];
+const uncountables = {};
+const irregularPlurals = {};
+const irregularSingles = {};
 /**
  * Sanitize a pluralization rule to a usable regular expression.
  *
  * @param  {(RegExp|string)} rule
  * @return {RegExp}
  */
-function sanitizeRule(rule: string | RegExp): RegExp {
-  if (typeof rule === "string") {
-    return new RegExp("^" + rule + "$", "i");
-  }
-
-  return rule;
+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.
@@ -29,31 +29,26 @@ function sanitizeRule(rule: string | RegExp): RegExp {
  * @param  {string}   token
  * @return {Function}
  */
-function restoreCase(word: string, token: string): string {
-  // Tokens are an exact match.
-  if (word === token) {
-    return token;
-  }
-
-  // Lower cased words. E.g. "hello".
-  if (word === word.toLowerCase()) {
+function restoreCase(word, token) {
+    // Tokens are an exact match.
+    if (word === token) {
+        return token;
+    }
+    // Lower cased words. E.g. "hello".
+    if (word === word.toLowerCase()) {
+        return token.toLowerCase();
+    }
+    // Upper cased words. E.g. "WHISKY".
+    if (word === word.toUpperCase()) {
+        return token.toUpperCase();
+    }
+    // Title cased words. E.g. "Title".
+    if (word[0] === word[0].toUpperCase()) {
+        return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+    }
+    // Lower cased words. E.g. "test".
     return token.toLowerCase();
-  }
-
-  // Upper cased words. E.g. "WHISKY".
-  if (word === word.toUpperCase()) {
-    return token.toUpperCase();
-  }
-
-  // Title cased words. E.g. "Title".
-  if (word[0] === word[0].toUpperCase()) {
-    return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
-  }
-
-  // Lower cased words. E.g. "test".
-  return token.toLowerCase();
 }
-
 /**
  * Interpolate a regexp string.
  *
@@ -61,12 +56,11 @@ function restoreCase(word: string, token: string): string {
  * @param  {Array}  args
  * @return {string}
  */
-function interpolate(str: string, args: string[]): string {
-  return str.replace(/\$(\d{1,2})/g, function (match, index) {
-    return args[index] || "";
-  });
+function interpolate(str, args) {
+    return str.replace(/\$(\d{1,2})/g, function (match, index) {
+        return args[index] || "";
+    });
 }
-
 /**
  * Replace a word using a rule.
  *
@@ -74,19 +68,16 @@ function interpolate(str: string, args: string[]): string {
  * @param  {Array}  rule
  * @return {string}
  */
-function replace(word: string, rule: [RegExp, string]): string {
-  return word.replace(rule[0], function (match, index) {
-    // eslint-disable-next-line prefer-rest-params
-    const result = interpolate(rule[1], arguments as unknown as string[]);
-
-    if (match === "") {
-      return restoreCase(word[index - 1], result);
-    }
-
-    return restoreCase(match, result);
-  });
+function replace(word, rule) {
+    return word.replace(rule[0], function (match, index) {
+        // eslint-disable-next-line prefer-rest-params
+        const 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.
  *
@@ -95,26 +86,21 @@ function replace(word: string, rule: [RegExp, string]): string {
  * @param  {Array}    rules
  * @return {string}
  */
-function sanitizeWord(token: string, word: string, rules: [RegExp, string][]): string {
-  // Empty string or doesn't need fixing.
-  if (!token.length || Object.keys(uncountables).some((key) => token.includes(key))) {
-    return word;
-  }
-
-  let len = rules.length;
-
-  // Iterate over the sanitization rules and use the first one to match.
-  while (len--) {
-    const rule = rules[len];
-
-    if (rule[0].test(word)) {
-      return replace(word, rule);
+function sanitizeWord(token, word, rules) {
+    // Empty string or doesn't need fixing.
+    if (!token.length || Object.keys(uncountables).some((key) => token.includes(key))) {
+        return word;
     }
-  }
-
-  return word;
+    let len = rules.length;
+    // Iterate over the sanitization rules and use the first one to match.
+    while (len--) {
+        const rule = rules[len];
+        if (rule[0].test(word)) {
+            return replace(word, rule);
+        }
+    }
+    return word;
 }
-
 /**
  * Replace a word with the updated word.
  *
@@ -123,52 +109,37 @@ function sanitizeWord(token: string, word: string, rules: [RegExp, string][]): s
  * @param  {Array}    rules
  * @return {Function}
  */
-function replaceWord(
-  replaceMap: Record<string, string>,
-  keepMap: Record<string, string>,
-  rules: [RegExp, string][]
-): (word: string) => string {
-  return function (word) {
-    // Get the correct token and case restoration functions.
-    const token = word.toLowerCase();
-
-    // Check against the keep object map.
-    if (Object.hasOwn(keepMap, token)) {
-      return restoreCase(word, token);
-    }
-
-    // Check against the replacement map for a direct word replacement.
-    if (Object.hasOwn(replaceMap, token)) {
-      return restoreCase(word, replaceMap[token]);
-    }
-
-    // Run all the rules against the word.
-    return sanitizeWord(token, word, rules);
-  };
+function replaceWord(replaceMap, keepMap, rules) {
+    return function (word) {
+        // Get the correct token and case restoration functions.
+        const token = word.toLowerCase();
+        // Check against the keep object map.
+        if (Object.hasOwn(keepMap, token)) {
+            return restoreCase(word, token);
+        }
+        // Check against the replacement map for a direct word replacement.
+        if (Object.hasOwn(replaceMap, token)) {
+            return restoreCase(word, replaceMap[token]);
+        }
+        // Run all the rules against the word.
+        return sanitizeWord(token, word, rules);
+    };
 }
-
 /**
  * Check if a word is part of the map.
  */
-function checkWord(
-  replaceMap: Record<string, string>,
-  keepMap: Record<string, string>,
-  rules: [RegExp, string][]
-): (word: string) => boolean {
-  return function (word) {
-    const token = word.toLowerCase();
-
-    if (Object.hasOwn(keepMap, token)) {
-      return true;
-    }
-    if (Object.hasOwn(replaceMap, token)) {
-      return false;
-    }
-
-    return sanitizeWord(token, token, rules) === token;
-  };
+function checkWord(replaceMap, keepMap, rules) {
+    return function (word) {
+        const token = word.toLowerCase();
+        if (Object.hasOwn(keepMap, token)) {
+            return true;
+        }
+        if (Object.hasOwn(replaceMap, token)) {
+            return false;
+        }
+        return sanitizeWord(token, token, rules) === token;
+    };
 }
-
 /**
  * Pluralize or singularize a word based on the passed in count.
  *
@@ -177,100 +148,87 @@ function checkWord(
  * @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
  * @return {string}
  */
-export function pluralize(word: string, count?: number, inclusive?: boolean): string {
-  if (count === undefined) {
-    return pluralize.plural(word);
-  }
-  const pluralized = count === 1 ? pluralize.singular(word) : pluralize.plural(word);
-
-  return (inclusive ? count + " " : "") + pluralized;
+function pluralize(word, count, inclusive) {
+    if (count === undefined) {
+        return pluralize.plural(word);
+    }
+    const 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: string | RegExp, replacement: string) {
-  pluralRules.push([sanitizeRule(rule), 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: string | RegExp, replacement: string) {
-  singularRules.push([sanitizeRule(rule), replacement]);
+pluralize.addSingularRule = function (rule, replacement) {
+    singularRules.push([sanitizeRule(rule), replacement]);
 };
-
 /**
  * Add an uncountable word rule.
  *
  * @param {(string|RegExp)} word
  */
-pluralize.addUncountableRule = function (word: string | RegExp) {
-  if (typeof word === "string") {
-    uncountables[word.toLowerCase()] = true;
-    return;
-  }
-
-  // Set singular and plural references for the word.
-  pluralize.addPluralRule(word, "$0");
-  pluralize.addSingularRule(word, "$0");
+pluralize.addUncountableRule = function (word) {
+    if (typeof word === "string") {
+        uncountables[word.toLowerCase()] = true;
+        return;
+    }
+    // Set singular and plural references for the word.
+    pluralize.addPluralRule(word, "$0");
+    pluralize.addSingularRule(word, "$0");
 };
-
 /**
  * Add an irregular word definition.
  *
  * @param {string} single
  * @param {string} plural
  */
-pluralize.addIrregularRule = function (single: string, plural: string) {
-  // eslint-disable-next-line no-param-reassign
-  plural = plural.toLowerCase();
-  // eslint-disable-next-line no-param-reassign
-  single = single.toLowerCase();
-
-  irregularSingles[single] = plural;
-  irregularPlurals[plural] = single;
+pluralize.addIrregularRule = function (single, plural) {
+    // eslint-disable-next-line no-param-reassign
+    plural = plural.toLowerCase();
+    // eslint-disable-next-line no-param-reassign
+    single = single.toLowerCase();
+    irregularSingles[single] = plural;
+    irregularPlurals[plural] = single;
 };
-
 /**
  * Irregular rules.
  */
-(
-  [
+[
     // Pronouns.
     ["I", "we"],
     ["me", "us"],
@@ -328,16 +286,13 @@ pluralize.addIrregularRule = function (single: string, plural: string) {
     ["pickaxe", "pickaxes"],
     ["passerby", "passersby"],
     ["canvas", "canvases"],
-  ] as const
-).forEach(function (rule) {
-  return pluralize.addIrregularRule(rule[0], rule[1]);
+].forEach(function (rule) {
+    return pluralize.addIrregularRule(rule[0], rule[1]);
 });
-
 /**
  * Pluralization rules.
  */
-(
-  [
+[
     [/s?$/i, "s"],
     // eslint-disable-next-line no-control-regex
     [/[^\u0000-\u007F]$/i, "$0"],
@@ -351,8 +306,8 @@ pluralize.addIrregularRule = function (single: string, plural: string) {
     [/(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",
+        /(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"],
@@ -367,16 +322,13 @@ pluralize.addIrregularRule = function (single: string, plural: string) {
     [/eaux$/i, "$0"],
     [/m[ae]n$/i, "men"],
     ["thou", "you"],
-  ] as const
-).forEach(function (rule) {
-  return pluralize.addPluralRule(rule[0], rule[1]);
+].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"],
@@ -384,8 +336,8 @@ pluralize.addIrregularRule = function (single: string, plural: string) {
     [/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(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"],
@@ -404,116 +356,114 @@ pluralize.addIrregularRule = function (single: string, plural: string) {
     [/(child)ren$/i, "$1"],
     [/(eau)x?$/i, "$1"],
     [/men$/i, "man"],
-  ] as const
-).forEach(function (rule) {
-  return pluralize.addSingularRule(rule[0], rule[1]);
+].forEach(function (rule) {
+    return pluralize.addSingularRule(rule[0], rule[1]);
 });
-
 /**
  * Uncountable rules.
  */
 [
-  // 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,
+    // 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,
 ].forEach(pluralize.addUncountableRule);