@shikijs/core 1.15.2 → 1.16.1

package/dist/index.mjs

@@ -1,5 +1,6 @@
-import { INITIAL, StackElementMetadata, Registry as Registry$1, Theme } from './textmate.mjs';
 import { FontStyle } from './types.mjs';
+import { INITIAL, EncodedTokenMetadata, Registry as Registry$1, Theme } from '@shikijs/vscode-textmate';
+export { EncodedTokenMetadata as StackElementMetadata } from '@shikijs/vscode-textmate';
 
 function toArray(x) {
     return Array.isArray(x) ? x : [x];
@@ -121,6 +122,12 @@ function splitTokens(tokens, breakpoints) {
         });
     });
 }
+/**
+ * Normalize a getter to a promise.
+ */
+async function normalizeGetter(p) {
+    return Promise.resolve(typeof p === 'function' ? p() : p).then(r => r.default || r);
+}
 function resolveColorReplacements(theme, options) {
     const replacements = typeof theme === 'string' ? {} : { ...theme.colorReplacements };
     const themeName = typeof theme === 'string' ? theme : theme.name;
@@ -194,6 +201,248 @@ function createPositionConverter(code) {
     };
 }
 
+class ShikiError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ShikiError';
+    }
+}
+
+/**
+ * A built-in transformer to add decorations to the highlighted code.
+ */
+function transformerDecorations() {
+    const map = new WeakMap();
+    function getContext(shiki) {
+        if (!map.has(shiki.meta)) {
+            const converter = createPositionConverter(shiki.source);
+            function normalizePosition(p) {
+                if (typeof p === 'number') {
+                    if (p < 0 || p > shiki.source.length)
+                        throw new ShikiError(`Invalid decoration offset: ${p}. Code length: ${shiki.source.length}`);
+                    return {
+                        ...converter.indexToPos(p),
+                        offset: p,
+                    };
+                }
+                else {
+                    const line = converter.lines[p.line];
+                    if (line === undefined)
+                        throw new ShikiError(`Invalid decoration position ${JSON.stringify(p)}. Lines length: ${converter.lines.length}`);
+                    if (p.character < 0 || p.character > line.length)
+                        throw new ShikiError(`Invalid decoration position ${JSON.stringify(p)}. Line ${p.line} length: ${line.length}`);
+                    return {
+                        ...p,
+                        offset: converter.posToIndex(p.line, p.character),
+                    };
+                }
+            }
+            const decorations = (shiki.options.decorations || [])
+                .map((d) => ({
+                ...d,
+                start: normalizePosition(d.start),
+                end: normalizePosition(d.end),
+            }));
+            verifyIntersections(decorations);
+            map.set(shiki.meta, {
+                decorations,
+                converter,
+                source: shiki.source,
+            });
+        }
+        return map.get(shiki.meta);
+    }
+    return {
+        name: 'shiki:decorations',
+        tokens(tokens) {
+            if (!this.options.decorations?.length)
+                return;
+            const ctx = getContext(this);
+            const breakpoints = ctx.decorations.flatMap(d => [d.start.offset, d.end.offset]);
+            const splitted = splitTokens(tokens, breakpoints);
+            return splitted;
+        },
+        code(codeEl) {
+            if (!this.options.decorations?.length)
+                return;
+            const ctx = getContext(this);
+            const lines = Array.from(codeEl.children).filter(i => i.type === 'element' && i.tagName === 'span');
+            if (lines.length !== ctx.converter.lines.length)
+                throw new ShikiError(`Number of lines in code element (${lines.length}) does not match the number of lines in the source (${ctx.converter.lines.length}). Failed to apply decorations.`);
+            function applyLineSection(line, start, end, decoration) {
+                const lineEl = lines[line];
+                let text = '';
+                let startIndex = -1;
+                let endIndex = -1;
+                if (start === 0)
+                    startIndex = 0;
+                if (end === 0)
+                    endIndex = 0;
+                if (end === Number.POSITIVE_INFINITY)
+                    endIndex = lineEl.children.length;
+                if (startIndex === -1 || endIndex === -1) {
+                    for (let i = 0; i < lineEl.children.length; i++) {
+                        text += stringify$2(lineEl.children[i]);
+                        if (startIndex === -1 && text.length === start)
+                            startIndex = i + 1;
+                        if (endIndex === -1 && text.length === end)
+                            endIndex = i + 1;
+                    }
+                }
+                if (startIndex === -1)
+                    throw new ShikiError(`Failed to find start index for decoration ${JSON.stringify(decoration.start)}`);
+                if (endIndex === -1)
+                    throw new ShikiError(`Failed to find end index for decoration ${JSON.stringify(decoration.end)}`);
+                const children = lineEl.children.slice(startIndex, endIndex);
+                // Full line decoration
+                if (!decoration.alwaysWrap && children.length === lineEl.children.length) {
+                    applyDecoration(lineEl, decoration, 'line');
+                }
+                // Single token decoration
+                else if (!decoration.alwaysWrap && children.length === 1 && children[0].type === 'element') {
+                    applyDecoration(children[0], decoration, 'token');
+                }
+                // Create a wrapper for the decoration
+                else {
+                    const wrapper = {
+                        type: 'element',
+                        tagName: 'span',
+                        properties: {},
+                        children,
+                    };
+                    applyDecoration(wrapper, decoration, 'wrapper');
+                    lineEl.children.splice(startIndex, children.length, wrapper);
+                }
+            }
+            function applyLine(line, decoration) {
+                lines[line] = applyDecoration(lines[line], decoration, 'line');
+            }
+            function applyDecoration(el, decoration, type) {
+                const properties = decoration.properties || {};
+                const transform = decoration.transform || (i => i);
+                el.tagName = decoration.tagName || 'span';
+                el.properties = {
+                    ...el.properties,
+                    ...properties,
+                    class: el.properties.class,
+                };
+                if (decoration.properties?.class)
+                    addClassToHast(el, decoration.properties.class);
+                el = transform(el, type) || el;
+                return el;
+            }
+            const lineApplies = [];
+            // Apply decorations in reverse order so the nested ones get applied first.
+            const sorted = ctx.decorations.sort((a, b) => b.start.offset - a.start.offset);
+            for (const decoration of sorted) {
+                const { start, end } = decoration;
+                if (start.line === end.line) {
+                    applyLineSection(start.line, start.character, end.character, decoration);
+                }
+                else if (start.line < end.line) {
+                    applyLineSection(start.line, start.character, Number.POSITIVE_INFINITY, decoration);
+                    for (let i = start.line + 1; i < end.line; i++)
+                        lineApplies.unshift(() => applyLine(i, decoration));
+                    applyLineSection(end.line, 0, end.character, decoration);
+                }
+            }
+            lineApplies.forEach(i => i());
+        },
+    };
+}
+function verifyIntersections(items) {
+    for (let i = 0; i < items.length; i++) {
+        const foo = items[i];
+        if (foo.start.offset > foo.end.offset)
+            throw new ShikiError(`Invalid decoration range: ${JSON.stringify(foo.start)} - ${JSON.stringify(foo.end)}`);
+        for (let j = i + 1; j < items.length; j++) {
+            const bar = items[j];
+            const isFooHasBarStart = foo.start.offset < bar.start.offset && bar.start.offset < foo.end.offset;
+            const isFooHasBarEnd = foo.start.offset < bar.end.offset && bar.end.offset < foo.end.offset;
+            const isBarHasFooStart = bar.start.offset < foo.start.offset && foo.start.offset < bar.end.offset;
+            const isBarHasFooEnd = bar.start.offset < foo.end.offset && foo.end.offset < bar.end.offset;
+            if (isFooHasBarStart || isFooHasBarEnd || isBarHasFooStart || isBarHasFooEnd) {
+                if (isFooHasBarEnd && isFooHasBarEnd)
+                    continue; // nested
+                if (isBarHasFooStart && isBarHasFooEnd)
+                    continue; // nested
+                throw new ShikiError(`Decorations ${JSON.stringify(foo.start)} and ${JSON.stringify(bar.start)} intersect.`);
+            }
+        }
+    }
+}
+function stringify$2(el) {
+    if (el.type === 'text')
+        return el.value;
+    if (el.type === 'element')
+        return el.children.map(stringify$2).join('');
+    return '';
+}
+
+const builtInTransformers = [
+    /* @__PURE__ */ transformerDecorations(),
+];
+function getTransformers(options) {
+    return [
+        ...options.transformers || [],
+        ...builtInTransformers,
+    ];
+}
+
+/**
+ * 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.
+ */
+class GrammarState {
+    _stack;
+    lang;
+    theme;
+    /**
+     * Static method to create a initial grammar state.
+     */
+    static initial(lang, theme) {
+        return new GrammarState(INITIAL, lang, theme);
+    }
+    constructor(_stack, lang, theme) {
+        this._stack = _stack;
+        this.lang = lang;
+        this.theme = theme;
+    }
+    get scopes() {
+        return getScopes(this._stack);
+    }
+    toJSON() {
+        return {
+            lang: this.lang,
+            theme: this.theme,
+            scopes: this.scopes,
+        };
+    }
+}
+function getScopes(stack) {
+    const scopes = [];
+    const visited = new Set();
+    function pushScope(stack) {
+        if (visited.has(stack))
+            return;
+        visited.add(stack);
+        const name = stack?.nameScopesList?.scopeName;
+        if (name)
+            scopes.push(name);
+        if (stack.parent)
+            pushScope(stack.parent);
+    }
+    pushScope(stack);
+    return scopes;
+}
+function getGrammarStack(state) {
+    if (!(state instanceof GrammarState))
+        throw new ShikiError('Invalid grammar state');
+    // @ts-expect-error _stack is private
+    return state._stack;
+}
+
 // src/colors.ts
 var namedColors = [
   "black",
@@ -525,67 +774,9 @@ function dimColor(color) {
     return color;
 }
 
-class ShikiError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ShikiError';
-    }
-}
-
-/**
- * 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.
- */
-class GrammarState {
-    _stack;
-    lang;
-    theme;
-    /**
-     * Static method to create a initial grammar state.
-     */
-    static initial(lang, theme) {
-        return new GrammarState(INITIAL, lang, theme);
-    }
-    constructor(_stack, lang, theme) {
-        this._stack = _stack;
-        this.lang = lang;
-        this.theme = theme;
-    }
-    get scopes() {
-        return getScopes(this._stack);
-    }
-    toJSON() {
-        return {
-            lang: this.lang,
-            theme: this.theme,
-            scopes: this.scopes,
-        };
-    }
-}
-function getScopes(stack) {
-    const scopes = [];
-    const visited = new Set();
-    function pushScope(stack) {
-        if (visited.has(stack))
-            return;
-        visited.add(stack);
-        const name = stack?.nameScopesList?.scopeName;
-        if (name)
-            scopes.push(name);
-        if (stack.parent)
-            pushScope(stack.parent);
-    }
-    pushScope(stack);
-    return scopes;
-}
-function getGrammarStack(state) {
-    if (!(state instanceof GrammarState))
-        throw new ShikiError('Invalid grammar state');
-    // @ts-expect-error _stack is private
-    return state._stack;
-}
-
+/* ---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *-------------------------------------------------------- */
 /**
  * Code to tokens, with a simple theme.
  */
@@ -669,8 +860,8 @@ function _tokenizeWithTheme(code, grammar, theme, colorMap, options) {
             if (startIndex === nextStartIndex)
                 continue;
             const metadata = result.tokens[2 * j + 1];
-            const color = applyColorReplacements(colorMap[StackElementMetadata.getForeground(metadata)], colorReplacements);
-            const fontStyle = StackElementMetadata.getFontStyle(metadata);
+            const color = applyColorReplacements(colorMap[EncodedTokenMetadata.getForeground(metadata)], colorReplacements);
+            const fontStyle = EncodedTokenMetadata.getFontStyle(metadata);
             const token = {
                 content: line.substring(startIndex, nextStartIndex),
                 offset: lineOffset + startIndex,
@@ -934,187 +1125,6 @@ function mergeToken(merged, variantsOrder, cssVariablePrefix, defaultColor) {
     return token;
 }
 
-/**
- * A built-in transformer to add decorations to the highlighted code.
- */
-function transformerDecorations() {
-    const map = new WeakMap();
-    function getContext(shiki) {
-        if (!map.has(shiki.meta)) {
-            const converter = createPositionConverter(shiki.source);
-            function normalizePosition(p) {
-                if (typeof p === 'number') {
-                    if (p < 0 || p > shiki.source.length)
-                        throw new ShikiError(`Invalid decoration offset: ${p}. Code length: ${shiki.source.length}`);
-                    return {
-                        ...converter.indexToPos(p),
-                        offset: p,
-                    };
-                }
-                else {
-                    const line = converter.lines[p.line];
-                    if (line === undefined)
-                        throw new ShikiError(`Invalid decoration position ${JSON.stringify(p)}. Lines length: ${converter.lines.length}`);
-                    if (p.character < 0 || p.character > line.length)
-                        throw new ShikiError(`Invalid decoration position ${JSON.stringify(p)}. Line ${p.line} length: ${line.length}`);
-                    return {
-                        ...p,
-                        offset: converter.posToIndex(p.line, p.character),
-                    };
-                }
-            }
-            const decorations = (shiki.options.decorations || [])
-                .map((d) => ({
-                ...d,
-                start: normalizePosition(d.start),
-                end: normalizePosition(d.end),
-            }));
-            verifyIntersections(decorations);
-            map.set(shiki.meta, {
-                decorations,
-                converter,
-                source: shiki.source,
-            });
-        }
-        return map.get(shiki.meta);
-    }
-    return {
-        name: 'shiki:decorations',
-        tokens(tokens) {
-            if (!this.options.decorations?.length)
-                return;
-            const ctx = getContext(this);
-            const breakpoints = ctx.decorations.flatMap(d => [d.start.offset, d.end.offset]);
-            const splitted = splitTokens(tokens, breakpoints);
-            return splitted;
-        },
-        code(codeEl) {
-            if (!this.options.decorations?.length)
-                return;
-            const ctx = getContext(this);
-            const lines = Array.from(codeEl.children).filter(i => i.type === 'element' && i.tagName === 'span');
-            if (lines.length !== ctx.converter.lines.length)
-                throw new ShikiError(`Number of lines in code element (${lines.length}) does not match the number of lines in the source (${ctx.converter.lines.length}). Failed to apply decorations.`);
-            function applyLineSection(line, start, end, decoration) {
-                const lineEl = lines[line];
-                let text = '';
-                let startIndex = -1;
-                let endIndex = -1;
-                if (start === 0)
-                    startIndex = 0;
-                if (end === 0)
-                    endIndex = 0;
-                if (end === Number.POSITIVE_INFINITY)
-                    endIndex = lineEl.children.length;
-                if (startIndex === -1 || endIndex === -1) {
-                    for (let i = 0; i < lineEl.children.length; i++) {
-                        text += stringify$2(lineEl.children[i]);
-                        if (startIndex === -1 && text.length === start)
-                            startIndex = i + 1;
-                        if (endIndex === -1 && text.length === end)
-                            endIndex = i + 1;
-                    }
-                }
-                if (startIndex === -1)
-                    throw new ShikiError(`Failed to find start index for decoration ${JSON.stringify(decoration.start)}`);
-                if (endIndex === -1)
-                    throw new ShikiError(`Failed to find end index for decoration ${JSON.stringify(decoration.end)}`);
-                const children = lineEl.children.slice(startIndex, endIndex);
-                // Full line decoration
-                if (!decoration.alwaysWrap && children.length === lineEl.children.length) {
-                    applyDecoration(lineEl, decoration, 'line');
-                }
-                // Single token decoration
-                else if (!decoration.alwaysWrap && children.length === 1 && children[0].type === 'element') {
-                    applyDecoration(children[0], decoration, 'token');
-                }
-                // Create a wrapper for the decoration
-                else {
-                    const wrapper = {
-                        type: 'element',
-                        tagName: 'span',
-                        properties: {},
-                        children,
-                    };
-                    applyDecoration(wrapper, decoration, 'wrapper');
-                    lineEl.children.splice(startIndex, children.length, wrapper);
-                }
-            }
-            function applyLine(line, decoration) {
-                lines[line] = applyDecoration(lines[line], decoration, 'line');
-            }
-            function applyDecoration(el, decoration, type) {
-                const properties = decoration.properties || {};
-                const transform = decoration.transform || (i => i);
-                el.tagName = decoration.tagName || 'span';
-                el.properties = {
-                    ...el.properties,
-                    ...properties,
-                    class: el.properties.class,
-                };
-                if (decoration.properties?.class)
-                    addClassToHast(el, decoration.properties.class);
-                el = transform(el, type) || el;
-                return el;
-            }
-            const lineApplies = [];
-            // Apply decorations in reverse order so the nested ones get applied first.
-            const sorted = ctx.decorations.sort((a, b) => b.start.offset - a.start.offset);
-            for (const decoration of sorted) {
-                const { start, end } = decoration;
-                if (start.line === end.line) {
-                    applyLineSection(start.line, start.character, end.character, decoration);
-                }
-                else if (start.line < end.line) {
-                    applyLineSection(start.line, start.character, Number.POSITIVE_INFINITY, decoration);
-                    for (let i = start.line + 1; i < end.line; i++)
-                        lineApplies.unshift(() => applyLine(i, decoration));
-                    applyLineSection(end.line, 0, end.character, decoration);
-                }
-            }
-            lineApplies.forEach(i => i());
-        },
-    };
-}
-function verifyIntersections(items) {
-    for (let i = 0; i < items.length; i++) {
-        const foo = items[i];
-        if (foo.start.offset > foo.end.offset)
-            throw new ShikiError(`Invalid decoration range: ${JSON.stringify(foo.start)} - ${JSON.stringify(foo.end)}`);
-        for (let j = i + 1; j < items.length; j++) {
-            const bar = items[j];
-            const isFooHasBarStart = foo.start.offset < bar.start.offset && bar.start.offset < foo.end.offset;
-            const isFooHasBarEnd = foo.start.offset < bar.end.offset && bar.end.offset < foo.end.offset;
-            const isBarHasFooStart = bar.start.offset < foo.start.offset && foo.start.offset < bar.end.offset;
-            const isBarHasFooEnd = bar.start.offset < foo.end.offset && foo.end.offset < bar.end.offset;
-            if (isFooHasBarStart || isFooHasBarEnd || isBarHasFooStart || isBarHasFooEnd) {
-                if (isFooHasBarEnd && isFooHasBarEnd)
-                    continue; // nested
-                if (isBarHasFooStart && isBarHasFooEnd)
-                    continue; // nested
-                throw new ShikiError(`Decorations ${JSON.stringify(foo.start)} and ${JSON.stringify(bar.start)} intersect.`);
-            }
-        }
-    }
-}
-function stringify$2(el) {
-    if (el.type === 'text')
-        return el.value;
-    if (el.type === 'element')
-        return el.children.map(stringify$2).join('');
-    return '';
-}
-
-const builtInTransformers = [
-    /* @__PURE__ */ transformerDecorations(),
-];
-function getTransformers(options) {
-    return [
-        ...options.transformers || [],
-        ...builtInTransformers,
-    ];
-}
-
 function codeToHast(internal, code, options, transformerContext = {
     meta: {},
     options,
@@ -4690,423 +4700,103 @@ function codeToHtml(internal, code, options) {
     return result;
 }
 
-/**
- * https://github.com/microsoft/vscode/blob/f7f05dee53fb33fe023db2e06e30a89d3094488f/src/vs/platform/theme/common/colorRegistry.ts#L258-L268
- */
-const VSCODE_FALLBACK_EDITOR_FG = { light: '#333333', dark: '#bbbbbb' };
-const VSCODE_FALLBACK_EDITOR_BG = { light: '#fffffe', dark: '#1e1e1e' };
-const RESOLVED_KEY = '__shiki_resolved';
-/**
- * Normalize a textmate theme to shiki theme
- */
-function normalizeTheme(rawTheme) {
-    // @ts-expect-error private field
-    if (rawTheme?.[RESOLVED_KEY])
-        return rawTheme;
-    const theme = {
-        ...rawTheme,
-    };
-    // Fallback settings
-    if (theme.tokenColors && !theme.settings) {
-        theme.settings = theme.tokenColors;
-        delete theme.tokenColors;
-    }
-    theme.type ||= 'dark';
-    theme.colorReplacements = { ...theme.colorReplacements };
-    theme.settings ||= [];
-    // Guess fg/bg colors
-    let { bg, fg } = theme;
-    if (!bg || !fg) {
-        /**
-         * First try:
-         * Theme might contain a global `tokenColor` without `name` or `scope`
-         * Used as default value for foreground/background
-         */
-        const globalSetting = theme.settings
-            ? theme.settings.find((s) => !s.name && !s.scope)
-            : undefined;
-        if (globalSetting?.settings?.foreground)
-            fg = globalSetting.settings.foreground;
-        if (globalSetting?.settings?.background)
-            bg = globalSetting.settings.background;
-        /**
-         * Second try:
-         * If there's no global `tokenColor` without `name` or `scope`
-         * Use `editor.foreground` and `editor.background`
-         */
-        if (!fg && theme?.colors?.['editor.foreground'])
-            fg = theme.colors['editor.foreground'];
-        if (!bg && theme?.colors?.['editor.background'])
-            bg = theme.colors['editor.background'];
-        /**
-         * Last try:
-         * If there's no fg/bg color specified in theme, use default
-         */
-        if (!fg)
-            fg = theme.type === 'light' ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;
-        if (!bg)
-            bg = theme.type === 'light' ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;
-        theme.fg = fg;
-        theme.bg = bg;
-    }
-    // Push a no-scope setting with fallback colors
-    if (!(theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope)) {
-        theme.settings.unshift({
-            settings: {
-                foreground: theme.fg,
-                background: theme.bg,
-            },
-        });
-    }
-    // Push non-hex colors to color replacements, as `vscode-textmate` doesn't support them
-    let replacementCount = 0;
-    const replacementMap = new Map();
-    function getReplacementColor(value) {
-        if (replacementMap.has(value))
-            return replacementMap.get(value);
-        replacementCount += 1;
-        const hex = `#${replacementCount.toString(16).padStart(8, '0').toLowerCase()}`;
-        if (theme.colorReplacements?.[`#${hex}`]) // already exists
-            return getReplacementColor(value);
-        replacementMap.set(value, hex);
-        return hex;
-    }
-    theme.settings = theme.settings.map((setting) => {
-        const replaceFg = setting.settings?.foreground && !setting.settings.foreground.startsWith('#');
-        const replaceBg = setting.settings?.background && !setting.settings.background.startsWith('#');
-        if (!replaceFg && !replaceBg)
-            return setting;
-        const clone = {
-            ...setting,
-            settings: {
-                ...setting.settings,
-            },
-        };
-        if (replaceFg) {
-            const replacement = getReplacementColor(setting.settings.foreground);
-            theme.colorReplacements[replacement] = setting.settings.foreground;
-            clone.settings.foreground = replacement;
-        }
-        if (replaceBg) {
-            const replacement = getReplacementColor(setting.settings.background);
-            theme.colorReplacements[replacement] = setting.settings.background;
-            clone.settings.background = replacement;
-        }
-        return clone;
-    });
-    for (const key of Object.keys(theme.colors || {})) {
-        // Only patch for known keys
-        if (key === 'editor.foreground' || key === 'editor.background' || key.startsWith('terminal.ansi')) {
-            if (!theme.colors[key]?.startsWith('#')) {
-                const replacement = getReplacementColor(theme.colors[key]);
-                theme.colorReplacements[replacement] = theme.colors[key];
-                theme.colors[key] = replacement;
-            }
-        }
-    }
-    Object.defineProperty(theme, RESOLVED_KEY, {
-        enumerable: false,
-        writable: false,
-        value: true,
-    });
-    return theme;
+function getHeapMax() {
+    return 2147483648;
 }
-
-class Registry extends Registry$1 {
-    _resolver;
-    _themes;
-    _langs;
-    _alias;
-    _resolvedThemes = new Map();
-    _resolvedGrammars = new Map();
-    _langMap = new Map();
-    _langGraph = new Map();
-    _textmateThemeCache = new WeakMap();
-    _loadedThemesCache = null;
-    _loadedLanguagesCache = null;
-    constructor(_resolver, _themes, _langs, _alias = {}) {
-        super(_resolver);
-        this._resolver = _resolver;
-        this._themes = _themes;
-        this._langs = _langs;
-        this._alias = _alias;
-        _themes.forEach(t => this.loadTheme(t));
-        _langs.forEach(l => this.loadLanguage(l));
+function _emscripten_get_now() {
+    return typeof performance !== 'undefined' ? performance.now() : Date.now();
+}
+const alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
+async function main(init) {
+    let wasmMemory;
+    let buffer;
+    const binding = {};
+    function updateGlobalBufferAndViews(buf) {
+        buffer = buf;
+        binding.HEAPU8 = new Uint8Array(buf);
+        binding.HEAPU32 = new Uint32Array(buf);
     }
-    getTheme(theme) {
-        if (typeof theme === 'string')
-            return this._resolvedThemes.get(theme);
-        else
-            return this.loadTheme(theme);
+    function _emscripten_memcpy_big(dest, src, num) {
+        binding.HEAPU8.copyWithin(dest, src, src + num);
     }
-    loadTheme(theme) {
-        const _theme = normalizeTheme(theme);
-        if (_theme.name) {
-            this._resolvedThemes.set(_theme.name, _theme);
-            // Reset cache
-            this._loadedThemesCache = null;
+    function emscripten_realloc_buffer(size) {
+        try {
+            wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
+            updateGlobalBufferAndViews(wasmMemory.buffer);
+            return 1;
         }
-        return _theme;
-    }
-    getLoadedThemes() {
-        if (!this._loadedThemesCache)
-            this._loadedThemesCache = [...this._resolvedThemes.keys()];
-        return this._loadedThemesCache;
+        catch { }
     }
-    // Override and re-implement this method to cache the textmate themes as `TextMateTheme.createFromRawTheme`
-    // is expensive. Themes can switch often especially for dual-theme support.
-    //
-    // The parent class also accepts `colorMap` as the second parameter, but since we don't use that,
-    // we omit here so it's easier to cache the themes.
-    setTheme(theme) {
-        let textmateTheme = this._textmateThemeCache.get(theme);
-        if (!textmateTheme) {
-            textmateTheme = Theme.createFromRawTheme(theme);
-            this._textmateThemeCache.set(theme, textmateTheme);
+    function _emscripten_resize_heap(requestedSize) {
+        const oldSize = binding.HEAPU8.length;
+        requestedSize = requestedSize >>> 0;
+        const maxHeapSize = getHeapMax();
+        if (requestedSize > maxHeapSize)
+            return false;
+        for (let cutDown = 1; cutDown <= 4; cutDown *= 2) {
+            let overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+            overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+            const newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+            const replacement = emscripten_realloc_buffer(newSize);
+            if (replacement)
+                return true;
         }
-        // @ts-expect-error Access private `_syncRegistry`, but should work in runtime
-        this._syncRegistry.setTheme(textmateTheme);
+        return false;
     }
-    getGrammar(name) {
-        if (this._alias[name]) {
-            const resolved = new Set([name]);
-            while (this._alias[name]) {
-                name = this._alias[name];
-                if (resolved.has(name))
-                    throw new ShikiError(`Circular alias \`${Array.from(resolved).join(' -> ')} -> ${name}\``);
-                resolved.add(name);
+    const UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
+    function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead = 1024) {
+        const endIdx = idx + maxBytesToRead;
+        let endPtr = idx;
+        while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+            ++endPtr;
+        if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+            return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+        }
+        let str = '';
+        while (idx < endPtr) {
+            let u0 = heapOrArray[idx++];
+            if (!(u0 & 128)) {
+                str += String.fromCharCode(u0);
+                continue;
+            }
+            const u1 = heapOrArray[idx++] & 63;
+            if ((u0 & 224) === 192) {
+                str += String.fromCharCode(((u0 & 31) << 6) | u1);
+                continue;
+            }
+            const u2 = heapOrArray[idx++] & 63;
+            if ((u0 & 240) === 224) {
+                u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+            }
+            else {
+                u0 = ((u0 & 7) << 18)
+                    | (u1 << 12)
+                    | (u2 << 6)
+                    | (heapOrArray[idx++] & 63);
+            }
+            if (u0 < 65536) {
+                str += String.fromCharCode(u0);
+            }
+            else {
+                const ch = u0 - 65536;
+                str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
             }
         }
-        return this._resolvedGrammars.get(name);
+        return str;
     }
-    async loadLanguage(lang) {
-        if (this.getGrammar(lang.name))
-            return;
-        const embeddedLazilyBy = new Set([...this._langMap.values()]
-            .filter(i => i.embeddedLangsLazy?.includes(lang.name)));
-        this._resolver.addLanguage(lang);
-        const grammarConfig = {
-            balancedBracketSelectors: lang.balancedBracketSelectors || ['*'],
-            unbalancedBracketSelectors: lang.unbalancedBracketSelectors || [],
-        };
-        // @ts-expect-error Private members, set this to override the previous grammar (that can be a stub)
-        this._syncRegistry._rawGrammars.set(lang.scopeName, lang);
-        const g = await this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);
-        g.name = lang.name;
-        this._resolvedGrammars.set(lang.name, g);
-        if (lang.aliases) {
-            lang.aliases.forEach((alias) => {
-                this._alias[alias] = lang.name;
-            });
-        }
-        // Reset cache
-        this._loadedLanguagesCache = null;
-        // If there is a language that embeds this language lazily, we need to reload it
-        if (embeddedLazilyBy.size) {
-            for (const e of embeddedLazilyBy) {
-                this._resolvedGrammars.delete(e.name);
-                // Reset cache
-                this._loadedLanguagesCache = null;
-                // @ts-expect-error clear cache
-                this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
-                // @ts-expect-error clear cache
-                this._syncRegistry?._grammars?.delete(e.scopeName);
-                await this.loadLanguage(this._langMap.get(e.name));
-            }
-        }
-    }
-    async init() {
-        this._themes.map(t => this.loadTheme(t));
-        await this.loadLanguages(this._langs);
-    }
-    dispose() {
-        super.dispose();
-        this._resolvedThemes.clear();
-        this._resolvedGrammars.clear();
-        this._langMap.clear();
-        this._langGraph.clear();
-        this._loadedThemesCache = null;
-    }
-    async loadLanguages(langs) {
-        for (const lang of langs)
-            this.resolveEmbeddedLanguages(lang);
-        const langsGraphArray = Array.from(this._langGraph.entries());
-        const missingLangs = langsGraphArray.filter(([_, lang]) => !lang);
-        if (missingLangs.length) {
-            const dependents = langsGraphArray
-                .filter(([_, lang]) => lang && lang.embeddedLangs?.some(l => missingLangs.map(([name]) => name).includes(l)))
-                .filter(lang => !missingLangs.includes(lang));
-            throw new ShikiError(`Missing languages ${missingLangs.map(([name]) => `\`${name}\``).join(', ')}, required by ${dependents.map(([name]) => `\`${name}\``).join(', ')}`);
-        }
-        for (const [_, lang] of langsGraphArray)
-            this._resolver.addLanguage(lang);
-        for (const [_, lang] of langsGraphArray)
-            await this.loadLanguage(lang);
-    }
-    getLoadedLanguages() {
-        if (!this._loadedLanguagesCache) {
-            this._loadedLanguagesCache = [
-                ...new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)]),
-            ];
-        }
-        return this._loadedLanguagesCache;
-    }
-    resolveEmbeddedLanguages(lang) {
-        this._langMap.set(lang.name, lang);
-        this._langGraph.set(lang.name, lang);
-        if (lang.embeddedLangs) {
-            for (const embeddedLang of lang.embeddedLangs)
-                this._langGraph.set(embeddedLang, this._langMap.get(embeddedLang));
-        }
-    }
-}
-
-class Resolver {
-    _langs = new Map();
-    _scopeToLang = new Map();
-    _injections = new Map();
-    _onigLibPromise;
-    constructor(onigLibPromise, langs) {
-        this._onigLibPromise = onigLibPromise
-            .then(engine => ({
-            createOnigScanner: patterns => engine.createScanner(patterns),
-            createOnigString: s => engine.createString(s),
-        }));
-        langs.forEach(i => this.addLanguage(i));
-    }
-    get onigLib() {
-        return this._onigLibPromise;
-    }
-    getLangRegistration(langIdOrAlias) {
-        return this._langs.get(langIdOrAlias);
-    }
-    async loadGrammar(scopeName) {
-        return this._scopeToLang.get(scopeName);
-    }
-    addLanguage(l) {
-        this._langs.set(l.name, l);
-        if (l.aliases) {
-            l.aliases.forEach((a) => {
-                this._langs.set(a, l);
-            });
-        }
-        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);
-            });
-        }
-    }
-    getInjections(scopeName) {
-        const scopeParts = scopeName.split('.');
-        let injections = [];
-        for (let i = 1; i <= scopeParts.length; i++) {
-            const subScopeName = scopeParts.slice(0, i).join('.');
-            injections = [...injections, ...(this._injections.get(subScopeName) || [])];
-        }
-        return injections;
-    }
-}
-
-function getHeapMax() {
-    return 2147483648;
-}
-function _emscripten_get_now() {
-    return typeof performance !== 'undefined' ? performance.now() : Date.now();
-}
-const alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
-async function main(init) {
-    let wasmMemory;
-    let buffer;
-    const binding = {};
-    function updateGlobalBufferAndViews(buf) {
-        buffer = buf;
-        binding.HEAPU8 = new Uint8Array(buf);
-        binding.HEAPU32 = new Uint32Array(buf);
-    }
-    function _emscripten_memcpy_big(dest, src, num) {
-        binding.HEAPU8.copyWithin(dest, src, src + num);
-    }
-    function emscripten_realloc_buffer(size) {
-        try {
-            wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
-            updateGlobalBufferAndViews(wasmMemory.buffer);
-            return 1;
-        }
-        catch { }
-    }
-    function _emscripten_resize_heap(requestedSize) {
-        const oldSize = binding.HEAPU8.length;
-        requestedSize = requestedSize >>> 0;
-        const maxHeapSize = getHeapMax();
-        if (requestedSize > maxHeapSize)
-            return false;
-        for (let cutDown = 1; cutDown <= 4; cutDown *= 2) {
-            let overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
-            overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
-            const newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
-            const replacement = emscripten_realloc_buffer(newSize);
-            if (replacement)
-                return true;
-        }
-        return false;
-    }
-    const UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
-    function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead = 1024) {
-        const endIdx = idx + maxBytesToRead;
-        let endPtr = idx;
-        while (heapOrArray[endPtr] && !(endPtr >= endIdx))
-            ++endPtr;
-        if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-            return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-        }
-        let str = '';
-        while (idx < endPtr) {
-            let u0 = heapOrArray[idx++];
-            if (!(u0 & 128)) {
-                str += String.fromCharCode(u0);
-                continue;
-            }
-            const u1 = heapOrArray[idx++] & 63;
-            if ((u0 & 224) === 192) {
-                str += String.fromCharCode(((u0 & 31) << 6) | u1);
-                continue;
-            }
-            const u2 = heapOrArray[idx++] & 63;
-            if ((u0 & 240) === 224) {
-                u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
-            }
-            else {
-                u0 = ((u0 & 7) << 18)
-                    | (u1 << 12)
-                    | (u2 << 6)
-                    | (heapOrArray[idx++] & 63);
-            }
-            if (u0 < 65536) {
-                str += String.fromCharCode(u0);
-            }
-            else {
-                const ch = u0 - 65536;
-                str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
-            }
-        }
-        return str;
-    }
-    function UTF8ToString(ptr, maxBytesToRead) {
-        return ptr ? UTF8ArrayToString(binding.HEAPU8, ptr, maxBytesToRead) : '';
-    }
-    const asmLibraryArg = {
-        emscripten_get_now: _emscripten_get_now,
-        emscripten_memcpy_big: _emscripten_memcpy_big,
-        emscripten_resize_heap: _emscripten_resize_heap,
-        fd_write: () => 0,
-    };
-    async function createWasm() {
-        const info = {
-            env: asmLibraryArg,
-            wasi_snapshot_preview1: asmLibraryArg,
+    function UTF8ToString(ptr, maxBytesToRead) {
+        return ptr ? UTF8ArrayToString(binding.HEAPU8, ptr, maxBytesToRead) : '';
+    }
+    const asmLibraryArg = {
+        emscripten_get_now: _emscripten_get_now,
+        emscripten_memcpy_big: _emscripten_memcpy_big,
+        emscripten_resize_heap: _emscripten_resize_heap,
+        fd_write: () => 0,
+    };
+    async function createWasm() {
+        const info = {
+            env: asmLibraryArg,
+            wasi_snapshot_preview1: asmLibraryArg,
         };
         const exports = await init(info);
         wasmMemory = exports.memory;
@@ -5241,284 +4931,599 @@ class UtfString {
         this.utf16OffsetToUtf8 = utf16OffsetToUtf8;
         this.utf8OffsetToUtf16 = utf8OffsetToUtf16;
     }
-    createString(onigBinding) {
-        const result = onigBinding.omalloc(this.utf8Length);
-        onigBinding.HEAPU8.set(this.utf8Value, result);
-        return result;
+    createString(onigBinding) {
+        const result = onigBinding.omalloc(this.utf8Length);
+        onigBinding.HEAPU8.set(this.utf8Value, result);
+        return result;
+    }
+}
+class OnigString {
+    static LAST_ID = 0;
+    static _sharedPtr = 0; // a pointer to a string of 10000 bytes
+    static _sharedPtrInUse = false;
+    id = (++OnigString.LAST_ID);
+    _onigBinding;
+    content;
+    utf16Length;
+    utf8Length;
+    utf16OffsetToUtf8;
+    utf8OffsetToUtf16;
+    ptr;
+    constructor(str) {
+        if (!onigBinding)
+            throw new ShikiError('Must invoke loadWasm first.');
+        this._onigBinding = onigBinding;
+        this.content = str;
+        const utfString = new UtfString(str);
+        this.utf16Length = utfString.utf16Length;
+        this.utf8Length = utfString.utf8Length;
+        this.utf16OffsetToUtf8 = utfString.utf16OffsetToUtf8;
+        this.utf8OffsetToUtf16 = utfString.utf8OffsetToUtf16;
+        if (this.utf8Length < 10000 && !OnigString._sharedPtrInUse) {
+            if (!OnigString._sharedPtr)
+                OnigString._sharedPtr = onigBinding.omalloc(10000);
+            OnigString._sharedPtrInUse = true;
+            onigBinding.HEAPU8.set(utfString.utf8Value, OnigString._sharedPtr);
+            this.ptr = OnigString._sharedPtr;
+        }
+        else {
+            this.ptr = utfString.createString(onigBinding);
+        }
+    }
+    convertUtf8OffsetToUtf16(utf8Offset) {
+        if (this.utf8OffsetToUtf16) {
+            if (utf8Offset < 0)
+                return 0;
+            if (utf8Offset > this.utf8Length)
+                return this.utf16Length;
+            return this.utf8OffsetToUtf16[utf8Offset];
+        }
+        return utf8Offset;
+    }
+    convertUtf16OffsetToUtf8(utf16Offset) {
+        if (this.utf16OffsetToUtf8) {
+            if (utf16Offset < 0)
+                return 0;
+            if (utf16Offset > this.utf16Length)
+                return this.utf8Length;
+            return this.utf16OffsetToUtf8[utf16Offset];
+        }
+        return utf16Offset;
+    }
+    dispose() {
+        if (this.ptr === OnigString._sharedPtr)
+            OnigString._sharedPtrInUse = false;
+        else
+            this._onigBinding.ofree(this.ptr);
+    }
+}
+class OnigScanner {
+    _onigBinding;
+    _ptr;
+    constructor(patterns) {
+        if (!onigBinding)
+            throw new ShikiError('Must invoke loadWasm first.');
+        const strPtrsArr = [];
+        const strLenArr = [];
+        for (let i = 0, len = patterns.length; i < len; i++) {
+            const utfString = new UtfString(patterns[i]);
+            strPtrsArr[i] = utfString.createString(onigBinding);
+            strLenArr[i] = utfString.utf8Length;
+        }
+        const strPtrsPtr = onigBinding.omalloc(4 * patterns.length);
+        onigBinding.HEAPU32.set(strPtrsArr, strPtrsPtr / 4);
+        const strLenPtr = onigBinding.omalloc(4 * patterns.length);
+        onigBinding.HEAPU32.set(strLenArr, strLenPtr / 4);
+        const scannerPtr = onigBinding.createOnigScanner(strPtrsPtr, strLenPtr, patterns.length);
+        for (let i = 0, len = patterns.length; i < len; i++)
+            onigBinding.ofree(strPtrsArr[i]);
+        onigBinding.ofree(strLenPtr);
+        onigBinding.ofree(strPtrsPtr);
+        if (scannerPtr === 0)
+            throwLastOnigError(onigBinding);
+        this._onigBinding = onigBinding;
+        this._ptr = scannerPtr;
+    }
+    dispose() {
+        this._onigBinding.freeOnigScanner(this._ptr);
+    }
+    findNextMatchSync(string, startPosition, arg) {
+        // let debugCall = defaultDebugCall
+        let options = 0 /* FindOption.None */;
+        if (typeof arg === 'number') {
+            // if (arg & FindOption.DebugCall)
+            //   debugCall = true
+            options = arg;
+        }
+        if (typeof string === 'string') {
+            string = new OnigString(string);
+            const result = this._findNextMatchSync(string, startPosition, false, options);
+            string.dispose();
+            return result;
+        }
+        return this._findNextMatchSync(string, startPosition, false, options);
+    }
+    _findNextMatchSync(string, startPosition, debugCall, options) {
+        const onigBinding = this._onigBinding;
+        // let resultPtr: Pointer
+        // if (debugCall)
+        //   resultPtr = onigBinding.findNextOnigScannerMatchDbg(this._ptr, string.id, string.ptr, string.utf8Length, string.convertUtf16OffsetToUtf8(startPosition), options)
+        // else
+        const resultPtr = onigBinding.findNextOnigScannerMatch(this._ptr, string.id, string.ptr, string.utf8Length, string.convertUtf16OffsetToUtf8(startPosition), options);
+        if (resultPtr === 0) {
+            // no match
+            return null;
+        }
+        const HEAPU32 = onigBinding.HEAPU32;
+        let offset = resultPtr / 4; // byte offset -> uint32 offset
+        const index = HEAPU32[offset++];
+        const count = HEAPU32[offset++];
+        const captureIndices = [];
+        for (let i = 0; i < count; i++) {
+            const beg = string.convertUtf8OffsetToUtf16(HEAPU32[offset++]);
+            const end = string.convertUtf8OffsetToUtf16(HEAPU32[offset++]);
+            captureIndices[i] = {
+                start: beg,
+                end,
+                length: end - beg,
+            };
+        }
+        return {
+            index,
+            captureIndices,
+        };
+    }
+}
+function isInstantiatorOptionsObject(dataOrOptions) {
+    return (typeof dataOrOptions.instantiator === 'function');
+}
+function isInstantiatorModule(dataOrOptions) {
+    return (typeof dataOrOptions.default === 'function');
+}
+function isDataOptionsObject(dataOrOptions) {
+    return (typeof dataOrOptions.data !== 'undefined');
+}
+function isResponse(dataOrOptions) {
+    return (typeof Response !== 'undefined' && dataOrOptions instanceof Response);
+}
+function isArrayBuffer(data) {
+    return (typeof ArrayBuffer !== 'undefined' && (data instanceof ArrayBuffer || ArrayBuffer.isView(data)))
+        // eslint-disable-next-line node/prefer-global/buffer
+        || (typeof Buffer !== 'undefined' && Buffer.isBuffer?.(data))
+        || (typeof SharedArrayBuffer !== 'undefined' && data instanceof SharedArrayBuffer)
+        || (typeof Uint32Array !== 'undefined' && data instanceof Uint32Array);
+}
+let initPromise;
+function loadWasm(options) {
+    if (initPromise)
+        return initPromise;
+    async function _load() {
+        onigBinding = await main(async (info) => {
+            let instance = options;
+            instance = await instance;
+            if (typeof instance === 'function')
+                instance = await instance(info);
+            if (typeof instance === 'function')
+                instance = await instance(info);
+            if (isInstantiatorOptionsObject(instance)) {
+                instance = await instance.instantiator(info);
+            }
+            else if (isInstantiatorModule(instance)) {
+                instance = await instance.default(info);
+            }
+            else {
+                if (isDataOptionsObject(instance))
+                    instance = instance.data;
+                if (isResponse(instance)) {
+                    if (typeof WebAssembly.instantiateStreaming === 'function')
+                        instance = await _makeResponseStreamingLoader(instance)(info);
+                    else
+                        instance = await _makeResponseNonStreamingLoader(instance)(info);
+                }
+                else if (isArrayBuffer(instance)) {
+                    instance = await _makeArrayBufferLoader(instance)(info);
+                }
+                // import("shiki/onig.wasm") returns `{ default: WebAssembly.Module }` on cloudflare workers
+                // https://developers.cloudflare.com/workers/wrangler/bundling/
+                else if (instance instanceof WebAssembly.Module) {
+                    instance = await _makeArrayBufferLoader(instance)(info);
+                }
+                else if ('default' in instance && instance.default instanceof WebAssembly.Module) {
+                    instance = await _makeArrayBufferLoader(instance.default)(info);
+                }
+            }
+            if ('instance' in instance)
+                instance = instance.instance;
+            if ('exports' in instance)
+                instance = instance.exports;
+            return instance;
+        });
+    }
+    initPromise = _load();
+    return initPromise;
+}
+function _makeArrayBufferLoader(data) {
+    return importObject => WebAssembly.instantiate(data, importObject);
+}
+function _makeResponseStreamingLoader(data) {
+    return importObject => WebAssembly.instantiateStreaming(data, importObject);
+}
+function _makeResponseNonStreamingLoader(data) {
+    return async (importObject) => {
+        const arrayBuffer = await data.arrayBuffer();
+        return WebAssembly.instantiate(arrayBuffer, importObject);
+    };
+}
+// export function createOnigString(str: string) {
+//   return new OnigString(str)
+// }
+// export function createOnigScanner(patterns: string[]) {
+//   return new OnigScanner(patterns)
+// }
+// export function setDefaultDebugCall(_defaultDebugCall: boolean): void {
+//   defaultDebugCall = _defaultDebugCall
+// }
+
+async function createWasmOnigEngine(options) {
+    if (options)
+        await loadWasm(options);
+    return {
+        createScanner(patterns) {
+            return new OnigScanner(patterns);
+        },
+        createString(s) {
+            return new OnigString(s);
+        },
+    };
+}
+
+/**
+ * https://github.com/microsoft/vscode/blob/f7f05dee53fb33fe023db2e06e30a89d3094488f/src/vs/platform/theme/common/colorRegistry.ts#L258-L268
+ */
+const VSCODE_FALLBACK_EDITOR_FG = { light: '#333333', dark: '#bbbbbb' };
+const VSCODE_FALLBACK_EDITOR_BG = { light: '#fffffe', dark: '#1e1e1e' };
+const RESOLVED_KEY = '__shiki_resolved';
+/**
+ * Normalize a textmate theme to shiki theme
+ */
+function normalizeTheme(rawTheme) {
+    // @ts-expect-error private field
+    if (rawTheme?.[RESOLVED_KEY])
+        return rawTheme;
+    const theme = {
+        ...rawTheme,
+    };
+    // Fallback settings
+    if (theme.tokenColors && !theme.settings) {
+        theme.settings = theme.tokenColors;
+        delete theme.tokenColors;
+    }
+    theme.type ||= 'dark';
+    theme.colorReplacements = { ...theme.colorReplacements };
+    theme.settings ||= [];
+    // Guess fg/bg colors
+    let { bg, fg } = theme;
+    if (!bg || !fg) {
+        /**
+         * First try:
+         * Theme might contain a global `tokenColor` without `name` or `scope`
+         * Used as default value for foreground/background
+         */
+        const globalSetting = theme.settings
+            ? theme.settings.find((s) => !s.name && !s.scope)
+            : undefined;
+        if (globalSetting?.settings?.foreground)
+            fg = globalSetting.settings.foreground;
+        if (globalSetting?.settings?.background)
+            bg = globalSetting.settings.background;
+        /**
+         * Second try:
+         * If there's no global `tokenColor` without `name` or `scope`
+         * Use `editor.foreground` and `editor.background`
+         */
+        if (!fg && theme?.colors?.['editor.foreground'])
+            fg = theme.colors['editor.foreground'];
+        if (!bg && theme?.colors?.['editor.background'])
+            bg = theme.colors['editor.background'];
+        /**
+         * Last try:
+         * If there's no fg/bg color specified in theme, use default
+         */
+        if (!fg)
+            fg = theme.type === 'light' ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;
+        if (!bg)
+            bg = theme.type === 'light' ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;
+        theme.fg = fg;
+        theme.bg = bg;
+    }
+    // Push a no-scope setting with fallback colors
+    if (!(theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope)) {
+        theme.settings.unshift({
+            settings: {
+                foreground: theme.fg,
+                background: theme.bg,
+            },
+        });
+    }
+    // Push non-hex colors to color replacements, as `vscode-textmate` doesn't support them
+    let replacementCount = 0;
+    const replacementMap = new Map();
+    function getReplacementColor(value) {
+        if (replacementMap.has(value))
+            return replacementMap.get(value);
+        replacementCount += 1;
+        const hex = `#${replacementCount.toString(16).padStart(8, '0').toLowerCase()}`;
+        if (theme.colorReplacements?.[`#${hex}`]) // already exists
+            return getReplacementColor(value);
+        replacementMap.set(value, hex);
+        return hex;
     }
-}
-class OnigString {
-    static LAST_ID = 0;
-    static _sharedPtr = 0; // a pointer to a string of 10000 bytes
-    static _sharedPtrInUse = false;
-    id = (++OnigString.LAST_ID);
-    _onigBinding;
-    content;
-    utf16Length;
-    utf8Length;
-    utf16OffsetToUtf8;
-    utf8OffsetToUtf16;
-    ptr;
-    constructor(str) {
-        if (!onigBinding)
-            throw new ShikiError('Must invoke loadWasm first.');
-        this._onigBinding = onigBinding;
-        this.content = str;
-        const utfString = new UtfString(str);
-        this.utf16Length = utfString.utf16Length;
-        this.utf8Length = utfString.utf8Length;
-        this.utf16OffsetToUtf8 = utfString.utf16OffsetToUtf8;
-        this.utf8OffsetToUtf16 = utfString.utf8OffsetToUtf16;
-        if (this.utf8Length < 10000 && !OnigString._sharedPtrInUse) {
-            if (!OnigString._sharedPtr)
-                OnigString._sharedPtr = onigBinding.omalloc(10000);
-            OnigString._sharedPtrInUse = true;
-            onigBinding.HEAPU8.set(utfString.utf8Value, OnigString._sharedPtr);
-            this.ptr = OnigString._sharedPtr;
+    theme.settings = theme.settings.map((setting) => {
+        const replaceFg = setting.settings?.foreground && !setting.settings.foreground.startsWith('#');
+        const replaceBg = setting.settings?.background && !setting.settings.background.startsWith('#');
+        if (!replaceFg && !replaceBg)
+            return setting;
+        const clone = {
+            ...setting,
+            settings: {
+                ...setting.settings,
+            },
+        };
+        if (replaceFg) {
+            const replacement = getReplacementColor(setting.settings.foreground);
+            theme.colorReplacements[replacement] = setting.settings.foreground;
+            clone.settings.foreground = replacement;
         }
-        else {
-            this.ptr = utfString.createString(onigBinding);
+        if (replaceBg) {
+            const replacement = getReplacementColor(setting.settings.background);
+            theme.colorReplacements[replacement] = setting.settings.background;
+            clone.settings.background = replacement;
+        }
+        return clone;
+    });
+    for (const key of Object.keys(theme.colors || {})) {
+        // Only patch for known keys
+        if (key === 'editor.foreground' || key === 'editor.background' || key.startsWith('terminal.ansi')) {
+            if (!theme.colors[key]?.startsWith('#')) {
+                const replacement = getReplacementColor(theme.colors[key]);
+                theme.colorReplacements[replacement] = theme.colors[key];
+                theme.colors[key] = replacement;
+            }
         }
     }
-    convertUtf8OffsetToUtf16(utf8Offset) {
-        if (this.utf8OffsetToUtf16) {
-            if (utf8Offset < 0)
-                return 0;
-            if (utf8Offset > this.utf8Length)
-                return this.utf16Length;
-            return this.utf8OffsetToUtf16[utf8Offset];
+    Object.defineProperty(theme, RESOLVED_KEY, {
+        enumerable: false,
+        writable: false,
+        value: true,
+    });
+    return theme;
+}
+
+/**
+ * Resolve
+ */
+async function resolveLangs(langs) {
+    return Array.from(new Set((await Promise.all(langs
+        .filter(l => !isSpecialLang(l))
+        .map(async (lang) => await normalizeGetter(lang).then(r => Array.isArray(r) ? r : [r])))).flat()));
+}
+async function resolveThemes(themes) {
+    const resolved = await Promise.all(themes.map(async (theme) => isSpecialTheme(theme)
+        ? null
+        : normalizeTheme(await normalizeGetter(theme))));
+    return resolved.filter(i => !!i);
+}
+
+class Registry extends Registry$1 {
+    _resolver;
+    _themes;
+    _langs;
+    _alias;
+    _resolvedThemes = new Map();
+    _resolvedGrammars = new Map();
+    _langMap = new Map();
+    _langGraph = new Map();
+    _textmateThemeCache = new WeakMap();
+    _loadedThemesCache = null;
+    _loadedLanguagesCache = null;
+    constructor(_resolver, _themes, _langs, _alias = {}) {
+        super(_resolver);
+        this._resolver = _resolver;
+        this._themes = _themes;
+        this._langs = _langs;
+        this._alias = _alias;
+        this._themes.map(t => this.loadTheme(t));
+        this.loadLanguages(this._langs);
+    }
+    getTheme(theme) {
+        if (typeof theme === 'string')
+            return this._resolvedThemes.get(theme);
+        else
+            return this.loadTheme(theme);
+    }
+    loadTheme(theme) {
+        const _theme = normalizeTheme(theme);
+        if (_theme.name) {
+            this._resolvedThemes.set(_theme.name, _theme);
+            // Reset cache
+            this._loadedThemesCache = null;
         }
-        return utf8Offset;
+        return _theme;
     }
-    convertUtf16OffsetToUtf8(utf16Offset) {
-        if (this.utf16OffsetToUtf8) {
-            if (utf16Offset < 0)
-                return 0;
-            if (utf16Offset > this.utf16Length)
-                return this.utf8Length;
-            return this.utf16OffsetToUtf8[utf16Offset];
+    getLoadedThemes() {
+        if (!this._loadedThemesCache)
+            this._loadedThemesCache = [...this._resolvedThemes.keys()];
+        return this._loadedThemesCache;
+    }
+    // Override and re-implement this method to cache the textmate themes as `TextMateTheme.createFromRawTheme`
+    // is expensive. Themes can switch often especially for dual-theme support.
+    //
+    // The parent class also accepts `colorMap` as the second parameter, but since we don't use that,
+    // we omit here so it's easier to cache the themes.
+    setTheme(theme) {
+        let textmateTheme = this._textmateThemeCache.get(theme);
+        if (!textmateTheme) {
+            textmateTheme = Theme.createFromRawTheme(theme);
+            this._textmateThemeCache.set(theme, textmateTheme);
         }
-        return utf16Offset;
+        // @ts-expect-error Access private `_syncRegistry`, but should work in runtime
+        this._syncRegistry.setTheme(textmateTheme);
     }
-    dispose() {
-        if (this.ptr === OnigString._sharedPtr)
-            OnigString._sharedPtrInUse = false;
-        else
-            this._onigBinding.ofree(this.ptr);
+    getGrammar(name) {
+        if (this._alias[name]) {
+            const resolved = new Set([name]);
+            while (this._alias[name]) {
+                name = this._alias[name];
+                if (resolved.has(name))
+                    throw new ShikiError(`Circular alias \`${Array.from(resolved).join(' -> ')} -> ${name}\``);
+                resolved.add(name);
+            }
+        }
+        return this._resolvedGrammars.get(name);
     }
-}
-class OnigScanner {
-    _onigBinding;
-    _ptr;
-    constructor(patterns) {
-        if (!onigBinding)
-            throw new ShikiError('Must invoke loadWasm first.');
-        const strPtrsArr = [];
-        const strLenArr = [];
-        for (let i = 0, len = patterns.length; i < len; i++) {
-            const utfString = new UtfString(patterns[i]);
-            strPtrsArr[i] = utfString.createString(onigBinding);
-            strLenArr[i] = utfString.utf8Length;
+    loadLanguage(lang) {
+        if (this.getGrammar(lang.name))
+            return;
+        const embeddedLazilyBy = new Set([...this._langMap.values()]
+            .filter(i => i.embeddedLangsLazy?.includes(lang.name)));
+        this._resolver.addLanguage(lang);
+        const grammarConfig = {
+            balancedBracketSelectors: lang.balancedBracketSelectors || ['*'],
+            unbalancedBracketSelectors: lang.unbalancedBracketSelectors || [],
+        };
+        // @ts-expect-error Private members, set this to override the previous grammar (that can be a stub)
+        this._syncRegistry._rawGrammars.set(lang.scopeName, lang);
+        const g = this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);
+        g.name = lang.name;
+        this._resolvedGrammars.set(lang.name, g);
+        if (lang.aliases) {
+            lang.aliases.forEach((alias) => {
+                this._alias[alias] = lang.name;
+            });
+        }
+        // Reset cache
+        this._loadedLanguagesCache = null;
+        // If there is a language that embeds this language lazily, we need to reload it
+        if (embeddedLazilyBy.size) {
+            for (const e of embeddedLazilyBy) {
+                this._resolvedGrammars.delete(e.name);
+                // Reset cache
+                this._loadedLanguagesCache = null;
+                // @ts-expect-error clear cache
+                this._syncRegistry?._injectionGrammars?.delete(e.scopeName);
+                // @ts-expect-error clear cache
+                this._syncRegistry?._grammars?.delete(e.scopeName);
+                this.loadLanguage(this._langMap.get(e.name));
+            }
         }
-        const strPtrsPtr = onigBinding.omalloc(4 * patterns.length);
-        onigBinding.HEAPU32.set(strPtrsArr, strPtrsPtr / 4);
-        const strLenPtr = onigBinding.omalloc(4 * patterns.length);
-        onigBinding.HEAPU32.set(strLenArr, strLenPtr / 4);
-        const scannerPtr = onigBinding.createOnigScanner(strPtrsPtr, strLenPtr, patterns.length);
-        for (let i = 0, len = patterns.length; i < len; i++)
-            onigBinding.ofree(strPtrsArr[i]);
-        onigBinding.ofree(strLenPtr);
-        onigBinding.ofree(strPtrsPtr);
-        if (scannerPtr === 0)
-            throwLastOnigError(onigBinding);
-        this._onigBinding = onigBinding;
-        this._ptr = scannerPtr;
     }
     dispose() {
-        this._onigBinding.freeOnigScanner(this._ptr);
+        super.dispose();
+        this._resolvedThemes.clear();
+        this._resolvedGrammars.clear();
+        this._langMap.clear();
+        this._langGraph.clear();
+        this._loadedThemesCache = null;
     }
-    findNextMatchSync(string, startPosition, arg) {
-        // let debugCall = defaultDebugCall
-        let options = 0 /* FindOption.None */;
-        if (typeof arg === 'number') {
-            // if (arg & FindOption.DebugCall)
-            //   debugCall = true
-            options = arg;
-        }
-        if (typeof string === 'string') {
-            string = new OnigString(string);
-            const result = this._findNextMatchSync(string, startPosition, false, options);
-            string.dispose();
-            return result;
+    loadLanguages(langs) {
+        for (const lang of langs)
+            this.resolveEmbeddedLanguages(lang);
+        const langsGraphArray = Array.from(this._langGraph.entries());
+        const missingLangs = langsGraphArray.filter(([_, lang]) => !lang);
+        if (missingLangs.length) {
+            const dependents = langsGraphArray
+                .filter(([_, lang]) => lang && lang.embeddedLangs?.some(l => missingLangs.map(([name]) => name).includes(l)))
+                .filter(lang => !missingLangs.includes(lang));
+            throw new ShikiError(`Missing languages ${missingLangs.map(([name]) => `\`${name}\``).join(', ')}, required by ${dependents.map(([name]) => `\`${name}\``).join(', ')}`);
         }
-        return this._findNextMatchSync(string, startPosition, false, options);
+        for (const [_, lang] of langsGraphArray)
+            this._resolver.addLanguage(lang);
+        for (const [_, lang] of langsGraphArray)
+            this.loadLanguage(lang);
     }
-    _findNextMatchSync(string, startPosition, debugCall, options) {
-        const onigBinding = this._onigBinding;
-        // let resultPtr: Pointer
-        // if (debugCall)
-        //   resultPtr = onigBinding.findNextOnigScannerMatchDbg(this._ptr, string.id, string.ptr, string.utf8Length, string.convertUtf16OffsetToUtf8(startPosition), options)
-        // else
-        const resultPtr = onigBinding.findNextOnigScannerMatch(this._ptr, string.id, string.ptr, string.utf8Length, string.convertUtf16OffsetToUtf8(startPosition), options);
-        if (resultPtr === 0) {
-            // no match
-            return null;
-        }
-        const HEAPU32 = onigBinding.HEAPU32;
-        let offset = resultPtr / 4; // byte offset -> uint32 offset
-        const index = HEAPU32[offset++];
-        const count = HEAPU32[offset++];
-        const captureIndices = [];
-        for (let i = 0; i < count; i++) {
-            const beg = string.convertUtf8OffsetToUtf16(HEAPU32[offset++]);
-            const end = string.convertUtf8OffsetToUtf16(HEAPU32[offset++]);
-            captureIndices[i] = {
-                start: beg,
-                end,
-                length: end - beg,
-            };
+    getLoadedLanguages() {
+        if (!this._loadedLanguagesCache) {
+            this._loadedLanguagesCache = [
+                ...new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)]),
+            ];
         }
-        return {
-            index,
-            captureIndices,
-        };
+        return this._loadedLanguagesCache;
     }
-}
-function isInstantiatorOptionsObject(dataOrOptions) {
-    return (typeof dataOrOptions.instantiator === 'function');
-}
-function isInstantiatorModule(dataOrOptions) {
-    return (typeof dataOrOptions.default === 'function');
-}
-function isDataOptionsObject(dataOrOptions) {
-    return (typeof dataOrOptions.data !== 'undefined');
-}
-function isResponse(dataOrOptions) {
-    return (typeof Response !== 'undefined' && dataOrOptions instanceof Response);
-}
-function isArrayBuffer(data) {
-    return (typeof ArrayBuffer !== 'undefined' && (data instanceof ArrayBuffer || ArrayBuffer.isView(data)))
-        // eslint-disable-next-line node/prefer-global/buffer
-        || (typeof Buffer !== 'undefined' && Buffer.isBuffer?.(data))
-        || (typeof SharedArrayBuffer !== 'undefined' && data instanceof SharedArrayBuffer)
-        || (typeof Uint32Array !== 'undefined' && data instanceof Uint32Array);
-}
-let initPromise;
-function loadWasm(options) {
-    if (initPromise)
-        return initPromise;
-    async function _load() {
-        onigBinding = await main(async (info) => {
-            let instance = options;
-            instance = await instance;
-            if (typeof instance === 'function')
-                instance = await instance(info);
-            if (typeof instance === 'function')
-                instance = await instance(info);
-            if (isInstantiatorOptionsObject(instance)) {
-                instance = await instance.instantiator(info);
-            }
-            else if (isInstantiatorModule(instance)) {
-                instance = await instance.default(info);
-            }
-            else {
-                if (isDataOptionsObject(instance))
-                    instance = instance.data;
-                if (isResponse(instance)) {
-                    if (typeof WebAssembly.instantiateStreaming === 'function')
-                        instance = await _makeResponseStreamingLoader(instance)(info);
-                    else
-                        instance = await _makeResponseNonStreamingLoader(instance)(info);
-                }
-                else if (isArrayBuffer(instance)) {
-                    instance = await _makeArrayBufferLoader(instance)(info);
-                }
-                // import("shiki/onig.wasm") returns `{ default: WebAssembly.Module }` on cloudflare workers
-                // https://developers.cloudflare.com/workers/wrangler/bundling/
-                else if (instance instanceof WebAssembly.Module) {
-                    instance = await _makeArrayBufferLoader(instance)(info);
-                }
-                else if ('default' in instance && instance.default instanceof WebAssembly.Module) {
-                    instance = await _makeArrayBufferLoader(instance.default)(info);
-                }
-            }
-            if ('instance' in instance)
-                instance = instance.instance;
-            if ('exports' in instance)
-                instance = instance.exports;
-            return instance;
-        });
+    resolveEmbeddedLanguages(lang) {
+        this._langMap.set(lang.name, lang);
+        this._langGraph.set(lang.name, lang);
+        if (lang.embeddedLangs) {
+            for (const embeddedLang of lang.embeddedLangs)
+                this._langGraph.set(embeddedLang, this._langMap.get(embeddedLang));
+        }
     }
-    initPromise = _load();
-    return initPromise;
-}
-function _makeArrayBufferLoader(data) {
-    return importObject => WebAssembly.instantiate(data, importObject);
-}
-function _makeResponseStreamingLoader(data) {
-    return importObject => WebAssembly.instantiateStreaming(data, importObject);
-}
-function _makeResponseNonStreamingLoader(data) {
-    return async (importObject) => {
-        const arrayBuffer = await data.arrayBuffer();
-        return WebAssembly.instantiate(arrayBuffer, importObject);
-    };
 }
-// export function createOnigString(str: string) {
-//   return new OnigString(str)
-// }
-// export function createOnigScanner(patterns: string[]) {
-//   return new OnigScanner(patterns)
-// }
-// export function setDefaultDebugCall(_defaultDebugCall: boolean): void {
-//   defaultDebugCall = _defaultDebugCall
-// }
 
-async function createWasmOnigEngine(options) {
-    if (options)
-        await loadWasm(options);
-    return {
-        createScanner(patterns) {
-            return new OnigScanner(patterns);
-        },
-        createString(s) {
-            return new OnigString(s);
-        },
-    };
+class Resolver {
+    _langs = new Map();
+    _scopeToLang = new Map();
+    _injections = new Map();
+    _onigLib;
+    constructor(engine, langs) {
+        this._onigLib = {
+            createOnigScanner: patterns => engine.createScanner(patterns),
+            createOnigString: s => engine.createString(s),
+        };
+        langs.forEach(i => this.addLanguage(i));
+    }
+    get onigLib() {
+        return this._onigLib;
+    }
+    getLangRegistration(langIdOrAlias) {
+        return this._langs.get(langIdOrAlias);
+    }
+    loadGrammar(scopeName) {
+        return this._scopeToLang.get(scopeName);
+    }
+    addLanguage(l) {
+        this._langs.set(l.name, l);
+        if (l.aliases) {
+            l.aliases.forEach((a) => {
+                this._langs.set(a, l);
+            });
+        }
+        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);
+            });
+        }
+    }
+    getInjections(scopeName) {
+        const scopeParts = scopeName.split('.');
+        let injections = [];
+        for (let i = 1; i <= scopeParts.length; i++) {
+            const subScopeName = scopeParts.slice(0, i).join('.');
+            injections = [...injections, ...(this._injections.get(subScopeName) || [])];
+        }
+        return injections;
+    }
 }
 
-let _defaultWasmLoader;
-/**
- * Set the default wasm loader for `loadWasm`.
- * @internal
- */
-function setDefaultWasmLoader(_loader) {
-    _defaultWasmLoader = _loader;
-}
 let instancesCount = 0;
 /**
  * Get the minimal shiki context for rendering.
+ *
+ * Synchronous version of `createShikiInternal`, which requires to provide the engine and all themes and languages upfront.
  */
-async function createShikiInternal(options = {}) {
+function createShikiInternalSync(options) {
     instancesCount += 1;
     if (options.warnings !== false && instancesCount >= 10 && instancesCount % 10 === 0)
         console.warn(`[Shiki] ${instancesCount} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance; Or call \`highlighter.dispose()\` to release unused instances.`);
     let isDisposed = false;
-    async function normalizeGetter(p) {
-        return Promise.resolve(typeof p === 'function' ? p() : p).then(r => r.default || r);
-    }
-    async function resolveLangs(langs) {
-        return Array.from(new Set((await Promise.all(langs
-            .filter(l => !isSpecialLang(l))
-            .map(async (lang) => await normalizeGetter(lang).then(r => Array.isArray(r) ? r : [r])))).flat()));
-    }
-    const [themes, langs,] = await Promise.all([
-        Promise.all((options.themes || []).map(normalizeGetter)).then(r => r.map(normalizeTheme)),
-        resolveLangs(options.langs || []),
-    ]);
-    const resolver = new Resolver(Promise.resolve(options.engine || createWasmOnigEngine(options.loadWasm || _defaultWasmLoader)), langs);
+    if (!options.engine)
+        throw new ShikiError('`engine` option is required for synchronous mode');
+    const langs = (options.langs || []).flat(1);
+    const themes = (options.themes || []).flat(1).map(normalizeTheme);
+    const resolver = new Resolver(options.engine, langs);
     const _registry = new Registry(resolver, themes, langs, options.langAlias);
-    await _registry.init();
     let _lastTheme;
     function getLanguage(name) {
         ensureNotDisposed();
@@ -5557,15 +5562,22 @@ async function createShikiInternal(options = {}) {
         ensureNotDisposed();
         return _registry.getLoadedLanguages();
     }
+    function loadLanguageSync(...langs) {
+        ensureNotDisposed();
+        _registry.loadLanguages(langs.flat(1));
+    }
     async function loadLanguage(...langs) {
+        return loadLanguageSync(await resolveLangs(langs));
+    }
+    async function loadThemeSync(...themes) {
         ensureNotDisposed();
-        await _registry.loadLanguages(await resolveLangs(langs));
+        for (const theme of themes.flat(1)) {
+            _registry.loadTheme(theme);
+        }
     }
     async function loadTheme(...themes) {
         ensureNotDisposed();
-        await Promise.all(themes.map(async (theme) => isSpecialTheme(theme)
-            ? null
-            : _registry.loadTheme(await normalizeGetter(theme))));
+        return loadThemeSync(await resolveThemes(themes));
     }
     function ensureNotDisposed() {
         if (isDisposed)
@@ -5585,11 +5597,39 @@ async function createShikiInternal(options = {}) {
         getLoadedThemes,
         getLoadedLanguages,
         loadLanguage,
+        loadLanguageSync,
         loadTheme,
+        loadThemeSync,
         dispose,
         [Symbol.dispose]: dispose,
     };
 }
+
+let _defaultWasmLoader;
+/**
+ * Set the default wasm loader for `loadWasm`.
+ * @internal
+ */
+function setDefaultWasmLoader(_loader) {
+    _defaultWasmLoader = _loader;
+}
+/**
+ * Get the minimal shiki context for rendering.
+ */
+async function createShikiInternal(options = {}) {
+    const [themes, langs, engine,] = await Promise.all([
+        resolveThemes(options.themes || []),
+        resolveLangs(options.langs || []),
+        (options.engine || createWasmOnigEngine(options.loadWasm || _defaultWasmLoader)),
+    ]);
+    return createShikiInternalSync({
+        ...options,
+        loadWasm: undefined,
+        themes,
+        langs,
+        engine,
+    });
+}
 /**
  * @deprecated Use `createShikiInternal` instead.
  */
@@ -5602,7 +5642,7 @@ function getShikiInternal(options = {}) {
  * 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/install#fine-grained-bundle
+ * @see http://shiki.style/guide/bundles#fine-grained-bundle
  */
 async function createHighlighterCore(options = {}) {
     const internal = await createShikiInternal(options);
@@ -5617,6 +5657,27 @@ async function createHighlighterCore(options = {}) {
         getInternalContext: () => internal,
     };
 }
+/**
+ * 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
+ */
+function createHighlighterCoreSync(options = {}) {
+    const internal = createShikiInternalSync(options);
+    return {
+        getLastGrammarState: (code, options) => getLastGrammarState(internal, code, options),
+        codeToTokensBase: (code, options) => codeToTokensBase(internal, code, options),
+        codeToTokensWithThemes: (code, options) => codeToTokensWithThemes(internal, code, options),
+        codeToTokens: (code, options) => codeToTokens(internal, code, options),
+        codeToHast: (code, options) => codeToHast(internal, code, options),
+        codeToHtml: (code, options) => codeToHtml(internal, code, options),
+        ...internal,
+        getInternalContext: () => internal,
+    };
+}
 function makeSingletonHighlighterCore(createHighlighter) {
     let _shiki;
     async function getSingletonHighlighterCore(options = {}) {
@@ -5649,14 +5710,23 @@ function getHighlighterCore(options = {}) {
     return createHighlighterCore(options);
 }
 
-/**
- * Create a `createHighlighter` function with bundled themes and languages.
- *
- * @param bundledLanguages
- * @param bundledThemes
- * @param loadWasm
- */
-function createdBundledHighlighter(bundledLanguages, bundledThemes, loadWasm) {
+// Implementation
+function createdBundledHighlighter(arg1, arg2, arg3) {
+    let bundledLanguages;
+    let bundledThemes;
+    let engine;
+    if (arg2) {
+        // TODO: next: console.warn('`createdBundledHighlighter` signature with `bundledLanguages` and `bundledThemes` is deprecated. Use the options object signature instead.')
+        bundledLanguages = arg1;
+        bundledThemes = arg2;
+        engine = () => createWasmOnigEngine(arg3);
+    }
+    else {
+        const options = arg1;
+        bundledLanguages = options.langs;
+        bundledThemes = options.themes;
+        engine = options.engine;
+    }
     async function createHighlighter(options) {
         function resolveLang(lang) {
             if (typeof lang === 'string') {
@@ -5684,10 +5754,10 @@ function createdBundledHighlighter(bundledLanguages, bundledThemes, loadWasm) {
         const langs = (options.langs ?? [])
             .map(i => resolveLang(i));
         const core = await createHighlighterCore({
+            engine: engine(),
             ...options,
             themes: _themes,
             langs,
-            loadWasm,
         });
         return {
             ...core,
@@ -5813,7 +5883,8 @@ function syntaxLowering(input, options = {}) {
   const {
     preserveFlags = false,
     removePossessiveQuantifier = false,
-    removeAtomicGroup = false
+    removeAtomicGroup = false,
+    convertHexDigitsShorthand = false
   } = options;
   let output = "";
   const flags = /* @__PURE__ */ new Set();
@@ -5830,14 +5901,29 @@ function syntaxLowering(input, options = {}) {
       const head = stack[0];
       const wsEscape = freeSpacingGlobal || freeSpacingLocal.length;
       if (char === "\\") {
-        if (input[i + 1] === "h") {
-          if (head === "[") {
-            output += " \\t";
-          } else {
-            output += "[ \\t]";
+        if (convertHexDigitsShorthand) {
+          if (input[i + 1] === "h") {
+            const body = `0-9A-Fa-f`;
+            if (head === "[") {
+              output += body;
+            } else {
+              output += `[${body}]`;
+            }
+            i += 2;
+            continue;
+          }
+          if (input[i + 1] === "H") {
+            if (head === "[") {
+              throw new RegExpConversionError(
+                "Expending \\H in character class is not supported",
+                { pattern: input, converted: output, cursor: i }
+              );
+            } else {
+              output += `[^0-9A-Fa-f]`;
+            }
+            i += 2;
+            continue;
           }
-          i += 2;
-          continue;
         }
         output += char + input[i + 1];
         i += 2;
@@ -6068,6 +6154,7 @@ function onigurumaToRegexp(pattern, options = {}) {
   } = syntaxLowering(pattern, {
     removePossessiveQuantifier: true,
     removeAtomicGroup: true,
+    convertHexDigitsShorthand: true,
     ...options
   });
   return construct(converted, {
@@ -6199,4 +6286,4 @@ function createJavaScriptRegexEngine(options = {}) {
     };
 }
 
-export { FontStyle, ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createJavaScriptRegexEngine, createPositionConverter, createShikiInternal, createSingletonShorthands, createWasmOnigEngine, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getSingletonHighlighterCore, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, loadWasm, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };
+export { FontStyle, ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createHighlighterCoreSync, createJavaScriptRegexEngine, createPositionConverter, createShikiInternal, createShikiInternalSync, createSingletonShorthands, createWasmOnigEngine, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getSingletonHighlighterCore, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, loadWasm, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };