@mythpe/quasar-ui-qui 0.1.93 → 0.1.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mythpe/quasar-ui-qui",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "description": "MyTh Quasar UI Kit App Extension",
   "author": {
     "name": "MyTh Ahmed Faiz",

package/src/utils/Str.ts

@@ -6,7 +6,7 @@
  * Github: https://github.com/mythpe
  */
 
-import { plural, singular } from 'pluralize'
+import __pluralize from './__pluralize'
 import { camelCase, capitalCase, dotCase, kebabCase, pascalCase, snakeCase } from 'change-case'
 
 export const Str = {
@@ -92,10 +92,10 @@ export const Str = {
     return string ? dotCase(string?.toString() || '') : ''
   },
   pluralize (string?: unknown): string {
-    return string ? plural(string?.toString() || '') : ''
+    return string ? __pluralize.plural(string?.toString() || '') : ''
   },
   singular (string?: unknown): string {
-    return string ? singular(string?.toString() || '') : ''
+    return string ? __pluralize.singular(string?.toString() || '') : ''
   },
   flipChoice (data: Record<any, any>) {
     const f: Record<any, any> = {}

package/src/utils/__pluralize.js

@@ -0,0 +1,510 @@
+/* global define */
+
+(function (root, pluralize) {
+  /* istanbul ignore else */
+  if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
+    // Node.
+    // module.exports = pluralize()
+    module.exports = {
+      pluralize: pluralize(),
+      default: pluralize()
+    }
+  } else if (typeof define === 'function' && define.amd) {
+    // AMD, registers as an anonymous module.
+    define(function () {
+      return pluralize()
+    })
+  } else {
+    // Browser global.
+    root.pluralize = pluralize()
+  }
+})(this, function () {
+  // Rule storage - pluralize and singularize need to be run sequentially,
+  // while other rules can be optimized using an object for instant lookups.
+  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) {
+    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) {
+    // 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()
+  }
+
+  /**
+   * 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) {
+      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.
+   *
+   * @param  {string}   token
+   * @param  {string}   word
+   * @param  {Array}    rules
+   * @return {string}
+   */
+  function sanitizeWord (token, word, rules) {
+    // Empty string or doesn't need fixing.
+    if (!token.length || uncountables.hasOwnProperty(token)) {
+      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.
+   *
+   * @param  {Object}   replaceMap
+   * @param  {Object}   keepMap
+   * @param  {Array}    rules
+   * @return {Function}
+   */
+  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 (keepMap.hasOwnProperty(token)) {
+        return restoreCase(word, token)
+      }
+
+      // Check against the replacement map for a direct word replacement.
+      if (replaceMap.hasOwnProperty(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, keepMap, rules, bool) {
+    return function (word) {
+      const 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) {
+    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, 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
+    }
+
+    // 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, plural) {
+    plural = plural.toLowerCase()
+    single = single.toLowerCase()
+
+    irregularSingles[single] = plural
+    irregularPlurals[plural] = single
+  }
+
+  /**
+   * Irregular rules.
+   */
+    [
+    // 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 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.
+   */
+    [
+    // 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(pluralize.addUncountableRule)
+
+  return pluralize
+})
+
+import pluralize from 'pluralize'
+export default pluralize

package/src/utils/copy_pluralize.js

@@ -1,241 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-
-// __pluralize.js
-
-// Rule storage - __pluralize and singularize need to be run sequentially,
-// while other rules can be optimized using an object for instant lookups.
-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) {
-  return typeof rule === 'string' ? new RegExp(`^${rule}$`, 'i') : 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 {string}
- */
-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, (match, index) => 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], (match, ...args) => {
-    const result = interpolate(rule[1], args)
-    return match === '' ? restoreCase(word[args[args.length - 2] - 1], result) : 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
-
-  for (let i = rules.length - 1; i >= 0; i--) {
-    const rule = rules[i]
-    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) {
-    const 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) {
-  return function (word) {
-    const 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) {
-  const pluralized = count === 1 ? __pluralize.singular(word) : __pluralize.plural(word)
-  return (inclusive ? `${count} ` : '') + pluralized
-}
-
-// Attach methods to __pluralize function
-__pluralize.plural = replaceWord(irregularSingles, irregularPlurals, pluralRules)
-__pluralize.isPlural = checkWord(irregularSingles, irregularPlurals, pluralRules)
-__pluralize.singular = replaceWord(irregularPlurals, irregularSingles, singularRules)
-__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) {
-  const pluralLower = plural.toLowerCase()
-  const singleLower = single.toLowerCase()
-  irregularSingles[singleLower] = pluralLower
-  irregularPlurals[pluralLower] = singleLower
-};
-
-// 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(([single, plural]) => __pluralize.addIrregularRule(single, plural));
-
-// 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(([rule, replacement]) => __pluralize.addPluralRule(rule, replacement));
-
-// 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(([rule, replacement]) => __pluralize.addSingularRule(rule, replacement));
-
-// 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)
-
-export default __pluralize