namefully 1.1.0 → 1.2.1

package/dist/lib/namefully.js

@@ -1,723 +1,410 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Namefully_instances, _Namefully_fullName, _Namefully_toParser, _Namefully_map;
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Welcome to namefully!
- *
- * namefully is a JS utility for handing person names.
- *
- * Sources
- * - repo: https://github.com/ralflorent/namefully
- * - docs: https://namefully.netlify.app
- * - npm: https://npmjs.com/package/namefully
- *
- * Created on March 03, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- * @license MIT
- */
-const core_1 = require("./core");
-const models_1 = require("./models");
-const validators_1 = require("./validators");
-/**
- * Person name handler
- * @class
- *
- * `Namefully` does not magically guess which part of the name is what. It relies
- * actually on how the developer indicates the roles of the name parts so that
- * it, internally, can perform certain operations and saves the developer some
- * calculations/processings. Nevertheless, Namefully can be constructed using
- * distinct raw data shape. This is intended to give some flexibility to the
- * developer so that he or she is not bound to a particular data format. Please,
- * do follow closely the APIs to know how to properly use it in order to avoid
- * some errors (mainly validation's).
- *
- * `Namefully` also works like a trap door. Once a raw data is provided and
- * validated, a developer can only ACCESS in a vast amount of, yet effective ways
- * the name info. NO EDITING is possible. If the name is mistaken, a new instance
- * of `Namefully` must be created. Remember, this utility's primary objective is
- * to help to **handle** a person name.
- *
- * Note that the name standards used for the current version of this library are
- * as follows:
- *      [Prefix] Firstname [Middlename] Lastname [Suffix]
- * The opening `[` and closing `]` brackets mean that these parts are optional.
- * In other words, the most basic and typical case is a name that looks like this:
- * `John Smith`, where `John` is the first name and `Smith`, the last name.
- * @see https://departments.weber.edu/qsupport&training/Data_Standards/Name.htm
- * for more info on name standards.
- *
- * **IMPORTANT**: Keep in mind that the order of appearance matters and can be
- * altered through configured parameters, which we will be seeing later on. By
- * default, the order of appearance is as shown above and will be used as a basis
- * for future examples and use cases.
- *
- * Once imported, all that is required to do is to create an instance of
- * `Namefully` and the rest will follow.
- *
- * Some terminologies used across the library are:
- * - namon: 1 piece of a name (e.g., firstname)
- * - nama: 2+ pieces of a name (e.g., firstname + lastname)
- *
- * Happy handling!
- */
+exports.Namefully = void 0;
+const constants_1 = require("./constants");
+const error_1 = require("./error");
+const parser_1 = require("./parser");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
 class Namefully {
-    /**
-     * Constructs an instance of the utility and helps to benefit from many helpers
-     * @param {string | string[] | Name[] | Nama | Fullname} raw element to parse or
-     * construct the pieces of the name
-     * @param {Config} options to configure how to run the utility
-     */
-    constructor(raw, options) {
-        // well, first thing first
-        this.configure(options);
-        // let's try to parse this, baby!
-        this.build(raw);
-    }
-    /**
-     * Gets the full name ordered as configured
-     * @param {NameOrder} orderedBy force to order by first or last
-     * name by overriding the preset configuration
-     *
-     * @see {format} to alter manually the order of appearance of the full name.
-     * For example, ::format('l f m') outputs `lastname firstname middlename`.
-     */
-    getFullname(orderedBy) {
-        orderedBy = this.parseNameOrder(orderedBy);
-        const { titling, ending } = this.config;
-        const pxSep = titling === 'us' ? models_1.Separator.PERIOD : models_1.Separator.EMPTY; // Mr[.]
-        const sxSep = ending ? ',' : models_1.Separator.EMPTY; // [,] PhD
-        const nama = [];
-        if (this.fullname.prefix)
-            nama.push(models_1.Separator.EMPTY.concat(this.fullname.prefix, pxSep));
-        if (orderedBy === 'firstname') {
-            nama.push(this.getFirstname());
-            nama.push(...this.getMiddlenames());
-            nama.push(models_1.Separator.EMPTY.concat(this.getLastname(), sxSep));
+    constructor(names, options) {
+        _Namefully_instances.add(this);
+        _Namefully_fullName.set(this, void 0);
+        __classPrivateFieldSet(this, _Namefully_fullName, __classPrivateFieldGet(this, _Namefully_instances, "m", _Namefully_toParser).call(this, names).parse(options), "f");
+    }
+    static tryParse(text) {
+        try {
+            return new this(parser_1.Parser.build(text));
         }
-        else {
-            nama.push(this.getLastname());
-            nama.push(this.getFirstname());
-            nama.push(this.getMiddlenames().join(models_1.Separator.SPACE).concat(sxSep));
+        catch (error) {
+            return undefined;
         }
-        if (this.fullname.suffix)
-            nama.push(this.fullname.suffix);
-        return nama.join(models_1.Separator.SPACE);
-    }
-    /**
-     * Gets the birth name ordered as configured, no prefix or suffix
-     * @param {NameOrder} orderedBy force to order by first or last
-     * name by overriding the preset configuration
-     */
-    getBirthname(orderedBy) {
-        orderedBy = this.parseNameOrder(orderedBy);
-        const nama = [];
-        if (orderedBy === 'firstname') {
-            nama.push(this.getFirstname());
-            nama.push(...this.getMiddlenames());
-            nama.push(this.getLastname());
+    }
+    static parse(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return parser_1.Parser.buildAsync(text).then((parser) => new Namefully(parser));
+        });
+    }
+    get config() {
+        return __classPrivateFieldGet(this, _Namefully_fullName, "f").config;
+    }
+    get length() {
+        return this.birth.length;
+    }
+    get prefix() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Namefully_fullName, "f").prefix) === null || _a === void 0 ? void 0 : _a.toString();
+    }
+    get first() {
+        return this.firstName();
+    }
+    get middle() {
+        return this.hasMiddle ? this.middleName()[0] : undefined;
+    }
+    get hasMiddle() {
+        return __classPrivateFieldGet(this, _Namefully_fullName, "f").has(types_1.Namon.MIDDLE_NAME);
+    }
+    get last() {
+        return this.lastName();
+    }
+    get suffix() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Namefully_fullName, "f").suffix) === null || _a === void 0 ? void 0 : _a.toString();
+    }
+    get birth() {
+        return this.birthName();
+    }
+    get short() {
+        return this.shorten();
+    }
+    get long() {
+        return this.birth;
+    }
+    get full() {
+        return this.fullName();
+    }
+    get public() {
+        return this.format('f $l');
+    }
+    toString() {
+        return this.full;
+    }
+    get(namon) {
+        if (namon.equal(types_1.Namon.PREFIX))
+            return __classPrivateFieldGet(this, _Namefully_fullName, "f").prefix;
+        if (namon.equal(types_1.Namon.FIRST_NAME))
+            return __classPrivateFieldGet(this, _Namefully_fullName, "f").firstName;
+        if (namon.equal(types_1.Namon.MIDDLE_NAME))
+            return __classPrivateFieldGet(this, _Namefully_fullName, "f").middleName;
+        if (namon.equal(types_1.Namon.LAST_NAME))
+            return __classPrivateFieldGet(this, _Namefully_fullName, "f").lastName;
+        if (namon.equal(types_1.Namon.SUFFIX))
+            return __classPrivateFieldGet(this, _Namefully_fullName, "f").suffix;
+        return undefined;
+    }
+    equal(other) {
+        return this.toString() === other.toString();
+    }
+    toJson() {
+        return {
+            prefix: this.prefix,
+            firstName: this.first,
+            middleName: this.middleName(),
+            lastName: this.last,
+            suffix: this.suffix,
+        };
+    }
+    has(namon) {
+        return __classPrivateFieldGet(this, _Namefully_fullName, "f").has(namon);
+    }
+    fullName(orderedBy) {
+        const sep = this.config.ending ? ',' : '';
+        const names = [];
+        orderedBy = orderedBy || this.config.orderedBy;
+        if (this.prefix)
+            names.push(this.prefix);
+        if (orderedBy === types_1.NameOrder.FIRST_NAME) {
+            names.push(this.first, ...this.middleName(), this.last + sep);
         }
         else {
-            nama.push(this.getLastname());
-            nama.push(this.getFirstname());
-            nama.push(...this.getMiddlenames());
-        }
-        return nama.join(models_1.Separator.SPACE);
-    }
-    /**
-     * Gets the first name part of the full name
-     * @param {boolean} includeAll whether to include other pieces of the first
-     * name
-     */
-    getFirstname(includeAll = true) {
-        return this.fullname.firstname.tostring(includeAll);
-    }
-    /**
-     * Gets the last name part of the full name
-     * @param {LastnameFormat} [format] overrides the how-to format of a surname
-     * output, considering its subparts.
-     */
-    getLastname(format) {
-        return this.fullname.lastname.tostring(format);
-    }
-    /**
-     * Gets the middle names part of the full name
-     */
-    getMiddlenames() {
-        return this.hasMiddlename() ? this.fullname.middlename.map(n => n.namon) : [];
-    }
-    /**
-     * Gets the prefix part of the full name
-     */
-    getPrefix() {
-        return this.fullname.prefix
-            ? this.fullname.prefix.concat(this.config.titling === 'us'
-                ? models_1.Separator.PERIOD
-                : models_1.Separator.EMPTY) : models_1.Separator.EMPTY;
-    }
-    /**
-     * Gets the suffix part of the full name
-     */
-    getSuffix() {
-        return this.fullname.suffix || models_1.Separator.EMPTY;
-    }
-    /**
-     * Gets the initials of the full name
-     * @param {NameOrder} orderedBy force to order by first or last name by
-     * overriding the preset configuration
-     * @param {boolean} [withMid] whether to include middle names's
-     *
-     * @example
-     * Given the names:
-     * - `John Smith` => ['J', 'S']
-     * - `John Ben Smith` => ['J', 'S']
-     * when `withMid` is set to true:
-     * - `John Ben Smith` => ['J', 'B', 'S']
-     *
-     * **NOTE**:
-     * Ordered by last name obeys the following format:
-     *  `lastname firstname [middlename]`
-     * which means that if no middle name was set, setting `withMid` to true
-     * will output nothing and warn the end user about it.
-     */
-    getInitials(orderedBy, withMid = false) {
-        orderedBy = this.parseNameOrder(orderedBy);
-        const midInits = this.fullname.middlename ?
-            this.fullname.middlename.map(n => n.getInitials()) : [];
-        if (withMid && !this.hasMiddlename()) {
-            console.warn('No initials for middle names since none was set.');
+            names.push(this.last, this.first, this.middleName().join(' ') + sep);
         }
+        if (this.suffix)
+            names.push(this.suffix);
+        return names.join(' ').trim();
+    }
+    birthName(orderedBy) {
+        orderedBy = orderedBy || this.config.orderedBy;
+        return orderedBy === types_1.NameOrder.FIRST_NAME
+            ? [this.first, ...this.middleName(), this.last].join(' ')
+            : [this.last, this.first, ...this.middleName()].join(' ');
+    }
+    firstName(withMore = true) {
+        return __classPrivateFieldGet(this, _Namefully_fullName, "f").firstName.toString(withMore);
+    }
+    middleName() {
+        return __classPrivateFieldGet(this, _Namefully_fullName, "f").middleName.map((n) => n.value);
+    }
+    lastName(format) {
+        return __classPrivateFieldGet(this, _Namefully_fullName, "f").lastName.toString(format);
+    }
+    initials(options) {
         const initials = [];
-        if (orderedBy === 'firstname') {
-            initials.push(...this.fullname.firstname.getInitials());
-            if (withMid)
-                midInits.forEach(m => initials.push(...m));
-            initials.push(...this.fullname.lastname.getInitials());
+        const firstInits = __classPrivateFieldGet(this, _Namefully_fullName, "f").firstName.initials();
+        const midInits = __classPrivateFieldGet(this, _Namefully_fullName, "f").middleName.map((n) => n.initials()[0]);
+        const lastInits = __classPrivateFieldGet(this, _Namefully_fullName, "f").lastName.initials();
+        const mergedOptions = Object.assign({ orderedBy: this.config.orderedBy, only: types_1.NameType.BIRTH_NAME }, options);
+        const { orderedBy, only } = mergedOptions;
+        if (only !== types_1.NameType.BIRTH_NAME) {
+            if (only === types_1.NameType.FIRST_NAME) {
+                initials.push(...firstInits);
+            }
+            else if (only === types_1.NameType.MIDDLE_NAME) {
+                initials.push(...midInits);
+            }
+            else {
+                initials.push(...lastInits);
+            }
+        }
+        else if (orderedBy === types_1.NameOrder.FIRST_NAME) {
+            initials.push(...firstInits, ...midInits, ...lastInits);
         }
         else {
-            initials.push(...this.fullname.lastname.getInitials());
-            initials.push(...this.fullname.firstname.getInitials());
-            if (withMid)
-                midInits.forEach(m => initials.push(...m));
+            initials.push(...lastInits, ...firstInits, ...midInits);
         }
         return initials;
     }
-    /**
-     * Gives some descriptive statistics that summarize the central tendency,
-     * dispersion and shape of the characters' distribution.
-     * @param what which variant to use when describe a name part
-     *
-     * Treated as a categorical dataset, the summary contains the following info:
-     * `count` : the number of *unrestricted* characters of the name;
-     * `frequency` : the highest frequency within the characters;
-     * `top` : the character with the highest frequency;
-     * `unique` : the count of unique characters of the name;
-     * `distribution` : the characters' distribution.
-     *
-     * @example
-     * Given the name "Thomas Alva Edison", the summary will output as follows:
-     *
-     * Descriptive statistics for "Thomas Alva Edison"
-     *  count    : 16
-     *  frequency: 3
-     *  top      : A
-     *  unique   : 12
-     *  distribution: { T: 1, H: 1, O: 2, M: 1, A: 2, S: 2, ' ': 2, L: 1, V: 1,
-     *  E: 1, D: 1, I: 1, N: 1 }
-     *
-     * **NOTE:**
-     * During the setup, a set of restricted characters can be defined to be removed
-     * from the stats. By default, the only restricted character is the `space`.
-     * That is why the `count` for the example below result in `16` instead of
-     * `16`.
-     * Another thing to consider is that the summary is case *insensitive*. Note
-     * that the letter `a` has the top frequency, be it `3`.
-     */
-    describe(what) {
-        what = core_1.allowShortNameType(what);
-        switch (what) {
-            case 'firstname':
-                return this.fullname.firstname.describe();
-            case 'lastname':
-                return this.fullname.lastname.describe();
-            case 'middlename':
-                if (!this.hasMiddlename()) {
-                    console.warn('No Summary for middle names since none was set.');
-                    return null;
-                }
-                return new models_1.Summary(this.fullname.middlename
-                    .map(n => n.namon)
-                    .join(models_1.Separator.SPACE));
-            default:
-                return this.summary;
-        }
-    }
-    /**
-     * Shortens a complex full name to a simple typical name, a combination of
-     * first name and last name.
-     * @param {NameOrder} orderedBy force to order by first or last
-     * name by overriding the preset configuration
-     *
-     * @example
-     * For a given name such as `Mr Keanu Charles Reeves`, shortening this name
-     * is equivalent to making it `Keanu Reeves`.
-     *
-     * As a shortened name, the namon of the first name is favored over the other
-     * names forming part of the entire first names, if any. Meanwhile, for
-     * the last name, the configured `lastnameFormat` is prioritized.
-     *
-     * @example
-     * For a given `Firstname Fathername Mothername`, shortening this name when
-     * the lastnameFormat is set as `mother` is equivalent to making it:
-     * `Firstname Mothername`.
-     */
     shorten(orderedBy) {
-        orderedBy = orderedBy || this.config.orderedBy; // override config
-        const { firstname, lastname } = this.fullname;
-        return orderedBy === 'firstname'
-            ? [firstname.namon, lastname.tostring()].join(models_1.Separator.SPACE)
-            : [lastname.tostring(), firstname.namon].join(models_1.Separator.SPACE);
-    }
-    /**
-     * Compresses a name by using different forms of variants
-     * @param {number} [limit] a threshold to limit the number of characters
-     * @param {'firstname'|'lastname'|'middlename'|'firstmid'|'midlast'} [by]
-     * a variant to use when compressing the long name. The last two variants
-     * represent respectively the combination of `firstname + middlename` and
-     * `middlename + lastname`.
-     * @param {boolean} [warning] should warn when the set limit is violated
-     *
-     * @example
-     * The compressing operation is only executed iff there is valid entry and it
-     * surpasses the limit set. In the examples below, let us assume that the
-     * name goes beyond the limit value.
-     *
-     * Compressing a long name refers to reducing the name to the following forms:
-     * 1. by firstname: 'John Moe Beau Lennon' => 'J. Moe Beau Lennon'
-     * 2. by middlename: 'John Moe Beau Lennon' => 'John M. B. Lennon'
-     * 3. by lastname: 'John Moe Beau Lennon' => 'John Moe Beau L.'
-     * 4. by firstmid: 'John Moe Beau Lennon' => 'J. M. B. Lennon'
-     * 5. by midlast: 'John Moe Beau Lennon' => 'John M. B. L.'
-     *
-     * By default, it compresses by 'firstmid' variant: 'J. M. B. Lennon'.
-     */
-    compress(limit = 20, by = 'mn', warning = true) {
-        if (this.getFullname().length <= limit) // no need to compress
-            return this.getFullname();
-        const { firstname: fn, lastname: ln, middlename } = this.fullname;
-        const mn = this.getMiddlenames().join(models_1.Separator.SPACE);
-        const hasmid = Array.isArray(middlename) && middlename.length > 0;
-        const sep = models_1.Separator.PERIOD;
-        const firsts = fn.getInitials().join(sep).concat(sep);
-        const lasts = ln.getInitials().join(sep).concat(sep);
-        const mids = hasmid
-            ? middlename.map(n => n.getInitials()).join(sep).concat(sep)
-            : models_1.Separator.EMPTY;
-        let cname = '';
-        if (this.config.orderedBy === 'firstname') {
+        orderedBy = orderedBy || this.config.orderedBy;
+        return orderedBy === types_1.NameOrder.FIRST_NAME
+            ? [__classPrivateFieldGet(this, _Namefully_fullName, "f").firstName.value, __classPrivateFieldGet(this, _Namefully_fullName, "f").lastName.toString()].join(' ')
+            : [__classPrivateFieldGet(this, _Namefully_fullName, "f").lastName.toString(), __classPrivateFieldGet(this, _Namefully_fullName, "f").firstName.value].join(' ');
+    }
+    flatten(options) {
+        if (this.length <= options.limit)
+            return this.full;
+        const mergedOptions = Object.assign({ limit: 20, by: types_1.Flat.MIDDLE_NAME, withPeriod: true, recursive: false, withMore: false }, options);
+        const { by, limit, recursive, withMore, withPeriod, surname } = mergedOptions;
+        const sep = withPeriod ? '.' : '';
+        const fn = __classPrivateFieldGet(this, _Namefully_fullName, "f").firstName.toString();
+        const mn = this.middleName().join(' ');
+        const ln = __classPrivateFieldGet(this, _Namefully_fullName, "f").lastName.toString();
+        const hasMid = this.hasMiddle;
+        const f = __classPrivateFieldGet(this, _Namefully_fullName, "f").firstName.initials(withMore).join(sep + ' ') + sep;
+        const l = __classPrivateFieldGet(this, _Namefully_fullName, "f").lastName.initials(surname).join(sep + ' ') + sep;
+        const m = hasMid ? __classPrivateFieldGet(this, _Namefully_fullName, "f").middleName.map((n) => n.initials()[0]).join(sep + ' ') + sep : '';
+        let name = [];
+        if (this.config.orderedBy === types_1.NameOrder.FIRST_NAME) {
             switch (by) {
-                case 'firstname':
-                case 'fn':
-                    cname = hasmid ?
-                        [firsts, mn, ln.tostring()].join(models_1.Separator.SPACE) :
-                        [firsts, ln.tostring()].join(models_1.Separator.SPACE);
+                case types_1.Flat.FIRST_NAME:
+                    name = hasMid ? [f, mn, ln] : [f, ln];
                     break;
-                case 'lastname':
-                case 'ln':
-                    cname = hasmid ?
-                        [fn.tostring(), mn, lasts].join(models_1.Separator.SPACE) :
-                        [fn.tostring(), lasts].join(models_1.Separator.SPACE);
+                case types_1.Flat.LAST_NAME:
+                    name = hasMid ? [fn, mn, l] : [fn, l];
                     break;
-                case 'middlename':
-                case 'mn':
-                    cname = hasmid ?
-                        [fn.tostring(), mids, ln.tostring()].join(models_1.Separator.SPACE) :
-                        [fn.tostring(), ln.tostring()].join(models_1.Separator.SPACE);
+                case types_1.Flat.MIDDLE_NAME:
+                    name = hasMid ? [fn, m, ln] : [fn, ln];
                     break;
-                case 'firstmid':
-                case 'fm':
-                    cname = hasmid ?
-                        [firsts, mids, ln.tostring()].join(models_1.Separator.SPACE) :
-                        [firsts, ln.tostring()].join(models_1.Separator.SPACE);
+                case types_1.Flat.FIRST_MID:
+                    name = hasMid ? [f, m, ln] : [f, ln];
                     break;
-                case 'midlast':
-                case 'ml':
-                    cname = hasmid ?
-                        [fn.tostring(), mids, lasts].join(models_1.Separator.SPACE) :
-                        [fn.tostring(), lasts].join(models_1.Separator.SPACE);
+                case types_1.Flat.MID_LAST:
+                    name = hasMid ? [fn, m, l] : [fn, l];
+                    break;
+                case types_1.Flat.ALL:
+                    name = hasMid ? [f, m, l] : [f, l];
                     break;
             }
         }
         else {
             switch (by) {
-                case 'firstname':
-                case 'fn':
-                    cname = hasmid ?
-                        [ln.tostring(), firsts, mn].join(models_1.Separator.SPACE) :
-                        [ln.tostring(), firsts].join(models_1.Separator.SPACE);
+                case types_1.Flat.FIRST_NAME:
+                    name = hasMid ? [ln, f, mn] : [ln, f];
+                    break;
+                case types_1.Flat.LAST_NAME:
+                    name = hasMid ? [l, fn, mn] : [l, fn];
                     break;
-                case 'lastname':
-                case 'ln':
-                    cname = hasmid ?
-                        [lasts, fn.tostring(), mn].join(models_1.Separator.SPACE) :
-                        [lasts, fn.tostring()].join(models_1.Separator.SPACE);
+                case types_1.Flat.MIDDLE_NAME:
+                    name = hasMid ? [ln, fn, m] : [ln, fn];
                     break;
-                case 'middlename':
-                case 'mn':
-                    cname = hasmid ?
-                        [ln.tostring(), fn.tostring(), mids].join(models_1.Separator.SPACE) :
-                        [ln.tostring(), fn.tostring()].join(models_1.Separator.SPACE);
+                case types_1.Flat.FIRST_MID:
+                    name = hasMid ? [ln, f, m] : [ln, f];
                     break;
-                case 'firstmid':
-                case 'fm':
-                    cname = hasmid ?
-                        [ln.tostring(), firsts, mids].join(models_1.Separator.SPACE) :
-                        [ln.tostring(), firsts].join(models_1.Separator.SPACE);
+                case types_1.Flat.MID_LAST:
+                    name = hasMid ? [l, fn, m] : [l, fn];
                     break;
-                case 'midlast':
-                case 'ml':
-                    cname = hasmid ?
-                        [lasts, fn.tostring(), mids].join(models_1.Separator.SPACE) :
-                        [lasts, fn.tostring()].join(models_1.Separator.SPACE);
+                case types_1.Flat.ALL:
+                    name = hasMid ? [l, f, m] : [l, f];
                     break;
             }
         }
-        if (warning && cname.length > limit)
-            console.warn(`The compressed name <${cname}> still surpasses the set limit ${limit}`);
-        return cname;
-    }
-    /**
-     * Zips or compresses a name by using different forms of variants
-     * @param by a variant to use when compressing the long name. The last two
-     * variants represent respectively the combination of `firstname + middlename`
-     * and `middlename + lastname`.
-     */
-    zip(by = 'mn') {
-        let v;
-        if (by === 'fn' || by === 'firstname')
-            v = 'firstname';
-        if (by === 'mn' || by === 'middlename')
-            v = 'middlename';
-        if (by === 'ln' || by === 'lastname')
-            v = 'lastname';
-        if (by === 'fm' || by === 'firstmid')
-            v = 'firstmid';
-        if (by === 'ml' || by === 'midlast')
-            v = 'midlast';
-        return this.compress(0, v, false);
-    }
-    /**
-     * Suggests possible (randomly) usernames closest to the name
-     *
-     * **NOTE**
-     * The validity of these usernames are not checked against any social media
-     * or web app online.
-     */
-    username() {
-        const unames = [];
-        const { firstname, lastname } = this.fullname;
-        const p = models_1.Separator.PERIOD;
-        const fn = firstname.tostring().toLowerCase();
-        const ln = lastname.father.toLowerCase();
-        // Given `John Smith`
-        unames.push(fn + ln); // johnsmith
-        unames.push(ln + fn); // smithjohn
-        unames.push(fn[0] + ln); // jsmith
-        unames.push(ln[0] + fn); // sjohn
-        unames.push(fn[0] + p + ln); // j.smith
-        unames.push(ln[0] + p + fn); // s.john
-        unames.push(fn.slice(0, 2) + ln); // josmith
-        unames.push(ln.slice(0, 2) + fn); // smjohn
-        unames.push(fn.slice(0, 2) + p + ln); // jo.smith
-        unames.push(ln.slice(0, 2) + p + fn); // sm.john
-        return unames;
-    }
-    /**
-     * Formats the name as desired
-     * @param {string} how to format the full name
-     *
-     * How to format it?
-     * string format
-     * -------------
-     * 'short': typical first + last name
-     * 'long': birth name (without prefix and suffix)
-     *
-     * char format
-     * -----------
-     * 'b': birth name
-     * 'B': capitalized birth name
-     * 'f': first name
-     * 'F': capitalized first name
-     * 'l': last name (official)
-     * 'L': capitalized last name
-     * 'm': middle names
-     * 'M': capitalized middle names
-     * 'o': official document format
-     * 'O': official document format in capital letters
-     * 'p': prefix
-     * 'P': capitalized prefix
-     * 's': suffix
-     * 'S': capitalized suffix
-     *
-     * punctuations
-     * ------------
-     * '.': period
-     * ',': comma
-     * ' ': space
-     * '-': hyphen
-     * '_': underscore
-     *
-     * @example
-     * Given the name `Joe Jim Smith`, call the `format` with the how string.
-     * - format('l f') => 'Smith Joe'
-     * - format('L, f') => 'SMITH, Joe'
-     * - format('short') => 'Joe Smith'
-     * - format() => 'SMITH, Joe Jim'
-     */
-    format(how = 'official') {
-        if (how === 'short')
-            return this.shorten();
-        if (how === 'long')
-            return this.getBirthname();
-        if (how === 'official')
-            how = 'o';
-        const formatted = [];
-        const tokens = [
-            '.', ',', ' ', '-', '_', 'b', 'B', 'f', 'F', 'l', 'L', 'm', 'M',
-            'n', 'N', 'o', 'O', 'p', 'P', 's', 'S'
-        ];
-        for (const c of how) {
-            if (tokens.indexOf(c) === -1)
-                throw new Error(`<${c}> is an invalid character for the formatting.`);
-            formatted.push(this.map(c));
-        }
-        return formatted.join(models_1.Separator.EMPTY).trim();
-    }
-    /**
-     * Returns the count of characters of the birth name, excluding punctuations
-     */
-    size() {
-        return new models_1.Summary(this.getBirthname(), [...core_1.RESTRICTED_CHARS]).count;
-    }
-    /**
-     * Returns an ascii representation of each characters of a name as specified
-     * @param options use specifics to shape conversion
-     */
-    ascii(options = {}) {
-        const { exceptions: restrictions } = options;
-        const nameType = core_1.allowShortNameType(options.nameType);
-        const { firstname, lastname, middlename } = this.fullname;
-        switch (nameType) {
-            case 'firstname':
-                return firstname.ascii(restrictions);
-            case 'lastname':
-                return lastname.ascii(restrictions);
-            case 'middlename':
-                if (!this.hasMiddlename())
-                    console.warn(`No ASCII conversion for middle names since none was set.`);
-                return middlename
-                    .map(n => n.ascii(restrictions)) // convert
-                    .reduce((acc, value) => acc.concat(value), []); // then flatten
-            default:
-                const firsts = firstname.ascii(restrictions);
-                const mids = middlename
-                    .map(n => n.ascii(restrictions))
-                    .reduce((acc, value) => acc.concat(value), []);
-                const lasts = lastname.ascii(restrictions);
-                if (this.config.orderedBy === 'firstname') {
-                    return firsts.concat(mids, lasts);
-                }
-                return lasts.concat(firsts, mids);
+        const flat = name.join(' ');
+        if (recursive && flat.length > limit) {
+            const next = by === types_1.Flat.FIRST_NAME
+                ? types_1.Flat.MIDDLE_NAME
+                : by === types_1.Flat.MIDDLE_NAME
+                    ? types_1.Flat.LAST_NAME
+                    : by === types_1.Flat.LAST_NAME
+                        ? types_1.Flat.FIRST_MID
+                        : by === types_1.Flat.FIRST_MID
+                            ? types_1.Flat.MID_LAST
+                            : by === types_1.Flat.MID_LAST
+                                ? types_1.Flat.ALL
+                                : by === types_1.Flat.ALL
+                                    ? types_1.Flat.ALL
+                                    : by;
+            if (next === by)
+                return flat;
+            return this.flatten(Object.assign(Object.assign({}, options), { by: next }));
         }
+        return flat;
     }
-    /**
-     * Transforms a birth name to a specific case
-     * @param case which case to convert a birth name to
-     */
-    to(_case) {
-        const birthname = this.getBirthname();
-        const nama = birthname
-            .replace(/[' -]/g, models_1.Separator.SPACE)
-            .split(models_1.Separator.SPACE);
-        switch (_case) {
-            case 'upper':
-                return birthname.toUpperCase();
-            case 'lower':
-                return birthname.toLowerCase();
-            case 'camel':
-            case 'pascal':
-                const pascalCase = nama.map(n => core_1.capitalize(n)).join(models_1.Separator.EMPTY);
-                return _case === 'camel' ? core_1.decapitalize(pascalCase) : pascalCase;
-            case 'snake':
-                return nama.map(n => n.toLowerCase()).join(models_1.Separator.UNDERSCORE);
-            case 'hyphen':
-                return nama.map(n => n.toLowerCase()).join(models_1.Separator.HYPHEN);
-            case 'dot':
-                return nama.map(n => n.toLowerCase()).join(models_1.Separator.PERIOD);
-            case 'toggle':
-                return core_1.toggleCase(birthname);
-            default:
-                return models_1.Separator.EMPTY;
-        }
+    zip(by = types_1.Flat.MID_LAST, withPeriod = true) {
+        return this.flatten({ limit: 0, by, withPeriod });
     }
-    /**
-     * Returns a password-like representation of a name
-     * @param {NameType} [what] which name part
-     */
-    passwd(what) {
-        what = core_1.allowShortNameType(what);
-        switch (what) {
-            case 'firstname':
-                return this.fullname.firstname.passwd();
-            case 'lastname':
-                return this.fullname.lastname.passwd();
-            case 'middlename':
-                if (!this.hasMiddlename())
-                    console.warn('No password for middle names since none was set.');
-                return this.fullname.middlename
-                    .map(n => n.passwd())
-                    .join(models_1.Separator.EMPTY);
-            default:
-                return core_1.generatePassword(this.getBirthname());
+    format(pattern) {
+        var _a;
+        if (pattern === 'short')
+            return this.short;
+        if (pattern === 'long')
+            return this.long;
+        if (pattern === 'public')
+            return this.public;
+        if (pattern === 'official')
+            pattern = 'o';
+        let group = '';
+        const formatted = [];
+        for (const char of pattern.split('')) {
+            if (constants_1.ALLOWED_TOKENS.indexOf(char) === -1) {
+                throw new error_1.NotAllowedError({
+                    source: this.full,
+                    operation: 'format',
+                    message: `unsupported character <${char}> from ${pattern}.`,
+                });
+            }
+            group += char;
+            if (char === '$')
+                continue;
+            formatted.push((_a = __classPrivateFieldGet(this, _Namefully_instances, "m", _Namefully_map).call(this, group)) !== null && _a !== void 0 ? _a : '');
+            group = '';
         }
+        return formatted.join('').trim();
     }
-    hasMiddlename() {
-        return Array.isArray(this.fullname.middlename) && this.fullname.middlename.length > 0;
-    }
-    configure(options) {
-        // consider using deepmerge if objects no longer stay shallow
-        this.config = Object.assign(Object.assign({}, core_1.CONFIG), options); // if options, it overrides CONFIG
-        this.config.orderedBy = core_1.allowShortNameOrder(this.config.orderedBy);
-    }
-    initialize(parser) {
-        const { orderedBy, separator, bypass, lastnameFormat } = this.config;
-        this.fullname = parser.parse({ orderedBy, separator, bypass, lastnameFormat });
-    }
-    parseNameOrder(orderedBy) {
-        orderedBy = orderedBy || this.config.orderedBy; // override config
-        return core_1.allowShortNameOrder(orderedBy);
-    }
-    map(c) {
-        const { firstname, lastname, middlename, prefix, suffix } = this.fullname;
-        switch (c) {
-            case '.':
-                return models_1.Separator.PERIOD;
-            case ',':
-                return models_1.Separator.COMMA;
-            case ' ':
-                return models_1.Separator.SPACE;
-            case '-':
-                return models_1.Separator.HYPHEN;
-            case '_':
-                return models_1.Separator.UNDERSCORE;
-            case 'b':
-                return this.getBirthname();
-            case 'B':
-                return this.getBirthname().toUpperCase();
-            case 'f':
-                return firstname.tostring();
-            case 'F':
-                return firstname.tostring().toUpperCase();
-            case 'l':
-                return lastname.tostring();
-            case 'L':
-                return lastname.tostring().toUpperCase();
-            case 'm':
-                if (!this.hasMiddlename()) {
-                    console.warn('No formatting for middle names since none was set.');
-                    return models_1.Separator.EMPTY;
-                }
-                return this.fullname.middlename.map(n => n.namon).join(models_1.Separator.SPACE);
-            case 'M':
-                if (!this.hasMiddlename()) {
-                    console.warn('No formatting for middle names since none was set.');
-                    return models_1.Separator.EMPTY;
-                }
-                return middlename.map(n => n.namon.toUpperCase()).join(models_1.Separator.SPACE);
-            case 'o':
-            case 'O':
-                const { titling, ending } = this.config;
-                const pxSep = titling === 'us' ? models_1.Separator.PERIOD : models_1.Separator.EMPTY;
-                const sxSep = ending ? ',' : models_1.Separator.EMPTY;
-                const nama = [];
-                if (prefix)
-                    nama.push(prefix.concat(pxSep));
-                nama.push(lastname.tostring().concat(models_1.Separator.COMMA).toUpperCase());
-                if (this.hasMiddlename()) {
-                    nama.push(firstname.tostring());
-                    nama.push(middlename.map(n => n.namon).join(models_1.Separator.SPACE).concat(sxSep));
-                }
-                else {
-                    nama.push(firstname.tostring().concat(sxSep));
-                }
-                nama.push(suffix || models_1.Separator.EMPTY);
-                const official = nama.join(models_1.Separator.SPACE).trim();
-                return c === 'o' ? official : official.toUpperCase();
-            case 'p':
-                return prefix || models_1.Separator.EMPTY;
-            case 'P':
-                return prefix ? prefix.toUpperCase() : models_1.Separator.EMPTY;
-            case 's':
-                return suffix || models_1.Separator.EMPTY;
-            case 'S':
-                return suffix ? suffix.toUpperCase() : models_1.Separator.EMPTY;
-        }
+    flip() {
+        this.config.updateOrder(this.config.orderedBy === types_1.NameOrder.FIRST_NAME ? types_1.NameOrder.LAST_NAME : types_1.NameOrder.FIRST_NAME);
     }
-    build(raw) {
-        if (this.config.parser) {
-            this.initialize(this.config.parser);
-        }
-        else if (typeof raw === 'string') { // check for string type
-            this.initialize(new core_1.StringParser(raw));
-        }
-        else if (Array.isArray(raw) && raw.length) { // check for T[]
-            if (typeof raw[0] === 'string') { // check for string[]
-                for (const key of raw)
-                    if (typeof key !== 'string')
-                        throw new Error(`Cannot parse raw data as array of 'string'`);
-                this.initialize(new core_1.ArrayStringParser(raw));
-            }
-            else if (raw[0] instanceof models_1.Name) { // check for Name[]
-                for (const obj of raw)
-                    if (!(obj instanceof models_1.Name))
-                        throw new Error(`Cannot parse raw data as array of 'Name'`);
-                this.initialize(new core_1.ArrayNameParser(raw));
+    split(separator = /[' -]/g) {
+        return this.birth.replace(separator, ' ').split(' ');
+    }
+    join(separator = '') {
+        return this.split().join(separator);
+    }
+    toUpperCase() {
+        return this.birth.toUpperCase();
+    }
+    toLowerCase() {
+        return this.birth.toLowerCase();
+    }
+    toCamelCase() {
+        return (0, utils_1.decapitalize)(this.toPascalCase());
+    }
+    toPascalCase() {
+        return this.split()
+            .map((n) => (0, utils_1.capitalize)(n))
+            .join('');
+    }
+    toSnakeCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('_');
+    }
+    toHyphenCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('-');
+    }
+    toDotCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('.');
+    }
+    toToggleCase() {
+        return (0, utils_1.toggleCase)(this.birth);
+    }
+}
+exports.Namefully = Namefully;
+_Namefully_fullName = new WeakMap(), _Namefully_instances = new WeakSet(), _Namefully_toParser = function _Namefully_toParser(raw) {
+    if (raw instanceof parser_1.Parser)
+        return raw;
+    if (typeof raw === 'string')
+        return new parser_1.StringParser(raw);
+    if ((0, utils_1.isStringArray)(raw))
+        return new parser_1.ArrayStringParser(raw);
+    if ((0, utils_1.isNameArray)(raw))
+        return new parser_1.ArrayNameParser(raw);
+    if (typeof raw === 'object')
+        return new parser_1.NamaParser(raw);
+    throw new error_1.InputError({ source: raw, message: 'Cannot parse raw data. Review expected data types.' });
+}, _Namefully_map = function _Namefully_map(char) {
+    var _a, _b;
+    switch (char) {
+        case '.':
+        case ',':
+        case ' ':
+        case '-':
+        case '_':
+            return char;
+        case 'b':
+            return this.birth;
+        case 'B':
+            return this.birth.toUpperCase();
+        case 'f':
+            return this.first;
+        case 'F':
+            return this.first.toUpperCase();
+        case 'l':
+            return this.last;
+        case 'L':
+            return this.last.toUpperCase();
+        case 'm':
+        case 'M':
+            return char === 'm' ? this.middleName().join(' ') : this.middleName().join(' ').toUpperCase();
+        case 'o':
+        case 'O':
+            const sep = this.config.ending ? ',' : '';
+            const names = [];
+            if (this.prefix)
+                names.push(this.prefix);
+            names.push(`${this.last},`.toUpperCase());
+            if (this.hasMiddle) {
+                names.push(this.first, this.middleName().join(' ') + sep);
             }
             else {
-                // typescript should stop them, but let's be paranoid (for JS developers)
-                throw new Error(`Cannot parse raw data as arrays that are not of 'Name' or string`);
-            }
-        }
-        else if (raw instanceof Object) { // check for json object
-            for (const [key, value] of Object.entries(raw)) { // make sure keys are correct
-                if (['firstname', 'lastname', 'middlename', 'prefix', 'suffix'].indexOf(key) === -1)
-                    throw new Error(`Cannot parse raw data as json object that does not contains keys of` +
-                        `'${Object.keys(models_1.Namon)}'`);
-                // make sure the values are proper string or object
-                if (typeof value !== 'string' && typeof value !== 'object')
-                    throw new Error(`Cannot parse raw data. The key <${key}> should be a 'string|object' type`);
+                names.push(this.first + sep);
             }
-            if (typeof raw['firstname'] === 'string') // this key must always exist
-                this.initialize(new core_1.NamaParser(raw));
-            else
-                this.fullname = raw;
-        }
-        else {
-            // typescript should stop them, but let's be paranoid again (for JS developers)
-            throw new Error(`Cannot parse raw data. Review the data type expected.`);
-        }
-        // paranoid coder mode: on :P
-        if (!this.config.bypass)
-            new validators_1.FullnameValidator().validate(this.fullname);
-        this.summary = new models_1.Summary(this.getFullname());
+            if (this.suffix)
+                names.push(this.suffix);
+            const nama = names.join(' ').trim();
+            return char === 'o' ? nama : nama.toUpperCase();
+        case 'p':
+            return this.prefix;
+        case 'P':
+            return (_a = this.prefix) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+        case 's':
+            return this.suffix;
+        case 'S':
+            return (_b = this.suffix) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+        case '$f':
+        case '$F':
+            return __classPrivateFieldGet(this, _Namefully_fullName, "f").firstName.initials()[0];
+        case '$l':
+        case '$L':
+            return __classPrivateFieldGet(this, _Namefully_fullName, "f").lastName.initials()[0];
+        case '$m':
+        case '$M':
+            return this.hasMiddle ? this.middle[0] : undefined;
+        default:
+            return undefined;
     }
-}
-exports.Namefully = Namefully;
-Namefully.prototype.full = Namefully.prototype.getFullname;
-Namefully.prototype.birth = Namefully.prototype.getBirthname;
-Namefully.prototype.fn = Namefully.prototype.getFirstname;
-Namefully.prototype.ln = Namefully.prototype.getLastname;
-Namefully.prototype.mn = Namefully.prototype.getMiddlenames;
-Namefully.prototype.px = Namefully.prototype.getPrefix;
-Namefully.prototype.sx = Namefully.prototype.getSuffix;
-Namefully.prototype.inits = Namefully.prototype.getInitials;
-Namefully.prototype.stats = Namefully.prototype.describe;
-//# sourceMappingURL=namefully.js.map
+};