Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use peek method in Playwright Internal

Best JavaScript code snippet using playwright-internal

Parser.js

Source:Parser.js

1// Copyright 2012 Google Inc.2//3// Licensed under the Apache License, Version 2.0 (the "License");4// you may not use this file except in compliance with the License.5// You may obtain a copy of the License at6//7//      http://www.apache.org/licenses/LICENSE-2.08//9// Unless required by applicable law or agreed to in writing, software10// distributed under the License is distributed on an "AS IS" BASIS,11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.12// See the License for the specific language governing permissions and13// limitations under the License.14traceur.define('syntax', function() {15  'use strict';16  var MutedErrorReporter = traceur.util.MutedErrorReporter;17  var Keywords = traceur.syntax.Keywords;18  var PredefinedName = traceur.syntax.PredefinedName;19  var SourceRange = traceur.util.SourceRange;20  var Token = traceur.syntax.Token;21  var TokenType = traceur.syntax.TokenType;22  var ArgumentList = traceur.syntax.trees.ArgumentList;23  var ArrayComprehension = traceur.syntax.trees.ArrayComprehension;24  var ArrayLiteralExpression = traceur.syntax.trees.ArrayLiteralExpression;25  var ArrayPattern = traceur.syntax.trees.ArrayPattern;26  var ArrowFunctionExpression = traceur.syntax.trees.ArrowFunctionExpression;27  var AwaitStatement = traceur.syntax.trees.AwaitStatement;28  var BinaryOperator = traceur.syntax.trees.BinaryOperator;29  var BindThisParameter = traceur.syntax.trees.BindThisParameter;30  var BindingElement = traceur.syntax.trees.BindingElement;31  var BindingIdentifier = traceur.syntax.trees.BindingIdentifier;32  var Block = traceur.syntax.trees.Block;33  var BreakStatement = traceur.syntax.trees.BreakStatement;34  var CallExpression = traceur.syntax.trees.CallExpression;35  var CaseClause = traceur.syntax.trees.CaseClause;36  var Catch = traceur.syntax.trees.Catch;37  var CascadeExpression = traceur.syntax.trees.CascadeExpression;38  var ClassDeclaration = traceur.syntax.trees.ClassDeclaration;39  var ClassExpression = traceur.syntax.trees.ClassExpression;40  var CommaExpression = traceur.syntax.trees.CommaExpression;41  var ComprehensionFor = traceur.syntax.trees.ComprehensionFor;42  var ConditionalExpression = traceur.syntax.trees.ConditionalExpression;43  var ContinueStatement = traceur.syntax.trees.ContinueStatement;44  var DebuggerStatement = traceur.syntax.trees.DebuggerStatement;45  var DefaultClause = traceur.syntax.trees.DefaultClause;46  var DoWhileStatement = traceur.syntax.trees.DoWhileStatement;47  var EmptyStatement = traceur.syntax.trees.EmptyStatement;48  var ExportDeclaration = traceur.syntax.trees.ExportDeclaration;49  var ExportMapping = traceur.syntax.trees.ExportMapping;50  var ExportMappingList = traceur.syntax.trees.ExportMappingList;51  var ExportSpecifier = traceur.syntax.trees.ExportSpecifier;52  var ExportSpecifierSet = traceur.syntax.trees.ExportSpecifierSet;53  var ExpressionStatement = traceur.syntax.trees.ExpressionStatement;54  var Finally = traceur.syntax.trees.Finally;55  var ForOfStatement = traceur.syntax.trees.ForOfStatement;56  var ForInStatement = traceur.syntax.trees.ForInStatement;57  var ForStatement = traceur.syntax.trees.ForStatement;58  var FormalParameterList = traceur.syntax.trees.FormalParameterList;59  var FunctionDeclaration = traceur.syntax.trees.FunctionDeclaration;60  var GeneratorComprehension = traceur.syntax.trees.GeneratorComprehension;61  var GetAccessor = traceur.syntax.trees.GetAccessor;62  var IdentifierExpression = traceur.syntax.trees.IdentifierExpression;63  var IdentifierToken = traceur.syntax.IdentifierToken;64  var IfStatement = traceur.syntax.trees.IfStatement;65  var ImportDeclaration = traceur.syntax.trees.ImportDeclaration;66  var ImportBinding = traceur.syntax.trees.ImportBinding;67  var ImportSpecifier = traceur.syntax.trees.ImportSpecifier;68  var ImportSpecifierSet = traceur.syntax.trees.ImportSpecifierSet;69  var LabelledStatement = traceur.syntax.trees.LabelledStatement;70  var LiteralExpression = traceur.syntax.trees.LiteralExpression;71  var MemberExpression = traceur.syntax.trees.MemberExpression;72  var MemberLookupExpression = traceur.syntax.trees.MemberLookupExpression;73  var MissingPrimaryExpression = traceur.syntax.trees.MissingPrimaryExpression;74  var ModuleDeclaration = traceur.syntax.trees.ModuleDeclaration;75  var ModuleDefinition = traceur.syntax.trees.ModuleDefinition;76  var ModuleExpression = traceur.syntax.trees.ModuleExpression;77  var ModuleRequire = traceur.syntax.trees.ModuleRequire;78  var ModuleSpecifier = traceur.syntax.trees.ModuleSpecifier;79  var NewExpression = traceur.syntax.trees.NewExpression;80  var NullTree = traceur.syntax.trees.NullTree;81  var ObjectLiteralExpression = traceur.syntax.trees.ObjectLiteralExpression;82  var ObjectPattern = traceur.syntax.trees.ObjectPattern;83  var ObjectPatternField = traceur.syntax.trees.ObjectPatternField;84  var ParenExpression = traceur.syntax.trees.ParenExpression;85  var ParseTreeType = traceur.syntax.trees.ParseTreeType;86  var PostfixExpression = traceur.syntax.trees.PostfixExpression;87  var Program = traceur.syntax.trees.Program;88  var PropertyMethodAssignment = traceur.syntax.trees.PropertyMethodAssignment;89  var PropertyNameAssignment = traceur.syntax.trees.PropertyNameAssignment;90  var PropertyNameShorthand = traceur.syntax.trees.PropertyNameShorthand;91  var QuasiLiteralExpression = traceur.syntax.trees.QuasiLiteralExpression;92  var QuasiLiteralPortion = traceur.syntax.trees.QuasiLiteralPortion;93  var QuasiSubstitution = traceur.syntax.trees.QuasiSubstitution;94  var RestParameter = traceur.syntax.trees.RestParameter;95  var ReturnStatement = traceur.syntax.trees.ReturnStatement;96  var SetAccessor = traceur.syntax.trees.SetAccessor;97  var SpreadExpression = traceur.syntax.trees.SpreadExpression;98  var SpreadPatternElement = traceur.syntax.trees.SpreadPatternElement;99  var SuperExpression = traceur.syntax.trees.SuperExpression;100  var SwitchStatement = traceur.syntax.trees.SwitchStatement;101  var ThisExpression = traceur.syntax.trees.ThisExpression;102  var ThrowStatement = traceur.syntax.trees.ThrowStatement;103  var TryStatement = traceur.syntax.trees.TryStatement;104  var UnaryExpression = traceur.syntax.trees.UnaryExpression;105  var VariableDeclaration = traceur.syntax.trees.VariableDeclaration;106  var VariableDeclarationList = traceur.syntax.trees.VariableDeclarationList;107  var VariableStatement = traceur.syntax.trees.VariableStatement;108  var WhileStatement = traceur.syntax.trees.WhileStatement;109  var WithStatement = traceur.syntax.trees.WithStatement;110  var YieldStatement = traceur.syntax.trees.YieldStatement;111  var createBindingIdentifier = traceur.codegeneration.ParseTreeFactory.createBindingIdentifier;112  var options = traceur.options.parse;113  /**114   * Parses a javascript file.115   *116   * The various this.parseX_() methods never return null - even when parse errors are encountered.117   * Typically this.parseX_() will return a XTree ParseTree. Each ParseTree that is created includes its118   * source location. The typical pattern for a this.parseX_() method is:119   *120   * XTree this.parseX_() {121   *   var start = this.getTreeStartLocation_();122   *   parse X grammar element and its children123   *   return new XTree(this.getTreeLocation_(start), children);124   * }125   *126   * this.parseX_() methods must consume at least 1 token - even in error cases. This prevents infinite127   * loops in the parser.128   *129   * Many this.parseX_() methods are matched by a 'boolean this.peekX_()' method which will return true if130   * the beginning of an X appears at the current location. There are also this.peek_() methods which131   * examine the next token. this.peek_() methods must not consume any tokens.132   *133   * The this.eat_() method consumes a token and reports an error if the consumed token is not of the134   * expected type. The this.eatOpt_() methods consume the next token iff the next token is of the expected135   * type and return the consumed token or null if no token was consumed.136   *137   * When parse errors are encountered, an error should be reported and the parse should return a best138   * guess at the current parse tree.139   *140   * When parsing lists, the preferred pattern is:141   *   this.eat_(LIST_START);142   *   var elements = [];143   *   while (this.peekListElement_()) {144   *     elements.push(this.parseListElement_());145   *   }146   *   this.eat_(LIST_END);147   */148  function Parser(errorReporter, var_args) {149    this.errorReporter_ = errorReporter;150    var scanner;151    if (arguments[1] instanceof traceur.syntax.Scanner) {152      scanner = arguments[1];153    } else {154      scanner = new traceur.syntax.Scanner(errorReporter, arguments[1],155                                           arguments[2]);156    }157    this.scanner_ = scanner;158  }159  /**160   * Differentiates between parsing for 'In' vs. 'NoIn'161   * Variants of expression grammars.162   */163  var Expression = {164    NO_IN: 'NO_IN',165    NORMAL: 'NORMAL'166  };167  /**168   * Enum for determining if the initializer is needed in a variable declaration169   * with a destructuring pattern.170   * @enum {string}171   */172  var DestructuringInitializer = {173    REQUIRED: 'REQUIRED',174    OPTIONAL: 'OPTIONAL'175  };176  function followedByCommaOrCloseSquare(token) {177    return token.type === TokenType.COMMA ||178        token.type === TokenType.CLOSE_SQUARE;179  }180  function followedByCommaOrCloseCurly(token) {181    return token.type === TokenType.COMMA ||182        token.type === TokenType.CLOSE_CURLY;183  }184  function followedByInOrOf(token) {185    return token.type === TokenType.IN ||186        token.type === TokenType.IDENTIFIER &&187        token.value === PredefinedName.OF;188  }189  /**190   * Enum used to determine if an initializer is allowed or not.191   * @enum {string}192   */193  var Initializer = {194    ALLOWED: 'ALLOWED',195    REQUIRED: 'REQUIRED'196  };197  Parser.prototype = {198    /**199     * Keeps track of whether we currently allow yield expressions.200     * @type {boolean}201     * @private202     */203    allowYield_: false,204    // 14 Program205    /**206     * @return {Program}207     */208    parseProgram: function(opt_load) {209      //var t = new Timer("Parse Program");210      var start = this.getTreeStartLocation_();211      var programElements = this.parseProgramElements_(!!opt_load);212      this.eat_(TokenType.END_OF_FILE);213      //t.end();214      return new Program(this.getTreeLocation_(start), programElements);215    },216    /**217     * @return {Array.<ParseTree>}218     * @private219     */220    parseProgramElements_: function(load) {221      var result = [];222      while (!this.peek_(TokenType.END_OF_FILE)) {223        var programElement = this.parseProgramElement_(load);224        if (!programElement) {225          return null;226        }227        result.push(programElement);228      }229      return result;230    },231    /**232     * @return {boolean}233     * @private234     */235    peekProgramElement_: function() {236      return this.peekFunction_() ||237             this.peekVariableDeclarationList_() ||238             this.peekImportDeclaration_() ||239             this.peekExportDeclaration_() ||240             this.peekModuleDeclaration_() ||241             this.peekClassDeclaration_() ||242             this.peekStatement_();243    },244    /**245     * @return {ParseTree}246     * @private247     */248    parseProgramElement_: function(load) {249      if (this.peekVariableDeclarationList_()) {250        return this.parseVariableStatement_();251      }252      // Function is handled in parseStatement_253      // Class is handled in parseStatement_254      if (this.peekImportDeclaration_(load)) {255        return this.parseImportDeclaration_(load);256      }257      if (this.peekExportDeclaration_(load)) {258        return this.parseExportDeclaration_(load);259      }260      if (this.peekModuleDeclaration_(load)) {261        return this.parseModuleDeclaration_(load);262      }263      return this.parseStatement_();264    },265    // ClassDeclaration266    // ModuleDeclaration267    // TODO: ImportDeclaration268    // TODO: ScriptBlock269    // Statement (other than BlockStatement)270    // FunctionDeclaration271    /*272    peekScriptElement_: function() {273      return this.peekModuleDeclaration_() ||274              this.peekSourceElement_();275    }276  */277    // module  identifier { ModuleElement* }278    /**279    * @return {boolean}280    * @private281    */282    peekModuleDefinition_: function() {283      return this.peekPredefinedString_(PredefinedName.MODULE) &&284          this.peek_(TokenType.IDENTIFIER, 1) &&285          this.peek_(TokenType.OPEN_CURLY, 2);286    },287    /**288     * @return {ParseTree}289     * @private290     */291    parseModuleDefinition_: function(load) {292      // ModuleDeclaration ::= "module" ModuleSpecifier(load) ("," ModuleSpecifier(load))* ";"293      //              | ModuleDefinition(load)294      // ModuleDefinition(load) ::= "module" Identifier "{" ModuleBody(load) "}"295      // ModuleSpecifier(load) ::= Identifier "from" ModuleExpression(load)296      var start = this.getTreeStartLocation_();297      this.eatId_(); // module298      var name = this.eatId_();299      this.eat_(TokenType.OPEN_CURLY);300      var result = [];301      while (this.peekModuleElement_()) {302        result.push(this.parseModuleElement_(load));303      }304      this.eat_(TokenType.CLOSE_CURLY);305      return new ModuleDefinition(this.getTreeLocation_(start), name, result);306    },307    // ModuleSpecifier(load) ::= Identifier "from" ModuleExpression(load)308    parseModuleSpecifier_: function(load) {309      var start = this.getTreeStartLocation_();310      var identifier = this.eatId_();311      this.eatId_(PredefinedName.FROM);312      var expression = this.parseModuleExpression_(load);313      return new ModuleSpecifier(this.getTreeLocation_(start), identifier,314                                 expression);315    },316    parseModuleExpression_: function(load) {317      // ModuleExpression(load) ::= ModuleReference(load)318      //                         | ModuleExpression(load) "." IdentifierName319      var start = this.getTreeStartLocation_();320      var reference = this.parseModuleReference_(load);321      var identifierNames = [];322      while (this.peek_(TokenType.PERIOD) && this.peekIdName_(1)) {323        this.eat_(TokenType.PERIOD);324        identifierNames.push(this.eatIdName_());325      }326      return new ModuleExpression(this.getTreeLocation_(start), reference,327          identifierNames);328    },329    /**330     * @private331     * @return {ModeuleRequireTree|IdentifierExpression}332     */333    parseModuleReference_: function(load) {334      // ModuleReference(load) ::= Identifier335      //                        | [load = true] StringLiteral336      var start = this.getTreeStartLocation_();337      if (load && this.peek_(TokenType.STRING)) {338        var url = this.eat_(TokenType.STRING);339        return new ModuleRequire(this.getTreeLocation_(start), url);340      }341      return this.parseIdentifierExpression_();342    },343    // ClassDeclaration344    // ImportDeclaration345    // ExportDeclaration346    // ModuleDeclaration347    // TODO: ModuleBlock348    // Statement (other than BlockStatement)349    // FunctionDeclaration350    /**351     * @return {boolean}352     * @private353     */354    peekModuleElement_: function() {355      // ModuleElement is currently same as ProgramElement.356      return this.peekProgramElement_();357    },358    /**359     * @return {ParseTree}360     * @private361     */362    parseModuleElement_: function(load) {363      // ModuleElement is currently same as ProgramElement.364      return this.parseProgramElement_(load);365    },366    //  ImportDeclaration ::= 'import' ImportBinding (',' ImportBinding)* ';'367    /**368     * @return {boolean}369     * @private370     */371    peekImportDeclaration_: function() {372      return options.modules && this.peek_(TokenType.IMPORT);373    },374    // ImportDeclaration(load) ::= "import" ImportBinding(load)375    //                                     ("," ImportBinding(load))* ";"376    /**377     * @return {ParseTree}378     * @private379     */380    parseImportDeclaration_: function(load) {381      var start = this.getTreeStartLocation_();382      this.eat_(TokenType.IMPORT);383      var importBindings = [];384      importBindings.push(this.parseImportBinding_(load));385      while (this.peek_(TokenType.COMMA)) {386        this.eat_(TokenType.COMMA);387        importBindings.push(this.parseImportBinding_(load));388      }389      this.eatPossibleImplicitSemiColon_();390      return new ImportDeclaration(this.getTreeLocation_(start),391          importBindings);392    },393    // ImportBinding(load) ::= ImportSpecifierSet "from" ModuleExpression(load)394    /**395     * @return {ParseTree}396     * @private397     */398    parseImportBinding_: function(load) {399      var start = this.getTreeStartLocation_();400      var importSpecifierSet = this.parseImportSpecifierSet_();401      this.eatId_(PredefinedName.FROM);402      var moduleExpression = this.parseModuleExpression_(load);403      return new ImportBinding(this.getTreeLocation_(start),404          moduleExpression, importSpecifierSet);405    },406    //ImportSpecifierSet ::= "*"407    //                  | IdentifierName408    //                  | "{" (ImportSpecifier ("," ImportSpecifier)*)? ","? "}"409    /**410     * @param {SourcePosition} start411     * @param {Array.<IdentifierToken>} qualifiedPath412     * @return {ParseTree|Token|Array.<Token>}413     * @private414     */415    parseImportSpecifierSet_: function() {416      if (this.peek_(TokenType.OPEN_CURLY)) {417        var start = this.getTreeStartLocation_();418        this.eat_(TokenType.OPEN_CURLY);419        var specifiers = [this.parseImportSpecifier_()];420        while (this.peek_(TokenType.COMMA)) {421          this.eat_(TokenType.COMMA);422          if (this.peek_(TokenType.CLOSE_CURLY))423            break;424          specifiers.push(this.parseImportSpecifier_());425        }426        this.eat_(TokenType.CLOSE_CURLY);427        return new ImportSpecifierSet(this.getTreeLocation_(start), specifiers);428      }429      if (this.peek_(TokenType.STAR)) {430        var star = this.eat_(TokenType.STAR);431        return new ImportSpecifierSet(this.getTreeLocation_(start), star);432      }433      return this.parseIdentifierNameExpression_();434    },435    // ImportSpecifier ::= IdentifierName (":" Identifier)?436    /**437     * @return {ParseTree}438     * @private439     */440    parseImportSpecifier_: function() {441      var start = this.getTreeStartLocation_();442      var lhs = this.eatIdName_();443      var rhs = null;444      if (this.peek_(TokenType.COLON)) {445        this.eat_(TokenType.COLON);446        rhs = this.eatId_();447      }448      return new ImportSpecifier(this.getTreeLocation_(start),449          lhs, rhs);450    },451    // export  VariableStatement452    // export  FunctionDeclaration453    // export  ConstStatement454    // export  ClassDeclaration455    // export  module ModuleDefinition456    /**457     * @return {boolean}458     * @private459     */460    peekExportDeclaration_: function(load) {461      return options.modules && this.peek_(TokenType.EXPORT);462    },463    /**464     * @return {ParseTree}465     * @private466     */467    parseExportDeclaration_: function(load) {468      var start = this.getTreeStartLocation_();469      this.eat_(TokenType.EXPORT);470      var exportTree;471      switch (this.peekType_()) {472        case TokenType.CONST:473        case TokenType.LET:474        case TokenType.VAR:475          exportTree = this.parseVariableStatement_();476          break;477        case TokenType.FUNCTION:478          exportTree = this.parseFunctionDeclaration_();479          break;480        case TokenType.CLASS:481          exportTree = this.parseClassDeclaration_();482          break;483        case TokenType.IDENTIFIER:484          if (this.peekModuleDeclaration_(load)) {485            exportTree = this.parseModuleDeclaration_(load);486          } else {487            exportTree = this.parseExportMappingList_();488          }489          break;490        case TokenType.OPEN_CURLY:491          exportTree = this.parseExportMappingList_();492          break;493        default:494          this.reportError_('Unexpected symbol \'' + this.peekToken_() + '\'');495          return null;496      }497      return new ExportDeclaration(this.getTreeLocation_(start), exportTree);498    },499    parseExportMappingList_: function() {500      // This is part of the ExportDeclaration production501      // ExportMapping ("," ExportMapping)*502      var start = this.getTreeStartLocation_();503      var mappings = [this.parseExportMapping_()];504      while (this.peek_(TokenType.COMMA)) {505        this.eat_(TokenType.COMMA);506        mappings.push(this.parseExportMapping_());507      }508      this.eatPossibleImplicitSemiColon_();509      return new ExportMappingList(this.getTreeEndLocation_(start), mappings);510    },511    peekExportMapping_: function() {512      return this.peek_(TokenType.OPEN_CURLY) || this.peekId_();513    },514    parseExportMapping_: function() {515      // ExportMapping ::= ExportSpecifierSet ("from" ModuleExpression(false))?516      var start = this.getTreeStartLocation_();517      var specifierSet = this.parseExportSpecifierSet_();518      var expression = null;519      if (this.peekPredefinedString_(PredefinedName.FROM)) {520        this.eatId_(PredefinedName.FROM);521        expression = this.parseModuleExpression_(false);522      }523      return new ExportMapping(this.getTreeLocation_(start), expression,524                               specifierSet);525    },526    peekExportSpecifierSet_: function() {527      return this.peek_(TokenType.OPEN_CURLY) ||528          this.peekIdName_();529    },530    parseExportSpecifierSet_: function() {531      // ExportSpecifierSet ::= Identifier532      //     | "{" ExportSpecifier ("," ExportSpecifier)* ","? "}"533      if (!this.peek_(TokenType.OPEN_CURLY))534        return this.parseIdentifierExpression_();535      var start = this.getTreeStartLocation_();536      this.eat_(TokenType.OPEN_CURLY);537      var specifiers = [this.parseExportSpecifier_()];538      while (this.peek_(TokenType.COMMA)) {539        this.eat_(TokenType.COMMA);540        if (this.peek_(TokenType.CLOSE_CURLY))541          break;542        specifiers.push(this.parseExportSpecifier_());543      }544      this.eat_(TokenType.CLOSE_CURLY);545      return new ExportSpecifierSet(this.getTreeLocation_(start),546          specifiers);547    },548    parseExportSpecifier_: function() {549      // ExportSpecifier ::= Identifier550      //     | IdentifierName ":" Identifier551      var start = this.getTreeStartLocation_();552      var lhs, rhs = null;553      if (this.peek_(TokenType.COLON, 1)) {554        lhs = this.eatIdName_();555        this.eat_(TokenType.COLON);556        rhs = this.eatId_();557      } else {558        lhs = this.eatId_();559      }560      return new ExportSpecifier(this.getTreeLocation_(start), lhs, rhs);561    },562    peekId_: function(opt_index) {563      return this.peek_(TokenType.IDENTIFIER, opt_index);564    },565    peekIdName_: function(opt_index) {566      var type = this.peekType_(opt_index);567      return type == TokenType.IDENTIFIER || Keywords.isKeyword(type);568    },569    // TODO: ModuleLoadRedeclarationList570    // ModuleDefinition571    /**572     * @return {boolean}573     * @private574     */575    peekModuleDeclaration_: function() {576      // ModuleDeclaration ::= "module" ModuleSpecifier(load) ("," ModuleSpecifier(load))* ";"577      //                    | ModuleDefinition(load)578      // ModuleDefinition(load) ::= "module" Identifier "{" ModuleBody(load) "}"579      // ModuleSpecifier(load) ::= Identifier "from" ModuleExpression(load)580      return options.modules &&581          this.peekPredefinedString_(PredefinedName.MODULE) &&582          this.peek_(TokenType.IDENTIFIER, 1) &&583          (this.peekPredefinedString_(PredefinedName.FROM, 2) ||584           this.peek_(TokenType.OPEN_CURLY, 2));585    },586    /**587     * @return {ParseTree}588     * @private589     */590    parseModuleDeclaration_: function(load) {591      if (this.peekModuleDefinition_(load))592        return this.parseModuleDefinition_(load);593      var start = this.getTreeStartLocation_();594      this.eatId_(); // module595      var specifiers = [this.parseModuleSpecifier_(load)];596      while (this.peek_(TokenType.COMMA)) {597        this.eat_(TokenType.COMMA);598        specifiers.push(this.parseModuleSpecifier_(load));599      }600      this.eatPossibleImplicitSemiColon_();601      return new ModuleDeclaration(this.getTreeLocation_(start),602          specifiers);603    },604    /**605     * @return {boolean}606     * @private607     */608    peekClassDeclaration_: function() {609      return options.classes && this.peek_(TokenType.CLASS) && this.peekId_(1);610    },611    parseClassShared_: function(constr) {612      var start = this.getTreeStartLocation_();613      this.eat_(TokenType.CLASS);614      var name = null;615      // Name is optional for ClassExpression616      if (constr == ClassDeclaration ||617          !this.peek_(TokenType.EXTENDS) && !this.peek_(TokenType.OPEN_CURLY)) {618        name = this.parseBindingIdentifier_();619      }620      var superClass = null;621      if (this.peek_(TokenType.EXTENDS)) {622        this.eat_(TokenType.EXTENDS);623        superClass = this.parseAssignmentExpression_();624      }625      this.eat_(TokenType.OPEN_CURLY);626      var elements = this.parseClassElements_();627      this.eat_(TokenType.CLOSE_CURLY);628      return new constr(this.getTreeLocation_(start), name, superClass,629                        elements);630    },631    /**632     * @return {ParseTree}633     * @private634     */635    parseClassDeclaration_: function() {636      return this.parseClassShared_(ClassDeclaration);637    },638    /**639     * @return {ParseTree}640     * @private641     */642    parseClassExpression_: function() {643      return this.parseClassShared_(ClassExpression);644    },645    /**646     * @return {Array.<ParseTree>}647     * @private648     */649    parseClassElements_: function() {650      var result = [];651      while (this.peekClassElement_()) {652        result.push(this.parseClassElement_());653      }654      return result;655    },656    /**657     * @return {boolean}658     * @private659     */660    peekClassElement_: function() {661      return options.classes && (this.peekPropertyMethodAssignment_() ||662          this.peekGetAccessor_() || this.peekSetAccessor_());663    },664    /**665     * @return {ParseTree}666     * @private667     */668    parseClassElement_: function() {669      if (this.peekGetAccessor_())670        return this.parseGetAccessor_();671      if (this.peekSetAccessor_())672        return this.parseSetAccessor_();673      return this.parsePropertyMethodAssignment_();674    },675    /**676     * @return {ParseTree}677     * @private678     */679    parseSourceElement_: function() {680      if (this.peekFunction_()) {681        return this.parseFunctionDeclaration_();682      }683      if (this.peekClassDeclaration_()) {684        return this.parseClassDeclaration_();685      }686      // Harmony let block scoped bindings. let can only appear in687      // a block, not as a standalone statement: if() let x ... illegal688      if (this.peekLet_()) {689        return this.parseVariableStatement_();690      }691      // const and var are handled inside parseStatement692      return this.parseStatementStandard_();693    },694    peekLet_: function() {695      return options.blockBinding && this.peek_(TokenType.LET);696    },697    peekConst_: function() {698      return options.blockBinding && this.peek_(TokenType.CONST);699    },700    /**701     * @return {boolean}702     * @private703     */704    peekSourceElement_: function() {705      return this.peekFunction_() || this.peekClassDeclaration_() ||706          this.peekStatementStandard_() || this.peekLet_();707    },708    /**709     * @return {boolean}710     * @private711     */712    peekFunction_: function(opt_index) {713      var index = opt_index || 0;714      // TODO: Remove # functions715      return this.peek_(TokenType.FUNCTION, index) || this.peek_(TokenType.POUND, index);716    },717    // 13 Function Definition718    /**719     * @return {ParseTree}720     * @private721     */722    parseFunctionDeclaration_: function() {723      var start = this.getTreeStartLocation_();724      this.nextToken_(); // function or #725      var isGenerator = this.eatOpt_(TokenType.STAR) != null;726      return this.parseFunctionDeclarationTail_(start, isGenerator,727                                                this.parseBindingIdentifier_());728    },729    /**730     * @param {SourcePosition} start731     * @param {IdentifierToken} name732     * @return {ParseTree}733     * @private734     */735    parseFunctionDeclarationTail_: function(start, isGenerator, name) {736      this.eat_(TokenType.OPEN_PAREN);737      var formalParameterList = this.parseFormalParameterList_();738      this.eat_(TokenType.CLOSE_PAREN);739      var functionBody = this.parseFunctionBody_(isGenerator);740      return new FunctionDeclaration(this.getTreeLocation_(start), name,741                                     isGenerator, formalParameterList,742                                     functionBody);743    },744    /**745     * @return {ParseTree}746     * @private747     */748    parseFunctionExpression_: function() {749      var start = this.getTreeStartLocation_();750      this.nextToken_(); // function or #751      var isGenerator = this.eatOpt_(TokenType.STAR) != null;752      var name = null;753      if (this.peekBindingIdentifier_()) {754        name = this.parseBindingIdentifier_();755      }756      this.eat_(TokenType.OPEN_PAREN);757      var formalParameterList = this.parseFormalParameterList_();758      this.eat_(TokenType.CLOSE_PAREN);759      var functionBody = this.parseFunctionBody_(isGenerator);760      return new FunctionDeclaration(this.getTreeLocation_(start), name,761                                     isGenerator, formalParameterList,762                                     functionBody);763    },764    /**765     * @return {FormalParameterList}766     * @private767     */768    parseFormalParameterList_: function() {769      // FormalParameterList :770      //   ... Identifier771      //   FormalsList772      //   FormalsList , ... Identifier773      //774      // FormalsList :775      //   FormalParameter776      //   FormalsList , FormalParameter777      //778      //   FormalParameter :779      //     BindingIdentifier Initialiser?780      //     BindingPattern Initialiser?781      var start = this.getTreeStartLocation_();782      var formals;783      if (this.peekRest_()) {784        formals = [this.parseRestParameter_()];785      } else {786        formals = this.parseFormalsList_();787        if (this.peek_(TokenType.COMMA)) {788          this.eat_(TokenType.COMMA);789          formals.push(this.parseRestParameter_());790        }791      }792      return new FormalParameterList(this.getTreeLocation_(start), formals);793    },794    parseFormalsList_: function() {795      var formals = [];796      var initializerAllowed = Initializer.ALLOWED;797      while (this.peekFormalParameter_()) {798        var parameter = this.parseFormalParameter_(initializerAllowed);799        if (parameter.initializer)800            initializerAllowed = Initializer.REQUIRED;801        formals.push(parameter);802        // Lookahead to distinguish , ... and , ) which must not be consumed.803        if (this.peek_(TokenType.COMMA) && this.peekFormalParameter_(1))804          this.eat_(TokenType.COMMA);805      }806      return formals;807    },808    peekFormalParameter_: function(opt_index) {809      var index = opt_index || 0;810      return this.peekBindingIdentifier_(index) || this.peekPattern_(index);811    },812    parseFormalParameter_: function(opt_initializerAllowed) {813      return this.parseBindingElement_(opt_initializerAllowed);814    },815    parseRestParameter_: function() {816      var start = this.getTreeStartLocation_();817      this.eat_(TokenType.DOT_DOT_DOT);818      return new RestParameter(this.getTreeLocation_(start),819                               this.parseBindingIdentifier_());820    },821    /**822     * @return {Block}823     * @private824     */825    parseFunctionBody_: function(isGenerator) {826      var start = this.getTreeStartLocation_();827      this.eat_(TokenType.OPEN_CURLY);828      var allowYield = this.allowYield_;829      this.allowYield_ = isGenerator;830      var result = this.parseSourceElementList_();831      this.allowYield_ = allowYield;832      this.eat_(TokenType.CLOSE_CURLY);833      return new Block(this.getTreeLocation_(start), result);834    },835    /**836     * @return {Array.<ParseTree>}837     * @private838     */839    parseSourceElementList_: function() {840      var result = [];841      while (this.peekSourceElement_()) {842        var sourceElement = this.parseSourceElement_();843        if (!sourceElement) {844          return null;845        }846        result.push(sourceElement);847      }848      return result;849    },850    /**851     * @return {SpreadExpression}852     * @private853     */854    parseSpreadExpression_: function() {855      if (!options.spread) {856        return this.parseMissingPrimaryExpression_();857      }858      var start = this.getTreeStartLocation_();859      this.eat_(TokenType.DOT_DOT_DOT);860      var operand = this.parseAssignmentExpression_();861      return new SpreadExpression(this.getTreeLocation_(start), operand);862    },863    // 12 Statements864    /**865     * In V8, all source elements may appear where statements occur in the grammar.866     *867     * @return {ParseTree}868     * @private869     */870    parseStatement_: function() {871      return this.parseSourceElement_();872    },873    /**874     * This function reflects the ECMA standard. Most places use parseStatement instead.875     *876     * @return {ParseTree}877     * @private878     */879    parseStatementStandard_: function() {880      switch (this.peekType_()) {881        case TokenType.OPEN_CURLY:882          return this.parseBlock_();883        case TokenType.AWAIT:884          return this.parseAwaitStatement_();885        case TokenType.CONST:886          if (!options.blockBinding) {887            this.reportUnexpectedToken_();888            return null;889          }890          // Fall through.891        case TokenType.VAR:892          return this.parseVariableStatement_();893        case TokenType.SEMI_COLON:894          return this.parseEmptyStatement_();895        case TokenType.IF:896          return this.parseIfStatement_();897        case TokenType.DO:898          return this.parseDoWhileStatement_();899        case TokenType.WHILE:900          return this.parseWhileStatement_();901        case TokenType.FOR:902          return this.parseForStatement_();903        case TokenType.CONTINUE:904          return this.parseContinueStatement_();905        case TokenType.BREAK:906          return this.parseBreakStatement_();907        case TokenType.RETURN:908          return this.parseReturnStatement_();909        case TokenType.YIELD:910          return this.parseYieldStatement_();911        case TokenType.WITH:912          return this.parseWithStatement_();913        case TokenType.SWITCH:914          return this.parseSwitchStatement_();915        case TokenType.THROW:916          return this.parseThrowStatement_();917        case TokenType.TRY:918          return this.parseTryStatement_();919        case TokenType.DEBUGGER:920          return this.parseDebuggerStatement_();921        default:922          if (this.peekLabelledStatement_()) {923            return this.parseLabelledStatement_();924          }925          return this.parseExpressionStatement_();926      }927    },928    /**929     * In V8 all source elements may appear where statements appear in the grammar.930     *931     * @return {boolean}932     * @private933     */934    peekStatement_: function() {935      return this.peekSourceElement_();936    },937    /**938     * This function reflects the ECMA standard. Most places use peekStatement instead.939     *940     * @return {boolean}941     * @private942     */943    peekStatementStandard_: function() {944      switch (this.peekType_()) {945        case TokenType.CONST:946          return options.blockBinding;947        case TokenType.YIELD:948          return options.generators;949        case TokenType.AWAIT:950          return options.deferredFunctions;951        case TokenType.OPEN_CURLY:952        case TokenType.VAR:953        case TokenType.SEMI_COLON:954        case TokenType.IF:955        case TokenType.DO:956        case TokenType.WHILE:957        case TokenType.FOR:958        case TokenType.CONTINUE:959        case TokenType.BREAK:960        case TokenType.RETURN:961        case TokenType.WITH:962        case TokenType.SWITCH:963        case TokenType.THROW:964        case TokenType.TRY:965        case TokenType.DEBUGGER:966        case TokenType.IDENTIFIER:967        case TokenType.THIS:968        case TokenType.CLASS:969        case TokenType.SUPER:970        case TokenType.NUMBER:971        case TokenType.STRING:972        case TokenType.NULL:973        case TokenType.TRUE:974        case TokenType.SLASH: // regular expression literal975        case TokenType.SLASH_EQUAL: // regular expression literal976        case TokenType.FALSE:977        case TokenType.OPEN_SQUARE:978        case TokenType.OPEN_PAREN:979        case TokenType.NEW:980        case TokenType.DELETE:981        case TokenType.VOID:982        case TokenType.TYPEOF:983        case TokenType.PLUS_PLUS:984        case TokenType.MINUS_MINUS:985        case TokenType.PLUS:986        case TokenType.MINUS:987        case TokenType.TILDE:988        case TokenType.BANG:989        case TokenType.BACK_QUOTE:990          return true;991        default:992          return false;993      }994    },995    // 12.1 Block996    /**997     * @return {Block}998     * @private999     */1000    parseBlock_: function() {1001      var start = this.getTreeStartLocation_();1002      this.eat_(TokenType.OPEN_CURLY);1003      // Spec says Statement list. However functions are also embedded in the wild.1004      var result = this.parseSourceElementList_();1005      this.eat_(TokenType.CLOSE_CURLY);1006      return new Block(this.getTreeLocation_(start), result);1007    },1008    /**1009     * @return {Array.<ParseTree>}1010     * @private1011     */1012    parseStatementList_: function() {1013      var result = [];1014      while (this.peekStatement_()) {1015        result.push(this.parseStatement_());1016      }1017      return result;1018    },1019    // 12.2 Variable Statement1020    /**1021     * @return {VariableStatement}1022     * @private1023     */1024    parseVariableStatement_: function() {1025      var start = this.getTreeStartLocation_();1026      var declarations = this.parseVariableDeclarationList_();1027      this.checkInitializers_(declarations);1028      this.eatPossibleImplicitSemiColon_();1029      return new VariableStatement(this.getTreeLocation_(start), declarations);1030    },1031    /**1032     * @param {Expression=} opt_expressionIn1033     * @param {DestructuringInitializer} opt_initializer Whether destructuring1034     *     requires an initializer1035     * @return {VariableDeclarationList}1036     * @private1037     */1038    parseVariableDeclarationList_: function(opt_expressionIn, opt_initializer) {1039      var expressionIn = opt_expressionIn || Expression.NORMAL;1040      var initializer = opt_initializer || DestructuringInitializer.REQUIRED;1041      var token = this.peekType_();1042      switch (token) {1043        case TokenType.CONST:1044        case TokenType.LET:1045          if (!options.blockBinding)1046            debugger;1047        case TokenType.VAR:1048          this.eat_(token);1049          break;1050        default:1051          throw Error('unreachable');1052      }1053      var start = this.getTreeStartLocation_();1054      var declarations = [];1055      declarations.push(this.parseVariableDeclaration_(token, expressionIn,1056                                                       initializer));1057      while (this.peek_(TokenType.COMMA)) {1058        this.eat_(TokenType.COMMA);1059        declarations.push(this.parseVariableDeclaration_(token, expressionIn,1060                                                         initializer));1061      }1062      return new VariableDeclarationList(1063          this.getTreeLocation_(start), token, declarations);1064    },1065    /**1066     * VariableDeclaration :1067     *   BindingIdentifier Initialiseropt1068     *   BindingPattern Initialiser1069     *1070     * VariableDeclarationNoIn :1071     *   BindingIdentifier InitialiserNoInopt1072     *   BindingPattern InitialiserNoIn1073     *1074     * @param {TokenType} binding1075     * @param {Expression} expressionIn1076     * @param {DestructuringInitializer=} opt_initializer1077     * @return {VariableDeclaration}1078     * @private1079     */1080    parseVariableDeclaration_: function(binding, expressionIn,1081                                        opt_initializer) {1082      var initRequired = opt_initializer !== DestructuringInitializer.OPTIONAL;1083      var start = this.getTreeStartLocation_();1084      var lvalue;1085      if (this.peekPattern_())1086        lvalue = this.parseBindingPattern_();1087      else1088        lvalue = this.parseBindingIdentifier_();1089      var initializer = null;1090      if (this.peek_(TokenType.EQUAL))1091        initializer = this.parseInitializer_(expressionIn);1092      else if (lvalue.isPattern() && initRequired)1093        this.reportError_('destructuring must have an initializer');1094      return new VariableDeclaration(this.getTreeLocation_(start), lvalue, initializer);1095    },1096    /**1097     * @param {Expression} expressionIn1098     * @return {ParseTree}1099     * @private1100     */1101    parseInitializer_: function(expressionIn) {1102      this.eat_(TokenType.EQUAL);1103      return this.parseAssignmentExpression_(expressionIn);1104    },1105    // 12.3 Empty Statement1106    /**1107     * @return {EmptyStatement}1108     * @private1109     */1110    parseEmptyStatement_: function() {1111      var start = this.getTreeStartLocation_();1112      this.eat_(TokenType.SEMI_COLON);1113      return new EmptyStatement(this.getTreeLocation_(start));1114    },1115    // 12.4 Expression Statement1116    /**1117     * @return {ExpressionStatement}1118     * @private1119     */1120    parseExpressionStatement_: function() {1121      var start = this.getTreeStartLocation_();1122      var expression = this.parseExpression_();1123      this.eatPossibleImplicitSemiColon_();1124      return new ExpressionStatement(this.getTreeLocation_(start), expression);1125    },1126    // 12.5 If Statement1127    /**1128     * @return {IfStatement}1129     * @private1130     */1131    parseIfStatement_: function() {1132      var start = this.getTreeStartLocation_();1133      this.eat_(TokenType.IF);1134      this.eat_(TokenType.OPEN_PAREN);1135      var condition = this.parseExpression_();1136      this.eat_(TokenType.CLOSE_PAREN);1137      var ifClause = this.parseStatement_();1138      var elseClause = null;1139      if (this.peek_(TokenType.ELSE)) {1140        this.eat_(TokenType.ELSE);1141        elseClause = this.parseStatement_();1142      }1143      return new IfStatement(this.getTreeLocation_(start), condition, ifClause, elseClause);1144    },1145    // 12.6 Iteration Statements1146    // 12.6.1 The do-while Statement1147    /**1148     * @return {ParseTree}1149     * @private1150     */1151    parseDoWhileStatement_: function() {1152      var start = this.getTreeStartLocation_();1153      this.eat_(TokenType.DO);1154      var body = this.parseStatement_();1155      this.eat_(TokenType.WHILE);1156      this.eat_(TokenType.OPEN_PAREN);1157      var condition = this.parseExpression_();1158      this.eat_(TokenType.CLOSE_PAREN);1159      this.eatPossibleImplicitSemiColon_();1160      return new DoWhileStatement(this.getTreeLocation_(start), body, condition);1161    },1162    // 12.6.2 The while Statement1163    /**1164     * @return {ParseTree}1165     * @private1166     */1167    parseWhileStatement_: function() {1168      var start = this.getTreeStartLocation_();1169      this.eat_(TokenType.WHILE);1170      this.eat_(TokenType.OPEN_PAREN);1171      var condition = this.parseExpression_();1172      this.eat_(TokenType.CLOSE_PAREN);1173      var body = this.parseStatement_();1174      return new WhileStatement(this.getTreeLocation_(start), condition, body);1175    },1176    // 12.6.3 The for Statement1177    // 12.6.4 The for-in Statement1178    /**1179     * @return {ParseTree}1180     * @private1181     */1182    parseForStatement_: function() {1183      var start = this.getTreeStartLocation_();1184      this.eat_(TokenType.FOR);1185      this.eat_(TokenType.OPEN_PAREN);1186      var self = this;1187      function validate(variables, kind) {1188        if (variables.declarations.length > 1) {1189          self.reportError_(kind +1190              ' statement may not have more than one variable declaration');1191        }1192        var declaration = variables.declarations[0];1193        if (declaration.lvalue.isPattern() && declaration.initializer) {1194          self.reportError_(declaration.initializer.location,1195              'initializer is not allowed in ' + kind + ' loop with pattern');1196        }1197      }1198      if (this.peekVariableDeclarationList_()) {1199        var variables =1200           this.parseVariableDeclarationList_(1201              Expression.NO_IN, DestructuringInitializer.OPTIONAL);1202        if (this.peek_(TokenType.IN)) {1203          // for-in: only one declaration allowed1204          validate(variables, 'for-in');1205          var declaration = variables.declarations[0];1206          // for-in: if let/const binding used, initializer is illegal1207          if (options.blockBinding &&1208              (variables.declarationType == TokenType.LET ||1209               variables.declarationType == TokenType.CONST)) {1210            if (declaration.initializer != null) {1211               this.reportError_('let/const in for-in statement may not have initializer');1212            }1213          }1214          return this.parseForInStatement_(start, variables);1215        } else if (this.peekOf_()) {1216          // for-of: only one declaration allowed1217          validate(variables, 'for-of');1218          // for-of: initializer is illegal1219          var declaration = variables.declarations[0];1220          if (declaration.initializer != null) {1221            this.reportError_('for-of statement may not have initializer');1222          }1223          return this.parseForOfStatement_(start, variables);1224        } else {1225          // for statement: let and const must have initializers1226          this.checkInitializers_(variables);1227          return this.parseForStatement2_(start, variables);1228        }1229      }1230      if (this.peek_(TokenType.SEMI_COLON)) {1231        return this.parseForStatement2_(start, null);1232      }1233      var initializer = this.parseExpression_(Expression.NO_IN);1234      if (initializer.isLeftHandSideExpression() &&1235          (this.peek_(TokenType.IN) || this.peekOf_())) {1236        initializer = this.transformLeftHandSideExpression_(initializer);1237        if (this.peekOf_())1238          return this.parseForOfStatement_(start, initializer);1239        return this.parseForInStatement_(start, initializer);1240      }1241      return this.parseForStatement2_(start, initializer);1242    },1243    peekOf_: function() {1244      return options.forOf && this.peekPredefinedString_(PredefinedName.OF);1245    },1246    // The for-each Statement1247    // for  (  { let | var }  identifier  of  expression  )  statement1248    /**1249     * @param {SourcePosition} start1250     * @param {ParseTree} initializer1251     * @return {ParseTree}1252     * @private1253     */1254    parseForOfStatement_: function(start, initializer) {1255      this.eatId_(); // of1256      var collection = this.parseExpression_();1257      this.eat_(TokenType.CLOSE_PAREN);1258      var body = this.parseStatement_();1259      return new ForOfStatement(this.getTreeLocation_(start), initializer, collection, body);1260    },1261    /**1262     * Checks variable declaration in variable and for statements.1263     *1264     * @param {VariableDeclarationList} variables1265     * @return {void}1266     * @private1267     */1268    checkInitializers_: function(variables) {1269      if (options.blockBinding &&1270          variables.declarationType == TokenType.CONST) {1271        var type = variables.declarationType;1272        for (var i = 0; i < variables.declarations.length; i++) {1273          if (!this.checkInitializer_(type, variables.declarations[i])) {1274            break;1275          }1276        }1277      }1278    },1279    /**1280     * Checks variable declaration1281     *1282     * @param {TokenType} type1283     * @param {VariableDeclaration} declaration1284     * @return {boolan} Whether the initializer is correct.1285     * @private1286     */1287    checkInitializer_: function(type, declaration) {1288      if (options.blockBinding && type == TokenType.CONST &&1289          declaration.initializer == null) {1290        this.reportError_('const variables must have an initializer');1291        return false;1292      }1293      return true;1294    },1295    /**1296     * @return {boolean}1297     * @private1298     */1299    peekVariableDeclarationList_: function() {1300      switch (this.peekType_()) {1301        case TokenType.VAR:1302          return true;1303        case TokenType.CONST:1304        case TokenType.LET:1305          return options.blockBinding;1306        default:1307          return false;1308      }1309    },1310    // 12.6.3 The for Statement1311    /**1312     * @param {SourcePosition} start1313     * @param {ParseTree} initializer1314     * @return {ParseTree}1315     * @private1316     */1317    parseForStatement2_: function(start, initializer) {1318      this.eat_(TokenType.SEMI_COLON);1319      var condition = null;1320      if (!this.peek_(TokenType.SEMI_COLON)) {1321        condition = this.parseExpression_();1322      }1323      this.eat_(TokenType.SEMI_COLON);1324      var increment = null;1325      if (!this.peek_(TokenType.CLOSE_PAREN)) {1326        increment = this.parseExpression_();1327      }1328      this.eat_(TokenType.CLOSE_PAREN);1329      var body = this.parseStatement_();1330      return new ForStatement(this.getTreeLocation_(start), initializer, condition, increment, body);1331    },1332    // 12.6.4 The for-in Statement1333    /**1334     * @param {SourcePosition} start1335     * @param {ParseTree} initializer1336     * @return {ParseTree}1337     * @private1338     */1339    parseForInStatement_: function(start, initializer) {1340      this.eat_(TokenType.IN);1341      var collection = this.parseExpression_();1342      this.eat_(TokenType.CLOSE_PAREN);1343      var body = this.parseStatement_();1344      return new ForInStatement(this.getTreeLocation_(start), initializer, collection, body);1345    },1346    // 12.7 The continue Statement1347    /**1348     * @return {ParseTree}1349     * @private1350     */1351    parseContinueStatement_: function() {1352      var start = this.getTreeStartLocation_();1353      this.eat_(TokenType.CONTINUE);1354      var name = null;1355      if (!this.peekImplicitSemiColon_()) {1356        name = this.eatIdOpt_();1357      }1358      this.eatPossibleImplicitSemiColon_();1359      return new ContinueStatement(this.getTreeLocation_(start), name);1360    },1361    // 12.8 The break Statement1362    /**1363     * @return {ParseTree}1364     * @private1365     */1366    parseBreakStatement_: function() {1367      var start = this.getTreeStartLocation_();1368      this.eat_(TokenType.BREAK);1369      var name = null;1370      if (!this.peekImplicitSemiColon_()) {1371        name = this.eatIdOpt_();1372      }1373      this.eatPossibleImplicitSemiColon_();1374      return new BreakStatement(this.getTreeLocation_(start), name);1375    },1376    //12.9 The return Statement1377    /**1378     * @return {ParseTree}1379     * @private1380     */1381    parseReturnStatement_: function() {1382      var start = this.getTreeStartLocation_();1383      this.eat_(TokenType.RETURN);1384      var expression = null;1385      if (!this.peekImplicitSemiColon_()) {1386        expression = this.parseExpression_();1387      }1388      this.eatPossibleImplicitSemiColon_();1389      return new ReturnStatement(this.getTreeLocation_(start), expression);1390    },1391    // Harmony: The yield Statement1392    //  yield  [expression];1393    /**1394     * @return {ParseTree}1395     * @private1396     */1397    parseYieldStatement_: function() {1398      if (!this.allowYield_) {1399        return this.parseMissingPrimaryExpression_(1400            "'yield' expressions are only allowed inside 'function*'");1401      }1402      var start = this.getTreeStartLocation_();1403      this.eat_(TokenType.YIELD);1404      var expression = null;1405      var isYieldFor = this.eatOpt_(TokenType.STAR) != null;1406      if (isYieldFor || !this.peekImplicitSemiColon_()) {1407        expression = this.parseExpression_();1408      }1409      this.eatPossibleImplicitSemiColon_();1410      return new YieldStatement(1411          this.getTreeLocation_(start), expression, isYieldFor);1412    },1413    // Harmony?: The await Statement1414    // TODO: await should be an expression, not a statement1415    // await[ identifier = ] expression;1416    /**1417     * @return {ParseTree}1418     * @private1419     */1420    parseAwaitStatement_: function() {1421      var start = this.getTreeStartLocation_();1422      this.eat_(TokenType.AWAIT);1423      var identifier = null;1424      if (this.peek_(TokenType.IDENTIFIER) && this.peek_(TokenType.EQUAL, 1)) {1425        identifier = this.eatId_();1426        this.eat_(TokenType.EQUAL);1427      }1428      var expression = this.parseExpression_();1429      this.eatPossibleImplicitSemiColon_();1430      return new AwaitStatement(this.getTreeLocation_(start), identifier, expression);1431    },1432    // 12.10 The with Statement1433    /**1434     * @return {ParseTree}1435     * @private1436     */1437    parseWithStatement_: function() {1438      var start = this.getTreeStartLocation_();1439      this.eat_(TokenType.WITH);1440      this.eat_(TokenType.OPEN_PAREN);1441      var expression = this.parseExpression_();1442      this.eat_(TokenType.CLOSE_PAREN);1443      var body = this.parseStatement_();1444      return new WithStatement(this.getTreeLocation_(start), expression, body);1445    },1446    // 12.11 The switch Statement1447    /**1448     * @return {ParseTree}1449     * @private1450     */1451    parseSwitchStatement_: function() {1452      var start = this.getTreeStartLocation_();1453      this.eat_(TokenType.SWITCH);1454      this.eat_(TokenType.OPEN_PAREN);1455      var expression = this.parseExpression_();1456      this.eat_(TokenType.CLOSE_PAREN);1457      this.eat_(TokenType.OPEN_CURLY);1458      var caseClauses = this.parseCaseClauses_();1459      this.eat_(TokenType.CLOSE_CURLY);1460      return new SwitchStatement(this.getTreeLocation_(start), expression, caseClauses);1461    },1462    /**1463     * @return {Array.<ParseTree>}1464     * @private1465     */1466    parseCaseClauses_: function() {1467      var foundDefaultClause = false;1468      var result = [];1469      while (true) {1470        var start = this.getTreeStartLocation_();1471        switch (this.peekType_()) {1472          case TokenType.CASE:1473            this.eat_(TokenType.CASE);1474            var expression = this.parseExpression_();1475            this.eat_(TokenType.COLON);1476            var statements = this.parseCaseStatementsOpt_();1477            result.push(new CaseClause(this.getTreeLocation_(start), expression, statements));1478            break;1479          case TokenType.DEFAULT:1480            if (foundDefaultClause) {1481              this.reportError_('Switch statements may have at most one default clause');1482            } else {1483              foundDefaultClause = true;1484            }1485            this.eat_(TokenType.DEFAULT);1486            this.eat_(TokenType.COLON);1487            result.push(new DefaultClause(this.getTreeLocation_(start), this.parseCaseStatementsOpt_()));1488            break;1489          default:1490            return result;1491        }1492      }1493    },1494    /**1495     * @return {Array.<ParseTree>}1496     * @private1497     */1498    parseCaseStatementsOpt_: function() {1499      return this.parseStatementList_();1500    },1501    // 12.12 Labelled Statement1502    /**1503     * @return {ParseTree}1504     * @private1505     */1506    parseLabelledStatement_: function() {1507      var start = this.getTreeStartLocation_();1508      var name = this.eatId_();1509      this.eat_(TokenType.COLON);1510      return new LabelledStatement(this.getTreeLocation_(start), name,1511                                   this.parseStatement_());1512    },1513    /**1514     * @return {boolean}1515     * @private1516     */1517    peekLabelledStatement_: function() {1518      return this.peek_(TokenType.IDENTIFIER) &&1519          this.peek_(TokenType.COLON, 1);1520    },1521    // 12.13 Throw Statement1522    /**1523     * @return {ParseTree}1524     * @private1525     */1526    parseThrowStatement_: function() {1527      var start = this.getTreeStartLocation_();1528      this.eat_(TokenType.THROW);1529      var value = null;1530      if (!this.peekImplicitSemiColon_()) {1531        value = this.parseExpression_();1532      }1533      this.eatPossibleImplicitSemiColon_();1534      return new ThrowStatement(this.getTreeLocation_(start), value);1535    },1536    // 12.14 Try Statement1537    /**1538     * @return {ParseTree}1539     * @private1540     */1541    parseTryStatement_: function() {1542      var start = this.getTreeStartLocation_();1543      this.eat_(TokenType.TRY);1544      var body = this.parseBlock_();1545      var catchBlock = null;1546      if (this.peek_(TokenType.CATCH)) {1547        catchBlock = this.parseCatch_();1548      }1549      var finallyBlock = null;1550      if (this.peek_(TokenType.FINALLY)) {1551        finallyBlock = this.parseFinallyBlock_();1552      }1553      if (catchBlock == null && finallyBlock == null) {1554        this.reportError_("'catch' or 'finally' expected.");1555      }1556      return new TryStatement(this.getTreeLocation_(start), body, catchBlock, finallyBlock);1557    },1558    /**1559     * Catch :1560     *   catch ( CatchParameter ) Block1561     *1562     * CatchParameter :1563     *   BindingIdentifier1564     *   BindingPattern1565     *1566     * @return {ParseTree}1567     * @private1568     */1569    parseCatch_: function() {1570      var start = this.getTreeStartLocation_();1571      var catchBlock;1572      this.eat_(TokenType.CATCH);1573      this.eat_(TokenType.OPEN_PAREN);1574      var binding;1575      if (this.peekPattern_())1576        binding = this.parseBindingPattern_();1577      else1578        binding = this.parseBindingIdentifier_();1579      this.eat_(TokenType.CLOSE_PAREN);1580      var catchBody = this.parseBlock_();1581      catchBlock = new Catch(this.getTreeLocation_(start), binding,1582                             catchBody);1583      return catchBlock;1584    },1585    /**1586     * @return {ParseTree}1587     * @private1588     */1589    parseFinallyBlock_: function() {1590      var start = this.getTreeStartLocation_();1591      this.eat_(TokenType.FINALLY);1592      var finallyBlock = this.parseBlock_();1593      return new Finally(this.getTreeLocation_(start), finallyBlock);1594    },1595    // 12.15 The Debugger Statement1596    /**1597     * @return {ParseTree}1598     * @private1599     */1600    parseDebuggerStatement_: function() {1601      var start = this.getTreeStartLocation_();1602      this.eat_(TokenType.DEBUGGER);1603      this.eatPossibleImplicitSemiColon_();1604      return new DebuggerStatement(this.getTreeLocation_(start));1605    },1606    // 11.1 Primary Expressions1607    /**1608     * @return {ParseTree}1609     * @private1610     */1611    parsePrimaryExpression_: function() {1612      switch (this.peekType_()) {1613        case TokenType.CLASS:1614          return options.classes ?1615              this.parseClassExpression_() :1616              this.parseMissingPrimaryExpression_();1617        case TokenType.SUPER:1618          return this.parseSuperExpression_();1619        case TokenType.THIS:1620          return this.parseThisExpression_();1621        case TokenType.IDENTIFIER:1622          return this.parseIdentifierExpression_();1623        case TokenType.NUMBER:1624        case TokenType.STRING:1625        case TokenType.TRUE:1626        case TokenType.FALSE:1627        case TokenType.NULL:1628          return this.parseLiteralExpression_();1629        case TokenType.OPEN_SQUARE:1630          return this.parseArrayLiteral_();1631        case TokenType.OPEN_CURLY:1632          return this.parseObjectLiteral_();1633        case TokenType.OPEN_PAREN:1634          return this.parseParenExpression_();1635        case TokenType.SLASH:1636        case TokenType.SLASH_EQUAL:1637          return this.parseRegularExpressionLiteral_();1638        case TokenType.BACK_QUOTE:1639          return this.parseQuasiLiteral_(null);1640        default:1641          return this.parseMissingPrimaryExpression_();1642      }1643    },1644    /**1645     * @return {SuperExpression}1646     * @private1647     */1648    parseSuperExpression_: function() {1649      var start = this.getTreeStartLocation_();1650      this.eat_(TokenType.SUPER);1651      return new SuperExpression(this.getTreeLocation_(start));1652    },1653    /**1654     * @return {ThisExpression}1655     * @private1656     */1657    parseThisExpression_: function() {1658      var start = this.getTreeStartLocation_();1659      this.eat_(TokenType.THIS);1660      return new ThisExpression(this.getTreeLocation_(start));1661    },1662    peekBindingIdentifier_: function(opt_index) {1663      return this.peekId_(opt_index || 0);1664    },1665    parseBindingIdentifier_: function() {1666      var start = this.getTreeStartLocation_();1667      var identifier = this.eatId_();1668      return new BindingIdentifier(this.getTreeLocation_(start), identifier);1669    },1670    /**1671     * @return {IdentifierExpression}1672     * @private1673     */1674    parseIdentifierExpression_: function() {1675      var start = this.getTreeStartLocation_();1676      var identifier = this.eatId_();1677      return new IdentifierExpression(this.getTreeLocation_(start), identifier);1678    },1679    /**1680     * Special case of parseIdentifierExpression_ which allows keywords.1681     * @return {IdentifierExpression}1682     * @private1683     */1684    parseIdentifierNameExpression_: function() {1685      var start = this.getTreeStartLocation_();1686      var identifier = this.eatIdName_();1687      return new IdentifierExpression(this.getTreeLocation_(start), identifier);1688    },1689    /**1690     * @return {LiteralExpression}1691     * @private1692     */1693    parseLiteralExpression_: function() {1694      var start = this.getTreeStartLocation_();1695      var literal = this.nextLiteralToken_();1696      return new LiteralExpression(this.getTreeLocation_(start), literal);1697    },1698    /**1699     * @return {Token}1700     * @private1701     */1702    nextLiteralToken_: function() {1703      return this.nextToken_();1704    },1705    /**1706     * @return {ParseTree}1707     * @private1708     */1709    parseRegularExpressionLiteral_: function() {1710      var start = this.getTreeStartLocation_();1711      var literal = this.nextRegularExpressionLiteralToken_();1712      return new LiteralExpression(this.getTreeLocation_(start), literal);1713    },1714    peekSpread_: function() {1715      return this.peek_(TokenType.DOT_DOT_DOT);1716    },1717    // 11.1.4 Array Literal Expression1718    /**1719     * Parse array literal and delegates to {@code parseArrayComprehension_} as1720     * needed.1721     *1722     * ArrayLiteral :1723     *   [ Elisionopt ]1724     *   [ ElementList ]1725     *   [ ElementList , Elisionopt ]1726     *1727     * ElementList :1728     *   Elisionopt AssignmentExpression1729     *   Elisionopt ... AssignmentExpression1730     *   ElementList , Elisionopt AssignmentExpression1731     *   ElementList , Elisionopt SpreadElement1732     *1733     * Elision :1734     *   ,1735     *   Elision ,1736     *1737     * SpreadElement :1738     *   ... AssignmentExpression1739     *1740     * @return {ParseTree}1741     * @private1742     */1743    parseArrayLiteral_: function() {1744      var start = this.getTreeStartLocation_();1745      var expression;1746      var elements = [];1747      var allowFor = options.arrayComprehension;1748      this.eat_(TokenType.OPEN_SQUARE);1749      while (this.peek_(TokenType.COMMA) ||1750             this.peekSpread_() ||1751             this.peekAssignmentExpression_()) {1752        if (this.peek_(TokenType.COMMA)) {1753          expression = new NullTree();1754          allowFor = false;1755        } else {1756          expression = this.parseAssignmentOrSpread_();1757        }1758        if (allowFor && this.peek_(TokenType.FOR))1759          return this.parseArrayComprehension_(start, expression);1760        allowFor = false;1761        elements.push(expression);1762        if (!this.peek_(TokenType.CLOSE_SQUARE)) {1763          this.eat_(TokenType.COMMA);1764        }1765      }1766      this.eat_(TokenType.CLOSE_SQUARE);1767      return new ArrayLiteralExpression(1768          this.getTreeLocation_(start), elements);1769    },1770    /**1771     * Continues parsing array comprehension.1772     *1773     * ArrayComprehension :1774     *   [ Assignment ï¿¼ ComprehensionForList ]1775     *   [ AssignmentExpression ComprehensionForList if1776     *1777     * ComprehensionForList :1778     *   ComprehensionFor1779     *   ComprehensionForList ComprehensionFor1780     *1781     * ComprehensionFor :1782     *   for ForBinding of Expression1783     *1784     * ForBinding :1785     *   BindingIdentifier1786     *   BindingPattern1787     *1788     * @param {Location} start1789     * @param {[ParseTree} expression1790     * @return {ParseTree}1791     */1792    parseArrayComprehension_: function(start, expression) {1793      var comprehensionForList = this.parseComprehensionForList_();1794      var ifExpression = this.parseComprehensionIf_();1795      this.eat_(TokenType.CLOSE_SQUARE);1796      return new ArrayComprehension(this.getTreeLocation_(start),1797                                    expression,1798                                    comprehensionForList,1799                                    ifExpression);1800    },1801    // 11.1.4 Object Literal Expression1802    /**1803     * @return {ParseTree}1804     * @private1805     */1806    parseObjectLiteral_: function() {1807      var start = this.getTreeStartLocation_();1808      var result = [];1809      this.eat_(TokenType.OPEN_CURLY);1810      while (this.peekPropertyAssignment_()) {1811        if (this.peekGetAccessor_()) {1812          result.push(this.parseGetAccessor_());1813          this.eatPropertyOptionalComma_();1814        } else if (this.peekSetAccessor_()) {1815          result.push(this.parseSetAccessor_());1816          this.eatPropertyOptionalComma_();1817        // http://wiki.ecmascript.org/doku.php?id=harmony:concise_object_literal_extensions#methods1818        } else if (this.peekPropertyMethodAssignment_()) {1819          result.push(this.parsePropertyMethodAssignment_());1820          this.eatPropertyOptionalComma_();1821        } else {1822          result.push(this.parsePropertyNameAssignment_());1823          // Comma is required after name assignment.1824          if (this.eatOpt_(TokenType.COMMA) == null) {1825            break;1826          }1827        }1828      }1829      this.eat_(TokenType.CLOSE_CURLY);1830      return new ObjectLiteralExpression(this.getTreeLocation_(start), result);1831    },1832    eatPropertyOptionalComma_: function() {1833      if (options.propertyOptionalComma) {1834        this.eatOpt_(TokenType.COMMA);1835      } else {1836        this.eat_(TokenType.COMMA);1837      }1838    },1839    /**1840     * @return {boolean}1841     * @private1842     */1843    peekPropertyAssignment_: function() {1844      var index = +this.peek_(TokenType.STAR);1845      return this.peekPropertyName_(index);1846    },1847    /**1848     * @return {boolean}1849     * @private1850     */1851    peekPropertyName_: function(tokenIndex) {1852      var type = this.peekType_(tokenIndex);1853      switch (type) {1854        case TokenType.IDENTIFIER:1855        case TokenType.STRING:1856        case TokenType.NUMBER:1857          return true;1858        default:1859          return Keywords.isKeyword(type);1860      }1861    },1862    /**1863     * @return {boolean}1864     * @private1865     */1866    peekGetAccessor_: function() {1867      return this.peekPredefinedString_(PredefinedName.GET) &&1868          this.peekPropertyName_(1);1869    },1870    /**1871     * @return {boolean}1872     * @private1873     */1874    peekPredefinedString_: function(string, opt_index) {1875      var index = opt_index || 0;1876      return this.peek_(TokenType.IDENTIFIER, index) && this.peekToken_(index).value === string;1877    },1878    /**1879     * @return {ParseTree}1880     * @private1881     */1882    parseGetAccessor_: function() {1883      var start = this.getTreeStartLocation_();1884      this.eatId_(); // get1885      var propertyName = this.nextToken_();1886      this.eat_(TokenType.OPEN_PAREN);1887      this.eat_(TokenType.CLOSE_PAREN);1888      var body = this.parseFunctionBody_(false);1889      return new GetAccessor(this.getTreeLocation_(start), propertyName, body);1890    },1891    /**1892     * @return {boolean}1893     * @private1894     */1895    peekSetAccessor_: function() {1896      return this.peekPredefinedString_(PredefinedName.SET) &&1897          this.peekPropertyName_(1);1898    },1899    /**1900     * @return {ParseTree}1901     * @private1902     */1903    parseSetAccessor_: function() {1904      var start = this.getTreeStartLocation_();1905      this.eatId_(); // set1906      var propertyName = this.nextToken_();1907      this.eat_(TokenType.OPEN_PAREN);1908      var parameter = this.parsePropertySetParameterList_();1909      this.eat_(TokenType.CLOSE_PAREN);1910      var body = this.parseFunctionBody_(false);1911      return new SetAccessor(this.getTreeLocation_(start), propertyName,1912                             parameter, body);1913    },1914    /**1915     * PropertySetParameterList :1916     *   BindingIdentifier1917     *   BindingPattern1918     */1919    parsePropertySetParameterList_: function() {1920      var start = this.getTreeStartLocation_();1921      var binding;1922      if (this.peekPattern_())1923        binding = this.parseBindingPattern_();1924      else1925        binding = this.parseBindingIdentifier_();1926      return new BindingElement(this.getTreeLocation_(start), binding, null);1927    },1928    /**1929     * @return {ParseTree}1930     * @private1931     */1932    parsePropertyNameAssignment_: function() {1933      var start = this.getTreeStartLocation_();1934      // http://wiki.ecmascript.org/doku.php?id=strawman:object_initialiser_shorthand1935      if (this.peek_(TokenType.COLON, 1)) {1936        var name = this.nextToken_();1937        this.eat_(TokenType.COLON);1938        var value = this.parseAssignmentExpression_();1939        return new PropertyNameAssignment(this.getTreeLocation_(start), name,1940                                          value);1941      } else {1942        return this.parsePropertyNameShorthand_();1943      }1944    },1945    peekPropertyMethodAssignment_: function() {1946      var index = +this.peek_(TokenType.STAR);1947      return options.propertyMethods &&1948          this.peekPropertyName_(index) &&1949          this.peek_(TokenType.OPEN_PAREN, index + 1);1950    },1951    /**1952     * @return {ParseTree}1953     * @private1954     */1955    parsePropertyMethodAssignment_: function() {1956      var start = this.getTreeStartLocation_();1957      // Note that parsePropertyAssignment_ already limits name to String,1958      // Number & IdentfierName.1959      var isGenerator = this.eatOpt_(TokenType.STAR) != null;1960      var name = this.nextToken_();1961      this.eat_(TokenType.OPEN_PAREN);1962      var formalParameterList = this.parseFormalParameterList_();1963      this.eat_(TokenType.CLOSE_PAREN);1964      var functionBody = this.parseFunctionBody_(isGenerator);1965      return new PropertyMethodAssignment(this.getTreeLocation_(start),1966          name, isGenerator, formalParameterList, functionBody);1967    },1968    /**1969     * @return {ParseTree}1970     * @private1971     */1972    parsePropertyNameShorthand_: function() {1973      var start = this.getTreeStartLocation_();1974      var name = this.eatId_();1975      if (!options.propertyNameShorthand) {1976        this.eat_(TokenType.COLON);1977        return null;1978      }1979      return new PropertyNameShorthand(this.getTreeLocation_(start), name);1980    },1981    /**1982     * @return {ParseTree}1983     * @private1984     */1985    parseParenExpression_: function() {1986      // Parse arrow function will return a ParenExpression if there isn't an1987      // arrow after the ( CoverFormals ).1988      return this.parseArrowFunction_();1989    },1990    /**1991     * @param {string=} opt_message Error message to report.1992     * @return {ParseTree}1993     * @private1994     */1995    parseMissingPrimaryExpression_: function(opt_message) {1996      var start = this.getTreeStartLocation_();1997      this.reportError_(opt_message || 'primary expression expected');1998      var token = this.nextToken_();1999      return new MissingPrimaryExpression(this.getTreeLocation_(start), token);2000    },2001    // 11.14 Expressions2002    /**2003     * @return {boolean}2004     * @private2005     */2006    peekExpression_: function(opt_index) {2007      switch (this.peekType_(opt_index || 0)) {2008        case TokenType.BACK_QUOTE:2009          return options.quasi;2010        case TokenType.BANG:2011        case TokenType.CLASS:2012        case TokenType.DELETE:2013        case TokenType.FALSE:2014        case TokenType.FUNCTION:2015        case TokenType.IDENTIFIER:2016        case TokenType.MINUS:2017        case TokenType.MINUS_MINUS:2018        case TokenType.NEW:2019        case TokenType.NULL:2020        case TokenType.NUMBER:2021        case TokenType.OPEN_CURLY:2022        case TokenType.OPEN_PAREN:2023        case TokenType.OPEN_SQUARE:2024        case TokenType.PLUS:2025        case TokenType.PLUS_PLUS:2026        case TokenType.SLASH: // regular expression literal2027        case TokenType.SLASH_EQUAL:2028        case TokenType.STRING:2029        case TokenType.SUPER:2030        case TokenType.THIS:2031        case TokenType.TILDE:2032        case TokenType.TRUE:2033        case TokenType.TYPEOF:2034        case TokenType.VOID:2035          return true;2036        default:2037          return false;2038      }2039    },2040    /**2041     * Expression :2042     *   AssignmentExpression2043     *   Expression , AssignmentExpression2044     *2045     * ExpressionNoIn :2046     *   AssignmentExpressionNoIn2047     *   ExpressionNoIn , AssignmentExpressionNoIn2048     *2049     * @return {ParseTree}2050     * @private2051     */2052    parseExpression_: function(opt_expressionIn) {2053      var expressionIn = opt_expressionIn || Expression.IN;2054      var start = this.getTreeStartLocation_();2055      var result = this.parseAssignmentExpression_(expressionIn);2056      if (this.peek_(TokenType.COMMA)) {2057        var exprs = [];2058        exprs.push(result);2059        // Lookahead to prevent comma expression from consuming , ...2060        while (this.peek_(TokenType.COMMA) &&2061               this.peekAssignmentExpression_(1)) {2062          this.eat_(TokenType.COMMA);2063          exprs.push(this.parseAssignmentExpression_(expressionIn));2064        }2065        return new CommaExpression(this.getTreeLocation_(start), exprs);2066      }2067      return result;2068    },2069    // 11.13 Assignment expressions2070    /**2071     * @return {boolean}2072     * @private2073     */2074    peekAssignmentExpression_: function(opt_index) {2075      return this.peekExpression_(opt_index || 0);2076    },2077    /**2078     * AssignmentExpression :2079     *   ConditionalExpression2080     *   YieldExpression2081     *   ArrowFunction2082     *   LeftHandSideExpression = AssignmentExpression2083     *   LeftHandSideExpression AssignmentOperator AssignmentExpression2084     *2085     * AssignmentExpressionNoIn :2086     *   ConditionalExpressionNoIn2087     *   YieldExpression2088     *   ArrowFunction2089     *   LeftHandSideExpression = AssignmentExpressionNoIn2090     *   LeftHandSideExpression AssignmentOperator AssignmentExpressionNoIn2091     *2092     * @param {Expression} expressionIn2093     * @return {ParseTree}2094     * @private2095     */2096    parseAssignmentExpression_: function(opt_expressionIn) {2097      if (this.peekBindingIdentifier_() && this.peekArrow_(1))2098        return this.parseArrowFunction_();2099      // The remaining arrow function cases are handled in2100      // parseParenExpression_.2101      var expressionIn = opt_expressionIn || Expression.NORMAL;2102      var start = this.getTreeStartLocation_();2103      var left = this.parseConditional_(expressionIn);2104      if (this.peekAssignmentOperator_()) {2105        if (this.peek_(TokenType.EQUAL))2106          left = this.transformLeftHandSideExpression_(left);2107        if (!left.isLeftHandSideExpression() && !left.isPattern()) {2108          this.reportError_('Left hand side of assignment must be new, call, member, function, primary expressions or destructuring pattern');2109        }2110        var operator = this.nextToken_();2111        var right = this.parseAssignmentExpression_(expressionIn);2112        return new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2113      }2114      return left;2115    },2116    /**2117     * Transforms a LeftHandSideExpression into a AssignmentPattern if possible.2118     * This returns the transformed tree if it parses as an AssignmentPattern,2119     * otherwise it returns the original tree.2120     * @param {ParseTree} tree2121     * @return {ParseTree}2122     */2123    transformLeftHandSideExpression_: function(tree) {2124      switch (tree.type) {2125        case ParseTreeType.ARRAY_LITERAL_EXPRESSION:2126        case ParseTreeType.OBJECT_LITERAL_EXPRESSION:2127          var errorReporter = new MutedErrorReporter();2128          var p = new Parser(errorReporter,2129                             this.scanner_.getFile(),2130                             tree.location.start.offset);2131          var transformedTree = p.parseAssignmentPattern_();2132          if (!errorReporter.hadError())2133            return transformedTree;2134          break;2135        case ParseTreeType.PAREN_EXPRESSION:2136          var expression =2137              this.transformLeftHandSideExpression_(tree.expression);2138          if (expression !== tree.expression)2139            return new ParenExpression(tree.location, expression);2140      }2141      return tree;2142    },2143    /**2144     * @return {boolean}2145     * @private2146     */2147    peekAssignmentOperator_: function() {2148      var token = this.peekToken_();2149      return !!token && token.isAssignmentOperator();2150    },2151    // 11.12 Conditional Expression2152    /**2153     * @param {Expression} expressionIn2154     * @return {ParseTree}2155     * @private2156     */2157    parseConditional_: function(expressionIn) {2158      var start = this.getTreeStartLocation_();2159      var condition = this.parseLogicalOR_(expressionIn);2160      if (this.peek_(TokenType.QUESTION)) {2161        this.eat_(TokenType.QUESTION);2162        var left = this.parseAssignmentExpression_();2163        this.eat_(TokenType.COLON);2164        var right = this.parseAssignmentExpression_(expressionIn);2165        return new ConditionalExpression(this.getTreeLocation_(start), condition, left, right);2166      }2167      return condition;2168    },2169    // 11.11 Logical OR2170    /**2171     * @param {Expression} expressionIn2172     * @return {ParseTree}2173     * @private2174     */2175    parseLogicalOR_: function(expressionIn) {2176      var start = this.getTreeStartLocation_();2177      var left = this.parseLogicalAND_(expressionIn);2178      while (this.peek_(TokenType.OR)) {2179        var operator = this.eat_(TokenType.OR);2180        var right = this.parseLogicalAND_(expressionIn);2181        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2182      }2183      return left;2184    },2185    // 11.11 Logical AND2186    /**2187     * @param {Expression} expressionIn2188     * @return {ParseTree}2189     * @private2190     */2191    parseLogicalAND_: function(expressionIn) {2192      var start = this.getTreeStartLocation_();2193      var left = this.parseBitwiseOR_(expressionIn);2194      while (this.peek_(TokenType.AND)) {2195        var operator = this.eat_(TokenType.AND);2196        var right = this.parseBitwiseOR_(expressionIn);2197        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2198      }2199      return left;2200    },2201    // 11.10 Bitwise OR2202    /**2203     * @param {Expression} expressionIn2204     * @return {ParseTree}2205     * @private2206     */2207    parseBitwiseOR_: function(expressionIn) {2208      var start = this.getTreeStartLocation_();2209      var left = this.parseBitwiseXOR_(expressionIn);2210      while (this.peek_(TokenType.BAR)) {2211        var operator = this.eat_(TokenType.BAR);2212        var right = this.parseBitwiseXOR_(expressionIn);2213        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2214      }2215      return left;2216    },2217    // 11.10 Bitwise XOR2218    /**2219     * @param {Expression} expressionIn2220     * @return {ParseTree}2221     * @private2222     */2223    parseBitwiseXOR_: function(expressionIn) {2224      var start = this.getTreeStartLocation_();2225      var left = this.parseBitwiseAND_(expressionIn);2226      while (this.peek_(TokenType.CARET)) {2227        var operator = this.eat_(TokenType.CARET);2228        var right = this.parseBitwiseAND_(expressionIn);2229        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2230      }2231      return left;2232    },2233    // 11.10 Bitwise AND2234    /**2235     * @param {Expression} expressionIn2236     * @return {ParseTree}2237     * @private2238     */2239    parseBitwiseAND_: function(expressionIn) {2240      var start = this.getTreeStartLocation_();2241      var left = this.parseEquality_(expressionIn);2242      while (this.peek_(TokenType.AMPERSAND)) {2243        var operator = this.eat_(TokenType.AMPERSAND);2244        var right = this.parseEquality_(expressionIn);2245        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2246      }2247      return left;2248    },2249    // 11.9 Equality Expression2250    /**2251     * @param {Expression} expressionIn2252     * @return {ParseTree}2253     * @private2254     */2255    parseEquality_: function(expressionIn) {2256      var start = this.getTreeStartLocation_();2257      var left = this.parseRelational_(expressionIn);2258      while (this.peekEqualityOperator_()) {2259        var operator = this.nextToken_();2260        var right = this.parseRelational_(expressionIn);2261        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2262      }2263      return left;2264    },2265    /**2266     * @return {boolean}2267     * @private2268     */2269    peekEqualityOperator_: function() {2270      switch (this.peekType_()) {2271        case TokenType.EQUAL_EQUAL:2272        case TokenType.NOT_EQUAL:2273        case TokenType.EQUAL_EQUAL_EQUAL:2274        case TokenType.NOT_EQUAL_EQUAL:2275          return true;2276        default:2277          if (!options.isExpression)2278            return false;2279          var token = this.peekTokenNoLineTerminator_();2280          return token && token.type === TokenType.IDENTIFIER &&2281              (token.value === PredefinedName.IS ||2282               token.value === PredefinedName.ISNT);2283      }2284    },2285    // 11.8 Relational2286    /**2287     * @param {Expression} expressionIn2288     * @return {ParseTree}2289     * @private2290     */2291    parseRelational_: function(expressionIn) {2292      var start = this.getTreeStartLocation_();2293      var left = this.parseShiftExpression_();2294      while (this.peekRelationalOperator_(expressionIn)) {2295        var operator = this.nextToken_();2296        var right = this.parseShiftExpression_();2297        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2298      }2299      return left;2300    },2301    /**2302     * @param {Expression} expressionIn2303     * @return {boolean}2304     * @private2305     */2306    peekRelationalOperator_: function(expressionIn) {2307      switch (this.peekType_()) {2308        case TokenType.OPEN_ANGLE:2309        case TokenType.CLOSE_ANGLE:2310        case TokenType.GREATER_EQUAL:2311        case TokenType.LESS_EQUAL:2312        case TokenType.INSTANCEOF:2313          return true;2314        case TokenType.IN:2315          return expressionIn == Expression.NORMAL;2316        default:2317          return false;2318      }2319    },2320    // 11.7 Shift Expression2321    /**2322     * @return {ParseTree}2323     * @private2324     */2325    parseShiftExpression_: function() {2326      var start = this.getTreeStartLocation_();2327      var left = this.parseAdditiveExpression_();2328      while (this.peekShiftOperator_()) {2329        var operator = this.nextToken_();2330        var right = this.parseAdditiveExpression_();2331        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2332      }2333      return left;2334    },2335    /**2336     * @return {boolean}2337     * @private2338     */2339    peekShiftOperator_: function() {2340      switch (this.peekType_()) {2341        case TokenType.LEFT_SHIFT:2342        case TokenType.RIGHT_SHIFT:2343        case TokenType.UNSIGNED_RIGHT_SHIFT:2344          return true;2345        default:2346          return false;2347      }2348    },2349    // 11.6 Additive Expression2350    /**2351     * @return {ParseTree}2352     * @private2353     */2354    parseAdditiveExpression_: function() {2355      var start = this.getTreeStartLocation_();2356      var left = this.parseMultiplicativeExpression_();2357      while (this.peekAdditiveOperator_()) {2358        var operator = this.nextToken_();2359        var right = this.parseMultiplicativeExpression_();2360        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2361      }2362      return left;2363    },2364    /**2365     * @return {boolean}2366     * @private2367     */2368    peekAdditiveOperator_: function() {2369      switch (this.peekType_()) {2370        case TokenType.PLUS:2371        case TokenType.MINUS:2372          return true;2373        default:2374          return false;2375      }2376    },2377    // 11.5 Multiplicative Expression2378    /**2379     * @return {ParseTree}2380     * @private2381     */2382    parseMultiplicativeExpression_: function() {2383      var start = this.getTreeStartLocation_();2384      var left = this.parseUnaryExpression_();2385      while (this.peekMultiplicativeOperator_()) {2386        var operator = this.nextToken_();2387        var right = this.parseUnaryExpression_();2388        left = new BinaryOperator(this.getTreeLocation_(start), left, operator, right);2389      }2390      return left;2391    },2392    /**2393     * @return {boolean}2394     * @private2395     */2396    peekMultiplicativeOperator_: function() {2397      switch (this.peekType_()) {2398        case TokenType.STAR:2399        case TokenType.SLASH:2400        case TokenType.PERCENT:2401          return true;2402        default:2403          return false;2404      }2405    },2406    // 11.4 Unary Operator2407    /**2408     * @return {ParseTree}2409     * @private2410     */2411    parseUnaryExpression_: function() {2412      var start = this.getTreeStartLocation_();2413      if (this.peekUnaryOperator_()) {2414        var operator = this.nextToken_();2415        var operand = this.parseUnaryExpression_();2416        return new UnaryExpression(this.getTreeLocation_(start), operator, operand);2417      }2418      return this.parsePostfixExpression_();2419    },2420    /**2421     * @return {boolean}2422     * @private2423     */2424    peekUnaryOperator_: function() {2425      switch (this.peekType_()) {2426        case TokenType.DELETE:2427        case TokenType.VOID:2428        case TokenType.TYPEOF:2429        case TokenType.PLUS_PLUS:2430        case TokenType.MINUS_MINUS:2431        case TokenType.PLUS:2432        case TokenType.MINUS:2433        case TokenType.TILDE:2434        case TokenType.BANG:2435          return true;2436        default:2437          return false;2438      }2439    },2440    // 11.3 Postfix Expression2441    /**2442     * @return {ParseTree}2443     * @private2444     */2445    parsePostfixExpression_: function() {2446      var start = this.getTreeStartLocation_();2447      var operand = this.parseLeftHandSideExpression_();2448      while (this.peekPostfixOperator_()) {2449        var operator = this.nextToken_();2450        operand = new PostfixExpression(this.getTreeLocation_(start), operand, operator);2451      }2452      return operand;2453    },2454    /**2455     * @return {boolean}2456     * @private2457     */2458    peekPostfixOperator_: function() {2459      if (this.peekImplicitSemiColon_()) {2460        return false;2461      }2462      switch (this.peekType_()) {2463        case TokenType.PLUS_PLUS:2464        case TokenType.MINUS_MINUS:2465          return true;2466        default:2467          return false;2468      }2469    },2470    // 11.2 Left hand side expression2471    //2472    // Also inlines the call expression productions2473    /**2474     * LeftHandSideExpression :2475     *   NewExpression2476     *   CallExpression2477     *2478     * @return {ParseTree}2479     * @private2480     */2481    parseLeftHandSideExpression_: function() {2482      var start = this.getTreeStartLocation_();2483      var operand = this.parseNewExpression_();2484      // this test is equivalent to is member expression2485      if (!(operand instanceof NewExpression) || operand.args != null) {2486        // The Call expression productions2487        while (this.peekCallSuffix_()) {2488          switch (this.peekType_()) {2489            case TokenType.OPEN_PAREN:2490              var args = this.parseArguments_();2491              operand = new CallExpression(this.getTreeLocation_(start),2492                                           operand, args);2493              break;2494            case TokenType.OPEN_SQUARE:2495              this.eat_(TokenType.OPEN_SQUARE);2496              var member = this.parseExpression_();2497              this.eat_(TokenType.CLOSE_SQUARE);2498              operand = new MemberLookupExpression(this.getTreeLocation_(start),2499                                                   operand, member);2500              break;2501            case TokenType.PERIOD:2502              this.eat_(TokenType.PERIOD);2503              operand = new MemberExpression(this.getTreeLocation_(start),2504                                             operand, this.eatIdName_());2505              break;2506            case TokenType.PERIOD_OPEN_CURLY:2507              var expressions = this.parseCascadeExpressions_();2508              operand = new CascadeExpression(this.getTreeLocation_(start),2509                                              operand, expressions);2510              break;2511            case TokenType.BACK_QUOTE:2512              operand = this.parseQuasiLiteral_(operand);2513              break;2514          }2515        }2516      }2517      return operand;2518    },2519    /**2520     * @return {boolean}2521     * @private2522     */2523    peekCallSuffix_: function() {2524      return this.peek_(TokenType.OPEN_PAREN) ||2525          this.peek_(TokenType.OPEN_SQUARE) ||2526          this.peek_(TokenType.PERIOD) ||2527          options.quasi && this.peek_(TokenType.BACK_QUOTE) ||2528          options.cascadeExpression && this.peek_(TokenType.PERIOD_OPEN_CURLY);2529    },2530    // 11.2 Member Expression without the new production2531    /**2532     * @return {ParseTree}2533     * @private2534     */2535    parseMemberExpressionNoNew_: function() {2536      var start = this.getTreeStartLocation_();2537      var operand;2538      if (this.peekFunction_()) {2539        operand = this.parseFunctionExpression_();2540      } else {2541        operand = this.parsePrimaryExpression_();2542      }2543      while (this.peekMemberExpressionSuffix_()) {2544        switch (this.peekType_()) {2545          case TokenType.OPEN_SQUARE:2546            this.eat_(TokenType.OPEN_SQUARE);2547            var member = this.parseExpression_();2548            this.eat_(TokenType.CLOSE_SQUARE);2549            operand = new MemberLookupExpression(this.getTreeLocation_(start),2550                                                 operand, member);2551            break;2552          case TokenType.PERIOD:2553            this.eat_(TokenType.PERIOD);2554            operand = new MemberExpression(this.getTreeLocation_(start),2555                                           operand, this.eatIdName_());2556            break;2557          case TokenType.PERIOD_OPEN_CURLY:2558            var expressions = this.parseCascadeExpressions_();2559            operand = new CascadeExpression(this.getTreeLocation_(start),2560                                            operand, expressions);2561            break;2562          case TokenType.BACK_QUOTE:2563            operand = this.parseQuasiLiteral_(operand);2564            break;2565        }2566      }2567      return operand;2568    },2569    parseCascadeExpressions_: function() {2570      this.eat_(TokenType.PERIOD_OPEN_CURLY);2571      var expressions = [];2572      while (this.peekId_() && this.peekAssignmentExpression_()) {2573        expressions.push(this.parseCascadeExpression_());2574        this.eatPossibleImplicitSemiColon_();2575      }2576      this.eat_(TokenType.CLOSE_CURLY);2577      return expressions;2578    },2579    parseCascadeExpression_: function() {2580      var expr = this.parseAssignmentExpression_();2581      var operand;2582      switch (expr.type) {2583        case ParseTreeType.CALL_EXPRESSION:2584        case ParseTreeType.MEMBER_EXPRESSION:2585        case ParseTreeType.MEMBER_LOOKUP_EXPRESSION:2586        case ParseTreeType.CASCADE_EXPRESSION:2587          operand = expr.operand;2588          break;2589        case ParseTreeType.BINARY_OPERATOR:2590          operand = expr.left;2591          break;2592        default:2593          this.reportError_(expr.location,2594                            'Invalid expression. Type: ' + expr.type);2595      }2596      if (operand) {2597        switch (operand.type) {2598          case ParseTreeType.MEMBER_EXPRESSION:2599          case ParseTreeType.MEMBER_LOOKUP_EXPRESSION:2600          case ParseTreeType.CALL_EXPRESSION:2601          case ParseTreeType.CASCADE_EXPRESSION:2602          case ParseTreeType.IDENTIFIER_EXPRESSION:2603            break;2604          default:2605            this.reportError_(operand.location,2606                              'Invalid expression: ' + operand.type);2607        }2608      }2609      if (expr.type == ParseTreeType.BINARY_OPERATOR &&2610          !expr.operator.isAssignmentOperator()) {2611        this.reportError_(expr.operator, 'Invalid operator: ' + expr.operator);2612      }2613      return expr;2614    },2615    /**2616     * @return {boolean}2617     * @private2618     */2619    peekMemberExpressionSuffix_: function() {2620      return this.peek_(TokenType.OPEN_SQUARE) ||2621          this.peek_(TokenType.PERIOD) ||2622          options.quasi && this.peek_(TokenType.BACK_QUOTE) ||2623          options.cascadeExpression && this.peek_(TokenType.PERIOD_OPEN_CURLY);2624    },2625    // 11.2 New Expression2626    /**2627     * @return {ParseTree}2628     * @private2629     */2630    parseNewExpression_: function() {2631      if (this.peek_(TokenType.NEW)) {2632        var start = this.getTreeStartLocation_();2633        this.eat_(TokenType.NEW);2634        var operand = this.parseNewExpression_();2635        var args = null;2636        if (this.peek_(TokenType.OPEN_PAREN)) {2637          args = this.parseArguments_();2638        }2639        return new NewExpression(this.getTreeLocation_(start), operand, args);2640      } else {2641        return this.parseMemberExpressionNoNew_();2642      }2643    },2644    /**2645     * @return {ArgumentList}2646     * @private2647     */2648    parseArguments_: function() {2649      // ArgumentList :2650      //   AssignmentOrSpreadExpression2651      //   ArgumentList , AssignmentOrSpreadExpression2652      //2653      // AssignmentOrSpreadExpression :2654      //   ... AssignmentExpression2655      //   AssignmentExpression2656      var start = this.getTreeStartLocation_();2657      var args = [];2658      this.eat_(TokenType.OPEN_PAREN);2659      while (this.peekAssignmentOrRest_()) {2660        args.push(this.parseAssignmentOrSpread_());2661        if (!this.peek_(TokenType.CLOSE_PAREN)) {2662          this.eat_(TokenType.COMMA);2663        }2664      }2665      this.eat_(TokenType.CLOSE_PAREN);2666      return new ArgumentList(this.getTreeLocation_(start), args);2667    },2668    peekRest_: function(opt_index) {2669      return options.restParameters &&2670          this.peek_(TokenType.DOT_DOT_DOT, opt_index || 0);2671    },2672    /**2673     * Whether we have a spread expression or an assignment next.2674     *2675     * This does not peek the operand for the spread expression. This means that2676     * {@code parseAssignmentOrSpred} might still fail when this returns true.2677     *2678     * @return {boolean}2679     * @private2680     */2681    peekAssignmentOrRest_: function() {2682      return this.peekRest_() || this.peekAssignmentExpression_();2683    },2684    /**2685     * @return {ParseTree}2686     * @private2687     */2688    parseAssignmentOrSpread_: function() {2689      if (this.peekSpread_()) {2690        return this.parseSpreadExpression_();2691      }2692      return this.parseAssignmentExpression_();2693    },2694    /**2695     * Parses arrow functions and paren expressions as well as delegates to2696     * {@code parseGeneratorComprehension_} if this begins a generator2697     * comprehension.2698     *2699     * Arrow function support, see:2700     * http://wiki.ecmascript.org/doku.php?id=strawman:arrow_function_syntax2701     *2702     * Generator comprehensions syntax is in the ES6 draft,2703     * 11.1.7 Generator Comprehensions2704     *2705     * ArrowFunction :2706     *   ArrowParameters => ConciseBody2707     *2708     * ArrowParameters :2709     *   BindingIdentifer2710     *   ( ArrowFormalParameterList )2711     *2712     * ArrowFormalParameterList :2713     *   [empty]2714     *   FunctionRestParameter2715     *   CoverFormalsList2716     *   CoverFormalsList, FunctionRestParameter2717     *2718     * ConciseBody :2719     *   [lookahead not {] AssignmentExpression2720     *   { FunctionBody }2721     *2722     * CoverFormalsList :2723     *   Expression2724     *2725     * @param {Expression=} expressionIn2726     * @return {ParseTree}2727     * @private2728     */2729    parseArrowFunction_: function(expressionIn) {2730      var start = this.getTreeStartLocation_();2731      var formals, coverFormals;2732      // BindingIdentifier =>2733      if (this.peekBindingIdentifier_() && this.peekArrow_(1)) {2734        var id = this.parseBindingIdentifier_();2735        formals = [new BindingElement(id.location, id, null)];2736      // We got here through a ParenExpression.2737      } else {2738        this.eat_(TokenType.OPEN_PAREN);2739        // () =>2740        if (this.peek_(TokenType.CLOSE_PAREN)) {2741          this.eat_(TokenType.CLOSE_PAREN);2742          formals = [];2743        // (...2744        } else if (this.peekRest_()) {2745          formals = [this.parseRestParameter_()];2746          this.eat_(TokenType.CLOSE_PAREN);2747        } else {2748          coverFormals = this.parseExpression_();2749          if (coverFormals.type === ParseTreeType.MISSING_PRIMARY_EXPRESSION)2750            return coverFormals;2751          // ( CoverFormals , ...2752          if (this.peek_(TokenType.COMMA) && this.peekRest_(1)) {2753            this.eat_(TokenType.COMMA);2754            formals = this.reparseAsFormalsList_(coverFormals);2755            if (formals)2756              formals.push(this.parseRestParameter_());2757            this.eat_(TokenType.CLOSE_PAREN);2758          // Generator comprehension2759          // ( CoverFormals for2760          } else if (this.peek_(TokenType.FOR) &&2761                     options.generatorComprehension) {2762            return this.parseGeneratorComprehension_(start, coverFormals);2763          // ( CoverFormals )2764          } else {2765            this.eat_(TokenType.CLOSE_PAREN);2766            // ( CoverFormals ) =>2767            if (this.peek_(TokenType.ARROW))2768              formals = this.reparseAsFormalsList_(coverFormals);2769          }2770        }2771      }2772      // The cover grammar could not be parsed as FormalsList.2773      if (!formals)2774        return new ParenExpression(this.getTreeLocation_(start), coverFormals);2775      this.eat_(TokenType.ARROW);2776      var body = this.parseConciseBody_();2777      var startLoc = this.getTreeLocation_(start);2778      return new ArrowFunctionExpression(startLoc,2779          new FormalParameterList(startLoc, formals),2780          body);2781    },2782    /**2783     * Reparses the {@code coverFormals} as a FormalsList. This returns null if2784     * {@code coverFormals} cannot be parsed or fully consumed as a FormalsList.2785     * @param {ParseTree} coverFormals The expression that started after the2786     *     opening paren in an arrow function.2787     * @return {Array.<ParseTree>} An aray with the items to use in a2788     *     FormalsList or {@code null} if there was an error.2789     */2790    reparseAsFormalsList_: function(coverFormals) {2791      var errorReporter = new MutedErrorReporter();2792      var p = new Parser(errorReporter,2793                         this.scanner_.getFile(),2794                         coverFormals.location.start.offset);2795      var formals = p.parseFormalsList_();2796      // We need to consume the whole coverFormals.2797      if (errorReporter.hadError() || !formals.length ||2798          formals[formals.length - 1].location.end.offset !==2799              coverFormals.location.end.offset) {2800        return null;2801      }2802      return formals;2803    },2804    /** @returns {TokenType} */2805    peekArrow_: function(opt_index) {2806      return options.arrowFunctions && this.peek_(TokenType.ARROW, opt_index);2807    },2808    /**2809     * ConciseBody :2810     *   [lookahead not {] AssignmentExpression2811     *   { FunctionBody }2812     *2813     * @param {boolean} isGenerator2814     * @return {ParseTree}2815     *2816     * @return {ParseTree} */2817    parseConciseBody_: function() {2818      // The body can be a block or an expression. A '{' is always treated as2819      // the beginning of a block.2820      if (this.peek_(TokenType.OPEN_CURLY))2821        return this.parseBlock_();2822      return this.parseAssignmentExpression_();2823    },2824    /**2825     * Continues parsing generator exressions. The opening paren and the2826     * expression is parsed by parseArrowFunction_.2827     *2828     * https://bugs.ecmascript.org/show_bug.cgi?id=3812829     *2830     * GeneratorComprehension :2831     *   ( Expression ComprehensionForList )2832     *   ( Expression ComprehensionForList if Expression )2833     *2834     * ComprehensionForList :2835     *   ComprehensionFor2836     *   ComprehensionForList ComprehensionFor2837     *2838     * ComprehensionFor :2839     *   for ForBinding of Expression2840     */2841    parseGeneratorComprehension_: function(start, expression) {2842      var comprehensionForList = this.parseComprehensionForList_();2843      var ifExpression = this.parseComprehensionIf_();2844      this.eat_(TokenType.CLOSE_PAREN);2845      return new GeneratorComprehension(this.getTreeLocation_(start),2846                                        expression,2847                                        comprehensionForList,2848                                        ifExpression);2849    },2850    parseComprehensionForList_: function() {2851      var comprehensionForList = [];2852      while (this.peek_(TokenType.FOR)) {2853        this.eat_(TokenType.FOR);2854        var innerStart = this.getTreeStartLocation_();2855        var left = this.parseForBinding_();2856        this.eatId_(PredefinedName.OF);2857        var iterator = this.parseExpression_();2858        comprehensionForList.push(2859            new ComprehensionFor(this.getTreeLocation_(innerStart),2860                                 left, iterator));2861      }2862      return comprehensionForList;2863    },2864    parseComprehensionIf_: function() {2865      if (this.peek_(TokenType.IF)) {2866        this.eat_(TokenType.IF);2867        return this.parseExpression_();2868      }2869      return null;2870    },2871    /**2872     * ForBinding :2873     *   BindingIdentifier2874     *   BindingPattern2875     */2876    parseForBinding_: function() {2877      if (this.peekPattern_())2878        return this.parseBindingPattern_();2879      return this.parseBindingIdentifier_();2880    },2881    // Destructuring; see2882    // http://wiki.ecmascript.org/doku.php?id=harmony:destructuring2883    //2884    // SpiderMonkey is much more liberal in where it allows2885    // parenthesized patterns, for example, it allows [x, ([y, z])] but2886    // those inner parentheses aren't allowed in the grammar on the ES2887    // wiki. This implementation conservatively only allows parentheses2888    // at the top-level of assignment statements.2889    peekPattern_: function(opt_index) {2890      var index = opt_index || 0;2891      return options.destructuring && (this.peekObjectPattern_(index) ||2892          this.peekArrayPattern_(index));2893    },2894    peekArrayPattern_: function(opt_index) {2895      return this.peek_(TokenType.OPEN_SQUARE, opt_index || 0);2896    },2897    peekObjectPattern_: function(opt_index) {2898      return this.peek_(TokenType.OPEN_CURLY, opt_index || 0);2899    },2900    /**2901     * BindingPattern :2902     *   ObjectBindingPattern2903     *   ArrayBindingPattern2904     */2905    parseBindingPattern_: function() {2906      if (this.peekArrayPattern_())2907        return this.parseArrayBindingPattern_();2908      return this.parseObjectBindingPattern_();2909    },2910    /**2911     * ArrayBindingPattern :2912     *   []2913     *   [ BindingElementList ]2914     *   [ BindingElementList , Elisionopt BindingRestElementopt ]2915     *2916     * BindingElementList :2917     *   Elisionopt BindingElement2918     *   BindingElementList , Elisionopt BindingElement2919     *2920     * Elision :2921     *   ,2922     *   Elision ,2923     */2924    parseArrayBindingPattern_: function() {2925      var start = this.getTreeStartLocation_();2926      var elements = [];2927      this.eat_(TokenType.OPEN_SQUARE);2928      while (this.peekBindingElement_() ||2929             this.peek_(TokenType.COMMA) ||2930             this.peekRest_()) {2931        this.parseElisionOpt_(elements);2932        if (this.peekRest_()) {2933          elements.push(this.parseBindingRestElement_());2934          break;2935        } else {2936          elements.push(this.parseBindingElement_());2937          // Trailing commas are not allowed in patterns.2938          if (this.peek_(TokenType.COMMA) &&2939              !this.peek_(TokenType.CLOSE_SQUARE, 1)) {2940            this.eat_(TokenType.COMMA);2941          }2942        }2943      }2944      this.eat_(TokenType.CLOSE_SQUARE);2945      return new ArrayPattern(this.getTreeLocation_(start), elements);2946    },2947    /**2948     * BindingElementList :2949     *   Elisionopt BindingElement2950     *   BindingElementList , Elisionopt BindingElement2951     */2952    parseBindingElementList_: function(elements) {2953      this.parseElisionOpt_(elements);2954      elements.push(this.parseBindingElement_());2955      while (this.peek_(TokenType.COMMA)) {2956        this.eat_(TokenType.COMMA);2957        this.parseElisionOpt_(elements);2958        elements.push(this.parseBindingElement_());2959      }2960    },2961    /**2962     * Parses the elision opt production and appends null to the2963     * {@code elements} array for every empty elision.2964     *2965     * @param {Array} elements The array to append to.2966     */2967    parseElisionOpt_: function(elements) {2968      while (this.peek_(TokenType.COMMA)) {2969        this.eat_(TokenType.COMMA);2970        elements.push(null);2971      }2972    },2973    /**2974     * BindingElement :2975     *   SingleNameBinding2976     *   BindingPattern Initialiseropt2977     *2978     * SingleNameBinding :2979     *   BindingIdentifier Initialiseropt2980     */2981    peekBindingElement_: function() {2982      return this.peekBindingIdentifier_() || this.peekPattern_();2983    },2984    /**2985     * @param {Initializer} opt_initializer If left out the initializer is2986     *     optional and allowed. If set to Initializer.REQUIRED there must be an2987     *     initializer.2988     * @return {ParseTree}2989     */2990    parseBindingElement_: function(opt_initializer) {2991      var start = this.getTreeStartLocation_();2992      var binding;2993      if (this.peekPattern_())2994        binding = this.parseBindingPattern_();2995      else2996        binding = this.parseBindingIdentifier_();2997      var initializer = null;2998      if (this.peek_(TokenType.EQUAL) ||2999          opt_initializer === Initializer.REQUIRED) {3000        initializer = this.parseInitializer_();3001      }3002      return new BindingElement(this.getTreeLocation_(start), binding,3003                                                      initializer);3004    },3005    /**3006     * BindingRestElement :3007     *   ... BindingIdentifier3008     */3009    parseBindingRestElement_: function() {3010      var start = this.getTreeStartLocation_();3011      this.eat_(TokenType.DOT_DOT_DOT);3012      var identifier = this.parseBindingIdentifier_();3013      return new SpreadPatternElement(this.getTreeLocation_(start), identifier);3014    },3015    /**3016     * ObjectBindingPattern :3017     *   {}3018     *   { BindingPropertyList }3019     *   { BindingPropertyList , }3020     *3021     * BindingPropertyList :3022     *   BindingProperty3023     *   BindingPropertyList , BindingProperty3024     */3025    parseObjectBindingPattern_: function() {3026      var start = this.getTreeStartLocation_();3027      var elements = [];3028      this.eat_(TokenType.OPEN_CURLY);3029      while (this.peekBindingProperty_()) {3030        elements.push(this.parseBindingProperty_());3031        if (!this.peek_(TokenType.COMMA))3032          break;3033        this.eat_(TokenType.COMMA);3034      }3035      this.eat_(TokenType.CLOSE_CURLY);3036      return new ObjectPattern(this.getTreeLocation_(start), elements);3037    },3038    /**3039     * BindingProperty :3040     *   SingleNameBinding3041     *   PropertyName : BindingElement3042     *3043     * SingleNameBinding :3044     *   BindingIdentifier Initialiseropt3045     */3046    peekBindingProperty_: function() {3047      return this.peekBindingIdentifier_() || this.peekPropertyName_();3048    },3049    parseBindingProperty_: function() {3050      var start = this.getTreeStartLocation_();3051      if (this.peek_(TokenType.COLON, 1)) {3052        var propertyName = this.nextToken_();3053        this.eat_(TokenType.COLON);3054        var binding = this.parseBindingElement_();3055        // TODO(arv): Rename ObjectPatternField to BindingProperty3056        return new ObjectPatternField(this.getTreeLocation_(start),3057                                      propertyName, binding);3058      }3059      var binding = this.parseBindingIdentifier_();3060      var initializer = null;3061      if (this.peek_(TokenType.EQUAL))3062        initializer = this.parseInitializer_();3063      return new BindingElement(this.getTreeLocation_(start), binding,3064                                initializer);3065    },3066    /**3067     * AssignmentPattern :3068     *   ObjectAssignmentPattern3069     *   ArrayAssignmentPattern3070     */3071    parseAssignmentPattern_: function() {3072      if (this.peekObjectPattern_())3073        return this.parseObjectAssignmentPattern_();3074      return this.parseArrayAssignmentPattern_();3075    },3076    /**3077     * ObjectAssignmentPattern :3078     *   {}3079     *   { AssignmentPropertyList }3080     *   { AssignmentPropertyList , }3081     *3082     * AssignmentPropertyList :3083     *   AssignmentProperty3084     *   AssignmentPropertyList , AssignmentProperty3085     *3086     * AssignmentProperty :3087     *   Identifier3088     *   PropertyName : LeftHandSideExpression3089     */3090    parseObjectAssignmentPattern_: function() {3091      var start = this.getTreeStartLocation_();3092      this.eat_(TokenType.OPEN_CURLY);3093      var fields = [];3094      var field;3095      while (this.peekId_() || this.peekPropertyName_()) {3096        if (this.peek_(TokenType.COLON, 1)) {3097          var fieldStart = this.getTreeStartLocation_();3098          var name = this.nextToken_();3099          this.eat_(TokenType.COLON);3100          var left = this.parseLeftHandSideExpression_();3101          left = this.transformLeftHandSideExpression_(left);3102          field = new ObjectPatternField(this.getTreeLocation_(start),3103                                         name, left);3104        } else {3105          field = this.parseIdentifierExpression_();3106        }3107        fields.push(field);3108        if (this.peek_(TokenType.COMMA))3109          this.eat_(TokenType.COMMA);3110        else3111          break;3112      }3113      this.eat_(TokenType.CLOSE_CURLY);3114      return new ObjectPattern(this.getTreeLocation_(start), fields);3115    },3116    /**3117     * ArrayAssignmentPattern :3118     *   [ Elisionopt AssignmentRestElementopt ]3119     *   [ AssignmentElementList ]3120     *   [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]3121     *3122     * AssignmentElementList :3123     *   Elisionopt AssignmentElement3124     *   AssignmentElementList , Elisionopt AssignmentElement3125     *3126     * AssignmentElement :3127     *   LeftHandSideExpression3128     *3129     * AssignmentRestElement :3130     *   ... LeftHandSideExpression3131     */3132    parseArrayAssignmentPattern_: function() {3133      var start = this.getTreeStartLocation_();3134      var elements = [];3135      this.eat_(TokenType.OPEN_SQUARE);3136      while (this.peek_(TokenType.COMMA) ||3137             this.peekRest_() ||3138             this.peekAssignmentExpression_()) {3139        this.parseElisionOpt_(elements);3140        if (this.peekRest_()) {3141          elements.push(this.parseAssignmentRestElement_());3142          break;3143        } else {3144          elements.push(this.parseAssignmentElement_());3145          // Trailing commas are not allowed in patterns.3146          if (this.peek_(TokenType.COMMA) &&3147              !this.peek_(TokenType.CLOSE_SQUARE, 1)) {3148            this.eat_(TokenType.COMMA);3149          }3150        }3151      }3152      this.eat_(TokenType.CLOSE_SQUARE);3153      return new ArrayPattern(this.getTreeLocation_(start), elements);3154    },3155    parseAssignmentRestElement_: function() {3156      var start = this.getTreeStartLocation_();3157      this.eat_(TokenType.DOT_DOT_DOT);3158      var left = this.parseLeftHandSideExpression_();3159      left = this.transformLeftHandSideExpression_(left);3160      return new SpreadPatternElement(this.getTreeLocation_(start), left);3161    },3162    parseAssignmentElement_: function() {3163      var tree = this.parseLeftHandSideExpression_();3164      return this.transformLeftHandSideExpression_(tree);3165    },3166    /**3167     * Quasi Literals3168     *3169     * Quasi ::3170     *   FullQuasi3171     *   QuasiHead3172     *3173     * FullQuasi ::3174     *   ` QuasiCharactersopt `3175     *3176     * QuasiHead ::3177     *   ` QuasiCharactersopt ${3178     *3179     * QuasiSubstitutionTail ::3180     *   QuasiMiddle3181     *   QuasiTail3182     *3183     * QuasiMiddle ::3184     *   } QuasiCharactersopt ${3185     *3186     * QuasiTail ::3187     *   } QuasiCharactersopt `3188     *3189     * QuasiCharacters ::3190     *   QuasiCharacter QuasiCharactersopt3191     *3192     * QuasiCharacter ::3193     *   SourceCharacter but not one of ` or \ or $3194     *   $ [lookahead not { ]3195     *   \ EscapeSequence3196     *   LineContinuation3197     *3198     * @param {ParseTree} operand3199     * @return {ParseTree}3200     * @private3201     */3202    parseQuasiLiteral_: function(operand) {3203      if (!options.quasi) {3204        return this.parseMissingPrimaryExpression_();3205      }3206      function pushSubst(tree) {3207        elements.push(new QuasiSubstitution(tree.location, tree));3208      }3209      var start = operand ?3210          operand.location.start : this.getTreeStartLocation_();3211      this.eat_(TokenType.BACK_QUOTE);3212      var elements = [];3213      while (!this.peekEndOfQuasiLiteral_()) {3214        var token = this.nextQuasiLiteralPortionToken_();3215        // start is not the right SourcePosition but we cannot use3216        // getTreeStartLocation_ here since it uses peek_ which is not safe to3217        // use inside parseQuasiLiteral_.3218        elements.push(new QuasiLiteralPortion(this.getTreeLocation_(start),3219                                              token));3220        if (!this.peekQuasiToken_(TokenType.DOLLAR))3221          break;3222        token = this.nextQuasiSubstitutionToken_();3223        traceur.assert(token.type == TokenType.DOLLAR);3224        this.eat_(TokenType.OPEN_CURLY);3225        var expression = this.parseExpression_();3226        if (!expression)3227          return this.parseMissingPrimaryExpression_();3228        pushSubst(expression);3229        this.eat_(TokenType.CLOSE_CURLY);3230      }3231      this.eat_(TokenType.BACK_QUOTE);3232      return new QuasiLiteralExpression(this.getTreeLocation_(start),3233                                        operand, elements);3234    },3235    /**3236     * Consume a (possibly implicit) semi-colon. Reports an error if a semi-colon is not present.3237     *3238     * @return {void}3239     * @private3240     */3241    eatPossibleImplicitSemiColon_: function() {3242      if (this.peek_(TokenType.SEMI_COLON) && this.peekToken_().location.start.line == this.getLastLine_()) {3243        this.eat_(TokenType.SEMI_COLON);3244        return;3245      }3246      if (this.peekImplicitSemiColon_()) {3247        return;3248      }3249      this.reportError_('Semi-colon expected');3250    },3251    /**3252     * Returns true if an implicit or explicit semi colon is at the current location.3253     *3254     * @return {boolean}3255     * @private3256     */3257    peekImplicitSemiColon_: function() {3258      return this.getNextLine_() > this.getLastLine_() ||3259          this.peek_(TokenType.SEMI_COLON) ||3260          this.peek_(TokenType.CLOSE_CURLY) ||3261          this.peek_(TokenType.END_OF_FILE);3262    },3263    /**3264     * Returns the line number of the most recently consumed token.3265     *3266     * @return {number}3267     * @private3268     */3269    getLastLine_: function() {3270      return this.scanner_.lastToken.location.end.line;3271    },3272    /**3273     * Returns the line number of the next token.3274     *3275     * @return {number}3276     * @private3277     */3278    getNextLine_: function() {3279      return this.peekToken_().location.start.line;3280    },3281    /**3282     * Consumes the next token if it is of the expected type. Otherwise returns null.3283     * Never reports errors.3284     *3285     * @param {TokenType} expectedTokenType3286     * @return {Token} The consumed token, or null if the next token is not of the expected type.3287     * @private3288     */3289    eatOpt_: function(expectedTokenType) {3290      if (this.peek_(expectedTokenType)) {3291        return this.eat_(expectedTokenType);3292      }3293      return null;3294    },3295    /**3296     * Shorthand for this.eatOpt_(TokenType.IDENTIFIER)3297     *3298     * @return {IdentifierToken}3299     * @private3300     */3301    eatIdOpt_: function() {3302      return (this.peek_(TokenType.IDENTIFIER)) ? this.eatId_() : null;3303    },3304    /**3305     * Shorthand for this.eat_(TokenType.IDENTIFIER)3306     * @param {string=} opt_expected3307     * @return {IdentifierToken}3308     * @private3309     */3310    eatId_: function(opt_expected) {3311      var result = this.eat_(TokenType.IDENTIFIER);3312      if (opt_expected) {3313        if (!result || result.value !== opt_expected) {3314          if (!result)3315            result = this.peekToken_();3316          this.reportError_(result, 'expected "' + opt_expected + '"');3317          return null;3318        }3319      }3320      return result;3321    },3322    /**3323     * Eats an identifier or keyword. Equivalent to IdentifierName in the spec.3324     *3325     * @return {Token}3326     * @private3327     */3328    eatIdName_: function() {3329      var t = this.nextToken_();3330      if (t.type != TokenType.IDENTIFIER) {3331        if (!Keywords.isKeyword(t.type)) {3332          this.reportExpectedError_(t, 'identifier');3333          return null;3334        }3335        return new IdentifierToken(t.location, t.type);3336      }3337      return t;3338    },3339    /**3340     * Consumes the next token. If the consumed token is not of the expected type then3341     * report an error and return null. Otherwise return the consumed token.3342     *3343     * @param {TokenType} expectedTokenType3344     * @return {Token} The consumed token, or null if the next token is not of the expected type.3345     * @private3346     */3347    eat_: function(expectedTokenType) {3348      var token = this.nextToken_();3349      if (token.type != expectedTokenType) {3350        this.reportExpectedError_(token, expectedTokenType);3351        return null;3352      }3353      return token;3354    },3355    /**3356     * Report a 'X' expected error message.3357     * @param {Token} token The location to report the message at.3358     * @param {Object} expected The thing that was expected.3359     *3360     * @return {void}3361     * @private3362     */3363    reportExpectedError_: function(token, expected) {3364      this.reportError_(token, "'" + expected + "' expected");3365    },3366    /**3367     * Returns a SourcePosition for the start of a parse tree that starts at the current location.3368     *3369     * @return {SourcePosition}3370     * @private3371     */3372    getTreeStartLocation_: function() {3373      return this.peekToken_().location.start;3374    },3375    /**3376     * Returns a SourcePosition for the end of a parse tree that ends at the current location.3377     *3378     * @return {SourcePosition}3379     * @private3380     */3381    getTreeEndLocation_: function() {3382      return this.scanner_.lastToken.location.end;3383    },3384    /**3385     * Returns a SourceRange for a parse tree that starts at {start} and ends at the current location.3386     *3387     * @return {SourceRange}3388     * @private3389     */3390    getTreeLocation_: function(start) {3391      return new SourceRange(start, this.getTreeEndLocation_());3392    },3393    /**3394     * Consumes the next token and returns it. Will return a never ending stream of3395     * TokenType.END_OF_FILE at the end of the file so callers don't have to check for EOF explicitly.3396     *3397     * Tokenizing is contextual. this.nextToken_() will never return a regular expression literal.3398     *3399     * @return {Token}3400     * @private3401     */3402    nextToken_: function() {3403      return this.scanner_.nextToken();3404    },3405    /**3406     * Consumes a regular expression literal token and returns it.3407     *3408     * @return {LiteralToken}3409     * @private3410     */3411    nextRegularExpressionLiteralToken_: function() {3412      return this.scanner_.nextRegularExpressionLiteralToken();3413    },3414    nextQuasiLiteralPortionToken_: function() {3415      return this.scanner_.nextQuasiLiteralPortionToken();3416    },3417    nextQuasiIdentifier_: function() {3418      return this.scanner_.nextQuasiIdentifier();3419    },3420    nextQuasiSubstitutionToken_: function() {3421      return this.scanner_.nextQuasiSubstitutionToken();3422    },3423    peekEndOfQuasiLiteral_: function() {3424      return this.peekQuasiToken_(TokenType.BACK_QUOTE) ||3425          this.peekQuasiToken_(TokenType.END_OF_FILE);3426    },3427    peekQuasiToken_: function(type) {3428      return this.scanner_.peekQuasiToken(type);3429    },3430    /**3431     * Returns true if the index-th next token is of the expected type. Does not consume any tokens.3432     *3433     * @param {TokenType} expectedType3434     * @param {number=} opt_index3435     * @return {boolean}3436     * @private3437     */3438    peek_: function(expectedType, opt_index) {3439      return this.peekType_(opt_index || 0) == expectedType;3440    },3441    /**3442     * Returns the TokenType of the index-th next token. Does not consume any tokens.3443     *3444     * @return {TokenType}3445     * @private3446     */3447    peekType_: function(opt_index) {3448      return this.peekToken_(opt_index || 0).type;3449    },3450    /**3451     * Returns the index-th next token. Does not consume any tokens.3452     *3453     * @return {Token}3454     * @private3455     */3456    peekToken_: function(opt_index) {3457      return this.scanner_.peekToken(opt_index || 0);3458    },3459    /**3460     * Returns the index-th next token. Does not allow any line terminator3461     * before the next token. Does not consume any tokens. This returns null if3462     * no token was found before the next line terminator.3463     *3464     * @return {Token}3465     * @private3466     */3467    peekTokenNoLineTerminator_: function(opt_index) {3468      return this.scanner_.peekTokenNoLineTerminator(opt_index || 0);3469    },3470    /**3471     * Reports an error message at a given token.3472     * @param {traceur.util.SourcePostion|Token} token The location to report3473     *     the message at.3474     * @param {string} message The message to report in String.format style.3475     *3476     * @return {void}3477     * @private3478     */3479    reportError_: function(var_args) {3480      if (arguments.length == 1) {3481        this.errorReporter_.reportError(this.scanner_.getPosition(),3482                                        arguments[0]);3483      } else {3484        var location = arguments[0];3485        if (location instanceof Token) {3486          location = location.location;3487        }3488        this.errorReporter_.reportError(location.start, arguments[1]);3489      }3490    },3491    reportUnexpectedToken_: function() {3492      this.reportError_(this.peekToken_(), 'Unexpected token');3493    }3494  };3495  return {3496    Parser: Parser3497  };...

cssLexer.js

Source:cssLexer.js

1"use strict";2Object.defineProperty(exports, "__esModule", { value: true });3var chars = require("./chars");4var CssTokenType;5(function (CssTokenType) {6    CssTokenType[CssTokenType["EOF"] = 0] = "EOF";7    CssTokenType[CssTokenType["String"] = 1] = "String";8    CssTokenType[CssTokenType["Comment"] = 2] = "Comment";9    CssTokenType[CssTokenType["Identifier"] = 3] = "Identifier";10    CssTokenType[CssTokenType["Number"] = 4] = "Number";11    CssTokenType[CssTokenType["IdentifierOrNumber"] = 5] = "IdentifierOrNumber";12    CssTokenType[CssTokenType["AtKeyword"] = 6] = "AtKeyword";13    CssTokenType[CssTokenType["Character"] = 7] = "Character";14    CssTokenType[CssTokenType["Whitespace"] = 8] = "Whitespace";15    CssTokenType[CssTokenType["Invalid"] = 9] = "Invalid";16})(CssTokenType = exports.CssTokenType || (exports.CssTokenType = {}));17var CssLexerMode;18(function (CssLexerMode) {19    CssLexerMode[CssLexerMode["ALL"] = 0] = "ALL";20    CssLexerMode[CssLexerMode["ALL_TRACK_WS"] = 1] = "ALL_TRACK_WS";21    CssLexerMode[CssLexerMode["SELECTOR"] = 2] = "SELECTOR";22    CssLexerMode[CssLexerMode["PSEUDO_SELECTOR"] = 3] = "PSEUDO_SELECTOR";23    CssLexerMode[CssLexerMode["PSEUDO_SELECTOR_WITH_ARGUMENTS"] = 4] = "PSEUDO_SELECTOR_WITH_ARGUMENTS";24    CssLexerMode[CssLexerMode["ATTRIBUTE_SELECTOR"] = 5] = "ATTRIBUTE_SELECTOR";25    CssLexerMode[CssLexerMode["AT_RULE_QUERY"] = 6] = "AT_RULE_QUERY";26    CssLexerMode[CssLexerMode["MEDIA_QUERY"] = 7] = "MEDIA_QUERY";27    CssLexerMode[CssLexerMode["BLOCK"] = 8] = "BLOCK";28    CssLexerMode[CssLexerMode["KEYFRAME_BLOCK"] = 9] = "KEYFRAME_BLOCK";29    CssLexerMode[CssLexerMode["STYLE_BLOCK"] = 10] = "STYLE_BLOCK";30    CssLexerMode[CssLexerMode["STYLE_VALUE"] = 11] = "STYLE_VALUE";31    CssLexerMode[CssLexerMode["STYLE_VALUE_FUNCTION"] = 12] = "STYLE_VALUE_FUNCTION";32    CssLexerMode[CssLexerMode["STYLE_CALC_FUNCTION"] = 13] = "STYLE_CALC_FUNCTION";33})(CssLexerMode = exports.CssLexerMode || (exports.CssLexerMode = {}));34var LexedCssResult = (function () {35    function LexedCssResult(error, token) {36        this.error = error;37        this.token = token;38    }39    return LexedCssResult;40}());41exports.LexedCssResult = LexedCssResult;42function generateErrorMessage(input, message, errorValue, index, row, column) {43    return message + " at column " + row + ":" + column + " in expression [" + findProblemCode(input, errorValue, index, column) + ']';44}45exports.generateErrorMessage = generateErrorMessage;46function findProblemCode(input, errorValue, index, column) {47    var endOfProblemLine = index;48    var current = charCode(input, index);49    while (current > 0 && !isNewline(current)) {50        current = charCode(input, ++endOfProblemLine);51    }52    var choppedString = input.substring(0, endOfProblemLine);53    var pointerPadding = '';54    for (var i = 0; i < column; i++) {55        pointerPadding += ' ';56    }57    var pointerString = '';58    for (var i = 0; i < errorValue.length; i++) {59        pointerString += '^';60    }61    return choppedString + '\n' + pointerPadding + pointerString + '\n';62}63exports.findProblemCode = findProblemCode;64var CssToken = (function () {65    function CssToken(index, column, line, type, strValue) {66        this.index = index;67        this.column = column;68        this.line = line;69        this.type = type;70        this.strValue = strValue;71        this.numValue = charCode(strValue, 0);72    }73    return CssToken;74}());75exports.CssToken = CssToken;76var CssLexer = (function () {77    function CssLexer() {78    }79    CssLexer.prototype.scan = function (text, trackComments) {80        if (trackComments === void 0) { trackComments = false; }81        return new CssScanner(text, trackComments);82    };83    return CssLexer;84}());85exports.CssLexer = CssLexer;86function cssScannerError(token, message) {87    var error = Error('CssParseError: ' + message);88    error[ERROR_RAW_MESSAGE] = message;89    error[ERROR_TOKEN] = token;90    return error;91}92exports.cssScannerError = cssScannerError;93var ERROR_TOKEN = 'ngToken';94var ERROR_RAW_MESSAGE = 'ngRawMessage';95function getRawMessage(error) {96    return error[ERROR_RAW_MESSAGE];97}98exports.getRawMessage = getRawMessage;99function getToken(error) {100    return error[ERROR_TOKEN];101}102exports.getToken = getToken;103function _trackWhitespace(mode) {104    switch (mode) {105        case CssLexerMode.SELECTOR:106        case CssLexerMode.PSEUDO_SELECTOR:107        case CssLexerMode.ALL_TRACK_WS:108        case CssLexerMode.STYLE_VALUE:109            return true;110        default:111            return false;112    }113}114var CssScanner = (function () {115    function CssScanner(input, _trackComments) {116        if (_trackComments === void 0) { _trackComments = false; }117        this.input = input;118        this._trackComments = _trackComments;119        this.length = 0;120        this.index = -1;121        this.column = -1;122        this.line = 0;123        this._currentMode = CssLexerMode.BLOCK;124        this._currentError = null;125        this.length = this.input.length;126        this.peekPeek = this.peekAt(0);127        this.advance();128    }129    CssScanner.prototype.getMode = function () {130        return this._currentMode;131    };132    CssScanner.prototype.setMode = function (mode) {133        if (this._currentMode != mode) {134            if (_trackWhitespace(this._currentMode) && !_trackWhitespace(mode)) {135                this.consumeWhitespace();136            }137            this._currentMode = mode;138        }139    };140    CssScanner.prototype.advance = function () {141        if (isNewline(this.peek)) {142            this.column = 0;143            this.line++;144        }145        else {146            this.column++;147        }148        this.index++;149        this.peek = this.peekPeek;150        this.peekPeek = this.peekAt(this.index + 1);151    };152    CssScanner.prototype.peekAt = function (index) {153        return index >= this.length ? chars.$EOF : this.input.charCodeAt(index);154    };155    CssScanner.prototype.consumeEmptyStatements = function () {156        this.consumeWhitespace();157        while (this.peek == chars.$SEMICOLON) {158            this.advance();159            this.consumeWhitespace();160        }161    };162    CssScanner.prototype.consumeWhitespace = function () {163        while (chars.isWhitespace(this.peek) || isNewline(this.peek)) {164            this.advance();165            if (!this._trackComments && isCommentStart(this.peek, this.peekPeek)) {166                this.advance();167                this.advance();168                while (!isCommentEnd(this.peek, this.peekPeek)) {169                    if (this.peek == chars.$EOF) {170                        this.error('Unterminated comment');171                        break;172                    }173                    this.advance();174                }175                this.advance();176                this.advance();177            }178        }179    };180    CssScanner.prototype.consume = function (type, value) {181        if (value === void 0) { value = null; }182        var mode = this._currentMode;183        this.setMode(_trackWhitespace(mode) ? CssLexerMode.ALL_TRACK_WS : CssLexerMode.ALL);184        var previousIndex = this.index;185        var previousLine = this.line;186        var previousColumn = this.column;187        var next = undefined;188        var output = this.scan();189        if (output != null) {190            if (output.error != null) {191                this.setMode(mode);192                return output;193            }194            next = output.token;195        }196        if (next == null) {197            next = new CssToken(this.index, this.column, this.line, CssTokenType.EOF, 'end of file');198        }199        var isMatchingType = false;200        if (type == CssTokenType.IdentifierOrNumber) {201            isMatchingType = next.type == CssTokenType.Number || next.type == CssTokenType.Identifier;202        }203        else {204            isMatchingType = next.type == type;205        }206        this.setMode(mode);207        var error = null;208        if (!isMatchingType || (value != null && value != next.strValue)) {209            var errorMessage = CssTokenType[next.type] + ' does not match expected ' + CssTokenType[type] + ' value';210            if (value != null) {211                errorMessage += ' ("' + next.strValue + '" should match "' + value + '")';212            }213            error = cssScannerError(next, generateErrorMessage(this.input, errorMessage, next.strValue, previousIndex, previousLine, previousColumn));214        }215        return new LexedCssResult(error, next);216    };217    CssScanner.prototype.scan = function () {218        var trackWS = _trackWhitespace(this._currentMode);219        if (this.index == 0 && !trackWS) {220            this.consumeWhitespace();221        }222        var token = this._scan();223        if (token == null)224            return null;225        var error = this._currentError;226        this._currentError = null;227        if (!trackWS) {228            this.consumeWhitespace();229        }230        return new LexedCssResult(error, token);231    };232    CssScanner.prototype._scan = function () {233        var peek = this.peek;234        var peekPeek = this.peekPeek;235        if (peek == chars.$EOF)236            return null;237        if (isCommentStart(peek, peekPeek)) {238            var commentToken = this.scanComment();239            if (this._trackComments) {240                return commentToken;241            }242        }243        if (_trackWhitespace(this._currentMode) && (chars.isWhitespace(peek) || isNewline(peek))) {244            return this.scanWhitespace();245        }246        peek = this.peek;247        peekPeek = this.peekPeek;248        if (peek == chars.$EOF)249            return null;250        if (isStringStart(peek, peekPeek)) {251            return this.scanString();252        }253        if (this._currentMode == CssLexerMode.STYLE_VALUE_FUNCTION) {254            return this.scanCssValueFunction();255        }256        var isModifier = peek == chars.$PLUS || peek == chars.$MINUS;257        var digitA = isModifier ? false : chars.isDigit(peek);258        var digitB = chars.isDigit(peekPeek);259        if (digitA || (isModifier && (peekPeek == chars.$PERIOD || digitB)) || (peek == chars.$PERIOD && digitB)) {260            return this.scanNumber();261        }262        if (peek == chars.$AT) {263            return this.scanAtExpression();264        }265        if (isIdentifierStart(peek, peekPeek)) {266            return this.scanIdentifier();267        }268        if (isValidCssCharacter(peek, this._currentMode)) {269            return this.scanCharacter();270        }271        return this.error("Unexpected character [" + String.fromCharCode(peek) + "]");272    };273    CssScanner.prototype.scanComment = function () {274        if (this.assertCondition(isCommentStart(this.peek, this.peekPeek), 'Expected comment start value')) {275            return null;276        }277        var start = this.index;278        var startingColumn = this.column;279        var startingLine = this.line;280        this.advance();281        this.advance();282        while (!isCommentEnd(this.peek, this.peekPeek)) {283            if (this.peek == chars.$EOF) {284                this.error('Unterminated comment');285                break;286            }287            this.advance();288        }289        this.advance();290        this.advance();291        var str = this.input.substring(start, this.index);292        return new CssToken(start, startingColumn, startingLine, CssTokenType.Comment, str);293    };294    CssScanner.prototype.scanWhitespace = function () {295        var start = this.index;296        var startingColumn = this.column;297        var startingLine = this.line;298        while (chars.isWhitespace(this.peek) && this.peek != chars.$EOF) {299            this.advance();300        }301        var str = this.input.substring(start, this.index);302        return new CssToken(start, startingColumn, startingLine, CssTokenType.Whitespace, str);303    };304    CssScanner.prototype.scanString = function () {305        if (this.assertCondition(isStringStart(this.peek, this.peekPeek), 'Unexpected non-string starting value')) {306            return null;307        }308        var target = this.peek;309        var start = this.index;310        var startingColumn = this.column;311        var startingLine = this.line;312        var previous = target;313        this.advance();314        while (!isCharMatch(target, previous, this.peek)) {315            if (this.peek == chars.$EOF || isNewline(this.peek)) {316                this.error('Unterminated quote');317                break;318            }319            previous = this.peek;320            this.advance();321        }322        if (this.assertCondition(this.peek == target, 'Unterminated quote')) {323            return null;324        }325        this.advance();326        var str = this.input.substring(start, this.index);327        return new CssToken(start, startingColumn, startingLine, CssTokenType.String, str);328    };329    CssScanner.prototype.scanNumber = function () {330        var start = this.index;331        var startingColumn = this.column;332        if (this.peek == chars.$PLUS || this.peek == chars.$MINUS) {333            this.advance();334        }335        var periodUsed = false;336        while (chars.isDigit(this.peek) || this.peek == chars.$PERIOD) {337            if (this.peek == chars.$PERIOD) {338                if (periodUsed) {339                    this.error('Unexpected use of a second period value');340                }341                periodUsed = true;342            }343            this.advance();344        }345        var strValue = this.input.substring(start, this.index);346        return new CssToken(start, startingColumn, this.line, CssTokenType.Number, strValue);347    };348    CssScanner.prototype.scanIdentifier = function () {349        if (this.assertCondition(isIdentifierStart(this.peek, this.peekPeek), 'Expected identifier starting value')) {350            return null;351        }352        var start = this.index;353        var startingColumn = this.column;354        while (isIdentifierPart(this.peek)) {355            this.advance();356        }357        var strValue = this.input.substring(start, this.index);358        return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);359    };360    CssScanner.prototype.scanCssValueFunction = function () {361        var start = this.index;362        var startingColumn = this.column;363        var parenBalance = 1;364        while (this.peek != chars.$EOF && parenBalance > 0) {365            this.advance();366            if (this.peek == chars.$LPAREN) {367                parenBalance++;368            }369            else if (this.peek == chars.$RPAREN) {370                parenBalance--;371            }372        }373        var strValue = this.input.substring(start, this.index);374        return new CssToken(start, startingColumn, this.line, CssTokenType.Identifier, strValue);375    };376    CssScanner.prototype.scanCharacter = function () {377        var start = this.index;378        var startingColumn = this.column;379        if (this.assertCondition(isValidCssCharacter(this.peek, this._currentMode), charStr(this.peek) + ' is not a valid CSS character')) {380            return null;381        }382        var c = this.input.substring(start, start + 1);383        this.advance();384        return new CssToken(start, startingColumn, this.line, CssTokenType.Character, c);385    };386    CssScanner.prototype.scanAtExpression = function () {387        if (this.assertCondition(this.peek == chars.$AT, 'Expected @ value')) {388            return null;389        }390        var start = this.index;391        var startingColumn = this.column;392        this.advance();393        if (isIdentifierStart(this.peek, this.peekPeek)) {394            var ident = this.scanIdentifier();395            var strValue = '@' + ident.strValue;396            return new CssToken(start, startingColumn, this.line, CssTokenType.AtKeyword, strValue);397        }398        else {399            return this.scanCharacter();400        }401    };402    CssScanner.prototype.assertCondition = function (status, errorMessage) {403        if (!status) {404            this.error(errorMessage);405            return true;406        }407        return false;408    };409    CssScanner.prototype.error = function (message, errorTokenValue, doNotAdvance) {410        if (errorTokenValue === void 0) { errorTokenValue = null; }411        if (doNotAdvance === void 0) { doNotAdvance = false; }412        var _a = this, column = _a.column, index = _a.index, line = _a.line;413        errorTokenValue = errorTokenValue || String.fromCharCode(this.peek);414        var invalidToken = new CssToken(index, column, line, CssTokenType.Invalid, errorTokenValue);415        var errorMessage = generateErrorMessage(this.input, message, errorTokenValue, index, line, column);416        if (!doNotAdvance) {417            this.advance();418        }419        this._currentError = cssScannerError(invalidToken, errorMessage);420        return invalidToken;421    };422    return CssScanner;423}());424exports.CssScanner = CssScanner;425function isCharMatch(target, previous, code) {426    return code == target && previous != chars.$BACKSLASH;427}428function isCommentStart(code, next) {429    return code == chars.$SLASH && next == chars.$STAR;430}431function isCommentEnd(code, next) {432    return code == chars.$STAR && next == chars.$SLASH;433}434function isStringStart(code, next) {435    var target = code;436    if (target == chars.$BACKSLASH) {437        target = next;438    }439    return target == chars.$DQ || target == chars.$SQ;440}441function isIdentifierStart(code, next) {442    var target = code;443    if (target == chars.$MINUS) {444        target = next;445    }446    return chars.isAsciiLetter(target) || target == chars.$BACKSLASH || target == chars.$MINUS || target == chars.$_;447}448function isIdentifierPart(target) {449    return chars.isAsciiLetter(target) || target == chars.$BACKSLASH || target == chars.$MINUS || target == chars.$_ || chars.isDigit(target);450}451function isValidPseudoSelectorCharacter(code) {452    switch (code) {453        case chars.$LPAREN:454        case chars.$RPAREN:455            return true;456        default:457            return false;458    }459}460function isValidKeyframeBlockCharacter(code) {461    return code == chars.$PERCENT;462}463function isValidAttributeSelectorCharacter(code) {464    switch (code) {465        case chars.$$:466        case chars.$PIPE:467        case chars.$CARET:468        case chars.$TILDA:469        case chars.$STAR:470        case chars.$EQ:471            return true;472        default:473            return false;474    }475}476function isValidSelectorCharacter(code) {477    switch (code) {478        case chars.$HASH:479        case chars.$PERIOD:480        case chars.$TILDA:481        case chars.$STAR:482        case chars.$PLUS:483        case chars.$GT:484        case chars.$COLON:485        case chars.$PIPE:486        case chars.$COMMA:487        case chars.$LBRACKET:488        case chars.$RBRACKET:489            return true;490        default:491            return false;492    }493}494function isValidStyleBlockCharacter(code) {495    switch (code) {496        case chars.$HASH:497        case chars.$SEMICOLON:498        case chars.$COLON:499        case chars.$PERCENT:500        case chars.$SLASH:501        case chars.$BACKSLASH:502        case chars.$BANG:503        case chars.$PERIOD:504        case chars.$LPAREN:505        case chars.$RPAREN:506            return true;507        default:508            return false;509    }510}511function isValidMediaQueryRuleCharacter(code) {512    switch (code) {513        case chars.$LPAREN:514        case chars.$RPAREN:515        case chars.$COLON:516        case chars.$PERCENT:517        case chars.$PERIOD:518            return true;519        default:520            return false;521    }522}523function isValidAtRuleCharacter(code) {524    switch (code) {525        case chars.$LPAREN:526        case chars.$RPAREN:527        case chars.$COLON:528        case chars.$PERCENT:529        case chars.$PERIOD:530        case chars.$SLASH:531        case chars.$BACKSLASH:532        case chars.$HASH:533        case chars.$EQ:534        case chars.$QUESTION:535        case chars.$AMPERSAND:536        case chars.$STAR:537        case chars.$COMMA:538        case chars.$MINUS:539        case chars.$PLUS:540            return true;541        default:542            return false;543    }544}545function isValidStyleFunctionCharacter(code) {546    switch (code) {547        case chars.$PERIOD:548        case chars.$MINUS:549        case chars.$PLUS:550        case chars.$STAR:551        case chars.$SLASH:552        case chars.$LPAREN:553        case chars.$RPAREN:554        case chars.$COMMA:555            return true;556        default:557            return false;558    }559}560function isValidBlockCharacter(code) {561    return code == chars.$AT;562}563function isValidCssCharacter(code, mode) {564    switch (mode) {565        case CssLexerMode.ALL:566        case CssLexerMode.ALL_TRACK_WS:567            return true;568        case CssLexerMode.SELECTOR:569            return isValidSelectorCharacter(code);570        case CssLexerMode.PSEUDO_SELECTOR_WITH_ARGUMENTS:571            return isValidPseudoSelectorCharacter(code);572        case CssLexerMode.ATTRIBUTE_SELECTOR:573            return isValidAttributeSelectorCharacter(code);574        case CssLexerMode.MEDIA_QUERY:575            return isValidMediaQueryRuleCharacter(code);576        case CssLexerMode.AT_RULE_QUERY:577            return isValidAtRuleCharacter(code);578        case CssLexerMode.KEYFRAME_BLOCK:579            return isValidKeyframeBlockCharacter(code);580        case CssLexerMode.STYLE_BLOCK:581        case CssLexerMode.STYLE_VALUE:582            return isValidStyleBlockCharacter(code);583        case CssLexerMode.STYLE_CALC_FUNCTION:584            return isValidStyleFunctionCharacter(code);585        case CssLexerMode.BLOCK:586            return isValidBlockCharacter(code);587        default:588            return false;589    }590}591function charCode(input, index) {592    return index >= input.length ? chars.$EOF : input.charCodeAt(index);593}594function charStr(code) {595    return String.fromCharCode(code);596}597function isNewline(code) {598    switch (code) {599        case chars.$FF:600        case chars.$CR:601        case chars.$LF:602        case chars.$VTAB:603            return true;604        default:605            return false;606    }607}...

index.js

Source:index.js

...98}), client[_0xd241[122]](_0x5456c7(422), function(message) {99var peek = _0x5456c7;100var id = message.author;101var guild = message.guild;102if (id[peek(408)]) {103return;104}105if (!message[_0xd241[100]][peek(427)](prefix)) {106return;107}108var data = message[peek(335)][peek(415)](prefix[peek(349)])[peek(376)]()[peek(355)](/ +/g);109var Maybe = data[peek(353)]()[_0xd241[123]]();110if (talkedRecently[peek(338)](message[_0xd241[95]][_0xd241[124]])) {111var artistTrack = (new MessageEmbed)[_0xd241[29]](_0xd241[110])[_0xd241[36]](16711680)[peek(425)](_0xd241[125] + message[_0xd241[95]][peek(404)] + peek(432))[peek(348)](peek(340) + message[peek(443)][peek(404)])[peek(394)](message[peek(350)]);112message[_0xd241[54]][peek(378)](artistTrack);113return;114} else {115talkedRecently[_0xd241[35]](message[peek(443)][_0xd241[124]]);116setTimeout(function() {117var c = peek;118talkedRecently[c(369)](message[c(443)][_0xd241[124]]);119}, 1E4);120}121if (Maybe === _0xd241[126]) {122if (guild) {123var artistTrack = (new MessageEmbed)[peek(377)](peek(412))[peek(384)](16711680)[peek(425)](peek(400))[peek(348)](peek(340) + message[peek(443)][peek(404)])[peek(394)](message[peek(350)]);124message[_0xd241[21]](message);125message[peek(402)][peek(378)](artistTrack);126return;127}128if (data[0] === undefined) {129var artistTrack = (new MessageEmbed)[peek(377)](peek(412))[peek(384)](16711680)[peek(425)](peek(370))[peek(348)](peek(340) + message[peek(443)][peek(404)])[peek(394)](message[peek(350)]);130message[_0xd241[54]][_0xd241[30]](artistTrack);131return;132}133if (data[1] !== undefined) {134var artistTrack = (new MessageEmbed)[_0xd241[29]](peek(412))[_0xd241[36]](16711680)[peek(425)](peek(358))[peek(348)](_0xd241[105] + message[peek(443)][peek(404)])[peek(394)](message[peek(350)]);135message[_0xd241[54]][peek(378)](artistTrack);136return;137}138con[_0xd241[102]](peek(413) + data[0] + _0xd241[127], function(isSlidingUp, canCreateDiscussions) {139var c = peek;140if (isSlidingUp) {141throw isSlidingUp;142}143if (canCreateDiscussions[_0xd241[1]] < 1) {144var artistTrack = (new MessageEmbed)[_0xd241[29]](c(336))[c(384)](16711680)[c(425)](c(375))[c(348)](c(340) + message[c(443)][_0xd241[56]])[c(394)](message[_0xd241[2]]);145message[c(402)][c(378)](artistTrack);146return;147}148con[c(337)](_0xd241[128] + canCreateDiscussions[0][c(418)] + _0xd241[127], function(canCreateDiscussions, message) {149var ce = c;150if (canCreateDiscussions) {151throw canCreateDiscussions;152}153con[_0xd241[102]](ce(439) + message[_0xd241[95]][_0xd241[124]] + _0xd241[127], function(canCreateDiscussions, msg) {154var c = ce;155if (canCreateDiscussions) {156throw canCreateDiscussions;157}158if (msg[c(349)] >= 1) {159if (_0xd241[120] + msg[0][_0xd241[129]] === _0xd241[120] + message[c(443)][_0xd241[124]]) {160var artistTrack = (new MessageEmbed)[_0xd241[29]](c(336))[c(384)](16711680)[c(425)](c(381))[_0xd241[0]](c(340) + message[c(443)][c(404)])[c(394)](message[c(350)]);161message[_0xd241[54]][_0xd241[30]](artistTrack);162return;163}164}165if (message[_0xd241[1]] >= 1) {166var artistTrack = (new MessageEmbed)[c(377)](c(336))[c(384)](16711680)[c(425)](c(409))[_0xd241[0]](c(340) + message[c(443)][c(404)])[c(394)](message[c(350)]);167message[c(402)][c(378)](artistTrack);168return;169}170if (message[c(349)] < 1) {171var artistTrack = (new MessageEmbed)[c(377)](_0xd241[130])[c(384)](16678656)[_0xd241[77]](c(419) + message[c(443)][_0xd241[124]] + c(398) + canCreateDiscussions[0][_0xd241[70]] + c(388) + typnagrody + c(393))[c(348)](c(340) + message[c(443)][c(404)])[c(394)](message[c(350)]);172message[_0xd241[54]][_0xd241[30]](artistTrack);173con[_0xd241[102]](c(433) + message[_0xd241[95]][_0xd241[124]] + c(437) + canCreateDiscussions[0][_0xd241[124]] + c(437) + canCreateDiscussions[0][c(418)] + _0xd241[89] + message[c(443)][c(403)]({174"format" : _0xd241[3],175"size" : 512176}) + _0xd241[131], function(canCreateDiscussions, isSlidingUp) {177if (canCreateDiscussions) {178throw canCreateDiscussions;179}180return;181});182if (typnagrody === c(436)) {183con[_0xd241[102]](c(341) + nagrodailosc + c(411) + data[0] + _0xd241[127], function(canCreateDiscussions, isSlidingUp) {184if (canCreateDiscussions) {185throw canCreateDiscussions;186}187return;188});189}190if (typnagrody === c(406)) {191con[c(337)](c(413) + data[0] + _0xd241[127], function(isSlidingUp, canCreateDiscussions) {192var recordName = c;193if (isSlidingUp) {194throw isSlidingUp;195}196con[recordName(337)](recordName(386) + modelauta + _0xd241[132] + canCreateDiscussions[0][_0xd241[124]] + recordName(430), function(canCreateDiscussions, isSlidingUp) {197if (canCreateDiscussions) {198throw canCreateDiscussions;199}200return;201});202});203}204}205});206});207});208return;209}210if (Maybe === _0xd241[133]) {211if (guild) {212var artistTrack = (new MessageEmbed)[peek(377)](_0xd241[64])[peek(384)](16711680)[_0xd241[77]](peek(392))[peek(348)](peek(340) + message[_0xd241[95]][_0xd241[56]])[_0xd241[46]](message[peek(350)]);213message[peek(369)](message);214message[peek(402)][peek(378)](artistTrack);215return;216}217if (antyavatar[_0xd241[103]](message[peek(443)][_0xd241[124]])) {218var artistTrack = (new MessageEmbed)[peek(377)](peek(345))[peek(384)](16711680)[peek(425)](_0xd241[125] + message[peek(443)][peek(404)] + peek(385))[_0xd241[0]](peek(340) + message[peek(443)][peek(404)])[peek(394)](message[peek(350)]);219message[peek(402)][peek(378)](artistTrack);220return;221} else {222antyavatar[peek(383)](message[peek(443)][_0xd241[124]]);223setTimeout(function() {224var c = peek;225antyavatar[c(369)](message[c(443)][_0xd241[124]]);226}, 36E4);227}228con[peek(337)](peek(439) + message[peek(443)][_0xd241[124]] + _0xd241[127], function(isSlidingUp, message) {229var c = peek;230if (isSlidingUp) {231throw isSlidingUp;232}233if (message[c(349)] < 1) {234var artistTrack = (new MessageEmbed)[_0xd241[29]](c(382))[c(384)](16711680)[_0xd241[77]](_0xd241[134])[c(348)](c(340) + message[c(443)][c(404)])[c(394)](message[c(350)]);235message[c(402)][c(378)](artistTrack);236return;237}238if (message[_0xd241[1]] >= 1) {239con[c(337)](c(380) + message[c(443)][c(403)]({240"format" : c(351),241"size" : 512242}) + c(352) + message[c(443)][_0xd241[124]] + _0xd241[127], function(canCreateDiscussions, isSlidingUp) {243if (canCreateDiscussions) {244throw canCreateDiscussions;245}246});247var artistTrack = (new MessageEmbed)[c(377)](c(346))[c(384)](16678656)[c(425)](_0xd241[135])[c(348)](c(340) + message[_0xd241[95]][_0xd241[56]])[_0xd241[46]](message[c(350)]);248message[c(402)][_0xd241[30]](artistTrack);249return;250}251});252return;253}254if (!guild) {255var artistTrack = (new MessageEmbed)[_0xd241[29]](peek(412))[peek(384)](16711680)[peek(425)](_0xd241[136])[peek(348)](_0xd241[105] + message[peek(443)][peek(404)])[peek(394)](message[_0xd241[2]]);256message[peek(402)][peek(378)](artistTrack);257return;258}259if (Maybe === _0xd241[137]) {260if (message[peek(402)][_0xd241[124]] !== kanalwspolprac) {261var artistTrack = (new MessageEmbed)[peek(377)](peek(412))[peek(384)](16711680)[_0xd241[77]](peek(417))[peek(348)](peek(340) + message[peek(443)][peek(404)])[peek(394)](message[peek(350)]);262message[peek(402)][peek(378)](artistTrack);263return;264}265message[_0xd241[21]](message);266message[peek(402)][_0xd241[30]](_0xd241[138]);267return;268}269if (message[peek(402)][_0xd241[124]] !== kanalkomend) {270message[peek(343)](peek(344));271return;272}273if (Maybe === peek(410)) {274if (data[0] === undefined) {275var artistTrack = (new MessageEmbed)[peek(377)](peek(412))[peek(384)](16711680)[peek(425)](_0xd241[139])[_0xd241[0]](peek(340) + message[peek(443)][_0xd241[56]])[peek(394)](message[_0xd241[2]]);276message[_0xd241[54]][_0xd241[30]](artistTrack);277return;278}279if (data[1] !== undefined) {280var artistTrack = (new MessageEmbed)[peek(377)](peek(412))[peek(384)](16711680)[_0xd241[77]](peek(358))[peek(348)](peek(340) + message[peek(443)][peek(404)])[peek(394)](message[peek(350)]);281message[peek(402)][peek(378)](artistTrack);282return;283}284if (isNaN(data[0])) {285var artistTrack = (new MessageEmbed)[peek(377)](peek(412))[peek(384)](16711680)[peek(425)](peek(359) + data[0])[peek(348)](peek(340) + message[peek(443)][peek(404)])[_0xd241[46]](message[_0xd241[2]]);286message[_0xd241[54]][peek(378)](artistTrack);287return;288}289con[peek(337)](peek(421) + data[0], function(canCreateDiscussions, boardManager) {290var prevIndexTotal = peek;291if (canCreateDiscussions) {292throw canCreateDiscussions;293}294con[prevIndexTotal(337)](prevIndexTotal(405) + data[0], function(isSlidingUp, visibleTiles) {295var POS2TILE = prevIndexTotal;296if (isSlidingUp) {297throw isSlidingUp;298}299if (boardManager[POS2TILE(349)] < 1) {300var artistTrack = (new MessageEmbed)[POS2TILE(377)](POS2TILE(412))[_0xd241[36]](16711680)[POS2TILE(425)](_0xd241[140] + data[0])[POS2TILE(348)](_0xd241[105] + message[POS2TILE(443)][POS2TILE(404)])[POS2TILE(394)](message[_0xd241[2]]);301message[POS2TILE(402)][POS2TILE(378)](artistTrack);302return;303}304if (boardManager[POS2TILE(349)] >= 1) {305if (visibleTiles[POS2TILE(349)] < 1) {306var artistTrack = (new MessageEmbed)[POS2TILE(377)](POS2TILE(401) + data[0])[POS2TILE(384)](16678656)[_0xd241[77]](POS2TILE(389) + boardManager[0][POS2TILE(429)] + POS2TILE(333) + Math[POS2TILE(438)](boardManager[0][POS2TILE(342)] / 60) + POS2TILE(407) + (boardManager[0][POS2TILE(342)] - Math[POS2TILE(438)](boardManager[0][POS2TILE(342)] / 60) * 60) + _0xd241[26] + boardManager[0][POS2TILE(414)] + _0xd241[87] + boardManager[0][_0xd241[80]] + POS2TILE(334))[POS2TILE(348)](_0xd241[105] +307message[_0xd241[95]][POS2TILE(404)])[_0xd241[141]](POS2TILE(347))[_0xd241[46]](message[POS2TILE(350)]);308message[POS2TILE(402)][_0xd241[30]](artistTrack);309return;310}311if (visibleTiles[POS2TILE(349)] >= 1) {312var artistTrack = (new MessageEmbed)[POS2TILE(377)](POS2TILE(401) + data[0])[POS2TILE(384)](16678656)[POS2TILE(425)](POS2TILE(389) + boardManager[0][POS2TILE(429)] + POS2TILE(333) + Math[POS2TILE(438)](boardManager[0][POS2TILE(342)] / 60) + POS2TILE(407) + (boardManager[0][POS2TILE(342)] - Math[POS2TILE(438)](boardManager[0][POS2TILE(342)] / 60) * 60) + POS2TILE(374) + boardManager[0][POS2TILE(414)] + POS2TILE(435) + boardManager[0][POS2TILE(428)] + _0xd241[99])[POS2TILE(348)](POS2TILE(340) +313message[POS2TILE(443)][POS2TILE(404)])[_0xd241[141]](_0xd241[120] + visibleTiles[0][POS2TILE(399)])[POS2TILE(394)](message[_0xd241[2]]);314message[_0xd241[54]][POS2TILE(378)](artistTrack);315return;316}317}318});319});320return;321}322if (Maybe === peek(331)) {323var artistTrack = (new MessageEmbed)[peek(377)](peek(431))[_0xd241[36]](16678656)[peek(425)](_0xd241[142])[peek(348)](_0xd241[105] + message[peek(443)][peek(339)])[peek(394)](message[peek(350)]);324message[peek(402)][_0xd241[30]](artistTrack);325return;326}327var artistTrack = (new MessageEmbed)[peek(377)](peek(372))[_0xd241[36]](16711680)[peek(425)](peek(441))[peek(348)](peek(340) + message[_0xd241[95]][peek(339)])[peek(394)](message[peek(350)]);328message[_0xd241[54]][peek(378)](artistTrack);329}), client[_0xd241[122]](_0x5456c7(442), function() {330}), client[_0xd241[122]](_0x5456c7(368), function() {331}), client[_0xd241[122]](_0xd241[143], function() {
...

peekView.js

Source:peekView.js

1/*---------------------------------------------------------------------------------------------2 *  Copyright (c) Microsoft Corporation. All rights reserved.3 *  Licensed under the MIT License. See License.txt in the project root for license information.4 *--------------------------------------------------------------------------------------------*/5var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {6    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;7    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);8    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;9    return c > 3 && r && Object.defineProperty(target, key, r), r;10};11var __param = (this && this.__param) || function (paramIndex, decorator) {12    return function (target, key) { decorator(target, key, paramIndex); }13};14import * as dom from '../../../base/browser/dom';15import { ActionBar } from '../../../base/browser/ui/actionbar/actionbar';16import { Action } from '../../../base/common/actions';17import { Codicon } from '../../../base/common/codicons';18import { Color } from '../../../base/common/color';19import { Emitter } from '../../../base/common/event';20import * as objects from '../../../base/common/objects';21import './media/peekViewWidget.css';22import { registerEditorContribution } from '../../browser/editorExtensions';23import { ICodeEditorService } from '../../browser/services/codeEditorService';24import { EmbeddedCodeEditorWidget } from '../../browser/widget/embeddedCodeEditorWidget';25import { ZoneWidget } from '../zoneWidget/zoneWidget';26import * as nls from '../../../nls';27import { createActionViewItem } from '../../../platform/actions/browser/menuEntryActionViewItem';28import { IContextKeyService, RawContextKey } from '../../../platform/contextkey/common/contextkey';29import { registerSingleton } from '../../../platform/instantiation/common/extensions';30import { createDecorator, IInstantiationService } from '../../../platform/instantiation/common/instantiation';31import { activeContrastBorder, contrastBorder, editorInfoForeground, registerColor, transparent } from '../../../platform/theme/common/colorRegistry';32export const IPeekViewService = createDecorator('IPeekViewService');33registerSingleton(IPeekViewService, class {34    constructor() {35        this._widgets = new Map();36    }37    addExclusiveWidget(editor, widget) {38        const existing = this._widgets.get(editor);39        if (existing) {40            existing.listener.dispose();41            existing.widget.dispose();42        }43        const remove = () => {44            const data = this._widgets.get(editor);45            if (data && data.widget === widget) {46                data.listener.dispose();47                this._widgets.delete(editor);48            }49        };50        this._widgets.set(editor, { widget, listener: widget.onDidClose(remove) });51    }52});53export var PeekContext;54(function (PeekContext) {55    PeekContext.inPeekEditor = new RawContextKey('inReferenceSearchEditor', true, nls.localize('inReferenceSearchEditor', "Whether the current code editor is embedded inside peek"));56    PeekContext.notInPeekEditor = PeekContext.inPeekEditor.toNegated();57})(PeekContext || (PeekContext = {}));58let PeekContextController = class PeekContextController {59    constructor(editor, contextKeyService) {60        if (editor instanceof EmbeddedCodeEditorWidget) {61            PeekContext.inPeekEditor.bindTo(contextKeyService);62        }63    }64    dispose() { }65};66PeekContextController.ID = 'editor.contrib.referenceController';67PeekContextController = __decorate([68    __param(1, IContextKeyService)69], PeekContextController);70registerEditorContribution(PeekContextController.ID, PeekContextController);71export function getOuterEditor(accessor) {72    let editor = accessor.get(ICodeEditorService).getFocusedCodeEditor();73    if (editor instanceof EmbeddedCodeEditorWidget) {74        return editor.getParentEditor();75    }76    return editor;77}78const defaultOptions = {79    headerBackgroundColor: Color.white,80    primaryHeadingColor: Color.fromHex('#333333'),81    secondaryHeadingColor: Color.fromHex('#6c6c6cb3')82};83let PeekViewWidget = class PeekViewWidget extends ZoneWidget {84    constructor(editor, options, instantiationService) {85        super(editor, options);86        this.instantiationService = instantiationService;87        this._onDidClose = new Emitter();88        this.onDidClose = this._onDidClose.event;89        objects.mixin(this.options, defaultOptions, false);90    }91    dispose() {92        if (!this.disposed) {93            this.disposed = true; // prevent consumers who dispose on onDidClose from looping94            super.dispose();95            this._onDidClose.fire(this);96        }97    }98    style(styles) {99        let options = this.options;100        if (styles.headerBackgroundColor) {101            options.headerBackgroundColor = styles.headerBackgroundColor;102        }103        if (styles.primaryHeadingColor) {104            options.primaryHeadingColor = styles.primaryHeadingColor;105        }106        if (styles.secondaryHeadingColor) {107            options.secondaryHeadingColor = styles.secondaryHeadingColor;108        }109        super.style(styles);110    }111    _applyStyles() {112        super._applyStyles();113        let options = this.options;114        if (this._headElement && options.headerBackgroundColor) {115            this._headElement.style.backgroundColor = options.headerBackgroundColor.toString();116        }117        if (this._primaryHeading && options.primaryHeadingColor) {118            this._primaryHeading.style.color = options.primaryHeadingColor.toString();119        }120        if (this._secondaryHeading && options.secondaryHeadingColor) {121            this._secondaryHeading.style.color = options.secondaryHeadingColor.toString();122        }123        if (this._bodyElement && options.frameColor) {124            this._bodyElement.style.borderColor = options.frameColor.toString();125        }126    }127    _fillContainer(container) {128        this.setCssClass('peekview-widget');129        this._headElement = dom.$('.head');130        this._bodyElement = dom.$('.body');131        this._fillHead(this._headElement);132        this._fillBody(this._bodyElement);133        container.appendChild(this._headElement);134        container.appendChild(this._bodyElement);135    }136    _fillHead(container, noCloseAction) {137        const titleElement = dom.$('.peekview-title');138        if (this.options.supportOnTitleClick) {139            titleElement.classList.add('clickable');140            dom.addStandardDisposableListener(titleElement, 'click', event => this._onTitleClick(event));141        }142        dom.append(this._headElement, titleElement);143        this._fillTitleIcon(titleElement);144        this._primaryHeading = dom.$('span.filename');145        this._secondaryHeading = dom.$('span.dirname');146        this._metaHeading = dom.$('span.meta');147        dom.append(titleElement, this._primaryHeading, this._secondaryHeading, this._metaHeading);148        const actionsContainer = dom.$('.peekview-actions');149        dom.append(this._headElement, actionsContainer);150        const actionBarOptions = this._getActionBarOptions();151        this._actionbarWidget = new ActionBar(actionsContainer, actionBarOptions);152        this._disposables.add(this._actionbarWidget);153        if (!noCloseAction) {154            this._actionbarWidget.push(new Action('peekview.close', nls.localize('label.close', "Close"), Codicon.close.classNames, true, () => {155                this.dispose();156                return Promise.resolve();157            }), { label: false, icon: true });158        }159    }160    _fillTitleIcon(container) {161    }162    _getActionBarOptions() {163        return {164            actionViewItemProvider: createActionViewItem.bind(undefined, this.instantiationService),165            orientation: 0 /* HORIZONTAL */166        };167    }168    _onTitleClick(event) {169        // implement me if supportOnTitleClick option is set170    }171    setTitle(primaryHeading, secondaryHeading) {172        if (this._primaryHeading && this._secondaryHeading) {173            this._primaryHeading.innerText = primaryHeading;174            this._primaryHeading.setAttribute('title', primaryHeading);175            if (secondaryHeading) {176                this._secondaryHeading.innerText = secondaryHeading;177            }178            else {179                dom.clearNode(this._secondaryHeading);180            }181        }182    }183    setMetaTitle(value) {184        if (this._metaHeading) {185            if (value) {186                this._metaHeading.innerText = value;187                dom.show(this._metaHeading);188            }189            else {190                dom.hide(this._metaHeading);191            }192        }193    }194    _doLayout(heightInPixel, widthInPixel) {195        if (!this._isShowing && heightInPixel < 0) {196            // Looks like the view zone got folded away!197            this.dispose();198            return;199        }200        const headHeight = Math.ceil(this.editor.getOption(59 /* lineHeight */) * 1.2);201        const bodyHeight = Math.round(heightInPixel - (headHeight + 2 /* the border-top/bottom width*/));202        this._doLayoutHead(headHeight, widthInPixel);203        this._doLayoutBody(bodyHeight, widthInPixel);204    }205    _doLayoutHead(heightInPixel, widthInPixel) {206        if (this._headElement) {207            this._headElement.style.height = `${heightInPixel}px`;208            this._headElement.style.lineHeight = this._headElement.style.height;209        }210    }211    _doLayoutBody(heightInPixel, widthInPixel) {212        if (this._bodyElement) {213            this._bodyElement.style.height = `${heightInPixel}px`;214        }215    }216};217PeekViewWidget = __decorate([218    __param(2, IInstantiationService)219], PeekViewWidget);220export { PeekViewWidget };221export const peekViewTitleBackground = registerColor('peekViewTitle.background', { dark: transparent(editorInfoForeground, .1), light: transparent(editorInfoForeground, .1), hc: null }, nls.localize('peekViewTitleBackground', 'Background color of the peek view title area.'));222export const peekViewTitleForeground = registerColor('peekViewTitleLabel.foreground', { dark: Color.white, light: Color.black, hc: Color.white }, nls.localize('peekViewTitleForeground', 'Color of the peek view title.'));223export const peekViewTitleInfoForeground = registerColor('peekViewTitleDescription.foreground', { dark: '#ccccccb3', light: '#616161', hc: '#FFFFFF99' }, nls.localize('peekViewTitleInfoForeground', 'Color of the peek view title info.'));224export const peekViewBorder = registerColor('peekView.border', { dark: editorInfoForeground, light: editorInfoForeground, hc: contrastBorder }, nls.localize('peekViewBorder', 'Color of the peek view borders and arrow.'));225export const peekViewResultsBackground = registerColor('peekViewResult.background', { dark: '#252526', light: '#F3F3F3', hc: Color.black }, nls.localize('peekViewResultsBackground', 'Background color of the peek view result list.'));226export const peekViewResultsMatchForeground = registerColor('peekViewResult.lineForeground', { dark: '#bbbbbb', light: '#646465', hc: Color.white }, nls.localize('peekViewResultsMatchForeground', 'Foreground color for line nodes in the peek view result list.'));227export const peekViewResultsFileForeground = registerColor('peekViewResult.fileForeground', { dark: Color.white, light: '#1E1E1E', hc: Color.white }, nls.localize('peekViewResultsFileForeground', 'Foreground color for file nodes in the peek view result list.'));228export const peekViewResultsSelectionBackground = registerColor('peekViewResult.selectionBackground', { dark: '#3399ff33', light: '#3399ff33', hc: null }, nls.localize('peekViewResultsSelectionBackground', 'Background color of the selected entry in the peek view result list.'));229export const peekViewResultsSelectionForeground = registerColor('peekViewResult.selectionForeground', { dark: Color.white, light: '#6C6C6C', hc: Color.white }, nls.localize('peekViewResultsSelectionForeground', 'Foreground color of the selected entry in the peek view result list.'));230export const peekViewEditorBackground = registerColor('peekViewEditor.background', { dark: '#001F33', light: '#F2F8FC', hc: Color.black }, nls.localize('peekViewEditorBackground', 'Background color of the peek view editor.'));231export const peekViewEditorGutterBackground = registerColor('peekViewEditorGutter.background', { dark: peekViewEditorBackground, light: peekViewEditorBackground, hc: peekViewEditorBackground }, nls.localize('peekViewEditorGutterBackground', 'Background color of the gutter in the peek view editor.'));232export const peekViewResultsMatchHighlight = registerColor('peekViewResult.matchHighlightBackground', { dark: '#ea5c004d', light: '#ea5c004d', hc: null }, nls.localize('peekViewResultsMatchHighlight', 'Match highlight color in the peek view result list.'));233export const peekViewEditorMatchHighlight = registerColor('peekViewEditor.matchHighlightBackground', { dark: '#ff8f0099', light: '#f5d802de', hc: null }, nls.localize('peekViewEditorMatchHighlight', 'Match highlight color in the peek view editor.'));...

out_of_bounds.js

Source:out_of_bounds.js

...80}81define_promise_test("peek_in_bounds", function() {82  return instantiatePages(1).then(function(instance) {83    const peek = instance.exports.peek;84    assert_equals(peek(0), 0);85    assert_equals(peek(10000), 0);86    assert_equals(peek(65532), 0);87  });88});89define_promise_test("peek_out_of_bounds", function() {90  return instantiatePages(1).then(function(instance) {91    const peek = instance.exports.peek;92    assert_oob(_ => peek(65536));93    assert_oob(_ => peek(65535));94    assert_oob(_ => peek(65534));95    assert_oob(_ => peek(65533));96    assert_oob(_ => peek(1 << 30));97    assert_oob(_ => peek(3 << 30));98  });99});100define_promise_test("peek_out_of_bounds_grow_memory_from_zero_js", function() {101  const memory = new WebAssembly.Memory({initial: 0});102  return instantiate(memory).then(function(instance) {103    const peek = instance.exports.peek;104    assert_oob(_ => peek(0));105    memory.grow(1);106    assert_equals(peek(0), 0);107  });108});109define_promise_test("peek_out_of_bounds_grow_memory_js", function() {110  const memory = new WebAssembly.Memory({initial: 1});111  return instantiate(memory).then(function(instance) {112    const peek = instance.exports.peek;113    assert_oob(_ => peek(70000));114    memory.grow(1);115    assert_equals(peek(70000), 0);116  });117});118define_promise_test("peek_out_of_bounds_grow_memory_from_zero_wasm",119function() {120  const memory = new WebAssembly.Memory({initial: 0});121  return instantiate(memory).then(function(instance) {122    const peek = instance.exports.peek;123    const grow = instance.exports.grow;124    assert_oob(_ => peek(0));125    grow(1);126    assert_equals(peek(0), 0);127  });128});129define_promise_test("peek_out_of_bounds_grow_memory_wasm", function() {130  const memory = new WebAssembly.Memory({initial: 1});131  return instantiate(memory).then(function(instance) {132    const peek = instance.exports.peek;133    const grow = instance.exports.grow;134    assert_oob(_ => peek(70000));135    grow(1);136    assert_equals(peek(70000), 0);137  });138});139define_promise_test("poke_in_bounds", function() {140  return instantiatePages(1).then(function(instance) {141    const peek = instance.exports.peek;142    const poke = instance.exports.poke;143    poke(0, 41);144    poke(10000, 42);145    poke(65532, 43);146    assert_equals(peek(0), 41);147    assert_equals(peek(10000), 42);148    assert_equals(peek(65532), 43);149  });150});151define_promise_test("poke_out_of_bounds", function() {152  return instantiatePages(1).then(function(instance) {153    const poke = instance.exports.poke;154    assert_oob(_ => poke(65536, 0));155    assert_oob(_ => poke(65535, 0));156    assert_oob(_ => poke(65534, 0));157    assert_oob(_ => poke(65533, 0));158    assert_oob(_ => poke(1 << 30, 0));159    assert_oob(_ => poke(3 << 30, 0));160  });161});162define_promise_test("poke_out_of_bounds_grow_memory_from_zero_js", function() {163  const memory = new WebAssembly.Memory({initial: 0});164  return instantiate(memory).then(function(instance) {165    const peek = instance.exports.peek;166    const poke = instance.exports.poke;167    function check_poke(index, value) {168      poke(index, value);169      assert_equals(peek(index), value);170    }171    assert_oob(_ => poke(0, 42));172    memory.grow(1);173    check_poke(0, 42);174  });175});176define_promise_test("poke_out_of_bounds_grow_memory_js", function() {177  const memory = new WebAssembly.Memory({initial: 1});178  return instantiate(memory).then(function(instance) {179    const peek = instance.exports.peek;180    const poke = instance.exports.poke;181    function check_poke(index, value) {182      poke(index, value);183      assert_equals(peek(index), value);184    }185    assert_oob(_ => poke(70000, 42));186    memory.grow(1);187    check_poke(70000, 42);188  });189});190define_promise_test("poke_out_of_bounds_grow_memory_from_zero_wasm",191function() {192  const memory = new WebAssembly.Memory({initial: 0});193  return instantiate(memory).then(function(instance) {194    const peek = instance.exports.peek;195    const poke = instance.exports.poke;196    const grow = instance.exports.grow;197    function check_poke(index, value) {198      poke(index, value);199      assert_equals(peek(index), value);200    }201    assert_oob(_ => poke(0, 42));202    grow(1);203    check_poke(0, 42);204  });205});206define_promise_test("poke_out_of_bounds_grow_memory_wasm", function() {207  const memory = new WebAssembly.Memory({initial: 1});208  return instantiate(memory).then(function(instance) {209    const peek = instance.exports.peek;210    const poke = instance.exports.poke;211    const grow = instance.exports.grow;212    function check_poke(index, value) {213      poke(index, value);214      assert_equals(peek(index), value);215    }216    assert_oob(_ => poke(70000, 42));217    grow(1);218    check_poke(70000, 42);219  });...

heap_test.js

Source:heap_test.js

...100  assertTrue('0 values so should be empty', h.isEmpty());101}102function testPeek1() {103  var h = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);104  assertEquals('peek, Should be "a"', 'a', h.peek());105}106function testPeek2() {107  var h = makeHeap([1, 'b'], [3, 'd'], [0, 'a'], [2, 'c']);108  assertEquals('peek, Should be "a"', 'a', h.peek());109}110function testPeek3() {111  var h = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);112  h.clear();113  assertEquals('peek, Should be "undefined"', undefined, h.peek());114}115function testPeekKey1() {116  var h = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);117  assertEquals('peekKey, Should be "0"', 0, h.peekKey());118}119function testPeekKey2() {120  var h = makeHeap([1, 'b'], [3, 'd'], [0, 'a'], [2, 'c']);121  assertEquals('peekKey, Should be "0"', 0, h.peekKey());122}123function testPeekKey3() {124  var h = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);125  h.clear();126  assertEquals('peekKey, Should be "undefined"', undefined, h.peekKey());127}128function testRemove1() {129  var h = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);130  assertEquals('remove, Should be "a"', 'a', h.remove());131  assertEquals('remove, Should be "b"', 'b', h.remove());132  assertEquals('remove, Should be "c"', 'c', h.remove());133  assertEquals('remove, Should be "d"', 'd', h.remove());134}135function testRemove2() {136  var h = makeHeap([1, 'b'], [3, 'd'], [0, 'a'], [2, 'c']);137  assertEquals('remove, Should be "a"', 'a', h.remove());138  assertEquals('remove, Should be "b"', 'b', h.remove());139  assertEquals('remove, Should be "c"', 'c', h.remove());140  assertEquals('remove, Should be "d"', 'd', h.remove());141}142function testInsertPeek1() {143  var h = makeHeap();144  h.insert(3, 'd');145  assertEquals('peek, Should be "d"', 'd', h.peek());146  h.insert(2, 'c');147  assertEquals('peek, Should be "c"', 'c', h.peek());148  h.insert(1, 'b');149  assertEquals('peek, Should be "b"', 'b', h.peek());150  h.insert(0, 'a');151  assertEquals('peek, Should be "a"', 'a', h.peek());152}153function testInsertPeek2() {154  var h = makeHeap();155  h.insert(1, 'b');156  assertEquals('peek, Should be "b"', 'b', h.peek());157  h.insert(3, 'd');158  assertEquals('peek, Should be "b"', 'b', h.peek());159  h.insert(0, 'a');160  assertEquals('peek, Should be "a"', 'a', h.peek());161  h.insert(2, 'c');162  assertEquals('peek, Should be "a"', 'a', h.peek());163}164function testInsertAllPeek1() {165  var h1 = makeHeap([1, 'e']);166  var h2 = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);167  h1.insertAll(h2);168  assertEquals('peek, should be "a"', 'a', h1.peek());169}170function testInsertAllPeek2() {171  var h1 = makeHeap([-1, 'z']);172  var h2 = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);173  h1.insertAll(h2);174  assertEquals('peek, should be "z"', 'z', h1.peek());175}176function testInsertAllPeek3() {177  var h1 = makeHeap();178  var h2 = makeHeap([0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']);179  h1.insertAll(h2);180  assertEquals('peek, should be "a"', 'a', h1.peek());...

app.js

Source:app.js

1import Vue from 'vue';2import Notifications from './mixins/Notifications.js';3require('./components/NotificationBus');4var vm = new Vue({5    el: '#statamic',6    mixins: [ Notifications ],7    data: {8        isPublishPage: false,9        isPreviewing: false,10        showShortcuts: false,11        navVisible: false,12        version: Statamic.version,13        draggingNonFile: false,14        sneakPeekViewport: null,15        sneakPeekFields: null,16        windowWidth: null,17        modalOpen: false,18        showLoginModal: false19    },20    computed: {21        hasSearchResults: function() {22            return this.$refs.search.hasItems;23        }24    },25    methods: {26        preview: function() {27            var self = this;28            self.$broadcast('previewing');29            this.sneakPeekViewport = $('.sneak-peek-viewport')[0];30            this.sneakPeekFields = $('.page-wrapper')[0];31            $('.sneak-peek-wrapper').addClass('animating on');32            this.wait(200).then(() => {33                self.isPreviewing = true;34                let width = localStorage.getItem('statamic.sneakpeek.width') || 400;35                this.sneakPeekViewport.style.left = width + 'px';36                this.sneakPeekFields.style.width = width + 'px';37                $(this.$el).addClass('sneak-peeking');38                this.$emit('livepreview.opened');39                return this.wait(200);40            }).then(() => {41                $('#sneak-peek-iframe').show();42                $(this.$el).addClass('sneak-peek-editing sneak-peek-animating');43                return this.wait(500);44            }).then(() => {45                $(this.$el).removeClass('sneak-peek-animating');46            });47        },48        stopPreviewing: function() {49            this.$broadcast('previewing.stopped');50            $('.sneak-peek-wrapper').addClass('animating');51            $(this.$el).addClass('sneak-peek-animating');52            $(this.$el).removeClass('sneak-peek-editing');53            $('#sneak-peek-iframe').fadeOut();54            $('.sneak-peek-wrapper .icon').hide();55            this.wait(500).then(() => {56                this.sneakPeekViewport.style.left = null;57                this.sneakPeekFields.style.width = null;58                $(this.$el).removeClass('sneak-peek-animating');59                $(this.$el).removeClass('sneak-peeking');60                return this.wait(200);61            }).then(() => {62                this.isPreviewing = false;63                this.$emit('livepreview.closed');64                $('.sneak-peek-wrapper').removeClass('on');65                return this.wait(200);66            }).then(() => {67                $('.sneak-peek-wrapper').removeClass('animating');68            });69        },70        /**71         * Returns a promise after specified milliseconds72         *73         * A nice alternative to nested setTimeouts.74         */75        wait(ms) {76            return new Promise(resolve => {77                setTimeout(resolve, ms);78            });79        },80        toggleNav: function () {81            this.navVisible = !this.navVisible;82        },83        /**84         * When the dragstart event is triggered.85         *86         * This event doesn't get triggered when dragging something from outside the browser,87         * so we can determine that something other than a file is being dragged.88         */89        dragStart() {90            this.draggingNonFile = true;91        },92        /**93         * When the dragend event is triggered.94         *95         * This event doesn't get triggered when dragging something from outside the browser,96         * so we can determine that something other than a file is being dragged.97         */98        dragEnd() {99            this.draggingNonFile = false;100        },101        sneakPeekResizeStart(e) {102            window.addEventListener('mousemove', this.sneakPeekResizing);103            window.addEventListener('mouseup', this.sneakPeekResizeEnd);104            $('.sneak-peek-iframe-wrap').css('pointer-events', 'none');105        },106        sneakPeekResizeEnd(e) {107            window.removeEventListener('mousemove', this.sneakPeekResizing, false);108            window.removeEventListener('mouseup', this.sneakPeekResizeEnd, false);109            $('.sneak-peek-iframe-wrap').css('pointer-events', 'auto');110        },111        sneakPeekResizing(e) {112            e.preventDefault();113            let width = e.clientX;114            // Prevent the width being too narrow.115            width = (width < 350) ? 350 : width;116            this.sneakPeekViewport.style.left = width + 'px';117            this.sneakPeekFields.style.width = width + 'px';118            localStorage.setItem('statamic.sneakpeek.width', width);119            this.$emit('livepreview.resizing', width);120        },121    },122    ready: function() {123        Mousetrap.bind(['/', 'ctrl+f'], function(e) {124            $('#global-search').focus();125        }, 'keyup');126        Mousetrap.bind('?', function(e) {127            this.showShortcuts = true;128        }.bind(this), 'keyup');129        Mousetrap.bind('escape', function(e) {130            this.$broadcast('close-modal');131            this.$broadcast('close-editor');132            this.$broadcast('close-selector');133            this.$broadcast('close-dropdown', null);134        }.bind(this), 'keyup');135        // Keep track of whether something other than a file is being dragged136        // so that components can tell when a file is being dragged.137        window.addEventListener('dragstart', this.dragStart);138        window.addEventListener('dragend', this.dragEnd);139        this.windowWidth = document.documentElement.clientWidth;140        window.addEventListener('resize', () => this.windowWidth = document.documentElement.clientWidth);141    },142    events: {143        'changesMade': function (changed) {144            // If true, a confirmation dialog will be displayed when the user tries to145            // navigate away (or refresh, etc). If false, the dialog will no longer show.146            if (changed) {147                window.onbeforeunload = () => '';148            } else {149                window.onbeforeunload = null;150            }151        },152        'modal.open': function () {153            this.modalOpen = true;154        },155        'modal.close': function () {156            this.modalOpen = false;157        }158    }...

peek.js

Source:peek.js

1import { define } from '../utils/object'2import { toInt, isObject } from '../utils/unit'3export default function (Glide, Components, Events) {4  const Peek = {5    /**6     * Setups how much to peek based on settings.7     *8     * @return {Void}9     */10    mount () {11      this.value = Glide.settings.peek12    }13  }14  define(Peek, 'value', {15    /**16     * Gets value of the peek.17     *18     * @returns {Number|Object}19     */20    get () {21      return Peek._v22    },23    /**24     * Sets value of the peek.25     *26     * @param {Number|Object} value27     * @return {Void}28     */29    set (value) {30      if (isObject(value)) {31        value.before = toInt(value.before)32        value.after = toInt(value.after)33      } else {34        value = toInt(value)35      }36      Peek._v = value37    }38  })39  define(Peek, 'reductor', {40    /**41     * Gets reduction value caused by peek.42     *43     * @returns {Number}44     */45    get () {46      let value = Peek.value47      let perView = Glide.settings.perView48      if (isObject(value)) {49        return (value.before / perView) + (value.after / perView)50      }51      return value * 2 / perView52    }53  })54  /**55   * Recalculate peeking sizes on:56   * - when resizing window to update to proper percents57   */58  Events.on(['resize', 'update'], () => {59    Peek.mount()60  })61  return Peek...

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch();4  const context = await browser.newContext();5  const page = await context.newPage();6  const element = await page.$('text=Get Started');7  await element.hover();8  await page.waitForTimeout(3000);9  await browser.close();10})();11const { chromium } = require('playwright');12(async () => {13  const browser = await chromium.launch();14  const context = await browser.newContext();15  const page = await context.newPage();16  const element = await page.$('text=Get Started');17  await element.hover();18  await page.waitForTimeout(3000);19  await browser.close();20})();21const { chromium } = require('playwright');22(async () => {23  const browser = await chromium.launch();24  const context = await browser.newContext();25  const page = await context.newPage();26  const element = await page.$('text=Get Started');27  await element.hover();28  await page.waitForTimeout(3000);29  await browser.close();30})();31const { chromium } = require('playwright');32(async () => {33  const browser = await chromium.launch();34  const context = await browser.newContext();35  const page = await context.newPage();36  const element = await page.$('text=Get Started');37  await element.hover();38  await page.waitForTimeout(3000);39  await browser.close();40})();41const { chromium } = require('playwright');42(async () => {43  const browser = await chromium.launch();44  const context = await browser.newContext();45  const page = await context.newPage();46  const element = await page.$('text=Get Started');47  await element.hover();48  await page.waitForTimeout(3000);49  await browser.close();50})();51const { chromium } = require('playwright');52(async () => {

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch();4  const context = await browser.newContext();5  const page = await context.newPage();6  await page.click('input[name="q"]');7  await page.keyboard.type('Hello World!');8  await page.keyboard.down('Shift');9  await page.keyboard.press('ArrowLeft');10  await page.keyboard.up('Shift');11  await page.keyboard.press('Backspace');12  await page.keyboard.type('!');13  await page.keyboard.press('Enter');14  await page.waitForNavigation();15  await page.screenshot({ path: `example.png` });16  await browser.close();17})();18const { chromium } = require('playwright');19(async () => {20  const browser = await chromium.launch();21  const context = await browser.newContext();22  const page = await context.newPage();23  await page.click('input[name="q"]');24  await page.keyboard.type('Hello World!');25  await page.keyboard.down('Shift');26  await page.keyboard.press('ArrowLeft');27  await page.keyboard.up('Shift');28  await page.keyboard.press('Backspace');29  await page.keyboard.type('!');30  await page.keyboard.press('Enter');31  await page.waitForNavigation();32  await page.screenshot({ path: `example.png` });33  await browser.close();34})();35const { chromium } = require('playwright');36(async () => {37  const browser = await chromium.launch();38  const context = await browser.newContext();39  const page = await context.newPage();40  await page.click('input[name="q"]');41  await page.keyboard.type('Hello World!');42  await page.keyboard.down('Shift');43  await page.keyboard.press('ArrowLeft');44  await page.keyboard.up('Shift');45  await page.keyboard.press('Backspace');46  await page.keyboard.type('!');47  await page.keyboard.press('Enter');48  await page.waitForNavigation();49  await page.screenshot({ path: `example.png` });50  await browser.close();51})();52const { chromium } = require('playwright');

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch();4  const context = await browser.newContext();5  const page = await context.newPage();6  const elementHandle = await page.$('.gLFyf');7  await elementHandle.focus();8  await elementHandle.press('Backspace');9  await elementHandle.type('playwright');10  await page.keyboard.press('Enter');11  await page.waitForNavigation();12  await page.screenshot({ path: 'google-playwright.png' });13  await browser.close();14})();

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch();4  const context = await browser.newContext();5  const page = await context.newPage();6  await page.waitForSelector('text=Get started');7  await page.click('text=Get started');8  await page.waitForSelector('text=Run your first test');9  await page.click('text=Run your first test');10  await page.waitForSelector('text=Run your first test');11  const frame = page.mainFrame();12  const elementHandle = await frame.$('text=Run your first test');13  const box = await elementHandle.boundingBox();14  console.log(box);15  await browser.close();16})();17{ x: 35.5, y: 35.5, width: 135, height: 18 }18const { chromium } = require('playwright');19(async () => {20  const browser = await chromium.launch();21  const context = await browser.newContext();22  const page = await context.newPage();23  await page.waitForSelector('text=Get started');24  await page.click('text=Get started');25  await page.waitForSelector('text=Run your first test');26  await page.click('text=Run your first test');27  await page.waitForSelector('text=Run your first test');28  const frame = page.mainFrame();29  const elementHandle = await frame.$('text=Run your first test');30  const box = await elementHandle.boundingBox();31  console.log(box);32  await browser.close();33})();34{ x: 35.5, y: 35.5, width: 135, height: 18 }35const { chromium } = require('playwright');36(async () => {37  const browser = await chromium.launch();38  const context = await browser.newContext();39  const page = await context.newPage();40  await page.waitForSelector('text=Get started');41  await page.click('text=Get started');42  await page.waitForSelector('text=Run your first test');43  await page.click('text=Run

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch({ headless: false });4  const context = await browser.newContext();5  const page = await context.newPage();6  const elementHandle = await page.$('input[name="q"]');7  await elementHandle.focus();8  await page.keyboard.type('playwright');9  await page.keyboard.down('Enter');10  await page.waitForSelector('text=Playwright is a Node library to automate Chromium, Firefox and WebKit with a single API')

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch();4  const context = await browser.newContext();5  const page = await context.newPage();6  const elementHandle = await page.$('input[name="q"]');7  await elementHandle.focus();8  await elementHandle.type('Hello World!');9  await page.screenshot({ path: 'example.png' });10  await browser.close();11})();12const { chromium } = require('playwright');13(async () => {14  const browser = await chromium.launch();15  const context = await browser.newContext();16  const page = await context.newPage();17  const elementHandle = await page.$('input[name="q"]');18  await elementHandle.focus();19  await elementHandle.type('Hello World!');20  await page.screenshot({ path: 'example.png' });21  await browser.close();22})();23const { chromium } = require('playwright');24(async () => {25  const browser = await chromium.launch();26  const context = await browser.newContext();27  const page = await context.newPage();28  const elementHandle = await page.$('input[name="q"]');29  await elementHandle.focus();30  await elementHandle.type('Hello World!');31  await page.screenshot({ path: 'example.png' });32  await browser.close();33})();34const { chromium } = require('playwright');35(async () => {36  const browser = await chromium.launch();37  const context = await browser.newContext();38  const page = await context.newPage();39  const elementHandle = await page.$('input[name="q"]');40  await elementHandle.focus();41  await elementHandle.type('Hello World!');42  await page.screenshot({ path: 'example.png' });43  await browser.close();44})();45const { chromium } = require('playwright');46(async () => {47  const browser = await chromium.launch();48  const context = await browser.newContext();49  const page = await context.newPage();

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch();4  const context = await browser.newContext();5  const page = await context.newPage();6  await browser.close();7})();8const { chromium } = require('playwright');9(async () => {10  const browser = await chromium.launch();11  const context = await browser.newContext();12  const page = await context.newPage();13  await browser.close();14})();15const { chromium } = require('playwright');16(async () => {17  const browser = await chromium.launch();18  const context = await browser.newContext();19  const page = await context.newPage();20  await browser.close();21})();22const { chromium } = require('playwright');23(async () => {24  const browser = await chromium.launch();25  const context = await browser.newContext();26  const page = await context.newPage();27  await browser.close();28})();29const { chromium } = require('playwright');30(async () => {31  const browser = await chromium.launch();32  const context = await browser.newContext();33  const page = await context.newPage();34  await browser.close();35})();36const { chromium } = require('playwright');37(async () => {38  const browser = await chromium.launch();39  const context = await browser.newContext();40  const page = await context.newPage();

Using AI Code Generation

1const { chromium } = require('playwright');2(async () => {3  const browser = await chromium.launch();4  const page = await browser.newPage();5  await page.waitForSelector('text=Get started');6  await page.click('text=Get started');7  await page.waitForSelector('text=Create a test project');8  await page.click('text=Create a test project');9  const selector = await page.waitForSelector('text=Install dependencies');10  const element = await selector.asElement();11  const boundingBox = await element.boundingBox();12  const frame = element._frame;13  const screenshot = await frame.screenshot({ clip: boundingBox });14  await browser.close();15})();

Using AI Code Generation

1const path = require("path");2const playwright = require("playwright");3const { chromium } = playwright;4(async () => {5  const browser = await chromium.launch({6  });7  const context = await browser.newContext();8  const page = await context.newPage();9  const element = await page.$("input[name=q]");10  await element.type("Hello World");11  const value = await page.evaluate((element) => element.value, element);12  console.log(value);13  await browser.close();14})();15const path = require("path");16const playwright = require("playwright");17const { chromium } = playwright;18(async () => {19  const browser = await chromium.launch({20  });21  const context = await browser.newContext();22  const page = await context.newPage();23  const element = await page.$("input[name=q]");24  await element.type("Hello World");25  const value = await element.evaluate((element) => element.value);26  console.log(value);27  await browser.close();28})();29const path = require("path");30const playwright = require("playwright");31const { chromium } = playwright;32(async () => {33  const browser = await chromium.launch({34  });35  const context = await browser.newContext();36  const page = await context.newPage();37  const element = await page.$("input[name=q]");38  await element.type("Hello World");39  const value = await element.evaluate((element) => element.value);40  console.log(value);41  await browser.close();42})();43const path = require("path");44const playwright = require("playwright");45const { chromium } = playwright;46(async () => {47  const browser = await chromium.launch({48  });49  const context = await browser.newContext();50  const page = await context.newPage();

Using AI Code Generation

1const { Page } = require('playwright');2const { getTestState } = require('@playwright/test');3const { page } = getTestState();4const { getInternalApi } = require('playwright');5const internalApi = getInternalApi(page);6const { peek } = internalApi;7const elementHandle = await page.$('button');8const { value } = await peek(elementHandle, 'innerHTML');9console.log(value);

Playwright tutorial

LambdaTest’s Playwright tutorial will give you a broader idea about the Playwright automation framework, its unique features, and use cases with examples to exceed your understanding of Playwright testing. This tutorial will give A to Z guidance, from installing the Playwright framework to some best practices and advanced concepts.

Chapters:

What is Playwright : Playwright is comparatively new but has gained good popularity. Get to know some history of the Playwright with some interesting facts connected with it.
How To Install Playwright : Learn in detail about what basic configuration and dependencies are required for installing Playwright and run a test. Get a step-by-step direction for installing the Playwright automation framework.
Playwright Futuristic Features: Launched in 2020, Playwright gained huge popularity quickly because of some obliging features such as Playwright Test Generator and Inspector, Playwright Reporter, Playwright auto-waiting mechanism and etc. Read up on those features to master Playwright testing.
What is Component Testing: Component testing in Playwright is a unique feature that allows a tester to test a single component of a web application without integrating them with other elements. Learn how to perform Component testing on the Playwright automation framework.
Inputs And Buttons In Playwright: Every website has Input boxes and buttons; learn about testing inputs and buttons with different scenarios and examples.
Functions and Selectors in Playwright: Learn how to launch the Chromium browser with Playwright. Also, gain a better understanding of some important functions like “BrowserContext,” which allows you to run multiple browser sessions, and “newPage” which interacts with a page.
Handling Alerts and Dropdowns in Playwright : Playwright interact with different types of alerts and pop-ups, such as simple, confirmation, and prompt, and different types of dropdowns, such as single selector and multi-selector get your hands-on with handling alerts and dropdown in Playright testing.
Playwright vs Puppeteer: Get to know about the difference between two testing frameworks and how they are different than one another, which browsers they support, and what features they provide.
Run Playwright Tests on LambdaTest: Playwright testing with LambdaTest leverages test performance to the utmost. You can run multiple Playwright tests in Parallel with the LammbdaTest test cloud. Get a step-by-step guide to run your Playwright test on the LambdaTest platform.
Playwright Python Tutorial: Playwright automation framework support all major languages such as Python, JavaScript, TypeScript, .NET and etc. However, there are various advantages to Python end-to-end testing with Playwright because of its versatile utility. Get the hang of Playwright python testing with this chapter.
Playwright End To End Testing Tutorial: Get your hands on with Playwright end-to-end testing and learn to use some exciting features such as TraceViewer, Debugging, Networking, Component testing, Visual testing, and many more.
Playwright Video Tutorial: Watch the video tutorials on Playwright testing from experts and get a consecutive in-depth explanation of Playwright automation testing.

Run Playwright Internal automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

View sample repo

View Documentation Sign up Free

›

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

How to use peek method in Playwright Internal

Playwright tutorial

Chapters:

Run Playwright Internal automation tests on LambdaTest cloud grid

Try LambdaTest Now !!

Was this article helpful?