applesauce-core 0.8.0 → 0.10.0

package/dist/helpers/mailboxes.js

@@ -1,11 +1,12 @@
 import { safeRelayUrl } from "./relays.js";
+import { getOrComputeCachedValue } from "./cache.js";
 export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
 export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
 /**
  * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
  */
 export function getInboxes(event) {
-    if (!event[MailboxesInboxesSymbol]) {
+    return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
         const inboxes = [];
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
@@ -14,15 +15,14 @@ export function getInboxes(event) {
                     inboxes.push(url);
             }
         }
-        event[MailboxesInboxesSymbol] = inboxes;
-    }
-    return event[MailboxesInboxesSymbol];
+        return inboxes;
+    });
 }
 /**
  * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
  */
 export function getOutboxes(event) {
-    if (!event[MailboxesOutboxesSymbol]) {
+    return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
         const outboxes = [];
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
@@ -31,7 +31,6 @@ export function getOutboxes(event) {
                     outboxes.push(url);
             }
         }
-        event[MailboxesOutboxesSymbol] = outboxes;
-    }
-    return event[MailboxesOutboxesSymbol];
+        return outboxes;
+    });
 }

package/dist/helpers/mailboxes.test.js

@@ -1,3 +1,4 @@
+import { describe, test, expect } from "vitest";
 import { getInboxes, getOutboxes } from "./mailboxes.js";
 const emptyEvent = {
     kind: 10002,
@@ -14,33 +15,33 @@ describe("Mailboxes", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
         test("should remove bad urls", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "bad://inbox.com"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "something that is not a url"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com,wss://inbox.org"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
         });
         test("without marker", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com/"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
         test("with marker", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com/", "read"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
     });
     describe("getOutboxes", () => {
@@ -48,33 +49,33 @@ describe("Mailboxes", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
         test("should remove bad urls", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "bad://inbox.com"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "something that is not a url"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com,wss://inbox.org"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
         });
         test("without marker", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com/"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
         test("with marker", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com/", "write"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
     });
 });

package/dist/helpers/media-attachment.d.ts

@@ -0,0 +1,33 @@
+import { NostrEvent } from "nostr-tools";
+export type MediaAttachment = {
+    /** URL of the file */
+    url: string;
+    /** mime type */
+    type?: string;
+    /** sha256 hash of the file */
+    sha256?: string;
+    /** size of the file in bytes */
+    size?: number;
+    /** size of file in pixels in the form <width>x<height> */
+    dimensions?: string;
+    /** magnet */
+    magnet?: string;
+    /** torrent infohash */
+    infohash?: string;
+    /** URL to a thumbnail */
+    thumb?: string;
+    /** URL to a preview image with the same dimensions */
+    image?: string;
+    /** summary */
+    summary?: string;
+    /** description for accessability */
+    alt?: string;
+};
+/**
+ * Parses a imeta tag into a {@link MediaAttachment}
+ * @throws
+ */
+export declare function parseMediaAttachmentTag(tag: string[]): MediaAttachment;
+export declare const MediaAttachmentsSymbol: unique symbol;
+/** Gets all the media attachments on an event */
+export declare function getMediaAttachments(event: NostrEvent): MediaAttachment[];

package/dist/helpers/media-attachment.js

@@ -0,0 +1,60 @@
+import { getOrComputeCachedValue } from "./cache.js";
+/**
+ * Parses a imeta tag into a {@link MediaAttachment}
+ * @throws
+ */
+export function parseMediaAttachmentTag(tag) {
+    const parts = tag.slice(1);
+    const fields = {};
+    for (const part of parts) {
+        const match = part.match(/^(.+?)\s(.+)$/);
+        if (match) {
+            const [_, name, value] = match;
+            fields[name] = value;
+        }
+    }
+    if (!fields.url)
+        throw new Error("Missing required url in attachment");
+    const attachment = { url: fields.url };
+    // parse size
+    if (fields.size)
+        attachment.size = parseInt(fields.size);
+    // copy optional fields
+    if (fields.m)
+        attachment.type = fields.m;
+    if (fields.x)
+        attachment.sha256 = fields.x;
+    if (fields.dim)
+        attachment.dimensions = fields.dim;
+    if (fields.magnet)
+        attachment.magnet = fields.magnet;
+    if (fields.i)
+        attachment.infohash = fields.i;
+    if (fields.thumb)
+        attachment.thumb = fields.thumb;
+    if (fields.image)
+        attachment.image = fields.image;
+    if (fields.summary)
+        attachment.summary = fields.summary;
+    if (fields.alt)
+        attachment.alt = fields.alt;
+    return attachment;
+}
+export const MediaAttachmentsSymbol = Symbol.for("media-attachments");
+/** Gets all the media attachments on an event */
+export function getMediaAttachments(event) {
+    return getOrComputeCachedValue(event, MediaAttachmentsSymbol, () => {
+        return event.tags
+            .filter((t) => t[0] === "imeta")
+            .map((tag) => {
+            try {
+                return parseMediaAttachmentTag(tag);
+            }
+            catch (error) {
+                // ignore invalid attachments
+                return undefined;
+            }
+        })
+            .filter((a) => !!a);
+    });
+}

package/dist/helpers/pointers.d.ts

@@ -1,7 +1,9 @@
 import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
 export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
     identifier?: string;
 };
+/** Parse the value of an "a" tag into an AddressPointer */
 export declare function parseCoordinate(a: string): AddressPointerWithoutD | null;
 export declare function parseCoordinate(a: string, requireD: false): AddressPointerWithoutD | null;
 export declare function parseCoordinate(a: string, requireD: true): AddressPointer | null;
@@ -9,14 +11,45 @@ export declare function parseCoordinate(a: string, requireD: false, silent: fals
 export declare function parseCoordinate(a: string, requireD: true, silent: false): AddressPointer;
 export declare function parseCoordinate(a: string, requireD: true, silent: true): AddressPointer | null;
 export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
+/** Extra a pubkey from the result of nip19.decode */
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
-export declare function encodeDecodeResult(result: DecodeResult): "" | `nsec1${string}` | `npub1${string}` | `note1${string}` | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nrelay1${string}`;
-export declare function getEventPointerFromTag(tag: string[]): EventPointer;
-export declare function getAddressPointerFromTag(tag: string[]): AddressPointer;
-export declare function getProfilePointerFromTag(tag: string[]): ProfilePointer;
+/** Encodes the result of nip19.decode */
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
+/**
+ * Gets an EventPointer form a common "e" tag
+ * @throws
+ */
+export declare function getEventPointerFromETag(tag: string[]): EventPointer;
+/**
+ * Gets an EventPointer form a "q" tag
+ * @throws
+ */
+export declare function getEventPointerFromQTag(tag: string[]): EventPointer;
+/**
+ * Get an AddressPointer from an "a" tag
+ * @throws
+ */
+export declare function getAddressPointerFromATag(tag: string[]): AddressPointer;
+/**
+ * Gets a ProfilePointer from a "p" tag
+ * @throws
+ */
+export declare function getProfilePointerFromPTag(tag: string[]): ProfilePointer;
+/** Parses "e", "a", "p", and "q" tags into a pointer */
 export declare function getPointerFromTag(tag: string[]): DecodeResult | null;
 export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
 export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
+/** Returns the coordinate string for an AddressPointer */
 export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
-export declare function getATagFromAddressPointer(pointer: AddressPointer): ["a", ...string[]];
-export declare function getETagFromEventPointer(pointer: EventPointer): ["e", ...string[]];
+/**
+ * Returns an AddressPointer for a replaceable event
+ * @throws
+ */
+export declare function getAddressPointerForEvent(event: NostrEvent, relays?: string[]): AddressPointer;
+/**
+ * Returns an EventPointer for an event
+ * @throws
+ */
+export declare function getEventPointerForEvent(event: NostrEvent, relays?: string[]): EventPointer;
+/** Returns a pointer for a given event */
+export declare function getPointerForEvent(event: NostrEvent, relays?: string[]): DecodeResult;

package/dist/helpers/pointers.js

@@ -1,6 +1,8 @@
-import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nrelayEncode, nsecEncode, } from "nostr-tools/nip19";
-import { getPublicKey } from "nostr-tools";
+import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
+import { getPublicKey, kinds } from "nostr-tools";
 import { safeRelayUrls } from "./relays.js";
+import { getTagValue } from "./index.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] && parseInt(parts[0]);
@@ -30,6 +32,7 @@ export function parseCoordinate(a, requireD = false, silent = true) {
         identifier: d,
     };
 }
+/** Extra a pubkey from the result of nip19.decode */
 export function getPubkeyFromDecodeResult(result) {
     if (!result)
         return;
@@ -45,6 +48,7 @@ export function getPubkeyFromDecodeResult(result) {
             return undefined;
     }
 }
+/** Encodes the result of nip19.decode */
 export function encodeDecodeResult(result) {
     switch (result.type) {
         case "naddr":
@@ -53,8 +57,6 @@ export function encodeDecodeResult(result) {
             return nprofileEncode(result.data);
         case "nevent":
             return neventEncode(result.data);
-        case "nrelay":
-            return nrelayEncode(result.data);
         case "nsec":
             return nsecEncode(result.data);
         case "npub":
@@ -64,7 +66,11 @@ export function encodeDecodeResult(result) {
     }
     return "";
 }
-export function getEventPointerFromTag(tag) {
+/**
+ * Gets an EventPointer form a common "e" tag
+ * @throws
+ */
+export function getEventPointerFromETag(tag) {
     if (!tag[1])
         throw new Error("Missing event id in tag");
     let pointer = { id: tag[1] };
@@ -72,7 +78,25 @@ export function getEventPointerFromTag(tag) {
         pointer.relays = safeRelayUrls([tag[2]]);
     return pointer;
 }
-export function getAddressPointerFromTag(tag) {
+/**
+ * Gets an EventPointer form a "q" tag
+ * @throws
+ */
+export function getEventPointerFromQTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    if (tag[3] && tag[3].length === 64)
+        pointer.author = tag[3];
+    return pointer;
+}
+/**
+ * Get an AddressPointer from an "a" tag
+ * @throws
+ */
+export function getAddressPointerFromATag(tag) {
     if (!tag[1])
         throw new Error("Missing coordinate in tag");
     const pointer = parseCoordinate(tag[1], true, false);
@@ -80,7 +104,11 @@ export function getAddressPointerFromTag(tag) {
         pointer.relays = safeRelayUrls([tag[2]]);
     return pointer;
 }
-export function getProfilePointerFromTag(tag) {
+/**
+ * Gets a ProfilePointer from a "p" tag
+ * @throws
+ */
+export function getProfilePointerFromPTag(tag) {
     if (!tag[1])
         throw new Error("Missing pubkey in tag");
     const pointer = { pubkey: tag[1] };
@@ -88,18 +116,22 @@ export function getProfilePointerFromTag(tag) {
         pointer.relays = safeRelayUrls([tag[2]]);
     return pointer;
 }
+/** Parses "e", "a", "p", and "q" tags into a pointer */
 export function getPointerFromTag(tag) {
     try {
         switch (tag[0]) {
             case "e":
-                return { type: "nevent", data: getEventPointerFromTag(tag) };
+                return { type: "nevent", data: getEventPointerFromETag(tag) };
             case "a":
                 return {
                     type: "naddr",
-                    data: getAddressPointerFromTag(tag),
+                    data: getAddressPointerFromATag(tag),
                 };
             case "p":
-                return { type: "nprofile", data: getProfilePointerFromTag(tag) };
+                return { type: "nprofile", data: getProfilePointerFromPTag(tag) };
+            // NIP-18 quote tags
+            case "q":
+                return { type: "nevent", data: getEventPointerFromETag(tag) };
         }
     }
     catch (error) { }
@@ -107,21 +139,71 @@ export function getPointerFromTag(tag) {
 }
 export function isAddressPointer(pointer) {
     return (typeof pointer !== "string" &&
-        Object.hasOwn(pointer, "identifier") &&
-        Object.hasOwn(pointer, "pubkey") &&
-        Object.hasOwn(pointer, "kind"));
+        Reflect.has(pointer, "identifier") &&
+        Reflect.has(pointer, "pubkey") &&
+        Reflect.has(pointer, "kind"));
 }
 export function isEventPointer(pointer) {
-    return typeof pointer !== "string" && Object.hasOwn(pointer, "id");
+    return typeof pointer !== "string" && Reflect.has(pointer, "id");
 }
+/** Returns the coordinate string for an AddressPointer */
 export function getCoordinateFromAddressPointer(pointer) {
     return `${pointer.kind}:${pointer.pubkey}:${pointer.identifier}`;
 }
-export function getATagFromAddressPointer(pointer) {
-    const relay = pointer.relays?.[0];
-    const coordinate = getCoordinateFromAddressPointer(pointer);
-    return relay ? ["a", coordinate, relay] : ["a", coordinate];
+/**
+ * Returns an AddressPointer for a replaceable event
+ * @throws
+ */
+export function getAddressPointerForEvent(event, relays) {
+    if (!isParameterizedReplaceableKind(event.kind))
+        throw new Error("Cant get AddressPointer for non-replaceable event");
+    const d = getTagValue(event, "d");
+    if (!d)
+        throw new Error("Event missing identifier");
+    return {
+        identifier: d,
+        kind: event.kind,
+        pubkey: event.pubkey,
+        relays,
+    };
 }
-export function getETagFromEventPointer(pointer) {
-    return pointer.relays?.length ? ["e", pointer.id, pointer.relays[0]] : ["e", pointer.id];
+/**
+ * Returns an EventPointer for an event
+ * @throws
+ */
+export function getEventPointerForEvent(event, relays) {
+    return {
+        id: event.id,
+        kind: event.kind,
+        author: event.pubkey,
+        relays,
+    };
+}
+/** Returns a pointer for a given event */
+export function getPointerForEvent(event, relays) {
+    if (kinds.isParameterizedReplaceableKind(event.kind)) {
+        const d = getTagValue(event, "d");
+        if (!d)
+            throw new Error("Event missing identifier");
+        return {
+            type: "naddr",
+            data: {
+                identifier: d,
+                kind: event.kind,
+                pubkey: event.pubkey,
+                relays,
+            },
+        };
+    }
+    else {
+        return {
+            type: "nevent",
+            data: {
+                id: event.id,
+                kind: event.kind,
+                author: event.pubkey,
+                relays,
+            },
+        };
+    }
 }

package/dist/helpers/profile.d.ts

@@ -1,10 +1,5 @@
 import { NostrEvent } from "nostr-tools";
 export declare const ProfileContentSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [ProfileContentSymbol]?: ProfileContent | Error;
-    }
-}
 export type ProfileContent = {
     name?: string;
     display_name?: string;
@@ -21,5 +16,5 @@ export type ProfileContent = {
 };
 /** Returns the parsed profile content for a kind 0 event */
 export declare function getProfileContent(event: NostrEvent): ProfileContent;
-export declare function getProfileContent(event: NostrEvent, quite: false): ProfileContent;
-export declare function getProfileContent(event: NostrEvent, quite: true): ProfileContent | Error;
+/** Checks if the content of the kind 0 event is valid JSON */
+export declare function isValidProfile(profile?: NostrEvent): boolean;

package/dist/helpers/profile.js

@@ -1,28 +1,31 @@
+import { kinds } from "nostr-tools";
+import { getOrComputeCachedValue } from "./cache.js";
 export const ProfileContentSymbol = Symbol.for("profile-content");
-export function getProfileContent(event, quite = false) {
-    let cached = event[ProfileContentSymbol];
-    if (!cached) {
-        try {
-            const profile = JSON.parse(event.content);
-            // ensure nip05 is a string
-            if (profile.nip05 && typeof profile.nip05 !== "string")
-                profile.nip05 = String(profile.nip05);
-            cached = event[ProfileContentSymbol] = profile;
+/** Returns the parsed profile content for a kind 0 event */
+export function getProfileContent(event) {
+    return getOrComputeCachedValue(event, ProfileContentSymbol, () => {
+        const profile = JSON.parse(event.content);
+        // ensure nip05 is a string
+        if (profile.nip05 && typeof profile.nip05 !== "string")
+            profile.nip05 = String(profile.nip05);
+        // add missing protocol to website
+        if (profile.website && profile.website?.length > 0 && profile.website?.startsWith("http") === false) {
+            profile.website = "https://" + profile.website;
         }
-        catch (e) {
-            if (e instanceof Error)
-                cached = event[ProfileContentSymbol] = e;
-        }
-    }
-    if (cached === undefined) {
-        throw new Error("Failed to parse profile");
+        return profile;
+    });
+}
+/** Checks if the content of the kind 0 event is valid JSON */
+export function isValidProfile(profile) {
+    if (!profile)
+        return false;
+    if (profile.kind !== kinds.Metadata)
+        return false;
+    try {
+        getProfileContent(profile);
+        return true;
     }
-    else if (cached instanceof Error) {
-        if (!quite)
-            throw cached;
-        else
-            return cached;
+    catch (error) {
+        return false;
     }
-    else
-        return cached;
 }

package/dist/helpers/string.d.ts

@@ -1,4 +1,10 @@
+/** Tests if a string is hex */
 export declare function isHex(str?: string): boolean;
+/** Tests if a string is a 64 length hex string */
 export declare function isHexKey(key?: string): boolean;
+/**
+ * Remove invisible characters from a string
+ * @see read more https://www.regular-expressions.info/unicode.html#category
+ */
 export declare function stripInvisibleChar(str: string): string;
 export declare function stripInvisibleChar(str?: string | undefined): string | undefined;

package/dist/helpers/string.js

@@ -1,8 +1,10 @@
+/** Tests if a string is hex */
 export function isHex(str) {
     if (str?.match(/^[0-9a-f]+$/i))
         return true;
     return false;
 }
+/** Tests if a string is a 64 length hex string */
 export function isHexKey(key) {
     if (key?.toLowerCase()?.match(/^[0-9a-f]{64}$/))
         return true;

package/dist/helpers/tags.d.ts

@@ -1,6 +1,12 @@
+/** Checks if tag is an "e" tag and has at least one value */
 export declare function isETag(tag: string[]): tag is ["e", string, ...string[]];
+/** Checks if tag is an "p" tag and has at least one value */
 export declare function isPTag(tag: string[]): tag is ["p", string, ...string[]];
+/** Checks if tag is an "r" tag and has at least one value */
 export declare function isRTag(tag: string[]): tag is ["r", string, ...string[]];
+/** Checks if tag is an "d" tag and has at least one value */
 export declare function isDTag(tag: string[]): tag is ["d", string, ...string[]];
+/** Checks if tag is an "a" tag and has at least one value */
 export declare function isATag(tag: string[]): tag is ["a", string, ...string[]];
+/** Checks if tag is an "a" tag and has at least one value */
 export declare function isTTag(tag: string[]): tag is ["t", string, ...string[]];

package/dist/helpers/tags.js

@@ -1,18 +1,24 @@
+/** Checks if tag is an "e" tag and has at least one value */
 export function isETag(tag) {
     return tag[0] === "e" && tag[1] !== undefined;
 }
+/** Checks if tag is an "p" tag and has at least one value */
 export function isPTag(tag) {
     return tag[0] === "p" && tag[1] !== undefined;
 }
+/** Checks if tag is an "r" tag and has at least one value */
 export function isRTag(tag) {
     return tag[0] === "r" && tag[1] !== undefined;
 }
+/** Checks if tag is an "d" tag and has at least one value */
 export function isDTag(tag) {
     return tag[0] === "d" && tag[1] !== undefined;
 }
+/** Checks if tag is an "a" tag and has at least one value */
 export function isATag(tag) {
     return tag[0] === "a" && tag[1] !== undefined;
 }
+/** Checks if tag is an "a" tag and has at least one value */
 export function isTTag(tag) {
     return tag[0] === "a" && tag[1] !== undefined;
 }

package/dist/helpers/threading.d.ts

@@ -1,4 +1,4 @@
-import { NostrEvent } from "nostr-tools";
+import { EventTemplate, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 export type ThreadReferences = {
     root?: {
@@ -23,13 +23,13 @@ export type ThreadReferences = {
     };
 };
 export declare const Nip10ThreadRefsSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [Nip10ThreadRefsSymbol]?: ThreadReferences;
-    }
-}
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export declare function getEventPointerFromThreadTag(tag: string[]): EventPointer;
 /** Parses NIP-10 tags and handles legacy behavior */
-export declare function interpretThreadTags(event: NostrEvent): {
+export declare function interpretThreadTags(tags: string[][]): {
     root?: {
         e: string[];
         a: undefined;
@@ -39,7 +39,7 @@ export declare function interpretThreadTags(event: NostrEvent): {
     } | {
         e: string[];
         a: string[];
-    } | undefined;
+    };
     reply?: {
         e: string[];
         a: undefined;
@@ -49,7 +49,7 @@ export declare function interpretThreadTags(event: NostrEvent): {
     } | {
         e: string[];
         a: string[];
-    } | undefined;
+    };
 };
 /** Returns the parsed NIP-10 tags for an event */
-export declare function getNip10References(event: NostrEvent): ThreadReferences;
+export declare function getNip10References(event: NostrEvent | EventTemplate): ThreadReferences;