namefully 1.0.9 → 1.2.0

package/dist/umd/namefully.js

@@ -91,7 +91,7 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 5);
+/******/ 	return __webpack_require__(__webpack_require__.s = 9);
 /******/ })
 /************************************************************************/
 /******/ ([
@@ -101,1440 +101,1274 @@ return /******/ (function(modules) { // webpackBootstrap
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(2);
+exports.Separator = exports.Namon = exports.CapsRange = exports.Flat = exports.NameType = exports.NameOrder = exports.Surname = exports.Title = void 0;
 /**
- * Make all the locals available
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
+ * The abbreviation type to indicate whether or not to add period to a prefix
+ * using the American or British way.
  */
-tslib_1.__exportStar(__webpack_require__(13), exports);
-tslib_1.__exportStar(__webpack_require__(14), exports);
-tslib_1.__exportStar(__webpack_require__(15), exports);
-var namon_validator_1 = __webpack_require__(16);
-exports.NamonValidator = namon_validator_1.default;
-var prefix_validator_1 = __webpack_require__(17);
-exports.PrefixValidator = prefix_validator_1.default;
-var suffix_validator_1 = __webpack_require__(18);
-exports.SuffixValidator = suffix_validator_1.default;
-var firstname_validator_1 = __webpack_require__(19);
-exports.FirstnameValidator = firstname_validator_1.default;
-var lastname_validator_1 = __webpack_require__(20);
-exports.LastnameValidator = lastname_validator_1.default;
-var middlename_validator_1 = __webpack_require__(21);
-exports.MiddlenameValidator = middlename_validator_1.default;
-var fullname_validator_1 = __webpack_require__(22);
-exports.FullnameValidator = fullname_validator_1.default;
-var nama_validator_1 = __webpack_require__(23);
-exports.NamaValidator = nama_validator_1.default;
-var array_name_validator_1 = __webpack_require__(24);
-exports.ArrayNameValidator = array_name_validator_1.default;
-var array_string_validator_1 = __webpack_require__(25);
-exports.ArrayStringValidator = array_string_validator_1.default;
-var string_name_validator_1 = __webpack_require__(26);
-exports.StringNameValidator = string_name_validator_1.default;
-
-
-/***/ }),
-/* 1 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(2);
+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 = {}));
 /**
- * Make all the locals available
+ * An option indicating how to format a surname.
  *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
+ * 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.
  */
-tslib_1.__exportStar(__webpack_require__(8), exports);
-tslib_1.__exportStar(__webpack_require__(9), exports);
-tslib_1.__exportStar(__webpack_require__(10), exports);
-tslib_1.__exportStar(__webpack_require__(11), exports);
-tslib_1.__exportStar(__webpack_require__(12), exports);
-
-
-/***/ }),
-/* 2 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__extends", function() { return __extends; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__assign", function() { return __assign; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__rest", function() { return __rest; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__decorate", function() { return __decorate; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__param", function() { return __param; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__metadata", function() { return __metadata; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__awaiter", function() { return __awaiter; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__generator", function() { return __generator; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__exportStar", function() { return __exportStar; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__values", function() { return __values; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__read", function() { return __read; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spread", function() { return __spread; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spreadArrays", function() { return __spreadArrays; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__await", function() { return __await; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncGenerator", function() { return __asyncGenerator; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncDelegator", function() { return __asyncDelegator; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncValues", function() { return __asyncValues; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__makeTemplateObject", function() { return __makeTemplateObject; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importStar", function() { return __importStar; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importDefault", function() { return __importDefault; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__classPrivateFieldGet", function() { return __classPrivateFieldGet; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__classPrivateFieldSet", function() { return __classPrivateFieldSet; });
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    }
-    return __assign.apply(this, arguments);
-}
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-function __metadata(metadataKey, metadataValue) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-function __awaiter(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());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __exportStar(m, exports) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
-}
-
-function __spreadArrays() {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-};
-
-function __await(v) {
-    return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-}
-
-function __asyncDelegator(o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
-}
-
-function __asyncValues(o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-}
-
-function __makeTemplateObject(cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-};
-
-function __importStar(mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result.default = mod;
-    return result;
-}
-
-function __importDefault(mod) {
-    return (mod && mod.__esModule) ? mod : { default: mod };
-}
-
-function __classPrivateFieldGet(receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-}
-
-
-/***/ }),
-/* 3 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(2);
+Namon.values = [Namon.PREFIX, Namon.FIRST_NAME, Namon.MIDDLE_NAME, Namon.LAST_NAME, Namon.SUFFIX];
 /**
- * Make all the locals available
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
+ * All the predefined name types.
  */
-tslib_1.__exportStar(__webpack_require__(4), exports);
-tslib_1.__exportStar(__webpack_require__(30), exports);
-tslib_1.__exportStar(__webpack_require__(31), exports);
-
-
-/***/ }),
-/* 4 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var array_name_parser_1 = __webpack_require__(7);
-exports.ArrayNameParser = array_name_parser_1.default;
-var array_string_parser_1 = __webpack_require__(27);
-exports.ArrayStringParser = array_string_parser_1.default;
-var nama_parser_1 = __webpack_require__(28);
-exports.NamaParser = nama_parser_1.default;
-var string_parser_1 = __webpack_require__(29);
-exports.StringParser = string_parser_1.default;
-
-
-/***/ }),
-/* 5 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(2);
+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],
+]);
 /**
- * Main entry to `Namefully`
- *
- * Created on March 03, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
+ * The token used to indicate how to split string values.
  */
-tslib_1.__exportStar(__webpack_require__(6), exports);
-tslib_1.__exportStar(__webpack_require__(3), exports);
-tslib_1.__exportStar(__webpack_require__(1), exports);
-tslib_1.__exportStar(__webpack_require__(0), exports);
+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);
 
 
 /***/ }),
-/* 6 */
+/* 1 */
 /***/ (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__(2);
 /**
- * `Namefully` person name handler
- *
- * Created on March 03, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- *
- * @license GPL-3.0
- * @see {@link https://github.com/ralflorent/namefully|namefully} for more info.
- */
-const index_1 = __webpack_require__(3);
-const index_2 = __webpack_require__(1);
-const index_3 = __webpack_require__(0);
-/**
- * Person name handler
- * @class
- * @classdesc
- * `Namefully` does not magically guess which part of the name is what. It relies
- * actually on how the developer indicates the roles of the name parts so that
- * it, internally, can perform certain operations and saves the developer some
- * calculations/processings. Nevertheless, Namefully can be constructed using
- * distinct raw data shape. This is intended to give some flexibility to the
- * developer so that he or she is not bound to a particular data format. Please,
- * do follow closely the APIs to know how to properly use it in order to avoid
- * some errors (mainly validation's).
- *
- * `Namefully` also works like a trap door. Once a raw data is provided and
- * validated, a developer can only ACCESS in a vast amount of, yet effective ways
- * the name info. NO EDITING is possible. If the name is mistaken, a new instance
- * of `Namefully` must be created. Remember, this utility's primary objective is
- * to help to **handle** a person name.
- *
- * Note that the name standards used for the current version of this library are
- * as follows:
- *      [Prefix] Firstname [Middlename] Lastname [Suffix]
- * The opening `[` and closing `]` brackets mean that these parts are optional.
- * In other words, the most basic and typical case is a name that looks like this:
- * `John Smith`, where `John` is the first name and `Smith`, the last name.
- * @see https://departments.weber.edu/qsupport&training/Data_Standards/Name.htm
- * for more info on name standards.
- *
- * **IMPORTANT**: Keep in mind that the order of appearance matters and can be
- * altered through configured parameters, which we will be seeing later on. By
- * default, the order of appearance is as shown above and will be used as a basis
- * for future examples and use cases.
- *
- * Once imported, all that is required to do is to create an instance of
- * `Namefully` and the rest will follow.
- *
- * Some terminologies used across the library are:
- * - namon: piece of a name (e.g., firstname)
- * - nama: pieces of a name (e.g., firstname + lastname)
- *
- * Happy naming!
+ * The error types supported by `Namefully`.
  */
-class Namefully {
+var NameErrorType;
+(function (NameErrorType) {
     /**
-     * Constructs an instance of the utility and helps to benefit from many helpers
-     * @param {string | string[] | Array<Name> | Nama} raw element to parse or
-     * construct the pieces of the name
-     * @param {Config} options to configure how to run the utility
+     * 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.
      */
-    constructor(raw, options) {
-        // well, first thing first
-        this.configure(options);
-        // let's try to parse this, baby!
-        this.build(raw);
-    }
+    NameErrorType[NameErrorType["INPUT"] = 0] = "INPUT";
     /**
-     * Gets the full name ordered as configured
-     * @param {'firstname'|'lastname'} orderedBy force to order by first or last
-     * name by overriding the preset configuration
-     * @returns {string} the suffix
+     * 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 {format} to alter manually the order of appearance of the full name.
-     * For example, ::format('l f m') outputs `lastname firstname middlename`.
-     */
-    getFullname(orderedBy) {
-        orderedBy = orderedBy || this.config.orderedBy; // override config
-        const { titling, ending } = this.config;
-        const pxSep = titling === 'us' ? index_2.Separator.PERIOD : index_2.Separator.EMPTY; // Mr[.]
-        const sxSep = ending !== index_2.Separator.SPACE ? ending : index_2.Separator.EMPTY; // [,] PhD
-        const nama = [];
-        if (this.fullname.prefix)
-            nama.push(index_2.Separator.EMPTY.concat(this.fullname.prefix, pxSep));
-        switch (orderedBy) {
-            case 'firstname':
-                nama.push(this.getFirstname());
-                nama.push(...this.getMiddlenames());
-                nama.push(index_2.Separator.EMPTY.concat(this.getLastname(), sxSep));
-                break;
-            case 'lastname':
-                nama.push(this.getLastname());
-                nama.push(this.getFirstname());
-                nama.push(this.getMiddlenames().join(index_2.Separator.SPACE).concat(sxSep));
-                break;
-        }
-        if (this.fullname.suffix)
-            nama.push(this.fullname.suffix);
-        return nama.join(index_2.Separator.SPACE);
-    }
+     * See also: `ValidationError`
+     */
+    NameErrorType[NameErrorType["VALIDATION"] = 1] = "VALIDATION";
     /**
-     * Gets the first name part of the full name
-     * @returns {string} the first name
+     * Thrown by not allowed operations such as in NameBuilder or name formatting.
+     *
+     * See also: `NotAllowedError`, `Namefully.format`.
      */
-    getFirstname() {
-        return this.fullname.firstname.tostring();
-    }
+    NameErrorType[NameErrorType["NOT_ALLOWED"] = 2] = "NOT_ALLOWED";
     /**
-     * Gets the last name part of the full name
-     * @param {LastnameFormat} [format] overrides the how-to format of a surname
-     * output, considering its subparts.
-     * @returns {string} the last name
+     * Thrown by any other unknown sources or unexpected situation.
      */
-    getLastname(format) {
-        return this.fullname.lastname.tostring(format);
-    }
+    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 {
     /**
-     * Gets the middle names part of the full name
-     * @returns {Array<string>} the middle names
+     * 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`
      */
-    getMiddlenames() {
-        return this.fullname.middlename ? this.fullname.middlename.map(n => n.namon) : [];
+    constructor(source, message, type = NameErrorType.UNKNOWN) {
+        super(message);
+        this.source = source;
+        this.type = type;
+        this.name = 'NameError';
     }
     /**
-     * Gets the prefix part of the full name
-     * @returns {string} the prefix
+     * The actual source input which caused the error.
      */
-    getPrefix() {
-        const pxSep = this.config.titling === 'us' ? index_2.Separator.PERIOD : index_2.Separator.EMPTY;
-        return this.fullname.prefix ?
-            index_2.Separator.EMPTY.concat(this.fullname.prefix, pxSep) :
-            index_2.Separator.EMPTY;
+    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;
     }
     /**
-     * Gets the suffix part of the full name
-     * @returns {string} the suffix
+     * Whether a message describing the failure exists.
      */
-    getSuffix() {
-        return this.fullname.suffix || index_2.Separator.EMPTY;
+    get hasMessage() {
+        return this.message && this.message.trim().length > 0;
     }
     /**
-     * Gets the initials of the full name
-     * @param {'firstname'|'lastname'} orderedBy force to order by first or last
-     * name by overriding the preset configuration
-     * @param {boolean} [withMid] whether to include middle names's
-     * @returns {Array<string>} the initials
-     *
-     * @example
-     * Given the names:
-     * - `John Smith` => ['J', 'S']
-     * - `John Ben Smith` => ['J', 'S']
-     * when `withMid` is set to true:
-     * - `John Ben Smith` => ['J', 'B', 'S']
-     *
-     * **NOTE**:
-     * Ordered by last name obeys the following format:
-     *  `lastname firstname [middlename]`
-     * which means that if no middle name was set, setting `withMid` to true
-     * will output nothing and warn the end user about it.
-     */
-    getInitials(orderedBy, withMid = false) {
-        orderedBy = orderedBy || this.config.orderedBy; // override config
-        const midInits = this.fullname.middlename ?
-            this.fullname.middlename.map(n => n.getInitials()) : [];
-        if (withMid && !this.fullname.middlename) {
-            console.warn('No initials for middle names since none was set.');
-        }
-        const initials = [];
-        switch (orderedBy) {
-            case 'firstname':
-                initials.push(...this.fullname.firstname.getInitials());
-                if (withMid)
-                    midInits.forEach(m => initials.push(...m));
-                initials.push(...this.fullname.lastname.getInitials());
-                break;
-            case 'lastname':
-                initials.push(...this.fullname.lastname.getInitials());
-                initials.push(...this.fullname.firstname.getInitials());
-                if (withMid)
-                    midInits.forEach(m => initials.push(...m));
-                break;
-        }
-        return initials;
+     * 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 {
     /**
-     * Gives some descriptive statistics that summarize the central tendency,
-     * dispersion and shape of the characters' distribution.
-     * @param what which variant to use when describe a name part
-     * @returns {string} the stats behind the full name.
-     *
-     * Treated as a categorical dataset, the summary contains the following info:
-     * `count` : the number of *unrestricted* characters of the name;
-     * `frequency` : the highest frequency within the characters;
-     * `top` : the character with the highest frequency;
-     * `unique` : the count of unique characters of the name.
-     *
-     * @example
-     * Given the name "Thomas Alva Edison", the summary will output as follows:
+     * Creates a new `InputError` with an optional error `message`.
      *
-     * Descriptive statistics for "Thomas Alva Edison"
-     *  count    : 16
-     *  frequency: 3
-     *  top      : A
-     *  unique   : 12
-     *
-     * **NOTE:**
-     * During the setup, a set of restricted characters can be defined to be removed
-     * from the stats. By default, the only restricted character is the `space`.
-     * That is why the `count` for the example below result in `16` instead of
-     * `16`.
-     * Another thing to consider is that the summary is case *insensitive*. Note
-     * that the letter `a` has the top frequency, be it `3`.
-     */
-    describe(what = 'fullname') {
-        switch (what) {
-            case 'fullname':
-                return this.summary;
-            case 'firstname':
-                return this.fullname.firstname.describe();
-            case 'lastname':
-                return this.fullname.lastname.describe();
-            case 'middlename':
-                return !this.fullname.middlename ? null :
-                    new index_2.Summary(this.fullname.middlename.map(n => n.namon).join(index_2.Separator.SPACE));
-        }
+     * 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 {
     /**
-     * Shortens a complex full name to a simple typical name, a combination of
-     * first name and last name.
-     * @param {'firstname'|'lastname'} orderedBy force to order by first or last
-     * name by overriding the preset configuration
-     * @returns {string} a typical name
+     * Creates error containing the invalid `nameType` and a `message` that
+     * briefly describes the problem if provided.
      *
-     * @example
-     * For a given name such as `Mr Keanu Charles Reeves`, shortening this name
-     * is equivalent to making it `Keanu Reeves`.
+     * For example, a validation error can be interpreted as:
+     *     "ValidationError (nameType='stringName')",
+     *     "ValidationError (nameType='stringName'): message"
      */
-    shorten(orderedBy) {
-        orderedBy = orderedBy || this.config.orderedBy; // override config
-        return orderedBy === 'firstname' ?
-            [
-                this.fullname.firstname.namon,
-                this.fullname.lastname.namon,
-            ].join(index_2.Separator.SPACE) :
-            [
-                this.fullname.lastname.namon,
-                this.fullname.firstname.namon,
-            ].join(index_2.Separator.SPACE);
-    }
-    /**
-     * Compresses a name by using different forms of variants
-     * @param {number} [limit] a threshold to limit the number of characters
-     * @param {'firstname'|'lastname'|'middlename'|'firstmid'|'midlast'} [by]
-     * a variant to use when compressing the long name. The last two variants
-     * represent respectively the combination of `firstname + middlename` and
-     * `middlename + lastname`.
-     * @param {boolean} [warning] should warn when the set limit is violated
-     *
-     * @example
-     * The compressing operation is only executed iff there is valid entry and it
-     * surpasses the limit set. In the examples below, let us assume that the
-     * name goes beyond the limit value.
-     *
-     * Compressing a long name refers to reducing the name to the following forms:
-     * 1. by firstname: 'John Moe Beau Lennon' => 'J. Moe Beau Lennon'
-     * 2. by middlename: 'John Moe Beau Lennon' => 'John M. B. Lennon'
-     * 3. by lastname: 'John Moe Beau Lennon' => 'John Moe Beau L.'
-     * 4. by firstmid: 'John Moe Beau Lennon' => 'J. M. B. Lennon'
-     * 5. by midlast: 'John Moe Beau Lennon' => 'John M. B. L.'
-     *
-     * By default, it compresses by 'firstmid' variant: 'J. M. B. Lennon'.
-     */
-    compress(limit = 20, by = 'middlename', warning = true) {
-        if (this.getFullname().length <= limit) // no need to compress
-            return this.getFullname();
-        const { firstname: fn, lastname: ln, middlename } = this.fullname;
-        const mn = this.getMiddlenames().join(index_2.Separator.SPACE);
-        const hasmid = Array.isArray(middlename) && middlename.length > 0;
-        const sep = this.config.titling === 'us' ? index_2.Separator.PERIOD : index_2.Separator.EMPTY;
-        const firsts = fn.getInitials().join(sep).concat(sep);
-        const lasts = ln.getInitials().join(sep).concat(sep);
-        const mids = hasmid ? middlename.map(n => n.getInitials()).join(sep).concat(sep) : index_2.Separator.EMPTY;
-        let cname = '';
-        if (this.config.orderedBy === 'firstname') {
-            switch (by) {
-                case 'firstname':
-                    cname = hasmid ?
-                        [firsts, mn, ln.tostring()].join(index_2.Separator.SPACE) :
-                        [firsts, ln.tostring()].join(index_2.Separator.SPACE);
-                    break;
-                case 'lastname':
-                    cname = hasmid ?
-                        [fn.tostring(), mn, lasts].join(index_2.Separator.SPACE) :
-                        [fn.tostring(), lasts].join(index_2.Separator.SPACE);
-                    break;
-                case 'middlename':
-                    cname = hasmid ?
-                        [fn.tostring(), mids, ln.tostring()].join(index_2.Separator.SPACE) :
-                        [fn.tostring(), ln.tostring()].join(index_2.Separator.SPACE);
-                    break;
-                case 'firstmid':
-                    cname = hasmid ?
-                        [firsts, mids, ln.tostring()].join(index_2.Separator.SPACE) :
-                        [firsts, ln.tostring()].join(index_2.Separator.SPACE);
-                    break;
-                case 'midlast':
-                    cname = hasmid ?
-                        [fn.tostring(), mids, lasts].join(index_2.Separator.SPACE) :
-                        [fn.tostring(), lasts].join(index_2.Separator.SPACE);
-                    break;
-            }
-        }
-        else {
-            switch (by) {
-                case 'firstname':
-                    cname = hasmid ?
-                        [ln.tostring(), firsts, mn].join(index_2.Separator.SPACE) :
-                        [ln.tostring(), firsts].join(index_2.Separator.SPACE);
-                    break;
-                case 'lastname':
-                    cname = hasmid ?
-                        [lasts, fn.tostring(), mn].join(index_2.Separator.SPACE) :
-                        [lasts, fn.tostring()].join(index_2.Separator.SPACE);
-                    break;
-                case 'middlename':
-                    cname = hasmid ?
-                        [ln.tostring(), fn.tostring(), mids].join(index_2.Separator.SPACE) :
-                        [ln.tostring(), fn.tostring()].join(index_2.Separator.SPACE);
-                    break;
-                case 'firstmid':
-                    cname = hasmid ?
-                        [ln.tostring(), firsts, mids].join(index_2.Separator.SPACE) :
-                        [ln.tostring(), firsts].join(index_2.Separator.SPACE);
-                    break;
-                case 'midlast':
-                    cname = hasmid ?
-                        [lasts, fn.tostring(), mids].join(index_2.Separator.SPACE) :
-                        [lasts, fn.tostring()].join(index_2.Separator.SPACE);
-                    break;
-            }
-        }
-        if (warning && cname.length > limit)
-            console.warn(`The compressed name <${cname}> still surpasses the set limit ${limit}`);
-        return cname;
-    }
-    /**
-     * Zips or compresses a name by using different forms of variants
-     * @param by a variant to use when compressing the long name. The last two
-     * variants represent respectively the combination of `firstname + middlename`
-     * and `middlename + lastname`.
-     */
-    zip(by = 'mn') {
-        let v;
-        if (by === 'fn' || by === 'firstname')
-            v = 'firstname';
-        if (by === 'mn' || by === 'middlename')
-            v = 'middlename';
-        if (by === 'ln' || by === 'lastname')
-            v = 'lastname';
-        if (by === 'fm' || by === 'firstmid')
-            v = 'firstmid';
-        if (by === 'ml' || by === 'midlast')
-            v = 'midlast';
-        return this.compress(0, v, false);
-    }
-    /**
-     * Suggests possible (randomly) usernames closest to the name
-     * @returns {Array<string>} a set of usernames
-     *
-     * **NOTE**
-     * The validity of these usernames are not checked against any social media
-     * or web app online.
-     */
-    username() {
-        const unames = [];
-        const { firstname: f, lastname: l } = this.fullname;
-        const p = index_2.Separator.PERIOD;
-        // Given `John Smith`
-        unames.push(f.lower() + l.lower()); // johnsmith
-        unames.push(l.lower() + f.lower()); // smithjohn
-        unames.push(f.lower()[0] + l.lower()); // jsmith
-        unames.push(l.lower()[0] + f.lower()); // sjohn
-        unames.push(f.lower()[0] + p + l.lower()); // j.smith
-        unames.push(l.lower()[0] + p + f.lower()); // s.john
-        unames.push(f.lower().slice(0, 2) + l.lower()); // josmith
-        unames.push(l.lower().slice(0, 2) + f.lower()); // smjohn
-        unames.push(f.lower().slice(0, 2) + p + l.lower()); // jo.smith
-        unames.push(l.lower().slice(0, 2) + p + f.lower()); // sm.john
-        return unames;
-    }
-    /**
-     * Formats the name as desired
-     * @param {string} how to format the full name
-     * @returns {string} the formatted name as specified
-     *
-     * How to format it?
-     * 'f': first name
-     * 'F': capitalized first name
-     * 'l': last name (official)
-     * 'L': capitalized last name
-     * 'm': middle names
-     * 'M': Capitalized middle names
-     * 'O': official document format
-     *
-     * @example
-     * Given the name `Joe Jim Smith`, call the `format` with the how string.
-     * - format('l f') => 'Smith Joe'
-     * - format('L, f') => 'SMITH, Joe'
-     * - format('fml') => 'JoeJimSmith'
-     * - format('FML') => 'JOEJIMSMITH'
-     * - format('L, f m') => 'SMITH, Joe Jim'
-     * - format('O') => 'SMITH, Joe Jim'
-     */
-    format(how) {
-        if (!how)
-            return this.getFullname();
-        const formatted = [];
-        const tokens = [
-            '.', ',', ' ', '-', '_', 'f', 'F', 'l', 'L', 'm', 'M',
-            'n', 'N', 'o', 'O', 'p', 'P', 's', 'S'
-        ];
-        for (const c of how) {
-            if (tokens.indexOf(c) === -1)
-                throw new Error(`<${c}> is an invalid character for the formatting.`);
-            formatted.push(this.map(c));
-        }
-        return formatted.join(index_2.Separator.EMPTY).trim();
+    constructor(error) {
+        super(error.source, error.message, NameErrorType.VALIDATION);
+        this.nameType = error.nameType;
+        this.name = 'ValidationError';
     }
-    /**
-     * Configures how the setup will be working
-     * @param {Config} options for a customized setup
-     */
-    configure(options) {
-        // consider using deepmerge if objects no longer stay shallow
-        this.config = Object.assign(Object.assign({}, index_1.CONFIG), options); // if options, it overrides CONFIG
+    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 {
     /**
-     * Defines the full name by having the pieces (namon) of the names ready
-     * @param parser customized or user-defined parser to get the full name
+     * 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"
      */
-    initialize(parser) {
-        const { orderedBy, separator, bypass, lastnameFormat } = this.config;
-        this.fullname = parser.parse({ orderedBy, separator, bypass, lastnameFormat });
+    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 {
     /**
-     * Maps a character to a specific piece of the name
-     * @param c character to be mapped
-     * @return {string} piece of name
+     * Creates a new `UnknownError` with an optional error `message`.
+     * Optionally, the original error revealing the true nature of the failure.
      */
-    map(c) {
-        switch (c) {
-            case '.':
-                return index_2.Separator.PERIOD;
-            case ',':
-                return index_2.Separator.COMMA;
-            case ' ':
-                return index_2.Separator.SPACE;
-            case '-':
-                return index_2.Separator.HYPHEN;
-            case '_':
-                return index_2.Separator.UNDERSCORE;
-            case 'f':
-                return this.fullname.firstname.namon;
-            case 'F':
-                return this.fullname.firstname.upper();
-            case 'l':
-                return this.fullname.lastname.namon;
-            case 'L':
-                return this.fullname.lastname.upper();
-            case 'm':
-                return this.fullname.middlename
-                    .map(n => n.namon).join(index_2.Separator.SPACE);
-            case 'M':
-                return this.fullname.middlename
-                    .map(n => n.upper()).join(index_2.Separator.SPACE);
-            case 'o':
-            case 'O':
-                const { titling, ending } = this.config;
-                const pxSep = titling === 'us' ? index_2.Separator.PERIOD : index_2.Separator.EMPTY;
-                const sxSep = ending !== index_2.Separator.SPACE ? ending : index_2.Separator.EMPTY;
-                const official = [
-                    this.fullname.prefix ? index_2.Separator.EMPTY.concat(this.fullname.prefix, pxSep) : index_2.Separator.EMPTY,
-                    this.fullname.lastname.upper().concat(index_2.Separator.COMMA),
-                    this.fullname.firstname.tostring(),
-                    this.fullname.middlename.map(n => n.namon).join(index_2.Separator.SPACE).concat(sxSep),
-                    this.fullname.suffix || index_2.Separator.EMPTY,
-                ].join(index_2.Separator.SPACE).trim();
-                return c === 'o' ? official : official.toUpperCase();
-            case 'p':
-                return this.fullname.prefix || index_2.Separator.EMPTY;
-            case 'P':
-                return this.fullname.prefix ? this.fullname.prefix.toUpperCase() : index_2.Separator.EMPTY;
-            case 's':
-                return this.fullname.suffix || index_2.Separator.EMPTY;
-            case 'S':
-                return this.fullname.suffix ? this.fullname.suffix.toUpperCase() : index_2.Separator.EMPTY;
-            default:
-                return index_2.Separator.EMPTY;
-        }
+    constructor(error) {
+        super(error.source, error.message, NameErrorType.UNKNOWN);
+        this.origin = error.error;
+        this.name = 'UnknownError';
     }
-    /**
-     * Builds a high qualitty of data using parsers and validators
-     * @param {string | string[] | Array<Name> | Nama} raw data to parse or
-     * construct the pieces of the name
-     */
-    build(raw) {
-        if (this.config.parser) {
-            this.initialize(this.config.parser);
-        }
-        else if (typeof raw === 'string') { // check for string type
-            this.initialize(new index_1.StringParser(raw));
-        }
-        else if (Array.isArray(raw) && raw.length) { // check for Array<T>
-            if (typeof raw[0] === 'string') { // check for Array<string>
-                for (const key of raw)
-                    if (typeof key !== 'string')
-                        throw new Error(`Cannot parse raw data as array of 'string'`);
-                this.initialize(new index_1.ArrayStringParser(raw));
-            }
-            else if (raw[0] instanceof index_2.Name) { // check for Array<Name>
-                for (const obj of raw)
-                    if (!(obj instanceof index_2.Name))
-                        throw new Error(`Cannot parse raw data as array of '${index_2.Name.name}'`);
-                this.initialize(new index_1.ArrayNameParser(raw));
-            }
-            else {
-                // typescript should stop them, but let's be paranoid (for JS developers)
-                throw new Error(`Cannot parse raw data as arrays that are not of '${index_2.Name.name}' or string`);
-            }
-        }
-        else if (raw instanceof Object) { // check for json object
-            for (const entry of Object.entries(raw)) { // make sure keys are correct
-                const key = entry[0], value = entry[1];
-                if (['firstname', 'lastname', 'middlename', 'prefix', 'suffix'].indexOf(key) === -1)
-                    throw new Error(`Cannot parse raw data as json object that does not contains keys of '${index_2.Namon}'`);
-                if (typeof value !== 'string') // make sure the values are proper string
-                    throw new Error(`Cannot parse raw data. The key <${key}> should be a 'string' type`);
-            }
-            this.initialize(new index_1.NamaParser(raw));
-        }
-        else {
-            // typescript should stop them, but let's be paranoid again (for JS developers)
-            throw new Error(`Cannot parse raw data. Review the data type expected.`);
-        }
-        // paranoid coder mode: on :P
-        if (!this.config.bypass)
-            new index_3.FullnameValidator().validate(this.fullname);
-        this.summary = new index_2.Summary(this.getFullname());
+    toString() {
+        let report = super.toString();
+        if (this.origin)
+            report += `\n${this.origin.toString()}`;
+        return report;
     }
 }
-exports.Namefully = Namefully;
-Namefully.prototype.full = Namefully.prototype.getFullname;
-Namefully.prototype.fn = Namefully.prototype.getFirstname;
-Namefully.prototype.ln = Namefully.prototype.getLastname;
-Namefully.prototype.mn = Namefully.prototype.getMiddlenames;
-Namefully.prototype.px = Namefully.prototype.getPrefix;
-Namefully.prototype.sx = Namefully.prototype.getSuffix;
-Namefully.prototype.inits = Namefully.prototype.getInitials;
-Namefully.prototype.stats = Namefully.prototype.describe;
+exports.UnknownError = UnknownError;
 
 
 /***/ }),
-/* 7 */
+/* 2 */
 /***/ (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__(5);
+const name_1 = __webpack_require__(3);
+const types_1 = __webpack_require__(0);
 /**
- * An array `Name` parser
+ * A fixed set of values to handle specific positions for list of names.
  *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-/**
- * Represents a `Name[]` parser
- * @class
- * @implements {Parser<Name[]>}
- * @classdesc
- * This parser parses an array of the class `Name` while checking that every part
- * plays the role they are supposed to play. The class `Name` is a ready-made
- * recipe that saves the how-to parsing for a raw data input.
+ * 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
  *
- * **NOTE**:
- * In this specific case, the user is expected to carefully set each name part
- * and submit a high-quality data. Why is this parser if the data is already
- * shaped as wanted? Well, it is better to be safe than sorry, so we implement a
- * double-check of these values and reconfirm a cleaner data. Remember, namefully
- * works like a trapdoor, once the data is set and confirmed safe, no editing is
- * possible.
+ * For example, `Jane Smith` (ordered by first name) is expected to be indexed:
+ * `['Jane', 'Smith']`.
  */
-class ArrayNameParser {
+class NameIndex {
+    constructor(prefix, firstName, middleName, lastName, suffix) {
+        this.prefix = prefix;
+        this.firstName = firstName;
+        this.middleName = middleName;
+        this.lastName = lastName;
+        this.suffix = suffix;
+    }
     /**
-     * Create a parser ready to parse the raw data
-     * @param {Name[]} raw data
+     * The minimum number of parts in a list of names.
      */
-    constructor(raw) {
-        this.raw = raw;
+    static get min() {
+        return constants_1.MIN_NUMBER_OF_NAME_PARTS;
     }
     /**
-     * Parses the raw data into a full name
-     * @returns {Fullname}
+     * The maximum number of parts in a list of names.
      */
-    parse(options) {
-        const { bypass, lastnameFormat } = options;
-        // validate first
-        if (!bypass)
-            new index_2.ArrayNameValidator().validate(this.raw);
-        // then distribute all the elements accordingly
-        const fullname = this.distribute(lastnameFormat);
-        // finally return high quality of data
-        return fullname;
-    }
-    distribute(lastnameFormat) {
-        const fullname = {
-            firstname: null,
-            lastname: null,
-            middlename: [],
-            prefix: null,
-            suffix: null,
-        };
-        this.raw.forEach(name => {
-            switch (name.type) {
-                case index_1.Namon.PREFIX:
-                    fullname.prefix = name.namon;
-                    break;
-                case index_1.Namon.FIRST_NAME:
-                    fullname.firstname = new index_1.Firstname(name.namon);
-                    break;
-                case index_1.Namon.LAST_NAME:
-                    if (name instanceof index_1.Lastname)
-                        fullname.lastname = new index_1.Lastname(name.father, name.mother, lastnameFormat);
-                    else
-                        fullname.lastname = new index_1.Lastname(name.namon, null, lastnameFormat);
-                    break;
-                case index_1.Namon.MIDDLE_NAME:
-                    fullname.middlename.push(name);
-                    break;
-                case index_1.Namon.SUFFIX:
-                    fullname.suffix = name.namon;
-                    break;
+    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();
             }
-        });
-        return fullname;
+        }
+        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.default = ArrayNameParser;
+exports.isNameArray = isNameArray;
 
 
 /***/ }),
-/* 8 */
+/* 3 */
 /***/ (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__(1);
+const types_1 = __webpack_require__(0);
+const utils_1 = __webpack_require__(2);
 /**
- * Name class definition
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-/**
- * Represents a namon with some extra functionalities
- * @class
- * @see {@link Namon} interface to understand the concept of namon/nama.
+ * Representation of a string type name with some extra capabilities.
  */
 class Name {
     /**
-     * Constructs a `Name`
-     * @param namon a piece of string that will be defined as a namon
-     * @param type which namon that is
+     * 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(namon, type, capitalized) {
-        this.namon = namon;
+    constructor(value, type, capsRange) {
         this.type = type;
-        this.initial = namon[0];
-        this.body = namon.slice(1, namon.length);
-        if (!!capitalized)
-            this.capitalize(capitalized);
+        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];
     }
     /**
-     * Gives some descriptive statistics that summarize the central tendency,
-     * dispersion and shape of the characters' distribution.
-     * @see {@link describe} in `Namefully` class for further information
+     * The piece of string treated as a name.
      */
-    describe() {
-        return new index_1.Summary(this.namon);
+    get value() {
+        return this.namon;
     }
     /**
-     * Gets the initials of the name
-     * @returns {Array<string>} the initials
+     * The length of the name.
      */
-    getInitials() {
-        return [this.initial];
+    get length() {
+        return this.namon.length;
     }
     /**
-     * Capitalizes a name
-     * @param {'initial' | 'all'} option how to capitalize it
+     * Whether the name is a prefix.
      */
-    capitalize(option = 'initial') {
-        if (option === 'initial') {
-            this.initial = this.initial.toUpperCase();
-            this.namon = this.initial.concat(this.body);
-        }
-        else {
-            this.initial = this.initial.toUpperCase();
-            this.namon = this.namon.toUpperCase();
-        }
+    get isPrefix() {
+        return this.type === types_1.Namon.PREFIX;
     }
     /**
-     * Converts all the alphabetic characters in a string to lowercase
+     * Whether the name is a first name.
      */
-    lower() {
-        return this.namon.toLowerCase();
+    get isFirstName() {
+        return this.type === types_1.Namon.FIRST_NAME;
     }
     /**
-     * Converts all the alphabetic characters in a string to uppercase
+     * Whether the name is a middle name.
      */
-    upper() {
-        return this.namon.toUpperCase();
+    get isMiddleName() {
+        return this.type === types_1.Namon.MIDDLE_NAME;
     }
-}
-exports.Name = Name;
-
-
-/***/ }),
-/* 9 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * 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;
 /**
- * First name class definition
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
+ * Representation of a first name with some extra functionality.
  */
-const index_1 = __webpack_require__(1);
+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;
 /**
- * Represents a first name with some extra functionalities
- * @class
- * @extends Name
+ * Representation of a last name with some extra functionality.
  */
-class Firstname extends index_1.Name {
+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;
+    }
     /**
-     * Constructs a `Firstname`
-     * @param {string} namon a piece of string that will be defined as a namon
-     * @param {string[]} [more] additional pieces considered as a given name
+     * The surname inherited from a father side.
      */
-    constructor(namon, more) {
-        super(namon, index_1.Namon.FIRST_NAME);
-        this.namon = namon;
-        this.more = more;
+    get father() {
+        return this.value;
     }
     /**
-     * Gives some descriptive statistics that summarize the central tendency,
-     * dispersion and shape of the characters' distribution.
-     * @param {boolean} includeAll whether to include other pieces of the first
-     * name in the summary
-     * @see {@link describe} in `Namefully` class for further information
+     * The surname inherited from a mother side.
      */
-    describe(includeAll = false) {
-        return new index_1.Summary(this.tostring(includeAll));
+    get mother() {
+        return this._mother;
     }
     /**
-     * Returns a string representation of the first name
-     * @param {boolean} includeAll whether to include other pieces of the first
-     * name
+     * Returns `true` if the mother's surname is defined.
      */
-    tostring(includeAll = false) {
-        return !includeAll ?
-            this.namon :
-            this.namon.concat(index_1.Separator.SPACE, this.more.join(index_1.Separator.SPACE));
+    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);
     }
     /**
-     * Gets the initials of the first name
-     * @returns {Array<string>} the initials
+     * Returns a combined version of the `father` and `mother` if any.
      */
-    getInitials(includeAll = false) {
-        const initials = [this.namon[0]];
-        if (includeAll && Array.isArray(this.more) && this.more.length) {
-            initials.push(...this.more.map(n => n[0]));
+    get asNames() {
+        const names = [Name.last(this.value)];
+        if (this.hasMother) {
+            names.push(Name.last(this._mother));
         }
-        return initials;
+        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.Firstname = Firstname;
+exports.LastName = LastName;
 
 
 /***/ }),
-/* 10 */
+/* 4 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const types_1 = __webpack_require__(0);
+const defaultName = 'default';
+const copyAlias = '_copy';
 /**
- * Last name class definition
+ * The Configuration to use across the other components.
  *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-/**
- * Represents a last name with some extra functionalities
- * @class
- * @extends Name
- */
-class Lastname extends index_1.Name {
-    /**
-     * Constructs a `Lastname`
-     * @param {string} father a piece of string that will be defined as a namon
-     * @param {string} [mother] additional pieces considered as a last name
-     * @param {LastnameFormat} [format] how to output a surname considering its
-     * subparts
-     */
-    constructor(father, mother, format = 'father') {
-        super(father, index_1.Namon.LAST_NAME);
-        this.father = father;
-        this.mother = mother;
-        this.format = format;
+ * 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;
     }
     /**
-     * Gives some descriptive statistics that summarize the central tendency,
-     * dispersion and shape of the characters' distribution.
-     * @param {LastnameFormat} [format] overrides the how-to format of a surname
-     * output, considering its subparts.
-     * @see {@link describe} in `Namefully` class for further information
+     * The order of appearance of a full name.
      */
-    describe(format) {
-        format = format || this.format;
-        return new index_1.Summary(this.tostring(format));
+    get orderedBy() {
+        return this._orderedBy;
     }
     /**
-     * Returns a string representation of the last name
-     * @param {LastnameFormat} [format] overrides the how-to format of a surname
-     * output, considering its subparts.
+     * The token used to indicate how to split string values.
      */
-    tostring(format) {
-        format = format || this.format;
-        switch (format) {
-            case 'father':
-                return this.father;
-            case 'mother':
-                return this.mother || index_1.Separator.EMPTY;
-            case 'hyphenated':
-                return this.mother ? this.father.concat(index_1.Separator.HYPHEN, this.mother) : this.father;
-            case 'all':
-                return this.mother ? this.father.concat(index_1.Separator.SPACE, this.mother) : this.father;
-            // default:
-            //     return this.father;
+    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);
     }
     /**
-     * Gets the initials of the last name
-     * @returns {Array<string>} the initials
+     * 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.
      */
-    getInitials(format) {
-        format = format || this.format;
-        const initials = [];
-        switch (format) {
-            case 'father':
-                initials.push(this.father[0]);
-                break;
-            case 'mother':
-                if (!!this.mother && this.mother.length)
-                    initials.push(this.mother[0]);
-                break;
-            case 'hyphenated':
-            case 'all':
-                initials.push(this.father[0]);
-                if (!!this.mother && this.mother.length)
-                    initials.push(this.mother[0]);
-                break;
+    static merge(other) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!other) {
+            return Config.create();
         }
-        return initials;
+        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.Lastname = Lastname;
+exports.Config = Config;
+/**
+ * Cache for multiple instances.
+ */
+Config.cache = new Map();
 
 
 /***/ }),
-/* 11 */
+/* 5 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
-/**
- * All the enums are listed here
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Enum `Namon` contains the finite set of a representative piece of a name
- * @readonly
- * @enum {string}
- * The word `Namon` is the singular form used to refer to a chunk|part|piece of
- * a name. And the plural form is `Nama`. (Same idea as in criterion/criteria)
- */
-var Namon;
-(function (Namon) {
-    Namon["PREFIX"] = "prefix";
-    Namon["LAST_NAME"] = "lastname";
-    Namon["MIDDLE_NAME"] = "middlename";
-    Namon["FIRST_NAME"] = "firstname";
-    Namon["SUFFIX"] = "suffix";
-})(Namon = exports.Namon || (exports.Namon = {}));
-/**
- * Enum for the prefix values
- * @readonly
- * @enum {string}
- * American and Canadian English follow slightly different rules for abbreviated
- * titles than British and Australian English. In North American English, titles
- * before a name require a period: `Mr., Mrs., Ms., Dr.` In British and Australian
- * English, no full stops are used in these abbreviations.
- */
-var Prefix;
-(function (Prefix) {
-    Prefix["FIRT_LIEUTENANT"] = "1st Lt";
-    Prefix["ADMIRAL"] = "Adm";
-    Prefix["ATTORNEY"] = "Atty";
-    Prefix["BROTHER"] = "Brother";
-    Prefix["CAPTAIN"] = "Capt";
-    Prefix["CHIEF"] = "Chief";
-    Prefix["COMMANDER"] = "Cmdr";
-    Prefix["COLONEL"] = "Col";
-    Prefix["UNI_DEAN"] = "Dean";
-    Prefix["DOCTOR"] = "Dr";
-    Prefix["ELDER"] = "Elder";
-    Prefix["FATHER"] = "Father";
-    Prefix["GENERAL"] = "Gen";
-    Prefix["HONORABLE"] = "Hon";
-    Prefix["LIEUTENANT_COLONEL"] = "Lt Col";
-    Prefix["MAJOR"] = "Maj";
-    Prefix["MASTER_SERGEANT"] = "MSgt";
-    Prefix["MISTER"] = "Mr";
-    Prefix["MARRIED_WOMAN"] = "Mrs";
-    Prefix["SINGLE_WOMAN"] = "Ms";
-    Prefix["PRINCE"] = "Prince";
-    Prefix["PROFESSOR"] = "Prof";
-    Prefix["RABBI"] = "Rabbi";
-    Prefix["REVEREND"] = "Rev";
-    Prefix["SISTER"] = "Sister";
-})(Prefix = exports.Prefix || (exports.Prefix = {}));
-/**
- * Enum for the suffix values
- * @readonly
- * @enum {string}
- */
-var Suffix;
-(function (Suffix) {
-    Suffix["THE_SECOND"] = "II";
-    Suffix["THE_THIRD"] = "III";
-    Suffix["THE_FOURTH"] = "IV";
-    Suffix["CERT_PUB_ACCOUNTANT"] = "CPA";
-    Suffix["DOCTOR_DENTAL_MED"] = "DDS";
-    Suffix["ESQUIRE"] = "Esq";
-    Suffix["JURIST_DOCTOR"] = "JD";
-    Suffix["JUNIOR"] = "Jr";
-    Suffix["DOCTOR_OF_LAWS"] = "LLD";
-    Suffix["DOCTORATE"] = "PhD";
-    Suffix["RETIRED_ARMED_FORCES"] = "Ret";
-    Suffix["REGISTERED_NURSE"] = "RN";
-    Suffix["SENIOR"] = "Sr";
-    Suffix["DOCTOR_OF_OSTEO"] = "DO";
-})(Suffix = exports.Suffix || (exports.Suffix = {}));
-/**
- * Enum for the separator values representing some of the ASCII characters
- * @readonly
- * @enum {string}
- */
-var Separator;
-(function (Separator) {
-    Separator["COLON"] = ":";
-    Separator["COMMA"] = ",";
-    Separator["EMPTY"] = "";
-    Separator["HYPHEN"] = "-";
-    Separator["PERIOD"] = ".";
-    Separator["SPACE"] = " ";
-    Separator["UNDERSCORE"] = "_";
-})(Separator = exports.Separator || (exports.Separator = {}));
+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',
+    '$',
+];
 
 
 /***/ }),
-/* 12 */
+/* 6 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Summary of descriptive stats of the name
+exports.FullName = void 0;
+const config_1 = __webpack_require__(4);
+const error_1 = __webpack_require__(1);
+const name_1 = __webpack_require__(3);
+const types_1 = __webpack_require__(0);
+const validator_1 = __webpack_require__(7);
+/**
+ * The core component of this utility.
  *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-/**
- * Represents the statistical summary of a string representation
- * @class
+ * 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 Summary {
+class FullName {
     /**
-     * Creates a `Summary` of a given string of alphabetical characters
-     * @param namon piece of name
-     * @param restrictions a set of undesired characters
+     * Creates a full name as it goes
+     * @param options optional configuration for additional features.
      */
-    constructor(namon, restrictions = [index_1.Separator.SPACE]) {
-        this.namon = namon;
-        this.compute(restrictions);
+    constructor(options) {
+        this._middleName = [];
+        this._config = config_1.Config.merge(options);
     }
     /**
-     * Returns a string representation of the summary
+     * A snapshot of the configuration used to set up this full name.
      */
-    tostring() {
-        return index_1.Separator.EMPTY.concat(`Descriptive statistics for "${this.namon}" \n`, `count    : ${this.count} \n`, `frequency: ${this.frequency} \n`, `top      : ${this.top} \n`, `unique   : ${this.unique} \n`);
+    get config() {
+        return this._config;
     }
-    compute(restrictions = []) {
-        // compute stats for the string
-        let count = 0, maxfreq = 0, uniq = 0, top = '';
-        const freqs = this.groupByChar();
-        for (const char in freqs) {
-            if (restrictions.indexOf(char) === -1) {
-                count += freqs[char];
-                if (freqs[char] >= maxfreq) {
-                    maxfreq = freqs[char];
-                    top = char;
-                }
-                uniq++;
+    /**
+     * 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;
+    }
+    /**
+     * 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,
+                });
             }
         }
-        this.count = count;
-        this.frequency = maxfreq;
-        this.top = top;
-        this.unique = uniq;
     }
-    groupByChar() {
-        const frequencies = {};
-        for (const char of this.namon.toUpperCase())
-            if (Object.keys(frequencies).includes(char))
-                frequencies[char] += 1;
-            else
-                frequencies[char] = 1;
-        return frequencies;
+    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;
     }
 }
-exports.Summary = Summary;
+exports.FullName = FullName;
 
 
 /***/ }),
-/* 13 */
+/* 7 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
-/**
- * Validation rules
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validators = exports.ArrayNameValidator = exports.ArrayStringValidator = exports.NamaValidator = void 0;
+const constants_1 = __webpack_require__(5);
+const error_1 = __webpack_require__(1);
+const name_1 = __webpack_require__(3);
+const types_1 = __webpack_require__(0);
+const utils_1 = __webpack_require__(2);
 /**
  * Represents a set of validation rules (regex)
- * @class
- * @static
  *
  * 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,
@@ -1546,30 +1380,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
  *  [\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)
- *  [\u04FFΆ-ωΑ-ώ]: Greek alphabet from Ά (index 902) to ω (index 969)
+ *  [Ά-ωΑ-ώ]: Greek alphabet from Ά (index 902) to ω (index 969)
  */
 class ValidationRule {
 }
-exports.ValidationRule = 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
- */
-ValidationRule.namon = /^[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]+((['-][a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ])?[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]*)*$/;
-/**
- * Matches 1+ name parts (namon) that are of nature:
- * - Latin (English, Spanish, French, etc.)
- * - European (Greek, Cyrillic, Icelandic, German)
- * - hyphenated
- * - with apostrophe
- * - with comma
- * - with period
  * - with space
  */
-ValidationRule.fullname = /^[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]+(([',. -][a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ ])?[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]*)*$/;
+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.)
@@ -1577,7 +1401,7 @@ ValidationRule.fullname = /^[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400
  * - hyphenated
  * - with apostrophe
  */
-ValidationRule.firstname = /^[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]+((['-][a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ])?[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]*)*$/;
+ValidationRule.firstName = ValidationRule.namon;
 /**
  * Matches 1+ names part (namon) that are of nature:
  * - Latin (English, Spanish, French, etc.)
@@ -1586,979 +1410,1235 @@ ValidationRule.firstname = /^[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u040
  * - with apostrophe
  * - with space
  */
-ValidationRule.middlename = /^[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]+(([' -][a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ])?[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]*)*$/;
+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 = /^[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]+((['-][a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ])?[a-zA-Z\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff\u0400-\u04FFΆ-ωΑ-ώ]*)*$/;
-
-
-/***/ }),
-/* 14 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-/**
- * Validation types
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Enum for the validation types
- * @enum
- */
-var ValidatorType;
-(function (ValidatorType) {
-    ValidatorType[ValidatorType["NONE"] = 0] = "NONE";
-    ValidatorType[ValidatorType["NAMON"] = 1] = "NAMON";
-    ValidatorType[ValidatorType["NAMA"] = 2] = "NAMA";
-    ValidatorType[ValidatorType["ARR_NAMES"] = 3] = "ARR_NAMES";
-    ValidatorType[ValidatorType["ARR_STRING"] = 4] = "ARR_STRING";
-    ValidatorType[ValidatorType["FULL_NAME"] = 5] = "FULL_NAME";
-    ValidatorType[ValidatorType["PREFIX"] = 6] = "PREFIX";
-    ValidatorType[ValidatorType["FIRST_NAME"] = 7] = "FIRST_NAME";
-    ValidatorType[ValidatorType["MIDDLE_NAME"] = 8] = "MIDDLE_NAME";
-    ValidatorType[ValidatorType["LAST_NAME"] = 9] = "LAST_NAME";
-    ValidatorType[ValidatorType["SUFFIX"] = 10] = "SUFFIX";
-    ValidatorType[ValidatorType["CUSTOM"] = 11] = "CUSTOM";
-})(ValidatorType = exports.ValidatorType || (exports.ValidatorType = {}));
-
-
-/***/ }),
-/* 15 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-/**
- * Validation error
- *
- * Created on March 06, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Represents a validation error
- * @class
- * @extends Error
- */
-class ValidationError extends Error {
-    /**
-     * Create a validation `Error`
-     * @param message of error to display
-     * @param type categorizes the error
-     */
-    constructor(message, type) {
-        super(`${type ? type + ' :: ' + message : message}`);
-        this.name = 'ValidationError';
+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`,
+            });
+        }
     }
 }
-exports.ValidationError = ValidationError;
-
-
-/***/ }),
-/* 16 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Namon validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(0);
-/**
- * Represents a namon validator to help to parse single pieces of string
- * @class
- * @implements {Validator}
- */
 class NamonValidator {
-    constructor() {
-        this.type = index_1.ValidatorType.NAMON;
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
     }
-    /**
-     * Validates the content of a name
-     * @param {string} value data to validate
-     */
-    validate(value) {
-        if (!index_1.ValidationRule.namon.test(value))
-            throw new index_1.ValidationError(`invalid string content '${value}'`, 'Name');
-    }
-}
-exports.default = NamonValidator;
-
-
-/***/ }),
-/* 17 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Prefix validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-/**
- * Represents a prefix validator
- * @class
- * @implements {Validator}
- */
-class PrefixValidator {
-    constructor() {
-        this.type = index_2.ValidatorType.PREFIX;
-    }
-    /**
-     * Validates the content of a prefix name
-     * @param {string} value data to validate
-     */
-    validate(value) {
-        const prefixes = Object.entries(index_1.Prefix).map(e => e[1].toLowerCase()); // values
-        if (prefixes.indexOf(value.toLowerCase()) === -1)
-            throw new index_2.ValidationError(`unknown value '${value}'`, 'Prefix');
+    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',
+            });
+        }
     }
 }
-exports.default = PrefixValidator;
-
-
-/***/ }),
-/* 18 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Suffix validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-/**
- * Represents a suffix validator
- * @class
- * @implements {Validator}
- */
-class SuffixValidator {
-    constructor() {
-        this.type = index_2.ValidatorType.SUFFIX;
+class FirstNameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
     }
-    /**
-     * Validates the content of a suffix name
-     * @param {string} value data to validate
-     */
     validate(value) {
-        const suffixes = Object.entries(index_1.Suffix).map(e => e[1].toLowerCase()); // values
-        if (suffixes.indexOf(value.toLowerCase()) === -1)
-            throw new index_2.ValidationError(`unknown value '${value}'`, 'Suffix');
+        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',
+            });
+        }
     }
 }
-exports.default = SuffixValidator;
-
-
-/***/ }),
-/* 19 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * First name validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(0);
-/**
- * Represents a first name validator
- * @class
- * @implements {Validator}
- */
-class FirstnameValidator {
-    constructor() {
-        this.type = index_1.ValidatorType.FIRST_NAME;
+class MiddleNameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
     }
-    /**
-     * Validates the content of a first name
-     * @param {string} value data to validate
-     */
     validate(value) {
-        if (!index_1.ValidationRule.firstname.test(value))
-            throw new index_1.ValidationError(`invalid string content '${value}'`, 'First name');
+        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 (const 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[]',
+            });
+        }
     }
 }
-exports.default = FirstnameValidator;
-
-
-/***/ }),
-/* 20 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Last name validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(0);
-/**
- * Represents a last name validator
- * @class
- * @implements {Validator}
- */
-class LastnameValidator {
-    constructor() {
-        this.type = index_1.ValidatorType.LAST_NAME;
+class LastNameValidator {
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
     }
-    /**
-     * Validates the content of a last name
-     * @param {string} value data to validate
-     */
     validate(value) {
-        if (!index_1.ValidationRule.lastname.test(value))
-            throw new index_1.ValidationError(`invalid string content '${value}'`, 'Last name');
-    }
-}
-exports.default = LastnameValidator;
-
-
-/***/ }),
-/* 21 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Middle name validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(0);
-/**
- * Represents a middle name validator
- * @class
- * @implements {Validator}
- */
-class MiddlenameValidator {
-    constructor() {
-        this.type = index_1.ValidatorType.MIDDLE_NAME;
-    }
-    /**
-     * Validates the content of a list of middle names
-     * @param {string | Array<string>} values to validate
-     */
-    validate(values) {
-        if (typeof values === 'string') {
-            if (!index_1.ValidationRule.middlename.test(values))
-                throw new index_1.ValidationError(`invalid string content '${values}'`, 'Middle name');
+        if (value instanceof name_1.LastName) {
+            value.asNames.forEach((name) => this.validate(name.value));
         }
-        else if (values instanceof Array) {
-            const namonValidator = new index_1.NamonValidator();
-            values.forEach(v => namonValidator.validate(v));
+        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('Expecting string or Array<string> type');
+            throw new error_1.InputError({
+                source: typeof value,
+                message: 'expecting types string | LastName',
+            });
         }
     }
 }
-exports.default = MiddlenameValidator;
-
-
-/***/ }),
-/* 22 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * `Fullname` validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-/**
- * Represents a `Fullname` (JSON signature) validator for provided custom parser
- * @class
- * @implements {Validator}
- */
-class FullnameValidator {
-    constructor() {
-        this.type = index_2.ValidatorType.FULL_NAME;
-    }
-    /**
-     * Validates that the `Fullname` contract is met
-     * @param {Fullname} value data to validate
-     */
-    validate(v) {
-        if (!v.firstname || !(v.firstname instanceof index_1.Firstname))
-            throw new index_2.ValidationError('first name is corrupted', 'Fullname');
-        if (!v.lastname || !(v.lastname instanceof index_1.Lastname))
-            throw new index_2.ValidationError('last name is corrupted', 'Fullname');
-        if (v.middlename && !(v.middlename instanceof Array))
-            throw new index_2.ValidationError('middle name is corrupted', 'Fullname');
-        if (v.prefix)
-            new index_2.PrefixValidator().validate(v.prefix);
-        if (v.suffix)
-            new index_2.SuffixValidator().validate(v.suffix);
+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',
+            });
+        }
     }
 }
-exports.default = FullnameValidator;
-
-
-/***/ }),
-/* 23 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Nama validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-/**
- * Represents a `Nama` validator to help the nama parser
- * @class
- * @implements {Validator}
- */
 class NamaValidator {
-    constructor() {
-        this.type = index_2.ValidatorType.NAMA;
+    constructor() { }
+    static create() {
+        return this.validator || (this.validator = new this());
     }
-    /**
-     * Validates the content of a JSON-formatted names
-     * @param {string} value data to validate
-     */
     validate(value) {
-        const entries = Object.entries(value);
-        if (entries.length <= 1 && entries.length > 5)
-            throw new index_2.ValidationError('incomplete JSON object', 'Nama');
-        const validators = {
-            [index_1.Namon.PREFIX]: new index_2.PrefixValidator(),
-            [index_1.Namon.FIRST_NAME]: new index_2.FirstnameValidator(),
-            [index_1.Namon.MIDDLE_NAME]: new index_2.MiddlenameValidator(),
-            [index_1.Namon.LAST_NAME]: new index_2.LastnameValidator(),
-            [index_1.Namon.SUFFIX]: new index_2.SuffixValidator(),
-        };
-        for (const entry of entries) {
-            const k = entry[0];
-            const v = entry[1];
-            validators[k].validate(v);
+        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.default = NamaValidator;
-
-
-/***/ }),
-/* 24 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Array of `Name` validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-/**
- * Represents a validator to help the array `Name` parser
- * @class
- * @classdesc
- * This validator validates a array of `Name` objects following a specific order
- * based on the count of elements. It is expected that the array has to be
- * between two and five elements.
- *
- */
-class ArrayNameValidator {
-    constructor() {
-        this.type = index_2.ValidatorType.ARR_NAMES;
+exports.NamaValidator = NamaValidator;
+class ArrayStringValidator extends ArrayValidator {
+    constructor(index = utils_1.NameIndex.base()) {
+        super();
+        this.index = index;
     }
-    /**
-     * Validates the content of a set of custom `Name`s
-     * @param {Array<Name>} value data to validate
-     */
     validate(values) {
-        if (values.length <= 1 || values.length > 5) {
-            throw new index_2.ValidationError(`must be an array of 2 - 5 'Name's`, 'Array of Names');
-        }
-        const validators = {
-            [index_1.Namon.PREFIX]: new index_2.PrefixValidator(),
-            [index_1.Namon.FIRST_NAME]: new index_2.FirstnameValidator(),
-            [index_1.Namon.MIDDLE_NAME]: new index_2.MiddlenameValidator(),
-            [index_1.Namon.LAST_NAME]: new index_2.LastnameValidator(),
-            [index_1.Namon.SUFFIX]: new index_2.SuffixValidator(),
-        };
+        this.validateIndex(values);
         switch (values.length) {
-            case 2: // first name + last name
-                values.forEach(n => {
-                    if (![index_1.Namon.FIRST_NAME, index_1.Namon.LAST_NAME].includes(n.type))
-                        throw new index_2.ValidationError('Both first and last names are required');
-                    if (n.type === index_1.Namon.LAST_NAME && n instanceof index_1.Lastname)
-                        validators[n.type].validate(n.mother);
-                    validators[n.type].validate(n.namon);
-                });
+            case 2:
+                Validators.firstName.validate(values[this.index.firstName]);
+                Validators.lastName.validate(values[this.index.lastName]);
                 break;
-            case 3: // first name + middle name + last name
-                values.forEach(n => {
-                    if (![index_1.Namon.FIRST_NAME, index_1.Namon.MIDDLE_NAME, index_1.Namon.LAST_NAME].includes(n.type))
-                        throw new index_2.ValidationError('First, middle and last names are required');
-                    if (n.type === index_1.Namon.LAST_NAME && n instanceof index_1.Lastname)
-                        validators[n.type].validate(n.mother);
-                    validators[n.type].validate(n.namon);
-                });
+            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: // first name + middle name + last name
-                values.forEach(n => {
-                    if (![index_1.Namon.PREFIX, index_1.Namon.FIRST_NAME, index_1.Namon.MIDDLE_NAME,
-                        index_1.Namon.LAST_NAME].includes(n.type))
-                        throw new index_2.ValidationError('More fields are required');
-                    if (n.type === index_1.Namon.LAST_NAME && n instanceof index_1.Lastname)
-                        validators[n.type].validate(n.mother);
-                    validators[n.type].validate(n.namon);
-                });
+            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: // first name + middle name + last name
-                values.forEach(n => {
-                    if (![index_1.Namon.PREFIX, index_1.Namon.FIRST_NAME, index_1.Namon.MIDDLE_NAME, index_1.Namon.LAST_NAME,
-                        index_1.Namon.SUFFIX].includes(n.type))
-                        throw new index_2.ValidationError('More fields are required');
-                    if (n.type === index_1.Namon.LAST_NAME && n instanceof index_1.Lastname)
-                        validators[n.type].validate(n.mother);
-                    validators[n.type].validate(n.namon);
-                });
+            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.default = ArrayNameValidator;
+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();
 
 
 /***/ }),
-/* 25 */
+/* 8 */
 /***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Array of string validator
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(0);
-/**
- * Represents a validator to help the array string parser
- * @class
- * @classdesc
- * This validator validates an array of string name following a specific order
- * based on the count of elements. It is expected that the array has to be between
- * two and five elements. Also, the order of appearance set in the configuration
- * influences how this validation is carried out.
- *
- * Ordered by first name, the validator validates the following:
- * - 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 validator validates the following:
- * - 2 elements: lastname firstname
- * - 3 elements: lastname firstname middlename
- * - 4 elements: prefix lastname firstname middlename
- * - 5 elements: prefix lastname firstname middlename suffix
- */
-class ArrayStringValidator {
+exports.ArrayNameParser = exports.NamaParser = exports.ArrayStringParser = exports.StringParser = exports.Parser = void 0;
+const full_name_1 = __webpack_require__(6);
+const config_1 = __webpack_require__(4);
+const utils_1 = __webpack_require__(2);
+const validator_1 = __webpack_require__(7);
+const name_1 = __webpack_require__(3);
+const types_1 = __webpack_require__(0);
+const error_1 = __webpack_require__(1);
+/**
+ * A parser signature that helps to organize the names accordingly.
+ */
+class Parser {
     /**
-     * Creates an instance of the validator
-     * @param indexing how to index the name parts
+     * Constructs a custom parser accordingly.
+     * @param raw data to be parsed
      */
-    constructor(indexing) {
-        this.indexing = indexing;
-        this.type = index_1.ValidatorType.ARR_STRING;
+    constructor(raw) {
+        this.raw = raw;
     }
     /**
-     * Validates the content of a name
-     * @param {string} value data to validate
+     * 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.
      */
-    validate(values) {
-        if (values.length <= 1 || values.length > 5)
-            throw new index_1.ValidationError('must be an array of 2 - 5 elements', 'Array of names');
-        const pf = new index_1.PrefixValidator();
-        const sf = new index_1.SuffixValidator();
-        const fn = new index_1.FirstnameValidator();
-        const ln = new index_1.LastnameValidator();
-        const mn = new index_1.MiddlenameValidator();
-        const index = this.indexing;
-        switch (values.length) {
+    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:
-                fn.validate(values[index.firstname]);
-                ln.validate(values[index.lastname]);
+                fullName.setFirstName(new name_1.FirstName(raw[index.firstName]));
+                fullName.setLastName(new name_1.LastName(raw[index.lastName]));
                 break;
             case 3:
-                fn.validate(values[index.firstname]);
-                mn.validate(values[index.middlename]);
-                ln.validate(values[index.lastname]);
+                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:
-                pf.validate(values[index.prefix]);
-                fn.validate(values[index.firstname]);
-                mn.validate(values[index.middlename]);
-                ln.validate(values[index.lastname]);
+                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:
-                pf.validate(values[index.prefix]);
-                fn.validate(values[index.firstname]);
-                mn.validate(values[index.middlename]);
-                ln.validate(values[index.lastname]);
-                sf.validate(values[index.suffix]);
+                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 (const 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.default = ArrayStringValidator;
+exports.ArrayNameParser = ArrayNameParser;
 
 
 /***/ }),
-/* 26 */
+/* 9 */
 /***/ (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 });
 /**
- * String of full name validator
+ * Welcome to namefully!
  *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(0);
-/**
- * Represents a string full name validator
- * @class
- * @implements {Validator}
+ * `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
  */
-class StringNameValidator {
-    constructor() {
-        this.type = index_1.ValidatorType.FULL_NAME;
-    }
-    /**
-     * Validates the content of a name
-     * @param {string} value data to validate
-     */
-    validate(value) {
-        if (!index_1.ValidationRule.fullname.test(value))
-            throw new index_1.ValidationError(`invalid string content '${value}'`, 'Full name');
-    }
-}
-exports.default = StringNameValidator;
+__exportStar(__webpack_require__(4), exports);
+__exportStar(__webpack_require__(1), exports);
+__exportStar(__webpack_require__(6), exports);
+__exportStar(__webpack_require__(3), exports);
+__exportStar(__webpack_require__(10), exports);
+var parser_1 = __webpack_require__(8);
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
+__exportStar(__webpack_require__(0), exports);
+var utils_1 = __webpack_require__(2);
+Object.defineProperty(exports, "NameIndex", { enumerable: true, get: function () { return utils_1.NameIndex; } });
 
 
 /***/ }),
-/* 27 */
+/* 10 */
 /***/ (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 });
-/**
- * An array of string parser
+exports.Namefully = void 0;
+const config_1 = __webpack_require__(4);
+const constants_1 = __webpack_require__(5);
+const error_1 = __webpack_require__(1);
+const parser_1 = __webpack_require__(8);
+const types_1 = __webpack_require__(0);
+const utils_1 = __webpack_require__(2);
+/**
+ * A helper for organizing person names in a particular order, way, or shape.
  *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-const index_3 = __webpack_require__(3);
-/**
- * Represents an array string parser
- * @class
- * @implements {Parser<string[]>}
- * @classdesc
- * This parser parses an array of string name following a specific order based
- * on the count of elements. It is expected that the array has to be between two
- * and five elements. Also, the order of appearance set in the configuration
- * influences how this parsing is carried out.
+ * 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.
  *
- * 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
+ * `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.
  *
- * 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
+ * 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 ArrayStringParser {
+class Namefully {
     /**
-     * Create a parser ready to parse the raw data
-     * @param {Array<string>} raw data
+     * 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(raw) {
-        this.raw = raw;
+    constructor(names, options) {
+        this.build(this.toParser(names), options);
     }
     /**
-     * Parses the raw data into a full name
-     * @returns {Fullname}
+     * Constructs a `Namefully` instance from a text.
+     *
+     * It works like `parse` except that this function returns `null` where `parse`
+     * would throw a `NameError`.
      */
-    parse(options) {
-        // given this setting
-        const { orderedBy, bypass } = options;
-        // validate first
-        const raw = this.raw.map(n => n.trim()); // cleanup
-        const index = index_3.organizeNameIndex(orderedBy, raw.length);
-        if (!bypass)
-            new index_2.ArrayStringValidator(index).validate(raw);
-        // then distribute all the elements accordingly
-        const fullname = this.distribute(raw, index);
-        // finally return high quality of data
-        return fullname;
-    }
-    distribute(raw, index) {
-        const fullname = {
-            firstname: null,
-            lastname: null,
-            middlename: [],
-            prefix: null,
-            suffix: null,
-        };
-        switch (raw.length) {
-            case 2: // first name + last name
-                fullname.firstname = new index_1.Firstname(raw[index.firstname]);
-                fullname.lastname = new index_1.Lastname(raw[index.lastname]);
-                break;
-            case 3: // first name + middle name + last name
-                fullname.firstname = new index_1.Firstname(raw[index.firstname]);
-                fullname.middlename.push(new index_1.Name(raw[index.middlename], index_1.Namon.MIDDLE_NAME));
-                fullname.lastname = new index_1.Lastname(raw[index.lastname]);
-                break;
-            case 4: // prefix + first name + middle name + last name
-                fullname.prefix = raw[index.prefix];
-                fullname.firstname = new index_1.Firstname(raw[index.firstname]);
-                fullname.middlename.push(new index_1.Name(raw[index.middlename], index_1.Namon.MIDDLE_NAME));
-                fullname.lastname = new index_1.Lastname(raw[index.lastname]);
-                break;
-            case 5: // prefix + first name + middle name + last name + suffix
-                fullname.prefix = raw[index.prefix];
-                fullname.firstname = new index_1.Firstname(raw[index.firstname]);
-                fullname.middlename.push(new index_1.Name(raw[index.middlename], index_1.Namon.MIDDLE_NAME));
-                fullname.lastname = new index_1.Lastname(raw[index.lastname]);
-                fullname.suffix = raw[index.suffix];
-                break;
+    static tryParse(text) {
+        try {
+            return new this(parser_1.Parser.build(text));
+        }
+        catch (error) {
+            return undefined;
         }
-        return fullname;
     }
-}
-exports.default = ArrayStringParser;
-
-
-/***/ }),
-/* 28 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * A `Nama` (JSON signature) parser
- *
- * Created on March 15, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-const index_2 = __webpack_require__(0);
-/**
- * Represents a `Nama` parser
- * @class
- * @implements {Parser<Nama>}
- * @classdesc
- * This parser parses a JSON signature of the name parts provided as string
- * values. This is to facilitate a developer's life that holds users' info in a
- * JSON format. In other words, the developer only needs to provide similar info
- * and the rest will follow.
- */
-class NamaParser {
     /**
-     * Create a parser ready to parse the raw data
-     * @param {Nama} raw data as JSON object
+     * 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.
      */
-    constructor(raw) {
-        this.raw = raw;
+    static parse(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return parser_1.Parser.buildAsync(text).then((parser) => new Namefully(parser));
+        });
     }
     /**
-     * Parses the raw data into a full name
-     * @returns {Fullname}
+     * The current configuration.
      */
-    parse(options) {
-        // validate first
-        if (!options.bypass)
-            new index_2.NamaValidator().validate(this.raw);
-        // then distribute all the elements accordingly
-        const fullname = this.distribute();
-        // finally return high quality of data
-        return fullname;
-    }
-    distribute() {
-        const fullname = {
-            firstname: null,
-            lastname: null,
-            middlename: [],
-            prefix: null,
-            suffix: null,
+    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,
         };
-        for (const entry of Object.entries(this.raw)) {
-            const key = entry[0];
-            const value = entry[1];
-            switch (key) {
-                case index_1.Namon.FIRST_NAME:
-                    fullname.firstname = new index_1.Firstname(value);
+    }
+    /**
+     * 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:
+     * ```ts
+     * 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 index_1.Namon.LAST_NAME:
-                    fullname.lastname = new index_1.Lastname(value);
+                case types_1.Flat.LAST_NAME:
+                    name = hasMid ? [fn, mn, l] : [fn, l];
                     break;
-                case index_1.Namon.MIDDLE_NAME:
-                    fullname.middlename.push(new index_1.Name(value, index_1.Namon.MIDDLE_NAME));
+                case types_1.Flat.MIDDLE_NAME:
+                    name = hasMid ? [fn, m, ln] : [fn, ln];
                     break;
-                case index_1.Namon.PREFIX:
-                    fullname.prefix = value;
+                case types_1.Flat.FIRST_MID:
+                    name = hasMid ? [f, m, ln] : [f, ln];
                     break;
-                case index_1.Namon.SUFFIX:
-                    fullname.suffix = value;
+                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;
             }
         }
-        return fullname;
+        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;
     }
-}
-exports.default = NamaParser;
-
-
-/***/ }),
-/* 29 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = __webpack_require__(4);
-/**
- * Represents a string parser
- * @class
- * @implements {Parser}
- * @classdesc
- * This parser parses a string name using a separator, if set, or simply using
- * the space character <' '> as a basis for the split.
- *
- * **NOTE**:
- * A string name is basically a string type containing the name parts differentiated
- * with the help of a separator. The default separator is the character <space>
- * or <' '>. However, it can be very, very helpful to use a distinct separator
- * (e.g., a colon <:>) to handle multiple names for a `Namon`. That is to say,
- * a piece of name shaped as `De La Cruz` is a last name that needs to be handled
- * as a whole, and therefore requires that a different type of separator to split
- * up the name parts. Alternatively, the `ArrayStringParser` can be used by indicating
- * specifically which part of the name is what. Do note that this parser is actually
- * a wrapper of the `ArrayStringParser`.
- *
- * @example
- * Given the name `Maria De La Cruz`, using this parser without indicating a
- * separator different than <space> will definitely throw an error. So, if the proper
- * proper of doing when `De La Cruz` is the last name:
- * ```
- *  > const name = new Namefully('Maria:De La Cruz', { separator: Separator.COLON })
- *  > console.log(name.getLastname())
- *  De La Cruz
- * ```
- * Or
- * ```
- *  > const name = new Namefully(['Maria', 'De La Cruz'])
- *  > console.log(name.getLastname())
- *  De La Cruz
- * ```
- */
-class StringParser {
     /**
-     * Create a parser ready to parse the raw data
-     * @param {string} raw data as a string representation
+     * Zips or compacts a name using different forms of variants.
+     *
+     * @see `flatten()` for more details.
      */
-    constructor(raw) {
-        this.raw = raw;
+    zip(by = types_1.Flat.MID_LAST, withPeriod = true) {
+        return this.flatten({ limit: 0, by, withPeriod });
     }
     /**
-     * Parses the raw data into a full name
-     * @param options how to parse
-     * @returns {Fullname}
+     * 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.
      */
-    parse(options) {
-        // given this setting
-        const { orderedBy, separator, bypass } = options;
-        // then distribute all the elements accordingly
-        const nama = this.raw.split(separator);
-        const fullname = new index_1.ArrayStringParser(nama).parse({ orderedBy, bypass });
-        // finally return high quality of data
-        return fullname;
+    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();
     }
-}
-exports.default = StringParser;
-
-
-/***/ }),
-/* 30 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = __webpack_require__(3);
-/**
- * Reorganizes the existing global indexes for array of name parts
- * @param orderedBy by first or last name
- * @param argLength length of the provided array
- * @param nameIndex global preset of indexing
- */
-function organizeNameIndex(orderedBy, argLength, nameIndex = core_1.NAME_INDEX) {
-    const out = Object.assign({}, nameIndex);
-    if (orderedBy === 'firstname') {
-        switch (argLength) {
-            case 2: // first name + last name
-                out.firstname = 0;
-                out.lastname = 1;
-                break;
-            case 3: // first name + middle name + last name
-                out.firstname = 0;
-                out.middlename = 1;
-                out.lastname = 2;
-                break;
-            case 4: // prefix + first name + middle name + last name
-                out.prefix = 0;
-                out.firstname = 1;
-                out.middlename = 2;
-                out.lastname = 3;
-                break;
-            case 5: // prefix + first name + middle name + last name + suffix
-                out.prefix = 0;
-                out.firstname = 1;
-                out.middlename = 2;
-                out.lastname = 3;
-                out.suffix = 4;
-                break;
+    /**
+     * 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}`);
         }
     }
-    else {
-        switch (argLength) {
-            case 2: // last name + first name
-                out.lastname = 0;
-                out.firstname = 1;
-                break;
-            case 3: // last name + first name + middle name
-                out.lastname = 0;
-                out.firstname = 1;
-                out.middlename = 2;
-                break;
-            case 4: // prefix + last name + first name + middle name
-                out.prefix = 0;
-                out.lastname = 1;
-                out.firstname = 2;
-                out.middlename = 3;
-                break;
-            case 5: // prefix + last name + first name + middle name + suffix
-                out.prefix = 0;
-                out.lastname = 1;
-                out.firstname = 2;
-                out.middlename = 3;
-                out.suffix = 4;
-                break;
+    /**
+     * 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.hasMiddle ? this.middle[0] : undefined;
+            default:
+                return undefined;
         }
     }
-    return out;
 }
-exports.organizeNameIndex = organizeNameIndex;
-
-
-/***/ }),
-/* 31 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Constants
- *
- * Created on March 07, 2020
- * @author Ralph Florent <ralflornt@gmail.com>
- */
-const index_1 = __webpack_require__(1);
-/**
- * The current version of `Namefully`.
- * @constant
- */
-exports.version = '1.0.9';
-/**
- * CONFIG constant
- * @constant
- * @type {Config}
- * @default
- */
-exports.CONFIG = {
-    orderedBy: 'firstname',
-    separator: index_1.Separator.SPACE,
-    titling: 'uk',
-    ending: index_1.Separator.SPACE,
-    bypass: false,
-    lastnameFormat: 'father',
-};
-/**
- * NAME_INDEX constant
- * @constant
- * @type {NameIndex}
- * @default
- */
-exports.NAME_INDEX = {
-    prefix: 0,
-    firstname: 1,
-    middlename: 2,
-    lastname: 3,
-    suffix: 4,
-};
+exports.Namefully = Namefully;
 
 
 /***/ })