"use strict";
/*!
 * inflection
 * Copyright(c) 2011 Ben Lin <ben@dreamerslab.com>
 * MIT Licensed
 *
 * @fileoverview
 * A port of inflection-js to node.js module.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.transform = exports.ordinalize = exports.foreignKey = exports.classify = exports.tableize = exports.demodulize = exports.titleize = exports.dasherize = exports.capitalize = exports.humanize = exports.underscore = exports.camelize = exports.inflect = exports.singularize = exports.pluralize = void 0;
/**
 * @description This is a list of nouns that use the same form for both singular and plural.
 *              This list should remain entirely in lower case to correctly match Strings.
 */
const uncountableWords = [
    // 'access',
    'accommodation',
    'adulthood',
    'advertising',
    'advice',
    'aggression',
    'aid',
    'air',
    'aircraft',
    'alcohol',
    'anger',
    'applause',
    'arithmetic',
    // 'art',
    'assistance',
    'athletics',
    // 'attention',
    'bacon',
    'baggage',
    // 'ballet',
    // 'beauty',
    'beef',
    // 'beer',
    // 'behavior',
    'biology',
    // 'billiards',
    'blood',
    'botany',
    // 'bowels',
    'bread',
    // 'business',
    'butter',
    'carbon',
    'cardboard',
    'cash',
    'chalk',
    'chaos',
    'chess',
    'crossroads',
    'countryside',
    // 'damage',
    'dancing',
    // 'danger',
    'deer',
    // 'delight',
    // 'dessert',
    'dignity',
    'dirt',
    // 'distribution',
    'dust',
    'economics',
    'education',
    'electricity',
    // 'employment',
    // 'energy',
    'engineering',
    'enjoyment',
    // 'entertainment',
    'envy',
    'equipment',
    'ethics',
    'evidence',
    'evolution',
    // 'failure',
    // 'faith',
    'fame',
    'fiction',
    // 'fish',
    'flour',
    'flu',
    'food',
    // 'freedom',
    // 'fruit',
    'fuel',
    'fun',
    // 'funeral',
    'furniture',
    'gallows',
    'garbage',
    'garlic',
    // 'gas',
    'genetics',
    // 'glass',
    'gold',
    'golf',
    'gossip',
    // 'grass',
    'gratitude',
    'grief',
    // 'ground',
    'guilt',
    'gymnastics',
    // 'hair',
    'happiness',
    'hardware',
    'harm',
    'hate',
    'hatred',
    'health',
    'heat',
    // 'height',
    'help',
    'homework',
    'honesty',
    'honey',
    'hospitality',
    'housework',
    'humour',
    'hunger',
    'hydrogen',
    'ice',
    'importance',
    'inflation',
    'information',
    // 'injustice',
    'innocence',
    // 'intelligence',
    'iron',
    'irony',
    'jam',
    // 'jealousy',
    // 'jelly',
    'jewelry',
    // 'joy',
    'judo',
    // 'juice',
    // 'justice',
    'karate',
    // 'kindness',
    'knowledge',
    // 'labour',
    'lack',
    // 'land',
    'laughter',
    'lava',
    'leather',
    'leisure',
    'lightning',
    'linguine',
    'linguini',
    'linguistics',
    'literature',
    'litter',
    'livestock',
    'logic',
    'loneliness',
    // 'love',
    'luck',
    'luggage',
    'macaroni',
    'machinery',
    'magic',
    // 'mail',
    'management',
    'mankind',
    'marble',
    'mathematics',
    'mayonnaise',
    'measles',
    // 'meat',
    // 'metal',
    'methane',
    'milk',
    'minus',
    'money',
    // 'moose',
    'mud',
    'music',
    'mumps',
    'nature',
    'news',
    'nitrogen',
    'nonsense',
    'nurture',
    'nutrition',
    'obedience',
    'obesity',
    // 'oil',
    'oxygen',
    // 'paper',
    // 'passion',
    'pasta',
    'patience',
    // 'permission',
    'physics',
    'poetry',
    'pollution',
    'poverty',
    // 'power',
    'pride',
    // 'production',
    // 'progress',
    // 'pronunciation',
    'psychology',
    'publicity',
    'punctuation',
    // 'quality',
    // 'quantity',
    'quartz',
    'racism',
    // 'rain',
    // 'recreation',
    'relaxation',
    'reliability',
    'research',
    'respect',
    'revenge',
    'rice',
    'rubbish',
    'rum',
    'safety',
    // 'salad',
    // 'salt',
    // 'sand',
    // 'satire',
    'scenery',
    'seafood',
    'seaside',
    'series',
    'shame',
    'sheep',
    'shopping',
    // 'silence',
    'sleep',
    // 'slang'
    'smoke',
    'smoking',
    'snow',
    'soap',
    'software',
    'soil',
    // 'sorrow',
    // 'soup',
    'spaghetti',
    // 'speed',
    'species',
    // 'spelling',
    // 'sport',
    'steam',
    // 'strength',
    'stuff',
    'stupidity',
    // 'success',
    // 'sugar',
    'sunshine',
    'symmetry',
    // 'tea',
    'tennis',
    'thirst',
    'thunder',
    'timber',
    // 'time',
    // 'toast',
    // 'tolerance',
    // 'trade',
    'traffic',
    'transportation',
    // 'travel',
    'trust',
    // 'understanding',
    'underwear',
    'unemployment',
    'unity',
    // 'usage',
    'validity',
    'veal',
    'vegetation',
    'vegetarianism',
    'vengeance',
    'violence',
    // 'vision',
    'vitality',
    'warmth',
    // 'water',
    'wealth',
    'weather',
    // 'weight',
    'welfare',
    'wheat',
    // 'whiskey',
    // 'width',
    'wildlife',
    // 'wine',
    'wisdom',
    // 'wood',
    // 'wool',
    // 'work',
    // 'yeast',
    'yoga',
    'zinc',
    'zoology',
];
/**
 * @description These rules translate from the singular form of a noun to its plural form.
 */
const regex = {
    plural: {
        men: new RegExp('^(m|wom)en$', 'gi'),
        people: new RegExp('(pe)ople$', 'gi'),
        children: new RegExp('(child)ren$', 'gi'),
        tia: new RegExp('([ti])a$', 'gi'),
        analyses: new RegExp('((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$', 'gi'),
        databases: new RegExp('(database)s$', 'gi'),
        drives: new RegExp('(drive)s$', 'gi'),
        hives: new RegExp('(hi|ti)ves$', 'gi'),
        curves: new RegExp('(curve)s$', 'gi'),
        lrves: new RegExp('([lr])ves$', 'gi'),
        aves: new RegExp('([a])ves$', 'gi'),
        foves: new RegExp('([^fo])ves$', 'gi'),
        movies: new RegExp('(m)ovies$', 'gi'),
        aeiouyies: new RegExp('([^aeiouy]|qu)ies$', 'gi'),
        series: new RegExp('(s)eries$', 'gi'),
        xes: new RegExp('(x|ch|ss|sh)es$', 'gi'),
        mice: new RegExp('([m|l])ice$', 'gi'),
        buses: new RegExp('(bus)es$', 'gi'),
        oes: new RegExp('(o)es$', 'gi'),
        shoes: new RegExp('(shoe)s$', 'gi'),
        crises: new RegExp('(cris|ax|test)es$', 'gi'),
        octopuses: new RegExp('(octop|vir)uses$', 'gi'),
        aliases: new RegExp('(alias|canvas|status|campus)es$', 'gi'),
        summonses: new RegExp('^(summons|bonus)es$', 'gi'),
        oxen: new RegExp('^(ox)en', 'gi'),
        matrices: new RegExp('(matr)ices$', 'gi'),
        vertices: new RegExp('(vert|ind)ices$', 'gi'),
        feet: new RegExp('^feet$', 'gi'),
        teeth: new RegExp('^teeth$', 'gi'),
        geese: new RegExp('^geese$', 'gi'),
        quizzes: new RegExp('(quiz)zes$', 'gi'),
        whereases: new RegExp('^(whereas)es$', 'gi'),
        criteria: new RegExp('^(criteri)a$', 'gi'),
        genera: new RegExp('^genera$', 'gi'),
        ss: new RegExp('ss$', 'gi'),
        s: new RegExp('s$', 'gi'),
    },
    singular: {
        man: new RegExp('^(m|wom)an$', 'gi'),
        person: new RegExp('(pe)rson$', 'gi'),
        child: new RegExp('(child)$', 'gi'),
        drive: new RegExp('(drive)$', 'gi'),
        ox: new RegExp('^(ox)$', 'gi'),
        axis: new RegExp('(ax|test)is$', 'gi'),
        octopus: new RegExp('(octop|vir)us$', 'gi'),
        alias: new RegExp('(alias|status|canvas|campus)$', 'gi'),
        summons: new RegExp('^(summons|bonus)$', 'gi'),
        bus: new RegExp('(bu)s$', 'gi'),
        buffalo: new RegExp('(buffal|tomat|potat)o$', 'gi'),
        tium: new RegExp('([ti])um$', 'gi'),
        sis: new RegExp('sis$', 'gi'),
        ffe: new RegExp('(?:([^f])fe|([lr])f)$', 'gi'),
        hive: new RegExp('(hi|ti)ve$', 'gi'),
        aeiouyy: new RegExp('([^aeiouy]|qu)y$', 'gi'),
        x: new RegExp('(x|ch|ss|sh)$', 'gi'),
        matrix: new RegExp('(matr)ix$', 'gi'),
        vertex: new RegExp('(vert|ind)ex$', 'gi'),
        mouse: new RegExp('([m|l])ouse$', 'gi'),
        foot: new RegExp('^foot$', 'gi'),
        tooth: new RegExp('^tooth$', 'gi'),
        goose: new RegExp('^goose$', 'gi'),
        quiz: new RegExp('(quiz)$', 'gi'),
        whereas: new RegExp('^(whereas)$', 'gi'),
        criterion: new RegExp('^(criteri)on$', 'gi'),
        genus: new RegExp('^genus$', 'gi'),
        s: new RegExp('s$', 'gi'),
        common: new RegExp('$', 'gi'),
    },
};
const pluralRules = [
    // do not replace if its already a plural word
    [regex.plural.men],
    [regex.plural.people],
    [regex.plural.children],
    [regex.plural.tia],
    [regex.plural.analyses],
    [regex.plural.databases],
    [regex.plural.drives],
    [regex.plural.hives],
    [regex.plural.curves],
    [regex.plural.lrves],
    [regex.plural.foves],
    [regex.plural.aeiouyies],
    [regex.plural.series],
    [regex.plural.movies],
    [regex.plural.xes],
    [regex.plural.mice],
    [regex.plural.buses],
    [regex.plural.oes],
    [regex.plural.shoes],
    [regex.plural.crises],
    [regex.plural.octopuses],
    [regex.plural.aliases],
    [regex.plural.summonses],
    [regex.plural.oxen],
    [regex.plural.matrices],
    [regex.plural.feet],
    [regex.plural.teeth],
    [regex.plural.geese],
    [regex.plural.quizzes],
    [regex.plural.whereases],
    [regex.plural.criteria],
    [regex.plural.genera],
    // original rule
    [regex.singular.man, '$1en'],
    [regex.singular.person, '$1ople'],
    [regex.singular.child, '$1ren'],
    [regex.singular.drive, '$1s'],
    [regex.singular.ox, '$1en'],
    [regex.singular.axis, '$1es'],
    [regex.singular.octopus, '$1uses'],
    [regex.singular.alias, '$1es'],
    [regex.singular.summons, '$1es'],
    [regex.singular.bus, '$1ses'],
    [regex.singular.buffalo, '$1oes'],
    [regex.singular.tium, '$1a'],
    [regex.singular.sis, 'ses'],
    [regex.singular.ffe, '$1$2ves'],
    [regex.singular.hive, '$1ves'],
    [regex.singular.aeiouyy, '$1ies'],
    [regex.singular.matrix, '$1ices'],
    [regex.singular.vertex, '$1ices'],
    [regex.singular.x, '$1es'],
    [regex.singular.mouse, '$1ice'],
    [regex.singular.foot, 'feet'],
    [regex.singular.tooth, 'teeth'],
    [regex.singular.goose, 'geese'],
    [regex.singular.quiz, '$1zes'],
    [regex.singular.whereas, '$1es'],
    [regex.singular.criterion, '$1a'],
    [regex.singular.genus, 'genera'],
    [regex.singular.s, 's'],
    [regex.singular.common, 's'],
];
/**
 * @description These rules translate from the plural form of a noun to its singular form.
 */
const singularRules = [
    // do not replace if its already a singular word
    [regex.singular.man],
    [regex.singular.person],
    [regex.singular.child],
    [regex.singular.drive],
    [regex.singular.ox],
    [regex.singular.axis],
    [regex.singular.octopus],
    [regex.singular.alias],
    [regex.singular.summons],
    [regex.singular.bus],
    [regex.singular.buffalo],
    [regex.singular.tium],
    [regex.singular.sis],
    [regex.singular.ffe],
    [regex.singular.hive],
    [regex.singular.aeiouyy],
    [regex.singular.x],
    [regex.singular.matrix],
    [regex.singular.mouse],
    [regex.singular.foot],
    [regex.singular.tooth],
    [regex.singular.goose],
    [regex.singular.quiz],
    [regex.singular.whereas],
    [regex.singular.criterion],
    [regex.singular.genus],
    // original rule
    [regex.plural.men, '$1an'],
    [regex.plural.people, '$1rson'],
    [regex.plural.children, '$1'],
    [regex.plural.databases, '$1'],
    [regex.plural.drives, '$1'],
    [regex.plural.genera, 'genus'],
    [regex.plural.criteria, '$1on'],
    [regex.plural.tia, '$1um'],
    [regex.plural.analyses, '$1$2sis'],
    [regex.plural.hives, '$1ve'],
    [regex.plural.curves, '$1'],
    [regex.plural.lrves, '$1f'],
    [regex.plural.aves, '$1ve'],
    [regex.plural.foves, '$1fe'],
    [regex.plural.movies, '$1ovie'],
    [regex.plural.aeiouyies, '$1y'],
    [regex.plural.series, '$1eries'],
    [regex.plural.xes, '$1'],
    [regex.plural.mice, '$1ouse'],
    [regex.plural.buses, '$1'],
    [regex.plural.oes, '$1'],
    [regex.plural.shoes, '$1'],
    [regex.plural.crises, '$1is'],
    [regex.plural.octopuses, '$1us'],
    [regex.plural.aliases, '$1'],
    [regex.plural.summonses, '$1'],
    [regex.plural.oxen, '$1'],
    [regex.plural.matrices, '$1ix'],
    [regex.plural.vertices, '$1ex'],
    [regex.plural.feet, 'foot'],
    [regex.plural.teeth, 'tooth'],
    [regex.plural.geese, 'goose'],
    [regex.plural.quizzes, '$1'],
    [regex.plural.whereases, '$1'],
    [regex.plural.ss, 'ss'],
    [regex.plural.s, ''],
];
/**
 * @description This is a list of words that should not be capitalized for title case.
 */
const nonTitlecasedWords = [
    'and',
    'or',
    'nor',
    'a',
    'an',
    'the',
    'so',
    'but',
    'to',
    'of',
    'at',
    'by',
    'from',
    'into',
    'on',
    'onto',
    'off',
    'out',
    'in',
    'over',
    'with',
    'for',
];
/**
 * @description These are regular expressions used for converting between String formats.
 */
const idSuffix = new RegExp('(_ids|_id)$', 'g');
const underbar = new RegExp('_', 'g');
const spaceOrUnderbar = new RegExp('[ _]', 'g');
const uppercase = new RegExp('([A-Z])', 'g');
const underbarPrefix = new RegExp('^_');
/**
 * A helper method that applies rules based replacement to a String.
 * @param str String to modify and return based on the passed rules.
 * @param rules Regexp to match paired with String to use for replacement
 * @param skip Strings to skip if they match
 * @param override String to return as though this method succeeded (used to conform to APIs)
 * @returns Return passed String modified by passed rules.
 * @example
 *
 *     applyRules( 'cows', singular_rules ); // === 'cow'
 */
function applyRules(str, rules, skip, override) {
    if (override) {
        return override;
    }
    else {
        if (skip.includes(str.toLocaleLowerCase())) {
            return str;
        }
        for (const rule of rules) {
            if (str.match(rule[0])) {
                if (rule[1] !== undefined) {
                    return str.replace(rule[0], rule[1]);
                }
                return str;
            }
        }
    }
    return str;
}
/**
 * This function adds pluralization support to every String object.
 * @param str The subject string.
 * @param plural Overrides normal output with said String.(optional)
 * @returns Singular English language nouns are returned in plural form.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.pluralize( 'person' ); // === 'people'
 *     inflection.pluralize( 'octopus' ); // === 'octopuses'
 *     inflection.pluralize( 'Hat' ); // === 'Hats'
 *     inflection.pluralize( 'person', 'guys' ); // === 'guys'
 */
function pluralize(str, plural) {
    return applyRules(str, pluralRules, uncountableWords, plural);
}
exports.pluralize = pluralize;
/**
 * This function adds singularization support to every String object.
 * @param str The subject string.
 * @param singular Overrides normal output with said String.(optional)
 * @returns Plural English language nouns are returned in singular form.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.singularize( 'people' ); // === 'person'
 *     inflection.singularize( 'octopuses' ); // === 'octopus'
 *     inflection.singularize( 'Hats' ); // === 'Hat'
 *     inflection.singularize( 'guys', 'person' ); // === 'person'
 */
function singularize(str, singular) {
    return applyRules(str, singularRules, uncountableWords, singular);
}
exports.singularize = singularize;
/**
 * This function will pluralize or singularlize a String appropriately based on a number value
 * @param str The subject string.
 * @param count The number to base pluralization off of.
 * @param singular Overrides normal output with said String.(optional)
 * @param plural Overrides normal output with said String.(optional)
 * @returns English language nouns are returned in the plural or singular form based on the count.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.inflect( 'people' 1 ); // === 'person'
 *     inflection.inflect( 'octopuses' 1 ); // === 'octopus'
 *     inflection.inflect( 'Hats' 1 ); // === 'Hat'
 *     inflection.inflect( 'guys', 1 , 'person' ); // === 'person'
 *     inflection.inflect( 'inches', 1.5 ); // === 'inches'
 *     inflection.inflect( 'person', 2 ); // === 'people'
 *     inflection.inflect( 'octopus', 2 ); // === 'octopuses'
 *     inflection.inflect( 'Hat', 2 ); // === 'Hats'
 *     inflection.inflect( 'person', 2, null, 'guys' ); // === 'guys'
 */
function inflect(str, count, singular, plural) {
    if (isNaN(count))
        return str;
    if (count === 1) {
        return applyRules(str, singularRules, uncountableWords, singular);
    }
    else {
        return applyRules(str, pluralRules, uncountableWords, plural);
    }
}
exports.inflect = inflect;
/**
 * This function adds camelization support to every String object.
 * @param str The subject string.
 * @param lowFirstLetter Default is to capitalize the first letter of the results.(optional)
 *                                 Passing true will lowercase it.
 * @returns Lower case underscored words will be returned in camel case.
 *                  additionally '/' is translated to '::'
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.camelize( 'message_properties' ); // === 'MessageProperties'
 *     inflection.camelize( 'message_properties', true ); // === 'messageProperties'
 */
function camelize(str, lowFirstLetter) {
    const strPath = str.split('/');
    const j = strPath.length;
    let strArr, k, l, first;
    for (let i = 0; i < j; i++) {
        strArr = strPath[i].split('_');
        k = 0;
        l = strArr.length;
        for (; k < l; k++) {
            if (k !== 0) {
                strArr[k] = strArr[k].toLowerCase();
            }
            first = strArr[k].charAt(0);
            first =
                lowFirstLetter && i === 0 && k === 0
                    ? first.toLowerCase()
                    : first.toUpperCase();
            strArr[k] = first + strArr[k].substring(1);
        }
        strPath[i] = strArr.join('');
    }
    return strPath.join('::');
}
exports.camelize = camelize;
/**
 * This function adds underscore support to every String object.
 * @param str The subject string.
 * @param allUpperCase Default is to lowercase and add underscore prefix.(optional)
 *                  Passing true will return as entered.
 * @returns Camel cased words are returned as lower cased and underscored.
 *                  additionally '::' is translated to '/'.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.underscore( 'MessageProperties' ); // === 'message_properties'
 *     inflection.underscore( 'messageProperties' ); // === 'message_properties'
 *     inflection.underscore( 'MP', true ); // === 'MP'
 */
function underscore(str, allUpperCase) {
    if (allUpperCase && str === str.toUpperCase())
        return str;
    const strPath = str.split('::');
    const j = strPath.length;
    for (let i = 0; i < j; i++) {
        strPath[i] = strPath[i].replace(uppercase, '_$1');
        strPath[i] = strPath[i].replace(underbarPrefix, '');
    }
    return strPath.join('/').toLowerCase();
}
exports.underscore = underscore;
/**
 * This function adds humanize support to every String object.
 * @param str The subject string.
 * @param lowFirstLetter Default is to capitalize the first letter of the results.(optional)
 *                                 Passing true will lowercase it.
 * @returns Lower case underscored words will be returned in humanized form.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.humanize( 'message_properties' ); // === 'Message properties'
 *     inflection.humanize( 'message_properties', true ); // === 'message properties'
 */
function humanize(str, lowFirstLetter) {
    str = str.toLowerCase();
    str = str.replace(idSuffix, '');
    str = str.replace(underbar, ' ');
    if (!lowFirstLetter) {
        str = capitalize(str);
    }
    return str;
}
exports.humanize = humanize;
/**
 * This function adds capitalization support to every String object.
 * @param str The subject string.
 * @returns All characters will be lower case and the first will be upper.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.capitalize( 'message_properties' ); // === 'Message_properties'
 *     inflection.capitalize( 'message properties', true ); // === 'Message properties'
 */
function capitalize(str) {
    str = str.toLowerCase();
    return str.substring(0, 1).toUpperCase() + str.substring(1);
}
exports.capitalize = capitalize;
/**
 * This function replaces underscores with dashes in the string.
 * @param str The subject string.
 * @returns Replaces all spaces or underscores with dashes.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.dasherize( 'message_properties' ); // === 'message-properties'
 *     inflection.dasherize( 'Message Properties' ); // === 'Message-Properties'
 */
function dasherize(str) {
    return str.replace(spaceOrUnderbar, '-');
}
exports.dasherize = dasherize;
/**
 * This function adds titleize support to every String object.
 * @param str The subject string.
 * @returns Capitalizes words as you would for a book title.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.titleize( 'message_properties' ); // === 'Message Properties'
 *     inflection.titleize( 'message properties to keep' ); // === 'Message Properties to Keep'
 */
function titleize(str) {
    str = str.toLowerCase().replace(underbar, ' ');
    const strArr = str.split(' ');
    const j = strArr.length;
    let d, l;
    for (let i = 0; i < j; i++) {
        d = strArr[i].split('-');
        l = d.length;
        for (let k = 0; k < l; k++) {
            if (nonTitlecasedWords.indexOf(d[k].toLowerCase()) < 0) {
                d[k] = capitalize(d[k]);
            }
        }
        strArr[i] = d.join('-');
    }
    str = strArr.join(' ');
    str = str.substring(0, 1).toUpperCase() + str.substring(1);
    return str;
}
exports.titleize = titleize;
/**
 * This function adds demodulize support to every String object.
 * @param str The subject string.
 * @returns Removes module names leaving only class names.(Ruby style)
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.demodulize( 'Message::Bus::Properties' ); // === 'Properties'
 */
function demodulize(str) {
    const strArr = str.split('::');
    return strArr[strArr.length - 1];
}
exports.demodulize = demodulize;
/**
 * This function adds tableize support to every String object.
 * @param str The subject string.
 * @returns Return camel cased words into their underscored plural form.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.tableize( 'MessageBusProperty' ); // === 'message_bus_properties'
 */
function tableize(str) {
    str = underscore(str);
    str = pluralize(str);
    return str;
}
exports.tableize = tableize;
/**
 * This function adds classification support to every String object.
 * @param str The subject string.
 * @returns Underscored plural nouns become the camel cased singular form.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.classify( 'message_bus_properties' ); // === 'MessageBusProperty'
 */
function classify(str) {
    str = camelize(str);
    str = singularize(str);
    return str;
}
exports.classify = classify;
/**
   * This function adds foreign key support to every String object.
   * @param str The subject string.
   * @param dropIdUbar Default is to seperate id with an underbar at the end of the class name,
                                 you can pass true to skip it.(optional)
   * @returns Underscored plural nouns become the camel cased singular form.
   * @example
   *
   *     const inflection = require( 'inflection' );
   *
   *     inflection.foreign_key( 'MessageBusProperty' ); // === 'message_bus_property_id'
   *     inflection.foreign_key( 'MessageBusProperty', true ); // === 'message_bus_propertyid'
   */
function foreignKey(str, dropIdUbar) {
    str = demodulize(str);
    str = underscore(str) + (dropIdUbar ? '' : '_') + 'id';
    return str;
}
exports.foreignKey = foreignKey;
/**
 * This function adds ordinalize support to every String object.
 * @param str The subject string.
 * @returns Return all found numbers their sequence like '22nd'.
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.ordinalize( 'the 1 pitch' ); // === 'the 1st pitch'
 */
function ordinalize(str) {
    const strArr = str.split(' ');
    const j = strArr.length;
    for (let i = 0; i < j; i++) {
        const k = parseInt(strArr[i], 10);
        if (!isNaN(k)) {
            const ltd = strArr[i].substring(strArr[i].length - 2);
            const ld = strArr[i].substring(strArr[i].length - 1);
            let suf = 'th';
            if (ltd != '11' && ltd != '12' && ltd != '13') {
                if (ld === '1') {
                    suf = 'st';
                }
                else if (ld === '2') {
                    suf = 'nd';
                }
                else if (ld === '3') {
                    suf = 'rd';
                }
            }
            strArr[i] += suf;
        }
    }
    return strArr.join(' ');
}
exports.ordinalize = ordinalize;
const transformFunctions = {
    pluralize,
    singularize,
    camelize,
    underscore,
    humanize,
    capitalize,
    dasherize,
    titleize,
    demodulize,
    tableize,
    classify,
    foreignKey,
    ordinalize,
};
/**
 * This function performs multiple inflection methods on a string
 * @param str The subject string.
 * @param arr An array of inflection methods.
 * @returns
 * @example
 *
 *     const inflection = require( 'inflection' );
 *
 *     inflection.transform( 'all job', [ 'pluralize', 'capitalize', 'dasherize' ]); // === 'All-jobs'
 */
function transform(str, arr) {
    const j = arr.length;
    for (let i = 0; i < j; i++) {
        const method = arr[i];
        const methodFn = transformFunctions[method];
        if (methodFn) {
            str = methodFn(str);
        }
    }
    return str;
}
exports.transform = transform;
