@alanszp/business-days-date-fns 12.0.1 → 12.0.3

package/node_modules/@babel/plugin-transform-classes/lib/inline-callSuper-helpers.js

@@ -1,73 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = addCallSuperHelper;
-var _core = require("@babel/core");
-const helper = _core.template.statement`
-  function CALL_SUPER(
-    _this,
-    derived,
-    args,
-  ) {
-    function isNativeReflectConstruct() {
-      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-
-      // core-js@3
-      if (Reflect.construct.sham) return false;
-
-      // Proxy can't be polyfilled. Every browser implemented
-      // proxies before or at the same time as Reflect.construct,
-      // so if they support Proxy they also support Reflect.construct.
-      if (typeof Proxy === "function") return true;
-
-      // Since Reflect.construct can't be properly polyfilled, some
-      // implementations (e.g. core-js@2) don't set the correct internal slots.
-      // Those polyfills don't allow us to subclass built-ins, so we need to
-      // use our fallback implementation.
-      try {
-        // If the internal slots aren't set, this throws an error similar to
-        //   TypeError: this is not a Boolean object.
-        return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}),);
-      } catch (e) {
-        return false;
-      }
-    }
-
-    // Super
-    derived = GET_PROTOTYPE_OF(derived);
-    return POSSIBLE_CONSTRUCTOR_RETURN(
-      _this,
-      isNativeReflectConstruct()
-        ? // NOTE: This doesn't work if this.__proto__.constructor has been modified.
-          Reflect.construct(
-            derived,
-            args || [],
-            GET_PROTOTYPE_OF(_this).constructor,
-          )
-        : derived.apply(_this, args),
-    );
-  }
-`;
-const helperIDs = new WeakMap();
-function addCallSuperHelper(file) {
-  if (helperIDs.has(file)) {
-    return (_core.types.cloneNode || _core.types.clone)(helperIDs.get(file));
-  }
-  try {
-    return file.addHelper("callSuper");
-  } catch (_unused) {}
-  const id = file.scope.generateUidIdentifier("callSuper");
-  helperIDs.set(file, id);
-  const fn = helper({
-    CALL_SUPER: id,
-    GET_PROTOTYPE_OF: file.addHelper("getPrototypeOf"),
-    POSSIBLE_CONSTRUCTOR_RETURN: file.addHelper("possibleConstructorReturn")
-  });
-  file.path.unshiftContainer("body", [fn]);
-  file.scope.registerDeclaration(file.path.get("body.0"));
-  return _core.types.cloneNode(id);
-}
-
-//# sourceMappingURL=inline-callSuper-helpers.js.map

package/node_modules/@babel/plugin-transform-classes/lib/inline-callSuper-helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_core","require","helper","template","statement","helperIDs","WeakMap","addCallSuperHelper","file","has","t","cloneNode","clone","get","addHelper","_unused","id","scope","generateUidIdentifier","set","fn","CALL_SUPER","GET_PROTOTYPE_OF","POSSIBLE_CONSTRUCTOR_RETURN","path","unshiftContainer","registerDeclaration"],"sources":["../src/inline-callSuper-helpers.ts"],"sourcesContent":["import { template, types as t, type File } from \"@babel/core\";\n\nconst helper = template.statement`\n  function CALL_SUPER(\n    _this,\n    derived,\n    args,\n  ) {\n    function isNativeReflectConstruct() {\n      if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n\n      // core-js@3\n      if (Reflect.construct.sham) return false;\n\n      // Proxy can't be polyfilled. Every browser implemented\n      // proxies before or at the same time as Reflect.construct,\n      // so if they support Proxy they also support Reflect.construct.\n      if (typeof Proxy === \"function\") return true;\n\n      // Since Reflect.construct can't be properly polyfilled, some\n      // implementations (e.g. core-js@2) don't set the correct internal slots.\n      // Those polyfills don't allow us to subclass built-ins, so we need to\n      // use our fallback implementation.\n      try {\n        // If the internal slots aren't set, this throws an error similar to\n        //   TypeError: this is not a Boolean object.\n        return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}),);\n      } catch (e) {\n        return false;\n      }\n    }\n\n    // Super\n    derived = GET_PROTOTYPE_OF(derived);\n    return POSSIBLE_CONSTRUCTOR_RETURN(\n      _this,\n      isNativeReflectConstruct()\n        ? // NOTE: This doesn't work if this.__proto__.constructor has been modified.\n          Reflect.construct(\n            derived,\n            args || [],\n            GET_PROTOTYPE_OF(_this).constructor,\n          )\n        : derived.apply(_this, args),\n    );\n  }\n`;\n\nconst helperIDs = new WeakMap();\n\nexport default function addCallSuperHelper(file: File) {\n  if (helperIDs.has(file)) {\n    // TODO: Only use t.cloneNode in Babel 8\n    // t.cloneNode isn't supported in every version\n    return (t.cloneNode || t.clone)(helperIDs.get(file));\n  }\n\n  try {\n    return file.addHelper(\"callSuper\");\n  } catch {\n    // old Babel doesn't support the helper.\n  }\n\n  const id = file.scope.generateUidIdentifier(\"callSuper\");\n  helperIDs.set(file, id);\n\n  const fn = helper({\n    CALL_SUPER: id,\n    GET_PROTOTYPE_OF: file.addHelper(\"getPrototypeOf\"),\n    POSSIBLE_CONSTRUCTOR_RETURN: file.addHelper(\"possibleConstructorReturn\"),\n  });\n\n  file.path.unshiftContainer(\"body\", [fn]);\n  file.scope.registerDeclaration(file.path.get(\"body.0\"));\n\n  return t.cloneNode(id);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AAEA,MAAMC,MAAM,GAAGC,cAAQ,CAACC,SAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AAED,MAAMC,SAAS,GAAG,IAAIC,OAAO,CAAC,CAAC;AAEhB,SAASC,kBAAkBA,CAACC,IAAU,EAAE;EACrD,IAAIH,SAAS,CAACI,GAAG,CAACD,IAAI,CAAC,EAAE;IAGvB,OAAO,CAACE,WAAC,CAACC,SAAS,IAAID,WAAC,CAACE,KAAK,EAAEP,SAAS,CAACQ,GAAG,CAACL,IAAI,CAAC,CAAC;EACtD;EAEA,IAAI;IACF,OAAOA,IAAI,CAACM,SAAS,CAAC,WAAW,CAAC;EACpC,CAAC,CAAC,OAAAC,OAAA,EAAM,CAER;EAEA,MAAMC,EAAE,GAAGR,IAAI,CAACS,KAAK,CAACC,qBAAqB,CAAC,WAAW,CAAC;EACxDb,SAAS,CAACc,GAAG,CAACX,IAAI,EAAEQ,EAAE,CAAC;EAEvB,MAAMI,EAAE,GAAGlB,MAAM,CAAC;IAChBmB,UAAU,EAAEL,EAAE;IACdM,gBAAgB,EAAEd,IAAI,CAACM,SAAS,CAAC,gBAAgB,CAAC;IAClDS,2BAA2B,EAAEf,IAAI,CAACM,SAAS,CAAC,2BAA2B;EACzE,CAAC,CAAC;EAEFN,IAAI,CAACgB,IAAI,CAACC,gBAAgB,CAAC,MAAM,EAAE,CAACL,EAAE,CAAC,CAAC;EACxCZ,IAAI,CAACS,KAAK,CAACS,mBAAmB,CAAClB,IAAI,CAACgB,IAAI,CAACX,GAAG,CAAC,QAAQ,CAAC,CAAC;EAEvD,OAAOH,WAAC,CAACC,SAAS,CAACK,EAAE,CAAC;AACxB"}

package/node_modules/@babel/plugin-transform-classes/lib/transformClass.js

@@ -1,511 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = transformClass;
-var _helperFunctionName = require("@babel/helper-function-name");
-var _helperReplaceSupers = require("@babel/helper-replace-supers");
-var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
-var _core = require("@babel/core");
-var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure");
-var _inlineCallSuperHelpers = require("./inline-callSuper-helpers.js");
-function buildConstructor(classRef, constructorBody, node) {
-  const func = _core.types.functionDeclaration(_core.types.cloneNode(classRef), [], constructorBody);
-  _core.types.inherits(func, node);
-  return func;
-}
-function transformClass(path, file, builtinClasses, isLoose, assumptions, supportUnicodeId) {
-  const classState = {
-    parent: undefined,
-    scope: undefined,
-    node: undefined,
-    path: undefined,
-    file: undefined,
-    classId: undefined,
-    classRef: undefined,
-    superName: null,
-    superReturns: [],
-    isDerived: false,
-    extendsNative: false,
-    construct: undefined,
-    constructorBody: undefined,
-    userConstructor: undefined,
-    userConstructorPath: undefined,
-    hasConstructor: false,
-    body: [],
-    superThises: [],
-    pushedConstructor: false,
-    pushedInherits: false,
-    pushedCreateClass: false,
-    protoAlias: null,
-    isLoose: false,
-    dynamicKeys: new Map(),
-    methods: {
-      instance: {
-        hasComputed: false,
-        list: [],
-        map: new Map()
-      },
-      static: {
-        hasComputed: false,
-        list: [],
-        map: new Map()
-      }
-    }
-  };
-  const setState = newState => {
-    Object.assign(classState, newState);
-  };
-  const findThisesVisitor = _core.traverse.visitors.merge([_helperEnvironmentVisitor.default, {
-    ThisExpression(path) {
-      classState.superThises.push(path);
-    }
-  }]);
-  function createClassHelper(args) {
-    return _core.types.callExpression(classState.file.addHelper("createClass"), args);
-  }
-  function maybeCreateConstructor() {
-    const classBodyPath = classState.path.get("body");
-    for (const path of classBodyPath.get("body")) {
-      if (path.isClassMethod({
-        kind: "constructor"
-      })) return;
-    }
-    let params, body;
-    if (classState.isDerived) {
-      const constructor = _core.template.expression.ast`
-        (function () {
-          super(...arguments);
-        })
-      `;
-      params = constructor.params;
-      body = constructor.body;
-    } else {
-      params = [];
-      body = _core.types.blockStatement([]);
-    }
-    classBodyPath.unshiftContainer("body", _core.types.classMethod("constructor", _core.types.identifier("constructor"), params, body));
-  }
-  function buildBody() {
-    maybeCreateConstructor();
-    pushBody();
-    verifyConstructor();
-    if (classState.userConstructor) {
-      const {
-        constructorBody,
-        userConstructor,
-        construct
-      } = classState;
-      constructorBody.body.push(...userConstructor.body.body);
-      _core.types.inherits(construct, userConstructor);
-      _core.types.inherits(constructorBody, userConstructor.body);
-    }
-    pushDescriptors();
-  }
-  function pushBody() {
-    const classBodyPaths = classState.path.get("body.body");
-    for (const path of classBodyPaths) {
-      const node = path.node;
-      if (path.isClassProperty() || path.isClassPrivateProperty()) {
-        throw path.buildCodeFrameError("Missing class properties transform.");
-      }
-      if (node.decorators) {
-        throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one.");
-      }
-      if (_core.types.isClassMethod(node)) {
-        const isConstructor = node.kind === "constructor";
-        const replaceSupers = new _helperReplaceSupers.default({
-          methodPath: path,
-          objectRef: classState.classRef,
-          superRef: classState.superName,
-          constantSuper: assumptions.constantSuper,
-          file: classState.file,
-          refToPreserve: classState.classRef
-        });
-        replaceSupers.replace();
-        const superReturns = [];
-        path.traverse(_core.traverse.visitors.merge([_helperEnvironmentVisitor.default, {
-          ReturnStatement(path) {
-            if (!path.getFunctionParent().isArrowFunctionExpression()) {
-              superReturns.push(path);
-            }
-          }
-        }]));
-        if (isConstructor) {
-          pushConstructor(superReturns, node, path);
-        } else {
-          pushMethod(node, path);
-        }
-      }
-    }
-  }
-  function pushDescriptors() {
-    pushInheritsToBody();
-    const {
-      body
-    } = classState;
-    const props = {
-      instance: null,
-      static: null
-    };
-    for (const placement of ["static", "instance"]) {
-      if (classState.methods[placement].list.length) {
-        props[placement] = classState.methods[placement].list.map(desc => {
-          const obj = _core.types.objectExpression([_core.types.objectProperty(_core.types.identifier("key"), desc.key)]);
-          for (const kind of ["get", "set", "value"]) {
-            if (desc[kind] != null) {
-              obj.properties.push(_core.types.objectProperty(_core.types.identifier(kind), desc[kind]));
-            }
-          }
-          return obj;
-        });
-      }
-    }
-    if (props.instance || props.static) {
-      let args = [_core.types.cloneNode(classState.classRef), props.instance ? _core.types.arrayExpression(props.instance) : _core.types.nullLiteral(), props.static ? _core.types.arrayExpression(props.static) : _core.types.nullLiteral()];
-      let lastNonNullIndex = 0;
-      for (let i = 0; i < args.length; i++) {
-        if (!_core.types.isNullLiteral(args[i])) lastNonNullIndex = i;
-      }
-      args = args.slice(0, lastNonNullIndex + 1);
-      body.push(_core.types.expressionStatement(createClassHelper(args)));
-      classState.pushedCreateClass = true;
-    }
-  }
-  function wrapSuperCall(bareSuper, superRef, thisRef, body) {
-    const bareSuperNode = bareSuper.node;
-    let call;
-    if (assumptions.superIsCallableConstructor) {
-      bareSuperNode.arguments.unshift(_core.types.thisExpression());
-      if (bareSuperNode.arguments.length === 2 && _core.types.isSpreadElement(bareSuperNode.arguments[1]) && _core.types.isIdentifier(bareSuperNode.arguments[1].argument, {
-        name: "arguments"
-      })) {
-        bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;
-        bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("apply"));
-      } else {
-        bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("call"));
-      }
-      call = _core.types.logicalExpression("||", bareSuperNode, _core.types.thisExpression());
-    } else {
-      var _bareSuperNode$argume;
-      const args = [_core.types.thisExpression(), _core.types.cloneNode(classState.classRef)];
-      if ((_bareSuperNode$argume = bareSuperNode.arguments) != null && _bareSuperNode$argume.length) {
-        const bareSuperNodeArguments = bareSuperNode.arguments;
-        if (bareSuperNodeArguments.length === 1 && _core.types.isSpreadElement(bareSuperNodeArguments[0]) && _core.types.isIdentifier(bareSuperNodeArguments[0].argument, {
-          name: "arguments"
-        })) {
-          args.push(bareSuperNodeArguments[0].argument);
-        } else {
-          args.push(_core.types.arrayExpression(bareSuperNodeArguments));
-        }
-      }
-      call = _core.types.callExpression((0, _inlineCallSuperHelpers.default)(classState.file), args);
-    }
-    if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) {
-      if (classState.superThises.length) {
-        call = _core.types.assignmentExpression("=", thisRef(), call);
-      }
-      bareSuper.parentPath.replaceWith(_core.types.returnStatement(call));
-    } else {
-      bareSuper.replaceWith(_core.types.assignmentExpression("=", thisRef(), call));
-    }
-  }
-  function verifyConstructor() {
-    if (!classState.isDerived) return;
-    const path = classState.userConstructorPath;
-    const body = path.get("body");
-    path.traverse(findThisesVisitor);
-    let thisRef = function () {
-      const ref = path.scope.generateDeclaredUidIdentifier("this");
-      thisRef = () => _core.types.cloneNode(ref);
-      return ref;
-    };
-    for (const thisPath of classState.superThises) {
-      const {
-        node,
-        parentPath
-      } = thisPath;
-      if (parentPath.isMemberExpression({
-        object: node
-      })) {
-        thisPath.replaceWith(thisRef());
-        continue;
-      }
-      thisPath.replaceWith(_core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]));
-    }
-    const bareSupers = [];
-    path.traverse(_core.traverse.visitors.merge([_helperEnvironmentVisitor.default, {
-      Super(path) {
-        const {
-          node,
-          parentPath
-        } = path;
-        if (parentPath.isCallExpression({
-          callee: node
-        })) {
-          bareSupers.unshift(parentPath);
-        }
-      }
-    }]));
-    let guaranteedSuperBeforeFinish = !!bareSupers.length;
-    for (const bareSuper of bareSupers) {
-      wrapSuperCall(bareSuper, classState.superName, thisRef, body);
-      if (guaranteedSuperBeforeFinish) {
-        bareSuper.find(function (parentPath) {
-          if (parentPath === path) {
-            return true;
-          }
-          if (parentPath.isLoop() || parentPath.isConditional() || parentPath.isArrowFunctionExpression()) {
-            guaranteedSuperBeforeFinish = false;
-            return true;
-          }
-        });
-      }
-    }
-    let wrapReturn;
-    if (classState.isLoose) {
-      wrapReturn = returnArg => {
-        const thisExpr = _core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]);
-        return returnArg ? _core.types.logicalExpression("||", returnArg, thisExpr) : thisExpr;
-      };
-    } else {
-      wrapReturn = returnArg => {
-        const returnParams = [thisRef()];
-        if (returnArg != null) {
-          returnParams.push(returnArg);
-        }
-        return _core.types.callExpression(classState.file.addHelper("possibleConstructorReturn"), returnParams);
-      };
-    }
-    const bodyPaths = body.get("body");
-    if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) {
-      body.pushContainer("body", _core.types.returnStatement(guaranteedSuperBeforeFinish ? thisRef() : wrapReturn()));
-    }
-    for (const returnPath of classState.superReturns) {
-      returnPath.get("argument").replaceWith(wrapReturn(returnPath.node.argument));
-    }
-  }
-  function pushMethod(node, path) {
-    const scope = path ? path.scope : classState.scope;
-    if (node.kind === "method") {
-      if (processMethod(node, scope)) return;
-    }
-    const placement = node.static ? "static" : "instance";
-    const methods = classState.methods[placement];
-    const descKey = node.kind === "method" ? "value" : node.kind;
-    const key = _core.types.isNumericLiteral(node.key) || _core.types.isBigIntLiteral(node.key) ? _core.types.stringLiteral(String(node.key.value)) : _core.types.toComputedKey(node);
-    let fn = _core.types.toExpression(node);
-    if (_core.types.isStringLiteral(key)) {
-      if (node.kind === "method") {
-        var _nameFunction;
-        fn = (_nameFunction = (0, _helperFunctionName.default)({
-          id: key,
-          node: node,
-          scope
-        }, undefined, supportUnicodeId)) != null ? _nameFunction : fn;
-      }
-    } else {
-      methods.hasComputed = true;
-    }
-    let descriptor;
-    if (!methods.hasComputed && methods.map.has(key.value)) {
-      descriptor = methods.map.get(key.value);
-      descriptor[descKey] = fn;
-      if (descKey === "value") {
-        descriptor.get = null;
-        descriptor.set = null;
-      } else {
-        descriptor.value = null;
-      }
-    } else {
-      descriptor = {
-        key: key,
-        [descKey]: fn
-      };
-      methods.list.push(descriptor);
-      if (!methods.hasComputed) {
-        methods.map.set(key.value, descriptor);
-      }
-    }
-  }
-  function processMethod(node, scope) {
-    if (assumptions.setClassMethods && !node.decorators) {
-      let {
-        classRef
-      } = classState;
-      if (!node.static) {
-        insertProtoAliasOnce();
-        classRef = classState.protoAlias;
-      }
-      const methodName = _core.types.memberExpression(_core.types.cloneNode(classRef), node.key, node.computed || _core.types.isLiteral(node.key));
-      let func = _core.types.functionExpression(null, node.params, node.body, node.generator, node.async);
-      _core.types.inherits(func, node);
-      const key = _core.types.toComputedKey(node, node.key);
-      if (_core.types.isStringLiteral(key)) {
-        var _nameFunction2;
-        func = (_nameFunction2 = (0, _helperFunctionName.default)({
-          node: func,
-          id: key,
-          scope
-        }, undefined, supportUnicodeId)) != null ? _nameFunction2 : func;
-      }
-      const expr = _core.types.expressionStatement(_core.types.assignmentExpression("=", methodName, func));
-      _core.types.inheritsComments(expr, node);
-      classState.body.push(expr);
-      return true;
-    }
-    return false;
-  }
-  function insertProtoAliasOnce() {
-    if (classState.protoAlias === null) {
-      setState({
-        protoAlias: classState.scope.generateUidIdentifier("proto")
-      });
-      const classProto = _core.types.memberExpression(classState.classRef, _core.types.identifier("prototype"));
-      const protoDeclaration = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(classState.protoAlias, classProto)]);
-      classState.body.push(protoDeclaration);
-    }
-  }
-  function pushConstructor(superReturns, method, path) {
-    setState({
-      userConstructorPath: path,
-      userConstructor: method,
-      hasConstructor: true,
-      superReturns
-    });
-    const {
-      construct
-    } = classState;
-    _core.types.inheritsComments(construct, method);
-    construct.params = method.params;
-    _core.types.inherits(construct.body, method.body);
-    construct.body.directives = method.body.directives;
-    pushConstructorToBody();
-  }
-  function pushConstructorToBody() {
-    if (classState.pushedConstructor) return;
-    classState.pushedConstructor = true;
-    if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) {
-      pushDescriptors();
-    }
-    classState.body.push(classState.construct);
-    pushInheritsToBody();
-  }
-  function pushInheritsToBody() {
-    if (!classState.isDerived || classState.pushedInherits) return;
-    classState.pushedInherits = true;
-    classState.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper(classState.isLoose ? "inheritsLoose" : "inherits"), [_core.types.cloneNode(classState.classRef), _core.types.cloneNode(classState.superName)])));
-  }
-  function extractDynamicKeys() {
-    const {
-      dynamicKeys,
-      node,
-      scope
-    } = classState;
-    for (const elem of node.body.body) {
-      if (!_core.types.isClassMethod(elem) || !elem.computed) continue;
-      if (scope.isPure(elem.key, true)) continue;
-      const id = scope.generateUidIdentifierBasedOnNode(elem.key);
-      dynamicKeys.set(id.name, elem.key);
-      elem.key = id;
-    }
-  }
-  function setupClosureParamsArgs() {
-    const {
-      superName,
-      dynamicKeys
-    } = classState;
-    const closureParams = [];
-    const closureArgs = [];
-    if (classState.isDerived) {
-      let arg = _core.types.cloneNode(superName);
-      if (classState.extendsNative) {
-        arg = _core.types.callExpression(classState.file.addHelper("wrapNativeSuper"), [arg]);
-        (0, _helperAnnotateAsPure.default)(arg);
-      }
-      const param = classState.scope.generateUidIdentifierBasedOnNode(superName);
-      closureParams.push(param);
-      closureArgs.push(arg);
-      setState({
-        superName: _core.types.cloneNode(param)
-      });
-    }
-    for (const [name, value] of dynamicKeys) {
-      closureParams.push(_core.types.identifier(name));
-      closureArgs.push(value);
-    }
-    return {
-      closureParams,
-      closureArgs
-    };
-  }
-  function classTransformer(path, file, builtinClasses, isLoose) {
-    setState({
-      parent: path.parent,
-      scope: path.scope,
-      node: path.node,
-      path,
-      file,
-      isLoose
-    });
-    setState({
-      classId: classState.node.id,
-      classRef: classState.node.id ? _core.types.identifier(classState.node.id.name) : classState.scope.generateUidIdentifier("class"),
-      superName: classState.node.superClass,
-      isDerived: !!classState.node.superClass,
-      constructorBody: _core.types.blockStatement([])
-    });
-    setState({
-      extendsNative: _core.types.isIdentifier(classState.superName) && builtinClasses.has(classState.superName.name) && !classState.scope.hasBinding(classState.superName.name, true)
-    });
-    const {
-      classRef,
-      node,
-      constructorBody
-    } = classState;
-    setState({
-      construct: buildConstructor(classRef, constructorBody, node)
-    });
-    extractDynamicKeys();
-    const {
-      body
-    } = classState;
-    const {
-      closureParams,
-      closureArgs
-    } = setupClosureParamsArgs();
-    buildBody();
-    if (!assumptions.noClassCalls) {
-      constructorBody.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper("classCallCheck"), [_core.types.thisExpression(), _core.types.cloneNode(classState.classRef)])));
-    }
-    const isStrict = path.isInStrictMode();
-    let constructorOnly = classState.classId && body.length === 1;
-    if (constructorOnly && !isStrict) {
-      for (const param of classState.construct.params) {
-        if (!_core.types.isIdentifier(param)) {
-          constructorOnly = false;
-          break;
-        }
-      }
-    }
-    const directives = constructorOnly ? body[0].body.directives : [];
-    if (!isStrict) {
-      directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
-    }
-    if (constructorOnly) {
-      const expr = _core.types.toExpression(body[0]);
-      return classState.isLoose ? expr : createClassHelper([expr]);
-    }
-    let returnArg = _core.types.cloneNode(classState.classRef);
-    if (!classState.pushedCreateClass && !classState.isLoose) {
-      returnArg = createClassHelper([returnArg]);
-    }
-    body.push(_core.types.returnStatement(returnArg));
-    const container = _core.types.arrowFunctionExpression(closureParams, _core.types.blockStatement(body, directives));
-    return _core.types.callExpression(container, closureArgs);
-  }
-  return classTransformer(path, file, builtinClasses, isLoose);
-}
-
-//# sourceMappingURL=transformClass.js.map