applesauce-core 0.9.0 → 0.11.0

package/dist/helpers/blossom.js

@@ -0,0 +1,22 @@
+import { isNameValueTag, processTags } from "./tags.js";
+export const BLOSSOM_SERVER_LIST_KIND = 10063;
+/** Check if two servers are the same */
+export function areBlossomServersEqual(a, b) {
+    const hostnameA = new URL("/", a).toString();
+    const hostnameB = new URL("/", b).toString();
+    return hostnameA === hostnameB;
+}
+/** Checks if a string is a sha256 hash */
+export function isSha256(str) {
+    return !!str.match(/^[0-9a-f]{64}$/);
+}
+/** Returns an ordered array of servers found in a server list event (10063) */
+export function getBlossomServersFromList(event) {
+    const tags = Array.isArray(event) ? event : event.tags;
+    return processTags(tags, (tag) => {
+        if (isNameValueTag(tag, "server") && URL.canParse(tag[1]))
+            return new URL("/", tag[1]);
+        else
+            return undefined;
+    });
+}

package/dist/helpers/bolt11.d.ts

@@ -5,4 +5,5 @@ export type ParsedInvoice = {
     timestamp: number;
     expiry: number;
 };
+/** Parses a lightning invoice */
 export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -1,4 +1,5 @@
 import { decode } from "light-bolt11-decoder";
+/** Parses a lightning invoice */
 export function parseBolt11(paymentRequest) {
     const decoded = decode(paymentRequest);
     const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;

package/dist/helpers/bookmarks.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+export declare const BookmarkPublicSymbol: unique symbol;
+export declare const BookmarkHiddenSymbol: unique symbol;
+export type Bookmarks = {
+    notes: EventPointer[];
+    articles: AddressPointer[];
+    hashtags: string[];
+    urls: string[];
+};
+export declare function parseBookmarkTags(tags: string[][]): Bookmarks;
+/** Returns the public bookmarks of the event */
+export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
+/** Returns the bookmarks of the event if its unlocked */
+export declare function getHiddenBookmarks(bookmark: NostrEvent): Bookmarks | undefined;

package/dist/helpers/bookmarks.js

@@ -0,0 +1,27 @@
+import { kinds } from "nostr-tools";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getHiddenTags } from "./index.js";
+export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
+export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
+export function parseBookmarkTags(tags) {
+    const notes = tags.filter((t) => t[0] === "e" && t[1]).map(getEventPointerFromETag);
+    const articles = tags
+        .filter((t) => t[0] === "a" && t[1])
+        .map(getAddressPointerFromATag)
+        .filter((addr) => addr.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 };
+}
+/** Returns the public bookmarks of the event */
+export function getBookmarks(bookmark) {
+    return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
+}
+/** Returns the bookmarks of the event if its unlocked */
+export function getHiddenBookmarks(bookmark) {
+    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => {
+        const tags = getHiddenTags(bookmark);
+        return tags && parseBookmarkTags(tags);
+    });
+}

package/dist/helpers/channels.d.ts

@@ -0,0 +1,10 @@
+import { nip19, NostrEvent } from "nostr-tools";
+import { ChannelMetadata } from "nostr-tools/nip28";
+export declare const ChannelMetadataSymbol: unique symbol;
+export type ChannelMetadataContent = ChannelMetadata & {
+    relays?: string[];
+};
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+/** gets the EventPointer for a channel message or metadata event */
+export declare function getChannelPointer(event: NostrEvent): nip19.EventPointer | undefined;

package/dist/helpers/channels.js

@@ -0,0 +1,27 @@
+import { getOrComputeCachedValue } from "./cache.js";
+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");
+    return metadata;
+}
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export function getChannelMetadataContent(channel) {
+    return getOrComputeCachedValue(channel, ChannelMetadataSymbol, () => {
+        return parseChannelMetadataContent(channel);
+    });
+}
+/** gets the EventPointer for a channel message or metadata event */
+export function getChannelPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e" && t[1]);
+    if (!tag)
+        return undefined;
+    return tag[2] ? { id: tag[1], relays: [tag[2]] } : { id: tag[1] };
+}

package/dist/helpers/comment.d.ts

@@ -0,0 +1,47 @@
+import { NostrEvent } from "nostr-tools";
+import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
+export declare const COMMENT_KIND = 1111;
+export type CommentEventPointer = {
+    id: string;
+    kind: number;
+    pubkey?: string;
+    relay?: string;
+};
+export type CommentAddressPointer = {
+    id?: string;
+    kind: number;
+    pubkey: string;
+    identifier: string;
+    relay?: string;
+};
+export type CommentExternalPointer = ExternalPointer<keyof ExternalIdentifiers>;
+export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer;
+export declare const CommentRootPointerSymbol: unique symbol;
+export declare const CommentReplyPointerSymbol: unique symbol;
+/**
+ * Gets the EventPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentEventPointer(tags: string[][], root?: boolean): CommentEventPointer | null;
+/**
+ * Gets the AddressPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentAddressPointer(tags: string[][], root?: boolean): CommentAddressPointer | null;
+/**
+ * Gets the ExternalPointer from an array of tags
+ * @throws
+ */
+export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer | null;
+/**
+ * Returns the root pointer for a comment
+ * @throws
+ */
+export declare function getCommentRootPointer(comment: NostrEvent): CommentPointer | null;
+/**
+ * Returns the reply pointer for a comment
+ * @throws
+ */
+export declare function getCommentReplyPointer(comment: NostrEvent): CommentPointer | null;
+export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
+export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;

package/dist/helpers/comment.js

@@ -0,0 +1,120 @@
+import { getExternalPointerFromTag } from "./external-id.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+import { isSafeRelayURL } from "./relays.js";
+export const COMMENT_KIND = 1111;
+export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
+export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
+/**
+ * Gets the EventPointer from an array of tags
+ * @throws
+ */
+export function getCommentEventPointer(tags, root = false) {
+    const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (eTag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        // only the root pubkey can be gotten from the tags, since due to quotes and mentions there will be many "p" tags for replies
+        const rootPubkey = root ? tags.find((t) => t[0] === "P")?.[1] : undefined;
+        const pointer = {
+            id: eTag[1],
+            kind: parseInt(kind),
+            pubkey: eTag[3] || rootPubkey || undefined,
+            relay: eTag[2] && isSafeRelayURL(eTag[2]) ? eTag[2] : undefined,
+        };
+        return pointer;
+    }
+    return null;
+}
+/**
+ * Gets the AddressPointer from an array of tags
+ * @throws
+ */
+export function getCommentAddressPointer(tags, root = false) {
+    const aTag = tags.find((t) => t[0] === (root ? "A" : "a"));
+    const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (aTag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        const addressPointer = getAddressPointerFromATag(aTag);
+        const pointer = {
+            id: eTag?.[1],
+            pubkey: addressPointer.pubkey,
+            identifier: addressPointer.identifier,
+            kind: addressPointer.kind || parseInt(kind),
+            relay: addressPointer.relays?.[0] || eTag?.[2],
+        };
+        return pointer;
+    }
+    return null;
+}
+/**
+ * Gets the ExternalPointer from an array of tags
+ * @throws
+ */
+export function getCommentExternalPointer(tags, root = false) {
+    const iTag = tags.find((t) => t[0] === (root ? "I" : "i"));
+    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
+    if (iTag) {
+        if (!kind)
+            throw new Error("Missing kind tag");
+        return getExternalPointerFromTag(iTag);
+    }
+    return null;
+}
+/**
+ * Returns the root pointer for a comment
+ * @throws
+ */
+export function getCommentRootPointer(comment) {
+    if (comment.kind !== COMMENT_KIND)
+        throw new Error("Event is not a comment");
+    return getOrComputeCachedValue(comment, CommentRootPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, true);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, true);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, true);
+        if (I)
+            return I;
+        return null;
+    });
+}
+/**
+ * Returns the reply pointer for a comment
+ * @throws
+ */
+export function getCommentReplyPointer(comment) {
+    if (comment.kind !== COMMENT_KIND)
+        throw new Error("Event is not a comment");
+    return getOrComputeCachedValue(comment, CommentReplyPointerSymbol, () => {
+        // check for address pointer first since it can also have E tags
+        const A = getCommentAddressPointer(comment.tags, false);
+        if (A)
+            return A;
+        const E = getCommentEventPointer(comment.tags, false);
+        if (E)
+            return E;
+        const I = getCommentExternalPointer(comment.tags, false);
+        if (I)
+            return I;
+        return null;
+    });
+}
+export function isCommentEventPointer(pointer) {
+    return (Reflect.has(pointer, "id") &&
+        Reflect.has(pointer, "kind") &&
+        !Reflect.has(pointer, "identifier") &&
+        typeof pointer.kind === "number");
+}
+export function isCommentAddressPointer(pointer) {
+    return (Reflect.has(pointer, "identifier") &&
+        Reflect.has(pointer, "pubkey") &&
+        Reflect.has(pointer, "kind") &&
+        typeof pointer.kind === "number");
+}

package/dist/helpers/contacts.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ContactsRelaysSymbol: unique symbol;
+export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "all" | "inbox" | "outbox"> | null;

package/dist/helpers/contacts.js

@@ -0,0 +1,25 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { isSafeRelayURL } from "./relays.js";
+export const ContactsRelaysSymbol = Symbol.for("contacts-relays");
+export function getRelaysFromContactsEvent(event) {
+    return getOrComputeCachedValue(event, ContactsRelaysSymbol, () => {
+        try {
+            const relayJson = JSON.parse(event.content);
+            const relays = new Map();
+            for (const [url, opts] of Object.entries(relayJson)) {
+                if (!isSafeRelayURL(url))
+                    continue;
+                if (opts.write && opts.read)
+                    relays.set(url, "all");
+                else if (opts.read)
+                    relays.set(url, "inbox");
+                else if (opts.write)
+                    relays.set(url, "outbox");
+            }
+            return relays;
+        }
+        catch (error) {
+            return null;
+        }
+    });
+}

package/dist/helpers/content.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export declare function getContentWarning(event: NostrEvent): string | boolean;

package/dist/helpers/content.js

@@ -0,0 +1,8 @@
+/** Returns the NIP-36 content-warning for an event. returns boolean if there is no "reason" */
+export function getContentWarning(event) {
+    const tag = event.tags.find((t) => t[0] === "content-warning");
+    if (tag)
+        return tag[1] || true;
+    else
+        return false;
+}

package/dist/helpers/delete.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+export declare function getDeleteIds(deleteEvent: NostrEvent): string[];
+export declare function getDeleteCoordinates(deleteEvent: NostrEvent): string[];

package/dist/helpers/delete.js

@@ -0,0 +1,7 @@
+import { isATag, isETag } from "./tags.js";
+export function getDeleteIds(deleteEvent) {
+    return deleteEvent.tags.filter(isETag).map((t) => t[1]);
+}
+export function getDeleteCoordinates(deleteEvent) {
+    return deleteEvent.tags.filter(isATag).map((t) => t[1]);
+}

package/dist/helpers/dns-identity.d.ts

@@ -0,0 +1,7 @@
+import { isNip05, NIP05_REGEX } from "nostr-tools/nip05";
+/** Returns the name and domain for a NIP-05 address */
+export declare function parseNIP05Address(address: string): {
+    name: string;
+    domain: string;
+} | null;
+export { isNip05, NIP05_REGEX };

package/dist/helpers/dns-identity.js

@@ -0,0 +1,10 @@
+import { isNip05, NIP05_REGEX } from "nostr-tools/nip05";
+/** Returns the name and domain for a NIP-05 address */
+export function parseNIP05Address(address) {
+    const match = address.toLowerCase().match(NIP05_REGEX);
+    if (!match)
+        return null;
+    const [, name = "_", domain] = match;
+    return { name, domain };
+}
+export { isNip05, NIP05_REGEX };

package/dist/helpers/emoji.d.ts

@@ -1,2 +1,13 @@
 import { EventTemplate, NostrEvent } from "nostr-tools";
-export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: string): ["emoji", string, string];
+/** Gets an "emoji" tag that matches an emoji code */
+export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: string): ["emoji", string, string] | undefined;
+/** Returns the name of a NIP-30 emoji pack */
+export declare function getPackName(pack: NostrEvent): string | undefined;
+export type Emoji = {
+    /** The emoji shortcode (without the ::) */
+    shortcode: string;
+    /** The URL to the emoji image */
+    url: string;
+};
+/** Returns an array of emojis from a NIP-30 emoji pack */
+export declare function getEmojis(pack: NostrEvent): Emoji[];

package/dist/helpers/emoji.js

@@ -1,4 +1,16 @@
+import { getTagValue } from "./event.js";
+/** Gets an "emoji" tag that matches an emoji code */
 export function getEmojiTag(event, code) {
     code = code.replace(/^:|:$/g, "").toLocaleLowerCase();
-    return event.tags.filter((t) => t[0] === "emoji" && t[1] && t[2]).find((t) => t[1].toLowerCase() === code);
+    return event.tags.find((t) => t[0] === "emoji" && t.length >= 3 && t[1].toLowerCase() === code);
+}
+/** Returns the name of a NIP-30 emoji pack */
+export function getPackName(pack) {
+    return getTagValue(pack, "title") || getTagValue(pack, "d");
+}
+/** Returns an array of emojis from a NIP-30 emoji pack */
+export function getEmojis(pack) {
+    return pack.tags
+        .filter((t) => t[0] === "emoji" && t[1] && t[2])
+        .map((t) => ({ shortcode: t[1], url: t[2] }));
 }

package/dist/helpers/event.d.ts

@@ -1,7 +1,8 @@
-import { NostrEvent, VerifiedEvent } from "nostr-tools";
+import { EventTemplate, NostrEvent, VerifiedEvent } from "nostr-tools";
 export declare const EventUIDSymbol: unique symbol;
 export declare const EventIndexableTagsSymbol: unique symbol;
 export declare const FromCacheSymbol: unique symbol;
+export declare const ReplaceableIdentifierSymbol: unique symbol;
 declare module "nostr-tools" {
     interface Event {
         [EventUIDSymbol]?: string;
@@ -9,6 +10,11 @@ declare module "nostr-tools" {
         [FromCacheSymbol]?: boolean;
     }
 }
+/**
+ * Checks if an object is a nostr event
+ * NOTE: does not validation the signature on the event
+ */
+export declare function isEvent(event: any): event is NostrEvent;
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )
@@ -24,11 +30,19 @@ export declare function getEventUID(event: NostrEvent): string;
 export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
 /** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
-/** Returns the second index ( tag[1] ) of the first tag that matches the name */
-export declare function getTagValue(event: NostrEvent, name: string): string | undefined;
+/**
+ * Returns the second index ( tag[1] ) of the first tag that matches the name
+ * If the event has any hidden tags they will be searched first
+ */
+export declare function getTagValue(event: NostrEvent | EventTemplate, name: string): string | undefined;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
 /** Marks an event as being from a cache */
 export declare function markFromCache(event: NostrEvent): void;
 /** Returns if an event was from a cache */
 export declare function isFromCache(event: NostrEvent): boolean;
+/**
+ * Returns the replaceable identifier for a replaceable event
+ * @throws
+ */
+export declare function getReplaceableIdentifier(event: NostrEvent): string;

package/dist/helpers/event.js

@@ -1,8 +1,28 @@
 import { kinds, verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
+import { getHiddenTags } from "./hidden-tags.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
+export const ReplaceableIdentifierSymbol = Symbol.for("replaceable-identifier");
+/**
+ * Checks if an object is a nostr event
+ * NOTE: does not validation the signature on the event
+ */
+export function isEvent(event) {
+    if (event === undefined || event === null)
+        return false;
+    return (event.id?.length === 64 &&
+        typeof event.sig === "string" &&
+        typeof event.pubkey === "string" &&
+        event.pubkey.length === 64 &&
+        typeof event.content === "string" &&
+        Array.isArray(event.tags) &&
+        typeof event.created_at === "number" &&
+        event.created_at > 0);
+}
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )
@@ -17,20 +37,20 @@ export function isReplaceable(kind) {
  * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
  */
 export function getEventUID(event) {
-    let id = event[EventUIDSymbol];
-    if (!id) {
+    let uid = event[EventUIDSymbol];
+    if (!uid) {
         if (isReplaceable(event.kind)) {
-            const d = event.tags.find((t) => t[0] === "d")?.[1];
-            id = getReplaceableUID(event.kind, event.pubkey, d);
-        }
-        else {
-            id = event.id;
+            let d = event.tags.find((t) => t[0] === "d")?.[1];
+            uid = getReplaceableUID(event.kind, event.pubkey, d);
         }
+        else
+            uid = event.id;
+        event[EventUIDSymbol] = uid;
     }
-    return id;
+    return uid;
 }
 export function getReplaceableUID(kind, pubkey, d) {
-    return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
+    return d ? kind + ":" + pubkey + ":" + d : kind + ":" + pubkey;
 }
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
@@ -38,7 +58,7 @@ export function getIndexableTags(event) {
     if (!indexable) {
         const tags = new Set();
         for (const tag of event.tags) {
-            if (tag[0] && INDEXABLE_TAGS.has(tag[0]) && tag[1]) {
+            if (tag.length >= 2 && tag[0].length === 1 && INDEXABLE_TAGS.has(tag[0])) {
                 tags.add(tag[0] + ":" + tag[1]);
             }
         }
@@ -46,13 +66,21 @@ export function getIndexableTags(event) {
     }
     return indexable;
 }
-/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+/**
+ * Returns the second index ( tag[1] ) of the first tag that matches the name
+ * If the event has any hidden tags they will be searched first
+ */
 export function getTagValue(event, name) {
+    const hidden = getHiddenTags(event);
+    const hiddenValue = hidden?.find((t) => t[0] === name)?.[1];
+    if (hiddenValue)
+        return hiddenValue;
     return event.tags.find((t) => t[0] === name)?.[1];
 }
 /** Sets events verified flag without checking anything */
 export function fakeVerifyEvent(event) {
-    return (event[verifiedSymbol] = true);
+    event[verifiedSymbol] = true;
+    return true;
 }
 /** Marks an event as being from a cache */
 export function markFromCache(event) {
@@ -62,3 +90,17 @@ export function markFromCache(event) {
 export function isFromCache(event) {
     return !!event[FromCacheSymbol];
 }
+/**
+ * Returns the replaceable identifier for a replaceable event
+ * @throws
+ */
+export function getReplaceableIdentifier(event) {
+    if (!isParameterizedReplaceableKind(event.kind))
+        throw new Error("Event is not replaceable");
+    return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
+        const d = getTagValue(event, "d");
+        if (d === undefined)
+            throw new Error("Event missing identifier");
+        return d;
+    });
+}

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

@@ -0,0 +1,29 @@
+export type ExternalIdentifiers = {
+    "#": `#${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}`;
+};
+export type ExternalPointer<Prefix extends keyof ExternalIdentifiers> = {
+    kind: Prefix;
+    identifier: ExternalIdentifiers[Prefix];
+};
+export type ParseResult = {
+    [P in keyof ExternalIdentifiers]: ExternalPointer<P>;
+}[keyof ExternalIdentifiers];
+/**
+ * Parses a NIP-73 external identifier
+ * @throws
+ */
+export declare function parseExternalPointer<Prefix extends keyof ExternalIdentifiers>(identifier: `${Prefix}1${string}`): ExternalPointer<Prefix>;
+export declare function parseExternalPointer(identifier: string): ParseResult;
+/**
+ * Gets an ExternalPointer for a "i" tag
+ * @throws
+ */
+export declare function getExternalPointerFromTag<Prefix extends keyof ExternalIdentifiers>(tag: string[]): ExternalPointer<Prefix>;
+export declare function getExternalPointerFromTag(tag: string[]): ParseResult;

package/dist/helpers/external-id.js

@@ -0,0 +1,20 @@
+export function parseExternalPointer(identifier) {
+    if (identifier.startsWith("#"))
+        return { kind: "#", identifier: identifier };
+    if (identifier.startsWith("geo:"))
+        return { kind: "geo", 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 };
+    throw new Error("Failed to parse external identifier");
+}
+export function getExternalPointerFromTag(tag) {
+    return parseExternalPointer(tag[1]);
+}