@shikijs/twoslash 4.0.2 → 4.1.0

package/dist/{renderer-rich-DEkszi0Z.mjs → core-VR43FShM.mjs}

@@ -1,3 +1,4 @@
+import { splitTokens } from "@shikijs/core";
 //#region src/error.ts
 var ShikiTwoslashError = class extends Error {
 	constructor(message) {
@@ -5,10 +6,11 @@ var ShikiTwoslashError = class extends Error {
 		this.name = "ShikiTwoslashError";
 	}
 };
-
 //#endregion
 //#region src/includes.ts
+const RE_INCLUDE_MARKER = /\/\/ @include: (.*)$/gm;
 var TwoslashIncludesManager = class {
+	map;
 	constructor(map = /* @__PURE__ */ new Map()) {
 		this.map = map;
 	}
@@ -24,13 +26,12 @@ var TwoslashIncludesManager = class {
 		this.map.set(name, lines.join("\n"));
 	}
 	applyInclude(code) {
-		const reMarker = /\/\/ @include: (.*)$/gm;
 		const toReplace = [];
-		for (const match of code.matchAll(reMarker)) {
+		for (const match of code.matchAll(RE_INCLUDE_MARKER)) {
 			const key = match[1];
 			const replaceWith = this.map.get(key);
 			if (!replaceWith) {
-				const msg = `Could not find an include with the key: '${key}'.\nThere is: ${Array.from(this.map.keys())}.`;
+				const msg = `Could not find an include with the key: '${key}'.\nThere is: ${[...this.map.keys()]}.`;
 				throw new Error(msg);
 			} else toReplace.push([
 				match.index,
@@ -58,7 +59,6 @@ function parseIncludeMeta(meta) {
 	if (!meta) return null;
 	return meta.match(INCLUDE_META_REGEX)?.[1] ?? null;
 }
-
 //#endregion
 //#region src/icons-completions.json
 var icons_completions_default = {
@@ -261,7 +261,6 @@ var icons_completions_default = {
 		}]
 	}
 };
-
 //#endregion
 //#region src/icons-tags.json
 var icons_tags_default = {
@@ -346,12 +345,10 @@ var icons_tags_default = {
 		}]
 	}
 };
-
 //#endregion
 //#region src/icons.ts
 const defaultCompletionIcons = icons_completions_default;
 const defaultCustomTagIcons = icons_tags_default;
-
 //#endregion
 //#region src/renderer-classic.ts
 /**
@@ -493,7 +490,6 @@ function rendererClassic() {
 		}
 	};
 }
-
 //#endregion
 //#region src/renderer-rich.ts
 function extend(extension, node) {
@@ -509,6 +505,7 @@ function extend(extension, node) {
 		children: extension.children?.(node.children) ?? node.children
 	};
 }
+const RE_WHITESPACE_CHAR = /\s/g;
 function renderMarkdownPassThrough(markdown) {
 	return [{
 		type: "text",
@@ -643,7 +640,7 @@ function rendererRich(options = {}) {
 					children: [...completionIcons ? [{
 						type: "element",
 						tagName: "span",
-						properties: { class: `twoslash-completions-icon completions-${kind.replace(/\s/g, "-")}` },
+						properties: { class: `twoslash-completions-icon completions-${kind.replace(RE_WHITESPACE_CHAR, "-")}` },
 						children: [completionIcons[kind] || completionIcons.property].filter(Boolean)
 					}] : [], {
 						type: "element",
@@ -803,15 +800,18 @@ function rendererRich(options = {}) {
 		}
 	};
 }
-const regexType = /^[A-Z]\w*(<[^>]*>)?:/;
+const RE_LEADING_MODIFIER = /^\(([\w-]+)\)\s+/gm;
+const RE_IMPORT_STATEMENT = /\nimport .*$/;
+const RE_INTERFACE_NAMESPACE = /^(interface|namespace) \w+$/gm;
+const regexType = /^[A-Z]\w*(?:<[^>]*>)?:/;
 const regexFunction = /^\w*\(/;
 /**
 * The default hover info processor, which will do some basic cleanup
 */
 function defaultHoverInfoProcessor(type) {
-	let content = type.replace(/^\(([\w-]+)\)\s+/gm, "").replace(/\nimport .*$/, "").replace(/^(interface|namespace) \w+$/gm, "").trim();
-	if (content.match(regexType)) content = `type ${content}`;
-	else if (content.match(regexFunction)) content = `function ${content}`;
+	let content = type.replace(RE_LEADING_MODIFIER, "").replace(RE_IMPORT_STATEMENT, "").replace(RE_INTERFACE_NAMESPACE, "").trim();
+	if (regexType.test(content)) content = `type ${content}`;
+	else if (regexFunction.test(content)) content = `function ${content}`;
 	return content;
 }
 function getErrorLevelClass(error) {
@@ -822,6 +822,215 @@ function getErrorLevelClass(error) {
 		default: return "";
 	}
 }
-
 //#endregion
-export { defaultCustomTagIcons as a, ShikiTwoslashError as c, defaultCompletionIcons as i, rendererRich as n, TwoslashIncludesManager as o, rendererClassic as r, parseIncludeMeta as s, defaultHoverInfoProcessor as t };
+//#region src/core.ts
+const RE_TWOSLASH = /\btwoslash\b/;
+function defaultTwoslashOptions() {
+	return {
+		customTags: [
+			"annotate",
+			"log",
+			"warn",
+			"error"
+		],
+		compilerOptions: { moduleResolution: 100 }
+	};
+}
+function createTransformerFactory(defaultTwoslasher, defaultRenderer) {
+	return function transformerTwoslash(options = {}) {
+		const { langs = ["ts", "tsx"], twoslashOptions = defaultTwoslashOptions(), langAlias = {
+			typescript: "ts",
+			json5: "json",
+			yml: "yaml"
+		}, twoslasher = defaultTwoslasher, explicitTrigger = false, disableTriggers = ["notwoslash", "no-twoslash"], renderer = defaultRenderer, throws = true, includesMap = /* @__PURE__ */ new Map(), typesCache } = options;
+		const onTwoslashError = options.onTwoslashError || (throws ? (error) => {
+			throw error;
+		} : () => false);
+		const onShikiError = options.onShikiError || (throws ? (error) => {
+			throw error;
+		} : () => false);
+		const trigger = explicitTrigger instanceof RegExp ? explicitTrigger : RE_TWOSLASH;
+		if (!renderer) throw new ShikiTwoslashError("Missing renderer");
+		const map = /* @__PURE__ */ new WeakMap();
+		const { filter = (lang, _, options) => {
+			return langs.includes(lang) && (!explicitTrigger || trigger.test(options.meta?.__raw || "")) && !disableTriggers.some((i) => typeof i === "string" ? options.meta?.__raw?.includes(i) : i.test(options.meta?.__raw || ""));
+		} } = options;
+		const includes = new TwoslashIncludesManager(includesMap);
+		let _twoslasher = twoslasher;
+		if (typesCache) {
+			_twoslasher = ((code, lang, options, meta) => {
+				const preprocessed = typesCache?.preprocess?.(code, lang, options, meta);
+				if (preprocessed !== void 0) code = preprocessed;
+				let twoslash = typesCache?.read(code, lang, options, meta);
+				if (!twoslash) {
+					twoslash = twoslasher(code, lang, options);
+					typesCache?.write(code, twoslash, lang, options, meta);
+				}
+				return twoslash;
+			});
+			typesCache.init?.();
+		}
+		return {
+			preprocess(code) {
+				let lang = this.options.lang;
+				if (lang in langAlias) lang = langAlias[this.options.lang];
+				if (filter(lang, code, this.options, this)) try {
+					const codeWithIncludes = includes.applyInclude(code);
+					const include = parseIncludeMeta(this.options.meta?.__raw);
+					if (include) includes.add(include, codeWithIncludes);
+					const twoslash = _twoslasher(codeWithIncludes, lang, twoslashOptions, this.meta);
+					map.set(this.meta, twoslash);
+					this.meta.twoslash = twoslash;
+					this.options.lang = twoslash.meta?.extension || lang;
+					return twoslash.code;
+				} catch (error) {
+					const result = onTwoslashError(error, code, lang, this.options);
+					if (typeof result === "string") return result;
+				}
+			},
+			tokens(tokens) {
+				const twoslash = map.get(this.meta);
+				if (!twoslash) return;
+				return splitTokens(tokens, twoslash.nodes.flatMap((i) => [
+					"hover",
+					"error",
+					"query",
+					"highlight",
+					"completion"
+				].includes(i.type) ? [i.start, i.start + i.length] : []));
+			},
+			pre(pre) {
+				if (!map.get(this.meta)) return;
+				this.addClassToHast(pre, "twoslash lsp");
+			},
+			code(codeEl) {
+				const twoslash = map.get(this.meta);
+				if (!twoslash) return;
+				const insertAfterLine = (line, nodes) => {
+					if (!nodes.length) return;
+					let index;
+					if (line >= this.lines.length) index = codeEl.children.length;
+					else {
+						const lineEl = this.lines[line];
+						index = codeEl.children.indexOf(lineEl);
+						if (index === -1) {
+							onShikiError(new ShikiTwoslashError(`Cannot find line ${line} in code element`), this.source, this.options.lang);
+							return;
+						}
+					}
+					const nodeAfter = codeEl.children[index + 1];
+					if (nodeAfter && nodeAfter.type === "text" && nodeAfter.value === "\n") codeEl.children.splice(index + 1, 1);
+					codeEl.children.splice(index + 1, 0, ...nodes);
+				};
+				const tokensMap = [];
+				this.lines.forEach((lineEl, line) => {
+					let index = 0;
+					for (const token of lineEl.children.flatMap((i) => i.type === "element" ? i.children || [] : [])) if ("value" in token && typeof token.value === "string") {
+						tokensMap.push([
+							line,
+							index,
+							index + token.value.length,
+							token
+						]);
+						index += token.value.length;
+					}
+				});
+				const locateTextTokens = (line, character, length) => {
+					const start = character;
+					const end = character + length;
+					if (length === 0) return tokensMap.filter(([l, s, e]) => l === line && s < start && start <= e).map((i) => i[3]);
+					return tokensMap.filter(([l, s, e]) => l === line && start <= s && s < end && start < e && e <= end).map((i) => i[3]);
+				};
+				const tokensSkipHover = /* @__PURE__ */ new Set();
+				const actionsHovers = [];
+				const actionsHighlights = [];
+				for (const node of twoslash.nodes) {
+					if (node.type === "tag") {
+						if (renderer.lineCustomTag) insertAfterLine(node.line, renderer.lineCustomTag.call(this, node));
+						continue;
+					}
+					const tokens = locateTextTokens(node.line, node.character, node.length);
+					if (!tokens.length && !(node.type === "error" && renderer.nodesError)) {
+						onShikiError(new ShikiTwoslashError(`Cannot find tokens for node: ${JSON.stringify(node)}`), this.source, this.options.lang);
+						continue;
+					}
+					const wrapTokens = (fn) => {
+						const line = this.lines[node.line];
+						let charIndex = 0;
+						let itemStart = line.children.length;
+						let itemEnd = 0;
+						line.children.forEach((token, index) => {
+							if (charIndex >= node.character && index < itemStart) itemStart = index;
+							if (charIndex <= node.character + node.length && index > itemEnd) itemEnd = index;
+							charIndex += getTokenString(token).length;
+						});
+						if (charIndex <= node.character + node.length) itemEnd = line.children.length;
+						const targets = line.children.slice(itemStart, itemEnd);
+						const length = targets.length;
+						line.children.splice(itemStart, length, ...fn(targets));
+					};
+					switch (node.type) {
+						case "error":
+							if (renderer.nodeError) tokens.forEach((token) => {
+								tokensSkipHover.add(token);
+								const clone = { ...token };
+								Object.assign(token, renderer.nodeError.call(this, node, clone));
+							});
+							if (renderer.nodesError) {
+								tokens.forEach((token) => {
+									tokensSkipHover.add(token);
+								});
+								actionsHighlights.push(() => {
+									wrapTokens((targets) => renderer.nodesError?.call(this, node, targets) || targets);
+								});
+							}
+							if (renderer.lineError) insertAfterLine(node.line, renderer.lineError.call(this, node));
+							break;
+						case "query": {
+							const token = tokens[0];
+							if (token && renderer.nodeQuery) {
+								tokensSkipHover.add(token);
+								const clone = { ...token };
+								Object.assign(token, renderer.nodeQuery.call(this, node, clone));
+							}
+							if (renderer.lineQuery) insertAfterLine(node.line, renderer.lineQuery.call(this, node, token));
+							break;
+						}
+						case "completion":
+							if (renderer.nodeCompletion) tokens.forEach((token) => {
+								tokensSkipHover.add(token);
+								const clone = { ...token };
+								Object.assign(token, renderer.nodeCompletion.call(this, node, clone));
+							});
+							if (renderer.lineCompletion) insertAfterLine(node.line, renderer.lineCompletion.call(this, node));
+							break;
+						case "highlight":
+							if (renderer.nodesHighlight) actionsHighlights.push(() => {
+								wrapTokens((targets) => renderer.nodesHighlight?.call(this, node, targets) || targets);
+							});
+							break;
+						case "hover":
+							if (renderer.nodeStaticInfo) actionsHovers.push(() => {
+								tokens.forEach((token) => {
+									if (tokensSkipHover.has(token)) return;
+									tokensSkipHover.add(token);
+									const clone = { ...token };
+									Object.assign(token, renderer.nodeStaticInfo.call(this, node, clone));
+								});
+							});
+							break;
+						default: onShikiError(new ShikiTwoslashError(`Unknown node type: ${node?.type}`), this.source, this.options.lang);
+					}
+				}
+				actionsHovers.forEach((i) => i());
+				actionsHighlights.forEach((i) => i());
+			}
+		};
+	};
+}
+function getTokenString(token) {
+	if ("value" in token) return token.value;
+	return token.children?.map(getTokenString).join("") || "";
+}
+//#endregion
+export { rendererClassic as a, ShikiTwoslashError as c, rendererRich as i, defaultTwoslashOptions as n, defaultCompletionIcons as o, defaultHoverInfoProcessor as r, defaultCustomTagIcons as s, createTransformerFactory as t };

package/dist/core.mjs

@@ -1,214 +1,2 @@
-import { a as defaultCustomTagIcons, c as ShikiTwoslashError, i as defaultCompletionIcons, n as rendererRich, o as TwoslashIncludesManager, r as rendererClassic, s as parseIncludeMeta, t as defaultHoverInfoProcessor } from "./renderer-rich-DEkszi0Z.mjs";
-import { splitTokens } from "@shikijs/core";
-
-//#region src/core.ts
-function defaultTwoslashOptions() {
-	return {
-		customTags: [
-			"annotate",
-			"log",
-			"warn",
-			"error"
-		],
-		compilerOptions: { moduleResolution: 100 }
-	};
-}
-function createTransformerFactory(defaultTwoslasher, defaultRenderer) {
-	return function transformerTwoslash(options = {}) {
-		const { langs = ["ts", "tsx"], twoslashOptions = defaultTwoslashOptions(), langAlias = {
-			typescript: "ts",
-			json5: "json",
-			yml: "yaml"
-		}, twoslasher = defaultTwoslasher, explicitTrigger = false, disableTriggers = ["notwoslash", "no-twoslash"], renderer = defaultRenderer, throws = true, includesMap = /* @__PURE__ */ new Map(), typesCache } = options;
-		const onTwoslashError = options.onTwoslashError || (throws ? (error) => {
-			throw error;
-		} : () => false);
-		const onShikiError = options.onShikiError || (throws ? (error) => {
-			throw error;
-		} : () => false);
-		const trigger = explicitTrigger instanceof RegExp ? explicitTrigger : /\btwoslash\b/;
-		if (!renderer) throw new ShikiTwoslashError("Missing renderer");
-		const map = /* @__PURE__ */ new WeakMap();
-		const { filter = (lang, _, options) => {
-			return langs.includes(lang) && (!explicitTrigger || trigger.test(options.meta?.__raw || "")) && !disableTriggers.some((i) => typeof i === "string" ? options.meta?.__raw?.includes(i) : i.test(options.meta?.__raw || ""));
-		} } = options;
-		const includes = new TwoslashIncludesManager(includesMap);
-		let _twoslasher = twoslasher;
-		if (typesCache) {
-			_twoslasher = ((code, lang, options, meta) => {
-				const preprocessed = typesCache?.preprocess?.(code, lang, options, meta);
-				if (preprocessed !== void 0) code = preprocessed;
-				let twoslash = typesCache?.read(code, lang, options, meta);
-				if (!twoslash) {
-					twoslash = twoslasher(code, lang, options);
-					typesCache?.write(code, twoslash, lang, options, meta);
-				}
-				return twoslash;
-			});
-			typesCache.init?.();
-		}
-		return {
-			preprocess(code) {
-				let lang = this.options.lang;
-				if (lang in langAlias) lang = langAlias[this.options.lang];
-				if (filter(lang, code, this.options, this)) try {
-					const codeWithIncludes = includes.applyInclude(code);
-					const include = parseIncludeMeta(this.options.meta?.__raw);
-					if (include) includes.add(include, codeWithIncludes);
-					const twoslash = _twoslasher(codeWithIncludes, lang, twoslashOptions, this.meta);
-					map.set(this.meta, twoslash);
-					this.meta.twoslash = twoslash;
-					this.options.lang = twoslash.meta?.extension || lang;
-					return twoslash.code;
-				} catch (error) {
-					const result = onTwoslashError(error, code, lang, this.options);
-					if (typeof result === "string") return result;
-				}
-			},
-			tokens(tokens) {
-				const twoslash = map.get(this.meta);
-				if (!twoslash) return;
-				return splitTokens(tokens, twoslash.nodes.flatMap((i) => [
-					"hover",
-					"error",
-					"query",
-					"highlight",
-					"completion"
-				].includes(i.type) ? [i.start, i.start + i.length] : []));
-			},
-			pre(pre) {
-				if (!map.get(this.meta)) return;
-				this.addClassToHast(pre, "twoslash lsp");
-			},
-			code(codeEl) {
-				const twoslash = map.get(this.meta);
-				if (!twoslash) return;
-				const insertAfterLine = (line, nodes) => {
-					if (!nodes.length) return;
-					let index;
-					if (line >= this.lines.length) index = codeEl.children.length;
-					else {
-						const lineEl = this.lines[line];
-						index = codeEl.children.indexOf(lineEl);
-						if (index === -1) {
-							onShikiError(new ShikiTwoslashError(`Cannot find line ${line} in code element`), this.source, this.options.lang);
-							return;
-						}
-					}
-					const nodeAfter = codeEl.children[index + 1];
-					if (nodeAfter && nodeAfter.type === "text" && nodeAfter.value === "\n") codeEl.children.splice(index + 1, 1);
-					codeEl.children.splice(index + 1, 0, ...nodes);
-				};
-				const tokensMap = [];
-				this.lines.forEach((lineEl, line) => {
-					let index = 0;
-					for (const token of lineEl.children.flatMap((i) => i.type === "element" ? i.children || [] : [])) if ("value" in token && typeof token.value === "string") {
-						tokensMap.push([
-							line,
-							index,
-							index + token.value.length,
-							token
-						]);
-						index += token.value.length;
-					}
-				});
-				const locateTextTokens = (line, character, length) => {
-					const start = character;
-					const end = character + length;
-					if (length === 0) return tokensMap.filter(([l, s, e]) => l === line && s < start && start <= e).map((i) => i[3]);
-					return tokensMap.filter(([l, s, e]) => l === line && start <= s && s < end && start < e && e <= end).map((i) => i[3]);
-				};
-				const tokensSkipHover = /* @__PURE__ */ new Set();
-				const actionsHovers = [];
-				const actionsHighlights = [];
-				for (const node of twoslash.nodes) {
-					if (node.type === "tag") {
-						if (renderer.lineCustomTag) insertAfterLine(node.line, renderer.lineCustomTag.call(this, node));
-						continue;
-					}
-					const tokens = locateTextTokens(node.line, node.character, node.length);
-					if (!tokens.length && !(node.type === "error" && renderer.nodesError)) {
-						onShikiError(new ShikiTwoslashError(`Cannot find tokens for node: ${JSON.stringify(node)}`), this.source, this.options.lang);
-						continue;
-					}
-					const wrapTokens = (fn) => {
-						const line = this.lines[node.line];
-						let charIndex = 0;
-						let itemStart = line.children.length;
-						let itemEnd = 0;
-						line.children.forEach((token, index) => {
-							if (charIndex >= node.character && index < itemStart) itemStart = index;
-							if (charIndex <= node.character + node.length && index > itemEnd) itemEnd = index;
-							charIndex += getTokenString(token).length;
-						});
-						if (charIndex <= node.character + node.length) itemEnd = line.children.length;
-						const targets = line.children.slice(itemStart, itemEnd);
-						const length = targets.length;
-						line.children.splice(itemStart, length, ...fn(targets));
-					};
-					switch (node.type) {
-						case "error":
-							if (renderer.nodeError) tokens.forEach((token) => {
-								tokensSkipHover.add(token);
-								const clone = { ...token };
-								Object.assign(token, renderer.nodeError.call(this, node, clone));
-							});
-							if (renderer.nodesError) {
-								tokens.forEach((token) => {
-									tokensSkipHover.add(token);
-								});
-								actionsHighlights.push(() => {
-									wrapTokens((targets) => renderer.nodesError?.call(this, node, targets) || targets);
-								});
-							}
-							if (renderer.lineError) insertAfterLine(node.line, renderer.lineError.call(this, node));
-							break;
-						case "query": {
-							const token = tokens[0];
-							if (token && renderer.nodeQuery) {
-								tokensSkipHover.add(token);
-								const clone = { ...token };
-								Object.assign(token, renderer.nodeQuery.call(this, node, clone));
-							}
-							if (renderer.lineQuery) insertAfterLine(node.line, renderer.lineQuery.call(this, node, token));
-							break;
-						}
-						case "completion":
-							if (renderer.nodeCompletion) tokens.forEach((token) => {
-								tokensSkipHover.add(token);
-								const clone = { ...token };
-								Object.assign(token, renderer.nodeCompletion.call(this, node, clone));
-							});
-							if (renderer.lineCompletion) insertAfterLine(node.line, renderer.lineCompletion.call(this, node));
-							break;
-						case "highlight":
-							if (renderer.nodesHighlight) actionsHighlights.push(() => {
-								wrapTokens((targets) => renderer.nodesHighlight?.call(this, node, targets) || targets);
-							});
-							break;
-						case "hover":
-							if (renderer.nodeStaticInfo) actionsHovers.push(() => {
-								tokens.forEach((token) => {
-									if (tokensSkipHover.has(token)) return;
-									tokensSkipHover.add(token);
-									const clone = { ...token };
-									Object.assign(token, renderer.nodeStaticInfo.call(this, node, clone));
-								});
-							});
-							break;
-						default: onShikiError(new ShikiTwoslashError(`Unknown node type: ${node?.type}`), this.source, this.options.lang);
-					}
-				}
-				actionsHovers.forEach((i) => i());
-				actionsHighlights.forEach((i) => i());
-			}
-		};
-	};
-}
-function getTokenString(token) {
-	if ("value" in token) return token.value;
-	return token.children?.map(getTokenString).join("") || "";
-}
-
-//#endregion
-export { ShikiTwoslashError, createTransformerFactory, defaultCompletionIcons, defaultCustomTagIcons, defaultHoverInfoProcessor, defaultTwoslashOptions, rendererClassic, rendererRich };
+import { a as rendererClassic, c as ShikiTwoslashError, i as rendererRich, n as defaultTwoslashOptions, o as defaultCompletionIcons, r as defaultHoverInfoProcessor, s as defaultCustomTagIcons, t as createTransformerFactory } from "./core-VR43FShM.mjs";
+export { ShikiTwoslashError, createTransformerFactory, defaultCompletionIcons, defaultCustomTagIcons, defaultHoverInfoProcessor, defaultTwoslashOptions, rendererClassic, rendererRich };

package/dist/index.d.mts

@@ -3,7 +3,7 @@ import { CreateTwoslashOptions } from "twoslash";
 import { ShikiTransformer } from "@shikijs/types";
 
 //#region src/index.d.ts
-interface TransformerTwoslashIndexOptions extends TransformerTwoslashOptions, Pick<CreateTwoslashOptions, 'cache'> {
+interface TransformerTwoslashIndexOptions extends TransformerTwoslashOptions, Pick<CreateTwoslashOptions, 'cache' | 'tsModule'> {
   /**
    * Options for the default rich renderer.
    *

package/dist/index.mjs

@@ -1,17 +1,17 @@
-import { a as defaultCustomTagIcons, c as ShikiTwoslashError, i as defaultCompletionIcons, n as rendererRich, r as rendererClassic, t as defaultHoverInfoProcessor } from "./renderer-rich-DEkszi0Z.mjs";
-import { createTransformerFactory, defaultTwoslashOptions } from "./core.mjs";
+import { a as rendererClassic, c as ShikiTwoslashError, i as rendererRich, n as defaultTwoslashOptions, o as defaultCompletionIcons, r as defaultHoverInfoProcessor, s as defaultCustomTagIcons, t as createTransformerFactory } from "./core-VR43FShM.mjs";
 import { createTwoslasher } from "twoslash";
-
 //#region src/index.ts
 /**
 * Factory function to create a Shiki transformer for twoslash integrations.
 */
 function transformerTwoslash(options = {}) {
-	return createTransformerFactory(createTwoslasher({
-		cache: options?.cache,
+	const twoslashOptions = {
+		cache: options.cache,
 		compilerOptions: { moduleResolution: 100 }
-	}), rendererRich(options.rendererRich))(options);
+	};
+	const tsModule = options.tsModule || options.twoslashOptions?.tsModule;
+	if (tsModule) twoslashOptions.tsModule = tsModule;
+	return createTransformerFactory(createTwoslasher(twoslashOptions), rendererRich(options.rendererRich))(options);
 }
-
 //#endregion
-export { ShikiTwoslashError, createTransformerFactory, defaultCompletionIcons, defaultCustomTagIcons, defaultHoverInfoProcessor, defaultTwoslashOptions, rendererClassic, rendererRich, transformerTwoslash };
+export { ShikiTwoslashError, createTransformerFactory, defaultCompletionIcons, defaultCustomTagIcons, defaultHoverInfoProcessor, defaultTwoslashOptions, rendererClassic, rendererRich, transformerTwoslash };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/twoslash",
   "type": "module",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "description": "Shiki transformer for twoslash",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -38,16 +38,16 @@
     "typescript": ">=5.5.0"
   },
   "dependencies": {
-    "twoslash": "^0.3.6",
-    "@shikijs/types": "4.0.2",
-    "@shikijs/core": "4.0.2"
+    "twoslash": "^0.3.8",
+    "@shikijs/core": "4.1.0",
+    "@shikijs/types": "4.1.0"
   },
   "devDependencies": {
-    "@iconify-json/carbon": "^1.2.19",
-    "@iconify-json/codicon": "^1.2.48",
+    "@iconify-json/carbon": "^1.2.21",
+    "@iconify-json/codicon": "^1.2.55",
     "hast-util-from-html": "^2.0.3",
-    "typescript": "^5.9.3",
-    "@shikijs/twoslash": "4.0.2"
+    "typescript": "^6.0.3",
+    "@shikijs/twoslash": "4.1.0"
   },
   "scripts": {
     "build": "tsdown",