applesauce-core 1.2.0 → 2.1.0

package/dist/helpers/legacy-messages.js

@@ -0,0 +1,39 @@
+import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
+import { getTagValue } from "./index.js";
+/** Checks if a legacy direct message content is encrypted */
+export function isLegacyMessageLocked(event) {
+    return isEncryptedContentLocked(event);
+}
+/**
+ * Returns the corraspondant of a legacy direct message
+ * @throws if no corraspondant is found
+ */
+export function getLegacyMessageCorraspondant(message, self) {
+    const corraspondant = message.pubkey === self ? getTagValue(message, "p") : message.pubkey;
+    if (!corraspondant)
+        throw new Error("No corraspondant found");
+    return corraspondant;
+}
+/** Returns the parent message id of a legacy message */
+export function getLegacyMessageParent(message) {
+    return getTagValue(message, "e");
+}
+/**
+ * Returns the decrypted content of a direct message
+ * @param message - The message to decrypt
+ * @param self - The public key of the user
+ * @param signer - The signer to use to decrypt the message
+ * @returns The decrypted content of the message
+ */
+export async function unlockLegacyMessage(message, self, signer) {
+    const cached = getEncryptedContent(message);
+    if (cached)
+        return cached;
+    const corraspondant = getLegacyMessageCorraspondant(message, self);
+    // Unlock the encrypted content
+    return await unlockEncryptedContent(message, corraspondant, signer);
+}
+/** Clears the cached plaintext of a direct message */
+export async function lockLegacyMessage(message) {
+    lockEncryptedContent(message);
+}

package/dist/helpers/lists.d.ts

@@ -1,5 +1,5 @@
-import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 export declare const FAVORITE_RELAYS_KIND = 10012;
 export type ReadListTags = "public" | "hidden" | "all";
 /** Returns all the tags of a list or set */
@@ -28,6 +28,8 @@ export declare function isAddressPointerInList(list: NostrEvent, pointer: string
  * @param type - Which types of tags to check
  */
 export declare function isProfilePointerInList(list: NostrEvent, pointer: string | ProfilePointer, type?: ReadListTags): boolean;
+/** Returns if an event is in a list */
+export declare function isEventInList(list: NostrEvent, event: NostrEvent): boolean;
 /**
  * Returns all the EventPointer in a list or set
  * @param list - The list or set to get the event pointers from

package/dist/helpers/lists.js

@@ -1,9 +1,9 @@
 import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { getReplaceableIdentifier, isReplaceable } from "./event.js";
 import { getHiddenTags } from "./hidden-tags.js";
-import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "./pointers.js";
-import { isATag, isETag, isPTag, processTags } from "./tags.js";
-import { getReplaceableIdentifier } from "./event.js";
+import { getAddressPointerForEvent, getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "./pointers.js";
 import { mergeRelaySets } from "./relays.js";
+import { isATag, isETag, isPTag, processTags } from "./tags.js";
 export const FAVORITE_RELAYS_KIND = 10012;
 /** Returns all the tags of a list or set */
 export function getListTags(list, type) {
@@ -53,6 +53,12 @@ export function isProfilePointerInList(list, pointer, type) {
     const tags = getListTags(list, type);
     return tags.some((t) => t[0] === "p" && t[1] === pubkey);
 }
+/** Returns if an event is in a list */
+export function isEventInList(list, event) {
+    return isReplaceable(event.kind)
+        ? isAddressPointerInList(list, getAddressPointerForEvent(event))
+        : isEventPointerInList(list, event);
+}
 /**
  * Returns all the EventPointer in a list or set
  * @param list - The list or set to get the event pointers from

package/dist/helpers/messages.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Groups messages into bubble sets based on the pubkey and time
+ *
+ * @param messages - The messages to group
+ * @param buffer - Minimum number of seconds between message groups
+ * @returns The grouped messages
+ */
+export declare function groupMessageEvents<T extends {
+    created_at: number;
+    pubkey: string;
+}>(messages: T[], buffer?: number): T[][];

package/dist/helpers/messages.js

@@ -0,0 +1,19 @@
+/**
+ * Groups messages into bubble sets based on the pubkey and time
+ *
+ * @param messages - The messages to group
+ * @param buffer - Minimum number of seconds between message groups
+ * @returns The grouped messages
+ */
+export function groupMessageEvents(messages, buffer = 5 * 60) {
+    const groups = [];
+    for (const message of messages) {
+        const group = groups[groups.length - 1];
+        const last = group?.[0];
+        if (group && last?.pubkey === message.pubkey && Math.abs(message.created_at - last.created_at) < buffer)
+            group.push(message);
+        else
+            groups.push([message]);
+    }
+    return groups;
+}

package/dist/helpers/mutes.js

@@ -1,8 +1,8 @@
 import { kinds } from "nostr-tools";
-import { isETag, isPTag, isTTag } from "./tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
 import { getIndexableTags, getNip10References } from "./index.js";
+import { isETag, isPTag, isTTag } from "./tags.js";
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
 /** Merges any number of mute sets */

package/dist/helpers/pointers.d.ts

@@ -1,5 +1,6 @@
-import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { AddressPointer, EventPointer, ProfilePointer, decode } from "nostr-tools/nip19";
 import { NostrEvent } from "nostr-tools";
+export type DecodeResult = ReturnType<typeof decode>;
 export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
     identifier?: string;
 };
@@ -21,23 +22,23 @@ export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile
  */
 export declare function getEventPointerFromETag(tag: string[]): EventPointer;
 /**
- * Gets an EventPointer form a "q" tag
+ * Gets an EventPointer form a common "q" tag
  * @throws
  */
 export declare function getEventPointerFromQTag(tag: string[]): EventPointer;
 /**
- * Get an AddressPointer from an "a" tag
+ * Get an AddressPointer from a common "a" tag
  * @throws
  */
 export declare function getAddressPointerFromATag(tag: string[]): AddressPointer;
 /**
- * Gets a ProfilePointer from a "p" tag
+ * Gets a ProfilePointer from a common "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;
+/** Checks if a pointer is an AddressPointer */
 export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
+/** Checks if a pointer is an EventPointer */
 export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
 /** Returns the coordinate string for an AddressPointer */
 export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
@@ -46,10 +47,33 @@ export declare function getCoordinateFromAddressPointer(pointer: AddressPointer)
  * @throws
  */
 export declare function getAddressPointerForEvent(event: NostrEvent, relays?: string[]): AddressPointer;
+/** Returns an EventPointer for an event */
+export declare function getEventPointerForEvent(event: NostrEvent, relays?: string[]): EventPointer;
 /**
- * Returns an EventPointer for an event
+ * Returns a pointer for a given 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;
+/** Adds relay hints to a pointer object that has a relays array */
+export declare function addRelayHintsToPointer<T extends {
+    relays?: string[];
+}>(pointer: T, relays?: Iterable<string>): T;
+/** Gets the hex pubkey from any nip-19 encoded string */
+export declare function normalizeToPubkey(str: string): string;
+/** Converts hex to nsec strings into Uint8 secret keys */
+export declare function normalizeToSecretKey(str: string | Uint8Array): Uint8Array;
+/**
+ * Merges two event points and keeps all relays
+ * @throws if the ids are different
+ */
+export declare function mergeEventPointers(a: EventPointer, b: EventPointer): EventPointer;
+/**
+ * Merges two address pointers and keeps all relays
+ * @throws if the kinds, pubkeys, or identifiers are different
+ */
+export declare function mergeAddressPointers(a: AddressPointer, b: AddressPointer): AddressPointer;
+/**
+ * Merges two profile pointers and keeps all relays
+ * @throws if the pubkeys are different
+ */
+export declare function mergeProfilePointers(a: ProfilePointer, b: ProfilePointer): ProfilePointer;

package/dist/helpers/pointers.js

@@ -1,8 +1,10 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
-import { getPublicKey, kinds } from "nostr-tools";
+import { getPublicKey, kinds, nip19 } from "nostr-tools";
 import { getReplaceableIdentifier } from "./event.js";
 import { isAddressableKind } from "nostr-tools/kinds";
-import { isSafeRelayURL } from "./relays.js";
+import { isSafeRelayURL, mergeRelaySets } from "./relays.js";
+import { isHexKey } from "./string.js";
+import { hexToBytes } from "@noble/hashes/utils";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] ? parseInt(parts[0]) : undefined;
@@ -79,7 +81,7 @@ export function getEventPointerFromETag(tag) {
     return pointer;
 }
 /**
- * Gets an EventPointer form a "q" tag
+ * Gets an EventPointer form a common "q" tag
  * @throws
  */
 export function getEventPointerFromQTag(tag) {
@@ -93,7 +95,7 @@ export function getEventPointerFromQTag(tag) {
     return pointer;
 }
 /**
- * Get an AddressPointer from an "a" tag
+ * Get an AddressPointer from a common "a" tag
  * @throws
  */
 export function getAddressPointerFromATag(tag) {
@@ -105,44 +107,27 @@ export function getAddressPointerFromATag(tag) {
     return pointer;
 }
 /**
- * Gets a ProfilePointer from a "p" tag
+ * Gets a ProfilePointer from a common "p" tag
  * @throws
  */
 export function getProfilePointerFromPTag(tag) {
     if (!tag[1])
         throw new Error("Missing pubkey in tag");
+    if (!isHexKey(tag[1]))
+        throw new Error("Invalid pubkey");
     const pointer = { pubkey: tag[1] };
     if (tag[2] && isSafeRelayURL(tag[2]))
         pointer.relays = [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: getEventPointerFromETag(tag) };
-            case "a":
-                return {
-                    type: "naddr",
-                    data: getAddressPointerFromATag(tag),
-                };
-            case "p":
-                return { type: "nprofile", data: getProfilePointerFromPTag(tag) };
-            // NIP-18 quote tags
-            case "q":
-                return { type: "nevent", data: getEventPointerFromETag(tag) };
-        }
-    }
-    catch (error) { }
-    return null;
-}
+/** Checks if a pointer is an AddressPointer */
 export function isAddressPointer(pointer) {
     return (typeof pointer !== "string" &&
         Reflect.has(pointer, "identifier") &&
         Reflect.has(pointer, "pubkey") &&
         Reflect.has(pointer, "kind"));
 }
+/** Checks if a pointer is an EventPointer */
 export function isEventPointer(pointer) {
     return typeof pointer !== "string" && Reflect.has(pointer, "id");
 }
@@ -165,10 +150,7 @@ export function getAddressPointerForEvent(event, relays) {
         relays,
     };
 }
-/**
- * Returns an EventPointer for an event
- * @throws
- */
+/** Returns an EventPointer for an event */
 export function getEventPointerForEvent(event, relays) {
     return {
         id: event.id,
@@ -177,29 +159,83 @@ export function getEventPointerForEvent(event, relays) {
         relays,
     };
 }
-/** Returns a pointer for a given event */
+/**
+ * Returns a pointer for a given event
+ * @throws
+ */
 export function getPointerForEvent(event, relays) {
     if (kinds.isAddressableKind(event.kind)) {
-        const d = getReplaceableIdentifier(event);
         return {
             type: "naddr",
-            data: {
-                identifier: d,
-                kind: event.kind,
-                pubkey: event.pubkey,
-                relays,
-            },
+            data: getAddressPointerForEvent(event, relays),
         };
     }
     else {
         return {
             type: "nevent",
-            data: {
-                id: event.id,
-                kind: event.kind,
-                author: event.pubkey,
-                relays,
-            },
+            data: getEventPointerForEvent(event, relays),
         };
     }
 }
+/** Adds relay hints to a pointer object that has a relays array */
+export function addRelayHintsToPointer(pointer, relays) {
+    if (!relays)
+        return pointer;
+    else
+        return { ...pointer, relays: mergeRelaySets(relays, pointer.relays) };
+}
+/** Gets the hex pubkey from any nip-19 encoded string */
+export function normalizeToPubkey(str) {
+    if (isHexKey(str))
+        return str;
+    else {
+        const decode = nip19.decode(str);
+        const pubkey = getPubkeyFromDecodeResult(decode);
+        if (!pubkey)
+            throw new Error(`Cant find pubkey in ${decode.type}`);
+        return pubkey;
+    }
+}
+/** Converts hex to nsec strings into Uint8 secret keys */
+export function normalizeToSecretKey(str) {
+    if (str instanceof Uint8Array)
+        return str;
+    else if (isHexKey(str))
+        return hexToBytes(str);
+    else {
+        const decode = nip19.decode(str);
+        if (decode.type !== "nsec")
+            throw new Error(`Cant get secret key from ${decode.type}`);
+        return decode.data;
+    }
+}
+/**
+ * Merges two event points and keeps all relays
+ * @throws if the ids are different
+ */
+export function mergeEventPointers(a, b) {
+    if (a.id !== b.id)
+        throw new Error("Cant merge event pointers with different ids");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { id: a.id, kind: a.kind ?? b.kind, author: a.author ?? b.author, relays };
+}
+/**
+ * Merges two address pointers and keeps all relays
+ * @throws if the kinds, pubkeys, or identifiers are different
+ */
+export function mergeAddressPointers(a, b) {
+    if (a.kind !== b.kind || a.pubkey !== b.pubkey || a.identifier !== b.identifier)
+        throw new Error("Cant merge address pointers with different kinds, pubkeys, or identifiers");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { ...a, relays };
+}
+/**
+ * Merges two profile pointers and keeps all relays
+ * @throws if the pubkeys are different
+ */
+export function mergeProfilePointers(a, b) {
+    if (a.pubkey !== b.pubkey)
+        throw new Error("Cant merge profile pointers with different pubkeys");
+    const relays = mergeRelaySets(a.relays, b.relays);
+    return { ...a, relays };
+}

package/dist/helpers/profile.d.ts

@@ -21,5 +21,13 @@ export type ProfileContent = {
 export declare function getProfileContent(event: NostrEvent): ProfileContent;
 /** Checks if the content of the kind 0 event is valid JSON */
 export declare function isValidProfile(profile?: NostrEvent): boolean;
-/** Gets the display name from a profile with fallbacks */
-export declare function getDisplayName(metadata?: ProfileContent): string | undefined;
+/** Gets the profile picture from a nostr event or profile content with fallback */
+export declare function getProfilePicture(metadata: ProfileContent | NostrEvent | undefined): string | undefined;
+export declare function getProfilePicture(metadata: ProfileContent | NostrEvent | undefined, fallback: string): string;
+export declare function getProfilePicture(metadata: ProfileContent | NostrEvent | undefined, fallback?: string): string | undefined;
+/** Gets the display name from a profile with fallback */
+export declare function getDisplayName(metadata: NostrEvent, fallback?: string): string;
+export declare function getDisplayName(metadata: undefined): undefined;
+export declare function getDisplayName(metadata: ProfileContent | undefined): string | undefined;
+export declare function getDisplayName(metadata: ProfileContent | NostrEvent | undefined, fallback: string): string;
+export declare function getDisplayName(metadata: ProfileContent | NostrEvent | undefined, fallback?: string): string | undefined;

package/dist/helpers/profile.js

@@ -1,4 +1,5 @@
 import { kinds } from "nostr-tools";
+import { npubEncode } from "nostr-tools/nip19";
 import { getOrComputeCachedValue } from "./cache.js";
 export const ProfileContentSymbol = Symbol.for("profile-content");
 /** Returns the parsed profile content for a kind 0 event */
@@ -19,7 +20,7 @@ export function getProfileContent(event) {
 export function isValidProfile(profile) {
     if (!profile)
         return false;
-    if (profile.kind !== kinds.Metadata)
+    if (profile.kind !== kinds.Metadata && profile.kind !== kinds.Handlerinformation)
         return false;
     try {
         getProfileContent(profile);
@@ -29,7 +30,35 @@ export function isValidProfile(profile) {
         return false;
     }
 }
-/** Gets the display name from a profile with fallbacks */
-export function getDisplayName(metadata) {
-    return metadata?.display_name?.trim() || metadata?.displayName?.trim() || metadata?.name?.trim();
+export function getProfilePicture(metadata, fallback) {
+    if (!metadata)
+        return fallback;
+    // Get the metadata from the nostr event
+    if ("pubkey" in metadata && "id" in metadata && "sig" in metadata) {
+        if (isValidProfile(metadata))
+            metadata = getProfileContent(metadata);
+        else
+            metadata = undefined;
+    }
+    // Return the display name or fallback
+    return (metadata?.picture || metadata?.image || fallback)?.trim();
+}
+export function getDisplayName(metadata, fallback) {
+    if (!metadata)
+        return fallback;
+    // Get the metadata from the nostr event
+    if ("pubkey" in metadata && "id" in metadata && "sig" in metadata) {
+        // Set the fallback to the npub if not set
+        if (!fallback) {
+            const npub = npubEncode(metadata.pubkey);
+            fallback = npub.slice(0, 5 + 4) + "…" + npub.slice(-4);
+        }
+        // Get the profile content
+        if (isValidProfile(metadata))
+            metadata = getProfileContent(metadata);
+        else
+            metadata = undefined;
+    }
+    // Return the display name or fallback
+    return (metadata?.display_name || metadata?.displayName || metadata?.name || fallback)?.trim();
 }

package/dist/helpers/reactions.d.ts

@@ -0,0 +1,8 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+export declare const ReactionEventPointerSymbol: unique symbol;
+export declare const ReactionAddressPointerSymbol: unique symbol;
+/** Returns the EventPointer for a reaction event */
+export declare function getReactionEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Returns the AddressPointer for a reaction event */
+export declare function getReactionAddressPointer(event: NostrEvent): AddressPointer | undefined;

package/dist/helpers/reactions.js

@@ -0,0 +1,56 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event.js";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
+import { mergeRelaySets } from "./relays.js";
+import { isATag, isETag, isPTag } from "./tags.js";
+const isInteger = (str) => Number.isInteger(Number(str));
+export const ReactionEventPointerSymbol = Symbol("reaction-event-pointer");
+export const ReactionAddressPointerSymbol = Symbol("reaction-address-pointer");
+/** Returns the EventPointer for a reaction event */
+export function getReactionEventPointer(event) {
+    return getOrComputeCachedValue(event, ReactionEventPointerSymbol, () => {
+        const eTag = event.tags.find(isETag);
+        if (!eTag)
+            return undefined;
+        // Get the event pointer from the e tag
+        const pointer = getEventPointerFromETag(eTag);
+        if (!pointer)
+            return undefined;
+        // set the kind if there is a k tag
+        const k = getTagValue(event, "k");
+        if (k && isInteger(k))
+            pointer.kind = parseInt(k);
+        // Get the author from the p tag if not set
+        if (!pointer.author) {
+            const p = event.tags.find(isPTag);
+            if (p) {
+                const author = getProfilePointerFromPTag(p);
+                pointer.author = author.pubkey;
+                // Copy relay hints from "p" tag
+                if (author.relays)
+                    pointer.relays = mergeRelaySets(author.relays, pointer.relays);
+            }
+        }
+        return pointer;
+    });
+}
+/** Returns the AddressPointer for a reaction event */
+export function getReactionAddressPointer(event) {
+    return getOrComputeCachedValue(event, ReactionAddressPointerSymbol, () => {
+        const aTag = event.tags.find(isATag);
+        if (!aTag)
+            return undefined;
+        const pointer = getAddressPointerFromATag(aTag);
+        if (!pointer)
+            return undefined;
+        // Get extra relay hints from the p tag
+        const p = event.tags.find(isPTag);
+        if (p) {
+            const author = getProfilePointerFromPTag(p);
+            // Copy relay hints from "p" tag
+            if (author.relays)
+                pointer.relays = mergeRelaySets(author.relays, pointer.relays);
+        }
+        return pointer;
+    });
+}

package/dist/helpers/reports.d.ts

@@ -0,0 +1,28 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ParsedReportSymbol: unique symbol;
+export declare enum ReportReason {
+    nudity = "nudity",
+    malware = "malware",
+    profanity = "profanity",
+    illegal = "illegal",
+    spam = "spam",
+    impersonation = "impersonation",
+    other = "other"
+}
+export type ReportedUser = {
+    type: "user";
+    event: NostrEvent;
+    pubkey: string;
+    reason?: ReportReason;
+};
+export type ReportedEvent = {
+    type: "event";
+    event: NostrEvent;
+    comment?: string;
+    id: string;
+    pubkey: string;
+    reason?: ReportReason;
+    blobs?: string[];
+};
+/** Reads a report event as either a user or event report */
+export declare function getReported(report: NostrEvent): ReportedEvent | ReportedUser;

package/dist/helpers/reports.js

@@ -0,0 +1,38 @@
+import { isETag, isPTag } from "./tags.js";
+import { getOrComputeCachedValue } from "./cache.js";
+export const ParsedReportSymbol = Symbol("parsed-report");
+export var ReportReason;
+(function (ReportReason) {
+    ReportReason["nudity"] = "nudity";
+    ReportReason["malware"] = "malware";
+    ReportReason["profanity"] = "profanity";
+    ReportReason["illegal"] = "illegal";
+    ReportReason["spam"] = "spam";
+    ReportReason["impersonation"] = "impersonation";
+    ReportReason["other"] = "other";
+})(ReportReason || (ReportReason = {}));
+/** Reads a report event as either a user or event report */
+export function getReported(report) {
+    return getOrComputeCachedValue(report, ParsedReportSymbol, () => {
+        const p = report.tags.find(isPTag);
+        if (!p)
+            throw new Error("Report missing p tag");
+        const comment = report.content ? report.content.trim() : undefined;
+        const e = report.tags.find(isETag);
+        // Event report
+        if (e) {
+            const blobs = report.tags.filter((t) => t[0] === "x" && t[1]).map((t) => t[1]);
+            return {
+                type: "event",
+                event: report,
+                comment,
+                id: e[1],
+                pubkey: p[1],
+                reason: e[2],
+                blobs,
+            };
+        }
+        // User report
+        return { type: "user", event: report, comment, pubkey: p[1], reason: p[2] };
+    });
+}

package/dist/helpers/share.d.ts

@@ -1,4 +1,13 @@
 import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 export declare const SharedEventSymbol: unique symbol;
+export declare const SharedEventPointerSymbol: unique symbol;
+export declare const SharedAddressPointerSymbol: unique symbol;
+/** Returns the event pointer of a kind 6 or 16 share event */
+export declare function getSharedEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Returns the address pointer of a kind 6 or 16 share event */
+export declare function getSharedAddressPointer(event: NostrEvent): AddressPointer | undefined;
 /** Returns the stringified event in the content of a kind 6 or 16 share event */
-export declare function parseSharedEvent(event: NostrEvent): NostrEvent | undefined;
+export declare function getEmbededSharedEvent(event: NostrEvent): NostrEvent | undefined;
+/** @deprecated use getEmbededSharedEvent instead */
+export declare const parseSharedEvent: typeof getEmbededSharedEvent;

package/dist/helpers/share.js

@@ -1,12 +1,26 @@
-import { safeParse } from "./json.js";
+import { nip18 } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
+import { isATag } from "./tags.js";
+import { getAddressPointerFromATag } from "./pointers.js";
 export const SharedEventSymbol = Symbol.for("shared-event");
-/** Returns the stringified event in the content of a kind 6 or 16 share event */
-export function parseSharedEvent(event) {
-    return getOrComputeCachedValue(event, SharedEventSymbol, () => {
-        const json = safeParse(event.content);
-        if (!json)
-            return;
-        return json;
+export const SharedEventPointerSymbol = Symbol.for("shared-event-pointer");
+export const SharedAddressPointerSymbol = Symbol.for("shared-address-pointer");
+/** Returns the event pointer of a kind 6 or 16 share event */
+export function getSharedEventPointer(event) {
+    return getOrComputeCachedValue(event, SharedEventPointerSymbol, () => nip18.getRepostedEventPointer(event));
+}
+/** Returns the address pointer of a kind 6 or 16 share event */
+export function getSharedAddressPointer(event) {
+    return getOrComputeCachedValue(event, SharedAddressPointerSymbol, () => {
+        const a = event.tags.find(isATag);
+        if (!a)
+            return undefined;
+        return getAddressPointerFromATag(a);
     });
 }
+/** Returns the stringified event in the content of a kind 6 or 16 share event */
+export function getEmbededSharedEvent(event) {
+    return getOrComputeCachedValue(event, SharedEventSymbol, () => nip18.getRepostedEvent(event));
+}
+/** @deprecated use getEmbededSharedEvent instead */
+export const parseSharedEvent = getEmbededSharedEvent;

package/dist/helpers/url.d.ts

@@ -14,6 +14,10 @@ export declare function isStreamURL(url: string | URL): boolean;
 export declare function isAudioURL(url: string | URL): boolean;
 /** Tests if two URLs are the same */
 export declare function isSameURL(a: string | URL, b: string | URL): boolean;
+/** Adds a protocol to a URL string if its missing one */
+export declare function ensureProtocol(url: string, protocol?: string): string;
+/** Converts a URL to a WebSocket URL */
+export declare function ensureWebSocketURL<T extends string | URL>(url: T): T;
 /**
  * Normalizes a string into a relay URL
  * Does not remove the trailing slash