Socket
Socket
Sign inDemoInstall

rollup

Package Overview
Dependencies
1
Maintainers
5
Versions
797
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 3.20.2 to 3.21.2

4

dist/es/rollup.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -6,0 +6,0 @@ https://github.com/rollup/rollup

4

dist/loadConfigFile.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -6,0 +6,0 @@ https://github.com/rollup/rollup

2

dist/rollup.d.ts

@@ -257,3 +257,3 @@ export const VERSION: string;

}
) => boolean;
) => boolean | NullValue;

@@ -260,0 +260,0 @@ export type IsExternal = (

4

dist/rollup.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -6,0 +6,0 @@ https://github.com/rollup/rollup

4

dist/shared/fsevents-importer.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -6,0 +6,0 @@ https://github.com/rollup/rollup

4

dist/shared/loadConfigFile.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -6,0 +6,0 @@ https://github.com/rollup/rollup

546

dist/shared/watch-cli.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -19,4 +19,2 @@ https://github.com/rollup/rollup

const rollup = require('./rollup.js');
const require$$0 = require('assert');
const require$$0$1 = require('events');
const loadConfigFile_js = require('./loadConfigFile.js');

@@ -31,2 +29,3 @@ const node_child_process = require('node:child_process');

require('./fsevents-importer.js');
require('events');
require('node:path');

@@ -77,85 +76,43 @@ require('tty');

var signalExitExports = {};
var signalExit = {
get exports(){ return signalExitExports; },
set exports(v){ signalExitExports = v; },
};
var signalsExports = {};
var signals$1 = {
get exports(){ return signalsExports; },
set exports(v){ signalsExports = v; },
};
var hasRequiredSignals;
function requireSignals () {
if (hasRequiredSignals) return signalsExports;
hasRequiredSignals = 1;
(function (module) {
// This is not the set of all possible signals.
//
// It IS, however, the set of all signals that trigger
// an exit on either Linux or BSD systems. Linux is a
// superset of the signal names supported on BSD, and
// the unknown signals just fail to register, so we can
// catch that easily enough.
//
// Don't bother with SIGKILL. It's uncatchable, which
// means that we can't fire any callbacks anyway.
//
// If a user does happen to register a handler on a non-
// fatal signal like SIGWINCH or something, and then
// exit, it'll end up firing `process.emit('exit')`, so
// the handler will be fired anyway.
//
// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
// artificially, inherently leave the process in a
// state from which it is not safe to try and enter JS
// listeners.
module.exports = [
'SIGABRT',
'SIGALRM',
'SIGHUP',
'SIGINT',
'SIGTERM'
];
if (process.platform !== 'win32') {
module.exports.push(
'SIGVTALRM',
'SIGXCPU',
'SIGXFSZ',
'SIGUSR2',
'SIGTRAP',
'SIGSYS',
'SIGQUIT',
'SIGIOT'
// should detect profiler and enable/disable accordingly.
// see #21
// 'SIGPROF'
);
}
if (process.platform === 'linux') {
module.exports.push(
'SIGIO',
'SIGPOLL',
'SIGPWR',
'SIGSTKFLT',
'SIGUNUSED'
);
}
} (signals$1));
return signalsExports;
/**
* This is not the set of all possible signals.
*
* It IS, however, the set of all signals that trigger
* an exit on either Linux or BSD systems. Linux is a
* superset of the signal names supported on BSD, and
* the unknown signals just fail to register, so we can
* catch that easily enough.
*
* Windows signals are a different set, since there are
* signals that terminate Windows processes, but don't
* terminate (or don't even exist) on Posix systems.
*
* Don't bother with SIGKILL. It's uncatchable, which
* means that we can't fire any callbacks anyway.
*
* If a user does happen to register a handler on a non-
* fatal signal like SIGWINCH or something, and then
* exit, it'll end up firing `process.emit('exit')`, so
* the handler will be fired anyway.
*
* SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
* artificially, inherently leave the process in a
* state from which it is not safe to try and enter JS
* listeners.
*/
const signals = [];
signals.push('SIGHUP', 'SIGINT', 'SIGTERM');
if (process.platform !== 'win32') {
signals.push('SIGALRM', 'SIGABRT', 'SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT'
// should detect profiler and enable/disable accordingly.
// see #21
// 'SIGPROF'
);
}
if (process.platform === 'linux') {
signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT');
}
// Note: since nyc uses this module to output coverage, any lines
// that are in the direct sync flow of nyc's outputCoverage are
// ignored, since we can never get coverage for them.
// grab a reference to node's real process object right away
var process$1 = rollup.commonjsGlobal.process;
const processOk = function (process) {
return process &&
const processOk = (process) => !!process &&
typeof process === 'object' &&

@@ -168,189 +125,256 @@ typeof process.removeListener === 'function' &&

typeof process.pid === 'number' &&
typeof process.on === 'function'
};
// some kind of non-node environment, just no-op
/* istanbul ignore if */
if (!processOk(process$1)) {
signalExit.exports = function () {
return function () {}
};
} else {
var assert = require$$0;
var signals = requireSignals();
var isWin = /^win/i.test(process$1.platform);
var EE = require$$0$1;
/* istanbul ignore if */
if (typeof EE !== 'function') {
EE = EE.EventEmitter;
}
var emitter;
if (process$1.__signal_exit_emitter__) {
emitter = process$1.__signal_exit_emitter__;
} else {
emitter = process$1.__signal_exit_emitter__ = new EE();
emitter.count = 0;
emitter.emitted = {};
}
// Because this emitter is a global, we have to check to see if a
// previous version of this library failed to enable infinite listeners.
// I know what you're about to say. But literally everything about
// signal-exit is a compromise with evil. Get used to it.
if (!emitter.infinite) {
emitter.setMaxListeners(Infinity);
emitter.infinite = true;
}
signalExit.exports = function (cb, opts) {
/* istanbul ignore if */
if (!processOk(rollup.commonjsGlobal.process)) {
return function () {}
typeof process.on === 'function';
const kExitEmitter = Symbol.for('signal-exit emitter');
const global = globalThis;
const ObjectDefineProperty = Object.defineProperty.bind(Object);
// teeny tiny ee
class Emitter {
emitted = {
afterExit: false,
exit: false,
};
listeners = {
afterExit: [],
exit: [],
};
count = 0;
id = Math.random();
constructor() {
if (global[kExitEmitter]) {
console.error('reusing global emitter');
return global[kExitEmitter];
}
ObjectDefineProperty(global, kExitEmitter, {
value: this,
writable: false,
enumerable: false,
configurable: false,
});
}
assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
if (loaded === false) {
load();
on(ev, fn) {
this.listeners[ev].push(fn);
}
var ev = 'exit';
if (opts && opts.alwaysLast) {
ev = 'afterexit';
removeListener(ev, fn) {
const list = this.listeners[ev];
const i = list.indexOf(fn);
/* c8 ignore start */
if (i === -1) {
return;
}
/* c8 ignore stop */
if (i === 0 && list.length === 1) {
list.length = 0;
}
else {
list.splice(i, 1);
}
}
var remove = function () {
emitter.removeListener(ev, cb);
if (emitter.listeners('exit').length === 0 &&
emitter.listeners('afterexit').length === 0) {
unload();
}
emit(ev, code, signal) {
if (this.emitted[ev]) {
return;
}
this.emitted[ev] = true;
for (const fn of this.listeners[ev]) {
fn(code, signal);
}
}
}
class SignalExitBase {
}
const signalExitWrap = (handler) => {
return {
onExit(cb, opts) {
return handler.onExit(cb, opts);
},
load() {
return handler.load();
},
unload() {
return handler.unload();
},
};
emitter.on(ev, cb);
return remove
};
var unload = function unload () {
if (!loaded || !processOk(rollup.commonjsGlobal.process)) {
return
};
class SignalExitFallback extends SignalExitBase {
onExit() {
return () => { };
}
loaded = false;
signals.forEach(function (sig) {
try {
process$1.removeListener(sig, sigListeners[sig]);
} catch (er) {}
});
process$1.emit = originalProcessEmit;
process$1.reallyExit = originalProcessReallyExit;
emitter.count -= 1;
};
signalExitExports.unload = unload;
var emit = function emit (event, code, signal) {
/* istanbul ignore if */
if (emitter.emitted[event]) {
return
load() { }
unload() { }
}
class SignalExit extends SignalExitBase {
// "SIGHUP" throws an `ENOSYS` error on Windows,
// so use a supported signal instead
/* c8 ignore start */
#hupSig = process$1.platform === 'win32' ? 'SIGINT' : 'SIGHUP';
/* c8 ignore stop */
#emitter = new Emitter();
#process;
#originalProcessEmit;
#originalProcessReallyExit;
#sigListeners = {};
#loaded = false;
constructor(process) {
super();
this.#process = process;
// { <signal>: <listener fn>, ... }
this.#sigListeners = {};
for (const sig of signals) {
this.#sigListeners[sig] = () => {
// If there are no other listeners, an exit is coming!
// Simplest way: remove us and then re-send the signal.
// We know that this will kill the process, so we can
// safely emit now.
const listeners = this.#process.listeners(sig);
let { count } = this.#emitter;
// This is a workaround for the fact that signal-exit v3 and signal
// exit v4 are not aware of each other, and each will attempt to let
// the other handle it, so neither of them do. To correct this, we
// detect if we're the only handler *except* for previous versions
// of signal-exit.
/* c8 ignore start */
//@ts-ignore
if (typeof process.__signal_exit_emitter__ === 'object')
count++;
/* c8 ignore stop */
if (listeners.length === count) {
this.unload();
this.#emitter.emit('exit', null, sig);
this.#emitter.emit('afterExit', null, sig);
/* c8 ignore start */
process.kill(process.pid, sig === 'SIGHUP' ? this.#hupSig : sig);
/* c8 ignore stop */
}
};
}
this.#originalProcessReallyExit = process.reallyExit;
this.#originalProcessEmit = process.emit;
}
emitter.emitted[event] = true;
emitter.emit(event, code, signal);
};
// { <signal>: <listener fn>, ... }
var sigListeners = {};
signals.forEach(function (sig) {
sigListeners[sig] = function listener () {
/* istanbul ignore if */
if (!processOk(rollup.commonjsGlobal.process)) {
return
}
// If there are no other listeners, an exit is coming!
// Simplest way: remove us and then re-send the signal.
// We know that this will kill the process, so we can
// safely emit now.
var listeners = process$1.listeners(sig);
if (listeners.length === emitter.count) {
unload();
emit('exit', null, sig);
/* istanbul ignore next */
emit('afterexit', null, sig);
/* istanbul ignore next */
if (isWin && sig === 'SIGHUP') {
// "SIGHUP" throws an `ENOSYS` error on Windows,
// so use a supported signal instead
sig = 'SIGINT';
onExit(cb, opts) {
/* c8 ignore start */
if (!processOk(this.#process)) {
return () => { };
}
/* istanbul ignore next */
process$1.kill(process$1.pid, sig);
}
};
});
signalExitExports.signals = function () {
return signals
};
var loaded = false;
var load = function load () {
if (loaded || !processOk(rollup.commonjsGlobal.process)) {
return
/* c8 ignore stop */
if (this.#loaded === false) {
this.load();
}
const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
this.#emitter.on(ev, cb);
return () => {
this.#emitter.removeListener(ev, cb);
if (this.#emitter.listeners['exit'].length === 0 &&
this.#emitter.listeners['afterExit'].length === 0) {
this.unload();
}
};
}
loaded = true;
// This is the number of onSignalExit's that are in play.
// It's important so that we can count the correct number of
// listeners on signals, and don't wait for the other one to
// handle it instead of us.
emitter.count += 1;
signals = signals.filter(function (sig) {
try {
process$1.on(sig, sigListeners[sig]);
return true
} catch (er) {
return false
}
});
process$1.emit = processEmit;
process$1.reallyExit = processReallyExit;
};
signalExitExports.load = load;
var originalProcessReallyExit = process$1.reallyExit;
var processReallyExit = function processReallyExit (code) {
/* istanbul ignore if */
if (!processOk(rollup.commonjsGlobal.process)) {
return
load() {
if (this.#loaded) {
return;
}
this.#loaded = true;
// This is the number of onSignalExit's that are in play.
// It's important so that we can count the correct number of
// listeners on signals, and don't wait for the other one to
// handle it instead of us.
this.#emitter.count += 1;
for (const sig of signals) {
try {
const fn = this.#sigListeners[sig];
if (fn)
this.#process.on(sig, fn);
}
catch (_) { }
}
this.#process.emit = (ev, ...a) => {
return this.#processEmit(ev, ...a);
};
this.#process.reallyExit = (code) => {
return this.#processReallyExit(code);
};
}
process$1.exitCode = code || /* istanbul ignore next */ 0;
emit('exit', process$1.exitCode, null);
/* istanbul ignore next */
emit('afterexit', process$1.exitCode, null);
/* istanbul ignore next */
originalProcessReallyExit.call(process$1, process$1.exitCode);
};
var originalProcessEmit = process$1.emit;
var processEmit = function processEmit (ev, arg) {
if (ev === 'exit' && processOk(rollup.commonjsGlobal.process)) {
/* istanbul ignore else */
if (arg !== undefined) {
process$1.exitCode = arg;
}
var ret = originalProcessEmit.apply(this, arguments);
/* istanbul ignore next */
emit('exit', process$1.exitCode, null);
/* istanbul ignore next */
emit('afterexit', process$1.exitCode, null);
/* istanbul ignore next */
return ret
} else {
return originalProcessEmit.apply(this, arguments)
unload() {
if (!this.#loaded) {
return;
}
this.#loaded = false;
signals.forEach(sig => {
const listener = this.#sigListeners[sig];
/* c8 ignore start */
if (!listener) {
throw new Error('Listener not defined for signal: ' + sig);
}
/* c8 ignore stop */
try {
this.#process.removeListener(sig, listener);
/* c8 ignore start */
}
catch (_) { }
/* c8 ignore stop */
});
this.#process.emit = this.#originalProcessEmit;
this.#process.reallyExit = this.#originalProcessReallyExit;
this.#emitter.count -= 1;
}
};
#processReallyExit(code) {
/* c8 ignore start */
if (!processOk(this.#process)) {
return 0;
}
this.#process.exitCode = code || 0;
/* c8 ignore stop */
this.#emitter.emit('exit', this.#process.exitCode, null);
this.#emitter.emit('afterExit', this.#process.exitCode, null);
return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
}
#processEmit(ev, ...args) {
const og = this.#originalProcessEmit;
if (ev === 'exit' && processOk(this.#process)) {
if (typeof args[0] === 'number') {
this.#process.exitCode = args[0];
/* c8 ignore start */
}
/* c8 ignore start */
const ret = og.call(this.#process, ev, ...args);
/* c8 ignore start */
this.#emitter.emit('exit', this.#process.exitCode, null);
this.#emitter.emit('afterExit', this.#process.exitCode, null);
/* c8 ignore stop */
return ret;
}
else {
return og.call(this.#process, ev, ...args);
}
}
}
const process$1 = globalThis.process;
// wrap so that we call the method on the actual handler, without
// exporting it directly.
const {
/**
* Called when the process is exiting, whether via signal, explicit
* exit, or running out of stuff to do.
*
* If the global process object is not suitable for instrumentation,
* then this will be a no-op.
*
* Returns a function that may be used to unload signal-exit.
*/
onExit,
/**
* Load the listeners. Likely you never need to call this, unless
* doing a rather deep integration with signal-exit functionality.
* Mostly exposed for the benefit of testing.
*
* @internal
*/
load,
/**
* Unload the listeners. Likely you never need to call this, unless
* doing a rather deep integration with signal-exit functionality.
* Mostly exposed for the benefit of testing.
*
* @internal
*/
unload, } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());

@@ -413,3 +437,3 @@ const CLEAR_SCREEN = '\u001Bc';

const runWatchHook = createWatchHooks(command);
signalExitExports(close);
onExit(close);
process$2.on('uncaughtException', close);

@@ -416,0 +440,0 @@ if (!process$2.stdin.isTTY) {

4

dist/shared/watch-proxy.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -6,0 +6,0 @@ https://github.com/rollup/rollup

4

dist/shared/watch.js
/*
@license
Rollup.js v3.20.2
Fri, 24 Mar 2023 06:17:57 GMT - commit 1517d0360d66893d5cacdbaf7bc9d841c1c38069
Rollup.js v3.21.2
Sun, 30 Apr 2023 05:31:29 GMT - commit f138dcee19367f17f2e66f940fb8d612471f7ddf

@@ -6,0 +6,0 @@ https://github.com/rollup/rollup

2

LICENSE.md

@@ -614,3 +614,3 @@ # Rollup core license

>
> Copyright (c) 2015, Contributors
> Copyright (c) 2015-2023 Benjamin Coe, Isaac Z. Schlueter, and Contributors
>

@@ -617,0 +617,0 @@ > Permission to use, copy, modify, and/or distribute this software

73

package.json
{
"name": "rollup",
"version": "3.20.2",
"version": "3.21.2",
"description": "Next-generation ES module bundler",

@@ -66,27 +66,26 @@ "main": "dist/rollup.js",

"devDependencies": {
"@codemirror/commands": "^6.2.1",
"@codemirror/lang-javascript": "^6.1.4",
"@codemirror/commands": "^6.2.3",
"@codemirror/lang-javascript": "^6.1.7",
"@codemirror/language": "^6.6.0",
"@codemirror/search": "^6.2.3",
"@codemirror/search": "^6.4.0",
"@codemirror/state": "^6.2.0",
"@codemirror/view": "^6.9.2",
"@jridgewell/sourcemap-codec": "^1.4.14",
"@mermaid-js/mermaid-cli": "^10.0.2",
"@rollup/plugin-alias": "^4.0.3",
"@codemirror/view": "^6.10.0",
"@jridgewell/sourcemap-codec": "^1.4.15",
"@mermaid-js/mermaid-cli": "^10.1.0",
"@rollup/plugin-alias": "^5.0.0",
"@rollup/plugin-buble": "^1.0.2",
"@rollup/plugin-commonjs": "^24.0.1",
"@rollup/plugin-commonjs": "^24.1.0",
"@rollup/plugin-json": "^6.0.0",
"@rollup/plugin-node-resolve": "^15.0.1",
"@rollup/plugin-node-resolve": "^15.0.2",
"@rollup/plugin-replace": "^5.0.2",
"@rollup/plugin-terser": "^0.4.0",
"@rollup/plugin-typescript": "^11.0.0",
"@rollup/plugin-terser": "^0.4.1",
"@rollup/plugin-typescript": "^11.1.0",
"@rollup/pluginutils": "^5.0.2",
"@types/estree": "1.0.0",
"@types/node": "^14.18.36",
"@types/signal-exit": "^3.0.1",
"@types/estree": "1.0.1",
"@types/node": "^14.18.42",
"@types/yargs-parser": "^21.0.0",
"@typescript-eslint/eslint-plugin": "^5.54.1",
"@typescript-eslint/parser": "^5.54.1",
"@typescript-eslint/eslint-plugin": "^5.59.1",
"@typescript-eslint/parser": "^5.59.1",
"@vue/eslint-config-prettier": "^7.1.0",
"@vue/eslint-config-typescript": "^11.0.2",
"@vue/eslint-config-typescript": "^11.0.3",
"acorn": "^8.8.2",

@@ -99,23 +98,23 @@ "acorn-import-assertions": "^1.8.0",

"chokidar": "^3.5.3",
"colorette": "^2.0.19",
"concurrently": "^7.6.0",
"core-js": "^3.29.0",
"colorette": "^2.0.20",
"concurrently": "^8.0.1",
"core-js": "^3.30.1",
"date-time": "^4.0.0",
"es5-shim": "^4.6.7",
"es6-shim": "^0.35.7",
"eslint": "^8.35.0",
"eslint-config-prettier": "^8.7.0",
"es6-shim": "^0.35.8",
"eslint": "^8.39.0",
"eslint-config-prettier": "^8.8.0",
"eslint-plugin-import": "^2.27.5",
"eslint-plugin-prettier": "^4.2.1",
"eslint-plugin-unicorn": "^46.0.0",
"eslint-plugin-vue": "^9.9.0",
"eslint-plugin-vue": "^9.11.0",
"fixturify": "^3.0.0",
"flru": "^1.0.2",
"fs-extra": "^11.1.0",
"fs-extra": "^11.1.1",
"github-api": "^3.4.0",
"hash.js": "^1.1.7",
"husky": "^8.0.3",
"inquirer": "^9.1.4",
"inquirer": "^9.2.0",
"is-reference": "^3.0.1",
"lint-staged": "^13.1.2",
"lint-staged": "^13.2.1",
"locate-character": "^2.0.5",

@@ -125,21 +124,21 @@ "magic-string": "^0.30.0",

"nyc": "^15.1.0",
"pinia": "^2.0.33",
"prettier": "^2.8.4",
"pinia": "^2.0.35",
"prettier": "^2.8.8",
"pretty-bytes": "^6.1.0",
"pretty-ms": "^8.0.0",
"requirejs": "^2.3.6",
"rollup": "^3.18.0",
"rollup": "^3.21.0",
"rollup-plugin-license": "^3.0.1",
"rollup-plugin-string": "^3.0.0",
"rollup-plugin-thatworks": "^1.0.4",
"semver": "^7.3.8",
"semver": "^7.5.0",
"shx": "^0.3.4",
"signal-exit": "^3.0.7",
"signal-exit": "^4.0.1",
"source-map": "^0.7.4",
"source-map-support": "^0.5.21",
"systemjs": "^6.14.0",
"terser": "^5.16.5",
"systemjs": "^6.14.1",
"terser": "^5.17.1",
"tslib": "^2.5.0",
"typescript": "^4.9.5",
"vitepress": "^1.0.0-alpha.50",
"typescript": "^5.0.4",
"vitepress": "^1.0.0-alpha.74",
"vue": "^3.2.47",

@@ -146,0 +145,0 @@ "weak-napi": "^2.0.2",

dist/bin/rollup

Sorry, the diff of this file is not supported yet

dist/es/shared/node-entry.js

Sorry, the diff of this file is too big to display

dist/es/shared/watch.js

Sorry, the diff of this file is too big to display

dist/shared/index.js

Sorry, the diff of this file is too big to display

dist/shared/rollup.js

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc