or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

index.md

tile.json

tessl/npm-babel--helper-create-regexp-features-plugin

Babel helper plugin that compiles ESNext regular expression features to ES5-compatible syntax

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:npm/@babel/helper-create-regexp-features-plugin@7.27.x

To install, run

npx @tessl/cli install tessl/npm-babel--helper-create-regexp-features-plugin@7.27.0

@babel/helper-create-regexp-features-plugin

@babel/helper-create-regexp-features-plugin is a Babel helper utility that creates plugins for transforming modern ECMAScript regular expression features to ES5-compatible syntax. It provides a factory function for building Babel plugins that can compile advanced regex patterns including Unicode property escapes, named capture groups, and other features not supported in older JavaScript environments.

Package Information

Package Name: @babel/helper-create-regexp-features-plugin
Package Type: npm
Language: JavaScript (TypeScript source)
Installation: npm install @babel/helper-create-regexp-features-plugin

Core Imports

import { createRegExpFeaturePlugin, type Options } from "@babel/helper-create-regexp-features-plugin";
import { declare } from "@babel/helper-plugin-utils";

For CommonJS:

const { createRegExpFeaturePlugin } = require("@babel/helper-create-regexp-features-plugin");
const { declare } = require("@babel/helper-plugin-utils");

Basic Usage

import { createRegExpFeaturePlugin } from "@babel/helper-create-regexp-features-plugin";
import { declare } from "@babel/helper-plugin-utils";

// Typical usage in a Babel plugin
export default declare((api, options) => {
  api.assertVersion("^7.0.0");
  
  return createRegExpFeaturePlugin({
    name: "transform-unicode-property-regex",
    feature: "unicodePropertyEscape",
    options: {
      useUnicodeFlag: options.useUnicodeFlag ?? true
    }
  });
});

// Direct usage (less common)
const namedGroupsPlugin = createRegExpFeaturePlugin({
  name: "transform-named-capturing-groups-regex", 
  feature: "namedCaptureGroups",
  options: {
    runtime: true
  }
});

Capabilities

Plugin Factory

Creates a Babel plugin that transforms specific regular expression features from modern ECMAScript to ES5-compatible syntax.

/**
 * Creates a Babel plugin for transforming specific regexp features
 * @param options - Configuration object for the plugin
 * @returns Babel plugin object with visitor methods
 */
function createRegExpFeaturePlugin(options: Options): PluginObject;

interface Options {
  /** Plugin name identifier */
  name: string;
  /** Specific regex feature to transform */
  feature: keyof typeof FEATURES;
  /** Optional configuration settings */
  options?: {
    /** Whether to use Unicode flag - when false, transforms Unicode flag (/u) to ES5 */
    useUnicodeFlag?: boolean;
    /** Whether to use runtime helpers for named capture groups (default: true) */
    runtime?: boolean;
  };
  /** Optional Babel plugin manipulateOptions method */
  manipulateOptions?: PluginObject["manipulateOptions"];
}

Available Features

Features are defined in the FEATURES constant:

const FEATURES = Object.freeze({
  unicodeFlag: 1 << 0,
  dotAllFlag: 1 << 1,
  unicodePropertyEscape: 1 << 2,
  namedCaptureGroups: 1 << 3,
  unicodeSetsFlag_syntax: 1 << 4, // Not used, for backward compatibility
  unicodeSetsFlag: 1 << 5,
  duplicateNamedCaptureGroups: 1 << 6,
  modifiers: 1 << 7,
});

The feature parameter accepts these feature keys:

"unicodeFlag" - Transforms Unicode flag (/u) syntax to ES5-compatible patterns
"dotAllFlag" - Transforms dot-all flag (/s) syntax to equivalent character classes
"unicodePropertyEscape" - Transforms Unicode property escapes (\p{...}) to character classes
"namedCaptureGroups" - Transforms named capture groups (?<name>...) with optional runtime helpers
"unicodeSetsFlag_syntax" - Legacy feature for backward compatibility (not used)
"unicodeSetsFlag" - Transforms Unicode sets flag (/v) syntax to Unicode flag (/u)
"duplicateNamedCaptureGroups" - Handles duplicate named capture groups across alternations
"modifiers" - Transforms inline regex modifiers (?flags:...) syntax

Types

// From @babel/core - Babel plugin object structure
interface PluginObject {
  name: string;
  manipulateOptions?: (opts: any, parserOpts: any) => void;
  pre?: (this: PluginPass) => void;
  post?: (this: PluginPass) => void;
  visitor: Visitor;
  inherits?: PluginObject | (() => PluginObject);
  parserOverride?: (code: string, opts: ParserOptions, parse: Function) => any;
  generatorOverride?: (ast: Node, opts: GeneratorOptions, code: string, generate: Function) => any;
}

// Plugin execution context
interface PluginPass {
  file: BabelFile;
  key: string;
  opts: any;
  cwd: string;
  filename: string | undefined;
  [key: string]: unknown;
}

// AST visitor pattern
interface Visitor {
  [key: string]: VisitNode<any> | VisitNode<any>[] | undefined;
}

type VisitNode<T> = VisitNodeFunction<any, T> | VisitNodeObject<any>;

interface VisitNodeFunction<S, P> {
  (this: S, path: NodePath<P>, state: S): void;
}

interface VisitNodeObject<S> {
  enter?(this: S, path: NodePath, state: S): void;
  exit?(this: S, path: NodePath, state: S): void;
}

Usage Examples

Complete Babel Plugin with Options

import { createRegExpFeaturePlugin } from "@babel/helper-create-regexp-features-plugin";
import { declare } from "@babel/helper-plugin-utils";

interface PluginOptions {
  useUnicodeFlag?: boolean;
}

export default declare((api, options: PluginOptions) => {
  api.assertVersion("^7.0.0");
  
  const { useUnicodeFlag = true } = options;
  if (typeof useUnicodeFlag !== "boolean") {
    throw new Error(".useUnicodeFlag must be a boolean, or undefined");
  }

  return createRegExpFeaturePlugin({
    name: "transform-unicode-property-regex",
    feature: "unicodePropertyEscape",
    options: { useUnicodeFlag },
  });
});

// Transforms: /\p{Letter}/u  →  /[compiled character class]/u

Named Capture Groups with Runtime Helper

import { createRegExpFeaturePlugin } from "@babel/helper-create-regexp-features-plugin";
import { declare } from "@babel/helper-plugin-utils";

interface PluginOptions {
  runtime?: boolean;
}

export default declare((api, options: PluginOptions) => {
  api.assertVersion("^7.0.0");
  
  const { runtime } = options;
  if (runtime !== undefined && typeof runtime !== "boolean") {
    throw new Error("The 'runtime' option must be boolean");
  }

  return createRegExpFeaturePlugin({
    name: "transform-named-capturing-groups-regex",
    feature: "namedCaptureGroups",
    options: { runtime },
  });
});

// Transforms: /(?<year>\d{4})/  →  runtime helper wrapper for named group access

Plugin with manipulateOptions

import { createRegExpFeaturePlugin } from "@babel/helper-create-regexp-features-plugin";
import { declare } from "@babel/helper-plugin-utils";

export default declare(api => {
  api.assertVersion("^7.19.0");

  return createRegExpFeaturePlugin({
    name: "transform-unicode-sets-regex",
    feature: "unicodeSetsFlag",
    manipulateOptions(opts, parserOpts) {
      // Enable parser plugin for Unicode sets syntax
      parserOpts.plugins.push("regexpUnicodeSets");
    },
  });
});

// Transforms: /[\p{ASCII}&&[^\p{Cc}]]/v  →  /[compiled character class]/u

Simple Feature Plugin (No Options)

import { createRegExpFeaturePlugin } from "@babel/helper-create-regexp-features-plugin";
import { declare } from "@babel/helper-plugin-utils";

export default declare(api => {
  api.assertVersion("^7.0.0");

  return createRegExpFeaturePlugin({
    name: "transform-dotall-regex",
    feature: "dotAllFlag"
  });
});

// Transforms: /./s  →  /[\s\S]/

Feature Transformation Details

Unicode Flag (`unicodeFlag`)

Transforms Unicode flag patterns to ES5-compatible syntax when options.useUnicodeFlag is false.

Input: /[𝒜]/u Output: /(?:(?:\uD835[\uDC9C-\uDCB5])|(?:\uD835[\uDCB6-\uDCCF]))/

Dot-All Flag (`dotAllFlag`)

Replaces the dot-all flag with equivalent character classes.

Input: /./s Output: /[\s\S]/ Input: /a.b/s Output: /a[\s\S]b/

Unicode Property Escapes (`unicodePropertyEscape`)

Compiles Unicode property escapes to character classes or ranges.

Input: /\p{Letter}/u Output: /[compiled character ranges]/u Input: /\p{Script=Greek}/u Output: /[\u0370-\u0373\u0375-\u0377...]/u

Named Capture Groups (`namedCaptureGroups`)

Transforms named capture groups with optional runtime helper for group access.

Input: /(?<year>\d{4})/ Output (runtime: false): /(\d{4})/ Input: /(?<year>\d{4})/ Output (runtime: true): _wrapRegExp(/(\d{4})/, {year: 1})

Unicode Sets Flag (`unicodeSetsFlag`)

Converts Unicode sets flag syntax to Unicode flag with compiled character classes.

Input: /[\p{ASCII}&&[^\p{Cc}]]/v Output: /[compiled intersection]/u

Duplicate Named Capture Groups (`duplicateNamedCaptureGroups`)

Handles regex patterns with duplicate named groups across alternations.

Input: /(?<n>a)|(?<n>b)/ Output: _wrapRegExp(/(a)|(b)/, {n: [1, 2]})

Regex Modifiers (`modifiers`)

Transforms inline modifier syntax to equivalent patterns.

Input: /(?i:hello)/ Output: /[Hh][Ee][Ll][Ll][Oo]/

Dependencies

This package depends on:

regexpu-core - Core regex transformation engine
@babel/helper-annotate-as-pure - Marks runtime helper calls as pure for optimizations
semver - Version comparison utilities

Error Handling

The plugin validates runtime option consistency across related features:

// This configuration will throw an error
const config = {
  plugins: [
    ["transform-named-capturing-groups-regex", { runtime: true }],
    ["transform-duplicate-named-capturing-groups-regex", { runtime: false }]
  ]
};
// Error: "The 'runtime' option must be the same for related plugins"