Upload folder using huggingface_hub

6.25.0/markdown-code/MarkdownCode.svelte

@@ -0,0 +1,271 @@
+<script lang="ts">
+	import { onMount, tick } from "svelte";
+	import { create_marked } from "./utils";
+	import { sanitize } from "@gradio/sanitize";
+	import "./prism.css";
+	import { standardHtmlAndSvgTags } from "./html-tags";
+	import type { ThemeMode } from "@gradio/core";
+
+	let {
+		chatbot = true,
+		message,
+		sanitize_html = true,
+		latex_delimiters = [],
+		render_markdown = true,
+		line_breaks = true,
+		header_links = false,
+		allow_tags = false,
+		theme_mode = "system",
+		onload
+	}: {
+		chatbot?: boolean;
+		message: string;
+		sanitize_html?: boolean;
+		latex_delimiters?: {
+			left: string;
+			right: string;
+			display: boolean;
+		}[];
+		render_markdown?: boolean | undefined;
+		line_breaks?: boolean;
+		header_links?: boolean;
+		allow_tags?: string[] | boolean | undefined;
+		theme_mode?: ThemeMode;
+		onload?: () => void;
+	} = $props();
+
+	let el: HTMLSpanElement;
+
+	const marked = create_marked({
+		header_links,
+		line_breaks,
+		latex_delimiters: latex_delimiters || []
+	});
+
+	let html = $state("");
+	let render_token = 0;
+
+	$effect(() => {
+		const token = ++render_token;
+		if (message && message.trim()) {
+			process_message(message).then((result) => {
+				// drop results from superseded renders so streaming chunks
+				// don't clobber each other out of order
+				if (token === render_token) html = result;
+			});
+		} else {
+			html = "";
+		}
+	});
+	let katex_loaded = false;
+
+	function has_math_syntax(text: string): boolean {
+		if (!latex_delimiters || latex_delimiters.length === 0) {
+			return false;
+		}
+
+		return latex_delimiters.some(
+			(delimiter) =>
+				text.includes(delimiter.left) && text.includes(delimiter.right)
+		);
+	}
+
+	function escapeRegExp(string: string): string {
+		return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
+
+	function escapeTags(
+		content: string,
+		tagsToEscape: string[] | boolean
+	): string {
+		if (tagsToEscape === true) {
+			// https://www.w3schools.com/tags/
+			const tagRegex = /<\/?([a-zA-Z][a-zA-Z0-9-]*)([\s>])/g;
+			return content.replace(tagRegex, (match, tagName, endChar) => {
+				if (!standardHtmlAndSvgTags.includes(tagName.toLowerCase())) {
+					return match.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+				}
+				return match;
+			});
+		}
+
+		if (Array.isArray(tagsToEscape)) {
+			const tagPattern = tagsToEscape.map((tag) => ({
+				open: new RegExp(`<(${tag})(\\s+[^>]*)?>`, "gi"),
+				close: new RegExp(`</(${tag})>`, "gi")
+			}));
+
+			let result = content;
+
+			tagPattern.forEach((pattern) => {
+				result = result.replace(pattern.open, (match) =>
+					match.replace(/</g, "&lt;").replace(/>/g, "&gt;")
+				);
+				result = result.replace(pattern.close, (match) =>
+					match.replace(/</g, "&lt;").replace(/>/g, "&gt;")
+				);
+			});
+			return result;
+		}
+		return content;
+	}
+
+	async function process_message(value: string): Promise<string> {
+		let parsedValue = value;
+		if (render_markdown) {
+			const latexBlocks: string[] = [];
+			latex_delimiters.forEach((delimiter, index) => {
+				const leftDelimiter = escapeRegExp(delimiter.left);
+				const rightDelimiter = escapeRegExp(delimiter.right);
+				const regex = new RegExp(
+					`${leftDelimiter}([\\s\\S]+?)${rightDelimiter}`,
+					"g"
+				);
+				parsedValue = parsedValue.replace(regex, (match, p1) => {
+					latexBlocks.push(match);
+					return `%%%LATEX_BLOCK_${latexBlocks.length - 1}%%%`;
+				});
+			});
+
+			parsedValue = (await marked.parse(parsedValue)) as string;
+
+			parsedValue = parsedValue.replace(
+				/%%%LATEX_BLOCK_(\d+)%%%/g,
+				(match, p1) => latexBlocks[parseInt(p1, 10)]
+			);
+		}
+
+		if (allow_tags) {
+			parsedValue = escapeTags(parsedValue, allow_tags);
+		}
+
+		if (sanitize_html && sanitize) {
+			parsedValue = sanitize(parsedValue);
+		}
+		return parsedValue;
+	}
+
+	async function render_html(value: string): Promise<void> {
+		if (latex_delimiters.length > 0 && value && has_math_syntax(value)) {
+			if (!katex_loaded) {
+				await Promise.all([
+					import("katex/dist/katex.min.css"),
+					import("katex/contrib/auto-render")
+				]).then(([, { default: render_math_in_element }]) => {
+					katex_loaded = true;
+					render_math_in_element(el, {
+						delimiters: latex_delimiters,
+						throwOnError: false
+					});
+				});
+			} else {
+				const { default: render_math_in_element } =
+					await import("katex/contrib/auto-render");
+				render_math_in_element(el, {
+					delimiters: latex_delimiters,
+					throwOnError: false
+				});
+			}
+		}
+
+		if (el) {
+			const mermaidDivs = el.querySelectorAll(".mermaid");
+			if (mermaidDivs.length > 0) {
+				await tick();
+				const { default: mermaid } = await import("mermaid");
+
+				mermaid.initialize({
+					startOnLoad: false,
+					theme: theme_mode === "dark" ? "dark" : "default",
+					securityLevel: "antiscript"
+				});
+				await mermaid.run({
+					nodes: Array.from(mermaidDivs).map((node) => node as HTMLElement)
+				});
+			}
+		}
+	}
+
+	$effect(() => {
+		if (el && document.body.contains(el)) {
+			render_html(message).then(() => onload?.());
+		} else {
+			console.error("Element is not in the DOM");
+		}
+	});
+</script>
+
+<span class:chatbot bind:this={el} class="md" class:prose={render_markdown}>
+	{@html html}
+</span>
+
+<style>
+	span {
+		/* `anywhere`, not `break-word`: it also lowers min-content width, so
+		   markdown in a table/flex container shrinks to fit instead of forcing
+		   the container to overflow. */
+		overflow-wrap: anywhere;
+	}
+
+	span :global(div[class*="code_wrap"]) {
+		position: relative;
+	}
+
+	/* KaTeX */
+	span :global(span.katex) {
+		font-size: var(--text-lg);
+		direction: ltr;
+	}
+
+	span :global(div[class*="code_wrap"] > button) {
+		z-index: 1;
+		cursor: pointer;
+		border-bottom-left-radius: var(--radius-sm);
+		padding: var(--spacing-md);
+		width: 25px;
+		height: 25px;
+		position: absolute;
+		right: 0;
+	}
+
+	span :global(.check) {
+		opacity: 0;
+		z-index: var(--layer-top);
+		transition: opacity 0.2s;
+		background: var(--code-background-fill);
+		color: var(--body-text-color);
+		position: absolute;
+		top: var(--size-1-5);
+		left: var(--size-1-5);
+	}
+
+	span :global(p:not(:first-child)) {
+		margin-top: var(--spacing-xxl);
+	}
+
+	span :global(.md-header-anchor) {
+		/* position: absolute; */
+		margin-left: -25px;
+		padding-right: 8px;
+		line-height: 1;
+		color: var(--body-text-color-subdued);
+		opacity: 0;
+	}
+
+	span :global(h1:hover .md-header-anchor),
+	span :global(h2:hover .md-header-anchor),
+	span :global(h3:hover .md-header-anchor),
+	span :global(h4:hover .md-header-anchor),
+	span :global(h5:hover .md-header-anchor),
+	span :global(h6:hover .md-header-anchor) {
+		opacity: 1;
+	}
+
+	span.md :global(.md-header-anchor > svg) {
+		color: var(--body-text-color-subdued);
+	}
+
+	span :global(table) {
+		word-break: break-word;
+	}
+</style>

6.25.0/markdown-code/html-tags.ts

@@ -0,0 +1,209 @@
+// https://www.w3schools.com/tags/
+export const standardHtmlTags = [
+	"!--",
+	"!doctype",
+	"a",
+	"abbr",
+	"acronym",
+	"address",
+	"applet",
+	"area",
+	"article",
+	"aside",
+	"audio",
+	"b",
+	"base",
+	"basefont",
+	"bdi",
+	"bdo",
+	"big",
+	"blockquote",
+	"body",
+	"br",
+	"button",
+	"canvas",
+	"caption",
+	"center",
+	"cite",
+	"code",
+	"col",
+	"colgroup",
+	"data",
+	"datalist",
+	"dd",
+	"del",
+	"details",
+	"dfn",
+	"dialog",
+	"dir",
+	"div",
+	"dl",
+	"dt",
+	"em",
+	"embed",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"font",
+	"footer",
+	"form",
+	"frame",
+	"frameset",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"head",
+	"header",
+	"hgroup",
+	"hr",
+	"html",
+	"i",
+	"iframe",
+	"img",
+	"input",
+	"ins",
+	"kbd",
+	"label",
+	"legend",
+	"li",
+	"link",
+	"main",
+	"map",
+	"mark",
+	"menu",
+	"meta",
+	"meter",
+	"nav",
+	"noframes",
+	"noscript",
+	"object",
+	"ol",
+	"optgroup",
+	"option",
+	"output",
+	"p",
+	"param",
+	"picture",
+	"pre",
+	"progress",
+	"q",
+	"rp",
+	"rt",
+	"ruby",
+	"s",
+	"samp",
+	"script",
+	"search",
+	"section",
+	"select",
+	"small",
+	"source",
+	"span",
+	"strike",
+	"strong",
+	"style",
+	"sub",
+	"summary",
+	"sup",
+	"svg",
+	"table",
+	"tbody",
+	"td",
+	"template",
+	"textarea",
+	"tfoot",
+	"th",
+	"thead",
+	"time",
+	"title",
+	"tr",
+	"track",
+	"tt",
+	"u",
+	"ul",
+	"var",
+	"video",
+	"wbr"
+];
+
+// SVG tags
+export const svgTags = [
+	// Base structural elements
+	"g",
+	"defs",
+	"use",
+	"symbol",
+
+	// Shape elements
+	"rect",
+	"circle",
+	"ellipse",
+	"line",
+	"polyline",
+	"polygon",
+	"path",
+	"image",
+
+	// Text elements
+	"text",
+	"tspan",
+	"textPath",
+
+	// Gradient and effects
+	"linearGradient",
+	"radialGradient",
+	"stop",
+	"pattern",
+	"clipPath",
+	"mask",
+	"filter",
+
+	// Filter effects
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feGaussianBlur",
+	"feMerge",
+	"feMorphology",
+	"feOffset",
+	"feSpecularLighting",
+	"feTurbulence",
+	"feMergeNode",
+	"feFuncR",
+	"feFuncG",
+	"feFuncB",
+	"feFuncA",
+	"feDistantLight",
+	"fePointLight",
+	"feSpotLight",
+	"feFlood",
+	"feTile",
+
+	// Animation elements
+	"animate",
+	"animateTransform",
+	"animateMotion",
+	"mpath",
+	"set",
+
+	// Interactive and other elements
+	"view",
+	"cursor",
+	"foreignObject",
+	"desc",
+	"title",
+	"metadata",
+	"switch"
+];
+
+export const standardHtmlAndSvgTags = [
+	...standardHtmlTags,
+	...svgTags.filter((tag) => !standardHtmlTags.includes(tag))
+];

6.25.0/markdown-code/index.ts

@@ -0,0 +1 @@
+export { default as MarkdownCode } from "./MarkdownCode.svelte";

6.25.0/markdown-code/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@gradio/markdown-code",
+	"version": "0.10.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"main_changeset": true,
+	"main": "Index.svelte",
+	"exports": {
+		".": {
+			"gradio": "./index.ts",
+			"svelte": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@gradio/sanitize": "workspace:^",
+		"@types/katex": "^0.16.7",
+		"@types/prismjs": "1.26.5",
+		"github-slugger": "^2.0.0",
+		"katex": "^0.16.23",
+		"marked": "^12.0.0",
+		"marked-gfm-heading-id": "^3.1.2",
+		"marked-highlight": "^2.0.1",
+		"mermaid": "^11.12.0",
+		"prismjs": "^1.30.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/markdown"
+	}
+}

6.25.0/markdown-code/utils.ts

@@ -0,0 +1,354 @@
+import { Marked, Renderer } from "marked";
+import { markedHighlight } from "marked-highlight";
+import { gfmHeadingId } from "marked-gfm-heading-id";
+import * as Prism from "prismjs";
+import GithubSlugger from "github-slugger";
+
+const prism_loaders: Record<string, () => Promise<unknown>> = {
+	python: () => import("prismjs/components/prism-python"),
+	latex: () => import("prismjs/components/prism-latex"),
+	bash: () => import("prismjs/components/prism-bash"),
+	c: () => import("prismjs/components/prism-c"),
+	cpp: () => import("prismjs/components/prism-cpp"),
+	json: () => import("prismjs/components/prism-json"),
+	sql: () => import("prismjs/components/prism-sql"),
+	java: () => import("prismjs/components/prism-java"),
+	go: () => import("prismjs/components/prism-go"),
+	rust: () => import("prismjs/components/prism-rust"),
+	php: () => import("prismjs/components/prism-php"),
+	yaml: () => import("prismjs/components/prism-yaml"),
+	"markup-templating": () =>
+		import("prismjs/components/prism-markup-templating")
+};
+
+// prism-php references Prism.languages["markup-templating"] at load time
+const prism_deps: Record<string, string[]> = {
+	php: ["markup-templating"]
+};
+
+const prism_loading = new Map<string, Promise<void>>();
+
+async function load_prism_language(lang: string): Promise<void> {
+	const loader = prism_loaders[lang];
+	if (!loader) return;
+	let p = prism_loading.get(lang);
+	if (p) return p;
+	p = (async () => {
+		for (const dep of prism_deps[lang] ?? []) await load_prism_language(dep);
+		await loader();
+	})();
+	prism_loading.set(lang, p);
+	return p;
+}
+
+const LINK_ICON_CODE = `<svg class="md-link-icon" viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true" fill="currentColor"><path d="m7.775 3.275 1.25-1.25a3.5 3.5 0 1 1 4.95 4.95l-2.5 2.5a3.5 3.5 0 0 1-4.95 0 .751.751 0 0 1 .018-1.042.751.751 0 0 1 1.042-.018 1.998 1.998 0 0 0 2.83 0l2.5-2.5a2.002 2.002 0 0 0-2.83-2.83l-1.25 1.25a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042Zm-4.69 9.64a1.998 1.998 0 0 0 2.83 0l1.25-1.25a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-1.25 1.25a3.5 3.5 0 1 1-4.95-4.95l2.5-2.5a3.5 3.5 0 0 1 4.95 0 .751.751 0 0 1-.018 1.042.751.751 0 0 1-1.042.018 1.998 1.998 0 0 0-2.83 0l-2.5 2.5a1.998 1.998 0 0 0 0 2.83Z"></path></svg>`;
+
+const COPY_ICON_CODE = `
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 15 15" color="currentColor" aria-hidden="true" aria-label="Copy" stroke-width="1.3" width="15" height="15">
+  <path fill="currentColor" d="M12.728 4.545v8.182H4.545V4.545zm0 -0.909H4.545a0.909 0.909 0 0 0 -0.909 0.909v8.182a0.909 0.909 0 0 0 0.909 0.909h8.182a0.909 0.909 0 0 0 0.909 -0.909V4.545a0.909 0.909 0 0 0 -0.909 -0.909"/>
+  <path fill="currentColor" d="M1.818 8.182H0.909V1.818a0.909 0.909 0 0 1 0.909 -0.909h6.364v0.909H1.818Z"/>
+</svg>
+
+`;
+
+const CHECK_ICON_CODE = `<svg xmlns="http://www.w3.org/2000/svg" width="17" height="17" viewBox="0 0 17 17" aria-hidden="true" aria-label="Copied" fill="none" stroke="currentColor" stroke-width="1.3">
+  <path d="m13.813 4.781 -7.438 7.438 -3.188 -3.188"/>
+</svg>
+`;
+
+const COPY_BUTTON_CODE = `<button title="copy" class="copy_code_button">
+  <span class="copy-text">${COPY_ICON_CODE}</span>
+  <span class="check">${CHECK_ICON_CODE}</span>
+</button>`;
+
+const default_renderer = new Renderer();
+
+function should_open_link_in_new_tab(href: string): boolean {
+	const trimmed_href = href.trim();
+	return trimmed_href !== "" && !trimmed_href.startsWith("#");
+}
+
+const escape_test = /[&<>"']/;
+const escape_replace = new RegExp(escape_test.source, "g");
+const escape_test_no_encode =
+	/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
+const escape_replace_no_encode = new RegExp(escape_test_no_encode.source, "g");
+const escape_replacements: Record<string, any> = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	'"': "&quot;",
+	"'": "&#39;"
+};
+
+const get_escape_replacement = (ch: string): string =>
+	escape_replacements[ch] || "";
+
+function escape(html: string, encode?: boolean): string {
+	if (encode) {
+		if (escape_test.test(html)) {
+			return html.replace(escape_replace, get_escape_replacement);
+		}
+	} else {
+		if (escape_test_no_encode.test(html)) {
+			return html.replace(escape_replace_no_encode, get_escape_replacement);
+		}
+	}
+
+	return html;
+}
+interface Tokenizer {
+	name: string;
+	level: string;
+	start: (src: string) => number | undefined;
+	tokenizer: (src: string, tokens: any) => any;
+	renderer: (token: any) => string;
+}
+
+function createLatexTokenizer(
+	delimiters: { left: string; right: string; display: boolean }[]
+): Tokenizer {
+	const delimiterPatterns = delimiters.map((delimiter) => ({
+		start: new RegExp(delimiter.left.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")),
+		end: new RegExp(delimiter.right.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"))
+	}));
+
+	return {
+		name: "latex",
+		level: "block",
+		start(src: string) {
+			for (const pattern of delimiterPatterns) {
+				const match = src.match(pattern.start);
+				if (match) {
+					return match.index;
+				}
+			}
+			return -1;
+		},
+		tokenizer(src: string, tokens: any) {
+			for (const pattern of delimiterPatterns) {
+				const match = new RegExp(
+					`${pattern.start.source}([\\s\\S]+?)${pattern.end.source}`
+				).exec(src);
+				if (match) {
+					return {
+						type: "latex",
+						raw: match[0],
+						text: match[1].trim()
+					};
+				}
+			}
+		},
+		renderer(token: any) {
+			return `<div class="latex-block">${token.text}</div>`;
+		}
+	};
+}
+
+function createMermaidTokenizer(): Tokenizer {
+	return {
+		name: "mermaid",
+		level: "block",
+		start(src) {
+			return src.match(/^```mermaid\s*\n/)?.index;
+		},
+		tokenizer(src) {
+			const match = /^```mermaid\s*\n([\s\S]*?)```\s*(?:\n|$)/.exec(src);
+			if (match) {
+				return {
+					type: "mermaid",
+					raw: match[0],
+					text: match[1].trim()
+				};
+			}
+			return undefined;
+		},
+		renderer(token) {
+			return `<div class="mermaid">${token.text}</div>\n`;
+		}
+	};
+}
+
+const renderer: Partial<Omit<Renderer, "constructor" | "options">> = {
+	code(
+		this: Renderer,
+		code: string,
+		infostring: string | undefined,
+		escaped: boolean
+	) {
+		const lang = (infostring ?? "").match(/\S*/)?.[0] ?? "";
+		code = code.replace(/\n$/, "") + "\n";
+
+		if (!lang || lang === "mermaid") {
+			// We include lang === "mermaid" to handle mermaid blocks that don't match our custom tokenizer
+			// (i.e., those without closing ```). This handles mermaid blocks that have started streaming
+			// but haven't finished yet.
+			return (
+				'<div class="code_wrap">' +
+				COPY_BUTTON_CODE +
+				"<pre><code>" +
+				(escaped ? code : escape(code, true)) +
+				"</code></pre></div>\n"
+			);
+		}
+		return (
+			'<div class="code_wrap">' +
+			COPY_BUTTON_CODE +
+			'<pre><code class="' +
+			"language-" +
+			escape(lang) +
+			'">' +
+			(escaped ? code : escape(code, true)) +
+			"</code></pre></div>\n"
+		);
+	},
+	link(
+		this: Renderer,
+		href: string,
+		title: string | null | undefined,
+		text: string
+	) {
+		const rendered_link = default_renderer.link(href, title, text);
+		if (
+			!should_open_link_in_new_tab(href) ||
+			!rendered_link.startsWith("<a ")
+		) {
+			return rendered_link;
+		}
+		return rendered_link.replace(
+			/^<a /,
+			'<a target="_blank" rel="noopener noreferrer" '
+		);
+	}
+};
+
+const slugger = new GithubSlugger();
+
+export function create_marked({
+	header_links,
+	line_breaks,
+	latex_delimiters
+}: {
+	header_links: boolean;
+	line_breaks: boolean;
+	latex_delimiters: { left: string; right: string; display: boolean }[];
+}): typeof marked {
+	const marked = new Marked();
+	marked.use(
+		{
+			gfm: true,
+			pedantic: false,
+			breaks: line_breaks
+		},
+		markedHighlight({
+			async: true,
+			highlight: async (code: string, lang: string) => {
+				await load_prism_language(lang);
+				if (Prism?.languages?.[lang]) {
+					return Prism.highlight(code, Prism.languages[lang], lang);
+				}
+				return code;
+			}
+		}),
+		{ renderer }
+	);
+
+	if (header_links) {
+		marked.use(gfmHeadingId());
+		marked.use({
+			extensions: [
+				{
+					name: "heading",
+					level: "block",
+					renderer(token) {
+						const raw = token.raw
+							.toLowerCase()
+							.trim()
+							.replace(/<[!\/a-z].*?>/gi, "");
+						const id = "h" + slugger.slug(raw);
+						const level = token.depth;
+						const text = this.parser.parseInline(token.tokens!);
+
+						return `<h${level} id="${id}"><a class="md-header-anchor" href="#${id}">${LINK_ICON_CODE}</a>${text}</h${level}>\n`;
+					}
+				}
+			]
+		});
+	}
+
+	const mermaidTokenizer = createMermaidTokenizer();
+	const latexTokenizer = createLatexTokenizer(latex_delimiters);
+
+	marked.use({
+		extensions: [mermaidTokenizer, latexTokenizer]
+	});
+
+	return marked;
+}
+
+export function copy(node: HTMLDivElement): any {
+	node.addEventListener("click", handle_copy);
+
+	async function handle_copy(event: MouseEvent): Promise<void> {
+		const path = event.composedPath() as HTMLButtonElement[];
+
+		const [copy_button] = path.filter(
+			(e) => e?.tagName === "BUTTON" && e.classList.contains("copy_code_button")
+		);
+
+		if (copy_button) {
+			event.stopImmediatePropagation();
+
+			const copy_text = copy_button.parentElement!.innerText.trim();
+			const copy_sucess_button = Array.from(
+				copy_button.children
+			)[1] as HTMLDivElement;
+
+			const copied = await copy_to_clipboard(copy_text);
+
+			if (copied) copy_feedback(copy_sucess_button);
+
+			function copy_feedback(_copy_sucess_button: HTMLDivElement): void {
+				_copy_sucess_button.style.opacity = "1";
+				setTimeout(() => {
+					_copy_sucess_button.style.opacity = "0";
+				}, 2000);
+			}
+		}
+	}
+
+	return {
+		destroy(): void {
+			node.removeEventListener("click", handle_copy);
+		}
+	};
+}
+
+async function copy_to_clipboard(value: string): Promise<boolean> {
+	let copied = false;
+	if ("clipboard" in navigator) {
+		await navigator.clipboard.writeText(value);
+		copied = true;
+	} else {
+		const textArea = document.createElement("textarea");
+		textArea.value = value;
+
+		textArea.style.position = "absolute";
+		textArea.style.left = "-999999px";
+
+		document.body.prepend(textArea);
+		textArea.select();
+
+		try {
+			document.execCommand("copy");
+			copied = true;
+		} catch (error) {
+			console.error(error);
+			copied = false;
+		} finally {
+			textArea.remove();
+		}
+	}
+
+	return copied;
+}