svelte-streamdown 0.0.1

package/dist/utils/parse-incomplete-markdown.js

@@ -0,0 +1,442 @@
+const linkImagePattern = /(!?\[)([^\]]*?)$/;
+const boldPattern = /(\*\*)([^*]*?)$/;
+const italicPattern = /(__)([^_]*?)$/;
+const boldItalicPattern = /(\*\*\*)([^*]*?)$/;
+const singleAsteriskPattern = /(\*)([^*]*?)$/;
+const singleUnderscorePattern = /(_)([^_]*?)$/;
+const inlineCodePattern = /(`)([^`]*?)$/;
+const strikethroughPattern = /(~~)([^~]*?)$/;
+// Helper function to check if we have a complete code block
+const hasCompleteCodeBlock = (text) => {
+    const tripleBackticks = (text.match(/```/g) || []).length;
+    return tripleBackticks > 0 && tripleBackticks % 2 === 0 && text.includes('\n');
+};
+// Handles incomplete links and images by preserving them with a special marker
+const handleIncompleteLinksAndImages = (text) => {
+    const linkMatch = text.match(linkImagePattern);
+    if (linkMatch) {
+        const isImage = linkMatch[1].startsWith('!');
+        // For images, we still remove them as they can't show skeleton
+        if (isImage) {
+            const startIndex = text.lastIndexOf(linkMatch[1]);
+            return text.substring(0, startIndex);
+        }
+        // For links, preserve the text and close the link with a
+        // special placeholder URL that indicates it's incomplete
+        return `${text}](streamdown:incomplete-link)`;
+    }
+    return text;
+};
+// Completes incomplete bold formatting (**)
+const handleIncompleteBold = (text) => {
+    // Don't process if inside a complete code block
+    if (hasCompleteCodeBlock(text)) {
+        return text;
+    }
+    const boldMatch = text.match(boldPattern);
+    if (boldMatch) {
+        // Don't close if there's no meaningful content after the opening markers
+        // boldMatch[2] contains the content after **
+        // Check if content is only whitespace or other emphasis markers
+        const contentAfterMarker = boldMatch[2];
+        if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+            return text;
+        }
+        // Check if the bold marker is in a list item context
+        // Find the position of the matched bold marker
+        const markerIndex = text.lastIndexOf(boldMatch[1]);
+        const beforeMarker = text.substring(0, markerIndex);
+        const lastNewlineBeforeMarker = beforeMarker.lastIndexOf('\n');
+        const lineStart = lastNewlineBeforeMarker === -1 ? 0 : lastNewlineBeforeMarker + 1;
+        const lineBeforeMarker = text.substring(lineStart, markerIndex);
+        // Check if this line is a list item with just the bold marker
+        if (/^[\s]*[-*+][\s]+$/.test(lineBeforeMarker)) {
+            // This is a list item with just emphasis markers
+            // Check if content after marker spans multiple lines
+            const hasNewlineInContent = contentAfterMarker.includes('\n');
+            if (hasNewlineInContent) {
+                // Don't complete if the content spans to another line
+                return text;
+            }
+        }
+        const asteriskPairs = (text.match(/\*\*/g) || []).length;
+        if (asteriskPairs % 2 === 1) {
+            return `${text}**`;
+        }
+    }
+    return text;
+};
+// Completes incomplete italic formatting with double underscores (__)
+const handleIncompleteDoubleUnderscoreItalic = (text) => {
+    const italicMatch = text.match(italicPattern);
+    if (italicMatch) {
+        // Don't close if there's no meaningful content after the opening markers
+        // italicMatch[2] contains the content after __
+        // Check if content is only whitespace or other emphasis markers
+        const contentAfterMarker = italicMatch[2];
+        if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+            return text;
+        }
+        // Check if the underscore marker is in a list item context
+        // Find the position of the matched underscore marker
+        const markerIndex = text.lastIndexOf(italicMatch[1]);
+        const beforeMarker = text.substring(0, markerIndex);
+        const lastNewlineBeforeMarker = beforeMarker.lastIndexOf('\n');
+        const lineStart = lastNewlineBeforeMarker === -1 ? 0 : lastNewlineBeforeMarker + 1;
+        const lineBeforeMarker = text.substring(lineStart, markerIndex);
+        // Check if this line is a list item with just the underscore marker
+        if (/^[\s]*[-*+][\s]+$/.test(lineBeforeMarker)) {
+            // This is a list item with just emphasis markers
+            // Check if content after marker spans multiple lines
+            const hasNewlineInContent = contentAfterMarker.includes('\n');
+            if (hasNewlineInContent) {
+                // Don't complete if the content spans to another line
+                return text;
+            }
+        }
+        const underscorePairs = (text.match(/__/g) || []).length;
+        if (underscorePairs % 2 === 1) {
+            return `${text}__`;
+        }
+    }
+    return text;
+};
+// Counts single asterisks that are not part of double asterisks, not escaped, and not list markers
+const countSingleAsterisks = (text) => {
+    return text.split('').reduce((acc, char, index) => {
+        if (char === '*') {
+            const prevChar = text[index - 1];
+            const nextChar = text[index + 1];
+            // Skip if escaped with backslash
+            if (prevChar === '\\') {
+                return acc;
+            }
+            // Check if this is a list marker (asterisk at start of line followed by space)
+            // Look backwards to find the start of the current line
+            let lineStartIndex = index;
+            for (let i = index - 1; i >= 0; i--) {
+                if (text[i] === '\n') {
+                    lineStartIndex = i + 1;
+                    break;
+                }
+                if (i === 0) {
+                    lineStartIndex = 0;
+                    break;
+                }
+            }
+            // Check if this asterisk is at the beginning of a line (with optional whitespace)
+            const beforeAsterisk = text.substring(lineStartIndex, index);
+            if (beforeAsterisk.trim() === '' && (nextChar === ' ' || nextChar === '\t')) {
+                // This is likely a list marker, don't count it
+                return acc;
+            }
+            if (prevChar !== '*' && nextChar !== '*') {
+                return acc + 1;
+            }
+        }
+        return acc;
+    }, 0);
+};
+// Completes incomplete italic formatting with single asterisks (*)
+const handleIncompleteSingleAsteriskItalic = (text) => {
+    // Don't process if inside a complete code block
+    if (hasCompleteCodeBlock(text)) {
+        return text;
+    }
+    const singleAsteriskMatch = text.match(singleAsteriskPattern);
+    if (singleAsteriskMatch) {
+        // Find the first single asterisk position (not part of **)
+        let firstSingleAsteriskIndex = -1;
+        for (let i = 0; i < text.length; i++) {
+            if (text[i] === '*' && text[i - 1] !== '*' && text[i + 1] !== '*') {
+                firstSingleAsteriskIndex = i;
+                break;
+            }
+        }
+        if (firstSingleAsteriskIndex === -1) {
+            return text;
+        }
+        // Get content after the first single asterisk
+        const contentAfterFirstAsterisk = text.substring(firstSingleAsteriskIndex + 1);
+        // Check if there's meaningful content after the asterisk
+        // Don't close if content is only whitespace or emphasis markers
+        if (!contentAfterFirstAsterisk || /^[\s_~*`]*$/.test(contentAfterFirstAsterisk)) {
+            return text;
+        }
+        const singleAsterisks = countSingleAsterisks(text);
+        if (singleAsterisks % 2 === 1) {
+            return `${text}*`;
+        }
+    }
+    return text;
+};
+// Check if a position is within a math block (between $ or $$)
+const isWithinMathBlock = (text, position) => {
+    // Count dollar signs before this position
+    let inInlineMath = false;
+    let inBlockMath = false;
+    for (let i = 0; i < text.length && i < position; i++) {
+        // Skip escaped dollar signs
+        if (text[i] === '\\' && text[i + 1] === '$') {
+            i++; // Skip the next character
+            continue;
+        }
+        if (text[i] === '$') {
+            // Check for block math ($$)
+            if (text[i + 1] === '$') {
+                inBlockMath = !inBlockMath;
+                i++; // Skip the second $
+                inInlineMath = false; // Block math takes precedence
+            }
+            else if (!inBlockMath) {
+                // Only toggle inline math if not in block math
+                inInlineMath = !inInlineMath;
+            }
+        }
+    }
+    return inInlineMath || inBlockMath;
+};
+// Counts single underscores that are not part of double underscores, not escaped, and not in math blocks
+const countSingleUnderscores = (text) => {
+    return text.split('').reduce((acc, char, index) => {
+        if (char === '_') {
+            const prevChar = text[index - 1];
+            const nextChar = text[index + 1];
+            // Skip if escaped with backslash
+            if (prevChar === '\\') {
+                return acc;
+            }
+            // Skip if within math block
+            if (isWithinMathBlock(text, index)) {
+                return acc;
+            }
+            if (prevChar !== '_' && nextChar !== '_') {
+                return acc + 1;
+            }
+        }
+        return acc;
+    }, 0);
+};
+// Completes incomplete italic formatting with single underscores (_)
+const handleIncompleteSingleUnderscoreItalic = (text) => {
+    // Don't process if inside a complete code block
+    if (hasCompleteCodeBlock(text)) {
+        return text;
+    }
+    const singleUnderscoreMatch = text.match(singleUnderscorePattern);
+    if (singleUnderscoreMatch) {
+        // Find the first single underscore position (not part of __)
+        let firstSingleUnderscoreIndex = -1;
+        for (let i = 0; i < text.length; i++) {
+            if (text[i] === '_' &&
+                text[i - 1] !== '_' &&
+                text[i + 1] !== '_' &&
+                !isWithinMathBlock(text, i)) {
+                firstSingleUnderscoreIndex = i;
+                break;
+            }
+        }
+        if (firstSingleUnderscoreIndex === -1) {
+            return text;
+        }
+        // Get content after the first single underscore
+        const contentAfterFirstUnderscore = text.substring(firstSingleUnderscoreIndex + 1);
+        // Check if there's meaningful content after the underscore
+        // Don't close if content is only whitespace or emphasis markers
+        if (!contentAfterFirstUnderscore || /^[\s_~*`]*$/.test(contentAfterFirstUnderscore)) {
+            return text;
+        }
+        const singleUnderscores = countSingleUnderscores(text);
+        if (singleUnderscores % 2 === 1) {
+            return `${text}_`;
+        }
+    }
+    return text;
+};
+// Checks if a backtick at position i is part of a triple backtick sequence
+const isPartOfTripleBacktick = (text, i) => {
+    const isTripleStart = text.substring(i, i + 3) === '```';
+    const isTripleMiddle = i > 0 && text.substring(i - 1, i + 2) === '```';
+    const isTripleEnd = i > 1 && text.substring(i - 2, i + 1) === '```';
+    return isTripleStart || isTripleMiddle || isTripleEnd;
+};
+// Counts single backticks that are not part of triple backticks
+const countSingleBackticks = (text) => {
+    let count = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '`' && !isPartOfTripleBacktick(text, i)) {
+            count++;
+        }
+    }
+    return count;
+};
+// Completes incomplete inline code formatting (`)
+// Avoids completing if inside an incomplete code block
+const handleIncompleteInlineCode = (text) => {
+    // Check if we have inline triple backticks (starts with ``` and should end with ```)
+    // This pattern should ONLY match truly inline code (no newlines)
+    // Examples: ```code``` or ```python code```
+    const inlineTripleBacktickMatch = text.match(/^```[^`\n]*```?$/);
+    if (inlineTripleBacktickMatch && !text.includes('\n')) {
+        // Check if it ends with exactly 2 backticks (incomplete)
+        if (text.endsWith('``') && !text.endsWith('```')) {
+            return `${text}\``;
+        }
+        // Already complete inline triple backticks
+        return text;
+    }
+    // Check if we're inside a multi-line code block (complete or incomplete)
+    const allTripleBackticks = (text.match(/```/g) || []).length;
+    const insideIncompleteCodeBlock = allTripleBackticks % 2 === 1;
+    // Don't modify text if we have complete multi-line code blocks (even pairs of ```)
+    if (allTripleBackticks > 0 && allTripleBackticks % 2 === 0 && text.includes('\n')) {
+        // We have complete multi-line code blocks, don't add any backticks
+        return text;
+    }
+    // Special case: if text ends with ```\n (triple backticks followed by newline)
+    // This is actually a complete code block, not incomplete
+    if (text.endsWith('```\n') || text.endsWith('```')) {
+        // Count all triple backticks - if even, it's complete
+        if (allTripleBackticks % 2 === 0) {
+            return text;
+        }
+    }
+    const inlineCodeMatch = text.match(inlineCodePattern);
+    if (inlineCodeMatch && !insideIncompleteCodeBlock) {
+        // Don't close if there's no meaningful content after the opening marker
+        // inlineCodeMatch[2] contains the content after `
+        // Check if content is only whitespace or other emphasis markers
+        const contentAfterMarker = inlineCodeMatch[2];
+        if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+            return text;
+        }
+        const singleBacktickCount = countSingleBackticks(text);
+        if (singleBacktickCount % 2 === 1) {
+            return `${text}\``;
+        }
+    }
+    return text;
+};
+// Completes incomplete strikethrough formatting (~~)
+const handleIncompleteStrikethrough = (text) => {
+    const strikethroughMatch = text.match(strikethroughPattern);
+    if (strikethroughMatch) {
+        // Don't close if there's no meaningful content after the opening markers
+        // strikethroughMatch[2] contains the content after ~~
+        // Check if content is only whitespace or other emphasis markers
+        const contentAfterMarker = strikethroughMatch[2];
+        if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+            return text;
+        }
+        const tildePairs = (text.match(/~~/g) || []).length;
+        if (tildePairs % 2 === 1) {
+            return `${text}~~`;
+        }
+    }
+    return text;
+};
+// Counts single dollar signs that are not part of double dollar signs and not escaped
+const _countSingleDollarSigns = (text) => {
+    return text.split('').reduce((acc, char, index) => {
+        if (char === '$') {
+            const prevChar = text[index - 1];
+            const nextChar = text[index + 1];
+            // Skip if escaped with backslash
+            if (prevChar === '\\') {
+                return acc;
+            }
+            if (prevChar !== '$' && nextChar !== '$') {
+                return acc + 1;
+            }
+        }
+        return acc;
+    }, 0);
+};
+// Completes incomplete block KaTeX formatting ($$)
+const handleIncompleteBlockKatex = (text) => {
+    // Count all $$ pairs in the text
+    const dollarPairs = (text.match(/\$\$/g) || []).length;
+    // If we have an even number of $$, the block is complete
+    if (dollarPairs % 2 === 0) {
+        return text;
+    }
+    // If we have an odd number, add closing $$
+    // Check if this looks like a multi-line math block (contains newlines after opening $$)
+    const firstDollarIndex = text.indexOf('$$');
+    const hasNewlineAfterStart = firstDollarIndex !== -1 && text.indexOf('\n', firstDollarIndex) !== -1;
+    // For multi-line blocks, add newline before closing $$ if not present
+    if (hasNewlineAfterStart && !text.endsWith('\n')) {
+        return `${text}\n$$`;
+    }
+    // For inline blocks or when already ending with newline, just add $$
+    return `${text}$$`;
+};
+// Counts triple asterisks that are not part of quadruple or more asterisks
+const countTripleAsterisks = (text) => {
+    let count = 0;
+    const matches = text.match(/\*+/g) || [];
+    for (const match of matches) {
+        // Count how many complete triple asterisks are in this sequence
+        const asteriskCount = match.length;
+        if (asteriskCount >= 3) {
+            // Each group of exactly 3 asterisks counts as one triple asterisk marker
+            count += Math.floor(asteriskCount / 3);
+        }
+    }
+    return count;
+};
+// Completes incomplete bold-italic formatting (***)
+const handleIncompleteBoldItalic = (text) => {
+    // Don't process if inside a complete code block
+    if (hasCompleteCodeBlock(text)) {
+        return text;
+    }
+    // Don't process if text is only asterisks and has 4 or more consecutive asterisks
+    // This prevents cases like **** from being treated as incomplete ***
+    if (/^\*{4,}$/.test(text)) {
+        return text;
+    }
+    const boldItalicMatch = text.match(boldItalicPattern);
+    if (boldItalicMatch) {
+        // Don't close if there's no meaningful content after the opening markers
+        // boldItalicMatch[2] contains the content after ***
+        // Check if content is only whitespace or other emphasis markers
+        const contentAfterMarker = boldItalicMatch[2];
+        if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+            return text;
+        }
+        const tripleAsteriskCount = countTripleAsterisks(text);
+        if (tripleAsteriskCount % 2 === 1) {
+            return `${text}***`;
+        }
+    }
+    return text;
+};
+// Parses markdown text and removes incomplete tokens to prevent partial rendering
+export const parseIncompleteMarkdown = (text) => {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    let result = text;
+    // Handle incomplete links and images first
+    const processedResult = handleIncompleteLinksAndImages(result);
+    // If we added an incomplete link marker, don't process other formatting
+    // as the content inside the link should be preserved as-is
+    if (processedResult.endsWith('](streamdown:incomplete-link)')) {
+        return processedResult;
+    }
+    result = processedResult;
+    // Handle various formatting completions
+    // Handle triple asterisks first (most specific)
+    result = handleIncompleteBoldItalic(result);
+    result = handleIncompleteBold(result);
+    result = handleIncompleteDoubleUnderscoreItalic(result);
+    result = handleIncompleteSingleAsteriskItalic(result);
+    result = handleIncompleteSingleUnderscoreItalic(result);
+    result = handleIncompleteInlineCode(result);
+    result = handleIncompleteStrikethrough(result);
+    // Handle KaTeX formatting (only block math with $$)
+    result = handleIncompleteBlockKatex(result);
+    // Note: We don't handle inline KaTeX with single $ as they're likely currency symbols
+    return result;
+};

package/dist/utils/parse.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,144 @@
+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 { VFile } from 'vfile';
+import remarkGfm from 'remark-gfm';
+import remarkMath from 'remark-math';
+import { rehypeGithubAlerts } from './alerts.js';
+import { squeezeParagraphs } from 'mdast-squeeze-paragraphs';
+const emptyPlugins = [];
+const emptyRemarkRehypeOptions = { allowDangerousHtml: true };
+const safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i;
+function createFile(content) {
+    const file = new VFile();
+    if (typeof content === 'string') {
+        file.value = content;
+    }
+    else {
+        throw new Error('Unexpected value `' + content + '` for content, expected `string`');
+    }
+    return file;
+}
+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 file = createFile(content);
+    const tree = processor.parse(file);
+    return post(processor.runSync(tree, file), {
+        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 '';
+}

package/dist/utils/save.d.ts

@@ -0,0 +1 @@
+export declare const save: (filename: string, content: string, mimeType: string) => void;

package/dist/utils/save.js

@@ -0,0 +1,11 @@
+export const save = (filename, content, mimeType) => {
+    const blob = new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+};

package/dist/utils/url.d.ts

@@ -0,0 +1,2 @@
+export declare const parseUrl: (url: unknown, defaultOrigin?: string) => URL | null;
+export declare const transformUrl: (url: unknown, allowedPrefixes: string[], defaultOrigin?: string) => string | null;

package/dist/utils/url.js

@@ -0,0 +1,71 @@
+export const parseUrl = (url, defaultOrigin) => {
+    if (typeof url !== 'string')
+        return null;
+    try {
+        // Try to parse as absolute URL first
+        const urlObject = new URL(url);
+        return urlObject;
+    }
+    catch (error) {
+        // If that fails and we have a defaultOrigin, try with it
+        if (defaultOrigin) {
+            try {
+                const urlObject = new URL(url, defaultOrigin);
+                return urlObject;
+            }
+            catch (error) {
+                return null;
+            }
+        }
+        return null;
+    }
+};
+const isPathRelativeUrl = (url) => {
+    if (typeof url !== 'string')
+        return false;
+    return url.startsWith('/');
+};
+export const transformUrl = (url, allowedPrefixes, defaultOrigin) => {
+    if (!url)
+        return null;
+    const parsedUrl = parseUrl(url, defaultOrigin);
+    if (!parsedUrl)
+        return null;
+    // If the input is path relative, we output a path relative URL as well,
+    // however, we always run the same checks on an absolute URL and we
+    // always rescronstruct the output from the parsed URL to ensure that
+    // the output is always a valid URL.
+    const inputWasRelative = isPathRelativeUrl(url);
+    const urlString = parseUrl(url);
+    if (urlString &&
+        allowedPrefixes.some((prefix) => {
+            const parsedPrefix = parseUrl(prefix);
+            if (!parsedPrefix) {
+                return false;
+            }
+            if (parsedPrefix.origin !== urlString.origin) {
+                return false;
+            }
+            return urlString.href.startsWith(parsedPrefix.href);
+        })) {
+        if (inputWasRelative) {
+            return urlString.pathname + urlString.search + urlString.hash;
+        }
+        return urlString.href;
+    }
+    // Check for wildcard - allow all URLs
+    if (allowedPrefixes.includes('*')) {
+        // Wildcard only allows http and https URLs
+        if (parsedUrl.protocol !== 'https:' && parsedUrl.protocol !== 'http:') {
+            return null;
+        }
+        const inputWasRelative = isPathRelativeUrl(url);
+        if (parsedUrl) {
+            if (inputWasRelative) {
+                return parsedUrl.pathname + parsedUrl.search + parsedUrl.hash;
+            }
+            return parsedUrl.href;
+        }
+    }
+    return null;
+};