@hichchi/utils 0.0.1-beta.2 → 0.0.2

package/constants/constants.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT_MULTIPLIER = exports.DEFAULT_ELLIPSIS = exports.DEFAULT_CONTEXT_LENGTH = exports.DEFAULT_BREAK_CHAR = exports.DEFAULT_LINE_LENGTH = exports.CHARACTERS_TO_REMOVE = exports.HEX_PADDING_CHAR = exports.HEX_PADDING_LENGTH = exports.HEX_RADIX = void 0;
-/**
- * Base for hexadecimal number conversion
- *
- * This constant defines the radix (base) used for hexadecimal number conversion.
- * The value 16 represents the standard hexadecimal numbering system (0-9, A-F).
- * It's used in toString() and parseInt() operations involving hex values.
- *
- * @example
- * ```typescript
- * // Converting a number to hexadecimal string
- * const hexString = number.toString(HEX_RADIX);
- *
- * // Converting a hexadecimal string to a number
- * const number = parseInt(hexString, HEX_RADIX);
- * ```
- *
- * @see {@link HEX_PADDING_LENGTH} Related constant for hex string formatting
- * @see {@link HEX_PADDING_CHAR} Related constant for hex string padding
- */
-exports.HEX_RADIX = 16;
-/**
- * Minimum length for padded hexadecimal strings
- *
- * This constant defines the minimum length for hexadecimal strings after padding.
- * It ensures that hex values have a consistent length (e.g., "0A" instead of "A").
- * The value 2 ensures that single-digit hex values are padded with a leading zero.
- *
- * @example
- * ```typescript
- * // Padding a hex string to ensure consistent length
- * const paddedHex = hexString.padStart(HEX_PADDING_LENGTH, HEX_PADDING_CHAR);
- *
- * // Full example with conversion and padding
- * const byteValue = 10;
- * const hexByte = byteValue.toString(HEX_RADIX).padStart(HEX_PADDING_LENGTH, HEX_PADDING_CHAR);
- * // hexByte = "0A"
- * ```
- *
- * @see {@link HEX_RADIX} Related constant for hex conversion
- * @see {@link HEX_PADDING_CHAR} Related constant for the padding character
- */
-exports.HEX_PADDING_LENGTH = 2;
-/**
- * Character used for padding hexadecimal strings
- *
- * This constant defines the character used to pad hexadecimal strings to reach
- * the minimum length defined by HEX_PADDING_LENGTH. The value "0" is the standard
- * padding character for hexadecimal values.
- *
- * @example
- * ```typescript
- * // Padding a hex string with zeros
- * const paddedHex = hexString.padStart(HEX_PADDING_LENGTH, HEX_PADDING_CHAR);
- *
- * // Example with a single-digit hex value
- * const hexValue = "F";
- * const paddedHex = hexValue.padStart(HEX_PADDING_LENGTH, HEX_PADDING_CHAR);
- * // paddedHex = "0F"
- * ```
- *
- * @see {@link HEX_RADIX} Related constant for hex conversion
- * @see {@link HEX_PADDING_LENGTH} Related constant for the minimum length
- */
-exports.HEX_PADDING_CHAR = "0";
-/**
- * Number of characters to remove in string truncation operations
- *
- * This constant defines the default number of characters to remove when
- * truncating strings in various utility functions. The value 2 is commonly
- * used when removing the last two characters of a string (e.g., removing
- * a trailing comma and space).
- *
- * @example
- * ```typescript
- * // Removing trailing characters from a string
- * const items = ["apple", "banana", "cherry"];
- * let result = "";
- *
- * for (const item of items) {
- *   result += item + ", ";
- * }
- *
- * // Remove trailing comma and space
- * if (result.length > 0) {
- *   result = result.slice(0, -CHARACTERS_TO_REMOVE);
- * }
- * // result = "apple, banana, cherry"
- * ```
- */
-exports.CHARACTERS_TO_REMOVE = 2;
-/**
- * Default maximum line length for word wrapping
- *
- * This constant defines the default maximum length of a line when performing
- * word wrapping operations. The value 80 is a common standard for line length
- * in many text formats and terminal displays.
- *
- * @example
- * ```typescript
- * // Wrapping a long text to the default line length
- * function wrapText(text: string, maxLength = DEFAULT_LINE_LENGTH, breakChar = DEFAULT_BREAK_CHAR): string {
- *   // Word wrapping implementation
- *   const result = [];
- *   let line = "";
- *
- *   for (const word of text.split(" ")) {
- *     if ((line + word).length > maxLength) {
- *       result.push(line);
- *       line = word;
- *     } else {
- *       line += (line ? " " : "") + word;
- *     }
- *   }
- *
- *   if (line) {
- *     result.push(line);
- *   }
- *
- *   return result.join(breakChar);
- * }
- * ```
- *
- * @see {@link DEFAULT_BREAK_CHAR} Related constant for line break character
- */
-exports.DEFAULT_LINE_LENGTH = 80;
-/**
- * Default line break character for word wrapping
- *
- * This constant defines the default character or string used to separate lines
- * when performing word wrapping operations. The value "\n" represents a standard
- * line feed character used for line breaks in most text formats.
- *
- * @example
- * ```typescript
- * // Using the default break character in word wrapping
- * const wrappedText = longText.match(new RegExp(`.{1,${DEFAULT_LINE_LENGTH}}(\\s|$)`, 'g'))
- *   ?.join(DEFAULT_BREAK_CHAR) || longText;
- * ```
- *
- * @see {@link DEFAULT_LINE_LENGTH} Related constant for maximum line length
- */
-exports.DEFAULT_BREAK_CHAR = "\n";
-/**
- * Default context length for text excerpts
- *
- * This constant defines the default number of characters to include before and after
- * a search term when generating text excerpts or snippets. The value 40 provides
- * enough context to understand the meaning while keeping the excerpt concise.
- *
- * @example
- * ```typescript
- * // Generating an excerpt around a search term
- * function generateExcerpt(text: string, searchTerm: string): string {
- *   const index = text.toLowerCase().indexOf(searchTerm.toLowerCase());
- *   if (index === -1) return text.substring(0, DEFAULT_CONTEXT_LENGTH * 2) + DEFAULT_ELLIPSIS;
- *
- *   const start = Math.max(0, index - DEFAULT_CONTEXT_LENGTH);
- *   const end = Math.min(text.length, index + searchTerm.length + DEFAULT_CONTEXT_LENGTH);
- *
- *   let excerpt = text.substring(start, end);
- *   if (start > 0) excerpt = DEFAULT_ELLIPSIS + excerpt;
- *   if (end < text.length) excerpt = excerpt + DEFAULT_ELLIPSIS;
- *
- *   return excerpt;
- * }
- * ```
- *
- * @see {@link DEFAULT_ELLIPSIS} Related constant for indicating truncated text
- * @see {@link CONTEXT_MULTIPLIER} Related constant for adjusting context length
- */
-exports.DEFAULT_CONTEXT_LENGTH = 40;
-/**
- * Default ellipsis string for indicating truncated text
- *
- * This constant defines the default string used to indicate that text has been
- * truncated or omitted in excerpts and summaries. The value "..." is the standard
- * ellipsis used to represent omitted content.
- *
- * @example
- * ```typescript
- * // Truncating a long string with ellipsis
- * function truncate(text: string, maxLength: number): string {
- *   if (text.length <= maxLength) return text;
- *   return text.substring(0, maxLength - DEFAULT_ELLIPSIS.length) + DEFAULT_ELLIPSIS;
- * }
- *
- * const longText = "This is a very long text that needs to be truncated";
- * const truncated = truncate(longText, 20);
- * // truncated = "This is a very lo..."
- * ```
- *
- * @see {@link DEFAULT_CONTEXT_LENGTH} Related constant for excerpt generation
- */
-exports.DEFAULT_ELLIPSIS = "...";
-/**
- * Multiplier for adjusting context length in excerpts
- *
- * This constant defines a multiplier used to adjust the context length when
- * generating excerpts under different conditions. The value 2 is typically
- * used to double the context length for certain scenarios, such as when no
- * search term is found.
- *
- * @example
- * ```typescript
- * // Using the multiplier to adjust context length
- * function getContextLength(hasSearchTerm: boolean): number {
- *   return hasSearchTerm
- *     ? DEFAULT_CONTEXT_LENGTH
- *     : DEFAULT_CONTEXT_LENGTH * CONTEXT_MULTIPLIER;
- * }
- *
- * // Getting the first part of a text when no search term is found
- * function getFirstPart(text: string): string {
- *   const length = DEFAULT_CONTEXT_LENGTH * CONTEXT_MULTIPLIER;
- *   return text.length > length
- *     ? text.substring(0, length) + DEFAULT_ELLIPSIS
- *     : text;
- * }
- * ```
- *
- * @see {@link DEFAULT_CONTEXT_LENGTH} Related constant for base context length
- */
-exports.CONTEXT_MULTIPLIER = 2;
-//# sourceMappingURL=constants.js.map

package/constants/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../libs/utils/src/constants/constants.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,SAAS,GAAG,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;GAoBG;AACU,QAAA,kBAAkB,GAAG,CAAC,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;GAoBG;AACU,QAAA,gBAAgB,GAAG,GAAG,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACU,QAAA,oBAAoB,GAAG,CAAC,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACU,QAAA,mBAAmB,GAAG,EAAE,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACU,QAAA,kBAAkB,GAAG,IAAI,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACU,QAAA,sBAAsB,GAAG,EAAE,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACU,QAAA,gBAAgB,GAAG,KAAK,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACU,QAAA,kBAAkB,GAAG,CAAC,CAAC"}

package/constants/english-inflection-rules.js

@@ -1,360 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnglishInflectionRules = void 0;
-const constants_1 = require("./constants");
-/**
- * Comprehensive rules for English word inflection (singular/plural transformations)
- *
- * This module provides a structured collection of rules for transforming English words
- * between singular and plural forms. The rules are organized into categories based on
- * linguistic patterns and exceptions, ensuring accurate transformations for various
- * word types.
- *
- * Key features:
- * - Invariant words that are identical in singular and plural forms
- * - Irregular plural forms that don't follow standard patterns
- * - Latin and Greek origin words with their specific plural formations
- * - Pattern-based rules for common English word endings
- * - Default fallback rules for standard English pluralization
- *
- * The rules are applied in a specific priority order, from most specific to most general,
- * to ensure correct handling of special cases. Each rule consists of a regular expression
- * pattern and a replacement string or function.
- *
- * @example
- * ```typescript
- * // Using the rules with the plural() function
- * import { EnglishInflectionRules } from '@hichchi/utils/constants';
- * import { InflectionRule } from '@hichchi/utils/interfaces';
- *
- * function plural(word: string): string {
- *   // Combine all rules in priority order
- *   const rules: InflectionRule[] = [
- *     ...EnglishInflectionRules.INVARIANT,
- *     ...EnglishInflectionRules.IRREGULAR.toPlural,
- *     ...EnglishInflectionRules.LATIN_GREEK.toPlural,
- *     ...EnglishInflectionRules.PATTERN_RULES.toPlural,
- *     ...EnglishInflectionRules.DEFAULT.toPlural,
- *   ];
- *
- *   // Apply the first matching rule
- *   for (const rule of rules) {
- *     if (rule.regex.test(word)) {
- *       return word.replace(rule.regex, rule.replacement as string);
- *     }
- *   }
- *
- *   return word;
- * }
- * ```
- *
- * @see {@link plural} Function that uses these rules to convert words to plural form
- * @see {@link singular} Function that uses these rules to convert words to singular form
- * @see {@link InflectionRuleCategories} Interface defining the structure of the rules
- * @see {@link InflectionRule} Interface for individual transformation rules
- */
-exports.EnglishInflectionRules = {
-    /**
-     * Words that are the same in singular and plural form
-     *
-     * This category contains rules for words that don't change between singular and plural forms.
-     * These invariant words (also called "zero plurals") have identical singular and plural forms
-     * in English. The rule simply returns the word unchanged.
-     *
-     * Common examples include:
-     * - Animal names: "fish", "deer", "sheep"
-     * - Scientific terms: "species", "series"
-     * - Uncountable nouns: "equipment"
-     *
-     * @example
-     * ```typescript
-     * // These words remain unchanged in plural form
-     * plural("fish");     // "fish"
-     * plural("deer");     // "deer"
-     * plural("sheep");    // "sheep"
-     * plural("species");  // "species"
-     * plural("equipment"); // "equipment"
-     * ```
-     *
-     * @see {@link plural} Function that applies these rules
-     * @see {@link singular} Function that applies these rules
-     */
-    INVARIANT: [{ regex: /^(fish|deer|sheep|species|series|equipment)$/i, replacement: "$1" }],
-    /**
-     * Irregular plural forms
-     *
-     * This category contains rules for words with irregular plural forms that don't
-     * follow standard English pluralization patterns. These words have unique
-     * transformations between singular and plural forms that must be handled as
-     * special cases.
-     *
-     * The category is divided into two rule sets:
-     * - toPlural: Rules for converting singular forms to their irregular plural forms
-     * - toSingular: Rules for converting irregular plural forms back to singular
-     *
-     * These rules handle common irregular English plurals like "child/children",
-     * "man/men", "tooth/teeth", etc. Many of these irregular forms have historical
-     * origins in Old English and other Germanic languages.
-     *
-     * @example
-     * ```typescript
-     * // Singular to plural transformations
-     * plural("child");   // "children"
-     * plural("man");     // "men"
-     * plural("tooth");   // "teeth"
-     * plural("person");  // "people"
-     *
-     * // Plural to singular transformations
-     * singular("children"); // "child"
-     * singular("men");      // "man"
-     * singular("teeth");    // "tooth"
-     * singular("people");   // "person"
-     * ```
-     *
-     * @see {@link plural} Function that applies these rules for pluralization
-     * @see {@link singular} Function that applies these rules for singularization
-     */
-    IRREGULAR: {
-        // Singular to plural transformations
-        toPlural: [
-            { regex: /^child$/i, replacement: "children" },
-            { regex: /^man$/i, replacement: "men" },
-            { regex: /^woman$/i, replacement: "women" },
-            { regex: /^tooth$/i, replacement: "teeth" },
-            { regex: /^foot$/i, replacement: "feet" },
-            { regex: /^goose$/i, replacement: "geese" },
-            { regex: /^mouse$/i, replacement: "mice" },
-            { regex: /^person$/i, replacement: "people" },
-            { regex: /^ox$/i, replacement: "oxen" },
-        ],
-        // Plural to singular transformations
-        toSingular: [
-            { regex: /children$/i, replacement: "child" },
-            { regex: /men$/i, replacement: "man" },
-            { regex: /women$/i, replacement: "woman" },
-            { regex: /teeth$/i, replacement: "tooth" },
-            { regex: /feet$/i, replacement: "foot" },
-            { regex: /geese$/i, replacement: "goose" },
-            { regex: /mice$/i, replacement: "mouse" },
-            { regex: /people$/i, replacement: "person" },
-            { regex: /oxen$/i, replacement: "ox" },
-        ],
-    },
-    /**
-     * Latin/Greek origin words
-     *
-     * This category contains rules for words borrowed from Latin and Greek that
-     * retain their original pluralization patterns. These words follow different
-     * rules than native English words and often have distinctive ending changes.
-     *
-     * The category is divided into two rule sets:
-     * - toPlural: Rules for converting Latin/Greek singular forms to their plural forms
-     * - toSingular: Rules for converting Latin/Greek plural forms back to singular
-     *
-     * Common patterns include:
-     * - "-us" → "-i" (cactus/cacti, fungus/fungi)
-     * - "-is" → "-es" (analysis/analyses, thesis/theses)
-     * - "-on"/"-um" → "-a" (criterion/criteria, datum/data)
-     * - "-ex"/"-ix" → "-ices" (index/indices, matrix/matrices)
-     *
-     * These words are often found in academic, scientific, and technical contexts.
-     * Note that some of these words have alternative anglicized plural forms that
-     * are also acceptable in modern English (e.g., "cactuses" alongside "cacti").
-     *
-     * @example
-     * ```typescript
-     * // Singular to plural transformations
-     * plural("cactus");    // "cacti"
-     * plural("analysis");  // "analyses"
-     * plural("criterion"); // "criteria"
-     * plural("index");     // "indices"
-     * plural("matrix");    // "matrices"
-     *
-     * // Plural to singular transformations
-     * singular("cacti");     // "cactus"
-     * singular("analyses");  // "analysis"
-     * singular("criteria");  // "criterion"
-     * singular("indices");   // "index"
-     * singular("matrices");  // "matrix"
-     * ```
-     *
-     * @see {@link plural} Function that applies these rules for pluralization
-     * @see {@link singular} Function that applies these rules for singularization
-     */
-    LATIN_GREEK: {
-        // Singular to plural transformations
-        toPlural: [
-            { regex: /^cactus$/i, replacement: "cacti" },
-            { regex: /^focus$/i, replacement: "foci" },
-            { regex: /^fungus$/i, replacement: "fungi" },
-            { regex: /^nucleus$/i, replacement: "nuclei" },
-            { regex: /^syllabus$/i, replacement: "syllabi" },
-            { regex: /^analysis$/i, replacement: "analyses" },
-            { regex: /^diagnosis$/i, replacement: "diagnoses" },
-            { regex: /^thesis$/i, replacement: "theses" },
-            { regex: /^criterion$/i, replacement: "criteria" },
-            { regex: /^datum$/i, replacement: "data" },
-            { regex: /^phenomenon$/i, replacement: "phenomena" },
-            { regex: /^index$/i, replacement: "indices" },
-            { regex: /^matrix$/i, replacement: "matrices" },
-            { regex: /^vertex$/i, replacement: "vertices" },
-            { regex: /^appendix$/i, replacement: "appendices" },
-        ],
-        // Plural to singular transformations
-        toSingular: [
-            { regex: /matrices$/i, replacement: "matrix" },
-            { regex: /indices$/i, replacement: "index" },
-            { regex: /vertices$/i, replacement: "vertex" },
-            { regex: /appendices$/i, replacement: "appendix" },
-            { regex: /cacti$/i, replacement: "cactus" },
-            { regex: /foci$/i, replacement: "focus" },
-            { regex: /fungi$/i, replacement: "fungus" },
-            { regex: /nuclei$/i, replacement: "nucleus" },
-            { regex: /syllabi$/i, replacement: "syllabus" },
-            { regex: /analyses$/i, replacement: "analysis" },
-            { regex: /diagnoses$/i, replacement: "diagnosis" },
-            { regex: /theses$/i, replacement: "thesis" },
-            { regex: /criteria$/i, replacement: "criterion" },
-            { regex: /data$/i, replacement: "datum" },
-            { regex: /phenomena$/i, replacement: "phenomenon" },
-        ],
-    },
-    /**
-     * Words with specific ending patterns
-     *
-     * This category contains rules for words that follow regular patterns based on
-     * their endings. These patterns represent the most common rules for English
-     * pluralization and singularization, covering a wide range of everyday words.
-     *
-     * The category is divided into two rule sets:
-     * - toPlural: Rules for converting singular forms to plural based on word endings
-     * - toSingular: Rules for converting plural forms back to singular
-     *
-     * Key pattern groups include:
-     *
-     * 1. Words ending in -f or -fe:
-     *    - "knife" → "knives", "life" → "lives", "wolf" → "wolves"
-     *
-     * 2. Words ending in -y:
-     *    - After consonant: "city" → "cities", "baby" → "babies"
-     *    - After vowel: "boy" → "boys", "key" → "keys"
-     *
-     * 3. Words ending in -o:
-     *    - Some specific words: "hero" → "heroes", "potato" → "potatoes"
-     *    - After consonant: "echo" → "echoes", "tomato" → "tomatoes"
-     *
-     * 4. Words ending in -s, -ss, -sh, -ch, -x, -z:
-     *    - "bus" → "buses", "box" → "boxes", "dish" → "dishes"
-     *
-     * These patterns cover the majority of regular English pluralization rules
-     * and are applied after checking for invariant words, irregular forms, and
-     * Latin/Greek words.
-     *
-     * @example
-     * ```typescript
-     * // Words ending in -f or -fe
-     * plural("knife");   // "knives"
-     * plural("life");    // "lives"
-     * plural("wolf");    // "wolves"
-     *
-     * // Words ending in -y
-     * plural("city");    // "cities"
-     * plural("boy");     // "boys"
-     *
-     * // Words ending in -o
-     * plural("hero");    // "heroes"
-     * plural("photo");   // "photos"
-     *
-     * // Words ending in -s, -ss, -sh, -ch, -x, -z
-     * plural("bus");     // "buses"
-     * plural("box");     // "boxes"
-     * plural("dish");    // "dishes"
-     *
-     * // Plural to singular
-     * singular("knives");  // "knife"
-     * singular("cities");  // "city"
-     * singular("boxes");   // "box"
-     * ```
-     *
-     * @see {@link plural} Function that applies these rules for pluralization
-     * @see {@link singular} Function that applies these rules for singularization
-     * @see {@link CHARACTERS_TO_REMOVE} Constant used in some replacement functions
-     */
-    PATTERN_RULES: {
-        // Singular to plural transformations
-        toPlural: [
-            // Words ending in -f or -fe
-            { regex: /^((?:wi|li)fe)$/i, replacement: "$1ves" },
-            { regex: /(fe)$/i, replacement: "ves" },
-            { regex: /([^f])f$/i, replacement: "$1ves" },
-            // Words ending in -y
-            { regex: /([^aeiou])y$/i, replacement: "$1ies" },
-            { regex: /([aeiou]y)$/i, replacement: "$1s" },
-            // Words ending in -o
-            { regex: /(hero|potato|tomato|torpedo|veto)$/i, replacement: "$1es" },
-            { regex: /([^aeiou])o$/i, replacement: "$1oes" },
-            // Words ending in -is
-            { regex: /(is)$/i, replacement: "es" },
-            // Words ending in -us
-            { regex: /(us)$/i, replacement: "uses" },
-            // Words ending in -s, -ss, -sh, -ch, -x, -z
-            { regex: /(s|ss|sh|ch|x|z)$/i, replacement: "$1es" },
-        ],
-        // Plural to singular transformations
-        toSingular: [
-            // Special spelling changes
-            { regex: /knives$/i, replacement: "knife" },
-            { regex: /lives$/i, replacement: "life" },
-            { regex: /shelves$/i, replacement: "shelf" },
-            // Common word patterns
-            {
-                regex: /(buses|dishes|matches)$/i,
-                replacement: (match) => match.slice(0, -constants_1.CHARACTERS_TO_REMOVE),
-            },
-            { regex: /([^aeiouy]|qu)ies$/i, replacement: "$1y" },
-            { regex: /(x|ch|ss|sh)es$/i, replacement: "$1" },
-            { regex: /oes$/i, replacement: "o" },
-            { regex: /ves$/i, replacement: "f" },
-        ],
-    },
-    /**
-     * Default rules for standard transformations
-     *
-     * This category contains fallback rules that are applied when no other rules match.
-     * These represent the most basic and common English pluralization pattern: adding
-     * an "s" to form plurals and removing an "s" to form singulars.
-     *
-     * The category is divided into two rule sets:
-     * - toPlural: Adds "s" to the end of any word to form its plural
-     * - toSingular: Removes a trailing "s" from any word to form its singular
-     *
-     * These rules are applied as a last resort after all other more specific rules
-     * have been checked. They handle the majority of regular English words that don't
-     * fall into any of the special categories or patterns.
-     *
-     * While simple, these rules can sometimes produce incorrect results for words that
-     * should follow more specific patterns but weren't included in the other rule sets.
-     * They're designed as a reasonable fallback rather than a comprehensive solution.
-     *
-     * @example
-     * ```typescript
-     * // Singular to plural with default rule
-     * plural("book");    // "books"
-     * plural("car");     // "cars"
-     * plural("apple");   // "apples"
-     *
-     * // Plural to singular with default rule
-     * singular("books");  // "book"
-     * singular("cars");   // "car"
-     * singular("apples"); // "apple"
-     * ```
-     *
-     * @see {@link plural} Function that applies these rules for pluralization
-     * @see {@link singular} Function that applies these rules for singularization
-     */
-    DEFAULT: {
-        toPlural: [{ regex: /(.*)$/i, replacement: "$1s" }],
-        toSingular: [{ regex: /s$/i, replacement: "" }],
-    },
-};
-//# sourceMappingURL=english-inflection-rules.js.map

package/constants/english-inflection-rules.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"english-inflection-rules.js","sourceRoot":"","sources":["../../../../libs/utils/src/constants/english-inflection-rules.ts"],"names":[],"mappings":"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"}

package/constants/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./constants"), exports);
-tslib_1.__exportStar(require("./english-inflection-rules"), exports);
-//# sourceMappingURL=index.js.map

package/constants/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/utils/src/constants/index.ts"],"names":[],"mappings":";;;AAAA,sDAA4B;AAC5B,qEAA2C"}

package/enums/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./template-tag.enum"), exports);
-//# sourceMappingURL=index.js.map

package/enums/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/utils/src/enums/index.ts"],"names":[],"mappings":";;;AAAA,8DAAoC"}

package/enums/template-tag.enum.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateTag = void 0;
-/**
- * Template tags for string transformations
- *
- * This enum defines all available template tags that can be used with the `applyTemplate`
- * and `applyTemplates` functions. Each tag corresponds to a specific string transformation
- * function from the string.utils module.
- *
- * Template tags are represented as strings in the format `#{transformationName}`. When these
- * tags appear in template strings, they are replaced with the result of applying the
- * corresponding transformation to the provided value.
- *
- * @see {@link applyTemplate} For applying a single value to a template
- * @see {@link applyTemplates} For applying multiple values to a template
- */
-var TemplateTag;
-(function (TemplateTag) {
-    TemplateTag["UPPER_CASE"] = "#{upperCase}";
-    TemplateTag["SNAKE_CASE"] = "#{snakeCase}";
-    TemplateTag["UPPER_SNAKE_CASE"] = "#{upperSnakeCase}";
-    TemplateTag["LOWER_CASE"] = "#{lowerCase}";
-    TemplateTag["SENTENCE_CASE"] = "#{sentenceCase}";
-    TemplateTag["FIRST_CASE"] = "#{firstCase}";
-    TemplateTag["CAMEL_CASE"] = "#{camelCase}";
-    TemplateTag["PASCAL_CASE"] = "#{pascalCase}";
-    TemplateTag["KEBAB_CASE"] = "#{kebabCase}";
-    TemplateTag["UPPER_KEBAB_CASE"] = "#{upperKebabCase}";
-    TemplateTag["TITLE_CASE"] = "#{titleCase}";
-    TemplateTag["LOWER_CASE_BREAK"] = "#{lowerCaseBreak}";
-    TemplateTag["UPPER_CASE_BREAK"] = "#{upperCaseBreak}";
-    TemplateTag["FIRST_CASE_BREAK"] = "#{firstCaseBreak}";
-    TemplateTag["SINGULAR"] = "#{singular}";
-    TemplateTag["NUMBER"] = "#{number}";
-    TemplateTag["HTML_TO_TEXT"] = "#{htmlToText}";
-    // FORMAT = "#{format}",
-})(TemplateTag || (exports.TemplateTag = TemplateTag = {}));
-//# sourceMappingURL=template-tag.enum.js.map

package/enums/template-tag.enum.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"template-tag.enum.js","sourceRoot":"","sources":["../../../../libs/utils/src/enums/template-tag.enum.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;GAaG;AACH,IAAY,WAmBX;AAnBD,WAAY,WAAW;IACnB,0CAA2B,CAAA;IAC3B,0CAA2B,CAAA;IAC3B,qDAAsC,CAAA;IACtC,0CAA2B,CAAA;IAC3B,gDAAiC,CAAA;IACjC,0CAA2B,CAAA;IAC3B,0CAA2B,CAAA;IAC3B,4CAA6B,CAAA;IAC7B,0CAA2B,CAAA;IAC3B,qDAAsC,CAAA;IACtC,0CAA2B,CAAA;IAC3B,qDAAsC,CAAA;IACtC,qDAAsC,CAAA;IACtC,qDAAsC,CAAA;IACtC,uCAAwB,CAAA;IACxB,mCAAoB,CAAA;IACpB,6CAA8B,CAAA;IAC9B,wBAAwB;AAC5B,CAAC,EAnBW,WAAW,2BAAX,WAAW,QAmBtB"}