applesauce-core 5.1.0 → 6.0.0

package/dist/factories/profile.js

@@ -0,0 +1,80 @@
+import { isKind } from "nostr-tools/kinds";
+import { kinds } from "../helpers/event.js";
+import { setProfile, updateProfile } from "../operations/profile.js";
+import { blankEventTemplate, EventFactory, toEventTemplate } from "./event.js";
+/** A factory class for building kind 0 profile/metadata events */
+export class ProfileFactory extends EventFactory {
+    /**
+     * Creates a new profile factory
+     * @returns A new profile factory
+     */
+    static create() {
+        return new ProfileFactory((res) => res(blankEventTemplate(kinds.Metadata)));
+    }
+    /**
+     * Creates a new profile factory from an existing metadata event with validation
+     * @param event - The existing metadata event
+     * @returns A new profile factory
+     */
+    static modify(event) {
+        if (!isKind(event, kinds.Metadata))
+            throw new Error("Event is not a profile event");
+        return new ProfileFactory((res) => res(toEventTemplate(event)));
+    }
+    /** Sets the entire profile content, replacing any existing content */
+    override(content) {
+        return this.chain(setProfile(content));
+    }
+    /** Updates specific fields in the profile content, merging with existing content */
+    update(content) {
+        return this.chain(updateProfile(content));
+    }
+    /** Sets the display name */
+    name(name) {
+        return this.chain(updateProfile({ name }));
+    }
+    /** Sets the username */
+    username(username) {
+        return this.chain(updateProfile({ username }));
+    }
+    /** Sets the display name (alias for name) */
+    displayName(displayName) {
+        return this.chain(updateProfile({ display_name: displayName }));
+    }
+    /** Sets the about/bio text */
+    about(about) {
+        return this.chain(updateProfile({ about }));
+    }
+    /** Sets the profile picture URL */
+    picture(picture) {
+        return this.chain(updateProfile({ picture }));
+    }
+    /** Sets the banner image URL */
+    banner(banner) {
+        return this.chain(updateProfile({ banner }));
+    }
+    /** Sets the website URL */
+    website(website) {
+        return this.chain(updateProfile({ website }));
+    }
+    /** Sets the NIP-05 identifier */
+    nip05(nip05) {
+        return this.chain(updateProfile({ nip05 }));
+    }
+    /** Sets the Lightning Network address */
+    lnurlp(lnurlp) {
+        return this.chain(updateProfile({ lud06: lnurlp }));
+    }
+    /** Sets the Lightning Network address (LNURL) */
+    lightningAddress(address) {
+        return this.chain(updateProfile({ lud16: address }));
+    }
+    /** Sets the bot flag */
+    bot(bot) {
+        return this.chain(updateProfile({ bot }));
+    }
+    /** Sets the languages */
+    languages(languages) {
+        return this.chain(updateProfile({ languages }));
+    }
+}

package/dist/factories/types.d.ts

@@ -0,0 +1,56 @@
+import { EventTemplate, NostrEvent, UnsignedEvent } from "../helpers/event.js";
+import { AddressPointer } from "../helpers/pointers.js";
+/** Nostr event signer */
+export interface EventSigner {
+    getPublicKey: () => Promise<string> | string;
+    signEvent: (draft: EventTemplate | UnsignedEvent) => Promise<NostrEvent> | NostrEvent;
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    nip44?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+}
+/** A single operation that transforms a value (context-free) */
+export type Operation<I extends unknown = unknown, R extends unknown = unknown> = (value: I) => R | Promise<R>;
+/** A single operation that modifies an events public or hidden tags array */
+export type TagOperation = Operation<string[][], string[][]>;
+/** A single operation that modifies an event */
+export type EventOperation<I extends EventTemplate | UnsignedEvent | NostrEvent = EventTemplate, R extends EventTemplate | UnsignedEvent | NostrEvent = EventTemplate> = Operation<I, R>;
+/** NIP-30 emoji type */
+export type Emoji = {
+    /** The emoji shortcode (without the ::) */
+    shortcode: string;
+    /** The URL to the emoji image */
+    url: string;
+    /** The NIP-01 "a" tag address of the emoji pack this emoji belongs to */
+    address?: AddressPointer;
+};
+/** A context with optional methods for getting relay hints */
+export interface RelayHintContext {
+    getEventRelayHint?: (event: string) => string | undefined | Promise<string> | Promise<undefined>;
+    getPubkeyRelayHint?: (pubkey: string) => string | undefined | Promise<string> | Promise<undefined>;
+}
+export interface EventFactoryClient {
+    name: string;
+    address?: Omit<AddressPointer, "kind" | "relays">;
+}
+export interface EmojiContext {
+    /** An array of custom emojis that will be used for text notes */
+    emojis?: Emoji[];
+}
+/** Services that can be provided to event operations */
+export interface EventFactoryServices {
+    /** Event signer for signing and stamping events */
+    signer?: EventSigner;
+    /** Function to get relay hint for an event ID */
+    getEventRelayHint?: (eventId: string) => Promise<string | undefined>;
+    /** Function to get relay hint for a pubkey */
+    getPubkeyRelayHint?: (pubkey: string) => Promise<string | undefined>;
+    /** Custom emojis for NIP-30 emoji tags */
+    emojis?: Emoji[];
+    /** NIP-89 client pointer */
+    client?: EventFactoryClient;
+}

package/dist/helpers/event.d.ts

@@ -1,14 +1,23 @@
 import { kinds } from "nostr-tools";
+import { isKind } from "nostr-tools/kinds";
 import { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind } from "nostr-tools/kinds";
-import { NostrEvent, VerifiedEvent } from "nostr-tools/pure";
+import { EventTemplate, NostrEvent, UnsignedEvent, VerifiedEvent } from "nostr-tools/pure";
 import { IAsyncEventStore, IEventStore } from "../event-store/interface.js";
 export { EventTemplate, finalizeEvent, getEventHash, NostrEvent, serializeEvent, UnsignedEvent, VerifiedEvent, verifiedSymbol, verifyEvent, } from "nostr-tools/pure";
 export { binarySearch, bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, } from "nostr-tools/utils";
-export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds };
+export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds, isKind };
 /** An event with a known kind. this is used to know if events have been validated */
 export type KnownEvent<K extends number> = Omit<NostrEvent, "kind"> & {
     kind: K;
 };
+/** An event template with a known kind. used in event factories */
+export type KnownEventTemplate<K extends number> = Omit<EventTemplate, "kind"> & {
+    kind: K;
+};
+/** An unsigned event with a known kind. used in event factories */
+export type KnownUnsignedEvent<K extends number> = Omit<UnsignedEvent, "kind"> & {
+    kind: K;
+};
 /** A symbol on an event that marks which event store its part of */
 export declare const EventStoreSymbol: unique symbol;
 export declare const EventUIDSymbol: unique symbol;

package/dist/helpers/event.js

@@ -1,11 +1,12 @@
 import { kinds } from "nostr-tools";
+import { isKind } from "nostr-tools/kinds";
 import { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind } from "nostr-tools/kinds";
 import { verifiedSymbol, verifyEvent } from "nostr-tools/pure";
 import { getOrComputeCachedValue } from "./cache.js";
 // Re-export types from nostr-tools
 export { finalizeEvent, getEventHash, serializeEvent, verifiedSymbol, verifyEvent, } from "nostr-tools/pure";
 export { binarySearch, bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, } from "nostr-tools/utils";
-export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds };
+export { isAddressableKind, isEphemeralKind, isRegularKind, isReplaceableKind, kinds, isKind };
 /** A symbol on an event that marks which event store its part of */
 export const EventStoreSymbol = Symbol.for("event-store");
 export const EventUIDSymbol = Symbol.for("event-uid");

package/dist/helpers/mailboxes.d.ts

@@ -1,7 +1,11 @@
-import { NostrEvent } from "./event.js";
+import { kinds, KnownEvent, NostrEvent } from "./event.js";
+/** Type for NIP-65 relay list events */
+export type MailboxesEvent = KnownEvent<kinds.RelayList>;
 export declare const MailboxesInboxesSymbol: unique symbol;
 export declare const MailboxesOutboxesSymbol: unique symbol;
 /** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export declare function getInboxes(event: NostrEvent): string[];
 /** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export declare function getOutboxes(event: NostrEvent): string[];
+/** Checks if an event is a valid mailboxes event */
+export declare function isMailboxesEvent(event: any): event is MailboxesEvent;

package/dist/helpers/mailboxes.js

@@ -1,3 +1,4 @@
+import { isKind, kinds } from "./event.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
 import { isRTag } from "./tags.js";
@@ -47,3 +48,7 @@ export function getOutboxes(event) {
         return outboxes;
     });
 }
+/** Checks if an event is a valid mailboxes event */
+export function isMailboxesEvent(event) {
+    return isKind(event, kinds.RelayList);
+}

package/dist/helpers/pipeline.d.ts

@@ -1,4 +1,4 @@
-import { EventOperation, Operation, TagOperation } from "../event-factory/types.js";
+import type { EventOperation, Operation, TagOperation } from "../factories/types.js";
 /** An array of Symbols to preserve when building events with {@link eventPipe} */
 export declare const PRESERVE_EVENT_SYMBOLS: Set<symbol>;
 export declare function identity<T>(x: T): T;
@@ -8,6 +8,19 @@ export declare function eventPipe(...operations: (EventOperation | undefined)[])
 export declare function tagPipe(...operations: (TagOperation | undefined)[]): TagOperation;
 /** A pipeline operation that does nothing */
 export declare function skip<T>(): (value: T) => T;
+/**
+ * Pipe a value through a series of async operations
+ * @example
+ * ```ts
+ * const result = await pipe(
+ *   draft,
+ *   setContent("hello"),
+ *   addTag("p", pubkey),
+ *   sign(signer)
+ * );
+ * ```
+ */
+export declare function pipe<T>(value: T, ...operations: Array<(v: any) => any | Promise<any>>): Promise<any>;
 /**
  * @param fns - An array of operations to pipe together
  * @param preserve - If set an array of symbols to keep, all other symbols will be removed

package/dist/helpers/pipeline.js

@@ -18,6 +18,21 @@ export function tagPipe(...operations) {
 export function skip() {
     return (value) => value;
 }
+/**
+ * Pipe a value through a series of async operations
+ * @example
+ * ```ts
+ * const result = await pipe(
+ *   draft,
+ *   setContent("hello"),
+ *   addTag("p", pubkey),
+ *   sign(signer)
+ * );
+ * ```
+ */
+export async function pipe(value, ...operations) {
+    return operations.reduce(async (prev, op) => op(await prev), Promise.resolve(value));
+}
 /**
  * @param fns - An array of operations to pipe together
  * @param preserve - If set an array of symbols to keep, all other symbols will be removed
@@ -26,9 +41,9 @@ export function skip() {
 export function pipeFromAsyncArray(fns, preserve) {
     if (fns.length === 0)
         return identity;
-    return async function piped(input, context) {
+    return async function piped(input) {
         return fns.reduce(async (prev, fn) => {
-            const result = await fn(await prev, context);
+            const result = await fn(await prev);
             // Copy the symbols and fields if result is an object
             if (preserve && typeof result === "object" && result !== null && typeof prev === "object" && prev !== null) {
                 const keys = Reflect.ownKeys(result).filter((key) => typeof key === "symbol");

package/dist/helpers/pointers.d.ts

@@ -4,42 +4,42 @@ export { decode as decodePointer, naddrEncode, neventEncode, noteEncode, nprofil
 export type { NAddr, NEvent, NProfile, NPub } from "nostr-tools/nip19";
 import { NostrEvent } from "./event.js";
 export type DecodeResult = DecodedResult;
-/** Decodes any nip-19 encoded entity to a ProfilePointer */
+/** Decodes any NIP-19 encoded string into a ProfilePointer. Returns null if the string cannot be decoded. */
 export declare function decodeProfilePointer(str: string): ProfilePointer | null;
-/** Decodes an naddr encoded string to an AddressPointer */
+/** Decodes an encoded NIP-19 naddr string to an AddressPointer. Returns null if the string cannot be decoded. */
 export declare function decodeAddressPointer(str: string): AddressPointer | null;
-/** Decodes a note1 or nevent encoded string to an EventPointer */
+/** Decodes an encoded NIP-19 note1 or nevent string to an EventPointer. Returns null if the string cannot be decoded. */
 export declare function decodeEventPointer(str: string): EventPointer | null;
 export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
     identifier?: string;
 };
-/** Parse the value of an "a" tag into an AddressPointer */
+/** Parses the value of an "a" tag into an AddressPointer. Returns null if the address cannot be parsed. */
 export declare function parseReplaceableAddress(address: string, requireIdentifier?: boolean): AddressPointer | null;
-/** Extra a pubkey from the result of nip19.decode */
+/** Extracts a pubkey from the result of nip19.decode  Returns undefined if the decode result does not have a pubkey */
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
-/** Gets the relays from a decode result */
+/** Extracts the relays from a decode result */
 export declare function getRelaysFromDecodeResult(result?: DecodeResult): string[] | undefined;
-/** Encodes the result of nip19.decode */
+/** Encodes the result of nip19.decode to a NIP-19 string. Returns an empty string if the result cannot be encoded. */
 export declare function encodeDecodeResult(result: DecodeResult): "" | `nevent1${string}` | `nprofile1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
-/** Encodes a pointer to a NIP-19 string */
+/** Encodes a pointer to a NIP-19 string. Returns an empty string if the pointer cannot be encoded. */
 export declare function encodePointer(pointer: AddressPointer | EventPointer | ProfilePointer): string;
-/** Gets an EventPointer form a common "e" tag */
+/** Parses a common "e" tag into an EventPointer. Returns null if the tag cannot be parsed. */
 export declare function getEventPointerFromETag(tag: string[]): EventPointer | null;
-/** Gets an EventPointer form a common "q" tag */
+/** Parses a common "q" tag into an EventPointer. Returns null if the tag cannot be parsed. */
 export declare function getEventPointerFromQTag(tag: string[]): EventPointer | null;
-/** Get an AddressPointer from a common "a" tag */
+/** Parses a common "a" tag into an AddressPointer. Returns null if the tag cannot be parsed. */
 export declare function getAddressPointerFromATag(tag: string[]): AddressPointer | null;
-/** Gets a ProfilePointer from a common "p" tag */
+/** Parses a common "p" tag into a ProfilePointer. Returns null if the tag cannot be parsed. */
 export declare function getProfilePointerFromPTag(tag: string[]): ProfilePointer | null;
-/** Checks if a pointer is an AddressPointer */
+/** Checks if a pointer object is an AddressPointer */
 export declare function isAddressPointer(pointer: any): pointer is AddressPointer;
-/** Checks if a pointer is a ProfilePointer */
+/** Checks if a pointer object is a ProfilePointer */
 export declare function isProfilePointer(pointer: any): pointer is ProfilePointer;
-/** Checks if a pointer is an EventPointer */
+/** Checks if a pointer object is an EventPointer */
 export declare function isEventPointer(pointer: any): pointer is EventPointer;
-/** Returns the stringified address pointer */
+/** Returns the stringified NIP-19 encoded naddr address pointer for an AddressPointer. */
 export declare function getReplaceableAddressFromPointer(pointer: AddressPointer): string;
-/** Returns an AddressPointer for a replaceable event */
+/** Returns an AddressPointer for a replaceable event. Returns null if the event is not addressable or replaceable. */
 export declare function getAddressPointerForEvent(event: NostrEvent, relays?: string[]): AddressPointer | null;
 /** Returns an EventPointer for an event */
 export declare function getEventPointerForEvent(event: NostrEvent, relays?: string[]): EventPointer;
@@ -49,17 +49,17 @@ export declare function getPointerForEvent(event: NostrEvent, relays?: string[])
 export declare function addRelayHintsToPointer<T extends {
     relays?: string[];
 }>(pointer: T, relays?: Iterable<string>): T;
-/** Gets the hex pubkey from any nip-19 encoded string */
+/** Parses any nip-19 encoded string into a hex pubkey. Returns null if the string is not a valid pubkey. */
 export declare function normalizeToPubkey(str: NPub): string;
 export declare function normalizeToPubkey(str: string): string | null;
-/** Gets a ProfilePointer from any nip-19 encoded string */
+/** Parses any nip-19 encoded string into a ProfilePointer. Returns null if the string cannot be parsed. */
 export declare function normalizeToProfilePointer(str: NProfile): ProfilePointer;
 export declare function normalizeToProfilePointer(str: NPub): ProfilePointer;
 export declare function normalizeToProfilePointer(str: string): ProfilePointer | null;
-/** Gets an AddressPointer from any nip-19 encoded string */
+/** Parses any nip-19 encoded string into an AddressPointer. Returns null if the string cannot be parsed. */
 export declare function normalizeToAddressPointer(str: NAddr): AddressPointer;
 export declare function normalizeToAddressPointer(str: string): AddressPointer | null;
-/** Gets an EventPointer from any nip-19 encoded string */
+/** Parses any nip-19 encoded string into an EventPointer. Returns null if the string cannot be parsed. */
 export declare function normalizeToEventPointer(str: NEvent): EventPointer;
 export declare function normalizeToEventPointer(str: string): EventPointer | null;
 /** Returns all NIP-19 pointers in a content string */
@@ -79,5 +79,9 @@ export declare function mergeAddressPointers(a: AddressPointer, b: AddressPointe
  * @throws if the pubkeys are different
  */
 export declare function mergeProfilePointers(a: ProfilePointer, b: ProfilePointer): ProfilePointer;
+/** Checks if two address pointers refer to the same addressable event. Ignores relays. */
+export declare function isAddressPointerSame(a: AddressPointer, b: AddressPointer): boolean;
+/** Checks if two event pointers refer to the same event. Ignores relays. */
+export declare function isEventPointerSame(a: EventPointer, b: EventPointer): boolean;
 /** Checks if an event matches a pointer */
 export declare function eventMatchesPointer(event: NostrEvent, pointer: EventPointer | AddressPointer | AddressPointerWithoutD): boolean;

package/dist/helpers/pointers.js

@@ -7,7 +7,7 @@ import { Tokens } from "./regexp.js";
 import { isSafeRelayURL, relaySet } from "./relays.js";
 import { isHexKey } from "./string.js";
 import { normalizeURL } from "./url.js";
-/** Decodes a string and handles errors */
+/** Decodes a string and handles errors. Returns null if the string cannot be decoded. */
 function safeDecode(str) {
     try {
         return decode(str);
@@ -16,7 +16,7 @@ function safeDecode(str) {
         return null;
     }
 }
-/** Decodes any nip-19 encoded entity to a ProfilePointer */
+/** Decodes any NIP-19 encoded string into a ProfilePointer. Returns null if the string cannot be decoded. */
 export function decodeProfilePointer(str) {
     const result = safeDecode(str);
     if (!result)
@@ -29,14 +29,14 @@ export function decodeProfilePointer(str) {
         relays: getRelaysFromDecodeResult(result),
     };
 }
-/** Decodes an naddr encoded string to an AddressPointer */
+/** Decodes an encoded NIP-19 naddr string to an AddressPointer. Returns null if the string cannot be decoded. */
 export function decodeAddressPointer(str) {
     const result = safeDecode(str);
     if (!result)
         return null;
     return result.type === "naddr" ? result.data : null;
 }
-/** Decodes a note1 or nevent encoded string to an EventPointer */
+/** Decodes an encoded NIP-19 note1 or nevent string to an EventPointer. Returns null if the string cannot be decoded. */
 export function decodeEventPointer(str) {
     const result = safeDecode(str);
     if (!result)
@@ -50,7 +50,7 @@ export function decodeEventPointer(str) {
             return null;
     }
 }
-/** Parse the value of an "a" tag into an AddressPointer */
+/** Parses the value of an "a" tag into an AddressPointer. Returns null if the address cannot be parsed. */
 export function parseReplaceableAddress(address, requireIdentifier = false) {
     const parts = address.split(":");
     const kind = parts[0] ? parseInt(parts[0]) : undefined;
@@ -73,7 +73,7 @@ export function parseReplaceableAddress(address, requireIdentifier = false) {
         identifier,
     };
 }
-/** Extra a pubkey from the result of nip19.decode */
+/** Extracts a pubkey from the result of nip19.decode  Returns undefined if the decode result does not have a pubkey */
 export function getPubkeyFromDecodeResult(result) {
     if (!result)
         return;
@@ -89,7 +89,7 @@ export function getPubkeyFromDecodeResult(result) {
             return undefined;
     }
 }
-/** Gets the relays from a decode result */
+/** Extracts the relays from a decode result */
 export function getRelaysFromDecodeResult(result) {
     if (!result)
         return;
@@ -103,7 +103,7 @@ export function getRelaysFromDecodeResult(result) {
     }
     return undefined;
 }
-/** Encodes the result of nip19.decode */
+/** Encodes the result of nip19.decode to a NIP-19 string. Returns an empty string if the result cannot be encoded. */
 export function encodeDecodeResult(result) {
     switch (result.type) {
         case "naddr":
@@ -121,7 +121,7 @@ export function encodeDecodeResult(result) {
     }
     return "";
 }
-/** Encodes a pointer to a NIP-19 string */
+/** Encodes a pointer to a NIP-19 string. Returns an empty string if the pointer cannot be encoded. */
 export function encodePointer(pointer) {
     if (isAddressPointer(pointer))
         return naddrEncode(pointer);
@@ -132,7 +132,7 @@ export function encodePointer(pointer) {
     else
         return "";
 }
-/** Gets an EventPointer form a common "e" tag */
+/** Parses a common "e" tag into an EventPointer. Returns null if the tag cannot be parsed. */
 export function getEventPointerFromETag(tag) {
     const id = tag[1];
     if (!id || !isHexKey(id))
@@ -142,7 +142,7 @@ export function getEventPointerFromETag(tag) {
         pointer.relays = [normalizeURL(tag[2])];
     return pointer;
 }
-/** Gets an EventPointer form a common "q" tag */
+/** Parses a common "q" tag into an EventPointer. Returns null if the tag cannot be parsed. */
 export function getEventPointerFromQTag(tag) {
     const id = tag[1];
     if (!id || !isHexKey(id))
@@ -154,7 +154,7 @@ export function getEventPointerFromQTag(tag) {
         pointer.author = tag[3];
     return pointer;
 }
-/** Get an AddressPointer from a common "a" tag */
+/** Parses a common "a" tag into an AddressPointer. Returns null if the tag cannot be parsed. */
 export function getAddressPointerFromATag(tag) {
     if (!tag[1])
         return null;
@@ -165,7 +165,7 @@ export function getAddressPointerFromATag(tag) {
         pointer.relays = [normalizeURL(tag[2])];
     return pointer;
 }
-/** Gets a ProfilePointer from a common "p" tag */
+/** Parses a common "p" tag into a ProfilePointer. Returns null if the tag cannot be parsed. */
 export function getProfilePointerFromPTag(tag) {
     const pubkey = tag[1];
     if (!pubkey || !isHexKey(pubkey))
@@ -175,7 +175,7 @@ export function getProfilePointerFromPTag(tag) {
         pointer.relays = [normalizeURL(tag[2])];
     return pointer;
 }
-/** Checks if a pointer is an AddressPointer */
+/** Checks if a pointer object is an AddressPointer */
 export function isAddressPointer(pointer) {
     return (typeof pointer === "object" &&
         pointer !== null &&
@@ -186,7 +186,7 @@ export function isAddressPointer(pointer) {
         typeof pointer.pubkey === "string" &&
         typeof pointer.kind === "number");
 }
-/** Checks if a pointer is a ProfilePointer */
+/** Checks if a pointer object is a ProfilePointer */
 export function isProfilePointer(pointer) {
     return (typeof pointer === "object" &&
         pointer !== null &&
@@ -196,15 +196,15 @@ export function isProfilePointer(pointer) {
         !isEventPointer(pointer) &&
         !isAddressPointer(pointer));
 }
-/** Checks if a pointer is an EventPointer */
+/** Checks if a pointer object is an EventPointer */
 export function isEventPointer(pointer) {
     return typeof pointer === "object" && pointer !== null && "id" in pointer && typeof pointer.id === "string";
 }
-/** Returns the stringified address pointer */
+/** Returns the stringified NIP-19 encoded naddr address pointer for an AddressPointer. */
 export function getReplaceableAddressFromPointer(pointer) {
     return pointer.kind + ":" + pointer.pubkey + ":" + pointer.identifier;
 }
-/** Returns an AddressPointer for a replaceable event */
+/** Returns an AddressPointer for a replaceable event. Returns null if the event is not addressable or replaceable. */
 export function getAddressPointerForEvent(event, relays) {
     if (!isAddressableKind(event.kind) && !isReplaceableKind(event.kind))
         return null;
@@ -345,6 +345,21 @@ export function mergeProfilePointers(a, b) {
     const relays = relaySet(a.relays, b.relays);
     return { ...a, relays };
 }
+/** Checks if two address pointers refer to the same addressable event. Ignores relays. */
+export function isAddressPointerSame(a, b) {
+    return a.kind === b.kind && a.pubkey === b.pubkey && a.identifier === b.identifier;
+}
+/** Checks if two event pointers refer to the same event. Ignores relays. */
+export function isEventPointerSame(a, b) {
+    return (
+    // Check if id is the same
+    a.id === b.id &&
+        // Because event id's are unique, we can skip extra checks if either pointer is missing some fields
+        // If any kind is undefined, ignore it
+        (a.kind !== undefined || b.kind !== undefined ? a.kind === b.kind : true) &&
+        // If any author is undefined, ignore it
+        (a.author !== undefined || b.author !== undefined ? a.author === b.author : true));
+}
 /** Checks if an event matches a pointer */
 export function eventMatchesPointer(event, pointer) {
     if (isEventPointer(pointer)) {

package/dist/helpers/profile.d.ts

@@ -19,10 +19,10 @@ export type ProfileContent = {
     banner?: string;
     /** A web URL related in any way to the event author */
     website?: string;
+    /** A LNURL-based Lightning address in the format `lnurlp://…` */
+    lud06?: string;
     /** Lightning address in the format `user@domain.com` (LUD-16 format) */
     lud16?: string;
-    /** Lightning address in the format `user@domain.com` (LUD-06 format) */
-    lud06?: string;
     /** DNS-based verification identifier in the format `_@domain.com` or `user@domain.com` */
     nip05?: string;
     /** Boolean to clarify that the content is entirely or partially the result of automation, such as with chatbots or newsfeeds */

package/dist/helpers/regexp.d.ts

@@ -6,6 +6,7 @@ export declare const Expressions: {
     readonly emoji: RegExp;
     readonly hashtag: RegExp;
     readonly lightning: RegExp;
+    readonly blossom: RegExp;
 };
 /** A list of Regular Expressions that match tokens surrounded by whitespace to avoid matching in URLs */
 export declare const Tokens: {
@@ -16,4 +17,5 @@ export declare const Tokens: {
     readonly emoji: RegExp;
     readonly hashtag: RegExp;
     readonly lightning: RegExp;
+    readonly blossom: RegExp;
 };

package/dist/helpers/regexp.js

@@ -1,9 +1,9 @@
 export const Expressions = {
     get url() {
-        return /(?:https?|wss?|ircs?|s?ftp):\/\/([a-zA-Z0-9\.\-]+\.[a-zA-Z]+(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
+        return /(?:https?|wss?|ircs?|s?ftp):\/\/((?:(?:\d{1,3}\.){3}\d{1,3}|localhost|[a-zA-Z0-9\.\-]+\.[a-zA-Z]+)(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
     },
     get link() {
-        return /https?:\/\/([a-zA-Z0-9\.\-]+\.[a-zA-Z]+(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
+        return /https?:\/\/((?:(?:\d{1,3}\.){3}\d{1,3}|localhost|[a-zA-Z0-9\.\-]+\.[a-zA-Z]+)(?::\d+)?)([\/\?#][\p{L}\p{N}\p{M}&\.-\/\?=#\-@%\+_,:!~*]*)?/gu;
     },
     get cashu() {
         return /(?:cashu:\/{0,2})?(cashu(?:A|B)[A-Za-z0-9_-]{100,}={0,3})/gi;
@@ -21,6 +21,9 @@ export const Expressions = {
     get lightning() {
         return /(?:lightning:)?(LNBC[A-Za-z0-9]+)/gim;
     },
+    get blossom() {
+        return /blossom:([0-9a-f]{64})\.([a-zA-Z0-9]+)(\?[^\s]*)?/g;
+    },
 };
 /** A list of Regular Expressions that match tokens surrounded by whitespace to avoid matching in URLs */
 export const Tokens = {
@@ -45,4 +48,7 @@ export const Tokens = {
     get lightning() {
         return new RegExp(`(?<=^|\\s)${Expressions.lightning.source}`, "gim");
     },
+    get blossom() {
+        return new RegExp(`(?<=^|\\s)${Expressions.blossom.source}`, "g");
+    },
 };

package/dist/helpers/relays.d.ts

@@ -1,5 +1,7 @@
 import { NostrEvent } from "./event.js";
 export declare const SeenRelaysSymbol: unique symbol;
+/** Normalizes a relay URL by using {@link normalizeURL} and {@link ensureWebSocketURL} */
+export declare function normalizeRelayUrl(input: string): string;
 /** Marks an event as being seen on a relay */
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
 /** Returns the set of relays this event was seen on */
@@ -9,6 +11,6 @@ export declare function isFromRelay(event: NostrEvent, relay: string): boolean;
 /** A fast check to make sure relay hints are safe to connect to */
 export declare function isSafeRelayURL(relay: string): boolean;
 /** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */
-export declare function mergeRelaySets(...sources: (Iterable<string> | string | undefined)[]): string[];
+export declare function mergeRelaySets(...sources: (Iterable<string> | string | undefined | null)[]): string[];
 /** Alias for {@link mergeRelaySets} */
 export declare const relaySet: typeof mergeRelaySets;

package/dist/helpers/relays.js

@@ -1,5 +1,9 @@
-import { normalizeURL } from "./url.js";
+import { ensureWebSocketURL, normalizeURL } from "./url.js";
 export const SeenRelaysSymbol = Symbol.for("seen-relays");
+/** Normalizes a relay URL by using {@link normalizeURL} and {@link ensureWebSocketURL} */
+export function normalizeRelayUrl(input) {
+    return normalizeURL(ensureWebSocketURL(input));
+}
 /** Marks an event as being seen on a relay */
 export function addSeenRelay(event, relay) {
     let seen = Reflect.get(event, SeenRelaysSymbol);
@@ -34,23 +38,17 @@ export function mergeRelaySets(...sources) {
         if (!src)
             continue;
         if (typeof src === "string") {
-            // Source is a string
             try {
-                const safe = normalizeURL(src).toString();
-                if (safe)
-                    set.add(safe);
+                set.add(normalizeRelayUrl(src));
             }
             catch (error) {
                 // failed to parse URL, ignore
             }
         }
-        else {
-            // Source is iterable
+        else if (Reflect.has(src, Symbol.iterator)) {
             for (const url of src) {
                 try {
-                    const safe = normalizeURL(url).toString();
-                    if (safe)
-                        set.add(safe);
+                    set.add(normalizeRelayUrl(url));
                 }
                 catch (error) {
                     // failed to parse URL, ignore