Oniguruma (鬼車) to ES

“I think [Oniguruma-To-ES] is very wonderful”
— K. Kosako, creator of Oniguruma

Oniguruma is a regular expression engine written in C that's used in Ruby (via a fork named Onigmo), PHP (mb_ereg, etc.), TextMate grammars (used by VS Code, Shiki, etc. for syntax highlighting), and many other tools.

Oniguruma-To-ES is an advanced Oniguruma to JavaScript regex translator that runs in the browser or the server, with support for ~99.99% of Oniguruma regexes (more details below). Use it to:

• Take advantage of Oniguruma's many extended regex features in JavaScript.
• Run regexes written for Oniguruma from JavaScript.
• Share regexes across your Ruby or PHP and JavaScript code.

Compared to running the Oniguruma C library via WASM using vscode-oniguruma, this library is ~4% of the size and its regexes often run much faster (even including transpilation time) since they run as native JavaScript.

[!TIP] You can further reduce bundle size (and increase run-time performance) by precompiling your regexes. In many cases, that avoids the need for any run-time dependency. Conversions for regexes that use certain advanced features rely on a RegExp subclass, in which case the tree-shakable EmulatedRegExp (3 kB minzip) is still needed after precompilation.

Oniguruma-To-ES deeply understands the hundreds of large and small differences between Oniguruma and JavaScript regex syntax and behavior, across multiple JavaScript version targets. It's obsessive about ensuring that the emulated features it supports have exactly the same behavior, even in extreme edge cases. And it's been battle-tested on tens of thousands of real-world Oniguruma regexes used in TextMate grammars. It's built on top of oniguruma-parser and Regex+, both by the same author as this library.

🧪 Try the demo REPL

📜 Contents

• Examples
• Install and use
• API: toRegExp, toRegExpDetails, EmulatedRegExp
• Options: accuracy, avoidSubclass, flags, global, hasIndices, lazyCompileLength, rules, target, verbose
• Supported features
• Unsupported features
• Unicode

🪧 Examples

1import {toRegExp} from 'oniguruma-to-es';
2
3toRegExp(String.raw`(?x)
4  (?<n>\d) (?<n>\p{greek}) \k<n>
5  ([0a-z&&\h]){,2}
6`);
7// → /(?<n>\p{Nd})(\p{sc=Greek})(?>\2|\1)(?:[[0a-z]&&\p{AHex}]){0,2}/v

Although the example above is fairly straightforward, it shows several kinds of differences being translated:

• New flags: JavaScript regexes don't support flag x for insignificant whitespace and comments.
• New syntax: JavaScript doesn't include standalone flag modifiers like (?x) or the \h hex-digit shorthand. Note: ES2025 added support for flag groups like (?i:…).
• Different syntax rules: JavaScript doesn't allow duplicate group names in the same alternation path, requires a prefix and specific casing for Unicode scripts like Greek, requires nested character classes for intersection of union and ranges, and doesn't allow an implicit 0 min for {…} quantifiers.
• Different behavior: Oniguruma's \d is Unicode based by default, backreferences to duplicate group names match the captured value of any of the groups, and (…) groups are noncapturing by default if named groups are present.

Many advanced features are supported that would produce more complicated transformations.

[!NOTE] The (?>…) atomic group shown in the result was a simplification for readability. Since JavaScript doesn't support atomic groups, the actual result uses (?=(\2|\1))\3 for the same effect, and then uses a RegExp subclass to automatically remove the added capturing group from reported matches.

This next example shows support for Unicode case folding with mixed case-sensitivity. Notice that code points ſ (U+017F) and K (U+212A) are added to the second, case-insensitive range if using a target prior to ES2025, and that modern JavaScript regex features (like flag groups) are used if supported by the target.

1toRegExp('[a-z](?i)[a-z]', {target: 'ES2018'});
2// → /[a-z][a-zA-ZſK]/u
3toRegExp('[a-z](?i)[a-z]', {target: 'ES2025'});
4// → /[a-z](?i:[a-z])/v

🕹️ Install and use

1npm install oniguruma-to-es

1import {toRegExp} from 'oniguruma-to-es';
2
3const str = '…';
4const pattern = '…';
5// Works with all string/regexp methods since it returns a native regexp
6str.match(toRegExp(pattern));

1<script src="https://cdn.jsdelivr.net/npm/oniguruma-to-es/dist/index.min.js"></script>
2<script>
3  const {toRegExp} = OnigurumaToEs;
4</script>

🔑 API

toRegExp

Accepts an Oniguruma pattern and returns an equivalent JavaScript RegExp.

[!TIP] Try it in the demo REPL.

1function toRegExp(
2  pattern: string,
3  options?: ToRegExpOptions
4): RegExp | EmulatedRegExp;

Type ToRegExpOptions

1type ToRegExpOptions = {
2  accuracy?: 'default' | 'strict';
3  avoidSubclass?: boolean;
4  flags?: string;
5  global?: boolean;
6  hasIndices?: boolean;
7  lazyCompileLength?: number;
8  rules?: {
9    allowOrphanBackrefs?: boolean;
10    asciiWordBoundaries?: boolean;
11    captureGroup?: boolean;
12    recursionLimit?: number;
13    singleline?: boolean;
14  };
15  target?: 'auto' | 'ES2025' | 'ES2024' | 'ES2018';
16  verbose?: boolean;
17};

See Options for more details.

toRegExpDetails

Accepts an Oniguruma pattern and returns the details needed to construct an equivalent JavaScript RegExp.

1function toRegExpDetails(
2  pattern: string,
3  options?: ToRegExpOptions
4): {
5  pattern: string;
6  flags: string;
7  options?: EmulatedRegExpOptions;
8};

Note that the returned flags might also be different than those provided, as a result of the emulation process. The returned pattern, flags, and options properties can be provided as arguments to the EmulatedRegExp constructor to produce the same result as toRegExp.

If the only keys returned are pattern and flags, they can optionally be provided to JavaScript's RegExp constructor instead. Setting option avoidSubclass to true ensures that this is always the case (resulting in an error for any patterns that require EmulatedRegExp's additional handling).

EmulatedRegExp

Works the same as JavaScript's native RegExp constructor in all contexts, but can be given results from toRegExpDetails to produce the same result as toRegExp.

1class EmulatedRegExp extends RegExp {
2  constructor(pattern: string, flags?: string, options?: EmulatedRegExpOptions);
3  constructor(pattern: EmulatedRegExp, flags?: string);
4  rawOptions: EmulatedRegExpOptions;
5}

The rawOptions property of EmulatedRegExp instances can be used for serialization.

Type EmulatedRegExpOptions

1type EmulatedRegExpOptions = {
2  hiddenCaptures?: Array<number>;
3  lazyCompile?: boolean;
4  strategy?: string | null;
5  transfers?: Array<[number, Array<number>]>;
6};

🔩 Options

The following options are shared by functions toRegExp and toRegExpDetails.

accuracy

One of 'default' (default) or 'strict'.

Sets the level of emulation rigor/strictness.

• Default: Permits a few close approximations in order to support additional features.
• Strict: Error if the pattern can't be emulated with identical behavior (even in rare edge cases) for the given target.

avoidSubclass

Default: false.

Disables advanced emulation that relies on returning a RegExp subclass. In cases when a subclass would otherwise have been used, this results in one of the following:

• An error is thrown for patterns that are not emulatable without a subclass.
• Some patterns can still be emulated accurately without a subclass, but in this case subpattern match details might differ from Oniguruma.
  • This is only relevant if you access the subpattern details of match results in your code (via subpattern array indices, groups, and indices).

flags

Oniguruma flags; a string with i, m, x, D, S, W, y{g} in any order (all optional).

Flags i, m, x can also be specified via modifiers in the pattern.

[!IMPORTANT] Oniguruma and JavaScript both have an m flag but with different meanings. Oniguruma's m is equivalent to JavaScript's s (dotAll).

global

Default: false.

Include JavaScript flag g (global) in the result.

hasIndices

Default: false.

Include JavaScript flag d (hasIndices) in the result.

lazyCompileLength

Default: Infinity. In other words, lazy compilation is off by default.

Delay regex construction until first use if the transpiled pattern is at least this length.

Although regex construction in JavaScript is fast, it can sometimes be helpful to defer the cost for extremely long patterns. Lazy compilation defers the time JavaScript spends inside the RegExp constructor (building the transpiled pattern into a regex object) until the first time the regex is used in a search. The regex object is outwardly identical before and after deferred compilation.

Lazy compilation relies on the EmulatedRegExp class.

rules

Advanced options that override standard behavior, error checking, and flags when enabled.

• allowOrphanBackrefs: Useful with TextMate grammars that merge backreferences across patterns.
• asciiWordBoundaries: Use ASCII \b and \B, which increases search performance of generated regexes.
• captureGroup: Allow unnamed captures and numbered calls (backreferences and subroutines) when using named capture.
  • This is Oniguruma option ONIG_OPTION_CAPTURE_GROUP; on by default in vscode-oniguruma.
• recursionLimit: Change the recursion depth limit from Oniguruma's 20 to an integer 2–20.
• singleline: ^ as \A; $ as \Z. Improves search performance of generated regexes without changing the meaning if searching line by line.
  • This is Oniguruma option ONIG_OPTION_SINGLELINE.

target

One of 'auto' (default), 'ES2025', 'ES2024', or 'ES2018'.

JavaScript version used for generated regexes. Using auto detects the best value for your environment. Later targets enable faster transpilation, simpler generated source, and support for additional features.

verbose

Default: false.

Disables minifications that simplify the pattern without changing the meaning.

Example: By default, unneeded noncapturing groups might be removed during transpilation. Setting this option to true disables such changes.

[!TIP] The oniguruma-parser library includes a regex optimizer that goes far beyond the basic, built-in minifications. If desired, you can call the optimizer first, and then use its result for transpilation. That isn't appropropriate in all cases (since it adds performance overhead and increases bundle size), but the benefits of optimization do pass through to the transpiled, JavaScript version of a regex.

✅ Supported features

Following are the supported features by target. The official Oniguruma syntax doc doesn't cover many of the finer details described here.

[!NOTE] Targets ES2024 and ES2025 have the same emulation capabilities. Resulting regexes might have different source and flags, but they match the same strings. See target.

🆕 = Syntax not available in JavaScript.
🆚 = JavaScript uses slightly different syntax for the same concept; ex: \x{…} → \u{…}.

Even for features not marked with one of the above symbols, notice that nearly every feature below has at least subtle differences from JavaScript. Unsupported features throw an error.

The table above doesn't include all aspects that Oniguruma-To-ES emulates (including error handling, subpattern details on match results, most aspects that work the same as in JavaScript, and many aspects of non-JavaScript features that work the same in the other regex flavors that support them). Where applicable, Oniguruma-To-ES follows the latest version of Oniguruma (6.9.10).

Footnotes

1. Unicode blocks (which in Oniguruma are specified with an In prefix) are easily emulatable but their character data would significantly increase library weight. They're also rarely used, fundamentally flawed, and arguably unuseful given the availability of Unicode scripts and other properties.
2. With target ES2018, the specific POSIX classes [:graph:] and [:print:] use ASCII versions rather than the Unicode versions available for target ES2024 and later, and they result in an error if using strict accuracy.
3. Target ES2018 has limited support for nested, negated character classes.
4. It's not an error for numbered backreferences to come before their referenced group in Oniguruma, but an error is the best path for Oniguruma-To-ES because ① most placements are mistakes and can never match (based on the Oniguruma behavior for backreferences to nonparticipating groups), ② erroring matches the behavior of named backreferences, and ③ the edge cases where they're matchable rely on rules for backreference resetting within quantified groups that are different in JavaScript and aren't emulatable. Note that it's not a backreference in the first place if using \10 or higher and not as many capturing groups are defined to the left (it's an octal or identity escape).
5. Oniguruma's recursion depth limit is 20. Oniguruma-To-ES uses the same limit by default but allows customizing it via the rules.recursionLimit option. Two rare uses of recursion aren't yet supported: overlapping recursions, and use of backreferences when a recursed subpattern contains captures. Patterns that would trigger an infinite recursion error in Oniguruma might find a match in Oniguruma-To-ES (since recursion is bounded), but future versions will detect this and error at transpilation time.
6. Other absence function types aren't yet supported. They start with (?~| and are extremely rare. Note that absence functions behave differently in Oniguruma and Onigmo.
7. Other named callouts aren't yet supported. They use the syntax (*…) and are extremely rare.
8. When using flag i, in rare cases Oniguruma can change the length of certain matches based on Unicode case conversion rules. That behavior isn't reproduced in this library because ① the rules are applied inconsistently (report) and ② Oniguruma planned to disable case conversion length changes by default in future versions.
9. Combining flags W and i can result in edge case Oniguruma bugs (report) that aren't reproduced in this library.

❌ Unsupported features

The following throw errors since they aren't yet supported. They're all extremely rare.

• Supportable:
  • Rarely-used character specifiers: Non-A-Za-z with \cx \C-x, meta \M-x \M-\C-x, octal code points \o{…}, and octal encoded bytes ≥ \200.
  • Code point sequences: \x{H H …} \o{O O …}.
  • Flags P (POSIX is ASCII) and y{w} (text segment mode is word), and whole-pattern flag C (don't capture group).
• Supportable for some uses:
  • Conditionals: (?(…)…), etc.
  • Whole-pattern flags I (ignore-case is ASCII) and L (find longest).
  • Named callout (*SKIP).
• Not supportable:
  • Text segment boundaries: \y \Y.
  • Callouts via (?{…}), and most named callouts.

See also the supported features table (above), which describes some additional, rarely-used sub-features that aren't yet supported.

Despite these gaps, ~99.99% of real-world Oniguruma regexes are supported, based on a sample of ~55k regexes used in TextMate grammars. Conditionals were used in three regexes, overlapping recursions in three regexes, and other unsupported features weren't used at all. Some Oniguruma features are so exotic that they aren't used in any public code on GitHub.

🌏 Unicode

Oniguruma-To-ES fully supports mixed case-sensitivity (ex: (?i)a(?-i)a) and handles the Unicode edge cases regardless of JavaScript target.

Oniguruma-To-ES focuses on being lightweight to make it better for use in browsers. This is partly achieved by not including heavyweight Unicode character data, which imposes a few minor/rare restrictions:

• Character class intersection and some uses of nested, negated character classes are unsupported with target ES2018. Use target ES2024 (supported by Node.js 20 and 2023-era browsers) or later if you need support for these features.
• With targets before ES2025, a handful of Unicode properties that target a specific character case (ex: \p{Lower}) can't be used case-insensitively in patterns that contain other characters with a specific case that are used case-sensitively.
  • In other words, almost every usage is fine, including A\p{Lower}, (?i)A\p{Lower}, (?i:A)\p{Lower}, (?i)A(?-i)\p{Lower}, and \w(?i)\p{Lower}, but not A(?i)\p{Lower}.
  • Using these properties case-insensitively is basically never done intentionally, so you're unlikely to encounter this error unless it's catching a mistake.
• Oniguruma-To-ES uses the version of Unicode supported natively by your JavaScript environment. Using Unicode properties via \p{…} that were added in a later version of Unicode than the environment supports results in a runtime error. This is an extreme edge case since modern JavaScript environments support recent versions of Unicode.

🧩 Contributing

Contributions are welcome. See the guide to help you get started.

👀 Similar projects

JsRegex transpiles Ruby regexes to JavaScript. Ruby uses Onigmo, a fork of Oniguruma. Although JsRegex and this library have important differences, JsRegex might be a better fit for some Ruby projects.

🏷️ About

Oniguruma-To-ES was created by Steven Levithan and contributors.

Special thanks:

• Anthony Fu for inspiring the project and adopting it in Shiki.
• RedCMD for sharing deep Oniguruma and TextMate grammar expertise, and contributions to the parser.
• tonco-miyazawa for sharing deep Oniguruma expertise.
• K. Kosako for creating Oniguruma and maintaining it for 23 years.

If you want to support this project, I'd love your help by contributing improvements (guide), sharing it with others, or sponsoring ongoing development.

MIT License.