applesauce-content 0.0.0-concord-20260710175615

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# applesauce-content
+
+applesauce package for parsing text note content
+
+## Example
+
+```ts
+import { getParsedContent } from "applesauce-content/text";
+
+const stringContent = `
+hello nostr!
+nostr:npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6
+`;
+const ats = getParsedContent(stringContent);
+
+console.log(ats);
+/*
+{
+  type: 'root',
+  event: undefined,
+  children: [
+    { type: 'text', value: 'hello nostr!' },
+    { type: 'text', value: '\n' },
+    {
+      type: 'mention',
+      decoded: [Object],
+      encoded: 'npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6'
+    }
+  ]
+}
+*/
+```

package/dist/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from "./media.js";

package/dist/helpers/index.js

@@ -0,0 +1 @@
+export * from "./media.js";

package/dist/helpers/media.d.ts

@@ -0,0 +1,3 @@
+import { MediaAttachment } from "applesauce-common/helpers/file-metadata";
+/** Returns all URLs in a content string that contain a sha256 hash */
+export declare function getMediaAttachmentURLsFromContent(content: string): MediaAttachment[];

package/dist/helpers/media.js

@@ -0,0 +1,15 @@
+import { getSha256FromURL } from "applesauce-common/helpers/file-metadata";
+import { Tokens } from "applesauce-core/helpers/regexp";
+/** Returns all URLs in a content string that contain a sha256 hash */
+export function getMediaAttachmentURLsFromContent(content) {
+    return (Array.from(content.matchAll(Tokens.link))
+        .map((match) => match[0])
+        // filter out invalid URLs
+        .filter((str) => URL.canParse(str))
+        // convert to URLs
+        .map((url) => new URL(url))
+        // only keep urls with sha256 hashes in the
+        .filter((url) => !!getSha256FromURL(url))
+        // convert to media attachments
+        .map((url) => ({ url: url.toString(), sha256: getSha256FromURL(url) })));
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * as Text from "./text/index.js";
+export * as Nast from "./nast/index.js";
+export * as Markdown from "./markdown/index.js";
+export * as Helpers from "./helpers/index.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * as Text from "./text/index.js";
+export * as Nast from "./nast/index.js";
+export * as Markdown from "./markdown/index.js";
+export * as Helpers from "./helpers/index.js";

package/dist/markdown/blossom.d.ts

@@ -0,0 +1,9 @@
+import { ParsedBlossomURI } from "applesauce-common/helpers/blossom";
+import { Link, Nodes } from "mdast";
+import { Transformer } from "unified";
+export interface BlossomMdastLink extends Link {
+    type: "link";
+    data: ParsedBlossomURI;
+}
+/** Finds and creates BUD-10 `blossom:` URI links in a mdast tree */
+export declare function remarkBlossomURIs(): Transformer<Nodes>;

package/dist/markdown/blossom.js

@@ -0,0 +1,22 @@
+import { parseBlossomURI } from "applesauce-common/helpers/blossom";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "mdast-util-find-and-replace";
+/** Finds and creates BUD-10 `blossom:` URI links in a mdast tree */
+export function remarkBlossomURIs() {
+    return (tree) => {
+        findAndReplace(tree, [
+            Tokens.blossom,
+            (raw) => {
+                const parsed = parseBlossomURI(raw);
+                if (!parsed)
+                    return false;
+                return {
+                    type: "link",
+                    data: parsed,
+                    url: raw,
+                    children: [{ type: "text", value: raw }],
+                };
+            },
+        ]);
+    };
+}

package/dist/markdown/cashu.d.ts

@@ -0,0 +1,12 @@
+import { type Token } from "@cashu/cashu-ts";
+import { Link, Nodes } from "mdast";
+import { Transformer } from "unified";
+export interface CashuMdastLink extends Link {
+    type: "link";
+    data: {
+        token: Token;
+        raw: string;
+    };
+}
+/** Finds cashu tokens in a mdast tree and replaces them with link nodes carrying the decoded token */
+export declare function remarkCashuTokens(): Transformer<Nodes>;

package/dist/markdown/cashu.js

@@ -0,0 +1,24 @@
+import { getDecodedToken } from "@cashu/cashu-ts";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "mdast-util-find-and-replace";
+/** Finds cashu tokens in a mdast tree and replaces them with link nodes carrying the decoded token */
+export function remarkCashuTokens() {
+    return (tree) => {
+        findAndReplace(tree, [
+            Tokens.cashu,
+            (_, $1) => {
+                try {
+                    const token = getDecodedToken($1, []);
+                    return {
+                        type: "link",
+                        data: { token, raw: $1 },
+                        url: "cashu:" + $1,
+                        children: [{ type: "text", value: $1 }],
+                    };
+                }
+                catch (error) { }
+                return false;
+            },
+        ]);
+    };
+}

package/dist/markdown/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./mentions.js";
+export * from "./blossom.js";

package/dist/markdown/index.js

@@ -0,0 +1,2 @@
+export * from "./mentions.js";
+export * from "./blossom.js";

package/dist/markdown/mentions.d.ts

@@ -0,0 +1,8 @@
+import { DecodeResult } from "applesauce-core/helpers";
+import { Link, Nodes } from "mdast";
+import { Transformer } from "unified";
+export interface NostrMention extends Link {
+    type: "link";
+    data: DecodeResult;
+}
+export declare function remarkNostrMentions(): Transformer<Nodes>;

package/dist/markdown/mentions.js

@@ -0,0 +1,22 @@
+import { decodePointer } from "applesauce-core/helpers/pointers";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "mdast-util-find-and-replace";
+export function remarkNostrMentions() {
+    return (tree) => {
+        findAndReplace(tree, [
+            Tokens.nostrLink,
+            (_, $1) => {
+                try {
+                    return {
+                        type: "link",
+                        data: decodePointer($1),
+                        children: [],
+                        url: "nostr:" + $1,
+                    };
+                }
+                catch (error) { }
+                return false;
+            },
+        ]);
+    };
+}

package/dist/nast/eol-metadata.d.ts

@@ -0,0 +1,3 @@
+import { Transformer } from "unified";
+import { Root } from "../nast/types.js";
+export declare function eolMetadata(): Transformer<Root>;

package/dist/nast/eol-metadata.js

@@ -0,0 +1,14 @@
+export function eolMetadata() {
+    return (tree) => {
+        for (let i = 0; i < tree.children.length; i++) {
+            const node = tree.children[i];
+            const next = tree.children[i + 1];
+            if ((node.type === "text" && node.value.endsWith("\n")) ||
+                !next ||
+                (next.type === "text" && next.value.startsWith("\n"))) {
+                node.data = node.data || {};
+                node.data.eol = true;
+            }
+        }
+    };
+}

package/dist/nast/find-and-replace.d.ts

@@ -0,0 +1,6 @@
+import { Content, Root } from "./types.js";
+type Replace = (...groups: string[]) => null | undefined | false | string | Content | Content[];
+type FindAndReplaceTuple = [RegExp, Replace];
+type FindAndReplaceList = FindAndReplaceTuple[];
+export declare function findAndReplace(tree: Root, list: FindAndReplaceList): void;
+export {};

package/dist/nast/find-and-replace.js

@@ -0,0 +1,95 @@
+import { visitParents } from "unist-util-visit-parents";
+export function findAndReplace(tree, list) {
+    const pairs = list;
+    let pairIndex = -1;
+    const visitor = (node, parents) => {
+        let index = -1;
+        /** @type {Parents | undefined} */
+        let grandparent;
+        while (++index < parents.length) {
+            const parent = parents[index];
+            // const siblings = grandparent ? grandparent.children : undefined;
+            grandparent = parent;
+        }
+        if (grandparent) {
+            return handler(node, parents);
+        }
+        return undefined;
+    };
+    while (++pairIndex < pairs.length) {
+        visitParents(tree, "text", visitor);
+    }
+    /**
+     * Handle a text node which is not in an ignored parent.
+     *
+     * @param {Text} node
+     *   Text node.
+     * @param {Array<Parents>} parents
+     *   Parents.
+     * @returns {VisitorResult}
+     *   Result.
+     */
+    function handler(node, parents) {
+        const parent = parents[parents.length - 1];
+        const find = pairs[pairIndex][0];
+        const replace = pairs[pairIndex][1];
+        let start = 0;
+        const siblings = parent.children;
+        const index = siblings.indexOf(node);
+        let change = false;
+        let nodes = [];
+        find.lastIndex = 0;
+        let match = find.exec(node.value);
+        while (match) {
+            const position = match.index;
+            /** @type {RegExpMatchObject} */
+            // const matchObject = {
+            //   index: match.index,
+            //   input: match.input,
+            //   stack: [...parents, node],
+            // };
+            // let value = replace(...match, matchObject);
+            let value = replace(...match);
+            if (typeof value === "string") {
+                value = value.length > 0 ? { type: "text", value } : undefined;
+            }
+            // It wasn’t a match after all.
+            if (value === false) {
+                // False acts as if there was no match.
+                // So we need to reset `lastIndex`, which currently being at the end of
+                // the current match, to the beginning.
+                find.lastIndex = position + 1;
+            }
+            else {
+                if (start !== position) {
+                    nodes.push({
+                        type: "text",
+                        value: node.value.slice(start, position),
+                    });
+                }
+                if (Array.isArray(value)) {
+                    nodes.push(...value);
+                }
+                else if (value) {
+                    nodes.push(value);
+                }
+                start = position + match[0].length;
+                change = true;
+            }
+            if (!find.global) {
+                break;
+            }
+            match = find.exec(node.value);
+        }
+        if (change) {
+            if (start < node.value.length) {
+                nodes.push({ type: "text", value: node.value.slice(start) });
+            }
+            parent.children.splice(index, 1, ...nodes);
+        }
+        else {
+            nodes = [node];
+        }
+        return index + nodes.length;
+    }
+}

package/dist/nast/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./find-and-replace.js";
+export * from "./eol-metadata.js";
+export * from "./truncate.js";

package/dist/nast/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./find-and-replace.js";
+export * from "./eol-metadata.js";
+export * from "./truncate.js";

package/dist/nast/truncate.d.ts

@@ -0,0 +1,2 @@
+import { Root } from "./types.js";
+export declare function truncateContent(tree: Root, maxLength?: number): Root;

package/dist/nast/truncate.js

@@ -0,0 +1,51 @@
+export function truncateContent(tree, maxLength = 256) {
+    let length = 0;
+    for (let i = 0; i < tree.children.length; i++) {
+        const node = tree.children[i];
+        switch (node.type) {
+            case "hashtag":
+                length += 1 + node.hashtag.length;
+                break;
+            case "mention":
+                // guess user names are about 10 long
+                length += 10;
+                break;
+            case "cashu":
+                length += node.raw.length;
+                break;
+            case "blossom":
+                length += node.raw.length;
+                break;
+            case "gallery":
+                length += node.links.reduce((t, l) => t + l.length, 0);
+                break;
+            case "link":
+            case "text":
+                length += node.value.length;
+                break;
+            case "emoji":
+                length += 1;
+                break;
+        }
+        if (length > maxLength) {
+            if (node.type === "text") {
+                const children = i > 0 ? tree.children.slice(0, i) : [];
+                const chunkLength = node.value.length - (length - maxLength);
+                // find the nearest newline
+                const newLines = node.value.matchAll(/\n/g);
+                for (const match of newLines) {
+                    if (match.index && match.index > chunkLength) {
+                        children.push({ type: "text", value: node.value.slice(0, match.index) });
+                        return { ...tree, children, truncated: true };
+                    }
+                }
+                // just cut the string
+                children.push({ type: "text", value: node.value.slice(0, maxLength - length) });
+                return { ...tree, children, truncated: true };
+            }
+            else
+                return { ...tree, children: tree.children.slice(0, i), truncated: true };
+        }
+    }
+    return tree;
+}

package/dist/nast/types.d.ts

@@ -0,0 +1,74 @@
+import { type EventTemplate, type NostrEvent } from "applesauce-core/helpers/event";
+import { type DecodeResult } from "applesauce-core/helpers/pointers";
+import { type Parent, type Node as UnistNode } from "unist";
+export interface CommonData {
+    eol?: boolean;
+}
+export interface Node extends Omit<UnistNode, "data"> {
+    data?: CommonData;
+}
+export interface Text extends Node {
+    type: "text";
+    value: string;
+}
+export interface Link extends Node {
+    type: "link";
+    value: string;
+    href: string;
+}
+export interface Gallery extends Node {
+    type: "gallery";
+    links: string[];
+}
+export interface Mention extends Node {
+    type: "mention";
+    decoded: DecodeResult;
+    encoded: string;
+}
+export interface Hashtag extends Node {
+    type: "hashtag";
+    /** The name as it was written in the event */
+    name: string;
+    /** The lowercase canonical name */
+    hashtag: string;
+    /** The indexable tag for the hashtag. will be undefined if none was found */
+    tag?: ["t", ...string[]];
+}
+export interface Emoji extends Node {
+    type: "emoji";
+    code: string;
+    raw: string;
+    url: string;
+    tag: ["emoji", ...string[]];
+}
+export interface BlossomURI extends Node {
+    type: "blossom";
+    /** The original matched text, e.g. `blossom:<hash>.pdf?xs=...` */
+    raw: string;
+    /** 64 character lowercase hex sha256 hash of the blob */
+    sha256: string;
+    /** File extension without the leading dot */
+    ext: string;
+    /** Optional exact blob size in bytes */
+    size?: number;
+    /** Server hints from repeated `xs` query parameters */
+    servers: string[];
+    /** Author hex pubkeys from repeated `as` query parameters */
+    authors: string[];
+}
+export interface ContentMap {
+    text: Text;
+    link: Link;
+    mention: Mention;
+    hashtag: Hashtag;
+    emoji: Emoji;
+    gallery: Gallery;
+    blossom: BlossomURI;
+}
+export type Content = ContentMap[keyof ContentMap];
+export interface Root extends Parent {
+    type: "root";
+    children: Content[];
+    event?: NostrEvent | EventTemplate;
+    truncated?: boolean;
+}

package/dist/nast/types.js

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

package/dist/text/blossom.d.ts

@@ -0,0 +1,4 @@
+import { Transformer } from "unified";
+import { Root } from "../nast/types.js";
+/** Finds and creates BUD-10 blossom URI nodes in the tree */
+export declare function blossomURIs(): Transformer<Root>;

package/dist/text/blossom.js

@@ -0,0 +1,23 @@
+import { parseBlossomURI } from "applesauce-common/helpers/blossom";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "../nast/find-and-replace.js";
+/** Finds and creates BUD-10 blossom URI nodes in the tree */
+export function blossomURIs() {
+    return (tree) => {
+        findAndReplace(tree, [
+            [
+                Tokens.blossom,
+                (raw) => {
+                    const parsed = parseBlossomURI(raw);
+                    if (!parsed)
+                        return false;
+                    return {
+                        type: "blossom",
+                        raw,
+                        ...parsed,
+                    };
+                },
+            ],
+        ]);
+    };
+}

package/dist/text/cashu.d.ts

@@ -0,0 +1,15 @@
+import { type Token } from "@cashu/cashu-ts";
+import { Transformer } from "unified";
+import { Node, Root } from "../nast/types.js";
+export interface CashuToken extends Node {
+    type: "cashu";
+    token: Token;
+    raw: string;
+}
+declare module "../nast/types.js" {
+    interface ContentMap {
+        cashu: CashuToken;
+    }
+}
+/** Parse cashu tokens from an ATS tree */
+export declare function cashuTokens(): Transformer<Root>;

package/dist/text/cashu.js

@@ -0,0 +1,32 @@
+import { getDecodedToken } from "@cashu/cashu-ts";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "../nast/find-and-replace.js";
+import { textNoteTransformers } from "./content.js";
+/** Parse cashu tokens from an ATS tree */
+export function cashuTokens() {
+    return (tree) => {
+        findAndReplace(tree, [
+            [
+                Tokens.cashu,
+                (_, $1) => {
+                    try {
+                        const token = getDecodedToken($1, []);
+                        return {
+                            type: "cashu",
+                            token,
+                            raw: $1,
+                        };
+                    }
+                    catch (error) { }
+                    return false;
+                },
+            ],
+        ]);
+    };
+}
+// Register the cashu transformer in the default text-note pipeline as a side
+// effect of importing this module. Consumers opt-in to cashu support by
+// importing `applesauce-content/text/cashu`.
+if (!textNoteTransformers.includes(cashuTokens)) {
+    textNoteTransformers.push(cashuTokens);
+}

package/dist/text/content.d.ts

@@ -0,0 +1,8 @@
+import { Transformer } from "unified";
+import { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
+import { Root } from "../nast/types.js";
+export declare const TextNoteContentSymbol: unique symbol;
+export declare const textNoteTransformers: (() => Transformer<Root>)[];
+/** Parsed and process a note with custom transformers */
+export declare function getParsedContent(event: NostrEvent | EventTemplate | string, content?: string, transformers?: (() => Transformer<Root>)[], cacheKey?: symbol | null | undefined): Root;
+export declare function removeParsedTextContent(event: NostrEvent | EventTemplate): void;

package/dist/text/content.js

@@ -0,0 +1,53 @@
+import { unified } from "unified";
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { nostrMentions } from "./mentions.js";
+import { emojis } from "./emoji.js";
+import { createEventContentTree } from "./parser.js";
+import { hashtags } from "./hashtag.js";
+import { galleries } from "./gallery.js";
+import { eolMetadata } from "../nast/eol-metadata.js";
+import { links } from "./links.js";
+import { blossomURIs } from "./blossom.js";
+export const TextNoteContentSymbol = Symbol.for("text-note-content");
+// default kind 1 transformers. Optional transformers (like `cashuTokens` and
+// `lightningInvoices`) opt in by appending to this array when their module is
+// imported — see `applesauce-content/text/cashu` and
+// `applesauce-content/text/lightning`.
+export const textNoteTransformers = [
+    blossomURIs,
+    links,
+    nostrMentions,
+    galleries,
+    emojis,
+    hashtags,
+    eolMetadata,
+];
+/** Parsed and process a note with custom transformers */
+export function getParsedContent(event, content, transformers = textNoteTransformers, cacheKey = TextNoteContentSymbol) {
+    // process strings
+    if (typeof event === "string") {
+        const processor = unified();
+        for (const transformer of transformers) {
+            processor.use(transformer);
+        }
+        return processor.runSync(createEventContentTree(event, content));
+    }
+    // no caching
+    if (!cacheKey) {
+        const processor = unified();
+        for (const transformer of transformers) {
+            processor.use(transformer);
+        }
+        return processor.runSync(createEventContentTree(event, content));
+    }
+    return getOrComputeCachedValue(event, cacheKey, () => {
+        const processor = unified();
+        for (const transformer of transformers) {
+            processor.use(transformer);
+        }
+        return processor.runSync(createEventContentTree(event, content));
+    });
+}
+export function removeParsedTextContent(event) {
+    Reflect.deleteProperty(event, TextNoteContentSymbol);
+}

package/dist/text/emoji.d.ts

@@ -0,0 +1,4 @@
+import { type Transformer } from "unified";
+import { Root } from "../nast/types.js";
+/** Finds and creates emoji nodes in the tree */
+export declare function emojis(): Transformer<Root>;

package/dist/text/emoji.js

@@ -0,0 +1,32 @@
+import { getEmojiTag } from "applesauce-common/helpers/emoji";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "../nast/find-and-replace.js";
+/** Finds and creates emoji nodes in the tree */
+export function emojis() {
+    return (tree) => {
+        const event = tree.event;
+        if (!event)
+            return;
+        findAndReplace(tree, [
+            [
+                Tokens.emoji,
+                (full, $1) => {
+                    try {
+                        const tag = getEmojiTag(event, $1);
+                        if (!tag)
+                            return false;
+                        return {
+                            type: "emoji",
+                            tag,
+                            raw: full,
+                            code: tag[1].toLowerCase(),
+                            url: tag[2],
+                        };
+                    }
+                    catch (error) { }
+                    return false;
+                },
+            ],
+        ]);
+    };
+}

package/dist/text/gallery.d.ts

@@ -0,0 +1,8 @@
+import { Transformer } from "unified";
+import { Root } from "../nast/types.js";
+export interface GalleriesOptions {
+    /** When true, adjacent `blossom:` image URIs are clustered alongside HTTP image links. Defaults to false. */
+    includeBlossom?: boolean;
+}
+/** Group images into galleries in an ATS tree */
+export declare function galleries(types?: string[], options?: GalleriesOptions): Transformer<Root>;

package/dist/text/gallery.js

@@ -0,0 +1,58 @@
+import { convertToUrl, getURLFilename, IMAGE_EXT } from "applesauce-core/helpers/url";
+/** Group images into galleries in an ATS tree */
+export function galleries(types = IMAGE_EXT, options = {}) {
+    const { includeBlossom = false } = options;
+    return (tree) => {
+        let items = [];
+        const getItemHref = (item) => (item.type === "link" ? item.href : item.raw);
+        const commit = (index) => {
+            // only create a gallery if there are more than a single image
+            if (items.length > 1) {
+                const start = tree.children.indexOf(items[0]);
+                const end = tree.children.indexOf(items[items.length - 1]);
+                // replace all nodes with a gallery
+                tree.children.splice(start, 1 + end - start, { type: "gallery", links: items.map(getItemHref) });
+                items = [];
+                // return new cursor
+                return end - 1;
+            }
+            else {
+                items = [];
+                return index;
+            }
+        };
+        for (let i = 0; i < tree.children.length; i++) {
+            const node = tree.children[i];
+            try {
+                if (node.type === "link") {
+                    const url = convertToUrl(node.href);
+                    const filename = getURLFilename(url);
+                    if (filename && types.some((ext) => filename.endsWith(ext))) {
+                        items.push(node);
+                    }
+                    else {
+                        i = commit(i);
+                    }
+                }
+                else if (node.type === "blossom" && includeBlossom) {
+                    if (types.some((ext) => ext === `.${node.ext.toLowerCase()}`)) {
+                        items.push(node);
+                    }
+                    else {
+                        i = commit(i);
+                    }
+                }
+                else if (node.type === "text" && items.length > 0) {
+                    const isEmpty = node.value === "\n" || !node.value.match(/[^\s]/g);
+                    if (!isEmpty)
+                        i = commit(i);
+                }
+            }
+            catch (error) {
+                i = commit(i);
+            }
+        }
+        // Do one finally commit, just in case a link is the last element in the list
+        commit(tree.children.length);
+    };
+}

package/dist/text/hashtag.d.ts

@@ -0,0 +1,4 @@
+import { Transformer } from "unified";
+import { Root } from "../nast/types.js";
+/** Find and create hashtag notes in provided tree */
+export declare function hashtags(): Transformer<Root>;

package/dist/text/hashtag.js

@@ -0,0 +1,30 @@
+import { getHashtagTag } from "applesauce-common/helpers/hashtag";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "../nast/find-and-replace.js";
+/** Find and create hashtag notes in provided tree */
+export function hashtags() {
+    return (tree) => {
+        const event = tree.event;
+        findAndReplace(tree, [
+            [
+                Tokens.hashtag,
+                (_, $1) => {
+                    try {
+                        const tag = event && getHashtagTag(event, $1);
+                        // Skip if the match if no tag was found in the event
+                        if (!tag && event)
+                            return false;
+                        return {
+                            type: "hashtag",
+                            tag,
+                            name: $1,
+                            hashtag: tag?.[1].toLowerCase() || $1.toLowerCase(),
+                        };
+                    }
+                    catch (error) { }
+                    return false;
+                },
+            ],
+        ]);
+    };
+}

package/dist/text/imeta.d.ts

@@ -0,0 +1,11 @@
+import { type FileMetadataFields } from "applesauce-common/helpers/file-metadata";
+import { type Transformer } from "unified";
+import { Root } from "../nast/types.js";
+declare module "../nast/types.js" {
+    interface Link {
+        /** File metadata from a matching NIP-92 `imeta` tag on the event */
+        metadata?: FileMetadataFields;
+    }
+}
+/** Hydrates link nodes with NIP-92 file metadata from matching `imeta` tags on the event */
+export declare function imetaLinks(): Transformer<Root>;

package/dist/text/imeta.js

@@ -0,0 +1,40 @@
+import { getMediaAttachments } from "applesauce-common/helpers/file-metadata";
+import { textNoteTransformers } from "./content.js";
+/** Hydrates link nodes with NIP-92 file metadata from matching `imeta` tags on the event */
+export function imetaLinks() {
+    return (tree) => {
+        const event = tree.event;
+        if (!event || !event.tags || event.tags.length === 0)
+            return;
+        const attachments = getMediaAttachments(event);
+        if (attachments.length === 0)
+            return;
+        // Build a normalized URL -> metadata map so lookups match `link.href` exactly
+        const byUrl = new Map();
+        for (const attachment of attachments) {
+            if (!attachment.url)
+                continue;
+            try {
+                byUrl.set(new URL(attachment.url).toString(), attachment);
+            }
+            catch {
+                // ignore invalid URLs
+            }
+        }
+        if (byUrl.size === 0)
+            return;
+        for (const node of tree.children) {
+            if (node.type !== "link")
+                continue;
+            const metadata = byUrl.get(node.href);
+            if (metadata)
+                node.metadata = metadata;
+        }
+    };
+}
+// Register the imeta transformer in the default text-note pipeline as a side
+// effect of importing this module. Consumers opt-in to imeta link hydration
+// by importing `applesauce-content/text/imeta`.
+if (!textNoteTransformers.includes(imetaLinks)) {
+    textNoteTransformers.push(imetaLinks);
+}

package/dist/text/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./blossom.js";
+export * from "./content.js";
+export * from "./emoji.js";
+export * from "./gallery.js";
+export * from "./hashtag.js";
+export * from "./imeta.js";
+export * from "./links.js";
+export * from "./mentions.js";
+export * from "./parser.js";

package/dist/text/index.js

@@ -0,0 +1,9 @@
+export * from "./blossom.js";
+export * from "./content.js";
+export * from "./emoji.js";
+export * from "./gallery.js";
+export * from "./hashtag.js";
+export * from "./imeta.js";
+export * from "./links.js";
+export * from "./mentions.js";
+export * from "./parser.js";

package/dist/text/lightning.d.ts

@@ -0,0 +1,15 @@
+import { type ParsedInvoice } from "applesauce-common/helpers/bolt11";
+import { type Transformer } from "unified";
+import { Node, Root } from "../nast/types.js";
+export interface LightningInvoice extends Node {
+    type: "lightning";
+    invoice: string;
+    parsed: ParsedInvoice;
+}
+declare module "../nast/types.js" {
+    interface ContentMap {
+        lightning: LightningInvoice;
+    }
+}
+/** Finds and creates lightning invoice nodes in the tree */
+export declare function lightningInvoices(): Transformer<Root>;

package/dist/text/lightning.js

@@ -0,0 +1,33 @@
+import { parseBolt11 } from "applesauce-common/helpers/bolt11";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "../nast/find-and-replace.js";
+import { textNoteTransformers } from "./content.js";
+/** Finds and creates lightning invoice nodes in the tree */
+export function lightningInvoices() {
+    return (tree) => {
+        findAndReplace(tree, [
+            [
+                Tokens.lightning,
+                (_, $1) => {
+                    try {
+                        const invoice = $1;
+                        const parsed = parseBolt11(invoice);
+                        return {
+                            type: "lightning",
+                            invoice,
+                            parsed,
+                        };
+                    }
+                    catch (error) { }
+                    return false;
+                },
+            ],
+        ]);
+    };
+}
+// Register the lightning transformer in the default text-note pipeline as a
+// side effect of importing this module. Consumers opt-in to lightning invoice
+// parsing by importing `applesauce-content/text/lightning`.
+if (!textNoteTransformers.includes(lightningInvoices)) {
+    textNoteTransformers.push(lightningInvoices);
+}

package/dist/text/links.d.ts

@@ -0,0 +1,4 @@
+import { Transformer } from "unified";
+import { Root } from "../nast/types.js";
+/** Finds and creates web links in the tree */
+export declare function links(): Transformer<Root>;

package/dist/text/links.js

@@ -0,0 +1,23 @@
+import { Tokens } from "applesauce-core/helpers";
+import { findAndReplace } from "../nast/find-and-replace.js";
+/** Finds and creates web links in the tree */
+export function links() {
+    return (tree) => {
+        findAndReplace(tree, [
+            [
+                Tokens.link,
+                (_) => {
+                    try {
+                        return {
+                            type: "link",
+                            href: new URL(_).toString(),
+                            value: _,
+                        };
+                    }
+                    catch (error) { }
+                    return false;
+                },
+            ],
+        ]);
+    };
+}

package/dist/text/mentions.d.ts

@@ -0,0 +1,4 @@
+import { Transformer } from "unified";
+import { Root } from "../nast/types.js";
+/** Finds and creates NIP-19 nostr mentions in the tree */
+export declare function nostrMentions(): Transformer<Root>;

package/dist/text/mentions.js

@@ -0,0 +1,24 @@
+import { decodePointer } from "applesauce-core/helpers/pointers";
+import { Tokens } from "applesauce-core/helpers/regexp";
+import { findAndReplace } from "../nast/find-and-replace.js";
+/** Finds and creates NIP-19 nostr mentions in the tree */
+export function nostrMentions() {
+    return (tree) => {
+        findAndReplace(tree, [
+            [
+                Tokens.nostrLink,
+                (_, $1) => {
+                    try {
+                        return {
+                            type: "mention",
+                            decoded: decodePointer($1),
+                            encoded: $1,
+                        };
+                    }
+                    catch (error) { }
+                    return false;
+                },
+            ],
+        ]);
+    };
+}

package/dist/text/parser.d.ts

@@ -0,0 +1,6 @@
+import { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
+import { Root } from "../nast/types.js";
+/** Creates a {@link Root} ATS node for a text note */
+export declare function createEventContentTree(event: NostrEvent | EventTemplate | string, content?: string): Root;
+/** @deprecated use createEventContentTree instead */
+export declare const createTextNoteATS: typeof createEventContentTree;

package/dist/text/parser.js

@@ -0,0 +1,15 @@
+/** Creates a {@link Root} ATS node for a text note */
+export function createEventContentTree(event, content) {
+    return {
+        type: "root",
+        event: typeof event !== "string" ? event : undefined,
+        children: [
+            {
+                type: "text",
+                value: content || (typeof event === "string" ? event : event.content),
+            },
+        ],
+    };
+}
+/** @deprecated use createEventContentTree instead */
+export const createTextNoteATS = createEventContentTree;

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "applesauce-content",
+  "version": "0.0.0-concord-20260710175615",
+  "description": "Unified plugins for processing event content",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "nostr"
+  ],
+  "author": "hzrd149",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./helpers": {
+      "import": "./dist/helpers/index.js",
+      "require": "./dist/helpers/index.js",
+      "types": "./dist/helpers/index.d.ts"
+    },
+    "./helpers/*": {
+      "import": "./dist/helpers/*.js",
+      "require": "./dist/helpers/*.js",
+      "types": "./dist/helpers/*.d.ts"
+    },
+    "./nast": {
+      "import": "./dist/nast/index.js",
+      "require": "./dist/nast/index.js",
+      "types": "./dist/nast/index.d.ts"
+    },
+    "./markdown": {
+      "import": "./dist/markdown/index.js",
+      "require": "./dist/markdown/index.js",
+      "types": "./dist/markdown/index.d.ts"
+    },
+    "./markdown/*": {
+      "import": "./dist/markdown/*.js",
+      "require": "./dist/markdown/*.js",
+      "types": "./dist/markdown/*.d.ts"
+    },
+    "./text": {
+      "import": "./dist/text/index.js",
+      "require": "./dist/text/index.js",
+      "types": "./dist/text/index.d.ts"
+    },
+    "./text/*": {
+      "import": "./dist/text/*.js",
+      "require": "./dist/text/*.js",
+      "types": "./dist/text/*.d.ts"
+    }
+  },
+  "dependencies": {
+    "@types/hast": "^3.0.4",
+    "@types/mdast": "^4.0.4",
+    "@types/unist": "^3.0.3",
+    "applesauce-common": "0.0.0-concord-20260710175615",
+    "applesauce-core": "0.0.0-concord-20260710175615",
+    "mdast-util-find-and-replace": "^3.0.2",
+    "remark": "^15.0.1",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.5",
+    "unist-util-visit-parents": "^6.0.1"
+  },
+  "devDependencies": {
+    "@cashu/cashu-ts": "^4.5.1",
+    "applesauce-signers": "0.0.0-concord-20260710175615",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.15"
+  },
+  "peerDependencies": {
+    "@cashu/cashu-ts": "^4.5.1"
+  },
+  "peerDependenciesMeta": {
+    "@cashu/cashu-ts": {
+      "optional": true
+    }
+  },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "tsc",
+    "watch:build": "tsc --watch > /dev/null",
+    "test": "vitest run --passWithNoTests",
+    "watch:test": "vitest"
+  }
+}