{"version":3,"names":["buildConstructor","classRef","constructorBody","node","func","t","functionDeclaration","cloneNode","inherits","transformClass","path","file","builtinClasses","isLoose","assumptions","supportUnicodeId","classState","parent","undefined","scope","classId","superFnId","superName","superReturns","isDerived","extendsNative","construct","userConstructor","userConstructorPath","hasConstructor","body","superThises","pushedConstructor","pushedInherits","pushedCreateClass","protoAlias","dynamicKeys","Map","methods","instance","hasComputed","list","map","static","setState","newState","Object","assign","findThisesVisitor","traverse","visitors","merge","environmentVisitor","ThisExpression","push","createClassHelper","args","callExpression","addHelper","maybeCreateConstructor","paths","get","equals","params","constructor","template","expression","ast","blockStatement","unshiftContainer","classMethod","identifier","buildBody","pushBody","verifyConstructor","pushDescriptors","classBodyPaths","isClassProperty","buildCodeFrameError","decorators","isClassMethod","isConstructor","kind","replaceSupers","ReplaceSupers","methodPath","objectRef","superRef","constantSuper","refToPreserve","replace","ReturnStatement","getFunctionParent","isArrowFunctionExpression","pushConstructor","pushMethod","pushInheritsToBody","props","placement","length","desc","obj","objectExpression","objectProperty","key","properties","arrayExpression","nullLiteral","lastNonNullIndex","i","isNullLiteral","slice","expressionStatement","wrapSuperCall","bareSuper","thisRef","bareSuperNode","call","superIsCallableConstructor","arguments","unshift","thisExpression","isSpreadElement","isIdentifier","argument","name","callee","memberExpression","logicalExpression","optimiseCall","parentPath","isExpressionStatement","container","assignmentExpression","replaceWith","returnStatement","ref","generateDeclaredUidIdentifier","thisPath","isMemberExpression","object","bareSupers","Super","isCallExpression","guaranteedSuperBeforeFinish","find","isLoop","isConditional","wrapReturn","returnArg","thisExpr","returnParams","bodyPaths","pop","isReturnStatement","pushContainer","returnPath","processMethod","descKey","isNumericLiteral","isBigIntLiteral","stringLiteral","String","value","toComputedKey","fn","toExpression","isStringLiteral","nameFunction","id","descriptor","has","set","setClassMethods","insertProtoAliasOnce","methodName","computed","isLiteral","functionExpression","generator","async","expr","inheritsComments","generateUidIdentifier","classProto","protoDeclaration","variableDeclaration","variableDeclarator","method","directives","pushConstructorToBody","hasInstanceDescriptors","hasStaticDescriptors","addCreateSuperHelper","extractDynamicKeys","elem","isPure","generateUidIdentifierBasedOnNode","setupClosureParamsArgs","closureParams","closureArgs","arg","annotateAsPure","param","classTransformer","superClass","hasBinding","noClassCalls","isStrict","isInStrictMode","constructorOnly","directive","directiveLiteral","arrowFunctionExpression"],"sources":["../src/transformClass.ts"],"sourcesContent":["import type { NodePath, Scope, Visitor } from \"@babel/traverse\";\nimport nameFunction from \"@babel/helper-function-name\";\nimport ReplaceSupers from \"@babel/helper-replace-supers\";\nimport environmentVisitor from \"@babel/helper-environment-visitor\";\nimport optimiseCall from \"@babel/helper-optimise-call-expression\";\nimport { traverse, template, types as t, type File } from \"@babel/core\";\nimport annotateAsPure from \"@babel/helper-annotate-as-pure\";\n\nimport addCreateSuperHelper from \"./inline-createSuper-helpers\";\n\ntype ClassAssumptions = {\n  setClassMethods: boolean;\n  constantSuper: boolean;\n  superIsCallableConstructor: boolean;\n  noClassCalls: boolean;\n};\n\ntype ClassConstructor = t.ClassMethod & { kind: \"constructor\" };\n\nfunction buildConstructor(\n  classRef: t.Identifier,\n  constructorBody: t.BlockStatement,\n  node: t.Class,\n) {\n  const func = t.functionDeclaration(\n    t.cloneNode(classRef),\n    [],\n    constructorBody,\n  );\n  t.inherits(func, node);\n  return func;\n}\n\ntype Descriptor = {\n  key: t.Expression;\n  get?: t.Expression | null;\n  set?: t.Expression | null;\n  value?: t.Expression | null;\n  constructor?: t.Expression | null;\n};\n\ntype State = {\n  parent: t.Node;\n  scope: Scope;\n  node: t.Class;\n  path: NodePath<t.Class>;\n  file: File;\n\n  classId: t.Identifier | void;\n  classRef: t.Identifier;\n  superFnId: t.Identifier;\n  superName: t.Expression | null;\n  superReturns: NodePath<t.ReturnStatement>[];\n  isDerived: boolean;\n  extendsNative: boolean;\n\n  construct: t.FunctionDeclaration;\n  constructorBody: t.BlockStatement;\n  userConstructor: ClassConstructor;\n  userConstructorPath: NodePath<ClassConstructor>;\n  hasConstructor: boolean;\n\n  body: t.Statement[];\n  superThises: NodePath<t.ThisExpression>[];\n  pushedConstructor: boolean;\n  pushedInherits: boolean;\n  pushedCreateClass: boolean;\n  protoAlias: t.Identifier | null;\n  isLoose: boolean;\n\n  dynamicKeys: Map<string, t.Expression>;\n\n  methods: {\n    // 'list' is in the same order as the elements appear in the class body.\n    // if there aren't computed keys, we can safely reorder class elements\n    // and use 'map' to merge duplicates.\n    instance: {\n      hasComputed: boolean;\n      list: Descriptor[];\n      map: Map<string, Descriptor>;\n    };\n    static: {\n      hasComputed: boolean;\n      list: Descriptor[];\n      map: Map<string, Descriptor>;\n    };\n  };\n};\n\ntype PropertyInfo = {\n  instance: t.ObjectExpression[] | null;\n  static: t.ObjectExpression[] | null;\n};\n\nexport default function transformClass(\n  path: NodePath<t.Class>,\n  file: File,\n  builtinClasses: ReadonlySet<string>,\n  isLoose: boolean,\n  assumptions: ClassAssumptions,\n  supportUnicodeId: boolean,\n) {\n  const classState: State = {\n    parent: undefined,\n    scope: undefined,\n    node: undefined,\n    path: undefined,\n    file: undefined,\n\n    classId: undefined,\n    classRef: undefined,\n    superFnId: undefined,\n    superName: null,\n    superReturns: [],\n    isDerived: false,\n    extendsNative: false,\n\n    construct: undefined,\n    constructorBody: undefined,\n    userConstructor: undefined,\n    userConstructorPath: undefined,\n    hasConstructor: false,\n\n    body: [],\n    superThises: [],\n    pushedConstructor: false,\n    pushedInherits: false,\n    pushedCreateClass: false,\n    protoAlias: null,\n    isLoose: false,\n\n    dynamicKeys: new Map(),\n\n    methods: {\n      instance: {\n        hasComputed: false,\n        list: [],\n        map: new Map(),\n      },\n      static: {\n        hasComputed: false,\n        list: [],\n        map: new Map(),\n      },\n    },\n  };\n\n  const setState = (newState: Partial<State>) => {\n    Object.assign(classState, newState);\n  };\n\n  const findThisesVisitor = traverse.visitors.merge([\n    environmentVisitor,\n    {\n      ThisExpression(path) {\n        classState.superThises.push(path);\n      },\n    },\n  ]);\n\n  function createClassHelper(args: t.Expression[]) {\n    return t.callExpression(classState.file.addHelper(\"createClass\"), args);\n  }\n\n  /**\n   * Creates a class constructor or bail out if there is none\n   */\n  function maybeCreateConstructor() {\n    let hasConstructor = false;\n    const paths = classState.path.get(\"body.body\");\n    for (const path of paths) {\n      // @ts-expect-error: StaticBlock does not have `kind` property\n      hasConstructor = path.equals(\"kind\", \"constructor\");\n      if (hasConstructor) break;\n    }\n    if (hasConstructor) return;\n\n    let params: t.FunctionExpression[\"params\"], body;\n\n    if (classState.isDerived) {\n      const constructor = template.expression.ast`\n        (function () {\n          super(...arguments);\n        })\n      ` as t.FunctionExpression;\n      params = constructor.params;\n      body = constructor.body;\n    } else {\n      params = [];\n      body = t.blockStatement([]);\n    }\n\n    classState.path\n      .get(\"body\")\n      .unshiftContainer(\n        \"body\",\n        t.classMethod(\"constructor\", t.identifier(\"constructor\"), params, body),\n      );\n  }\n\n  function buildBody() {\n    maybeCreateConstructor();\n    pushBody();\n    verifyConstructor();\n\n    if (classState.userConstructor) {\n      const { constructorBody, userConstructor, construct } = classState;\n\n      constructorBody.body.push(...userConstructor.body.body);\n      t.inherits(construct, userConstructor);\n      t.inherits(constructorBody, userConstructor.body);\n    }\n\n    pushDescriptors();\n  }\n\n  function pushBody() {\n    const classBodyPaths: Array<any> = classState.path.get(\"body.body\");\n\n    for (const path of classBodyPaths) {\n      const node = path.node;\n\n      if (path.isClassProperty()) {\n        throw path.buildCodeFrameError(\"Missing class properties transform.\");\n      }\n\n      if (node.decorators) {\n        throw path.buildCodeFrameError(\n          \"Method has decorators, put the decorator plugin before the classes one.\",\n        );\n      }\n\n      if (t.isClassMethod(node)) {\n        const isConstructor = node.kind === \"constructor\";\n\n        const replaceSupers = new ReplaceSupers({\n          methodPath: path,\n          objectRef: classState.classRef,\n          superRef: classState.superName,\n          constantSuper: assumptions.constantSuper,\n          file: classState.file,\n          refToPreserve: classState.classRef,\n        });\n\n        replaceSupers.replace();\n\n        const superReturns: NodePath<t.ReturnStatement>[] = [];\n        path.traverse(\n          traverse.visitors.merge([\n            environmentVisitor,\n            {\n              ReturnStatement(path) {\n                if (!path.getFunctionParent().isArrowFunctionExpression()) {\n                  superReturns.push(path);\n                }\n              },\n            },\n          ]),\n        );\n\n        if (isConstructor) {\n          pushConstructor(superReturns, node as ClassConstructor, path);\n        } else {\n          pushMethod(node, path);\n        }\n      }\n    }\n  }\n\n  function pushDescriptors() {\n    pushInheritsToBody();\n\n    const { body } = classState;\n\n    const props: PropertyInfo = {\n      instance: null,\n      static: null,\n    };\n\n    for (const placement of [\"static\", \"instance\"] as const) {\n      if (classState.methods[placement].list.length) {\n        props[placement] = classState.methods[placement].list.map(desc => {\n          const obj = t.objectExpression([\n            t.objectProperty(t.identifier(\"key\"), desc.key),\n          ]);\n\n          for (const kind of [\"get\", \"set\", \"value\"] as const) {\n            if (desc[kind] != null) {\n              obj.properties.push(\n                t.objectProperty(t.identifier(kind), desc[kind]),\n              );\n            }\n          }\n\n          return obj;\n        });\n      }\n    }\n\n    if (props.instance || props.static) {\n      let args = [\n        t.cloneNode(classState.classRef), // Constructor\n        props.instance ? t.arrayExpression(props.instance) : t.nullLiteral(), // instanceDescriptors\n        props.static ? t.arrayExpression(props.static) : t.nullLiteral(), // staticDescriptors\n      ];\n\n      let lastNonNullIndex = 0;\n      for (let i = 0; i < args.length; i++) {\n        if (!t.isNullLiteral(args[i])) lastNonNullIndex = i;\n      }\n      args = args.slice(0, lastNonNullIndex + 1);\n\n      body.push(t.expressionStatement(createClassHelper(args)));\n      classState.pushedCreateClass = true;\n    }\n  }\n\n  function wrapSuperCall(\n    bareSuper: NodePath<t.CallExpression>,\n    superRef: t.Expression,\n    thisRef: () => t.Identifier,\n    body: NodePath<t.BlockStatement>,\n  ) {\n    const bareSuperNode = bareSuper.node;\n    let call;\n\n    if (assumptions.superIsCallableConstructor) {\n      bareSuperNode.arguments.unshift(t.thisExpression());\n      if (\n        bareSuperNode.arguments.length === 2 &&\n        t.isSpreadElement(bareSuperNode.arguments[1]) &&\n        t.isIdentifier(bareSuperNode.arguments[1].argument, {\n          name: \"arguments\",\n        })\n      ) {\n        // special case single arguments spread\n        bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;\n        bareSuperNode.callee = t.memberExpression(\n          t.cloneNode(superRef),\n          t.identifier(\"apply\"),\n        );\n      } else {\n        bareSuperNode.callee = t.memberExpression(\n          t.cloneNode(superRef),\n          t.identifier(\"call\"),\n        );\n      }\n\n      call = t.logicalExpression(\"||\", bareSuperNode, t.thisExpression());\n    } else {\n      call = optimiseCall(\n        t.cloneNode(classState.superFnId),\n        t.thisExpression(),\n        bareSuperNode.arguments,\n        false,\n      );\n    }\n\n    if (\n      bareSuper.parentPath.isExpressionStatement() &&\n      bareSuper.parentPath.container === body.node.body &&\n      body.node.body.length - 1 === bareSuper.parentPath.key\n    ) {\n      // this super call is the last statement in the body so we can just straight up\n      // turn it into a return\n\n      if (classState.superThises.length) {\n        call = t.assignmentExpression(\"=\", thisRef(), call);\n      }\n\n      bareSuper.parentPath.replaceWith(t.returnStatement(call));\n    } else {\n      bareSuper.replaceWith(t.assignmentExpression(\"=\", thisRef(), call));\n    }\n  }\n\n  function verifyConstructor() {\n    if (!classState.isDerived) return;\n\n    const path = classState.userConstructorPath;\n    const body = path.get(\"body\");\n\n    path.traverse(findThisesVisitor);\n\n    let thisRef = function () {\n      const ref = path.scope.generateDeclaredUidIdentifier(\"this\");\n      thisRef = () => t.cloneNode(ref);\n      return ref;\n    };\n\n    for (const thisPath of classState.superThises) {\n      const { node, parentPath } = thisPath;\n      if (parentPath.isMemberExpression({ object: node })) {\n        thisPath.replaceWith(thisRef());\n        continue;\n      }\n      thisPath.replaceWith(\n        t.callExpression(classState.file.addHelper(\"assertThisInitialized\"), [\n          thisRef(),\n        ]),\n      );\n    }\n\n    const bareSupers: NodePath<t.CallExpression>[] = [];\n    path.traverse(\n      traverse.visitors.merge([\n        environmentVisitor,\n        {\n          Super(path) {\n            const { node, parentPath } = path;\n            if (parentPath.isCallExpression({ callee: node })) {\n              bareSupers.unshift(parentPath);\n            }\n          },\n        } as Visitor,\n      ]),\n    );\n\n    let guaranteedSuperBeforeFinish = !!bareSupers.length;\n\n    for (const bareSuper of bareSupers) {\n      wrapSuperCall(bareSuper, classState.superName, thisRef, body);\n\n      if (guaranteedSuperBeforeFinish) {\n        bareSuper.find(function (parentPath) {\n          // hit top so short circuit\n          if (parentPath === path) {\n            return true;\n          }\n\n          if (\n            parentPath.isLoop() ||\n            parentPath.isConditional() ||\n            parentPath.isArrowFunctionExpression()\n          ) {\n            guaranteedSuperBeforeFinish = false;\n            return true;\n          }\n        });\n      }\n    }\n\n    let wrapReturn;\n\n    if (classState.isLoose) {\n      wrapReturn = (returnArg: t.Expression | void) => {\n        const thisExpr = t.callExpression(\n          classState.file.addHelper(\"assertThisInitialized\"),\n          [thisRef()],\n        );\n        return returnArg\n          ? t.logicalExpression(\"||\", returnArg, thisExpr)\n          : thisExpr;\n      };\n    } else {\n      wrapReturn = (returnArg: t.Expression | undefined) => {\n        const returnParams: t.Expression[] = [thisRef()];\n        if (returnArg != null) {\n          returnParams.push(returnArg);\n        }\n        return t.callExpression(\n          classState.file.addHelper(\"possibleConstructorReturn\"),\n          returnParams,\n        );\n      };\n    }\n\n    // if we have a return as the last node in the body then we've already caught that\n    // return\n    const bodyPaths = body.get(\"body\");\n    if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) {\n      body.pushContainer(\n        \"body\",\n        t.returnStatement(\n          guaranteedSuperBeforeFinish ? thisRef() : wrapReturn(),\n        ),\n      );\n    }\n\n    for (const returnPath of classState.superReturns) {\n      returnPath\n        .get(\"argument\")\n        .replaceWith(wrapReturn(returnPath.node.argument));\n    }\n  }\n\n  /**\n   * Push a method to its respective mutatorMap.\n   */\n  function pushMethod(node: t.ClassMethod, path?: NodePath) {\n    const scope = path ? path.scope : classState.scope;\n\n    if (node.kind === \"method\") {\n      if (processMethod(node, scope)) return;\n    }\n\n    const placement = node.static ? \"static\" : \"instance\";\n    const methods = classState.methods[placement];\n\n    const descKey = node.kind === \"method\" ? \"value\" : node.kind;\n    const key =\n      t.isNumericLiteral(node.key) || t.isBigIntLiteral(node.key)\n        ? t.stringLiteral(String(node.key.value))\n        : t.toComputedKey(node);\n\n    let fn: t.Expression = t.toExpression(node);\n\n    if (t.isStringLiteral(key)) {\n      // infer function name\n      if (node.kind === \"method\") {\n        // @ts-expect-error Fixme: we are passing a ClassMethod to nameFunction, but nameFunction\n        // does not seem to support it\n        fn =\n          nameFunction(\n            // @ts-expect-error Fixme: we are passing a ClassMethod to nameFunction, but nameFunction\n            // does not seem to support it\n            { id: key, node: node, scope },\n            undefined,\n            supportUnicodeId,\n          ) ?? fn;\n      }\n    } else {\n      // todo(flow->ts) find a way to avoid \"key as t.StringLiteral\" below which relies on this assignment\n      methods.hasComputed = true;\n    }\n\n    let descriptor: Descriptor;\n    if (\n      !methods.hasComputed &&\n      methods.map.has((key as t.StringLiteral).value)\n    ) {\n      descriptor = methods.map.get((key as t.StringLiteral).value);\n      descriptor[descKey] = fn;\n\n      if (descKey === \"value\") {\n        descriptor.get = null;\n        descriptor.set = null;\n      } else {\n        descriptor.value = null;\n      }\n    } else {\n      descriptor = {\n        key:\n          // private name has been handled in class-properties transform\n          key as t.Expression,\n        [descKey]: fn,\n      } as Descriptor;\n      methods.list.push(descriptor);\n\n      if (!methods.hasComputed) {\n        methods.map.set((key as t.StringLiteral).value, descriptor);\n      }\n    }\n  }\n\n  function processMethod(node: t.ClassMethod, scope: Scope) {\n    if (assumptions.setClassMethods && !node.decorators) {\n      // use assignments instead of define properties for loose classes\n      let { classRef } = classState;\n      if (!node.static) {\n        insertProtoAliasOnce();\n        classRef = classState.protoAlias;\n      }\n      const methodName = t.memberExpression(\n        t.cloneNode(classRef),\n        node.key,\n        node.computed || t.isLiteral(node.key),\n      );\n\n      let func: t.Expression = t.functionExpression(\n        null,\n        // @ts-expect-error Fixme: should throw when we see TSParameterProperty\n        node.params,\n        node.body,\n        node.generator,\n        node.async,\n      );\n      t.inherits(func, node);\n\n      const key = t.toComputedKey(node, node.key);\n      if (t.isStringLiteral(key)) {\n        // @ts-expect-error: requires strictNullCheck\n        func =\n          nameFunction(\n            {\n              node: func,\n              id: key,\n              scope,\n            },\n            undefined,\n            supportUnicodeId,\n          ) ?? func;\n      }\n\n      const expr = t.expressionStatement(\n        t.assignmentExpression(\"=\", methodName, func),\n      );\n      t.inheritsComments(expr, node);\n      classState.body.push(expr);\n      return true;\n    }\n\n    return false;\n  }\n\n  function insertProtoAliasOnce() {\n    if (classState.protoAlias === null) {\n      setState({ protoAlias: classState.scope.generateUidIdentifier(\"proto\") });\n      const classProto = t.memberExpression(\n        classState.classRef,\n        t.identifier(\"prototype\"),\n      );\n      const protoDeclaration = t.variableDeclaration(\"var\", [\n        t.variableDeclarator(classState.protoAlias, classProto),\n      ]);\n\n      classState.body.push(protoDeclaration);\n    }\n  }\n\n  /**\n   * Replace the constructor body of our class.\n   */\n  function pushConstructor(\n    superReturns: NodePath<t.ReturnStatement>[],\n    method: ClassConstructor,\n    path: NodePath<ClassConstructor>,\n  ) {\n    setState({\n      userConstructorPath: path,\n      userConstructor: method,\n      hasConstructor: true,\n      superReturns,\n    });\n\n    const { construct } = classState;\n\n    t.inheritsComments(construct, method);\n\n    // @ts-expect-error Fixme: should throw when we see TSParameterProperty\n    construct.params = method.params;\n\n    t.inherits(construct.body, method.body);\n    construct.body.directives = method.body.directives;\n\n    pushConstructorToBody();\n  }\n\n  function pushConstructorToBody() {\n    if (classState.pushedConstructor) return;\n    classState.pushedConstructor = true;\n\n    // we haven't pushed any descriptors yet\n    // @ts-expect-error todo(flow->ts) maybe remove this block - properties from condition are not used anywhere esle\n    if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) {\n      pushDescriptors();\n    }\n\n    classState.body.push(classState.construct);\n\n    pushInheritsToBody();\n  }\n\n  /**\n   * Push inherits helper to body.\n   */\n  function pushInheritsToBody() {\n    if (!classState.isDerived || classState.pushedInherits) return;\n\n    const superFnId = path.scope.generateUidIdentifier(\"super\");\n\n    setState({ pushedInherits: true, superFnId });\n\n    // Unshift to ensure that the constructor inheritance is set up before\n    // any properties can be assigned to the prototype.\n\n    if (!assumptions.superIsCallableConstructor) {\n      classState.body.unshift(\n        t.variableDeclaration(\"var\", [\n          t.variableDeclarator(\n            superFnId,\n            t.callExpression(addCreateSuperHelper(classState.file), [\n              t.cloneNode(classState.classRef),\n            ]),\n          ),\n        ]),\n      );\n    }\n\n    classState.body.unshift(\n      t.expressionStatement(\n        t.callExpression(\n          classState.file.addHelper(\n            classState.isLoose ? \"inheritsLoose\" : \"inherits\",\n          ),\n          [t.cloneNode(classState.classRef), t.cloneNode(classState.superName)],\n        ),\n      ),\n    );\n  }\n\n  function extractDynamicKeys() {\n    const { dynamicKeys, node, scope } = classState;\n\n    for (const elem of node.body.body) {\n      if (!t.isClassMethod(elem) || !elem.computed) continue;\n      if (scope.isPure(elem.key, /* constatns only*/ true)) continue;\n\n      const id = scope.generateUidIdentifierBasedOnNode(elem.key);\n      dynamicKeys.set(id.name, elem.key);\n\n      elem.key = id;\n    }\n  }\n\n  function setupClosureParamsArgs() {\n    const { superName, dynamicKeys } = classState;\n    const closureParams = [];\n    const closureArgs = [];\n\n    if (classState.isDerived) {\n      let arg = t.cloneNode(superName);\n      if (classState.extendsNative) {\n        arg = t.callExpression(classState.file.addHelper(\"wrapNativeSuper\"), [\n          arg,\n        ]);\n        annotateAsPure(arg);\n      }\n\n      const param =\n        classState.scope.generateUidIdentifierBasedOnNode(superName);\n\n      closureParams.push(param);\n      closureArgs.push(arg);\n\n      setState({ superName: t.cloneNode(param) });\n    }\n\n    for (const [name, value] of dynamicKeys) {\n      closureParams.push(t.identifier(name));\n      closureArgs.push(value);\n    }\n\n    return { closureParams, closureArgs };\n  }\n\n  function classTransformer(\n    path: NodePath<t.Class>,\n    file: File,\n    builtinClasses: ReadonlySet<string>,\n    isLoose: boolean,\n  ) {\n    setState({\n      parent: path.parent,\n      scope: path.scope,\n      node: path.node,\n      path,\n      file,\n      isLoose,\n    });\n\n    setState({\n      classId: classState.node.id,\n      // this is the name of the binding that will **always** reference the class we've constructed\n      classRef: classState.node.id\n        ? t.identifier(classState.node.id.name)\n        : classState.scope.generateUidIdentifier(\"class\"),\n      superName: classState.node.superClass,\n      isDerived: !!classState.node.superClass,\n      constructorBody: t.blockStatement([]),\n    });\n\n    setState({\n      extendsNative:\n        t.isIdentifier(classState.superName) &&\n        builtinClasses.has(classState.superName.name) &&\n        !classState.scope.hasBinding(\n          classState.superName.name,\n          /* noGlobals */ true,\n        ),\n    });\n\n    const { classRef, node, constructorBody } = classState;\n\n    setState({\n      construct: buildConstructor(classRef, constructorBody, node),\n    });\n\n    extractDynamicKeys();\n\n    const { body } = classState;\n    const { closureParams, closureArgs } = setupClosureParamsArgs();\n\n    buildBody();\n\n    // make sure this class isn't directly called (with A() instead new A())\n    if (!assumptions.noClassCalls) {\n      constructorBody.body.unshift(\n        t.expressionStatement(\n          t.callExpression(classState.file.addHelper(\"classCallCheck\"), [\n            t.thisExpression(),\n            t.cloneNode(classState.classRef),\n          ]),\n        ),\n      );\n    }\n\n    const isStrict = path.isInStrictMode();\n    let constructorOnly = classState.classId && body.length === 1;\n    if (constructorOnly && !isStrict) {\n      for (const param of classState.construct.params) {\n        // It's illegal to put a use strict directive into the body of a function\n        // with non-simple parameters for some reason. So, we have to use a strict\n        // wrapper function.\n        if (!t.isIdentifier(param)) {\n          constructorOnly = false;\n          break;\n        }\n      }\n    }\n\n    const directives = constructorOnly\n      ? (body[0] as t.FunctionExpression | t.FunctionDeclaration).body\n          .directives\n      : [];\n    if (!isStrict) {\n      directives.push(t.directive(t.directiveLiteral(\"use strict\")));\n    }\n\n    if (constructorOnly) {\n      // named class with only a constructor\n      const expr = t.toExpression(\n        body[0] as t.FunctionExpression | t.FunctionDeclaration,\n      );\n      return classState.isLoose ? expr : createClassHelper([expr]);\n    }\n\n    let returnArg: t.Expression = t.cloneNode(classState.classRef);\n    if (!classState.pushedCreateClass && !classState.isLoose) {\n      returnArg = createClassHelper([returnArg]);\n    }\n\n    body.push(t.returnStatement(returnArg));\n    const container = t.arrowFunctionExpression(\n      closureParams,\n      t.blockStatement(body, directives),\n    );\n    return t.callExpression(container, closureArgs);\n  }\n\n  return classTransformer(path, file, builtinClasses, isLoose);\n}\n"],"mappings":"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"}