@openclaw/diffs 2026.10.2 → 2026.10.5-beta.2

package/node_modules/@pierre/diffs/node_modules/@shikijs/core/dist/index.d.mts

@@ -24,8 +24,8 @@ export * from "@shikijs/types";
  *
  * @param options
  */
-declare function createBundledHighlighter<BundledLangs extends string, BundledThemes extends string>(options: CreateBundledHighlighterOptions<BundledLangs, BundledThemes>): CreateHighlighterFactory<BundledLangs, BundledThemes>;
-interface ShorthandsBundle<L extends string, T extends string> {
+export declare function createBundledHighlighter<BundledLangs extends string, BundledThemes extends string>(options: CreateBundledHighlighterOptions<BundledLangs, BundledThemes>): CreateHighlighterFactory<BundledLangs, BundledThemes>;
+export interface ShorthandsBundle<L extends string, T extends string> {
   /**
    * Shorthand for `codeToHtml` with auto-loaded theme and language.
    * A singleton highlighter it maintained internally.
@@ -71,14 +71,14 @@ interface ShorthandsBundle<L extends string, T extends string> {
    */
   getLastGrammarState: ((element: ThemedToken[][] | Root) => GrammarState) | ((code: string, options: CodeToTokensBaseOptions<L, T>) => Promise<GrammarState>);
 }
-declare function makeSingletonHighlighter<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>): (options?: Partial<BundledHighlighterOptions<L, T>>) => Promise<HighlighterGeneric<L, T>>;
-interface CreateSingletonShorthandsOptions<L extends string, T extends string> {
+export declare function makeSingletonHighlighter<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>): (options?: Partial<BundledHighlighterOptions<L, T>>) => Promise<HighlighterGeneric<L, T>>;
+export interface CreateSingletonShorthandsOptions<L extends string, T extends string> {
   /**
    * A custom function to guess embedded languages to be loaded.
    */
   guessEmbeddedLanguages?: (code: string, lang: string | undefined, highlighter: HighlighterGeneric<L, T>) => Awaitable<string[] | undefined>;
 }
-declare function createSingletonShorthands<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>, config?: CreateSingletonShorthandsOptions<L, T>): ShorthandsBundle<L, T>;
+export declare function createSingletonShorthands<L extends string, T extends string>(createHighlighter: CreateHighlighterFactory<L, T>, config?: CreateSingletonShorthandsOptions<L, T>): ShorthandsBundle<L, T>;
 //#endregion
 //#region src/constructors/highlighter.d.ts
 /**
@@ -87,7 +87,7 @@ declare function createSingletonShorthands<L extends string, T extends string>(c
  *
  * @see http://shiki.style/guide/bundles#fine-grained-bundle
  */
-declare function createHighlighterCore(options: HighlighterCoreOptions<false>): Promise<HighlighterCore>;
+export declare function createHighlighterCore(options: HighlighterCoreOptions<false>): Promise<HighlighterCore>;
 /**
  * Create a Shiki core highlighter instance, with no languages or themes bundled.
  * Wasm and each language and theme must be loaded manually.
@@ -96,20 +96,20 @@ declare function createHighlighterCore(options: HighlighterCoreOptions<false>):
  *
  * @see http://shiki.style/guide/bundles#fine-grained-bundle
  */
-declare function createHighlighterCoreSync(options: HighlighterCoreOptions<true>): HighlighterCore;
-declare function makeSingletonHighlighterCore(createHighlighter: typeof createHighlighterCore): (options: HighlighterCoreOptions) => Promise<HighlighterCore>;
-declare const getSingletonHighlighterCore: (options: HighlighterCoreOptions) => Promise<HighlighterCore>;
+export declare function createHighlighterCoreSync(options: HighlighterCoreOptions<true>): HighlighterCore;
+export declare function makeSingletonHighlighterCore(createHighlighter: typeof createHighlighterCore): (options: HighlighterCoreOptions) => Promise<HighlighterCore>;
+export declare const getSingletonHighlighterCore: (options: HighlighterCoreOptions) => Promise<HighlighterCore>;
 //#endregion
 //#region src/highlight/code-to-hast.d.ts
-declare function codeToHast(primitive: ShikiPrimitive, code: string, options: CodeToHastOptions, transformerContext?: ShikiTransformerContextCommon): Root;
-declare function tokensToHast(tokens: ThemedToken[][], options: CodeToHastRenderOptions, transformerContext: ShikiTransformerContextSource, grammarState?: GrammarState | undefined): Root;
+export declare function codeToHast(primitive: ShikiPrimitive, code: string, options: CodeToHastOptions, transformerContext?: ShikiTransformerContextCommon): Root;
+export declare function tokensToHast(tokens: ThemedToken[][], options: CodeToHastRenderOptions, transformerContext: ShikiTransformerContextSource, grammarState?: GrammarState | undefined): Root;
 //#endregion
 //#region src/highlight/code-to-html.d.ts
-declare const hastToHtml: typeof toHtml;
+export declare const hastToHtml: typeof toHtml;
 /**
  * Get highlighted code in HTML.
  */
-declare function codeToHtml(primitive: ShikiPrimitive, code: string, options: CodeToHastOptions): string;
+export declare function codeToHtml(primitive: ShikiPrimitive, code: string, options: CodeToHastOptions): string;
 //#endregion
 //#region src/highlight/code-to-tokens.d.ts
 /**
@@ -117,20 +117,20 @@ declare function codeToHtml(primitive: ShikiPrimitive, code: string, options: Co
  *
  * It will use `codeToTokensWithThemes` or `codeToTokensBase` based on the options.
  */
-declare function codeToTokens(primitive: ShikiPrimitive, code: string, options: CodeToTokensOptions): TokensResult;
+export declare function codeToTokens(primitive: ShikiPrimitive, code: string, options: CodeToTokensOptions): TokensResult;
 //#endregion
 //#region src/highlight/code-to-tokens-ansi.d.ts
-declare function tokenizeAnsiWithTheme(theme: ThemeRegistrationResolved, fileContents: string, options?: TokenizeWithThemeOptions): ThemedToken[][];
+export declare function tokenizeAnsiWithTheme(theme: ThemeRegistrationResolved, fileContents: string, options?: TokenizeWithThemeOptions): ThemedToken[][];
 //#endregion
 //#region src/highlight/code-to-tokens-base.d.ts
 /**
  * Code to tokens, with a simple theme.
  * This wraps the tokenizer's implementation to add ANSI support.
  */
-declare function codeToTokensBase(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): ThemedToken[][];
+export declare function codeToTokensBase(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): ThemedToken[][];
 //#endregion
 //#region src/theme-css-variables.d.ts
-interface CssVariablesThemeOptions {
+export interface CssVariablesThemeOptions {
   /**
    * Theme name. Need to unique if multiple css variables themes are created
    *
@@ -161,13 +161,13 @@ interface CssVariablesThemeOptions {
  *
  * @see https://shiki.style/guide/theme-colors#css-variables-theme
  */
-declare function createCssVariablesTheme(options?: CssVariablesThemeOptions): ThemeRegistration;
+export declare function createCssVariablesTheme(options?: CssVariablesThemeOptions): ThemeRegistration;
 //#endregion
 //#region src/transformer-decorations.d.ts
 /**
  * A built-in transformer to add decorations to the highlighted code.
  */
-declare function transformerDecorations(): ShikiTransformer;
+export declare function transformerDecorations(): ShikiTransformer;
 //#endregion
 //#region src/utils/hast.d.ts
 /**
@@ -175,7 +175,7 @@ declare function transformerDecorations(): ShikiTransformer;
  *
  * If the `property.class` is a string, it will be splitted by space and converted to an array.
  */
-declare function addClassToHast(node: Element, className: string | string[]): Element;
+export declare function addClassToHast(node: Element, className: string | string[]): Element;
 //#endregion
 //#region src/utils/strings.d.ts
 /**
@@ -183,7 +183,7 @@ declare function addClassToHast(node: Element, className: string | string[]): El
  *
  * Overflow/underflow are unchecked.
  */
-declare function createPositionConverter(code: string): {
+export declare function createPositionConverter(code: string): {
   lines: string[];
   indexToPos: (index: number) => Position;
   posToIndex: (line: number, character: number) => number;
@@ -207,7 +207,7 @@ declare function createPositionConverter(code: string): {
  * guessEmbeddedLanguages('```python\nprint("hi")\n```')
  * ```
  */
-declare function guessEmbeddedLanguages(code: string, _lang: string | undefined, highlighter?: HighlighterGeneric<any, any>): string[];
+export declare function guessEmbeddedLanguages(code: string, _lang: string | undefined, highlighter?: HighlighterGeneric<any, any>): string[];
 //#endregion
 //#region src/utils/tokens.d.ts
 /**
@@ -215,13 +215,13 @@ declare function guessEmbeddedLanguages(code: string, _lang: string | undefined,
  *
  * The offsets are relative to the token, and should be sorted.
  */
-declare function splitToken<T extends Pick<ThemedToken, 'content' | 'offset'>>(token: T, offsets: number[]): T[];
+export declare function splitToken<T extends Pick<ThemedToken, 'content' | 'offset'>>(token: T, offsets: number[]): T[];
 /**
  * Split 2D tokens array by given breakpoints.
  */
-declare function splitTokens<T extends Pick<ThemedToken, 'content' | 'offset'>>(tokens: T[][], breakpoints: number[] | Set<number>): T[][];
-declare function flatTokenVariants(merged: ThemedTokenWithVariants, variantsOrder: string[], cssVariablePrefix: string, defaultColor: CodeOptionsMultipleThemes['defaultColor'], colorsRendering?: CodeOptionsMultipleThemes['colorsRendering']): ThemedToken;
-declare function getTokenStyleObject(token: TokenStyles): Record<string, string>;
-declare function stringifyTokenStyle(token: string | Record<string, string>): string;
+export declare function splitTokens<T extends Pick<ThemedToken, 'content' | 'offset'>>(tokens: T[][], breakpoints: number[] | Set<number>): T[][];
+export declare function flatTokenVariants(merged: ThemedTokenWithVariants, variantsOrder: string[], cssVariablePrefix: string, defaultColor: CodeOptionsMultipleThemes['defaultColor'], colorsRendering?: CodeOptionsMultipleThemes['colorsRendering']): ThemedToken;
+export declare function getTokenStyleObject(token: TokenStyles): Record<string, string>;
+export declare function stringifyTokenStyle(token: string | Record<string, string>): string;
 //#endregion
-export { CreateSingletonShorthandsOptions, CssVariablesThemeOptions, ShikiError, ShorthandsBundle, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createBundledHighlighter, createCssVariablesTheme, createHighlighterCore, createHighlighterCoreSync, createPositionConverter, createShikiInternal, createShikiInternalSync, createShikiPrimitive, createShikiPrimitiveAsync, createSingletonShorthands, flatTokenVariants, getLastGrammarState, getSingletonHighlighterCore, getTokenStyleObject, guessEmbeddedLanguages, hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };
+export { ShikiError, applyColorReplacements, codeToTokensWithThemes, createShikiInternal, createShikiInternalSync, createShikiPrimitive, createShikiPrimitiveAsync, getLastGrammarState, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeGetter, normalizeTheme, resolveColorReplacements, splitLines, toArray, tokenizeWithTheme };

package/node_modules/@pierre/diffs/node_modules/@shikijs/core/dist/index.mjs

@@ -177,16 +177,17 @@ function flatTokenVariants(merged, variantsOrder, cssVariablePrefix, defaultColo
 	styles.forEach((cur, idx) => {
 		for (const key of styleKeys) {
 			const value = cur[key] || "inherit";
-			if (idx === 0 && defaultColor && COLOR_KEYS.includes(key)) if (defaultColor === "light-dark()" && styles.length > 1) {
-				const lightIndex = variantsOrder.findIndex((t) => t === "light");
-				const darkIndex = variantsOrder.findIndex((t) => t === "dark");
-				if (lightIndex === -1 || darkIndex === -1) throw new ShikiError$1("When using `defaultColor: \"light-dark()\"`, you must provide both `light` and `dark` themes");
-				const lightValue = styles[lightIndex][key] || "inherit";
-				const darkValue = styles[darkIndex][key] || "inherit";
-				mergedStyles[key] = `light-dark(${lightValue}, ${darkValue})`;
-				if (colorsRendering === "css-vars") mergedStyles[varKey(idx, key)] = value;
-			} else mergedStyles[key] = value;
-			else if (colorsRendering === "css-vars") mergedStyles[varKey(idx, key)] = value;
+			if (idx === 0 && defaultColor && COLOR_KEYS.includes(key)) {
+				if (defaultColor === "light-dark()" && styles.length > 1) {
+					const lightIndex = variantsOrder.findIndex((t) => t === "light");
+					const darkIndex = variantsOrder.findIndex((t) => t === "dark");
+					if (lightIndex === -1 || darkIndex === -1) throw new ShikiError$1("When using `defaultColor: \"light-dark()\"`, you must provide both `light` and `dark` themes");
+					const lightValue = styles[lightIndex][key] || "inherit";
+					const darkValue = styles[darkIndex][key] || "inherit";
+					mergedStyles[key] = `light-dark(${lightValue}, ${darkValue})`;
+					if (colorsRendering === "css-vars") mergedStyles[varKey(idx, key)] = value;
+				} else mergedStyles[key] = value;
+			} else if (colorsRendering === "css-vars") mergedStyles[varKey(idx, key)] = value;
 		}
 	});
 	token.htmlStyle = mergedStyles;
@@ -829,8 +830,10 @@ function tokensToHast(tokens, options, transformerContext, grammarState = getLas
 	};
 	const { structure = "classic", tabindex = "0" } = options;
 	const properties = { class: `shiki ${options.themeName || ""}` };
-	if (options.rootStyle !== false) if (options.rootStyle != null) properties.style = options.rootStyle;
-	else properties.style = `background-color:${options.bg};color:${options.fg}`;
+	if (options.rootStyle !== false) {
+		if (options.rootStyle != null) properties.style = options.rootStyle;
+		else properties.style = `background-color:${options.bg};color:${options.fg}`;
+	}
 	if (tabindex !== false && tabindex != null) properties.tabindex = tabindex.toString();
 	for (const [key, value] of Object.entries(options.meta || {})) if (!key.startsWith("_")) properties[key] = value;
 	let preNode = {

package/node_modules/@pierre/diffs/node_modules/@shikijs/core/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/core",
   "type": "module",
-  "version": "4.4.3",
+  "version": "4.5.0",
   "description": "Core of Shiki",
   "author": "Pine Wu <octref@gmail.com>; Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -46,11 +46,11 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@shikijs/primitive": "4.5.0",
+    "@shikijs/types": "4.5.0",
     "@shikijs/vscode-textmate": "^10.0.2",
     "@types/hast": "^3.0.5",
-    "hast-util-to-html": "^9.0.5",
-    "@shikijs/primitive": "4.4.3",
-    "@shikijs/types": "4.4.3"
+    "hast-util-to-html": "^9.0.5"
   },
   "scripts": {
     "build": "tsdown",

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/{engine-compile-Bdn9ihA2.d.mts → engine-compile-CtqiSkRk.d.mts}

@@ -24,6 +24,11 @@ declare class JavaScriptScanner implements PatternScanner {
   patterns: (string | RegExp)[];
   options: JavaScriptRegexScannerOptions;
   regexps: (RegExp | null)[];
+  /**
+   * Last search of each regexp on the current string, reused the way `vscode-oniguruma` does.
+   * `null` for regexps whose searches can't be reused.
+   */
+  private lastSearches;
   constructor(patterns: (string | RegExp)[], options?: JavaScriptRegexScannerOptions);
   findNextMatchSync(string: string | RegexEngineString, startPosition: number, _options: number): IOnigMatch | null;
 }

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/engine-compile.d.mts

@@ -1,2 +1,2 @@
-import { n as createJavaScriptRegexEngine, r as defaultJavaScriptRegexConstructor, t as JavaScriptRegexEngineOptions } from "./engine-compile-Bdn9ihA2.mjs";
+import { n as createJavaScriptRegexEngine, r as defaultJavaScriptRegexConstructor, t as JavaScriptRegexEngineOptions } from "./engine-compile-CtqiSkRk.mjs";
 export { JavaScriptRegexEngineOptions, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/engine-compile.mjs

@@ -1,4 +1,4 @@
-import { t as JavaScriptScanner } from "./scanner-DX8LRFGE.mjs";
+import { n as JavaScriptScanner, t as createJavaScriptEngineString } from "./string-TLTPtCPs.mjs";
 import { toRegExp } from "oniguruma-to-es";
 //#region src/engine-compile.ts
 /**
@@ -38,9 +38,7 @@ function createJavaScriptRegexEngine(options = {}) {
 		createScanner(patterns) {
 			return new JavaScriptScanner(patterns, _options);
 		},
-		createString(s) {
-			return { content: s };
-		}
+		createString: createJavaScriptEngineString
 	};
 }
 //#endregion

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/engine-raw.d.mts

@@ -7,6 +7,5 @@ import { RegexEngine } from "@shikijs/types";
  *
  * Zero dependencies.
  */
-declare function createJavaScriptRawEngine(): RegexEngine;
-//#endregion
-export { createJavaScriptRawEngine };
+export declare function createJavaScriptRawEngine(): RegexEngine;
+//#endregion

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/engine-raw.mjs

@@ -1,4 +1,4 @@
-import { t as JavaScriptScanner } from "./scanner-DX8LRFGE.mjs";
+import { n as JavaScriptScanner, t as createJavaScriptEngineString } from "./string-TLTPtCPs.mjs";
 //#region src/engine-raw.ts
 /**
 * Raw JavaScript regex engine that only supports precompiled grammars.
@@ -18,9 +18,7 @@ function createJavaScriptRawEngine() {
 		createScanner(patterns) {
 			return new JavaScriptScanner(patterns, options);
 		},
-		createString(s) {
-			return { content: s };
-		}
+		createString: createJavaScriptEngineString
 	};
 }
 //#endregion

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/index.d.mts

@@ -1,3 +1,3 @@
-import { a as JavaScriptScanner, i as JavaScriptRegexScannerOptions, n as createJavaScriptRegexEngine, r as defaultJavaScriptRegexConstructor, t as JavaScriptRegexEngineOptions } from "./engine-compile-Bdn9ihA2.mjs";
+import { a as JavaScriptScanner, i as JavaScriptRegexScannerOptions, n as createJavaScriptRegexEngine, r as defaultJavaScriptRegexConstructor, t as JavaScriptRegexEngineOptions } from "./engine-compile-CtqiSkRk.mjs";
 import { createJavaScriptRawEngine } from "./engine-raw.mjs";
 export { JavaScriptRegexEngineOptions, JavaScriptRegexScannerOptions, JavaScriptScanner, createJavaScriptRawEngine, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as JavaScriptScanner } from "./scanner-DX8LRFGE.mjs";
+import { n as JavaScriptScanner } from "./string-TLTPtCPs.mjs";
 import { createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor } from "./engine-compile.mjs";
 import { createJavaScriptRawEngine } from "./engine-raw.mjs";
 export { JavaScriptScanner, createJavaScriptRawEngine, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/dist/string-TLTPtCPs.mjs

@@ -0,0 +1,115 @@
+//#region src/scanner.ts
+const MAX = 4294967295;
+function isSearchCacheable(regexp) {
+	return !regexp.sticky && !regexp.rawOptions?.strategy;
+}
+function toResult(index, indices) {
+	return {
+		index,
+		captureIndices: indices.map((indice) => {
+			if (indice == null) return {
+				start: MAX,
+				end: MAX,
+				length: 0
+			};
+			return {
+				start: indice[0],
+				end: indice[1],
+				length: indice[1] - indice[0]
+			};
+		})
+	};
+}
+var JavaScriptScanner = class {
+	patterns;
+	options;
+	regexps;
+	/**
+	* Last search of each regexp on the current string, reused the way `vscode-oniguruma` does.
+	* `null` for regexps whose searches can't be reused.
+	*/
+	lastSearches;
+	constructor(patterns, options = {}) {
+		this.patterns = patterns;
+		this.options = options;
+		const { forgiving = false, cache, regexConstructor } = options;
+		if (!regexConstructor) throw new Error("Option `regexConstructor` is not provided");
+		this.regexps = patterns.map((p) => {
+			if (typeof p !== "string") return p;
+			const cached = cache?.get(p);
+			if (cached) {
+				if (cached instanceof RegExp) return cached;
+				if (forgiving) return null;
+				throw cached;
+			}
+			try {
+				const regex = regexConstructor(p);
+				cache?.set(p, regex);
+				return regex;
+			} catch (e) {
+				cache?.set(p, e);
+				if (forgiving) return null;
+				throw e;
+			}
+		});
+		this.lastSearches = this.regexps.map((regexp) => regexp && isSearchCacheable(regexp) ? {
+			strId: 0,
+			searchedFrom: 0,
+			matchIndex: -1,
+			indices: null
+		} : null);
+	}
+	findNextMatchSync(string, startPosition, _options) {
+		const str = typeof string === "string" ? string : string.content;
+		const strId = typeof string === "string" ? 0 : string.id || 0;
+		let bestIndex = -1;
+		let bestMatchIndex = 0;
+		let bestIndices = null;
+		for (let i = 0; i < this.regexps.length; i++) {
+			const regexp = this.regexps[i];
+			if (!regexp) continue;
+			try {
+				const last = strId ? this.lastSearches[i] : null;
+				let matchIndex;
+				let indices;
+				if (last && last.strId === strId && last.searchedFrom <= startPosition && (last.matchIndex === -1 || last.matchIndex >= startPosition)) {
+					matchIndex = last.matchIndex;
+					indices = last.indices;
+				} else {
+					regexp.lastIndex = startPosition;
+					const match = regexp.exec(str);
+					matchIndex = match ? match.index : -1;
+					indices = match ? match.indices : null;
+					if (last) {
+						last.strId = strId;
+						last.searchedFrom = startPosition;
+						last.matchIndex = matchIndex;
+						last.indices = indices;
+					}
+				}
+				if (matchIndex === -1) continue;
+				if (matchIndex === startPosition) return toResult(i, indices);
+				if (bestIndex === -1 || matchIndex < bestMatchIndex) {
+					bestIndex = i;
+					bestMatchIndex = matchIndex;
+					bestIndices = indices;
+				}
+			} catch (e) {
+				if (this.options.forgiving) continue;
+				throw e;
+			}
+		}
+		return bestIndex === -1 ? null : toResult(bestIndex, bestIndices);
+	}
+};
+//#endregion
+//#region src/string.ts
+let lastStringId = 0;
+function createJavaScriptEngineString(content) {
+	return {
+		content,
+		id: ++lastStringId
+	};
+}
+//#endregion
+export { JavaScriptScanner as n, createJavaScriptEngineString as t };

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-javascript/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/engine-javascript",
   "type": "module",
-  "version": "4.4.3",
+  "version": "4.5.0",
   "description": "Engine for Shiki using JavaScript's native RegExp",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -31,9 +31,9 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@shikijs/types": "4.5.0",
     "@shikijs/vscode-textmate": "^10.0.2",
-    "oniguruma-to-es": "^4.3.6",
-    "@shikijs/types": "4.4.3"
+    "oniguruma-to-es": "^4.3.6"
   },
   "scripts": {
     "build": "tsdown",

package/node_modules/@pierre/diffs/node_modules/@shikijs/engine-oniguruma/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/engine-oniguruma",
   "type": "module",
-  "version": "4.4.3",
+  "version": "4.5.0",
   "description": "Engine for Shiki using Oniguruma RegExp engine in WebAssembly",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -32,8 +32,8 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@shikijs/vscode-textmate": "^10.0.2",
-    "@shikijs/types": "4.4.3"
+    "@shikijs/types": "4.5.0",
+    "@shikijs/vscode-textmate": "^10.0.2"
   },
   "devDependencies": {
     "vscode-oniguruma": "1.7.0"

package/node_modules/@pierre/diffs/node_modules/@shikijs/primitive/dist/index.d.mts

@@ -6,11 +6,11 @@ export * from "@shikijs/types";
 /**
  * Get the minimal shiki primitive instance.
  */
-declare function createShikiPrimitiveAsync(options: HighlighterCoreOptions): Promise<ShikiPrimitive>;
+export declare function createShikiPrimitiveAsync(options: HighlighterCoreOptions): Promise<ShikiPrimitive>;
 /**
  * @deprecated Use `createShikiPrimitiveAsync` instead.
  */
-declare const createShikiInternal: typeof createShikiPrimitiveAsync;
+export declare const createShikiInternal: typeof createShikiPrimitiveAsync;
 //#endregion
 //#region src/constructors/primitive.d.ts
 /**
@@ -18,26 +18,26 @@ declare const createShikiInternal: typeof createShikiPrimitiveAsync;
  *
  * Requires to provide the engine and all themes and languages upfront.
  */
-declare function createShikiPrimitive(options: HighlighterCoreOptions<true>): ShikiPrimitive;
+export declare function createShikiPrimitive(options: HighlighterCoreOptions<true>): ShikiPrimitive;
 /**
  * @deprecated Use `createShikiPrimitive` instead.
  */
-declare const createShikiInternalSync: typeof createShikiPrimitive;
+export declare const createShikiInternalSync: typeof createShikiPrimitive;
 //#endregion
 //#region src/highlight/code-to-tokens-base.d.ts
 /**
  * Code to tokens, with a simple theme.
  */
-declare function codeToTokensBase(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): ThemedToken[][];
-declare function getLastGrammarState(primitive: ShikiPrimitive, element: ThemedToken[][] | Root): GrammarState$1 | undefined;
-declare function getLastGrammarState(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): GrammarState$1;
-declare function tokenizeWithTheme(code: string, grammar: Grammar, theme: ThemeRegistrationResolved, colorMap: string[], options: TokenizeWithThemeOptions): ThemedToken[][];
+export declare function codeToTokensBase(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): ThemedToken[][];
+export declare function getLastGrammarState(primitive: ShikiPrimitive, element: ThemedToken[][] | Root): GrammarState$1 | undefined;
+export declare function getLastGrammarState(primitive: ShikiPrimitive, code: string, options?: CodeToTokensBaseOptions): GrammarState$1;
+export declare function tokenizeWithTheme(code: string, grammar: Grammar, theme: ThemeRegistrationResolved, colorMap: string[], options: TokenizeWithThemeOptions): ThemedToken[][];
 //#endregion
 //#region src/highlight/code-to-tokens-themes.d.ts
 /**
  * Get tokens with multiple themes
  */
-declare function codeToTokensWithThemes(primitive: ShikiPrimitive, code: string, options: CodeToTokensWithThemesOptions, codeToTokensBaseFn?: typeof codeToTokensBase): ThemedTokenWithVariants[][];
+export declare function codeToTokensWithThemes(primitive: ShikiPrimitive, code: string, options: CodeToTokensWithThemesOptions, codeToTokensBaseFn?: typeof codeToTokensBase): ThemedTokenWithVariants[][];
 /**
  * Break tokens from multiple themes into same tokenization.
  *
@@ -51,24 +51,24 @@ declare function codeToTokensWithThemes(primitive: ShikiPrimitive, code: string,
  * - `console . log ( " hello " )` (8 tokens)
  * - `console . log ( " hello " )` (8 tokens)
  */
-declare function alignThemesTokenization(...themes: ThemedToken[][][]): ThemedToken[][][];
+export declare function alignThemesTokenization(...themes: ThemedToken[][][]): ThemedToken[][][];
 //#endregion
 //#region src/textmate/getters-resolve.d.ts
 /**
  * Resolve
  */
-declare function resolveLangs(langs: (LanguageInput | SpecialLanguage)[]): Promise<LanguageRegistration[]>;
-declare function resolveThemes(themes: (ThemeInput | SpecialTheme)[]): Promise<ThemeRegistrationResolved[]>;
+export declare function resolveLangs(langs: (LanguageInput | SpecialLanguage)[]): Promise<LanguageRegistration[]>;
+export declare function resolveThemes(themes: (ThemeInput | SpecialTheme)[]): Promise<ThemeRegistrationResolved[]>;
 //#endregion
 //#region src/textmate/grammar-state.d.ts
-declare function setLastGrammarStateToMap(keys: GrammarStateMapKey, state: GrammarState$1): void;
-declare function getLastGrammarStateFromMap(keys: GrammarStateMapKey): GrammarState$1 | undefined;
+export declare function setLastGrammarStateToMap(keys: GrammarStateMapKey, state: GrammarState$1): void;
+export declare function getLastGrammarStateFromMap(keys: GrammarStateMapKey): GrammarState$1 | undefined;
 /**
  * GrammarState is a special reference object that holds the state of a grammar.
  *
  * It's used to highlight code snippets that are part of the target language.
  */
-declare class GrammarState implements GrammarState$1 {
+export declare class GrammarState implements GrammarState$1 {
   /**
    * Theme to Stack mapping
    */
@@ -96,16 +96,16 @@ declare class GrammarState implements GrammarState$1 {
     scopes: string[];
   };
 }
-declare function getGrammarStack(state: GrammarState | GrammarState$1, theme?: string): StateStack | undefined;
+export declare function getGrammarStack(state: GrammarState | GrammarState$1, theme?: string): StateStack | undefined;
 //#endregion
 //#region src/textmate/normalize-theme.d.ts
 /**
  * Normalize a textmate theme to shiki theme
  */
-declare function normalizeTheme(rawTheme: ThemeRegistrationAny): ThemeRegistrationResolved;
+export declare function normalizeTheme(rawTheme: ThemeRegistrationAny): ThemeRegistrationResolved;
 //#endregion
 //#region src/textmate/resolver.d.ts
-declare class Resolver implements RegistryOptions {
+export declare class Resolver implements RegistryOptions {
   private readonly _langs;
   private readonly _scopeToLang;
   private readonly _injections;
@@ -119,7 +119,7 @@ declare class Resolver implements RegistryOptions {
 }
 //#endregion
 //#region src/textmate/registry.d.ts
-declare class Registry extends Registry$1 {
+export declare class Registry extends Registry$1 {
   private _resolver;
   private _themes;
   private _langs;
@@ -145,45 +145,44 @@ declare class Registry extends Registry$1 {
 }
 //#endregion
 //#region src/utils/colors.d.ts
-declare function resolveColorReplacements(theme: ThemeRegistrationAny | string, options?: TokenizeWithThemeOptions): Record<string, string | undefined>;
-declare function applyColorReplacements(color: string, replacements?: Record<string, string | undefined>): string;
-declare function applyColorReplacements(color?: string | undefined, replacements?: Record<string, string | undefined>): string | undefined;
+export declare function resolveColorReplacements(theme: ThemeRegistrationAny | string, options?: TokenizeWithThemeOptions): Record<string, string | undefined>;
+export declare function applyColorReplacements(color: string, replacements?: Record<string, string | undefined>): string;
+export declare function applyColorReplacements(color?: string | undefined, replacements?: Record<string, string | undefined>): string | undefined;
 //#endregion
 //#region src/utils/general.d.ts
-declare function toArray<T>(x: MaybeArray<T>): T[];
+export declare function toArray<T>(x: MaybeArray<T>): T[];
 /**
  * Normalize a getter to a promise.
  */
-declare function normalizeGetter<T>(p: MaybeGetter<T>): Promise<T>;
+export declare function normalizeGetter<T>(p: MaybeGetter<T>): Promise<T>;
 /**
  * Check if the language is plaintext that is ignored by Shiki.
  *
  * Hard-coded plain text languages: `plaintext`, `txt`, `text`, `plain`.
  */
-declare function isPlainLang(lang: string | null | undefined): lang is PlainTextLanguage;
+export declare function isPlainLang(lang: string | null | undefined): lang is PlainTextLanguage;
 /**
  * Check if the language is specially handled or bypassed by Shiki.
  *
  * Hard-coded languages: `ansi` and plaintexts like `plaintext`, `txt`, `text`, `plain`.
  */
-declare function isSpecialLang(lang: any): lang is SpecialLanguage;
+export declare function isSpecialLang(lang: any): lang is SpecialLanguage;
 /**
  * Check if the theme is specially handled or bypassed by Shiki.
  *
  * Hard-coded themes: `none`.
  */
-declare function isNoneTheme(theme: string | ThemeInput | null | undefined): theme is 'none';
+export declare function isNoneTheme(theme: string | ThemeInput | null | undefined): theme is 'none';
 /**
  * Check if the theme is specially handled or bypassed by Shiki.
  *
  * Hard-coded themes: `none`.
  */
-declare function isSpecialTheme(theme: string | ThemeInput | null | undefined): theme is SpecialTheme;
+export declare function isSpecialTheme(theme: string | ThemeInput | null | undefined): theme is SpecialTheme;
 //#endregion
 //#region src/utils/strings.d.ts
-declare function splitLines(code: string, preserveEnding?: boolean): [string, number][];
+export declare function splitLines(code: string, preserveEnding?: boolean): [string, number][];
 //#endregion
 //#region src/utils/alias.d.ts
-declare function resolveLangAlias(name: string, alias?: Record<string, string>): string;
-//#endregion
-export { GrammarState, Registry, Resolver, alignThemesTokenization, applyColorReplacements, codeToTokensBase, codeToTokensWithThemes, createShikiInternal, createShikiInternalSync, createShikiPrimitive, createShikiPrimitiveAsync, getGrammarStack, getLastGrammarState, getLastGrammarStateFromMap, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeGetter, normalizeTheme, resolveColorReplacements, resolveLangAlias, resolveLangs, resolveThemes, setLastGrammarStateToMap, splitLines, toArray, tokenizeWithTheme };
+export declare function resolveLangAlias(name: string, alias?: Record<string, string>): string;
+//#endregion

package/node_modules/@pierre/diffs/node_modules/@shikijs/primitive/dist/index.mjs

@@ -287,6 +287,7 @@ var Registry = class extends Registry$1 {
 		});
 		this._loadedLanguagesCache = null;
 		if (embeddedLazilyBy.size) for (const e of embeddedLazilyBy) {
+			this._syncRegistry?._grammars?.get(e.scopeName)?.dispose();
 			this._resolvedGrammars.delete(e.name);
 			this._loadedLanguagesCache = null;
 			this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
@@ -358,7 +359,7 @@ var Resolver = class {
 		this._scopeToLang.set(l.scopeName, l);
 		if (l.injectTo) l.injectTo.forEach((i) => {
 			if (!this._injections.get(i)) this._injections.set(i, []);
-			this._injections.get(i).push(l.scopeName);
+			if (!this._injections.get(i).includes(l.scopeName)) this._injections.get(i).push(l.scopeName);
 		});
 	}
 	getInjections(scopeName) {