@shikijs/engine-javascript 3.22.0 → 4.0.0

package/dist/engine-compile.d.mts

@@ -1,4 +1,37 @@
-import '@shikijs/types';
-import 'oniguruma-to-es';
-export { J as JavaScriptRegexEngineOptions, c as createJavaScriptRegexEngine, d as defaultJavaScriptRegexConstructor } from './shared/engine-javascript.CDEDnU-m.mjs';
-import '@shikijs/vscode-textmate';
+import { t as JavaScriptRegexScannerOptions } from "./scanner-CFS1MV4a.mjs";
+import { ToRegExpOptions } from "oniguruma-to-es";
+import { RegexEngine } from "@shikijs/types";
+
+//#region src/engine-compile.d.ts
+interface JavaScriptRegexEngineOptions extends JavaScriptRegexScannerOptions {
+  /**
+   * The target ECMAScript version.
+   *
+   * Oniguruma-To-ES uses RegExp features from later versions of ECMAScript to add support for a
+   * few more grammars. If using target `ES2024` or later, the RegExp `v` flag is used which
+   * requires Node.js 20+ or Chrome 112+.
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets
+   *
+   * For maximum compatibility, you can set it to `ES2018` which uses the RegExp `u` flag.
+   *
+   * Set to `auto` to automatically detect the latest version supported by the environment.
+   *
+   * @default 'auto'
+   */
+  target?: 'auto' | 'ES2025' | 'ES2024' | 'ES2018';
+}
+/**
+ * The default regex constructor for the JavaScript RegExp engine.
+ */
+declare function defaultJavaScriptRegexConstructor(pattern: string, options?: ToRegExpOptions): RegExp;
+/**
+ * Use the modern JavaScript RegExp engine to implement the OnigScanner.
+ *
+ * As Oniguruma supports some features that can't be emulated using native JavaScript regexes, some
+ * patterns are not supported. Errors will be thrown when parsing TextMate grammars with
+ * unsupported patterns, and when the grammar includes patterns that use invalid Oniguruma syntax.
+ * Set `forgiving` to `true` to ignore these errors and skip any unsupported or invalid patterns.
+ */
+declare function createJavaScriptRegexEngine(options?: JavaScriptRegexEngineOptions): RegexEngine;
+//#endregion
+export { JavaScriptRegexEngineOptions, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/dist/engine-compile.mjs

@@ -1,52 +1,48 @@
-import { toRegExp } from 'oniguruma-to-es';
-import { J as JavaScriptScanner } from './shared/engine-javascript.hzpS1_41.mjs';
+import { t as JavaScriptScanner } from "./scanner-BFcBmQR1.mjs";
+import { toRegExp } from "oniguruma-to-es";
 
+//#region src/engine-compile.ts
+/**
+* The default regex constructor for the JavaScript RegExp engine.
+*/
 function defaultJavaScriptRegexConstructor(pattern, options) {
-  return toRegExp(
-    pattern,
-    {
-      global: true,
-      hasIndices: true,
-      // This has no benefit for the standard JS engine, but it avoids a perf penalty for
-      // precompiled grammars when constructing extremely long patterns that aren't always used
-      lazyCompileLength: 3e3,
-      rules: {
-        // Needed since TextMate grammars merge backrefs across patterns
-        allowOrphanBackrefs: true,
-        // Improves search performance for generated regexes
-        asciiWordBoundaries: true,
-        // Follow `vscode-oniguruma` which enables this Oniguruma option by default
-        captureGroup: true,
-        // Oniguruma uses depth limit `20`; lowered here to keep regexes shorter and maybe
-        // sometimes faster, but can be increased if issues reported due to low limit
-        recursionLimit: 5,
-        // Oniguruma option for `^`->`\A`, `$`->`\Z`; improves search performance without any
-        // change in meaning since TM grammars search line by line
-        singleline: true
-      },
-      ...options
-    }
-  );
+	return toRegExp(pattern, {
+		global: true,
+		hasIndices: true,
+		lazyCompileLength: 3e3,
+		rules: {
+			allowOrphanBackrefs: true,
+			asciiWordBoundaries: true,
+			captureGroup: true,
+			recursionLimit: 5,
+			singleline: true
+		},
+		...options
+	});
 }
+/**
+* Use the modern JavaScript RegExp engine to implement the OnigScanner.
+*
+* As Oniguruma supports some features that can't be emulated using native JavaScript regexes, some
+* patterns are not supported. Errors will be thrown when parsing TextMate grammars with
+* unsupported patterns, and when the grammar includes patterns that use invalid Oniguruma syntax.
+* Set `forgiving` to `true` to ignore these errors and skip any unsupported or invalid patterns.
+*/
 function createJavaScriptRegexEngine(options = {}) {
-  const _options = Object.assign(
-    {
-      target: "auto",
-      cache: /* @__PURE__ */ new Map()
-    },
-    options
-  );
-  _options.regexConstructor ||= (pattern) => defaultJavaScriptRegexConstructor(pattern, { target: _options.target });
-  return {
-    createScanner(patterns) {
-      return new JavaScriptScanner(patterns, _options);
-    },
-    createString(s) {
-      return {
-        content: s
-      };
-    }
-  };
+	const _options = Object.assign({
+		target: "auto",
+		cache: /* @__PURE__ */ new Map()
+	}, options);
+	_options.regexConstructor ||= (pattern) => defaultJavaScriptRegexConstructor(pattern, { target: _options.target });
+	return {
+		createScanner(patterns) {
+			return new JavaScriptScanner(patterns, _options);
+		},
+		createString(s) {
+			return { content: s };
+		}
+	};
 }
 
-export { createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };
+//#endregion
+export { createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/dist/engine-raw.d.mts

@@ -1,5 +1,6 @@
-import { RegexEngine } from '@shikijs/types';
+import { RegexEngine } from "@shikijs/types";
 
+//#region src/engine-raw.d.ts
 /**
  * Raw JavaScript regex engine that only supports precompiled grammars.
  *
@@ -8,5 +9,5 @@ import { RegexEngine } from '@shikijs/types';
  * Zero dependencies.
  */
 declare function createJavaScriptRawEngine(): RegexEngine;
-
-export { createJavaScriptRawEngine };
+//#endregion
+export { createJavaScriptRawEngine };

package/dist/engine-raw.mjs

@@ -1,22 +1,29 @@
-import { J as JavaScriptScanner } from './shared/engine-javascript.hzpS1_41.mjs';
+import { t as JavaScriptScanner } from "./scanner-BFcBmQR1.mjs";
 
+//#region src/engine-raw.ts
+/**
+* Raw JavaScript regex engine that only supports precompiled grammars.
+*
+* This further simplifies the engine by excluding the regex compilation step.
+*
+* Zero dependencies.
+*/
 function createJavaScriptRawEngine() {
-  const options = {
-    cache: /* @__PURE__ */ new Map(),
-    regexConstructor: () => {
-      throw new Error("JavaScriptRawEngine: only support precompiled grammar");
-    }
-  };
-  return {
-    createScanner(patterns) {
-      return new JavaScriptScanner(patterns, options);
-    },
-    createString(s) {
-      return {
-        content: s
-      };
-    }
-  };
+	const options = {
+		cache: /* @__PURE__ */ new Map(),
+		regexConstructor: () => {
+			throw new Error("JavaScriptRawEngine: only support precompiled grammar");
+		}
+	};
+	return {
+		createScanner(patterns) {
+			return new JavaScriptScanner(patterns, options);
+		},
+		createString(s) {
+			return { content: s };
+		}
+	};
 }
 
-export { createJavaScriptRawEngine };
+//#endregion
+export { createJavaScriptRawEngine };

package/dist/index.d.mts

@@ -1,5 +1,4 @@
-export { J as JavaScriptRegexEngineOptions, a as JavaScriptRegexScannerOptions, b as JavaScriptScanner, c as createJavaScriptRegexEngine, d as defaultJavaScriptRegexConstructor } from './shared/engine-javascript.CDEDnU-m.mjs';
-export { createJavaScriptRawEngine } from './engine-raw.mjs';
-import '@shikijs/types';
-import 'oniguruma-to-es';
-import '@shikijs/vscode-textmate';
+import { n as JavaScriptScanner, t as JavaScriptRegexScannerOptions } from "./scanner-CFS1MV4a.mjs";
+import { JavaScriptRegexEngineOptions, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor } from "./engine-compile.mjs";
+import { createJavaScriptRawEngine } from "./engine-raw.mjs";
+export { JavaScriptRegexEngineOptions, JavaScriptRegexScannerOptions, JavaScriptScanner, createJavaScriptRawEngine, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/dist/index.mjs

@@ -1,4 +1,5 @@
-export { createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor } from './engine-compile.mjs';
-export { createJavaScriptRawEngine } from './engine-raw.mjs';
-export { J as JavaScriptScanner } from './shared/engine-javascript.hzpS1_41.mjs';
-import 'oniguruma-to-es';
+import { t as JavaScriptScanner } from "./scanner-BFcBmQR1.mjs";
+import { createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor } from "./engine-compile.mjs";
+import { createJavaScriptRawEngine } from "./engine-raw.mjs";
+
+export { JavaScriptScanner, createJavaScriptRawEngine, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/dist/scanner-BFcBmQR1.mjs

@@ -0,0 +1,76 @@
+//#region src/scanner.ts
+const MAX = 4294967295;
+var JavaScriptScanner = class {
+	regexps;
+	constructor(patterns, options = {}) {
+		this.patterns = patterns;
+		this.options = options;
+		const { forgiving = false, cache, regexConstructor } = options;
+		if (!regexConstructor) throw new Error("Option `regexConstructor` is not provided");
+		this.regexps = patterns.map((p) => {
+			if (typeof p !== "string") return p;
+			const cached = cache?.get(p);
+			if (cached) {
+				if (cached instanceof RegExp) return cached;
+				if (forgiving) return null;
+				throw cached;
+			}
+			try {
+				const regex = regexConstructor(p);
+				cache?.set(p, regex);
+				return regex;
+			} catch (e) {
+				cache?.set(p, e);
+				if (forgiving) return null;
+				throw e;
+			}
+		});
+	}
+	findNextMatchSync(string, startPosition, _options) {
+		const str = typeof string === "string" ? string : string.content;
+		const pending = [];
+		function toResult(index, match, offset = 0) {
+			return {
+				index,
+				captureIndices: match.indices.map((indice) => {
+					if (indice == null) return {
+						start: MAX,
+						end: MAX,
+						length: 0
+					};
+					return {
+						start: indice[0] + offset,
+						end: indice[1] + offset,
+						length: indice[1] - indice[0]
+					};
+				})
+			};
+		}
+		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 (match.index === startPosition) return toResult(i, match, 0);
+				pending.push([
+					i,
+					match,
+					0
+				]);
+			} catch (e) {
+				if (this.options.forgiving) continue;
+				throw e;
+			}
+		}
+		if (pending.length) {
+			const minIndex = Math.min(...pending.map((m) => m[1].index));
+			for (const [i, match, offset] of pending) if (match.index === minIndex) return toResult(i, match, offset);
+		}
+		return null;
+	}
+};
+
+//#endregion
+export { JavaScriptScanner as t };

package/dist/scanner-CFS1MV4a.d.mts

@@ -0,0 +1,31 @@
+import { PatternScanner, RegexEngineString } from "@shikijs/types";
+import { IOnigMatch } from "@shikijs/vscode-textmate";
+
+//#region src/scanner.d.ts
+interface JavaScriptRegexScannerOptions {
+  /**
+   * Whether to allow invalid regex patterns.
+   *
+   * @default false
+   */
+  forgiving?: boolean;
+  /**
+   * Cache for regex patterns.
+   */
+  cache?: Map<string, RegExp | Error> | null;
+  /**
+   * Custom pattern to RegExp constructor.
+   *
+   * By default `oniguruma-to-es` is used.
+   */
+  regexConstructor?: (pattern: string) => RegExp;
+}
+declare class JavaScriptScanner implements PatternScanner {
+  patterns: (string | RegExp)[];
+  options: JavaScriptRegexScannerOptions;
+  regexps: (RegExp | null)[];
+  constructor(patterns: (string | RegExp)[], options?: JavaScriptRegexScannerOptions);
+  findNextMatchSync(string: string | RegexEngineString, startPosition: number, _options: number): IOnigMatch | null;
+}
+//#endregion
+export { JavaScriptScanner as n, JavaScriptRegexScannerOptions as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/engine-javascript",
   "type": "module",
-  "version": "3.22.0",
+  "version": "4.0.0",
   "description": "Engine for Shiki using JavaScript's native RegExp",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -27,13 +27,16 @@
   "files": [
     "dist"
   ],
+  "engines": {
+    "node": ">=20"
+  },
   "dependencies": {
     "@shikijs/vscode-textmate": "^10.0.2",
     "oniguruma-to-es": "^4.3.4",
-    "@shikijs/types": "3.22.0"
+    "@shikijs/types": "4.0.0"
   },
   "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub"
+    "build": "tsdown",
+    "dev": "tsdown --watch"
   }
 }

package/dist/shared/engine-javascript.CDEDnU-m.d.mts

@@ -1,63 +0,0 @@
-import { PatternScanner, RegexEngineString, RegexEngine } from '@shikijs/types';
-import { ToRegExpOptions } from 'oniguruma-to-es';
-import { IOnigMatch } from '@shikijs/vscode-textmate';
-
-interface JavaScriptRegexScannerOptions {
-    /**
-     * Whether to allow invalid regex patterns.
-     *
-     * @default false
-     */
-    forgiving?: boolean;
-    /**
-     * Cache for regex patterns.
-     */
-    cache?: Map<string, RegExp | Error> | null;
-    /**
-     * Custom pattern to RegExp constructor.
-     *
-     * By default `oniguruma-to-es` is used.
-     */
-    regexConstructor?: (pattern: string) => RegExp;
-}
-declare class JavaScriptScanner implements PatternScanner {
-    patterns: (string | RegExp)[];
-    options: JavaScriptRegexScannerOptions;
-    regexps: (RegExp | null)[];
-    constructor(patterns: (string | RegExp)[], options?: JavaScriptRegexScannerOptions);
-    findNextMatchSync(string: string | RegexEngineString, startPosition: number, _options: number): IOnigMatch | null;
-}
-
-interface JavaScriptRegexEngineOptions extends JavaScriptRegexScannerOptions {
-    /**
-     * The target ECMAScript version.
-     *
-     * Oniguruma-To-ES uses RegExp features from later versions of ECMAScript to add support for a
-     * few more grammars. If using target `ES2024` or later, the RegExp `v` flag is used which
-     * requires Node.js 20+ or Chrome 112+.
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets
-     *
-     * For maximum compatibility, you can set it to `ES2018` which uses the RegExp `u` flag.
-     *
-     * Set to `auto` to automatically detect the latest version supported by the environment.
-     *
-     * @default 'auto'
-     */
-    target?: 'auto' | 'ES2025' | 'ES2024' | 'ES2018';
-}
-/**
- * The default regex constructor for the JavaScript RegExp engine.
- */
-declare function defaultJavaScriptRegexConstructor(pattern: string, options?: ToRegExpOptions): RegExp;
-/**
- * Use the modern JavaScript RegExp engine to implement the OnigScanner.
- *
- * As Oniguruma supports some features that can't be emulated using native JavaScript regexes, some
- * patterns are not supported. Errors will be thrown when parsing TextMate grammars with
- * unsupported patterns, and when the grammar includes patterns that use invalid Oniguruma syntax.
- * Set `forgiving` to `true` to ignore these errors and skip any unsupported or invalid patterns.
- */
-declare function createJavaScriptRegexEngine(options?: JavaScriptRegexEngineOptions): RegexEngine;
-
-export { JavaScriptScanner as b, createJavaScriptRegexEngine as c, defaultJavaScriptRegexConstructor as d };
-export type { JavaScriptRegexEngineOptions as J, JavaScriptRegexScannerOptions as a };

package/dist/shared/engine-javascript.hzpS1_41.mjs

@@ -1,93 +0,0 @@
-const MAX = 4294967295;
-class JavaScriptScanner {
-  constructor(patterns, options = {}) {
-    this.patterns = patterns;
-    this.options = options;
-    const {
-      forgiving = false,
-      cache,
-      regexConstructor
-    } = options;
-    if (!regexConstructor) {
-      throw new Error("Option `regexConstructor` is not provided");
-    }
-    this.regexps = patterns.map((p) => {
-      if (typeof p !== "string") {
-        return p;
-      }
-      const cached = cache?.get(p);
-      if (cached) {
-        if (cached instanceof RegExp) {
-          return cached;
-        }
-        if (forgiving)
-          return null;
-        throw cached;
-      }
-      try {
-        const regex = regexConstructor(p);
-        cache?.set(p, regex);
-        return regex;
-      } catch (e) {
-        cache?.set(p, e);
-        if (forgiving)
-          return null;
-        throw e;
-      }
-    });
-  }
-  regexps;
-  findNextMatchSync(string, startPosition, _options) {
-    const str = typeof string === "string" ? string : string.content;
-    const pending = [];
-    function toResult(index, match, offset = 0) {
-      return {
-        index,
-        captureIndices: match.indices.map((indice) => {
-          if (indice == null) {
-            return {
-              start: MAX,
-              end: MAX,
-              length: 0
-            };
-          }
-          return {
-            start: indice[0] + offset,
-            end: indice[1] + offset,
-            length: indice[1] - indice[0]
-          };
-        })
-      };
-    }
-    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 (match.index === startPosition) {
-          return toResult(i, match, 0);
-        }
-        pending.push([i, match, 0]);
-      } catch (e) {
-        if (this.options.forgiving)
-          continue;
-        throw e;
-      }
-    }
-    if (pending.length) {
-      const minIndex = Math.min(...pending.map((m) => m[1].index));
-      for (const [i, match, offset] of pending) {
-        if (match.index === minIndex) {
-          return toResult(i, match, offset);
-        }
-      }
-    }
-    return null;
-  }
-}
-
-export { JavaScriptScanner as J };