less 4.4.2 → 4.6.0

package/lib/less/parser/parser-input.js

@@ -1,64 +1,70 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var chunker_1 = tslib_1.__importDefault(require("./chunker"));
-exports.default = (function () {
-    var // Less input string
-    input;
-    var // current chunk
-    j;
-    var // holds state for backtracking
-    saveStack = [];
-    var // furthest index the parser has gone to
-    furthest;
-    var // if this is furthest we got to, this is the probably cause
-    furthestPossibleErrorMessage;
-    var // chunkified input
-    chunks;
-    var // current chunk
-    current;
-    var // index of current chunk, in `input`
-    currentPos;
-    var parserInput = {};
-    var CHARCODE_SPACE = 32;
-    var CHARCODE_TAB = 9;
-    var CHARCODE_LF = 10;
-    var CHARCODE_CR = 13;
-    var CHARCODE_PLUS = 43;
-    var CHARCODE_COMMA = 44;
-    var CHARCODE_FORWARD_SLASH = 47;
-    var CHARCODE_9 = 57;
+export default () => {
+    let // Less input string
+        input;
+
+    let // current chunk
+        j;
+
+    const // holds state for backtracking
+        saveStack = [];
+
+    let // furthest index the parser has gone to
+        furthest;
+
+    let // if this is furthest we got to, this is the probably cause
+        furthestPossibleErrorMessage;
+
+    let // chunkified input
+        chunks;
+
+    let // current chunk
+        current;
+
+    let // index of current chunk, in `input`
+        currentPos;
+
+    const parserInput = {};
+    const CHARCODE_SPACE = 32;
+    const CHARCODE_TAB = 9;
+    const CHARCODE_LF = 10;
+    const CHARCODE_CR = 13;
+    const CHARCODE_PLUS = 43;
+    const CHARCODE_COMMA = 44;
+    const CHARCODE_FORWARD_SLASH = 47;
+    const CHARCODE_9 = 57;
+
     function skipWhitespace(length) {
-        var oldi = parserInput.i;
-        var oldj = j;
-        var curr = parserInput.i - currentPos;
-        var endIndex = parserInput.i + current.length - curr;
-        var mem = (parserInput.i += length);
-        var inp = input;
-        var c;
-        var nextChar;
-        var comment;
+        const oldi = parserInput.i;
+        const oldj = j;
+        const curr = parserInput.i - currentPos;
+        const endIndex = parserInput.i + current.length - curr;
+        const mem = (parserInput.i += length);
+        const inp = input;
+        let c;
+        let nextChar;
+        let comment;
+
         for (; parserInput.i < endIndex; parserInput.i++) {
             c = inp.charCodeAt(parserInput.i);
+
             if (parserInput.autoCommentAbsorb && c === CHARCODE_FORWARD_SLASH) {
                 nextChar = inp.charAt(parserInput.i + 1);
                 if (nextChar === '/') {
-                    comment = { index: parserInput.i, isLineComment: true };
-                    var nextNewLine = inp.indexOf('\n', parserInput.i + 2);
+                    comment = {index: parserInput.i, isLineComment: true};
+                    let nextNewLine = inp.indexOf('\n', parserInput.i + 2);
                     if (nextNewLine < 0) {
                         nextNewLine = endIndex;
                     }
                     parserInput.i = nextNewLine;
-                    comment.text = inp.substr(comment.index, parserInput.i - comment.index);
+                    comment.text = inp.slice(comment.index, parserInput.i);
                     parserInput.commentStore.push(comment);
                     continue;
-                }
-                else if (nextChar === '*') {
-                    var nextStarSlash = inp.indexOf('*/', parserInput.i + 2);
+                } else if (nextChar === '*') {
+                    const nextStarSlash = inp.indexOf('*/', parserInput.i + 2);
                     if (nextStarSlash >= 0) {
                         comment = {
                             index: parserInput.i,
-                            text: inp.substr(parserInput.i, nextStarSlash + 2 - parserInput.i),
+                            text: inp.slice(parserInput.i, nextStarSlash + 2),
                             isLineComment: false
                         };
                         parserInput.i += comment.text.length - 1;
@@ -68,12 +74,15 @@ exports.default = (function () {
                 }
                 break;
             }
+
             if ((c !== CHARCODE_SPACE) && (c !== CHARCODE_LF) && (c !== CHARCODE_TAB) && (c !== CHARCODE_CR)) {
                 break;
             }
         }
+
         current = current.slice(length + parserInput.i - mem + curr);
         currentPos = parserInput.i;
+
         if (!current.length) {
             if (j < chunks.length - 1) {
                 current = chunks[++j];
@@ -82,80 +91,95 @@ exports.default = (function () {
             }
             parserInput.finished = true;
         }
+
         return oldi !== parserInput.i || oldj !== j;
     }
-    parserInput.save = function () {
+
+    parserInput.save = () => {
         currentPos = parserInput.i;
-        saveStack.push({ current: current, i: parserInput.i, j: j });
+        saveStack.push( { current, i: parserInput.i, j });
     };
-    parserInput.restore = function (possibleErrorMessage) {
+    parserInput.restore = possibleErrorMessage => {
+
         if (parserInput.i > furthest || (parserInput.i === furthest && possibleErrorMessage && !furthestPossibleErrorMessage)) {
             furthest = parserInput.i;
             furthestPossibleErrorMessage = possibleErrorMessage;
         }
-        var state = saveStack.pop();
+        const state = saveStack.pop();
         current = state.current;
         currentPos = parserInput.i = state.i;
         j = state.j;
     };
-    parserInput.forget = function () {
+    parserInput.forget = () => {
         saveStack.pop();
     };
-    parserInput.isWhitespace = function (offset) {
-        var pos = parserInput.i + (offset || 0);
-        var code = input.charCodeAt(pos);
+    parserInput.isWhitespace = offset => {
+        const pos = parserInput.i + (offset || 0);
+        const code = input.charCodeAt(pos);
         return (code === CHARCODE_SPACE || code === CHARCODE_CR || code === CHARCODE_TAB || code === CHARCODE_LF);
     };
+
     // Specialization of $(tok)
-    parserInput.$re = function (tok) {
+    parserInput.$re = tok => {
         if (parserInput.i > currentPos) {
             current = current.slice(parserInput.i - currentPos);
             currentPos = parserInput.i;
         }
-        var m = tok.exec(current);
+
+        const m = tok.exec(current);
         if (!m) {
             return null;
         }
+
         skipWhitespace(m[0].length);
         if (typeof m === 'string') {
             return m;
         }
+
         return m.length === 1 ? m[0] : m;
     };
-    parserInput.$char = function (tok) {
+
+    parserInput.$char = tok => {
         if (input.charAt(parserInput.i) !== tok) {
             return null;
         }
         skipWhitespace(1);
         return tok;
     };
-    parserInput.$peekChar = function (tok) {
+
+    parserInput.$peekChar = tok => {
         if (input.charAt(parserInput.i) !== tok) {
             return null;
         }
         return tok;
     };
-    parserInput.$str = function (tok) {
-        var tokLength = tok.length;
+
+    parserInput.$str = tok => {
+        const tokLength = tok.length;
+
         // https://jsperf.com/string-startswith/21
-        for (var i = 0; i < tokLength; i++) {
+        for (let i = 0; i < tokLength; i++) {
             if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
                 return null;
             }
         }
+
         skipWhitespace(tokLength);
         return tok;
     };
-    parserInput.$quoted = function (loc) {
-        var pos = loc || parserInput.i;
-        var startChar = input.charAt(pos);
+
+    parserInput.$quoted = loc => {
+        const pos = loc || parserInput.i;
+        const startChar = input.charAt(pos);
+
         if (startChar !== '\'' && startChar !== '"') {
             return;
         }
-        var length = input.length;
-        var currentPosition = pos;
-        for (var i = 1; i + currentPosition < length; i++) {
-            var nextChar = input.charAt(i + currentPosition);
+        const length = input.length;
+        const currentPosition = pos;
+
+        for (let i = 1; i + currentPosition < length; i++) {
+            const nextChar = input.charAt(i + currentPosition);
             switch (nextChar) {
                 case '\\':
                     i++;
@@ -164,10 +188,10 @@ exports.default = (function () {
                 case '\n':
                     break;
                 case startChar: {
-                    var str = input.substr(currentPosition, i + 1);
+                    const str = input.slice(currentPosition, currentPosition + i + 1);
                     if (!loc && loc !== 0) {
                         skipWhitespace(i + 1);
-                        return str;
+                        return str
                     }
                     return [startChar, str];
                 }
@@ -176,33 +200,35 @@ exports.default = (function () {
         }
         return null;
     };
+
     /**
      * Permissive parsing. Ignores everything except matching {} [] () and quotes
      * until matching token (outside of blocks)
      */
-    parserInput.$parseUntil = function (tok) {
-        var quote = '';
-        var returnVal = null;
-        var inComment = false;
-        var blockDepth = 0;
-        var blockStack = [];
-        var parseGroups = [];
-        var length = input.length;
-        var startPos = parserInput.i;
-        var lastPos = parserInput.i;
-        var i = parserInput.i;
-        var loop = true;
-        var testChar;
+    parserInput.$parseUntil = tok => {
+        let quote = '';
+        let returnVal = null;
+        let inComment = false;
+        let blockDepth = 0;
+        const blockStack = [];
+        const parseGroups = [];
+        const length = input.length;
+        const startPos = parserInput.i;
+        let lastPos = parserInput.i;
+        let i = parserInput.i;
+        let loop = true;
+        let testChar;
+
         if (typeof tok === 'string') {
-            testChar = function (char) { return char === tok; };
-        }
-        else {
-            testChar = function (char) { return tok.test(char); };
+            testChar = char => char === tok
+        } else {
+            testChar = char => tok.test(char)
         }
+
         do {
-            var nextChar = input.charAt(i);
+            let nextChar = input.charAt(i);
             if (blockDepth === 0 && testChar(nextChar)) {
-                returnVal = input.substr(lastPos, i - lastPos);
+                returnVal = input.slice(lastPos, i);
                 if (returnVal) {
                     parseGroups.push(returnVal);
                 }
@@ -211,9 +237,8 @@ exports.default = (function () {
                 }
                 returnVal = parseGroups;
                 skipWhitespace(i - startPos);
-                loop = false;
-            }
-            else {
+                loop = false
+            } else {
                 if (inComment) {
                     if (nextChar === '*' &&
                         input.charAt(i + 1) === '/') {
@@ -228,7 +253,7 @@ exports.default = (function () {
                     case '\\':
                         i++;
                         nextChar = input.charAt(i);
-                        parseGroups.push(input.substr(lastPos, i - lastPos + 1));
+                        parseGroups.push(input.slice(lastPos, i + 1));
                         lastPos = i + 1;
                         break;
                     case '/':
@@ -242,7 +267,7 @@ exports.default = (function () {
                     case '"':
                         quote = parserInput.$quoted(i);
                         if (quote) {
-                            parseGroups.push(input.substr(lastPos, i - lastPos), quote);
+                            parseGroups.push(input.slice(lastPos, i), quote);
                             i += quote[1].length - 1;
                             lastPos = i + 1;
                         }
@@ -267,11 +292,10 @@ exports.default = (function () {
                     case '}':
                     case ')':
                     case ']': {
-                        var expected = blockStack.pop();
+                        const expected = blockStack.pop();
                         if (nextChar === expected) {
                             blockDepth--;
-                        }
-                        else {
+                        } else {
                             // move the parser to the error and return expected
                             skipWhitespace(i - startPos);
                             returnVal = expected;
@@ -285,75 +309,72 @@ exports.default = (function () {
                 }
             }
         } while (loop);
+
         return returnVal ? returnVal : null;
-    };
+    }
+
     parserInput.autoCommentAbsorb = true;
     parserInput.commentStore = [];
     parserInput.finished = false;
+
     // Same as $(), but don't change the state of the parser,
     // just return the match.
-    parserInput.peek = function (tok) {
+    parserInput.peek = tok => {
         if (typeof tok === 'string') {
             // https://jsperf.com/string-startswith/21
-            for (var i = 0; i < tok.length; i++) {
+            for (let i = 0; i < tok.length; i++) {
                 if (input.charAt(parserInput.i + i) !== tok.charAt(i)) {
                     return false;
                 }
             }
             return true;
-        }
-        else {
+        } else {
             return tok.test(current);
         }
     };
+
     // Specialization of peek()
     // TODO remove or change some currentChar calls to peekChar
-    parserInput.peekChar = function (tok) { return input.charAt(parserInput.i) === tok; };
-    parserInput.currentChar = function () { return input.charAt(parserInput.i); };
-    parserInput.prevChar = function () { return input.charAt(parserInput.i - 1); };
-    parserInput.getInput = function () { return input; };
-    parserInput.peekNotNumeric = function () {
-        var c = input.charCodeAt(parserInput.i);
+    parserInput.peekChar = tok => input.charAt(parserInput.i) === tok;
+
+    parserInput.currentChar = () => input.charAt(parserInput.i);
+
+    parserInput.prevChar = () => input.charAt(parserInput.i - 1);
+
+    parserInput.getInput = () => input;
+
+    parserInput.peekNotNumeric = () => {
+        const c = input.charCodeAt(parserInput.i);
         // Is the first char of the dimension 0-9, '.', '+' or '-'
         return (c > CHARCODE_9 || c < CHARCODE_PLUS) || c === CHARCODE_FORWARD_SLASH || c === CHARCODE_COMMA;
     };
-    parserInput.start = function (str, chunkInput, failFunction) {
+
+    parserInput.start = (str) => {
         input = str;
         parserInput.i = j = currentPos = furthest = 0;
-        // chunking apparently makes things quicker (but my tests indicate
-        // it might actually make things slower in node at least)
-        // and it is a non-perfect parse - it can't recognise
-        // unquoted urls, meaning it can't distinguish comments
-        // meaning comments with quotes or {}() in them get 'counted'
-        // and then lead to parse errors.
-        // In addition if the chunking chunks in the wrong place we might
-        // not be able to parse a parser statement in one go
-        // this is officially deprecated but can be switched on via an option
-        // in the case it causes too much performance issues.
-        if (chunkInput) {
-            chunks = (0, chunker_1.default)(str, failFunction);
-        }
-        else {
-            chunks = [str];
-        }
+
+        chunks = [str];
         current = chunks[0];
+
         skipWhitespace(0);
     };
-    parserInput.end = function () {
-        var message;
-        var isFinished = parserInput.i >= input.length;
+
+    parserInput.end = () => {
+        let message;
+        const isFinished = parserInput.i >= input.length;
+
         if (parserInput.i < furthest) {
             message = furthestPossibleErrorMessage;
             parserInput.i = furthest;
         }
         return {
-            isFinished: isFinished,
+            isFinished,
             furthest: parserInput.i,
             furthestPossibleErrorMessage: message,
             furthestReachedEnd: parserInput.i >= input.length - 1,
             furthestChar: input[parserInput.i]
         };
     };
+
     return parserInput;
-});
-//# sourceMappingURL=parser-input.js.map
+};