applesauce-common 0.0.0-next-20251203172109

package/dist/blueprints/reaction.js

@@ -0,0 +1,14 @@
+import { blueprint } from "applesauce-core/event-factory";
+import { kinds } from "applesauce-core/helpers/event";
+import { includeEmojis } from "applesauce-core/operations/content";
+import { setReaction, setReactionParent } from "../operations/reaction.js";
+// Import EventFactory as a value (class) to modify its prototype
+import { EventFactory } from "applesauce-core/event-factory";
+/** blueprint for kind 7 reaction event */
+export function ReactionBlueprint(event, emoji = "+") {
+    return blueprint(kinds.Reaction, setReaction(emoji), setReactionParent(event), typeof emoji !== "string" ? includeEmojis([emoji]) : undefined);
+}
+// Register this blueprint with EventFactory
+EventFactory.prototype.reaction = function (event, emoji = "+") {
+    return this.create(ReactionBlueprint, event, emoji);
+};

package/dist/blueprints/share.d.ts

@@ -0,0 +1,12 @@
+import { MetaTagOptions } from "applesauce-core/operations/event";
+import { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
+import { ZapOptions } from "../operations/zap-split.js";
+export type ShareBlueprintOptions = MetaTagOptions & ZapOptions;
+/** Blueprint for a NIP-18 repost event */
+export declare function ShareBlueprint(event: NostrEvent, options?: ShareBlueprintOptions): import("applesauce-core/event-factory").EventBlueprint;
+declare module "applesauce-core/event-factory" {
+    interface EventFactory {
+        /** Create a NIP-18 repost event */
+        share(event: NostrEvent, options?: ShareBlueprintOptions): Promise<EventTemplate>;
+    }
+}

package/dist/blueprints/share.js

@@ -0,0 +1,25 @@
+import { setMetaTags } from "applesauce-core/operations/event";
+import { embedSharedEvent, setShareKind, setShareTags } from "../operations/share.js";
+import { blueprint } from "applesauce-core/event-factory";
+import { kinds } from "applesauce-core/helpers/event";
+import { setZapSplit } from "../operations/zap-split.js";
+// Import EventFactory as a value (class) to modify its prototype
+import { EventFactory } from "applesauce-core/event-factory";
+/** Blueprint for a NIP-18 repost event */
+export function ShareBlueprint(event, options) {
+    return blueprint(kinds.Repost, 
+    // set the kind to 6 or 16 based on the kind of event being shared
+    setShareKind(event), 
+    // embed the shared event as a JSON string
+    embedSharedEvent(event), 
+    // include the NIP-18 repost tags
+    setShareTags(event), 
+    // include the meta tags
+    setMetaTags(options), 
+    // include the zap split tags
+    setZapSplit(options));
+}
+// Register this blueprint with EventFactory
+EventFactory.prototype.share = function (event, options) {
+    return this.create(ShareBlueprint, event, options);
+};

package/dist/blueprints/stream.d.ts

@@ -0,0 +1,6 @@
+import { TextContentOptions } from "applesauce-core/operations";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { EventBlueprint } from "applesauce-core/event-factory";
+/** Creates a stream chat message */
+export declare function StreamChatMessage(stream: AddressPointer | NostrEvent, content: string, options?: TextContentOptions): EventBlueprint;

package/dist/blueprints/stream.js

@@ -0,0 +1,7 @@
+import { blueprint } from "applesauce-core/event-factory";
+import { kinds } from "applesauce-core/helpers/event";
+import { setMessage, setStream } from "../operations/stream-chat.js";
+/** Creates a stream chat message */
+export function StreamChatMessage(stream, content, options) {
+    return blueprint(kinds.LiveChatMessage, setMessage(content, options), setStream(stream));
+}

package/dist/blueprints/torrent.d.ts

@@ -0,0 +1,23 @@
+import { MetaTagOptions } from "applesauce-core/operations/event";
+import { TorrentExternalIdentifier, TorrentFile } from "../helpers/torrent.js";
+export type TorrentBlueprintOptions = MetaTagOptions & {
+    /** Torrent title */
+    title?: string;
+    /** File entries in the torrent */
+    files?: TorrentFile[];
+    /** Tracker URLs */
+    trackers?: string[];
+    /** Newznab category ID */
+    category?: number;
+    /** Search tags for searchability (t tags) */
+    searchTags?: string[];
+    /** Category path (tcat) */
+    categoryPath?: string;
+    /** External identifiers */
+    externalIdentifiers?: TorrentExternalIdentifier[];
+};
+/**
+ * NIP-35 Torrent event (kind 2003) blueprint
+ * Creates a torrent event with info hash and optional metadata
+ */
+export declare function TorrentBlueprint(infoHash: string, content: string, options?: TorrentBlueprintOptions): import("applesauce-core/event-factory").EventBlueprint;

package/dist/blueprints/torrent.js

@@ -0,0 +1,25 @@
+import { blueprint } from "applesauce-core/event-factory";
+import { eventPipe } from "applesauce-core/helpers/pipeline";
+import { setContent } from "applesauce-core/operations/content";
+import { setMetaTags } from "applesauce-core/operations/event";
+import { TORRENT_KIND } from "../helpers/torrent.js";
+import { addTorrentExternalIdentifier, addTorrentFile, addTorrentSearchTag, addTorrentTracker, setTorrentCategory, setTorrentCategoryPath, setTorrentInfoHash, setTorrentTitle, } from "../operations/torrent.js";
+/**
+ * NIP-35 Torrent event (kind 2003) blueprint
+ * Creates a torrent event with info hash and optional metadata
+ */
+export function TorrentBlueprint(infoHash, content, options) {
+    return blueprint(TORRENT_KIND, setTorrentInfoHash(infoHash), setContent(content), options?.title ? setTorrentTitle(options.title) : undefined, options?.categoryPath ? setTorrentCategoryPath(options.categoryPath) : undefined, 
+    // Add files
+    options?.files ? eventPipe(...options.files.map((file) => addTorrentFile(file))) : undefined, 
+    // Add trackers
+    options?.trackers ? eventPipe(...options.trackers.map((tracker) => addTorrentTracker(tracker))) : undefined, 
+    // Set newznab category
+    options?.category !== undefined ? setTorrentCategory(options.category) : undefined, 
+    // Add search tags
+    options?.searchTags ? eventPipe(...options.searchTags.map((tag) => addTorrentSearchTag(tag))) : undefined, 
+    // Add external identifiers
+    options?.externalIdentifiers
+        ? eventPipe(...options.externalIdentifiers.map((id) => addTorrentExternalIdentifier(id)))
+        : undefined, setMetaTags({ ...options, alt: options?.alt ?? `Torrent: ${options?.title ?? infoHash}` }));
+}

package/dist/blueprints/wrapped-message.d.ts

@@ -0,0 +1,20 @@
+import { Emoji } from "applesauce-core/event-factory";
+import { EventBlueprint } from "applesauce-core/event-factory";
+import { Rumor } from "../helpers/gift-wrap.js";
+export type WrappedMessageBlueprintOptions = {
+    emojis?: Emoji[];
+    subject?: string;
+};
+/**
+ * A blueprint that creates a wrapped message event to a conversation
+ * @param participants - The conversation identifier (pubkey1:pubkey2:pubkey3), a users pubkey, or a list of participant pubkeys
+ * @param message - The message to wrap
+ * @returns A blueprint that creates a wrapped message event to a conversation
+ */
+export declare function WrappedMessageBlueprint(participants: string | string[], message: string, opts?: WrappedMessageBlueprintOptions): EventBlueprint<Rumor>;
+/**
+ * A blueprint that creates a reply to a wrapped message event
+ * @param message - The message to wrap
+ * @returns A blueprint that creates a wrapped message event to a conversation
+ */
+export declare function WrappedMessageReplyBlueprint(parent: Rumor, message: string, opts?: WrappedMessageBlueprintOptions): EventBlueprint<Rumor>;

package/dist/blueprints/wrapped-message.js

@@ -0,0 +1,64 @@
+import { blueprint } from "applesauce-core/event-factory";
+import { kinds } from "applesauce-core/helpers/event";
+import { repairNostrLinks, setContent } from "applesauce-core/operations";
+import { setConversation, setParent, setSubject } from "../operations/wrapped-message.js";
+import { includeEmojis } from "applesauce-core/operations/content";
+import { toRumor } from "../operations/gift-wrap.js";
+import { getConversationParticipants } from "../helpers/messages.js";
+/**
+ * A blueprint that creates a wrapped message event to a conversation
+ * @param participants - The conversation identifier (pubkey1:pubkey2:pubkey3), a users pubkey, or a list of participant pubkeys
+ * @param message - The message to wrap
+ * @returns A blueprint that creates a wrapped message event to a conversation
+ */
+export function WrappedMessageBlueprint(participants, message, opts) {
+    return async (context) => {
+        if (!context.signer)
+            throw new Error("Missing signer");
+        const self = await context.signer.getPublicKey();
+        return blueprint(kinds.PrivateDirectMessage, 
+        // set text content
+        setContent(message), 
+        // fix @ mentions
+        repairNostrLinks(), 
+        // Include the "p" tags for the conversation
+        setConversation(participants, self), 
+        // include "emoji" tags
+        opts?.emojis ? includeEmojis(opts.emojis) : undefined, 
+        // Include the subject if provided
+        opts?.subject ? setSubject(opts.subject) : undefined, 
+        // Convert the event to a rumor
+        toRumor())(context);
+    };
+}
+/**
+ * A blueprint that creates a reply to a wrapped message event
+ * @param message - The message to wrap
+ * @returns A blueprint that creates a wrapped message event to a conversation
+ */
+export function WrappedMessageReplyBlueprint(parent, message, opts) {
+    return async (context) => {
+        if (typeof parent !== "string" && parent.kind !== kinds.PrivateDirectMessage)
+            throw new Error("Parent must be a wrapped message event (kind 14)");
+        if (!context.signer)
+            throw new Error("Missing signer");
+        const self = await context.signer.getPublicKey();
+        // Get the identifier for the conversation
+        const participants = getConversationParticipants(parent);
+        return blueprint(kinds.PrivateDirectMessage, 
+        // set text content
+        setContent(message), 
+        // fix @ mentions
+        repairNostrLinks(), 
+        // Include the "p" tags for the conversation
+        setConversation(participants, self), 
+        // Include the parent message id
+        setParent(parent), 
+        // include "emoji" tags
+        opts?.emojis ? includeEmojis(opts.emojis) : undefined, 
+        // Include the subject if provided
+        opts?.subject ? setSubject(opts.subject) : undefined, 
+        // Convert the event to a rumor
+        toRumor())(context);
+    };
+}

package/dist/helpers/app-data.d.ts

@@ -0,0 +1,39 @@
+import { EncryptionMethod } from "applesauce-core/helpers/encrypted-content";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
+export declare const APP_DATA_KIND = 30078;
+/** A symbol used to cache the application data content */
+export declare const AppDataContentSymbol: unique symbol;
+/** Checks if an event has application data */
+export declare function hasAppData<T extends {
+    kind: number;
+    content: string;
+}>(event: T): boolean;
+/** Checks if the application data is encrypted */
+export declare function getAppDataEncryption<T extends {
+    kind: number;
+    content: string;
+}>(event: T): EncryptionMethod | undefined;
+/** Checks if the application data is locked (encrypted and not decrypted) */
+export declare function isAppDataUnlocked<T extends {
+    kind: number;
+}>(event: T): boolean;
+/** Returns the parsed application data for an event if it's unlocked */
+export declare function getAppDataContent<R extends unknown = unknown, T extends {
+    kind: number;
+    content: string;
+} = NostrEvent>(event: T): R | undefined;
+/**
+ * Unlocks the encrypted application data in the event
+ * @param event The event with encrypted content to decrypt
+ * @param signer A signer to use to decrypt the content
+ * @param override The encryption method to use instead of the default
+ * @returns The decrypted application data
+ */
+export declare function unlockAppData<R extends unknown = unknown, T extends {
+    kind: number;
+    pubkey: string;
+    content: string;
+} = NostrEvent>(event: T, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<R>;
+/** Removes the unencrypted application data cache on an event */
+export declare function lockAppData<T extends object>(event: T): void;

package/dist/helpers/app-data.js

@@ -0,0 +1,68 @@
+import { isNIP04Encrypted } from "applesauce-core/helpers/encryption";
+import { getHiddenContent, isHiddenContentUnlocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers/hidden-content";
+import { safeParse } from "applesauce-core/helpers/json";
+// NIP-78 Application Data event kind
+export const APP_DATA_KIND = 30078;
+/** A symbol used to cache the application data content */
+export const AppDataContentSymbol = Symbol.for("app-data-content");
+// Set the encryption method for app data events (default to nip44)
+setHiddenContentEncryptionMethod(APP_DATA_KIND, "nip44");
+/** Checks if an event has application data */
+export function hasAppData(event) {
+    return event.kind === APP_DATA_KIND && event.content.length > 0;
+}
+/** Checks if the application data is encrypted */
+export function getAppDataEncryption(event) {
+    // If content is empty, it can't be encrypted
+    if (event.content.length === 0)
+        return undefined;
+    // Try to parse as JSON - if it fails, it's likely encrypted
+    const parsed = safeParse(event.content);
+    if (parsed !== undefined)
+        return undefined;
+    return isNIP04Encrypted(event.content) ? "nip04" : "nip44";
+}
+/** Checks if the application data is locked (encrypted and not decrypted) */
+export function isAppDataUnlocked(event) {
+    return isHiddenContentUnlocked(event);
+}
+/** Returns the parsed application data for an event if it's unlocked */
+export function getAppDataContent(event) {
+    const cached = Reflect.get(event, AppDataContentSymbol);
+    if (cached)
+        return cached;
+    // If content is empty, return undefined
+    if (event.content.length === 0)
+        return undefined;
+    let data = getAppDataEncryption(event) ? undefined : safeParse(event.content);
+    if (!data) {
+        const decrypted = getHiddenContent(event);
+        if (decrypted)
+            data = safeParse(decrypted);
+    }
+    if (!data)
+        return undefined;
+    Reflect.set(event, AppDataContentSymbol, data);
+    return data;
+}
+/**
+ * Unlocks the encrypted application data in the event
+ * @param event The event with encrypted content to decrypt
+ * @param signer A signer to use to decrypt the content
+ * @param override The encryption method to use instead of the default
+ * @returns The decrypted application data
+ */
+export async function unlockAppData(event, signer, override) {
+    if (!getAppDataEncryption(event))
+        return getAppDataContent(event);
+    const method = override ?? getAppDataEncryption(event);
+    const plaintext = await unlockHiddenContent(event, signer, method);
+    const parsed = safeParse(plaintext);
+    if (parsed === undefined)
+        throw new Error("Failed to parse decrypted application data as JSON");
+    return parsed;
+}
+/** Removes the unencrypted application data cache on an event */
+export function lockAppData(event) {
+    lockHiddenContent(event);
+}

package/dist/helpers/app-handler.d.ts

@@ -0,0 +1,22 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "applesauce-core/helpers/pointers";
+export type HandlerLinkPlatform = "web" | "ios" | "android";
+export type HandlerLinkType = DecodeResult["type"];
+/** Returns an array of supported kinds for a given handler */
+export declare function getHandlerSupportedKinds(handler: NostrEvent): number[];
+/** Returns the name of the handler */
+export declare function getHandlerName(handler: NostrEvent): string;
+/** Returns the picture of the handler */
+export declare function getHandlerPicture(handler: NostrEvent, fallback?: string): string | undefined;
+/** Returns the description of the handler */
+export declare function getHandlerDescription(handler: NostrEvent): string | undefined;
+/** Returns the web link template for a handler and type */
+export declare function getHandlerLinkTemplate(handler: NostrEvent, platform?: HandlerLinkPlatform, type?: HandlerLinkType): string | undefined;
+/** Returns a link for a Profile Pointer */
+export declare function createHandlerProfileLink(handler: NostrEvent, pointer: ProfilePointer, platform?: HandlerLinkPlatform): string | undefined;
+/** Returns a link for an Event Pointer */
+export declare function createHandlerEventLink(handler: NostrEvent, pointer: EventPointer, platform?: HandlerLinkPlatform): string | undefined;
+/** Returns a link for an Address Pointer */
+export declare function createHandlerAddressLink(handler: NostrEvent, pointer: AddressPointer, platform?: HandlerLinkPlatform): string | undefined;
+/** Creates a handler link for a pointer and optionally fallsback to a web link */
+export declare function createHandlerLink(handler: NostrEvent, pointer: AddressPointer | EventPointer | ProfilePointer, platform?: HandlerLinkPlatform, webFallback?: boolean): string | undefined;

package/dist/helpers/app-handler.js

@@ -0,0 +1,67 @@
+import { isAddressPointer, isEventPointer, naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, } from "applesauce-core/helpers/pointers";
+import { getDisplayName, getProfileContent, getProfilePicture, isValidProfile } from "applesauce-core/helpers/profile";
+import { processTags } from "applesauce-core/helpers/tags";
+/** Returns an array of supported kinds for a given handler */
+export function getHandlerSupportedKinds(handler) {
+    return processTags(handler.tags, (t) => (t[0] === "k" && t[1] ? parseInt(t[1]) : undefined));
+}
+/** Returns the name of the handler */
+export function getHandlerName(handler) {
+    return getDisplayName(handler);
+}
+/** Returns the picture of the handler */
+export function getHandlerPicture(handler, fallback) {
+    if (!isValidProfile(handler))
+        return fallback;
+    return getProfilePicture(handler, fallback);
+}
+/** Returns the description of the handler */
+export function getHandlerDescription(handler) {
+    if (!isValidProfile(handler))
+        return;
+    return getProfileContent(handler).about;
+}
+/** Returns the web link template for a handler and type */
+export function getHandlerLinkTemplate(handler, platform = "web", type) {
+    // Get all tags for this platform
+    const tags = handler.tags.filter((t) => t[0] === platform);
+    // Find the tag for this type, otherwise use default
+    if (type)
+        return tags.find((t) => t[2] === type)?.[1];
+    else
+        return tags.find((t) => t[2] === undefined || t[2] === "")?.[1];
+}
+/** Returns a link for a Profile Pointer */
+export function createHandlerProfileLink(handler, pointer, platform = "web") {
+    // First attempt to use a nprofile link, then fallback to npub
+    return (getHandlerLinkTemplate(handler, platform, "nprofile")?.replace("<bech32>", nprofileEncode(pointer)) ||
+        getHandlerLinkTemplate(handler, platform, "npub")?.replace("<bech32>", npubEncode(pointer.pubkey)) ||
+        getHandlerLinkTemplate(handler, platform)?.replace("<bech32>", nprofileEncode(pointer)));
+}
+/** Returns a link for an Event Pointer */
+export function createHandlerEventLink(handler, pointer, platform = "web") {
+    // First attempt to use a nevent link, then fallback to note
+    return (getHandlerLinkTemplate(handler, platform, "nevent")?.replace("<bech32>", neventEncode(pointer)) ||
+        getHandlerLinkTemplate(handler, platform, "note")?.replace("<bech32>", noteEncode(pointer.id)) ||
+        getHandlerLinkTemplate(handler, platform)?.replace("<bech32>", neventEncode(pointer)));
+}
+/** Returns a link for an Address Pointer */
+export function createHandlerAddressLink(handler, pointer, platform = "web") {
+    // First attempt to use a nevent link, then fallback to note
+    return (getHandlerLinkTemplate(handler, platform, "naddr")?.replace("<bech32>", naddrEncode(pointer)) ||
+        getHandlerLinkTemplate(handler, platform)?.replace("<bech32>", naddrEncode(pointer)));
+}
+/** Creates a handler link for a pointer and optionally fallsback to a web link */
+export function createHandlerLink(handler, pointer, platform, webFallback = true) {
+    let link = undefined;
+    if (isEventPointer(pointer))
+        link = createHandlerEventLink(handler, pointer, platform);
+    else if (isAddressPointer(pointer))
+        link = createHandlerAddressLink(handler, pointer, platform);
+    else
+        link = createHandlerProfileLink(handler, pointer, platform);
+    // Fallback to a web link if one cant be found for the platform
+    if (!link && platform && platform !== "web" && webFallback)
+        link = createHandlerLink(handler, pointer, "web");
+    return link;
+}

package/dist/helpers/article.d.ts

@@ -0,0 +1,14 @@
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+/** Type for validated article events */
+export type ArticleEvent = KnownEvent<kinds.LongFormArticle>;
+/** Returns an articles title, if it exists */
+export declare function getArticleTitle(article: ArticleEvent): string;
+export declare function getArticleTitle(article: NostrEvent): string | undefined;
+/** Returns an articles image, if it exists */
+export declare function getArticleImage(article: NostrEvent): string | undefined;
+/** Returns an articles summary, if it exists */
+export declare function getArticleSummary(article: NostrEvent): string | undefined;
+/** Returns an articles published date, if it exists */
+export declare function getArticlePublished(article: NostrEvent): number;
+/** validates that an event is a valid article event */
+export declare function isValidArticle(article: NostrEvent): article is ArticleEvent;

package/dist/helpers/article.js

@@ -0,0 +1,24 @@
+import { getTagValue, kinds } from "applesauce-core/helpers/event";
+export function getArticleTitle(article) {
+    return getTagValue(article, "title");
+}
+/** Returns an articles image, if it exists */
+export function getArticleImage(article) {
+    return getTagValue(article, "image");
+}
+/** Returns an articles summary, if it exists */
+export function getArticleSummary(article) {
+    return getTagValue(article, "summary");
+}
+/** Returns an articles published date, if it exists */
+export function getArticlePublished(article) {
+    const ts = getTagValue(article, "published_at");
+    if (ts && !Number.isNaN(parseInt(ts)))
+        return parseInt(ts);
+    else
+        return article.created_at;
+}
+/** validates that an event is a valid article event */
+export function isValidArticle(article) {
+    return article.kind === kinds.LongFormArticle && getArticleTitle(article) !== undefined && article.content.length > 0;
+}

package/dist/helpers/blossom.d.ts

@@ -0,0 +1,11 @@
+export declare const BLOSSOM_SERVER_LIST_KIND = 10063;
+/** Check if two servers are the same */
+export declare function areBlossomServersEqual(a: string | URL, b: string | URL): boolean;
+/** Checks if a string is a sha256 hash */
+export declare function isSha256(str: string): boolean;
+/** Returns an ordered array of servers found in a server list event (10063) */
+export declare function getBlossomServersFromList(event: {
+    tags: string[][];
+} | string[][]): URL[];
+/** A method that merges multiple arrays of blossom servers into a single array of unique servers */
+export declare function mergeBlossomServers<T extends URL | string | (string | URL)>(...servers: (T | null | undefined | T[])[]): T[];

package/dist/helpers/blossom.js

@@ -0,0 +1,40 @@
+import { isNameValueTag, processTags } from "applesauce-core/helpers/tags";
+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;
+    });
+}
+/** A method that merges multiple arrays of blossom servers into a single array of unique servers */
+export function mergeBlossomServers(...servers) {
+    let merged = [];
+    const seen = new Set();
+    for (const arg of servers) {
+        let arr = Array.isArray(arg) ? arg : [arg];
+        for (const s of arr) {
+            if (s === null || s === undefined)
+                continue;
+            const key = new URL("/", s).toString();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            merged.push(s);
+        }
+    }
+    return merged;
+}

package/dist/helpers/bolt11.d.ts

@@ -0,0 +1,10 @@
+export type ParsedInvoice = {
+    paymentRequest: string;
+    description: string;
+    amount?: number;
+    timestamp: number;
+    expiry: number;
+    paymentHash?: string;
+};
+/** Parses a lightning invoice */
+export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -0,0 +1,17 @@
+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;
+    const description = decoded.sections.find((s) => s.name === "description")?.value ?? "";
+    const amount = parseInt(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
+    const paymentHash = decoded.sections.find((s) => s.name === "payment_hash");
+    return {
+        paymentRequest: decoded.paymentRequest,
+        description: description,
+        amount: amount,
+        timestamp: timestamp,
+        expiry: timestamp + decoded.expiry,
+        paymentHash: paymentHash?.value,
+    };
+}

package/dist/helpers/bookmark.d.ts

@@ -0,0 +1,30 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+export declare const BookmarkPublicSymbol: unique symbol;
+export declare const BookmarkHiddenSymbol: unique symbol;
+/** Type for unlocked bookmarks events */
+export type UnlockedBookmarks = {
+    [BookmarkHiddenSymbol]: Bookmarks;
+};
+export type Bookmarks = {
+    notes: EventPointer[];
+    articles: AddressPointer[];
+    hashtags: string[];
+    urls: string[];
+};
+/** Parses an array of tags into a {@link Bookmarks} object */
+export declare function parseBookmarkTags(tags: string[][]): Bookmarks;
+/** 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;
+/** 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;
+/** Unlocks the hidden bookmarks on a bookmarks event */
+export declare function unlockHiddenBookmarks(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<Bookmarks>;