diff --git a/spec/match-search-start.spec.js b/spec/match-search-start.spec.js index 73dd5b0..975d5b5 100644 --- a/spec/match-search-start.spec.js +++ b/spec/match-search-start.spec.js @@ -135,7 +135,7 @@ describe('Assertion: Search start', () => { ]; patterns.forEach(pattern => { expect(() => toDetails(pattern)).toThrow(); - expect(() => toDetails(pattern, {rules: {allowUnhandledGAnchors: true}})).not.toThrow(); + expect(() => toDetails(pattern, {rules: {ignoreUnsupportedGAnchors: true}})).not.toThrow(); }); }); }); diff --git a/src/index.js b/src/index.js index a91206d..7b8169c 100644 --- a/src/index.js +++ b/src/index.js @@ -30,9 +30,9 @@ import {recursion} from 'regex-recursion'; maxRecursionDepth?: number | null; rules?: { allowOrphanBackrefs?: boolean; - allowUnhandledGAnchors?: boolean; asciiWordBoundaries?: boolean; captureGroup?: boolean; + ignoreUnsupportedGAnchors?: boolean; }; target?: keyof Target; verbose?: boolean; @@ -59,10 +59,10 @@ function toDetails(pattern, options) { }); const regexAst = transform(onigurumaAst, { accuracy: opts.accuracy, - allowUnhandledGAnchors: opts.rules.allowUnhandledGAnchors, asciiWordBoundaries: opts.rules.asciiWordBoundaries, avoidSubclass, bestEffortTarget: opts.target, + ignoreUnsupportedGAnchors: opts.rules.ignoreUnsupportedGAnchors, }); const generated = generate(regexAst, opts); const pluginData = {useEmulationGroups: !avoidSubclass}; diff --git a/src/options.js b/src/options.js index b866de0..7f84232 100644 --- a/src/options.js +++ b/src/options.js @@ -55,13 +55,13 @@ function getOptions(options) { rules: { // Useful with TextMate grammars that merge backreferences across patterns. allowOrphanBackrefs: false, - // Removes unsupported uses of `\G`, rather than erroring. - allowUnhandledGAnchors: false, // Use ASCII-based `\b` and `\B`, which increases search performance of generated regexes. asciiWordBoundaries: false, // Oniguruma option `ONIG_OPTION_CAPTURE_GROUP`. Unnamed captures and numbered calls allowed // when using named capture. captureGroup: false, + // Removes unsupported uses of `\G`, rather than erroring. + ignoreUnsupportedGAnchors: false, ...(options?.rules), }, }; diff --git a/src/transform.js b/src/transform.js index fe9e956..390220e 100644 --- a/src/transform.js +++ b/src/transform.js @@ -30,10 +30,10 @@ AST represents what's needed to precisely reproduce Oniguruma behavior using Reg @param {import('./parse.js').OnigurumaAst} ast @param {{ accuracy?: keyof Accuracy; - allowUnhandledGAnchors?: boolean; asciiWordBoundaries?: boolean; avoidSubclass?: boolean; bestEffortTarget?: keyof Target; + ignoreUnsupportedGAnchors?: boolean; }} [options] @returns {RegexAst} */ @@ -46,19 +46,19 @@ function transform(ast, options) { // representations would be hard to change to ASCII-based after the fact in the generator // based on `target`/`accuracy`, so produce the appropriate structure here. accuracy: 'default', - allowUnhandledGAnchors: false, asciiWordBoundaries: false, avoidSubclass: false, bestEffortTarget: 'ES2025', + ignoreUnsupportedGAnchors: false, ...options, }; // AST transformations that work together with a `RegExp` subclass to add advanced emulation const strategy = opts.avoidSubclass ? null : applySubclassStrategies(ast); const firstPassState = { accuracy: opts.accuracy, - allowUnhandledGAnchors: opts.allowUnhandledGAnchors, asciiWordBoundaries: opts.asciiWordBoundaries, flagDirectivesByAlt: new Map(), + ignoreUnsupportedGAnchors: opts.ignoreUnsupportedGAnchors, minTargetEs2024: isMinTarget(opts.bestEffortTarget, 'ES2024'), // Subroutines can appear before the groups they ref, so collect reffed nodes for a second pass subroutineRefMap: new Map(), @@ -130,7 +130,7 @@ const FirstPassVisitor = { }, }, - Assertion({node, ast, remove, replaceWith}, {allowUnhandledGAnchors, asciiWordBoundaries, supportedGNodes, wordIsAscii}) { + Assertion({node, ast, remove, replaceWith}, {asciiWordBoundaries, ignoreUnsupportedGAnchors, supportedGNodes, wordIsAscii}) { const {kind, negate} = node; if (kind === AstAssertionKinds.line_end) { // Onig's only line break char is line feed, unlike JS @@ -142,7 +142,7 @@ const FirstPassVisitor = { } else if (kind === AstAssertionKinds.search_start) { if (supportedGNodes.has(node)) { ast.flags.sticky = true; - } else if (!allowUnhandledGAnchors) { + } else if (!ignoreUnsupportedGAnchors) { throw new Error(r`Uses "\G" in a way that's unsupported`); } remove(); @@ -305,7 +305,7 @@ const FirstPassVisitor = { !node.flags.enable && !node.flags.disable && delete node.flags; }, - Pattern({node}, {allowUnhandledGAnchors, supportedGNodes}) { + Pattern({node}, {ignoreUnsupportedGAnchors, supportedGNodes}) { // For `\G` to be accurately emulatable using JS flag y, it must be at (and only at) the start // of every top-level alternative (with complex rules for what determines being at the start). // Additional `\G` error checking in `Assertion` visitor @@ -327,7 +327,7 @@ const FirstPassVisitor = { if (!hasAltWithoutLeadG) { // Supported `\G` nodes will be removed (and add flag y) when traversed; others will error leadingGs.forEach(g => supportedGNodes.add(g)); - } else if (!allowUnhandledGAnchors) { + } else if (!ignoreUnsupportedGAnchors) { throw new Error(r`Uses "\G" in a way that's unsupported`); } }