applesauce-core 0.9.0 → 0.11.0

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

@@ -0,0 +1,55 @@
+import { NostrEvent } from "nostr-tools";
+export type FileMetadata = {
+    /** URL of the file */
+    url: string;
+    /** MIME type */
+    type?: string;
+    /** sha256 hash of the file */
+    sha256?: string;
+    /**
+     * The original sha256 hash before the file was transformed
+     * @deprecated
+     */
+    originalSha256?: string;
+    /** size of the file in bytes */
+    size?: number;
+    /** size of file in pixels in the form <width>x<height> */
+    dimensions?: string;
+    /** magnet */
+    magnet?: string;
+    /** torrent infohash */
+    infohash?: string;
+    /** URL to a thumbnail */
+    thumbnail?: string;
+    /** URL to a preview image with the same dimensions */
+    image?: string;
+    /** summary */
+    summary?: string;
+    /** description for accessability */
+    alt?: string;
+    /** blurhash */
+    blurhash?: string;
+    /** fallback URLs */
+    fallback?: string[];
+};
+export type MediaAttachment = FileMetadata;
+/**
+ * Parses file metadata tags into {@link FileMetadata}
+ * @throws
+ */
+export declare function parseFileMetadataTags(tags: string[][]): FileMetadata;
+/**
+ * Parses a imeta tag into a {@link FileMetadata}
+ * @throws
+ */
+export declare function getFileMetadataFromImetaTag(tag: string[]): FileMetadata;
+export declare const MediaAttachmentsSymbol: unique symbol;
+/** Gets all the media attachments on an event */
+export declare function getMediaAttachments(event: NostrEvent): FileMetadata[];
+/**
+ * Gets {@link FileMetadata} for a NIP-94 kind 1063 event
+ * @throws
+ */
+export declare function getFileMetadata(file: NostrEvent): FileMetadata;
+/** Returns the last 64 length hex string in a URL */
+export declare function getSha256FromURL(url: string | URL): string | undefined;

package/dist/helpers/file-metadata.js

@@ -0,0 +1,99 @@
+import { getOrComputeCachedValue } from "./cache.js";
+/**
+ * Parses file metadata tags into {@link FileMetadata}
+ * @throws
+ */
+export function parseFileMetadataTags(tags) {
+    const fields = {};
+    let fallback = undefined;
+    for (const [name, value] of tags) {
+        switch (name) {
+            case "fallback":
+                fallback = fallback ? [...fallback, value] : [value];
+                break;
+            default:
+                fields[name] = value;
+                break;
+        }
+    }
+    if (!fields.url)
+        throw new Error("Missing required url in file metadata");
+    const metadata = { url: fields.url, fallback };
+    // parse size
+    if (fields.size)
+        metadata.size = parseInt(fields.size);
+    // copy optional fields
+    if (fields.m)
+        metadata.type = fields.m;
+    if (fields.x)
+        metadata.sha256 = fields.x;
+    if (fields.ox)
+        metadata.originalSha256 = fields.ox;
+    if (fields.dim)
+        metadata.dimensions = fields.dim;
+    if (fields.magnet)
+        metadata.magnet = fields.magnet;
+    if (fields.i)
+        metadata.infohash = fields.i;
+    if (fields.thumb)
+        metadata.thumbnail = fields.thumb;
+    if (fields.image)
+        metadata.image = fields.image;
+    if (fields.summary)
+        metadata.summary = fields.summary;
+    if (fields.alt)
+        metadata.alt = fields.alt;
+    if (fields.blurhash)
+        metadata.blurhash = fields.blurhash;
+    return metadata;
+}
+/**
+ * Parses a imeta tag into a {@link FileMetadata}
+ * @throws
+ */
+export function getFileMetadataFromImetaTag(tag) {
+    const parts = tag.slice(1);
+    const tags = [];
+    for (const part of parts) {
+        const match = part.match(/^(.+?)\s(.+)$/);
+        if (match) {
+            const [_, name, value] = match;
+            tags.push([name, value]);
+        }
+    }
+    return parseFileMetadataTags(tags);
+}
+export const MediaAttachmentsSymbol = Symbol.for("media-attachments");
+/** Gets all the media attachments on an event */
+export function getMediaAttachments(event) {
+    return getOrComputeCachedValue(event, MediaAttachmentsSymbol, () => {
+        return event.tags
+            .filter((t) => t[0] === "imeta")
+            .map((tag) => {
+            try {
+                return getFileMetadataFromImetaTag(tag);
+            }
+            catch (error) {
+                // ignore invalid attachments
+                return undefined;
+            }
+        })
+            .filter((a) => !!a);
+    });
+}
+/**
+ * Gets {@link FileMetadata} for a NIP-94 kind 1063 event
+ * @throws
+ */
+export function getFileMetadata(file) {
+    return parseFileMetadataTags(file.tags);
+}
+/** Returns the last 64 length hex string in a URL */
+export function getSha256FromURL(url) {
+    if (typeof url === "string")
+        url = new URL(url);
+    const hashes = Array.from(url.pathname.matchAll(/[0-9a-f]{64}/gi));
+    if (hashes.length > 0)
+        return hashes[hashes.length - 1][0];
+    return;
+}

package/dist/helpers/filter.d.ts

@@ -6,7 +6,9 @@ import { Filter, NostrEvent } from "nostr-tools";
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
 /** Copied from nostr-tools */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
-/** Stringify filters in a predictable way */
-export declare function stringifyFilter(filter: Filter | Filter[]): string;
+/**
+ * Copied from nostr-tools and modified to support undefined
+ */
+export declare function mergeFilters(...filters: Filter[]): Filter;
 /** Check if two filters are equal */
 export declare function isFilterEqual(a: Filter | Filter[], b: Filter | Filter[]): boolean;

package/dist/helpers/filter.js

@@ -1,5 +1,5 @@
 import { getIndexableTags } from "./event.js";
-import stringify from "json-stringify-deterministic";
+import equal from "fast-deep-equal";
 /**
  * Copied from nostr-tools and modified to use getIndexableTags
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
@@ -17,10 +17,10 @@ export function matchFilter(filter, event) {
     for (let f in filter) {
         if (f[0] === "#") {
             let tagName = f.slice(1);
-            let values = filter[`#${tagName}`];
+            let values = filter[f];
             if (values) {
                 const tags = getIndexableTags(event);
-                if (values.some((v) => !tags.has(tagName + ":" + v)))
+                if (values.some((v) => tags.has(tagName + ":" + v)) === false)
                     return false;
             }
         }
@@ -40,11 +40,40 @@ export function matchFilters(filters, event) {
     }
     return false;
 }
-/** Stringify filters in a predictable way */
-export function stringifyFilter(filter) {
-    return stringify(filter);
+/**
+ * Copied from nostr-tools and modified to support undefined
+ */
+export function mergeFilters(...filters) {
+    let result = {};
+    for (let i = 0; i < filters.length; i++) {
+        let filter = filters[i];
+        Object.entries(filter).forEach(([property, values]) => {
+            // skip undefined
+            if (values === undefined)
+                return;
+            if (property === "kinds" || property === "ids" || property === "authors" || property[0] === "#") {
+                // @ts-ignore
+                result[property] = result[property] || [];
+                // @ts-ignore
+                for (let v = 0; v < values.length; v++) {
+                    // @ts-ignore
+                    let value = values[v];
+                    // @ts-ignore
+                    if (!result[property].includes(value))
+                        result[property].push(value);
+                }
+            }
+        });
+        if (filter.limit && (!result.limit || filter.limit > result.limit))
+            result.limit = filter.limit;
+        if (filter.until && (!result.until || filter.until > result.until))
+            result.until = filter.until;
+        if (filter.since && (!result.since || filter.since < result.since))
+            result.since = filter.since;
+    }
+    return result;
 }
 /** Check if two filters are equal */
 export function isFilterEqual(a, b) {
-    return stringifyFilter(a) === stringifyFilter(b);
+    return equal(a, b);
 }

package/dist/helpers/groups.d.ts

@@ -0,0 +1,24 @@
+import { NostrEvent } from "nostr-tools";
+export declare const GROUPS_LIST_KIND = 10009;
+export declare const GROUP_MESSAGE_KIND = 9;
+/** NIP-29 group pointer */
+export type GroupPointer = {
+    id: string;
+    relay: string;
+    name?: string;
+};
+/**
+ * decodes a group identifier into a group pointer object
+ * @throws
+ */
+export declare function decodeGroupPointer(str: string): GroupPointer;
+/** Converts a group pointer into a group identifier */
+export declare function encodeGroupPointer(pointer: GroupPointer): string;
+export declare const GroupsPublicSymbol: unique symbol;
+export declare const GroupsHiddenSymbol: unique symbol;
+/** gets a {@link GroupPointer} from a "group" tag */
+export declare function getGroupPointerFromGroupTag(tag: string[]): GroupPointer;
+/** Returns all the public groups from a k:10009 list */
+export declare function getPublicGroups(bookmark: NostrEvent): GroupPointer[];
+/** Returns all the hidden groups from a k:10009 list */
+export declare function getHiddenGroups(bookmark: NostrEvent): GroupPointer[] | undefined;

package/dist/helpers/groups.js

@@ -0,0 +1,39 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { processTags } from "./tags.js";
+import { getHiddenTags } from "./hidden-tags.js";
+export const GROUPS_LIST_KIND = 10009;
+export const GROUP_MESSAGE_KIND = 9;
+/**
+ * decodes a group identifier into a group pointer object
+ * @throws
+ */
+export function decodeGroupPointer(str) {
+    const [relay, id] = str.split("'");
+    if (!relay)
+        throw new Error("Group pointer missing relay");
+    return { relay, id: id || "_" };
+}
+/** Converts a group pointer into a group identifier */
+export function encodeGroupPointer(pointer) {
+    const hostname = URL.canParse(pointer.relay) ? new URL(pointer.relay).hostname : pointer.relay;
+    return `${hostname}'${pointer.id}`;
+}
+export const GroupsPublicSymbol = Symbol.for("groups-public");
+export const GroupsHiddenSymbol = Symbol.for("groups-hidden");
+/** gets a {@link GroupPointer} from a "group" tag */
+export function getGroupPointerFromGroupTag(tag) {
+    const [_, id, relay, name] = tag;
+    return { id, relay, name };
+}
+/** Returns all the public groups from a k:10009 list */
+export function getPublicGroups(bookmark) {
+    return getOrComputeCachedValue(bookmark, GroupsPublicSymbol, () => processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+}
+/** Returns all the hidden groups from a k:10009 list */
+export function getHiddenGroups(bookmark) {
+    return getOrComputeCachedValue(bookmark, GroupsHiddenSymbol, () => {
+        const tags = getHiddenTags(bookmark);
+        return (tags &&
+            processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+    });
+}

package/dist/helpers/hidden-tags.d.ts

@@ -0,0 +1,48 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+import { EventStore } from "../event-store/event-store.js";
+export type HiddenTagsSigner = {
+    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;
+    };
+};
+export declare const HiddenTagsSymbol: unique symbol;
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export declare const EventEncryptionMethod: Record<number, "nip04" | "nip44">;
+/** Checks if an event can have hidden tags */
+export declare function canHaveHiddenTags(kind: number): boolean;
+/** Checks if an event has hidden tags */
+export declare function hasHiddenTags(event: NostrEvent | EventTemplate): boolean;
+/** Returns the hidden tags for an event if they are unlocked */
+export declare function getHiddenTags(event: NostrEvent | EventTemplate): string[][] | undefined;
+/** Checks if the hidden tags are locked */
+export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
+/** Returns either nip04 or nip44 encryption method depending on list kind */
+export declare function getListEncryptionMethods(kind: number, signer: HiddenTagsSigner): {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+} | {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+};
+/**
+ * Decrypts the private list
+ * @param event The list event to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @param store An optional EventStore to notify about the update
+ * @throws
+ */
+export declare function unlockHiddenTags<T extends {
+    kind: number;
+    pubkey: string;
+    content: string;
+}>(event: T, signer: HiddenTagsSigner, store?: EventStore): Promise<T>;
+/**
+ * Override the hidden tags in an event
+ * @throws
+ */
+export declare function overrideHiddenTags(event: NostrEvent, hidden: string[][], signer: HiddenTagsSigner): Promise<EventTemplate>;

package/dist/helpers/hidden-tags.js

@@ -0,0 +1,86 @@
+import { kinds } from "nostr-tools";
+import { GROUPS_LIST_KIND } from "./groups.js";
+import { unixNow } from "./time.js";
+import { isEvent } from "./event.js";
+export const HiddenTagsSymbol = Symbol.for("hidden-tags");
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export const EventEncryptionMethod = {
+    // NIP-60 wallet
+    37375: "nip44",
+    // NIP-51 lists
+    [kinds.BookmarkList]: "nip04",
+    [kinds.InterestsList]: "nip04",
+    [kinds.Mutelist]: "nip04",
+    [kinds.CommunitiesList]: "nip04",
+    [kinds.PublicChatsList]: "nip04",
+    [kinds.SearchRelaysList]: "nip04",
+    [GROUPS_LIST_KIND]: "nip04",
+    // NIP-51 sets
+    [kinds.Bookmarksets]: "nip04",
+    [kinds.Relaysets]: "nip04",
+    [kinds.Followsets]: "nip04",
+    [kinds.Curationsets]: "nip04",
+    [kinds.Interestsets]: "nip04",
+};
+/** Checks if an event can have hidden tags */
+export function canHaveHiddenTags(kind) {
+    return EventEncryptionMethod[kind] !== undefined;
+}
+/** Checks if an event has hidden tags */
+export function hasHiddenTags(event) {
+    return canHaveHiddenTags(event.kind) && event.content.length > 0;
+}
+/** Returns the hidden tags for an event if they are unlocked */
+export function getHiddenTags(event) {
+    return Reflect.get(event, HiddenTagsSymbol);
+}
+/** Checks if the hidden tags are locked */
+export function isHiddenTagsLocked(event) {
+    return hasHiddenTags(event) && getHiddenTags(event) === undefined;
+}
+/** Returns either nip04 or nip44 encryption method depending on list kind */
+export function getListEncryptionMethods(kind, signer) {
+    const method = EventEncryptionMethod[kind];
+    const encryption = signer[method];
+    if (!encryption)
+        throw new Error(`Signer does not support ${method} encryption`);
+    return encryption;
+}
+/**
+ * Decrypts the private list
+ * @param event The list event to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @param store An optional EventStore to notify about the update
+ * @throws
+ */
+export async function unlockHiddenTags(event, signer, store) {
+    if (!canHaveHiddenTags(event.kind))
+        throw new Error("Event kind does not support hidden tags");
+    const encryption = getListEncryptionMethods(event.kind, signer);
+    const plaintext = await encryption.decrypt(event.pubkey, event.content);
+    const parsed = JSON.parse(plaintext);
+    if (!Array.isArray(parsed))
+        throw new Error("Content is not an array of tags");
+    // Convert array to tags array string[][]
+    const tags = parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
+    Reflect.set(event, HiddenTagsSymbol, tags);
+    if (store && isEvent(event))
+        store.update(event);
+    return event;
+}
+/**
+ * Override the hidden tags in an event
+ * @throws
+ */
+export async function overrideHiddenTags(event, hidden, signer) {
+    if (!canHaveHiddenTags(event.kind))
+        throw new Error("Event kind does not support hidden tags");
+    const encryption = getListEncryptionMethods(event.kind, signer);
+    const ciphertext = await encryption.encrypt(event.pubkey, JSON.stringify(hidden));
+    return {
+        kind: event.kind,
+        content: ciphertext,
+        created_at: unixNow(),
+        tags: event.tags,
+    };
+}

package/dist/helpers/index.d.ts

@@ -1,16 +1,36 @@
-export * from "./profile.js";
-export * from "./relays.js";
+export * from "./blossom.js";
+export * from "./bolt11.js";
+export * from "./bookmarks.js";
+export * from "./cache.js";
+export * from "./channels.js";
+export * from "./comment.js";
+export * from "./contacts.js";
+export * from "./content.js";
+export * from "./delete.js";
+export * from "./dns-identity.js";
+export * from "./emoji.js";
 export * from "./event.js";
+export * from "./external-id.js";
+export * from "./file-metadata.js";
 export * from "./filter.js";
+export * from "./groups.js";
+export * from "./hashtag.js";
+export * from "./hidden-tags.js";
+export * from "./json.js";
+export * from "./lists.js";
+export * from "./lnurl.js";
+export * from "./lru.js";
 export * from "./mailboxes.js";
-export * from "./threading.js";
+export * from "./mutes.js";
+export * from "./picture-post.js";
 export * from "./pointers.js";
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./share.js";
 export * from "./string.js";
-export * from "./time.js";
 export * from "./tags.js";
-export * from "./emoji.js";
-export * from "./lru.js";
-export * from "./hashtag.js";
+export * from "./threading.js";
+export * from "./time.js";
 export * from "./url.js";
+export * from "./user-status.js";
 export * from "./zap.js";
-export * from "./bolt11.js";

package/dist/helpers/index.js

@@ -1,16 +1,36 @@
-export * from "./profile.js";
-export * from "./relays.js";
+export * from "./blossom.js";
+export * from "./bolt11.js";
+export * from "./bookmarks.js";
+export * from "./cache.js";
+export * from "./channels.js";
+export * from "./comment.js";
+export * from "./contacts.js";
+export * from "./content.js";
+export * from "./delete.js";
+export * from "./dns-identity.js";
+export * from "./emoji.js";
 export * from "./event.js";
+export * from "./external-id.js";
+export * from "./file-metadata.js";
 export * from "./filter.js";
+export * from "./groups.js";
+export * from "./hashtag.js";
+export * from "./hidden-tags.js";
+export * from "./json.js";
+export * from "./lists.js";
+export * from "./lnurl.js";
+export * from "./lru.js";
 export * from "./mailboxes.js";
-export * from "./threading.js";
+export * from "./mutes.js";
+export * from "./picture-post.js";
 export * from "./pointers.js";
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./share.js";
 export * from "./string.js";
-export * from "./time.js";
 export * from "./tags.js";
-export * from "./emoji.js";
-export * from "./lru.js";
-export * from "./hashtag.js";
+export * from "./threading.js";
+export * from "./time.js";
 export * from "./url.js";
+export * from "./user-status.js";
 export * from "./zap.js";
-export * from "./bolt11.js";

package/dist/helpers/json.d.ts

@@ -1 +1,2 @@
+/** Returns the parsed JSON or undefined if invalid */
 export declare function safeParse<T extends unknown = any>(str: string): T | undefined;

package/dist/helpers/json.js

@@ -1,3 +1,4 @@
+/** Returns the parsed JSON or undefined if invalid */
 export function safeParse(str) {
     try {
         return JSON.parse(str);

package/dist/helpers/lists.d.ts

@@ -0,0 +1,28 @@
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+/**
+ * Checks if an event pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in EventPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export declare function isEventPointerInList(list: NostrEvent, pointer: string | EventPointer): boolean;
+/**
+ * Checks if an address pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in AddressPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export declare function isAddressPointerInList(list: NostrEvent, pointer: string | AddressPointer): boolean;
+/**
+ * Checks if an profile pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in ProfilePointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export declare function isProfilePointerInList(list: NostrEvent, pointer: string | ProfilePointer): boolean;
+/** Returns all the EventPointer in a list or set */
+export declare function getEventPointersFromList(list: NostrEvent): EventPointer[];
+/** Returns all the AddressPointer in a list or set */
+export declare function getAddressPointersFromList(list: NostrEvent): AddressPointer[];
+/** Returns all the ProfilePointer in a list or set */
+export declare function getProfilePointersFromList(list: NostrEvent): ProfilePointer[];
+/** Returns if an event is a valid list or set */
+export declare function isValidList(event: NostrEvent): boolean;

package/dist/helpers/lists.js

@@ -0,0 +1,65 @@
+import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { getHiddenTags } from "./hidden-tags.js";
+import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "./pointers.js";
+import { isATag, isETag, isPTag, processTags } from "./tags.js";
+import { getReplaceableIdentifier } from "./event.js";
+function listGetAllTags(list) {
+    const hidden = getHiddenTags(list);
+    return hidden ? [...hidden, ...list.tags] : list.tags;
+}
+/**
+ * Checks if an event pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in EventPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export function isEventPointerInList(list, pointer) {
+    const id = typeof pointer === "string" ? pointer : pointer.id;
+    return listGetAllTags(list).some((t) => t[0] === "e" && t[1] === id);
+}
+/**
+ * Checks if an address pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in AddressPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export function isAddressPointerInList(list, pointer) {
+    const cord = typeof pointer === "string" ? pointer : getCoordinateFromAddressPointer(pointer);
+    return listGetAllTags(list).some((t) => t[0] === "a" && t[1] === cord);
+}
+/**
+ * Checks if an profile pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in ProfilePointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export function isProfilePointerInList(list, pointer) {
+    const pubkey = typeof pointer === "string" ? pointer : pointer.pubkey;
+    return listGetAllTags(list).some((t) => t[0] === "p" && t[1] === pubkey);
+}
+/** Returns all the EventPointer in a list or set */
+export function getEventPointersFromList(list) {
+    return processTags(listGetAllTags(list), (tag) => (isETag(tag) ? tag : undefined), getEventPointerFromETag);
+}
+/** Returns all the AddressPointer in a list or set */
+export function getAddressPointersFromList(list) {
+    return processTags(listGetAllTags(list), (t) => (isATag(t) ? t : undefined), getAddressPointerFromATag);
+}
+/** Returns all the ProfilePointer in a list or set */
+export function getProfilePointersFromList(list) {
+    return processTags(listGetAllTags(list), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag);
+}
+/** Returns if an event is a valid list or set */
+export function isValidList(event) {
+    try {
+        if (isParameterizedReplaceableKind(event.kind)) {
+            // event is a set
+            // ensure the set has an identifier
+            getReplaceableIdentifier(event);
+            return true;
+        }
+        else if (isReplaceableKind(event.kind) && event.kind >= 10000 && event.kind < 20000) {
+            // event is a list
+            return true;
+        }
+    }
+    catch (error) { }
+    return false;
+}

package/dist/helpers/lnurl.d.ts

@@ -0,0 +1,4 @@
+export declare function parseLightningAddress(address: string): URL | undefined;
+export declare function decodeLNURL(lnurl: string): URL | undefined;
+export declare function parseLNURLOrAddress(addressOrLNURL: string): URL | undefined;
+export declare function getInvoice(callback: URL): Promise<string>;