build: update npm install command to use --legacy-peer-deps
This change modifies the build scripts to use --legacy-peer-deps flag when installing npm dependencies to resolve potential peer dependency conflicts during the build process. The change is applied to both bash (build.sh) and batch (build.bat) build scripts.
This commit is contained in:
Luiz Costa committed
1 parent
20129a1ac7
commit
ac4f232e5e
787 files changed
+82341
-121690
No files matched your search
+280
-356
@@ -15,386 +15,310 @@ const astUtils = require("./utils/ast-utils");
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Formatting rules are being moved out of ESLint core.",
|
||||
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
|
||||
deprecatedSince: "8.53.0",
|
||||
availableUntil: "11.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin",
|
||||
url: "https://eslint.style",
|
||||
},
|
||||
rule: {
|
||||
name: "space-unary-ops",
|
||||
url: "https://eslint.style/rules/space-unary-ops",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "layout",
|
||||
meta: {
|
||||
deprecated: true,
|
||||
replacedBy: [],
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Enforce consistent spacing before or after unary operators",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/space-unary-ops",
|
||||
},
|
||||
docs: {
|
||||
description: "Enforce consistent spacing before or after unary operators",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/space-unary-ops"
|
||||
},
|
||||
|
||||
fixable: "whitespace",
|
||||
fixable: "whitespace",
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
words: {
|
||||
type: "boolean",
|
||||
default: true,
|
||||
},
|
||||
nonwords: {
|
||||
type: "boolean",
|
||||
default: false,
|
||||
},
|
||||
overrides: {
|
||||
type: "object",
|
||||
additionalProperties: {
|
||||
type: "boolean",
|
||||
},
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
messages: {
|
||||
unexpectedBefore:
|
||||
"Unexpected space before unary operator '{{operator}}'.",
|
||||
unexpectedAfter:
|
||||
"Unexpected space after unary operator '{{operator}}'.",
|
||||
unexpectedAfterWord:
|
||||
"Unexpected space after unary word operator '{{word}}'.",
|
||||
wordOperator:
|
||||
"Unary word operator '{{word}}' must be followed by whitespace.",
|
||||
operator:
|
||||
"Unary operator '{{operator}}' must be followed by whitespace.",
|
||||
beforeUnaryExpressions:
|
||||
"Space is required before unary expressions '{{token}}'.",
|
||||
},
|
||||
},
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
words: {
|
||||
type: "boolean",
|
||||
default: true
|
||||
},
|
||||
nonwords: {
|
||||
type: "boolean",
|
||||
default: false
|
||||
},
|
||||
overrides: {
|
||||
type: "object",
|
||||
additionalProperties: {
|
||||
type: "boolean"
|
||||
}
|
||||
}
|
||||
},
|
||||
additionalProperties: false
|
||||
}
|
||||
],
|
||||
messages: {
|
||||
unexpectedBefore: "Unexpected space before unary operator '{{operator}}'.",
|
||||
unexpectedAfter: "Unexpected space after unary operator '{{operator}}'.",
|
||||
unexpectedAfterWord: "Unexpected space after unary word operator '{{word}}'.",
|
||||
wordOperator: "Unary word operator '{{word}}' must be followed by whitespace.",
|
||||
operator: "Unary operator '{{operator}}' must be followed by whitespace.",
|
||||
beforeUnaryExpressions: "Space is required before unary expressions '{{token}}'."
|
||||
}
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const options = context.options[0] || { words: true, nonwords: false };
|
||||
create(context) {
|
||||
const options = context.options[0] || { words: true, nonwords: false };
|
||||
|
||||
const sourceCode = context.sourceCode;
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Check if the node is the first "!" in a "!!" convert to Boolean expression
|
||||
* @param {ASTnode} node AST node
|
||||
* @returns {boolean} Whether or not the node is first "!" in "!!"
|
||||
*/
|
||||
function isFirstBangInBangBangExpression(node) {
|
||||
return (
|
||||
node &&
|
||||
node.type === "UnaryExpression" &&
|
||||
node.argument.operator === "!" &&
|
||||
node.argument &&
|
||||
node.argument.type === "UnaryExpression" &&
|
||||
node.argument.operator === "!"
|
||||
);
|
||||
}
|
||||
/**
|
||||
* Check if the node is the first "!" in a "!!" convert to Boolean expression
|
||||
* @param {ASTnode} node AST node
|
||||
* @returns {boolean} Whether or not the node is first "!" in "!!"
|
||||
*/
|
||||
function isFirstBangInBangBangExpression(node) {
|
||||
return node && node.type === "UnaryExpression" && node.argument.operator === "!" &&
|
||||
node.argument && node.argument.type === "UnaryExpression" && node.argument.operator === "!";
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if an override exists for a given operator.
|
||||
* @param {string} operator Operator
|
||||
* @returns {boolean} Whether or not an override has been provided for the operator
|
||||
*/
|
||||
function overrideExistsForOperator(operator) {
|
||||
return (
|
||||
options.overrides && Object.hasOwn(options.overrides, operator)
|
||||
);
|
||||
}
|
||||
/**
|
||||
* Checks if an override exists for a given operator.
|
||||
* @param {string} operator Operator
|
||||
* @returns {boolean} Whether or not an override has been provided for the operator
|
||||
*/
|
||||
function overrideExistsForOperator(operator) {
|
||||
return options.overrides && Object.prototype.hasOwnProperty.call(options.overrides, operator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the value that the override was set to for this operator
|
||||
* @param {string} operator Operator
|
||||
* @returns {boolean} Whether or not an override enforces a space with this operator
|
||||
*/
|
||||
function overrideEnforcesSpaces(operator) {
|
||||
return options.overrides[operator];
|
||||
}
|
||||
/**
|
||||
* Gets the value that the override was set to for this operator
|
||||
* @param {string} operator Operator
|
||||
* @returns {boolean} Whether or not an override enforces a space with this operator
|
||||
*/
|
||||
function overrideEnforcesSpaces(operator) {
|
||||
return options.overrides[operator];
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify Unary Word Operator has spaces after the word operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken first token from the AST node
|
||||
* @param {Object} secondToken second token from the AST node
|
||||
* @param {string} word The word to be used for reporting
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyWordHasSpaces(node, firstToken, secondToken, word) {
|
||||
if (secondToken.range[0] === firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "wordOperator",
|
||||
data: {
|
||||
word,
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.insertTextAfter(firstToken, " ");
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Verify Unary Word Operator has spaces after the word operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken first token from the AST node
|
||||
* @param {Object} secondToken second token from the AST node
|
||||
* @param {string} word The word to be used for reporting
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyWordHasSpaces(node, firstToken, secondToken, word) {
|
||||
if (secondToken.range[0] === firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "wordOperator",
|
||||
data: {
|
||||
word
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.insertTextAfter(firstToken, " ");
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify Unary Word Operator doesn't have spaces after the word operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken first token from the AST node
|
||||
* @param {Object} secondToken second token from the AST node
|
||||
* @param {string} word The word to be used for reporting
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyWordDoesntHaveSpaces(
|
||||
node,
|
||||
firstToken,
|
||||
secondToken,
|
||||
word,
|
||||
) {
|
||||
if (astUtils.canTokensBeAdjacent(firstToken, secondToken)) {
|
||||
if (secondToken.range[0] > firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedAfterWord",
|
||||
data: {
|
||||
word,
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.removeRange([
|
||||
firstToken.range[1],
|
||||
secondToken.range[0],
|
||||
]);
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Verify Unary Word Operator doesn't have spaces after the word operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken first token from the AST node
|
||||
* @param {Object} secondToken second token from the AST node
|
||||
* @param {string} word The word to be used for reporting
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word) {
|
||||
if (astUtils.canTokensBeAdjacent(firstToken, secondToken)) {
|
||||
if (secondToken.range[0] > firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedAfterWord",
|
||||
data: {
|
||||
word
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check Unary Word Operators for spaces after the word operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken first token from the AST node
|
||||
* @param {Object} secondToken second token from the AST node
|
||||
* @param {string} word The word to be used for reporting
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkUnaryWordOperatorForSpaces(
|
||||
node,
|
||||
firstToken,
|
||||
secondToken,
|
||||
word,
|
||||
) {
|
||||
if (overrideExistsForOperator(word)) {
|
||||
if (overrideEnforcesSpaces(word)) {
|
||||
verifyWordHasSpaces(node, firstToken, secondToken, word);
|
||||
} else {
|
||||
verifyWordDoesntHaveSpaces(
|
||||
node,
|
||||
firstToken,
|
||||
secondToken,
|
||||
word,
|
||||
);
|
||||
}
|
||||
} else if (options.words) {
|
||||
verifyWordHasSpaces(node, firstToken, secondToken, word);
|
||||
} else {
|
||||
verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Check Unary Word Operators for spaces after the word operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken first token from the AST node
|
||||
* @param {Object} secondToken second token from the AST node
|
||||
* @param {string} word The word to be used for reporting
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, word) {
|
||||
if (overrideExistsForOperator(word)) {
|
||||
if (overrideEnforcesSpaces(word)) {
|
||||
verifyWordHasSpaces(node, firstToken, secondToken, word);
|
||||
} else {
|
||||
verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);
|
||||
}
|
||||
} else if (options.words) {
|
||||
verifyWordHasSpaces(node, firstToken, secondToken, word);
|
||||
} else {
|
||||
verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies YieldExpressions satisfy spacing requirements
|
||||
* @param {ASTnode} node AST node
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSpacesAfterYield(node) {
|
||||
const tokens = sourceCode.getFirstTokens(node, 3),
|
||||
word = "yield";
|
||||
/**
|
||||
* Verifies YieldExpressions satisfy spacing requirements
|
||||
* @param {ASTnode} node AST node
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSpacesAfterYield(node) {
|
||||
const tokens = sourceCode.getFirstTokens(node, 3),
|
||||
word = "yield";
|
||||
|
||||
if (!node.argument || node.delegate) {
|
||||
return;
|
||||
}
|
||||
if (!node.argument || node.delegate) {
|
||||
return;
|
||||
}
|
||||
|
||||
checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], word);
|
||||
}
|
||||
checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], word);
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies AwaitExpressions satisfy spacing requirements
|
||||
* @param {ASTNode} node AwaitExpression AST node
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSpacesAfterAwait(node) {
|
||||
const tokens = sourceCode.getFirstTokens(node, 3);
|
||||
/**
|
||||
* Verifies AwaitExpressions satisfy spacing requirements
|
||||
* @param {ASTNode} node AwaitExpression AST node
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSpacesAfterAwait(node) {
|
||||
const tokens = sourceCode.getFirstTokens(node, 3);
|
||||
|
||||
checkUnaryWordOperatorForSpaces(
|
||||
node,
|
||||
tokens[0],
|
||||
tokens[1],
|
||||
"await",
|
||||
);
|
||||
}
|
||||
checkUnaryWordOperatorForSpaces(node, tokens[0], tokens[1], "await");
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies UnaryExpression, UpdateExpression and NewExpression have spaces before or after the operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken First token in the expression
|
||||
* @param {Object} secondToken Second token in the expression
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyNonWordsHaveSpaces(node, firstToken, secondToken) {
|
||||
if (node.prefix) {
|
||||
if (isFirstBangInBangBangExpression(node)) {
|
||||
return;
|
||||
}
|
||||
if (firstToken.range[1] === secondToken.range[0]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "operator",
|
||||
data: {
|
||||
operator: firstToken.value,
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.insertTextAfter(firstToken, " ");
|
||||
},
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (firstToken.range[1] === secondToken.range[0]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "beforeUnaryExpressions",
|
||||
data: {
|
||||
token: secondToken.value,
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.insertTextBefore(secondToken, " ");
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Verifies UnaryExpression, UpdateExpression and NewExpression have spaces before or after the operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken First token in the expression
|
||||
* @param {Object} secondToken Second token in the expression
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyNonWordsHaveSpaces(node, firstToken, secondToken) {
|
||||
if (node.prefix) {
|
||||
if (isFirstBangInBangBangExpression(node)) {
|
||||
return;
|
||||
}
|
||||
if (firstToken.range[1] === secondToken.range[0]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "operator",
|
||||
data: {
|
||||
operator: firstToken.value
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.insertTextAfter(firstToken, " ");
|
||||
}
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (firstToken.range[1] === secondToken.range[0]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "beforeUnaryExpressions",
|
||||
data: {
|
||||
token: secondToken.value
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.insertTextBefore(secondToken, " ");
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies UnaryExpression, UpdateExpression and NewExpression don't have spaces before or after the operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken First token in the expression
|
||||
* @param {Object} secondToken Second token in the expression
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyNonWordsDontHaveSpaces(node, firstToken, secondToken) {
|
||||
if (node.prefix) {
|
||||
if (secondToken.range[0] > firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedAfter",
|
||||
data: {
|
||||
operator: firstToken.value,
|
||||
},
|
||||
fix(fixer) {
|
||||
if (
|
||||
astUtils.canTokensBeAdjacent(
|
||||
firstToken,
|
||||
secondToken,
|
||||
)
|
||||
) {
|
||||
return fixer.removeRange([
|
||||
firstToken.range[1],
|
||||
secondToken.range[0],
|
||||
]);
|
||||
}
|
||||
return null;
|
||||
},
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (secondToken.range[0] > firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedBefore",
|
||||
data: {
|
||||
operator: secondToken.value,
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.removeRange([
|
||||
firstToken.range[1],
|
||||
secondToken.range[0],
|
||||
]);
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Verifies UnaryExpression, UpdateExpression and NewExpression don't have spaces before or after the operator
|
||||
* @param {ASTnode} node AST node
|
||||
* @param {Object} firstToken First token in the expression
|
||||
* @param {Object} secondToken Second token in the expression
|
||||
* @returns {void}
|
||||
*/
|
||||
function verifyNonWordsDontHaveSpaces(node, firstToken, secondToken) {
|
||||
if (node.prefix) {
|
||||
if (secondToken.range[0] > firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedAfter",
|
||||
data: {
|
||||
operator: firstToken.value
|
||||
},
|
||||
fix(fixer) {
|
||||
if (astUtils.canTokensBeAdjacent(firstToken, secondToken)) {
|
||||
return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
});
|
||||
}
|
||||
} else {
|
||||
if (secondToken.range[0] > firstToken.range[1]) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedBefore",
|
||||
data: {
|
||||
operator: secondToken.value
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verifies UnaryExpression, UpdateExpression and NewExpression satisfy spacing requirements
|
||||
* @param {ASTnode} node AST node
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSpaces(node) {
|
||||
const tokens =
|
||||
node.type === "UpdateExpression" && !node.prefix
|
||||
? sourceCode.getLastTokens(node, 2)
|
||||
: sourceCode.getFirstTokens(node, 2);
|
||||
const firstToken = tokens[0];
|
||||
const secondToken = tokens[1];
|
||||
/**
|
||||
* Verifies UnaryExpression, UpdateExpression and NewExpression satisfy spacing requirements
|
||||
* @param {ASTnode} node AST node
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkForSpaces(node) {
|
||||
const tokens = node.type === "UpdateExpression" && !node.prefix
|
||||
? sourceCode.getLastTokens(node, 2)
|
||||
: sourceCode.getFirstTokens(node, 2);
|
||||
const firstToken = tokens[0];
|
||||
const secondToken = tokens[1];
|
||||
|
||||
if (
|
||||
(node.type === "NewExpression" || node.prefix) &&
|
||||
firstToken.type === "Keyword"
|
||||
) {
|
||||
checkUnaryWordOperatorForSpaces(
|
||||
node,
|
||||
firstToken,
|
||||
secondToken,
|
||||
firstToken.value,
|
||||
);
|
||||
return;
|
||||
}
|
||||
if ((node.type === "NewExpression" || node.prefix) && firstToken.type === "Keyword") {
|
||||
checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, firstToken.value);
|
||||
return;
|
||||
}
|
||||
|
||||
const operator = node.prefix ? tokens[0].value : tokens[1].value;
|
||||
const operator = node.prefix ? tokens[0].value : tokens[1].value;
|
||||
|
||||
if (overrideExistsForOperator(operator)) {
|
||||
if (overrideEnforcesSpaces(operator)) {
|
||||
verifyNonWordsHaveSpaces(node, firstToken, secondToken);
|
||||
} else {
|
||||
verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);
|
||||
}
|
||||
} else if (options.nonwords) {
|
||||
verifyNonWordsHaveSpaces(node, firstToken, secondToken);
|
||||
} else {
|
||||
verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);
|
||||
}
|
||||
}
|
||||
if (overrideExistsForOperator(operator)) {
|
||||
if (overrideEnforcesSpaces(operator)) {
|
||||
verifyNonWordsHaveSpaces(node, firstToken, secondToken);
|
||||
} else {
|
||||
verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);
|
||||
}
|
||||
} else if (options.nonwords) {
|
||||
verifyNonWordsHaveSpaces(node, firstToken, secondToken);
|
||||
} else {
|
||||
verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public
|
||||
//--------------------------------------------------------------------------
|
||||
//--------------------------------------------------------------------------
|
||||
// Public
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
UnaryExpression: checkForSpaces,
|
||||
UpdateExpression: checkForSpaces,
|
||||
NewExpression: checkForSpaces,
|
||||
YieldExpression: checkForSpacesAfterYield,
|
||||
AwaitExpression: checkForSpacesAfterAwait,
|
||||
};
|
||||
},
|
||||
return {
|
||||
UnaryExpression: checkForSpaces,
|
||||
UpdateExpression: checkForSpaces,
|
||||
NewExpression: checkForSpaces,
|
||||
YieldExpression: checkForSpacesAfterYield,
|
||||
AwaitExpression: checkForSpacesAfterAwait
|
||||
};
|
||||
|
||||
}
|
||||
};
|
||||
Reference in new issue
Block a user