or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/npm-babel--plugin-transform-instanceof

This plugin transforms all the ES2015 'instanceof' methods

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@babel/plugin-transform-instanceof@7.27.x

To install, run

npx @tessl/cli install tessl/npm-babel--plugin-transform-instanceof@7.27.0

index.mddocs/

@babel/plugin-transform-instanceof

@babel/plugin-transform-instanceof is a Babel plugin that transforms ES2015 instanceof operator expressions into helper function calls. This transformation ensures consistent instanceof behavior across different JavaScript environments by replacing native instanceof operations with a helper function that provides standardized implementation.

Package Information

  • Package Name: @babel/plugin-transform-instanceof
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install --save-dev @babel/plugin-transform-instanceof

Core Imports

import plugin from "@babel/plugin-transform-instanceof";

For CommonJS:

const plugin = require("@babel/plugin-transform-instanceof");

Basic Usage

Configure the plugin in your Babel configuration:

// babel.config.js
module.exports = {
  plugins: ["@babel/plugin-transform-instanceof"]
};

Or with options object:

// babel.config.js
module.exports = {
  plugins: [
    ["@babel/plugin-transform-instanceof", {}]
  ]
};

Input code:

a instanceof b;

Transformed output:

babelHelpers.instanceof(a, b);

Architecture

The plugin is built as a standard Babel transformation plugin:

  • Plugin Factory: Default export function created using declare from @babel/helper-plugin-utils
  • Visitor Pattern: Uses Babel's AST visitor to find and transform instanceof expressions
  • Helper Integration: Integrates with Babel's helper system to inject the instanceof helper function
  • Recursion Prevention: Includes safeguards to prevent infinite transformation loops

Capabilities

Plugin Factory Function

The main export that creates the Babel plugin instance.

/**
 * Creates a Babel plugin that transforms instanceof expressions
 * @param api - Babel plugin API provided by Babel core
 * @param options - Plugin configuration options (unused by this plugin)
 * @param dirname - Directory name (provided by Babel)
 * @returns Babel plugin object with visitor and metadata
 */
declare function default(
  api: PluginAPI,
  options: object,
  dirname: string
): PluginObject<PluginPass>;

interface PluginObject<State> {
  name: string;
  visitor: Visitor<State>;
}

interface Visitor<State> {
  BinaryExpression?(
    path: NodePath<t.BinaryExpression>, 
    state: State & PluginPass
  ): void;
}

Binary Expression Transformation

Transforms instanceof binary expressions into helper function calls.

/**
 * Visitor method that processes BinaryExpression AST nodes
 * @param path - Babel NodePath for the binary expression
 */
BinaryExpression(path: NodePath<t.BinaryExpression>): void;

The transformation logic:

  1. Checks if the binary expression uses the instanceof operator
  2. Adds the instanceof helper function to the current scope
  3. Prevents infinite recursion by checking if already within the helper
  4. Replaces the expression with a call to babelHelpers.instanceof(left, right)

Types

// From @babel/core
interface PluginAPI {
  version: string;
  assertVersion(version: number | string): void;
}

interface PluginPass {
  // Babel plugin pass state
}

// From @babel/types
interface BinaryExpression extends Node {
  type: "BinaryExpression";
  operator: BinaryOperator;
  left: Expression | PrivateName;
  right: Expression;
}

type BinaryOperator = "instanceof" | "in" | "==" | "!=" | /* ... other operators */;

Dependencies

Required Dependencies

  • @babel/core: ^7.0.0-0 (peer dependency)
  • @babel/helper-plugin-utils: Provides plugin creation utilities

Helper Functions

The plugin requires the instanceof helper function to be available in the transformed code. This helper is automatically injected by Babel's helper system when the plugin is used.

The helper function implementation (from @babel/helpers):

/**
 * Runtime helper for instanceof operations
 * @minVersion 7.0.0-beta.0
 * @param left - Left operand of instanceof
 * @param right - Right operand (constructor function)
 * @returns Boolean result of instanceof check
 */
function _instanceof(left: any, right: Function): boolean;

Usage Examples

Basic Transformation

// Input
class Animal {}
class Dog extends Animal {}
const pet = new Dog();

if (pet instanceof Animal) {
  console.log("pet is an animal");
}

// Output (transformed)
class Animal {}
class Dog extends Animal {}
const pet = new Dog();

if (babelHelpers.instanceof(pet, Animal)) {
  console.log("pet is an animal");
}

With Symbol.hasInstance

The transformation works correctly with custom Symbol.hasInstance implementations:

// Input
function CustomClass() {}
CustomClass[Symbol.hasInstance] = function(instance) {
  return instance.customProp === true;
};

const obj = { customProp: true };
console.log(obj instanceof CustomClass);

// Output (transformed)
function CustomClass() {}
CustomClass[Symbol.hasInstance] = function(instance) {
  return instance.customProp === true;
};

const obj = { customProp: true };
console.log(babelHelpers.instanceof(obj, CustomClass));

Complex Expressions

// Input
const result = (a instanceof Array) && (b instanceof Object);

// Output (transformed)
const result = babelHelpers.instanceof(a, Array) && babelHelpers.instanceof(b, Object);