@next-core/brick-utils 2.37.24 → 2.38.0

package/dist/index.bundle.js

@@ -1,16 +1,16 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@babel/runtime/helpers/taggedTemplateLiteral'), require('@babel/runtime/helpers/objectWithoutProperties'), require('@next-core/pipes'), require('js-yaml')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@babel/runtime/helpers/taggedTemplateLiteral', '@babel/runtime/helpers/objectWithoutProperties', '@next-core/pipes', 'js-yaml'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global._taggedTemplateLiteral, global._objectWithoutProperties, global.pipes, global.yaml));
-})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, _taggedTemplateLiteral, _objectWithoutProperties, pipes, yaml) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@babel/runtime/helpers/objectWithoutProperties'), require('@babel/runtime/helpers/taggedTemplateLiteral'), require('@next-core/pipes'), require('js-yaml')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@babel/runtime/helpers/objectWithoutProperties', '@babel/runtime/helpers/taggedTemplateLiteral', '@next-core/pipes', 'js-yaml'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global._objectWithoutProperties, global._taggedTemplateLiteral, global.pipes, global.yaml));
+})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, _objectWithoutProperties, _taggedTemplateLiteral, pipes, yaml) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
   var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
   var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
   var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
-  var _taggedTemplateLiteral__default = /*#__PURE__*/_interopDefaultLegacy(_taggedTemplateLiteral);
   var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+  var _taggedTemplateLiteral__default = /*#__PURE__*/_interopDefaultLegacy(_taggedTemplateLiteral);
   var yaml__default = /*#__PURE__*/_interopDefaultLegacy(yaml);
 
   var cache$1 = new Map();
@@ -3277,6 +3277,7 @@
     }),
     ImportCallNotNewExpression: _("Cannot use new with import(...)."),
     ImportCallSpreadArgument: _("`...` is not allowed in `import()`."),
+    ImportJSONBindingNotDefault: _("A JSON module can only be imported with `default`."),
     IncompatibleRegExpUVFlags: _("The 'u' and 'v' regular expression flags cannot be enabled at the same time."),
     InvalidBigIntLiteral: _("Invalid BigIntLiteral."),
     InvalidCodePoint: _("Code point out of bounds."),
@@ -3613,8 +3614,8 @@
   });
 
   function toESTreeLocation(node) {
-    toUnenumerable(node.loc.start, "index");
-    toUnenumerable(node.loc.end, "index");
+    node.loc.start && toUnenumerable(node.loc.start, "index");
+    node.loc.end && toUnenumerable(node.loc.end, "index");
     return node;
   }
 
@@ -3888,10 +3889,9 @@
         }
 
         this.toAssignable(value, isLHS);
-        return node;
+      } else {
+        super.toAssignable(node, isLHS);
       }
-
-      return super.toAssignable(node, isLHS);
     }
 
     toAssignableObjectExpressionProp(prop) {
@@ -3904,11 +3904,7 @@
           at: prop.key
         });
       } else {
-        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-          args[_key3 - 1] = arguments[_key3];
-        }
-
-        super.toAssignableObjectExpressionProp(prop, ...args);
+        super.toAssignableObjectExpressionProp(...arguments);
       }
     }
 
@@ -4005,6 +4001,11 @@
       return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
     }
 
+    resetStartLocation(node, start, startLoc) {
+      super.resetStartLocation(node, start, startLoc);
+      toESTreeLocation(node);
+    }
+
     resetEndLocation(node) {
       var endLoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.lastTokEndLoc;
       super.resetEndLocation(node, endLoc);
@@ -4152,9 +4153,7 @@
       beforeExpr,
       startsExpr
     }),
-    braceR: createToken("}", {
-      beforeExpr
-    }),
+    braceR: createToken("}"),
     braceBarR: createToken("|}"),
     parenL: createToken("(", {
       beforeExpr,
@@ -5044,6 +5043,7 @@
       this.hasFlowComment = false;
       this.isAmbientContext = false;
       this.inAbstractClass = false;
+      this.inDisallowConditionalTypesContext = false;
       this.topicContext = {
         maxNumOfResolvableTopics: 0,
         maxTopicIndex: null
@@ -7056,7 +7056,7 @@
       this.parser.raise(toParseError, origin);
     }
 
-    recordParenthesizedIdentifierError(_ref45) {
+    recordArrowParemeterBindingError(error, _ref45) {
       var {
         at: node
       } = _ref45;
@@ -7069,9 +7069,9 @@
       };
 
       if (scope.isCertainlyParameterDeclaration()) {
-        this.parser.raise(Errors.InvalidParenthesizedAssignment, origin);
+        this.parser.raise(error, origin);
       } else if (scope.canBeArrowParameterDeclaration()) {
-        scope.recordDeclarationError(Errors.InvalidParenthesizedAssignment, origin);
+        scope.recordDeclarationError(error, origin);
       } else {
         return;
       }
@@ -9522,11 +9522,11 @@
     toAssignable(node) {
       var isLHS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
-      if (node.type === "TypeCastExpression") {
-        return super.toAssignable(this.typeCastToParameter(node), isLHS);
-      } else {
-        return super.toAssignable(node, isLHS);
+      if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") {
+        node.left = this.typeCastToParameter(node.left);
       }
+
+      super.toAssignable(...arguments);
     }
 
     toAssignableList(exprList, trailingCommaLoc, isLHS) {
@@ -9538,7 +9538,7 @@
         }
       }
 
-      return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
+      super.toAssignableList(exprList, trailingCommaLoc, isLHS);
     }
 
     toReferencedList(exprList, isParenthesizedExpr) {
@@ -9568,8 +9568,8 @@
     }
 
     isValidLVal(type) {
-      for (var _len4 = arguments.length, rest = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
-        rest[_key4 - 1] = arguments[_key4];
+      for (var _len3 = arguments.length, rest = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+        rest[_key3 - 1] = arguments[_key3];
       }
 
       return type === "TypeCastExpression" || super.isValidLVal(type, ...rest);
@@ -10118,7 +10118,8 @@
       return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState);
     }
 
-    parseNewArguments(node) {
+    parseNewCallee(node) {
+      super.parseNewCallee(node);
       var targs = null;
 
       if (this.shouldParseTypes() && this.match(47)) {
@@ -10126,7 +10127,6 @@
       }
 
       node.typeArguments = targs;
-      super.parseNewArguments(node);
     }
 
     parseAsyncArrowWithTypeParameters(startPos, startLoc) {
@@ -11199,6 +11199,7 @@
       this.next();
       node.expression = this.parseExpression();
       this.setContext(types.j_oTag);
+      this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXSpreadChild");
     }
@@ -11212,6 +11213,7 @@
       }
 
       this.setContext(previousContext);
+      this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXExpressionContainer");
     }
@@ -11225,6 +11227,7 @@
         this.expect(21);
         node.argument = this.parseMaybeAssignAllowIn();
         this.setContext(types.j_oTag);
+        this.state.canStartJSXElement = true;
         this.expect(8);
         return this.finishNode(node, "JSXSpreadAttribute");
       }
@@ -11237,8 +11240,7 @@
     jsxParseOpeningElementAt(startPos, startLoc) {
       var node = this.startNodeAt(startPos, startLoc);
 
-      if (this.match(139)) {
-        this.expect(139);
+      if (this.eat(139)) {
         return this.finishNode(node, "JSXOpeningFragment");
       }
 
@@ -11262,8 +11264,7 @@
     jsxParseClosingElementAt(startPos, startLoc) {
       var node = this.startNodeAt(startPos, startLoc);
 
-      if (this.match(139)) {
-        this.expect(139);
+      if (this.eat(139)) {
         return this.finishNode(node, "JSXClosingFragment");
       }
 
@@ -11619,12 +11620,25 @@
       } = _ref80;
       return "'".concat(modifier, "' modifier cannot appear on a type member.");
     }),
-    InvalidModifiersOrder: _(_ref81 => {
+    InvalidModifierOnTypeParameter: _(_ref81 => {
       var {
-        orderedModifiers
+        modifier
       } = _ref81;
+      return "'".concat(modifier, "' modifier cannot appear on a type parameter.");
+    }),
+    InvalidModifierOnTypeParameterPositions: _(_ref82 => {
+      var {
+        modifier
+      } = _ref82;
+      return "'".concat(modifier, "' modifier can only appear on a type parameter of a class, interface or type alias.");
+    }),
+    InvalidModifiersOrder: _(_ref83 => {
+      var {
+        orderedModifiers
+      } = _ref83;
       return "'".concat(orderedModifiers[0], "' modifier must precede '").concat(orderedModifiers[1], "' modifier.");
     }),
+    InvalidPropertyAccessAfterInstantiationExpression: _("Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments."),
     InvalidTupleMemberLabel: _("Tuple members must be labeled with a simple identifier."),
     MissingInterfaceName: _("'interface' declarations must be followed by an identifier."),
     MixedLabeledAndUnlabeledElements: _("Tuple members must all have names or all not have names."),
@@ -11634,10 +11648,10 @@
     OverrideNotInSubClass: _("This member cannot have an 'override' modifier because its containing class does not extend another class."),
     PatternIsOptional: _("A binding pattern parameter cannot be optional in an implementation signature."),
     PrivateElementHasAbstract: _("Private elements cannot have the 'abstract' modifier."),
-    PrivateElementHasAccessibility: _(_ref82 => {
+    PrivateElementHasAccessibility: _(_ref84 => {
       var {
         modifier
-      } = _ref82;
+      } = _ref84;
       return "Private elements cannot have an accessibility modifier ('".concat(modifier, "').");
     }),
     ReadonlyForMethodSignature: _("'readonly' modifier can only appear on a property declaration or index signature."),
@@ -11646,10 +11660,10 @@
     SetAccesorCannotHaveOptionalParameter: _("A 'set' accessor cannot have an optional parameter."),
     SetAccesorCannotHaveRestParameter: _("A 'set' accessor cannot have rest parameter."),
     SetAccesorCannotHaveReturnType: _("A 'set' accessor cannot have a return type annotation."),
-    SingleTypeParameterWithoutTrailingComma: _(_ref83 => {
+    SingleTypeParameterWithoutTrailingComma: _(_ref85 => {
       var {
         typeParameterName
-      } = _ref83;
+      } = _ref85;
       return "Single type parameter ".concat(typeParameterName, " should have a trailing comma. Example usage: <").concat(typeParameterName, ",>.");
     }),
     StaticBlockCannotHaveModifier: _("Static class blocks cannot have any modifier."),
@@ -11663,10 +11677,10 @@
     UnexpectedTypeCastInParameter: _("Unexpected type cast in parameter position."),
     UnsupportedImportTypeArgument: _("Argument in a type import must be a string literal."),
     UnsupportedParameterPropertyKind: _("A parameter property may not be declared using a binding pattern."),
-    UnsupportedSignatureParameterKind: _(_ref84 => {
+    UnsupportedSignatureParameterKind: _(_ref86 => {
       var {
         type
-      } = _ref84;
+      } = _ref86;
       return "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ".concat(type, ".");
     })
   }));
@@ -11712,6 +11726,10 @@
     return modifier === "private" || modifier === "public" || modifier === "protected";
   }
 
+  function tsIsVarianceAnnotations(modifier) {
+    return modifier === "in" || modifier === "out";
+  }
+
   var typescript = superClass => class extends superClass {
     getScopeHandler() {
       return TypeScriptScopeHandler;
@@ -11731,7 +11749,7 @@
     }
 
     tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
-      if (!tokenIsIdentifier(this.state.type)) {
+      if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58) {
         return undefined;
       }
 
@@ -11750,13 +11768,14 @@
       return undefined;
     }
 
-    tsParseModifiers(_ref85) {
+    tsParseModifiers(_ref87) {
       var {
         modified,
         allowedModifiers,
         disallowedModifiers,
-        stopOnStartOfClassStaticBlock
-      } = _ref85;
+        stopOnStartOfClassStaticBlock,
+        errorTemplate = TSErrors.InvalidModifierOnTypeMember
+      } = _ref87;
 
       var enforceOrder = (loc, modifier, before, after) => {
         if (modifier === before && modified[after]) {
@@ -11795,6 +11814,16 @@
             enforceOrder(startLoc, modifier, modifier, "readonly");
             modified.accessibility = modifier;
           }
+        } else if (tsIsVarianceAnnotations(modifier)) {
+          if (modified[modifier]) {
+            this.raise(TSErrors.DuplicateModifier, {
+              at: startLoc,
+              modifier
+            });
+          }
+
+          modified[modifier] = true;
+          enforceOrder(startLoc, modifier, "in", "out");
         } else {
           if (Object.hasOwnProperty.call(modified, modifier)) {
             this.raise(TSErrors.DuplicateModifier, {
@@ -11814,7 +11843,7 @@
         }
 
         if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-          this.raise(TSErrors.InvalidModifierOnTypeMember, {
+          this.raise(errorTemplate, {
             at: startLoc,
             modifier
           });
@@ -11991,24 +12020,48 @@
         node.exprName = this.tsParseEntityName();
       }
 
+      if (!this.hasPrecedingLineBreak() && this.match(47)) {
+        node.typeParameters = this.tsParseTypeArguments();
+      }
+
       return this.finishNode(node, "TSTypeQuery");
     }
 
+    tsParseInOutModifiers(node) {
+      this.tsParseModifiers({
+        modified: node,
+        allowedModifiers: ["in", "out"],
+        disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
+        errorTemplate: TSErrors.InvalidModifierOnTypeParameter
+      });
+    }
+
+    tsParseNoneModifiers(node) {
+      this.tsParseModifiers({
+        modified: node,
+        allowedModifiers: [],
+        disallowedModifiers: ["in", "out"],
+        errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
+      });
+    }
+
     tsParseTypeParameter() {
+      var parseModifiers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.tsParseNoneModifiers.bind(this);
       var node = this.startNode();
+      parseModifiers(node);
       node.name = this.tsParseTypeParameterName();
       node.constraint = this.tsEatThenParseType(81);
       node.default = this.tsEatThenParseType(29);
       return this.finishNode(node, "TSTypeParameter");
     }
 
-    tsTryParseTypeParameters() {
+    tsTryParseTypeParameters(parseModifiers) {
       if (this.match(47)) {
-        return this.tsParseTypeParameters();
+        return this.tsParseTypeParameters(parseModifiers);
       }
     }
 
-    tsParseTypeParameters() {
+    tsParseTypeParameters(parseModifiers) {
       var node = this.startNode();
 
       if (this.match(47) || this.match(138)) {
@@ -12020,7 +12073,7 @@
       var refTrailingCommaPos = {
         value: -1
       };
-      node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this), false, true, refTrailingCommaPos);
+      node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
 
       if (node.params.length === 0) {
         this.raise(TSErrors.EmptyTypeParameters, {
@@ -12411,7 +12464,7 @@
         this.next();
       }
 
-      this.tsFillSignature(19, node);
+      this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
       return this.finishNode(node, type);
     }
 
@@ -12580,13 +12633,24 @@
       this.expectContextual(112);
       var typeParameter = this.startNode();
       typeParameter.name = this.tsParseTypeParameterName();
+      typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
       node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
       return this.finishNode(node, "TSInferType");
     }
 
+    tsParseConstraintForInferType() {
+      if (this.eat(81)) {
+        var constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
+
+        if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
+          return constraint;
+        }
+      }
+    }
+
     tsParseTypeOperatorOrHigher() {
       var isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
-      return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsParseArrayTypeOrHigher();
+      return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
     }
 
     tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
@@ -12788,17 +12852,17 @@
       assert(this.state.inType);
       var type = this.tsParseNonConditionalType();
 
-      if (this.hasPrecedingLineBreak() || !this.eat(81)) {
+      if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
         return type;
       }
 
       var node = this.startNodeAtNode(type);
       node.checkType = type;
-      node.extendsType = this.tsParseNonConditionalType();
+      node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
       this.expect(17);
-      node.trueType = this.tsParseType();
+      node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
       this.expect(14);
-      node.falseType = this.tsParseType();
+      node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
       return this.finishNode(node, "TSConditionalType");
     }
 
@@ -12839,7 +12903,16 @@
 
     tsParseHeritageClause(token) {
       var originalStartLoc = this.state.startLoc;
-      var delimitedList = this.tsParseDelimitedList("HeritageClauseElement", this.tsParseExpressionWithTypeArguments.bind(this));
+      var delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
+        var node = this.startNode();
+        node.expression = this.tsParseEntityName();
+
+        if (this.match(47)) {
+          node.typeParameters = this.tsParseTypeArguments();
+        }
+
+        return this.finishNode(node, "TSExpressionWithTypeArguments");
+      });
 
       if (!delimitedList.length) {
         this.raise(TSErrors.EmptyHeritageClauseType, {
@@ -12851,17 +12924,6 @@
       return delimitedList;
     }
 
-    tsParseExpressionWithTypeArguments() {
-      var node = this.startNode();
-      node.expression = this.tsParseEntityName();
-
-      if (this.match(47)) {
-        node.typeParameters = this.tsParseTypeArguments();
-      }
-
-      return this.finishNode(node, "TSExpressionWithTypeArguments");
-    }
-
     tsParseInterfaceDeclaration(node) {
       var properties = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       if (this.hasFollowingLineBreak()) return null;
@@ -12878,7 +12940,7 @@
         });
       }
 
-      node.typeParameters = this.tsTryParseTypeParameters();
+      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
 
       if (this.eat(81)) {
         node.extends = this.tsParseHeritageClause("extends");
@@ -12894,7 +12956,7 @@
       node.id = this.parseIdentifier();
       this.checkIdentifier(node.id, BIND_TS_TYPE);
       node.typeAnnotation = this.tsInType(() => {
-        node.typeParameters = this.tsTryParseTypeParameters();
+        node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
         this.expect(29);
 
         if (this.isContextual(111) && this.lookahead().type !== 16) {
@@ -12932,6 +12994,28 @@
       }
     }
 
+    tsInDisallowConditionalTypesContext(cb) {
+      var oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
+      this.state.inDisallowConditionalTypesContext = true;
+
+      try {
+        return cb();
+      } finally {
+        this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+      }
+    }
+
+    tsInAllowConditionalTypesContext(cb) {
+      var oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
+      this.state.inDisallowConditionalTypesContext = false;
+
+      try {
+        return cb();
+      } finally {
+        this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+      }
+    }
+
     tsEatThenParseType(token) {
       return !this.match(token) ? undefined : this.tsNextThenParseType();
     }
@@ -13451,61 +13535,78 @@
             }
           }
 
-          var node = this.startNodeAt(startPos, startLoc);
-          node.callee = base;
           var typeArguments = this.tsParseTypeArgumentsInExpression();
+          if (!typeArguments) return;
 
-          if (typeArguments) {
-            if (isOptionalCall && !this.match(10)) {
-              missingParenErrorLoc = this.state.curPosition();
-              this.unexpected();
-            }
+          if (isOptionalCall && !this.match(10)) {
+            missingParenErrorLoc = this.state.curPosition();
+            return;
+          }
 
-            if (!noCalls && this.eat(10)) {
-              node.arguments = this.parseCallExpressionArguments(11, false);
-              this.tsCheckForInvalidTypeCasts(node.arguments);
-              node.typeParameters = typeArguments;
+          if (tokenIsTemplate(this.state.type)) {
+            var _result = this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
 
-              if (state.optionalChainMember) {
-                node.optional = isOptionalCall;
-              }
+            _result.typeParameters = typeArguments;
+            return _result;
+          }
+
+          if (!noCalls && this.eat(10)) {
+            var _node9 = this.startNodeAt(startPos, startLoc);
 
-              return this.finishCallExpression(node, state.optionalChainMember);
-            } else if (tokenIsTemplate(this.state.type)) {
-              var _result = this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
+            _node9.callee = base;
+            _node9.arguments = this.parseCallExpressionArguments(11, false);
+            this.tsCheckForInvalidTypeCasts(_node9.arguments);
+            _node9.typeParameters = typeArguments;
 
-              _result.typeParameters = typeArguments;
-              return _result;
+            if (state.optionalChainMember) {
+              _node9.optional = isOptionalCall;
             }
+
+            return this.finishCallExpression(_node9, state.optionalChainMember);
           }
 
-          this.unexpected();
+          var tokenType = this.state.type;
+
+          if (tokenType === 48 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
+            return;
+          }
+
+          var node = this.startNodeAt(startPos, startLoc);
+          node.expression = base;
+          node.typeParameters = typeArguments;
+          return this.finishNode(node, "TSInstantiationExpression");
         });
 
         if (missingParenErrorLoc) {
           this.unexpected(missingParenErrorLoc, 10);
         }
 
-        if (result) return result;
+        if (result) {
+          if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
+            this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
+              at: this.state.startLoc
+            });
+          }
+
+          return result;
+        }
       }
 
       return super.parseSubscript(base, startPos, startLoc, noCalls, state);
     }
 
-    parseNewArguments(node) {
-      if (this.match(47) || this.match(51)) {
-        var typeParameters = this.tsTryParseAndCatch(() => {
-          var args = this.tsParseTypeArgumentsInExpression();
-          if (!this.match(10)) this.unexpected();
-          return args;
-        });
+    parseNewCallee(node) {
+      var _callee$extra;
 
-        if (typeParameters) {
-          node.typeParameters = typeParameters;
-        }
-      }
+      super.parseNewCallee(node);
+      var {
+        callee
+      } = node;
 
-      super.parseNewArguments(node);
+      if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
+        node.typeParameters = callee.typeParameters;
+        node.callee = callee.expression;
+      }
     }
 
     parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {
@@ -13693,7 +13794,9 @@
       this.tsParseModifiers({
         modified: member,
         allowedModifiers: modifiers,
-        stopOnStartOfClassStaticBlock: true
+        disallowedModifiers: ["in", "out"],
+        stopOnStartOfClassStaticBlock: true,
+        errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
       });
 
       var callParseClassMemberWithIsStatic = () => {
@@ -13872,7 +13975,7 @@
       }
 
       super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
-      var typeParameters = this.tsTryParseTypeParameters();
+      var typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
       if (typeParameters) node.typeParameters = typeParameters;
     }
 
@@ -13978,8 +14081,8 @@
       var typeParameters = this.tsTryParseTypeParameters();
       if (typeParameters) prop.typeParameters = typeParameters;
 
-      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
-        args[_key5 - 1] = arguments[_key5];
+      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+        args[_key4 - 1] = arguments[_key4];
       }
 
       super.parseObjPropValue(prop, ...args);
@@ -14015,8 +14118,8 @@
     }
 
     parseMaybeAssign() {
-      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-        args[_key6] = arguments[_key6];
+      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        args[_key5] = arguments[_key5];
       }
 
       var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;
@@ -14043,10 +14146,10 @@
         return super.parseMaybeAssign(...args);
       }
 
+      if (!state || state === this.state) state = this.state.clone();
       var typeParameters;
-      state = state || this.state.clone();
       var arrow = this.tryParse(abort => {
-        var _expr$extra, _typeParameters, _expr$typeParameters$;
+        var _expr$extra, _typeParameters;
 
         typeParameters = this.tsParseTypeParameters();
         var expr = super.parseMaybeAssign(...args);
@@ -14060,12 +14163,6 @@
         }
 
         expr.typeParameters = typeParameters;
-
-        if (this.hasPlugin("jsx") && expr.typeParameters.params.length === 1 && !((_expr$typeParameters$ = expr.typeParameters.extra) != null && _expr$typeParameters$.trailingComma)) {
-          var parameter = expr.typeParameters.params[0];
-          if (!parameter.constraint) ;
-        }
-
         return expr;
       }, state);
 
@@ -14172,23 +14269,33 @@
       var isLHS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
       switch (node.type) {
-        case "TSTypeCastExpression":
-          return super.toAssignable(this.typeCastToParameter(node), isLHS);
-
-        case "TSParameterProperty":
-          return super.toAssignable(node, isLHS);
-
         case "ParenthesizedExpression":
-          return this.toAssignableParenthesizedExpression(node, isLHS);
+          this.toAssignableParenthesizedExpression(node, isLHS);
+          break;
 
         case "TSAsExpression":
         case "TSNonNullExpression":
         case "TSTypeAssertion":
-          node.expression = this.toAssignable(node.expression, isLHS);
-          return node;
+          if (isLHS) {
+            this.expressionScope.recordArrowParemeterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
+              at: node
+            });
+          } else {
+            this.raise(TSErrors.UnexpectedTypeCastInParameter, {
+              at: node
+            });
+          }
+
+          this.toAssignable(node.expression, isLHS);
+          break;
+
+        case "AssignmentExpression":
+          if (!isLHS && node.left.type === "TSTypeCastExpression") {
+            node.left = this.typeCastToParameter(node.left);
+          }
 
         default:
-          return super.toAssignable(node, isLHS);
+          super.toAssignable(node, isLHS);
       }
     }
 
@@ -14198,22 +14305,35 @@
         case "TSNonNullExpression":
         case "TSTypeAssertion":
         case "ParenthesizedExpression":
-          node.expression = this.toAssignable(node.expression, isLHS);
-          return node;
+          this.toAssignable(node.expression, isLHS);
+          break;
 
         default:
-          return super.toAssignable(node, isLHS);
+          super.toAssignable(node, isLHS);
       }
     }
 
-    isValidLVal(type, isParenthesized, binding) {
+    checkToRestConversion(node, allowPattern) {
+      switch (node.type) {
+        case "TSAsExpression":
+        case "TSTypeAssertion":
+        case "TSNonNullExpression":
+          this.checkToRestConversion(node.expression, false);
+          break;
+
+        default:
+          super.checkToRestConversion(node, allowPattern);
+      }
+    }
+
+    isValidLVal(type, isUnparenthesizedInAssign, binding) {
       return getOwn$1({
         TSTypeCastExpression: true,
         TSParameterProperty: "parameter",
         TSNonNullExpression: "expression",
-        TSAsExpression: (binding !== BIND_NONE || isParenthesized) && ["expression", true],
-        TSTypeAssertion: (binding !== BIND_NONE || isParenthesized) && ["expression", true]
-      }, type) || super.isValidLVal(type, isParenthesized, binding);
+        TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
+        TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true]
+      }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
     }
 
     parseBindingAtom() {
@@ -14316,28 +14436,13 @@
     toAssignableList(exprList) {
       for (var i = 0; i < exprList.length; i++) {
         var expr = exprList[i];
-        if (!expr) continue;
-
-        switch (expr.type) {
-          case "TSTypeCastExpression":
-            exprList[i] = this.typeCastToParameter(expr);
-            break;
 
-          case "TSAsExpression":
-          case "TSTypeAssertion":
-            if (!this.state.maybeInArrowParameters) {
-              exprList[i] = this.typeCastToParameter(expr);
-            } else {
-              this.raise(TSErrors.UnexpectedTypeCastInParameter, {
-                at: expr
-              });
-            }
-
-            break;
+        if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
+          exprList[i] = this.typeCastToParameter(expr);
         }
       }
 
-      return super.toAssignableList(...arguments);
+      super.toAssignableList(...arguments);
     }
 
     typeCastToParameter(node) {
@@ -14407,8 +14512,8 @@
       this.state.inAbstractClass = !!node.abstract;
 
       try {
-        for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
-          args[_key7 - 1] = arguments[_key7];
+        for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+          args[_key6 - 1] = arguments[_key6];
         }
 
         return super.parseClass(node, ...args);
@@ -14532,7 +14637,16 @@
         }
       } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
         hasTypeSpecifier = true;
-        leftOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
+
+        if (isImport) {
+          leftOfAs = this.parseIdentifier(true);
+
+          if (!this.isContextual(93)) {
+            this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
+          }
+        } else {
+          leftOfAs = this.parseModuleExportName();
+        }
       }
 
       if (hasTypeSpecifier && isInTypeOnlyImportExport) {
@@ -14631,8 +14745,8 @@
     }
 
     isValidLVal(type) {
-      for (var _len8 = arguments.length, rest = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
-        rest[_key8 - 1] = arguments[_key8];
+      for (var _len7 = arguments.length, rest = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
+        rest[_key7 - 1] = arguments[_key7];
       }
 
       return type === "Placeholder" || super.isValidLVal(type, ...rest);
@@ -14641,10 +14755,9 @@
     toAssignable(node) {
       if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
         node.expectedNode = "Pattern";
-        return node;
+      } else {
+        super.toAssignable(...arguments);
       }
-
-      return super.toAssignable(...arguments);
     }
 
     isLet(context) {
@@ -14956,9 +15069,9 @@
           throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
         }
 
-        var moduleAttributesVerionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
+        var moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
 
-        if (moduleAttributesVerionPluginOption !== "may-2020") {
+        if (moduleAttributesVersionPluginOption !== "may-2020") {
           throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
         }
       }
@@ -15032,7 +15145,7 @@
 
         if (isLHS) {
           if (parenthesized.type === "Identifier") {
-            this.expressionScope.recordParenthesizedIdentifierError({
+            this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, {
               at: node
             });
           } else if (parenthesized.type !== "MemberExpression") {
@@ -15091,11 +15204,7 @@
 
         case "SpreadElement":
           {
-            this.checkToRestConversion(node);
-            node.type = "RestElement";
-            var arg = node.argument;
-            this.toAssignable(arg, isLHS);
-            break;
+            throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
           }
 
         case "ArrayExpression":
@@ -15119,8 +15228,6 @@
           this.toAssignable(parenthesized, isLHS);
           break;
       }
-
-      return node;
     }
 
     toAssignableObjectExpressionProp(prop, isLast, isLHS) {
@@ -15128,58 +15235,50 @@
         this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
           at: prop.key
         });
-      } else if (prop.type === "SpreadElement" && !isLast) {
-        this.raise(Errors.RestTrailingComma, {
-          at: prop
-        });
+      } else if (prop.type === "SpreadElement") {
+        prop.type = "RestElement";
+        var arg = prop.argument;
+        this.checkToRestConversion(arg, false);
+        this.toAssignable(arg, isLHS);
+
+        if (!isLast) {
+          this.raise(Errors.RestTrailingComma, {
+            at: prop
+          });
+        }
       } else {
         this.toAssignable(prop, isLHS);
       }
     }
 
     toAssignableList(exprList, trailingCommaLoc, isLHS) {
-      var end = exprList.length;
-
-      if (end) {
-        var last = exprList[end - 1];
+      var end = exprList.length - 1;
 
-        if ((last == null ? void 0 : last.type) === "RestElement") {
-          --end;
-        } else if ((last == null ? void 0 : last.type) === "SpreadElement") {
-          last.type = "RestElement";
-          var arg = last.argument;
-          this.toAssignable(arg, isLHS);
-          arg = unwrapParenthesizedExpression(arg);
-
-          if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern" && arg.type !== "ObjectPattern") {
-            this.unexpected(arg.start);
-          }
-
-          if (trailingCommaLoc) {
-            this.raise(Errors.RestTrailingComma, {
-              at: trailingCommaLoc
-            });
-          }
-
-          --end;
-        }
-      }
-
-      for (var i = 0; i < end; i++) {
+      for (var i = 0; i <= end; i++) {
         var elt = exprList[i];
+        if (!elt) continue;
 
-        if (elt) {
+        if (elt.type === "SpreadElement") {
+          elt.type = "RestElement";
+          var arg = elt.argument;
+          this.checkToRestConversion(arg, true);
+          this.toAssignable(arg, isLHS);
+        } else {
           this.toAssignable(elt, isLHS);
+        }
 
-          if (elt.type === "RestElement") {
+        if (elt.type === "RestElement") {
+          if (i < end) {
             this.raise(Errors.RestTrailingComma, {
               at: elt
             });
+          } else if (trailingCommaLoc) {
+            this.raise(Errors.RestTrailingComma, {
+              at: trailingCommaLoc
+            });
           }
         }
       }
-
-      return exprList;
     }
 
     isAssignable(node, isBinding) {
@@ -15369,7 +15468,7 @@
       return this.finishNode(node, "AssignmentPattern");
     }
 
-    isValidLVal(type, isParenthesized, binding) {
+    isValidLVal(type, isUnparenthesizedInAssign, binding) {
       return getOwn({
         AssignmentPattern: "left",
         RestElement: "argument",
@@ -15380,7 +15479,7 @@
       }, type);
     }
 
-    checkLVal(expression, _ref86) {
+    checkLVal(expression, _ref88) {
       var {
         in: ancestor,
         binding = BIND_NONE,
@@ -15388,7 +15487,7 @@
         strictModeChanged = false,
         allowingSloppyLetBinding = !(binding & BIND_SCOPE_LEXICAL),
         hasParenthesizedAncestor = false
-      } = _ref86;
+      } = _ref88;
 
       var _expression$extra;
 
@@ -15424,7 +15523,7 @@
         return;
       }
 
-      var validity = this.isValidLVal(expression.type, hasParenthesizedAncestor || ((_expression$extra = expression.extra) == null ? void 0 : _expression$extra.parenthesized), binding);
+      var validity = this.isValidLVal(expression.type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
       if (validity === true) return;
 
       if (validity === false) {
@@ -15491,11 +15590,24 @@
       this.scope.declareName(identifier.name, binding, identifier.loc.start);
     }
 
-    checkToRestConversion(node) {
-      if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
-        this.raise(Errors.InvalidRestAssignmentPattern, {
-          at: node.argument
-        });
+    checkToRestConversion(node, allowPattern) {
+      switch (node.type) {
+        case "ParenthesizedExpression":
+          this.checkToRestConversion(node.expression, allowPattern);
+          break;
+
+        case "Identifier":
+        case "MemberExpression":
+          break;
+
+        case "ArrayExpression":
+        case "ObjectExpression":
+          if (allowPattern) break;
+
+        default:
+          this.raise(Errors.InvalidRestAssignmentPattern, {
+            at: node
+          });
       }
     }
 
@@ -15656,7 +15768,8 @@
         node.operator = operator;
 
         if (this.match(29)) {
-          node.left = this.toAssignable(left, true);
+          this.toAssignable(left, true);
+          node.left = left;
 
           if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startPos) {
             refExpressionErrors.doubleProtoLoc = null;
@@ -15956,14 +16069,14 @@
       if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
 
       while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {
-        var _node9 = this.startNodeAt(startPos, startLoc);
+        var _node10 = this.startNodeAt(startPos, startLoc);
 
-        _node9.operator = this.state.value;
-        _node9.prefix = false;
-        _node9.argument = expr;
+        _node10.operator = this.state.value;
+        _node10.prefix = false;
+        _node10.argument = expr;
         this.next();
         this.checkLVal(expr, {
-          in: expr = this.finishNode(_node9, "UpdateExpression")
+          in: expr = this.finishNode(_node10, "UpdateExpression")
         });
       }
 
@@ -16823,6 +16936,20 @@
     }
 
     parseNew(node) {
+      this.parseNewCallee(node);
+
+      if (this.eat(10)) {
+        var args = this.parseExprList(11);
+        this.toReferencedList(args);
+        node.arguments = args;
+      } else {
+        node.arguments = [];
+      }
+
+      return this.finishNode(node, "NewExpression");
+    }
+
+    parseNewCallee(node) {
       node.callee = this.parseNoCallExpr();
 
       if (node.callee.type === "Import") {
@@ -16838,19 +16965,6 @@
           at: this.state.startLoc
         });
       }
-
-      this.parseNewArguments(node);
-      return this.finishNode(node, "NewExpression");
-    }
-
-    parseNewArguments(node) {
-      if (this.eat(10)) {
-        var args = this.parseExprList(11);
-        this.toReferencedList(args);
-        node.arguments = args;
-      } else {
-        node.arguments = [];
-      }
     }
 
     parseTemplateElement(isTagged) {
@@ -17257,7 +17371,8 @@
     }
 
     setArrowFunctionParameters(node, params, trailingCommaLoc) {
-      node.params = this.toAssignableList(params, trailingCommaLoc, false);
+      this.toAssignableList(params, trailingCommaLoc, false);
+      node.params = params;
     }
 
     parseFunctionBodyAndFinish(node, type) {
@@ -18177,7 +18292,7 @@
     }
 
     parseDecorator() {
-      this.expectOnePlugin(["decorators-legacy", "decorators"]);
+      this.expectOnePlugin(["decorators", "decorators-legacy"]);
       var node = this.startNode();
       this.next();
 
@@ -18198,12 +18313,12 @@
           expr = this.parseIdentifier(false);
 
           while (this.eat(16)) {
-            var _node10 = this.startNodeAt(startPos, startLoc);
+            var _node11 = this.startNodeAt(startPos, startLoc);
 
-            _node10.object = expr;
-            _node10.property = this.parseIdentifier(true);
-            _node10.computed = false;
-            expr = this.finishNode(_node10, "MemberExpression");
+            _node11.object = expr;
+            _node11.property = this.parseIdentifier(true);
+            _node11.computed = false;
+            expr = this.finishNode(_node11, "MemberExpression");
           }
         }
 
@@ -19424,6 +19539,7 @@
 
         if (assertions) {
           node.assertions = assertions;
+          this.checkJSONModuleImport(node);
         }
       } else if (expect) {
         this.unexpected();
@@ -19609,6 +19725,50 @@
       return this.parseIdentifier(true);
     }
 
+    isJSONModuleImport(node) {
+      if (node.assertions != null) {
+        return node.assertions.some(_ref89 => {
+          var {
+            key,
+            value
+          } = _ref89;
+          return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type");
+        });
+      }
+
+      return false;
+    }
+
+    checkJSONModuleImport(node) {
+      if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") {
+        var {
+          specifiers
+        } = node;
+
+        if (node.specifiers != null) {
+          var nonDefaultNamedSpecifier = specifiers.find(specifier => {
+            var imported;
+
+            if (specifier.type === "ExportSpecifier") {
+              imported = specifier.local;
+            } else if (specifier.type === "ImportSpecifier") {
+              imported = specifier.imported;
+            }
+
+            if (imported !== undefined) {
+              return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default";
+            }
+          });
+
+          if (nonDefaultNamedSpecifier !== undefined) {
+            this.raise(Errors.ImportJSONBindingNotDefault, {
+              at: nonDefaultNamedSpecifier.loc.start
+            });
+          }
+        }
+      }
+    }
+
     parseImport(node) {
       node.specifiers = [];
 
@@ -19633,6 +19793,7 @@
         }
       }
 
+      this.checkJSONModuleImport(node);
       this.semicolon();
       return this.finishNode(node, "ImportDeclaration");
     }
@@ -20641,7 +20802,7 @@
                     loc: {
                       start: node.loc.start,
                       end: {
-                        line: node.loc.end.line,
+                        line: node.loc.start.line,
                         // Only decorate the "var".
                         column: node.loc.start.column + 3
                       }
@@ -22874,6 +23035,39 @@
     };
   }
 
+  var INSTALLED_APPS = "INSTALLED_APPS";
+  var has = "has";
+  function scanInstalledAppsInStoryboard(storyboard) {
+    var _storyboard$meta;
+
+    var collection = new Set();
+    var beforeVisitInstalledApps = beforeVisitInstalledAppsFactory(collection);
+    var {
+      customTemplates,
+      functions
+    } = (_storyboard$meta = storyboard.meta) !== null && _storyboard$meta !== void 0 ? _storyboard$meta : {};
+    visitStoryboardExpressions([storyboard.routes, customTemplates], beforeVisitInstalledApps, INSTALLED_APPS);
+    visitStoryboardFunctions(functions, beforeVisitInstalledApps);
+    return Array.from(collection);
+  }
+
+  function beforeVisitInstalledAppsFactory(collection) {
+    return function beforeVisitPermissions(node, parent) {
+      if (node.name === INSTALLED_APPS) {
+        var memberParent = parent[parent.length - 1];
+        var callParent = parent[parent.length - 2];
+
+        if ((callParent === null || callParent === void 0 ? void 0 : callParent.node.type) === "CallExpression" && (callParent === null || callParent === void 0 ? void 0 : callParent.key) === "callee" && (memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object" && !memberParent.node.computed && memberParent.node.property.type === "Identifier" && memberParent.node.property.name === has) {
+          var args = callParent.node.arguments;
+
+          if (args.length > 0 && args[0].type === "Literal" && typeof args[0].value === "string") {
+            collection.add(args[0].value);
+          }
+        }
+      }
+    };
+  }
+
   Object.defineProperty(exports, 'pipes', {
     enumerable: true,
     get: function () { return pipes.pipes; }
@@ -22924,6 +23118,7 @@
   exports.scanCustomApisInStoryboard = scanCustomApisInStoryboard;
   exports.scanI18NInAny = scanI18NInAny;
   exports.scanI18NInStoryboard = scanI18NInStoryboard;
+  exports.scanInstalledAppsInStoryboard = scanInstalledAppsInStoryboard;
   exports.scanPermissionActionsInAny = scanPermissionActionsInAny;
   exports.scanPermissionActionsInStoryboard = scanPermissionActionsInStoryboard;
   exports.scanProcessorsInAny = scanProcessorsInAny;