esupgrade 2025.3.4 → 2025.4.0

package/.github/copilot-instructions.md

@@ -0,0 +1,18 @@
+When writing code, you MUST ALWAYS follow the [naming-things](https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md) guidelines.
+
+All code must be fully tested with a 100% coverage. Unreachable code must be removed.
+
+All transformers must be documented in the README.md.
+
+Use class syntax for all object-oriented code.
+Use named functions instead of anonymous functions whenever possible.
+Use `#` for private methods.
+
+Avoid overly complex functions. Break them into smaller functions if necessary.
+
+Write docstrings with jsdoc type annotations for all functions, classes, and methods.
+Docstrings should be written in present tense imperative mood.
+Docstrings must describe the external behavior of the function, class, or method.
+Docstrings should avoid redundant phrases like "This function" or "This method".
+Class docstrings must not repeat the class name or start with a verb since they don't do anything themselves.
+Avoid code comments unless they describe behavior of 3rd party code or complex algorithms.

package/README.md

@@ -212,6 +212,47 @@ Supports:
 > [!NOTE]
 > Functions using `this`, `arguments`, or `super` are not converted to preserve semantics.
 
+#### Constructor functions → [Classes][mdn-classes]
+
+```diff
+-function Person(name, age) {
+-  this.name = name;
+-  this.age = age;
+-}
+-
+-Person.prototype.greet = function() {
+-  return 'Hello, I am ' + this.name;
+-};
+-
+-Person.prototype.getAge = function() {
+-  return this.age;
+-};
++class Person {
++  constructor(name, age) {
++    this.name = name;
++    this.age = age;
++  }
++
++  greet() {
++    return 'Hello, I am ' + this.name;
++  }
++
++  getAge() {
++    return this.age;
++  }
++}
+```
+
+> [!NOTE]
+> Transforms constructor functions (both function declarations and variable declarations) that meet these criteria:
+>
+> - Function name starts with an uppercase letter
+> - Constructor bodies are limited to simple statements (variable declarations and expression statements)
+> - No control flow statements (`if`, `for`, `while`, `return`, `throw`, etc.) in constructor body
+> - At least one prototype method is defined
+> - Prototype methods must be function expressions (not arrow functions)
+> - Prototype object literals with getters, setters, or computed properties are skipped
+
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-newly-word-dark.svg">
   <source media="(prefers-color-scheme: light)" srcset="https://web-platform-dx.github.io/web-features/assets/img/baseline-newly-word.svg">
@@ -258,6 +299,7 @@ Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is
 [calver]: https://calver.org/
 [django-upgrade]: https://github.com/adamchainz/django-upgrade
 [mdn-arrow-functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
+[mdn-classes]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
 [mdn-const]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const
 [mdn-exponentiation]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation
 [mdn-for-in]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esupgrade",
-  "version": "2025.3.4",
+  "version": "2025.4.0",
   "description": "Auto-upgrade your JavaScript syntax",
   "type": "module",
   "main": "src/index.js",

package/src/widelyAvailable.js

@@ -1363,3 +1363,306 @@ export function arrayConcatToSpread(j, root) {
 
   return { modified, changes }
 }
+
+/**
+ * Transform old-school constructor functions with prototype methods to ES6 class syntax
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
+ */
+export function constructorToClass(j, root) {
+  /**
+   * Check if a function name follows constructor naming convention.
+   * @param {string} name - The function name to check.
+   * @returns {boolean} True if the name starts with an uppercase letter.
+   */
+  function isConstructorName(name) {
+    return name && /^[A-Z]/.test(name)
+  }
+
+  /**
+   * Check if a function body contains only simple constructor statements.
+   * @param {import('jscodeshift').BlockStatement} functionBody - The function body to check.
+   * @returns {boolean} True if the body contains only allowed statements.
+   */
+  function hasSimpleConstructorBody(functionBody) {
+    if (functionBody.body.length === 0) {
+      return true
+    }
+
+    return functionBody.body.every((statement) => {
+      if (j.VariableDeclaration.check(statement)) {
+        return true
+      }
+
+      if (j.ExpressionStatement.check(statement)) {
+        return true
+      }
+
+      return false
+    })
+  }
+
+  /**
+   * Find all constructor functions in the AST.
+   * @param {import('jscodeshift').JSCodeshift} j - The jscodeshift API.
+   * @param {import('jscodeshift').Collection} root - The root AST collection.
+   * @returns {Map<string, { declaration: import('jscodeshift').ASTPath, prototypeMethods: Array<any> }>} Map of constructor names to their info.
+   */
+  function findConstructors(j, root) {
+    const constructors = new Map()
+
+    // Handle function declarations
+    root.find(j.FunctionDeclaration).forEach((path) => {
+      const node = path.node
+      const functionName = node.id ? node.id.name : null
+
+      if (!functionName || !isConstructorName(functionName)) {
+        return
+      }
+
+      if (!hasSimpleConstructorBody(node.body)) {
+        return
+      }
+
+      constructors.set(functionName, {
+        declaration: path,
+        prototypeMethods: [],
+      })
+    })
+
+    // Handle variable declarations with function expressions
+    root.find(j.VariableDeclaration).forEach((path) => {
+      path.node.declarations.forEach((declarator) => {
+        const functionName = declarator.id.name
+
+        if (!isConstructorName(functionName)) {
+          return
+        }
+
+        if (!j.FunctionExpression.check(declarator.init)) {
+          return
+        }
+
+        const functionExpr = declarator.init
+
+        if (!hasSimpleConstructorBody(functionExpr.body)) {
+          return
+        }
+
+        constructors.set(functionName, {
+          declaration: path,
+          prototypeMethods: [],
+        })
+      })
+    })
+
+    return constructors
+  }
+
+  /**
+   * Find and associate prototype methods with constructors.
+   * @param {import('jscodeshift').JSCodeshift} j - The jscodeshift API.
+   * @param {import('jscodeshift').Collection} root - The root AST collection.
+   * @param {Map<string, { declaration: import('jscodeshift').ASTPath, prototypeMethods: Array<any> }>} constructors - Map of constructors.
+   */
+  function findPrototypeMethods(j, root, constructors) {
+    // Pattern 1: ConstructorName.prototype.methodName = ...
+    root
+      .find(j.ExpressionStatement)
+      .filter((path) => {
+        const node = path.node
+        if (!j.AssignmentExpression.check(node.expression)) {
+          return false
+        }
+
+        const assignment = node.expression
+        const left = assignment.left
+
+        if (
+          !j.MemberExpression.check(left) ||
+          !j.MemberExpression.check(left.object) ||
+          !j.Identifier.check(left.object.object) ||
+          !j.Identifier.check(left.object.property) ||
+          left.object.property.name !== "prototype" ||
+          !j.Identifier.check(left.property)
+        ) {
+          return false
+        }
+
+        const constructorName = left.object.object.name
+        return constructors.has(constructorName)
+      })
+      .forEach((path) => {
+        const assignment = path.node.expression
+        const left = assignment.left
+        const constructorName = left.object.object.name
+        const methodName = left.property.name
+        const methodValue = assignment.right
+
+        if (!j.FunctionExpression.check(methodValue)) {
+          return
+        }
+
+        constructors.get(constructorName).prototypeMethods.push({
+          path,
+          methodName,
+          methodValue,
+        })
+      })
+
+    // Pattern 2: ConstructorName.prototype = { methodName: function() {...}, ... }
+    root
+      .find(j.ExpressionStatement)
+      .filter((path) => {
+        const node = path.node
+        if (!j.AssignmentExpression.check(node.expression)) {
+          return false
+        }
+
+        const assignment = node.expression
+        const left = assignment.left
+
+        if (
+          !j.MemberExpression.check(left) ||
+          !j.Identifier.check(left.object) ||
+          !j.Identifier.check(left.property) ||
+          left.property.name !== "prototype"
+        ) {
+          return false
+        }
+
+        const constructorName = left.object.name
+        return constructors.has(constructorName)
+      })
+      .forEach((path) => {
+        const assignment = path.node.expression
+        const left = assignment.left
+        const constructorName = left.object.name
+        const methodValue = assignment.right
+
+        if (!j.ObjectExpression.check(methodValue)) {
+          return
+        }
+
+        methodValue.properties.forEach((prop) => {
+          if (!j.Property.check(prop) && !j.ObjectProperty.check(prop)) {
+            return
+          }
+
+          if (prop.computed) {
+            return
+          }
+
+          let methodName
+          if (j.Identifier.check(prop.key)) {
+            methodName = prop.key.name
+          } else {
+            return
+          }
+
+          if (!j.FunctionExpression.check(prop.value)) {
+            return
+          }
+
+          constructors.get(constructorName).prototypeMethods.push({
+            path,
+            methodName,
+            methodValue: prop.value,
+            isObjectLiteral: true,
+          })
+        })
+      })
+  }
+
+  /**
+   * Transform constructors and their prototype methods to class syntax.
+   * @param {import('jscodeshift').JSCodeshift} j - The jscodeshift API.
+   * @param {import('jscodeshift').Collection} root - The root AST collection.
+   * @param {Map<string, { declaration: import('jscodeshift').ASTPath, prototypeMethods: Array<any> }>} constructors - Map of constructors.
+   * @returns {{ modified: boolean, changes: Array<{ type: string, line: number }> }} Transformation result.
+   */
+  function transformConstructorsToClasses(j, root, constructors) {
+    let modified = false
+    const changes = []
+
+    constructors.forEach((info, constructorName) => {
+      if (info.prototypeMethods.length === 0) {
+        return
+      }
+
+      const declarationPath = info.declaration
+      const declarationNode = declarationPath.node
+
+      let constructorNode
+      if (j.FunctionDeclaration.check(declarationNode)) {
+        constructorNode = declarationNode
+      } else {
+        const declarator = declarationNode.declarations.find(
+          (decl) => decl.id.name === constructorName,
+        )
+        constructorNode = declarator.init
+      }
+
+      const classBody = []
+
+      const constructorMethod = j.methodDefinition(
+        "constructor",
+        j.identifier("constructor"),
+        j.functionExpression(
+          null,
+          constructorNode.params,
+          constructorNode.body,
+          constructorNode.generator,
+          constructorNode.async,
+        ),
+        false,
+      )
+      classBody.push(constructorMethod)
+
+      info.prototypeMethods.forEach(({ methodName, methodValue }) => {
+        const method = j.methodDefinition(
+          "method",
+          j.identifier(methodName),
+          j.functionExpression(
+            null,
+            methodValue.params,
+            methodValue.body,
+            methodValue.generator,
+            methodValue.async,
+          ),
+          false,
+        )
+        classBody.push(method)
+      })
+
+      const classDeclaration = j.classDeclaration(
+        j.identifier(constructorName),
+        j.classBody(classBody),
+      )
+
+      j(info.declaration).replaceWith(classDeclaration)
+
+      const pathsToRemove = new Set()
+      info.prototypeMethods.forEach(({ path }) => {
+        pathsToRemove.add(path)
+      })
+
+      pathsToRemove.forEach((path) => {
+        j(path).remove()
+      })
+
+      modified = true
+      if (constructorNode.loc) {
+        changes.push({
+          type: "constructorToClass",
+          line: constructorNode.loc.start.line,
+        })
+      }
+    })
+
+    return { modified, changes }
+  }
+
+  const constructors = findConstructors(j, root)
+  findPrototypeMethods(j, root, constructors)
+  return transformConstructorsToClasses(j, root, constructors)
+}

package/tests/widelyAvailable.test.js

@@ -2175,4 +2175,579 @@ const result = [1, 2].concat(other);`)
       assert.match(result.code, /`Hello \$\{userName\}`/)
     })
   })
+
+  describe("constructorToClass", () => {
+    test("simple constructor with prototype methods", () => {
+      const result = transform(`
+function Person(name) {
+  this.name = name;
+}
+
+Person.prototype.greet = function() {
+  return 'Hello, ' + this.name;
+};
+      `)
+
+      assert(result.modified, "transform constructor to class")
+      assert.match(result.code, /class Person/)
+      assert.match(result.code, /constructor\(name\)/)
+      assert.match(result.code, /greet\(\)/)
+    })
+
+    test("constructor with multiple prototype methods", () => {
+      const result = transform(`
+function Animal(type) {
+  this.type = type;
+}
+
+Animal.prototype.speak = function() {
+  return this.type + ' makes a sound';
+};
+
+Animal.prototype.move = function() {
+  return this.type + ' is moving';
+};
+      `)
+
+      assert(result.modified, "transform constructor with multiple methods")
+      assert.match(result.code, /class Animal/)
+      assert.match(result.code, /speak\(\)/)
+      assert.match(result.code, /move\(\)/)
+    })
+
+    test("skip lowercase function names", () => {
+      const result = transform(`
+function helper(value) {
+  this.value = value;
+}
+
+helper.prototype.process = function() {
+  return this.value * 2;
+};
+      `)
+
+      assert(!result.modified, "skip lowercase function names")
+      assert.match(result.code, /function helper/)
+    })
+
+    test("skip constructor without prototype methods", () => {
+      const result = transform(`
+function Person(name) {
+  this.name = name;
+}
+      `)
+
+      assert(!result.modified, "skip constructor without prototype methods")
+      assert.match(result.code, /function Person/)
+    })
+
+    test("skip if not all methods are function expressions", () => {
+      const result = transform(`
+function Person(name) {
+  this.name = name;
+}
+
+Person.prototype.greet = () => {
+  return 'Hello';
+};
+      `)
+
+      assert(!result.modified, "skip arrow functions on prototype")
+      assert.match(result.code, /function Person/)
+    })
+
+    test("constructor with no parameters", () => {
+      const result = transform(`
+function Counter() {
+  this.count = 0;
+}
+
+Counter.prototype.increment = function() {
+  this.count++;
+};
+      `)
+
+      assert(result.modified, "transform constructor with no parameters")
+      assert.match(result.code, /class Counter/)
+      assert.match(result.code, /constructor\(\)/)
+      assert.match(result.code, /increment\(\)/)
+    })
+
+    test("transform constructor with variable declarations in body", () => {
+      const result = transform(`
+function Person(name) {
+  this.name = name;
+  const temp = processName(name);
+  this.processed = temp;
+}
+
+Person.prototype.greet = function() {
+  return 'Hello, I am ' + this.name;
+};
+      `)
+
+      // The constructor can be safely transformed even with variable declarations
+      assert.match(result.code, /class Person/)
+      assert.match(result.code, /constructor\(name\)/)
+      assert.match(result.code, /greet\(\)/)
+    })
+
+    test("constructor with expression body statements", () => {
+      const result = transform(`
+function Person(name, age) {
+  this.name = name;
+  this.age = age;
+}
+
+Person.prototype.greet = function() {
+  return 'Hello, ' + this.name;
+};
+
+Person.prototype.getAge = function() {
+  return this.age;
+};
+      `)
+
+      assert(result.modified, "transform constructor with multiple properties")
+      assert.match(result.code, /class Person/)
+      assert.match(result.code, /constructor\(name, age\)/)
+    })
+
+    test("skip factory pattern with return statement", () => {
+      const result = transform(`
+function Something() {
+  var depth = 0;
+  return {
+    incDepth: function() {
+      depth++;
+    }
+  };
+}
+
+foo = Something();
+      `)
+
+      // Factory pattern should not be transformed to a class
+      assert.match(result.code, /function Something/)
+      assert.doesNotMatch(result.code, /class Something/)
+    })
+
+    test("skip constructor with return statement", () => {
+      const result = transform(`
+function Factory(config) {
+  this.config = config;
+  return this.config;
+}
+
+Factory.prototype.process = function() {
+  return this.config;
+};
+      `)
+
+      // Constructor with return statement should not be transformed
+      assert.match(result.code, /function Factory/)
+      assert.doesNotMatch(result.code, /class Factory/)
+    })
+
+    test("skip function expression with method call in constructor", () => {
+      const result = transform(`
+var SomeClass = function (selector) {
+  this.element = document.querySelector(selector);
+  this.init();
+};
+
+SomeClass.prototype = {
+  init: function () {
+    console.log('init');
+  }
+};
+      `)
+
+      // Constructor with method call should not be transformed (not a simple constructor)
+      assert.doesNotMatch(result.code, /class SomeClass/)
+    })
+
+    test("skip prototype assignment with non-function methods", () => {
+      const result = transform(`
+function Widget(id) {
+  this.id = id;
+}
+
+Widget.prototype = {
+  value: 42
+};
+      `)
+
+      assert(!result.modified, "skip prototype object without function expressions")
+      assert.match(result.code, /function Widget/)
+    })
+
+    test("skip prototype assignment with arrow function methods", () => {
+      const result = transform(`
+function Component(props) {
+  this.props = props;
+}
+
+Component.prototype = {
+  render: () => {
+    return null;
+  }
+};
+      `)
+
+      assert(!result.modified, "skip prototype object with arrow functions")
+      assert.match(result.code, /function Component/)
+    })
+
+    test("skip prototype assignment with getter/setter properties", () => {
+      const result = transform(`
+function Model(name) {
+  this.name = name;
+}
+
+Model.prototype = {
+  get value() {
+    return this.name;
+  }
+};
+      `)
+
+      assert(!result.modified, "skip prototype object with getter properties")
+      assert.match(result.code, /function Model/)
+    })
+
+    test("skip prototype assignment with computed properties", () => {
+      const result = transform(`
+function Handler(type) {
+  this.type = type;
+}
+
+Handler.prototype = {
+  [Symbol.toStringTag]: function() {
+    return this.type;
+  }
+};
+      `)
+
+      assert(!result.modified, "skip prototype object with computed properties")
+      assert.match(result.code, /function Handler/)
+    })
+
+    test("skip constructor with complex body statements", () => {
+      const result = transform(`
+function Service(config) {
+  if (config) {
+    this.config = config;
+  }
+}
+
+Service.prototype.init = function() {
+  return this.config;
+};
+      `)
+
+      assert(!result.modified, "skip constructor with if statement")
+      assert.match(result.code, /function Service/)
+    })
+
+    test("skip prototype method assignment with non-function value", () => {
+      const result = transform(`
+function Manager(id) {
+  this.id = id;
+}
+
+Manager.prototype.defaultValue = 10;
+      `)
+
+      assert(!result.modified, "skip prototype with non-function assignment")
+      assert.match(result.code, /function Manager/)
+    })
+
+    test("variable declaration constructor with generator method", () => {
+      const result = transform(`
+var Generator = function(data) {
+  this.data = data;
+}
+
+Generator.prototype.process = function*() {
+  yield this.data;
+};
+      `)
+
+      assert(result.modified, "transform constructor with generator method")
+      assert.match(result.code, /class Generator/)
+      assert.match(result.code, /\*process/)
+    })
+
+    test("skip pattern 2 assignment with non-object value", () => {
+      const result = transform(`
+function Parser(input) {
+  this.input = input;
+}
+
+Parser.prototype = null;
+      `)
+
+      assert(!result.modified, "skip prototype assignment to non-object")
+      assert.match(result.code, /function Parser/)
+    })
+
+    test("constructor with block statement in body", () => {
+      const result = transform(`
+function Strict(mode) {
+  'use strict';
+  this.mode = mode;
+}
+
+Strict.prototype.check = function() {
+  return this.mode;
+};
+      `)
+
+      assert(result.modified, "transform constructor with directive")
+      assert.match(result.code, /class Strict/)
+    })
+
+    test("variable declaration constructor with prototype methods", () => {
+      const result = transform(`
+var Calculator = function(value) {
+  this.value = value;
+}
+
+Calculator.prototype.add = function(num) {
+  return this.value + num;
+};
+      `)
+
+      assert(result.modified, "transform variable declaration constructor")
+      assert.match(result.code, /class Calculator/)
+    })
+
+    test("skip constructor with throw statement in body", () => {
+      const result = transform(`
+function Validator(value) {
+  if (!value) {
+    throw new Error('invalid');
+  }
+  this.value = value;
+}
+
+Validator.prototype.validate = function() {
+  return this.value;
+};
+      `)
+
+      assert(!result.modified, "skip constructor with throw")
+      assert.match(result.code, /function Validator/)
+    })
+
+    test("transform constructor with only assignment statements", () => {
+      const result = transform(`
+function Iterator(items) {
+  this.items = items;
+  this.index = 0;
+}
+
+Iterator.prototype.next = function() {
+  return this.items[this.index++];
+};
+      `)
+
+      assert(result.modified, "transform constructor with safe body")
+      assert.match(result.code, /class Iterator/)
+    })
+
+    test("skip constructor with computed property in prototype literal", () => {
+      const result = transform(`
+function Handler(type) {
+  this.type = type;
+}
+
+Handler.prototype = {
+  [Symbol.toStringTag]: function() {
+    return this.type;
+  }
+};
+      `)
+
+      assert(!result.modified, "skip prototype with computed property")
+      assert.match(result.code, /function Handler/)
+    })
+
+    test("prototype literal with non-identifier properties", () => {
+      const result = transform(`
+function Component(props) {
+  this.props = props;
+}
+
+Component.prototype = {
+  'method-name': function() {
+    return this.props;
+  }
+};
+      `)
+
+      assert(!result.modified, "skip prototype literal with string keys")
+      assert.match(result.code, /function Component/)
+    })
+
+    test("constructor with return statement prevents transformation", () => {
+      const result = transform(`
+function Creator(config) {
+  this.config = config;
+  if (!config) {
+    return;
+  }
+}
+
+Creator.prototype.start = function() {
+  return this.config;
+};
+      `)
+
+      assert(!result.modified, "skip constructor with return")
+      assert.match(result.code, /function Creator/)
+    })
+
+    test("prototype object with only getter property", () => {
+      const result = transform(`
+function Box(value) {
+  this.value = value;
+}
+
+Box.prototype = {
+  get size() {
+    return this.value * 2;
+  }
+};
+      `)
+
+      assert(!result.modified, "skip constructor when only getter in prototype")
+      assert.match(result.code, /function Box/)
+    })
+
+    test("prototype object with getter and function method", () => {
+      const result = transform(`
+function Box(value) {
+  this.value = value;
+}
+
+Box.prototype = {
+  get size() {
+    return this.value * 2;
+  },
+  getValue: function() {
+    return this.value;
+  }
+};
+      `)
+
+      assert(result.modified, "transform constructor ignoring getter property")
+      assert.match(result.code, /class Box/)
+    })
+
+    test("prototype object with only non-function property", () => {
+      const result = transform(`
+function Widget(id) {
+  this.id = id;
+}
+
+Widget.prototype = {
+  config: { timeout: 1000 }
+};
+      `)
+
+      assert(!result.modified, "skip constructor when no function methods")
+      assert.match(result.code, /function Widget/)
+    })
+
+    test("prototype object with non-function and function properties", () => {
+      const result = transform(`
+function Widget(id) {
+  this.id = id;
+}
+
+Widget.prototype = {
+  config: { timeout: 1000 },
+  getValue: function() {
+    return this.id;
+  }
+};
+      `)
+
+      assert(result.modified, "transform constructor ignoring non-function property")
+      assert.match(result.code, /class Widget/)
+    })
+
+    test("skip var declaration with arrow function", () => {
+      const result = transform(`
+var Calculator = (value) => {
+  this.value = value;
+};
+
+Calculator.prototype.add = function(num) {
+  return this.value + num;
+};
+      `)
+
+      assert.doesNotMatch(
+        result.code,
+        /class Calculator/,
+        "skip arrow function constructor",
+      )
+    })
+
+    test("skip var declaration constructor with complex body", () => {
+      const result = transform(`
+var Service = function(config) {
+  if (config) {
+    this.config = config;
+  }
+};
+
+Service.prototype.init = function() {
+  return this.config;
+};
+      `)
+
+      assert.doesNotMatch(
+        result.code,
+        /class Service/,
+        "skip var declaration with complex body",
+      )
+    })
+
+    test("var declaration prototype with getter property", () => {
+      const result = transform(`
+var Box = function(value) {
+  this.value = value;
+};
+
+Box.prototype = {
+  get size() {
+    return this.value * 2;
+  }
+};
+      `)
+
+      assert.doesNotMatch(
+        result.code,
+        /class Box/,
+        "skip var declaration with getter prototype",
+      )
+    })
+
+    test("function declaration constructor with empty body", () => {
+      const result = transform(`
+function Empty() {}
+
+Empty.prototype.run = function() {
+  return this.value;
+};
+      `)
+
+      assert(result.modified, "transform function declaration with empty body")
+      assert.match(result.code, /class Empty/)
+    })
+  })
 })

package/AGENTS.md

@@ -1,5 +0,0 @@
-When writing code, you MUST ALWAYS follow the [naming-things](https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md) guidelines.
-
-All code must be fully tested with a 100% coverage. Unreachable code must be removed.
-
-All transformers must be documented in the README.md.