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