Merge branch 'MLAB-671' into 'testing'

Mlab 671

See merge request !158

node_modules/@babel/helper-function-name/LICENSE

+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-function-name/README.md

+# @babel/helper-function-name
+
+> Helper function to change the property 'name' of every function
+
+See our website [@babel/helper-function-name](https://babeljs.io/docs/en/babel-helper-function-name) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-function-name
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-function-name
+```

node_modules/@babel/helper-function-name/lib/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _template = require("@babel/template");
+
+var _t = require("@babel/types");
+
+const {
+  NOT_LOCAL_BINDING,
+  cloneNode,
+  identifier,
+  isAssignmentExpression,
+  isAssignmentPattern,
+  isFunction,
+  isIdentifier,
+  isLiteral,
+  isNullLiteral,
+  isObjectMethod,
+  isObjectProperty,
+  isRegExpLiteral,
+  isRestElement,
+  isTemplateLiteral,
+  isVariableDeclarator,
+  toBindingIdentifierName
+} = _t;
+
+function getFunctionArity(node) {
+  const count = node.params.findIndex(param => isAssignmentPattern(param) || isRestElement(param));
+  return count === -1 ? node.params.length : count;
+}
+
+const buildPropertyMethodAssignmentWrapper = _template.default.statement(`
+  (function (FUNCTION_KEY) {
+    function FUNCTION_ID() {
+      return FUNCTION_KEY.apply(this, arguments);
+    }
+
+    FUNCTION_ID.toString = function () {
+      return FUNCTION_KEY.toString();
+    }
+
+    return FUNCTION_ID;
+  })(FUNCTION)
+`);
+
+const buildGeneratorPropertyMethodAssignmentWrapper = _template.default.statement(`
+  (function (FUNCTION_KEY) {
+    function* FUNCTION_ID() {
+      return yield* FUNCTION_KEY.apply(this, arguments);
+    }
+
+    FUNCTION_ID.toString = function () {
+      return FUNCTION_KEY.toString();
+    };
+
+    return FUNCTION_ID;
+  })(FUNCTION)
+`);
+
+const visitor = {
+  "ReferencedIdentifier|BindingIdentifier"(path, state) {
+    if (path.node.name !== state.name) return;
+    const localDeclar = path.scope.getBindingIdentifier(state.name);
+    if (localDeclar !== state.outerDeclar) return;
+    state.selfReference = true;
+    path.stop();
+  }
+
+};
+
+function getNameFromLiteralId(id) {
+  if (isNullLiteral(id)) {
+    return "null";
+  }
+
+  if (isRegExpLiteral(id)) {
+    return `_${id.pattern}_${id.flags}`;
+  }
+
+  if (isTemplateLiteral(id)) {
+    return id.quasis.map(quasi => quasi.value.raw).join("");
+  }
+
+  if (id.value !== undefined) {
+    return id.value + "";
+  }
+
+  return "";
+}
+
+function wrap(state, method, id, scope) {
+  if (state.selfReference) {
+    if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
+      scope.rename(id.name);
+    } else {
+      if (!isFunction(method)) return;
+      let build = buildPropertyMethodAssignmentWrapper;
+
+      if (method.generator) {
+        build = buildGeneratorPropertyMethodAssignmentWrapper;
+      }
+
+      const template = build({
+        FUNCTION: method,
+        FUNCTION_ID: id,
+        FUNCTION_KEY: scope.generateUidIdentifier(id.name)
+      }).expression;
+      const params = template.callee.body.body[0].params;
+
+      for (let i = 0, len = getFunctionArity(method); i < len; i++) {
+        params.push(scope.generateUidIdentifier("x"));
+      }
+
+      return template;
+    }
+  }
+
+  method.id = id;
+  scope.getProgramParent().references[id.name] = true;
+}
+
+function visit(node, name, scope) {
+  const state = {
+    selfAssignment: false,
+    selfReference: false,
+    outerDeclar: scope.getBindingIdentifier(name),
+    name: name
+  };
+  const binding = scope.getOwnBinding(name);
+
+  if (binding) {
+    if (binding.kind === "param") {
+      state.selfReference = true;
+    } else {}
+  } else if (state.outerDeclar || scope.hasGlobal(name)) {
+    scope.traverse(node, visitor, state);
+  }
+
+  return state;
+}
+
+function _default({
+  node,
+  parent,
+  scope,
+  id
+}, localBinding = false, supportUnicodeId = false) {
+  if (node.id) return;
+
+  if ((isObjectProperty(parent) || isObjectMethod(parent, {
+    kind: "method"
+  })) && (!parent.computed || isLiteral(parent.key))) {
+    id = parent.key;
+  } else if (isVariableDeclarator(parent)) {
+    id = parent.id;
+
+    if (isIdentifier(id) && !localBinding) {
+      const binding = scope.parent.getBinding(id.name);
+
+      if (binding && binding.constant && scope.getBinding(id.name) === binding) {
+        node.id = cloneNode(id);
+        node.id[NOT_LOCAL_BINDING] = true;
+        return;
+      }
+    }
+  } else if (isAssignmentExpression(parent, {
+    operator: "="
+  })) {
+    id = parent.left;
+  } else if (!id) {
+    return;
+  }
+
+  let name;
+
+  if (id && isLiteral(id)) {
+    name = getNameFromLiteralId(id);
+  } else if (id && isIdentifier(id)) {
+    name = id.name;
+  }
+
+  if (name === undefined) {
+    return;
+  }
+
+  if (!supportUnicodeId && isFunction(node) && /[\uD800-\uDFFF]/.test(name)) {
+    return;
+  }
+
+  name = toBindingIdentifierName(name);
+  const newId = identifier(name);
+  newId[NOT_LOCAL_BINDING] = true;
+  const state = visit(node, name, scope);
+  return wrap(state, node, newId, scope) || node;
+}
\ No newline at end of file

node_modules/@babel/helper-function-name/package.json

+{
+  "name": "@babel/helper-function-name",
+  "version": "7.18.6",
+  "description": "Helper function to change the property 'name' of every function",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-function-name"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-function-name",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/template": "^7.18.6",
+    "@babel/types": "^7.18.6"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}
\ No newline at end of file

node_modules/@babel/helper-hoist-variables/LICENSE

+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-hoist-variables/README.md

+# @babel/helper-hoist-variables
+
+> Helper function to hoist variables
+
+See our website [@babel/helper-hoist-variables](https://babeljs.io/docs/en/babel-helper-hoist-variables) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-hoist-variables
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-hoist-variables
+```

node_modules/@babel/helper-hoist-variables/lib/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = hoistVariables;
+
+var _t = require("@babel/types");
+
+const {
+  assignmentExpression,
+  expressionStatement,
+  identifier
+} = _t;
+const visitor = {
+  Scope(path, state) {
+    if (state.kind === "let") path.skip();
+  },
+
+  FunctionParent(path) {
+    path.skip();
+  },
+
+  VariableDeclaration(path, state) {
+    if (state.kind && path.node.kind !== state.kind) return;
+    const nodes = [];
+    const declarations = path.get("declarations");
+    let firstId;
+
+    for (const declar of declarations) {
+      firstId = declar.node.id;
+
+      if (declar.node.init) {
+        nodes.push(expressionStatement(assignmentExpression("=", declar.node.id, declar.node.init)));
+      }
+
+      for (const name of Object.keys(declar.getBindingIdentifiers())) {
+        state.emit(identifier(name), name, declar.node.init !== null);
+      }
+    }
+
+    if (path.parentPath.isFor({
+      left: path.node
+    })) {
+      path.replaceWith(firstId);
+    } else {
+      path.replaceWithMultiple(nodes);
+    }
+  }
+
+};
+
+function hoistVariables(path, emit, kind = "var") {
+  path.traverse(visitor, {
+    kind,
+    emit
+  });
+}
\ No newline at end of file

node_modules/@babel/helper-hoist-variables/package.json

+{
+  "name": "@babel/helper-hoist-variables",
+  "version": "7.18.6",
+  "description": "Helper function to hoist variables",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-hoist-variables"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-hoist-variables",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/types": "^7.18.6"
+  },
+  "TODO": "The @babel/traverse dependency is only needed for the NodePath TS type. We can consider exporting it from @babel/core.",
+  "devDependencies": {
+    "@babel/traverse": "^7.18.6"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}
\ No newline at end of file

node_modules/@babel/helper-member-expression-to-functions/LICENSE

+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-member-expression-to-functions/README.md

+# @babel/helper-member-expression-to-functions
+
+> Helper function to replace certain member expressions with function calls
+
+See our website [@babel/helper-member-expression-to-functions](https://babeljs.io/docs/en/babel-helper-member-expression-to-functions) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-member-expression-to-functions
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-member-expression-to-functions
+```

node_modules/@babel/helper-member-expression-to-functions/lib/index.js

+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _t = require('@babel/types');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var _t__namespace = /*#__PURE__*/_interopNamespace(_t);
+
+function willPathCastToBoolean(path) {
+  const maybeWrapped = path;
+  const {
+    node,
+    parentPath
+  } = maybeWrapped;
+
+  if (parentPath.isLogicalExpression()) {
+    const {
+      operator,
+      right
+    } = parentPath.node;
+
+    if (operator === "&&" || operator === "||" || operator === "??" && node === right) {
+      return willPathCastToBoolean(parentPath);
+    }
+  }
+
+  if (parentPath.isSequenceExpression()) {
+    const {
+      expressions
+    } = parentPath.node;
+
+    if (expressions[expressions.length - 1] === node) {
+      return willPathCastToBoolean(parentPath);
+    } else {
+      return true;
+    }
+  }
+
+  return parentPath.isConditional({
+    test: node
+  }) || parentPath.isUnaryExpression({
+    operator: "!"
+  }) || parentPath.isLoop({
+    test: node
+  });
+}
+
+const {
+  LOGICAL_OPERATORS,
+  arrowFunctionExpression,
+  assignmentExpression,
+  binaryExpression,
+  booleanLiteral,
+  callExpression,
+  cloneNode,
+  conditionalExpression,
+  identifier,
+  isMemberExpression,
+  isOptionalCallExpression,
+  isOptionalMemberExpression,
+  isUpdateExpression,
+  logicalExpression,
+  memberExpression,
+  nullLiteral,
+  optionalCallExpression,
+  optionalMemberExpression,
+  sequenceExpression,
+  updateExpression
+} = _t__namespace;
+
+class AssignmentMemoiser {
+  constructor() {
+    this._map = void 0;
+    this._map = new WeakMap();
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  get(key) {
+    if (!this.has(key)) return;
+
+    const record = this._map.get(key);
+
+    const {
+      value
+    } = record;
+    record.count--;
+
+    if (record.count === 0) {
+      return assignmentExpression("=", value, key);
+    }
+
+    return value;
+  }
+
+  set(key, value, count) {
+    return this._map.set(key, {
+      count,
+      value
+    });
+  }
+
+}
+
+function toNonOptional(path, base) {
+  const {
+    node
+  } = path;
+
+  if (isOptionalMemberExpression(node)) {
+    return memberExpression(base, node.property, node.computed);
+  }
+
+  if (path.isOptionalCallExpression()) {
+    const callee = path.get("callee");
+
+    if (path.node.optional && callee.isOptionalMemberExpression()) {
+      const object = callee.node.object;
+      const context = path.scope.maybeGenerateMemoised(object);
+      callee.get("object").replaceWith(assignmentExpression("=", context, object));
+      return callExpression(memberExpression(base, identifier("call")), [context, ...path.node.arguments]);
+    }
+
+    return callExpression(base, path.node.arguments);
+  }
+
+  return path.node;
+}
+
+function isInDetachedTree(path) {
+  while (path) {
+    if (path.isProgram()) break;
+    const {
+      parentPath,
+      container,
+      listKey
+    } = path;
+    const parentNode = parentPath.node;
+
+    if (listKey) {
+      if (container !== parentNode[listKey]) {
+        return true;
+      }
+    } else {
+      if (container !== parentNode) return true;
+    }
+
+    path = parentPath;
+  }
+
+  return false;
+}
+
+const handle = {
+  memoise() {},
+
+  handle(member, noDocumentAll) {
+    const {
+      node,
+      parent,
+      parentPath,
+      scope
+    } = member;
+
+    if (member.isOptionalMemberExpression()) {
+      if (isInDetachedTree(member)) return;
+      const endPath = member.find(({
+        node,
+        parent
+      }) => {
+        if (isOptionalMemberExpression(parent)) {
+          return parent.optional || parent.object !== node;
+        }
+
+        if (isOptionalCallExpression(parent)) {
+          return node !== member.node && parent.optional || parent.callee !== node;
+        }
+
+        return true;
+      });
+
+      if (scope.path.isPattern()) {
+        endPath.replaceWith(callExpression(arrowFunctionExpression([], endPath.node), []));
+        return;
+      }
+
+      const willEndPathCastToBoolean = willPathCastToBoolean(endPath);
+      const rootParentPath = endPath.parentPath;
+
+      if (rootParentPath.isUpdateExpression({
+        argument: node
+      }) || rootParentPath.isAssignmentExpression({
+        left: node
+      })) {
+        throw member.buildCodeFrameError(`can't handle assignment`);
+      }
+
+      const isDeleteOperation = rootParentPath.isUnaryExpression({
+        operator: "delete"
+      });
+
+      if (isDeleteOperation && endPath.isOptionalMemberExpression() && endPath.get("property").isPrivateName()) {
+        throw member.buildCodeFrameError(`can't delete a private class element`);
+      }
+
+      let startingOptional = member;
+
+      for (;;) {
+        if (startingOptional.isOptionalMemberExpression()) {
+          if (startingOptional.node.optional) break;
+          startingOptional = startingOptional.get("object");
+          continue;
+        } else if (startingOptional.isOptionalCallExpression()) {
+          if (startingOptional.node.optional) break;
+          startingOptional = startingOptional.get("callee");
+          continue;
+        }
+
+        throw new Error(`Internal error: unexpected ${startingOptional.node.type}`);
+      }
+
+      const startingNode = startingOptional.isOptionalMemberExpression() ? startingOptional.node.object : startingOptional.node.callee;
+      const baseNeedsMemoised = scope.maybeGenerateMemoised(startingNode);
+      const baseRef = baseNeedsMemoised != null ? baseNeedsMemoised : startingNode;
+      const parentIsOptionalCall = parentPath.isOptionalCallExpression({
+        callee: node
+      });
+
+      const isOptionalCall = parent => parentIsOptionalCall;
+
+      const parentIsCall = parentPath.isCallExpression({
+        callee: node
+      });
+      startingOptional.replaceWith(toNonOptional(startingOptional, baseRef));
+
+      if (isOptionalCall()) {
+        if (parent.optional) {
+          parentPath.replaceWith(this.optionalCall(member, parent.arguments));
+        } else {
+          parentPath.replaceWith(this.call(member, parent.arguments));
+        }
+      } else if (parentIsCall) {
+        member.replaceWith(this.boundGet(member));
+      } else {
+        member.replaceWith(this.get(member));
+      }
+
+      let regular = member.node;
+
+      for (let current = member; current !== endPath;) {
+        const parentPath = current.parentPath;
+
+        if (parentPath === endPath && isOptionalCall() && parent.optional) {
+          regular = parentPath.node;
+          break;
+        }
+
+        regular = toNonOptional(parentPath, regular);
+        current = parentPath;
+      }
+
+      let context;
+      const endParentPath = endPath.parentPath;
+
+      if (isMemberExpression(regular) && endParentPath.isOptionalCallExpression({
+        callee: endPath.node,
+        optional: true
+      })) {
+        const {
+          object
+        } = regular;
+        context = member.scope.maybeGenerateMemoised(object);
+
+        if (context) {
+          regular.object = assignmentExpression("=", context, object);
+        }
+      }
+
+      let replacementPath = endPath;
+
+      if (isDeleteOperation) {
+        replacementPath = endParentPath;
+        regular = endParentPath.node;
+      }
+
+      const baseMemoised = baseNeedsMemoised ? assignmentExpression("=", cloneNode(baseRef), cloneNode(startingNode)) : cloneNode(baseRef);
+
+      if (willEndPathCastToBoolean) {
+        let nonNullishCheck;
+
+        if (noDocumentAll) {
+          nonNullishCheck = binaryExpression("!=", baseMemoised, nullLiteral());
+        } else {
+          nonNullishCheck = logicalExpression("&&", binaryExpression("!==", baseMemoised, nullLiteral()), binaryExpression("!==", cloneNode(baseRef), scope.buildUndefinedNode()));
+        }
+
+        replacementPath.replaceWith(logicalExpression("&&", nonNullishCheck, regular));
+      } else {
+        let nullishCheck;
+
+        if (noDocumentAll) {
+          nullishCheck = binaryExpression("==", baseMemoised, nullLiteral());
+        } else {
+          nullishCheck = logicalExpression("||", binaryExpression("===", baseMemoised, nullLiteral()), binaryExpression("===", cloneNode(baseRef), scope.buildUndefinedNode()));
+        }
+
+        replacementPath.replaceWith(conditionalExpression(nullishCheck, isDeleteOperation ? booleanLiteral(true) : scope.buildUndefinedNode(), regular));
+      }
+
+      if (context) {
+        const endParent = endParentPath.node;
+        endParentPath.replaceWith(optionalCallExpression(optionalMemberExpression(endParent.callee, identifier("call"), false, true), [cloneNode(context), ...endParent.arguments], false));
+      }
+
+      return;
+    }
+
+    if (isUpdateExpression(parent, {
+      argument: node
+    })) {
+      if (this.simpleSet) {
+        member.replaceWith(this.simpleSet(member));
+        return;
+      }
+
+      const {
+        operator,
+        prefix
+      } = parent;
+      this.memoise(member, 2);
+      const ref = scope.generateUidIdentifierBasedOnNode(node);
+      scope.push({
+        id: ref
+      });
+      const seq = [assignmentExpression("=", cloneNode(ref), this.get(member))];
+
+      if (prefix) {
+        seq.push(updateExpression(operator, cloneNode(ref), prefix));
+        const value = sequenceExpression(seq);
+        parentPath.replaceWith(this.set(member, value));
+        return;
+      } else {
+        const ref2 = scope.generateUidIdentifierBasedOnNode(node);
+        scope.push({
+          id: ref2
+        });
+        seq.push(assignmentExpression("=", cloneNode(ref2), updateExpression(operator, cloneNode(ref), prefix)), cloneNode(ref));
+        const value = sequenceExpression(seq);
+        parentPath.replaceWith(sequenceExpression([this.set(member, value), cloneNode(ref2)]));
+        return;
+      }
+    }
+
+    if (parentPath.isAssignmentExpression({
+      left: node
+    })) {
+      if (this.simpleSet) {
+        member.replaceWith(this.simpleSet(member));
+        return;
+      }
+
+      const {
+        operator,
+        right: value
+      } = parentPath.node;
+
+      if (operator === "=") {
+        parentPath.replaceWith(this.set(member, value));
+      } else {
+        const operatorTrunc = operator.slice(0, -1);
+
+        if (LOGICAL_OPERATORS.includes(operatorTrunc)) {
+          this.memoise(member, 1);
+          parentPath.replaceWith(logicalExpression(operatorTrunc, this.get(member), this.set(member, value)));
+        } else {
+          this.memoise(member, 2);
+          parentPath.replaceWith(this.set(member, binaryExpression(operatorTrunc, this.get(member), value)));
+        }
+      }
+
+      return;
+    }
+
+    if (parentPath.isCallExpression({
+      callee: node
+    })) {
+      parentPath.replaceWith(this.call(member, parentPath.node.arguments));
+      return;
+    }
+
+    if (parentPath.isOptionalCallExpression({
+      callee: node
+    })) {
+      if (scope.path.isPattern()) {
+        parentPath.replaceWith(callExpression(arrowFunctionExpression([], parentPath.node), []));
+        return;
+      }
+
+      parentPath.replaceWith(this.optionalCall(member, parentPath.node.arguments));
+      return;
+    }
+
+    if (parentPath.isForXStatement({
+      left: node
+    }) || parentPath.isObjectProperty({
+      value: node
+    }) && parentPath.parentPath.isObjectPattern() || parentPath.isAssignmentPattern({
+      left: node
+    }) && parentPath.parentPath.isObjectProperty({
+      value: parent
+    }) && parentPath.parentPath.parentPath.isObjectPattern() || parentPath.isArrayPattern() || parentPath.isAssignmentPattern({
+      left: node
+    }) && parentPath.parentPath.isArrayPattern() || parentPath.isRestElement()) {
+      member.replaceWith(this.destructureSet(member));
+      return;
+    }
+
+    if (parentPath.isTaggedTemplateExpression()) {
+      member.replaceWith(this.boundGet(member));
+    } else {
+      member.replaceWith(this.get(member));
+    }
+  }
+
+};
+function memberExpressionToFunctions(path, visitor, state) {
+  path.traverse(visitor, Object.assign({}, handle, state, {
+    memoiser: new AssignmentMemoiser()
+  }));
+}
+
+exports["default"] = memberExpressionToFunctions;
+//# sourceMappingURL=index.js.map

node_modules/@babel/helper-member-expression-to-functions/lib/index.js.map

+{"version":3,"file":"index.js","sources":["../src/util.ts","../src/index.ts"],"sourcesContent":["import type { NodePath } from \"@babel/traverse\";\n\n/**\n * Test if a NodePath will be cast to boolean when evaluated.\n *\n * @example\n * // returns true\n * const nodePathAQDotB = NodePath(\"if (a?.#b) {}\").get(\"test\"); // a?.#b\n * willPathCastToBoolean(nodePathAQDotB)\n * @example\n * // returns false\n * willPathCastToBoolean(NodePath(\"a?.#b\"))\n * @todo Respect transparent expression wrappers\n * @see {@link packages/babel-plugin-proposal-optional-chaining/src/util.js}\n * @param {NodePath} path\n * @returns {boolean}\n */\nexport function willPathCastToBoolean(path: NodePath): boolean {\n  const maybeWrapped = path;\n  const { node, parentPath } = maybeWrapped;\n  if (parentPath.isLogicalExpression()) {\n    const { operator, right } = parentPath.node;\n    if (\n      operator === \"&&\" ||\n      operator === \"||\" ||\n      (operator === \"??\" && node === right)\n    ) {\n      return willPathCastToBoolean(parentPath);\n    }\n  }\n  if (parentPath.isSequenceExpression()) {\n    const { expressions } = parentPath.node;\n    if (expressions[expressions.length - 1] === node) {\n      return willPathCastToBoolean(parentPath);\n    } else {\n      // if it is in the middle of a sequence expression, we don't\n      // care the return value so just cast to boolean for smaller\n      // output\n      return true;\n    }\n  }\n  return (\n    parentPath.isConditional({ test: node }) ||\n    parentPath.isUnaryExpression({ operator: \"!\" }) ||\n    parentPath.isLoop({ test: node })\n  );\n}\n","import type { NodePath, Visitor } from \"@babel/traverse\";\nimport {\n  LOGICAL_OPERATORS,\n  arrowFunctionExpression,\n  assignmentExpression,\n  binaryExpression,\n  booleanLiteral,\n  callExpression,\n  cloneNode,\n  conditionalExpression,\n  identifier,\n  isMemberExpression,\n  isOptionalCallExpression,\n  isOptionalMemberExpression,\n  isUpdateExpression,\n  logicalExpression,\n  memberExpression,\n  nullLiteral,\n  optionalCallExpression,\n  optionalMemberExpression,\n  sequenceExpression,\n  updateExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport { willPathCastToBoolean } from \"./util\";\n\nclass AssignmentMemoiser {\n  private _map: WeakMap<t.Expression, { count: number; value: t.Identifier }>;\n  constructor() {\n    this._map = new WeakMap();\n  }\n\n  has(key: t.Expression) {\n    return this._map.has(key);\n  }\n\n  get(key: t.Expression) {\n    if (!this.has(key)) return;\n\n    const record = this._map.get(key);\n    const { value } = record;\n\n    record.count--;\n    if (record.count === 0) {\n      // The `count` access is the outermost function call (hopefully), so it\n      // does the assignment.\n      return assignmentExpression(\"=\", value, key);\n    }\n    return value;\n  }\n\n  set(key: t.Expression, value: t.Identifier, count: number) {\n    return this._map.set(key, { count, value });\n  }\n}\n\nfunction toNonOptional(\n  path: NodePath<t.Expression>,\n  base: t.Expression,\n): t.Expression {\n  const { node } = path;\n  if (isOptionalMemberExpression(node)) {\n    return memberExpression(base, node.property, node.computed);\n  }\n\n  if (path.isOptionalCallExpression()) {\n    const callee = path.get(\"callee\");\n    if (path.node.optional && callee.isOptionalMemberExpression()) {\n      // object must be a conditional expression because the optional private access in object has been transformed\n      const object = callee.node.object as t.ConditionalExpression;\n      const context = path.scope.maybeGenerateMemoised(object);\n      callee\n        .get(\"object\")\n        .replaceWith(assignmentExpression(\"=\", context, object));\n\n      return callExpression(memberExpression(base, identifier(\"call\")), [\n        context,\n        ...path.node.arguments,\n      ]);\n    }\n\n    return callExpression(base, path.node.arguments);\n  }\n\n  return path.node;\n}\n\n// Determines if the current path is in a detached tree. This can happen when\n// we are iterating on a path, and replace an ancestor with a new node. Babel\n// doesn't always stop traversing the old node tree, and that can cause\n// inconsistencies.\nfunction isInDetachedTree(path: NodePath) {\n  while (path) {\n    if (path.isProgram()) break;\n\n    const { parentPath, container, listKey } = path;\n    const parentNode = parentPath.node;\n    if (listKey) {\n      if (\n        container !==\n        // @ts-expect-error listKey must be a valid parent node key\n        parentNode[listKey]\n      ) {\n        return true;\n      }\n    } else {\n      if (container !== parentNode) return true;\n    }\n\n    path = parentPath;\n  }\n\n  return false;\n}\n\ntype Member = NodePath<t.OptionalMemberExpression | t.MemberExpression>;\n\nconst handle = {\n  memoise() {\n    // noop.\n  },\n\n  handle(this: HandlerState, member: Member, noDocumentAll: boolean) {\n    const { node, parent, parentPath, scope } = member;\n\n    if (member.isOptionalMemberExpression()) {\n      // Transforming optional chaining requires we replace ancestors.\n      if (isInDetachedTree(member)) return;\n\n      // We're looking for the end of _this_ optional chain, which is actually\n      // the \"rightmost\" property access of the chain. This is because\n      // everything up to that property access is \"optional\".\n      //\n      // Let's take the case of `FOO?.BAR.baz?.qux`, with `FOO?.BAR` being our\n      // member. The \"end\" to most users would be `qux` property access.\n      // Everything up to it could be skipped if it `FOO` were nullish. But\n      // actually, we can consider the `baz` access to be the end. So we're\n      // looking for the nearest optional chain that is `optional: true`.\n      const endPath = member.find(({ node, parent }) => {\n        if (isOptionalMemberExpression(parent)) {\n          // We need to check `parent.object` since we could be inside the\n          // computed expression of a `bad?.[FOO?.BAR]`. In this case, the\n          // endPath is the `FOO?.BAR` member itself.\n          return parent.optional || parent.object !== node;\n        }\n        if (isOptionalCallExpression(parent)) {\n          // Checking `parent.callee` since we could be in the arguments, eg\n          // `bad?.(FOO?.BAR)`.\n          // Also skip `FOO?.BAR` in `FOO?.BAR?.()` since we need to transform the optional call to ensure proper this\n          return (\n            // In FOO?.#BAR?.(), endPath points the optional call expression so we skip FOO?.#BAR\n            (node !== member.node && parent.optional) || parent.callee !== node\n          );\n        }\n        return true;\n      }) as NodePath<t.OptionalMemberExpression>;\n\n      // Replace `function (a, x = a.b?.#c) {}` to `function (a, x = (() => a.b?.#c)() ){}`\n      // so the temporary variable can be injected in correct scope\n      // This can be further optimized to avoid unecessary IIFE\n      if (scope.path.isPattern()) {\n        endPath.replaceWith(\n          // The injected member will be queued and eventually transformed when visited\n          callExpression(arrowFunctionExpression([], endPath.node), []),\n        );\n        return;\n      }\n\n      const willEndPathCastToBoolean = willPathCastToBoolean(endPath);\n\n      const rootParentPath = endPath.parentPath;\n      if (\n        rootParentPath.isUpdateExpression({ argument: node }) ||\n        rootParentPath.isAssignmentExpression({ left: node })\n      ) {\n        throw member.buildCodeFrameError(`can't handle assignment`);\n      }\n      const isDeleteOperation = rootParentPath.isUnaryExpression({\n        operator: \"delete\",\n      });\n      if (\n        isDeleteOperation &&\n        endPath.isOptionalMemberExpression() &&\n        endPath.get(\"property\").isPrivateName()\n      ) {\n        // @babel/parser will throw error on `delete obj?.#x`.\n        // This error serves as fallback when `delete obj?.#x` is constructed from babel types\n        throw member.buildCodeFrameError(\n          `can't delete a private class element`,\n        );\n      }\n\n      // Now, we're looking for the start of this optional chain, which is\n      // optional to the left of this member.\n      //\n      // Let's take the case of `foo?.bar?.baz.QUX?.BAM`, with `QUX?.BAM` being\n      // our member. The \"start\" to most users would be `foo` object access.\n      // But actually, we can consider the `bar` access to be the start. So\n      // we're looking for the nearest optional chain that is `optional: true`,\n      // which is guaranteed to be somewhere in the object/callee tree.\n      let startingOptional: NodePath<t.Expression> = member;\n      for (;;) {\n        if (startingOptional.isOptionalMemberExpression()) {\n          if (startingOptional.node.optional) break;\n          startingOptional = startingOptional.get(\"object\");\n          continue;\n        } else if (startingOptional.isOptionalCallExpression()) {\n          if (startingOptional.node.optional) break;\n          startingOptional = startingOptional.get(\"callee\");\n          continue;\n        }\n        // prevent infinite loop: unreachable if the AST is well-formed\n        throw new Error(\n          `Internal error: unexpected ${startingOptional.node.type}`,\n        );\n      }\n\n      const startingNode = startingOptional.isOptionalMemberExpression()\n        ? startingOptional.node.object\n        : startingOptional.node.callee;\n      const baseNeedsMemoised = scope.maybeGenerateMemoised(startingNode);\n      const baseRef = baseNeedsMemoised ?? startingNode;\n\n      // Compute parentIsOptionalCall before `startingOptional` is replaced\n      // as `node` may refer to `startingOptional.node` before replaced.\n      const parentIsOptionalCall = parentPath.isOptionalCallExpression({\n        callee: node,\n      });\n      // here we use a function to wrap `parentIsOptionalCall` to get type\n      // for parent, do not use it anywhere else\n      // See https://github.com/microsoft/TypeScript/issues/10421\n      const isOptionalCall = (\n        parent: t.Node,\n      ): parent is t.OptionalCallExpression => parentIsOptionalCall;\n      // if parentIsCall is true, it implies that node.extra.parenthesized is always true\n      const parentIsCall = parentPath.isCallExpression({ callee: node });\n      startingOptional.replaceWith(toNonOptional(startingOptional, baseRef));\n      if (isOptionalCall(parent)) {\n        if (parent.optional) {\n          parentPath.replaceWith(this.optionalCall(member, parent.arguments));\n        } else {\n          parentPath.replaceWith(this.call(member, parent.arguments));\n        }\n      } else if (parentIsCall) {\n        // `(a?.#b)()` to `(a == null ? void 0 : a.#b.bind(a))()`\n        member.replaceWith(this.boundGet(member));\n      } else {\n        member.replaceWith(this.get(member));\n      }\n\n      let regular: t.Expression = member.node;\n      for (let current: NodePath = member; current !== endPath; ) {\n        const parentPath = current.parentPath as NodePath<t.Expression>;\n        // skip transforming `Foo.#BAR?.call(FOO)`\n        if (\n          parentPath === endPath &&\n          isOptionalCall(parent) &&\n          parent.optional\n        ) {\n          regular = parentPath.node;\n          break;\n        }\n        regular = toNonOptional(parentPath, regular);\n        current = parentPath;\n      }\n\n      let context: t.Identifier;\n      const endParentPath = endPath.parentPath as NodePath<t.Expression>;\n      if (\n        isMemberExpression(regular) &&\n        endParentPath.isOptionalCallExpression({\n          callee: endPath.node,\n          optional: true,\n        })\n      ) {\n        const { object } = regular;\n        context = member.scope.maybeGenerateMemoised(object);\n        if (context) {\n          regular.object = assignmentExpression(\"=\", context, object);\n        }\n      }\n\n      let replacementPath: NodePath = endPath;\n      if (isDeleteOperation) {\n        replacementPath = endParentPath;\n        regular = endParentPath.node;\n      }\n\n      const baseMemoised = baseNeedsMemoised\n        ? assignmentExpression(\n            \"=\",\n            // When base needs memoised, the baseRef must be an identifier\n            cloneNode(baseRef as t.Identifier),\n            cloneNode(startingNode),\n          )\n        : cloneNode(baseRef);\n\n      if (willEndPathCastToBoolean) {\n        let nonNullishCheck;\n        if (noDocumentAll) {\n          nonNullishCheck = binaryExpression(\"!=\", baseMemoised, nullLiteral());\n        } else {\n          nonNullishCheck = logicalExpression(\n            \"&&\",\n            binaryExpression(\"!==\", baseMemoised, nullLiteral()),\n            binaryExpression(\n              \"!==\",\n              cloneNode(baseRef),\n              scope.buildUndefinedNode(),\n            ),\n          );\n        }\n        replacementPath.replaceWith(\n          logicalExpression(\"&&\", nonNullishCheck, regular),\n        );\n      } else {\n        let nullishCheck;\n        if (noDocumentAll) {\n          nullishCheck = binaryExpression(\"==\", baseMemoised, nullLiteral());\n        } else {\n          nullishCheck = logicalExpression(\n            \"||\",\n            binaryExpression(\"===\", baseMemoised, nullLiteral()),\n            binaryExpression(\n              \"===\",\n              cloneNode(baseRef),\n              scope.buildUndefinedNode(),\n            ),\n          );\n        }\n\n        replacementPath.replaceWith(\n          conditionalExpression(\n            nullishCheck,\n            isDeleteOperation\n              ? booleanLiteral(true)\n              : scope.buildUndefinedNode(),\n            regular,\n          ),\n        );\n      }\n\n      // context and isDeleteOperation can not be both truthy\n      if (context) {\n        const endParent = endParentPath.node as t.OptionalCallExpression;\n        endParentPath.replaceWith(\n          optionalCallExpression(\n            optionalMemberExpression(\n              endParent.callee,\n              identifier(\"call\"),\n              false,\n              true,\n            ),\n            [cloneNode(context), ...endParent.arguments],\n            false,\n          ),\n        );\n      }\n\n      return;\n    }\n\n    // MEMBER++   ->   _set(MEMBER, (ref = _get(MEMBER), ref2 = ref++, ref)), ref2\n    // ++MEMBER   ->   _set(MEMBER, (ref = _get(MEMBER), ++ref))\n    if (isUpdateExpression(parent, { argument: node })) {\n      if (this.simpleSet) {\n        member.replaceWith(this.simpleSet(member));\n        return;\n      }\n\n      const { operator, prefix } = parent;\n\n      // Give the state handler a chance to memoise the member, since we'll\n      // reference it twice. The second access (the set) should do the memo\n      // assignment.\n      this.memoise(member, 2);\n\n      const ref = scope.generateUidIdentifierBasedOnNode(node);\n      scope.push({ id: ref });\n\n      const seq: t.Expression[] = [\n        // ref = _get(MEMBER)\n        assignmentExpression(\"=\", cloneNode(ref), this.get(member)),\n      ];\n\n      if (prefix) {\n        seq.push(updateExpression(operator, cloneNode(ref), prefix));\n\n        // (ref = _get(MEMBER), ++ref)\n        const value = sequenceExpression(seq);\n        parentPath.replaceWith(this.set(member, value));\n\n        return;\n      } else {\n        const ref2 = scope.generateUidIdentifierBasedOnNode(node);\n        scope.push({ id: ref2 });\n\n        seq.push(\n          assignmentExpression(\n            \"=\",\n            cloneNode(ref2),\n            updateExpression(operator, cloneNode(ref), prefix),\n          ),\n          cloneNode(ref),\n        );\n\n        // (ref = _get(MEMBER), ref2 = ref++, ref)\n        const value = sequenceExpression(seq);\n        parentPath.replaceWith(\n          sequenceExpression([this.set(member, value), cloneNode(ref2)]),\n        );\n\n        return;\n      }\n    }\n\n    // MEMBER = VALUE   ->   _set(MEMBER, VALUE)\n    // MEMBER += VALUE   ->   _set(MEMBER, _get(MEMBER) + VALUE)\n    // MEMBER ??= VALUE   ->   _get(MEMBER) ?? _set(MEMBER, VALUE)\n    if (parentPath.isAssignmentExpression({ left: node })) {\n      if (this.simpleSet) {\n        member.replaceWith(this.simpleSet(member));\n        return;\n      }\n\n      const { operator, right: value } = parentPath.node;\n\n      if (operator === \"=\") {\n        parentPath.replaceWith(this.set(member, value));\n      } else {\n        const operatorTrunc = operator.slice(0, -1);\n        if (LOGICAL_OPERATORS.includes(operatorTrunc)) {\n          // Give the state handler a chance to memoise the member, since we'll\n          // reference it twice. The first access (the get) should do the memo\n          // assignment.\n          this.memoise(member, 1);\n          parentPath.replaceWith(\n            logicalExpression(\n              operatorTrunc as t.LogicalExpression[\"operator\"],\n              this.get(member),\n              this.set(member, value),\n            ),\n          );\n        } else {\n          // Here, the second access (the set) is evaluated first.\n          this.memoise(member, 2);\n          parentPath.replaceWith(\n            this.set(\n              member,\n              binaryExpression(\n                operatorTrunc as t.BinaryExpression[\"operator\"],\n                this.get(member),\n                value,\n              ),\n            ),\n          );\n        }\n      }\n      return;\n    }\n\n    // MEMBER(ARGS) -> _call(MEMBER, ARGS)\n    if (parentPath.isCallExpression({ callee: node })) {\n      parentPath.replaceWith(this.call(member, parentPath.node.arguments));\n      return;\n    }\n\n    // MEMBER?.(ARGS) -> _optionalCall(MEMBER, ARGS)\n    if (parentPath.isOptionalCallExpression({ callee: node })) {\n      // Replace `function (a, x = a.b.#c?.()) {}` to `function (a, x = (() => a.b.#c?.())() ){}`\n      // so the temporary variable can be injected in correct scope\n      // This can be further optimized to avoid unecessary IIFE\n      if (scope.path.isPattern()) {\n        parentPath.replaceWith(\n          // The injected member will be queued and eventually transformed when visited\n          callExpression(arrowFunctionExpression([], parentPath.node), []),\n        );\n        return;\n      }\n      parentPath.replaceWith(\n        this.optionalCall(member, parentPath.node.arguments),\n      );\n      return;\n    }\n\n    // for (MEMBER of ARR)\n    // for (MEMBER in ARR)\n    // { KEY: MEMBER } = OBJ -> { KEY: _destructureSet(MEMBER) } = OBJ\n    // { KEY: MEMBER = _VALUE } = OBJ -> { KEY: _destructureSet(MEMBER) = _VALUE } = OBJ\n    // {...MEMBER} -> {..._destructureSet(MEMBER)}\n    //\n    // [MEMBER] = ARR -> [_destructureSet(MEMBER)] = ARR\n    // [MEMBER = _VALUE] = ARR -> [_destructureSet(MEMBER) = _VALUE] = ARR\n    // [...MEMBER] -> [..._destructureSet(MEMBER)]\n    if (\n      // for (MEMBER of ARR)\n      // for (MEMBER in ARR)\n      parentPath.isForXStatement({ left: node }) ||\n      // { KEY: MEMBER } = OBJ\n      (parentPath.isObjectProperty({ value: node }) &&\n        parentPath.parentPath.isObjectPattern()) ||\n      // { KEY: MEMBER = _VALUE } = OBJ\n      (parentPath.isAssignmentPattern({ left: node }) &&\n        parentPath.parentPath.isObjectProperty({ value: parent }) &&\n        parentPath.parentPath.parentPath.isObjectPattern()) ||\n      // [MEMBER] = ARR\n      parentPath.isArrayPattern() ||\n      // [MEMBER = _VALUE] = ARR\n      (parentPath.isAssignmentPattern({ left: node }) &&\n        parentPath.parentPath.isArrayPattern()) ||\n      // {...MEMBER}\n      // [...MEMBER]\n      parentPath.isRestElement()\n    ) {\n      member.replaceWith(this.destructureSet(member));\n      return;\n    }\n\n    if (parentPath.isTaggedTemplateExpression()) {\n      // MEMBER   ->   _get(MEMBER).bind(this)\n      member.replaceWith(this.boundGet(member));\n    } else {\n      // MEMBER   ->   _get(MEMBER)\n      member.replaceWith(this.get(member));\n    }\n  },\n};\n\nexport interface Handler<State> {\n  memoise?(\n    this: HandlerState<State> & State,\n    member: Member,\n    count: number,\n  ): void;\n  destructureSet(\n    this: HandlerState<State> & State,\n    member: Member,\n  ): t.Expression;\n  boundGet(this: HandlerState<State> & State, member: Member): t.Expression;\n  simpleSet?(this: HandlerState<State> & State, member: Member): t.Expression;\n  get(this: HandlerState<State> & State, member: Member): t.Expression;\n  set(\n    this: HandlerState<State> & State,\n    member: Member,\n    value: t.Expression,\n  ): t.Expression;\n  call(\n    this: HandlerState<State> & State,\n    member: Member,\n    args: t.CallExpression[\"arguments\"],\n  ): t.Expression;\n  optionalCall(\n    this: HandlerState<State> & State,\n    member: Member,\n    args: t.OptionalCallExpression[\"arguments\"],\n  ): t.Expression;\n}\n\nexport interface HandlerState<State = {}> extends Handler<State> {\n  handle(\n    this: HandlerState<State> & State,\n    member: Member,\n    noDocumentAll?: boolean,\n  ): void;\n  memoiser: AssignmentMemoiser;\n}\n\n// We do not provide a default traversal visitor\n// Instead, caller passes one, and must call `state.handle` on the members\n// it wishes to be transformed.\n// Additionally, the caller must pass in a state object with at least\n// get, set, and call methods.\n// Optionally, a memoise method may be defined on the state, which will be\n// called when the member is a self-referential update.\nexport default function memberExpressionToFunctions<CustomState = {}>(\n  path: NodePath,\n  visitor: Visitor<HandlerState<CustomState>>,\n  state: Handler<CustomState> & CustomState,\n) {\n  path.traverse(visitor, {\n    ...handle,\n    ...state,\n    memoiser: new AssignmentMemoiser(),\n  });\n}\n"],"names":["willPathCastToBoolean","path","maybeWrapped","node","parentPath","isLogicalExpression","operator","right","isSequenceExpression","expressions","length","isConditional","test","isUnaryExpression","isLoop","LOGICAL_OPERATORS","arrowFunctionExpression","assignmentExpression","binaryExpression","booleanLiteral","callExpression","cloneNode","conditionalExpression","identifier","isMemberExpression","isOptionalCallExpression","isOptionalMemberExpression","isUpdateExpression","logicalExpression","memberExpression","nullLiteral","optionalCallExpression","optionalMemberExpression","sequenceExpression","updateExpression","AssignmentMemoiser","constructor","_map","WeakMap","has","key","get","record","value","count","set","toNonOptional","base","property","computed","callee","optional","object","context","scope","maybeGenerateMemoised","replaceWith","arguments","isInDetachedTree","isProgram","container","listKey","parentNode","handle","memoise","member","noDocumentAll","parent","endPath","find","isPattern","willEndPathCastToBoolean","rootParentPath","argument","isAssignmentExpression","left","buildCodeFrameError","isDeleteOperation","isPrivateName","startingOptional","Error","type","startingNode","baseNeedsMemoised","baseRef","parentIsOptionalCall","isOptionalCall","parentIsCall","isCallExpression","optionalCall","call","boundGet","regular","current","endParentPath","replacementPath","baseMemoised","nonNullishCheck","buildUndefinedNode","nullishCheck","endParent","simpleSet","prefix","ref","generateUidIdentifierBasedOnNode","push","id","seq","ref2","operatorTrunc","slice","includes","isForXStatement","isObjectProperty","isObjectPattern","isAssignmentPattern","isArrayPattern","isRestElement","destructureSet","isTaggedTemplateExpression","memberExpressionToFunctions","visitor","state","traverse","memoiser"],"mappings":"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"}
\ No newline at end of file

node_modules/@babel/helper-member-expression-to-functions/package.json

+{
+  "name": "@babel/helper-member-expression-to-functions",
+  "version": "7.18.6",
+  "description": "Helper function to replace certain member expressions with function calls",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-member-expression-to-functions"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-member-expression-to-functions",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "dependencies": {
+    "@babel/types": "^7.18.6"
+  },
+  "devDependencies": {
+    "@babel/traverse": "^7.18.6"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}
\ No newline at end of file

node_modules/@babel/helper-module-imports/LICENSE

+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-module-imports/README.md

+# @babel/helper-module-imports
+
+> Babel helper functions for inserting module loads
+
+See our website [@babel/helper-module-imports](https://babeljs.io/docs/en/babel-helper-module-imports) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-module-imports
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-module-imports
+```

node_modules/@babel/helper-module-imports/lib/import-builder.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = require("assert");
+
+var _t = require("@babel/types");
+
+const {
+  callExpression,
+  cloneNode,
+  expressionStatement,
+  identifier,
+  importDeclaration,
+  importDefaultSpecifier,
+  importNamespaceSpecifier,
+  importSpecifier,
+  memberExpression,
+  stringLiteral,
+  variableDeclaration,
+  variableDeclarator
+} = _t;
+
+class ImportBuilder {
+  constructor(importedSource, scope, hub) {
+    this._statements = [];
+    this._resultName = null;
+    this._importedSource = void 0;
+    this._scope = scope;
+    this._hub = hub;
+    this._importedSource = importedSource;
+  }
+
+  done() {
+    return {
+      statements: this._statements,
+      resultName: this._resultName
+    };
+  }
+
+  import() {
+    this._statements.push(importDeclaration([], stringLiteral(this._importedSource)));
+
+    return this;
+  }
+
+  require() {
+    this._statements.push(expressionStatement(callExpression(identifier("require"), [stringLiteral(this._importedSource)])));
+
+    return this;
+  }
+
+  namespace(name = "namespace") {
+    const local = this._scope.generateUidIdentifier(name);
+
+    const statement = this._statements[this._statements.length - 1];
+
+    _assert(statement.type === "ImportDeclaration");
+
+    _assert(statement.specifiers.length === 0);
+
+    statement.specifiers = [importNamespaceSpecifier(local)];
+    this._resultName = cloneNode(local);
+    return this;
+  }
+
+  default(name) {
+    const id = this._scope.generateUidIdentifier(name);
+
+    const statement = this._statements[this._statements.length - 1];
+
+    _assert(statement.type === "ImportDeclaration");
+
+    _assert(statement.specifiers.length === 0);
+
+    statement.specifiers = [importDefaultSpecifier(id)];
+    this._resultName = cloneNode(id);
+    return this;
+  }
+
+  named(name, importName) {
+    if (importName === "default") return this.default(name);
+
+    const id = this._scope.generateUidIdentifier(name);
+
+    const statement = this._statements[this._statements.length - 1];
+
+    _assert(statement.type === "ImportDeclaration");
+
+    _assert(statement.specifiers.length === 0);
+
+    statement.specifiers = [importSpecifier(id, identifier(importName))];
+    this._resultName = cloneNode(id);
+    return this;
+  }
+
+  var(name) {
+    const id = this._scope.generateUidIdentifier(name);
+
+    let statement = this._statements[this._statements.length - 1];
+
+    if (statement.type !== "ExpressionStatement") {
+      _assert(this._resultName);
+
+      statement = expressionStatement(this._resultName);
+
+      this._statements.push(statement);
+    }
+
+    this._statements[this._statements.length - 1] = variableDeclaration("var", [variableDeclarator(id, statement.expression)]);
+    this._resultName = cloneNode(id);
+    return this;
+  }
+
+  defaultInterop() {
+    return this._interop(this._hub.addHelper("interopRequireDefault"));
+  }
+
+  wildcardInterop() {
+    return this._interop(this._hub.addHelper("interopRequireWildcard"));
+  }
+
+  _interop(callee) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = callExpression(callee, [statement.expression]);
+    } else if (statement.type === "VariableDeclaration") {
+      _assert(statement.declarations.length === 1);
+
+      statement.declarations[0].init = callExpression(callee, [statement.declarations[0].init]);
+    } else {
+      _assert.fail("Unexpected type.");
+    }
+
+    return this;
+  }
+
+  prop(name) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = memberExpression(statement.expression, identifier(name));
+    } else if (statement.type === "VariableDeclaration") {
+      _assert(statement.declarations.length === 1);
+
+      statement.declarations[0].init = memberExpression(statement.declarations[0].init, identifier(name));
+    } else {
+      _assert.fail("Unexpected type:" + statement.type);
+    }
+
+    return this;
+  }
+
+  read(name) {
+    this._resultName = memberExpression(this._resultName, identifier(name));
+  }
+
+}
+
+exports.default = ImportBuilder;
\ No newline at end of file

node_modules/@babel/helper-module-imports/lib/import-injector.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = require("assert");
+
+var _t = require("@babel/types");
+
+var _importBuilder = require("./import-builder");
+
+var _isModule = require("./is-module");
+
+const {
+  numericLiteral,
+  sequenceExpression
+} = _t;
+
+class ImportInjector {
+  constructor(path, importedSource, opts) {
+    this._defaultOpts = {
+      importedSource: null,
+      importedType: "commonjs",
+      importedInterop: "babel",
+      importingInterop: "babel",
+      ensureLiveReference: false,
+      ensureNoContext: false,
+      importPosition: "before"
+    };
+    const programPath = path.find(p => p.isProgram());
+    this._programPath = programPath;
+    this._programScope = programPath.scope;
+    this._hub = programPath.hub;
+    this._defaultOpts = this._applyDefaults(importedSource, opts, true);
+  }
+
+  addDefault(importedSourceIn, opts) {
+    return this.addNamed("default", importedSourceIn, opts);
+  }
+
+  addNamed(importName, importedSourceIn, opts) {
+    _assert(typeof importName === "string");
+
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
+  }
+
+  addNamespace(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
+  }
+
+  addSideEffect(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), void 0);
+  }
+
+  _applyDefaults(importedSource, opts, isInit = false) {
+    let newOpts;
+
+    if (typeof importedSource === "string") {
+      newOpts = Object.assign({}, this._defaultOpts, {
+        importedSource
+      }, opts);
+    } else {
+      _assert(!opts, "Unexpected secondary arguments.");
+
+      newOpts = Object.assign({}, this._defaultOpts, importedSource);
+    }
+
+    if (!isInit && opts) {
+      if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
+      if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
+    }
+
+    return newOpts;
+  }
+
+  _generateImport(opts, importName) {
+    const isDefault = importName === "default";
+    const isNamed = !!importName && !isDefault;
+    const isNamespace = importName === null;
+    const {
+      importedSource,
+      importedType,
+      importedInterop,
+      importingInterop,
+      ensureLiveReference,
+      ensureNoContext,
+      nameHint,
+      importPosition,
+      blockHoist
+    } = opts;
+    let name = nameHint || importName;
+    const isMod = (0, _isModule.default)(this._programPath);
+    const isModuleForNode = isMod && importingInterop === "node";
+    const isModuleForBabel = isMod && importingInterop === "babel";
+
+    if (importPosition === "after" && !isMod) {
+      throw new Error(`"importPosition": "after" is only supported in modules`);
+    }
+
+    const builder = new _importBuilder.default(importedSource, this._programScope, this._hub);
+
+    if (importedType === "es6") {
+      if (!isModuleForNode && !isModuleForBabel) {
+        throw new Error("Cannot import an ES6 module from CommonJS");
+      }
+
+      builder.import();
+
+      if (isNamespace) {
+        builder.namespace(nameHint || importedSource);
+      } else if (isDefault || isNamed) {
+        builder.named(name, importName);
+      }
+    } else if (importedType !== "commonjs") {
+      throw new Error(`Unexpected interopType "${importedType}"`);
+    } else if (importedInterop === "babel") {
+      if (isModuleForNode) {
+        name = name !== "default" ? name : importedSource;
+        const es6Default = `${importedSource}$es6Default`;
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(es6Default).var(name || importedSource).wildcardInterop();
+        } else if (isDefault) {
+          if (ensureLiveReference) {
+            builder.default(es6Default).var(name || importedSource).defaultInterop().read("default");
+          } else {
+            builder.default(es6Default).var(name).defaultInterop().prop(importName);
+          }
+        } else if (isNamed) {
+          builder.default(es6Default).read(importName);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource).wildcardInterop();
+        } else if ((isDefault || isNamed) && ensureLiveReference) {
+          if (isDefault) {
+            name = name !== "default" ? name : importedSource;
+            builder.var(name).read(importName);
+            builder.defaultInterop();
+          } else {
+            builder.var(importedSource).read(importName);
+          }
+        } else if (isDefault) {
+          builder.var(name).defaultInterop().prop(importName);
+        } else if (isNamed) {
+          builder.var(name).prop(importName);
+        }
+      }
+    } else if (importedInterop === "compiled") {
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault || isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.prop(importName).var(name);
+          }
+        }
+      }
+    } else if (importedInterop === "uncompiled") {
+      if (isDefault && ensureLiveReference) {
+        throw new Error("No live reference for commonjs default");
+      }
+
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault) {
+          builder.var(name);
+        } else if (isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.var(name).prop(importName);
+          }
+        }
+      }
+    } else {
+      throw new Error(`Unknown importedInterop "${importedInterop}".`);
+    }
+
+    const {
+      statements,
+      resultName
+    } = builder.done();
+
+    this._insertStatements(statements, importPosition, blockHoist);
+
+    if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
+      return sequenceExpression([numericLiteral(0), resultName]);
+    }
+
+    return resultName;
+  }
+
+  _insertStatements(statements, importPosition = "before", blockHoist = 3) {
+    const body = this._programPath.get("body");
+
+    if (importPosition === "after") {
+      for (let i = body.length - 1; i >= 0; i--) {
+        if (body[i].isImportDeclaration()) {
+          body[i].insertAfter(statements);
+          return;
+        }
+      }
+    } else {
+      statements.forEach(node => {
+        node._blockHoist = blockHoist;
+      });
+      const targetPath = body.find(p => {
+        const val = p.node._blockHoist;
+        return Number.isFinite(val) && val < 4;
+      });
+
+      if (targetPath) {
+        targetPath.insertBefore(statements);
+        return;
+      }
+    }
+
+    this._programPath.unshiftContainer("body", statements);
+  }
+
+}
+
+exports.default = ImportInjector;
\ No newline at end of file

node_modules/@babel/helper-module-imports/lib/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ImportInjector", {
+  enumerable: true,
+  get: function () {
+    return _importInjector.default;
+  }
+});
+exports.addDefault = addDefault;
+exports.addNamed = addNamed;
+exports.addNamespace = addNamespace;
+exports.addSideEffect = addSideEffect;
+Object.defineProperty(exports, "isModule", {
+  enumerable: true,
+  get: function () {
+    return _isModule.default;
+  }
+});
+
+var _importInjector = require("./import-injector");
+
+var _isModule = require("./is-module");
+
+function addDefault(path, importedSource, opts) {
+  return new _importInjector.default(path).addDefault(importedSource, opts);
+}
+
+function addNamed(path, name, importedSource, opts) {
+  return new _importInjector.default(path).addNamed(name, importedSource, opts);
+}
+
+function addNamespace(path, importedSource, opts) {
+  return new _importInjector.default(path).addNamespace(importedSource, opts);
+}
+
+function addSideEffect(path, importedSource, opts) {
+  return new _importInjector.default(path).addSideEffect(importedSource, opts);
+}
\ No newline at end of file

node_modules/@babel/helper-module-imports/lib/is-module.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isModule;
+
+function isModule(path) {
+  const {
+    sourceType
+  } = path.node;
+
+  if (sourceType !== "module" && sourceType !== "script") {
+    throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`);
+  }
+
+  return path.node.sourceType === "module";
+}
\ No newline at end of file

node_modules/@babel/helper-module-imports/package.json

+{
+  "name": "@babel/helper-module-imports",
+  "version": "7.18.6",
+  "description": "Babel helper functions for inserting module loads",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-module-imports",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-module-imports"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/types": "^7.18.6"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.18.6",
+    "@babel/traverse": "^7.18.6"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}
\ No newline at end of file