pi-umbra 0.1.5 → 0.2.0

package/README.md

@@ -1,33 +1,35 @@
 # pi-umbra
 
-Every small thing pi does not build in, in one install.
+Every pi-umbra package in one install: seven dark themes, tool calls drawn as cards, a
+status footer, an input bar with the session name, a working line that names the running
+tool, and the `/umb-*` commands.
+
+![Tool cards, the working line, a question from the model and the card settings](https://raw.githubusercontent.com/grknbyk/pi-umbra/main/assets/carousel.webp)
 
 ```sh
 pi install npm:pi-umbra
 ```
 
-One tarball. The nine packages below ship bundled inside it, so the install does not
-depend on npm hoisting nine separate trees into the layout pi expects.
+The nine packages ship bundled inside this one tarball. Two of them patch pi's bundle, so
+run both scripts once now and again after every pi update, then restart pi:
 
-```
-pi-umbra
-├── pi-umbra-theme          seven themes and the chrome around them
-├── pi-umbra-ask            the model asks you a question mid-turn
-├── pi-umbra-copy-chat      /umb-copy-chat
-├── pi-umbra-help           /umb-help, /umb-doctor
-├── pi-umbra-inputbar       the input box
-├── pi-umbra-preview        /umb-preview
-├── pi-umbra-rename         /umb-rename
-├── pi-umbra-shimmer        a shimmer through the working indicator
-└── pi-umbra-skill-matcher  skill completion mid-prompt
+```sh
+node ~/.pi/agent/npm/node_modules/pi-umbra/node_modules/pi-umbra-shimmer/patch.mjs
+node ~/.pi/agent/npm/node_modules/pi-umbra/node_modules/pi-umbra-skill-matcher/patch.mjs
 ```
 
-Install any of them on its own if you want less. Each package has its own README saying
-what it solves.
+| Package | What it adds |
+|---|---|
+| [pi-umbra-theme](https://www.npmjs.com/package/pi-umbra-theme) | seven themes, terminal background, footer, gutter, tool cards, working line |
+| [pi-umbra-inputbar](https://www.npmjs.com/package/pi-umbra-inputbar) | `❯` prompt, session name on the input border, `/umb-color` |
+| [pi-umbra-ask](https://www.npmjs.com/package/pi-umbra-ask) | a tool the model calls to ask you a question and wait |
+| [pi-umbra-shimmer](https://www.npmjs.com/package/pi-umbra-shimmer) | a wave of colour through the working line, `/umb-shimmer` |
+| [pi-umbra-skill-matcher](https://www.npmjs.com/package/pi-umbra-skill-matcher) | `/name` runs `skill:name`, completion mid-sentence |
+| [pi-umbra-rename](https://www.npmjs.com/package/pi-umbra-rename) | `/umb-rename`, session name and terminal title |
+| [pi-umbra-copy-chat](https://www.npmjs.com/package/pi-umbra-copy-chat) | `/umb-copy-chat`, the session on the clipboard |
+| [pi-umbra-preview](https://www.npmjs.com/package/pi-umbra-preview) | `/umb-preview`, render a document in the browser |
+| [pi-umbra-help](https://www.npmjs.com/package/pi-umbra-help) | `/umb-help` and `/umb-doctor` |
 
-`pi-umbra-shimmer` and `pi-umbra-skill-matcher` reach past what the extension API
-exposes, so each ships a `patch.mjs` that has to be run once after installing and again
-after every pi update. Their own READMEs carry the command. Until it is run, those two
-load and do nothing; the rest of the family is unaffected.
+Full documentation: [github.com/grknbyk/pi-umbra](https://github.com/grknbyk/pi-umbra).
 
 MIT.

package/node_modules/@shikijs/cli/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Pine Wu
+Copyright (c) 2023 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@shikijs/cli/README.md

@@ -0,0 +1,9 @@
+# shiki-cli
+
+Shiki in the command line.
+
+[Documentation](https://shiki.style/packages/cli)
+
+## License
+
+MIT

package/node_modules/@shikijs/cli/bin.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('./dist/cli.mjs')

package/node_modules/@shikijs/cli/dist/cli.d.mts

@@ -0,0 +1,10 @@
+//#region src/cli.d.ts
+declare function isUrl(path: string): boolean;
+declare function getExtFromUrl(url: string): string;
+declare function readSource(path: string): Promise<{
+  content: string;
+  ext: string;
+}>;
+declare function run(argv?: string[], log?: (...data: any[]) => void): Promise<void>;
+//#endregion
+export { getExtFromUrl, isUrl, readSource, run };

package/node_modules/@shikijs/cli/dist/cli.mjs

@@ -0,0 +1,85 @@
+import { t as codeToANSI } from "./code-to-ansi-BNrZay-4.mjs";
+import fs from "node:fs/promises";
+import { parse } from "node:path";
+import process from "node:process";
+import cac from "cac";
+//#region package.json
+var version = "4.4.3";
+//#endregion
+//#region src/cli.ts
+function isUrl(path) {
+	return path.startsWith("http://") || path.startsWith("https://");
+}
+function getExtFromUrl(url) {
+	try {
+		const pathname = new URL(url).pathname;
+		return parse(pathname).ext.slice(1).toLowerCase();
+	} catch {
+		return "";
+	}
+}
+async function readSource(path) {
+	if (isUrl(path)) {
+		const response = await fetch(path);
+		if (!response.ok) throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`);
+		return {
+			content: await response.text(),
+			ext: getExtFromUrl(path)
+		};
+	} else return {
+		content: await fs.readFile(path, "utf-8"),
+		ext: parse(path).ext.slice(1).toLowerCase()
+	};
+}
+async function run(argv = process.argv, log = console.log) {
+	const cli = cac("shiki");
+	cli.option("--theme <theme>", "Color theme to use", { default: "vitesse-dark" }).option("--lang <lang>", "Programming language").option("--format <format>", "Output format (ansi, html)", { default: "ansi" }).option("--list-themes", "List all available themes").option("--list-langs", "List all available languages").help().version(version);
+	const { options, args } = cli.parse(argv);
+	if (options.listThemes) {
+		const { bundledThemes } = await import("shiki");
+		for (const theme of Object.keys(bundledThemes)) log(theme);
+		return;
+	}
+	if (options.listLangs) {
+		const { bundledLanguages } = await import("shiki");
+		for (const lang of Object.keys(bundledLanguages)) log(lang);
+		return;
+	}
+	const files = args;
+	if (files.length === 0) {
+		if (!process.stdin.isTTY) {
+			const content = await new Promise((resolve, reject) => {
+				let data = "";
+				process.stdin.on("data", (chunk) => data += chunk);
+				process.stdin.on("end", () => resolve(data));
+				process.stdin.on("error", reject);
+			});
+			const lang = options.lang || "text";
+			if (options.format === "html") {
+				const { codeToHtml } = await import("shiki");
+				log(await codeToHtml(content, {
+					lang,
+					theme: options.theme
+				}));
+			} else log(await codeToANSI(content, lang, options.theme));
+			return;
+		}
+		cli.outputHelp();
+		return;
+	}
+	const codes = await Promise.all(files.map(async (path) => {
+		const { content, ext } = await readSource(path);
+		const lang = (options.lang || ext).toLowerCase();
+		if (options.format === "html") {
+			const { codeToHtml } = await import("shiki");
+			return await codeToHtml(content, {
+				lang,
+				theme: options.theme
+			});
+		} else return await codeToANSI(content, lang, options.theme);
+	}));
+	for (const code of codes) log(code);
+}
+run();
+//#endregion
+export { getExtFromUrl, isUrl, readSource, run };

package/node_modules/@shikijs/cli/dist/code-to-ansi-BNrZay-4.mjs

@@ -0,0 +1,64 @@
+import { FontStyle } from "@shikijs/vscode-textmate";
+import c from "ansis";
+import { codeToTokensBase, getSingletonHighlighter } from "shiki";
+//#region src/colors.ts
+const RE_HASH = /#/;
+function normalizeHex(hex) {
+	hex = hex.replace(RE_HASH, "");
+	if (hex.length === 3) hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+	if (hex.length === 4) hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2] + hex[3] + hex[3];
+	if (hex.length === 6) hex = `${hex}ff`;
+	return hex.toLowerCase();
+}
+function hexToRgba(hex) {
+	hex = normalizeHex(hex);
+	return {
+		r: Number.parseInt(hex.slice(0, 2), 16),
+		g: Number.parseInt(hex.slice(2, 4), 16),
+		b: Number.parseInt(hex.slice(4, 6), 16),
+		a: Number.parseInt(hex.slice(6, 8), 16) / 255
+	};
+}
+function RgbToHex(r, g, b) {
+	return [
+		r,
+		g,
+		b
+	].map((x) => {
+		const hex = x.toString(16);
+		return hex.length === 1 ? `0${hex}` : hex;
+	}).join("");
+}
+function hexApplyAlpha(hex, type = "dark") {
+	const { r, g, b, a } = hexToRgba(hex);
+	if (type === "dark") return RgbToHex(r * a, g * a, b * a);
+	else return RgbToHex(r * a + 255 * (1 - a), g * a + 255 * (1 - a), b * a + 255 * (1 - a));
+}
+//#endregion
+//#region src/code-to-ansi.ts
+async function codeToANSI(code, lang, theme) {
+	let output = "";
+	const lines = await codeToTokensBase(code, {
+		lang,
+		theme
+	});
+	const themeReg = (await getSingletonHighlighter()).getTheme(theme);
+	for (const line of lines) {
+		for (const token of line) {
+			let text = token.content;
+			const color = token.color || themeReg.fg;
+			if (color) text = c.hex(hexApplyAlpha(color, themeReg.type))(text);
+			if (token.fontStyle) {
+				if (token.fontStyle & FontStyle.Bold) text = c.bold(text);
+				if (token.fontStyle & FontStyle.Italic) text = c.italic(text);
+				if (token.fontStyle & FontStyle.Underline) text = c.underline(text);
+				if (token.fontStyle & FontStyle.Strikethrough) text = c.strikethrough(text);
+			}
+			output += text;
+		}
+		output += "\n";
+	}
+	return output;
+}
+//#endregion
+export { codeToANSI as t };

package/node_modules/@shikijs/cli/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { BundledLanguage, BundledTheme } from "shiki";
+//#region src/code-to-ansi.d.ts
+declare function codeToANSI(code: string, lang: BundledLanguage, theme: BundledTheme): Promise<string>;
+//#endregion
+export { codeToANSI };

package/node_modules/@shikijs/cli/dist/index.mjs

@@ -0,0 +1,2 @@
+import { t as codeToANSI } from "./code-to-ansi-BNrZay-4.mjs";
+export { codeToANSI };

package/node_modules/@shikijs/cli/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@shikijs/cli",
+  "type": "module",
+  "version": "4.4.3",
+  "description": "Shiki in the command line",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/shikijs/shiki#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shikijs/shiki.git",
+    "directory": "packages/cli"
+  },
+  "bugs": "https://github.com/shikijs/shiki/issues",
+  "keywords": [
+    "shiki",
+    "shiki",
+    "cli"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "shiki": "bin.mjs",
+    "shiki-cli": "bin.mjs",
+    "@shikijs/cli": "bin.mjs",
+    "skat": "bin.mjs"
+  },
+  "files": [
+    "bin.mjs",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@shikijs/vscode-textmate": "^10.0.2",
+    "ansis": "^4.3.1",
+    "cac": "^7.0.0",
+    "shiki": "4.4.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  }
+}

package/node_modules/@shikijs/core/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Pine Wu
+Copyright (c) 2023 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@shikijs/core/README.md

@@ -0,0 +1,5 @@
+# @shikijs/core
+
+The core functionality of [Shiki](https://github.com/shikijs/shiki), without any grammar of themes bundled.
+
+It's the same as importing `shiki/core`.

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

@@ -0,0 +1,227 @@
+import { Awaitable, BundledHighlighterOptions, CodeOptionsMultipleThemes, CodeToHastOptions, CodeToHastRenderOptions, CodeToTokensBaseOptions, CodeToTokensOptions, CodeToTokensWithThemesOptions, CreateBundledHighlighterOptions, CreateHighlighterFactory, GrammarState, HighlighterCore, HighlighterCoreOptions, HighlighterGeneric, Position, RequireKeys, ShikiPrimitive, ShikiTransformer, ShikiTransformerContextCommon, ShikiTransformerContextSource, ThemeRegistration, ThemeRegistrationResolved, ThemedToken, ThemedTokenWithVariants, TokenStyles, TokenizeWithThemeOptions, TokensResult } from "@shikijs/types";
+import { ShikiError, applyColorReplacements, codeToTokensWithThemes, createShikiInternal, createShikiInternalSync, createShikiPrimitive, createShikiPrimitiveAsync, getLastGrammarState, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, normalizeGetter, normalizeTheme, resolveColorReplacements, splitLines, toArray, tokenizeWithTheme } from "@shikijs/primitive";
+import { toHtml } from "hast-util-to-html";
+import { Element, Root } from "hast";
+export * from "@shikijs/types";
+//#region src/constructors/bundle-factory.d.ts
+/**
+ * Create a `createHighlighter` function with bundled themes, languages, and engine.
+ *
+ * @example
+ * ```ts
+ * const createHighlighter = createBundledHighlighter({
+ *   langs: {
+ *     typescript: () => import('@shikijs/langs/typescript'),
+ *     // ...
+ *   },
+ *   themes: {
+ *     nord: () => import('@shikijs/themes/nord'),
+ *     // ...
+ *   },
+ *   engine: () => createOnigurumaEngine(), // or createJavaScriptRegexEngine()
+ * })
+ * ```
+ *
+ * @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> {
+  /**
+   * Shorthand for `codeToHtml` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToHtml()`, this function is async.
+   */
+  codeToHtml: (code: string, options: CodeToHastOptions<L, T>) => Promise<string>;
+  /**
+   * Shorthand for `codeToHtml` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToHtml()`, this function is async.
+   */
+  codeToHast: (code: string, options: CodeToHastOptions<L, T>) => Promise<Root>;
+  /**
+   * Shorthand for `codeToTokens` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToTokens()`, this function is async.
+   */
+  codeToTokens: (code: string, options: CodeToTokensOptions<L, T>) => Promise<TokensResult>;
+  /**
+   * Shorthand for `codeToTokensBase` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToTokensBase()`, this function is async.
+   */
+  codeToTokensBase: (code: string, options: RequireKeys<CodeToTokensBaseOptions<L, T>, 'theme' | 'lang'>) => Promise<ThemedToken[][]>;
+  /**
+   * Shorthand for `codeToTokensWithThemes` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   *
+   * Differences from `highlighter.codeToTokensWithThemes()`, this function is async.
+   */
+  codeToTokensWithThemes: (code: string, options: RequireKeys<CodeToTokensWithThemesOptions<L, T>, 'themes' | 'lang'>) => Promise<ThemedTokenWithVariants[][]>;
+  /**
+   * Get the singleton highlighter.
+   */
+  getSingletonHighlighter: (options?: Partial<BundledHighlighterOptions<L, T>>) => Promise<HighlighterGeneric<L, T>>;
+  /**
+   * Shorthand for `getLastGrammarState` with auto-loaded theme and language.
+   * A singleton highlighter it maintained internally.
+   */
+  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> {
+  /**
+   * 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>;
+//#endregion
+//#region src/constructors/highlighter.d.ts
+/**
+ * Create a Shiki core highlighter instance, with no languages or themes bundled.
+ * Wasm and each language and theme must be loaded manually.
+ *
+ * @see http://shiki.style/guide/bundles#fine-grained-bundle
+ */
+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.
+ *
+ * Synchronous version of `createHighlighterCore`, which requires to provide the engine and all themes and languages upfront.
+ *
+ * @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>;
+//#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;
+//#endregion
+//#region src/highlight/code-to-html.d.ts
+declare const hastToHtml: typeof toHtml;
+/**
+ * Get highlighted code in HTML.
+ */
+declare function codeToHtml(primitive: ShikiPrimitive, code: string, options: CodeToHastOptions): string;
+//#endregion
+//#region src/highlight/code-to-tokens.d.ts
+/**
+ * High-level code-to-tokens API.
+ *
+ * It will use `codeToTokensWithThemes` or `codeToTokensBase` based on the options.
+ */
+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[][];
+//#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[][];
+//#endregion
+//#region src/theme-css-variables.d.ts
+interface CssVariablesThemeOptions {
+  /**
+   * Theme name. Need to unique if multiple css variables themes are created
+   *
+   * @default 'css-variables'
+   */
+  name?: string;
+  /**
+   * Prefix for css variables
+   *
+   * @default '--shiki-'
+   */
+  variablePrefix?: string;
+  /**
+   * Default value for css variables, the key is without the prefix
+   *
+   * @example `{ 'token-comment': '#888' }` will generate `var(--shiki-token-comment, #888)` for comments
+   */
+  variableDefaults?: Record<string, string>;
+  /**
+   * Enable font style
+   *
+   * @default true
+   */
+  fontStyle?: boolean;
+}
+/**
+ * A factory function to create a css-variable-based theme
+ *
+ * @see https://shiki.style/guide/theme-colors#css-variables-theme
+ */
+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;
+//#endregion
+//#region src/utils/hast.d.ts
+/**
+ * Utility to append class to a hast node
+ *
+ * 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;
+//#endregion
+//#region src/utils/strings.d.ts
+/**
+ * Creates a converter between index and position in a code block.
+ *
+ * Overflow/underflow are unchecked.
+ */
+declare function createPositionConverter(code: string): {
+  lines: string[];
+  indexToPos: (index: number) => Position;
+  posToIndex: (line: number, character: number) => number;
+};
+/**
+ * Guess embedded languages from given code and highlighter.
+ *
+ * When highlighter is provided, only bundled languages will be included.
+ *
+ * @param code - The code string to analyze
+ * @param _lang - The primary language of the code (currently unused)
+ * @param highlighter - Optional highlighter instance to validate languages
+ * @returns Array of detected language identifiers
+ *
+ * @example
+ * ```ts
+ * // Detects 'javascript' from Vue SFC
+ * guessEmbeddedLanguages('<script lang="javascript">')
+ *
+ * // Detects 'python' from markdown code block
+ * guessEmbeddedLanguages('```python\nprint("hi")\n```')
+ * ```
+ */
+declare function guessEmbeddedLanguages(code: string, _lang: string | undefined, highlighter?: HighlighterGeneric<any, any>): string[];
+//#endregion
+//#region src/utils/tokens.d.ts
+/**
+ * Split a token into multiple tokens by given offsets.
+ *
+ * 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[];
+/**
+ * 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;
+//#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 };