podns 1.0.0

package/README.md

@@ -0,0 +1,28 @@
+# PoDNS
+This is a Node.JS implementation of [Pronouns over DNS](https://github.com/CutieZone/pronouns-over-dns), a way to define pronouns using DNS TXT records.
+
+## Usage
+```js
+const getPronouns = require("podns");
+await getPronouns("mauve.beer");
+```
+
+## Return values
+```js
+{
+    type: "pronouns"|"wildcard"|"none"|"comment-only"
+    raw // raw data fetched
+    cleanedRaw // cleaned up version of the fetch data (e.g. "SHE/ Her #hello!" -> "she/her")
+    comment?
+
+    // everything below this requires type to be "pronouns" in order to exist
+    tags // array that can only contain "preferred" and/or "plural"
+    pronouns: {
+        subject //first part of the pronouns
+        object // second
+        possessiveDeterminer // third
+        possessivePronoun // fourth
+        reflexive // fifth
+    }
+}
+```

package/dist/http.d.ts

@@ -0,0 +1,2 @@
+export declare function getPronounsRecords(domain: string): Promise<string[]>;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAEA,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAO1E"}

package/dist/http.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPronounsRecords = getPronounsRecords;
+const node_dns_1 = require("node:dns");
+async function getPronounsRecords(domain) {
+    try {
+        const addresses = await node_dns_1.promises.resolveTxt("pronouns." + domain);
+        return addresses.flat();
+    }
+    catch (err) {
+        throw err;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { PronounRecord } from "./types.js";
+/**
+ * Get pronouns from a domain name and parse their values
+ * @param domain The domain to check. Must follow the format of `domain-name.tld`.
+ * @param silenceParseErrors Whether to silence errors and ignore misformed pronouns or not. Defaults to `true`.
+ * @returns The parsed pronouns
+ */
+export default function getPronouns(domain: string, silenceParseErrors?: boolean): Promise<PronounRecord[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;GAKG;AACH,wBAA8B,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,kBAAkB,UAAO,4BAYlF"}

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getPronouns;
+const http_js_1 = require("./http.js");
+const parser_js_1 = require("./parser.js");
+/**
+ * Get pronouns from a domain name and parse their values
+ * @param domain The domain to check. Must follow the format of `domain-name.tld`.
+ * @param silenceParseErrors Whether to silence errors and ignore misformed pronouns or not. Defaults to `true`.
+ * @returns The parsed pronouns
+ */
+async function getPronouns(domain, silenceParseErrors = true) {
+    const pronounsRecords = await (0, http_js_1.getPronounsRecords)(domain);
+    let processed = [];
+    for (let r in pronounsRecords) {
+        const parsed = (0, parser_js_1.parseRecord)(r, silenceParseErrors);
+        if (parsed != null) {
+            processed.push(parsed);
+        }
+    }
+    return processed;
+}

package/dist/parser.d.ts

@@ -0,0 +1,9 @@
+import { PronounRecord } from "./types.js";
+/**
+ * Parses a record of pronouns
+ * @param record The record to parse
+ * @param silenceErrors Whether to silently error and return null or to `throw` errors
+ * @returns
+ */
+export declare function parseRecord(record: string, silenceErrors?: boolean): PronounRecord | null;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,aAAa,EAA8C,MAAM,YAAY,CAAC;AAEhI;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,UAAQ,GAAG,aAAa,GAAG,IAAI,CA8GvF"}

package/dist/parser.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRecord = parseRecord;
+const types_js_1 = require("./types.js");
+/**
+ * Parses a record of pronouns
+ * @param record The record to parse
+ * @param silenceErrors Whether to silently error and return null or to `throw` errors
+ * @returns
+ */
+function parseRecord(record, silenceErrors = false) {
+    let parsed = record;
+    // separating the comment from the rest
+    let comment;
+    if (parsed.includes("#")) {
+        comment = record.split("#")[1];
+        parsed = record.split("#")[0];
+    }
+    // remove all whitespaces, make everything lowercase
+    parsed = parsed.trim().toLocaleLowerCase().replace(/\s/g, "");
+    // check special cases (wildcard, none, nothing other than a comment)
+    switch (parsed) {
+        case "*": {
+            return {
+                type: "wildcard",
+                comment: comment,
+                raw: record,
+                cleanedRaw: parsed
+            };
+        }
+        case "!": {
+            return {
+                type: "none",
+                comment: comment,
+                raw: record,
+                cleanedRaw: parsed
+            };
+        }
+        case "": {
+            if (comment) {
+                return {
+                    type: "comment-only",
+                    comment: comment,
+                    raw: record,
+                    cleanedRaw: parsed
+                };
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    // check for tags
+    let tags = [];
+    if (parsed.includes(";")) {
+        const parsedTags = parsed.split(";").slice(1);
+        for (const i in parsedTags) {
+            let t = parsedTags[i];
+            if (t == "") {
+                continue;
+            }
+            if (!types_js_1.PRONOUN_TAGS.includes(t)) {
+                if (!silenceErrors) {
+                    throw Error("fetched pronoun \"" + record + "\" contains invalid tag(s)");
+                }
+                else {
+                    return null;
+                }
+            }
+            if (!tags.includes(t)) {
+                tags.push(t);
+            }
+        }
+        parsed = parsed.split(";")[0];
+    }
+    // check for pronoun parts
+    let parts = parsed.split("/");
+    if (parts.length < 2 || parts.length > 5) {
+        if (!silenceErrors) {
+            throw Error("fetched pronoun \"" + record + "\" is not formatted correctly");
+        }
+        else {
+            return null;
+        }
+    }
+    for (const i in parts) {
+        if (!/^[a-z]+$/.test(parts[i])) {
+            if (!silenceErrors) {
+                throw Error("fetched pronoun \"" + record + "\" contains invalid characters in its pronoun set");
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    // special cases
+    if (parts[0] == "it" && parts[1] == "its") {
+        parts = ["it", "it", "its", "its", "itself"];
+    }
+    if (parts[0] == "they" && parts[1] == "them" && !tags.includes("plural")) {
+        tags.push("plural");
+    }
+    return {
+        pronouns: {
+            subject: parts[0],
+            object: parts[1],
+            possessiveDeterminer: parts[2],
+            possessivePronoun: parts[3],
+            reflexive: parts[4]
+        },
+        tags: tags,
+        type: "pronouns",
+        raw: record,
+        comment: comment,
+        cleanedRaw: parsed
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+interface PronounSet {
+    subject: string;
+    object: string;
+    possessiveDeterminer?: string;
+    possessivePronoun?: string;
+    reflexive?: string;
+}
+export declare const PRONOUN_TAGS: readonly ["preferred", "plural"];
+export type PronounTag = typeof PRONOUN_TAGS[number];
+interface Record {
+    raw: string;
+    cleanedRaw: string;
+    comment?: string;
+}
+export interface PronounsRecord extends Record {
+    type: 'pronouns';
+    pronouns: PronounSet;
+    tags: PronounTag[];
+}
+export interface WildcardRecord extends Record {
+    type: 'wildcard';
+}
+export interface NoneRecord extends Record {
+    type: 'none';
+}
+export interface CommentRecord extends Record {
+    type: 'comment-only';
+}
+export type PronounRecord = PronounsRecord | WildcardRecord | NoneRecord | CommentRecord;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,UAAU,UAAU;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,kCAAmC,CAAC;AAC7D,MAAM,MAAM,UAAU,GAAG,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AAErD,UAAU,MAAM;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAe,SAAQ,MAAM;IAC1C,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,cAAe,SAAQ,MAAM;IAC1C,IAAI,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,UAAW,SAAQ,MAAM;IACtC,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,MAAM;IACzC,IAAI,EAAE,cAAc,CAAA;CACvB;AAED,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,cAAc,GAAG,UAAU,GAAG,aAAa,CAAC"}

package/dist/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRONOUN_TAGS = void 0;
+exports.PRONOUN_TAGS = ['preferred', 'plural'];

package/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "podns",
+    "version": "1.0.0",
+    "author": "lumap <lumap@duck.com>",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "repository": {
+        "url": "https://codeberg.org/lumap/podns-js"
+    },
+    "devDependencies": {
+        "@types/node": "^25.0.9",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.17"
+    },
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build",
+        "test": "vitest run ./src/"
+    },
+    "license": "MIT"
+}

package/src/http.test.ts

@@ -0,0 +1,9 @@
+import { test, assert } from "vitest";
+import { getPronounsRecords } from "./http.js"
+
+test("fetch pronouns from domain name & tld", async (t) => {
+    const pronouns = await getPronounsRecords("mauve.beer")
+    assert.equal(pronouns.includes("she/her;preferred"), true)
+    assert.equal(pronouns.includes("they/them"), true)
+    assert.equal(pronouns.length, 2)
+})

package/src/http.ts

@@ -0,0 +1,10 @@
+import { promises as dnsPromises } from "node:dns";
+
+export async function getPronounsRecords(domain: string): Promise<string[]> {
+    try {
+        const addresses = await dnsPromises.resolveTxt("pronouns." + domain);
+        return addresses.flat();
+    } catch (err) {
+        throw err;
+    }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+import { getPronounsRecords} from "./http.js";
+import { parseRecord } from "./parser.js";
+import { PronounRecord } from "./types.js";
+
+/**
+ * Get pronouns from a domain name and parse their values
+ * @param domain The domain to check. Must follow the format of `domain-name.tld`.
+ * @param silenceParseErrors Whether to silence errors and ignore misformed pronouns or not. Defaults to `true`.
+ * @returns The parsed pronouns
+ */
+export default async function getPronouns(domain: string, silenceParseErrors = true) {
+    const pronounsRecords = await getPronounsRecords(domain);
+
+    let processed: PronounRecord[] = []
+    for (let r in pronounsRecords) {
+        const parsed = parseRecord(r, silenceParseErrors)
+        if (parsed != null) {
+            processed.push(parsed)
+        }
+    }
+
+    return processed
+}

package/src/parser.test.ts

@@ -0,0 +1,137 @@
+import { parseRecord } from "./parser.js";
+import {test, assert, expect} from "vitest";
+import { CommentRecord, NoneRecord, PronounsRecord, WildcardRecord } from "./types.js";
+
+// special cases
+test("parse nothing", () => {
+    assert.equal(parseRecord(""), null)
+})
+
+test("parse comment-only", () => {
+    const parsed = parseRecord("#meow") as CommentRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "comment-only")
+    assert.equal(parsed.comment, "meow")
+    assert.equal(parsed.raw, "#meow")
+    assert.equal(parsed.cleanedRaw, "")
+})
+
+test("parse none", () => {
+    const parsed = parseRecord("!   ") as NoneRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "none")
+    assert.equal(parsed.comment, undefined)
+    assert.equal(parsed.raw, "!   ")
+    assert.equal(parsed.cleanedRaw, "!")
+})
+
+test("parse wildcard", () => {
+    const parsed = parseRecord("  *") as WildcardRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "wildcard")
+    assert.equal(parsed.comment, undefined)
+    assert.equal(parsed.raw, "  *")
+    assert.equal(parsed.cleanedRaw, "*")
+})
+
+// invalid cases
+test("parse wildcard and none", () => {
+    expect(()=>parseRecord("*!")).toThrowError("fetched pronoun \"*!\" is not formatted correctly")
+})
+
+test("parse invalid tag", () => {
+    expect(() => parseRecord("she;meow")).toThrowError("fetched pronoun \"she;meow\" contains invalid tag(s)")
+})
+
+test("parse invalid pronoun set", () => {
+    expect(() => parseRecord("she/Ìê®;")).toThrowError("fetched pronoun \"she/Ìê®;\" contains invalid characters in its pronoun set")
+})
+test("parse invalid pronoun set 2", () => {
+    expect(() => parseRecord("she/")).toThrowError("fetched pronoun \"she/\" contains invalid characters in its pronoun set")
+})
+
+test("parse return null if errors are silenced", () => {
+    assert.equal(parseRecord("meow3", true), null)
+})
+
+// valid cases
+test("parse pronouns without tags or comments",() => {
+    const parsed = parseRecord("she/her") as PronounsRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "pronouns")
+    assert.equal(parsed.comment, undefined)
+    assert.equal(Array.isArray(parsed.tags), true)
+    assert.equal(parsed.tags[0], undefined)
+    assert.equal(parsed.raw, "she/her")
+    assert.equal(parsed.pronouns.subject, "she")
+    assert.equal(parsed.pronouns.object, "her")
+    assert.equal(parsed.cleanedRaw, "she/her")
+    assert.equal(parsed.pronouns.possessiveDeterminer, undefined)
+    assert.equal(parsed.pronouns.possessivePronoun, undefined)
+    assert.equal(parsed.pronouns.reflexive, undefined)
+})
+
+test("parse pronouns with a tag and a comment", () => {
+    const parsed = parseRecord("she/HUr/hur/HUR/hur; preferred  #O Cholera Czy To Freddy Fazbear") as PronounsRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "pronouns")
+    assert.equal(parsed.comment, "O Cholera Czy To Freddy Fazbear")
+    assert.equal(Array.isArray(parsed.tags), true)
+    assert.equal(parsed.tags[0], "preferred")
+    assert.equal(parsed.raw, "she/HUr/hur/HUR/hur; preferred  #O Cholera Czy To Freddy Fazbear")
+    assert.equal(parsed.cleanedRaw, "she/hur/hur/hur/hur")
+    assert.equal(parsed.pronouns.subject, "she")
+    assert.equal(parsed.pronouns.object, "hur")
+    assert.equal(parsed.pronouns.possessiveDeterminer, "hur")
+    assert.equal(parsed.pronouns.possessivePronoun, "hur")
+    assert.equal(parsed.pronouns.reflexive, "hur")
+})
+
+test("parse pronouns with multiple tags and a comment", () => {
+    const parsed = parseRecord("she/ HUr/hur/HUR/hur; preferred;;;plural  #O Cholera Czy To Freddy Fazbear") as PronounsRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "pronouns")
+    assert.equal(parsed.comment, "O Cholera Czy To Freddy Fazbear")
+    assert.equal(Array.isArray(parsed.tags), true)
+    assert.equal(parsed.tags[0], "preferred")
+    assert.equal(parsed.tags[1], "plural")
+    assert.equal(parsed.raw, "she/ HUr/hur/HUR/hur; preferred;;;plural  #O Cholera Czy To Freddy Fazbear")
+    assert.equal(parsed.cleanedRaw, "she/hur/hur/hur/hur")
+    assert.equal(parsed.pronouns.subject, "she")
+    assert.equal(parsed.pronouns.object, "hur")
+    assert.equal(parsed.pronouns.possessiveDeterminer, "hur")
+    assert.equal(parsed.pronouns.possessivePronoun, "hur")
+    assert.equal(parsed.pronouns.reflexive, "hur")
+})
+
+test("parse it/its", () => {
+    const parsed = parseRecord("it/its # meow!") as PronounsRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "pronouns")
+    assert.equal(parsed.comment, " meow!")
+    assert.equal(Array.isArray(parsed.tags), true)
+    assert.equal(parsed.tags[0], undefined)
+    assert.equal(parsed.raw, "it/its # meow!")
+    assert.equal(parsed.cleanedRaw, "it/its")
+    assert.equal(parsed.pronouns.subject, "it")
+    assert.equal(parsed.pronouns.object, "it")
+    assert.equal(parsed.pronouns.possessiveDeterminer, "its")
+    assert.equal(parsed.pronouns.possessivePronoun, "its")
+    assert.equal(parsed.pronouns.reflexive, "itself")
+})
+
+test("parse they/them is automatically plural", () => {
+    const parsed = parseRecord("they/them") as PronounsRecord;
+    assert.notEqual(parsed, null)
+    assert.equal(parsed.type, "pronouns")
+    assert.equal(parsed.comment, undefined)
+    assert.equal(Array.isArray(parsed.tags), true)
+    assert.equal(parsed.tags[0], "plural")
+    assert.equal(parsed.raw, "they/them")
+    assert.equal(parsed.cleanedRaw, "they/them")
+    assert.equal(parsed.pronouns.subject, "they")
+    assert.equal(parsed.pronouns.object, "them")
+    assert.equal(parsed.pronouns.possessiveDeterminer, undefined)
+    assert.equal(parsed.pronouns.possessivePronoun, undefined)
+    assert.equal(parsed.pronouns.reflexive, undefined)
+})

package/src/parser.ts

@@ -0,0 +1,119 @@
+import { CommentRecord, NoneRecord, PRONOUN_TAGS, PronounRecord, PronounsRecord, PronounTag, WildcardRecord } from "./types.js";
+
+/**
+ * Parses a record of pronouns
+ * @param record The record to parse
+ * @param silenceErrors Whether to silently error and return null or to `throw` errors
+ * @returns 
+ */
+export function parseRecord(record: string, silenceErrors = false): PronounRecord | null {
+    let parsed = record;
+    // separating the comment from the rest
+    let comment;
+    if (parsed.includes("#")) {
+        comment = record.split("#")[1]
+        parsed = record.split("#")[0]
+    }
+
+    // remove all whitespaces, make everything lowercase
+    parsed = parsed.trim().toLocaleLowerCase().replace(/\s/g, "")
+
+    // check special cases (wildcard, none, nothing other than a comment)
+    switch (parsed) {
+        case "*": {
+            return {
+                type: "wildcard",
+                comment: comment,
+                raw: record,
+                cleanedRaw: parsed
+            } as WildcardRecord
+        }
+        case "!": {
+            return {
+                type: "none",
+                comment: comment,
+                raw: record,
+                cleanedRaw: parsed
+            } as NoneRecord
+        }
+        case "": {
+            if (comment) {
+                return {
+                    type: "comment-only",
+                    comment: comment,
+                    raw: record,
+                    cleanedRaw: parsed
+                } as CommentRecord
+            } else {
+                return null;
+            }
+        }
+    }
+
+    // check for tags
+    let tags: PronounTag[] = [];
+    if (parsed.includes(";")) {
+        const parsedTags = parsed.split(";").slice(1);
+        for (const i in parsedTags) {
+            let t = parsedTags[i]
+            if (t == "") {
+                continue
+            }
+            if (!PRONOUN_TAGS.includes(t as PronounTag)) {
+                if (!silenceErrors) {
+                    throw Error("fetched pronoun \""+record+"\" contains invalid tag(s)")
+                } else {
+                    return null
+                }
+            }
+            if (!tags.includes(t as PronounTag)) {
+                tags.push(t as PronounTag)
+            }
+        }
+        parsed = parsed.split(";")[0]
+    }
+
+    // check for pronoun parts
+    let parts = parsed.split("/")
+    if (parts.length < 2 || parts.length > 5) {
+        if (!silenceErrors) {
+            throw Error("fetched pronoun \"" + record + "\" is not formatted correctly")
+        } else {
+            return null
+        }
+    }
+
+    for (const i in parts) {
+        if (!/^[a-z]+$/.test(parts[i])) {
+            if (!silenceErrors) {
+                throw Error("fetched pronoun \"" + record +"\" contains invalid characters in its pronoun set")
+            } else {
+                return null
+            }
+        }
+    }
+
+    // special cases
+    if (parts[0] == "it" && parts[1] == "its") {
+        parts = ["it","it","its","its","itself"]
+    }
+    if (parts[0] == "they" && parts[1] == "them" && !tags.includes("plural")) {
+        tags.push("plural")
+    }
+    
+    return {
+        pronouns: {
+            subject: parts[0],
+            object: parts[1],
+            possessiveDeterminer: parts[2],
+            possessivePronoun: parts[3],
+            reflexive: parts[4]
+
+        },
+        tags: tags,
+        type: "pronouns",
+        raw: record,
+        comment: comment,
+        cleanedRaw: parsed
+    } as PronounsRecord
+}

package/src/types.ts

@@ -0,0 +1,36 @@
+interface PronounSet {
+    subject: string;
+    object: string;
+    possessiveDeterminer?: string;
+    possessivePronoun?: string;
+    reflexive?: string;
+}
+
+export const PRONOUN_TAGS = ['preferred', 'plural'] as const;
+export type PronounTag = typeof PRONOUN_TAGS[number];
+
+interface Record {
+    raw: string;
+    cleanedRaw: string;
+    comment?: string;
+}
+
+export interface PronounsRecord extends Record {
+    type: 'pronouns';
+    pronouns: PronounSet;
+    tags: PronounTag[];
+}
+
+export interface WildcardRecord extends Record {
+    type: 'wildcard';
+}
+
+export interface NoneRecord extends Record {
+    type: 'none';
+}
+
+export interface CommentRecord extends Record {
+    type: 'comment-only'
+}
+
+export type PronounRecord = PronounsRecord | WildcardRecord | NoneRecord | CommentRecord;

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "nodenext",
+        "declaration": true,
+        "declarationMap": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "src/**/*.test.ts"
+    ]
+}