pronouny 0.4.0 → 0.5.0

package/README.md

@@ -72,10 +72,24 @@ console.log(
 // This returns "vaynegarden updated her status", "vaynegarden
 // updated hir status", or "vaynegarden updated their status",
 // selected randomly among the three.
+
+// Alternatively, you can use the `parse()` template string method
+// to parse a string with pronouns and write in reasonably natural syntax.
+// This functionality will be updated more in the future.
+console.log(
+	vayne.pronouns.parse`${vayne.username} has updated ${"her"} status.`
+);
+// Returns the same as above.
 ```
 
 ## Changelog
 
+### v0.5.0
+
+-   Added `parse()` method to `Pronoun` and `PronounSet` to allow for parsing of strings into their correct pronoun forms.
+-   Added optional `resolver` property to `Pronoun`s to allow retracing to related Pronouny instance.
+-   Added `identify()` method to `Pronouny` to allow for identification for type of pronouns.
+
 ### v0.4.0
 
 -   Optimized `forEach()` calls to use `for` loops instead.

package/lib/cjs/index.d.ts

@@ -6,11 +6,13 @@
  * and `rfx`.
  */
 declare class Pronoun {
+    [key: string]: any;
     sbj: Array<string>;
     obj: Array<string>;
     psv: Array<string>;
     psj: Array<string>;
     rfx: Array<string>;
+    resolver?: Pronouny;
     /** @constructor */
     constructor(pronouns: {
         subject: Array<string> | string;
@@ -18,7 +20,7 @@ declare class Pronoun {
         possessive: Array<string> | string;
         psAdjective: Array<string> | string;
         reflexive: Array<string> | string;
-    });
+    }, resolver?: Pronouny);
     /**# Subject Getter
      * Get a subject pronoun. By default, uses one at
      * random and fails silently by using the last
@@ -115,6 +117,11 @@ declare class Pronoun {
      * Default is `true`.
      */
     reflexive(index?: number, useRandom?: boolean, failQuietly?: boolean): string;
+    /**# `.parse()` a Template String
+     * A method to parse tagged template strings and provide
+     * the correct pronouns, as per a particular PronounSet.
+     */
+    parse(strings: TemplateStringsArray, ...args: Array<string>): string;
 }
 /**# `PronounSet` class
  * A private class to construct the methods on
@@ -162,7 +169,7 @@ declare class PronounSet {
      * {@link PronounSet.possessive|`.possessive()`}, or
      * {@link PronounSet.reflexive|`.reflexive()`}. This is mostly
      * here if you'd like to explicitly get a `Pronoun` instance
-     * from a `PronounSet`.
+     * from a `PronounSet`. Also useful for narrowing {@link PronounSet.parse|`.parse()`}.
      *
      * @param index
      * Retrieve `index`th pronoun from insertion.
@@ -185,6 +192,13 @@ declare class PronounSet {
     psAdjective(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random reflexive pronoun. */
     reflexive(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
+    /**# Template Parsing
+     * A method to select only one pronoun from the set
+     * and reuse it for the entire string. This is useful
+     * for when you want to use the same pronoun for a
+     * sentence.
+     */
+    parse(strings: TemplateStringsArray, ...args: Array<string>): string;
 }
 /**# Config
  * `failQuietly`: Controls various quiet failure states.
@@ -250,8 +264,23 @@ type PronounyConfig = {
  * `Pronoun` object.
  */
 export default class Pronouny {
+    [keyof: string]: any;
     config: PronounyConfig;
     resolveMap: Map<string, Pronoun>;
+    default: {
+        he: Pronoun;
+        she: Pronoun;
+        they: Pronoun;
+        you: Pronoun;
+        i: Pronoun;
+        we: Pronoun;
+        config: {
+            failQuietly: boolean;
+            deepSearch: boolean;
+            useRandom: boolean;
+            fallbackPronoun: string;
+        };
+    };
     constructor(config?: PronounyConfig);
     /**# `.resolve()` a Pronoun
      * Returns a pronoun from a given string. Uses
@@ -259,6 +288,16 @@ export default class Pronouny {
      * By default, only checks the first subject pronoun.
      */
     resolve(pronoun: string, deepSearch?: boolean): Pronoun;
+    /**# `.identify()` a Pronoun
+     * Returns a string describing the type of pronoun
+     * passed in. Returns `subject`, `object`,
+     * `possessive`, `possessive adjective`, or
+     * `reflexive`. You can use this to access other
+     * pronouns by retrieving via string indexing.
+     * **This method is case-sensitive and does not
+     * have a quiet failure state.**
+     */
+    identify(pronoun: string): string;
     /**# `.add()` an Unlisted Pronoun
      * If you made a `.new()` Pronoun but disabled
      * `autoAppend`, you can later append it back by

package/lib/cjs/index.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function randomToLimit(limit) {
     return Math.floor(Math.random() * limit);
 }
+function isUpperCase(str) {
+    return str === str.toUpperCase() && str !== str.toLowerCase();
+}
 /**# `Pronoun` class
  * A private class to construct the methods for pronoun
  * access. Use {@link Pronouny} to create and
@@ -12,7 +15,7 @@ function randomToLimit(limit) {
  */
 class Pronoun {
     /** @constructor */
-    constructor(pronouns) {
+    constructor(pronouns, resolver) {
         this.sbj =
             typeof pronouns.subject === "string"
                 ? [pronouns.subject]
@@ -33,6 +36,9 @@ class Pronoun {
             typeof pronouns.reflexive === "string"
                 ? [pronouns.reflexive]
                 : pronouns.reflexive;
+        if (resolver) {
+            this.resolver = resolver;
+        }
         return this;
     }
     /**# Subject Getter
@@ -201,6 +207,25 @@ class Pronoun {
                 throw new Error(`could not retrieve index ${index} from "${this.sbj[0]}" reflexive pronoun`);
         }
     }
+    /**# `.parse()` a Template String
+     * A method to parse tagged template strings and provide
+     * the correct pronouns, as per a particular PronounSet.
+     */
+    parse(strings, ...args) {
+        let result = strings[0];
+        for (let i = 0; i < args.length; i++) {
+            const upperCaseFlag = isUpperCase(args[i][0]);
+            let argSub = this.resolver?.identify(args[i].toLowerCase()) !== ""
+                ? this.use()[this.resolver?.identify(args[i].toLowerCase()) ||
+                    new Pronouny().identify(args[i].toLowerCase())]()
+                : args[i];
+            if (upperCaseFlag) {
+                argSub = argSub[0].toUpperCase() + argSub.slice(1);
+            }
+            result += argSub + strings[i + 1];
+        }
+        return result;
+    }
 }
 /**# `PronounSet` class
  * A private class to construct the methods on
@@ -316,7 +341,7 @@ class PronounSet {
      * {@link PronounSet.possessive|`.possessive()`}, or
      * {@link PronounSet.reflexive|`.reflexive()`}. This is mostly
      * here if you'd like to explicitly get a `Pronoun` instance
-     * from a `PronounSet`.
+     * from a `PronounSet`. Also useful for narrowing {@link PronounSet.parse|`.parse()`}.
      *
      * @param index
      * Retrieve `index`th pronoun from insertion.
@@ -371,55 +396,27 @@ class PronounSet {
     reflexive(index = -1, failQuietly = this.resolver.config.failQuietly, useRandom = this.resolver.config.useRandom) {
         return this.use(index, failQuietly, useRandom).reflexive(-1, failQuietly, useRandom);
     }
+    /**# Template Parsing
+     * A method to select only one pronoun from the set
+     * and reuse it for the entire string. This is useful
+     * for when you want to use the same pronoun for a
+     * sentence.
+     */
+    parse(strings, ...args) {
+        let result = strings[0];
+        for (let i = 0; i < args.length; i++) {
+            const upperCaseFlag = isUpperCase(args[i][0]);
+            let argSub = this.resolver.identify(args[i].toLowerCase()) !== ""
+                ? this.use()[this.resolver.identify(args[i].toLowerCase())]()
+                : args[i];
+            if (upperCaseFlag) {
+                argSub = argSub[0].toUpperCase() + argSub.slice(1);
+            }
+            result += argSub + strings[i + 1];
+        }
+        return result;
+    }
 }
-const pronounHe = new Pronoun({
-    subject: ["he"],
-    object: ["him"],
-    possessive: ["his"],
-    psAdjective: ["his"],
-    reflexive: ["himself"],
-});
-const pronounShe = new Pronoun({
-    subject: ["she"],
-    object: ["her"],
-    possessive: ["hers"],
-    psAdjective: ["her"],
-    reflexive: ["herself"],
-});
-const pronounThey = new Pronoun({
-    subject: ["they"],
-    object: ["them"],
-    possessive: ["theirs"],
-    psAdjective: ["their"],
-    reflexive: ["theirself", "theirselves", "themselves", "themself"],
-});
-const pronounYou = new Pronoun({
-    subject: ["you"],
-    object: ["you"],
-    possessive: ["yours"],
-    psAdjective: ["your"],
-    reflexive: ["yourself"],
-});
-const pronounI = new Pronoun({
-    subject: ["I"],
-    object: ["me"],
-    possessive: ["mine"],
-    psAdjective: ["my"],
-    reflexive: ["myself"],
-});
-const pronounWe = new Pronoun({
-    subject: ["we"],
-    object: ["us"],
-    possessive: ["our"],
-    psAdjective: ["ours"],
-    reflexive: ["ourselves"],
-});
-const PronounyDefaultConfig = {
-    failQuietly: true,
-    deepSearch: false,
-    useRandom: true,
-    fallbackPronoun: "they",
-};
 /**# Pronouny
  * A typed library intended to make English pronoun
  * resolution easy. Instantiate in your project using
@@ -445,15 +442,76 @@ const PronounyDefaultConfig = {
  * `Pronoun` object.
  */
 class Pronouny {
-    constructor(config = PronounyDefaultConfig) {
-        this.config = Object.assign(PronounyDefaultConfig, config);
+    constructor(config = {
+        failQuietly: true,
+        deepSearch: false,
+        useRandom: true,
+        fallbackPronoun: "they",
+    }) {
+        this.default = {
+            he: new Pronoun({
+                subject: ["he"],
+                object: ["him"],
+                possessive: ["his"],
+                psAdjective: ["his"],
+                reflexive: ["himself"],
+            }, this),
+            she: new Pronoun({
+                subject: ["she"],
+                object: ["her"],
+                possessive: ["hers"],
+                psAdjective: ["her"],
+                reflexive: ["herself"],
+            }, this),
+            they: new Pronoun({
+                subject: ["they"],
+                object: ["them"],
+                possessive: ["theirs"],
+                psAdjective: ["their"],
+                reflexive: [
+                    "theirself",
+                    "theirselves",
+                    "themselves",
+                    "themself",
+                ],
+            }, this),
+            you: new Pronoun({
+                subject: ["you"],
+                object: ["you"],
+                possessive: ["yours"],
+                psAdjective: ["your"],
+                reflexive: ["yourself"],
+            }, this),
+            i: new Pronoun({
+                subject: ["I"],
+                object: ["me"],
+                possessive: ["mine"],
+                psAdjective: ["my"],
+                reflexive: ["myself"],
+            }, this),
+            we: new Pronoun({
+                subject: ["we"],
+                object: ["us"],
+                possessive: ["ours"],
+                psAdjective: ["our"],
+                reflexive: ["ourselves"],
+            }, this),
+            config: {
+                failQuietly: true,
+                deepSearch: false,
+                useRandom: true,
+                fallbackPronoun: "they",
+            },
+        };
+        const defaults = this.default;
+        this.config = Object.assign(defaults.config, config);
         this.resolveMap = new Map([
-            [pronounThey.sbj[0], pronounThey],
-            [pronounYou.sbj[0], pronounYou],
-            [pronounWe.sbj[0], pronounWe],
-            [pronounI.sbj[0], pronounI],
-            [pronounHe.sbj[0], pronounHe],
-            [pronounShe.sbj[0], pronounShe],
+            [defaults.they.sbj[0], defaults.they],
+            [defaults.you.sbj[0], defaults.you],
+            [defaults.we.sbj[0], defaults.we],
+            [defaults.i.sbj[0], defaults.i],
+            [defaults.he.sbj[0], defaults.he],
+            [defaults.she.sbj[0], defaults.she],
         ]);
         return this;
     }
@@ -485,12 +543,50 @@ class Pronouny {
                 throw new Error(`Pronoun "${pronoun}" not found`);
         }
     }
+    /**# `.identify()` a Pronoun
+     * Returns a string describing the type of pronoun
+     * passed in. Returns `subject`, `object`,
+     * `possessive`, `possessive adjective`, or
+     * `reflexive`. You can use this to access other
+     * pronouns by retrieving via string indexing.
+     * **This method is case-sensitive and does not
+     * have a quiet failure state.**
+     */
+    identify(pronoun) {
+        let pronounType = "";
+        for (const [_, value] of this.resolveMap) {
+            for (let i = 0, types = Object.values(value); i < types.length; i++) {
+                let type = types[i];
+                if (Object.keys(value)[i] === "resolver") {
+                    continue;
+                }
+                if (type.includes(pronoun)) {
+                    pronounType = Object.keys(value)[i];
+                }
+            }
+        }
+        switch (pronounType) {
+            case "sbj":
+                return "subject";
+            case "obj":
+                return "object";
+            case "psv":
+                return "possessive";
+            case "psj":
+                return "psAdjective";
+            case "rfx":
+                return "reflexive";
+            default:
+                return "";
+        }
+    }
     /**# `.add()` an Unlisted Pronoun
      * If you made a `.new()` Pronoun but disabled
      * `autoAppend`, you can later append it back by
      * using this method. Returns `Pronouny`.
      */
     add(pronoun) {
+        pronoun.resolver = this;
         this.resolveMap.set(pronoun.sbj[0], pronoun);
         return this;
     }
@@ -502,6 +598,7 @@ class Pronouny {
         if (pronoun === this.resolveMap.get(this.config.fallbackPronoun)) {
             throw new Error(`Cannot remove fallback pronoun. Assign a new one before removal.`);
         }
+        pronoun.resolver = undefined;
         this.resolveMap.delete(pronoun.sbj[0]);
         return this;
     }

package/lib/esm/index.d.ts

@@ -6,11 +6,13 @@
  * and `rfx`.
  */
 declare class Pronoun {
+    [key: string]: any;
     sbj: Array<string>;
     obj: Array<string>;
     psv: Array<string>;
     psj: Array<string>;
     rfx: Array<string>;
+    resolver?: Pronouny;
     /** @constructor */
     constructor(pronouns: {
         subject: Array<string> | string;
@@ -18,7 +20,7 @@ declare class Pronoun {
         possessive: Array<string> | string;
         psAdjective: Array<string> | string;
         reflexive: Array<string> | string;
-    });
+    }, resolver?: Pronouny);
     /**# Subject Getter
      * Get a subject pronoun. By default, uses one at
      * random and fails silently by using the last
@@ -115,6 +117,11 @@ declare class Pronoun {
      * Default is `true`.
      */
     reflexive(index?: number, useRandom?: boolean, failQuietly?: boolean): string;
+    /**# `.parse()` a Template String
+     * A method to parse tagged template strings and provide
+     * the correct pronouns, as per a particular PronounSet.
+     */
+    parse(strings: TemplateStringsArray, ...args: Array<string>): string;
 }
 /**# `PronounSet` class
  * A private class to construct the methods on
@@ -162,7 +169,7 @@ declare class PronounSet {
      * {@link PronounSet.possessive|`.possessive()`}, or
      * {@link PronounSet.reflexive|`.reflexive()`}. This is mostly
      * here if you'd like to explicitly get a `Pronoun` instance
-     * from a `PronounSet`.
+     * from a `PronounSet`. Also useful for narrowing {@link PronounSet.parse|`.parse()`}.
      *
      * @param index
      * Retrieve `index`th pronoun from insertion.
@@ -185,6 +192,13 @@ declare class PronounSet {
     psAdjective(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
     /**Retrieves a random reflexive pronoun. */
     reflexive(index?: number, failQuietly?: boolean, useRandom?: boolean): string;
+    /**# Template Parsing
+     * A method to select only one pronoun from the set
+     * and reuse it for the entire string. This is useful
+     * for when you want to use the same pronoun for a
+     * sentence.
+     */
+    parse(strings: TemplateStringsArray, ...args: Array<string>): string;
 }
 /**# Config
  * `failQuietly`: Controls various quiet failure states.
@@ -250,8 +264,23 @@ type PronounyConfig = {
  * `Pronoun` object.
  */
 export default class Pronouny {
+    [keyof: string]: any;
     config: PronounyConfig;
     resolveMap: Map<string, Pronoun>;
+    default: {
+        he: Pronoun;
+        she: Pronoun;
+        they: Pronoun;
+        you: Pronoun;
+        i: Pronoun;
+        we: Pronoun;
+        config: {
+            failQuietly: boolean;
+            deepSearch: boolean;
+            useRandom: boolean;
+            fallbackPronoun: string;
+        };
+    };
     constructor(config?: PronounyConfig);
     /**# `.resolve()` a Pronoun
      * Returns a pronoun from a given string. Uses
@@ -259,6 +288,16 @@ export default class Pronouny {
      * By default, only checks the first subject pronoun.
      */
     resolve(pronoun: string, deepSearch?: boolean): Pronoun;
+    /**# `.identify()` a Pronoun
+     * Returns a string describing the type of pronoun
+     * passed in. Returns `subject`, `object`,
+     * `possessive`, `possessive adjective`, or
+     * `reflexive`. You can use this to access other
+     * pronouns by retrieving via string indexing.
+     * **This method is case-sensitive and does not
+     * have a quiet failure state.**
+     */
+    identify(pronoun: string): string;
     /**# `.add()` an Unlisted Pronoun
      * If you made a `.new()` Pronoun but disabled
      * `autoAppend`, you can later append it back by

package/lib/esm/index.js

@@ -1,6 +1,9 @@
 function randomToLimit(limit) {
     return Math.floor(Math.random() * limit);
 }
+function isUpperCase(str) {
+    return str === str.toUpperCase() && str !== str.toLowerCase();
+}
 /**# `Pronoun` class
  * A private class to construct the methods for pronoun
  * access. Use {@link Pronouny} to create and
@@ -10,7 +13,7 @@ function randomToLimit(limit) {
  */
 class Pronoun {
     /** @constructor */
-    constructor(pronouns) {
+    constructor(pronouns, resolver) {
         this.sbj =
             typeof pronouns.subject === "string"
                 ? [pronouns.subject]
@@ -31,6 +34,9 @@ class Pronoun {
             typeof pronouns.reflexive === "string"
                 ? [pronouns.reflexive]
                 : pronouns.reflexive;
+        if (resolver) {
+            this.resolver = resolver;
+        }
         return this;
     }
     /**# Subject Getter
@@ -199,6 +205,25 @@ class Pronoun {
                 throw new Error(`could not retrieve index ${index} from "${this.sbj[0]}" reflexive pronoun`);
         }
     }
+    /**# `.parse()` a Template String
+     * A method to parse tagged template strings and provide
+     * the correct pronouns, as per a particular PronounSet.
+     */
+    parse(strings, ...args) {
+        let result = strings[0];
+        for (let i = 0; i < args.length; i++) {
+            const upperCaseFlag = isUpperCase(args[i][0]);
+            let argSub = this.resolver?.identify(args[i].toLowerCase()) !== ""
+                ? this.use()[this.resolver?.identify(args[i].toLowerCase()) ||
+                    new Pronouny().identify(args[i].toLowerCase())]()
+                : args[i];
+            if (upperCaseFlag) {
+                argSub = argSub[0].toUpperCase() + argSub.slice(1);
+            }
+            result += argSub + strings[i + 1];
+        }
+        return result;
+    }
 }
 /**# `PronounSet` class
  * A private class to construct the methods on
@@ -314,7 +339,7 @@ class PronounSet {
      * {@link PronounSet.possessive|`.possessive()`}, or
      * {@link PronounSet.reflexive|`.reflexive()`}. This is mostly
      * here if you'd like to explicitly get a `Pronoun` instance
-     * from a `PronounSet`.
+     * from a `PronounSet`. Also useful for narrowing {@link PronounSet.parse|`.parse()`}.
      *
      * @param index
      * Retrieve `index`th pronoun from insertion.
@@ -369,55 +394,27 @@ class PronounSet {
     reflexive(index = -1, failQuietly = this.resolver.config.failQuietly, useRandom = this.resolver.config.useRandom) {
         return this.use(index, failQuietly, useRandom).reflexive(-1, failQuietly, useRandom);
     }
+    /**# Template Parsing
+     * A method to select only one pronoun from the set
+     * and reuse it for the entire string. This is useful
+     * for when you want to use the same pronoun for a
+     * sentence.
+     */
+    parse(strings, ...args) {
+        let result = strings[0];
+        for (let i = 0; i < args.length; i++) {
+            const upperCaseFlag = isUpperCase(args[i][0]);
+            let argSub = this.resolver.identify(args[i].toLowerCase()) !== ""
+                ? this.use()[this.resolver.identify(args[i].toLowerCase())]()
+                : args[i];
+            if (upperCaseFlag) {
+                argSub = argSub[0].toUpperCase() + argSub.slice(1);
+            }
+            result += argSub + strings[i + 1];
+        }
+        return result;
+    }
 }
-const pronounHe = new Pronoun({
-    subject: ["he"],
-    object: ["him"],
-    possessive: ["his"],
-    psAdjective: ["his"],
-    reflexive: ["himself"],
-});
-const pronounShe = new Pronoun({
-    subject: ["she"],
-    object: ["her"],
-    possessive: ["hers"],
-    psAdjective: ["her"],
-    reflexive: ["herself"],
-});
-const pronounThey = new Pronoun({
-    subject: ["they"],
-    object: ["them"],
-    possessive: ["theirs"],
-    psAdjective: ["their"],
-    reflexive: ["theirself", "theirselves", "themselves", "themself"],
-});
-const pronounYou = new Pronoun({
-    subject: ["you"],
-    object: ["you"],
-    possessive: ["yours"],
-    psAdjective: ["your"],
-    reflexive: ["yourself"],
-});
-const pronounI = new Pronoun({
-    subject: ["I"],
-    object: ["me"],
-    possessive: ["mine"],
-    psAdjective: ["my"],
-    reflexive: ["myself"],
-});
-const pronounWe = new Pronoun({
-    subject: ["we"],
-    object: ["us"],
-    possessive: ["our"],
-    psAdjective: ["ours"],
-    reflexive: ["ourselves"],
-});
-const PronounyDefaultConfig = {
-    failQuietly: true,
-    deepSearch: false,
-    useRandom: true,
-    fallbackPronoun: "they",
-};
 /**# Pronouny
  * A typed library intended to make English pronoun
  * resolution easy. Instantiate in your project using
@@ -443,15 +440,76 @@ const PronounyDefaultConfig = {
  * `Pronoun` object.
  */
 export default class Pronouny {
-    constructor(config = PronounyDefaultConfig) {
-        this.config = Object.assign(PronounyDefaultConfig, config);
+    constructor(config = {
+        failQuietly: true,
+        deepSearch: false,
+        useRandom: true,
+        fallbackPronoun: "they",
+    }) {
+        this.default = {
+            he: new Pronoun({
+                subject: ["he"],
+                object: ["him"],
+                possessive: ["his"],
+                psAdjective: ["his"],
+                reflexive: ["himself"],
+            }, this),
+            she: new Pronoun({
+                subject: ["she"],
+                object: ["her"],
+                possessive: ["hers"],
+                psAdjective: ["her"],
+                reflexive: ["herself"],
+            }, this),
+            they: new Pronoun({
+                subject: ["they"],
+                object: ["them"],
+                possessive: ["theirs"],
+                psAdjective: ["their"],
+                reflexive: [
+                    "theirself",
+                    "theirselves",
+                    "themselves",
+                    "themself",
+                ],
+            }, this),
+            you: new Pronoun({
+                subject: ["you"],
+                object: ["you"],
+                possessive: ["yours"],
+                psAdjective: ["your"],
+                reflexive: ["yourself"],
+            }, this),
+            i: new Pronoun({
+                subject: ["I"],
+                object: ["me"],
+                possessive: ["mine"],
+                psAdjective: ["my"],
+                reflexive: ["myself"],
+            }, this),
+            we: new Pronoun({
+                subject: ["we"],
+                object: ["us"],
+                possessive: ["ours"],
+                psAdjective: ["our"],
+                reflexive: ["ourselves"],
+            }, this),
+            config: {
+                failQuietly: true,
+                deepSearch: false,
+                useRandom: true,
+                fallbackPronoun: "they",
+            },
+        };
+        const defaults = this.default;
+        this.config = Object.assign(defaults.config, config);
         this.resolveMap = new Map([
-            [pronounThey.sbj[0], pronounThey],
-            [pronounYou.sbj[0], pronounYou],
-            [pronounWe.sbj[0], pronounWe],
-            [pronounI.sbj[0], pronounI],
-            [pronounHe.sbj[0], pronounHe],
-            [pronounShe.sbj[0], pronounShe],
+            [defaults.they.sbj[0], defaults.they],
+            [defaults.you.sbj[0], defaults.you],
+            [defaults.we.sbj[0], defaults.we],
+            [defaults.i.sbj[0], defaults.i],
+            [defaults.he.sbj[0], defaults.he],
+            [defaults.she.sbj[0], defaults.she],
         ]);
         return this;
     }
@@ -483,12 +541,50 @@ export default class Pronouny {
                 throw new Error(`Pronoun "${pronoun}" not found`);
         }
     }
+    /**# `.identify()` a Pronoun
+     * Returns a string describing the type of pronoun
+     * passed in. Returns `subject`, `object`,
+     * `possessive`, `possessive adjective`, or
+     * `reflexive`. You can use this to access other
+     * pronouns by retrieving via string indexing.
+     * **This method is case-sensitive and does not
+     * have a quiet failure state.**
+     */
+    identify(pronoun) {
+        let pronounType = "";
+        for (const [_, value] of this.resolveMap) {
+            for (let i = 0, types = Object.values(value); i < types.length; i++) {
+                let type = types[i];
+                if (Object.keys(value)[i] === "resolver") {
+                    continue;
+                }
+                if (type.includes(pronoun)) {
+                    pronounType = Object.keys(value)[i];
+                }
+            }
+        }
+        switch (pronounType) {
+            case "sbj":
+                return "subject";
+            case "obj":
+                return "object";
+            case "psv":
+                return "possessive";
+            case "psj":
+                return "psAdjective";
+            case "rfx":
+                return "reflexive";
+            default:
+                return "";
+        }
+    }
     /**# `.add()` an Unlisted Pronoun
      * If you made a `.new()` Pronoun but disabled
      * `autoAppend`, you can later append it back by
      * using this method. Returns `Pronouny`.
      */
     add(pronoun) {
+        pronoun.resolver = this;
         this.resolveMap.set(pronoun.sbj[0], pronoun);
         return this;
     }
@@ -500,6 +596,7 @@ export default class Pronouny {
         if (pronoun === this.resolveMap.get(this.config.fallbackPronoun)) {
             throw new Error(`Cannot remove fallback pronoun. Assign a new one before removal.`);
         }
+        pronoun.resolver = undefined;
         this.resolveMap.delete(pronoun.sbj[0]);
         return this;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pronouny",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"description": "a small, typed utility library to determine the correct pronoun from a string and several utility functions.",
 	"main": "./lib/cjs/index.js",
 	"module": "./lib/esm/index.js",