svelte-streamdown 1.0.6 → 1.0.7

package/dist/marked/marked-footnotes.js

@@ -0,0 +1,75 @@
+import { lex } from './index.js';
+export default function markedFootnote() {
+    const ensureMaps = (tokenizer) => {
+        if (!tokenizer.lexer.hasFootnotes) {
+            tokenizer.lexer.footnotes = {
+                refs: new Map(),
+                footnotes: new Map()
+            };
+            tokenizer.lexer.hasFootnotes = true;
+        }
+        return tokenizer.lexer.footnotes;
+    };
+    return {
+        extensions: [
+            {
+                name: 'footnote',
+                level: 'block',
+                tokenizer(src) {
+                    const maps = ensureMaps(this);
+                    const match = /^\[\^([^\]\n]+)\]:(?:[ \t]+|[\n]*?|$)([^\n]*?(?:\n|$)(?:\n*?[ ]{4,}[^\n]*)*)/.exec(src);
+                    if (match) {
+                        const [raw, label, text = ''] = match;
+                        let content = text.split('\n').reduce((acc, curr) => {
+                            return acc + '\n' + curr.replace(/^(?:[ ]{4}|[\t])/, '');
+                        }, '');
+                        const contentLastLine = content.trimEnd().split('\n').pop();
+                        content +=
+                            // add lines after list, blockquote, codefence, and table
+                            contentLastLine &&
+                                /^[ \t]*?[>\-*][ ]|[`]{3,}$|^[ \t]*?[|].+[|]$/.test(contentLastLine)
+                                ? '\n\n'
+                                : '';
+                        const token = {
+                            type: 'footnote',
+                            raw,
+                            label,
+                            tokens: lex(content)
+                        };
+                        maps.footnotes.set(label, token);
+                        const ref = maps.refs.get(label);
+                        if (ref) {
+                            ref.content = token;
+                        }
+                        return token;
+                    }
+                }
+            },
+            {
+                name: 'footnoteRef',
+                level: 'inline',
+                tokenizer(src) {
+                    const maps = ensureMaps(this);
+                    const match = /^\[\^([^\]\n]+)\]/.exec(src);
+                    if (match) {
+                        const [raw, label] = match;
+                        const footnote = maps.footnotes.get(label);
+                        const token = {
+                            type: 'footnoteRef',
+                            raw,
+                            label,
+                            content: footnote || {
+                                type: 'footnote',
+                                raw,
+                                label,
+                                tokens: []
+                            }
+                        };
+                        maps.refs.set(label, token);
+                        return token;
+                    }
+                }
+            }
+        ]
+    };
+}

package/dist/marked/marked-math.d.ts

@@ -0,0 +1,10 @@
+import type { TokenizerAndRendererExtension } from 'marked';
+export declare function markedMath(): {
+    extensions: TokenizerAndRendererExtension<string, string>[];
+};
+export type MathToken = {
+    type: 'math';
+    isInline: boolean;
+    raw: string;
+    text: string;
+};

package/dist/marked/marked-math.js

@@ -0,0 +1,60 @@
+const inlineRule = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])*?(?:\\.|[^\\\n\$]))\1(?=[\s?!\.,:？！。，：]|$)/;
+const inlineRuleNonStandard = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])*?(?:\\.|[^\\\n\$]))\1/; // Non-standard, even if there are no spaces before and after $ or $$, try to parse
+const blockRule = /^(\${1,2})\n((?:\\[^]|[^\\])+?)\n\1(?:\n|$)/;
+export function markedMath() {
+    return {
+        extensions: [
+            {
+                name: 'inline-math',
+                level: 'inline',
+                start(src) {
+                    let index;
+                    let indexSrc = src;
+                    while (indexSrc) {
+                        index = indexSrc.indexOf('$');
+                        if (index === -1) {
+                            return;
+                        }
+                        const f = index > -1;
+                        if (f) {
+                            const possibleKatex = indexSrc.substring(index);
+                            if (possibleKatex.match(inlineRuleNonStandard)) {
+                                return index;
+                            }
+                        }
+                        indexSrc = indexSrc.substring(index + 1).replace(/^\$+/, '');
+                    }
+                },
+                tokenizer(src) {
+                    const match = src.match(inlineRuleNonStandard);
+                    if (match) {
+                        console.log('match', match);
+                    }
+                    if (match) {
+                        return {
+                            type: 'math',
+                            isInline: true,
+                            raw: match[0],
+                            text: match[2].trim()
+                        };
+                    }
+                }
+            },
+            {
+                name: 'block-math',
+                level: 'block',
+                tokenizer(src) {
+                    const match = src.match(blockRule);
+                    if (match) {
+                        return {
+                            type: 'math',
+                            isInline: false,
+                            raw: match[0],
+                            text: match[2].trim()
+                        };
+                    }
+                }
+            }
+        ]
+    };
+}

package/dist/theme.d.ts

@@ -23,7 +23,7 @@ export declare const theme: {
     h6: {
         base: string;
     };
-    p: {
+    paragraph: {
         base: string;
     };
     ul: {
@@ -142,7 +142,7 @@ export declare const shadcnTheme: {
     h6: {
         base: string;
     };
-    p: {
+    paragraph: {
         base: string;
     };
     ul: {
@@ -262,7 +262,7 @@ export declare const mergeTheme: (customTheme?: Partial<Theme>, baseTheme?: "tai
     h6: {
         base: string;
     };
-    p: {
+    paragraph: {
         base: string;
     };
     ul: {

package/dist/theme.js

@@ -24,7 +24,7 @@ export const theme = {
     h6: {
         base: 'mt-6 mb-2 text-sm font-semibold'
     },
-    p: {
+    paragraph: {
         base: ''
     },
     ul: {
@@ -46,7 +46,7 @@ export const theme = {
         pre: 'overflow-x-auto font-mono p-0 bg-gray-100/40'
     },
     inlineCode: {
-        base: 'bg-gray-100 rounded px-1.5 py-0.5 font-mono text-sm'
+        base: 'bg-gray-100 rounded px-1.5 py-0.5 font-mono'
     },
     img: {
         base: 'group relative my-4  mx-auto w-fit block',
@@ -80,7 +80,7 @@ export const theme = {
         base: 'divide-gray-200 bg-gray-100/40 divide-y'
     },
     tr: {
-        base: 'border-gray-200 border-b'
+        base: 'border-gray-200 border-b hover:bg-gray-100/50 transition-colors'
     },
     th: {
         base: 'px-4 py-3 text-left text-sm font-semibold whitespace-nowrap min-w-[200px]'
@@ -143,7 +143,7 @@ export const shadcnTheme = {
     h6: {
         base: 'mt-6 mb-2 text-sm font-semibold text-foreground'
     },
-    p: {
+    paragraph: {
         base: 'text-foreground'
     },
     ul: {
@@ -165,7 +165,7 @@ export const shadcnTheme = {
         pre: 'overflow-x-auto font-mono p-0 bg-muted/40'
     },
     inlineCode: {
-        base: 'bg-muted rounded px-1.5 py-0.5 font-mono text-sm text-foreground'
+        base: 'bg-muted rounded px-1.5 py-0.5 font-mono text-foreground'
     },
     img: {
         base: 'group relative my-4 mx-auto w-fit block',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-streamdown",
-	"version": "1.0.6",
+	"version": "1.0.7",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -68,24 +68,12 @@
 		]
 	},
 	"dependencies": {
-		"@types/hast": "^3.0.4",
 		"clsx": "^2.1.1",
-		"hast": "^1.0.0",
-		"hast-util-is-element": "^3.0.0",
 		"html-url-attributes": "^3.0.1",
 		"katex": "^0.16.22",
 		"marked": "^16.2.1",
-		"mdast": "^3.0.0",
 		"mermaid": "^11.11.0",
-		"rehype-github-alerts": "^4.1.1",
-		"rehype-katex": "^7.0.1",
-		"remark-gfm": "^4.0.1",
-		"remark-math": "^6.0.0",
-		"remark-parse": "^11.0.0",
-		"remark-rehype": "^11.1.2",
 		"shiki": "^3.12.2",
-		"tailwind-merge": "^3.3.1",
-		"unified": "^11.0.5",
-		"unist-util-visit": "^5.0.0"
+		"tailwind-merge": "^3.3.1"
 	}
 }

package/dist/Elements/H1.svelte

@@ -1,23 +0,0 @@
-<script lang="ts">
-	import { useStreamdown } from '../Streamdown.svelte';
-	import { clsx } from 'clsx';
-	import type { ElementProps } from './element.js';
-	import Slot from './Slot.svelte';
-
-	const streamdown = useStreamdown();
-
-	const { children, node, className, props }: ElementProps = $props();
-</script>
-
-<Slot
-	props={{
-		children,
-		node,
-		...props
-	}}
-	render={streamdown.snippets.h1}
->
-	<h1 {...props} class={clsx(streamdown.theme.h1.base, className)}>
-		{@render children()}
-	</h1>
-</Slot>

package/dist/Elements/H1.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { ElementProps } from './element.js';
-declare const H1: import("svelte").Component<ElementProps, {}, "">;
-type H1 = ReturnType<typeof H1>;
-export default H1;

package/dist/Elements/H2.svelte

@@ -1,23 +0,0 @@
-<script lang="ts">
-	import { useStreamdown } from '../Streamdown.svelte';
-	import { clsx } from 'clsx';
-	import type { ElementProps } from './element.js';
-	import Slot from './Slot.svelte';
-
-	const streamdown = useStreamdown();
-
-	const { children, node, className, props }: ElementProps = $props();
-</script>
-
-<Slot
-	props={{
-		children,
-		node,
-		...props
-	}}
-	render={streamdown.snippets.h2}
->
-	<h2 {...props} class={clsx(streamdown.theme.h2.base, className)}>
-		{@render children()}
-	</h2>
-</Slot>

package/dist/Elements/H2.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { ElementProps } from './element.js';
-declare const H2: import("svelte").Component<ElementProps, {}, "">;
-type H2 = ReturnType<typeof H2>;
-export default H2;

package/dist/Elements/H3.svelte

@@ -1,23 +0,0 @@
-<script lang="ts">
-	import { useStreamdown } from '../Streamdown.svelte';
-	import { clsx } from 'clsx';
-	import type { ElementProps } from './element.js';
-	import Slot from './Slot.svelte';
-
-	const streamdown = useStreamdown();
-
-	const { children, node, className, props }: ElementProps = $props();
-</script>
-
-<Slot
-	props={{
-		children,
-		node,
-		...props
-	}}
-	render={streamdown.snippets.h3}
->
-	<h3 {...props} class={clsx(streamdown.theme.h3.base, className)}>
-		{@render children()}
-	</h3>
-</Slot>

package/dist/Elements/H3.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { ElementProps } from './element.js';
-declare const H3: import("svelte").Component<ElementProps, {}, "">;
-type H3 = ReturnType<typeof H3>;
-export default H3;

package/dist/Elements/H4.svelte

@@ -1,23 +0,0 @@
-<script lang="ts">
-	import { useStreamdown } from '../Streamdown.svelte';
-	import { clsx } from 'clsx';
-	import type { ElementProps } from './element.js';
-	import Slot from './Slot.svelte';
-
-	const streamdown = useStreamdown();
-
-	const { children, node, className, props }: ElementProps = $props();
-</script>
-
-<Slot
-	props={{
-		children,
-		node,
-		...props
-	}}
-	render={streamdown.snippets.h4}
->
-	<h4 {...props} class={clsx(streamdown.theme.h4.base, className)}>
-		{@render children()}
-	</h4>
-</Slot>

package/dist/Elements/H4.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { ElementProps } from './element.js';
-declare const H4: import("svelte").Component<ElementProps, {}, "">;
-type H4 = ReturnType<typeof H4>;
-export default H4;

package/dist/Elements/H5.svelte

@@ -1,23 +0,0 @@
-<script lang="ts">
-	import { useStreamdown } from '../Streamdown.svelte';
-	import { clsx } from 'clsx';
-	import type { ElementProps } from './element.js';
-	import Slot from './Slot.svelte';
-
-	const streamdown = useStreamdown();
-
-	const { children, node, className, props }: ElementProps = $props();
-</script>
-
-<Slot
-	props={{
-		children,
-		node,
-		...props
-	}}
-	render={streamdown.snippets.h5}
->
-	<h5 {...props} class={clsx(streamdown.theme.h5.base, className)}>
-		{@render children()}
-	</h5>
-</Slot>

package/dist/Elements/H5.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { ElementProps } from './element.js';
-declare const H5: import("svelte").Component<ElementProps, {}, "">;
-type H5 = ReturnType<typeof H5>;
-export default H5;

package/dist/Elements/H6.svelte

@@ -1,23 +0,0 @@
-<script lang="ts">
-	import { useStreamdown } from '../Streamdown.svelte';
-	import { clsx } from 'clsx';
-	import type { ElementProps } from './element.js';
-	import Slot from './Slot.svelte';
-
-	const streamdown = useStreamdown();
-
-	const { children, node, className, props }: ElementProps = $props();
-</script>
-
-<Slot
-	props={{
-		children,
-		node,
-		...props
-	}}
-	render={streamdown.snippets.h6}
->
-	<h6 {...props} class={clsx(streamdown.theme.h6.base, className)}>
-		{@render children()}
-	</h6>
-</Slot>

package/dist/Elements/H6.svelte.d.ts

@@ -1,4 +0,0 @@
-import type { ElementProps } from './element.js';
-declare const H6: import("svelte").Component<ElementProps, {}, "">;
-type H6 = ReturnType<typeof H6>;
-export default H6;

package/dist/Elements/element.d.ts

@@ -1,8 +0,0 @@
-import type { Snippet } from 'svelte';
-import type { Element as HastElement } from 'hast';
-export type ElementProps<T = {}> = {
-    children: Snippet;
-    className?: string[];
-    node: HastElement;
-    props: Record<string, any>;
-} & T & Record<string, any>;

package/dist/Elements/element.js

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

package/dist/utils/alerts.d.ts

@@ -1,12 +0,0 @@
-import type { Root, ElementContent } from 'hast';
-export interface IAlert {
-    keyword: string;
-}
-export type DefaultBuildType = (alertOptions: IAlert, originalChildren: ElementContent[]) => ElementContent | null;
-export interface IOptions {
-    alerts: IAlert[];
-    supportLegacy?: boolean;
-    build?: DefaultBuildType;
-}
-export declare const rehypeGithubAlerts: (options: IOptions) => (tree: Root) => void;
-export declare const defaultBuild: DefaultBuildType;

package/dist/utils/alerts.js

@@ -1,207 +0,0 @@
-import { SKIP, visit } from 'unist-util-visit';
-import { isElement } from 'hast-util-is-element';
-let internalOptions;
-export const rehypeGithubAlerts = (options) => {
-    const defaultOptions = {
-        supportLegacy: false,
-        alerts: [
-            {
-                keyword: 'NOTE'
-            },
-            {
-                keyword: 'IMPORTANT'
-            },
-            {
-                keyword: 'WARNING'
-            },
-            {
-                keyword: 'TIP'
-            },
-            {
-                keyword: 'CAUTION'
-            }
-        ]
-    };
-    internalOptions = Object.assign({}, defaultOptions, options);
-    return (tree) => {
-        visit(tree, 'element', (node, index, parent) => {
-            create(node, index, parent);
-        });
-    };
-};
-const create = (node, index, parent) => {
-    // check if main element is a blockquote
-    if (node.tagName !== 'blockquote') {
-        return [SKIP];
-    }
-    // make sure the blockquote is not empty
-    if (node.children.length < 1) {
-        return [SKIP];
-    }
-    // find the first paragraph inside of the blockquote
-    const firstParagraph = node.children.find((child) => {
-        return child.type === 'element' && child.tagName === 'p';
-    });
-    // typescript type guard
-    // make sure the first paragraph is a valid element
-    if (!isElement(firstParagraph)) {
-        return [SKIP];
-    }
-    // try to find the alert type
-    const headerData = extractHeaderData(firstParagraph);
-    // typescript type guard
-    if (headerData === null) {
-        return [SKIP];
-    }
-    // if the first line contains more than the type
-    // drop out of rendering as alert, this is what
-    // GitHub does (as of Mar. 2024)
-    if (headerData.rest.trim() !== '') {
-        if (!headerData.rest.startsWith('\n') && !headerData.rest.startsWith('\r')) {
-            return [SKIP];
-        }
-    }
-    // try to find options matching the alert keyword
-    const alertOptions = getAlertOptions(headerData.alertType);
-    if (alertOptions === null) {
-        return [SKIP];
-    }
-    // make sure we have parent element and an index
-    // or we won't be able to replace the blockquote
-    // with the new alert element
-    if (!parent || typeof index !== 'number') {
-        return [SKIP];
-    }
-    // use a build to convert the blockquote into an alert
-    const build = internalOptions.build ?? defaultBuild;
-    const alertBodyChildren = [];
-    // for alerts the blockquote first element is always
-    // a paragraph but it can have more children than just
-    // the alert type text node
-    const remainingFirstParagraphChildren = firstParagraph.children.slice(1, firstParagraph.children.length);
-    const newFirstParagraphChildren = [];
-    // remove the first line break from rest if there is one
-    const rest = headerData.rest.replace(/^(\r\n|\r|\n)/, '');
-    // if the rest is empty and the first paragraph has no children
-    // this is a special github case (as of Mar. 2024)
-    // where the alert is only the type (no alert body)
-    // in this case github keeps the original blockquote
-    if (rest === '' && remainingFirstParagraphChildren.length === 0 && node.children.length < 4) {
-        return [SKIP];
-    }
-    if (remainingFirstParagraphChildren.length > 0) {
-        // if the alert type has a hard line break we remove it
-        // to not start the alert with a blank line
-        // meaning we start the slice at 2 to not take
-        // the br element and new line text nodes
-        if (remainingFirstParagraphChildren[0].type === 'element' &&
-            remainingFirstParagraphChildren[0].tagName === 'br') {
-            const remainingChildrenWithoutLineBreak = remainingFirstParagraphChildren.slice(2, firstParagraph.children.length);
-            newFirstParagraphChildren.push(...remainingChildrenWithoutLineBreak);
-        }
-        else {
-            // if the first line of the blockquote has no hard line break
-            // after the alert type but some text, then both the type
-            // and the text will be in a single text node
-            // headerData rest contains the remaining text without the alert type
-            if (rest !== '') {
-                const restAsTextNode = {
-                    type: 'text',
-                    value: rest
-                };
-                remainingFirstParagraphChildren.unshift(restAsTextNode);
-            }
-            // if no hard line break (br) take all the remaining
-            // and add them to new paragraph to mimic the initial structure
-            newFirstParagraphChildren.push(...remainingFirstParagraphChildren);
-        }
-    }
-    else {
-        if (rest !== '') {
-            const restAsTextNode = {
-                type: 'text',
-                value: rest
-            };
-            newFirstParagraphChildren.push(restAsTextNode);
-        }
-    }
-    if (newFirstParagraphChildren.length > 0) {
-        const paragraphElement = {
-            type: 'element',
-            tagName: 'p',
-            properties: {},
-            children: newFirstParagraphChildren
-        };
-        alertBodyChildren.push(paragraphElement);
-    }
-    // outside of the first paragraph there may also be children
-    // we add them too back into the alert body
-    if (node.children.length > 2) {
-        alertBodyChildren.push(...node.children.slice(2, node.children.length));
-    }
-    const alertElement = build(alertOptions, alertBodyChildren);
-    // replace the original blockquote with the
-    // new alert element and its children
-    if (alertElement !== null) {
-        parent.children[index] = alertElement;
-    }
-    return [SKIP];
-};
-export const defaultBuild = (alertOptions, originalChildren) => {
-    // Filter out any title paragraphs that might contain icons or titles
-    const filteredChildren = originalChildren.filter((child) => {
-        if (child.type === 'element' && child.tagName === 'p') {
-            const className = child.properties?.className;
-            // Remove paragraphs with markdown-alert-title class
-            if (className?.includes('markdown-alert-title')) {
-                return false;
-            }
-        }
-        return true;
-    });
-    const alert = {
-        type: 'element',
-        tagName: 'alert',
-        properties: {
-            className: ['markdown-alert', `markdown-alert-${alertOptions.keyword.toLowerCase()}`]
-        },
-        children: filteredChildren
-    };
-    return alert;
-};
-const extractHeaderData = (paragraph) => {
-    const header = paragraph.children[0];
-    let alertType;
-    let rest = '';
-    if (internalOptions.supportLegacy) {
-        if (header.type === 'element' && header.tagName === 'strong') {
-            if (header.children[0].type === 'text') {
-                alertType = header.children[0].value;
-            }
-        }
-    }
-    if (header.type === 'text') {
-        const match = /\[!(.*?)\]/.exec(header.value);
-        if (!match?.input) {
-            return null;
-        }
-        if (match.input.length > match[0].length) {
-            // if in markdown there are no two spaces at the end
-            // then in html there will be no line break
-            // this means in the first line there will be more
-            // content than just the alert type
-            rest = match.input.replace(match[0], '');
-        }
-        alertType = match[1];
-    }
-    if (typeof alertType === 'undefined') {
-        return null;
-    }
-    return { alertType, rest };
-};
-const getAlertOptions = (alertType) => {
-    const alertOptions = internalOptions.alerts.find((alert) => {
-        return alertType.toUpperCase() === alert.keyword.toUpperCase();
-    });
-    return alertOptions ?? null;
-};

package/dist/utils/parse-blocks.d.ts

@@ -1 +0,0 @@
-export declare const parseMarkdownIntoBlocks: (markdown: string) => string[];