@babel/plugin-transform-parameters

// As a Babel plugin in configuration
module.exports = {
  plugins: ["@babel/plugin-transform-parameters"]
};

// CommonJS
const transformParametersPlugin = require("@babel/plugin-transform-parameters").default;

// ES modules  
import transformParametersPlugin from "@babel/plugin-transform-parameters";

// Named export utility (for advanced plugin development)
import { convertFunctionParams } from "@babel/plugin-transform-parameters";

{
  "plugins": ["@babel/plugin-transform-parameters"]
}

{
  "presets": [
    ["@babel/preset-env", {
      "targets": "> 0.25%, not dead"
    }]
  ]
}

{
  "plugins": [
    ["@babel/plugin-transform-parameters", { "loose": true }]
  ]
}

// Input (ES6)
function greet(name = "World") {
  console.log(`Hello, ${name}!`);
}

// Output (ES5)
function greet() {
  var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "World";
  console.log("Hello, " + name + "!");
}

// Input (ES6)
function sum(...numbers) {
  return numbers.reduce((a, b) => a + b, 0);
}

// Output (ES5)
function sum() {
  for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
    numbers[_key] = arguments[_key];
  }
  return numbers.reduce(function(a, b) { return a + b; }, 0);
}

/**
 * Main Babel plugin factory function
 * @param api - Babel API object with version assertion and assumption methods
 * @param options - Plugin configuration options
 * @returns Babel plugin configuration object
 */
export default function(api: BabelAPI, options: Options = {}): BabelPlugin;

interface Options {
  /**
   * Enable loose transformation mode for better performance
   * When true, uses simpler transformations that may not preserve exact ES6 semantics
   */
  loose?: boolean;
}

interface BabelPlugin {
  name: string;
  visitor: {
    Function(path: NodePath<t.Function>): void;
  };
}

/**
 * Convert function parameters with default values and destructuring patterns
 * @param path - Babel AST path to the function node
 * @param ignoreFunctionLength - Whether to ignore function.length property preservation
 * @param shouldTransformParam - Optional predicate to determine which parameters to transform
 * @param replaceRestElement - Optional callback for custom rest element handling
 * @returns Boolean indicating whether any transformations were made
 */
export function convertFunctionParams(
  path: NodePath<t.Function>,
  ignoreFunctionLength: boolean | void,
  shouldTransformParam?: (index: number) => boolean,
  replaceRestElement?: (
    path: NodePath<t.Function>,
    paramPath: NodePath<t.Function["params"][number]>,
    transformedRestNodes: t.Statement[]
  ) => void
): boolean;

/**
 * Internal utility function for converting rest parameters (not part of public API)
 * Used internally by the main plugin to handle rest parameter transformations
 */
function convertFunctionRest(path: NodePath<t.Function>): boolean;

// Input
const add = (a = 0, b = 0) => a + b;

// Output  
const add = function(a, b) {
  var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
  var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  return a + b;
};

// Strict mode (loose: false)
function foo(a = 1) {
  var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
}

// Loose mode (loose: true)
function foo(a) {
  if (a === undefined) {
    a = 1;
  }
}

interface Options {
  loose?: boolean;
}

interface BabelAPI {
  assertVersion(version: number | string): void;
  assumption(name: string): any;
}

// Babel AST types namespace
declare namespace t {
  interface Function {
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement | Expression;
    async: boolean;
    generator: boolean;
  }

  interface Statement {
    type: string;
  }

  interface Identifier {
    type: "Identifier";
    name: string;
  }

  interface Pattern {
    type: string;
  }

  interface RestElement {
    type: "RestElement";
    argument: Pattern;
  }

  interface BlockStatement {
    type: "BlockStatement";
    body: Statement[];
  }

  interface Expression {
    type: string;
  }
}

interface NodePath<T = any> {
  node: T;
  scope: Scope;
  get(key: string): NodePath;
  replaceWith(node: any): void;
  isArrowFunctionExpression(): boolean;
  isFunctionExpression(): boolean;
  // ... other Babel NodePath methods
}

interface Scope {
  // Babel scope methods
}