@babel/plugin-proposal-decorators 8.0.0-alpha.1 → 8.0.0-alpha.11

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+import * as _babel_core from '@babel/core';
+import { Options as Options$1 } from '@babel/plugin-syntax-decorators';
+
+interface Options extends Options$1 {
+    /** @deprecated use `constantSuper` assumption instead. Only supported in 2021-12 version. */
+    loose?: boolean;
+}
+
+declare const _default: (api: _babel_core.PluginAPI, options: Options, dirname: string) => _babel_core.PluginObject<_babel_core.PluginPass<{}>>;
+//# sourceMappingURL=index.d.ts.map
+
+export { type Options, _default as default };

package/lib/index.js

@@ -1,9 +1,7 @@
 import { declare } from '@babel/helper-plugin-utils';
 import syntaxDecorators from '@babel/plugin-syntax-decorators';
-import '@babel/helper-create-class-features-plugin';
+import { createClassFeaturePlugin, FEATURES } from '@babel/helper-create-class-features-plugin';
 import { template, types } from '@babel/core';
-import ReplaceSupers from '@babel/helper-replace-supers';
-import splitExportDeclaration from '@babel/helper-split-export-declaration';
 
 const buildClassDecorator = template.statement(`
   DECORATOR(CLASS_REF = INNER) || CLASS_REF;
@@ -157,624 +155,8 @@ const visitor = {
   }
 };
 
-function incrementId(id, idx = id.length - 1) {
-  if (idx === -1) {
-    id.unshift(65);
-    return;
-  }
-  const current = id[idx];
-  if (current === 90) {
-    id[idx] = 97;
-  } else if (current === 122) {
-    id[idx] = 65;
-    incrementId(id, idx - 1);
-  } else {
-    id[idx] = current + 1;
-  }
-}
-function createPrivateUidGeneratorForClass(classPath) {
-  const currentPrivateId = [];
-  const privateNames = new Set();
-  classPath.traverse({
-    PrivateName(path) {
-      privateNames.add(path.node.id.name);
-    }
-  });
-  return () => {
-    let reifiedId;
-    do {
-      incrementId(currentPrivateId);
-      reifiedId = String.fromCharCode(...currentPrivateId);
-    } while (privateNames.has(reifiedId));
-    return types.privateName(types.identifier(reifiedId));
-  };
-}
-function createLazyPrivateUidGeneratorForClass(classPath) {
-  let generator;
-  return () => {
-    if (!generator) {
-      generator = createPrivateUidGeneratorForClass(classPath);
-    }
-    return generator();
-  };
-}
-function replaceClassWithVar(path) {
-  if (path.type === "ClassDeclaration") {
-    const varId = path.scope.generateUidIdentifierBasedOnNode(path.node.id);
-    const classId = types.identifier(path.node.id.name);
-    path.scope.rename(classId.name, varId.name);
-    path.insertBefore(types.variableDeclaration("let", [types.variableDeclarator(varId)]));
-    path.get("id").replaceWith(classId);
-    return [types.cloneNode(varId), path];
-  } else {
-    let className;
-    let varId;
-    if (path.node.id) {
-      className = path.node.id.name;
-      varId = path.scope.parent.generateDeclaredUidIdentifier(className);
-      path.scope.rename(className, varId.name);
-    } else if (path.parentPath.node.type === "VariableDeclarator" && path.parentPath.node.id.type === "Identifier") {
-      className = path.parentPath.node.id.name;
-      varId = path.scope.parent.generateDeclaredUidIdentifier(className);
-    } else {
-      varId = path.scope.parent.generateDeclaredUidIdentifier("decorated_class");
-    }
-    const newClassExpr = types.classExpression(className && types.identifier(className), path.node.superClass, path.node.body);
-    const [newPath] = path.replaceWith(types.sequenceExpression([newClassExpr, varId]));
-    return [types.cloneNode(varId), newPath.get("expressions.0")];
-  }
-}
-function generateClassProperty(key, value, isStatic) {
-  if (key.type === "PrivateName") {
-    return types.classPrivateProperty(key, value, undefined, isStatic);
-  } else {
-    return types.classProperty(key, value, undefined, undefined, isStatic);
-  }
-}
-function addProxyAccessorsFor(className, element, originalKey, targetKey, version, isComputed = false) {
-  const {
-    static: isStatic
-  } = element.node;
-  const thisArg = version === "2023-05" && isStatic ? className : types.thisExpression();
-  const getterBody = types.blockStatement([types.returnStatement(types.memberExpression(types.cloneNode(thisArg), types.cloneNode(targetKey)))]);
-  const setterBody = types.blockStatement([types.expressionStatement(types.assignmentExpression("=", types.memberExpression(types.cloneNode(thisArg), types.cloneNode(targetKey)), types.identifier("v")))]);
-  let getter, setter;
-  if (originalKey.type === "PrivateName") {
-    getter = types.classPrivateMethod("get", types.cloneNode(originalKey), [], getterBody, isStatic);
-    setter = types.classPrivateMethod("set", types.cloneNode(originalKey), [types.identifier("v")], setterBody, isStatic);
-  } else {
-    getter = types.classMethod("get", types.cloneNode(originalKey), [], getterBody, isComputed, isStatic);
-    setter = types.classMethod("set", types.cloneNode(originalKey), [types.identifier("v")], setterBody, isComputed, isStatic);
-  }
-  element.insertAfter(setter);
-  element.insertAfter(getter);
-}
-function extractProxyAccessorsFor(targetKey, version) {
-  if (version !== "2023-05" && version !== "2023-01") {
-    return [template.expression.ast`
-        function () {
-          return this.${types.cloneNode(targetKey)};
-        }
-      `, template.expression.ast`
-        function (value) {
-          this.${types.cloneNode(targetKey)} = value;
-        }
-      `];
-  }
-  return [template.expression.ast`
-      o => o.${types.cloneNode(targetKey)}
-    `, template.expression.ast`
-      (o, v) => o.${types.cloneNode(targetKey)} = v
-    `];
-}
-const FIELD = 0;
-const ACCESSOR = 1;
-const METHOD = 2;
-const GETTER = 3;
-const SETTER = 4;
-const STATIC_OLD_VERSION = 5;
-const STATIC = 8;
-const DECORATORS_HAVE_THIS = 16;
-function getElementKind(element) {
-  switch (element.node.type) {
-    case "ClassProperty":
-    case "ClassPrivateProperty":
-      return FIELD;
-    case "ClassAccessorProperty":
-      return ACCESSOR;
-    case "ClassMethod":
-    case "ClassPrivateMethod":
-      if (element.node.kind === "get") {
-        return GETTER;
-      } else if (element.node.kind === "set") {
-        return SETTER;
-      } else {
-        return METHOD;
-      }
-  }
-}
-function isDecoratorInfo(info) {
-  return "decorators" in info;
-}
-function filteredOrderedDecoratorInfo(info) {
-  const filtered = info.filter(isDecoratorInfo);
-  return [...filtered.filter(el => el.isStatic && el.kind >= ACCESSOR && el.kind <= SETTER), ...filtered.filter(el => !el.isStatic && el.kind >= ACCESSOR && el.kind <= SETTER), ...filtered.filter(el => el.isStatic && el.kind === FIELD), ...filtered.filter(el => !el.isStatic && el.kind === FIELD)];
-}
-function generateDecorationList(decorators, decoratorsThis, version) {
-  const decsCount = decorators.length;
-  const hasOneThis = decoratorsThis.some(Boolean);
-  const decs = [];
-  for (let i = 0; i < decsCount; i++) {
-    if (version === "2023-05" && hasOneThis) {
-      decs.push(decoratorsThis[i] || types.unaryExpression("void", types.numericLiteral(0)));
-    }
-    decs.push(decorators[i]);
-  }
-  return {
-    hasThis: hasOneThis,
-    decs
-  };
-}
-function generateDecorationExprs(info, version) {
-  return types.arrayExpression(filteredOrderedDecoratorInfo(info).map(el => {
-    const {
-      decs,
-      hasThis
-    } = generateDecorationList(el.decorators, el.decoratorsThis, version);
-    let flag = el.kind;
-    if (el.isStatic) {
-      flag += version === "2023-05" ? STATIC : STATIC_OLD_VERSION;
-    }
-    if (hasThis) flag += DECORATORS_HAVE_THIS;
-    return types.arrayExpression([decs.length === 1 ? decs[0] : types.arrayExpression(decs), types.numericLiteral(flag), el.name, ...(el.privateMethods || [])]);
-  }));
-}
-function extractElementLocalAssignments(decorationInfo) {
-  const localIds = [];
-  for (const el of filteredOrderedDecoratorInfo(decorationInfo)) {
-    const {
-      locals
-    } = el;
-    if (Array.isArray(locals)) {
-      localIds.push(...locals);
-    } else if (locals !== undefined) {
-      localIds.push(locals);
-    }
-  }
-  return localIds;
-}
-function addCallAccessorsFor(element, key, getId, setId) {
-  element.insertAfter(types.classPrivateMethod("get", types.cloneNode(key), [], types.blockStatement([types.returnStatement(types.callExpression(types.cloneNode(getId), [types.thisExpression()]))])));
-  element.insertAfter(types.classPrivateMethod("set", types.cloneNode(key), [types.identifier("v")], types.blockStatement([types.expressionStatement(types.callExpression(types.cloneNode(setId), [types.thisExpression(), types.identifier("v")]))])));
-}
-function isNotTsParameter(node) {
-  return node.type !== "TSParameterProperty";
-}
-function movePrivateAccessor(element, key, methodLocalVar, isStatic) {
-  let params;
-  let block;
-  if (element.node.kind === "set") {
-    params = [types.identifier("v")];
-    block = [types.expressionStatement(types.callExpression(methodLocalVar, [types.thisExpression(), types.identifier("v")]))];
-  } else {
-    params = [];
-    block = [types.returnStatement(types.callExpression(methodLocalVar, [types.thisExpression()]))];
-  }
-  element.replaceWith(types.classPrivateMethod(element.node.kind, types.cloneNode(key), params, types.blockStatement(block), isStatic));
-}
-function isClassDecoratableElementPath(path) {
-  const {
-    type
-  } = path;
-  return type !== "TSDeclareMethod" && type !== "TSIndexSignature" && type !== "StaticBlock";
-}
-function staticBlockToIIFE(block) {
-  return types.callExpression(types.arrowFunctionExpression([], types.blockStatement(block.body)), []);
-}
-function maybeSequenceExpression(exprs) {
-  if (exprs.length === 0) return types.unaryExpression("void", types.numericLiteral(0));
-  if (exprs.length === 1) return exprs[0];
-  return types.sequenceExpression(exprs);
-}
-function transformClass(path, state, constantSuper, version) {
-  const body = path.get("body.body");
-  const classDecorators = path.node.decorators;
-  let hasElementDecorators = false;
-  const generateClassPrivateUid = createLazyPrivateUidGeneratorForClass(path);
-  for (const element of body) {
-    if (!isClassDecoratableElementPath(element)) {
-      continue;
-    }
-    if (element.node.decorators && element.node.decorators.length > 0) {
-      hasElementDecorators = true;
-    } else if (element.node.type === "ClassAccessorProperty") {
-      const {
-        key,
-        value,
-        static: isStatic,
-        computed
-      } = element.node;
-      const newId = generateClassPrivateUid();
-      const valueNode = value ? types.cloneNode(value) : undefined;
-      const newField = generateClassProperty(newId, valueNode, isStatic);
-      const [newPath] = element.replaceWith(newField);
-      addProxyAccessorsFor(path.node.id, newPath, key, newId, version, computed);
-    }
-  }
-  if (!classDecorators && !hasElementDecorators) return;
-  const elementDecoratorInfo = [];
-  let firstFieldPath;
-  let constructorPath;
-  let requiresProtoInit = false;
-  let requiresStaticInit = false;
-  const decoratedPrivateMethods = new Set();
-  let protoInitLocal, staticInitLocal, classInitLocal, classIdLocal;
-  const assignments = [];
-  const scopeParent = path.scope.parent;
-  const memoiseExpression = (expression, hint) => {
-    const localEvaluatedId = scopeParent.generateDeclaredUidIdentifier(hint);
-    assignments.push(types.assignmentExpression("=", localEvaluatedId, expression));
-    return types.cloneNode(localEvaluatedId);
-  };
-  const decoratorsThis = new Map();
-  const maybeExtractDecorator = decorator => {
-    const {
-      expression
-    } = decorator;
-    if (version === "2023-05" && types.isMemberExpression(expression)) {
-      let object;
-      if (types.isSuper(expression.object) || types.isThisExpression(expression.object)) {
-        object = memoiseExpression(types.thisExpression(), "obj");
-      } else if (!scopeParent.isStatic(expression.object)) {
-        object = memoiseExpression(expression.object, "obj");
-        expression.object = object;
-      } else {
-        object = expression.object;
-      }
-      decoratorsThis.set(decorator, types.cloneNode(object));
-    }
-    if (!scopeParent.isStatic(expression)) {
-      decorator.expression = memoiseExpression(expression, "dec");
-    }
-  };
-  if (classDecorators) {
-    classInitLocal = scopeParent.generateDeclaredUidIdentifier("initClass");
-    const [classId, classPath] = replaceClassWithVar(path);
-    path = classPath;
-    classIdLocal = classId;
-    path.node.decorators = null;
-    for (const classDecorator of classDecorators) {
-      maybeExtractDecorator(classDecorator);
-    }
-  } else {
-    if (!path.node.id) {
-      path.node.id = path.scope.generateUidIdentifier("Class");
-    }
-    classIdLocal = types.cloneNode(path.node.id);
-  }
-  let lastInstancePrivateName;
-  let needsInstancePrivateBrandCheck = false;
-  if (hasElementDecorators) {
-    for (const element of body) {
-      if (!isClassDecoratableElementPath(element)) {
-        continue;
-      }
-      const {
-        node
-      } = element;
-      const decorators = element.get("decorators");
-      const hasDecorators = Array.isArray(decorators) && decorators.length > 0;
-      if (hasDecorators) {
-        for (const decoratorPath of decorators) {
-          maybeExtractDecorator(decoratorPath.node);
-        }
-      }
-      const isComputed = "computed" in element.node && element.node.computed === true;
-      if (isComputed) {
-        if (!scopeParent.isStatic(node.key)) {
-          node.key = memoiseExpression(node.key, "computedKey");
-        }
-      }
-      const kind = getElementKind(element);
-      const {
-        key
-      } = node;
-      const isPrivate = key.type === "PrivateName";
-      const isStatic = !!element.node.static;
-      let name = "computedKey";
-      if (isPrivate) {
-        name = key.id.name;
-      } else if (!isComputed && key.type === "Identifier") {
-        name = key.name;
-      }
-      if (isPrivate && !isStatic) {
-        if (hasDecorators) {
-          needsInstancePrivateBrandCheck = true;
-        }
-        if (types.isClassPrivateProperty(node) || !lastInstancePrivateName) {
-          lastInstancePrivateName = key;
-        }
-      }
-      if (element.isClassMethod({
-        kind: "constructor"
-      })) {
-        constructorPath = element;
-      }
-      if (hasDecorators) {
-        let locals;
-        let privateMethods;
-        if (kind === ACCESSOR) {
-          const {
-            value
-          } = element.node;
-          const params = [types.thisExpression()];
-          if (value) {
-            params.push(types.cloneNode(value));
-          }
-          const newId = generateClassPrivateUid();
-          const newFieldInitId = element.scope.parent.generateDeclaredUidIdentifier(`init_${name}`);
-          const newValue = types.callExpression(types.cloneNode(newFieldInitId), params);
-          const newField = generateClassProperty(newId, newValue, isStatic);
-          const [newPath] = element.replaceWith(newField);
-          if (isPrivate) {
-            privateMethods = extractProxyAccessorsFor(newId, version);
-            const getId = newPath.scope.parent.generateDeclaredUidIdentifier(`get_${name}`);
-            const setId = newPath.scope.parent.generateDeclaredUidIdentifier(`set_${name}`);
-            addCallAccessorsFor(newPath, key, getId, setId);
-            locals = [newFieldInitId, getId, setId];
-          } else {
-            addProxyAccessorsFor(path.node.id, newPath, key, newId, version, isComputed);
-            locals = newFieldInitId;
-          }
-        } else if (kind === FIELD) {
-          const initId = element.scope.parent.generateDeclaredUidIdentifier(`init_${name}`);
-          const valuePath = element.get("value");
-          valuePath.replaceWith(types.callExpression(types.cloneNode(initId), [types.thisExpression(), valuePath.node].filter(v => v)));
-          locals = initId;
-          if (isPrivate) {
-            privateMethods = extractProxyAccessorsFor(key, version);
-          }
-        } else if (isPrivate) {
-          locals = element.scope.parent.generateDeclaredUidIdentifier(`call_${name}`);
-          const replaceSupers = new ReplaceSupers({
-            constantSuper,
-            methodPath: element,
-            objectRef: classIdLocal,
-            superRef: path.node.superClass,
-            file: state.file,
-            refToPreserve: classIdLocal
-          });
-          replaceSupers.replace();
-          const {
-            params,
-            body,
-            async: isAsync
-          } = element.node;
-          privateMethods = [types.functionExpression(undefined, params.filter(isNotTsParameter), body, isAsync)];
-          if (kind === GETTER || kind === SETTER) {
-            movePrivateAccessor(element, types.cloneNode(key), types.cloneNode(locals), isStatic);
-          } else {
-            const node = element.node;
-            path.node.body.body.unshift(types.classPrivateProperty(key, types.cloneNode(locals), [], node.static));
-            decoratedPrivateMethods.add(key.id.name);
-            element.remove();
-          }
-        }
-        let nameExpr;
-        if (isComputed) {
-          nameExpr = types.cloneNode(key);
-        } else if (key.type === "PrivateName") {
-          nameExpr = types.stringLiteral(key.id.name);
-        } else if (key.type === "Identifier") {
-          nameExpr = types.stringLiteral(key.name);
-        } else {
-          nameExpr = types.cloneNode(key);
-        }
-        elementDecoratorInfo.push({
-          kind,
-          decorators: decorators.map(d => d.node.expression),
-          decoratorsThis: decorators.map(d => decoratorsThis.get(d.node)),
-          name: nameExpr,
-          isStatic,
-          privateMethods,
-          locals
-        });
-        if (kind !== FIELD) {
-          if (isStatic) {
-            requiresStaticInit = true;
-          } else {
-            requiresProtoInit = true;
-          }
-        }
-        if (element.node) {
-          element.node.decorators = null;
-        }
-        if (!firstFieldPath && !isStatic && (kind === FIELD || kind === ACCESSOR)) {
-          firstFieldPath = element;
-        }
-      }
-    }
-  }
-  const elementDecorations = generateDecorationExprs(elementDecoratorInfo, version);
-  let classDecorationsFlag = 0;
-  let classDecorations = [];
-  if (classDecorators) {
-    const {
-      hasThis,
-      decs
-    } = generateDecorationList(classDecorators.map(el => el.expression), classDecorators.map(dec => decoratorsThis.get(dec)), version);
-    classDecorationsFlag = hasThis ? 1 : 0;
-    classDecorations = decs;
-  }
-  const elementLocals = extractElementLocalAssignments(elementDecoratorInfo);
-  if (requiresProtoInit) {
-    protoInitLocal = scopeParent.generateDeclaredUidIdentifier("initProto");
-    elementLocals.push(protoInitLocal);
-    const protoInitCall = types.callExpression(types.cloneNode(protoInitLocal), [types.thisExpression()]);
-    if (firstFieldPath) {
-      const value = firstFieldPath.get("value");
-      const body = [protoInitCall];
-      if (value.node) {
-        body.push(value.node);
-      }
-      value.replaceWith(types.sequenceExpression(body));
-    } else if (constructorPath) {
-      if (path.node.superClass) {
-        path.traverse({
-          CallExpression: {
-            exit(path) {
-              if (!path.get("callee").isSuper()) return;
-              path.replaceWith(types.callExpression(types.cloneNode(protoInitLocal), [path.node]));
-              path.skip();
-            }
-          }
-        });
-      } else {
-        constructorPath.node.body.body.unshift(types.expressionStatement(protoInitCall));
-      }
-    } else {
-      const body = [types.expressionStatement(protoInitCall)];
-      if (path.node.superClass) {
-        body.unshift(types.expressionStatement(types.callExpression(types.super(), [types.spreadElement(types.identifier("args"))])));
-      }
-      path.node.body.body.unshift(types.classMethod("constructor", types.identifier("constructor"), [types.restElement(types.identifier("args"))], types.blockStatement(body)));
-    }
-  }
-  if (requiresStaticInit) {
-    staticInitLocal = scopeParent.generateDeclaredUidIdentifier("initStatic");
-    elementLocals.push(staticInitLocal);
-  }
-  if (decoratedPrivateMethods.size > 0) {
-    path.traverse({
-      PrivateName(path) {
-        if (!decoratedPrivateMethods.has(path.node.id.name)) return;
-        const parentPath = path.parentPath;
-        const parentParentPath = parentPath.parentPath;
-        if (parentParentPath.node.type === "AssignmentExpression" && parentParentPath.node.left === parentPath.node || parentParentPath.node.type === "UpdateExpression" || parentParentPath.node.type === "RestElement" || parentParentPath.node.type === "ArrayPattern" || parentParentPath.node.type === "ObjectProperty" && parentParentPath.node.value === parentPath.node && parentParentPath.parentPath.type === "ObjectPattern" || parentParentPath.node.type === "ForOfStatement" && parentParentPath.node.left === parentPath.node) {
-          throw path.buildCodeFrameError(`Decorated private methods are not updatable, but "#${path.node.id.name}" is updated via this expression.`);
-        }
-      }
-    });
-  }
-  const classLocals = [];
-  let classInitInjected = false;
-  const classInitCall = classInitLocal && types.callExpression(types.cloneNode(classInitLocal), []);
-  const originalClass = path.node;
-  if (classDecorators) {
-    classLocals.push(classIdLocal, classInitLocal);
-    const statics = [];
-    let staticBlocks = [];
-    path.get("body.body").forEach(element => {
-      if (element.isStaticBlock()) {
-        staticBlocks.push(element.node);
-        element.remove();
-        return;
-      }
-      const isProperty = element.isClassProperty() || element.isClassPrivateProperty();
-      if ((isProperty || element.isClassPrivateMethod()) && element.node.static) {
-        if (isProperty && staticBlocks.length > 0) {
-          const allValues = staticBlocks.map(staticBlockToIIFE);
-          if (element.node.value) allValues.push(element.node.value);
-          element.node.value = maybeSequenceExpression(allValues);
-          staticBlocks = [];
-        }
-        element.node.static = false;
-        statics.push(element.node);
-        element.remove();
-      }
-    });
-    if (statics.length > 0 || staticBlocks.length > 0) {
-      const staticsClass = template.expression.ast`
-        class extends ${state.addHelper("identity")} {}
-      `;
-      staticsClass.body.body = [types.staticBlock([types.toStatement(originalClass, true) || types.expressionStatement(originalClass)]), ...statics];
-      const constructorBody = [];
-      const newExpr = types.newExpression(staticsClass, []);
-      if (staticBlocks.length > 0) {
-        constructorBody.push(...staticBlocks.map(staticBlockToIIFE));
-      }
-      if (classInitCall) {
-        classInitInjected = true;
-        constructorBody.push(classInitCall);
-      }
-      if (constructorBody.length > 0) {
-        constructorBody.unshift(types.callExpression(types.super(), [types.cloneNode(classIdLocal)]));
-        staticsClass.body.body.push(types.classMethod("constructor", types.identifier("constructor"), [], types.blockStatement([types.expressionStatement(types.sequenceExpression(constructorBody))])));
-      } else {
-        newExpr.arguments.push(types.cloneNode(classIdLocal));
-      }
-      path.replaceWith(newExpr);
-    }
-  }
-  if (!classInitInjected && classInitCall) {
-    path.node.body.body.push(types.staticBlock([types.expressionStatement(classInitCall)]));
-  }
-  originalClass.body.body.unshift(types.staticBlock([types.expressionStatement(createLocalsAssignment(elementLocals, classLocals, elementDecorations, types.arrayExpression(classDecorations), types.numericLiteral(classDecorationsFlag), needsInstancePrivateBrandCheck ? lastInstancePrivateName : null, state)), requiresStaticInit && types.expressionStatement(types.callExpression(types.cloneNode(staticInitLocal), [types.thisExpression()]))].filter(Boolean)));
-  path.insertBefore(assignments.map(expr => types.expressionStatement(expr)));
-  path.scope.crawl();
-  return path;
-}
-function createLocalsAssignment(elementLocals, classLocals, elementDecorations, classDecorations, classDecorationsFlag, maybePrivateBranName, state, version) {
-  let lhs, rhs;
-  const args = [types.thisExpression(), elementDecorations, classDecorations];
-  {
-    if (maybePrivateBranName || classDecorationsFlag.value !== 0) {
-      args.push(classDecorationsFlag);
-    }
-    if (maybePrivateBranName) {
-      args.push(template.expression.ast`
-            _ => ${types.cloneNode(maybePrivateBranName)} in _
-          `);
-    }
-    rhs = types.callExpression(state.addHelper("applyDecs2305"), args);
-  }
-  if (elementLocals.length > 0) {
-    if (classLocals.length > 0) {
-      lhs = types.objectPattern([types.objectProperty(types.identifier("e"), types.arrayPattern(elementLocals)), types.objectProperty(types.identifier("c"), types.arrayPattern(classLocals))]);
-    } else {
-      lhs = types.arrayPattern(elementLocals);
-      rhs = types.memberExpression(rhs, types.identifier("e"), false, false);
-    }
-  } else {
-    lhs = types.arrayPattern(classLocals);
-    rhs = types.memberExpression(rhs, types.identifier("c"), false, false);
-  }
-  return types.assignmentExpression("=", lhs, rhs);
-}
-function transformer2023_05 ({
-  assertVersion,
-  assumption
-}, {
-  loose
-}, version) {
-  {
-    assertVersion("^7.21.0");
-  }
-  const VISITED = new WeakSet();
-  const constantSuper = assumption("constantSuper") ?? loose;
-  return {
-    name: "proposal-decorators",
-    inherits: syntaxDecorators,
-    visitor: {
-      "ExportNamedDeclaration|ExportDefaultDeclaration"(path) {
-        const {
-          declaration
-        } = path.node;
-        if (declaration?.type === "ClassDeclaration" && declaration.decorators?.length > 0) {
-          splitExportDeclaration(path);
-        }
-      },
-      Class(path, state) {
-        if (VISITED.has(path)) return;
-        const newPath = transformClass(path, state, constantSuper, version);
-        if (newPath) VISITED.add(newPath);
-      }
-    }
-  };
-}
-
 var index = declare((api, options) => {
-  api.assertVersion(7);
+  api.assertVersion("8.0.0-alpha.11");
   const {
     version
   } = options;
@@ -784,10 +166,17 @@ var index = declare((api, options) => {
       inherits: syntaxDecorators,
       visitor: visitor
     };
-  } else if (version === "2021-12" || version === "2022-03" || version === "2023-01" || version === "2023-05") {
-    return transformer2023_05(api, options, version);
+  } else if (!version || version === "2018-09" || version === "2021-12" || version === "2022-03" || version === "2023-01" || version === "2023-05" || version === "2023-11") {
+    api.assertVersion("8.0.0-alpha.11");
+    return createClassFeaturePlugin({
+      name: "proposal-decorators",
+      api,
+      feature: FEATURES.decorators,
+      inherits: syntaxDecorators,
+      decoratorVersion: version
+    });
   } else {
-    throw new Error("The '.version' option must be one of 'legacy', '2021-12', '2022-03', or '2023-01'.");
+    throw new Error("The '.version' option must be one of 'legacy', '2023-11', '2023-05', '2023-01', '2022-03', or '2021-12'.");
   }
 });