applesauce-core 0.9.0 → 0.10.0

package/dist/helpers/emoji.d.ts

@@ -1,2 +1,11 @@
 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 = {
+    name: string;
+    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);
 }
+/** 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) => ({ name: t[1], url: t[2] }));
+}

package/dist/helpers/event.d.ts

@@ -9,6 +9,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,7 +29,10 @@ 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 */
+/**
+ * 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, name: string): string | undefined;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;

package/dist/helpers/event.js

@@ -1,8 +1,25 @@
 import { kinds, verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
+import { getHiddenTags } from "./hidden-tags.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
+/**
+ * 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 )
@@ -46,8 +63,15 @@ 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 */

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]);
+}

package/dist/helpers/filter.d.ts

@@ -6,7 +6,5 @@ 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;
 /** 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
@@ -20,7 +20,7 @@ export function matchFilter(filter, event) {
             let values = filter[`#${tagName}`];
             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,7 @@ export function matchFilters(filters, event) {
     }
     return false;
 }
-/** Stringify filters in a predictable way */
-export function stringifyFilter(filter) {
-    return stringify(filter);
-}
 /** Check if two filters are equal */
 export function isFilterEqual(a, b) {
-    return stringifyFilter(a) === stringifyFilter(b);
+    return equal(a, b);
 }

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

@@ -0,0 +1,48 @@
+import { EventTemplate, NostrEvent, UnsignedEvent } from "nostr-tools";
+import { EventStore } from "applesauce-core";
+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 type TagOperation = (tags: 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;
+/**
+ * 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(event: NostrEvent, signer: HiddenTagsSigner, store?: EventStore): Promise<NostrEvent>;
+/**
+ * Modifies tags and returns an EventTemplate
+ * @param event Event to modify
+ * @param operations Operations for hidden and public tags
+ * @param signer A signer to use to decrypt the tags
+ * @throws
+ */
+export declare function modifyEventTags(event: NostrEvent | UnsignedEvent, operations: {
+    public?: TagOperation;
+    hidden?: TagOperation;
+}, signer?: HiddenTagsSigner): Promise<EventTemplate>;
+/**
+ * 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,108 @@
+import { unixNow } from "applesauce-core/helpers";
+import { kinds } from "nostr-tools";
+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",
+    // 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;
+}
+function getEventEncryption(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 = getEventEncryption(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)
+        store.update(event);
+    return event;
+}
+/**
+ * Modifies tags and returns an EventTemplate
+ * @param event Event to modify
+ * @param operations Operations for hidden and public tags
+ * @param signer A signer to use to decrypt the tags
+ * @throws
+ */
+export async function modifyEventTags(event, operations, signer) {
+    const draft = { content: event.content, tags: event.tags, kind: event.kind, created_at: unixNow() };
+    if (operations.public) {
+        draft.tags = operations.public(event.tags);
+    }
+    if (operations.hidden) {
+        if (!signer)
+            throw new Error("Missing signer for hidden tags");
+        if (!canHaveHiddenTags(event.kind))
+            throw new Error("Event kind does not support hidden tags");
+        const hidden = hasHiddenTags(event) ? getHiddenTags(event) : [];
+        if (!hidden)
+            throw new Error("Hidden tags are locked");
+        const newHidden = operations.hidden(hidden);
+        const encryption = getEventEncryption(event.kind, signer);
+        draft.content = await encryption.encrypt(event.pubkey, JSON.stringify(newHidden));
+    }
+    return draft;
+}
+/**
+ * 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 = getEventEncryption(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/hidden-tags.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/hidden-tags.test.js

@@ -0,0 +1,28 @@
+import { describe, beforeEach, it, expect } from "vitest";
+import { getHiddenTags, unixNow, unlockHiddenTags } from "applesauce-core/helpers";
+import { finalizeEvent, generateSecretKey, getPublicKey, kinds, nip04 } from "nostr-tools";
+const key = generateSecretKey();
+const pubkey = getPublicKey(key);
+const signer = {
+    nip04: {
+        encrypt: (pubkey, plaintext) => nip04.encrypt(key, pubkey, plaintext),
+        decrypt: (pubkey, ciphertext) => nip04.decrypt(key, pubkey, ciphertext),
+    },
+};
+describe("Private Lists", () => {
+    describe("unlockHiddenTags", () => {
+        let list;
+        beforeEach(async () => {
+            list = finalizeEvent({
+                kind: kinds.Mutelist,
+                created_at: unixNow(),
+                content: await nip04.encrypt(key, pubkey, JSON.stringify([["p", "npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr"]])),
+                tags: [],
+            }, key);
+        });
+        it("should unlock hidden tags", async () => {
+            await unlockHiddenTags(list, signer);
+            expect(getHiddenTags(list)).toEqual(expect.arrayContaining([["p", "npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr"]]));
+        });
+    });
+});

package/dist/helpers/index.d.ts

@@ -1,16 +1,24 @@
-export * from "./profile.js";
-export * from "./relays.js";
+export * from "./bolt11.js";
+export * from "./cache.js";
+export * from "./comment.js";
+export * from "./content.js";
+export * from "./delete.js";
+export * from "./emoji.js";
 export * from "./event.js";
+export * from "./external-id.js";
 export * from "./filter.js";
+export * from "./hashtag.js";
+export * from "./hidden-tags.js";
+export * from "./lnurl.js";
+export * from "./lru.js";
 export * from "./mailboxes.js";
-export * from "./threading.js";
+export * from "./media-attachment.js";
 export * from "./pointers.js";
+export * from "./profile.js";
+export * from "./relays.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 "./zap.js";
-export * from "./bolt11.js";

package/dist/helpers/index.js

@@ -1,16 +1,24 @@
-export * from "./profile.js";
-export * from "./relays.js";
+export * from "./bolt11.js";
+export * from "./cache.js";
+export * from "./comment.js";
+export * from "./content.js";
+export * from "./delete.js";
+export * from "./emoji.js";
 export * from "./event.js";
+export * from "./external-id.js";
 export * from "./filter.js";
+export * from "./hashtag.js";
+export * from "./hidden-tags.js";
+export * from "./lnurl.js";
+export * from "./lru.js";
 export * from "./mailboxes.js";
-export * from "./threading.js";
+export * from "./media-attachment.js";
 export * from "./pointers.js";
+export * from "./profile.js";
+export * from "./relays.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 "./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/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>;

package/dist/helpers/lnurl.js

@@ -0,0 +1,40 @@
+import { bech32 } from "@scure/base";
+import { parseBolt11 } from "./bolt11.js";
+const decoder = new TextDecoder();
+export function parseLightningAddress(address) {
+    let [name, domain] = address.split("@");
+    if (!name || !domain)
+        return;
+    return new URL(`https://${domain}/.well-known/lnurlp/${name}`);
+}
+export function decodeLNURL(lnurl) {
+    try {
+        const { words, prefix } = bech32.decode(lnurl);
+        if (prefix !== "lnurl")
+            return;
+        const str = decoder.decode(bech32.fromWords(words));
+        return new URL(str);
+    }
+    catch (error) { }
+    return undefined;
+}
+export function parseLNURLOrAddress(addressOrLNURL) {
+    if (addressOrLNURL.includes("@")) {
+        return parseLightningAddress(addressOrLNURL);
+    }
+    return decodeLNURL(addressOrLNURL);
+}
+export async function getInvoice(callback) {
+    const { pr: payRequest } = await fetch(callback).then((res) => res.json());
+    const amount = callback.searchParams.get("amount");
+    if (!amount)
+        throw new Error("Missing amount");
+    if (payRequest) {
+        const parsed = parseBolt11(payRequest);
+        if (parsed.amount !== parseInt(amount))
+            throw new Error("Incorrect amount");
+        return payRequest;
+    }
+    else
+        throw new Error("Failed to get invoice");
+}

package/dist/helpers/mailboxes.test.js

@@ -1,3 +1,4 @@
+import { describe, test, expect } from "vitest";
 import { getInboxes, getOutboxes } from "./mailboxes.js";
 const emptyEvent = {
     kind: 10002,
@@ -14,33 +15,33 @@ describe("Mailboxes", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
         test("should remove bad urls", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "bad://inbox.com"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "something that is not a url"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com,wss://inbox.org"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
         });
         test("without marker", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com/"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
         test("with marker", () => {
             expect(Array.from(getInboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://inbox.com/", "read"]],
-            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
         });
     });
     describe("getOutboxes", () => {
@@ -48,33 +49,33 @@ describe("Mailboxes", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
         test("should remove bad urls", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "bad://inbox.com"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "something that is not a url"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com,wss://inbox.org"]],
-            }))).toBeArrayOfSize(0);
+            }))).toHaveLength(0);
         });
         test("without marker", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com/"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
         test("with marker", () => {
             expect(Array.from(getOutboxes({
                 ...emptyEvent,
                 tags: [["r", "wss://outbox.com/", "write"]],
-            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
         });
     });
 });

package/dist/helpers/media-attachment.d.ts

@@ -0,0 +1,33 @@
+import { NostrEvent } from "nostr-tools";
+export type MediaAttachment = {
+    /** URL of the file */
+    url: string;
+    /** mime type */
+    type?: string;
+    /** sha256 hash of the file */
+    sha256?: 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 */
+    thumb?: string;
+    /** URL to a preview image with the same dimensions */
+    image?: string;
+    /** summary */
+    summary?: string;
+    /** description for accessability */
+    alt?: string;
+};
+/**
+ * Parses a imeta tag into a {@link MediaAttachment}
+ * @throws
+ */
+export declare function parseMediaAttachmentTag(tag: string[]): MediaAttachment;
+export declare const MediaAttachmentsSymbol: unique symbol;
+/** Gets all the media attachments on an event */
+export declare function getMediaAttachments(event: NostrEvent): MediaAttachment[];