namefully 2.0.0 → 2.0.2

package/dist/esm/name.js

@@ -40,19 +40,19 @@ export class Name {
         return this.type === Namon.SUFFIX;
     }
     static prefix(value) {
-        return new this(value, Namon.PREFIX);
+        return new Name(value, Namon.PREFIX);
     }
     static first(value) {
-        return new this(value, Namon.FIRST_NAME);
+        return new Name(value, Namon.FIRST_NAME);
     }
     static middle(value) {
-        return new this(value, Namon.MIDDLE_NAME);
+        return new Name(value, Namon.MIDDLE_NAME);
     }
     static last(value) {
-        return new this(value, Namon.LAST_NAME);
+        return new Name(value, Namon.LAST_NAME);
     }
     static suffix(value) {
-        return new this(value, Namon.SUFFIX);
+        return new Name(value, Namon.SUFFIX);
     }
     initials() {
         return [this.initial];
@@ -72,8 +72,8 @@ export class Name {
         return this;
     }
     validate(name) {
-        if (name && name?.trim()?.length < 2) {
-            throw new InputError({ source: name, message: 'must be 2+ characters' });
+        if (typeof name === 'string' && name.trim().length < 1) {
+            throw new InputError({ source: name, message: 'must be 1+ characters' });
         }
     }
 }
@@ -81,7 +81,7 @@ export class FirstName extends Name {
     #more;
     constructor(value, ...more) {
         super(value, Namon.FIRST_NAME);
-        more.forEach((n) => this.validate(n));
+        more.forEach(this.validate);
         this.#more = more;
     }
     get hasMore() {
@@ -92,9 +92,8 @@ export class FirstName extends Name {
     }
     get asNames() {
         const names = [Name.first(this.value)];
-        if (this.hasMore) {
-            names.push(...this.#more.map((n) => Name.first(n)));
-        }
+        if (this.hasMore)
+            names.push(...this.#more.map(Name.first));
         return names;
     }
     get more() {
@@ -105,9 +104,8 @@ export class FirstName extends Name {
     }
     initials(withMore = false) {
         const inits = [this.initial];
-        if (withMore && this.hasMore) {
+        if (withMore && this.hasMore)
             inits.push(...this.#more.map((n) => n[0]));
-        }
         return inits;
     }
     caps(range) {
@@ -169,34 +167,32 @@ export class LastName extends Name {
         }
     }
     initials(format) {
-        format = format || this.format;
         const inits = [];
-        switch (format) {
-            case Surname.MOTHER:
-                if (this.#mother)
-                    inits.push(this.#mother[0]);
-                break;
+        switch (format ?? this.format) {
             case Surname.HYPHENATED:
             case Surname.ALL:
                 inits.push(this.initial);
                 if (this.#mother)
                     inits.push(this.#mother[0]);
                 break;
-            case Surname.FATHER:
+            case Surname.MOTHER:
+                if (this.#mother)
+                    inits.push(this.#mother[0]);
+                break;
             default:
                 inits.push(this.initial);
         }
         return inits;
     }
     caps(range) {
-        range = range || this.capsRange;
+        range ??= this.capsRange;
         this.value = capitalize(this.value, range);
         if (this.hasMother)
             this.#mother = capitalize(this.#mother, range);
         return this;
     }
     decaps(range) {
-        range = range || this.capsRange;
+        range ??= this.capsRange;
         this.value = decapitalize(this.value, range);
         if (this.hasMother)
             this.#mother = decapitalize(this.#mother, range);

package/dist/esm/namefully.d.ts

@@ -1,74 +1,76 @@
 import { Config } from './config.js';
 import { Name, JsonName } from './name.js';
-import { Parser } from './parser.js';
 import { Flat, NameOrder, NameType, Namon, Nullable, Surname } from './types.js';
 import { NameIndex } from './utils.js';
+import { Parser } from './parser.js';
 /**
- * A helper for organizing person names in a particular order, way, or shape.
+ * A utility for organizing human names in a particular order, way, or shape.
  *
- * Though `namefully` is easy to use, it does not magically guess which part of
- * the name is what (prefix, suffix, first, last, or middle names). It relies
- * actually on how the name parts are indicated (i.e., their roles) so that
- * it can perform internally certain operations and saves us some extra
- * calculations/processing. In addition, `Namefully` can be created using
- * distinct raw data shapes. This is intended to give some flexibility to the
- * developer so that he or she is not bound to a particular data format.
- * By following closely the API reference to know how to harness its usability,
- * this utility aims to save time in formatting names.
+ * Though `namefully` is designed to be 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. Additionally, `Namefully` objects may be created using
+ * distinct raw data shapes. This is intended to give some flexibility to you
+ * so that you are not bound to a particular data format (e.g., string).
+ * Follow the API reference to know how to harness its usability as this utility
+ * aims to save time in formatting names.
  *
- * `namefully` also works like a trapdoor. Once a raw data is provided and
- * validated, a developer can only *access* in a vast amount of, yet effective
- * ways the name info. *No editing* is possible. If the name is mistaken, a new
- * instance of `Namefully` must be created. In other words, it's immutable.
- * Remember, this utility's primary objective is to help manipulate a person name.
+ * `namefully` also works like a trapdoor. Once some name data is provided and
+ * validated, you may only *access* it but not update any part of it. This
+ * means that *no editing* is possible. If the name is mistaken, a new
+ * instance of `Namefully` must be created. In simple terms, it's immutable.
+ * Remember, this utility's primary objective is to help manipulate human names,
+ * not the opposite.
  *
- * Note that the name standards used for the current version of this library
- * are as follows:
+ * Note that the name standards used for the current version of this utility are
+ * as follows:
  *      `[prefix] firstName [middleName] lastName [suffix]`
- * The opening `[` and closing `]` symbols mean that these parts are optional.
+ * where 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 piece and `Smith`, the last
  * name piece.
  *
- * @see https://www.fbiic.gov/public/2008/nov/Naming_practice_guide_UK_2006.pdf
+ * @see {@link https://www.fbiic.gov/public/2008/nov/Naming_practice_guide_UK_2006.pdf}
  * 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.
+ * and may be altered through configurable 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.
+ * Once imported, all that is required to do is to create instances of `Namefully`
+ * as you see fit 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)
+ * - namon: 1 piece of name (e.g., prefix)
+ * - nama: a combination of 2+ pieces of name (e.g., first name + last name)
  *
  * Happy name handling 😊!
  */
 export declare class Namefully {
     #private;
-    /** Creates a name with distinguishable parts from a raw string content.
+    /**
+     * Creates a name with distinguishable parts.
      * @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.
+     * Optional parameters may be provided with specifics on how to treat a full
+     * name during its existence. All name parts must have at least one (1) character
+     * to proceed. That is the only requirement/validation of namefully.
      */
     constructor(names: string | string[] | Name[] | JsonName | Parser, options?: Partial<Config>);
     /**
      * Constructs a `Namefully` instance from a text.
      *
-     * It works like `parse` except that this function returns `null` where `parse`
-     * would throw a `NameError`.
+     * It works like `parse` except that this function returns `undefined` when
+     * `parse` would throw a `NameError`.
      */
     static tryParse(text: string, index?: NameIndex): Namefully | undefined;
     /**
      * Constructs a `Namefully` instance from a text.
      *
-     * It throws a `NameError` if the text cannot be parsed. Use `tryParse`
+     * @throws a `NameError` if the @param 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
@@ -81,27 +83,27 @@ export declare class Namefully {
      * process.
      */
     static parse(text: string, index?: NameIndex): Promise<Namefully>;
-    /** The current configuration. */
+    /** The configuration dictating this name's behavior. */
     get config(): Config;
     /** The number of characters of the `birthName`, including spaces. */
     get length(): number;
-    /** The prefix part. */
+    /** The prefix part of the name set. */
     get prefix(): string | undefined;
-    /** The firt name part. */
+    /** The firt name part of the name set. */
     get first(): string;
-    /** The first middle name part if any. */
+    /** The first middle name part of the name set if any. */
     get middle(): string | undefined;
     /** Returns true if any middle name has been set. */
     get hasMiddle(): boolean;
-    /** The last name part. */
+    /** The last name part of the name set. */
     get last(): string;
-    /** The suffix part. */
+    /** The suffix part of the name set. */
     get suffix(): string | undefined;
-    /** The birth name part. */
+    /** The birth name part of the name set. */
     get birth(): string;
-    /** The shortest version of a person name. */
+    /** The shortest version of a human name (first + last name). */
     get short(): string;
-    /** The longest version of a person name. */
+    /** The longest version of a human name (a.k.a birth name). */
     get long(): string;
     /** The entire name set. */
     get full(): string;
@@ -117,18 +119,17 @@ export declare class Namefully {
     equal(other: Namefully): boolean;
     /** Gets a JSON representation of the full name. */
     toJson(): JsonName;
+    json: () => JsonName;
     /** Confirms that a name part has been set. */
     has(namon: Namon): boolean;
     /**
      * 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.
+     * @param {NameOrder} orderedBy forces to arrange a name set by first or last
+     * name, overriding the preset configuration.
      *
-     * For example:
+     * `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"
@@ -145,26 +146,26 @@ export declare class Namefully {
     birthName(orderedBy?: NameOrder): string;
     /**
      * Gets the first name part of the `FullName`.
-     *
-     * @param withMore determines whether to include other pieces of the first
-     * name.
+     * @param {boolean} withMore determines whether to include other pieces of the
+     * first name.
      */
     firstName(withMore?: boolean): string;
     /** Gets the middle name part of the `FullName`. */
     middleName(): string[];
     /**
      * Gets the last name part of the `FullName`.
-     *
-     * @param format overrides the how-to formatting of a surname output,
+     * @param {Surname} format overrides the how-to formatting of a surname output,
      * considering its sub-parts.
      */
     lastName(format?: Surname): string;
     /**
      * Gets the initials of the `FullName`.
      *
-     * @param {options.orderedBy} forces to order by first or last name by
+     * @param {object} options when getting the initials.
+     * @param {NameOrder} options.orderedBy forces to order by first or last name by
      * overriding the preset configuration.
-     * @param
+     * @param {NameType} options.only selects initials of only certain name parts.
+     * @param {boolean} options.asJson whether to return initials as an array or JSON.
      *
      * For example, given the names:
      * - `John Smith` => `['J', 'S']`
@@ -179,23 +180,22 @@ export declare class Namefully {
      * 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.
+     * @param {NameOrder} orderedBy forces to order by first or last name, 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.
+     * 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`.
+     * the surname is set as `mother` is equivalent to making it: `FirstName MotherName`.
      */
     shorten(orderedBy?: NameOrder): string;
     /**
-     * Flattens a long name using the name types as variants.
+     * Flattens long names 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
@@ -233,13 +233,12 @@ export declare class Namefully {
     }>): string;
     /**
      * Zips or compacts a name using different forms of variants.
-     *
      * @see `flatten()` for more details.
      */
     zip(by?: Flat, withPeriod?: boolean): string;
     /**
      * Formats the full name as desired.
-     * @param pattern character used to format it.
+     * @param {string} pattern character used to format it.
      *
      * string format
      * -------------
@@ -285,7 +284,7 @@ export declare class Namefully {
      * first, middle, and last names.
      */
     format(pattern: string): string;
-    /** Flips definitely the name order from the preset/current config. */
+    /** Flips or swaps the name order from the preset/current config. */
     flip(): void;
     /**
      * Splits the name parts of a birth name.
@@ -294,7 +293,7 @@ export declare class Namefully {
     split(separator?: string | RegExp): string[];
     /**
      * Joins the name parts of a birth name.
-     * @param separator token for the junction.
+     * @param {string} separator token for the junction.
      */
     join(separator?: string): string;
     /** Transforms a birth name into UPPERCASE. */

package/dist/esm/namefully.js

@@ -1,9 +1,9 @@
-import { ALLOWED_TOKENS } from './constants.js';
+import { ALLOWED_FORMAT_TOKENS } from './constants.js';
 import { InputError, NotAllowedError } from './error.js';
 import { isNameArray } from './name.js';
-import { ArrayNameParser, ArrayStringParser, NamaParser, Parser, StringParser } from './parser.js';
 import { Flat, NameOrder, NameType, Namon } from './types.js';
 import { capitalize, decapitalize, isStringArray, toggleCase } from './utils.js';
+import { ArrayNameParser, ArrayStringParser, NamaParser, Parser, StringParser } from './parser.js';
 export class Namefully {
     #fullName;
     constructor(names, options) {
@@ -90,16 +90,16 @@ export class Namefully {
             suffix: this.suffix,
         };
     }
+    json = this.toJson;
     has(namon) {
         return this.#fullName.has(namon);
     }
     fullName(orderedBy) {
         const sep = this.config.ending ? ',' : '';
         const names = [];
-        orderedBy = orderedBy || this.config.orderedBy;
         if (this.prefix)
             names.push(this.prefix);
-        if (orderedBy === NameOrder.FIRST_NAME) {
+        if ((orderedBy ?? this.config.orderedBy) === NameOrder.FIRST_NAME) {
             names.push(this.first, ...this.middleName(), this.last + sep);
         }
         else {
@@ -110,7 +110,7 @@ export class Namefully {
         return names.join(' ').trim();
     }
     birthName(orderedBy) {
-        orderedBy = orderedBy || this.config.orderedBy;
+        orderedBy ??= this.config.orderedBy;
         return orderedBy === NameOrder.FIRST_NAME
             ? [this.first, ...this.middleName(), this.last].join(' ')
             : [this.last, this.first, ...this.middleName()].join(' ');
@@ -125,50 +125,42 @@ export class Namefully {
         return this.#fullName.lastName.toString(format);
     }
     initials(options) {
+        const { orderedBy = this.config.orderedBy, only = NameType.BIRTH_NAME, asJson } = options ?? {};
         const firstInits = this.#fullName.firstName.initials();
-        const midInits = this.#fullName.middleName.map((n) => n.initials()[0]);
+        const midInits = this.#fullName.middleName.map((n) => n.value[0]);
         const lastInits = this.#fullName.lastName.initials();
-        if (options?.asJson)
+        if (asJson)
             return { firstName: firstInits, middleName: midInits, lastName: lastInits };
-        const initials = [];
-        const { orderedBy = this.config.orderedBy, only = NameType.BIRTH_NAME } = options ?? {};
         if (only !== NameType.BIRTH_NAME) {
-            if (only === NameType.FIRST_NAME) {
-                initials.push(...firstInits);
-            }
-            else if (only === NameType.MIDDLE_NAME) {
-                initials.push(...midInits);
-            }
-            else {
-                initials.push(...lastInits);
-            }
+            return only === NameType.FIRST_NAME ? firstInits : only === NameType.MIDDLE_NAME ? midInits : lastInits;
         }
         else if (orderedBy === NameOrder.FIRST_NAME) {
-            initials.push(...firstInits, ...midInits, ...lastInits);
+            return [...firstInits, ...midInits, ...lastInits];
         }
         else {
-            initials.push(...lastInits, ...firstInits, ...midInits);
+            return [...lastInits, ...firstInits, ...midInits];
         }
-        return initials;
     }
     shorten(orderedBy) {
-        orderedBy = orderedBy || this.config.orderedBy;
+        orderedBy ??= this.config.orderedBy;
+        const { firstName, lastName } = this.#fullName;
         return orderedBy === NameOrder.FIRST_NAME
-            ? [this.#fullName.firstName.value, this.#fullName.lastName.toString()].join(' ')
-            : [this.#fullName.lastName.toString(), this.#fullName.firstName.value].join(' ');
+            ? [firstName.value, lastName.toString()].join(' ')
+            : [lastName.toString(), firstName.value].join(' ');
     }
     flatten(options) {
         const { by = Flat.MIDDLE_NAME, limit = 20, recursive = false, withMore = false, withPeriod = true, surname, } = options;
         if (this.length <= limit)
             return this.full;
+        const { firstName, lastName, middleName } = this.#fullName;
         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 : '';
+        const fn = firstName.toString();
+        const mn = this.middleName().join(' ');
+        const ln = lastName.toString();
+        const f = firstName.initials(withMore).join(sep + ' ') + sep;
+        const l = lastName.initials(surname).join(sep + ' ') + sep;
+        const m = hasMid ? middleName.map((n) => n.value[0]).join(sep + ' ') + sep : '';
         let name = [];
         if (this.config.orderedBy === NameOrder.FIRST_NAME) {
             switch (by) {
@@ -249,8 +241,8 @@ export class Namefully {
             pattern = 'o';
         let group = '';
         const formatted = [];
-        for (const char of pattern.split('')) {
-            if (ALLOWED_TOKENS.indexOf(char) === -1) {
+        for (const char of pattern) {
+            if (ALLOWED_FORMAT_TOKENS.indexOf(char) === -1) {
                 throw new NotAllowedError({
                     source: this.full,
                     operation: 'format',
@@ -266,7 +258,8 @@ export class Namefully {
         return formatted.join('').trim();
     }
     flip() {
-        this.config.updateOrder(this.config.orderedBy === NameOrder.FIRST_NAME ? NameOrder.LAST_NAME : NameOrder.FIRST_NAME);
+        const order = this.config.orderedBy === NameOrder.FIRST_NAME ? NameOrder.LAST_NAME : NameOrder.FIRST_NAME;
+        this.config.update({ orderedBy: order });
     }
     split(separator = /[' -]/g) {
         return this.birth.replace(separator, ' ').split(' ');
@@ -317,7 +310,7 @@ export class Namefully {
             return new ArrayNameParser(raw);
         if (typeof raw === 'object')
             return new NamaParser(raw);
-        throw new InputError({ source: raw, message: 'Cannot parse raw data. Review expected data types.' });
+        throw new InputError({ source: raw, message: 'Cannot parse raw data; review expected data types.' });
     }
     #map(char) {
         switch (char) {
@@ -345,16 +338,15 @@ export class Namefully {
             case 'o':
             case 'O':
                 return ((character) => {
-                    const sep = this.config.ending ? ',' : '', names = [];
+                    const sep = this.config.ending ? ',' : '';
+                    const names = [];
                     if (this.prefix)
                         names.push(this.prefix);
                     names.push(`${this.last},`.toUpperCase());
-                    if (this.hasMiddle) {
+                    if (this.hasMiddle)
                         names.push(this.first, this.middleName().join(' ') + sep);
-                    }
-                    else {
+                    else
                         names.push(this.first + sep);
-                    }
                     if (this.suffix)
                         names.push(this.suffix);
                     const nama = names.join(' ').trim();
@@ -370,10 +362,10 @@ export class Namefully {
                 return this.suffix?.toUpperCase();
             case '$f':
             case '$F':
-                return this.#fullName.firstName.initials()[0];
+                return this.#fullName.firstName.value[0];
             case '$l':
             case '$L':
-                return this.#fullName.lastName.initials()[0];
+                return this.#fullName.lastName.value[0];
             case '$m':
             case '$M':
                 return this.hasMiddle ? this.middle[0] : undefined;

package/dist/esm/parser.d.ts

@@ -1,6 +1,6 @@
-import { FullName } from './fullname.js';
 import { Config } from './config.js';
 import { NameIndex } from './utils.js';
+import { FullName } from './fullname.js';
 import { Name, JsonName } from './name.js';
 /**
  * A parser signature that helps to organize the names accordingly.
@@ -17,13 +17,11 @@ export declare abstract class Parser<T = unknown> {
      * to do so. The built parser only knows how to operate birth names.
      */
     static build(text: string, index?: NameIndex): Parser;
-    /**
-     * Builds asynchronously a dynamic `Parser`.
-     */
+    /** Builds asynchronously a dynamic `Parser`. */
     static buildAsync(text: string, index?: NameIndex): Promise<Parser>;
     /**
      * Parses the raw data into a `FullName` while considering some options.
-     * @param options additional configuration to apply.
+     * @param options for additional configuration to apply.
      */
     abstract parse(options?: Partial<Config>): FullName;
 }
@@ -34,7 +32,6 @@ export declare class ArrayStringParser extends Parser<string[]> {
     parse(options: Partial<Config>): FullName;
 }
 export declare class NamaParser extends Parser<JsonName> {
-    #private;
     parse(options: Partial<Config>): FullName;
 }
 export declare class ArrayNameParser extends Parser<Name[]> {

package/dist/esm/parser.js

@@ -1,10 +1,10 @@
-import { FullName } from './fullname.js';
 import { Config } from './config.js';
 import { NameIndex } from './utils.js';
-import { ArrayStringValidator, ArrayNameValidator, NamaValidator } from './validator.js';
-import { FirstName, LastName, Name } from './name.js';
-import { Namon, Separator } from './types.js';
 import { InputError } from './error.js';
+import { FullName } from './fullname.js';
+import { Namon, Separator } from './types.js';
+import { FirstName, LastName, Name } from './name.js';
+import { ArrayStringValidator, ArrayNameValidator, NamaValidator } from './validator.js';
 export class Parser {
     raw;
     constructor(raw) {
@@ -14,7 +14,7 @@ export class Parser {
         const parts = text.trim().split(Separator.SPACE.token);
         const length = parts.length;
         if (index instanceof NameIndex) {
-            const names = Object.entries(index.toJson())
+            const names = Object.entries(index.json())
                 .filter(([, position]) => position > -1 && position < length)
                 .map(([key, position]) => new Name(parts[position], Namon.all.get(key)));
             return new ArrayNameParser(names);
@@ -78,16 +78,7 @@ export class ArrayStringParser extends Parser {
 export class NamaParser extends Parser {
     parse(options) {
         const config = Config.merge(options);
-        if (config.bypass) {
-            NamaValidator.create().validateKeys(this.#asNama());
-        }
-        else {
-            NamaValidator.create().validate(this.#asNama());
-        }
-        return FullName.parse(this.raw, config);
-    }
-    #asNama() {
-        return new Map(Object.entries(this.raw).map(([key, value]) => {
+        const names = new Map(Object.entries(this.raw).map(([key, value]) => {
             const namon = Namon.cast(key);
             if (!namon) {
                 throw new InputError({
@@ -97,6 +88,13 @@ export class NamaParser extends Parser {
             }
             return [namon, value];
         }));
+        if (config.bypass) {
+            NamaValidator.create().validateKeys(names);
+        }
+        else {
+            NamaValidator.create().validate(names);
+        }
+        return FullName.parse(this.raw, config);
     }
 }
 export class ArrayNameParser extends Parser {