svelte-streamdown 1.0.6 → 1.0.8

package/dist/utils/parse-blocks.js

@@ -1,40 +0,0 @@
-import { marked } from 'marked';
-export const parseMarkdownIntoBlocks = (markdown) => {
-    const tokens = marked.use({ gfm: true }).lexer(markdown);
-    const blocks = tokens.map((token) => token.raw);
-    // Post-process to merge consecutive blocks that are part of the same math block
-    const mergedBlocks = [];
-    for (let i = 0; i < blocks.length; i++) {
-        const currentBlock = blocks[i];
-        // Check if this is a standalone $$ that might be a closing delimiter
-        if (currentBlock.trim() === '$$' && mergedBlocks.length > 0) {
-            const previousBlock = mergedBlocks.at(-1);
-            // Check if the previous block starts with $$ but doesn't end with $$
-            const prevStartsWith$$ = previousBlock?.trimStart().startsWith('$$');
-            const prevDollarCount = (previousBlock?.match(/\$\$/g) || []).length;
-            // If previous block has odd number of $$ and starts with $$, merge them
-            if (prevStartsWith$$ && prevDollarCount % 2 === 1) {
-                mergedBlocks[mergedBlocks.length - 1] = previousBlock + currentBlock;
-                continue;
-            }
-        }
-        // Check if current block ends with $$ and previous block started with $$ but didn't close
-        if (mergedBlocks.length > 0 && currentBlock.trimEnd().endsWith('$$')) {
-            const previousBlock = mergedBlocks.at(-1);
-            const prevStartsWith$$ = previousBlock?.trimStart().startsWith('$$');
-            const prevDollarCount = (previousBlock?.match(/\$\$/g) || []).length;
-            const currDollarCount = (currentBlock.match(/\$\$/g) || []).length;
-            // If previous block has unclosed math (odd $$) and current block ends with $$
-            // AND current block doesn't start with $$, it's likely a continuation
-            if (prevStartsWith$$ &&
-                prevDollarCount % 2 === 1 &&
-                !currentBlock.trimStart().startsWith('$$') &&
-                currDollarCount === 1) {
-                mergedBlocks[mergedBlocks.length - 1] = previousBlock + currentBlock;
-                continue;
-            }
-        }
-        mergedBlocks.push(currentBlock);
-    }
-    return mergedBlocks;
-};

package/dist/utils/parse.d.ts

@@ -1,3 +0,0 @@
-import type { StreamdownContext } from '../Streamdown.svelte';
-import type { Root } from 'hast';
-export declare function parseMarkdown(context: StreamdownContext, content: string): Root;

package/dist/utils/parse.js

@@ -1,131 +0,0 @@
-import { urlAttributes } from 'html-url-attributes';
-import remarkParse from 'remark-parse';
-import remarkRehype, {} from 'remark-rehype';
-import { unified } from 'unified';
-import { visit } from 'unist-util-visit';
-import remarkGfm from 'remark-gfm';
-import remarkMath from 'remark-math';
-import { rehypeGithubAlerts } from './alerts.js';
-const emptyPlugins = [];
-const emptyRemarkRehypeOptions = { allowDangerousHtml: true };
-const safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i;
-export function parseMarkdown(context, content) {
-    const rehypePlugins = context.rehypePlugins || emptyPlugins;
-    const remarkPlugins = context.remarkPlugins || emptyPlugins;
-    const remarkRehypeOptions = context.remarkRehypeOptions
-        ? { ...context.remarkRehypeOptions, ...emptyRemarkRehypeOptions }
-        : emptyRemarkRehypeOptions;
-    const processor = unified()
-        .use(remarkParse)
-        .use(remarkPlugins)
-        .use(remarkMath)
-        .use(remarkGfm)
-        .use(remarkRehype, remarkRehypeOptions)
-        .use(rehypePlugins)
-        .use([rehypeGithubAlerts]);
-    const tree = processor.runSync(processor.parse(content));
-    return post(tree, {
-        allowElement: context.allowElement,
-        allowedElements: context.allowedElements,
-        disallowedElements: context.disallowedElements,
-        skipHtml: context.skipHtml,
-        unwrapDisallowed: context.unwrapDisallowed,
-        urlTransform: context.urlTransform
-    });
-}
-/**
- * Process the HAST tree with filtering and transformations
- */
-function post(tree, options) {
-    const allowedElements = options.allowedElements;
-    const allowElement = options.allowElement;
-    const disallowedElements = options.disallowedElements;
-    const skipHtml = options.skipHtml;
-    const unwrapDisallowed = options.unwrapDisallowed;
-    const urlTransform = options.urlTransform || defaultUrlTransform;
-    if (allowedElements && disallowedElements) {
-        throw new Error('Unexpected combined `allowedElements` and `disallowedElements`, expected one or the other');
-    }
-    visit(tree, transform);
-    return tree;
-    /** @type {import('unist-util-visit').BuildVisitor<Root>} */
-    function transform(node, index, parent) {
-        if (node.type === 'raw' && parent && typeof index === 'number') {
-            if (skipHtml) {
-                parent.children.splice(index, 1);
-            }
-            else {
-                parent.children[index] = { type: 'text', value: node.value };
-            }
-            return index;
-        }
-        if (node.type === 'element') {
-            const element = node;
-            // Transform URLs
-            for (const key in urlAttributes) {
-                if (Object.hasOwn(urlAttributes, key) && Object.hasOwn(element.properties, key)) {
-                    const value = element.properties[key];
-                    const test = urlAttributes[key];
-                    if (test === null || test.includes(element.tagName)) {
-                        element.properties[key] = urlTransform(String(value || ''), key, element);
-                    }
-                }
-            }
-            const className = node.properties.className;
-            if (node.tagName === 'code') {
-                const LANGUAGE_REGEX = /language-([^\s]+)/;
-                const match = (Array.isArray(className) ? className : [className])?.reduce((acc, c) => {
-                    const match = String(c).match(LANGUAGE_REGEX);
-                    const lang = match?.[1];
-                    if (lang) {
-                        acc = lang;
-                    }
-                    return acc;
-                }, '');
-                const language = (match ?? 'plaintext');
-                node.properties.language = language;
-            }
-        }
-        if (node.type === 'element') {
-            const element = node;
-            let remove = allowedElements
-                ? !allowedElements.includes(element.tagName)
-                : disallowedElements
-                    ? disallowedElements.includes(element.tagName)
-                    : false;
-            if (!remove && allowElement && typeof index === 'number') {
-                remove = !allowElement(element, index, parent);
-            }
-            if (remove && parent && typeof index === 'number') {
-                if (unwrapDisallowed && element.children) {
-                    parent.children.splice(index, 1, ...element.children);
-                }
-                else {
-                    parent.children.splice(index, 1);
-                }
-                return index;
-            }
-        }
-    }
-}
-/**
- * Make a URL safe (GitHub-style)
- */
-function defaultUrlTransform(value) {
-    const colon = value.indexOf(':');
-    const questionMark = value.indexOf('?');
-    const numberSign = value.indexOf('#');
-    const slash = value.indexOf('/');
-    if (
-    // If there is no protocol, it's relative
-    colon === -1 ||
-        // If the first colon is after a `?`, `#`, or `/`, it's not a protocol
-        (slash !== -1 && colon > slash) ||
-        (questionMark !== -1 && colon > questionMark) ||
-        (numberSign !== -1 && colon > numberSign) ||
-        // It is a protocol, it should be allowed
-        safeProtocol.test(value.slice(0, colon))) {
-        return value;
-    }
-    return '';
-}