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

package/lib/transformer-2023-05.js

@@ -1,631 +0,0 @@
-import { types as t, template } from "@babel/core";
-import syntaxDecorators from "@babel/plugin-syntax-decorators";
-import ReplaceSupers from "@babel/helper-replace-supers";
-import splitExportDeclaration from "@babel/helper-split-export-declaration";
-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 t.privateName(t.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 = t.identifier(path.node.id.name);
-    path.scope.rename(classId.name, varId.name);
-    path.insertBefore(t.variableDeclaration("let", [t.variableDeclarator(varId)]));
-    path.get("id").replaceWith(classId);
-    return [t.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 = t.classExpression(className && t.identifier(className), path.node.superClass, path.node.body);
-    const [newPath] = path.replaceWith(t.sequenceExpression([newClassExpr, varId]));
-    return [t.cloneNode(varId), newPath.get("expressions.0")];
-  }
-}
-function generateClassProperty(key, value, isStatic) {
-  if (key.type === "PrivateName") {
-    return t.classPrivateProperty(key, value, undefined, isStatic);
-  } else {
-    return t.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 : t.thisExpression();
-  const getterBody = t.blockStatement([t.returnStatement(t.memberExpression(t.cloneNode(thisArg), t.cloneNode(targetKey)))]);
-  const setterBody = t.blockStatement([t.expressionStatement(t.assignmentExpression("=", t.memberExpression(t.cloneNode(thisArg), t.cloneNode(targetKey)), t.identifier("v")))]);
-  let getter, setter;
-  if (originalKey.type === "PrivateName") {
-    getter = t.classPrivateMethod("get", t.cloneNode(originalKey), [], getterBody, isStatic);
-    setter = t.classPrivateMethod("set", t.cloneNode(originalKey), [t.identifier("v")], setterBody, isStatic);
-  } else {
-    getter = t.classMethod("get", t.cloneNode(originalKey), [], getterBody, isComputed, isStatic);
-    setter = t.classMethod("set", t.cloneNode(originalKey), [t.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.${t.cloneNode(targetKey)};
-        }
-      `, template.expression.ast`
-        function (value) {
-          this.${t.cloneNode(targetKey)} = value;
-        }
-      `];
-  }
-  return [template.expression.ast`
-      o => o.${t.cloneNode(targetKey)}
-    `, template.expression.ast`
-      (o, v) => o.${t.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] || t.unaryExpression("void", t.numericLiteral(0)));
-    }
-    decs.push(decorators[i]);
-  }
-  return {
-    hasThis: hasOneThis,
-    decs
-  };
-}
-function generateDecorationExprs(info, version) {
-  return t.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 t.arrayExpression([decs.length === 1 ? decs[0] : t.arrayExpression(decs), t.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(t.classPrivateMethod("get", t.cloneNode(key), [], t.blockStatement([t.returnStatement(t.callExpression(t.cloneNode(getId), [t.thisExpression()]))])));
-  element.insertAfter(t.classPrivateMethod("set", t.cloneNode(key), [t.identifier("v")], t.blockStatement([t.expressionStatement(t.callExpression(t.cloneNode(setId), [t.thisExpression(), t.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 = [t.identifier("v")];
-    block = [t.expressionStatement(t.callExpression(methodLocalVar, [t.thisExpression(), t.identifier("v")]))];
-  } else {
-    params = [];
-    block = [t.returnStatement(t.callExpression(methodLocalVar, [t.thisExpression()]))];
-  }
-  element.replaceWith(t.classPrivateMethod(element.node.kind, t.cloneNode(key), params, t.blockStatement(block), isStatic));
-}
-function isClassDecoratableElementPath(path) {
-  const {
-    type
-  } = path;
-  return type !== "TSDeclareMethod" && type !== "TSIndexSignature" && type !== "StaticBlock";
-}
-function staticBlockToIIFE(block) {
-  return t.callExpression(t.arrowFunctionExpression([], t.blockStatement(block.body)), []);
-}
-function maybeSequenceExpression(exprs) {
-  if (exprs.length === 0) return t.unaryExpression("void", t.numericLiteral(0));
-  if (exprs.length === 1) return exprs[0];
-  return t.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 ? t.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(t.assignmentExpression("=", localEvaluatedId, expression));
-    return t.cloneNode(localEvaluatedId);
-  };
-  const decoratorsThis = new Map();
-  const maybeExtractDecorator = decorator => {
-    const {
-      expression
-    } = decorator;
-    if (version === "2023-05" && t.isMemberExpression(expression)) {
-      let object;
-      if (t.isSuper(expression.object) || t.isThisExpression(expression.object)) {
-        object = memoiseExpression(t.thisExpression(), "obj");
-      } else if (!scopeParent.isStatic(expression.object)) {
-        object = memoiseExpression(expression.object, "obj");
-        expression.object = object;
-      } else {
-        object = expression.object;
-      }
-      decoratorsThis.set(decorator, t.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 = t.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 (t.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 = [t.thisExpression()];
-          if (value) {
-            params.push(t.cloneNode(value));
-          }
-          const newId = generateClassPrivateUid();
-          const newFieldInitId = element.scope.parent.generateDeclaredUidIdentifier(`init_${name}`);
-          const newValue = t.callExpression(t.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(t.callExpression(t.cloneNode(initId), [t.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 = [t.functionExpression(undefined, params.filter(isNotTsParameter), body, isAsync)];
-          if (kind === GETTER || kind === SETTER) {
-            movePrivateAccessor(element, t.cloneNode(key), t.cloneNode(locals), isStatic);
-          } else {
-            const node = element.node;
-            path.node.body.body.unshift(t.classPrivateProperty(key, t.cloneNode(locals), [], node.static));
-            decoratedPrivateMethods.add(key.id.name);
-            element.remove();
-          }
-        }
-        let nameExpr;
-        if (isComputed) {
-          nameExpr = t.cloneNode(key);
-        } else if (key.type === "PrivateName") {
-          nameExpr = t.stringLiteral(key.id.name);
-        } else if (key.type === "Identifier") {
-          nameExpr = t.stringLiteral(key.name);
-        } else {
-          nameExpr = t.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 = t.callExpression(t.cloneNode(protoInitLocal), [t.thisExpression()]);
-    if (firstFieldPath) {
-      const value = firstFieldPath.get("value");
-      const body = [protoInitCall];
-      if (value.node) {
-        body.push(value.node);
-      }
-      value.replaceWith(t.sequenceExpression(body));
-    } else if (constructorPath) {
-      if (path.node.superClass) {
-        path.traverse({
-          CallExpression: {
-            exit(path) {
-              if (!path.get("callee").isSuper()) return;
-              path.replaceWith(t.callExpression(t.cloneNode(protoInitLocal), [path.node]));
-              path.skip();
-            }
-          }
-        });
-      } else {
-        constructorPath.node.body.body.unshift(t.expressionStatement(protoInitCall));
-      }
-    } else {
-      const body = [t.expressionStatement(protoInitCall)];
-      if (path.node.superClass) {
-        body.unshift(t.expressionStatement(t.callExpression(t.super(), [t.spreadElement(t.identifier("args"))])));
-      }
-      path.node.body.body.unshift(t.classMethod("constructor", t.identifier("constructor"), [t.restElement(t.identifier("args"))], t.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 && t.callExpression(t.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 = [t.staticBlock([t.toStatement(originalClass, true) || t.expressionStatement(originalClass)]), ...statics];
-      const constructorBody = [];
-      const newExpr = t.newExpression(staticsClass, []);
-      if (staticBlocks.length > 0) {
-        constructorBody.push(...staticBlocks.map(staticBlockToIIFE));
-      }
-      if (classInitCall) {
-        classInitInjected = true;
-        constructorBody.push(classInitCall);
-      }
-      if (constructorBody.length > 0) {
-        constructorBody.unshift(t.callExpression(t.super(), [t.cloneNode(classIdLocal)]));
-        staticsClass.body.body.push(t.classMethod("constructor", t.identifier("constructor"), [], t.blockStatement([t.expressionStatement(t.sequenceExpression(constructorBody))])));
-      } else {
-        newExpr.arguments.push(t.cloneNode(classIdLocal));
-      }
-      path.replaceWith(newExpr);
-    }
-  }
-  if (!classInitInjected && classInitCall) {
-    path.node.body.body.push(t.staticBlock([t.expressionStatement(classInitCall)]));
-  }
-  originalClass.body.body.unshift(t.staticBlock([t.expressionStatement(createLocalsAssignment(elementLocals, classLocals, elementDecorations, t.arrayExpression(classDecorations), t.numericLiteral(classDecorationsFlag), needsInstancePrivateBrandCheck ? lastInstancePrivateName : null, state, version)), requiresStaticInit && t.expressionStatement(t.callExpression(t.cloneNode(staticInitLocal), [t.thisExpression()]))].filter(Boolean)));
-  path.insertBefore(assignments.map(expr => t.expressionStatement(expr)));
-  path.scope.crawl();
-  return path;
-}
-function createLocalsAssignment(elementLocals, classLocals, elementDecorations, classDecorations, classDecorationsFlag, maybePrivateBranName, state, version) {
-  let lhs, rhs;
-  const args = [t.thisExpression(), elementDecorations, classDecorations];
-  ;
-  if (true) {
-    if (maybePrivateBranName || classDecorationsFlag.value !== 0) {
-      args.push(classDecorationsFlag);
-    }
-    if (maybePrivateBranName) {
-      args.push(template.expression.ast`
-            _ => ${t.cloneNode(maybePrivateBranName)} in _
-          `);
-    }
-    rhs = t.callExpression(state.addHelper("applyDecs2305"), args);
-  } else if (version === "2023-01") {
-    if (maybePrivateBranName) {
-      args.push(template.expression.ast`
-            _ => ${t.cloneNode(maybePrivateBranName)} in _
-          `);
-    }
-    rhs = t.callExpression(state.addHelper("applyDecs2301"), args);
-  } else {
-    rhs = t.callExpression(state.addHelper("applyDecs2203R"), args);
-  }
-  if (elementLocals.length > 0) {
-    if (classLocals.length > 0) {
-      lhs = t.objectPattern([t.objectProperty(t.identifier("e"), t.arrayPattern(elementLocals)), t.objectProperty(t.identifier("c"), t.arrayPattern(classLocals))]);
-    } else {
-      lhs = t.arrayPattern(elementLocals);
-      rhs = t.memberExpression(rhs, t.identifier("e"), false, false);
-    }
-  } else {
-    lhs = t.arrayPattern(classLocals);
-    rhs = t.memberExpression(rhs, t.identifier("c"), false, false);
-  }
-  return t.assignmentExpression("=", lhs, rhs);
-}
-export default function ({
-  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);
-      }
-    }
-  };
-}
-
-//# sourceMappingURL=transformer-2023-05.js.map