update
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier
|
||||
* @author Ian Christian Myers
|
||||
* @deprecated in ESLint v5.1.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow `catch` clause parameters from shadowing variables in the outer scope",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-catch-shadow",
|
||||
},
|
||||
|
||||
deprecated: {
|
||||
message: "This rule was renamed.",
|
||||
url: "https://eslint.org/blog/2018/07/eslint-v5.1.0-released/",
|
||||
deprecatedSince: "5.1.0",
|
||||
availableUntil: null,
|
||||
replacedBy: [
|
||||
{
|
||||
rule: {
|
||||
name: "no-shadow",
|
||||
url: "https://eslint.org/docs/rules/no-shadow",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
mutable:
|
||||
"Value of '{{name}}' may be overwritten in IE 8 and earlier.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Check if the parameters are been shadowed
|
||||
* @param {Object} scope current scope
|
||||
* @param {string} name parameter name
|
||||
* @returns {boolean} True is its been shadowed
|
||||
*/
|
||||
function paramIsShadowing(scope, name) {
|
||||
return astUtils.getVariableByName(scope, name) !== null;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public API
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
"CatchClause[param!=null]"(node) {
|
||||
let scope = sourceCode.getScope(node);
|
||||
|
||||
/*
|
||||
* When ecmaVersion >= 6, CatchClause creates its own scope
|
||||
* so start from one upper scope to exclude the current node
|
||||
*/
|
||||
if (scope.block === node) {
|
||||
scope = scope.upper;
|
||||
}
|
||||
|
||||
if (paramIsShadowing(scope, node.param.name)) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "mutable",
|
||||
data: { name: node.param.name },
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,23 @@
|
||||
var test = require('tape');
|
||||
var equal = require('../');
|
||||
|
||||
test('equal', function (t) {
|
||||
t.ok(equal(
|
||||
{ a : [ 2, 3 ], b : [ 4 ] },
|
||||
{ a : [ 2, 3 ], b : [ 4 ] }
|
||||
));
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('not equal', function (t) {
|
||||
t.notOk(equal(
|
||||
{ x : 5, y : [6] },
|
||||
{ x : 5, y : 6 }
|
||||
));
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('nested nulls', function (t) {
|
||||
t.ok(equal([ null, null, null ], [ null, null, null ]));
|
||||
t.end();
|
||||
});
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={C:{"49":0.00165,"64":0.00165,"81":0.00165,"84":0.0033,"94":0.00165,"112":0.0033,"115":0.02803,"127":0.00165,"128":0.01814,"133":0.00165,"134":0.00495,"135":0.20118,"136":0.54912,_:"2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 50 51 52 53 54 55 56 57 58 59 60 61 62 63 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 82 83 85 86 87 88 89 90 91 92 93 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 113 114 116 117 118 119 120 121 122 123 124 125 126 129 130 131 132 137 138 139 140 3.5 3.6"},D:{"22":0.0033,"37":0.00165,"39":0.00165,"42":0.00165,"44":0.00165,"46":0.00825,"47":0.00825,"59":0.00165,"64":0.01154,"65":0.00165,"67":0.00989,"68":0.02803,"69":0.00165,"73":0.00165,"74":0.00165,"75":0.00165,"76":0.00825,"79":0.00165,"80":0.00495,"81":0.00165,"83":0.00165,"84":0.00165,"86":0.0033,"87":0.00989,"88":0.00495,"89":0.00165,"90":0.0066,"92":0.01484,"93":0.01649,"94":0.0066,"96":0.00165,"97":0.00165,"98":0.00165,"100":0.00165,"102":0.00989,"103":0.02968,"104":0.00165,"105":0.00495,"106":0.00165,"108":0.00495,"109":0.16325,"111":0.03463,"114":0.01814,"115":0.00495,"116":0.01814,"117":0.00495,"118":0.01814,"119":0.0033,"120":0.00825,"121":0.00495,"122":0.02474,"123":0.00825,"124":0.01814,"125":0.01814,"126":0.03463,"127":0.01814,"128":0.03133,"129":0.01649,"130":0.02474,"131":0.18964,"132":0.10059,"133":1.27303,"134":2.3086,"135":0.00495,_:"4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 23 24 25 26 27 28 29 30 31 32 33 34 35 36 38 40 41 43 45 48 49 50 51 52 53 54 55 56 57 58 60 61 62 63 66 70 71 72 77 78 85 91 95 99 101 107 110 112 113 136 137 138"},F:{"35":0.00495,"36":0.00825,"40":0.00165,"46":0.0033,"86":0.00165,"87":0.0907,"88":0.00165,"95":0.0066,"99":0.0033,"101":0.00165,"112":0.00165,"113":0.00165,"114":0.0033,"115":0.0033,"116":0.01814,"117":0.36938,_:"9 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 37 38 39 41 42 43 44 45 47 48 49 50 51 52 53 54 55 56 57 58 60 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 89 90 91 92 93 94 96 97 98 100 102 103 104 105 106 107 108 109 110 111 9.5-9.6 10.0-10.1 10.5 10.6 11.1 11.5 11.6 12.1"},B:{"12":0.01979,"13":0.0066,"14":0.0066,"15":0.00165,"16":0.0033,"17":0.00165,"18":0.05112,"84":0.0066,"89":0.00989,"90":0.01154,"91":0.00165,"92":0.06101,"99":0.00825,"100":0.01154,"102":0.00825,"107":0.00165,"108":0.00165,"109":0.0033,"110":0.00165,"111":0.00165,"112":0.00165,"114":0.00165,"118":0.00165,"119":0.00825,"120":0.03793,"122":0.00825,"123":0.0033,"124":0.0066,"125":0.00165,"126":0.00495,"127":0.0066,"128":0.04782,"129":0.02144,"130":0.02968,"131":0.10883,"132":0.04452,"133":0.6662,"134":1.09659,_:"79 80 81 83 85 86 87 88 93 94 95 96 97 98 101 103 104 105 106 113 115 116 117 121"},E:{"10":0.00165,"11":0.00495,"13":0.0066,_:"0 4 5 6 7 8 9 12 14 15 3.1 3.2 5.1 6.1 7.1 9.1 10.1 12.1 15.1 15.2-15.3 15.4 15.5 16.2 17.0 17.3","11.1":0.0033,"13.1":0.01814,"14.1":0.01154,"15.6":0.01319,"16.0":0.00165,"16.1":0.00165,"16.3":0.0033,"16.4":0.00165,"16.5":0.00989,"16.6":0.01649,"17.1":0.01154,"17.2":0.0033,"17.4":0.00825,"17.5":0.01319,"17.6":0.11543,"18.0":0.0066,"18.1":0.00495,"18.2":0.00495,"18.3":0.09564,"18.4":0.00165},G:{"8":0,"3.2":0,"4.0-4.1":0,"4.2-4.3":0.0011,"5.0-5.1":0,"6.0-6.1":0.0033,"7.0-7.1":0.0022,"8.1-8.4":0,"9.0-9.2":0.00165,"9.3":0.0077,"10.0-10.2":0.00055,"10.3":0.01266,"11.0-11.2":0.05834,"11.3-11.4":0.00385,"12.0-12.1":0.0022,"12.2-12.5":0.05448,"13.0-13.1":0.0011,"13.2":0.00165,"13.3":0.0022,"13.4-13.7":0.0077,"14.0-14.4":0.01926,"14.5-14.8":0.02311,"15.0-15.1":0.01266,"15.2-15.3":0.01266,"15.4":0.01541,"15.5":0.01761,"15.6-15.8":0.21683,"16.0":0.03082,"16.1":0.06329,"16.2":0.03302,"16.3":0.05723,"16.4":0.01266,"16.5":0.02366,"16.6-16.7":0.257,"17.0":0.01541,"17.1":0.02752,"17.2":0.02091,"17.3":0.02917,"17.4":0.05834,"17.5":0.12988,"17.6-17.7":0.37698,"18.0":0.10566,"18.1":0.34561,"18.2":0.15464,"18.3":3.23209,"18.4":0.04788},P:{"4":0.04002,"20":0.01,"21":0.01,"22":0.06002,"23":0.04002,"24":0.11004,"25":0.10004,"26":0.09003,"27":0.40015,_:"5.0-5.4 8.2 10.1 12.0 14.0 15.0 17.0 18.0","6.2-6.4":0.01,"7.2-7.4":0.02001,"9.2":0.01,"11.1-11.2":0.02001,"13.0":0.01,"16.0":0.02001,"19.0":0.01},I:{"0":0.04167,"3":0,"4":0,"2.1":0,"2.2":0,"2.3":0,"4.1":0,"4.2-4.3":0.00001,"4.4":0,"4.4.3-4.4.4":0.00005},K:{"0":3.04601,_:"10 11 12 11.1 11.5 12.1"},A:{"10":0.00406,"11":0.02232,_:"6 7 8 9 5.5"},S:{"2.5":0.00835,_:"3.0-3.1"},J:{_:"7 10"},N:{_:"10 11"},R:{_:"0"},M:{"0":0.07516},Q:{"14.9":0.05011},O:{"0":0.48436},H:{"0":4.52},L:{"0":76.33148}};
|
||||
Binary file not shown.
@@ -0,0 +1,3 @@
|
||||
import type { OutlineContextType } from './shared/types.js';
|
||||
declare const outlineContext: React.Context<OutlineContextType>;
|
||||
export default outlineContext;
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"names":["_iterableToArrayLimit","arr","i","iterator","Symbol","_arr","iteratorNormalCompletion","didIteratorError","step","iteratorError","next","_return","call","Object","done","push","value","length","err"],"sources":["../../src/helpers/iterableToArrayLimit.ts"],"sourcesContent":["/* @minVersion 7.0.0-beta.0 */\n\nexport default function _iterableToArrayLimit<T>(arr: Iterable<T>, i: number) {\n // this is an expanded form of \\`for...of\\` that properly supports abrupt completions of\n // iterators etc.\n\n var iterator: Iterator<T> =\n arr == null\n ? null\n : (typeof Symbol !== \"undefined\" && arr[Symbol.iterator]) ||\n (arr as any)[\"@@iterator\"];\n if (iterator == null) return;\n\n var _arr: T[] = [];\n var iteratorNormalCompletion = true;\n var didIteratorError = false;\n var step, iteratorError, next, _return;\n try {\n next = (iterator = (iterator as unknown as Function).call(arr)).next;\n if (i === 0) {\n if (Object(iterator) !== iterator) return;\n iteratorNormalCompletion = false;\n } else {\n for (\n ;\n !(iteratorNormalCompletion = (step = next.call(iterator)).done);\n iteratorNormalCompletion = true\n ) {\n _arr.push(step.value);\n if (_arr.length === i) break;\n }\n }\n } catch (err) {\n didIteratorError = true;\n iteratorError = err;\n } finally {\n try {\n if (!iteratorNormalCompletion && iterator[\"return\"] != null) {\n _return = iterator[\"return\"]();\n // eslint-disable-next-line no-unsafe-finally\n if (Object(_return) !== _return) return;\n }\n } finally {\n // eslint-disable-next-line no-unsafe-finally\n if (didIteratorError) throw iteratorError;\n }\n }\n return _arr;\n}\n"],"mappings":";;;;;;AAEe,SAASA,qBAAqBA,CAAIC,GAAgB,EAAEC,CAAS,EAAE;EAI5E,IAAIC,QAAqB,GACvBF,GAAG,IAAI,IAAI,GACP,IAAI,GACH,OAAOG,MAAM,KAAK,WAAW,IAAIH,GAAG,CAACG,MAAM,CAACD,QAAQ,CAAC,IACrDF,GAAG,CAAS,YAAY,CAAC;EAChC,IAAIE,QAAQ,IAAI,IAAI,EAAE;EAEtB,IAAIE,IAAS,GAAG,EAAE;EAClB,IAAIC,wBAAwB,GAAG,IAAI;EACnC,IAAIC,gBAAgB,GAAG,KAAK;EAC5B,IAAIC,IAAI,EAAEC,aAAa,EAAEC,IAAI,EAAEC,OAAO;EACtC,IAAI;IACFD,IAAI,GAAG,CAACP,QAAQ,GAAIA,QAAQ,CAAyBS,IAAI,CAACX,GAAG,CAAC,EAAES,IAAI;IACpE,IAAIR,CAAC,KAAK,CAAC,EAAE;MACX,IAAIW,MAAM,CAACV,QAAQ,CAAC,KAAKA,QAAQ,EAAE;MACnCG,wBAAwB,GAAG,KAAK;IAClC,CAAC,MAAM;MACL,OAEE,EAAEA,wBAAwB,GAAG,CAACE,IAAI,GAAGE,IAAI,CAACE,IAAI,CAACT,QAAQ,CAAC,EAAEW,IAAI,CAAC,EAC/DR,wBAAwB,GAAG,IAAI,EAC/B;QACAD,IAAI,CAACU,IAAI,CAACP,IAAI,CAACQ,KAAK,CAAC;QACrB,IAAIX,IAAI,CAACY,MAAM,KAAKf,CAAC,EAAE;MACzB;IACF;EACF,CAAC,CAAC,OAAOgB,GAAG,EAAE;IACZX,gBAAgB,GAAG,IAAI;IACvBE,aAAa,GAAGS,GAAG;EACrB,CAAC,SAAS;IACR,IAAI;MACF,IAAI,CAACZ,wBAAwB,IAAIH,QAAQ,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE;QAC3DQ,OAAO,GAAGR,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QAE9B,IAAIU,MAAM,CAACF,OAAO,CAAC,KAAKA,OAAO,EAAE;MACnC;IACF,CAAC,SAAS;MAER,IAAIJ,gBAAgB,EAAE,MAAME,aAAa;IAC3C;EACF;EACA,OAAOJ,IAAI;AACb","ignoreList":[]}
|
||||
@@ -0,0 +1,22 @@
|
||||
{
|
||||
"name": "@rollup/rollup-linux-arm64-gnu",
|
||||
"version": "4.39.0",
|
||||
"os": [
|
||||
"linux"
|
||||
],
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
"files": [
|
||||
"rollup.linux-arm64-gnu.node"
|
||||
],
|
||||
"description": "Native bindings for Rollup",
|
||||
"author": "Lukas Taegert-Atkinson",
|
||||
"homepage": "https://rollupjs.org/",
|
||||
"license": "MIT",
|
||||
"repository": "rollup/rollup",
|
||||
"libc": [
|
||||
"glibc"
|
||||
],
|
||||
"main": "./rollup.linux-arm64-gnu.node"
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
/**
|
||||
* @fileoverview Require or disallow newlines around directives.
|
||||
* @author Kai Cataldo
|
||||
* @deprecated in ESLint v4.0.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description: "Require or disallow newlines around directives",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/lines-around-directive",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
oneOf: [
|
||||
{
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
before: {
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
after: {
|
||||
enum: ["always", "never"],
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
minProperties: 2,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
|
||||
fixable: "whitespace",
|
||||
messages: {
|
||||
expected: 'Expected newline {{location}} "{{value}}" directive.',
|
||||
unexpected:
|
||||
'Unexpected newline {{location}} "{{value}}" directive.',
|
||||
},
|
||||
deprecated: {
|
||||
message: "The rule was replaced with a more general rule.",
|
||||
url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/",
|
||||
deprecatedSince: "4.0.0",
|
||||
availableUntil: null,
|
||||
replacedBy: [
|
||||
{
|
||||
message: "The new rule moved to a plugin.",
|
||||
url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin-js",
|
||||
url: "https://eslint.style/packages/js",
|
||||
},
|
||||
rule: {
|
||||
name: "padding-line-between-statements",
|
||||
url: "https://eslint.style/rules/js/padding-line-between-statements",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
const config = context.options[0] || "always";
|
||||
const expectLineBefore =
|
||||
typeof config === "string" ? config : config.before;
|
||||
const expectLineAfter =
|
||||
typeof config === "string" ? config : config.after;
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Check if node is preceded by a blank newline.
|
||||
* @param {ASTNode} node Node to check.
|
||||
* @returns {boolean} Whether or not the passed in node is preceded by a blank newline.
|
||||
*/
|
||||
function hasNewlineBefore(node) {
|
||||
const tokenBefore = sourceCode.getTokenBefore(node, {
|
||||
includeComments: true,
|
||||
});
|
||||
const tokenLineBefore = tokenBefore ? tokenBefore.loc.end.line : 0;
|
||||
|
||||
return node.loc.start.line - tokenLineBefore >= 2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the last token of a node that is on the same line as the rest of the node.
|
||||
* This will usually be the last token of the node, but it will be the second-to-last token if the node has a trailing
|
||||
* semicolon on a different line.
|
||||
* @param {ASTNode} node A directive node
|
||||
* @returns {Token} The last token of the node on the line
|
||||
*/
|
||||
function getLastTokenOnLine(node) {
|
||||
const lastToken = sourceCode.getLastToken(node);
|
||||
const secondToLastToken = sourceCode.getTokenBefore(lastToken);
|
||||
|
||||
return astUtils.isSemicolonToken(lastToken) &&
|
||||
lastToken.loc.start.line > secondToLastToken.loc.end.line
|
||||
? secondToLastToken
|
||||
: lastToken;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if node is followed by a blank newline.
|
||||
* @param {ASTNode} node Node to check.
|
||||
* @returns {boolean} Whether or not the passed in node is followed by a blank newline.
|
||||
*/
|
||||
function hasNewlineAfter(node) {
|
||||
const lastToken = getLastTokenOnLine(node);
|
||||
const tokenAfter = sourceCode.getTokenAfter(lastToken, {
|
||||
includeComments: true,
|
||||
});
|
||||
|
||||
return tokenAfter.loc.start.line - lastToken.loc.end.line >= 2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Report errors for newlines around directives.
|
||||
* @param {ASTNode} node Node to check.
|
||||
* @param {string} location Whether the error was found before or after the directive.
|
||||
* @param {boolean} expected Whether or not a newline was expected or unexpected.
|
||||
* @returns {void}
|
||||
*/
|
||||
function reportError(node, location, expected) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: expected ? "expected" : "unexpected",
|
||||
data: {
|
||||
value: node.expression.value,
|
||||
location,
|
||||
},
|
||||
fix(fixer) {
|
||||
const lastToken = getLastTokenOnLine(node);
|
||||
|
||||
if (expected) {
|
||||
return location === "before"
|
||||
? fixer.insertTextBefore(node, "\n")
|
||||
: fixer.insertTextAfter(lastToken, "\n");
|
||||
}
|
||||
return fixer.removeRange(
|
||||
location === "before"
|
||||
? [node.range[0] - 1, node.range[0]]
|
||||
: [lastToken.range[1], lastToken.range[1] + 1],
|
||||
);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Check lines around directives in node
|
||||
* @param {ASTNode} node node to check
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkDirectives(node) {
|
||||
const directives = astUtils.getDirectivePrologue(node);
|
||||
|
||||
if (!directives.length) {
|
||||
return;
|
||||
}
|
||||
|
||||
const firstDirective = directives[0];
|
||||
const leadingComments =
|
||||
sourceCode.getCommentsBefore(firstDirective);
|
||||
|
||||
/*
|
||||
* Only check before the first directive if it is preceded by a comment or if it is at the top of
|
||||
* the file and expectLineBefore is set to "never". This is to not force a newline at the top of
|
||||
* the file if there are no comments as well as for compatibility with padded-blocks.
|
||||
*/
|
||||
if (leadingComments.length) {
|
||||
if (
|
||||
expectLineBefore === "always" &&
|
||||
!hasNewlineBefore(firstDirective)
|
||||
) {
|
||||
reportError(firstDirective, "before", true);
|
||||
}
|
||||
|
||||
if (
|
||||
expectLineBefore === "never" &&
|
||||
hasNewlineBefore(firstDirective)
|
||||
) {
|
||||
reportError(firstDirective, "before", false);
|
||||
}
|
||||
} else if (
|
||||
node.type === "Program" &&
|
||||
expectLineBefore === "never" &&
|
||||
!leadingComments.length &&
|
||||
hasNewlineBefore(firstDirective)
|
||||
) {
|
||||
reportError(firstDirective, "before", false);
|
||||
}
|
||||
|
||||
const lastDirective = directives.at(-1);
|
||||
const statements =
|
||||
node.type === "Program" ? node.body : node.body.body;
|
||||
|
||||
/*
|
||||
* Do not check after the last directive if the body only
|
||||
* contains a directive prologue and isn't followed by a comment to ensure
|
||||
* this rule behaves well with padded-blocks.
|
||||
*/
|
||||
if (
|
||||
lastDirective === statements.at(-1) &&
|
||||
!lastDirective.trailingComments
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
expectLineAfter === "always" &&
|
||||
!hasNewlineAfter(lastDirective)
|
||||
) {
|
||||
reportError(lastDirective, "after", true);
|
||||
}
|
||||
|
||||
if (expectLineAfter === "never" && hasNewlineAfter(lastDirective)) {
|
||||
reportError(lastDirective, "after", false);
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
Program: checkDirectives,
|
||||
FunctionDeclaration: checkDirectives,
|
||||
FunctionExpression: checkDirectives,
|
||||
ArrowFunctionExpression: checkDirectives,
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,216 @@
|
||||
/**
|
||||
* @fileoverview Enforce return after a callback.
|
||||
* @author Jamund Ferguson
|
||||
* @deprecated in ESLint v7.0.0
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
deprecated: {
|
||||
message: "Node.js rules were moved out of ESLint core.",
|
||||
url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
|
||||
deprecatedSince: "7.0.0",
|
||||
availableUntil: null,
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"eslint-plugin-n now maintains deprecated Node.js-related rules.",
|
||||
plugin: {
|
||||
name: "eslint-plugin-n",
|
||||
url: "https://github.com/eslint-community/eslint-plugin-n",
|
||||
},
|
||||
rule: {
|
||||
name: "callback-return",
|
||||
url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/callback-return.md",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Require `return` statements after callbacks",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/callback-return",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "array",
|
||||
items: { type: "string" },
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
missingReturn: "Expected return with your callback function.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const callbacks = context.options[0] || ["callback", "cb", "next"],
|
||||
sourceCode = context.sourceCode;
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Find the closest parent matching a list of types.
|
||||
* @param {ASTNode} node The node whose parents we are searching
|
||||
* @param {Array} types The node types to match
|
||||
* @returns {ASTNode} The matched node or undefined.
|
||||
*/
|
||||
function findClosestParentOfType(node, types) {
|
||||
if (!node.parent) {
|
||||
return null;
|
||||
}
|
||||
if (!types.includes(node.parent.type)) {
|
||||
return findClosestParentOfType(node.parent, types);
|
||||
}
|
||||
return node.parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check to see if a node contains only identifiers
|
||||
* @param {ASTNode} node The node to check
|
||||
* @returns {boolean} Whether or not the node contains only identifiers
|
||||
*/
|
||||
function containsOnlyIdentifiers(node) {
|
||||
if (node.type === "Identifier") {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (node.type === "MemberExpression") {
|
||||
if (node.object.type === "Identifier") {
|
||||
return true;
|
||||
}
|
||||
if (node.object.type === "MemberExpression") {
|
||||
return containsOnlyIdentifiers(node.object);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check to see if a CallExpression is in our callback list.
|
||||
* @param {ASTNode} node The node to check against our callback names list.
|
||||
* @returns {boolean} Whether or not this function matches our callback name.
|
||||
*/
|
||||
function isCallback(node) {
|
||||
return (
|
||||
containsOnlyIdentifiers(node.callee) &&
|
||||
callbacks.includes(sourceCode.getText(node.callee))
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether or not the callback is part of a callback expression.
|
||||
* @param {ASTNode} node The callback node
|
||||
* @param {ASTNode} parentNode The expression node
|
||||
* @returns {boolean} Whether or not this is part of a callback expression
|
||||
*/
|
||||
function isCallbackExpression(node, parentNode) {
|
||||
// ensure the parent node exists and is an expression
|
||||
if (!parentNode || parentNode.type !== "ExpressionStatement") {
|
||||
return false;
|
||||
}
|
||||
|
||||
// cb()
|
||||
if (parentNode.expression === node) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// special case for cb && cb() and similar
|
||||
if (
|
||||
parentNode.expression.type === "BinaryExpression" ||
|
||||
parentNode.expression.type === "LogicalExpression"
|
||||
) {
|
||||
if (parentNode.expression.right === node) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
// Public
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
return {
|
||||
CallExpression(node) {
|
||||
// if we're not a callback we can return
|
||||
if (!isCallback(node)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// find the closest block, return or loop
|
||||
const closestBlock =
|
||||
findClosestParentOfType(node, [
|
||||
"BlockStatement",
|
||||
"ReturnStatement",
|
||||
"ArrowFunctionExpression",
|
||||
]) || {};
|
||||
|
||||
// if our parent is a return we know we're ok
|
||||
if (closestBlock.type === "ReturnStatement") {
|
||||
return;
|
||||
}
|
||||
|
||||
// arrow functions don't always have blocks and implicitly return
|
||||
if (closestBlock.type === "ArrowFunctionExpression") {
|
||||
return;
|
||||
}
|
||||
|
||||
// block statements are part of functions and most if statements
|
||||
if (closestBlock.type === "BlockStatement") {
|
||||
// find the last item in the block
|
||||
const lastItem = closestBlock.body.at(-1);
|
||||
|
||||
// if the callback is the last thing in a block that might be ok
|
||||
if (isCallbackExpression(node, lastItem)) {
|
||||
const parentType = closestBlock.parent.type;
|
||||
|
||||
// but only if the block is part of a function
|
||||
if (
|
||||
parentType === "FunctionExpression" ||
|
||||
parentType === "FunctionDeclaration" ||
|
||||
parentType === "ArrowFunctionExpression"
|
||||
) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// ending a block with a return is also ok
|
||||
if (lastItem.type === "ReturnStatement") {
|
||||
// but only if the callback is immediately before
|
||||
if (
|
||||
isCallbackExpression(node, closestBlock.body.at(-2))
|
||||
) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// as long as you're the child of a function at this point you should be asked to return
|
||||
if (
|
||||
findClosestParentOfType(node, [
|
||||
"FunctionDeclaration",
|
||||
"FunctionExpression",
|
||||
"ArrowFunctionExpression",
|
||||
])
|
||||
) {
|
||||
context.report({ node, messageId: "missingReturn" });
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,29 @@
|
||||
export class BaseFilterFactory {
|
||||
addFilter(maps: any): string;
|
||||
addHCMFilter(fgColor: any, bgColor: any): string;
|
||||
addAlphaFilter(map: any): string;
|
||||
addLuminosityFilter(map: any): string;
|
||||
addHighlightHCMFilter(filterName: any, fgColor: any, bgColor: any, newFgColor: any, newBgColor: any): string;
|
||||
destroy(keepHCM?: boolean): void;
|
||||
}
|
||||
/**
|
||||
* FilterFactory aims to create some SVG filters we can use when drawing an
|
||||
* image (or whatever) on a canvas.
|
||||
* Filters aren't applied with ctx.putImageData because it just overwrites the
|
||||
* underlying pixels.
|
||||
* With these filters, it's possible for example to apply some transfer maps on
|
||||
* an image without the need to apply them on the pixel arrays: the renderer
|
||||
* does the magic for us.
|
||||
*/
|
||||
export class DOMFilterFactory extends BaseFilterFactory {
|
||||
constructor({ docId, ownerDocument }: {
|
||||
docId: any;
|
||||
ownerDocument?: Document | undefined;
|
||||
});
|
||||
addFilter(maps: any): any;
|
||||
addHCMFilter(fgColor: any, bgColor: any): any;
|
||||
addAlphaFilter(map: any): any;
|
||||
addLuminosityFilter(map: any): any;
|
||||
addHighlightHCMFilter(filterName: any, fgColor: any, bgColor: any, newFgColor: any, newBgColor: any): any;
|
||||
#private;
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag use of certain node types
|
||||
* @author Burak Yigit Kaya
|
||||
*/
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow specified syntax",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-restricted-syntax",
|
||||
},
|
||||
|
||||
schema: {
|
||||
type: "array",
|
||||
items: {
|
||||
oneOf: [
|
||||
{
|
||||
type: "string",
|
||||
},
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
selector: { type: "string" },
|
||||
message: { type: "string" },
|
||||
},
|
||||
required: ["selector"],
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
},
|
||||
uniqueItems: true,
|
||||
minItems: 0,
|
||||
},
|
||||
|
||||
messages: {
|
||||
// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
|
||||
restrictedSyntax: "{{message}}",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
return context.options.reduce((result, selectorOrObject) => {
|
||||
const isStringFormat = typeof selectorOrObject === "string";
|
||||
const hasCustomMessage =
|
||||
!isStringFormat && Boolean(selectorOrObject.message);
|
||||
|
||||
const selector = isStringFormat
|
||||
? selectorOrObject
|
||||
: selectorOrObject.selector;
|
||||
const message = hasCustomMessage
|
||||
? selectorOrObject.message
|
||||
: `Using '${selector}' is not allowed.`;
|
||||
|
||||
return Object.assign(result, {
|
||||
[selector](node) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "restrictedSyntax",
|
||||
data: { message },
|
||||
});
|
||||
},
|
||||
});
|
||||
}, {});
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,25 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
||||
const router = require("./router.cjs");
|
||||
const TSR_DEFERRED_PROMISE = Symbol.for("TSR_DEFERRED_PROMISE");
|
||||
function defer(_promise, options) {
|
||||
const promise = _promise;
|
||||
if (promise[TSR_DEFERRED_PROMISE]) {
|
||||
return promise;
|
||||
}
|
||||
promise[TSR_DEFERRED_PROMISE] = { status: "pending" };
|
||||
promise.then((data) => {
|
||||
promise[TSR_DEFERRED_PROMISE].status = "success";
|
||||
promise[TSR_DEFERRED_PROMISE].data = data;
|
||||
}).catch((error) => {
|
||||
promise[TSR_DEFERRED_PROMISE].status = "error";
|
||||
promise[TSR_DEFERRED_PROMISE].error = {
|
||||
data: ((options == null ? void 0 : options.serializeError) ?? router.defaultSerializeError)(error),
|
||||
__isServerError: true
|
||||
};
|
||||
});
|
||||
return promise;
|
||||
}
|
||||
exports.TSR_DEFERRED_PROMISE = TSR_DEFERRED_PROMISE;
|
||||
exports.defer = defer;
|
||||
//# sourceMappingURL=defer.cjs.map
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,286 @@
|
||||
export type VisitTraversalStep = import("@eslint/core").VisitTraversalStep;
|
||||
export type CallTraversalStep = import("@eslint/core").CallTraversalStep;
|
||||
export type TextSourceCode = import("@eslint/core").TextSourceCode;
|
||||
export type TraversalStep = import("@eslint/core").TraversalStep;
|
||||
export type SourceLocation = import("@eslint/core").SourceLocation;
|
||||
export type SourceLocationWithOffset = import("@eslint/core").SourceLocationWithOffset;
|
||||
export type SourceRange = import("@eslint/core").SourceRange;
|
||||
export type IDirective = import("@eslint/core").Directive;
|
||||
export type DirectiveType = import("@eslint/core").DirectiveType;
|
||||
export type RuleConfig = import("@eslint/core").RuleConfig;
|
||||
export type RulesConfig = import("@eslint/core").RulesConfig;
|
||||
export type StringConfig = import("./types.ts").StringConfig;
|
||||
export type BooleanConfig = import("./types.ts").BooleanConfig;
|
||||
/**
|
||||
* A class to represent a step in the traversal process where a
|
||||
* method is called.
|
||||
* @implements {CallTraversalStep}
|
||||
*/
|
||||
export class CallMethodStep implements CallTraversalStep {
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {Object} options The options for the step.
|
||||
* @param {string} options.target The target of the step.
|
||||
* @param {Array<any>} options.args The arguments of the step.
|
||||
*/
|
||||
constructor({ target, args }: {
|
||||
target: string;
|
||||
args: Array<any>;
|
||||
});
|
||||
/**
|
||||
* The type of the step.
|
||||
* @type {"call"}
|
||||
* @readonly
|
||||
*/
|
||||
readonly type: "call";
|
||||
/**
|
||||
* The kind of the step. Represents the same data as the `type` property
|
||||
* but it's a number for performance.
|
||||
* @type {2}
|
||||
* @readonly
|
||||
*/
|
||||
readonly kind: 2;
|
||||
/**
|
||||
* The name of the method to call.
|
||||
* @type {string}
|
||||
*/
|
||||
target: string;
|
||||
/**
|
||||
* The arguments to pass to the method.
|
||||
* @type {Array<any>}
|
||||
*/
|
||||
args: Array<any>;
|
||||
}
|
||||
/**
|
||||
* Object to parse ESLint configuration comments.
|
||||
*/
|
||||
export class ConfigCommentParser {
|
||||
/**
|
||||
* Parses a list of "name:string_value" or/and "name" options divided by comma or
|
||||
* whitespace. Used for "global" comments.
|
||||
* @param {string} string The string to parse.
|
||||
* @returns {StringConfig} Result map object of names and string values, or null values if no value was provided.
|
||||
*/
|
||||
parseStringConfig(string: string): StringConfig;
|
||||
/**
|
||||
* Parses a JSON-like config.
|
||||
* @param {string} string The string to parse.
|
||||
* @returns {({ok: true, config: RulesConfig}|{ok: false, error: {message: string}})} Result map object
|
||||
*/
|
||||
parseJSONLikeConfig(string: string): ({
|
||||
ok: true;
|
||||
config: RulesConfig;
|
||||
} | {
|
||||
ok: false;
|
||||
error: {
|
||||
message: string;
|
||||
};
|
||||
});
|
||||
/**
|
||||
* Parses a config of values separated by comma.
|
||||
* @param {string} string The string to parse.
|
||||
* @returns {BooleanConfig} Result map of values and true values
|
||||
*/
|
||||
parseListConfig(string: string): BooleanConfig;
|
||||
/**
|
||||
* Parses a directive comment into directive text and value.
|
||||
* @param {string} string The string with the directive to be parsed.
|
||||
* @returns {DirectiveComment|undefined} The parsed directive or `undefined` if the directive is invalid.
|
||||
*/
|
||||
parseDirective(string: string): DirectiveComment | undefined;
|
||||
#private;
|
||||
}
|
||||
/**
|
||||
* A class to represent a directive comment.
|
||||
* @implements {IDirective}
|
||||
*/
|
||||
export class Directive implements IDirective {
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {Object} options The options for the directive.
|
||||
* @param {"disable"|"enable"|"disable-next-line"|"disable-line"} options.type The type of directive.
|
||||
* @param {unknown} options.node The node representing the directive.
|
||||
* @param {string} options.value The value of the directive.
|
||||
* @param {string} options.justification The justification for the directive.
|
||||
*/
|
||||
constructor({ type, node, value, justification }: {
|
||||
type: "disable" | "enable" | "disable-next-line" | "disable-line";
|
||||
node: unknown;
|
||||
value: string;
|
||||
justification: string;
|
||||
});
|
||||
/**
|
||||
* The type of directive.
|
||||
* @type {DirectiveType}
|
||||
* @readonly
|
||||
*/
|
||||
readonly type: DirectiveType;
|
||||
/**
|
||||
* The node representing the directive.
|
||||
* @type {unknown}
|
||||
* @readonly
|
||||
*/
|
||||
readonly node: unknown;
|
||||
/**
|
||||
* Everything after the "eslint-disable" portion of the directive,
|
||||
* but before the "--" that indicates the justification.
|
||||
* @type {string}
|
||||
* @readonly
|
||||
*/
|
||||
readonly value: string;
|
||||
/**
|
||||
* The justification for the directive.
|
||||
* @type {string}
|
||||
* @readonly
|
||||
*/
|
||||
readonly justification: string;
|
||||
}
|
||||
/**
|
||||
* Source Code Base Object
|
||||
* @implements {TextSourceCode}
|
||||
*/
|
||||
export class TextSourceCodeBase implements TextSourceCode {
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {Object} options The options for the instance.
|
||||
* @param {string} options.text The source code text.
|
||||
* @param {object} options.ast The root AST node.
|
||||
* @param {RegExp} [options.lineEndingPattern] The pattern to match lineEndings in the source code.
|
||||
*/
|
||||
constructor({ text, ast, lineEndingPattern }: {
|
||||
text: string;
|
||||
ast: object;
|
||||
lineEndingPattern?: RegExp;
|
||||
});
|
||||
/**
|
||||
* The AST of the source code.
|
||||
* @type {object}
|
||||
*/
|
||||
ast: object;
|
||||
/**
|
||||
* The text of the source code.
|
||||
* @type {string}
|
||||
*/
|
||||
text: string;
|
||||
/**
|
||||
* Returns the loc information for the given node or token.
|
||||
* @param {object} nodeOrToken The node or token to get the loc information for.
|
||||
* @returns {SourceLocation} The loc information for the node or token.
|
||||
*/
|
||||
getLoc(nodeOrToken: object): SourceLocation;
|
||||
/**
|
||||
* Returns the range information for the given node or token.
|
||||
* @param {object} nodeOrToken The node or token to get the range information for.
|
||||
* @returns {SourceRange} The range information for the node or token.
|
||||
*/
|
||||
getRange(nodeOrToken: object): SourceRange;
|
||||
/**
|
||||
* Returns the parent of the given node.
|
||||
* @param {object} node The node to get the parent of.
|
||||
* @returns {object|undefined} The parent of the node.
|
||||
*/
|
||||
getParent(node: object): object | undefined;
|
||||
/**
|
||||
* Gets all the ancestors of a given node
|
||||
* @param {object} node The node
|
||||
* @returns {Array<object>} All the ancestor nodes in the AST, not including the provided node, starting
|
||||
* from the root node at index 0 and going inwards to the parent node.
|
||||
* @throws {TypeError} When `node` is missing.
|
||||
*/
|
||||
getAncestors(node: object): Array<object>;
|
||||
/**
|
||||
* Gets the source code for the given node.
|
||||
* @param {object} [node] The AST node to get the text for.
|
||||
* @param {number} [beforeCount] The number of characters before the node to retrieve.
|
||||
* @param {number} [afterCount] The number of characters after the node to retrieve.
|
||||
* @returns {string} The text representing the AST node.
|
||||
* @public
|
||||
*/
|
||||
public getText(node?: object, beforeCount?: number, afterCount?: number): string;
|
||||
/**
|
||||
* Gets the entire source text split into an array of lines.
|
||||
* @returns {Array<string>} The source text as an array of lines.
|
||||
* @public
|
||||
*/
|
||||
public get lines(): Array<string>;
|
||||
/**
|
||||
* Traverse the source code and return the steps that were taken.
|
||||
* @returns {Iterable<TraversalStep>} The steps that were taken while traversing the source code.
|
||||
*/
|
||||
traverse(): Iterable<TraversalStep>;
|
||||
#private;
|
||||
}
|
||||
/**
|
||||
* A class to represent a step in the traversal process where a node is visited.
|
||||
* @implements {VisitTraversalStep}
|
||||
*/
|
||||
export class VisitNodeStep implements VisitTraversalStep {
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {Object} options The options for the step.
|
||||
* @param {object} options.target The target of the step.
|
||||
* @param {1|2} options.phase The phase of the step.
|
||||
* @param {Array<any>} options.args The arguments of the step.
|
||||
*/
|
||||
constructor({ target, phase, args }: {
|
||||
target: object;
|
||||
phase: 1 | 2;
|
||||
args: Array<any>;
|
||||
});
|
||||
/**
|
||||
* The type of the step.
|
||||
* @type {"visit"}
|
||||
* @readonly
|
||||
*/
|
||||
readonly type: "visit";
|
||||
/**
|
||||
* The kind of the step. Represents the same data as the `type` property
|
||||
* but it's a number for performance.
|
||||
* @type {1}
|
||||
* @readonly
|
||||
*/
|
||||
readonly kind: 1;
|
||||
/**
|
||||
* The target of the step.
|
||||
* @type {object}
|
||||
*/
|
||||
target: object;
|
||||
/**
|
||||
* The phase of the step.
|
||||
* @type {1|2}
|
||||
*/
|
||||
phase: 1 | 2;
|
||||
/**
|
||||
* The arguments of the step.
|
||||
* @type {Array<any>}
|
||||
*/
|
||||
args: Array<any>;
|
||||
}
|
||||
/**
|
||||
* Represents a directive comment.
|
||||
*/
|
||||
declare class DirectiveComment {
|
||||
/**
|
||||
* Creates a new directive comment.
|
||||
* @param {string} label The label of the directive.
|
||||
* @param {string} value The value of the directive.
|
||||
* @param {string} justification The justification of the directive.
|
||||
*/
|
||||
constructor(label: string, value: string, justification: string);
|
||||
/**
|
||||
* The label of the directive, such as "eslint", "eslint-disable", etc.
|
||||
* @type {string}
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* The value of the directive (the string after the label).
|
||||
* @type {string}
|
||||
*/
|
||||
value: string;
|
||||
/**
|
||||
* The justification of the directive (the string after the --).
|
||||
* @type {string}
|
||||
*/
|
||||
justification: string;
|
||||
}
|
||||
export {};
|
||||
@@ -0,0 +1,34 @@
|
||||
// This alphabet uses `A-Za-z0-9_-` symbols.
|
||||
// The order of characters is optimized for better gzip and brotli compression.
|
||||
// References to the same file (works both for gzip and brotli):
|
||||
// `'use`, `andom`, and `rict'`
|
||||
// References to the brotli default dictionary:
|
||||
// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
|
||||
let urlAlphabet =
|
||||
'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
|
||||
|
||||
let customAlphabet = (alphabet, defaultSize = 21) => {
|
||||
return (size = defaultSize) => {
|
||||
let id = ''
|
||||
// A compact alternative for `for (var i = 0; i < step; i++)`.
|
||||
let i = size | 0
|
||||
while (i--) {
|
||||
// `| 0` is more compact and faster than `Math.floor()`.
|
||||
id += alphabet[(Math.random() * alphabet.length) | 0]
|
||||
}
|
||||
return id
|
||||
}
|
||||
}
|
||||
|
||||
let nanoid = (size = 21) => {
|
||||
let id = ''
|
||||
// A compact alternative for `for (var i = 0; i < step; i++)`.
|
||||
let i = size | 0
|
||||
while (i--) {
|
||||
// `| 0` is more compact and faster than `Math.floor()`.
|
||||
id += urlAlphabet[(Math.random() * 64) | 0]
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
module.exports = { nanoid, customAlphabet }
|
||||
@@ -0,0 +1,96 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
||||
const jsxRuntime = require("react/jsx-runtime");
|
||||
const React = require("react");
|
||||
const Match = require("./Match.cjs");
|
||||
function _interopNamespaceDefault(e) {
|
||||
const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
|
||||
if (e) {
|
||||
for (const k in e) {
|
||||
if (k !== "default") {
|
||||
const d = Object.getOwnPropertyDescriptor(e, k);
|
||||
Object.defineProperty(n, k, d.get ? d : {
|
||||
enumerable: true,
|
||||
get: () => e[k]
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
n.default = e;
|
||||
return Object.freeze(n);
|
||||
}
|
||||
const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
|
||||
function isModuleNotFoundError(error) {
|
||||
if (typeof (error == null ? void 0 : error.message) !== "string") return false;
|
||||
return error.message.startsWith("Failed to fetch dynamically imported module") || error.message.startsWith("error loading dynamically imported module") || error.message.startsWith("Importing a module script failed");
|
||||
}
|
||||
function ClientOnly({
|
||||
children,
|
||||
fallback = null
|
||||
}) {
|
||||
return useHydrated() ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }) : /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
|
||||
}
|
||||
function subscribe() {
|
||||
return () => {
|
||||
};
|
||||
}
|
||||
function useHydrated() {
|
||||
return React__namespace.useSyncExternalStore(
|
||||
subscribe,
|
||||
() => true,
|
||||
() => false
|
||||
);
|
||||
}
|
||||
function lazyRouteComponent(importer, exportName, ssr) {
|
||||
let loadPromise;
|
||||
let comp;
|
||||
let error;
|
||||
let reload;
|
||||
const load = () => {
|
||||
if (typeof document === "undefined" && (ssr == null ? void 0 : ssr()) === false) {
|
||||
comp = () => null;
|
||||
return Promise.resolve();
|
||||
}
|
||||
if (!loadPromise) {
|
||||
loadPromise = importer().then((res) => {
|
||||
loadPromise = void 0;
|
||||
comp = res[exportName ?? "default"];
|
||||
}).catch((err) => {
|
||||
error = err;
|
||||
if (isModuleNotFoundError(error)) {
|
||||
if (error instanceof Error && typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
|
||||
const storageKey = `tanstack_router_reload:${error.message}`;
|
||||
if (!sessionStorage.getItem(storageKey)) {
|
||||
sessionStorage.setItem(storageKey, "1");
|
||||
reload = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
return loadPromise;
|
||||
};
|
||||
const lazyComp = function Lazy(props) {
|
||||
if (reload) {
|
||||
window.location.reload();
|
||||
throw new Promise(() => {
|
||||
});
|
||||
}
|
||||
if (error) {
|
||||
throw error;
|
||||
}
|
||||
if (!comp) {
|
||||
throw load();
|
||||
}
|
||||
if ((ssr == null ? void 0 : ssr()) === false) {
|
||||
return /* @__PURE__ */ jsxRuntime.jsx(ClientOnly, { fallback: /* @__PURE__ */ jsxRuntime.jsx(Match.Outlet, {}), children: React__namespace.createElement(comp, props) });
|
||||
}
|
||||
return React__namespace.createElement(comp, props);
|
||||
};
|
||||
lazyComp.preload = load;
|
||||
return lazyComp;
|
||||
}
|
||||
exports.ClientOnly = ClientOnly;
|
||||
exports.lazyRouteComponent = lazyRouteComponent;
|
||||
exports.useHydrated = useHydrated;
|
||||
//# sourceMappingURL=lazyRouteComponent.cjs.map
|
||||
@@ -0,0 +1,20 @@
|
||||
/*!
|
||||
* is-extglob <https://github.com/jonschlinkert/is-extglob>
|
||||
*
|
||||
* Copyright (c) 2014-2016, Jon Schlinkert.
|
||||
* Licensed under the MIT License.
|
||||
*/
|
||||
|
||||
module.exports = function isExtglob(str) {
|
||||
if (typeof str !== 'string' || str === '') {
|
||||
return false;
|
||||
}
|
||||
|
||||
var match;
|
||||
while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
|
||||
if (match[2]) return true;
|
||||
str = str.slice(match.index + match[0].length);
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
@@ -0,0 +1,360 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = rewriteLiveReferences;
|
||||
var _core = require("@babel/core");
|
||||
function isInType(path) {
|
||||
do {
|
||||
switch (path.parent.type) {
|
||||
case "TSTypeAnnotation":
|
||||
case "TSTypeAliasDeclaration":
|
||||
case "TSTypeReference":
|
||||
case "TypeAnnotation":
|
||||
case "TypeAlias":
|
||||
return true;
|
||||
case "ExportSpecifier":
|
||||
return path.parentPath.parent.exportKind === "type";
|
||||
default:
|
||||
if (path.parentPath.isStatement() || path.parentPath.isExpression()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} while (path = path.parentPath);
|
||||
}
|
||||
function rewriteLiveReferences(programPath, metadata, wrapReference) {
|
||||
const imported = new Map();
|
||||
const exported = new Map();
|
||||
const requeueInParent = path => {
|
||||
programPath.requeue(path);
|
||||
};
|
||||
for (const [source, data] of metadata.source) {
|
||||
for (const [localName, importName] of data.imports) {
|
||||
imported.set(localName, [source, importName, null]);
|
||||
}
|
||||
for (const localName of data.importsNamespace) {
|
||||
imported.set(localName, [source, null, localName]);
|
||||
}
|
||||
}
|
||||
for (const [local, data] of metadata.local) {
|
||||
let exportMeta = exported.get(local);
|
||||
if (!exportMeta) {
|
||||
exportMeta = [];
|
||||
exported.set(local, exportMeta);
|
||||
}
|
||||
exportMeta.push(...data.names);
|
||||
}
|
||||
const rewriteBindingInitVisitorState = {
|
||||
metadata,
|
||||
requeueInParent,
|
||||
scope: programPath.scope,
|
||||
exported
|
||||
};
|
||||
programPath.traverse(rewriteBindingInitVisitor, rewriteBindingInitVisitorState);
|
||||
const rewriteReferencesVisitorState = {
|
||||
seen: new WeakSet(),
|
||||
metadata,
|
||||
requeueInParent,
|
||||
scope: programPath.scope,
|
||||
imported,
|
||||
exported,
|
||||
buildImportReference([source, importName, localName], identNode) {
|
||||
const meta = metadata.source.get(source);
|
||||
meta.referenced = true;
|
||||
if (localName) {
|
||||
if (meta.wrap) {
|
||||
var _wrapReference;
|
||||
identNode = (_wrapReference = wrapReference(identNode, meta.wrap)) != null ? _wrapReference : identNode;
|
||||
}
|
||||
return identNode;
|
||||
}
|
||||
let namespace = _core.types.identifier(meta.name);
|
||||
if (meta.wrap) {
|
||||
var _wrapReference2;
|
||||
namespace = (_wrapReference2 = wrapReference(namespace, meta.wrap)) != null ? _wrapReference2 : namespace;
|
||||
}
|
||||
if (importName === "default" && meta.interop === "node-default") {
|
||||
return namespace;
|
||||
}
|
||||
const computed = metadata.stringSpecifiers.has(importName);
|
||||
return _core.types.memberExpression(namespace, computed ? _core.types.stringLiteral(importName) : _core.types.identifier(importName), computed);
|
||||
}
|
||||
};
|
||||
programPath.traverse(rewriteReferencesVisitor, rewriteReferencesVisitorState);
|
||||
}
|
||||
const rewriteBindingInitVisitor = {
|
||||
Scope(path) {
|
||||
path.skip();
|
||||
},
|
||||
ClassDeclaration(path) {
|
||||
const {
|
||||
requeueInParent,
|
||||
exported,
|
||||
metadata
|
||||
} = this;
|
||||
const {
|
||||
id
|
||||
} = path.node;
|
||||
if (!id) throw new Error("Expected class to have a name");
|
||||
const localName = id.name;
|
||||
const exportNames = exported.get(localName) || [];
|
||||
if (exportNames.length > 0) {
|
||||
const statement = _core.types.expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, _core.types.identifier(localName), path.scope));
|
||||
statement._blockHoist = path.node._blockHoist;
|
||||
requeueInParent(path.insertAfter(statement)[0]);
|
||||
}
|
||||
},
|
||||
VariableDeclaration(path) {
|
||||
const {
|
||||
requeueInParent,
|
||||
exported,
|
||||
metadata
|
||||
} = this;
|
||||
const isVar = path.node.kind === "var";
|
||||
for (const decl of path.get("declarations")) {
|
||||
const {
|
||||
id
|
||||
} = decl.node;
|
||||
let {
|
||||
init
|
||||
} = decl.node;
|
||||
if (_core.types.isIdentifier(id) && exported.has(id.name) && !_core.types.isArrowFunctionExpression(init) && (!_core.types.isFunctionExpression(init) || init.id) && (!_core.types.isClassExpression(init) || init.id)) {
|
||||
if (!init) {
|
||||
if (isVar) {
|
||||
continue;
|
||||
} else {
|
||||
init = path.scope.buildUndefinedNode();
|
||||
}
|
||||
}
|
||||
decl.node.init = buildBindingExportAssignmentExpression(metadata, exported.get(id.name), init, path.scope);
|
||||
requeueInParent(decl.get("init"));
|
||||
} else {
|
||||
for (const localName of Object.keys(decl.getOuterBindingIdentifiers())) {
|
||||
if (exported.has(localName)) {
|
||||
const statement = _core.types.expressionStatement(buildBindingExportAssignmentExpression(metadata, exported.get(localName), _core.types.identifier(localName), path.scope));
|
||||
statement._blockHoist = path.node._blockHoist;
|
||||
requeueInParent(path.insertAfter(statement)[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
const buildBindingExportAssignmentExpression = (metadata, exportNames, localExpr, scope) => {
|
||||
const exportsObjectName = metadata.exportName;
|
||||
for (let currentScope = scope; currentScope != null; currentScope = currentScope.parent) {
|
||||
if (currentScope.hasOwnBinding(exportsObjectName)) {
|
||||
currentScope.rename(exportsObjectName);
|
||||
}
|
||||
}
|
||||
return (exportNames || []).reduce((expr, exportName) => {
|
||||
const {
|
||||
stringSpecifiers
|
||||
} = metadata;
|
||||
const computed = stringSpecifiers.has(exportName);
|
||||
return _core.types.assignmentExpression("=", _core.types.memberExpression(_core.types.identifier(exportsObjectName), computed ? _core.types.stringLiteral(exportName) : _core.types.identifier(exportName), computed), expr);
|
||||
}, localExpr);
|
||||
};
|
||||
const buildImportThrow = localName => {
|
||||
return _core.template.expression.ast`
|
||||
(function() {
|
||||
throw new Error('"' + '${localName}' + '" is read-only.');
|
||||
})()
|
||||
`;
|
||||
};
|
||||
const rewriteReferencesVisitor = {
|
||||
ReferencedIdentifier(path) {
|
||||
const {
|
||||
seen,
|
||||
buildImportReference,
|
||||
scope,
|
||||
imported,
|
||||
requeueInParent
|
||||
} = this;
|
||||
if (seen.has(path.node)) return;
|
||||
seen.add(path.node);
|
||||
const localName = path.node.name;
|
||||
const importData = imported.get(localName);
|
||||
if (importData) {
|
||||
if (isInType(path)) {
|
||||
throw path.buildCodeFrameError(`Cannot transform the imported binding "${localName}" since it's also used in a type annotation. ` + `Please strip type annotations using @babel/preset-typescript or @babel/preset-flow.`);
|
||||
}
|
||||
const localBinding = path.scope.getBinding(localName);
|
||||
const rootBinding = scope.getBinding(localName);
|
||||
if (rootBinding !== localBinding) return;
|
||||
const ref = buildImportReference(importData, path.node);
|
||||
ref.loc = path.node.loc;
|
||||
if ((path.parentPath.isCallExpression({
|
||||
callee: path.node
|
||||
}) || path.parentPath.isOptionalCallExpression({
|
||||
callee: path.node
|
||||
}) || path.parentPath.isTaggedTemplateExpression({
|
||||
tag: path.node
|
||||
})) && _core.types.isMemberExpression(ref)) {
|
||||
path.replaceWith(_core.types.sequenceExpression([_core.types.numericLiteral(0), ref]));
|
||||
} else if (path.isJSXIdentifier() && _core.types.isMemberExpression(ref)) {
|
||||
const {
|
||||
object,
|
||||
property
|
||||
} = ref;
|
||||
path.replaceWith(_core.types.jsxMemberExpression(_core.types.jsxIdentifier(object.name), _core.types.jsxIdentifier(property.name)));
|
||||
} else {
|
||||
path.replaceWith(ref);
|
||||
}
|
||||
requeueInParent(path);
|
||||
path.skip();
|
||||
}
|
||||
},
|
||||
UpdateExpression(path) {
|
||||
const {
|
||||
scope,
|
||||
seen,
|
||||
imported,
|
||||
exported,
|
||||
requeueInParent,
|
||||
buildImportReference
|
||||
} = this;
|
||||
if (seen.has(path.node)) return;
|
||||
seen.add(path.node);
|
||||
const arg = path.get("argument");
|
||||
if (arg.isMemberExpression()) return;
|
||||
const update = path.node;
|
||||
if (arg.isIdentifier()) {
|
||||
const localName = arg.node.name;
|
||||
if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
|
||||
return;
|
||||
}
|
||||
const exportedNames = exported.get(localName);
|
||||
const importData = imported.get(localName);
|
||||
if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) {
|
||||
if (importData) {
|
||||
path.replaceWith(_core.types.assignmentExpression(update.operator[0] + "=", buildImportReference(importData, arg.node), buildImportThrow(localName)));
|
||||
} else if (update.prefix) {
|
||||
path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, _core.types.cloneNode(update), path.scope));
|
||||
} else {
|
||||
const ref = scope.generateDeclaredUidIdentifier(localName);
|
||||
path.replaceWith(_core.types.sequenceExpression([_core.types.assignmentExpression("=", _core.types.cloneNode(ref), _core.types.cloneNode(update)), buildBindingExportAssignmentExpression(this.metadata, exportedNames, _core.types.identifier(localName), path.scope), _core.types.cloneNode(ref)]));
|
||||
}
|
||||
}
|
||||
}
|
||||
requeueInParent(path);
|
||||
path.skip();
|
||||
},
|
||||
AssignmentExpression: {
|
||||
exit(path) {
|
||||
const {
|
||||
scope,
|
||||
seen,
|
||||
imported,
|
||||
exported,
|
||||
requeueInParent,
|
||||
buildImportReference
|
||||
} = this;
|
||||
if (seen.has(path.node)) return;
|
||||
seen.add(path.node);
|
||||
const left = path.get("left");
|
||||
if (left.isMemberExpression()) return;
|
||||
if (left.isIdentifier()) {
|
||||
const localName = left.node.name;
|
||||
if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
|
||||
return;
|
||||
}
|
||||
const exportedNames = exported.get(localName);
|
||||
const importData = imported.get(localName);
|
||||
if ((exportedNames == null ? void 0 : exportedNames.length) > 0 || importData) {
|
||||
const assignment = path.node;
|
||||
if (importData) {
|
||||
assignment.left = buildImportReference(importData, left.node);
|
||||
assignment.right = _core.types.sequenceExpression([assignment.right, buildImportThrow(localName)]);
|
||||
}
|
||||
const {
|
||||
operator
|
||||
} = assignment;
|
||||
let newExpr;
|
||||
if (operator === "=") {
|
||||
newExpr = assignment;
|
||||
} else if (operator === "&&=" || operator === "||=" || operator === "??=") {
|
||||
newExpr = _core.types.assignmentExpression("=", assignment.left, _core.types.logicalExpression(operator.slice(0, -1), _core.types.cloneNode(assignment.left), assignment.right));
|
||||
} else {
|
||||
newExpr = _core.types.assignmentExpression("=", assignment.left, _core.types.binaryExpression(operator.slice(0, -1), _core.types.cloneNode(assignment.left), assignment.right));
|
||||
}
|
||||
path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, newExpr, path.scope));
|
||||
requeueInParent(path);
|
||||
path.skip();
|
||||
}
|
||||
} else {
|
||||
const ids = left.getOuterBindingIdentifiers();
|
||||
const programScopeIds = Object.keys(ids).filter(localName => scope.getBinding(localName) === path.scope.getBinding(localName));
|
||||
const id = programScopeIds.find(localName => imported.has(localName));
|
||||
if (id) {
|
||||
path.node.right = _core.types.sequenceExpression([path.node.right, buildImportThrow(id)]);
|
||||
}
|
||||
const items = [];
|
||||
programScopeIds.forEach(localName => {
|
||||
const exportedNames = exported.get(localName) || [];
|
||||
if (exportedNames.length > 0) {
|
||||
items.push(buildBindingExportAssignmentExpression(this.metadata, exportedNames, _core.types.identifier(localName), path.scope));
|
||||
}
|
||||
});
|
||||
if (items.length > 0) {
|
||||
let node = _core.types.sequenceExpression(items);
|
||||
if (path.parentPath.isExpressionStatement()) {
|
||||
node = _core.types.expressionStatement(node);
|
||||
node._blockHoist = path.parentPath.node._blockHoist;
|
||||
}
|
||||
const statement = path.insertAfter(node)[0];
|
||||
requeueInParent(statement);
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
ForXStatement(path) {
|
||||
const {
|
||||
scope,
|
||||
node
|
||||
} = path;
|
||||
const {
|
||||
left
|
||||
} = node;
|
||||
const {
|
||||
exported,
|
||||
imported,
|
||||
scope: programScope
|
||||
} = this;
|
||||
if (!_core.types.isVariableDeclaration(left)) {
|
||||
let didTransformExport = false,
|
||||
importConstViolationName;
|
||||
const loopBodyScope = path.get("body").scope;
|
||||
for (const name of Object.keys(_core.types.getOuterBindingIdentifiers(left))) {
|
||||
if (programScope.getBinding(name) === scope.getBinding(name)) {
|
||||
if (exported.has(name)) {
|
||||
didTransformExport = true;
|
||||
if (loopBodyScope.hasOwnBinding(name)) {
|
||||
loopBodyScope.rename(name);
|
||||
}
|
||||
}
|
||||
if (imported.has(name) && !importConstViolationName) {
|
||||
importConstViolationName = name;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!didTransformExport && !importConstViolationName) {
|
||||
return;
|
||||
}
|
||||
path.ensureBlock();
|
||||
const bodyPath = path.get("body");
|
||||
const newLoopId = scope.generateUidIdentifierBasedOnNode(left);
|
||||
path.get("left").replaceWith(_core.types.variableDeclaration("let", [_core.types.variableDeclarator(_core.types.cloneNode(newLoopId))]));
|
||||
scope.registerDeclaration(path.get("left"));
|
||||
if (didTransformExport) {
|
||||
bodyPath.unshiftContainer("body", _core.types.expressionStatement(_core.types.assignmentExpression("=", left, newLoopId)));
|
||||
}
|
||||
if (importConstViolationName) {
|
||||
bodyPath.unshiftContainer("body", _core.types.expressionStatement(buildImportThrow(importConstViolationName)));
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
//# sourceMappingURL=rewrite-live-references.js.map
|
||||
@@ -0,0 +1,110 @@
|
||||
/**
|
||||
* @fileoverview Rule to check for tabs inside a file
|
||||
* @author Gyandeep Singh
|
||||
* @deprecated in ESLint v8.53.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const tabRegex = /\t+/gu;
|
||||
const anyNonWhitespaceRegex = /\S/u;
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Public Interface
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @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: "10.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
message:
|
||||
"ESLint Stylistic now maintains deprecated stylistic core rules.",
|
||||
url: "https://eslint.style/guide/migration",
|
||||
plugin: {
|
||||
name: "@stylistic/eslint-plugin-js",
|
||||
url: "https://eslint.style/packages/js",
|
||||
},
|
||||
rule: {
|
||||
name: "no-tabs",
|
||||
url: "https://eslint.style/rules/js/no-tabs",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
type: "layout",
|
||||
|
||||
docs: {
|
||||
description: "Disallow all tabs",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-tabs",
|
||||
},
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
allowIndentationTabs: {
|
||||
type: "boolean",
|
||||
default: false,
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
unexpectedTab: "Unexpected tab character.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
const allowIndentationTabs =
|
||||
context.options &&
|
||||
context.options[0] &&
|
||||
context.options[0].allowIndentationTabs;
|
||||
|
||||
return {
|
||||
Program(node) {
|
||||
sourceCode.getLines().forEach((line, index) => {
|
||||
let match;
|
||||
|
||||
while ((match = tabRegex.exec(line)) !== null) {
|
||||
if (
|
||||
allowIndentationTabs &&
|
||||
!anyNonWhitespaceRegex.test(
|
||||
line.slice(0, match.index),
|
||||
)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
context.report({
|
||||
node,
|
||||
loc: {
|
||||
start: {
|
||||
line: index + 1,
|
||||
column: match.index,
|
||||
},
|
||||
end: {
|
||||
line: index + 1,
|
||||
column: match.index + match[0].length,
|
||||
},
|
||||
},
|
||||
messageId: "unexpectedTab",
|
||||
});
|
||||
}
|
||||
});
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,53 @@
|
||||
declare namespace pLocate {
|
||||
interface Options {
|
||||
/**
|
||||
Number of concurrently pending promises returned by `tester`. Minimum: `1`.
|
||||
|
||||
@default Infinity
|
||||
*/
|
||||
readonly concurrency?: number;
|
||||
|
||||
/**
|
||||
Preserve `input` order when searching.
|
||||
|
||||
Disable this to improve performance if you don't care about the order.
|
||||
|
||||
@default true
|
||||
*/
|
||||
readonly preserveOrder?: boolean;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Get the first fulfilled promise that satisfies the provided testing function.
|
||||
|
||||
@param input - An iterable of promises/values to test.
|
||||
@param tester - This function will receive resolved values from `input` and is expected to return a `Promise<boolean>` or `boolean`.
|
||||
@returns A `Promise` that is fulfilled when `tester` resolves to `true` or the iterable is done, or rejects if any of the promises reject. The fulfilled value is the current iterable value or `undefined` if `tester` never resolved to `true`.
|
||||
|
||||
@example
|
||||
```
|
||||
import pathExists = require('path-exists');
|
||||
import pLocate = require('p-locate');
|
||||
|
||||
const files = [
|
||||
'unicorn.png',
|
||||
'rainbow.png', // Only this one actually exists on disk
|
||||
'pony.png'
|
||||
];
|
||||
|
||||
(async () => {
|
||||
const foundPath = await pLocate(files, file => pathExists(file));
|
||||
|
||||
console.log(foundPath);
|
||||
//=> 'rainbow'
|
||||
})();
|
||||
```
|
||||
*/
|
||||
declare function pLocate<ValueType>(
|
||||
input: Iterable<PromiseLike<ValueType> | ValueType>,
|
||||
tester: (element: ValueType) => PromiseLike<boolean> | boolean,
|
||||
options?: pLocate.Options
|
||||
): Promise<ValueType | undefined>;
|
||||
|
||||
export = pLocate;
|
||||
@@ -0,0 +1,19 @@
|
||||
# @babel/helper-string-parser
|
||||
|
||||
> A utility package to parse strings
|
||||
|
||||
See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information.
|
||||
|
||||
## Install
|
||||
|
||||
Using npm:
|
||||
|
||||
```sh
|
||||
npm install --save @babel/helper-string-parser
|
||||
```
|
||||
|
||||
or using yarn:
|
||||
|
||||
```sh
|
||||
yarn add @babel/helper-string-parser
|
||||
```
|
||||
@@ -0,0 +1,5 @@
|
||||
'use strict';
|
||||
|
||||
throw new Error(
|
||||
'react-dom/profiling is not supported in React Server Components.'
|
||||
);
|
||||
Reference in New Issue
Block a user