update
This commit is contained in:
File diff suppressed because one or more lines are too long
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
@license
|
||||
Rollup.js v4.39.0
|
||||
Wed, 02 Apr 2025 04:49:00 GMT - commit 5c001245779063abac3899aa9d25294ab003581b
|
||||
|
||||
https://github.com/rollup/rollup
|
||||
|
||||
Released under the MIT License.
|
||||
*/
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
||||
|
||||
const rollup = require('./shared/rollup.js');
|
||||
const parseAst_js = require('./shared/parseAst.js');
|
||||
const fseventsImporter = require('./shared/fsevents-importer.js');
|
||||
require('node:process');
|
||||
require('node:path');
|
||||
require('path');
|
||||
require('./native.js');
|
||||
require('node:perf_hooks');
|
||||
require('node:fs/promises');
|
||||
|
||||
class WatchEmitter {
|
||||
constructor() {
|
||||
this.currentHandlers = Object.create(null);
|
||||
this.persistentHandlers = Object.create(null);
|
||||
}
|
||||
// Will be overwritten by Rollup
|
||||
async close() { }
|
||||
emit(event, ...parameters) {
|
||||
return Promise.all([...this.getCurrentHandlers(event), ...this.getPersistentHandlers(event)].map(handler => handler(...parameters)));
|
||||
}
|
||||
off(event, listener) {
|
||||
const listeners = this.persistentHandlers[event];
|
||||
if (listeners) {
|
||||
// A hack stolen from "mitt": ">>> 0" does not change numbers >= 0, but -1
|
||||
// (which would remove the last array element if used unchanged) is turned
|
||||
// into max_int, which is outside the array and does not change anything.
|
||||
listeners.splice(listeners.indexOf(listener) >>> 0, 1);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
on(event, listener) {
|
||||
this.getPersistentHandlers(event).push(listener);
|
||||
return this;
|
||||
}
|
||||
onCurrentRun(event, listener) {
|
||||
this.getCurrentHandlers(event).push(listener);
|
||||
return this;
|
||||
}
|
||||
once(event, listener) {
|
||||
const selfRemovingListener = (...parameters) => {
|
||||
this.off(event, selfRemovingListener);
|
||||
return listener(...parameters);
|
||||
};
|
||||
this.on(event, selfRemovingListener);
|
||||
return this;
|
||||
}
|
||||
removeAllListeners() {
|
||||
this.removeListenersForCurrentRun();
|
||||
this.persistentHandlers = Object.create(null);
|
||||
return this;
|
||||
}
|
||||
removeListenersForCurrentRun() {
|
||||
this.currentHandlers = Object.create(null);
|
||||
return this;
|
||||
}
|
||||
getCurrentHandlers(event) {
|
||||
return this.currentHandlers[event] || (this.currentHandlers[event] = []);
|
||||
}
|
||||
getPersistentHandlers(event) {
|
||||
return this.persistentHandlers[event] || (this.persistentHandlers[event] = []);
|
||||
}
|
||||
}
|
||||
|
||||
function watch(configs) {
|
||||
const emitter = new WatchEmitter();
|
||||
watchInternal(configs, emitter).catch(error => {
|
||||
rollup.handleError(error);
|
||||
});
|
||||
return emitter;
|
||||
}
|
||||
async function watchInternal(configs, emitter) {
|
||||
const optionsList = await Promise.all(rollup.ensureArray(configs).map(config => rollup.mergeOptions(config, true)));
|
||||
const watchOptionsList = optionsList.filter(config => config.watch !== false);
|
||||
if (watchOptionsList.length === 0) {
|
||||
return parseAst_js.error(parseAst_js.logInvalidOption('watch', parseAst_js.URL_WATCH, 'there must be at least one config where "watch" is not set to "false"'));
|
||||
}
|
||||
await fseventsImporter.loadFsEvents();
|
||||
const { Watcher } = await Promise.resolve().then(() => require('./shared/watch.js'));
|
||||
new Watcher(watchOptionsList, emitter);
|
||||
}
|
||||
|
||||
exports.VERSION = rollup.version;
|
||||
exports.defineConfig = rollup.defineConfig;
|
||||
exports.rollup = rollup.rollup;
|
||||
exports.watch = watch;
|
||||
//# sourceMappingURL=rollup.js.map
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"1":"0 9 Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I","2":"C L M G N O P"},C:{"1":"0 9 oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC","2":"1 2 3 4 5 nC LC J PB K D E F A B C L M G N O P QB qC rC","194":"fB gB hB","450":"6 7 8 RB SB TB UB VB WB XB YB ZB aB bB cB dB eB","2242":"iB jB kB lB mB nB"},D:{"1":"0 9 tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC","2":"1 2 3 4 5 6 7 8 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB","578":"gB hB iB jB kB lB mB nB oB pB qB rB sB"},E:{"1":"G zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C","2":"J PB K D E F A sC SC tC uC vC wC","1090":"B C L M TC FC GC xC yC"},F:{"1":"0 gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB 4C 5C 6C 7C FC kC 8C GC"},G:{"1":"SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC","2":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD","1090":"KD LD MD ND OD PD QD RD"},H:{"2":"WD"},I:{"1":"I","2":"LC J XD YD ZD aD lC bD cD"},J:{"2":"D A"},K:{"1":"H","2":"A B C FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"2":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 fD gD hD TC iD jD kD lD mD IC JC KC nD","2":"J dD eD"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"rD","2242":"qD"}},B:6,C:"WebGL 2.0",D:true};
|
||||
@@ -0,0 +1,301 @@
|
||||
/**
|
||||
* @fileoverview A utility for retrying failed async method calls.
|
||||
*/
|
||||
|
||||
/* global setTimeout, clearTimeout */
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Constants
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
const MAX_TASK_TIMEOUT = 60000;
|
||||
const MAX_TASK_DELAY = 100;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
* The following logic has been extracted from graceful-fs.
|
||||
*
|
||||
* The ISC License
|
||||
*
|
||||
* Copyright (c) 2011-2023 Isaac Z. Schlueter, Ben Noordhuis, and Contributors
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
|
||||
* IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Checks if it is time to retry a task based on the timestamp and last attempt time.
|
||||
* @param {RetryTask} task The task to check.
|
||||
* @param {number} maxDelay The maximum delay for the queue.
|
||||
* @returns {boolean} true if it is time to retry, false otherwise.
|
||||
*/
|
||||
function isTimeToRetry(task, maxDelay) {
|
||||
const timeSinceLastAttempt = Date.now() - task.lastAttempt;
|
||||
const timeSinceStart = Math.max(task.lastAttempt - task.timestamp, 1);
|
||||
const desiredDelay = Math.min(timeSinceStart * 1.2, maxDelay);
|
||||
|
||||
return timeSinceLastAttempt >= desiredDelay;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if it is time to bail out based on the given timestamp.
|
||||
* @param {RetryTask} task The task to check.
|
||||
* @param {number} timeout The timeout for the queue.
|
||||
* @returns {boolean} true if it is time to bail, false otherwise.
|
||||
*/
|
||||
function isTimeToBail(task, timeout) {
|
||||
return task.age > timeout;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A class to represent a task in the retry queue.
|
||||
*/
|
||||
class RetryTask {
|
||||
|
||||
/**
|
||||
* The unique ID for the task.
|
||||
* @type {string}
|
||||
*/
|
||||
id = Math.random().toString(36).slice(2);
|
||||
|
||||
/**
|
||||
* The function to call.
|
||||
* @type {Function}
|
||||
*/
|
||||
fn;
|
||||
|
||||
/**
|
||||
* The error that was thrown.
|
||||
* @type {Error}
|
||||
*/
|
||||
error;
|
||||
|
||||
/**
|
||||
* The timestamp of the task.
|
||||
* @type {number}
|
||||
*/
|
||||
timestamp = Date.now();
|
||||
|
||||
/**
|
||||
* The timestamp of the last attempt.
|
||||
* @type {number}
|
||||
*/
|
||||
lastAttempt = this.timestamp;
|
||||
|
||||
/**
|
||||
* The resolve function for the promise.
|
||||
* @type {Function}
|
||||
*/
|
||||
resolve;
|
||||
|
||||
/**
|
||||
* The reject function for the promise.
|
||||
* @type {Function}
|
||||
*/
|
||||
reject;
|
||||
|
||||
/**
|
||||
* The AbortSignal to monitor for cancellation.
|
||||
* @type {AbortSignal|undefined}
|
||||
*/
|
||||
signal;
|
||||
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {Function} fn The function to call.
|
||||
* @param {Error} error The error that was thrown.
|
||||
* @param {Function} resolve The resolve function for the promise.
|
||||
* @param {Function} reject The reject function for the promise.
|
||||
* @param {AbortSignal|undefined} signal The AbortSignal to monitor for cancellation.
|
||||
*/
|
||||
constructor(fn, error, resolve, reject, signal) {
|
||||
this.fn = fn;
|
||||
this.error = error;
|
||||
this.timestamp = Date.now();
|
||||
this.lastAttempt = Date.now();
|
||||
this.resolve = resolve;
|
||||
this.reject = reject;
|
||||
this.signal = signal;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the age of the task.
|
||||
* @returns {number} The age of the task in milliseconds.
|
||||
* @readonly
|
||||
*/
|
||||
get age() {
|
||||
return Date.now() - this.timestamp;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Exports
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* A class that manages a queue of retry jobs.
|
||||
*/
|
||||
class Retrier {
|
||||
|
||||
/**
|
||||
* Represents the queue for processing tasks.
|
||||
* @type {Array<RetryTask>}
|
||||
*/
|
||||
#queue = [];
|
||||
|
||||
/**
|
||||
* The timeout for the queue.
|
||||
* @type {number}
|
||||
*/
|
||||
#timeout;
|
||||
|
||||
/**
|
||||
* The maximum delay for the queue.
|
||||
* @type {number}
|
||||
*/
|
||||
#maxDelay;
|
||||
|
||||
/**
|
||||
* The setTimeout() timer ID.
|
||||
* @type {NodeJS.Timeout|undefined}
|
||||
*/
|
||||
#timerId;
|
||||
|
||||
/**
|
||||
* The function to call.
|
||||
* @type {Function}
|
||||
*/
|
||||
#check;
|
||||
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {Function} check The function to call.
|
||||
* @param {object} [options] The options for the instance.
|
||||
* @param {number} [options.timeout] The timeout for the queue.
|
||||
* @param {number} [options.maxDelay] The maximum delay for the queue.
|
||||
*/
|
||||
constructor(check, { timeout = MAX_TASK_TIMEOUT, maxDelay = MAX_TASK_DELAY } = {}) {
|
||||
|
||||
if (typeof check !== "function") {
|
||||
throw new Error("Missing function to check errors");
|
||||
}
|
||||
|
||||
this.#check = check;
|
||||
this.#timeout = timeout;
|
||||
this.#maxDelay = maxDelay;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a new retry job to the queue.
|
||||
* @param {Function} fn The function to call.
|
||||
* @param {object} [options] The options for the job.
|
||||
* @param {AbortSignal} [options.signal] The AbortSignal to monitor for cancellation.
|
||||
* @returns {Promise<any>} A promise that resolves when the queue is
|
||||
* processed.
|
||||
*/
|
||||
retry(fn, { signal } = {}) {
|
||||
|
||||
signal?.throwIfAborted();
|
||||
|
||||
let result;
|
||||
|
||||
try {
|
||||
result = fn();
|
||||
} catch (/** @type {any} */ error) {
|
||||
return Promise.reject(new Error(`Synchronous error: ${error.message}`, { cause: error }));
|
||||
}
|
||||
|
||||
// if the result is not a promise then reject an error
|
||||
if (!result || typeof result.then !== "function") {
|
||||
return Promise.reject(new Error("Result is not a promise."));
|
||||
}
|
||||
|
||||
// call the original function and catch any ENFILE or EMFILE errors
|
||||
// @ts-ignore because we know it's any
|
||||
return Promise.resolve(result).catch(error => {
|
||||
if (!this.#check(error)) {
|
||||
throw error;
|
||||
}
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
this.#queue.push(new RetryTask(fn, error, resolve, reject, signal));
|
||||
|
||||
signal?.addEventListener("abort", () => {
|
||||
reject(signal.reason);
|
||||
});
|
||||
|
||||
this.#processQueue();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes the queue.
|
||||
* @returns {void}
|
||||
*/
|
||||
#processQueue() {
|
||||
// clear any timer because we're going to check right now
|
||||
clearTimeout(this.#timerId);
|
||||
this.#timerId = undefined;
|
||||
|
||||
// if there's nothing in the queue, we're done
|
||||
const task = this.#queue.shift();
|
||||
if (!task) {
|
||||
return;
|
||||
}
|
||||
const processAgain = () => {
|
||||
this.#timerId = setTimeout(() => this.#processQueue(), 0);
|
||||
};
|
||||
|
||||
// if it's time to bail, then bail
|
||||
if (isTimeToBail(task, this.#timeout)) {
|
||||
task.reject(task.error);
|
||||
processAgain();
|
||||
return;
|
||||
}
|
||||
|
||||
// if it's not time to retry, then wait and try again
|
||||
if (!isTimeToRetry(task, this.#maxDelay)) {
|
||||
this.#queue.push(task);
|
||||
processAgain();
|
||||
return;
|
||||
}
|
||||
|
||||
// otherwise, try again
|
||||
task.lastAttempt = Date.now();
|
||||
|
||||
// Promise.resolve needed in case it's a thenable but not a Promise
|
||||
Promise.resolve(task.fn())
|
||||
// @ts-ignore because we know it's any
|
||||
.then(result => task.resolve(result))
|
||||
|
||||
// @ts-ignore because we know it's any
|
||||
.catch(error => {
|
||||
if (!this.#check(error)) {
|
||||
task.reject(error);
|
||||
return;
|
||||
}
|
||||
|
||||
// update the task timestamp and push to back of queue to try again
|
||||
task.lastAttempt = Date.now();
|
||||
this.#queue.push(task);
|
||||
|
||||
})
|
||||
.finally(() => this.#processQueue());
|
||||
}
|
||||
}
|
||||
|
||||
export { Retrier };
|
||||
@@ -0,0 +1,156 @@
|
||||
/**
|
||||
* @fileoverview A rule to disallow `this` keywords in contexts where the value of `this` is `undefined`.
|
||||
* @author Toru Nagashima
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Determines if the given code path is a code path with lexical `this` binding.
|
||||
* That is, if `this` within the code path refers to `this` of surrounding code path.
|
||||
* @param {CodePath} codePath Code path.
|
||||
* @param {ASTNode} node Node that started the code path.
|
||||
* @returns {boolean} `true` if it is a code path with lexical `this` binding.
|
||||
*/
|
||||
function isCodePathWithLexicalThis(codePath, node) {
|
||||
return (
|
||||
codePath.origin === "function" &&
|
||||
node.type === "ArrowFunctionExpression"
|
||||
);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
defaultOptions: [{ capIsConstructor: true }],
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow use of `this` in contexts where the value of `this` is `undefined`",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-invalid-this",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
type: "object",
|
||||
properties: {
|
||||
capIsConstructor: {
|
||||
type: "boolean",
|
||||
},
|
||||
},
|
||||
additionalProperties: false,
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
unexpectedThis: "Unexpected 'this'.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const [{ capIsConstructor }] = context.options;
|
||||
const stack = [],
|
||||
sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Gets the current checking context.
|
||||
*
|
||||
* The return value has a flag that whether or not `this` keyword is valid.
|
||||
* The flag is initialized when got at the first time.
|
||||
* @returns {{valid: boolean}}
|
||||
* an object which has a flag that whether or not `this` keyword is valid.
|
||||
*/
|
||||
stack.getCurrent = function () {
|
||||
const current = this.at(-1);
|
||||
|
||||
if (!current.init) {
|
||||
current.init = true;
|
||||
current.valid = !astUtils.isDefaultThisBinding(
|
||||
current.node,
|
||||
sourceCode,
|
||||
{ capIsConstructor },
|
||||
);
|
||||
}
|
||||
return current;
|
||||
};
|
||||
|
||||
return {
|
||||
onCodePathStart(codePath, node) {
|
||||
if (isCodePathWithLexicalThis(codePath, node)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (codePath.origin === "program") {
|
||||
const scope = sourceCode.getScope(node);
|
||||
const features =
|
||||
context.languageOptions.parserOptions.ecmaFeatures ||
|
||||
{};
|
||||
|
||||
// `this` at the top level of scripts always refers to the global object
|
||||
stack.push({
|
||||
init: true,
|
||||
node,
|
||||
valid: !(
|
||||
node.sourceType === "module" ||
|
||||
(features.globalReturn &&
|
||||
scope.childScopes[0].isStrict)
|
||||
),
|
||||
});
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* `init: false` means that `valid` isn't determined yet.
|
||||
* Most functions don't use `this`, and the calculation for `valid`
|
||||
* is relatively costly, so we'll calculate it lazily when the first
|
||||
* `this` within the function is traversed. A special case are non-strict
|
||||
* functions, because `this` refers to the global object and therefore is
|
||||
* always valid, so we can set `init: true` right away.
|
||||
*/
|
||||
stack.push({
|
||||
init: !sourceCode.getScope(node).isStrict,
|
||||
node,
|
||||
valid: true,
|
||||
});
|
||||
},
|
||||
|
||||
onCodePathEnd(codePath, node) {
|
||||
if (isCodePathWithLexicalThis(codePath, node)) {
|
||||
return;
|
||||
}
|
||||
|
||||
stack.pop();
|
||||
},
|
||||
|
||||
// Reports if `this` of the current context is invalid.
|
||||
ThisExpression(node) {
|
||||
const current = stack.getCurrent();
|
||||
|
||||
if (current && !current.valid) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpectedThis",
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,37 @@
|
||||
{
|
||||
"name": "lightningcss-linux-arm64-gnu",
|
||||
"version": "1.29.2",
|
||||
"license": "MPL-2.0",
|
||||
"description": "A CSS parser, transformer, and minifier written in Rust",
|
||||
"main": "lightningcss.linux-arm64-gnu.node",
|
||||
"browserslist": "last 2 versions, not dead",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/parcel"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/parcel-bundler/lightningcss.git"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 12.0.0"
|
||||
},
|
||||
"files": [
|
||||
"lightningcss.linux-arm64-gnu.node"
|
||||
],
|
||||
"resolutions": {
|
||||
"lightningcss": "link:."
|
||||
},
|
||||
"os": [
|
||||
"linux"
|
||||
],
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
"libc": [
|
||||
"glibc"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = addComment;
|
||||
var _addComments = require("./addComments.js");
|
||||
function addComment(node, type, content, line) {
|
||||
return (0, _addComments.default)(node, type, [{
|
||||
type: line ? "CommentLine" : "CommentBlock",
|
||||
value: content
|
||||
}]);
|
||||
}
|
||||
|
||||
//# sourceMappingURL=addComment.js.map
|
||||
@@ -0,0 +1,52 @@
|
||||
'use strict'
|
||||
|
||||
const statuses = require('../lib/statuses')
|
||||
const supported = require('../lib/supported')
|
||||
const browsers = require('./browsers').browsers
|
||||
const versions = require('./browserVersions').browserVersions
|
||||
|
||||
const MATH2LOG = Math.log(2)
|
||||
|
||||
function unpackSupport(cipher) {
|
||||
// bit flags
|
||||
let stats = Object.keys(supported).reduce((list, support) => {
|
||||
if (cipher & supported[support]) list.push(support)
|
||||
return list
|
||||
}, [])
|
||||
|
||||
// notes
|
||||
let notes = cipher >> 7
|
||||
let notesArray = []
|
||||
while (notes) {
|
||||
let note = Math.floor(Math.log(notes) / MATH2LOG) + 1
|
||||
notesArray.unshift(`#${note}`)
|
||||
notes -= Math.pow(2, note - 1)
|
||||
}
|
||||
|
||||
return stats.concat(notesArray).join(' ')
|
||||
}
|
||||
|
||||
function unpackFeature(packed) {
|
||||
let unpacked = {
|
||||
status: statuses[packed.B],
|
||||
title: packed.C,
|
||||
shown: packed.D
|
||||
}
|
||||
unpacked.stats = Object.keys(packed.A).reduce((browserStats, key) => {
|
||||
let browser = packed.A[key]
|
||||
browserStats[browsers[key]] = Object.keys(browser).reduce(
|
||||
(stats, support) => {
|
||||
let packedVersions = browser[support].split(' ')
|
||||
let unpacked2 = unpackSupport(support)
|
||||
packedVersions.forEach(v => (stats[versions[v]] = unpacked2))
|
||||
return stats
|
||||
},
|
||||
{}
|
||||
)
|
||||
return browserStats
|
||||
}, {})
|
||||
return unpacked
|
||||
}
|
||||
|
||||
module.exports = unpackFeature
|
||||
module.exports.default = unpackFeature
|
||||
Binary file not shown.
@@ -0,0 +1,69 @@
|
||||
export {
|
||||
// Type-only exports
|
||||
AcceptedPlugin,
|
||||
|
||||
AnyNode,
|
||||
atRule,
|
||||
AtRule,
|
||||
AtRuleProps,
|
||||
Builder,
|
||||
ChildNode,
|
||||
ChildProps,
|
||||
comment,
|
||||
Comment,
|
||||
CommentProps,
|
||||
Container,
|
||||
ContainerProps,
|
||||
CssSyntaxError,
|
||||
decl,
|
||||
Declaration,
|
||||
DeclarationProps,
|
||||
// postcss function / namespace
|
||||
default,
|
||||
document,
|
||||
Document,
|
||||
DocumentProps,
|
||||
FilePosition,
|
||||
fromJSON,
|
||||
Helpers,
|
||||
Input,
|
||||
|
||||
JSONHydrator,
|
||||
// This is a class, but it’s not re-exported. That’s why it’s exported as type-only here.
|
||||
type LazyResult,
|
||||
list,
|
||||
Message,
|
||||
Node,
|
||||
NodeErrorOptions,
|
||||
NodeProps,
|
||||
OldPlugin,
|
||||
parse,
|
||||
Parser,
|
||||
// @ts-expect-error This value exists, but it’s untyped.
|
||||
plugin,
|
||||
Plugin,
|
||||
PluginCreator,
|
||||
Position,
|
||||
Postcss,
|
||||
ProcessOptions,
|
||||
Processor,
|
||||
Result,
|
||||
root,
|
||||
Root,
|
||||
RootProps,
|
||||
rule,
|
||||
Rule,
|
||||
RuleProps,
|
||||
Source,
|
||||
SourceMap,
|
||||
SourceMapOptions,
|
||||
Stringifier,
|
||||
// Value exports from postcss.mjs
|
||||
stringify,
|
||||
Syntax,
|
||||
TransformCallback,
|
||||
Transformer,
|
||||
Warning,
|
||||
|
||||
WarningOptions
|
||||
} from './postcss.js'
|
||||
@@ -0,0 +1,15 @@
|
||||
# Installation
|
||||
> `npm install --save @types/babel__traverse`
|
||||
|
||||
# Summary
|
||||
This package contains type definitions for @babel/traverse (https://github.com/babel/babel/tree/main/packages/babel-traverse).
|
||||
|
||||
# Details
|
||||
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__traverse.
|
||||
|
||||
### Additional Details
|
||||
* Last updated: Wed, 26 Mar 2025 08:02:36 GMT
|
||||
* Dependencies: [@babel/types](https://npmjs.com/package/@babel/types)
|
||||
|
||||
# Credits
|
||||
These definitions were written by [Troy Gerwien](https://github.com/yortus), [Marvin Hagemeister](https://github.com/marvinhagemeister), [Ryan Petrich](https://github.com/rpetrich), [Melvin Groenhoff](https://github.com/mgroenhoff), [Dean L.](https://github.com/dlgrit), [Ifiok Jr.](https://github.com/ifiokjr), [ExE Boss](https://github.com/ExE-Boss), and [Daniel Tschinder](https://github.com/danez).
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"1":"E F A B","4":"mC","132":"K D"},B:{"1":"0 9 C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I"},C:{"1":"0 1 2 3 4 5 6 7 8 9 LC J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC qC rC","36":"nC"},D:{"1":"0 1 2 3 4 5 6 7 8 9 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC"},E:{"1":"J PB K D E F A B C L M G sC SC tC uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C"},F:{"1":"0 1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 4C 5C 6C 7C FC kC 8C GC"},G:{"1":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC"},H:{"1":"WD"},I:{"1":"LC J I XD YD ZD aD lC bD cD"},J:{"1":"D A"},K:{"1":"A B C H FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"1":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"qD rD"}},B:2,C:"CSS inline-block",D:true};
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag when using new Function
|
||||
* @author Ilya Volodin
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const callMethods = new Set(["apply", "bind", "call"]);
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../shared/types').Rule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow `new` operators with the `Function` object",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-new-func",
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
noFunctionConstructor: "The Function constructor is eval.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
return {
|
||||
"Program:exit"(node) {
|
||||
const globalScope = sourceCode.getScope(node);
|
||||
const variable = globalScope.set.get("Function");
|
||||
|
||||
if (variable && variable.defs.length === 0) {
|
||||
variable.references.forEach(ref => {
|
||||
const idNode = ref.identifier;
|
||||
const { parent } = idNode;
|
||||
let evalNode;
|
||||
|
||||
if (parent) {
|
||||
if (
|
||||
idNode === parent.callee &&
|
||||
(parent.type === "NewExpression" ||
|
||||
parent.type === "CallExpression")
|
||||
) {
|
||||
evalNode = parent;
|
||||
} else if (
|
||||
parent.type === "MemberExpression" &&
|
||||
idNode === parent.object &&
|
||||
callMethods.has(
|
||||
astUtils.getStaticPropertyName(parent),
|
||||
)
|
||||
) {
|
||||
const maybeCallee =
|
||||
parent.parent.type === "ChainExpression"
|
||||
? parent.parent
|
||||
: parent;
|
||||
|
||||
if (
|
||||
maybeCallee.parent.type ===
|
||||
"CallExpression" &&
|
||||
maybeCallee.parent.callee === maybeCallee
|
||||
) {
|
||||
evalNode = maybeCallee.parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (evalNode) {
|
||||
context.report({
|
||||
node: evalNode,
|
||||
messageId: "noFunctionConstructor",
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"1":"0 9 Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I","2":"C L M G N O P"},C:{"1":"0 9 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC","2":"1 2 3 4 5 6 7 8 nC LC J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB qC rC","194":"eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B"},D:{"1":"0 9 pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC","2":"1 2 3 4 5 6 7 8 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB","66":"oB"},E:{"1":"VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C","2":"J PB K D E F A B C L M G sC SC tC uC vC wC TC FC GC xC yC zC UC"},F:{"1":"0 dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB VB WB XB YB ZB aB 4C 5C 6C 7C FC kC 8C GC","66":"bB cB"},G:{"1":"VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC","2":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC"},H:{"2":"WD"},I:{"1":"I","2":"LC J XD YD ZD aD lC bD cD"},J:{"2":"D A"},K:{"1":"H","2":"A B C FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"2":"A B"},O:{"1":"HC"},P:{"1":"1 2 3 4 5 6 7 8 eD fD gD hD TC iD jD kD lD mD IC JC KC nD","2":"J dD"},Q:{"1":"oD"},R:{"1":"pD"},S:{"1":"rD","194":"qD"}},B:2,C:"CSS Containment",D:true};
|
||||
@@ -0,0 +1,262 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.AssignmentExpression = AssignmentExpression;
|
||||
exports.Binary = Binary;
|
||||
exports.BinaryExpression = BinaryExpression;
|
||||
exports.ClassExpression = ClassExpression;
|
||||
exports.ArrowFunctionExpression = exports.ConditionalExpression = ConditionalExpression;
|
||||
exports.DoExpression = DoExpression;
|
||||
exports.FunctionExpression = FunctionExpression;
|
||||
exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
|
||||
exports.Identifier = Identifier;
|
||||
exports.LogicalExpression = LogicalExpression;
|
||||
exports.NullableTypeAnnotation = NullableTypeAnnotation;
|
||||
exports.ObjectExpression = ObjectExpression;
|
||||
exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
|
||||
exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
|
||||
exports.SequenceExpression = SequenceExpression;
|
||||
exports.TSSatisfiesExpression = exports.TSAsExpression = TSAsExpression;
|
||||
exports.TSConditionalType = TSConditionalType;
|
||||
exports.TSConstructorType = exports.TSFunctionType = TSFunctionType;
|
||||
exports.TSInferType = TSInferType;
|
||||
exports.TSInstantiationExpression = TSInstantiationExpression;
|
||||
exports.TSIntersectionType = TSIntersectionType;
|
||||
exports.UnaryLike = exports.TSTypeAssertion = UnaryLike;
|
||||
exports.TSTypeOperator = TSTypeOperator;
|
||||
exports.TSUnionType = TSUnionType;
|
||||
exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
|
||||
exports.UpdateExpression = UpdateExpression;
|
||||
exports.AwaitExpression = exports.YieldExpression = YieldExpression;
|
||||
var _t = require("@babel/types");
|
||||
var _index = require("./index.js");
|
||||
const {
|
||||
isArrayTypeAnnotation,
|
||||
isBinaryExpression,
|
||||
isCallExpression,
|
||||
isForOfStatement,
|
||||
isIndexedAccessType,
|
||||
isMemberExpression,
|
||||
isObjectPattern,
|
||||
isOptionalMemberExpression,
|
||||
isYieldExpression,
|
||||
isStatement
|
||||
} = _t;
|
||||
const PRECEDENCE = new Map([["||", 0], ["??", 0], ["|>", 0], ["&&", 1], ["|", 2], ["^", 3], ["&", 4], ["==", 5], ["===", 5], ["!=", 5], ["!==", 5], ["<", 6], [">", 6], ["<=", 6], [">=", 6], ["in", 6], ["instanceof", 6], [">>", 7], ["<<", 7], [">>>", 7], ["+", 8], ["-", 8], ["*", 9], ["/", 9], ["%", 9], ["**", 10]]);
|
||||
function getBinaryPrecedence(node, nodeType) {
|
||||
if (nodeType === "BinaryExpression" || nodeType === "LogicalExpression") {
|
||||
return PRECEDENCE.get(node.operator);
|
||||
}
|
||||
if (nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression") {
|
||||
return PRECEDENCE.get("in");
|
||||
}
|
||||
}
|
||||
function isTSTypeExpression(nodeType) {
|
||||
return nodeType === "TSAsExpression" || nodeType === "TSSatisfiesExpression" || nodeType === "TSTypeAssertion";
|
||||
}
|
||||
const isClassExtendsClause = (node, parent) => {
|
||||
const parentType = parent.type;
|
||||
return (parentType === "ClassDeclaration" || parentType === "ClassExpression") && parent.superClass === node;
|
||||
};
|
||||
const hasPostfixPart = (node, parent) => {
|
||||
const parentType = parent.type;
|
||||
return (parentType === "MemberExpression" || parentType === "OptionalMemberExpression") && parent.object === node || (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression") && parent.callee === node || parentType === "TaggedTemplateExpression" && parent.tag === node || parentType === "TSNonNullExpression";
|
||||
};
|
||||
function NullableTypeAnnotation(node, parent) {
|
||||
return isArrayTypeAnnotation(parent);
|
||||
}
|
||||
function FunctionTypeAnnotation(node, parent, tokenContext) {
|
||||
const parentType = parent.type;
|
||||
return (parentType === "UnionTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "ArrayTypeAnnotation" || Boolean(tokenContext & _index.TokenContext.arrowFlowReturnType)
|
||||
);
|
||||
}
|
||||
function UpdateExpression(node, parent) {
|
||||
return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
|
||||
}
|
||||
function needsParenBeforeExpressionBrace(tokenContext) {
|
||||
return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.arrowBody));
|
||||
}
|
||||
function ObjectExpression(node, parent, tokenContext) {
|
||||
return needsParenBeforeExpressionBrace(tokenContext);
|
||||
}
|
||||
function DoExpression(node, parent, tokenContext) {
|
||||
return !node.async && Boolean(tokenContext & _index.TokenContext.expressionStatement);
|
||||
}
|
||||
function Binary(node, parent) {
|
||||
const parentType = parent.type;
|
||||
if (node.type === "BinaryExpression" && node.operator === "**" && parentType === "BinaryExpression" && parent.operator === "**") {
|
||||
return parent.left === node;
|
||||
}
|
||||
if (isClassExtendsClause(node, parent)) {
|
||||
return true;
|
||||
}
|
||||
if (hasPostfixPart(node, parent) || parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "AwaitExpression") {
|
||||
return true;
|
||||
}
|
||||
const parentPos = getBinaryPrecedence(parent, parentType);
|
||||
if (parentPos != null) {
|
||||
const nodePos = getBinaryPrecedence(node, node.type);
|
||||
if (parentPos === nodePos && parentType === "BinaryExpression" && parent.right === node || parentPos > nodePos) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
function UnionTypeAnnotation(node, parent) {
|
||||
const parentType = parent.type;
|
||||
return parentType === "ArrayTypeAnnotation" || parentType === "NullableTypeAnnotation" || parentType === "IntersectionTypeAnnotation" || parentType === "UnionTypeAnnotation";
|
||||
}
|
||||
function OptionalIndexedAccessType(node, parent) {
|
||||
return isIndexedAccessType(parent) && parent.objectType === node;
|
||||
}
|
||||
function TSAsExpression(node, parent) {
|
||||
if ((parent.type === "AssignmentExpression" || parent.type === "AssignmentPattern") && parent.left === node) {
|
||||
return true;
|
||||
}
|
||||
if (parent.type === "BinaryExpression" && (parent.operator === "|" || parent.operator === "&") && node === parent.left) {
|
||||
return true;
|
||||
}
|
||||
return Binary(node, parent);
|
||||
}
|
||||
function TSConditionalType(node, parent) {
|
||||
const parentType = parent.type;
|
||||
if (parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType" || parentType === "TSTypeOperator" || parentType === "TSTypeParameter") {
|
||||
return true;
|
||||
}
|
||||
if ((parentType === "TSIntersectionType" || parentType === "TSUnionType") && parent.types[0] === node) {
|
||||
return true;
|
||||
}
|
||||
if (parentType === "TSConditionalType" && (parent.checkType === node || parent.extendsType === node)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function TSUnionType(node, parent) {
|
||||
const parentType = parent.type;
|
||||
return parentType === "TSIntersectionType" || parentType === "TSTypeOperator" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType";
|
||||
}
|
||||
function TSIntersectionType(node, parent) {
|
||||
const parentType = parent.type;
|
||||
return parentType === "TSTypeOperator" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType";
|
||||
}
|
||||
function TSInferType(node, parent) {
|
||||
const parentType = parent.type;
|
||||
if (parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType") {
|
||||
return true;
|
||||
}
|
||||
if (node.typeParameter.constraint) {
|
||||
if ((parentType === "TSIntersectionType" || parentType === "TSUnionType") && parent.types[0] === node) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function TSTypeOperator(node, parent) {
|
||||
const parentType = parent.type;
|
||||
return parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSOptionalType";
|
||||
}
|
||||
function TSInstantiationExpression(node, parent) {
|
||||
const parentType = parent.type;
|
||||
return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeParameters;
|
||||
}
|
||||
function TSFunctionType(node, parent) {
|
||||
const parentType = parent.type;
|
||||
return parentType === "TSIntersectionType" || parentType === "TSUnionType" || parentType === "TSTypeOperator" || parentType === "TSOptionalType" || parentType === "TSArrayType" || parentType === "TSIndexedAccessType" && parent.objectType === node || parentType === "TSConditionalType" && (parent.checkType === node || parent.extendsType === node);
|
||||
}
|
||||
function BinaryExpression(node, parent, tokenContext, inForStatementInit) {
|
||||
return node.operator === "in" && inForStatementInit;
|
||||
}
|
||||
function SequenceExpression(node, parent) {
|
||||
const parentType = parent.type;
|
||||
if (parentType === "SequenceExpression" || parentType === "ParenthesizedExpression" || parentType === "MemberExpression" && parent.property === node || parentType === "OptionalMemberExpression" && parent.property === node || parentType === "TemplateLiteral") {
|
||||
return false;
|
||||
}
|
||||
if (parentType === "ClassDeclaration") {
|
||||
return true;
|
||||
}
|
||||
if (parentType === "ForOfStatement") {
|
||||
return parent.right === node;
|
||||
}
|
||||
if (parentType === "ExportDefaultDeclaration") {
|
||||
return true;
|
||||
}
|
||||
return !isStatement(parent);
|
||||
}
|
||||
function YieldExpression(node, parent) {
|
||||
const parentType = parent.type;
|
||||
return parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "UnaryExpression" || parentType === "SpreadElement" || hasPostfixPart(node, parent) || parentType === "AwaitExpression" && isYieldExpression(node) || parentType === "ConditionalExpression" && node === parent.test || isClassExtendsClause(node, parent) || isTSTypeExpression(parentType);
|
||||
}
|
||||
function ClassExpression(node, parent, tokenContext) {
|
||||
return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault));
|
||||
}
|
||||
function UnaryLike(node, parent) {
|
||||
return hasPostfixPart(node, parent) || isBinaryExpression(parent) && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent);
|
||||
}
|
||||
function FunctionExpression(node, parent, tokenContext) {
|
||||
return Boolean(tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault));
|
||||
}
|
||||
function ConditionalExpression(node, parent) {
|
||||
const parentType = parent.type;
|
||||
if (parentType === "UnaryExpression" || parentType === "SpreadElement" || parentType === "BinaryExpression" || parentType === "LogicalExpression" || parentType === "ConditionalExpression" && parent.test === node || parentType === "AwaitExpression" || isTSTypeExpression(parentType)) {
|
||||
return true;
|
||||
}
|
||||
return UnaryLike(node, parent);
|
||||
}
|
||||
function OptionalMemberExpression(node, parent) {
|
||||
return isCallExpression(parent) && parent.callee === node || isMemberExpression(parent) && parent.object === node;
|
||||
}
|
||||
function AssignmentExpression(node, parent, tokenContext) {
|
||||
if (needsParenBeforeExpressionBrace(tokenContext) && isObjectPattern(node.left)) {
|
||||
return true;
|
||||
} else {
|
||||
return ConditionalExpression(node, parent);
|
||||
}
|
||||
}
|
||||
function LogicalExpression(node, parent) {
|
||||
const parentType = parent.type;
|
||||
if (isTSTypeExpression(parentType)) return true;
|
||||
if (parentType !== "LogicalExpression") return false;
|
||||
switch (node.operator) {
|
||||
case "||":
|
||||
return parent.operator === "??" || parent.operator === "&&";
|
||||
case "&&":
|
||||
return parent.operator === "??";
|
||||
case "??":
|
||||
return parent.operator !== "??";
|
||||
}
|
||||
}
|
||||
function Identifier(node, parent, tokenContext, _inForInit, getRawIdentifier) {
|
||||
var _node$extra;
|
||||
const parentType = parent.type;
|
||||
if ((_node$extra = node.extra) != null && _node$extra.parenthesized && parentType === "AssignmentExpression" && parent.left === node) {
|
||||
const rightType = parent.right.type;
|
||||
if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (getRawIdentifier && getRawIdentifier(node) !== node.name) {
|
||||
return false;
|
||||
}
|
||||
if (node.name === "let") {
|
||||
const isFollowedByBracket = isMemberExpression(parent, {
|
||||
object: node,
|
||||
computed: true
|
||||
}) || isOptionalMemberExpression(parent, {
|
||||
object: node,
|
||||
computed: true,
|
||||
optional: false
|
||||
});
|
||||
if (isFollowedByBracket && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forHead | _index.TokenContext.forInHead)) {
|
||||
return true;
|
||||
}
|
||||
return Boolean(tokenContext & _index.TokenContext.forOfHead);
|
||||
}
|
||||
return node.name === "async" && isForOfStatement(parent, {
|
||||
left: node,
|
||||
await: false
|
||||
});
|
||||
}
|
||||
|
||||
//# sourceMappingURL=parentheses.js.map
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* @license React
|
||||
* use-sync-external-store-shim.production.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var React = require("react");
|
||||
function is(x, y) {
|
||||
return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
|
||||
}
|
||||
var objectIs = "function" === typeof Object.is ? Object.is : is,
|
||||
useState = React.useState,
|
||||
useEffect = React.useEffect,
|
||||
useLayoutEffect = React.useLayoutEffect,
|
||||
useDebugValue = React.useDebugValue;
|
||||
function useSyncExternalStore$2(subscribe, getSnapshot) {
|
||||
var value = getSnapshot(),
|
||||
_useState = useState({ inst: { value: value, getSnapshot: getSnapshot } }),
|
||||
inst = _useState[0].inst,
|
||||
forceUpdate = _useState[1];
|
||||
useLayoutEffect(
|
||||
function () {
|
||||
inst.value = value;
|
||||
inst.getSnapshot = getSnapshot;
|
||||
checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
|
||||
},
|
||||
[subscribe, value, getSnapshot]
|
||||
);
|
||||
useEffect(
|
||||
function () {
|
||||
checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
|
||||
return subscribe(function () {
|
||||
checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
|
||||
});
|
||||
},
|
||||
[subscribe]
|
||||
);
|
||||
useDebugValue(value);
|
||||
return value;
|
||||
}
|
||||
function checkIfSnapshotChanged(inst) {
|
||||
var latestGetSnapshot = inst.getSnapshot;
|
||||
inst = inst.value;
|
||||
try {
|
||||
var nextValue = latestGetSnapshot();
|
||||
return !objectIs(inst, nextValue);
|
||||
} catch (error) {
|
||||
return !0;
|
||||
}
|
||||
}
|
||||
function useSyncExternalStore$1(subscribe, getSnapshot) {
|
||||
return getSnapshot();
|
||||
}
|
||||
var shim =
|
||||
"undefined" === typeof window ||
|
||||
"undefined" === typeof window.document ||
|
||||
"undefined" === typeof window.document.createElement
|
||||
? useSyncExternalStore$1
|
||||
: useSyncExternalStore$2;
|
||||
exports.useSyncExternalStore =
|
||||
void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"K D E F A B mC"},B:{"1":"0 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I","2":"C L M G N O P Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w"},C:{"2":"1 2 3 4 5 6 7 8 nC LC J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g qC rC","194":"0 9 h i j k l m n o p q r s t u v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC oC pC"},D:{"1":"0 9 x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB I PC EC QC RC","2":"1 2 3 4 5 6 7 8 J PB K D E F A B C L M G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB MC wB NC xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w"},E:{"2":"J PB K D E F A B C L M G sC SC tC uC vC wC TC FC GC xC yC zC UC VC HC 0C IC WC XC YC ZC aC 1C JC bC cC dC eC fC 2C KC gC hC iC jC 3C"},F:{"1":"0 j k l m n o p q r s t u v w x y z","2":"1 2 3 4 5 6 7 8 F B C G N O P QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC Q H R OC S T U V W X Y Z a b c d e f g h i 4C 5C 6C 7C FC kC 8C GC"},G:{"2":"E SC 9C lC AD BD CD DD ED FD GD HD ID JD KD LD MD ND OD PD QD RD SD UC VC HC TD IC WC XC YC ZC aC UD JC bC cC dC eC fC VD KC gC hC iC jC"},H:{"2":"WD"},I:{"1":"I","2":"LC J XD YD ZD aD lC bD cD"},J:{"2":"D A"},K:{"2":"A B C H FC kC GC"},L:{"1":"I"},M:{"1":"EC"},N:{"2":"A B"},O:{"1":"HC"},P:{"1":"4 5 6 7 8","2":"1 2 3 J dD eD fD gD hD TC iD jD kD lD mD IC JC KC nD"},Q:{"16":"oD"},R:{"16":"pD"},S:{"2":"qD","16":"rD"}},B:5,C:"WebAssembly Relaxed SIMD",D:false};
|
||||
@@ -0,0 +1,85 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
var _genMapping = require("@jridgewell/gen-mapping");
|
||||
var _traceMapping = require("@jridgewell/trace-mapping");
|
||||
class SourceMap {
|
||||
constructor(opts, code) {
|
||||
var _opts$sourceFileName;
|
||||
this._map = void 0;
|
||||
this._rawMappings = void 0;
|
||||
this._sourceFileName = void 0;
|
||||
this._lastGenLine = 0;
|
||||
this._lastSourceLine = 0;
|
||||
this._lastSourceColumn = 0;
|
||||
this._inputMap = void 0;
|
||||
const map = this._map = new _genMapping.GenMapping({
|
||||
sourceRoot: opts.sourceRoot
|
||||
});
|
||||
this._sourceFileName = (_opts$sourceFileName = opts.sourceFileName) == null ? void 0 : _opts$sourceFileName.replace(/\\/g, "/");
|
||||
this._rawMappings = undefined;
|
||||
if (opts.inputSourceMap) {
|
||||
this._inputMap = new _traceMapping.TraceMap(opts.inputSourceMap);
|
||||
const resolvedSources = this._inputMap.resolvedSources;
|
||||
if (resolvedSources.length) {
|
||||
for (let i = 0; i < resolvedSources.length; i++) {
|
||||
var _this$_inputMap$sourc;
|
||||
(0, _genMapping.setSourceContent)(map, resolvedSources[i], (_this$_inputMap$sourc = this._inputMap.sourcesContent) == null ? void 0 : _this$_inputMap$sourc[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (typeof code === "string" && !opts.inputSourceMap) {
|
||||
(0, _genMapping.setSourceContent)(map, this._sourceFileName, code);
|
||||
} else if (typeof code === "object") {
|
||||
for (const sourceFileName of Object.keys(code)) {
|
||||
(0, _genMapping.setSourceContent)(map, sourceFileName.replace(/\\/g, "/"), code[sourceFileName]);
|
||||
}
|
||||
}
|
||||
}
|
||||
get() {
|
||||
return (0, _genMapping.toEncodedMap)(this._map);
|
||||
}
|
||||
getDecoded() {
|
||||
return (0, _genMapping.toDecodedMap)(this._map);
|
||||
}
|
||||
getRawMappings() {
|
||||
return this._rawMappings || (this._rawMappings = (0, _genMapping.allMappings)(this._map));
|
||||
}
|
||||
mark(generated, line, column, identifierName, identifierNamePos, filename) {
|
||||
var _originalMapping;
|
||||
this._rawMappings = undefined;
|
||||
let originalMapping;
|
||||
if (line != null) {
|
||||
if (this._inputMap) {
|
||||
originalMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, {
|
||||
line,
|
||||
column
|
||||
});
|
||||
if (!originalMapping.name && identifierNamePos) {
|
||||
const originalIdentifierMapping = (0, _traceMapping.originalPositionFor)(this._inputMap, identifierNamePos);
|
||||
if (originalIdentifierMapping.name) {
|
||||
identifierName = originalIdentifierMapping.name;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
originalMapping = {
|
||||
source: (filename == null ? void 0 : filename.replace(/\\/g, "/")) || this._sourceFileName,
|
||||
line: line,
|
||||
column: column
|
||||
};
|
||||
}
|
||||
}
|
||||
(0, _genMapping.maybeAddMapping)(this._map, {
|
||||
name: identifierName,
|
||||
generated,
|
||||
source: (_originalMapping = originalMapping) == null ? void 0 : _originalMapping.source,
|
||||
original: originalMapping
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.default = SourceMap;
|
||||
|
||||
//# sourceMappingURL=source-map.js.map
|
||||
@@ -0,0 +1,227 @@
|
||||
/**
|
||||
* @fileoverview `OverrideTester` class.
|
||||
*
|
||||
* `OverrideTester` class handles `files` property and `excludedFiles` property
|
||||
* of `overrides` config.
|
||||
*
|
||||
* It provides one method.
|
||||
*
|
||||
* - `test(filePath)`
|
||||
* Test if a file path matches the pair of `files` property and
|
||||
* `excludedFiles` property. The `filePath` argument must be an absolute
|
||||
* path.
|
||||
*
|
||||
* `ConfigArrayFactory` creates `OverrideTester` objects when it processes
|
||||
* `overrides` properties.
|
||||
*
|
||||
* @author Toru Nagashima <https://github.com/mysticatea>
|
||||
*/
|
||||
|
||||
import assert from "node:assert";
|
||||
import path from "node:path";
|
||||
import util from "node:util";
|
||||
import minimatch from "minimatch";
|
||||
|
||||
const { Minimatch } = minimatch;
|
||||
|
||||
const minimatchOpts = { dot: true, matchBase: true };
|
||||
|
||||
/**
|
||||
* @typedef {Object} Pattern
|
||||
* @property {InstanceType<Minimatch>[] | null} includes The positive matchers.
|
||||
* @property {InstanceType<Minimatch>[] | null} excludes The negative matchers.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Normalize a given pattern to an array.
|
||||
* @param {string|string[]|undefined} patterns A glob pattern or an array of glob patterns.
|
||||
* @returns {string[]|null} Normalized patterns.
|
||||
* @private
|
||||
*/
|
||||
function normalizePatterns(patterns) {
|
||||
if (Array.isArray(patterns)) {
|
||||
return patterns.filter(Boolean);
|
||||
}
|
||||
if (typeof patterns === "string" && patterns) {
|
||||
return [patterns];
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Create the matchers of given patterns.
|
||||
* @param {string[]} patterns The patterns.
|
||||
* @returns {InstanceType<Minimatch>[] | null} The matchers.
|
||||
*/
|
||||
function toMatcher(patterns) {
|
||||
if (patterns.length === 0) {
|
||||
return null;
|
||||
}
|
||||
return patterns.map(pattern => {
|
||||
if (/^\.[/\\]/u.test(pattern)) {
|
||||
return new Minimatch(
|
||||
pattern.slice(2),
|
||||
|
||||
// `./*.js` should not match with `subdir/foo.js`
|
||||
{ ...minimatchOpts, matchBase: false }
|
||||
);
|
||||
}
|
||||
return new Minimatch(pattern, minimatchOpts);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a given matcher to string.
|
||||
* @param {Pattern} matchers The matchers.
|
||||
* @returns {string} The string expression of the matcher.
|
||||
*/
|
||||
function patternToJson({ includes, excludes }) {
|
||||
return {
|
||||
includes: includes && includes.map(m => m.pattern),
|
||||
excludes: excludes && excludes.map(m => m.pattern)
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* The class to test given paths are matched by the patterns.
|
||||
*/
|
||||
class OverrideTester {
|
||||
|
||||
/**
|
||||
* Create a tester with given criteria.
|
||||
* If there are no criteria, returns `null`.
|
||||
* @param {string|string[]} files The glob patterns for included files.
|
||||
* @param {string|string[]} excludedFiles The glob patterns for excluded files.
|
||||
* @param {string} basePath The path to the base directory to test paths.
|
||||
* @returns {OverrideTester|null} The created instance or `null`.
|
||||
* @throws {Error} When invalid patterns are given.
|
||||
*/
|
||||
static create(files, excludedFiles, basePath) {
|
||||
const includePatterns = normalizePatterns(files);
|
||||
const excludePatterns = normalizePatterns(excludedFiles);
|
||||
let endsWithWildcard = false;
|
||||
|
||||
if (includePatterns.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Rejects absolute paths or relative paths to parents.
|
||||
for (const pattern of includePatterns) {
|
||||
if (path.isAbsolute(pattern) || pattern.includes("..")) {
|
||||
throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
|
||||
}
|
||||
if (pattern.endsWith("*")) {
|
||||
endsWithWildcard = true;
|
||||
}
|
||||
}
|
||||
for (const pattern of excludePatterns) {
|
||||
if (path.isAbsolute(pattern) || pattern.includes("..")) {
|
||||
throw new Error(`Invalid override pattern (expected relative path not containing '..'): ${pattern}`);
|
||||
}
|
||||
}
|
||||
|
||||
const includes = toMatcher(includePatterns);
|
||||
const excludes = toMatcher(excludePatterns);
|
||||
|
||||
return new OverrideTester(
|
||||
[{ includes, excludes }],
|
||||
basePath,
|
||||
endsWithWildcard
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Combine two testers by logical and.
|
||||
* If either of the testers was `null`, returns the other tester.
|
||||
* The `basePath` property of the two must be the same value.
|
||||
* @param {OverrideTester|null} a A tester.
|
||||
* @param {OverrideTester|null} b Another tester.
|
||||
* @returns {OverrideTester|null} Combined tester.
|
||||
*/
|
||||
static and(a, b) {
|
||||
if (!b) {
|
||||
return a && new OverrideTester(
|
||||
a.patterns,
|
||||
a.basePath,
|
||||
a.endsWithWildcard
|
||||
);
|
||||
}
|
||||
if (!a) {
|
||||
return new OverrideTester(
|
||||
b.patterns,
|
||||
b.basePath,
|
||||
b.endsWithWildcard
|
||||
);
|
||||
}
|
||||
|
||||
assert.strictEqual(a.basePath, b.basePath);
|
||||
return new OverrideTester(
|
||||
a.patterns.concat(b.patterns),
|
||||
a.basePath,
|
||||
a.endsWithWildcard || b.endsWithWildcard
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize this instance.
|
||||
* @param {Pattern[]} patterns The matchers.
|
||||
* @param {string} basePath The base path.
|
||||
* @param {boolean} endsWithWildcard If `true` then a pattern ends with `*`.
|
||||
*/
|
||||
constructor(patterns, basePath, endsWithWildcard = false) {
|
||||
|
||||
/** @type {Pattern[]} */
|
||||
this.patterns = patterns;
|
||||
|
||||
/** @type {string} */
|
||||
this.basePath = basePath;
|
||||
|
||||
/** @type {boolean} */
|
||||
this.endsWithWildcard = endsWithWildcard;
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if a given path is matched or not.
|
||||
* @param {string} filePath The absolute path to the target file.
|
||||
* @returns {boolean} `true` if the path was matched.
|
||||
* @throws {Error} When invalid `filePath` is given.
|
||||
*/
|
||||
test(filePath) {
|
||||
if (typeof filePath !== "string" || !path.isAbsolute(filePath)) {
|
||||
throw new Error(`'filePath' should be an absolute path, but got ${filePath}.`);
|
||||
}
|
||||
const relativePath = path.relative(this.basePath, filePath);
|
||||
|
||||
return this.patterns.every(({ includes, excludes }) => (
|
||||
(!includes || includes.some(m => m.match(relativePath))) &&
|
||||
(!excludes || !excludes.some(m => m.match(relativePath)))
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts this instance to a JSON compatible object.
|
||||
* @returns {Object} a JSON compatible object.
|
||||
*/
|
||||
toJSON() {
|
||||
if (this.patterns.length === 1) {
|
||||
return {
|
||||
...patternToJson(this.patterns[0]),
|
||||
basePath: this.basePath
|
||||
};
|
||||
}
|
||||
return {
|
||||
AND: this.patterns.map(patternToJson),
|
||||
basePath: this.basePath
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Custom inspect method for Node.js `console.log()`.
|
||||
* @returns {Object} an object to display by `console.log()`.
|
||||
*/
|
||||
[util.inspect.custom]() {
|
||||
return this.toJSON();
|
||||
}
|
||||
}
|
||||
|
||||
export { OverrideTester };
|
||||
@@ -0,0 +1,7 @@
|
||||
export {};
|
||||
|
||||
export {
|
||||
/**
|
||||
* @deprecated Import `act` from `react` instead.
|
||||
*/ act,
|
||||
} from "react";
|
||||
Reference in New Issue
Block a user