eslint 3.15.0 → 3.16.0

package/lib/rules/object-curly-newline.js

@@ -128,8 +128,8 @@ module.exports = {
             const options = normalizedOptions[node.type];
             const openBrace = sourceCode.getFirstToken(node);
             const closeBrace = sourceCode.getLastToken(node);
-            let first = sourceCode.getTokenOrCommentAfter(openBrace);
-            let last = sourceCode.getTokenOrCommentBefore(closeBrace);
+            let first = sourceCode.getTokenAfter(openBrace, { includeComments: true });
+            let last = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
             const needsLinebreaks = (
                 node.properties.length >= options.minProperties ||
                 (

package/lib/rules/object-curly-spacing.js

@@ -206,14 +206,8 @@ module.exports = {
          */
         function getClosingBraceOfObject(node) {
             const lastProperty = node.properties[node.properties.length - 1];
-            let token = sourceCode.getTokenAfter(lastProperty);
 
-            // skip ')' and trailing commas.
-            while (token.type !== "Punctuator" || token.value !== "}") {
-                token = sourceCode.getTokenAfter(token);
-            }
-
-            return token;
+            return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken);
         }
 
         /**
@@ -254,15 +248,9 @@ module.exports = {
                 firstSpecifier = node.specifiers[1];
             }
 
-            const first = sourceCode.getTokenBefore(firstSpecifier);
-            let last = sourceCode.getTokenAfter(lastSpecifier);
-
-            // to support a trailing comma.
-            if (last.value === ",") {
-                last = sourceCode.getTokenAfter(last);
-            }
-
-            const second = sourceCode.getTokenAfter(first),
+            const first = sourceCode.getTokenBefore(firstSpecifier),
+                last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken),
+                second = sourceCode.getTokenAfter(first),
                 penultimate = sourceCode.getTokenBefore(last);
 
             validateBraceSpacing(node, first, second, penultimate, last);
@@ -280,15 +268,9 @@ module.exports = {
 
             const firstSpecifier = node.specifiers[0],
                 lastSpecifier = node.specifiers[node.specifiers.length - 1],
-                first = sourceCode.getTokenBefore(firstSpecifier);
-            let last = sourceCode.getTokenAfter(lastSpecifier);
-
-            // to support a trailing comma.
-            if (last.value === ",") {
-                last = sourceCode.getTokenAfter(last);
-            }
-
-            const second = sourceCode.getTokenAfter(first),
+                first = sourceCode.getTokenBefore(firstSpecifier),
+                last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken),
+                second = sourceCode.getTokenAfter(first),
                 penultimate = sourceCode.getTokenBefore(last);
 
             validateBraceSpacing(node, first, second, penultimate, last);

package/lib/rules/object-property-newline.js

@@ -34,9 +34,9 @@ module.exports = {
 
     create(context) {
         const allowSameLine = context.options[0] && Boolean(context.options[0].allowMultiplePropertiesPerLine);
-        const errorMessage = allowSameLine ?
-            "Object properties must go on a new line if they aren't all on the same line." :
-            "Object properties must go on a new line.";
+        const errorMessage = allowSameLine
+            ? "Object properties must go on a new line if they aren't all on the same line."
+            : "Object properties must go on a new line.";
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/object-shorthand.js

@@ -215,8 +215,8 @@ module.exports = {
         * @returns {Object} A fix for this node
         */
         function makeFunctionShorthand(fixer, node) {
-            const firstKeyToken = node.computed ? sourceCode.getTokens(node).find(token => token.value === "[") : sourceCode.getFirstToken(node.key);
-            const lastKeyToken = node.computed ? sourceCode.getTokensBetween(node.key, node.value).find(token => token.value === "]") : sourceCode.getLastToken(node.key);
+            const firstKeyToken = node.computed ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken) : sourceCode.getFirstToken(node.key);
+            const lastKeyToken = node.computed ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken) : sourceCode.getLastToken(node.key);
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let keyPrefix = "";
 

package/lib/rules/operator-assignment.js

@@ -108,7 +108,7 @@ module.exports = {
         * @returns {Token} The operator token in the node
         */
         function getOperatorToken(node) {
-            return sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+            return sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
         }
 
         /**

package/lib/rules/operator-linebreak.js

@@ -5,14 +5,16 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const LINEBREAK_REGEX = /\r\n|\r|\n|\u2028|\u2029/g;
-
 module.exports = {
     meta: {
         docs: {
@@ -85,7 +87,7 @@ module.exports = {
                 if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== "none") {
 
                     // If there is a comment before and after the operator, don't do a fix.
-                    if (sourceCode.getTokenOrCommentBefore(operatorToken) !== tokenBefore && sourceCode.getTokenOrCommentAfter(operatorToken) !== tokenAfter) {
+                    if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore && sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {
                         return null;
                     }
 
@@ -100,6 +102,7 @@ module.exports = {
                     newTextBefore = textAfter;
                     newTextAfter = textBefore;
                 } else {
+                    const LINEBREAK_REGEX = astUtils.createGlobalLinebreakMatcher();
 
                     // Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings.
                     newTextBefore = desiredStyle === "before" || textBefore.trim() ? textBefore : textBefore.replace(LINEBREAK_REGEX, "");
@@ -129,19 +132,14 @@ module.exports = {
          * @returns {void}
          */
         function validateNode(node, leftSide) {
-            let leftToken = sourceCode.getLastToken(leftSide);
-            let operatorToken = sourceCode.getTokenAfter(leftToken);
 
             // When the left part of a binary expression is a single expression wrapped in
             // parentheses (ex: `(a) + b`), leftToken will be the last token of the expression
             // and operatorToken will be the closing parenthesis.
             // The leftToken should be the last closing parenthesis, and the operatorToken
             // should be the token right after that.
-            while (operatorToken.value === ")") {
-                leftToken = operatorToken;
-                operatorToken = sourceCode.getTokenAfter(operatorToken);
-            }
-
+            const operatorToken = sourceCode.getTokenAfter(leftSide, astUtils.isNotClosingParenToken);
+            const leftToken = sourceCode.getTokenBefore(operatorToken);
             const rightToken = sourceCode.getTokenAfter(operatorToken);
             const operator = operatorToken.value;
             const operatorStyleOverride = styleOverrides[operator];

package/lib/rules/padded-blocks.js

@@ -101,7 +101,7 @@ module.exports = {
             let first = token;
 
             do {
-                first = sourceCode.getTokenOrCommentAfter(first);
+                first = sourceCode.getTokenAfter(first, { includeComments: true });
             } while (isComment(first) && first.loc.start.line === tokenStartLine);
 
             const firstLine = first.loc.start.line;
@@ -120,7 +120,7 @@ module.exports = {
             let last = token;
 
             do {
-                last = sourceCode.getTokenOrCommentBefore(last);
+                last = sourceCode.getTokenBefore(last, { includeComments: true });
             } while (isComment(last) && last.loc.end.line === blockEnd);
 
             const lastLine = last.loc.end.line;
@@ -182,7 +182,7 @@ module.exports = {
                 }
             } else {
                 if (blockHasTopPadding) {
-                    const nextToken = sourceCode.getTokenOrCommentAfter(openBrace);
+                    const nextToken = sourceCode.getTokenAfter(openBrace, { includeComments: true });
 
                     context.report({
                         node,
@@ -195,7 +195,7 @@ module.exports = {
                 }
 
                 if (blockHasBottomPadding) {
-                    const previousToken = sourceCode.getTokenOrCommentBefore(closeBrace);
+                    const previousToken = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
 
                     context.report({
                         node,

package/lib/rules/prefer-spread.js

@@ -108,7 +108,7 @@ module.exports = {
                                 return null;
                             }
 
-                            const propertyDot = sourceCode.getTokensBetween(applied, node.callee.property).find(token => token.value === ".");
+                            const propertyDot = sourceCode.getFirstTokenBetween(applied, node.callee.property, token => token.value === ".");
 
                             return fixer.replaceTextRange([propertyDot.range[0], node.range[1]], `(...${sourceCode.getText(node.arguments[1])})`);
                         }

package/lib/rules/prefer-template.js

@@ -157,7 +157,7 @@ module.exports = {
             }
 
             if (isConcatenation(currentNode) && hasStringLiteral(currentNode) && hasNonStringLiteral(currentNode)) {
-                const plusSign = sourceCode.getTokensBetween(currentNode.left, currentNode.right).find(token => token.value === "+");
+                const plusSign = sourceCode.getFirstTokenBetween(currentNode.left, currentNode.right, token => token.value === "+");
                 const textBeforePlus = getTextBetween(currentNode.left, plusSign);
                 const textAfterPlus = getTextBetween(plusSign, currentNode.right);
                 const leftEndsWithCurly = endsWithTemplateCurly(currentNode.left);

package/lib/rules/quotes.js

@@ -33,6 +33,9 @@ const QUOTE_SETTINGS = {
     }
 };
 
+// An unescaped newline is a newline preceded by an even number of backslashes.
+const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`);
+
 /**
  * Switches quoting of javascript string between ' " and `
  * escaping and unescaping as necessary.
@@ -254,15 +257,16 @@ module.exports = {
             TemplateLiteral(node) {
 
                 // If backticks are expected or it's a tagged template, then this shouldn't throw an errors
-                if (allowTemplateLiterals || quoteOption === "backtick" || node.parent.type === "TaggedTemplateExpression") {
+                if (
+                    allowTemplateLiterals ||
+                    quoteOption === "backtick" ||
+                    node.parent.type === "TaggedTemplateExpression" && node === node.parent.quasi
+                ) {
                     return;
                 }
 
-                /*
-                 * A warning should be produced if the template literal only has one TemplateElement, and has no unescaped newlines.
-                 * An unescaped newline is a newline preceded by an even number of backslashes.
-                 */
-                const shouldWarn = node.quasis.length === 1 && !/(^|[^\\])(\\\\)*[\r\n\u2028\u2029]/.test(node.quasis[0].value.raw);
+                // A warning should be produced if the template literal only has one TemplateElement, and has no unescaped newlines.
+                const shouldWarn = node.quasis.length === 1 && !UNESCAPED_LINEBREAK_PATTERN.test(node.quasis[0].value.raw);
 
                 if (shouldWarn) {
                     context.report({

package/lib/rules/semi-spacing.js

@@ -206,6 +206,10 @@ module.exports = {
             DebuggerStatement: checkNode,
             ReturnStatement: checkNode,
             ThrowStatement: checkNode,
+            ImportDeclaration: checkNode,
+            ExportNamedDeclaration: checkNode,
+            ExportAllDeclaration: checkNode,
+            ExportDefaultDeclaration: checkNode,
             ForStatement(node) {
                 if (node.init) {
                     checkSemicolonSpacing(sourceCode.getTokenAfter(node.init), node);

package/lib/rules/space-before-function-paren.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -104,7 +110,7 @@ module.exports = {
             const isAnonymousGenerator = node.generator && !isNamed;
             const isNormalArrow = isArrow && !node.async;
             const isArrowWithoutParens = isArrow && sourceCode.getFirstToken(node, 1).value !== "(";
-            let forbidSpacing, requireSpacing, rightToken;
+            let forbidSpacing, requireSpacing;
 
             // isAnonymousGenerator → `generator-star-spacing` should warn it. E.g. `function* () {}`
             // isNormalArrow → ignore always.
@@ -124,10 +130,7 @@ module.exports = {
                 requireSpacing = requireAnonymousFunctionSpacing;
             }
 
-            rightToken = sourceCode.getFirstToken(node);
-            while (rightToken.value !== "(") {
-                rightToken = sourceCode.getTokenAfter(rightToken);
-            }
+            const rightToken = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
             const leftToken = sourceCode.getTokenBefore(rightToken);
             const location = leftToken.loc.end;
 

package/lib/rules/spaced-comment.js

@@ -5,6 +5,7 @@
 "use strict";
 
 const lodash = require("lodash");
+const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -88,8 +89,7 @@ function createExceptionsPattern(exceptions) {
             pattern += exceptions.map(escapeAndRepeat).join("|");
             pattern += ")";
         }
-
-        pattern += "(?:$|[\n\r]))";
+        pattern += `(?:$|[${Array.from(astUtils.LINEBREAKS).join("")}]))`;
     }
 
     return pattern;

package/lib/rules/strict.js

@@ -212,8 +212,8 @@ module.exports = {
          */
         function enterFunction(node) {
             const isBlock = node.body.type === "BlockStatement",
-                useStrictDirectives = isBlock ?
-                    getUseStrictDirectives(node.body.body) : [];
+                useStrictDirectives = isBlock
+                    ? getUseStrictDirectives(node.body.body) : [];
 
             if (mode === "function") {
                 enterFunctionInFunctionMode(node, useStrictDirectives);

package/lib/rules/unicode-bom.js

@@ -45,7 +45,7 @@ module.exports = {
                         loc: location,
                         message: "Expected Unicode BOM (Byte Order Mark).",
                         fix(fixer) {
-                            return fixer.insertTextBefore(node, "\uFEFF");
+                            return fixer.insertTextBeforeRange([0, 1], "\uFEFF");
                         }
                     });
                 } else if (sourceCode.hasBOM && (requireBOM === "never")) {

package/lib/rules/wrap-iife.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
@@ -51,11 +55,7 @@ module.exports = {
          * @private
          */
         function wrapped(node) {
-            const previousToken = sourceCode.getTokenBefore(node),
-                nextToken = sourceCode.getTokenAfter(node);
-
-            return previousToken && previousToken.value === "(" &&
-                nextToken && nextToken.value === ")";
+            return astUtils.isParenthesised(sourceCode, node);
         }
 
         /**

package/lib/rules/yoda.js

@@ -235,12 +235,7 @@ module.exports = {
              *                    paren token.
              */
             function isParenWrapped() {
-                let tokenBefore, tokenAfter;
-
-                return ((tokenBefore = sourceCode.getTokenBefore(node)) &&
-                    tokenBefore.value === "(" &&
-                    (tokenAfter = sourceCode.getTokenAfter(node)) &&
-                    tokenAfter.value === ")");
+                return astUtils.isParenthesised(sourceCode, node);
             }
 
             return (node.type === "LogicalExpression" &&
@@ -269,7 +264,7 @@ module.exports = {
         * @returns {string} A string representation of the node with the sides and operator flipped
         */
         function getFlippedString(node) {
-            const operatorToken = sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+            const operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
             const textBeforeOperator = sourceCode.getText().slice(sourceCode.getTokenBefore(operatorToken).range[1], operatorToken.range[0]);
             const textAfterOperator = sourceCode.getText().slice(operatorToken.range[1], sourceCode.getTokenAfter(operatorToken).range[0]);
             const leftText = sourceCode.getText().slice(sourceCode.getFirstToken(node).range[0], sourceCode.getTokenBefore(operatorToken).range[1]);

package/lib/testers/rule-tester.js

@@ -147,6 +147,12 @@ function RuleTester(testerConfig) {
         lodash.cloneDeep(defaultConfig),
         testerConfig
     );
+
+    /**
+     * Rule definitions to define before tests.
+     * @type {Object}
+     */
+    this.rules = {};
 }
 
 /**
@@ -239,7 +245,7 @@ RuleTester.prototype = {
      * @returns {void}
      */
     defineRule(name, rule) {
-        eslint.defineRule(name, rule);
+        this.rules[name] = rule;
     },
 
     /**
@@ -488,13 +494,12 @@ RuleTester.prototype = {
                         assert.fail(messages[i], null, "Error should be a string or object.");
                     }
                 }
+            }
 
-                if (item.hasOwnProperty("output")) {
-                    const fixResult = SourceCodeFixer.applyFixes(eslint.getSourceCode(), messages);
-
-                    assert.equal(fixResult.output, item.output, "Output is incorrect.");
-                }
+            if (item.hasOwnProperty("output")) {
+                const fixResult = SourceCodeFixer.applyFixes(eslint.getSourceCode(), messages);
 
+                assert.equal(fixResult.output, item.output, "Output is incorrect.");
             }
 
             assertASTDidntChange(result.beforeAST, result.afterAST);
@@ -508,6 +513,7 @@ RuleTester.prototype = {
             RuleTester.describe("valid", () => {
                 test.valid.forEach(valid => {
                     RuleTester.it(valid.code || valid, () => {
+                        eslint.defineRules(this.rules);
                         testValidTemplate(ruleName, valid);
                     });
                 });
@@ -516,6 +522,7 @@ RuleTester.prototype = {
             RuleTester.describe("invalid", () => {
                 test.invalid.forEach(invalid => {
                     RuleTester.it(invalid.code, () => {
+                        eslint.defineRules(this.rules);
                         testInvalidTemplate(ruleName, invalid);
                     });
                 });

package/lib/token-store/backward-token-comment-cursor.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Define the cursor which iterates tokens and comments in reverse.
+ * @author Toru Nagashima
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const Cursor = require("./cursor");
+const utils = require("./utils");
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+/**
+ * The cursor which iterates tokens and comments in reverse.
+ */
+module.exports = class BackwardTokenCommentCursor extends Cursor {
+
+    /**
+     * Initializes this cursor.
+     * @param {Token[]} tokens - The array of tokens.
+     * @param {Comment[]} comments - The array of comments.
+     * @param {Object} indexMap - The map from locations to indices in `tokens`.
+     * @param {number} startLoc - The start location of the iteration range.
+     * @param {number} endLoc - The end location of the iteration range.
+     */
+    constructor(tokens, comments, indexMap, startLoc, endLoc) {
+        super();
+        this.tokens = tokens;
+        this.comments = comments;
+        this.tokenIndex = utils.getLastIndex(tokens, indexMap, endLoc);
+        this.commentIndex = utils.search(comments, endLoc) - 1;
+        this.border = startLoc;
+    }
+
+    /** @inheritdoc */
+    moveNext() {
+        const token = (this.tokenIndex >= 0) ? this.tokens[this.tokenIndex] : null;
+        const comment = (this.commentIndex >= 0) ? this.comments[this.commentIndex] : null;
+
+        if (token && (!comment || token.range[1] > comment.range[1])) {
+            this.current = token;
+            this.tokenIndex -= 1;
+        } else if (comment) {
+            this.current = comment;
+            this.commentIndex -= 1;
+        } else {
+            this.current = null;
+        }
+
+        return Boolean(this.current) && (this.border === -1 || this.current.range[0] >= this.border);
+    }
+};

package/lib/token-store/backward-token-cursor.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Define the cursor which iterates tokens only in reverse.
+ * @author Toru Nagashima
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const Cursor = require("./cursor");
+const utils = require("./utils");
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+/**
+ * The cursor which iterates tokens only in reverse.
+ */
+module.exports = class BackwardTokenCursor extends Cursor {
+
+    /**
+     * Initializes this cursor.
+     * @param {Token[]} tokens - The array of tokens.
+     * @param {Comment[]} comments - The array of comments.
+     * @param {Object} indexMap - The map from locations to indices in `tokens`.
+     * @param {number} startLoc - The start location of the iteration range.
+     * @param {number} endLoc - The end location of the iteration range.
+     */
+    constructor(tokens, comments, indexMap, startLoc, endLoc) {
+        super();
+        this.tokens = tokens;
+        this.index = utils.getLastIndex(tokens, indexMap, endLoc);
+        this.indexEnd = utils.getFirstIndex(tokens, indexMap, startLoc);
+    }
+
+    /** @inheritdoc */
+    moveNext() {
+        if (this.index >= this.indexEnd) {
+            this.current = this.tokens[this.index];
+            this.index -= 1;
+            return true;
+        }
+        return false;
+    }
+
+    //
+    // Shorthand for performance.
+    //
+
+    /** @inheritdoc */
+    getOneToken() {
+        return (this.index >= this.indexEnd) ? this.tokens[this.index] : null;
+    }
+};

package/lib/token-store/cursor.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview Define the abstract class about cursors which iterate tokens.
+ * @author Toru Nagashima
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+/**
+ * The abstract class about cursors which iterate tokens.
+ *
+ * This class has 2 abstract methods.
+ *
+ * - `current: Token | Comment | null` ... The current token.
+ * - `moveNext(): boolean` ... Moves this cursor to the next token. If the next token didn't exist, it returns `false`.
+ *
+ * This is similar to ES2015 Iterators.
+ * However, Iterators were slow (at 2017-01), so I created this class as similar to C# IEnumerable.
+ *
+ * There are the following known sub classes.
+ *
+ * - ForwardTokenCursor .......... The cursor which iterates tokens only.
+ * - BackwardTokenCursor ......... The cursor which iterates tokens only in reverse.
+ * - ForwardTokenCommentCursor ... The cursor which iterates tokens and comments.
+ * - BackwardTokenCommentCursor .. The cursor which iterates tokens and comments in reverse.
+ * - DecorativeCursor
+ *     - FilterCursor ............ The cursor which ignores the specified tokens.
+ *     - SkipCursor .............. The cursor which ignores the first few tokens.
+ *     - LimitCursor ............. The cursor which limits the count of tokens.
+ *
+ */
+module.exports = class Cursor {
+
+    /**
+     * Initializes this cursor.
+     */
+    constructor() {
+        this.current = null;
+    }
+
+    /**
+     * Gets the first token.
+     * This consumes this cursor.
+     * @returns {Token|Comment} The first token or null.
+     */
+    getOneToken() {
+        return this.moveNext() ? this.current : null;
+    }
+
+    /**
+     * Gets the first tokens.
+     * This consumes this cursor.
+     * @returns {(Token|Comment)[]} All tokens.
+     */
+    getAllTokens() {
+        const tokens = [];
+
+        while (this.moveNext()) {
+            tokens.push(this.current);
+        }
+
+        return tokens;
+    }
+
+    /**
+     * Moves this cursor to the next token.
+     * @returns {boolean} `true` if the next token exists.
+     * @abstract
+     */
+    /* istanbul ignore next */
+    moveNext() { // eslint-disable-line class-methods-use-this
+        throw new Error("Not implemented.");
+    }
+};