applesauce-core 0.0.0-next-20250123214405 → 0.0.0-next-20250124150519

package/dist/helpers/pointers.js

@@ -0,0 +1,205 @@
+import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
+import { getPublicKey, kinds } from "nostr-tools";
+import { getReplaceableIdentifier } from "./event.js";
+import { safeRelayUrls } from "./relays.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+export function parseCoordinate(a, requireD = false, silent = true) {
+    const parts = a.split(":");
+    const kind = parts[0] && parseInt(parts[0]);
+    const pubkey = parts[1];
+    const d = parts[2];
+    if (!kind) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing kind");
+    }
+    if (!pubkey) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing pubkey");
+    }
+    if (requireD && d === undefined) {
+        if (silent)
+            return null;
+        else
+            throw new Error("Missing identifier");
+    }
+    return {
+        kind,
+        pubkey,
+        identifier: d,
+    };
+}
+/** Extra a pubkey from the result of nip19.decode */
+export function getPubkeyFromDecodeResult(result) {
+    if (!result)
+        return;
+    switch (result.type) {
+        case "naddr":
+        case "nprofile":
+            return result.data.pubkey;
+        case "npub":
+            return result.data;
+        case "nsec":
+            return getPublicKey(result.data);
+        default:
+            return undefined;
+    }
+}
+/** Encodes the result of nip19.decode */
+export function encodeDecodeResult(result) {
+    switch (result.type) {
+        case "naddr":
+            return naddrEncode(result.data);
+        case "nprofile":
+            return nprofileEncode(result.data);
+        case "nevent":
+            return neventEncode(result.data);
+        case "nsec":
+            return nsecEncode(result.data);
+        case "npub":
+            return npubEncode(result.data);
+        case "note":
+            return noteEncode(result.data);
+    }
+    return "";
+}
+/**
+ * Gets an EventPointer form a common "e" tag
+ * @throws
+ */
+export function getEventPointerFromETag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+/**
+ * Gets an EventPointer form a "q" tag
+ * @throws
+ */
+export function getEventPointerFromQTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    if (tag[3] && tag[3].length === 64)
+        pointer.author = tag[3];
+    return pointer;
+}
+/**
+ * Get an AddressPointer from an "a" tag
+ * @throws
+ */
+export function getAddressPointerFromATag(tag) {
+    if (!tag[1])
+        throw new Error("Missing coordinate in tag");
+    const pointer = parseCoordinate(tag[1], true, false);
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+/**
+ * Gets a ProfilePointer from a "p" tag
+ * @throws
+ */
+export function getProfilePointerFromPTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing pubkey in tag");
+    const pointer = { pubkey: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    return pointer;
+}
+/** Parses "e", "a", "p", and "q" tags into a pointer */
+export function getPointerFromTag(tag) {
+    try {
+        switch (tag[0]) {
+            case "e":
+                return { type: "nevent", data: getEventPointerFromETag(tag) };
+            case "a":
+                return {
+                    type: "naddr",
+                    data: getAddressPointerFromATag(tag),
+                };
+            case "p":
+                return { type: "nprofile", data: getProfilePointerFromPTag(tag) };
+            // NIP-18 quote tags
+            case "q":
+                return { type: "nevent", data: getEventPointerFromETag(tag) };
+        }
+    }
+    catch (error) { }
+    return null;
+}
+export function isAddressPointer(pointer) {
+    return (typeof pointer !== "string" &&
+        Reflect.has(pointer, "identifier") &&
+        Reflect.has(pointer, "pubkey") &&
+        Reflect.has(pointer, "kind"));
+}
+export function isEventPointer(pointer) {
+    return typeof pointer !== "string" && Reflect.has(pointer, "id");
+}
+/** Returns the coordinate string for an AddressPointer */
+export function getCoordinateFromAddressPointer(pointer) {
+    return `${pointer.kind}:${pointer.pubkey}:${pointer.identifier}`;
+}
+/**
+ * Returns an AddressPointer for a replaceable event
+ * @throws
+ */
+export function getAddressPointerForEvent(event, relays) {
+    if (!isParameterizedReplaceableKind(event.kind))
+        throw new Error("Cant get AddressPointer for non-replaceable event");
+    const d = getReplaceableIdentifier(event);
+    return {
+        identifier: d,
+        kind: event.kind,
+        pubkey: event.pubkey,
+        relays,
+    };
+}
+/**
+ * Returns an EventPointer for an event
+ * @throws
+ */
+export function getEventPointerForEvent(event, relays) {
+    return {
+        id: event.id,
+        kind: event.kind,
+        author: event.pubkey,
+        relays,
+    };
+}
+/** Returns a pointer for a given event */
+export function getPointerForEvent(event, relays) {
+    if (kinds.isParameterizedReplaceableKind(event.kind)) {
+        const d = getReplaceableIdentifier(event);
+        return {
+            type: "naddr",
+            data: {
+                identifier: d,
+                kind: event.kind,
+                pubkey: event.pubkey,
+                relays,
+            },
+        };
+    }
+    else {
+        return {
+            type: "nevent",
+            data: {
+                id: event.id,
+                kind: event.kind,
+                author: event.pubkey,
+                relays,
+            },
+        };
+    }
+}

package/dist/helpers/profile.d.ts

@@ -0,0 +1,20 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ProfileContentSymbol: unique symbol;
+export type ProfileContent = {
+    name?: string;
+    display_name?: string;
+    displayName?: string;
+    about?: string;
+    /** @deprecated */
+    image?: string;
+    picture?: string;
+    banner?: string;
+    website?: string;
+    lud16?: string;
+    lud06?: string;
+    nip05?: string;
+};
+/** Returns the parsed profile content for a kind 0 event */
+export declare function getProfileContent(event: NostrEvent): ProfileContent;
+/** Checks if the content of the kind 0 event is valid JSON */
+export declare function isValidProfile(profile?: NostrEvent): boolean;

package/dist/helpers/profile.js

@@ -0,0 +1,31 @@
+import { kinds } from "nostr-tools";
+import { getOrComputeCachedValue } from "./cache.js";
+export const ProfileContentSymbol = Symbol.for("profile-content");
+/** Returns the parsed profile content for a kind 0 event */
+export function getProfileContent(event) {
+    return getOrComputeCachedValue(event, ProfileContentSymbol, () => {
+        const profile = JSON.parse(event.content);
+        // ensure nip05 is a string
+        if (profile.nip05 && typeof profile.nip05 !== "string")
+            profile.nip05 = String(profile.nip05);
+        // add missing protocol to website
+        if (profile.website && profile.website?.length > 0 && profile.website?.startsWith("http") === false) {
+            profile.website = "https://" + profile.website;
+        }
+        return profile;
+    });
+}
+/** Checks if the content of the kind 0 event is valid JSON */
+export function isValidProfile(profile) {
+    if (!profile)
+        return false;
+    if (profile.kind !== kinds.Metadata)
+        return false;
+    try {
+        getProfileContent(profile);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/dist/helpers/relays.d.ts

@@ -0,0 +1,12 @@
+import { NostrEvent } from "nostr-tools";
+export declare const SeenRelaysSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [SeenRelaysSymbol]?: Set<string>;
+    }
+}
+export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
+export declare function getSeenRelays(event: NostrEvent): Set<string> | undefined;
+export declare function validateRelayURL(relay: string | URL): URL;
+export declare function safeRelayUrl(relayUrl: string | URL): string | null;
+export declare function safeRelayUrls(urls: Iterable<string>): string[];

package/dist/helpers/relays.js

@@ -0,0 +1,31 @@
+export const SeenRelaysSymbol = Symbol.for("seen-relays");
+// Seen relays
+export function addSeenRelay(event, relay) {
+    if (!event[SeenRelaysSymbol])
+        event[SeenRelaysSymbol] = new Set();
+    event[SeenRelaysSymbol].add(relay);
+    return event[SeenRelaysSymbol];
+}
+export function getSeenRelays(event) {
+    return event[SeenRelaysSymbol];
+}
+// Relay URLs
+export function validateRelayURL(relay) {
+    if (typeof relay === "string" && relay.includes(",ws"))
+        throw new Error("Can not have multiple relays in one string");
+    const url = typeof relay === "string" ? new URL(relay) : relay;
+    if (url.protocol !== "wss:" && url.protocol !== "ws:")
+        throw new Error("Incorrect protocol");
+    return url;
+}
+export function safeRelayUrl(relayUrl) {
+    try {
+        return validateRelayURL(relayUrl).toString();
+    }
+    catch (e) {
+        return null;
+    }
+}
+export function safeRelayUrls(urls) {
+    return Array.from(urls).map(safeRelayUrl).filter(Boolean);
+}

package/dist/helpers/share.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+export declare const SharedEventSymbol: unique symbol;
+/** Returns the stringified event in the content of a kind 6 or 16 share event */
+export declare function parseSharedEvent(event: NostrEvent): NostrEvent | undefined;

package/dist/helpers/share.js

@@ -0,0 +1,12 @@
+import { safeParse } from "./json.js";
+import { getOrComputeCachedValue } from "./cache.js";
+export const SharedEventSymbol = Symbol.for("shared-event");
+/** Returns the stringified event in the content of a kind 6 or 16 share event */
+export function parseSharedEvent(event) {
+    return getOrComputeCachedValue(event, SharedEventSymbol, () => {
+        const json = safeParse(event.content);
+        if (!json)
+            return;
+        return json;
+    });
+}

package/dist/helpers/string.d.ts

@@ -0,0 +1,10 @@
+/** Tests if a string is hex */
+export declare function isHex(str?: string): boolean;
+/** Tests if a string is a 64 length hex string */
+export declare function isHexKey(key?: string): boolean;
+/**
+ * Remove invisible characters from a string
+ * @see read more https://www.regular-expressions.info/unicode.html#category
+ */
+export declare function stripInvisibleChar(str: string): string;
+export declare function stripInvisibleChar(str?: string | undefined): string | undefined;

package/dist/helpers/string.js

@@ -0,0 +1,15 @@
+/** Tests if a string is hex */
+export function isHex(str) {
+    if (str?.match(/^[0-9a-f]+$/i))
+        return true;
+    return false;
+}
+/** Tests if a string is a 64 length hex string */
+export function isHexKey(key) {
+    if (key?.toLowerCase()?.match(/^[0-9a-f]{64}$/))
+        return true;
+    return false;
+}
+export function stripInvisibleChar(str) {
+    return str && str.replaceAll(/[\p{Cf}\p{Zs}]/gu, "");
+}

package/dist/helpers/tags.d.ts

@@ -0,0 +1,25 @@
+/** Checks if tag is an "e" tag and has at least one value */
+export declare function isETag(tag: string[]): tag is ["e", string, ...string[]];
+/** Checks if tag is an "p" tag and has at least one value */
+export declare function isPTag(tag: string[]): tag is ["p", string, ...string[]];
+/** Checks if tag is an "r" tag and has at least one value */
+export declare function isRTag(tag: string[]): tag is ["r", string, ...string[]];
+/** Checks if tag is an "d" tag and has at least one value */
+export declare function isDTag(tag: string[]): tag is ["d", string, ...string[]];
+/** Checks if tag is an "a" tag and has at least one value */
+export declare function isATag(tag: string[]): tag is ["a", string, ...string[]];
+/** Checks if tag is an "a" tag and has at least one value */
+export declare function isTTag(tag: string[]): tag is ["t", string, ...string[]];
+/** A pipeline that filters and maps each tag */
+type TagPipe = {
+    <A>(tags: string[][], ta: (tag: string[]) => A | undefined): A[];
+    <A, B>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined): B[];
+    <A, B, C>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined): C[];
+    <A, B, C, D>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined): D[];
+    <A, B, C, D, E>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined): E[];
+    <A, B, C, D, E, F>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined, ef: (e: E) => F | undefined): F[];
+    <A, B, C, D, E, F, G>(tags: string[][], ta: (tag: string[]) => A | undefined, ab: (a: A) => B | undefined, bc: (b: B) => C | undefined, cd: (c: C) => D | undefined, de: (d: D) => E | undefined, ef: (e: E) => F | undefined, fg: (f: F) => G | undefined): G[];
+};
+/** Filter and transform tags */
+export declare const processTags: TagPipe;
+export {};

package/dist/helpers/tags.js

@@ -0,0 +1,42 @@
+/** Checks if tag is an "e" tag and has at least one value */
+export function isETag(tag) {
+    return tag[0] === "e" && tag[1] !== undefined;
+}
+/** Checks if tag is an "p" tag and has at least one value */
+export function isPTag(tag) {
+    return tag[0] === "p" && tag[1] !== undefined;
+}
+/** Checks if tag is an "r" tag and has at least one value */
+export function isRTag(tag) {
+    return tag[0] === "r" && tag[1] !== undefined;
+}
+/** Checks if tag is an "d" tag and has at least one value */
+export function isDTag(tag) {
+    return tag[0] === "d" && tag[1] !== undefined;
+}
+/** Checks if tag is an "a" tag and has at least one value */
+export function isATag(tag) {
+    return tag[0] === "a" && tag[1] !== undefined;
+}
+/** Checks if tag is an "a" tag and has at least one value */
+export function isTTag(tag) {
+    return tag[0] === "a" && tag[1] !== undefined;
+}
+/** Filter and transform tags */
+export const processTags = (tags, ...fns) => {
+    return fns.reduce((step, fn) => {
+        const next = [];
+        for (const value of step) {
+            try {
+                const result = fn(value);
+                if (result === undefined)
+                    continue; // value is undefined, ignore
+                next.push(result);
+            }
+            catch (error) {
+                // failed to process value, ignore
+            }
+        }
+        return next;
+    }, tags);
+};

package/dist/helpers/tags.test.d.ts

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

package/dist/helpers/tags.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { isATag, processTags } from "./tags.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+describe("tag helpers", () => {
+    describe("processTags", () => {
+        it("should filter out errors", () => {
+            expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], getAddressPointerFromATag)).toEqual([{ identifier: "list", kind: 30000, pubkey: "pubkey" }]);
+        });
+        it("should filter out undefined", () => {
+            expect(processTags([["a", "bad coordinate"], ["e"], ["a", "30000:pubkey:list"]], (tag) => isATag(tag) ? tag : undefined)).toEqual([
+                ["a", "bad coordinate"],
+                ["a", "30000:pubkey:list"],
+            ]);
+        });
+    });
+});

package/dist/helpers/threading.d.ts

@@ -0,0 +1,55 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+export type ThreadReferences = {
+    root?: {
+        e: EventPointer;
+        a: undefined;
+    } | {
+        e: undefined;
+        a: AddressPointer;
+    } | {
+        e: EventPointer;
+        a: AddressPointer;
+    };
+    reply?: {
+        e: EventPointer;
+        a: undefined;
+    } | {
+        e: undefined;
+        a: AddressPointer;
+    } | {
+        e: EventPointer;
+        a: AddressPointer;
+    };
+};
+export declare const Nip10ThreadRefsSymbol: unique symbol;
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export declare function getEventPointerFromThreadTag(tag: string[]): EventPointer;
+/** Parses NIP-10 tags and handles legacy behavior */
+export declare function interpretThreadTags(tags: string[][]): {
+    root?: {
+        e: string[];
+        a: undefined;
+    } | {
+        e: undefined;
+        a: string[];
+    } | {
+        e: string[];
+        a: string[];
+    };
+    reply?: {
+        e: string[];
+        a: undefined;
+    } | {
+        e: undefined;
+        a: string[];
+    } | {
+        e: string[];
+        a: string[];
+    };
+};
+/** Returns the parsed NIP-10 tags for an event */
+export declare function getNip10References(event: NostrEvent | EventTemplate): ThreadReferences;

package/dist/helpers/threading.js

@@ -0,0 +1,94 @@
+import { getAddressPointerFromATag } from "./pointers.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { safeRelayUrls } from "./relays.js";
+export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
+/**
+ * Gets an EventPointer form a NIP-10 threading "e" tag
+ * @throws
+ */
+export function getEventPointerFromThreadTag(tag) {
+    if (!tag[1])
+        throw new Error("Missing event id in tag");
+    let pointer = { id: tag[1] };
+    if (tag[2])
+        pointer.relays = safeRelayUrls([tag[2]]);
+    // get author from NIP-18 quote tags, nip-22 comments tags, or nip-10 thread tags
+    if (tag[0] === "e" &&
+        (tag[3] === "root" || tag[3] === "reply" || tag[3] === "mention") &&
+        tag[4] &&
+        tag[4].length === 64) {
+        // NIP-10 "e" tag
+        pointer.author = tag[4];
+    }
+    return pointer;
+}
+/** Parses NIP-10 tags and handles legacy behavior */
+export function interpretThreadTags(tags) {
+    const eTags = tags.filter((t) => t[0] === "e" && t[1]);
+    const aTags = tags.filter((t) => t[0] === "a" && t[1]);
+    // find the root and reply tags.
+    let rootETag = eTags.find((t) => t[3] === "root");
+    let replyETag = eTags.find((t) => t[3] === "reply");
+    let rootATag = aTags.find((t) => t[3] === "root");
+    let replyATag = aTags.find((t) => t[3] === "reply");
+    if (!rootETag || !replyETag) {
+        // a direct reply does not need a "reply" reference
+        // https://github.com/nostr-protocol/nips/blob/master/10.md
+        // this is not necessarily to spec. but if there is only one id (root or reply) then assign it to both
+        // this handles the cases where a client only set a "reply" tag and no root
+        rootETag = replyETag = rootETag || replyETag;
+    }
+    if (!rootATag || !replyATag) {
+        rootATag = replyATag = rootATag || replyATag;
+    }
+    if (!rootETag && !replyETag) {
+        // legacy behavior
+        // https://github.com/nostr-protocol/nips/blob/master/10.md#positional-e-tags-deprecated
+        const legacyETags = eTags.filter((t) => {
+            // ignore it if there is a marker
+            if (t[3])
+                return false;
+            return true;
+        });
+        if (legacyETags.length >= 1) {
+            // first tag is the root
+            rootETag = legacyETags[0];
+            // last tag is reply
+            replyETag = legacyETags[legacyETags.length - 1] ?? rootETag;
+        }
+    }
+    return {
+        root: rootETag || rootATag ? { e: rootETag, a: rootATag } : undefined,
+        reply: replyETag || replyATag ? { e: replyETag, a: replyATag } : undefined,
+    };
+}
+/** Returns the parsed NIP-10 tags for an event */
+export function getNip10References(event) {
+    return getOrComputeCachedValue(event, Nip10ThreadRefsSymbol, () => {
+        const tags = interpretThreadTags(event.tags);
+        let root;
+        if (tags.root) {
+            try {
+                root = {
+                    e: tags.root.e && getEventPointerFromThreadTag(tags.root.e),
+                    a: tags.root.a && getAddressPointerFromATag(tags.root.a),
+                };
+            }
+            catch (error) { }
+        }
+        let reply;
+        if (tags.reply) {
+            try {
+                reply = {
+                    e: tags.reply.e && getEventPointerFromThreadTag(tags.reply.e),
+                    a: tags.reply.a && getAddressPointerFromATag(tags.reply.a),
+                };
+            }
+            catch (error) { }
+        }
+        return {
+            root,
+            reply,
+        };
+    });
+}

package/dist/helpers/threading.test.d.ts

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

package/dist/helpers/threading.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { interpretThreadTags } from "./threading.js";
+describe("threading helpers", () => {
+    describe("interpretThreadTags", () => {
+        it("should handle legacy tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id"],
+                ["e", "reply-id"],
+            ])).toEqual({ root: { a: undefined, e: ["e", "root-id"] }, reply: { a: undefined, e: ["e", "reply-id"] } });
+        });
+        it("should handle nip-10 tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id", "relay", "root"],
+                ["e", "reply-id", "relay", "reply"],
+            ])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+        it("should ignore mention nip-10 tags", () => {
+            expect(interpretThreadTags([
+                ["e", "root-id", "relay", "root"],
+                ["e", "mention-id", "relay", "mention"],
+                ["e", "reply-id", "relay", "reply"],
+            ])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+        it("should handle single nip-10 tags", () => {
+            expect(interpretThreadTags([["e", "root-id", "relay", "root"]])).toEqual({
+                root: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+                reply: { a: undefined, e: ["e", "root-id", "relay", "root"] },
+            });
+            expect(interpretThreadTags([["e", "reply-id", "relay", "reply"]])).toEqual({
+                root: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+                reply: { a: undefined, e: ["e", "reply-id", "relay", "reply"] },
+            });
+        });
+    });
+});

package/dist/helpers/time.d.ts

@@ -0,0 +1,2 @@
+/** Returns the current unix timestamp */
+export declare function unixNow(): number;

package/dist/helpers/time.js

@@ -0,0 +1,4 @@
+/** Returns the current unix timestamp */
+export function unixNow() {
+    return Math.round(Date.now() / 1000);
+}

package/dist/helpers/url.d.ts

@@ -0,0 +1,14 @@
+export declare const convertToUrl: (url: string | URL) => URL;
+export declare const getURLFilename: (url: URL) => string | undefined;
+export declare const IMAGE_EXT: string[];
+export declare const VIDEO_EXT: string[];
+export declare const STREAM_EXT: string[];
+export declare const AUDIO_EXT: string[];
+/** Checks if a url is a image URL */
+export declare function isImageURL(url: string | URL): boolean;
+/** Checks if a url is a video URL */
+export declare function isVideoURL(url: string | URL): boolean;
+/** Checks if a url is a stream URL */
+export declare function isStreamURL(url: string | URL): boolean;
+/** Checks if a url is a audio URL */
+export declare function isAudioURL(url: string | URL): boolean;