@shikijs/core 1.14.1 → 1.15.0

package/dist/index.mjs

@@ -978,27 +978,6 @@ function transformerDecorations() {
         }
         return map.get(shiki.meta);
     }
-    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.`);
-                }
-            }
-        }
-    }
     return {
         name: 'shiki:decorations',
         tokens(tokens) {
@@ -1021,13 +1000,6 @@ function transformerDecorations() {
                 let text = '';
                 let startIndex = -1;
                 let endIndex = -1;
-                function stringify(el) {
-                    if (el.type === 'text')
-                        return el.value;
-                    if (el.type === 'element')
-                        return el.children.map(stringify).join('');
-                    return '';
-                }
                 if (start === 0)
                     startIndex = 0;
                 if (end === 0)
@@ -1036,7 +1008,7 @@ function transformerDecorations() {
                     endIndex = lineEl.children.length;
                 if (startIndex === -1 || endIndex === -1) {
                     for (let i = 0; i < lineEl.children.length; i++) {
-                        text += stringify(lineEl.children[i]);
+                        text += stringify$2(lineEl.children[i]);
                         if (startIndex === -1 && text.length === start)
                             startIndex = i + 1;
                         if (endIndex === -1 && text.length === end)
@@ -1104,6 +1076,34 @@ function transformerDecorations() {
         },
     };
 }
+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(),
@@ -3383,10 +3383,8 @@ function stringifyEntities(value, options) {
 }
 
 /**
- * @typedef {import('hast').Comment} Comment
- * @typedef {import('hast').Parents} Parents
- *
- * @typedef {import('../index.js').State} State
+ * @import {Comment, Parents} from 'hast'
+ * @import {State} from '../index.js'
  */
 
 
@@ -3437,13 +3435,10 @@ function comment(node, _1, _2, state) {
 }
 
 /**
- * @typedef {import('hast').Doctype} Doctype
- * @typedef {import('hast').Parents} Parents
- *
- * @typedef {import('../index.js').State} State
+ * @import {Doctype, Parents} from 'hast'
+ * @import {State} from '../index.js'
  */
 
-
 /**
  * Serialize a doctype.
  *
@@ -3587,8 +3582,7 @@ function empty(value) {
 }
 
 /**
- * @typedef {import('hast').Parents} Parents
- * @typedef {import('hast').RootContent} RootContent
+ * @import {Parents, RootContent} from 'hast'
  */
 
 
@@ -3638,8 +3632,7 @@ function siblings(increment) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Parents} Parents
+ * @import {Element, Parents} from 'hast'
  */
 
 /**
@@ -3684,8 +3677,7 @@ function omission(handlers) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Parents} Parents
+ * @import {Element, Parents} from 'hast'
  */
 
 
@@ -4041,8 +4033,7 @@ function cells(_, index, parent) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Parents} Parents
+ * @import {Element, Parents} from 'hast'
  */
 
 
@@ -4185,11 +4176,8 @@ function tbody(node, index, parent) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Parents} Parents
- * @typedef {import('hast').Properties} Properties
- *
- * @typedef {import('../index.js').State} State
+ * @import {Element, Parents, Properties} from 'hast'
+ * @import {State} from '../index.js'
  */
 
 
@@ -4447,12 +4435,9 @@ function serializeAttribute(state, key, value) {
 }
 
 /**
- * @typedef {import('hast').Parents} Parents
- * @typedef {import('hast').Text} Text
- *
- * @typedef {import('mdast-util-to-hast').Raw} Raw
- *
- * @typedef {import('../index.js').State} State
+ * @import {Parents, Text} from 'hast'
+ * @import {Raw} from 'mdast-util-to-hast'
+ * @import {State} from '../index.js'
  */
 
 
@@ -4488,11 +4473,9 @@ function text(node, _, parent, state) {
 }
 
 /**
- * @typedef {import('hast').Parents} Parents
- *
- * @typedef {import('mdast-util-to-hast').Raw} Raw
- *
- * @typedef {import('../index.js').State} State
+ * @import {Parents} from 'hast'
+ * @import {Raw} from 'mdast-util-to-hast'
+ * @import {State} from '../index.js'
  */
 
 
@@ -4517,13 +4500,10 @@ function raw(node, index, parent, state) {
 }
 
 /**
- * @typedef {import('hast').Parents} Parents
- * @typedef {import('hast').Root} Root
- *
- * @typedef {import('../index.js').State} State
+ * @import {Parents, Root} from 'hast'
+ * @import {State} from '../index.js'
  */
 
-
 /**
  * Serialize a root.
  *
@@ -4543,10 +4523,8 @@ function root(node, _1, _2, state) {
 }
 
 /**
- * @typedef {import('hast').Nodes} Nodes
- * @typedef {import('hast').Parents} Parents
- *
- * @typedef {import('../index.js').State} State
+ * @import {Nodes, Parents} from 'hast'
+ * @import {State} from '../index.js'
  */
 
 
@@ -4586,13 +4564,9 @@ function unknown(node_) {
 }
 
 /**
- * @typedef {import('hast').Nodes} Nodes
- * @typedef {import('hast').Parents} Parents
- * @typedef {import('hast').RootContent} RootContent
- *
- * @typedef {import('property-information').Schema} Schema
- *
- * @typedef {import('stringify-entities').Options} StringifyEntitiesOptions
+ * @import {Nodes, Parents, RootContent} from 'hast'
+ * @import {Schema} from 'property-information'
+ * @import {Options as StringifyEntitiesOptions} from 'stringify-entities'
  */
 
 
@@ -4716,590 +4690,126 @@ function codeToHtml(internal, code, options) {
     return result;
 }
 
-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_get_now() {
-        return typeof performance !== 'undefined' ? performance.now() : Date.now();
+/**
+ * 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;
     }
-    function _emscripten_memcpy_big(dest, src, num) {
-        binding.HEAPU8.copyWithin(dest, src, src + num);
+    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;
     }
-    function getHeapMax() {
-        return 2147483648;
+    // 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,
+            },
+        });
     }
-    function emscripten_realloc_buffer(size) {
-        try {
-            wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
-            updateGlobalBufferAndViews(wasmMemory.buffer);
-            return 1;
-        }
-        catch { }
+    // 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;
     }
-    function _emscripten_resize_heap(requestedSize) {
-        const oldSize = binding.HEAPU8.length;
-        requestedSize = requestedSize >>> 0;
-        const maxHeapSize = getHeapMax();
-        if (requestedSize > maxHeapSize)
-            return false;
-        const alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
-        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;
+    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;
         }
-        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));
+        if (replaceBg) {
+            const replacement = getReplacementColor(setting.settings.background);
+            theme.colorReplacements[replacement] = setting.settings.background;
+            clone.settings.background = replacement;
         }
-        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 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;
             }
         }
-        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,
-        };
-        const exports = await init(info);
-        wasmMemory = exports.memory;
-        updateGlobalBufferAndViews(wasmMemory.buffer);
-        Object.assign(binding, exports);
-        binding.UTF8ToString = UTF8ToString;
     }
-    await createWasm();
-    return binding;
-}
-
-/* ---------------------------------------------------------
- * Copyright (C) Microsoft Corporation. All rights reserved.
- *-------------------------------------------------------- */
-let onigBinding = null;
-let defaultDebugCall = false;
-function throwLastOnigError(onigBinding) {
-    throw new ShikiError(onigBinding.UTF8ToString(onigBinding.getLastOnigError()));
-}
-class UtfString {
-    static _utf8ByteLength(str) {
-        let result = 0;
-        for (let i = 0, len = str.length; i < len; i++) {
-            const charCode = str.charCodeAt(i);
-            let codepoint = charCode;
-            let wasSurrogatePair = false;
-            if (charCode >= 0xD800 && charCode <= 0xDBFF) {
-                // Hit a high surrogate, try to look for a matching low surrogate
-                if (i + 1 < len) {
-                    const nextCharCode = str.charCodeAt(i + 1);
-                    if (nextCharCode >= 0xDC00 && nextCharCode <= 0xDFFF) {
-                        // Found the matching low surrogate
-                        codepoint = (((charCode - 0xD800) << 10) + 0x10000) | (nextCharCode - 0xDC00);
-                        wasSurrogatePair = true;
-                    }
-                }
-            }
-            if (codepoint <= 0x7F)
-                result += 1;
-            else if (codepoint <= 0x7FF)
-                result += 2;
-            else if (codepoint <= 0xFFFF)
-                result += 3;
-            else
-                result += 4;
-            if (wasSurrogatePair)
-                i++;
-        }
-        return result;
-    }
-    utf16Length;
-    utf8Length;
-    utf16Value;
-    utf8Value;
-    utf16OffsetToUtf8;
-    utf8OffsetToUtf16;
-    constructor(str) {
-        const utf16Length = str.length;
-        const utf8Length = UtfString._utf8ByteLength(str);
-        const computeIndicesMapping = (utf8Length !== utf16Length);
-        const utf16OffsetToUtf8 = computeIndicesMapping ? new Uint32Array(utf16Length + 1) : null;
-        if (computeIndicesMapping)
-            utf16OffsetToUtf8[utf16Length] = utf8Length;
-        const utf8OffsetToUtf16 = computeIndicesMapping ? new Uint32Array(utf8Length + 1) : null;
-        if (computeIndicesMapping)
-            utf8OffsetToUtf16[utf8Length] = utf16Length;
-        const utf8Value = new Uint8Array(utf8Length);
-        let i8 = 0;
-        for (let i16 = 0; i16 < utf16Length; i16++) {
-            const charCode = str.charCodeAt(i16);
-            let codePoint = charCode;
-            let wasSurrogatePair = false;
-            if (charCode >= 0xD800 && charCode <= 0xDBFF) {
-                // Hit a high surrogate, try to look for a matching low surrogate
-                if (i16 + 1 < utf16Length) {
-                    const nextCharCode = str.charCodeAt(i16 + 1);
-                    if (nextCharCode >= 0xDC00 && nextCharCode <= 0xDFFF) {
-                        // Found the matching low surrogate
-                        codePoint = (((charCode - 0xD800) << 10) + 0x10000) | (nextCharCode - 0xDC00);
-                        wasSurrogatePair = true;
-                    }
-                }
-            }
-            if (computeIndicesMapping) {
-                utf16OffsetToUtf8[i16] = i8;
-                if (wasSurrogatePair)
-                    utf16OffsetToUtf8[i16 + 1] = i8;
-                if (codePoint <= 0x7F) {
-                    utf8OffsetToUtf16[i8 + 0] = i16;
-                }
-                else if (codePoint <= 0x7FF) {
-                    utf8OffsetToUtf16[i8 + 0] = i16;
-                    utf8OffsetToUtf16[i8 + 1] = i16;
-                }
-                else if (codePoint <= 0xFFFF) {
-                    utf8OffsetToUtf16[i8 + 0] = i16;
-                    utf8OffsetToUtf16[i8 + 1] = i16;
-                    utf8OffsetToUtf16[i8 + 2] = i16;
-                }
-                else {
-                    utf8OffsetToUtf16[i8 + 0] = i16;
-                    utf8OffsetToUtf16[i8 + 1] = i16;
-                    utf8OffsetToUtf16[i8 + 2] = i16;
-                    utf8OffsetToUtf16[i8 + 3] = i16;
-                }
-            }
-            if (codePoint <= 0x7F) {
-                utf8Value[i8++] = codePoint;
-            }
-            else if (codePoint <= 0x7FF) {
-                utf8Value[i8++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);
-                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
-            }
-            else if (codePoint <= 0xFFFF) {
-                utf8Value[i8++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);
-                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
-                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
-            }
-            else {
-                utf8Value[i8++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);
-                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);
-                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
-                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
-            }
-            if (wasSurrogatePair)
-                i16++;
-        }
-        this.utf16Length = utf16Length;
-        this.utf8Length = utf8Length;
-        this.utf16Value = str;
-        this.utf8Value = utf8Value;
-        this.utf16OffsetToUtf8 = utf16OffsetToUtf8;
-        this.utf8OffsetToUtf16 = utf8OffsetToUtf16;
-    }
-    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 & 8 /* FindOption.DebugCall */)
-                debugCall = true;
-            options = arg;
-        }
-        else if (typeof arg === 'boolean') {
-            debugCall = arg;
-        }
-        if (typeof string === 'string') {
-            string = new OnigString(string);
-            const result = this._findNextMatchSync(string, startPosition, debugCall, options);
-            string.dispose();
-            return result;
-        }
-        return this._findNextMatchSync(string, startPosition, debugCall, options);
-    }
-    _findNextMatchSync(string, startPosition, debugCall, options) {
-        const onigBinding = this._onigBinding;
-        let resultPtr;
-        if (debugCall)
-            resultPtr = onigBinding.findNextOnigScannerMatchDbg(this._ptr, string.id, string.ptr, string.utf8Length, string.convertUtf16OffsetToUtf8(startPosition), options);
-        else
-            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);
-    };
-}
-function createOnigString(str) {
-    return new OnigString(str);
-}
-function createOnigScanner(patterns) {
-    return new OnigScanner(patterns);
-}
-
-/**
- * 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;
+    Object.defineProperty(theme, RESOLVED_KEY, {
+        enumerable: false,
+        writable: false,
+        value: true,
+    });
+    return theme;
 }
 
 class Registry extends Registry$1 {
@@ -5367,133 +4877,614 @@ class Registry extends Registry$1 {
                 resolved.add(name);
             }
         }
-        return this._resolvedGrammars.get(name);
+        return this._resolvedGrammars.get(name);
+    }
+    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,
+        };
+        const exports = await init(info);
+        wasmMemory = exports.memory;
+        updateGlobalBufferAndViews(wasmMemory.buffer);
+        Object.assign(binding, exports);
+        binding.UTF8ToString = UTF8ToString;
+    }
+    await createWasm();
+    return binding;
+}
+
+/* ---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *-------------------------------------------------------- */
+let onigBinding = null;
+// let defaultDebugCall = false
+function throwLastOnigError(onigBinding) {
+    throw new ShikiError(onigBinding.UTF8ToString(onigBinding.getLastOnigError()));
+}
+class UtfString {
+    static _utf8ByteLength(str) {
+        let result = 0;
+        for (let i = 0, len = str.length; i < len; i++) {
+            const charCode = str.charCodeAt(i);
+            let codepoint = charCode;
+            let wasSurrogatePair = false;
+            if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+                // Hit a high surrogate, try to look for a matching low surrogate
+                if (i + 1 < len) {
+                    const nextCharCode = str.charCodeAt(i + 1);
+                    if (nextCharCode >= 0xDC00 && nextCharCode <= 0xDFFF) {
+                        // Found the matching low surrogate
+                        codepoint = (((charCode - 0xD800) << 10) + 0x10000) | (nextCharCode - 0xDC00);
+                        wasSurrogatePair = true;
+                    }
+                }
+            }
+            if (codepoint <= 0x7F)
+                result += 1;
+            else if (codepoint <= 0x7FF)
+                result += 2;
+            else if (codepoint <= 0xFFFF)
+                result += 3;
+            else
+                result += 4;
+            if (wasSurrogatePair)
+                i++;
+        }
+        return result;
     }
-    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));
+    utf16Length;
+    utf8Length;
+    utf16Value;
+    utf8Value;
+    utf16OffsetToUtf8;
+    utf8OffsetToUtf16;
+    constructor(str) {
+        const utf16Length = str.length;
+        const utf8Length = UtfString._utf8ByteLength(str);
+        const computeIndicesMapping = (utf8Length !== utf16Length);
+        const utf16OffsetToUtf8 = computeIndicesMapping ? new Uint32Array(utf16Length + 1) : null;
+        if (computeIndicesMapping)
+            utf16OffsetToUtf8[utf16Length] = utf8Length;
+        const utf8OffsetToUtf16 = computeIndicesMapping ? new Uint32Array(utf8Length + 1) : null;
+        if (computeIndicesMapping)
+            utf8OffsetToUtf16[utf8Length] = utf16Length;
+        const utf8Value = new Uint8Array(utf8Length);
+        let i8 = 0;
+        for (let i16 = 0; i16 < utf16Length; i16++) {
+            const charCode = str.charCodeAt(i16);
+            let codePoint = charCode;
+            let wasSurrogatePair = false;
+            if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+                // Hit a high surrogate, try to look for a matching low surrogate
+                if (i16 + 1 < utf16Length) {
+                    const nextCharCode = str.charCodeAt(i16 + 1);
+                    if (nextCharCode >= 0xDC00 && nextCharCode <= 0xDFFF) {
+                        // Found the matching low surrogate
+                        codePoint = (((charCode - 0xD800) << 10) + 0x10000) | (nextCharCode - 0xDC00);
+                        wasSurrogatePair = true;
+                    }
+                }
+            }
+            if (computeIndicesMapping) {
+                utf16OffsetToUtf8[i16] = i8;
+                if (wasSurrogatePair)
+                    utf16OffsetToUtf8[i16 + 1] = i8;
+                if (codePoint <= 0x7F) {
+                    utf8OffsetToUtf16[i8 + 0] = i16;
+                }
+                else if (codePoint <= 0x7FF) {
+                    utf8OffsetToUtf16[i8 + 0] = i16;
+                    utf8OffsetToUtf16[i8 + 1] = i16;
+                }
+                else if (codePoint <= 0xFFFF) {
+                    utf8OffsetToUtf16[i8 + 0] = i16;
+                    utf8OffsetToUtf16[i8 + 1] = i16;
+                    utf8OffsetToUtf16[i8 + 2] = i16;
+                }
+                else {
+                    utf8OffsetToUtf16[i8 + 0] = i16;
+                    utf8OffsetToUtf16[i8 + 1] = i16;
+                    utf8OffsetToUtf16[i8 + 2] = i16;
+                    utf8OffsetToUtf16[i8 + 3] = i16;
+                }
+            }
+            if (codePoint <= 0x7F) {
+                utf8Value[i8++] = codePoint;
+            }
+            else if (codePoint <= 0x7FF) {
+                utf8Value[i8++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);
+                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+            }
+            else if (codePoint <= 0xFFFF) {
+                utf8Value[i8++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);
+                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
+                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+            }
+            else {
+                utf8Value[i8++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);
+                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);
+                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
+                utf8Value[i8++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
             }
+            if (wasSurrogatePair)
+                i16++;
         }
+        this.utf16Length = utf16Length;
+        this.utf8Length = utf8Length;
+        this.utf16Value = str;
+        this.utf8Value = utf8Value;
+        this.utf16OffsetToUtf8 = utf16OffsetToUtf8;
+        this.utf8OffsetToUtf16 = utf8OffsetToUtf16;
     }
-    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;
+    createString(onigBinding) {
+        const result = onigBinding.omalloc(this.utf8Length);
+        onigBinding.HEAPU8.set(this.utf8Value, result);
+        return result;
     }
-    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(', ')}`);
+}
+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;
         }
-        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)]),
-            ];
+        else {
+            this.ptr = utfString.createString(onigBinding);
         }
-        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));
+    convertUtf8OffsetToUtf16(utf8Offset) {
+        if (this.utf8OffsetToUtf16) {
+            if (utf8Offset < 0)
+                return 0;
+            if (utf8Offset > this.utf8Length)
+                return this.utf16Length;
+            return this.utf8OffsetToUtf16[utf8Offset];
         }
+        return utf8Offset;
     }
-}
-
-class Resolver {
-    _langs = new Map();
-    _scopeToLang = new Map();
-    _injections = new Map();
-    _onigLibPromise;
-    constructor(onigLibPromise, langs) {
-        this._onigLibPromise = onigLibPromise;
-        langs.forEach(i => this.addLanguage(i));
+    convertUtf16OffsetToUtf8(utf16Offset) {
+        if (this.utf16OffsetToUtf8) {
+            if (utf16Offset < 0)
+                return 0;
+            if (utf16Offset > this.utf16Length)
+                return this.utf8Length;
+            return this.utf16OffsetToUtf8[utf16Offset];
+        }
+        return utf16Offset;
     }
-    get onigLib() {
-        return this._onigLibPromise;
+    dispose() {
+        if (this.ptr === OnigString._sharedPtr)
+            OnigString._sharedPtrInUse = false;
+        else
+            this._onigBinding.ofree(this.ptr);
     }
-    getLangRegistration(langIdOrAlias) {
-        return this._langs.get(langIdOrAlias);
+}
+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;
     }
-    async loadGrammar(scopeName) {
-        return this._scopeToLang.get(scopeName);
+    dispose() {
+        this._onigBinding.freeOnigScanner(this._ptr);
     }
-    addLanguage(l) {
-        this._langs.set(l.name, l);
-        if (l.aliases) {
-            l.aliases.forEach((a) => {
-                this._langs.set(a, l);
-            });
+    findNextMatchSync(string, startPosition, arg) {
+        // let debugCall = defaultDebugCall
+        let options = 0 /* FindOption.None */;
+        if (typeof arg === 'number') {
+            // if (arg & FindOption.DebugCall)
+            //   debugCall = true
+            options = arg;
         }
-        this._scopeToLang.set(l.scopeName, l);
-        if (l.injectTo) {
-            l.injectTo.forEach((i) => {
-                if (!this._injections.get(i))
-                    this._injections.set(i, []);
-                this._injections.get(i).push(l.scopeName);
-            });
+        if (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);
     }
-    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) || [])];
+    _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;
         }
-        return injections;
+        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);
+        },
+    };
 }
 
 let _defaultWasmLoader;
@@ -5521,20 +5512,11 @@ async function createShikiInternal(options = {}) {
             .filter(l => !isSpecialLang(l))
             .map(async (lang) => await normalizeGetter(lang).then(r => Array.isArray(r) ? r : [r])))).flat()));
     }
-    const wasmLoader = options.loadWasm || _defaultWasmLoader;
     const [themes, langs,] = await Promise.all([
         Promise.all((options.themes || []).map(normalizeGetter)).then(r => r.map(normalizeTheme)),
         resolveLangs(options.langs || []),
-        wasmLoader ? loadWasm(wasmLoader) : undefined,
     ]);
-    const resolver = new Resolver(Promise.resolve({
-        createOnigScanner(patterns) {
-            return createOnigScanner(patterns);
-        },
-        createOnigString(s) {
-            return createOnigString(s);
-        },
-    }), langs);
+    const resolver = new Resolver(Promise.resolve(options.engine || createWasmOnigEngine(options.loadWasm || _defaultWasmLoader)), langs);
     const _registry = new Registry(resolver, themes, langs, options.langAlias);
     await _registry.init();
     let _lastTheme;
@@ -5792,4 +5774,421 @@ function createSingletonShorthands(createHighlighter) {
     };
 }
 
-export { FontStyle, ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createPositionConverter, createShikiInternal, createSingletonShorthands, 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 };
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RegExpConversionError extends SyntaxError {
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    __publicField(this, "patternOriginal");
+    __publicField(this, "patternConverted");
+    __publicField(this, "cursorPosition");
+    this.patternOriginal = options.pattern;
+    this.patternConverted = options.converted;
+    this.cursorPosition = options.cursor;
+  }
+}
+
+const TABLE_POSIX = {
+  alnum: "0-9A-Za-z",
+  alpha: "A-Za-z",
+  ascii: "\0-\x7F",
+  blank: " \\t",
+  cntrl: "\0-\x7F",
+  digit: "\\d",
+  graph: "!-~",
+  lower: "a-z",
+  print: " -~",
+  punct: "!-/:-@[-`{-~",
+  space: "\\s",
+  upper: "A-Z",
+  xdigit: "0-9A-Fa-f",
+  word: "\\w"
+};
+const KNOWN_FLAGS = /* @__PURE__ */ new Set("gimsuyx");
+function syntaxLowering(input, options = {}) {
+  const {
+    preserveFlags = false,
+    removePossessiveQuantifier = false,
+    removeAtomicGroup = false
+  } = options;
+  let output = "";
+  const flags = /* @__PURE__ */ new Set();
+  const stack = [];
+  const freeSpacingLocal = [];
+  let freeSpacingGlobal = false;
+  let i = 0;
+  try {
+    while (i < input.length) {
+      const char = input[i];
+      while (freeSpacingLocal.length && freeSpacingLocal[0] > stack.length) {
+        freeSpacingLocal.shift();
+      }
+      const head = stack[0];
+      const wsEscape = freeSpacingGlobal || freeSpacingLocal.length;
+      if (char === "\\") {
+        if (input[i + 1] === "h") {
+          if (head === "[") {
+            output += " \\t";
+          } else {
+            output += "[ \\t]";
+          }
+          i += 2;
+          continue;
+        }
+        output += char + input[i + 1];
+        i += 2;
+        continue;
+      }
+      if (char === "#" && wsEscape && input[i - 1].match(/\s/) && head !== "[") {
+        for (let j = i + 1; j <= input.length; j++) {
+          if (input[j] === "\n" || j === input.length) {
+            i = j;
+            break;
+          }
+        }
+        continue;
+      }
+      if (char === "(" && head !== "[") {
+        if (input[i + 1] === "?") {
+          if (input[i + 2] === "#") {
+            for (let j = i + 3; j < input.length; j++) {
+              if (input[j] === ")" && input[j - 1] !== "\\") {
+                i = j + 1;
+                break;
+              }
+            }
+            continue;
+          }
+          if (removeAtomicGroup && input[i + 2] === ">") {
+            output += "(?:";
+            i += 3;
+            continue;
+          }
+          if (KNOWN_FLAGS.has(input[i + 2])) {
+            let end = i + 3;
+            for (; end < input.length; end++) {
+              if (!KNOWN_FLAGS.has(input[end]))
+                break;
+            }
+            const flagStr = input.slice(i + 2, end);
+            const hasX = flagStr.includes("x") && flagStr[0] !== "-";
+            let remainFlags = [...flagStr].filter((x) => x !== "x").join("");
+            if (!preserveFlags) {
+              if (remainFlags[0] === "-") {
+                remainFlags = remainFlags.slice(1);
+                for (const flag of flagStr) {
+                  flags.delete(flag);
+                }
+              } else {
+                for (const flag of remainFlags) {
+                  flags.add(flag);
+                }
+              }
+              remainFlags = "";
+            }
+            if (input[end] === ")") {
+              i = end + 1;
+              if (hasX) {
+                freeSpacingGlobal = true;
+              }
+              if (remainFlags.length) {
+                output += `(?${remainFlags})`;
+              }
+              continue;
+            } else if (input[end] === ":") {
+              i = end + 1;
+              stack.unshift(char);
+              if (hasX) {
+                freeSpacingLocal.unshift(stack.length);
+              }
+              output += `(?${remainFlags}:`;
+              continue;
+            }
+          }
+          stack.unshift(char);
+          output += char + input[i + 1] + input[i + 2];
+          i += 3;
+        } else {
+          stack.unshift(char);
+          output += char;
+          i += 1;
+        }
+        continue;
+      }
+      if (char === ")" && head !== "[") {
+        if (head === "(")
+          stack.shift();
+        output += char;
+        i += 1;
+        continue;
+      }
+      if (char === "[") {
+        if (input[i + 1] === ":") {
+          let name = "";
+          let negated = false;
+          if (input[i + 2] === "^") {
+            negated = true;
+            i += 1;
+          }
+          for (let j = i + 2; j < input.length; j++) {
+            if (input[j] === ":") {
+              i = j + 2;
+              break;
+            }
+            if (!input[j].match(/[a-z]/i)) {
+              name = "";
+              break;
+            }
+            name += input[j];
+          }
+          if (name) {
+            let resolved = TABLE_POSIX[name];
+            if (!resolved) {
+              throw new RegExpConversionError(
+                `Unknown posix class "${name}"`,
+                { pattern: input, converted: output, cursor: i }
+              );
+            }
+            if (negated)
+              resolved = `^${resolved}`;
+            if (head === "[")
+              output += resolved;
+            else
+              output += `[${resolved}]`;
+            continue;
+          }
+        }
+        if (head !== "[") {
+          stack.unshift(char);
+        }
+        output += char;
+        i += 1;
+        continue;
+      }
+      if (char === "]") {
+        if (head === "[")
+          stack.shift();
+        output += char;
+        i += 1;
+        continue;
+      }
+      if (removePossessiveQuantifier && char === "+" && head !== "[") {
+        if ("?+}*".includes(input[i - 1])) {
+          i += 1;
+          continue;
+        }
+      }
+      if (!(wsEscape && head !== "[" && char.match(/\s/))) {
+        output += char;
+      }
+      i += 1;
+    }
+  } catch (e) {
+    if (e instanceof RegExpConversionError)
+      throw e;
+    throw new RegExpConversionError(
+      `Error lowering regex at position ${i}`,
+      { pattern: input, converted: output, cursor: i, cause: e }
+    );
+  }
+  return {
+    pattern: output,
+    flags: [...flags].join("")
+  };
+}
+
+function construct(pattern, options = {}) {
+  const {
+    original = pattern,
+    flags = ["g"]
+  } = options;
+  if (pattern.startsWith("(?x)") || pattern.includes("(?x:")) {
+    throw new RegExpConversionError(
+      "RegExp Free-spacing mode `(?x)` is not supported, you might want to run syntaxLowering() first",
+      { pattern: original, converted: pattern }
+    );
+  }
+  if (pattern.match(/\[:\w+:\]/)) {
+    throw new RegExpConversionError(
+      "POSIX character classes are not supported, you might want to run syntaxLowering() first",
+      { pattern: original, converted: pattern }
+    );
+  }
+  const flagSet = new Set(Array.isArray(flags) ? flags : flags.split(""));
+  pattern = pattern.replace(/\\A/g, "^").replace(/\\x\{([^}]*)\}/g, (m, hex) => `\\u${hex.padStart(4, "0")}`).replace(/\(\?(-)?(\w+):/g, (_, neg, flagStr) => {
+    if (neg) {
+      for (const flag of flagStr)
+        flagSet.delete(flag);
+    } else {
+      for (const flag of flagStr)
+        flagSet.add(flag);
+    }
+    return "(?:";
+  }).replace(/\(\?(-)?(\w+)\)/g, (_, neg, flags2) => {
+    if (neg) {
+      for (const flag of flags2)
+        flagSet.delete(flag);
+    } else {
+      for (const flag of flags2)
+        flagSet.add(flag);
+    }
+    return "";
+  });
+  if (flagSet.has("x")) {
+    throw new RegExpConversionError(
+      "JavaScript does not support extended mode (x flag), you might want to run syntaxLowering() first",
+      { pattern: original, converted: pattern }
+    );
+  }
+  try {
+    return new RegExp(pattern, [...flagSet].join(""));
+  } catch (e) {
+    throw new RegExpConversionError(
+      `Failed to construct RegExp`,
+      {
+        pattern: original,
+        converted: pattern,
+        cause: e
+      }
+    );
+  }
+}
+
+function onigurumaToRegexp(pattern, options = {}) {
+  const {
+    pattern: converted,
+    flags
+  } = syntaxLowering(pattern, {
+    removePossessiveQuantifier: true,
+    removeAtomicGroup: true,
+    ...options
+  });
+  return construct(converted, {
+    original: pattern,
+    flags,
+    ...options
+  });
+}
+
+const MAX = 4294967295;
+class JavaScriptScanner {
+    patterns;
+    cache;
+    forgiving;
+    regexps;
+    constructor(patterns, cache, forgiving) {
+        this.patterns = patterns;
+        this.cache = cache;
+        this.forgiving = forgiving;
+        this.regexps = patterns.map((p) => {
+            const cached = cache?.get(p);
+            if (cached) {
+                if (cached instanceof RegExp) {
+                    return cached;
+                }
+                if (forgiving)
+                    return null;
+                throw cached;
+            }
+            try {
+                const regex = onigurumaToRegexp(p
+                    // YAML specific handling; TODO: move to tm-grammars
+                    .replaceAll('[^\\s[-?:,\\[\\]{}#&*!|>\'"%@`]]', '[^\\s\\-?:,\\[\\]{}#&*!|>\'"%@`]'), { flags: 'dg' });
+                cache?.set(p, regex);
+                return regex;
+            }
+            catch (e) {
+                cache?.set(p, e);
+                if (forgiving)
+                    return null;
+                // console.error({ ...e })
+                throw e;
+            }
+        });
+    }
+    findNextMatchSync(string, startPosition) {
+        const str = typeof string === 'string'
+            ? string
+            : string.content;
+        const pending = [];
+        function toResult(index, match) {
+            return {
+                index,
+                captureIndices: match.indices.map((indice) => {
+                    if (indice == null) {
+                        return {
+                            end: MAX,
+                            start: MAX,
+                            length: 0,
+                        };
+                    }
+                    return {
+                        start: indice[0],
+                        length: indice[1] - indice[0],
+                        end: indice[1],
+                    };
+                }),
+            };
+        }
+        for (let i = 0; i < this.regexps.length; i++) {
+            const regexp = this.regexps[i];
+            if (!regexp)
+                continue;
+            try {
+                regexp.lastIndex = startPosition;
+                const match = regexp.exec(str);
+                if (!match)
+                    continue;
+                // If the match is at the start position, return it immediately
+                if (match.index === startPosition) {
+                    return toResult(i, match);
+                }
+                // Otherwise, store it for later
+                pending.push([i, match]);
+            }
+            catch (e) {
+                if (this.forgiving)
+                    continue;
+                throw e;
+            }
+        }
+        // Find the closest match to the start position
+        if (pending.length) {
+            const minIndex = Math.min(...pending.map(m => m[1].index));
+            for (const [i, match] of pending) {
+                if (match.index === minIndex) {
+                    return toResult(i, match);
+                }
+            }
+        }
+        return null;
+    }
+}
+/**
+ * Use the modern JavaScript RegExp engine to implement the OnigScanner.
+ *
+ * As Oniguruma regex is more powerful than JavaScript regex, some patterns may not be supported.
+ * Errors will be thrown when parsing TextMate grammars with unsupported patterns.
+ * Set `forgiving` to `true` to ignore these errors and skip the unsupported patterns.
+ *
+ * @experimental
+ */
+function createJavaScriptRegexEngine(options = {}) {
+    const { forgiving = false, cache = new Map(), } = options;
+    return {
+        createScanner(patterns) {
+            return new JavaScriptScanner(patterns, cache, forgiving);
+        },
+        createString(s) {
+            return {
+                content: s,
+            };
+        },
+    };
+}
+
+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 };