applesauce-common 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

package/dist/casts/zap.js

@@ -0,0 +1,47 @@
+import { of } from "rxjs";
+import { getZapAddressPointer, getZapAmount, getZapEventPointer, getZapPayment, getZapPreimage, getZapRecipient, getZapRequest, getZapSender, isValidZap, } from "../helpers/zap.js";
+import { EventCast } from "./cast.js";
+import { castUser } from "./user.js";
+// NOTE: extending BaseCast since there is no need for author$ or comments$
+/** Cast a kind 9735 event to a Zap */
+export class Zap extends EventCast {
+    constructor(event, store) {
+        if (!isValidZap(event))
+            throw new Error("Invalid zap");
+        super(event, store);
+    }
+    get sender() {
+        return castUser(getZapSender(this.event), this.store);
+    }
+    get recipient() {
+        return castUser(getZapRecipient(this.event), this.store);
+    }
+    get payment() {
+        return getZapPayment(this.event);
+    }
+    get amount() {
+        return getZapAmount(this.event);
+    }
+    get preimage() {
+        return getZapPreimage(this.event);
+    }
+    get request() {
+        return getZapRequest(this.event);
+    }
+    get addressPointer() {
+        return getZapAddressPointer(this.event);
+    }
+    get eventPointer() {
+        return getZapEventPointer(this.event);
+    }
+    /** An observable of the zapped event */
+    get event$() {
+        return this.$$ref("event$", (store) => {
+            if (this.addressPointer)
+                return store.replaceable(this.addressPointer);
+            if (this.eventPointer)
+                return store.event(this.eventPointer.id);
+            return of(undefined);
+        });
+    }
+}

package/dist/helpers/bookmark.d.ts

@@ -1,30 +1,31 @@
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
 import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+/** Type for a validated bookmark list event */
+export type BookmarkListEvent = KnownEvent<kinds.BookmarkList>;
+/** Type for a validated bookmark set event */
+export type BookmarkSetEvent = KnownEvent<kinds.Bookmarksets>;
+/** Validates that an event is a valid bookmark list (kind 10000) */
+export declare function isValidBookmarkList(event: NostrEvent): event is BookmarkListEvent;
+/** Validates that an event is a valid bookmark set (kind 30003) */
+export declare function isValidBookmarkSet(event: NostrEvent): event is BookmarkSetEvent;
 export declare const BookmarkPublicSymbol: unique symbol;
 export declare const BookmarkHiddenSymbol: unique symbol;
+export type BookmarkPointer = EventPointer | AddressPointer;
 /** Type for unlocked bookmarks events */
 export type UnlockedBookmarks = {
-    [BookmarkHiddenSymbol]: Bookmarks;
-};
-export type Bookmarks = {
-    notes: EventPointer[];
-    articles: AddressPointer[];
-    hashtags: string[];
-    urls: string[];
+    [BookmarkHiddenSymbol]: BookmarkPointer[];
 };
 /** Parses an array of tags into a {@link Bookmarks} object */
-export declare function parseBookmarkTags(tags: string[][]): Bookmarks;
+export declare function parseBookmarkTags(tags: string[][]): BookmarkPointer[];
 /** Merges any number of {@link Bookmarks} objects */
-export declare function mergeBookmarks(...bookmarks: (Bookmarks | undefined)[]): Bookmarks;
-/** Returns all the bookmarks of the event */
-export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
-/** Returns the public bookmarks of the event */
-export declare function getPublicBookmarks(bookmark: NostrEvent): Bookmarks;
+export declare function mergeBookmarks(...bookmarks: (BookmarkPointer[] | undefined)[]): BookmarkPointer[];
+/** Returns the bookmarks of the event */
+export declare function getBookmarks(bookmark: NostrEvent): BookmarkPointer[];
 /** Checks if the hidden bookmarks are unlocked */
 export declare function isHiddenBookmarksUnlocked<T extends NostrEvent>(bookmark: T): bookmark is T & UnlockedBookmarks;
 /** Returns the bookmarks of the event if its unlocked */
-export declare function getHiddenBookmarks<T extends NostrEvent & UnlockedBookmarks>(bookmark: T): Bookmarks;
-export declare function getHiddenBookmarks<T extends NostrEvent>(bookmark: T): Bookmarks | undefined;
+export declare function getHiddenBookmarks<T extends NostrEvent & UnlockedBookmarks>(bookmark: T): BookmarkPointer[];
+export declare function getHiddenBookmarks<T extends NostrEvent>(bookmark: T): BookmarkPointer[] | undefined;
 /** Unlocks the hidden bookmarks on a bookmarks event */
-export declare function unlockHiddenBookmarks(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<Bookmarks>;
+export declare function unlockHiddenBookmarks(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<BookmarkPointer[]>;

package/dist/helpers/bookmark.js

@@ -1,78 +1,65 @@
-import { getOrComputeCachedValue, notifyEventUpdate } from "applesauce-core/helpers";
+import { getOrComputeCachedValue, isATag, isETag, notifyEventUpdate, processTags } from "applesauce-core/helpers";
 import { kinds } from "applesauce-core/helpers/event";
 import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
-import { getAddressPointerFromATag, getReplaceableAddressFromPointer, getEventPointerFromETag, mergeAddressPointers, mergeEventPointers, } from "applesauce-core/helpers/pointers";
+import { getAddressPointerFromATag, getEventPointerFromETag, getReplaceableAddressFromPointer, isAddressPointer, isEventPointer, mergeAddressPointers, mergeEventPointers, } from "applesauce-core/helpers/pointers";
+/** Validates that an event is a valid bookmark list (kind 10000) */
+export function isValidBookmarkList(event) {
+    return event.kind === kinds.BookmarkList;
+}
+/** Validates that an event is a valid bookmark set (kind 30003) */
+export function isValidBookmarkSet(event) {
+    return event.kind === kinds.Bookmarksets;
+}
 export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
 export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
 /** Parses an array of tags into a {@link Bookmarks} object */
 export function parseBookmarkTags(tags) {
-    const notes = tags
-        .filter((t) => t[0] === "e" && t[1])
-        .map(getEventPointerFromETag)
-        .filter((pointer) => pointer !== null);
-    const articles = tags
-        .filter((t) => t[0] === "a" && t[1])
-        .map(getAddressPointerFromATag)
-        .filter((pointer) => pointer !== null)
-        .filter((pointer) => pointer.kind === kinds.LongFormArticle);
-    const hashtags = tags.filter((t) => t[0] === "t" && t[1]).map((t) => t[1]);
-    const urls = tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
-    return { notes, articles, hashtags, urls };
+    return processTags(tags, (t) => {
+        if (isETag(t))
+            return getEventPointerFromETag(t) ?? undefined;
+        if (isATag(t)) {
+            const pointer = getAddressPointerFromATag(t) ?? undefined;
+            // Ensure the address pointer is a long form article
+            if (pointer?.kind !== kinds.LongFormArticle)
+                return undefined;
+            return pointer;
+        }
+        return undefined;
+    });
 }
 /** Merges any number of {@link Bookmarks} objects */
 export function mergeBookmarks(...bookmarks) {
     const notes = new Map();
     const articles = new Map();
-    const hashtags = new Set();
-    const urls = new Set();
-    for (const bookmark of bookmarks) {
-        if (!bookmark)
-            continue;
-        for (const note of bookmark.notes) {
-            const existing = notes.get(note.id);
+    for (const pointer of bookmarks.flat()) {
+        if (isEventPointer(pointer)) {
+            const existing = notes.get(pointer.id);
             if (existing)
-                notes.set(note.id, mergeEventPointers(existing, note));
+                notes.set(pointer.id, mergeEventPointers(existing, pointer));
             else
-                notes.set(note.id, note);
+                notes.set(pointer.id, pointer);
         }
-        for (const article of bookmark.articles) {
-            const coord = getReplaceableAddressFromPointer(article);
-            const existing = articles.get(coord);
+        else if (isAddressPointer(pointer)) {
+            const address = getReplaceableAddressFromPointer(pointer);
+            const existing = articles.get(address);
             if (existing)
-                articles.set(coord, mergeAddressPointers(existing, article));
+                articles.set(address, mergeAddressPointers(existing, pointer));
             else
-                articles.set(coord, article);
+                articles.set(address, pointer);
         }
-        for (const hashtag of bookmark.hashtags)
-            hashtags.add(hashtag);
-        for (const url of bookmark.urls)
-            urls.add(url);
     }
-    return {
-        notes: Array.from(notes.values()),
-        articles: Array.from(articles.values()),
-        hashtags: Array.from(hashtags),
-        urls: Array.from(urls),
-    };
+    return [...notes.values(), ...articles.values()];
 }
-/** Returns all the bookmarks of the event */
+/** Returns the bookmarks of the event */
 export function getBookmarks(bookmark) {
-    const hidden = getHiddenBookmarks(bookmark);
-    if (hidden)
-        return mergeBookmarks(hidden, getPublicBookmarks(bookmark));
-    else
-        return getPublicBookmarks(bookmark);
-}
-/** Returns the public bookmarks of the event */
-export function getPublicBookmarks(bookmark) {
     return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
 }
 /** Checks if the hidden bookmarks are unlocked */
 export function isHiddenBookmarksUnlocked(bookmark) {
-    return isHiddenTagsUnlocked(bookmark) && Reflect.has(bookmark, BookmarkHiddenSymbol);
+    return (isHiddenTagsUnlocked(bookmark) && (BookmarkHiddenSymbol in bookmark || getHiddenBookmarks(bookmark) !== undefined));
 }
 export function getHiddenBookmarks(bookmark) {
-    if (isHiddenBookmarksUnlocked(bookmark))
+    if (BookmarkHiddenSymbol in bookmark)
         return bookmark[BookmarkHiddenSymbol];
     //get hidden tags
     const tags = getHiddenTags(bookmark);

package/dist/helpers/calendar-event.d.ts

@@ -1,8 +1,14 @@
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { ProfilePointer } from "applesauce-core/helpers/pointers";
 import { NameValueTag } from "applesauce-core/helpers/tags";
 export declare const DATE_BASED_CALENDAR_EVENT_KIND = 31922;
 export declare const TIME_BASED_CALENDAR_EVENT_KIND = 31923;
+export type DateBasedCalendarEvent = KnownEvent<typeof DATE_BASED_CALENDAR_EVENT_KIND>;
+export type TimeBasedCalendarEvent = KnownEvent<typeof TIME_BASED_CALENDAR_EVENT_KIND>;
+/** Checks if an event is a date-based calendar event */
+export declare function isValidDateBasedCalendarEvent(event: NostrEvent): event is DateBasedCalendarEvent;
+/** Checks if an event is a time-based calendar event */
+export declare function isValidTimeBasedCalendarEvent(event: NostrEvent): event is TimeBasedCalendarEvent;
 export type CalendarEventParticipant = ProfilePointer & {
     role?: string;
 };

package/dist/helpers/calendar-event.js

@@ -6,6 +6,14 @@ import { fillAndTrimTag, isPTag, isRTag, isTTag } from "applesauce-core/helpers/
 // NIP-52 Calendar Event Kinds
 export const DATE_BASED_CALENDAR_EVENT_KIND = 31922;
 export const TIME_BASED_CALENDAR_EVENT_KIND = 31923;
+/** Checks if an event is a date-based calendar event */
+export function isValidDateBasedCalendarEvent(event) {
+    return event.kind === DATE_BASED_CALENDAR_EVENT_KIND;
+}
+/** Checks if an event is a time-based calendar event */
+export function isValidTimeBasedCalendarEvent(event) {
+    return event.kind === TIME_BASED_CALENDAR_EVENT_KIND;
+}
 // Cache symbols for complex operations only
 export const CalendarEventLocationsSymbol = Symbol.for("calendar-event-locations");
 export const CalendarEventParticipantsSymbol = Symbol.for("calendar-event-participants");
@@ -62,16 +70,12 @@ export function getCalendarEventEnd(event) {
 }
 /** Gets all locations from a calendar event */
 export function getCalendarEventLocations(event) {
-    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
-        throw new Error("Event is not a date-based or time-based calendar event");
     return getOrComputeCachedValue(event, CalendarEventLocationsSymbol, () => {
         return event.tags.filter((t) => t[0] === "location" && t[1]).map((t) => t[1]);
     });
 }
 /** Gets the geohash of a calendar event */
 export function getCalendarEventGeohash(event) {
-    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
-        throw new Error("Event is not a date-based or time-based calendar event");
     return getOrComputeCachedValue(event, CalendarEventGeohashSymbol, () => {
         let hash = undefined;
         for (const tag of event.tags) {
@@ -83,8 +87,6 @@ export function getCalendarEventGeohash(event) {
 }
 /** Gets all participants from a calendar event */
 export function getCalendarEventParticipants(event) {
-    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
-        throw new Error("Event is not a date-based or time-based calendar event");
     return getOrComputeCachedValue(event, CalendarEventParticipantsSymbol, () => {
         return event.tags
             .filter(isPTag)
@@ -102,16 +104,12 @@ export function getCalendarEventParticipants(event) {
 }
 /** Gets all hashtags from a calendar event */
 export function getCalendarEventHashtags(event) {
-    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
-        throw new Error("Event is not a date-based or time-based calendar event");
     return getOrComputeCachedValue(event, CalendarEventHashtagsSymbol, () => {
         return event.tags.filter(isTTag).map((t) => t[1]);
     });
 }
 /** Gets all references from a calendar event */
 export function getCalendarEventReferences(event) {
-    if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
-        throw new Error("Event is not a date-based or time-based calendar event");
     return getOrComputeCachedValue(event, CalendarEventReferencesSymbol, () => {
         return event.tags.filter(isRTag).map((t) => t[1]);
     });

package/dist/helpers/channels.d.ts

@@ -8,6 +8,6 @@ export type ChannelMetadataContent = {
     relays?: string[];
 };
 /** Gets the parsed metadata on a channel creation or channel metadata event */
-export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent | null;
 /** gets the EventPointer for a channel message or metadata event */
 export declare function getChannelPointer(event: NostrEvent): EventPointer | undefined;

package/dist/helpers/channels.js

@@ -2,14 +2,11 @@ import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
 export const ChannelMetadataSymbol = Symbol.for("channel-metadata");
 function parseChannelMetadataContent(channel) {
     const metadata = JSON.parse(channel.content);
-    if (metadata.name === undefined)
-        throw new Error("Missing name");
-    if (metadata.about === undefined)
-        throw new Error("Missing about");
-    if (metadata.picture === undefined)
-        throw new Error("Missing picture");
-    if (metadata.relays && !Array.isArray(metadata.relays))
-        throw new Error("Invalid relays");
+    if (metadata.name === undefined ||
+        metadata.about === undefined ||
+        metadata.picture === undefined ||
+        (metadata.relays && !Array.isArray(metadata.relays)))
+        return null;
     return metadata;
 }
 /** Gets the parsed metadata on a channel creation or channel metadata event */

package/dist/helpers/comment.d.ts

@@ -1,5 +1,5 @@
 import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
-import { ExternalIdentifiers, ExternalPointer } from "applesauce-core/helpers/external-id";
+import { ExternalIdentifiers, ExternalPointer } from "./external-id.js";
 export declare const COMMENT_KIND = 1111;
 /** Type for validated comment events */
 export type CommentEvent = KnownEvent<typeof COMMENT_KIND>;
@@ -39,6 +39,8 @@ export declare function getCommentReplyPointer(comment: NostrEvent): CommentPoin
 export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
 /** Checks if a pointer is a {@link CommentAddressPointer} */
 export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;
+/** Checks if a pointer is a {@link CommentExternalPointer} */
+export declare function isCommentExternalPointer(pointer: any): pointer is CommentExternalPointer<keyof ExternalIdentifiers>;
 /** Checks if a comment event is valid */
 export declare function isValidComment(comment: NostrEvent): comment is CommentEvent;
 /** Create a set fo tags for a single CommentPointer */

package/dist/helpers/comment.js

@@ -1,9 +1,9 @@
 import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
 import { createReplaceableAddress, getTagValue, isAddressableKind, } from "applesauce-core/helpers/event";
-import { getExternalPointerFromTag } from "applesauce-core/helpers/external-id";
 import { getAddressPointerFromATag } from "applesauce-core/helpers/pointers";
 import { isSafeRelayURL } from "applesauce-core/helpers/relays";
 import { fillAndTrimTag } from "applesauce-core/helpers/tags";
+import { getExternalPointerFromTag } from "./external-id.js";
 export const COMMENT_KIND = 1111;
 export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
 export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
@@ -56,9 +56,12 @@ export function getCommentAddressPointer(tags, root = false) {
 export function getCommentExternalPointer(tags, root = false) {
     const iTag = tags.find((t) => t[0] === (root ? "I" : "i"));
     if (iTag) {
+        const pointer = getExternalPointerFromTag(iTag);
+        if (!pointer)
+            return null;
         return {
             type: "external",
-            ...getExternalPointerFromTag(iTag),
+            ...pointer,
         };
     }
     return null;
@@ -112,6 +115,13 @@ export function isCommentAddressPointer(pointer) {
         Reflect.has(pointer, "kind") &&
         typeof pointer.kind === "number");
 }
+/** Checks if a pointer is a {@link CommentExternalPointer} */
+export function isCommentExternalPointer(pointer) {
+    return (pointer?.type === "external" &&
+        Reflect.has(pointer, "kind") &&
+        Reflect.has(pointer, "identifier") &&
+        typeof pointer.kind === "string");
+}
 /** Checks if a comment event is valid */
 export function isValidComment(comment) {
     return (comment.kind === COMMENT_KIND && getCommentRootPointer(comment) !== null && getCommentReplyPointer(comment) !== null);

package/dist/helpers/encrypted-content-cache.js

@@ -1,8 +1,8 @@
 import { logger } from "applesauce-core";
 import { canHaveEncryptedContent, getEncryptedContent, isEncryptedContentUnlocked, setEncryptedContentCache, } from "applesauce-core/helpers/encrypted-content";
 import { kinds, notifyEventUpdate } from "applesauce-core/helpers/event";
-import { catchError, combineLatest, distinct, EMPTY, filter, isObservable, map, merge, mergeMap, of, switchMap, } from "rxjs";
-import { getGiftWrapSeal, getSealGiftWrap, getSealRumor } from "./gift-wrap.js";
+import { catchError, combineLatest, combineLatestWith, distinct, EMPTY, filter, isObservable, map, merge, mergeMap, of, switchMap, } from "rxjs";
+import { getGiftWrapSeal, getSealGiftWrap, getSealRumor, isGiftWrapUnlocked } from "./gift-wrap.js";
 /** A symbol that is used to mark encrypted content as being from a cache */
 export const EncryptedContentFromCacheSymbol = Symbol.for("encrypted-content-from-cache");
 /** Marks the encrypted content as being from a cache */
@@ -32,15 +32,20 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
         .pipe(
     // Look for events that support encrypted content and are locked
     filter((e) => canHaveEncryptedContent(e.kind) && isEncryptedContentUnlocked(e) === false), 
+    // Get the storage
+    combineLatestWith(storage$), 
     // Get the encrypted content from storage
-    mergeMap((event) => 
-    // Wait for storage to be available
-    storage$.pipe(switchMap((storage) => combineLatest([of(event), getItem(storage, event)])), catchError((error) => {
-        log(`Failed to restore encrypted content for ${event.id}`, error);
-        return EMPTY;
-    }))))
+    mergeMap(([event, storage]) => 
+    // Get content from storage
+    combineLatest([
+        of(event),
+        getItem(storage, event).catch((error) => {
+            log(`Failed to restore encrypted content for ${event.id}`, error);
+            return of(null);
+        }),
+    ])))
         .subscribe(async ([event, content]) => {
-        if (!content)
+        if (typeof content !== "string")
             return;
         // Restore the encrypted content and set it as from a cache
         markEncryptedContentFromCache(event);
@@ -79,14 +84,16 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
         log(`Restored encrypted content for ${seal.id}`);
     });
     // Persist encrypted content when it is updated or inserted
-    const persist = combineLatest([merge(eventStore.update$, eventStore.insert$), storage$])
+    const persist = merge(eventStore.update$, eventStore.insert$)
         .pipe(
     // Look for events that support encrypted content and are unlocked and not from the cache
-    filter(([event]) => canHaveEncryptedContent(event.kind) &&
+    filter((event) => canHaveEncryptedContent(event.kind) &&
         isEncryptedContentUnlocked(event) &&
-        !isEncryptedContentFromCache(event)), 
+        isEncryptedContentFromCache(event) === false), 
     // Only persist the encrypted content once
-    distinct(([event]) => event.id))
+    distinct((event) => event.id), 
+    // get the storage
+    combineLatestWith(storage$))
         .subscribe(async ([event, storage]) => {
         try {
             const content = getEncryptedContent(event);
@@ -102,18 +109,9 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     });
     // Persist seals when the gift warp is unlocked or inserted unlocked
     // This relies on the gift wrap event being updated when a seal is unlocked
-    const persistSeals = combineLatest([merge(eventStore.update$, eventStore.insert$), storage$])
-        .pipe(
-    // Look for gift wraps that are unlocked
-    filter(([event]) => event.kind === kinds.GiftWrap && isEncryptedContentUnlocked(event)), 
-    // Get the seal event
-    map(([gift, storage]) => [getGiftWrapSeal(gift), storage]), 
-    // Make sure the seal is defined
-    filter(([seal]) => seal !== undefined), 
-    // Make sure seal is unlocked and not from cache
-    filter(([seal]) => isEncryptedContentUnlocked(seal) && !isEncryptedContentFromCache(seal)), 
-    // Only persist the seal once
-    distinct(([seal]) => seal.id))
+    const unlockedSeals$ = merge(eventStore.update$, eventStore.insert$).pipe(filter((event) => event.kind === kinds.GiftWrap), filter(isGiftWrapUnlocked), map((gift) => getGiftWrapSeal(gift)), distinct((seal) => seal.id));
+    const persistSeals = unlockedSeals$
+        .pipe(filter((seal) => isEncryptedContentFromCache(seal) === false), combineLatestWith(storage$))
         .subscribe(async ([seal, storage]) => {
         if (!seal)
             return;

package/dist/helpers/external-id.d.ts

@@ -0,0 +1,32 @@
+export type ExternalIdentifiers = {
+    web: string;
+    "#": `#${string}`;
+    geo: `geo:${string}`;
+    isbn: `isbn:${string}`;
+    "podcast:guid": `podcast:guid:${string}`;
+    "podcast:item:guid": `podcast:item:guid:${string}`;
+    "podcast:publisher:guid": `podcast:publisher:guid:${string}`;
+    isan: `isan:${string}`;
+    doi: `doi:${string}`;
+    "bitcoin:tx": `bitcoin:tx:${string}`;
+    "bitcoin:address": `bitcoin:address:${string}`;
+    "ethereum:tx": `ethereum:${string}:tx:${string}`;
+    "ethereum:address": `ethereum:${string}:address:${string}`;
+    [key: `${string}:tx`]: `${string}:tx:${string}`;
+    [key: `${string}:address`]: `${string}:address:${string}`;
+};
+export type ExternalPointer<Prefix extends keyof ExternalIdentifiers> = {
+    kind: Prefix;
+    identifier: ExternalIdentifiers[Prefix];
+};
+export type ParseResult = {
+    [P in keyof ExternalIdentifiers]: ExternalPointer<P>;
+}[keyof ExternalIdentifiers];
+/** Casts a string to a valid external pointer */
+export declare function isValidExternalPointer(identifier: string): identifier is `${keyof ExternalIdentifiers}1${string}`;
+/** Parses a NIP-73 external identifier */
+export declare function parseExternalPointer<Prefix extends keyof ExternalIdentifiers>(identifier: `${Prefix}1${string}`): ExternalPointer<Prefix>;
+export declare function parseExternalPointer(identifier: string): ParseResult | null;
+/** Gets an ExternalPointer for a "i" tag */
+export declare function getExternalPointerFromTag<Prefix extends keyof ExternalIdentifiers>(tag: string[]): ExternalPointer<Prefix> | null;
+export declare function getExternalPointerFromTag(tag: string[]): ParseResult | null;

package/dist/helpers/external-id.js

@@ -0,0 +1,85 @@
+/** Casts a string to a valid external pointer */
+export function isValidExternalPointer(identifier) {
+    return parseExternalPointer(identifier) !== null;
+}
+/**
+ * Normalizes a URL according to NIP-73:
+ * - Removes fragment
+ * - Returns the normalized URL string
+ */
+function normalizeUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        urlObj.hash = ""; // Remove fragment
+        return urlObj.toString();
+    }
+    catch {
+        // If URL parsing fails, return original (will be caught by validation)
+        return url;
+    }
+}
+export function parseExternalPointer(identifier) {
+    // Check explicit prefixes first (these take precedence over URL parsing)
+    if (identifier.startsWith("#"))
+        return { kind: "#", identifier: identifier };
+    if (identifier.startsWith("geo:"))
+        return { kind: "geo", identifier: identifier };
+    if (identifier.startsWith("isbn:"))
+        return { kind: "isbn", identifier: identifier };
+    if (identifier.startsWith("podcast:guid:"))
+        return { kind: "podcast:guid", identifier: identifier };
+    if (identifier.startsWith("podcast:item:guid:"))
+        return { kind: "podcast:item:guid", identifier: identifier };
+    if (identifier.startsWith("podcast:publisher:guid:"))
+        return { kind: "podcast:publisher:guid", identifier: identifier };
+    if (identifier.startsWith("isan:"))
+        return { kind: "isan", identifier: identifier };
+    if (identifier.startsWith("doi:"))
+        return { kind: "doi", identifier: identifier };
+    // Check for blockchain identifiers
+    // Bitcoin: bitcoin:tx:<txid> or bitcoin:address:<address>
+    if (identifier.startsWith("bitcoin:tx:")) {
+        return { kind: "bitcoin:tx", identifier: identifier };
+    }
+    if (identifier.startsWith("bitcoin:address:")) {
+        return { kind: "bitcoin:address", identifier: identifier };
+    }
+    // Ethereum: ethereum:<chainId>:tx:<txHash> or ethereum:<chainId>:address:<address>
+    const ethereumTxMatch = identifier.match(/^ethereum:(\d+):tx:(.+)$/);
+    if (ethereumTxMatch) {
+        return { kind: "ethereum:tx", identifier: identifier };
+    }
+    const ethereumAddressMatch = identifier.match(/^ethereum:(\d+):address:(.+)$/);
+    if (ethereumAddressMatch) {
+        return { kind: "ethereum:address", identifier: identifier };
+    }
+    // Other blockchains: <blockchain>:tx:<txid> or <blockchain>:address:<address>
+    // Exclude known prefixes to avoid false matches
+    const blockchainTxMatch = identifier.match(/^([a-z0-9]+):tx:(.+)$/);
+    if (blockchainTxMatch && !identifier.startsWith("bitcoin:") && !identifier.startsWith("ethereum:")) {
+        const blockchain = blockchainTxMatch[1];
+        return { kind: `${blockchain}:tx`, identifier: identifier };
+    }
+    const blockchainAddressMatch = identifier.match(/^([a-z0-9]+):address:(.+)$/);
+    if (blockchainAddressMatch && !identifier.startsWith("bitcoin:") && !identifier.startsWith("ethereum:")) {
+        const blockchain = blockchainAddressMatch[1];
+        return { kind: `${blockchain}:address`, identifier: identifier };
+    }
+    // Check for URL (must be a valid URL, normalized, no fragment)
+    // URLs don't have a prefix, so we check if it's a valid URL after checking all prefixes
+    try {
+        new URL(identifier); // Validate URL
+        // Valid URL - normalize it (remove fragment) and return
+        const normalized = normalizeUrl(identifier);
+        return { kind: "web", identifier: normalized };
+    }
+    catch {
+        // Not a valid URL
+    }
+    return null;
+}
+export function getExternalPointerFromTag(tag) {
+    if (!tag[1])
+        return null;
+    return parseExternalPointer(tag[1]);
+}

package/dist/helpers/file-metadata.d.ts

@@ -35,10 +35,7 @@ export type FileMetadata = {
 };
 /** Alias for {@link FileMetadata} */
 export type MediaAttachment = FileMetadata;
-/**
- * Parses file metadata tags into {@link FileMetadata}
- * @throws
- */
+/** Parses file metadata tags into {@link FileMetadata} */
 export declare function parseFileMetadataTags(tags: string[][]): FileMetadata;
 /** Parses a imeta tag into a {@link FileMetadata} */
 export declare function getFileMetadataFromImetaTag(tag: string[]): FileMetadata;

package/dist/helpers/file-metadata.js

@@ -1,8 +1,5 @@
 import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
-/**
- * Parses file metadata tags into {@link FileMetadata}
- * @throws
- */
+/** Parses file metadata tags into {@link FileMetadata} */
 export function parseFileMetadataTags(tags) {
     const fields = {};
     let fallback = undefined;

package/dist/helpers/gift-wrap.js

@@ -1,4 +1,5 @@
 import { EventMemory } from "applesauce-core/event-store";
+import { safeParse } from "applesauce-core/helpers";
 import { getEncryptedContent, isEncryptedContentUnlocked, lockEncryptedContent, unlockEncryptedContent, } from "applesauce-core/helpers/encrypted-content";
 import { kinds, notifyEventUpdate, verifyWrappedEvent, } from "applesauce-core/helpers/event";
 /**
@@ -64,7 +65,7 @@ export function getRumorGiftWraps(rumor) {
 }
 /** Checks if a seal event is locked and casts it to the {@link UnlockedSeal} type */
 export function isSealUnlocked(seal) {
-    return isEncryptedContentUnlocked(seal) === true && Reflect.has(seal, RumorSymbol) === true;
+    return RumorSymbol in seal || (isEncryptedContentUnlocked(seal) === true && getSealRumor(seal) !== undefined);
 }
 /** Returns if a gift-wrap event or gift-wrap seal is locked */
 export function isGiftWrapUnlocked(gift) {
@@ -84,7 +85,7 @@ export function getSealRumor(seal) {
     if (seal.kind !== kinds.Seal)
         return undefined;
     // If unlocked return the rumor
-    if (isSealUnlocked(seal))
+    if (RumorSymbol in seal)
         return seal[RumorSymbol];
     // Get the encrypted content plaintext
     const content = getEncryptedContent(seal);
@@ -92,7 +93,12 @@ export function getSealRumor(seal) {
     if (!content)
         return undefined;
     // Parse the content as a rumor event
-    let rumor = JSON.parse(content);
+    let rumor = safeParse(content);
+    // Failed to parse rumor, save undefined and return undefined
+    if (!rumor) {
+        Reflect.set(seal, RumorSymbol, undefined);
+        return undefined;
+    }
     // Check if the rumor event already exists in the internal event set
     const existing = internalGiftWrapEvents.getEvent(rumor.id);
     if (existing)
@@ -112,8 +118,8 @@ export function getSealRumor(seal) {
 }
 export function getGiftWrapSeal(gift) {
     // Returned cached seal if it exists (downstream)
-    if (Reflect.has(gift, SealSymbol))
-        return Reflect.get(gift, SealSymbol);
+    if (SealSymbol in gift)
+        return gift[SealSymbol];
     // Get the encrypted content
     const content = getEncryptedContent(gift);
     // Return undefined if the content is not found