@warp-drive/utilities 5.6.0-alpha.11

package/dist/inflect-C1laviCe.js

@@ -0,0 +1,376 @@
+import { LRUCache, dasherize as dasherize$1, STRING_DASHERIZE_CACHE } from '@warp-drive/core/utils/string';
+import { InflectionRuleDefaults as defaultRules } from "./-private.js";
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+
+// eslint-disable-next-line no-useless-escape
+const STRING_CAMELIZE_REGEXP_1 = /(\-|\_|\.|\s)+(.)?/g;
+const STRING_CAMELIZE_REGEXP_2 = /(^|\/)([A-Z])/g;
+const CAMELIZE_CACHE = new LRUCache(key => key.replace(STRING_CAMELIZE_REGEXP_1, (_match, _separator, chr) => chr ? chr.toUpperCase() : '').replace(STRING_CAMELIZE_REGEXP_2, (match /*, separator, chr */) => match.toLowerCase()));
+const STRING_UNDERSCORE_REGEXP_1 = /([a-z\d])([A-Z]+)/g;
+// eslint-disable-next-line no-useless-escape
+const STRING_UNDERSCORE_REGEXP_2 = /\-|\s+/g;
+const UNDERSCORE_CACHE = new LRUCache(str => str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase());
+const STRING_CAPITALIZE_REGEXP = /(^|\/)([a-z\u00C0-\u024F])/g;
+const CAPITALIZE_CACHE = new LRUCache(str => str.replace(STRING_CAPITALIZE_REGEXP, (match /*, separator, chr */) => match.toUpperCase()));
+
+/**
+ * Replaces underscores, spaces, or camelCase with dashes.
+ *
+ * ```js
+ * import { dasherize } from '@warp-drive/utilities/string';
+ *
+ * dasherize('innerHTML');                // 'inner-html'
+ * dasherize('action_name');              // 'action-name'
+ * dasherize('css-class-name');           // 'css-class-name'
+ * dasherize('my favorite items');        // 'my-favorite-items'
+ * dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+ * ```
+ *
+ * @public
+ * @param {String} str
+ * @return {String}
+ * @since 4.13.0
+ */
+const dasherize = dasherize$1;
+
+/**
+ * Returns the lowerCamelCase form of a string.
+ *
+ * ```js
+ * import { camelize } from '@warp-drive/utilities/string';
+ *
+ * camelize('innerHTML');                   // 'innerHTML'
+ * camelize('action_name');                 // 'actionName'
+ * camelize('css-class-name');              // 'cssClassName'
+ * camelize('my favorite items');           // 'myFavoriteItems'
+ * camelize('My Favorite Items');           // 'myFavoriteItems'
+ * camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'
+ * ```
+ *
+ * @public
+ * @param {String} str
+ * @return {String}
+ * @since 4.13.0
+ */
+function camelize(str) {
+  return CAMELIZE_CACHE.get(str);
+}
+
+/**
+ * Returns the lower\_case\_and\_underscored form of a string.
+ *
+ * ```js
+ * import { underscore } from '@warp-drive/utilities/string';
+ *
+ * underscore('innerHTML');                 // 'inner_html'
+ * underscore('action_name');               // 'action_name'
+ * underscore('css-class-name');            // 'css_class_name'
+ * underscore('my favorite items');         // 'my_favorite_items'
+ * underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'
+ * ```
+ *
+ * @public
+ * @param {String} str
+ * @return {String}
+ * @since 4.13.0
+ */
+function underscore(str) {
+  return UNDERSCORE_CACHE.get(str);
+}
+
+/**
+ * Returns the Capitalized form of a string
+ *
+ * ```js
+ * import { capitalize } from '@warp-drive/utilities/string';
+ *
+ * capitalize('innerHTML')                 // 'InnerHTML'
+ * capitalize('action_name')               // 'Action_name'
+ * capitalize('css-class-name')            // 'Css-class-name'
+ * capitalize('my favorite items')         // 'My favorite items'
+ * capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'
+ * ```
+ *
+ * @public
+ * @param {String} str
+ * @return {String}
+ * @since 4.13.0
+ */
+function capitalize(str) {
+  return CAPITALIZE_CACHE.get(str);
+}
+
+/**
+ * Sets the maximum size of the LRUCache for all string transformation functions.
+ * The default size is 10,000.
+ *
+ * @public
+ * @param {Number} size
+ * @return {void}
+ * @since 4.13.0
+ */
+function setMaxLRUCacheSize(size) {
+  CAMELIZE_CACHE.size = size;
+  UNDERSCORE_CACHE.size = size;
+  CAPITALIZE_CACHE.size = size;
+  STRING_DASHERIZE_CACHE.size = size;
+}
+const BLANK_REGEX = /^\s*$/;
+const LAST_WORD_DASHED_REGEX = /([\w/-]+[_/\s-])([a-z\d]+$)/;
+const LAST_WORD_CAMELIZED_REGEX = /([\w/\s-]+)([A-Z][a-z\d]*$)/;
+const CAMELIZED_REGEX = /[A-Z][a-z\d]*$/;
+const SINGULARS = new LRUCache(word => {
+  return _singularize(word);
+});
+const PLURALS = new LRUCache(word => {
+  return _pluralize(word);
+});
+const UNCOUNTABLE = new Set(defaultRules.uncountable);
+const IRREGULAR = new Map();
+const INVERSE_IRREGULAR = new Map();
+const SINGULAR_RULES = new Map(defaultRules.singular.reverse());
+const PLURAL_RULES = new Map(defaultRules.plurals.reverse());
+
+/**
+ * Marks a word as uncountable. Uncountable words are not pluralized
+ * or singularized.
+ *
+ * @public
+ * @param {String} word
+ * @return {void}
+ * @since 4.13.0
+ */
+function uncountable(word) {
+  UNCOUNTABLE.add(word.toLowerCase());
+}
+
+/**
+ * Marks a list of words as uncountable. Uncountable words are not pluralized
+ * or singularized.
+ *
+ * @public
+ * @param {Array<String>} uncountables
+ * @return {void}
+ * @since 4.13.0
+ */
+function loadUncountable(uncountables) {
+  uncountables.forEach(word => {
+    uncountable(word);
+  });
+}
+
+/**
+ * Marks a word as irregular. Irregular words have unique
+ * pluralization and singularization rules.
+ *
+ * @public
+ * @param {String} single
+ * @param {String} plur
+ * @return {void}
+ * @since 4.13.0
+ */
+function irregular(single, plur) {
+  //pluralizing
+  IRREGULAR.set(single.toLowerCase(), plur);
+  IRREGULAR.set(plur.toLowerCase(), plur);
+
+  //singularizing
+  INVERSE_IRREGULAR.set(plur.toLowerCase(), single);
+  INVERSE_IRREGULAR.set(single.toLowerCase(), single);
+}
+
+/**
+ * Marks a list of word pairs as irregular. Irregular words have unique
+ * pluralization and singularization rules.
+ *
+ * @public
+ * @param {Array<Array<String>>} irregularPairs
+ * @return {void}
+ * @since 4.13.0
+ */
+function loadIrregular(irregularPairs) {
+  irregularPairs.forEach(pair => {
+    //pluralizing
+    IRREGULAR.set(pair[0].toLowerCase(), pair[1]);
+    IRREGULAR.set(pair[1].toLowerCase(), pair[1]);
+
+    //singularizing
+    INVERSE_IRREGULAR.set(pair[1].toLowerCase(), pair[0]);
+    INVERSE_IRREGULAR.set(pair[0].toLowerCase(), pair[0]);
+  });
+}
+loadIrregular(defaultRules.irregularPairs);
+
+/**
+ * Clears the caches for singularize and pluralize.
+ *
+ * @public
+ * @return {void}
+ * @since 4.13.0
+ */
+function clear() {
+  SINGULARS.clear();
+  PLURALS.clear();
+}
+
+/**
+ * Resets the inflection rules to the defaults.
+ *
+ * @public
+ * @return {void}
+ * @since 4.13.0
+ */
+function resetToDefaults() {
+  clearRules();
+  defaultRules.uncountable.forEach(v => UNCOUNTABLE.add(v));
+  defaultRules.singular.forEach(v => SINGULAR_RULES.set(v[0], v[1]));
+  defaultRules.plurals.forEach(v => PLURAL_RULES.set(v[0], v[1]));
+  loadIrregular(defaultRules.irregularPairs);
+}
+
+/**
+ * Clears all inflection rules
+ * and resets the caches for singularize and pluralize.
+ *
+ * @public
+ * @return {void}
+ * @since 4.13.0
+ */
+function clearRules() {
+  SINGULARS.clear();
+  PLURALS.clear();
+  UNCOUNTABLE.clear();
+  IRREGULAR.clear();
+  INVERSE_IRREGULAR.clear();
+  SINGULAR_RULES.clear();
+  PLURAL_RULES.clear();
+}
+
+/**
+ * Singularizes a word.
+ *
+ * @public
+ * @param {String} word
+ * @return {String}
+ * @since 4.13.0
+ */
+function singularize(word) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`singularize expects to receive a non-empty string`);
+    }
+  })(typeof word === 'string' && word.length > 0) : {};
+  if (!word) return '';
+  return SINGULARS.get(word);
+}
+
+/**
+ * Pluralizes a word.
+ *
+ * @public
+ * @param {String} word
+ * @return {String}
+ * @since 4.13.0
+ */
+function pluralize(word) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`pluralize expects to receive a non-empty string`);
+    }
+  })(typeof word === 'string' && word.length > 0) : {};
+  if (!word) return '';
+  return PLURALS.get(word);
+}
+function unshiftMap(v, map) {
+  // reorder
+  const rules = [v, ...map.entries()];
+  map.clear();
+  rules.forEach(rule => {
+    map.set(rule[0], rule[1]);
+  });
+}
+
+/**
+ * Adds a pluralization rule.
+ *
+ * @public
+ * @param {RegExp} regex
+ * @param {String} string
+ * @return {void}
+ * @since 4.13.0
+ */
+function plural(regex, string) {
+  // rule requires reordering if exists, so remove it first
+  if (PLURAL_RULES.has(regex)) {
+    PLURAL_RULES.delete(regex);
+  }
+
+  // reorder
+  unshiftMap([regex, string], PLURAL_RULES);
+}
+
+/**
+ * Adds a singularization rule.
+ *
+ * @public
+ * @param {RegExp} regex
+ * @param {String} string
+ * @return {void}
+ * @since 4.13.0
+ */
+function singular(regex, string) {
+  // rule requires reordering if exists, so remove it first
+  if (SINGULAR_RULES.has(regex)) {
+    SINGULAR_RULES.delete(regex);
+  }
+
+  // reorder
+  unshiftMap([regex, string], SINGULAR_RULES);
+}
+function _pluralize(word) {
+  return inflect(word, PLURAL_RULES, IRREGULAR);
+}
+function _singularize(word) {
+  return inflect(word, SINGULAR_RULES, INVERSE_IRREGULAR);
+}
+function inflect(word, typeRules, irregulars) {
+  // empty strings
+  const isBlank = !word || BLANK_REGEX.test(word);
+  if (isBlank) {
+    return word;
+  }
+
+  // basic uncountables
+  const lowercase = word.toLowerCase();
+  if (UNCOUNTABLE.has(lowercase)) {
+    return word;
+  }
+
+  // adv uncountables
+  const wordSplit = LAST_WORD_DASHED_REGEX.exec(word) || LAST_WORD_CAMELIZED_REGEX.exec(word);
+  const lastWord = wordSplit ? wordSplit[2].toLowerCase() : null;
+  if (lastWord && UNCOUNTABLE.has(lastWord)) {
+    return word;
+  }
+
+  // handle irregulars
+  const isCamelized = CAMELIZED_REGEX.test(word);
+  for (let [rule, substitution] of irregulars) {
+    if (lowercase.match(rule + '$')) {
+      if (isCamelized && lastWord && irregulars.has(lastWord)) {
+        substitution = capitalize(substitution);
+        rule = capitalize(rule);
+      }
+      return word.replace(new RegExp(rule, 'i'), substitution);
+    }
+  }
+
+  // do the actual inflection
+  for (const [rule, substitution] of typeRules) {
+    if (rule.test(word)) {
+      return word.replace(rule, substitution);
+    }
+  }
+  return word;
+}
+export { singular as a, plural as b, loadUncountable as c, clear as d, clearRules as e, dasherize as f, camelize as g, capitalize as h, irregular as i, underscore as j, setMaxLRUCacheSize as k, loadIrregular as l, pluralize as p, resetToDefaults as r, singularize as s, uncountable as u };

package/dist/inflect-C1laviCe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflect-C1laviCe.js","sources":["../src/-private/string/transform.ts","../src/-private/string/inflect.ts"],"sourcesContent":["import { dasherize as internalDasherize, LRUCache, STRING_DASHERIZE_CACHE } from '@warp-drive/core/utils/string';\n\n// eslint-disable-next-line no-useless-escape\nconst STRING_CAMELIZE_REGEXP_1 = /(\\-|\\_|\\.|\\s)+(.)?/g;\nconst STRING_CAMELIZE_REGEXP_2 = /(^|\\/)([A-Z])/g;\nconst CAMELIZE_CACHE = new LRUCache<string, string>((key: string) =>\n  key\n    .replace(STRING_CAMELIZE_REGEXP_1, (_match, _separator, chr: string | null) => (chr ? chr.toUpperCase() : ''))\n    .replace(STRING_CAMELIZE_REGEXP_2, (match /*, separator, chr */) => match.toLowerCase())\n);\n\nconst STRING_UNDERSCORE_REGEXP_1 = /([a-z\\d])([A-Z]+)/g;\n// eslint-disable-next-line no-useless-escape\nconst STRING_UNDERSCORE_REGEXP_2 = /\\-|\\s+/g;\nconst UNDERSCORE_CACHE = new LRUCache<string, string>((str: string) =>\n  str.replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2').replace(STRING_UNDERSCORE_REGEXP_2, '_').toLowerCase()\n);\n\nconst STRING_CAPITALIZE_REGEXP = /(^|\\/)([a-z\\u00C0-\\u024F])/g;\nconst CAPITALIZE_CACHE = new LRUCache<string, string>((str: string) =>\n  str.replace(STRING_CAPITALIZE_REGEXP, (match /*, separator, chr */) => match.toUpperCase())\n);\n\n/**\n * Replaces underscores, spaces, or camelCase with dashes.\n *\n * ```js\n * import { dasherize } from '@warp-drive/utilities/string';\n *\n * dasherize('innerHTML');                // 'inner-html'\n * dasherize('action_name');              // 'action-name'\n * dasherize('css-class-name');           // 'css-class-name'\n * dasherize('my favorite items');        // 'my-favorite-items'\n * dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'\n * ```\n *\n * @public\n * @param {String} str\n * @return {String}\n * @since 4.13.0\n */\nexport const dasherize = internalDasherize;\n\n/**\n * Returns the lowerCamelCase form of a string.\n *\n * ```js\n * import { camelize } from '@warp-drive/utilities/string';\n *\n * camelize('innerHTML');                   // 'innerHTML'\n * camelize('action_name');                 // 'actionName'\n * camelize('css-class-name');              // 'cssClassName'\n * camelize('my favorite items');           // 'myFavoriteItems'\n * camelize('My Favorite Items');           // 'myFavoriteItems'\n * camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'\n * ```\n *\n * @public\n * @param {String} str\n * @return {String}\n * @since 4.13.0\n */\nexport function camelize(str: string): string {\n  return CAMELIZE_CACHE.get(str);\n}\n\n/**\n * Returns the lower\\_case\\_and\\_underscored form of a string.\n *\n * ```js\n * import { underscore } from '@warp-drive/utilities/string';\n *\n * underscore('innerHTML');                 // 'inner_html'\n * underscore('action_name');               // 'action_name'\n * underscore('css-class-name');            // 'css_class_name'\n * underscore('my favorite items');         // 'my_favorite_items'\n * underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'\n * ```\n *\n * @public\n * @param {String} str\n * @return {String}\n * @since 4.13.0\n */\nexport function underscore(str: string): string {\n  return UNDERSCORE_CACHE.get(str);\n}\n\n/**\n * Returns the Capitalized form of a string\n *\n * ```js\n * import { capitalize } from '@warp-drive/utilities/string';\n *\n * capitalize('innerHTML')                 // 'InnerHTML'\n * capitalize('action_name')               // 'Action_name'\n * capitalize('css-class-name')            // 'Css-class-name'\n * capitalize('my favorite items')         // 'My favorite items'\n * capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'\n * ```\n *\n * @public\n * @param {String} str\n * @return {String}\n * @since 4.13.0\n */\nexport function capitalize(str: string): string {\n  return CAPITALIZE_CACHE.get(str);\n}\n\n/**\n * Sets the maximum size of the LRUCache for all string transformation functions.\n * The default size is 10,000.\n *\n * @public\n * @param {Number} size\n * @return {void}\n * @since 4.13.0\n */\nexport function setMaxLRUCacheSize(size: number) {\n  CAMELIZE_CACHE.size = size;\n  UNDERSCORE_CACHE.size = size;\n  CAPITALIZE_CACHE.size = size;\n  STRING_DASHERIZE_CACHE.size = size;\n}\n","import { assert } from '@warp-drive/core/build-config/macros';\nimport { LRUCache } from '@warp-drive/core/utils/string';\n\nimport { defaultRules } from './inflections.ts';\nimport { capitalize } from './transform.ts';\n\nconst BLANK_REGEX = /^\\s*$/;\nconst LAST_WORD_DASHED_REGEX = /([\\w/-]+[_/\\s-])([a-z\\d]+$)/;\nconst LAST_WORD_CAMELIZED_REGEX = /([\\w/\\s-]+)([A-Z][a-z\\d]*$)/;\nconst CAMELIZED_REGEX = /[A-Z][a-z\\d]*$/;\n\nconst SINGULARS = new LRUCache<string, string>((word: string) => {\n  return _singularize(word);\n});\nconst PLURALS = new LRUCache<string, string>((word: string) => {\n  return _pluralize(word);\n});\nconst UNCOUNTABLE = new Set(defaultRules.uncountable);\nconst IRREGULAR: Map<string, string> = new Map();\nconst INVERSE_IRREGULAR: Map<string, string> = new Map();\nconst SINGULAR_RULES = new Map(defaultRules.singular.reverse());\nconst PLURAL_RULES = new Map(defaultRules.plurals.reverse());\n\n/**\n * Marks a word as uncountable. Uncountable words are not pluralized\n * or singularized.\n *\n * @public\n * @param {String} word\n * @return {void}\n * @since 4.13.0\n */\nexport function uncountable(word: string) {\n  UNCOUNTABLE.add(word.toLowerCase());\n}\n\n/**\n * Marks a list of words as uncountable. Uncountable words are not pluralized\n * or singularized.\n *\n * @public\n * @param {Array<String>} uncountables\n * @return {void}\n * @since 4.13.0\n */\nexport function loadUncountable(uncountables: string[]) {\n  uncountables.forEach((word) => {\n    uncountable(word);\n  });\n}\n\n/**\n * Marks a word as irregular. Irregular words have unique\n * pluralization and singularization rules.\n *\n * @public\n * @param {String} single\n * @param {String} plur\n * @return {void}\n * @since 4.13.0\n */\nexport function irregular(single: string, plur: string) {\n  //pluralizing\n  IRREGULAR.set(single.toLowerCase(), plur);\n  IRREGULAR.set(plur.toLowerCase(), plur);\n\n  //singularizing\n  INVERSE_IRREGULAR.set(plur.toLowerCase(), single);\n  INVERSE_IRREGULAR.set(single.toLowerCase(), single);\n}\n\n/**\n * Marks a list of word pairs as irregular. Irregular words have unique\n * pluralization and singularization rules.\n *\n * @public\n * @param {Array<Array<String>>} irregularPairs\n * @return {void}\n * @since 4.13.0\n */\nexport function loadIrregular(irregularPairs: Array<[string, string]>) {\n  irregularPairs.forEach((pair) => {\n    //pluralizing\n    IRREGULAR.set(pair[0].toLowerCase(), pair[1]);\n    IRREGULAR.set(pair[1].toLowerCase(), pair[1]);\n\n    //singularizing\n    INVERSE_IRREGULAR.set(pair[1].toLowerCase(), pair[0]);\n    INVERSE_IRREGULAR.set(pair[0].toLowerCase(), pair[0]);\n  });\n}\nloadIrregular(defaultRules.irregularPairs);\n\n/**\n * Clears the caches for singularize and pluralize.\n *\n * @public\n * @return {void}\n * @since 4.13.0\n */\nexport function clear() {\n  SINGULARS.clear();\n  PLURALS.clear();\n}\n\n/**\n * Resets the inflection rules to the defaults.\n *\n * @public\n * @return {void}\n * @since 4.13.0\n */\nexport function resetToDefaults() {\n  clearRules();\n  defaultRules.uncountable.forEach((v) => UNCOUNTABLE.add(v));\n  defaultRules.singular.forEach((v) => SINGULAR_RULES.set(v[0], v[1]));\n  defaultRules.plurals.forEach((v) => PLURAL_RULES.set(v[0], v[1]));\n  loadIrregular(defaultRules.irregularPairs);\n}\n\n/**\n * Clears all inflection rules\n * and resets the caches for singularize and pluralize.\n *\n * @public\n * @return {void}\n * @since 4.13.0\n */\nexport function clearRules() {\n  SINGULARS.clear();\n  PLURALS.clear();\n  UNCOUNTABLE.clear();\n  IRREGULAR.clear();\n  INVERSE_IRREGULAR.clear();\n  SINGULAR_RULES.clear();\n  PLURAL_RULES.clear();\n}\n\n/**\n * Singularizes a word.\n *\n * @public\n * @param {String} word\n * @return {String}\n * @since 4.13.0\n */\nexport function singularize(word: string) {\n  assert(`singularize expects to receive a non-empty string`, typeof word === 'string' && word.length > 0);\n  if (!word) return '';\n  return SINGULARS.get(word);\n}\n\n/**\n * Pluralizes a word.\n *\n * @public\n * @param {String} word\n * @return {String}\n * @since 4.13.0\n */\nexport function pluralize(word: string) {\n  assert(`pluralize expects to receive a non-empty string`, typeof word === 'string' && word.length > 0);\n  if (!word) return '';\n  return PLURALS.get(word);\n}\n\nfunction unshiftMap<K, V>(v: [K, V], map: Map<K, V>) {\n  // reorder\n  const rules = [v, ...map.entries()];\n  map.clear();\n  rules.forEach((rule) => {\n    map.set(rule[0], rule[1]);\n  });\n}\n\n/**\n * Adds a pluralization rule.\n *\n * @public\n * @param {RegExp} regex\n * @param {String} string\n * @return {void}\n * @since 4.13.0\n */\nexport function plural(regex: RegExp, string: string) {\n  // rule requires reordering if exists, so remove it first\n  if (PLURAL_RULES.has(regex)) {\n    PLURAL_RULES.delete(regex);\n  }\n\n  // reorder\n  unshiftMap([regex, string], PLURAL_RULES);\n}\n\n/**\n * Adds a singularization rule.\n *\n * @public\n * @param {RegExp} regex\n * @param {String} string\n * @return {void}\n * @since 4.13.0\n */\nexport function singular(regex: RegExp, string: string) {\n  // rule requires reordering if exists, so remove it first\n  if (SINGULAR_RULES.has(regex)) {\n    SINGULAR_RULES.delete(regex);\n  }\n\n  // reorder\n  unshiftMap([regex, string], SINGULAR_RULES);\n}\n\nfunction _pluralize(word: string) {\n  return inflect(word, PLURAL_RULES, IRREGULAR);\n}\n\nfunction _singularize(word: string) {\n  return inflect(word, SINGULAR_RULES, INVERSE_IRREGULAR);\n}\n\nfunction inflect(word: string, typeRules: Map<RegExp, string>, irregulars: Map<string, string>) {\n  // empty strings\n  const isBlank = !word || BLANK_REGEX.test(word);\n  if (isBlank) {\n    return word;\n  }\n\n  // basic uncountables\n  const lowercase = word.toLowerCase();\n  if (UNCOUNTABLE.has(lowercase)) {\n    return word;\n  }\n\n  // adv uncountables\n  const wordSplit = LAST_WORD_DASHED_REGEX.exec(word) || LAST_WORD_CAMELIZED_REGEX.exec(word);\n  const lastWord = wordSplit ? wordSplit[2].toLowerCase() : null;\n  if (lastWord && UNCOUNTABLE.has(lastWord)) {\n    return word;\n  }\n\n  // handle irregulars\n  const isCamelized = CAMELIZED_REGEX.test(word);\n  for (let [rule, substitution] of irregulars) {\n    if (lowercase.match(rule + '$')) {\n      if (isCamelized && lastWord && irregulars.has(lastWord)) {\n        substitution = capitalize(substitution);\n        rule = capitalize(rule);\n      }\n\n      return word.replace(new RegExp(rule, 'i'), substitution);\n    }\n  }\n\n  // do the actual inflection\n  for (const [rule, substitution] of typeRules) {\n    if (rule.test(word)) {\n      return word.replace(rule, substitution);\n    }\n  }\n\n  return word;\n}\n"],"names":["STRING_CAMELIZE_REGEXP_1","STRING_CAMELIZE_REGEXP_2","CAMELIZE_CACHE","LRUCache","key","replace","_match","_separator","chr","toUpperCase","match","toLowerCase","STRING_UNDERSCORE_REGEXP_1","STRING_UNDERSCORE_REGEXP_2","UNDERSCORE_CACHE","str","STRING_CAPITALIZE_REGEXP","CAPITALIZE_CACHE","dasherize","internalDasherize","camelize","get","underscore","capitalize","setMaxLRUCacheSize","size","STRING_DASHERIZE_CACHE","BLANK_REGEX","LAST_WORD_DASHED_REGEX","LAST_WORD_CAMELIZED_REGEX","CAMELIZED_REGEX","SINGULARS","word","_singularize","PLURALS","_pluralize","UNCOUNTABLE","Set","defaultRules","uncountable","IRREGULAR","Map","INVERSE_IRREGULAR","SINGULAR_RULES","singular","reverse","PLURAL_RULES","plurals","add","loadUncountable","uncountables","forEach","irregular","single","plur","set","loadIrregular","irregularPairs","pair","clear","resetToDefaults","clearRules","v","singularize","macroCondition","getGlobalConfig","WarpDrive","env","DEBUG","test","Error","length","pluralize","unshiftMap","map","rules","entries","rule","plural","regex","string","has","delete","inflect","typeRules","irregulars","isBlank","lowercase","wordSplit","exec","lastWord","isCamelized","substitution","RegExp"],"mappings":";;;;AAEA;AACA,MAAMA,wBAAwB,GAAG,qBAAqB;AACtD,MAAMC,wBAAwB,GAAG,gBAAgB;AACjD,MAAMC,cAAc,GAAG,IAAIC,QAAQ,CAAkBC,GAAW,IAC9DA,GAAG,CACAC,OAAO,CAACL,wBAAwB,EAAE,CAACM,MAAM,EAAEC,UAAU,EAAEC,GAAkB,KAAMA,GAAG,GAAGA,GAAG,CAACC,WAAW,EAAE,GAAG,EAAG,CAAC,CAC7GJ,OAAO,CAACJ,wBAAwB,EAAE,CAACS,KAAK,2BAA2BA,KAAK,CAACC,WAAW,EAAE,CAC3F,CAAC;AAED,MAAMC,0BAA0B,GAAG,oBAAoB;AACvD;AACA,MAAMC,0BAA0B,GAAG,SAAS;AAC5C,MAAMC,gBAAgB,GAAG,IAAIX,QAAQ,CAAkBY,GAAW,IAChEA,GAAG,CAACV,OAAO,CAACO,0BAA0B,EAAE,OAAO,CAAC,CAACP,OAAO,CAACQ,0BAA0B,EAAE,GAAG,CAAC,CAACF,WAAW,EACvG,CAAC;AAED,MAAMK,wBAAwB,GAAG,6BAA6B;AAC9D,MAAMC,gBAAgB,GAAG,IAAId,QAAQ,CAAkBY,GAAW,IAChEA,GAAG,CAACV,OAAO,CAACW,wBAAwB,EAAE,CAACN,KAAK,2BAA2BA,KAAK,CAACD,WAAW,EAAE,CAC5F,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMS,SAAS,GAAGC;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,QAAQA,CAACL,GAAW,EAAU;AAC5C,EAAA,OAAOb,cAAc,CAACmB,GAAG,CAACN,GAAG,CAAC;AAChC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASO,UAAUA,CAACP,GAAW,EAAU;AAC9C,EAAA,OAAOD,gBAAgB,CAACO,GAAG,CAACN,GAAG,CAAC;AAClC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASQ,UAAUA,CAACR,GAAW,EAAU;AAC9C,EAAA,OAAOE,gBAAgB,CAACI,GAAG,CAACN,GAAG,CAAC;AAClC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASS,kBAAkBA,CAACC,IAAY,EAAE;EAC/CvB,cAAc,CAACuB,IAAI,GAAGA,IAAI;EAC1BX,gBAAgB,CAACW,IAAI,GAAGA,IAAI;EAC5BR,gBAAgB,CAACQ,IAAI,GAAGA,IAAI;EAC5BC,sBAAsB,CAACD,IAAI,GAAGA,IAAI;AACpC;;ACtHA,MAAME,WAAW,GAAG,OAAO;AAC3B,MAAMC,sBAAsB,GAAG,6BAA6B;AAC5D,MAAMC,yBAAyB,GAAG,6BAA6B;AAC/D,MAAMC,eAAe,GAAG,gBAAgB;AAExC,MAAMC,SAAS,GAAG,IAAI5B,QAAQ,CAAkB6B,IAAY,IAAK;EAC/D,OAAOC,YAAY,CAACD,IAAI,CAAC;AAC3B,CAAC,CAAC;AACF,MAAME,OAAO,GAAG,IAAI/B,QAAQ,CAAkB6B,IAAY,IAAK;EAC7D,OAAOG,UAAU,CAACH,IAAI,CAAC;AACzB,CAAC,CAAC;AACF,MAAMI,WAAW,GAAG,IAAIC,GAAG,CAACC,YAAY,CAACC,WAAW,CAAC;AACrD,MAAMC,SAA8B,GAAG,IAAIC,GAAG,EAAE;AAChD,MAAMC,iBAAsC,GAAG,IAAID,GAAG,EAAE;AACxD,MAAME,cAAc,GAAG,IAAIF,GAAG,CAACH,YAAY,CAACM,QAAQ,CAACC,OAAO,EAAE,CAAC;AAC/D,MAAMC,YAAY,GAAG,IAAIL,GAAG,CAACH,YAAY,CAACS,OAAO,CAACF,OAAO,EAAE,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASN,WAAWA,CAACP,IAAY,EAAE;EACxCI,WAAW,CAACY,GAAG,CAAChB,IAAI,CAACrB,WAAW,EAAE,CAAC;AACrC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASsC,eAAeA,CAACC,YAAsB,EAAE;AACtDA,EAAAA,YAAY,CAACC,OAAO,CAAEnB,IAAI,IAAK;IAC7BO,WAAW,CAACP,IAAI,CAAC;AACnB,GAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASoB,SAASA,CAACC,MAAc,EAAEC,IAAY,EAAE;AACtD;EACAd,SAAS,CAACe,GAAG,CAACF,MAAM,CAAC1C,WAAW,EAAE,EAAE2C,IAAI,CAAC;EACzCd,SAAS,CAACe,GAAG,CAACD,IAAI,CAAC3C,WAAW,EAAE,EAAE2C,IAAI,CAAC;;AAEvC;EACAZ,iBAAiB,CAACa,GAAG,CAACD,IAAI,CAAC3C,WAAW,EAAE,EAAE0C,MAAM,CAAC;EACjDX,iBAAiB,CAACa,GAAG,CAACF,MAAM,CAAC1C,WAAW,EAAE,EAAE0C,MAAM,CAAC;AACrD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,aAAaA,CAACC,cAAuC,EAAE;AACrEA,EAAAA,cAAc,CAACN,OAAO,CAAEO,IAAI,IAAK;AAC/B;AACAlB,IAAAA,SAAS,CAACe,GAAG,CAACG,IAAI,CAAC,CAAC,CAAC,CAAC/C,WAAW,EAAE,EAAE+C,IAAI,CAAC,CAAC,CAAC,CAAC;AAC7ClB,IAAAA,SAAS,CAACe,GAAG,CAACG,IAAI,CAAC,CAAC,CAAC,CAAC/C,WAAW,EAAE,EAAE+C,IAAI,CAAC,CAAC,CAAC,CAAC;;AAE7C;AACAhB,IAAAA,iBAAiB,CAACa,GAAG,CAACG,IAAI,CAAC,CAAC,CAAC,CAAC/C,WAAW,EAAE,EAAE+C,IAAI,CAAC,CAAC,CAAC,CAAC;AACrDhB,IAAAA,iBAAiB,CAACa,GAAG,CAACG,IAAI,CAAC,CAAC,CAAC,CAAC/C,WAAW,EAAE,EAAE+C,IAAI,CAAC,CAAC,CAAC,CAAC;AACvD,GAAC,CAAC;AACJ;AACAF,aAAa,CAAClB,YAAY,CAACmB,cAAc,CAAC;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,KAAKA,GAAG;EACtB5B,SAAS,CAAC4B,KAAK,EAAE;EACjBzB,OAAO,CAACyB,KAAK,EAAE;AACjB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,eAAeA,GAAG;AAChCC,EAAAA,UAAU,EAAE;AACZvB,EAAAA,YAAY,CAACC,WAAW,CAACY,OAAO,CAAEW,CAAC,IAAK1B,WAAW,CAACY,GAAG,CAACc,CAAC,CAAC,CAAC;EAC3DxB,YAAY,CAACM,QAAQ,CAACO,OAAO,CAAEW,CAAC,IAAKnB,cAAc,CAACY,GAAG,CAACO,CAAC,CAAC,CAAC,CAAC,EAAEA,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;EACpExB,YAAY,CAACS,OAAO,CAACI,OAAO,CAAEW,CAAC,IAAKhB,YAAY,CAACS,GAAG,CAACO,CAAC,CAAC,CAAC,CAAC,EAAEA,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjEN,EAAAA,aAAa,CAAClB,YAAY,CAACmB,cAAc,CAAC;AAC5C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,UAAUA,GAAG;EAC3B9B,SAAS,CAAC4B,KAAK,EAAE;EACjBzB,OAAO,CAACyB,KAAK,EAAE;EACfvB,WAAW,CAACuB,KAAK,EAAE;EACnBnB,SAAS,CAACmB,KAAK,EAAE;EACjBjB,iBAAiB,CAACiB,KAAK,EAAE;EACzBhB,cAAc,CAACgB,KAAK,EAAE;EACtBb,YAAY,CAACa,KAAK,EAAE;AACtB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,WAAWA,CAAC/B,IAAY,EAAE;EACxCgC,cAAA,CAAAC,eAAA,EAAAC,CAAAA,SAAA,CAAAC,GAAA,CAAAC,KAAA,CAAA,GAAA,CAAAC,IAAA,IAAA;AAAA,IAAA,IAAA,CAAAA,IAAA,EAAA;MAAA,MAAAC,IAAAA,KAAA,CAAO,CAAmD,iDAAA,CAAA,CAAA;AAAA;GAAE,EAAA,OAAOtC,IAAI,KAAK,QAAQ,IAAIA,IAAI,CAACuC,MAAM,GAAG,CAAC,CAAA,GAAA,EAAA;AACvG,EAAA,IAAI,CAACvC,IAAI,EAAE,OAAO,EAAE;AACpB,EAAA,OAAOD,SAAS,CAACV,GAAG,CAACW,IAAI,CAAC;AAC5B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASwC,SAASA,CAACxC,IAAY,EAAE;EACtCgC,cAAA,CAAAC,eAAA,EAAAC,CAAAA,SAAA,CAAAC,GAAA,CAAAC,KAAA,CAAA,GAAA,CAAAC,IAAA,IAAA;AAAA,IAAA,IAAA,CAAAA,IAAA,EAAA;MAAA,MAAAC,IAAAA,KAAA,CAAO,CAAiD,+CAAA,CAAA,CAAA;AAAA;GAAE,EAAA,OAAOtC,IAAI,KAAK,QAAQ,IAAIA,IAAI,CAACuC,MAAM,GAAG,CAAC,CAAA,GAAA,EAAA;AACrG,EAAA,IAAI,CAACvC,IAAI,EAAE,OAAO,EAAE;AACpB,EAAA,OAAOE,OAAO,CAACb,GAAG,CAACW,IAAI,CAAC;AAC1B;AAEA,SAASyC,UAAUA,CAAOX,CAAS,EAAEY,GAAc,EAAE;AACnD;EACA,MAAMC,KAAK,GAAG,CAACb,CAAC,EAAE,GAAGY,GAAG,CAACE,OAAO,EAAE,CAAC;EACnCF,GAAG,CAACf,KAAK,EAAE;AACXgB,EAAAA,KAAK,CAACxB,OAAO,CAAE0B,IAAI,IAAK;AACtBH,IAAAA,GAAG,CAACnB,GAAG,CAACsB,IAAI,CAAC,CAAC,CAAC,EAAEA,IAAI,CAAC,CAAC,CAAC,CAAC;AAC3B,GAAC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,MAAMA,CAACC,KAAa,EAAEC,MAAc,EAAE;AACpD;AACA,EAAA,IAAIlC,YAAY,CAACmC,GAAG,CAACF,KAAK,CAAC,EAAE;AAC3BjC,IAAAA,YAAY,CAACoC,MAAM,CAACH,KAAK,CAAC;AAC5B;;AAEA;EACAN,UAAU,CAAC,CAACM,KAAK,EAAEC,MAAM,CAAC,EAAElC,YAAY,CAAC;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASF,QAAQA,CAACmC,KAAa,EAAEC,MAAc,EAAE;AACtD;AACA,EAAA,IAAIrC,cAAc,CAACsC,GAAG,CAACF,KAAK,CAAC,EAAE;AAC7BpC,IAAAA,cAAc,CAACuC,MAAM,CAACH,KAAK,CAAC;AAC9B;;AAEA;EACAN,UAAU,CAAC,CAACM,KAAK,EAAEC,MAAM,CAAC,EAAErC,cAAc,CAAC;AAC7C;AAEA,SAASR,UAAUA,CAACH,IAAY,EAAE;AAChC,EAAA,OAAOmD,OAAO,CAACnD,IAAI,EAAEc,YAAY,EAAEN,SAAS,CAAC;AAC/C;AAEA,SAASP,YAAYA,CAACD,IAAY,EAAE;AAClC,EAAA,OAAOmD,OAAO,CAACnD,IAAI,EAAEW,cAAc,EAAED,iBAAiB,CAAC;AACzD;AAEA,SAASyC,OAAOA,CAACnD,IAAY,EAAEoD,SAA8B,EAAEC,UAA+B,EAAE;AAC9F;EACA,MAAMC,OAAO,GAAG,CAACtD,IAAI,IAAIL,WAAW,CAAC0C,IAAI,CAACrC,IAAI,CAAC;AAC/C,EAAA,IAAIsD,OAAO,EAAE;AACX,IAAA,OAAOtD,IAAI;AACb;;AAEA;AACA,EAAA,MAAMuD,SAAS,GAAGvD,IAAI,CAACrB,WAAW,EAAE;AACpC,EAAA,IAAIyB,WAAW,CAAC6C,GAAG,CAACM,SAAS,CAAC,EAAE;AAC9B,IAAA,OAAOvD,IAAI;AACb;;AAEA;AACA,EAAA,MAAMwD,SAAS,GAAG5D,sBAAsB,CAAC6D,IAAI,CAACzD,IAAI,CAAC,IAAIH,yBAAyB,CAAC4D,IAAI,CAACzD,IAAI,CAAC;AAC3F,EAAA,MAAM0D,QAAQ,GAAGF,SAAS,GAAGA,SAAS,CAAC,CAAC,CAAC,CAAC7E,WAAW,EAAE,GAAG,IAAI;EAC9D,IAAI+E,QAAQ,IAAItD,WAAW,CAAC6C,GAAG,CAACS,QAAQ,CAAC,EAAE;AACzC,IAAA,OAAO1D,IAAI;AACb;;AAEA;AACA,EAAA,MAAM2D,WAAW,GAAG7D,eAAe,CAACuC,IAAI,CAACrC,IAAI,CAAC;EAC9C,KAAK,IAAI,CAAC6C,IAAI,EAAEe,YAAY,CAAC,IAAIP,UAAU,EAAE;IAC3C,IAAIE,SAAS,CAAC7E,KAAK,CAACmE,IAAI,GAAG,GAAG,CAAC,EAAE;MAC/B,IAAIc,WAAW,IAAID,QAAQ,IAAIL,UAAU,CAACJ,GAAG,CAACS,QAAQ,CAAC,EAAE;AACvDE,QAAAA,YAAY,GAAGrE,UAAU,CAACqE,YAAY,CAAC;AACvCf,QAAAA,IAAI,GAAGtD,UAAU,CAACsD,IAAI,CAAC;AACzB;AAEA,MAAA,OAAO7C,IAAI,CAAC3B,OAAO,CAAC,IAAIwF,MAAM,CAAChB,IAAI,EAAE,GAAG,CAAC,EAAEe,YAAY,CAAC;AAC1D;AACF;;AAEA;EACA,KAAK,MAAM,CAACf,IAAI,EAAEe,YAAY,CAAC,IAAIR,SAAS,EAAE;AAC5C,IAAA,IAAIP,IAAI,CAACR,IAAI,CAACrC,IAAI,CAAC,EAAE;AACnB,MAAA,OAAOA,IAAI,CAAC3B,OAAO,CAACwE,IAAI,EAAEe,YAAY,CAAC;AACzC;AACF;AAEA,EAAA,OAAO5D,IAAI;AACb;;;;"}