namefully 1.1.0 → 1.2.0

package/dist/example/index.js

@@ -0,0 +1,2734 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./example/example.ts");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./example/example.ts":
+/*!****************************!*\
+  !*** ./example/example.ts ***!
+  \****************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __webpack_require__(/*! ../src/index */ "./src/index.ts");
+function example() {
+    // Gives a simple name some super power.
+    const name = new index_1.Namefully('Thomas Alva Edison', { orderedBy: index_1.NameOrder.LAST_NAME });
+    // Gets the count of characters, including space.
+    console.log(name.length); // 18
+    // Gets the first name.
+    console.log(name.first); // Thomas
+    // Gets the first middle name.
+    console.log(name.middle); // Alva
+    // Gets the last name.
+    console.log(name.last); // Edison
+    // Controls what the public sees.
+    console.log(name.public); // Thomas E
+    // Gets all the initials.
+    console.log(name.initials()); // ['T', 'A', 'E']
+    // Formats it as desired.
+    console.log(name.format('L, f m')); // EDISON, Thomas Alva
+    // Makes it short.
+    console.log(name.shorten()); // Thomas Edison
+    // Makes it flat.
+    console.log(name.zip()); // Thomas A. E.
+    // Makes it uppercase.
+    console.log(name.toUpperCase()); // THOMAS ALVA EDISON
+    // Transforms it into dot.case.
+    console.log(name.toDotCase()); // thomas.alva.edison
+}
+example();
+
+
+/***/ }),
+
+/***/ "./src/config.ts":
+/*!***********************!*\
+  !*** ./src/config.ts ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const defaultName = 'default';
+const copyAlias = '_copy';
+/**
+ * The Configuration to use across the other components.
+ *
+ * The multiton pattern is used to handle configurations across the `namefully`
+ * setup. This adds consistency when building other components such as `FirstName`,
+ * `LastName`, or `Name` of distinct types that may be of particular shapes.
+ *
+ * For example, a person's `FullName` may appear by:
+ * - NameOrder.FIRST_NAME: `Jon Snow` or
+ * - NameOrder.LAST_NAME: `Snow Jon`.
+ *
+ * `Config` makes it easy to set up a specific configuration for `Namefully`
+ * and reuse it through other instances or components along the way. If a new
+ * `Config` is needed, a named configuration may be created. It is actually
+ * advised to use named `Config.create(name)` instead as it may help mitigate issues
+ * and avoid confusion and ambiguity in the future. Plus, a named configuration
+ * explains its purpose.
+ *
+ * ```ts
+ * const defaultConfig = Config.create();
+ * const mergedConfig = Config.merge({ name: 'other', title: Title.US });
+ * const copyConfig = mergedConfig.copyWith({ ending: true });
+ * ```
+ *
+ * Additionally, a configuration may be merged with or copied from an existing
+ * configuration, prioritizing the new one's values, as shown in the example
+ * above.
+ */
+class Config {
+    constructor(name, orderedBy = types_1.NameOrder.FIRST_NAME, separator = types_1.Separator.SPACE, title = types_1.Title.UK, ending = false, bypass = true, surname = types_1.Surname.FATHER) {
+        this._name = name;
+        this._orderedBy = orderedBy;
+        this._separator = separator;
+        this._title = title;
+        this._ending = ending;
+        this._bypass = bypass;
+        this._surname = surname;
+    }
+    /**
+     * The order of appearance of a full name.
+     */
+    get orderedBy() {
+        return this._orderedBy;
+    }
+    /**
+     * The token used to indicate how to split string values.
+     */
+    get separator() {
+        return this._separator;
+    }
+    /**
+     * The abbreviation type to indicate whether or not to add period to a prefix
+     * using the American or British way.
+     */
+    get title() {
+        return this._title;
+    }
+    /**
+     * The option indicating if an ending suffix is used in a formal way.
+     */
+    get ending() {
+        return this._ending;
+    }
+    /**
+     * A bypass of the validation rules with this option. This option is ideal
+     * to avoid checking their validity.
+     */
+    get bypass() {
+        return this._bypass;
+    }
+    /**
+     * An option indicating how to format a surname.
+     *
+     * The supported formats are:
+     * - `FATHER` name only
+     * - `MOTHER` name only
+     * - `HYPHENATED`, joining both father and mother names with a hyphen
+     * - `ALL`, joining both father and mother names with a space.
+     *
+     * Note that this option can be set when creating a `LastName`. As this can
+     * become ambiguous at the time of handling it, the value set in this is
+     * prioritized and viewed as the source of truth for future considerations.
+     */
+    get surname() {
+        return this._surname;
+    }
+    /**
+     * The name of the cached configuration.
+     */
+    get name() {
+        return this._name;
+    }
+    /**
+     * Returns a named configuration with default values.
+     * @param name describing its purpose.
+     */
+    static create(name = defaultName) {
+        if (!Config.cache.has(name)) {
+            Config.cache.set(name, new this(name));
+        }
+        return Config.cache.get(name);
+    }
+    /**
+     * Returns a combined version of the existing values of the default configuration
+     * and the provided optional values of another configuration.
+     * @param other partial config to be combined with.
+     */
+    static merge(other) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!other) {
+            return Config.create();
+        }
+        else {
+            const config = Config.create(other.name);
+            config._orderedBy = (_a = other.orderedBy) !== null && _a !== void 0 ? _a : config.orderedBy;
+            config._separator = (_b = other.separator) !== null && _b !== void 0 ? _b : config.separator;
+            config._title = (_c = other.title) !== null && _c !== void 0 ? _c : config.title;
+            config._ending = (_d = other.ending) !== null && _d !== void 0 ? _d : config.ending;
+            config._bypass = (_e = other.bypass) !== null && _e !== void 0 ? _e : config.bypass;
+            config._surname = (_f = other.surname) !== null && _f !== void 0 ? _f : config.surname;
+            return config;
+        }
+    }
+    /**
+     * Returns a copy of this configuration merged with the provided values.
+     *
+     * The word `_copy` is added to the existing config's name to create the new
+     * config's name if the name already exists for previous configurations. This
+     * is useful to maintain the uniqueness of each configuration. For example,
+     * if the new copy is made from the default configuration, this new copy will
+     * be named `default_copy`.
+     */
+    copyWith(options = {}) {
+        const { name, orderedBy, separator, title, ending, bypass, surname } = options;
+        const config = Config.create(this.genNewName(name !== null && name !== void 0 ? name : this.name + copyAlias));
+        config._orderedBy = orderedBy !== null && orderedBy !== void 0 ? orderedBy : this.orderedBy;
+        config._separator = separator !== null && separator !== void 0 ? separator : this.separator;
+        config._title = title !== null && title !== void 0 ? title : this.title;
+        config._ending = ending !== null && ending !== void 0 ? ending : this.ending;
+        config._bypass = bypass !== null && bypass !== void 0 ? bypass : this.bypass;
+        config._surname = surname !== null && surname !== void 0 ? surname : this.surname;
+        return config;
+    }
+    /**
+     * Makes an exact copy of the current configuration.
+     */
+    clone() {
+        return this.copyWith();
+    }
+    /**
+     * Resets the configuration by setting it back to its default values.
+     */
+    reset() {
+        this._orderedBy = types_1.NameOrder.FIRST_NAME;
+        this._separator = types_1.Separator.SPACE;
+        this._title = types_1.Title.UK;
+        this._ending = false;
+        this._bypass = true;
+        this._surname = types_1.Surname.FATHER;
+        Config.cache.set(this.name, this);
+    }
+    /**
+     * Alters the name order between the first and last name, and rearrange the
+     * order of appearance of a name set.
+     */
+    updateOrder(order) {
+        if (order && order !== this._orderedBy) {
+            Config.cache.get(this.name)._orderedBy = order;
+        }
+    }
+    /**
+     * Generates a unique new name.
+     */
+    genNewName(name) {
+        return name === this.name || Config.cache.has(name) ? this.genNewName(name + copyAlias) : name;
+    }
+}
+exports.Config = Config;
+/**
+ * Cache for multiple instances.
+ */
+Config.cache = new Map();
+
+
+/***/ }),
+
+/***/ "./src/constants.ts":
+/*!**************************!*\
+  !*** ./src/constants.ts ***!
+  \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_TOKENS = exports.MAX_NUMBER_OF_NAME_PARTS = exports.MIN_NUMBER_OF_NAME_PARTS = exports.version = void 0;
+exports.version = '1.2.0';
+exports.MIN_NUMBER_OF_NAME_PARTS = 2;
+exports.MAX_NUMBER_OF_NAME_PARTS = 5;
+exports.ALLOWED_TOKENS = [
+    '.',
+    ',',
+    ' ',
+    '-',
+    '_',
+    'b',
+    'B',
+    'f',
+    'F',
+    'l',
+    'L',
+    'm',
+    'M',
+    'n',
+    'N',
+    'o',
+    'O',
+    'p',
+    'P',
+    's',
+    'S',
+    '$',
+];
+
+
+/***/ }),
+
+/***/ "./src/error.ts":
+/*!**********************!*\
+  !*** ./src/error.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownError = exports.NotAllowedError = exports.ValidationError = exports.InputError = exports.NameError = exports.NameErrorType = void 0;
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+/**
+ * The error types supported by `Namefully`.
+ */
+var NameErrorType;
+(function (NameErrorType) {
+    /**
+     * Thrown when a name entry/argument is incorrect.
+     *
+     * For example, a name should have a minimum of 2 characters, so an empty
+     * string or a string of one character would cause this kind of error.
+     */
+    NameErrorType[NameErrorType["INPUT"] = 0] = "INPUT";
+    /**
+     * Thrown when the name components do not match the validation rules if the
+     * `Config.bypass` is not flagged up. This bypass option skips the validation
+     * rules.
+     *
+     * See also: `ValidationError`
+     */
+    NameErrorType[NameErrorType["VALIDATION"] = 1] = "VALIDATION";
+    /**
+     * Thrown by not allowed operations such as in NameBuilder or name formatting.
+     *
+     * See also: `NotAllowedError`, `Namefully.format`.
+     */
+    NameErrorType[NameErrorType["NOT_ALLOWED"] = 2] = "NOT_ALLOWED";
+    /**
+     * Thrown by any other unknown sources or unexpected situation.
+     */
+    NameErrorType[NameErrorType["UNKNOWN"] = 3] = "UNKNOWN";
+})(NameErrorType = exports.NameErrorType || (exports.NameErrorType = {}));
+/**
+ * Base class for all name-related errors.
+ *
+ * A custom error is intended to convey information to the user about a failure,
+ * so that it can be addressed programmatically.
+ *
+ * A name handling failure is not considered a native error that should cause a
+ * program failure. Au contraire, it is expected that a programmer using this utility
+ * would consider validating a name using its own business rules. That is not
+ * this utility's job to guess those rules. So, the predefined `ValidationRules`
+ * obey some common validation techniques when it comes to sanitizing a person
+ * name. For this reason, the [Config.bypass] is set to `true` by default,
+ * indicating that those predefined rules should be skipped for the sake of the
+ * program.
+ *
+ * A programmer may leverage `Parser` to indicate business-tailored rules if he
+ * or she wants this utility to perform those safety checks behind the scenes.
+ *
+ * A name error intends to provide useful information about what causes the error
+ * and let the user take initiative on what happens next to the given name:
+ * reconstructing it or skipping it.
+ */
+class NameError extends Error {
+    /**
+     * Creates an error with a message describing the issue for a name source.
+     * @param source name input that caused the error
+     * @param message a message describing the failure.
+     * @param type of `NameErrorType`
+     */
+    constructor(source, message, type = NameErrorType.UNKNOWN) {
+        super(message);
+        this.source = source;
+        this.type = type;
+        this.name = 'NameError';
+    }
+    /**
+     * The actual source input which caused the error.
+     */
+    get sourceAsString() {
+        let input = '';
+        if (!this.source)
+            input = '<undefined>';
+        if (typeof this.source === 'string')
+            input = this.source;
+        if (utils_1.isNameArray(this.source))
+            input = this.source.map((n) => n.toString()).join(' ');
+        if (utils_1.isStringArray(this.source))
+            input = this.source.join(' ');
+        return input;
+    }
+    /**
+     * Whether a message describing the failure exists.
+     */
+    get hasMessage() {
+        return this.message && this.message.trim().length > 0;
+    }
+    /**
+     * Returns a string representation of the error.
+     */
+    toString() {
+        let report = `${this.name} (${this.sourceAsString})`;
+        if (this.hasMessage)
+            report = `${report}: ${this.message}`;
+        return report;
+    }
+}
+exports.NameError = NameError;
+/**
+ * An error thrown when a name source input is incorrect.
+ *
+ * A `Name` is a name for this utility under certain criteria (i.e., 2+ chars),
+ * hence, a wrong input will cause this kind of error. Another common reason
+ * may be a wrong key in a Json name parsing mechanism.
+ *
+ * Keep in mind that this error is different from a `ValidationError`.
+ */
+class InputError extends NameError {
+    /**
+     * Creates a new `InputError` with an optional error `message`.
+     *
+     * The name source is by nature a string content, maybe wrapped up in a different
+     * type. This string value may be extracted to form the following output:
+     *   "InputError (stringName)",
+     *   "InputError (stringName): message".
+     */
+    constructor(error) {
+        super(error.source, error.message, NameErrorType.INPUT);
+        this.name = 'InputError';
+    }
+}
+exports.InputError = InputError;
+/**
+ * An error thrown to indicate that a name fails the validation rules.
+ */
+class ValidationError extends NameError {
+    /**
+     * Creates error containing the invalid `nameType` and a `message` that
+     * briefly describes the problem if provided.
+     *
+     * For example, a validation error can be interpreted as:
+     *     "ValidationError (nameType='stringName')",
+     *     "ValidationError (nameType='stringName'): message"
+     */
+    constructor(error) {
+        super(error.source, error.message, NameErrorType.VALIDATION);
+        this.nameType = error.nameType;
+        this.name = 'ValidationError';
+    }
+    toString() {
+        let report = `${this.name} (${this.nameType}='${this.sourceAsString}')`;
+        if (this.hasMessage)
+            report = `${report}: ${this.message}`;
+        return report;
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Thrown by not allowed operations such as in name formatting.
+ *
+ * For example, this will occur when trying to format a name accordingly using
+ * a non-supported key.
+ */
+class NotAllowedError extends NameError {
+    /**
+     * Creates a new `NotAllowedError` with an optional error `message` and the
+     * `operation` name.
+     *
+     * For example, an error of this kind can be interpreted as:
+     *     "NotAllowedError (stringName)",
+     *     "NotAllowedError (stringName) - operationName",
+     *     "NotAllowedError (stringName) - operationName: message"
+     */
+    constructor(error) {
+        super(error.source, error.message, NameErrorType.NOT_ALLOWED);
+        this.operation = error.operation;
+        this.name = 'NotAllowedError';
+    }
+    toString() {
+        let report = `${this.name} (${this.sourceAsString})`;
+        if (this.operation && this.operation.trim().length > 0)
+            report = `${report} - ${this.operation}`;
+        if (this.hasMessage)
+            report = `${report}: ${this.message}`;
+        return report;
+    }
+}
+exports.NotAllowedError = NotAllowedError;
+/**
+ * A fallback error thrown by any unknown sources or unexpected failure that are
+ * not of `NameError`.
+ *
+ * In this particular case, an `origin` remains useful as it provides details
+ * on the sources and the true nature of the unexpected error.
+ * At this point, deciding whether to exit the program or not depends on the
+ * programmer.
+ */
+class UnknownError extends NameError {
+    /**
+     * Creates a new `UnknownError` with an optional error `message`.
+     * Optionally, the original error revealing the true nature of the failure.
+     */
+    constructor(error) {
+        super(error.source, error.message, NameErrorType.UNKNOWN);
+        this.origin = error.error;
+        this.name = 'UnknownError';
+    }
+    toString() {
+        let report = super.toString();
+        if (this.origin)
+            report += `\n${this.origin.toString()}`;
+        return report;
+    }
+}
+exports.UnknownError = UnknownError;
+
+
+/***/ }),
+
+/***/ "./src/full-name.ts":
+/*!**************************!*\
+  !*** ./src/full-name.ts ***!
+  \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullName = void 0;
+const config_1 = __webpack_require__(/*! ./config */ "./src/config.ts");
+const error_1 = __webpack_require__(/*! ./error */ "./src/error.ts");
+const name_1 = __webpack_require__(/*! ./name */ "./src/name.ts");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const validator_1 = __webpack_require__(/*! ./validator */ "./src/validator.ts");
+/**
+ * The core component of this utility.
+ *
+ * This component is comprised of five entities that make it easy to handle a
+ * full name set: prefix, first name, middle name, last name, and suffix.
+ * This class is intended for internal processes. However, it is understandable
+ * that it might be needed at some point for additional purposes. For this reason,
+ * it's made available.
+ *
+ * It is recommended to avoid using this class unless it is highly necessary or
+ * a custom parser is used for uncommon use cases. This utility tries to cover
+ * as many use cases as possible.
+ *
+ * Additionally, an optional configuration can be used to indicate some specific
+ * behaviors related to that name handling.
+ */
+class FullName {
+    /**
+     * Creates a full name as it goes
+     * @param options optional configuration for additional features.
+     */
+    constructor(options) {
+        this._middleName = [];
+        this._config = config_1.Config.merge(options);
+    }
+    /**
+     * A snapshot of the configuration used to set up this full name.
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * The prefix part of the full name.
+     */
+    get prefix() {
+        return this._prefix;
+    }
+    /**
+     * The first name part of the full name.
+     */
+    get firstName() {
+        return this._firstName;
+    }
+    /**
+     * The last name part of the full name.
+     */
+    get lastName() {
+        return this._lastName;
+    }
+    /**
+     * The middle name part of the full name.
+     */
+    get middleName() {
+        return this._middleName;
+    }
+    /**
+     * The suffix part of the full name.
+     */
+    get suffix() {
+        return this._suffix;
+    }
+    setPrefix(name) {
+        if (!name)
+            return this;
+        if (!this._config.bypass)
+            validator_1.Validators.prefix.validate(name);
+        const prefix = name instanceof name_1.Name ? name.value : name;
+        this._prefix = name_1.Name.prefix(this._config.title === types_1.Title.US ? `${prefix}.` : prefix);
+        return this;
+    }
+    setFirstName(name) {
+        if (!this._config.bypass)
+            validator_1.Validators.firstName.validate(name);
+        this._firstName = name instanceof name_1.FirstName ? name : new name_1.FirstName(name);
+        return this;
+    }
+    setLastName(name) {
+        if (!this._config.bypass)
+            validator_1.Validators.lastName.validate(name);
+        this._lastName = name instanceof name_1.LastName ? name : new name_1.LastName(name);
+        return this;
+    }
+    setMiddleName(names) {
+        if (!Array.isArray(names))
+            return;
+        if (!this._config.bypass)
+            validator_1.Validators.middleName.validate(names);
+        this._middleName = names.map((name) => name instanceof name_1.Name ? name : name_1.Name.middle(name));
+        return this;
+    }
+    setSuffix(name) {
+        if (!name)
+            return this;
+        if (!this._config.bypass)
+            validator_1.Validators.suffix.validate(name);
+        this._suffix = name_1.Name.suffix(name instanceof name_1.Name ? name.value : name);
+        return this;
+    }
+    /**
+     * Returns true if a namon has been set.
+     */
+    has(namon) {
+        if (namon.equal(types_1.Namon.PREFIX))
+            return !!this._prefix;
+        if (namon.equal(types_1.Namon.SUFFIX))
+            return !!this._suffix;
+        return namon.equal(types_1.Namon.MIDDLE_NAME) ? this._middleName.length > 0 : true;
+    }
+    /**
+     * Parses a json name into a full name.
+     * @param json parsable name element
+     * @param config optional configuration for additional features.
+     */
+    static parse(json, config) {
+        try {
+            const fullName = new FullName(config);
+            fullName.setPrefix(json.prefix);
+            fullName.setFirstName(json.firstName);
+            fullName.setMiddleName(json.middleName);
+            fullName.setLastName(json.lastName);
+            fullName.setSuffix(json.suffix);
+            return fullName;
+        }
+        catch (error) {
+            if (error instanceof error_1.NameError) {
+                throw error;
+            }
+            else {
+                throw new error_1.UnknownError({
+                    source: Object.values(json).join(' '),
+                    message: 'could not parse JSON content',
+                    error,
+                });
+            }
+        }
+    }
+}
+exports.FullName = FullName;
+
+
+/***/ }),
+
+/***/ "./src/index.ts":
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Welcome to namefully!
+ *
+ * `namefully` is a JavaScript utility for handing person names.
+ *
+ * Sources
+ * - repo: https://github.com/ralflorent/namefully
+ * - docs: https://namefully.netlify.app
+ * - npm: https://npmjs.com/package/namefully
+ *
+ * @license MIT
+ */
+__exportStar(__webpack_require__(/*! ./config */ "./src/config.ts"), exports);
+__exportStar(__webpack_require__(/*! ./error */ "./src/error.ts"), exports);
+__exportStar(__webpack_require__(/*! ./full-name */ "./src/full-name.ts"), exports);
+__exportStar(__webpack_require__(/*! ./name */ "./src/name.ts"), exports);
+__exportStar(__webpack_require__(/*! ./namefully */ "./src/namefully.ts"), exports);
+var parser_1 = __webpack_require__(/*! ./parser */ "./src/parser.ts");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
+__exportStar(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
+var utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+Object.defineProperty(exports, "NameIndex", { enumerable: true, get: function () { return utils_1.NameIndex; } });
+
+
+/***/ }),
+
+/***/ "./src/name.ts":
+/*!*********************!*\
+  !*** ./src/name.ts ***!
+  \*********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LastName = exports.FirstName = exports.Name = void 0;
+const error_1 = __webpack_require__(/*! ./error */ "./src/error.ts");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+/**
+ * Representation of a string type name with some extra capabilities.
+ */
+class Name {
+    /**
+     * Creates augmented names by adding extra functionality to a string name.
+     * @param type must be indicated to categorize the name so it can be
+     * treated accordingly.
+     * @param capsRange determines how the name should be capitalized initially.
+     */
+    constructor(value, type, capsRange) {
+        this.type = type;
+        this.capsRange = capsRange !== null && capsRange !== void 0 ? capsRange : types_1.CapsRange.INITIAL;
+        this.value = value;
+        if (capsRange)
+            this.caps(capsRange);
+    }
+    set value(newValue) {
+        if (newValue.trim().length < 2) {
+            throw new error_1.InputError({ source: newValue, message: 'must be 2+ characters' });
+        }
+        this.namon = newValue;
+        this.initial = newValue[0];
+    }
+    /**
+     * The piece of string treated as a name.
+     */
+    get value() {
+        return this.namon;
+    }
+    /**
+     * The length of the name.
+     */
+    get length() {
+        return this.namon.length;
+    }
+    /**
+     * Whether the name is a prefix.
+     */
+    get isPrefix() {
+        return this.type === types_1.Namon.PREFIX;
+    }
+    /**
+     * Whether the name is a first name.
+     */
+    get isFirstName() {
+        return this.type === types_1.Namon.FIRST_NAME;
+    }
+    /**
+     * Whether the name is a middle name.
+     */
+    get isMiddleName() {
+        return this.type === types_1.Namon.MIDDLE_NAME;
+    }
+    /**
+     * Whether the name is a last name.
+     */
+    get isLastName() {
+        return this.type === types_1.Namon.LAST_NAME;
+    }
+    /**
+     * Whether the name is a suffix.
+     */
+    get isSuffix() {
+        return this.type === types_1.Namon.SUFFIX;
+    }
+    /**
+     * Creates a prefix.
+     */
+    static prefix(value) {
+        return new this(value, types_1.Namon.PREFIX);
+    }
+    /**
+     * Creates a first name.
+     */
+    static first(value) {
+        return new this(value, types_1.Namon.FIRST_NAME);
+    }
+    /**
+     * Creates a middle name.
+     */
+    static middle(value) {
+        return new this(value, types_1.Namon.MIDDLE_NAME);
+    }
+    /**
+     * Creates a last name.
+     */
+    static last(value) {
+        return new this(value, types_1.Namon.LAST_NAME);
+    }
+    /**
+     * Creates a suffix.
+     */
+    static suffix(value) {
+        return new this(value, types_1.Namon.SUFFIX);
+    }
+    /**
+     * Gets the initials (first character) of this name.
+     */
+    initials() {
+        return [this.initial];
+    }
+    /**
+     * String representation of this object.
+     */
+    toString() {
+        return this.namon;
+    }
+    /**
+     * Returns true if the other is equal to this name.
+     */
+    equal(other) {
+        return other instanceof Name && other.value === this.value && other.type === this.type;
+    }
+    /**
+     * Capitalizes the name.
+     */
+    caps(range) {
+        this.value = utils_1.capitalize(this.namon, range !== null && range !== void 0 ? range : this.capsRange);
+        return this;
+    }
+    /**
+     * De-capitalizes the name.
+     */
+    decaps(range) {
+        this.value = utils_1.decapitalize(this.namon, range !== null && range !== void 0 ? range : this.capsRange);
+        return this;
+    }
+}
+exports.Name = Name;
+/**
+ * Representation of a first name with some extra functionality.
+ */
+class FirstName extends Name {
+    /**
+     * Creates an extended version of `Name` and flags it as a first name `type`.
+     *
+     * Some may consider `more` additional name parts of a given name as their
+     * first names, but not as their middle names. Though, it may mean the same,
+     * `more` provides the freedom to do it as it pleases.
+     */
+    constructor(value, ...more) {
+        super(value, types_1.Namon.FIRST_NAME);
+        for (const name of more) {
+            if (name.trim().length < 2) {
+                throw new error_1.InputError({ source: name, message: 'must be 2+ characters' });
+            }
+        }
+        this._more = more;
+    }
+    /**
+     * Determines whether a first name has `more` name parts.
+     */
+    get hasMore() {
+        return this._more.length > 0;
+    }
+    get length() {
+        return super.length + (this.hasMore ? this._more.reduce((acc, n) => acc + n).length : 0);
+    }
+    /**
+     * Returns a combined version of the `value` and `more` if any.
+     */
+    get asNames() {
+        const names = [Name.first(this.value)];
+        if (this.hasMore) {
+            names.push(...this._more.map((n) => Name.first(n)));
+        }
+        return names;
+    }
+    /**
+     * The additional name parts of the first name.
+     */
+    get more() {
+        return this._more;
+    }
+    toString(withMore = false) {
+        return withMore && this.hasMore ? `${this.value} ${this._more.join(' ')}`.trim() : this.value;
+    }
+    initials(withMore = false) {
+        const inits = [this.initial];
+        if (withMore && this.hasMore) {
+            inits.push(...this._more.map((n) => n[0]));
+        }
+        return inits;
+    }
+    caps(range) {
+        range = range || this.capsRange;
+        this.value = utils_1.capitalize(this.value, range);
+        if (this.hasMore)
+            this._more = this._more.map((n) => utils_1.capitalize(n, range));
+        return this;
+    }
+    decaps(range) {
+        range = range || this.capsRange;
+        this.value = utils_1.decapitalize(this.value, range);
+        if (this.hasMore)
+            this._more = this._more.map((n) => utils_1.decapitalize(n, range));
+        return this;
+    }
+    /**
+     * Makes a copy of the current name.
+     */
+    copyWith(values) {
+        var _a, _b;
+        return new FirstName((_a = values.first) !== null && _a !== void 0 ? _a : this.value, ...((_b = values.more) !== null && _b !== void 0 ? _b : this._more));
+    }
+}
+exports.FirstName = FirstName;
+/**
+ * Representation of a last name with some extra functionality.
+ */
+class LastName extends Name {
+    /**
+     * Creates an extended version of `Name` and flags it as a last name `type`.
+     *
+     * Some people may keep their `mother`'s surname and want to keep a clear cut
+     * from their `father`'s surname. However, there are no clear rules about it.
+     */
+    constructor(father, mother, format = types_1.Surname.FATHER) {
+        super(father, types_1.Namon.LAST_NAME);
+        this.format = format;
+        if (mother && mother.trim().length < 2) {
+            throw new error_1.InputError({ source: mother, message: 'must be 2+ characters' });
+        }
+        this._mother = mother;
+    }
+    /**
+     * The surname inherited from a father side.
+     */
+    get father() {
+        return this.value;
+    }
+    /**
+     * The surname inherited from a mother side.
+     */
+    get mother() {
+        return this._mother;
+    }
+    /**
+     * Returns `true` if the mother's surname is defined.
+     */
+    get hasMother() {
+        return !!this._mother;
+    }
+    get length() {
+        var _a, _b;
+        return super.length + ((_b = (_a = this._mother) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0);
+    }
+    /**
+     * Returns a combined version of the `father` and `mother` if any.
+     */
+    get asNames() {
+        const names = [Name.last(this.value)];
+        if (this.hasMother) {
+            names.push(Name.last(this._mother));
+        }
+        return names;
+    }
+    toString(format) {
+        var _a;
+        format = format !== null && format !== void 0 ? format : this.format;
+        switch (format) {
+            case types_1.Surname.FATHER:
+                return this.value;
+            case types_1.Surname.MOTHER:
+                return (_a = this.mother) !== null && _a !== void 0 ? _a : '';
+            case types_1.Surname.HYPHENATED:
+                return this.hasMother ? `${this.value}-${this._mother}` : this.value;
+            case types_1.Surname.ALL:
+                return this.hasMother ? `${this.value} ${this._mother}` : this.value;
+        }
+    }
+    initials(format) {
+        format = format || this.format;
+        const inits = [];
+        switch (format) {
+            case types_1.Surname.MOTHER:
+                if (this.hasMother)
+                    inits.push(this._mother[0]);
+                break;
+            case types_1.Surname.HYPHENATED:
+            case types_1.Surname.ALL:
+                inits.push(this.initial);
+                if (this.hasMother)
+                    inits.push(this._mother[0]);
+                break;
+            case types_1.Surname.FATHER:
+            default:
+                inits.push(this.initial);
+        }
+        return inits;
+    }
+    caps(range) {
+        range = range || this.capsRange;
+        this.value = utils_1.capitalize(this.value, range);
+        if (this.hasMother)
+            this._mother = utils_1.capitalize(this._mother, range);
+        return this;
+    }
+    decaps(range) {
+        range = range || this.capsRange;
+        this.value = utils_1.decapitalize(this.value, range);
+        if (this.hasMother)
+            this._mother = utils_1.decapitalize(this._mother, range);
+        return this;
+    }
+    /**
+     * Makes a copy of the current name.
+     */
+    copyWith(values) {
+        var _a, _b, _c;
+        return new LastName((_a = values.father) !== null && _a !== void 0 ? _a : this.value, (_b = values.mother) !== null && _b !== void 0 ? _b : this.mother, (_c = values.format) !== null && _c !== void 0 ? _c : this.format);
+    }
+}
+exports.LastName = LastName;
+
+
+/***/ }),
+
+/***/ "./src/namefully.ts":
+/*!**************************!*\
+  !*** ./src/namefully.ts ***!
+  \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Namefully = void 0;
+const config_1 = __webpack_require__(/*! ./config */ "./src/config.ts");
+const constants_1 = __webpack_require__(/*! ./constants */ "./src/constants.ts");
+const error_1 = __webpack_require__(/*! ./error */ "./src/error.ts");
+const parser_1 = __webpack_require__(/*! ./parser */ "./src/parser.ts");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+/**
+ * A helper for organizing person names in a particular order, way, or shape.
+ *
+ * Though `namefully` is easy to use, it does not magically guess which part of
+ * the name is what (prefix, suffix, first, last, or middle names). It relies
+ * actually on how the name parts are indicated (i.e., their roles) so that
+ * it can perform internally certain operations and saves us some extra
+ * calculations/processing. In addition, `Namefully` can be created using
+ * distinct raw data shapes. This is intended to give some flexibility to the
+ * developer so that he or she is not bound to a particular data format.
+ * By following closely the API reference to know how to harness its usability,
+ * this utility aims to save time in formatting names.
+ *
+ * `namefully` also works like a trapdoor. 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. In other words, it's immutable.
+ * Remember, this utility's primary objective is to help manipulate 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 `]` symbols 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 piece and `Smith`, the last
+ * name piece.
+ *
+ * @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 (or name order) matters
+ * and may be altered through configured parameters, which will be seen later.
+ * 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 name (e.g., first name)
+ * - nama: 2+ pieces of name (e.g., first name + last name)
+ *
+ * Happy name handling 😊!
+ */
+class Namefully {
+    /**
+     * Creates a name with distinguishable parts from a raw string content.
+     * @param names element to parse.
+     * @param options additional settings.
+     *
+     * An optional configuration may be provided with specifics on how to treat
+     * a full name during its course. By default, all name parts are validated
+     * against some basic validation rules to avoid common runtime exceptions.
+     */
+    constructor(names, options) {
+        this.build(this.toParser(names), options);
+    }
+    /**
+     * Constructs a `Namefully` instance from a text.
+     *
+     * It works like `parse` except that this function returns `null` where `parse`
+     * would throw a `NameError`.
+     */
+    static tryParse(text) {
+        try {
+            return new this(parser_1.Parser.build(text));
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    /**
+     * Constructs a `Namefully` instance from a text.
+     *
+     * It throws a `NameError` if the text cannot be parsed. Use `tryParse`
+     * instead if a `null` return is preferred over a throwable error.
+     *
+     * This operation is computed asynchronously, which gives more flexibility at
+     * the time of catching the error (and stack trace if any). The acceptable
+     * text format is a string composed of two or more name pieces. For instance,
+     * `John Lennon`, or `John Winston Ono Lennon` are parsable names and follow
+     * the basic name standard rules (i.e., first-middle-last).
+     *
+     * Keep in mind that prefix and suffix are not considered during the parsing
+     * process.
+     */
+    static parse(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return parser_1.Parser.buildAsync(text).then((parser) => new Namefully(parser));
+        });
+    }
+    /**
+     * The current configuration.
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * The number of characters of the `birthName`, including spaces.
+     */
+    get length() {
+        return this.birth.length;
+    }
+    /**
+     * The prefix part.
+     */
+    get prefix() {
+        var _a;
+        return (_a = this._fullName.prefix) === null || _a === void 0 ? void 0 : _a.toString();
+    }
+    /**
+     * The firt name.
+     */
+    get first() {
+        return this.firstName();
+    }
+    /**
+     * The first middle name if any.
+     */
+    get middle() {
+        return this.hasMiddle ? this.middleName()[0] : undefined;
+    }
+    /**
+     * Returns true if any middle name has been set.
+     */
+    get hasMiddle() {
+        return this._fullName.has(types_1.Namon.MIDDLE_NAME);
+    }
+    /**
+     * The last name.
+     */
+    get last() {
+        return this.lastName();
+    }
+    /**
+     * The suffix part.
+     */
+    get suffix() {
+        var _a;
+        return (_a = this._fullName.suffix) === null || _a === void 0 ? void 0 : _a.toString();
+    }
+    /**
+     * The birth name.
+     */
+    get birth() {
+        return this.birthName();
+    }
+    /**
+     * The shortest version of a person name.
+     */
+    get short() {
+        return this.shorten();
+    }
+    /**
+     * The longest version of a person name.
+     */
+    get long() {
+        return this.birth;
+    }
+    /**
+     * The entire name set.
+     */
+    get full() {
+        return this.fullName();
+    }
+    /**
+     * The first name combined with the last name's initial.
+     */
+    get public() {
+        return this.format('f $l');
+    }
+    /**
+     * Returns the full name as set.
+     */
+    toString() {
+        return this.full;
+    }
+    /**
+     * Fetches the raw form of a name piece.
+     */
+    get(namon) {
+        if (namon.equal(types_1.Namon.PREFIX))
+            return this._fullName.prefix;
+        if (namon.equal(types_1.Namon.FIRST_NAME))
+            return this._fullName.firstName;
+        if (namon.equal(types_1.Namon.MIDDLE_NAME))
+            return this._fullName.middleName;
+        if (namon.equal(types_1.Namon.LAST_NAME))
+            return this._fullName.lastName;
+        if (namon.equal(types_1.Namon.SUFFIX))
+            return this._fullName.suffix;
+        return undefined;
+    }
+    /**
+     * Whether this name is equal to another one from a raw-string perspective.
+     */
+    equal(other) {
+        return this.toString() === other.toString();
+    }
+    /**
+     * Gets a JSON representation of the full name.
+     */
+    toJson() {
+        return {
+            prefix: this.prefix,
+            firstName: this.first,
+            middleName: this.middleName(),
+            lastName: this.last,
+            suffix: this.suffix,
+        };
+    }
+    /**
+     * Confirms that a name part has been set.
+     */
+    has(namon) {
+        return this._fullName.has(namon);
+    }
+    /**
+     * Gets the full name ordered as configured.
+     *
+     * The name order `orderedBy` forces to order by first or last name by
+     * overriding the preset configuration.
+     *
+     * `Namefully.format` may also be used to alter manually the order of appearance
+     * of full name.
+     *
+     * For example:
+     * ```typescript
+     * const name = new Namefully('Jon Stark Snow');
+     * console.log(name.fullName(NameOrder.LAST_NAME)); // "Snow Jon Stark"
+     * console.log(name.format('l f m')); // "Snow Jon Stark"
+     * ```
+     */
+    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 {
+            names.push(this.last, this.first, this.middleName().join(' ') + sep);
+        }
+        if (this.suffix)
+            names.push(this.suffix);
+        return names.join(' ').trim();
+    }
+    /**
+     * Gets the birth name ordered as configured, no `prefix` or `suffix`.
+     *
+     * @param orderedBy forces to order by first or last name by overriding the
+     * preset configuration.
+     */
+    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(' ');
+    }
+    /**
+     * Gets the first name part of the `FullName`.
+     *
+     * @param withMore determines whether to include other pieces of the first
+     * name.
+     */
+    firstName(withMore = true) {
+        return this._fullName.firstName.toString(withMore);
+    }
+    /**
+     * Gets the middle name part of the `FullName`.
+     */
+    middleName() {
+        return this._fullName.middleName.map((n) => n.value);
+    }
+    /**
+     * Gets the last name part of the `FullName`.
+     *
+     * @param format overrides the how-to formatting of a surname output,
+     * considering its sub-parts.
+     */
+    lastName(format) {
+        return this._fullName.lastName.toString(format);
+    }
+    /**
+     * Gets the initials of the `FullName`.
+     *
+     * @param {options.orderedBy} forces to order by first or last name by
+     * overriding the preset configuration.
+     * @param
+     *
+     * For example, given the names:
+     * - `John Smith` => `['J', 'S']`
+     * - `John Ben Smith` => `['J', 'B', 'S']`.
+     */
+    initials(options) {
+        const initials = [];
+        const firstInits = this._fullName.firstName.initials();
+        const midInits = this._fullName.middleName.map((n) => n.initials()[0]);
+        const lastInits = this._fullName.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(...lastInits, ...firstInits, ...midInits);
+        }
+        return initials;
+    }
+    /**
+     * Shortens a complex full name to a simple typical name, a combination of
+     * first and last name.
+     *
+     * @param orderedBy forces to order by first or last name by overriding the
+     * preset configuration.
+     *
+     * 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 `surname` is prioritized.
+     *
+     * For a given `FirstName FatherName MotherName`, shortening this name when
+     * the surname is set as `mother` is equivalent to making it:
+     * `FirstName MotherName`.
+     */
+    shorten(orderedBy) {
+        orderedBy = orderedBy || this._config.orderedBy;
+        return orderedBy == types_1.NameOrder.FIRST_NAME
+            ? [this._fullName.firstName.value, this._fullName.lastName.toString()].join(' ')
+            : [this._fullName.lastName.toString(), this._fullName.firstName.value].join(' ');
+    }
+    /**
+     * Flattens a long name using the name types as variants.
+     *
+     * While @param limit sets a threshold as a limited number of characters
+     * supported to flatten a `FullName`, @param by indicates which variant
+     * to use when doing so. By default, a full name gets flattened by
+     * `Flat.MIDDLE_NAME`.
+     *
+     * The flattening operation is only executed iff there is a valid entry and
+     * it surpasses the limit set. In the examples below, let us assume that the
+     * name goes beyond the limit value.
+     *
+     * Flattening a long name refers to reducing the name to the following forms.
+     * For example, `John Winston Ono Lennon` flattened by:
+     * * Flat.FIRST_NAME: => 'J. Winston Ono Lennon'
+     * * Flat.MIDDLE_NAME: => 'John W. O. Lennon'
+     * * Flat.LAST_NAME: => 'John Winston Ono L.'
+     * * Flat.FIRST_MID: => 'J. W. O. Lennon'
+     * * Flat.MID_LAST: => 'John W. O. L.'
+     * * Flat.ALL: => 'J. W. O. L.'
+     *
+     * With the help of the @param recursive flag, the above operation can happen
+     * recursively in the same order if the name is still too long. For example,
+     * flattening `John Winston Ono Lennon` using the following params:
+     * `flatten({ limit: 18, by: Flat.FIRST_NAME, recursive: true })`
+     * will result in `John W. O. Lennon` and not `J. Winston Ono Lennon`.
+     *
+     * A shorter version of this method is `zip()`.
+     */
+    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 = this._fullName.firstName.toString();
+        const mn = this.middleName().join(' ');
+        const ln = this._fullName.lastName.toString();
+        const hasMid = this.hasMiddle;
+        const f = this._fullName.firstName.initials(withMore).join(sep + ' ') + sep;
+        const l = this._fullName.lastName.initials(surname).join(sep + ' ') + sep;
+        const m = hasMid ? this._fullName.middleName.map((n) => n.initials()[0]).join(sep + ' ') + sep : '';
+        let name = [];
+        if (this._config.orderedBy == types_1.NameOrder.FIRST_NAME) {
+            switch (by) {
+                case types_1.Flat.FIRST_NAME:
+                    name = hasMid ? [f, mn, ln] : [f, ln];
+                    break;
+                case types_1.Flat.LAST_NAME:
+                    name = hasMid ? [fn, mn, l] : [fn, l];
+                    break;
+                case types_1.Flat.MIDDLE_NAME:
+                    name = hasMid ? [fn, m, ln] : [fn, ln];
+                    break;
+                case types_1.Flat.FIRST_MID:
+                    name = hasMid ? [f, m, ln] : [f, ln];
+                    break;
+                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 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 types_1.Flat.MIDDLE_NAME:
+                    name = hasMid ? [ln, fn, m] : [ln, fn];
+                    break;
+                case types_1.Flat.FIRST_MID:
+                    name = hasMid ? [ln, f, m] : [ln, f];
+                    break;
+                case types_1.Flat.MID_LAST:
+                    name = hasMid ? [l, fn, m] : [l, fn];
+                    break;
+                case types_1.Flat.ALL:
+                    name = hasMid ? [l, f, m] : [l, f];
+                    break;
+            }
+        }
+        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;
+    }
+    /**
+     * Zips or compacts a name using different forms of variants.
+     *
+     * @see `flatten()` for more details.
+     */
+    zip(by = types_1.Flat.MID_LAST, withPeriod = true) {
+        return this.flatten({ limit: 0, by, withPeriod });
+    }
+    /**
+     * Formats the full name as desired.
+     * @param pattern character used to format it.
+     *
+     * string format
+     * -------------
+     * - 'short': typical first + last name
+     * - 'long': birth name (without prefix and suffix)
+     * - 'public': first name combined with the last name's initial.
+     * - 'official': official document format
+     *
+     * char format
+     * -----------
+     * - 'b': birth name
+     * - 'B': capitalized birth name
+     * - 'f': first name
+     * - 'F': capitalized first name
+     * - 'l': last name
+     * - '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
+     * - '$': an escape character to select only the initial of the next char.
+     *
+     * Given the name `Joe Jim Smith`, use `format` with the `pattern` string.
+     * - format('l f') => 'Smith Joe'
+     * - format('L, f') => 'SMITH, Joe'
+     * - format('short') => 'Joe Smith'
+     * - format() => 'SMITH, Joe Jim'
+     * - format(r'f $l.') => 'Joe S.'.
+     *
+     * Do note that the escape character is only valid for the birth name parts:
+     * first, middle, and last names.
+     */
+    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 = this.map(group)) !== null && _a !== void 0 ? _a : '');
+            group = '';
+        }
+        return formatted.join('').trim();
+    }
+    /**
+     * Flips definitely the name order from the preset/current config.
+     */
+    flip() {
+        if (this._config.orderedBy === types_1.NameOrder.FIRST_NAME) {
+            this._config.updateOrder(types_1.NameOrder.LAST_NAME);
+            console.log(`The name order is now changed to: ${types_1.NameOrder.LAST_NAME}`);
+        }
+        else {
+            this._config.updateOrder(types_1.NameOrder.FIRST_NAME);
+            console.log(`The name order is now changed to: ${types_1.NameOrder.FIRST_NAME}`);
+        }
+    }
+    /**
+     * Splits the name parts of a birth name.
+     * @param separator token for the split.
+     */
+    split(separator = /[' -]/g) {
+        return this.birth.replace(separator, ' ').split(' ');
+    }
+    /**
+     * Joins the name parts of a birth name.
+     * @param separator token for the junction.
+     */
+    join(separator = '') {
+        return this.split().join(separator);
+    }
+    /**
+     * Transforms a birth name into UPPERCASE
+     */
+    toUpperCase() {
+        return this.birth.toUpperCase();
+    }
+    /**
+     * Transforms a birth name into lowercase
+     */
+    toLowerCase() {
+        return this.birth.toLowerCase();
+    }
+    /**
+     * Transforms a birth name into camelCase
+     */
+    toCamelCase() {
+        return utils_1.decapitalize(this.toPascalCase());
+    }
+    /**
+     * Transforms a birth name into PascalCase
+     */
+    toPascalCase() {
+        return this.split()
+            .map((n) => utils_1.capitalize(n))
+            .join('');
+    }
+    /**
+     * Transforms a birth name into snake_case
+     */
+    toSnakeCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('_');
+    }
+    /**
+     * Transforms a birth name into hyphen-case
+     */
+    toHyphenCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('-');
+    }
+    /**
+     * Transforms a birth name into dot.case
+     */
+    toDotCase() {
+        return this.split()
+            .map((n) => n.toLowerCase())
+            .join('.');
+    }
+    /**
+     * Transforms a birth name into ToGgLeCaSe
+     */
+    toToggleCase() {
+        return utils_1.toggleCase(this.birth);
+    }
+    build(parser, options) {
+        this._config = config_1.Config.merge(options);
+        this._fullName = parser.parse(this._config);
+    }
+    toParser(raw) {
+        if (raw instanceof parser_1.Parser)
+            return raw;
+        if (typeof raw === 'string')
+            return new parser_1.StringParser(raw);
+        if (utils_1.isStringArray(raw))
+            return new parser_1.ArrayStringParser(raw);
+        if (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.',
+        });
+    }
+    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 {
+                    names.push(this.first + sep);
+                }
+                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 this._fullName.firstName.initials()[0];
+            case '$l':
+            case '$L':
+                return this._fullName.lastName.initials()[0];
+            case '$m':
+            case '$M':
+                return this._fullName.middleName.map((n) => n.initials()[0])[0];
+            default:
+                return undefined;
+        }
+    }
+}
+exports.Namefully = Namefully;
+
+
+/***/ }),
+
+/***/ "./src/parser.ts":
+/*!***********************!*\
+  !*** ./src/parser.ts ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayNameParser = exports.NamaParser = exports.ArrayStringParser = exports.StringParser = exports.Parser = void 0;
+const full_name_1 = __webpack_require__(/*! ./full-name */ "./src/full-name.ts");
+const config_1 = __webpack_require__(/*! ./config */ "./src/config.ts");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+const validator_1 = __webpack_require__(/*! ./validator */ "./src/validator.ts");
+const name_1 = __webpack_require__(/*! ./name */ "./src/name.ts");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const error_1 = __webpack_require__(/*! ./error */ "./src/error.ts");
+/**
+ * A parser signature that helps to organize the names accordingly.
+ */
+class Parser {
+    /**
+     * Constructs a custom parser accordingly.
+     * @param raw data to be parsed
+     */
+    constructor(raw) {
+        this.raw = raw;
+    }
+    /**
+     * Builds a dynamic `Parser` on the fly and throws a `NameError` when unable
+     * to do so. The built parser only knows how to operate birth names.
+     */
+    static build(text) {
+        const parts = text.trim().split(types_1.Separator.SPACE.token);
+        const length = parts.length;
+        if (length == 0 || length == 1) {
+            throw new error_1.InputError({
+                source: text,
+                message: 'cannot build from invalid input',
+            });
+        }
+        else if (length == 2 || length == 3) {
+            return new StringParser(text);
+        }
+        else {
+            const last = parts.pop();
+            const [first, ...middles] = parts;
+            return new ArrayStringParser([first, middles.join(' '), last]);
+        }
+    }
+    /**
+     * Builds asynchronously a dynamic `Parser`.
+     */
+    static buildAsync(text) {
+        try {
+            return Promise.resolve(Parser.build(text));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}
+exports.Parser = Parser;
+class StringParser extends Parser {
+    constructor(raw) {
+        super(raw);
+    }
+    parse(options) {
+        const config = config_1.Config.merge(options);
+        const names = this.raw.split(config.separator.token);
+        return new ArrayStringParser(names).parse(options);
+    }
+}
+exports.StringParser = StringParser;
+class ArrayStringParser extends Parser {
+    constructor(raw) {
+        super(raw);
+    }
+    parse(options) {
+        const config = config_1.Config.merge(options);
+        const fullName = new full_name_1.FullName(config);
+        const raw = this.raw.map((n) => n.trim());
+        const index = utils_1.NameIndex.when(config.orderedBy, raw.length);
+        const validator = new validator_1.ArrayStringValidator(index);
+        if (config.bypass) {
+            validator.validateIndex(raw);
+        }
+        else {
+            validator.validate(raw);
+        }
+        switch (raw.length) {
+            case 2:
+                fullName.setFirstName(new name_1.FirstName(raw[index.firstName]));
+                fullName.setLastName(new name_1.LastName(raw[index.lastName]));
+                break;
+            case 3:
+                fullName.setFirstName(new name_1.FirstName(raw[index.firstName]));
+                fullName.setMiddleName(this.split(raw[index.middleName], config));
+                fullName.setLastName(new name_1.LastName(raw[index.lastName]));
+                break;
+            case 4:
+                fullName.setPrefix(name_1.Name.prefix(raw[index.prefix]));
+                fullName.setFirstName(new name_1.FirstName(raw[index.firstName]));
+                fullName.setMiddleName(this.split(raw[index.middleName], config));
+                fullName.setLastName(new name_1.LastName(raw[index.lastName]));
+                break;
+            case 5:
+                fullName.setPrefix(name_1.Name.prefix(raw[index.prefix]));
+                fullName.setFirstName(new name_1.FirstName(raw[index.firstName]));
+                fullName.setMiddleName(this.split(raw[index.middleName], config));
+                fullName.setLastName(new name_1.LastName(raw[index.lastName]));
+                fullName.setSuffix(name_1.Name.suffix(raw[index.suffix]));
+                break;
+        }
+        return fullName;
+    }
+    split(raw, config) {
+        return raw.split(config.separator.token).map((name) => name_1.Name.middle(name));
+    }
+}
+exports.ArrayStringParser = ArrayStringParser;
+class NamaParser extends Parser {
+    constructor(raw) {
+        super(raw);
+    }
+    parse(options) {
+        const config = config_1.Config.merge(options);
+        if (config.bypass) {
+            validator_1.NamaValidator.create().validateKeys(this.asNama());
+        }
+        else {
+            validator_1.NamaValidator.create().validate(this.asNama());
+        }
+        return full_name_1.FullName.parse(this.raw, config);
+    }
+    asNama() {
+        return new Map(Object.entries(this.raw).map(([key, value]) => {
+            const namon = types_1.Namon.cast(key);
+            if (!namon) {
+                throw new error_1.InputError({
+                    source: Object.values(this.raw).join(' '),
+                    message: `unsupported key "${key}"`,
+                });
+            }
+            return [namon, value];
+        }));
+    }
+}
+exports.NamaParser = NamaParser;
+class ArrayNameParser extends Parser {
+    constructor(raw) {
+        super(raw);
+    }
+    parse(options) {
+        const config = config_1.Config.merge(options);
+        const fullName = new full_name_1.FullName(config);
+        validator_1.ArrayNameValidator.create().validate(this.raw);
+        for (let name of this.raw) {
+            if (name.isPrefix) {
+                fullName.setPrefix(name);
+            }
+            else if (name.isSuffix) {
+                fullName.setSuffix(name);
+            }
+            else if (name.isFirstName) {
+                fullName.setFirstName(name instanceof name_1.FirstName ? name : new name_1.FirstName(name.value));
+            }
+            else if (name.isMiddleName) {
+                fullName.middleName.push(name);
+            }
+            else if (name.isLastName) {
+                const lastName = new name_1.LastName(name.value, name instanceof name_1.LastName ? name.mother : undefined, config.surname);
+                fullName.setLastName(lastName);
+            }
+        }
+        return fullName;
+    }
+}
+exports.ArrayNameParser = ArrayNameParser;
+
+
+/***/ }),
+
+/***/ "./src/types.ts":
+/*!**********************!*\
+  !*** ./src/types.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Separator = exports.Namon = exports.CapsRange = exports.Flat = exports.NameType = exports.NameOrder = exports.Surname = exports.Title = void 0;
+/**
+ * The abbreviation type to indicate whether or not to add period to a prefix
+ * using the American or British way.
+ */
+var Title;
+(function (Title) {
+    // A period after the prefix.
+    Title["US"] = "US";
+    // No period after the prefix.
+    Title["UK"] = "UK";
+})(Title = exports.Title || (exports.Title = {}));
+/**
+ * An option indicating how to format a surname.
+ *
+ * This enum can be set via `Config` or when creating a `LastName`. As this can
+ * become ambiguous at the time of handling it, the value set in `Config` is
+ * prioritized and viewed as the source of truth for future considerations.
+ */
+var Surname;
+(function (Surname) {
+    // The fatherly surname only.
+    Surname["FATHER"] = "father";
+    // The motherly surname only.
+    Surname["MOTHER"] = "mother";
+    // The junction of both the fatherly and motherly surnames with a hyphen.
+    Surname["HYPHENATED"] = "hyphenated";
+    // The junction of both the fatherly and motherly surnames with a space.
+    Surname["ALL"] = "all";
+})(Surname = exports.Surname || (exports.Surname = {}));
+/**
+ * The order of appearance of a `FullName`.
+ */
+var NameOrder;
+(function (NameOrder) {
+    // The first part of a full name, usually the first piece of a person name.
+    NameOrder["FIRST_NAME"] = "firstName";
+    // The last part of a full name, usually the last piece of a person name.
+    NameOrder["LAST_NAME"] = "lastName";
+})(NameOrder = exports.NameOrder || (exports.NameOrder = {}));
+/**
+ * The types of name handled in this according the name standards.
+ */
+var NameType;
+(function (NameType) {
+    NameType["FIRST_NAME"] = "firstName";
+    NameType["MIDDLE_NAME"] = "middleName";
+    NameType["LAST_NAME"] = "lastName";
+    NameType["BIRTH_NAME"] = "birthName";
+})(NameType = exports.NameType || (exports.NameType = {}));
+/**
+ * The possible variants to indicate how to flatten a `FullName`.
+ */
+var Flat;
+(function (Flat) {
+    // Use the first name's initial combined with the remaining parts.
+    Flat["FIRST_NAME"] = "firstName";
+    // Use the middle name's initial combined with the remaining parts.
+    Flat["MIDDLE_NAME"] = "middleName";
+    // Use the last name's initial combined with the remaining parts.
+    Flat["LAST_NAME"] = "lastName";
+    // Use both the first and middle names' initials combined with the remaining parts.
+    Flat["FIRST_MID"] = "firstMid";
+    // Use both the last and middle names' initials combined with the remaining parts.
+    Flat["MID_LAST"] = "midLast";
+    // Use the first, middle and last names' initials combined with the remaining parts.
+    Flat["ALL"] = "all";
+})(Flat = exports.Flat || (exports.Flat = {}));
+/**
+ * The range to use when capitalizing a string content.
+ */
+var CapsRange;
+(function (CapsRange) {
+    // No capitalization.
+    CapsRange[CapsRange["NONE"] = 0] = "NONE";
+    // Apply capitalization to the first letter.
+    CapsRange[CapsRange["INITIAL"] = 1] = "INITIAL";
+    // Apply capitalization to all the letters.
+    CapsRange[CapsRange["ALL"] = 2] = "ALL";
+})(CapsRange = exports.CapsRange || (exports.CapsRange = {}));
+/**
+ * The types of name handled in this utility according the name standards.
+ */
+class Namon {
+    constructor(index, key) {
+        this.index = index;
+        this.key = key;
+    }
+    /**
+     * Whether this string key is part of the predefined keys.
+     */
+    static has(key) {
+        return Namon.all.has(key);
+    }
+    /**
+     * Makes a string key a namon type.
+     */
+    static cast(key) {
+        return Namon.has(key) ? Namon.all.get(key) : undefined;
+    }
+    /**
+     * String representation of this object.
+     */
+    toString() {
+        return `Namon.${this.key}`;
+    }
+    /**
+     * Whether this and the other value are equal.
+     */
+    equal(other) {
+        return other instanceof Namon && other.index == this.index && other.key == this.key;
+    }
+}
+exports.Namon = Namon;
+Namon.PREFIX = new Namon(0, 'prefix');
+Namon.FIRST_NAME = new Namon(1, 'firstName');
+Namon.MIDDLE_NAME = new Namon(2, 'middleName');
+Namon.LAST_NAME = new Namon(3, 'lastName');
+Namon.SUFFIX = new Namon(4, 'suffix');
+/**
+ * The list of supported name types.
+ */
+Namon.values = [Namon.PREFIX, Namon.FIRST_NAME, Namon.MIDDLE_NAME, Namon.LAST_NAME, Namon.SUFFIX];
+/**
+ * All the predefined name types.
+ */
+Namon.all = new Map([
+    [Namon.PREFIX.key, Namon.PREFIX],
+    [Namon.FIRST_NAME.key, Namon.FIRST_NAME],
+    [Namon.MIDDLE_NAME.key, Namon.MIDDLE_NAME],
+    [Namon.LAST_NAME.key, Namon.LAST_NAME],
+    [Namon.SUFFIX.key, Namon.SUFFIX],
+]);
+/**
+ * The token used to indicate how to split string values.
+ */
+class Separator {
+    constructor(name, token) {
+        this.name = name;
+        this.token = token;
+    }
+    /**
+     * String representation of this object.
+     */
+    toString() {
+        return `Separator.${this.name}`;
+    }
+}
+exports.Separator = Separator;
+Separator.COMMA = new Separator('comma', ',');
+Separator.COLON = new Separator('colon', ':');
+Separator.DOUBLE_QUOTE = new Separator('doubleQuote', '"');
+Separator.EMPTY = new Separator('empty', '');
+Separator.HYPHEN = new Separator('hyphen', '-');
+Separator.PERIOD = new Separator('period', '.');
+Separator.SEMI_COLON = new Separator('semiColon', ';');
+Separator.SINGLE_QUOTE = new Separator('singleQuote', "'");
+Separator.SPACE = new Separator('space', ' ');
+Separator.UNDERSCORE = new Separator('underscore', '_');
+/**
+ * All the available separators.
+ */
+Separator.all = new Map([
+    [Separator.COMMA.name, Separator.COMMA],
+    [Separator.COLON.name, Separator.COLON],
+    [Separator.DOUBLE_QUOTE.name, Separator.DOUBLE_QUOTE],
+    [Separator.EMPTY.name, Separator.EMPTY],
+    [Separator.HYPHEN.name, Separator.HYPHEN],
+    [Separator.PERIOD.name, Separator.PERIOD],
+    [Separator.SEMI_COLON.name, Separator.SEMI_COLON],
+    [Separator.SINGLE_QUOTE.name, Separator.SINGLE_QUOTE],
+    [Separator.SPACE.name, Separator.SPACE],
+    [Separator.UNDERSCORE.name, Separator.UNDERSCORE],
+]);
+/**
+ * All the available tokens.
+ */
+Separator.tokens = [...Separator.all.values()].map((s) => s.token);
+
+
+/***/ }),
+
+/***/ "./src/utils.ts":
+/*!**********************!*\
+  !*** ./src/utils.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNameArray = exports.isStringArray = exports.toggleCase = exports.decapitalize = exports.capitalize = exports.NameIndex = void 0;
+const constants_1 = __webpack_require__(/*! ./constants */ "./src/constants.ts");
+const name_1 = __webpack_require__(/*! ./name */ "./src/name.ts");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+/**
+ * A fixed set of values to handle specific positions for list of names.
+ *
+ * As for list of names, this helps to follow a specific order based on the
+ * count of elements. It is expected that the list has to be between two and
+ * five elements. Also, the order of appearance set in the configuration
+ * influences how the parsing is carried out.
+ *
+ * Ordered by first name, the parser works as follows:
+ * - 2 elements: firstName lastName
+ * - 3 elements: firstName middleName lastName
+ * - 4 elements: prefix firstName middleName lastName
+ * - 5 elements: prefix firstName middleName lastName suffix
+ *
+ * Ordered by last name, the parser works as follows:
+ * - 2 elements: lastName firstName
+ * - 3 elements: lastName firstName middleName
+ * - 4 elements: prefix lastName firstName middleName
+ * - 5 elements: prefix lastName firstName middleName suffix
+ *
+ * For example, `Jane Smith` (ordered by first name) is expected to be indexed:
+ * `['Jane', 'Smith']`.
+ */
+class NameIndex {
+    constructor(prefix, firstName, middleName, lastName, suffix) {
+        this.prefix = prefix;
+        this.firstName = firstName;
+        this.middleName = middleName;
+        this.lastName = lastName;
+        this.suffix = suffix;
+    }
+    /**
+     * The minimum number of parts in a list of names.
+     */
+    static get min() {
+        return constants_1.MIN_NUMBER_OF_NAME_PARTS;
+    }
+    /**
+     * The maximum number of parts in a list of names.
+     */
+    static get max() {
+        return constants_1.MAX_NUMBER_OF_NAME_PARTS;
+    }
+    /**
+     * The default or base indexing: firstName lastName.
+     */
+    static base() {
+        return new this(-1, 0, -1, 1, -1);
+    }
+    /**
+     * Gets the name index for a list of names based on the `count` of elements
+     * and their `order` of appearance.
+     */
+    static when(order, count = 2) {
+        if (order == types_1.NameOrder.FIRST_NAME) {
+            switch (count) {
+                case 2: // first name + last name
+                    return new this(-1, 0, -1, 1, -1);
+                case 3: // first name + middle name + last name
+                    return new this(-1, 0, 1, 2, -1);
+                case 4: // prefix + first name + middle name + last name
+                    return new this(0, 1, 2, 3, -1);
+                case 5: // prefix + first name + middle name + last name + suffix
+                    return new this(0, 1, 2, 3, 4);
+                default:
+                    return NameIndex.base();
+            }
+        }
+        else {
+            switch (count) {
+                case 2: // last name + first name
+                    return new this(-1, 1, -1, 0, -1);
+                case 3: // last name + first name + middle name
+                    return new this(-1, 1, 2, 0, -1);
+                case 4: // prefix + last name + first name + middle name
+                    return new this(0, 2, 3, 1, -1);
+                case 5: // prefix + last name + first name + middle name + suffix
+                    return new this(0, 2, 3, 1, 4);
+                default:
+                    return NameIndex.base();
+            }
+        }
+    }
+}
+exports.NameIndex = NameIndex;
+/**
+ * Capitalizes a string via a `CapsRange` option.
+ */
+function capitalize(str, range = types_1.CapsRange.INITIAL) {
+    if (!str || range === types_1.CapsRange.NONE)
+        return str;
+    const initial = str[0].toUpperCase();
+    const rest = str.slice(1).toLowerCase();
+    return range === types_1.CapsRange.INITIAL ? initial.concat(rest) : str.toUpperCase();
+}
+exports.capitalize = capitalize;
+/**
+ * Decapitalizes a string via a `CapsRange` option.
+ */
+function decapitalize(str, range = types_1.CapsRange.INITIAL) {
+    if (!str || range === types_1.CapsRange.NONE)
+        return str;
+    const initial = str[0].toLowerCase();
+    const rest = str.slice(1);
+    return range === types_1.CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase();
+}
+exports.decapitalize = decapitalize;
+/**
+ * Toggles a string representation.
+ */
+function toggleCase(str) {
+    const chars = [];
+    for (const c of str) {
+        if (c === c.toUpperCase()) {
+            chars.push(c.toLowerCase());
+        }
+        else {
+            chars.push(c.toUpperCase());
+        }
+    }
+    return chars.join('');
+}
+exports.toggleCase = toggleCase;
+function isStringArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((e) => typeof e === 'string');
+}
+exports.isStringArray = isStringArray;
+function isNameArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((e) => e instanceof name_1.Name);
+}
+exports.isNameArray = isNameArray;
+
+
+/***/ }),
+
+/***/ "./src/validator.ts":
+/*!**************************!*\
+  !*** ./src/validator.ts ***!
+  \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validators = exports.ArrayNameValidator = exports.ArrayStringValidator = exports.NamaValidator = void 0;
+const constants_1 = __webpack_require__(/*! ./constants */ "./src/constants.ts");
+const error_1 = __webpack_require__(/*! ./error */ "./src/error.ts");
+const name_1 = __webpack_require__(/*! ./name */ "./src/name.ts");
+const types_1 = __webpack_require__(/*! ./types */ "./src/types.ts");
+const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
+/**
+ * Represents a set of validation rules (regex)
+ *
+ * This regex is intented to match specific alphabets only as a person name does
+ * not contain special characters. `\w` does not cover non-Latin characters. So,
+ * it is extended using unicode chars to cover more cases (e.g., Icelandic).
+ * It matches as follows:
+ *  [a-z]: Latin alphabet from a (index 97) to z (index 122)
+ *  [A-Z]: Latin alphabet from A (index 65) to Z (index 90)
+ *  [\u00C0-\u00D6]: Latin/German chars from À (index 192) to Ö (index 214)
+ *  [\u00D8-\u00f6]: German/Icelandic chars from Ø (index 216) to ö (index 246)
+ *  [\u00f8-\u00ff]: German/Icelandic chars from ø (index 248) to ÿ (index 255)
+ *  [\u0400-\u04FF]: Cyrillic alphabet from Ѐ (index 1024) to ӿ (index 1279)
+ *  [Ά-ωΑ-ώ]: Greek alphabet from Ά (index 902) to ω (index 969)
+ */
+class ValidationRule {
+}
+ValidationRule.base = /[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]/;
+/**
+ * Matches one name part (namon) that is of nature:
+ * - Latin (English, Spanish, French, etc.)
+ * - European (Greek, Cyrillic, Icelandic, German)
+ * - hyphenated
+ * - with apostrophe
+ * - with space
+ */
+ValidationRule.namon = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
+/**
+ * Matches one name part (namon) that is of nature:
+ * - Latin (English, Spanish, French, etc.)
+ * - European (Greek, Cyrillic, Icelandic, German)
+ * - hyphenated
+ * - with apostrophe
+ */
+ValidationRule.firstName = ValidationRule.namon;
+/**
+ * Matches 1+ names part (namon) that are of nature:
+ * - Latin (English, Spanish, French, etc.)
+ * - European (Greek, Cyrillic, Icelandic, German)
+ * - hyphenated
+ * - with apostrophe
+ * - with space
+ */
+ValidationRule.middleName = new RegExp(`^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`);
+/**
+ * Matches one name part (namon) that is of nature:
+ * - Latin (English, Spanish, French, etc.)
+ * - European (Greek, Cyrillic, Icelandic, German)
+ * - hyphenated
+ * - with apostrophe
+ * - with space
+ */
+ValidationRule.lastName = ValidationRule.namon;
+class ArrayValidator {
+    validate(values) {
+        if (values.length == 0 ||
+            values.length < constants_1.MIN_NUMBER_OF_NAME_PARTS ||
+            values.length > constants_1.MAX_NUMBER_OF_NAME_PARTS) {
+            throw new error_1.InputError({
+                source: values.map((n) => n.toString()),
+                message: `expecting a list of ${constants_1.MIN_NUMBER_OF_NAME_PARTS}-${constants_1.MIN_NUMBER_OF_NAME_PARTS} elements`,
+            });
+        }
+    }
+}
+class NamonValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
+    }
+    validate(value, type) {
+        if (value instanceof name_1.Name) {
+            NameValidator.create().validate(value, type);
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.namon.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'namon',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types of string | Name',
+            });
+        }
+    }
+}
+class FirstNameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
+    }
+    validate(value) {
+        if (value instanceof name_1.FirstName) {
+            value.asNames.forEach((name) => this.validate(name.value));
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.firstName.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'firstName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types string | FirstName',
+            });
+        }
+    }
+}
+class MiddleNameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
+    }
+    validate(value) {
+        if (typeof value === 'string') {
+            if (!ValidationRule.middleName.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'middleName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else if (Array.isArray(value)) {
+            try {
+                const validator = NamonValidator.create();
+                for (let name of value)
+                    validator.validate(name, types_1.Namon.MIDDLE_NAME);
+            }
+            catch (error) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'middleName',
+                    message: error === null || error === void 0 ? void 0 : error.message,
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types of string | string[] | Name[]',
+            });
+        }
+    }
+}
+class LastNameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
+    }
+    validate(value) {
+        if (value instanceof name_1.LastName) {
+            value.asNames.forEach((name) => this.validate(name.value));
+        }
+        else if (typeof value === 'string') {
+            if (!ValidationRule.lastName.test(value)) {
+                throw new error_1.ValidationError({
+                    source: value,
+                    nameType: 'lastName',
+                    message: 'invalid content',
+                });
+            }
+        }
+        else {
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types string | LastName',
+            });
+        }
+    }
+}
+class NameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
+    }
+    validate(name, type) {
+        if (type && name.type !== type) {
+            throw new error_1.ValidationError({
+                source: [name],
+                nameType: name.type.toString(),
+                message: 'wrong type',
+            });
+        }
+        if (!ValidationRule.namon.test(name.value)) {
+            throw new error_1.ValidationError({
+                source: [name],
+                nameType: name.type.toString(),
+                message: 'invalid content',
+            });
+        }
+    }
+}
+class NamaValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
+    }
+    validate(value) {
+        this.validateKeys(value);
+        Validators.firstName.validate(value.get(types_1.Namon.FIRST_NAME));
+        Validators.lastName.validate(value.get(types_1.Namon.LAST_NAME));
+        if (value.has(types_1.Namon.PREFIX)) {
+            Validators.namon.validate(value.get(types_1.Namon.PREFIX));
+        }
+        if (value.has(types_1.Namon.SUFFIX)) {
+            Validators.namon.validate(value.get(types_1.Namon.SUFFIX));
+        }
+    }
+    validateKeys(nama) {
+        if (!nama.size) {
+            throw new error_1.InputError({ source: undefined, message: 'Map<k,v> must not be empty' });
+        }
+        else if (nama.size < constants_1.MIN_NUMBER_OF_NAME_PARTS || nama.size > constants_1.MAX_NUMBER_OF_NAME_PARTS) {
+            throw new error_1.InputError({
+                source: [...nama.values()],
+                message: `expecting ${constants_1.MIN_NUMBER_OF_NAME_PARTS}-${constants_1.MIN_NUMBER_OF_NAME_PARTS} fields`,
+            });
+        }
+        if (!nama.has(types_1.Namon.FIRST_NAME)) {
+            throw new error_1.InputError({
+                source: [...nama.values()],
+                message: '"firstName" is a required key',
+            });
+        }
+        if (!nama.has(types_1.Namon.LAST_NAME)) {
+            throw new error_1.InputError({
+                source: [...nama.values()],
+                message: '"lastName" is a required key',
+            });
+        }
+    }
+}
+exports.NamaValidator = NamaValidator;
+class ArrayStringValidator extends ArrayValidator {
+    constructor(index = utils_1.NameIndex.base()) {
+        super();
+        this.index = index;
+    }
+    validate(values) {
+        this.validateIndex(values);
+        switch (values.length) {
+            case 2:
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                break;
+            case 3:
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.middleName.validate(values[this.index.middleName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                break;
+            case 4:
+                Validators.namon.validate(values[this.index.prefix]);
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.middleName.validate(values[this.index.middleName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                break;
+            case 5:
+                Validators.namon.validate(values[this.index.prefix]);
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.middleName.validate(values[this.index.middleName]);
+                Validators.lastName.validate(values[this.index.lastName]);
+                Validators.namon.validate(values[this.index.suffix]);
+                break;
+        }
+    }
+    validateIndex(values) {
+        super.validate(values);
+    }
+}
+exports.ArrayStringValidator = ArrayStringValidator;
+class ArrayNameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
+    }
+    validate(value) {
+        if (value.length < constants_1.MIN_NUMBER_OF_NAME_PARTS) {
+            throw new error_1.InputError({
+                source: value,
+                message: `expecting at least ${constants_1.MIN_NUMBER_OF_NAME_PARTS} elements`,
+            });
+        }
+        if (!this.hasBasicNames(value)) {
+            throw new error_1.InputError({
+                source: value,
+                message: 'both first and last names are required',
+            });
+        }
+    }
+    hasBasicNames(names) {
+        const accumulator = {};
+        for (const name of names) {
+            if (name.isFirstName || name.isLastName) {
+                accumulator[name.type.key] = name.toString();
+            }
+        }
+        return Object.keys(accumulator).length == constants_1.MIN_NUMBER_OF_NAME_PARTS;
+    }
+}
+exports.ArrayNameValidator = ArrayNameValidator;
+/**
+ * A list of validators for a specific namon.
+ */
+class Validators {
+}
+exports.Validators = Validators;
+Validators.namon = NamonValidator.create();
+Validators.nama = NamaValidator.create();
+Validators.prefix = NamonValidator.create();
+Validators.firstName = FirstNameValidator.create();
+Validators.middleName = MiddleNameValidator.create();
+Validators.lastName = LastNameValidator.create();
+Validators.suffix = NamonValidator.create();
+
+
+/***/ })
+
+/******/ });
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./example/example.ts","webpack:///./src/config.ts","webpack:///./src/constants.ts","webpack:///./src/error.ts","webpack:///./src/full-name.ts","webpack:///./src/index.ts","webpack:///./src/name.ts","webpack:///./src/namefully.ts","webpack:///./src/parser.ts","webpack:///./src/types.ts","webpack:///./src/utils.ts","webpack:///./src/validator.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./example/example.ts\");\n","import { Namefully, NameOrder } from '../src/index'\n\nfunction example() {\n    // Gives a simple name some super power.\n    const name = new Namefully('Thomas Alva Edison', { orderedBy: NameOrder.LAST_NAME })\n\n    // Gets the count of characters, including space.\n    console.log(name.length) // 18\n\n    // Gets the first name.\n    console.log(name.first) // Thomas\n\n    // Gets the first middle name.\n    console.log(name.middle) // Alva\n\n    // Gets the last name.\n    console.log(name.last) // Edison\n\n    // Controls what the public sees.\n    console.log(name.public) // Thomas E\n\n    // Gets all the initials.\n    console.log(name.initials()) // ['T', 'A', 'E']\n\n    // Formats it as desired.\n    console.log(name.format('L, f m')) // EDISON, Thomas Alva\n\n    // Makes it short.\n    console.log(name.shorten()) // Thomas Edison\n\n    // Makes it flat.\n    console.log(name.zip()) // Thomas A. E.\n\n    // Makes it uppercase.\n    console.log(name.toUpperCase()) // THOMAS ALVA EDISON\n\n    // Transforms it into dot.case.\n    console.log(name.toDotCase()) // thomas.alva.edison\n}\n\nexample()\n","import { NameOrder, Separator, Title, Surname } from './types'\n\nconst defaultName = 'default'\nconst copyAlias = '_copy'\n\n/**\n * The Configuration to use across the other components.\n *\n * The multiton pattern is used to handle configurations across the `namefully`\n * setup. This adds consistency when building other components such as `FirstName`,\n * `LastName`, or `Name` of distinct types that may be of particular shapes.\n *\n * For example, a person's `FullName` may appear by:\n * - NameOrder.FIRST_NAME: `Jon Snow` or\n * - NameOrder.LAST_NAME: `Snow Jon`.\n *\n * `Config` makes it easy to set up a specific configuration for `Namefully`\n * and reuse it through other instances or components along the way. If a new\n * `Config` is needed, a named configuration may be created. It is actually\n * advised to use named `Config.create(name)` instead as it may help mitigate issues\n * and avoid confusion and ambiguity in the future. Plus, a named configuration\n * explains its purpose.\n *\n * ```ts\n * const defaultConfig = Config.create();\n * const mergedConfig = Config.merge({ name: 'other', title: Title.US });\n * const copyConfig = mergedConfig.copyWith({ ending: true });\n * ```\n *\n * Additionally, a configuration may be merged with or copied from an existing\n * configuration, prioritizing the new one's values, as shown in the example\n * above.\n */\nexport class Config {\n    private _name: string\n    private _orderedBy: NameOrder\n    private _separator: Separator\n    private _title: Title\n    private _ending: boolean\n    private _bypass: boolean\n    private _surname: Surname\n\n    /**\n     * The order of appearance of a full name.\n     */\n    get orderedBy(): NameOrder {\n        return this._orderedBy\n    }\n\n    /**\n     * The token used to indicate how to split string values.\n     */\n    get separator(): Separator {\n        return this._separator\n    }\n\n    /**\n     * The abbreviation type to indicate whether or not to add period to a prefix\n     * using the American or British way.\n     */\n    get title(): Title {\n        return this._title\n    }\n\n    /**\n     * The option indicating if an ending suffix is used in a formal way.\n     */\n    get ending(): boolean {\n        return this._ending\n    }\n\n    /**\n     * A bypass of the validation rules with this option. This option is ideal\n     * to avoid checking their validity.\n     */\n    get bypass(): boolean {\n        return this._bypass\n    }\n\n    /**\n     * An option indicating how to format a surname.\n     *\n     * The supported formats are:\n     * - `FATHER` name only\n     * - `MOTHER` name only\n     * - `HYPHENATED`, joining both father and mother names with a hyphen\n     * - `ALL`, joining both father and mother names with a space.\n     *\n     * Note that this option can be set when creating a `LastName`. As this can\n     * become ambiguous at the time of handling it, the value set in this is\n     * prioritized and viewed as the source of truth for future considerations.\n     */\n    get surname(): Surname {\n        return this._surname\n    }\n\n    /**\n     * The name of the cached configuration.\n     */\n    get name(): string {\n        return this._name\n    }\n\n    /**\n     * Cache for multiple instances.\n     */\n    private static cache = new Map<string, Config>()\n\n    private constructor(\n        name: string,\n        orderedBy = NameOrder.FIRST_NAME,\n        separator = Separator.SPACE,\n        title = Title.UK,\n        ending = false,\n        bypass = true,\n        surname = Surname.FATHER,\n    ) {\n        this._name = name\n        this._orderedBy = orderedBy\n        this._separator = separator\n        this._title = title\n        this._ending = ending\n        this._bypass = bypass\n        this._surname = surname\n    }\n\n    /**\n     * Returns a named configuration with default values.\n     * @param name describing its purpose.\n     */\n    static create(name = defaultName): Config {\n        if (!Config.cache.has(name)) {\n            Config.cache.set(name, new this(name))\n        }\n        return Config.cache.get(name)\n    }\n\n    /**\n     * Returns a combined version of the existing values of the default configuration\n     * and the provided optional values of another configuration.\n     * @param other partial config to be combined with.\n     */\n    static merge(other?: Partial<Config>): Config {\n        if (!other) {\n            return Config.create()\n        } else {\n            const config = Config.create(other.name)\n            config._orderedBy = other.orderedBy ?? config.orderedBy\n            config._separator = other.separator ?? config.separator\n            config._title = other.title ?? config.title\n            config._ending = other.ending ?? config.ending\n            config._bypass = other.bypass ?? config.bypass\n            config._surname = other.surname ?? config.surname\n            return config\n        }\n    }\n\n    /**\n     * Returns a copy of this configuration merged with the provided values.\n     *\n     * The word `_copy` is added to the existing config's name to create the new\n     * config's name if the name already exists for previous configurations. This\n     * is useful to maintain the uniqueness of each configuration. For example,\n     * if the new copy is made from the default configuration, this new copy will\n     * be named `default_copy`.\n     */\n    copyWith(options: Partial<Config> = {}): Config {\n        const { name, orderedBy, separator, title, ending, bypass, surname } = options\n        const config = Config.create(this.genNewName(name ?? this.name + copyAlias))\n        config._orderedBy = orderedBy ?? this.orderedBy\n        config._separator = separator ?? this.separator\n        config._title = title ?? this.title\n        config._ending = ending ?? this.ending\n        config._bypass = bypass ?? this.bypass\n        config._surname = surname ?? this.surname\n        return config\n    }\n\n    /**\n     * Makes an exact copy of the current configuration.\n     */\n    clone(): Config {\n        return this.copyWith()\n    }\n\n    /**\n     * Resets the configuration by setting it back to its default values.\n     */\n    reset(): void {\n        this._orderedBy = NameOrder.FIRST_NAME\n        this._separator = Separator.SPACE\n        this._title = Title.UK\n        this._ending = false\n        this._bypass = true\n        this._surname = Surname.FATHER\n        Config.cache.set(this.name, this)\n    }\n\n    /**\n     * Alters the name order between the first and last name, and rearrange the\n     * order of appearance of a name set.\n     */\n    updateOrder(order: NameOrder): void {\n        if (order && order !== this._orderedBy) {\n            Config.cache.get(this.name)._orderedBy = order\n        }\n    }\n\n    /**\n     * Generates a unique new name.\n     */\n    private genNewName(name: string): string {\n        return name === this.name || Config.cache.has(name) ? this.genNewName(name + copyAlias) : name\n    }\n}\n","export const version = '1.2.0'\nexport const MIN_NUMBER_OF_NAME_PARTS = 2\nexport const MAX_NUMBER_OF_NAME_PARTS = 5\nexport const ALLOWED_TOKENS = [\n    '.',\n    ',',\n    ' ',\n    '-',\n    '_',\n    'b',\n    'B',\n    'f',\n    'F',\n    'l',\n    'L',\n    'm',\n    'M',\n    'n',\n    'N',\n    'o',\n    'O',\n    'p',\n    'P',\n    's',\n    'S',\n    '$',\n]\n","import { Name } from './name'\nimport { Nullable } from './types'\nimport { isNameArray, isStringArray } from './utils'\n\ntype NameSource = Nullable<string | string[] | Name[]>\n\ninterface ErrorMessage {\n    source: NameSource\n    message?: string\n}\n\n/**\n * The error types supported by `Namefully`.\n */\nexport enum NameErrorType {\n    /**\n     * Thrown when a name entry/argument is incorrect.\n     *\n     * For example, a name should have a minimum of 2 characters, so an empty\n     * string or a string of one character would cause this kind of error.\n     */\n    INPUT,\n\n    /**\n     * Thrown when the name components do not match the validation rules if the\n     * `Config.bypass` is not flagged up. This bypass option skips the validation\n     * rules.\n     *\n     * See also: `ValidationError`\n     */\n    VALIDATION,\n\n    /**\n     * Thrown by not allowed operations such as in NameBuilder or name formatting.\n     *\n     * See also: `NotAllowedError`, `Namefully.format`.\n     */\n    NOT_ALLOWED,\n\n    /**\n     * Thrown by any other unknown sources or unexpected situation.\n     */\n    UNKNOWN,\n}\n\n/**\n * Base class for all name-related errors.\n *\n * A custom error is intended to convey information to the user about a failure,\n * so that it can be addressed programmatically.\n *\n * A name handling failure is not considered a native error that should cause a\n * program failure. Au contraire, it is expected that a programmer using this utility\n * would consider validating a name using its own business rules. That is not\n * this utility's job to guess those rules. So, the predefined `ValidationRules`\n * obey some common validation techniques when it comes to sanitizing a person\n * name. For this reason, the [Config.bypass] is set to `true` by default,\n * indicating that those predefined rules should be skipped for the sake of the\n * program.\n *\n * A programmer may leverage `Parser` to indicate business-tailored rules if he\n * or she wants this utility to perform those safety checks behind the scenes.\n *\n * A name error intends to provide useful information about what causes the error\n * and let the user take initiative on what happens next to the given name:\n * reconstructing it or skipping it.\n */\nexport class NameError extends Error {\n    /**\n     * Creates an error with a message describing the issue for a name source.\n     * @param source name input that caused the error\n     * @param message a message describing the failure.\n     * @param type of `NameErrorType`\n     */\n    constructor(readonly source: NameSource, message?: string, readonly type: NameErrorType = NameErrorType.UNKNOWN) {\n        super(message)\n        this.name = 'NameError'\n    }\n\n    /**\n     * The actual source input which caused the error.\n     */\n    get sourceAsString(): string {\n        let input = ''\n        if (!this.source) input = '<undefined>'\n        if (typeof this.source === 'string') input = this.source\n        if (isNameArray(this.source)) input = (<Name[]>this.source).map((n) => n.toString()).join(' ')\n        if (isStringArray(this.source)) input = (<string[]>this.source).join(' ')\n        return input\n    }\n\n    /**\n     * Whether a message describing the failure exists.\n     */\n    get hasMessage(): boolean {\n        return this.message && this.message.trim().length > 0\n    }\n\n    /**\n     * Returns a string representation of the error.\n     */\n    toString(): string {\n        let report = `${this.name} (${this.sourceAsString})`\n        if (this.hasMessage) report = `${report}: ${this.message}`\n        return report\n    }\n}\n\n/**\n * An error thrown when a name source input is incorrect.\n *\n * A `Name` is a name for this utility under certain criteria (i.e., 2+ chars),\n * hence, a wrong input will cause this kind of error. Another common reason\n * may be a wrong key in a Json name parsing mechanism.\n *\n * Keep in mind that this error is different from a `ValidationError`.\n */\nexport class InputError extends NameError {\n    /**\n     * Creates a new `InputError` with an optional error `message`.\n     *\n     * The name source is by nature a string content, maybe wrapped up in a different\n     * type. This string value may be extracted to form the following output:\n     *   \"InputError (stringName)\",\n     *   \"InputError (stringName): message\".\n     */\n    constructor(error: ErrorMessage) {\n        super(error.source, error.message, NameErrorType.INPUT)\n        this.name = 'InputError'\n    }\n}\n\n/**\n * An error thrown to indicate that a name fails the validation rules.\n */\nexport class ValidationError extends NameError {\n    /**\n     * Name of the invalid `nameType` if available.\n     */\n    readonly nameType: string\n\n    /**\n     * Creates error containing the invalid `nameType` and a `message` that\n     * briefly describes the problem if provided.\n     *\n     * For example, a validation error can be interpreted as:\n     *     \"ValidationError (nameType='stringName')\",\n     *     \"ValidationError (nameType='stringName'): message\"\n     */\n    constructor(error: ErrorMessage & { nameType: string }) {\n        super(error.source, error.message, NameErrorType.VALIDATION)\n        this.nameType = error.nameType\n        this.name = 'ValidationError'\n    }\n\n    toString(): string {\n        let report = `${this.name} (${this.nameType}='${this.sourceAsString}')`\n        if (this.hasMessage) report = `${report}: ${this.message}`\n        return report\n    }\n}\n\n/**\n * Thrown by not allowed operations such as in name formatting.\n *\n * For example, this will occur when trying to format a name accordingly using\n * a non-supported key.\n */\nexport class NotAllowedError extends NameError {\n    /**\n     * The revoked operation name.\n     */\n    readonly operation: string\n\n    /**\n     * Creates a new `NotAllowedError` with an optional error `message` and the\n     * `operation` name.\n     *\n     * For example, an error of this kind can be interpreted as:\n     *     \"NotAllowedError (stringName)\",\n     *     \"NotAllowedError (stringName) - operationName\",\n     *     \"NotAllowedError (stringName) - operationName: message\"\n     */\n    constructor(error: ErrorMessage & { operation: string }) {\n        super(error.source, error.message, NameErrorType.NOT_ALLOWED)\n        this.operation = error.operation\n        this.name = 'NotAllowedError'\n    }\n\n    toString(): string {\n        let report = `${this.name} (${this.sourceAsString})`\n        if (this.operation && this.operation.trim().length > 0) report = `${report} - ${this.operation}`\n        if (this.hasMessage) report = `${report}: ${this.message}`\n        return report\n    }\n}\n\n/**\n * A fallback error thrown by any unknown sources or unexpected failure that are\n * not of `NameError`.\n *\n * In this particular case, an `origin` remains useful as it provides details\n * on the sources and the true nature of the unexpected error.\n * At this point, deciding whether to exit the program or not depends on the\n * programmer.\n */\nexport class UnknownError extends NameError {\n    /**\n     * The possible unknown error, with trace revealing its source and reason.\n     */\n    readonly origin?: Error\n\n    /**\n     * Creates a new `UnknownError` with an optional error `message`.\n     * Optionally, the original error revealing the true nature of the failure.\n     */\n    constructor(error: ErrorMessage & { error?: Error }) {\n        super(error.source, error.message, NameErrorType.UNKNOWN)\n        this.origin = error.error\n        this.name = 'UnknownError'\n    }\n\n    toString(): string {\n        let report = super.toString()\n        if (this.origin) report += `\\n${this.origin.toString()}`\n        return report\n    }\n}\n","import { Config } from './config'\nimport { NameError, UnknownError } from './error'\nimport { FirstName, LastName, Name, JsonName } from './name'\nimport { Nullable, Namon, Title } from './types'\nimport { Validators } from './validator'\n\n/**\n * The core component of this utility.\n *\n * This component is comprised of five entities that make it easy to handle a\n * full name set: prefix, first name, middle name, last name, and suffix.\n * This class is intended for internal processes. However, it is understandable\n * that it might be needed at some point for additional purposes. For this reason,\n * it's made available.\n *\n * It is recommended to avoid using this class unless it is highly necessary or\n * a custom parser is used for uncommon use cases. This utility tries to cover\n * as many use cases as possible.\n *\n * Additionally, an optional configuration can be used to indicate some specific\n * behaviors related to that name handling.\n */\nexport class FullName {\n    private _prefix: Nullable<Name>\n    private _firstName: FirstName\n    private _middleName: Name[] = []\n    private _lastName: LastName\n    private _suffix: Nullable<Name>\n    private _config: Config\n\n    /**\n     * Creates a full name as it goes\n     * @param options optional configuration for additional features.\n     */\n    constructor(options?: Partial<Config>) {\n        this._config = Config.merge(options)\n    }\n\n    /**\n     * A snapshot of the configuration used to set up this full name.\n     */\n    get config(): Config {\n        return this._config\n    }\n\n    /**\n     * The prefix part of the full name.\n     */\n    get prefix(): Nullable<Name> {\n        return this._prefix\n    }\n\n    /**\n     * The first name part of the full name.\n     */\n    get firstName(): FirstName {\n        return this._firstName\n    }\n\n    /**\n     * The last name part of the full name.\n     */\n    get lastName(): LastName {\n        return this._lastName\n    }\n\n    /**\n     * The middle name part of the full name.\n     */\n    get middleName(): Name[] {\n        return this._middleName\n    }\n\n    /**\n     * The suffix part of the full name.\n     */\n    get suffix(): Nullable<Name> {\n        return this._suffix\n    }\n\n    setPrefix(name: Nullable<string | Name>): FullName {\n        if (!name) return this\n        if (!this._config.bypass) Validators.prefix.validate(name)\n        const prefix = name instanceof Name ? name.value : name\n        this._prefix = Name.prefix(this._config.title === Title.US ? `${prefix}.` : prefix)\n        return this\n    }\n\n    setFirstName(name: string | FirstName): FullName {\n        if (!this._config.bypass) Validators.firstName.validate(name)\n        this._firstName = name instanceof FirstName ? name : new FirstName(name)\n        return this\n    }\n\n    setLastName(name: string | LastName): FullName {\n        if (!this._config.bypass) Validators.lastName.validate(name)\n        this._lastName = name instanceof LastName ? name : new LastName(name)\n        return this\n    }\n\n    setMiddleName(names: string[] | Name[]): FullName {\n        if (!Array.isArray(names)) return\n        if (!this._config.bypass) Validators.middleName.validate(names)\n        this._middleName = (names as Array<string | Name>).map((name) =>\n            name instanceof Name ? name : Name.middle(name),\n        )\n        return this\n    }\n\n    setSuffix(name: Nullable<string | Name>): FullName {\n        if (!name) return this\n        if (!this._config.bypass) Validators.suffix.validate(name)\n        this._suffix = Name.suffix(name instanceof Name ? name.value : name)\n        return this\n    }\n\n    /**\n     * Returns true if a namon has been set.\n     */\n    has(namon: Namon): boolean {\n        if (namon.equal(Namon.PREFIX)) return !!this._prefix\n        if (namon.equal(Namon.SUFFIX)) return !!this._suffix\n        return namon.equal(Namon.MIDDLE_NAME) ? this._middleName.length > 0 : true\n    }\n\n    /**\n     * Parses a json name into a full name.\n     * @param json parsable name element\n     * @param config optional configuration for additional features.\n     */\n    static parse(json: JsonName, config?: Config): FullName {\n        try {\n            const fullName = new FullName(config)\n            fullName.setPrefix(json.prefix)\n            fullName.setFirstName(json.firstName)\n            fullName.setMiddleName(json.middleName)\n            fullName.setLastName(json.lastName)\n            fullName.setSuffix(json.suffix)\n            return fullName\n        } catch (error) {\n            if (error instanceof NameError) {\n                throw error\n            } else {\n                throw new UnknownError({\n                    source: Object.values(json).join(' '),\n                    message: 'could not parse JSON content',\n                    error,\n                })\n            }\n        }\n    }\n}\n","/**\n * Welcome to namefully!\n *\n * `namefully` is a JavaScript utility for handing person names.\n *\n * Sources\n * - repo: https://github.com/ralflorent/namefully\n * - docs: https://namefully.netlify.app\n * - npm: https://npmjs.com/package/namefully\n *\n * @license MIT\n */\nexport * from './config'\nexport * from './error'\nexport * from './full-name'\nexport * from './name'\nexport * from './namefully'\nexport { Parser } from './parser'\nexport * from './types'\nexport { NameIndex } from './utils'\n","import { InputError } from './error'\nimport { CapsRange, Namon, Surname } from './types'\nimport { capitalize, decapitalize } from './utils'\n\n/**\n * Representation of a string type name with some extra capabilities.\n */\nexport class Name {\n    private namon: string\n    protected initial: string\n    protected capsRange: CapsRange\n\n    /**\n     * Creates augmented names by adding extra functionality to a string name.\n     * @param type must be indicated to categorize the name so it can be\n     * treated accordingly.\n     * @param capsRange determines how the name should be capitalized initially.\n     */\n    constructor(value: string, readonly type: Namon, capsRange?: CapsRange) {\n        this.capsRange = capsRange ?? CapsRange.INITIAL\n        this.value = value\n        if (capsRange) this.caps(capsRange)\n    }\n\n    set value(newValue: string) {\n        if (newValue.trim().length < 2) {\n            throw new InputError({ source: newValue, message: 'must be 2+ characters' })\n        }\n\n        this.namon = newValue\n        this.initial = newValue[0]\n    }\n\n    /**\n     * The piece of string treated as a name.\n     */\n    get value(): string {\n        return this.namon\n    }\n\n    /**\n     * The length of the name.\n     */\n    get length(): number {\n        return this.namon.length\n    }\n\n    /**\n     * Whether the name is a prefix.\n     */\n    get isPrefix(): boolean {\n        return this.type === Namon.PREFIX\n    }\n\n    /**\n     * Whether the name is a first name.\n     */\n    get isFirstName(): boolean {\n        return this.type === Namon.FIRST_NAME\n    }\n\n    /**\n     * Whether the name is a middle name.\n     */\n    get isMiddleName(): boolean {\n        return this.type === Namon.MIDDLE_NAME\n    }\n\n    /**\n     * Whether the name is a last name.\n     */\n    get isLastName(): boolean {\n        return this.type === Namon.LAST_NAME\n    }\n\n    /**\n     * Whether the name is a suffix.\n     */\n    get isSuffix(): boolean {\n        return this.type === Namon.SUFFIX\n    }\n\n    /**\n     * Creates a prefix.\n     */\n    static prefix(value: string): Name {\n        return new this(value, Namon.PREFIX)\n    }\n\n    /**\n     * Creates a first name.\n     */\n    static first(value: string): Name {\n        return new this(value, Namon.FIRST_NAME)\n    }\n\n    /**\n     * Creates a middle name.\n     */\n    static middle(value: string): Name {\n        return new this(value, Namon.MIDDLE_NAME)\n    }\n\n    /**\n     * Creates a last name.\n     */\n    static last(value: string): Name {\n        return new this(value, Namon.LAST_NAME)\n    }\n\n    /**\n     * Creates a suffix.\n     */\n    static suffix(value: string): Name {\n        return new this(value, Namon.SUFFIX)\n    }\n\n    /**\n     * Gets the initials (first character) of this name.\n     */\n    initials(): string[] {\n        return [this.initial]\n    }\n\n    /**\n     * String representation of this object.\n     */\n    toString(): string {\n        return this.namon\n    }\n    /**\n     * Returns true if the other is equal to this name.\n     */\n    equal(other: Name | unknown): boolean {\n        return other instanceof Name && other.value === this.value && other.type === this.type\n    }\n\n    /**\n     * Capitalizes the name.\n     */\n    caps(range?: CapsRange): Name {\n        this.value = capitalize(this.namon, range ?? this.capsRange)\n        return this\n    }\n\n    /**\n     * De-capitalizes the name.\n     */\n    decaps(range?: CapsRange): Name {\n        this.value = decapitalize(this.namon, range ?? this.capsRange)\n        return this\n    }\n}\n\n/**\n * Representation of a first name with some extra functionality.\n */\nexport class FirstName extends Name {\n    private _more: string[]\n\n    /**\n     * Creates an extended version of `Name` and flags it as a first name `type`.\n     *\n     * Some may consider `more` additional name parts of a given name as their\n     * first names, but not as their middle names. Though, it may mean the same,\n     * `more` provides the freedom to do it as it pleases.\n     */\n    constructor(value: string, ...more: string[]) {\n        super(value, Namon.FIRST_NAME)\n\n        for (const name of more) {\n            if (name.trim().length < 2) {\n                throw new InputError({ source: name, message: 'must be 2+ characters' })\n            }\n        }\n        this._more = more\n    }\n\n    /**\n     * Determines whether a first name has `more` name parts.\n     */\n    get hasMore(): boolean {\n        return this._more.length > 0\n    }\n\n    get length(): number {\n        return super.length + (this.hasMore ? this._more.reduce((acc, n) => acc + n).length : 0)\n    }\n\n    /**\n     * Returns a combined version of the `value` and `more` if any.\n     */\n    get asNames(): Name[] {\n        const names: Name[] = [Name.first(this.value)]\n        if (this.hasMore) {\n            names.push(...this._more.map((n) => Name.first(n)))\n        }\n        return names\n    }\n\n    /**\n     * The additional name parts of the first name.\n     */\n    get more(): string[] {\n        return this._more\n    }\n\n    toString(withMore = false): string {\n        return withMore && this.hasMore ? `${this.value} ${this._more.join(' ')}`.trim() : this.value\n    }\n\n    initials(withMore = false): string[] {\n        const inits: string[] = [this.initial]\n        if (withMore && this.hasMore) {\n            inits.push(...this._more.map((n) => n[0]))\n        }\n        return inits\n    }\n\n    caps(range?: CapsRange): FirstName {\n        range = range || this.capsRange\n        this.value = capitalize(this.value, range)\n        if (this.hasMore) this._more = this._more.map((n) => capitalize(n, range))\n        return this\n    }\n\n    decaps(range?: CapsRange): FirstName {\n        range = range || this.capsRange\n        this.value = decapitalize(this.value, range)\n        if (this.hasMore) this._more = this._more.map((n) => decapitalize(n, range))\n        return this\n    }\n\n    /**\n     * Makes a copy of the current name.\n     */\n    copyWith(values?: { first?: string; more?: string[] }): FirstName {\n        return new FirstName(values.first ?? this.value, ...(values.more ?? this._more))\n    }\n}\n\n/**\n * Representation of a last name with some extra functionality.\n */\nexport class LastName extends Name {\n    private _mother?: string\n\n    /**\n     * Creates an extended version of `Name` and flags it as a last name `type`.\n     *\n     * Some people may keep their `mother`'s surname and want to keep a clear cut\n     * from their `father`'s surname. However, there are no clear rules about it.\n     */\n    constructor(father: string, mother?: string, readonly format = Surname.FATHER) {\n        super(father, Namon.LAST_NAME)\n\n        if (mother && mother.trim().length < 2) {\n            throw new InputError({ source: mother, message: 'must be 2+ characters' })\n        }\n        this._mother = mother\n    }\n\n    /**\n     * The surname inherited from a father side.\n     */\n    get father(): string {\n        return this.value\n    }\n\n    /**\n     * The surname inherited from a mother side.\n     */\n    get mother(): string | undefined {\n        return this._mother\n    }\n\n    /**\n     * Returns `true` if the mother's surname is defined.\n     */\n    get hasMother(): boolean {\n        return !!this._mother\n    }\n\n    get length(): number {\n        return super.length + (this._mother?.length ?? 0)\n    }\n\n    /**\n     * Returns a combined version of the `father` and `mother` if any.\n     */\n    get asNames(): Name[] {\n        const names: Name[] = [Name.last(this.value)]\n        if (this.hasMother) {\n            names.push(Name.last(this._mother))\n        }\n        return names\n    }\n\n    toString(format?: Surname): string {\n        format = format ?? this.format\n        switch (format) {\n            case Surname.FATHER:\n                return this.value\n            case Surname.MOTHER:\n                return this.mother ?? ''\n            case Surname.HYPHENATED:\n                return this.hasMother ? `${this.value}-${this._mother}` : this.value\n            case Surname.ALL:\n                return this.hasMother ? `${this.value} ${this._mother}` : this.value\n        }\n    }\n\n    initials(format?: Surname): string[] {\n        format = format || this.format\n        const inits: string[] = []\n        switch (format) {\n            case Surname.MOTHER:\n                if (this.hasMother) inits.push(this._mother[0])\n                break\n            case Surname.HYPHENATED:\n            case Surname.ALL:\n                inits.push(this.initial)\n                if (this.hasMother) inits.push(this._mother[0])\n                break\n            case Surname.FATHER:\n            default:\n                inits.push(this.initial)\n        }\n        return inits\n    }\n\n    caps(range?: CapsRange): LastName {\n        range = range || this.capsRange\n        this.value = capitalize(this.value, range)\n        if (this.hasMother) this._mother = capitalize(this._mother, range)\n        return this\n    }\n\n    decaps(range?: CapsRange): LastName {\n        range = range || this.capsRange\n        this.value = decapitalize(this.value, range)\n        if (this.hasMother) this._mother = decapitalize(this._mother, range)\n        return this\n    }\n\n    /**\n     * Makes a copy of the current name.\n     */\n    copyWith(values?: { father?: string; mother?: string; format?: Surname }): LastName {\n        return new LastName(values.father ?? this.value, values.mother ?? this.mother, values.format ?? this.format)\n    }\n}\n\n/**\n * JSON signature for `FullName` data.\n */\nexport interface JsonName {\n    prefix?: string\n    firstName: string\n    middleName?: string[]\n    lastName: string\n    suffix?: string\n}\n","import { Config } from './config'\nimport { ALLOWED_TOKENS } from './constants'\nimport { InputError, NotAllowedError } from './error'\nimport { FullName } from './full-name'\nimport { Name, JsonName } from './name'\nimport { ArrayNameParser, ArrayStringParser, NamaParser, Parser, StringParser } from './parser'\nimport { Flat, NameOrder, NameType, Namon, Nullable, Surname } from './types'\nimport { capitalize, decapitalize, isNameArray, isStringArray, toggleCase } from './utils'\n\n/**\n * A helper for organizing person names in a particular order, way, or shape.\n *\n * Though `namefully` is easy to use, it does not magically guess which part of\n * the name is what (prefix, suffix, first, last, or middle names). It relies\n * actually on how the name parts are indicated (i.e., their roles) so that\n * it can perform internally certain operations and saves us some extra\n * calculations/processing. In addition, `Namefully` can be created using\n * distinct raw data shapes. This is intended to give some flexibility to the\n * developer so that he or she is not bound to a particular data format.\n * By following closely the API reference to know how to harness its usability,\n * this utility aims to save time in formatting names.\n *\n * `namefully` also works like a trapdoor. Once a raw data is provided and\n * validated, a developer can only *access* in a vast amount of, yet effective\n * ways the name info. *No editing* is possible. If the name is mistaken, a new\n * instance of `Namefully` must be created. In other words, it's immutable.\n * Remember, this utility's primary objective is to help manipulate a person name.\n *\n * Note that the name standards used for the current version of this library\n * are as follows:\n *      `[prefix] firstName [middleName] lastName [suffix]`\n * The opening `[` and closing `]` symbols mean that these parts are optional.\n * In other words, the most basic and typical case is a name that looks like\n * this: `John Smith`, where `John` is the first name piece and `Smith`, the last\n * name piece.\n *\n * @see https://departments.weber.edu/qsupport&training/Data_Standards/Name.htm\n * for more info on name standards.\n *\n * **IMPORTANT**: Keep in mind that the order of appearance (or name order) matters\n * and may be altered through configured parameters, which will be seen later.\n * By default, the order of appearance is as shown above and will be used as a\n * basis for future examples and use cases.\n *\n * Once imported, all that is required to do is to create an instance of\n * `Namefully` and the rest will follow.\n *\n * Some terminologies used across the library are:\n * - namon: 1 piece of name (e.g., first name)\n * - nama: 2+ pieces of name (e.g., first name + last name)\n *\n * Happy name handling 😊!\n */\nexport class Namefully {\n    /**\n     * A copy of high-quality name data.\n     */\n    private _fullName: FullName\n\n    /**\n     * A copy of the default configuration (combined with a custom one if any).\n     */\n    private _config: Config\n\n    /**\n     * Creates a name with distinguishable parts from a raw string content.\n     * @param names element to parse.\n     * @param options additional settings.\n     *\n     * An optional configuration may be provided with specifics on how to treat\n     * a full name during its course. By default, all name parts are validated\n     * against some basic validation rules to avoid common runtime exceptions.\n     */\n    constructor(names: string | string[] | Name[] | JsonName | Parser, options?: Partial<Config>) {\n        this.build(this.toParser(names), options)\n    }\n\n    /**\n     * Constructs a `Namefully` instance from a text.\n     *\n     * It works like `parse` except that this function returns `null` where `parse`\n     * would throw a `NameError`.\n     */\n    static tryParse(text: string): Namefully | undefined {\n        try {\n            return new this(Parser.build(text))\n        } catch (error) {\n            return undefined\n        }\n    }\n\n    /**\n     * Constructs a `Namefully` instance from a text.\n     *\n     * It throws a `NameError` if the text cannot be parsed. Use `tryParse`\n     * instead if a `null` return is preferred over a throwable error.\n     *\n     * This operation is computed asynchronously, which gives more flexibility at\n     * the time of catching the error (and stack trace if any). The acceptable\n     * text format is a string composed of two or more name pieces. For instance,\n     * `John Lennon`, or `John Winston Ono Lennon` are parsable names and follow\n     * the basic name standard rules (i.e., first-middle-last).\n     *\n     * Keep in mind that prefix and suffix are not considered during the parsing\n     * process.\n     */\n    static async parse(text: string): Promise<Namefully> {\n        return Parser.buildAsync(text).then((parser) => new Namefully(parser))\n    }\n\n    /**\n     * The current configuration.\n     */\n    get config(): Config {\n        return this._config\n    }\n\n    /**\n     * The number of characters of the `birthName`, including spaces.\n     */\n    get length(): number {\n        return this.birth.length\n    }\n\n    /**\n     * The prefix part.\n     */\n    get prefix(): Nullable<string> {\n        return this._fullName.prefix?.toString()\n    }\n\n    /**\n     * The firt name.\n     */\n    get first(): string {\n        return this.firstName()\n    }\n\n    /**\n     * The first middle name if any.\n     */\n    get middle(): Nullable<string> {\n        return this.hasMiddle ? this.middleName()[0] : undefined\n    }\n\n    /**\n     * Returns true if any middle name has been set.\n     */\n    get hasMiddle(): boolean {\n        return this._fullName.has(Namon.MIDDLE_NAME)\n    }\n\n    /**\n     * The last name.\n     */\n    get last(): string {\n        return this.lastName()\n    }\n\n    /**\n     * The suffix part.\n     */\n    get suffix(): Nullable<string> {\n        return this._fullName.suffix?.toString()\n    }\n\n    /**\n     * The birth name.\n     */\n    get birth(): string {\n        return this.birthName()\n    }\n\n    /**\n     * The shortest version of a person name.\n     */\n    get short(): string {\n        return this.shorten()\n    }\n\n    /**\n     * The longest version of a person name.\n     */\n    get long(): string {\n        return this.birth\n    }\n\n    /**\n     * The entire name set.\n     */\n    get full(): string {\n        return this.fullName()\n    }\n\n    /**\n     * The first name combined with the last name's initial.\n     */\n    get public(): string {\n        return this.format('f $l')\n    }\n\n    /**\n     * Returns the full name as set.\n     */\n    toString(): string {\n        return this.full\n    }\n\n    /**\n     * Fetches the raw form of a name piece.\n     */\n    get(namon: Namon): Nullable<Name | Name[]> {\n        if (namon.equal(Namon.PREFIX)) return this._fullName.prefix\n        if (namon.equal(Namon.FIRST_NAME)) return this._fullName.firstName\n        if (namon.equal(Namon.MIDDLE_NAME)) return this._fullName.middleName\n        if (namon.equal(Namon.LAST_NAME)) return this._fullName.lastName\n        if (namon.equal(Namon.SUFFIX)) return this._fullName.suffix\n        return undefined\n    }\n\n    /**\n     * Whether this name is equal to another one from a raw-string perspective.\n     */\n    equal(other: Namefully): boolean {\n        return this.toString() === other.toString()\n    }\n\n    /**\n     * Gets a JSON representation of the full name.\n     */\n    toJson(): JsonName {\n        return {\n            prefix: this.prefix,\n            firstName: this.first,\n            middleName: this.middleName(),\n            lastName: this.last,\n            suffix: this.suffix,\n        }\n    }\n\n    /**\n     * Confirms that a name part has been set.\n     */\n    has(namon: Namon): boolean {\n        return this._fullName.has(namon)\n    }\n\n    /**\n     * Gets the full name ordered as configured.\n     *\n     * The name order `orderedBy` forces to order by first or last name by\n     * overriding the preset configuration.\n     *\n     * `Namefully.format` may also be used to alter manually the order of appearance\n     * of full name.\n     *\n     * For example:\n     * ```typescript\n     * const name = new Namefully('Jon Stark Snow');\n     * console.log(name.fullName(NameOrder.LAST_NAME)); // \"Snow Jon Stark\"\n     * console.log(name.format('l f m')); // \"Snow Jon Stark\"\n     * ```\n     */\n    fullName(orderedBy?: NameOrder): string {\n        const sep = this._config.ending ? ',' : ''\n        const names: string[] = []\n        orderedBy = orderedBy || this._config.orderedBy\n\n        if (this.prefix) names.push(this.prefix)\n        if (orderedBy === NameOrder.FIRST_NAME) {\n            names.push(this.first, ...this.middleName(), this.last + sep)\n        } else {\n            names.push(this.last, this.first, this.middleName().join(' ') + sep)\n        }\n        if (this.suffix) names.push(this.suffix)\n\n        return names.join(' ').trim()\n    }\n\n    /**\n     * Gets the birth name ordered as configured, no `prefix` or `suffix`.\n     *\n     * @param orderedBy forces to order by first or last name by overriding the\n     * preset configuration.\n     */\n    birthName(orderedBy?: NameOrder): string {\n        orderedBy = orderedBy || this._config.orderedBy\n        return orderedBy === NameOrder.FIRST_NAME\n            ? [this.first, ...this.middleName(), this.last].join(' ')\n            : [this.last, this.first, ...this.middleName()].join(' ')\n    }\n\n    /**\n     * Gets the first name part of the `FullName`.\n     *\n     * @param withMore determines whether to include other pieces of the first\n     * name.\n     */\n    firstName(withMore = true): string {\n        return this._fullName.firstName.toString(withMore)\n    }\n\n    /**\n     * Gets the middle name part of the `FullName`.\n     */\n    middleName(): string[] {\n        return this._fullName.middleName.map((n) => n.value)\n    }\n\n    /**\n     * Gets the last name part of the `FullName`.\n     *\n     * @param format overrides the how-to formatting of a surname output,\n     * considering its sub-parts.\n     */\n    lastName(format?: Surname): string {\n        return this._fullName.lastName.toString(format)\n    }\n\n    /**\n     * Gets the initials of the `FullName`.\n     *\n     * @param {options.orderedBy} forces to order by first or last name by\n     * overriding the preset configuration.\n     * @param\n     *\n     * For example, given the names:\n     * - `John Smith` => `['J', 'S']`\n     * - `John Ben Smith` => `['J', 'B', 'S']`.\n     */\n    initials(options?: { orderedBy?: NameOrder; only?: NameType }): string[] {\n        const initials: string[] = []\n        const firstInits = this._fullName.firstName.initials()\n        const midInits = this._fullName.middleName.map((n) => n.initials()[0])\n        const lastInits = this._fullName.lastName.initials()\n\n        const mergedOptions = {\n            orderedBy: this._config.orderedBy,\n            only: NameType.BIRTH_NAME,\n            ...options,\n        }\n        const { orderedBy, only } = mergedOptions\n\n        if (only != NameType.BIRTH_NAME) {\n            if (only == NameType.FIRST_NAME) {\n                initials.push(...firstInits)\n            } else if (only == NameType.MIDDLE_NAME) {\n                initials.push(...midInits)\n            } else {\n                initials.push(...lastInits)\n            }\n        } else if (orderedBy == NameOrder.FIRST_NAME) {\n            initials.push(...firstInits, ...midInits, ...lastInits)\n        } else {\n            initials.push(...lastInits, ...firstInits, ...midInits)\n        }\n        return initials\n    }\n\n    /**\n     * Shortens a complex full name to a simple typical name, a combination of\n     * first and last name.\n     *\n     * @param orderedBy forces to order by first or last name by overriding the\n     * preset configuration.\n     *\n     * For a given name such as `Mr Keanu Charles Reeves`, shortening this name\n     * is equivalent to making it `Keanu Reeves`.\n     *\n     * As a shortened name, the namon of the first name is favored over the other\n     * names forming part of the entire first names, if any. Meanwhile, for\n     * the last name, the configured `surname` is prioritized.\n     *\n     * For a given `FirstName FatherName MotherName`, shortening this name when\n     * the surname is set as `mother` is equivalent to making it:\n     * `FirstName MotherName`.\n     */\n    shorten(orderedBy?: NameOrder): string {\n        orderedBy = orderedBy || this._config.orderedBy\n        return orderedBy == NameOrder.FIRST_NAME\n            ? [this._fullName.firstName.value, this._fullName.lastName.toString()].join(' ')\n            : [this._fullName.lastName.toString(), this._fullName.firstName.value].join(' ')\n    }\n\n    /**\n     * Flattens a long name using the name types as variants.\n     *\n     * While @param limit sets a threshold as a limited number of characters\n     * supported to flatten a `FullName`, @param by indicates which variant\n     * to use when doing so. By default, a full name gets flattened by\n     * `Flat.MIDDLE_NAME`.\n     *\n     * The flattening operation is only executed iff there is a valid entry and\n     * it surpasses the limit set. In the examples below, let us assume that the\n     * name goes beyond the limit value.\n     *\n     * Flattening a long name refers to reducing the name to the following forms.\n     * For example, `John Winston Ono Lennon` flattened by:\n     * * Flat.FIRST_NAME: => 'J. Winston Ono Lennon'\n     * * Flat.MIDDLE_NAME: => 'John W. O. Lennon'\n     * * Flat.LAST_NAME: => 'John Winston Ono L.'\n     * * Flat.FIRST_MID: => 'J. W. O. Lennon'\n     * * Flat.MID_LAST: => 'John W. O. L.'\n     * * Flat.ALL: => 'J. W. O. L.'\n     *\n     * With the help of the @param recursive flag, the above operation can happen\n     * recursively in the same order if the name is still too long. For example,\n     * flattening `John Winston Ono Lennon` using the following params:\n     * `flatten({ limit: 18, by: Flat.FIRST_NAME, recursive: true })`\n     * will result in `John W. O. Lennon` and not `J. Winston Ono Lennon`.\n     *\n     * A shorter version of this method is `zip()`.\n     */\n    flatten(\n        options: Partial<{\n            limit: number\n            by: Flat\n            withPeriod: boolean\n            recursive: boolean\n            withMore: boolean\n            surname: Surname\n        }>,\n    ): string {\n        if (this.length <= options.limit) return this.full\n\n        const mergedOptions = {\n            limit: 20,\n            by: Flat.MIDDLE_NAME,\n            withPeriod: true,\n            recursive: false,\n            withMore: false,\n            ...options,\n        }\n\n        const { by, limit, recursive, withMore, withPeriod, surname } = mergedOptions\n        const sep = withPeriod ? '.' : ''\n        const fn = this._fullName.firstName.toString()\n        const mn = this.middleName().join(' ')\n        const ln = this._fullName.lastName.toString()\n        const hasMid = this.hasMiddle\n        const f = this._fullName.firstName.initials(withMore).join(sep + ' ') + sep\n        const l = this._fullName.lastName.initials(surname).join(sep + ' ') + sep\n        const m = hasMid ? this._fullName.middleName.map((n) => n.initials()[0]).join(sep + ' ') + sep : ''\n        let name: string[] = []\n\n        if (this._config.orderedBy == NameOrder.FIRST_NAME) {\n            switch (by) {\n                case Flat.FIRST_NAME:\n                    name = hasMid ? [f, mn, ln] : [f, ln]\n                    break\n                case Flat.LAST_NAME:\n                    name = hasMid ? [fn, mn, l] : [fn, l]\n                    break\n                case Flat.MIDDLE_NAME:\n                    name = hasMid ? [fn, m, ln] : [fn, ln]\n                    break\n                case Flat.FIRST_MID:\n                    name = hasMid ? [f, m, ln] : [f, ln]\n                    break\n                case Flat.MID_LAST:\n                    name = hasMid ? [fn, m, l] : [fn, l]\n                    break\n                case Flat.ALL:\n                    name = hasMid ? [f, m, l] : [f, l]\n                    break\n            }\n        } else {\n            switch (by) {\n                case Flat.FIRST_NAME:\n                    name = hasMid ? [ln, f, mn] : [ln, f]\n                    break\n                case Flat.LAST_NAME:\n                    name = hasMid ? [l, fn, mn] : [l, fn]\n                    break\n                case Flat.MIDDLE_NAME:\n                    name = hasMid ? [ln, fn, m] : [ln, fn]\n                    break\n                case Flat.FIRST_MID:\n                    name = hasMid ? [ln, f, m] : [ln, f]\n                    break\n                case Flat.MID_LAST:\n                    name = hasMid ? [l, fn, m] : [l, fn]\n                    break\n                case Flat.ALL:\n                    name = hasMid ? [l, f, m] : [l, f]\n                    break\n            }\n        }\n\n        const flat = name.join(' ')\n        if (recursive && flat.length > limit) {\n            const next =\n                by == Flat.FIRST_NAME\n                    ? Flat.MIDDLE_NAME\n                    : by == Flat.MIDDLE_NAME\n                    ? Flat.LAST_NAME\n                    : by == Flat.LAST_NAME\n                    ? Flat.FIRST_MID\n                    : by == Flat.FIRST_MID\n                    ? Flat.MID_LAST\n                    : by == Flat.MID_LAST\n                    ? Flat.ALL\n                    : by == Flat.ALL\n                    ? Flat.ALL\n                    : by\n            if (next == by) return flat\n            return this.flatten({ ...options, by: next })\n        }\n        return flat\n    }\n\n    /**\n     * Zips or compacts a name using different forms of variants.\n     *\n     * @see `flatten()` for more details.\n     */\n    zip(by = Flat.MID_LAST, withPeriod = true): string {\n        return this.flatten({ limit: 0, by, withPeriod })\n    }\n\n    /**\n     * Formats the full name as desired.\n     * @param pattern character used to format it.\n     *\n     * string format\n     * -------------\n     * - 'short': typical first + last name\n     * - 'long': birth name (without prefix and suffix)\n     * - 'public': first name combined with the last name's initial.\n     * - 'official': official document format\n     *\n     * char format\n     * -----------\n     * - 'b': birth name\n     * - 'B': capitalized birth name\n     * - 'f': first name\n     * - 'F': capitalized first name\n     * - 'l': last name\n     * - 'L': capitalized last name\n     * - 'm': middle names\n     * - 'M': capitalized middle names\n     * - 'o': official document format\n     * - 'O': official document format in capital letters\n     * - 'p': prefix\n     * - 'P': capitalized prefix\n     * - 's': suffix\n     * - 'S': capitalized suffix\n     *\n     * punctuations\n     * ------------\n     * - '.': period\n     * - ',': comma\n     * - ' ': space\n     * - '-': hyphen\n     * - '_': underscore\n     * - '$': an escape character to select only the initial of the next char.\n     *\n     * Given the name `Joe Jim Smith`, use `format` with the `pattern` string.\n     * - format('l f') => 'Smith Joe'\n     * - format('L, f') => 'SMITH, Joe'\n     * - format('short') => 'Joe Smith'\n     * - format() => 'SMITH, Joe Jim'\n     * - format(r'f $l.') => 'Joe S.'.\n     *\n     * Do note that the escape character is only valid for the birth name parts:\n     * first, middle, and last names.\n     */\n    format(pattern: string): string {\n        if (pattern == 'short') return this.short\n        if (pattern == 'long') return this.long\n        if (pattern == 'public') return this.public\n        if (pattern == 'official') pattern = 'o'\n\n        let group = ''\n        const formatted: string[] = []\n        for (const char of pattern.split('')) {\n            if (ALLOWED_TOKENS.indexOf(char) === -1) {\n                throw new NotAllowedError({\n                    source: this.full,\n                    operation: 'format',\n                    message: `unsupported character <${char}> from ${pattern}.`,\n                })\n            }\n            group += char\n            if (char === '$') continue\n            formatted.push(this.map(group) ?? '')\n            group = ''\n        }\n        return formatted.join('').trim()\n    }\n\n    /**\n     * Flips definitely the name order from the preset/current config.\n     */\n    flip(): void {\n        if (this._config.orderedBy === NameOrder.FIRST_NAME) {\n            this._config.updateOrder(NameOrder.LAST_NAME)\n            console.log(`The name order is now changed to: ${NameOrder.LAST_NAME}`)\n        } else {\n            this._config.updateOrder(NameOrder.FIRST_NAME)\n            console.log(`The name order is now changed to: ${NameOrder.FIRST_NAME}`)\n        }\n    }\n\n    /**\n     * Splits the name parts of a birth name.\n     * @param separator token for the split.\n     */\n    split(separator: string | RegExp = /[' -]/g): string[] {\n        return this.birth.replace(separator, ' ').split(' ')\n    }\n\n    /**\n     * Joins the name parts of a birth name.\n     * @param separator token for the junction.\n     */\n    join(separator = ''): string {\n        return this.split().join(separator)\n    }\n\n    /**\n     * Transforms a birth name into UPPERCASE\n     */\n    toUpperCase(): string {\n        return this.birth.toUpperCase()\n    }\n\n    /**\n     * Transforms a birth name into lowercase\n     */\n    toLowerCase(): string {\n        return this.birth.toLowerCase()\n    }\n\n    /**\n     * Transforms a birth name into camelCase\n     */\n    toCamelCase(): string {\n        return decapitalize(this.toPascalCase())\n    }\n\n    /**\n     * Transforms a birth name into PascalCase\n     */\n    toPascalCase(): string {\n        return this.split()\n            .map((n) => capitalize(n))\n            .join('')\n    }\n\n    /**\n     * Transforms a birth name into snake_case\n     */\n    toSnakeCase(): string {\n        return this.split()\n            .map((n) => n.toLowerCase())\n            .join('_')\n    }\n\n    /**\n     * Transforms a birth name into hyphen-case\n     */\n    toHyphenCase(): string {\n        return this.split()\n            .map((n) => n.toLowerCase())\n            .join('-')\n    }\n\n    /**\n     * Transforms a birth name into dot.case\n     */\n    toDotCase(): string {\n        return this.split()\n            .map((n) => n.toLowerCase())\n            .join('.')\n    }\n\n    /**\n     * Transforms a birth name into ToGgLeCaSe\n     */\n    toToggleCase(): string {\n        return toggleCase(this.birth)\n    }\n\n    private build<T>(parser: Parser<T>, options?: Partial<Config>): void {\n        this._config = Config.merge(options)\n        this._fullName = parser.parse(this._config)\n    }\n\n    private toParser(raw: string | string[] | Name[] | JsonName | Parser): Parser {\n        if (raw instanceof Parser) return raw\n        if (typeof raw === 'string') return new StringParser(raw)\n        if (isStringArray(raw)) return new ArrayStringParser(raw as string[])\n        if (isNameArray(raw)) return new ArrayNameParser(raw as Name[])\n        if (typeof raw === 'object') return new NamaParser(raw as JsonName)\n\n        throw new InputError({\n            source: raw,\n            message: 'Cannot parse raw data. Review expected data types.',\n        })\n    }\n\n    private map(char: string): Nullable<string> {\n        switch (char) {\n            case '.':\n            case ',':\n            case ' ':\n            case '-':\n            case '_':\n                return char\n            case 'b':\n                return this.birth\n            case 'B':\n                return this.birth.toUpperCase()\n            case 'f':\n                return this.first\n            case 'F':\n                return this.first.toUpperCase()\n            case 'l':\n                return this.last\n            case 'L':\n                return this.last.toUpperCase()\n            case 'm':\n            case 'M':\n                return char == 'm' ? this.middleName().join(' ') : this.middleName().join(' ').toUpperCase()\n            case 'o':\n            case 'O':\n                const sep = this._config.ending ? ',' : ''\n                const names: string[] = []\n                if (this.prefix) names.push(this.prefix)\n                names.push(`${this.last},`.toUpperCase())\n                if (this.hasMiddle) {\n                    names.push(this.first, this.middleName().join(' ') + sep)\n                } else {\n                    names.push(this.first + sep)\n                }\n                if (this.suffix) names.push(this.suffix)\n                const nama = names.join(' ').trim()\n                return char === 'o' ? nama : nama.toUpperCase()\n            case 'p':\n                return this.prefix\n            case 'P':\n                return this.prefix?.toUpperCase()\n            case 's':\n                return this.suffix\n            case 'S':\n                return this.suffix?.toUpperCase()\n            case '$f':\n            case '$F':\n                return this._fullName.firstName.initials()[0]\n            case '$l':\n            case '$L':\n                return this._fullName.lastName.initials()[0]\n            case '$m':\n            case '$M':\n                return this._fullName.middleName.map((n) => n.initials()[0])[0]\n            default:\n                return undefined\n        }\n    }\n}\n","import { FullName } from './full-name'\nimport { Config } from './config'\nimport { NameIndex } from './utils'\nimport { ArrayStringValidator, ArrayNameValidator, NamaValidator } from './validator'\nimport { FirstName, LastName, Name, JsonName } from './name'\nimport { Namon, Nullable, Separator } from './types'\nimport { InputError } from './error'\n\n/**\n * A parser signature that helps to organize the names accordingly.\n */\nexport abstract class Parser<T = any> {\n    /**\n     * Constructs a custom parser accordingly.\n     * @param raw data to be parsed\n     */\n    constructor(public raw: T) {}\n\n    /**\n     * Parses the raw data into a `FullName` while considering some options.\n     * @param options additional configuration to apply.\n     */\n    abstract parse(options?: Partial<Config>): FullName\n\n    /**\n     * Builds a dynamic `Parser` on the fly and throws a `NameError` when unable\n     * to do so. The built parser only knows how to operate birth names.\n     */\n    static build(text: string): Parser {\n        const parts = text.trim().split(Separator.SPACE.token)\n        const length = parts.length\n        if (length == 0 || length == 1) {\n            throw new InputError({\n                source: text,\n                message: 'cannot build from invalid input',\n            })\n        } else if (length == 2 || length == 3) {\n            return new StringParser(text)\n        } else {\n            const last = parts.pop()\n            const [first, ...middles] = parts\n            return new ArrayStringParser([first, middles.join(' '), last])\n        }\n    }\n\n    /**\n     * Builds asynchronously a dynamic `Parser`.\n     */\n    static buildAsync(text: string): Promise<Parser> {\n        try {\n            return Promise.resolve(Parser.build(text))\n        } catch (error) {\n            return Promise.reject(error)\n        }\n    }\n}\n\nexport class StringParser extends Parser<string> {\n    constructor(raw: string) {\n        super(raw)\n    }\n\n    parse(options: Partial<Config>): FullName {\n        const config = Config.merge(options)\n        const names = this.raw.split(config.separator.token)\n        return new ArrayStringParser(names).parse(options)\n    }\n}\n\nexport class ArrayStringParser extends Parser<string[]> {\n    constructor(raw: string[]) {\n        super(raw)\n    }\n\n    parse(options: Partial<Config>): FullName {\n        const config = Config.merge(options)\n        const fullName = new FullName(config)\n\n        const raw = this.raw.map((n) => n.trim())\n        const index = NameIndex.when(config.orderedBy, raw.length)\n        const validator = new ArrayStringValidator(index)\n\n        if (config.bypass) {\n            validator.validateIndex(raw)\n        } else {\n            validator.validate(raw)\n        }\n\n        switch (raw.length) {\n            case 2:\n                fullName.setFirstName(new FirstName(raw[index.firstName]))\n                fullName.setLastName(new LastName(raw[index.lastName]))\n                break\n            case 3:\n                fullName.setFirstName(new FirstName(raw[index.firstName]))\n                fullName.setMiddleName(this.split(raw[index.middleName], config))\n                fullName.setLastName(new LastName(raw[index.lastName]))\n                break\n            case 4:\n                fullName.setPrefix(Name.prefix(raw[index.prefix]))\n                fullName.setFirstName(new FirstName(raw[index.firstName]))\n                fullName.setMiddleName(this.split(raw[index.middleName], config))\n                fullName.setLastName(new LastName(raw[index.lastName]))\n                break\n            case 5:\n                fullName.setPrefix(Name.prefix(raw[index.prefix]))\n                fullName.setFirstName(new FirstName(raw[index.firstName]))\n                fullName.setMiddleName(this.split(raw[index.middleName], config))\n                fullName.setLastName(new LastName(raw[index.lastName]))\n                fullName.setSuffix(Name.suffix(raw[index.suffix]))\n                break\n        }\n        return fullName\n    }\n\n    private split(raw: string, config: Config): Name[] {\n        return raw.split(config.separator.token).map((name) => Name.middle(name))\n    }\n}\n\nexport class NamaParser extends Parser<JsonName> {\n    constructor(raw: JsonName) {\n        super(raw)\n    }\n\n    parse(options: Partial<Config>): FullName {\n        const config = Config.merge(options)\n\n        if (config.bypass) {\n            NamaValidator.create().validateKeys(this.asNama())\n        } else {\n            NamaValidator.create().validate(this.asNama())\n        }\n\n        return FullName.parse(this.raw, config)\n    }\n\n    private asNama(): Map<Namon, string> {\n        return new Map<Namon, string>(\n            Object.entries(this.raw).map(([key, value]) => {\n                const namon: Nullable<Namon> = Namon.cast(key)\n                if (!namon) {\n                    throw new InputError({\n                        source: Object.values(this.raw).join(' '),\n                        message: `unsupported key \"${key}\"`,\n                    })\n                }\n                return [namon, value as string]\n            }),\n        )\n    }\n}\n\nexport class ArrayNameParser extends Parser<Name[]> {\n    constructor(raw: Name[]) {\n        super(raw)\n    }\n\n    parse(options: Partial<Config>): FullName {\n        const config = Config.merge(options)\n        const fullName = new FullName(config)\n\n        ArrayNameValidator.create().validate(this.raw)\n\n        for (let name of this.raw) {\n            if (name.isPrefix) {\n                fullName.setPrefix(name)\n            } else if (name.isSuffix) {\n                fullName.setSuffix(name)\n            } else if (name.isFirstName) {\n                fullName.setFirstName(name instanceof FirstName ? name : new FirstName(name.value))\n            } else if (name.isMiddleName) {\n                fullName.middleName.push(name)\n            } else if (name.isLastName) {\n                const lastName = new LastName(\n                    name.value,\n                    name instanceof LastName ? name.mother : undefined,\n                    config.surname,\n                )\n                fullName.setLastName(lastName)\n            }\n        }\n        return fullName\n    }\n}\n","/**\n * Make a type nullable.\n */\nexport type Nullable<T> = T | null | undefined\n\n/**\n * The abbreviation type to indicate whether or not to add period to a prefix\n * using the American or British way.\n */\nexport enum Title {\n    // A period after the prefix.\n    US = 'US',\n\n    // No period after the prefix.\n    UK = 'UK',\n}\n\n/**\n * An option indicating how to format a surname.\n *\n * This enum can be set via `Config` or when creating a `LastName`. As this can\n * become ambiguous at the time of handling it, the value set in `Config` is\n * prioritized and viewed as the source of truth for future considerations.\n */\nexport enum Surname {\n    // The fatherly surname only.\n    FATHER = 'father',\n\n    // The motherly surname only.\n    MOTHER = 'mother',\n\n    // The junction of both the fatherly and motherly surnames with a hyphen.\n    HYPHENATED = 'hyphenated',\n\n    // The junction of both the fatherly and motherly surnames with a space.\n    ALL = 'all',\n}\n\n/**\n * The order of appearance of a `FullName`.\n */\nexport enum NameOrder {\n    // The first part of a full name, usually the first piece of a person name.\n    FIRST_NAME = 'firstName',\n\n    // The last part of a full name, usually the last piece of a person name.\n    LAST_NAME = 'lastName',\n}\n\n/**\n * The types of name handled in this according the name standards.\n */\nexport enum NameType {\n    FIRST_NAME = 'firstName',\n    MIDDLE_NAME = 'middleName',\n    LAST_NAME = 'lastName',\n    BIRTH_NAME = 'birthName',\n}\n\n/**\n * The possible variants to indicate how to flatten a `FullName`.\n */\nexport enum Flat {\n    // Use the first name's initial combined with the remaining parts.\n    FIRST_NAME = 'firstName',\n\n    // Use the middle name's initial combined with the remaining parts.\n    MIDDLE_NAME = 'middleName',\n\n    // Use the last name's initial combined with the remaining parts.\n    LAST_NAME = 'lastName',\n\n    // Use both the first and middle names' initials combined with the remaining parts.\n    FIRST_MID = 'firstMid',\n\n    // Use both the last and middle names' initials combined with the remaining parts.\n    MID_LAST = 'midLast',\n\n    // Use the first, middle and last names' initials combined with the remaining parts.\n    ALL = 'all',\n}\n\n/**\n * The range to use when capitalizing a string content.\n */\nexport enum CapsRange {\n    // No capitalization.\n    NONE,\n\n    // Apply capitalization to the first letter.\n    INITIAL,\n\n    // Apply capitalization to all the letters.\n    ALL,\n}\n\n/**\n * The types of name handled in this utility according the name standards.\n */\nexport class Namon {\n    static readonly PREFIX = new Namon(0, 'prefix')\n    static readonly FIRST_NAME = new Namon(1, 'firstName')\n    static readonly MIDDLE_NAME = new Namon(2, 'middleName')\n    static readonly LAST_NAME = new Namon(3, 'lastName')\n    static readonly SUFFIX = new Namon(4, 'suffix')\n\n    /**\n     * The list of supported name types.\n     */\n    static readonly values: Namon[] = [Namon.PREFIX, Namon.FIRST_NAME, Namon.MIDDLE_NAME, Namon.LAST_NAME, Namon.SUFFIX]\n\n    /**\n     * All the predefined name types.\n     */\n    static readonly all = new Map<string, Namon>([\n        [Namon.PREFIX.key, Namon.PREFIX],\n        [Namon.FIRST_NAME.key, Namon.FIRST_NAME],\n        [Namon.MIDDLE_NAME.key, Namon.MIDDLE_NAME],\n        [Namon.LAST_NAME.key, Namon.LAST_NAME],\n        [Namon.SUFFIX.key, Namon.SUFFIX],\n    ])\n\n    private constructor(readonly index: number, readonly key: string) {}\n\n    /**\n     * Whether this string key is part of the predefined keys.\n     */\n    static has(key: string): boolean {\n        return Namon.all.has(key)\n    }\n\n    /**\n     * Makes a string key a namon type.\n     */\n    static cast(key: string): Nullable<Namon> {\n        return Namon.has(key) ? Namon.all.get(key) : undefined\n    }\n\n    /**\n     * String representation of this object.\n     */\n    toString(): string {\n        return `Namon.${this.key}`\n    }\n\n    /**\n     * Whether this and the other value are equal.\n     */\n    equal(other: Namon | unknown): boolean {\n        return other instanceof Namon && other.index == this.index && other.key == this.key\n    }\n}\n\n/**\n * The token used to indicate how to split string values.\n */\nexport class Separator {\n    static readonly COMMA = new Separator('comma', ',')\n    static readonly COLON = new Separator('colon', ':')\n    static readonly DOUBLE_QUOTE = new Separator('doubleQuote', '\"')\n    static readonly EMPTY = new Separator('empty', '')\n    static readonly HYPHEN = new Separator('hyphen', '-')\n    static readonly PERIOD = new Separator('period', '.')\n    static readonly SEMI_COLON = new Separator('semiColon', ';')\n    static readonly SINGLE_QUOTE = new Separator('singleQuote', \"'\")\n    static readonly SPACE = new Separator('space', ' ')\n    static readonly UNDERSCORE = new Separator('underscore', '_')\n\n    /**\n     * All the available separators.\n     */\n    static readonly all = new Map<string, Separator>([\n        [Separator.COMMA.name, Separator.COMMA],\n        [Separator.COLON.name, Separator.COLON],\n        [Separator.DOUBLE_QUOTE.name, Separator.DOUBLE_QUOTE],\n        [Separator.EMPTY.name, Separator.EMPTY],\n        [Separator.HYPHEN.name, Separator.HYPHEN],\n        [Separator.PERIOD.name, Separator.PERIOD],\n        [Separator.SEMI_COLON.name, Separator.SEMI_COLON],\n        [Separator.SINGLE_QUOTE.name, Separator.SINGLE_QUOTE],\n        [Separator.SPACE.name, Separator.SPACE],\n        [Separator.UNDERSCORE.name, Separator.UNDERSCORE],\n    ])\n\n    /**\n     * All the available tokens.\n     */\n    static readonly tokens: string[] = [...Separator.all.values()].map((s) => s.token)\n\n    private constructor(readonly name: string, readonly token: string) {}\n\n    /**\n     * String representation of this object.\n     */\n    toString(): string {\n        return `Separator.${this.name}`\n    }\n}\n","import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants'\nimport { Name } from './name'\nimport { NameOrder, CapsRange } from './types'\n\n/**\n * A fixed set of values to handle specific positions for list of names.\n *\n * As for list of names, this helps to follow a specific order based on the\n * count of elements. It is expected that the list has to be between two and\n * five elements. Also, the order of appearance set in the configuration\n * influences how the parsing is carried out.\n *\n * Ordered by first name, the parser works as follows:\n * - 2 elements: firstName lastName\n * - 3 elements: firstName middleName lastName\n * - 4 elements: prefix firstName middleName lastName\n * - 5 elements: prefix firstName middleName lastName suffix\n *\n * Ordered by last name, the parser works as follows:\n * - 2 elements: lastName firstName\n * - 3 elements: lastName firstName middleName\n * - 4 elements: prefix lastName firstName middleName\n * - 5 elements: prefix lastName firstName middleName suffix\n *\n * For example, `Jane Smith` (ordered by first name) is expected to be indexed:\n * `['Jane', 'Smith']`.\n */\nexport class NameIndex {\n    /**\n     * The minimum number of parts in a list of names.\n     */\n    static get min(): number {\n        return MIN_NUMBER_OF_NAME_PARTS\n    }\n\n    /**\n     * The maximum number of parts in a list of names.\n     */\n    static get max(): number {\n        return MAX_NUMBER_OF_NAME_PARTS\n    }\n\n    private constructor(\n        readonly prefix: number,\n        readonly firstName: number,\n        readonly middleName: number,\n        readonly lastName: number,\n        readonly suffix: number,\n    ) {}\n\n    /**\n     * The default or base indexing: firstName lastName.\n     */\n    static base(): NameIndex {\n        return new this(-1, 0, -1, 1, -1)\n    }\n\n    /**\n     * Gets the name index for a list of names based on the `count` of elements\n     * and their `order` of appearance.\n     */\n    static when(order: NameOrder, count = 2): NameIndex {\n        if (order == NameOrder.FIRST_NAME) {\n            switch (count) {\n                case 2: // first name + last name\n                    return new this(-1, 0, -1, 1, -1)\n                case 3: // first name + middle name + last name\n                    return new this(-1, 0, 1, 2, -1)\n                case 4: // prefix + first name + middle name + last name\n                    return new this(0, 1, 2, 3, -1)\n                case 5: // prefix + first name + middle name + last name + suffix\n                    return new this(0, 1, 2, 3, 4)\n                default:\n                    return NameIndex.base()\n            }\n        } else {\n            switch (count) {\n                case 2: // last name + first name\n                    return new this(-1, 1, -1, 0, -1)\n                case 3: // last name + first name + middle name\n                    return new this(-1, 1, 2, 0, -1)\n                case 4: // prefix + last name + first name + middle name\n                    return new this(0, 2, 3, 1, -1)\n                case 5: // prefix + last name + first name + middle name + suffix\n                    return new this(0, 2, 3, 1, 4)\n                default:\n                    return NameIndex.base()\n            }\n        }\n    }\n}\n\n/**\n * Capitalizes a string via a `CapsRange` option.\n */\nexport function capitalize(str: string, range: CapsRange = CapsRange.INITIAL): string {\n    if (!str || range === CapsRange.NONE) return str\n    const initial = str[0].toUpperCase()\n    const rest = str.slice(1).toLowerCase()\n    return range === CapsRange.INITIAL ? initial.concat(rest) : str.toUpperCase()\n}\n\n/**\n * Decapitalizes a string via a `CapsRange` option.\n */\nexport function decapitalize(str: string, range: CapsRange = CapsRange.INITIAL): string {\n    if (!str || range === CapsRange.NONE) return str\n    const initial = str[0].toLowerCase()\n    const rest = str.slice(1)\n    return range === CapsRange.INITIAL ? initial.concat(rest) : str.toLowerCase()\n}\n\n/**\n * Toggles a string representation.\n */\nexport function toggleCase(str: string): string {\n    const chars = []\n    for (const c of str) {\n        if (c === c.toUpperCase()) {\n            chars.push(c.toLowerCase())\n        } else {\n            chars.push(c.toUpperCase())\n        }\n    }\n    return chars.join('')\n}\n\nexport function isStringArray(value?: unknown): boolean {\n    return Array.isArray(value) && value.length > 0 && value.every((e) => typeof e === 'string')\n}\n\nexport function isNameArray(value?: unknown): boolean {\n    return Array.isArray(value) && value.length > 0 && value.every((e) => e instanceof Name)\n}\n","import { MIN_NUMBER_OF_NAME_PARTS, MAX_NUMBER_OF_NAME_PARTS } from './constants'\nimport { InputError, ValidationError } from './error'\nimport { FirstName, LastName, Name } from './name'\nimport { Namon } from './types'\nimport { NameIndex } from './utils'\n\n/**\n * Represents a set of validation rules (regex)\n *\n * This regex is intented to match specific alphabets only as a person name does\n * not contain special characters. `\\w` does not cover non-Latin characters. So,\n * it is extended using unicode chars to cover more cases (e.g., Icelandic).\n * It matches as follows:\n *  [a-z]: Latin alphabet from a (index 97) to z (index 122)\n *  [A-Z]: Latin alphabet from A (index 65) to Z (index 90)\n *  [\\u00C0-\\u00D6]: Latin/German chars from À (index 192) to Ö (index 214)\n *  [\\u00D8-\\u00f6]: German/Icelandic chars from Ø (index 216) to ö (index 246)\n *  [\\u00f8-\\u00ff]: German/Icelandic chars from ø (index 248) to ÿ (index 255)\n *  [\\u0400-\\u04FF]: Cyrillic alphabet from Ѐ (index 1024) to ӿ (index 1279)\n *  [Ά-ωΑ-ώ]: Greek alphabet from Ά (index 902) to ω (index 969)\n */\nclass ValidationRule {\n    static base: RegExp = /[a-zA-Z\\u00C0-\\u00D6\\u00D8-\\u00f6\\u00f8-\\u00ff\\u0400-\\u04FFΆ-ωΑ-ώ]/\n\n    /**\n     * Matches one name part (namon) that is of nature:\n     * - Latin (English, Spanish, French, etc.)\n     * - European (Greek, Cyrillic, Icelandic, German)\n     * - hyphenated\n     * - with apostrophe\n     * - with space\n     */\n    static namon: RegExp = new RegExp(\n        `^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`,\n    )\n\n    /**\n     * Matches one name part (namon) that is of nature:\n     * - Latin (English, Spanish, French, etc.)\n     * - European (Greek, Cyrillic, Icelandic, German)\n     * - hyphenated\n     * - with apostrophe\n     */\n    static firstName: RegExp = ValidationRule.namon\n\n    /**\n     * Matches 1+ names part (namon) that are of nature:\n     * - Latin (English, Spanish, French, etc.)\n     * - European (Greek, Cyrillic, Icelandic, German)\n     * - hyphenated\n     * - with apostrophe\n     * - with space\n     */\n    static middleName: RegExp = new RegExp(\n        `^${ValidationRule.base.source}+(([' -]${ValidationRule.base.source})?${ValidationRule.base.source}*)*$`,\n    )\n\n    /**\n     * Matches one name part (namon) that is of nature:\n     * - Latin (English, Spanish, French, etc.)\n     * - European (Greek, Cyrillic, Icelandic, German)\n     * - hyphenated\n     * - with apostrophe\n     * - with space\n     */\n    static lastName: RegExp = ValidationRule.namon\n}\n\nexport interface Validator<T> {\n    validate(value: T): void\n}\n\nclass ArrayValidator<T extends string | Name> implements Validator<T[]> {\n    validate(values: T[]): void {\n        if (\n            values.length == 0 ||\n            values.length < MIN_NUMBER_OF_NAME_PARTS ||\n            values.length > MAX_NUMBER_OF_NAME_PARTS\n        ) {\n            throw new InputError({\n                source: values.map((n) => n.toString()),\n                message: `expecting a list of ${MIN_NUMBER_OF_NAME_PARTS}-${MIN_NUMBER_OF_NAME_PARTS} elements`,\n            })\n        }\n    }\n}\n\nclass NamonValidator implements Validator<string | Name> {\n    private static validator: NamonValidator\n    private constructor() {}\n    static create(): NamonValidator {\n        return this.validator || (this.validator = new this())\n    }\n\n    validate(value: string | Name, type?: Namon): void {\n        if (value instanceof Name) {\n            NameValidator.create().validate(value, type)\n        } else if (typeof value === 'string') {\n            if (!ValidationRule.namon.test(value)) {\n                throw new ValidationError({\n                    source: value,\n                    nameType: 'namon',\n                    message: 'invalid content',\n                })\n            }\n        } else {\n            throw new InputError({\n                source: typeof value,\n                message: 'expecting types of string | Name',\n            })\n        }\n    }\n}\n\nclass FirstNameValidator implements Validator<string | FirstName> {\n    private static validator: FirstNameValidator\n    private constructor() {}\n    static create(): FirstNameValidator {\n        return this.validator || (this.validator = new this())\n    }\n\n    validate(value: string | FirstName): void {\n        if (value instanceof FirstName) {\n            value.asNames.forEach((name) => this.validate(name.value))\n        } else if (typeof value === 'string') {\n            if (!ValidationRule.firstName.test(value)) {\n                throw new ValidationError({\n                    source: value,\n                    nameType: 'firstName',\n                    message: 'invalid content',\n                })\n            }\n        } else {\n            throw new InputError({\n                source: typeof value,\n                message: 'expecting types string | FirstName',\n            })\n        }\n    }\n}\n\nclass MiddleNameValidator implements Validator<string | string[] | Name[]> {\n    private static validator: MiddleNameValidator\n    private constructor() {}\n    static create(): MiddleNameValidator {\n        return this.validator || (this.validator = new this())\n    }\n\n    validate(value: string | string[] | Name[]): void {\n        if (typeof value === 'string') {\n            if (!ValidationRule.middleName.test(value)) {\n                throw new ValidationError({\n                    source: value,\n                    nameType: 'middleName',\n                    message: 'invalid content',\n                })\n            }\n        } else if (Array.isArray(value)) {\n            try {\n                const validator = NamonValidator.create()\n                for (let name of value) validator.validate(name, Namon.MIDDLE_NAME)\n            } catch (error) {\n                throw new ValidationError({\n                    source: value,\n                    nameType: 'middleName',\n                    message: error?.message,\n                })\n            }\n        } else {\n            throw new InputError({\n                source: typeof value,\n                message: 'expecting types of string | string[] | Name[]',\n            })\n        }\n    }\n}\n\nclass LastNameValidator implements Validator<string | LastName> {\n    private static validator: LastNameValidator\n    private constructor() {}\n    static create(): LastNameValidator {\n        return this.validator || (this.validator = new this())\n    }\n\n    validate(value: string | LastName): void {\n        if (value instanceof LastName) {\n            value.asNames.forEach((name) => this.validate(name.value))\n        } else if (typeof value === 'string') {\n            if (!ValidationRule.lastName.test(value)) {\n                throw new ValidationError({\n                    source: value,\n                    nameType: 'lastName',\n                    message: 'invalid content',\n                })\n            }\n        } else {\n            throw new InputError({\n                source: typeof value,\n                message: 'expecting types string | LastName',\n            })\n        }\n    }\n}\n\nclass NameValidator implements Validator<Name> {\n    private static validator: NameValidator\n    private constructor() {}\n    static create(): NameValidator {\n        return this.validator || (this.validator = new this())\n    }\n\n    validate(name: Name, type?: Namon): void {\n        if (type && name.type !== type) {\n            throw new ValidationError({\n                source: [name],\n                nameType: name.type.toString(),\n                message: 'wrong type',\n            })\n        }\n\n        if (!ValidationRule.namon.test(name.value)) {\n            throw new ValidationError({\n                source: [name],\n                nameType: name.type.toString(),\n                message: 'invalid content',\n            })\n        }\n    }\n}\n\nexport class NamaValidator implements Validator<Map<Namon, string>> {\n    private static validator: NamaValidator\n    private constructor() {}\n    static create(): NamaValidator {\n        return this.validator || (this.validator = new this())\n    }\n\n    validate(value: Map<Namon, string>): void {\n        this.validateKeys(value)\n        Validators.firstName.validate(value.get(Namon.FIRST_NAME))\n        Validators.lastName.validate(value.get(Namon.LAST_NAME))\n\n        if (value.has(Namon.PREFIX)) {\n            Validators.namon.validate(value.get(Namon.PREFIX))\n        }\n        if (value.has(Namon.SUFFIX)) {\n            Validators.namon.validate(value.get(Namon.SUFFIX))\n        }\n    }\n\n    validateKeys(nama: Map<Namon, string>): void {\n        if (!nama.size) {\n            throw new InputError({ source: undefined, message: 'Map<k,v> must not be empty' })\n        } else if (nama.size < MIN_NUMBER_OF_NAME_PARTS || nama.size > MAX_NUMBER_OF_NAME_PARTS) {\n            throw new InputError({\n                source: [...nama.values()],\n                message: `expecting ${MIN_NUMBER_OF_NAME_PARTS}-${MIN_NUMBER_OF_NAME_PARTS} fields`,\n            })\n        }\n\n        if (!nama.has(Namon.FIRST_NAME)) {\n            throw new InputError({\n                source: [...nama.values()],\n                message: '\"firstName\" is a required key',\n            })\n        }\n\n        if (!nama.has(Namon.LAST_NAME)) {\n            throw new InputError({\n                source: [...nama.values()],\n                message: '\"lastName\" is a required key',\n            })\n        }\n    }\n}\n\nexport class ArrayStringValidator extends ArrayValidator<string> {\n    constructor(readonly index = NameIndex.base()) {\n        super()\n    }\n\n    validate(values: string[]): void {\n        this.validateIndex(values)\n\n        switch (values.length) {\n            case 2:\n                Validators.firstName.validate(values[this.index.firstName])\n                Validators.lastName.validate(values[this.index.lastName])\n                break\n            case 3:\n                Validators.firstName.validate(values[this.index.firstName])\n                Validators.middleName.validate(values[this.index.middleName])\n                Validators.lastName.validate(values[this.index.lastName])\n                break\n            case 4:\n                Validators.namon.validate(values[this.index.prefix])\n                Validators.firstName.validate(values[this.index.firstName])\n                Validators.middleName.validate(values[this.index.middleName])\n                Validators.lastName.validate(values[this.index.lastName])\n                break\n            case 5:\n                Validators.namon.validate(values[this.index.prefix])\n                Validators.firstName.validate(values[this.index.firstName])\n                Validators.middleName.validate(values[this.index.middleName])\n                Validators.lastName.validate(values[this.index.lastName])\n                Validators.namon.validate(values[this.index.suffix])\n                break\n        }\n    }\n\n    validateIndex(values: string[]): void {\n        super.validate(values)\n    }\n}\n\nexport class ArrayNameValidator implements Validator<Name[]> {\n    private static validator: ArrayNameValidator\n    private constructor() {}\n    static create(): ArrayNameValidator {\n        return this.validator || (this.validator = new this())\n    }\n\n    validate(value: Name[]): void {\n        if (value.length < MIN_NUMBER_OF_NAME_PARTS) {\n            throw new InputError({\n                source: value,\n                message: `expecting at least ${MIN_NUMBER_OF_NAME_PARTS} elements`,\n            })\n        }\n\n        if (!this.hasBasicNames(value)) {\n            throw new InputError({\n                source: value,\n                message: 'both first and last names are required',\n            })\n        }\n    }\n\n    private hasBasicNames(names: Name[]): boolean {\n        const accumulator: { [key: string]: string } = {}\n        for (const name of names) {\n            if (name.isFirstName || name.isLastName) {\n                accumulator[name.type.key] = name.toString()\n            }\n        }\n        return Object.keys(accumulator).length == MIN_NUMBER_OF_NAME_PARTS\n    }\n}\n\n/**\n * A list of validators for a specific namon.\n */\nexport abstract class Validators {\n    static namon = NamonValidator.create()\n    static nama = NamaValidator.create()\n    static prefix = NamonValidator.create()\n    static firstName = FirstNameValidator.create()\n    static middleName = MiddleNameValidator.create()\n    static lastName = LastNameValidator.create()\n    static suffix = NamonValidator.create()\n}\n"],"sourceRoot":""}