applesauce-common 0.0.0-next-20251220152312 → 0.0.0-next-20251231055351

package/dist/casts/relay-monitor.d.ts

@@ -0,0 +1,21 @@
+import { NostrEvent } from "applesauce-core/helpers";
+import { RelayMonitorAnnouncementEvent } from "../helpers/relay-discovery.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { RelayDiscovery } from "./relay-discovery.js";
+/** Cast a kind 10166 event to a RelayMonitor */
+export declare class RelayMonitor extends EventCast<RelayMonitorAnnouncementEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** Gets the frequency at which this monitor publishes events (in seconds) */
+    get frequency(): number | undefined;
+    /** Gets all timeout values from this monitor announcement */
+    get timeouts(): {
+        test?: string;
+        timeout: number;
+    }[];
+    /** Gets all checks conducted by this monitor */
+    get checks(): string[];
+    /** Gets the geohash from this monitor announcement (NIP-52 geohash) */
+    get geohash(): string | undefined;
+    /** Get the status of a relay from this monitor */
+    relayStatus(relay: string): import("../observable/chainable.js").ChainableObservable<RelayDiscovery | undefined>;
+}

package/dist/casts/relay-monitor.js

@@ -0,0 +1,41 @@
+import { switchMap } from "rxjs";
+import { getMonitorChecks, getMonitorFrequency, getMonitorGeohash, getMonitorTimeouts, isValidRelayMonitorAnnouncement, RELAY_DISCOVERY_KIND, } from "../helpers/relay-discovery.js";
+import { castEventStream } from "../observable/cast-stream.js";
+import { chainable } from "../observable/chainable.js";
+import { EventCast } from "./cast.js";
+import { RelayDiscovery } from "./relay-discovery.js";
+/** Cast a kind 10166 event to a RelayMonitor */
+export class RelayMonitor extends EventCast {
+    constructor(event, store) {
+        if (!isValidRelayMonitorAnnouncement(event))
+            throw new Error("Invalid relay monitor announcement");
+        super(event, store);
+    }
+    /** Gets the frequency at which this monitor publishes events (in seconds) */
+    get frequency() {
+        return getMonitorFrequency(this.event);
+    }
+    /** Gets all timeout values from this monitor announcement */
+    get timeouts() {
+        return getMonitorTimeouts(this.event);
+    }
+    /** Gets all checks conducted by this monitor */
+    get checks() {
+        return getMonitorChecks(this.event);
+    }
+    /** Gets the geohash from this monitor announcement (NIP-52 geohash) */
+    get geohash() {
+        return getMonitorGeohash(this.event);
+    }
+    /** Get the status of a relay from this monitor */
+    relayStatus(relay) {
+        return chainable(this.author.outboxes$.pipe(switchMap((outboxes) => this.store
+            .replaceable({
+            kind: RELAY_DISCOVERY_KIND,
+            pubkey: this.author.pubkey,
+            identifier: relay,
+            relays: outboxes,
+        })
+            .pipe(castEventStream(RelayDiscovery, this.store)))));
+    }
+}

package/dist/casts/report.d.ts

@@ -0,0 +1,31 @@
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { ReportReason, ReportedEvent, ReportedUser } from "../helpers/reports.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+declare const REPORT_KIND = 1984;
+/** Cast a kind 1984 event to a Report */
+export declare class Report extends EventCast<KnownEvent<typeof REPORT_KIND>> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** Get the parsed report data (either a user or event report) */
+    get reported(): ReportedEvent | ReportedUser | null;
+    /** Check if this is a user report */
+    get isUserReport(): boolean;
+    /** Check if this is an event report */
+    get isEventReport(): boolean;
+    /** Get the reason for the report */
+    get reason(): ReportReason | undefined;
+    /** Get the comment/content of the report */
+    get comment(): string | undefined;
+    /** Get the pubkey of the user being reported */
+    get reportedPubkey(): string | undefined;
+    /** Get the User being reported */
+    get reportedUser(): import("./user.js").User | undefined;
+    /** Get the event ID being reported (for event reports) */
+    get reportedEventId(): string | undefined;
+    /** Get the event being reported (for event reports) */
+    get reportedEvent$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+    /** Get the blob hashes being reported (for event reports with x tags) */
+    get blobs(): string[] | undefined;
+    /** Get the server URLs for blob reports */
+    get servers(): string[];
+}
+export {};

package/dist/casts/report.js

@@ -0,0 +1,74 @@
+import { of } from "rxjs";
+import { getReportServers, getReported } from "../helpers/reports.js";
+import { EventCast } from "./cast.js";
+import { castUser } from "./user.js";
+import { addRelayHintsToPointer } from "applesauce-core/helpers";
+const REPORT_KIND = 1984;
+function isValidReport(event) {
+    return event.kind === REPORT_KIND;
+}
+/** Cast a kind 1984 event to a Report */
+export class Report extends EventCast {
+    constructor(event, store) {
+        if (!isValidReport(event))
+            throw new Error("Invalid report");
+        super(event, store);
+    }
+    /** Get the parsed report data (either a user or event report) */
+    get reported() {
+        return getReported(this.event);
+    }
+    /** Check if this is a user report */
+    get isUserReport() {
+        return this.reported?.type === "user";
+    }
+    /** Check if this is an event report */
+    get isEventReport() {
+        return this.reported?.type === "event";
+    }
+    /** Get the reason for the report */
+    get reason() {
+        return this.reported?.reason;
+    }
+    /** Get the comment/content of the report */
+    get comment() {
+        if (!this.reported)
+            return undefined;
+        return this.reported.type === "event" ? this.reported.comment : this.reported.comment;
+    }
+    /** Get the pubkey of the user being reported */
+    get reportedPubkey() {
+        return this.reported?.pubkey;
+    }
+    /** Get the User being reported */
+    get reportedUser() {
+        const pubkey = this.reportedPubkey;
+        if (!pubkey)
+            return undefined;
+        return castUser(pubkey, this.store);
+    }
+    /** Get the event ID being reported (for event reports) */
+    get reportedEventId() {
+        return this.reported?.type === "event" ? this.reported.id : undefined;
+    }
+    /** Get the event being reported (for event reports) */
+    get reportedEvent$() {
+        return this.$$ref("reportedEvent$", (store) => {
+            const eventId = this.reportedEventId;
+            if (!eventId)
+                return of(undefined);
+            const pointer = {
+                id: eventId,
+            };
+            return store.event(addRelayHintsToPointer(pointer, this.seen));
+        });
+    }
+    /** Get the blob hashes being reported (for event reports with x tags) */
+    get blobs() {
+        return this.reported?.type === "event" ? this.reported.blobs : undefined;
+    }
+    /** Get the server URLs for blob reports */
+    get servers() {
+        return getReportServers(this.event);
+    }
+}

package/dist/casts/share.d.ts

@@ -1,6 +1,7 @@
 import { NostrEvent } from "applesauce-core/helpers/event";
 import { ShareEvent } from "../helpers/share.js";
 import { CastRefEventStore, EventCast } from "./cast.js";
+import { Reaction } from "./reaction.js";
 /** Cast class for kind 6 and 16 share events */
 export declare class Share extends EventCast<ShareEvent> {
     constructor(event: NostrEvent, store: CastRefEventStore);
@@ -10,4 +11,5 @@ export declare class Share extends EventCast<ShareEvent> {
     get sharedEventPointer(): import("nostr-tools/nip19").EventPointer;
     get sharedPointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer;
     get shared$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+    get reactions$(): import("../observable/chainable.js").ChainableObservable<Reaction[]>;
 }

package/dist/casts/share.js

@@ -1,5 +1,8 @@
 import { getEmbededSharedEvent, getSharedAddressPointer, getSharedEventPointer, isValidShare, } from "../helpers/share.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { castTimelineStream } from "../observable/cast-stream.js";
 import { EventCast } from "./cast.js";
+import { Reaction } from "./reaction.js";
 /** Cast class for kind 6 and 16 share events */
 export class Share extends EventCast {
     constructor(event, store) {
@@ -25,4 +28,7 @@ export class Share extends EventCast {
     get shared$() {
         return this.$$ref("shared$", (store) => store.event(this.sharedPointer));
     }
+    get reactions$() {
+        return this.$$ref("reactions$", (store) => store.model(ReactionsModel, this.event).pipe(castTimelineStream(Reaction, store)));
+    }
 }

package/dist/casts/torrent.d.ts

@@ -0,0 +1,31 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { TorrentEvent } from "../helpers/torrent.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { Comment } from "./comment.js";
+import { Reaction } from "./reaction.js";
+import { Zap } from "./zap.js";
+export declare class Torrent extends EventCast<TorrentEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** The BitTorrent info hash from the `x` tag */
+    get infoHash(): string;
+    /** The torrent title from the `title` tag */
+    get title(): string | undefined;
+    /** All file entries from `file` tags */
+    get files(): import("../helpers/torrent.js").TorrentFile[];
+    /** All tracker URLs from `tracker` tags */
+    get trackers(): string[];
+    /** The newznab category ID from the `i` tag with `newznab:` prefix */
+    get category(): number | undefined;
+    /** All search tags (for searchability) from `t` tags */
+    get searchTags(): string[];
+    /** The category path from the `tcat` identifier in `i` tags (e.g., "video,movie,4k") */
+    get categoryPath(): string | undefined;
+    /** All external identifiers from `i` tags (excluding tcat and newznab, which are handled separately) */
+    get externalIdentifiers(): import("../helpers/torrent.js").TorrentExternalIdentifier[];
+    /** The magnet link for the torrent, built from the info hash, trackers, and title */
+    get magnetLink(): string | undefined;
+    /** Gets the NIP-22 comments to this event */
+    get comments$(): import("../observable/chainable.js").ChainableObservable<Comment[]>;
+    get zaps$(): import("../observable/chainable.js").ChainableObservable<Zap[]>;
+    get reactions$(): import("../observable/chainable.js").ChainableObservable<Reaction[]>;
+}

package/dist/casts/torrent.js

@@ -0,0 +1,62 @@
+import { getTorrentCategory, getTorrentCategoryPath, getTorrentExternalIdentifiers, getTorrentFiles, getTorrentInfoHash, getTorrentMagnetLink, getTorrentSearchTags, getTorrentTitle, getTorrentTrackers, isValidTorrent, } from "../helpers/torrent.js";
+import { CommentsModel } from "../models/comments.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { EventZapsModel } from "../models/zaps.js";
+import { castTimelineStream } from "../observable/cast-stream.js";
+import { EventCast } from "./cast.js";
+import { Comment } from "./comment.js";
+import { Reaction } from "./reaction.js";
+import { Zap } from "./zap.js";
+export class Torrent extends EventCast {
+    constructor(event, store) {
+        if (!isValidTorrent(event))
+            throw new Error("Invalid torrent");
+        super(event, store);
+    }
+    /** The BitTorrent info hash from the `x` tag */
+    get infoHash() {
+        return getTorrentInfoHash(this.event);
+    }
+    /** The torrent title from the `title` tag */
+    get title() {
+        return getTorrentTitle(this.event);
+    }
+    /** All file entries from `file` tags */
+    get files() {
+        return getTorrentFiles(this.event);
+    }
+    /** All tracker URLs from `tracker` tags */
+    get trackers() {
+        return getTorrentTrackers(this.event);
+    }
+    /** The newznab category ID from the `i` tag with `newznab:` prefix */
+    get category() {
+        return getTorrentCategory(this.event);
+    }
+    /** All search tags (for searchability) from `t` tags */
+    get searchTags() {
+        return getTorrentSearchTags(this.event);
+    }
+    /** The category path from the `tcat` identifier in `i` tags (e.g., "video,movie,4k") */
+    get categoryPath() {
+        return getTorrentCategoryPath(this.event);
+    }
+    /** All external identifiers from `i` tags (excluding tcat and newznab, which are handled separately) */
+    get externalIdentifiers() {
+        return getTorrentExternalIdentifiers(this.event);
+    }
+    /** The magnet link for the torrent, built from the info hash, trackers, and title */
+    get magnetLink() {
+        return getTorrentMagnetLink(this.event);
+    }
+    /** Gets the NIP-22 comments to this event */
+    get comments$() {
+        return this.$$ref("comments$", (store) => store.model(CommentsModel, this.event).pipe(castTimelineStream(Comment, store)));
+    }
+    get zaps$() {
+        return this.$$ref("zaps$", (store) => store.model(EventZapsModel, this.event).pipe(castTimelineStream(Zap, store)));
+    }
+    get reactions$() {
+        return this.$$ref("reactions$", (store) => store.model(ReactionsModel, this.event).pipe(castTimelineStream(Reaction, store)));
+    }
+}

package/dist/casts/user.d.ts

@@ -33,6 +33,8 @@ export declare class User {
     get searchRelays$(): ChainableObservable<import("./relay-lists.js").SearchRelays | undefined>;
     get blockedRelays$(): ChainableObservable<import("./relay-lists.js").BlockedRelays | undefined>;
     get directMessageRelays$(): ChainableObservable<string[] | undefined>;
+    /** Gets the users list of NIP-29 groups */
+    get groups$(): ChainableObservable<import("./groups.js").GroupsList | undefined>;
     /** Get the latest live stream for the user */
     get live$(): ChainableObservable<import("./stream.js").Stream | undefined>;
 }

package/dist/casts/user.js

@@ -1,9 +1,10 @@
 import { isEvent, isHexKey, kinds, nprofileEncode, npubEncode, } from "applesauce-core/helpers";
 import { combineLatest, defer, from, map, switchMap, tap } from "rxjs";
+import { GROUPS_LIST_KIND } from "../helpers/groups.js";
+import { getRelaysFromList } from "../helpers/lists.js";
 import { FAVORITE_RELAYS_KIND } from "../helpers/relay-list.js";
 import { castEventStream } from "../observable/cast-stream.js";
 import { chainable } from "../observable/chainable.js";
-import { getRelaysFromList } from "../helpers/lists.js";
 export function castUser(user, store) {
     if (isEvent(user)) {
         return castUser(user.pubkey, store);
@@ -157,6 +158,17 @@ export class User {
             .replaceable({ kind: kinds.DirectMessageRelaysList, pubkey: this.pubkey, relays: outboxes })
             .pipe(map((event) => event && getRelaysFromList(event))))));
     }
+    /** Gets the users list of NIP-29 groups */
+    get groups$() {
+        return this.$$ref("groups$", (store) => combineLatest([
+            // Import the BlockedRelays class
+            defer(() => from(import("./groups.js").then((m) => m.GroupsList))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(switchMap(([GroupsList, outboxes]) => store
+            .replaceable({ kind: GROUPS_LIST_KIND, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(GroupsList, store)))));
+    }
     /** Get the latest live stream for the user */
     get live$() {
         return this.$$ref("live$", (store) => defer(() => import("./stream.js").then((m) => m.Stream)).pipe(switchMap((Stream) => store

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/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;