npm - @snoirtrom/electron-vite - Versions diffs - 6.0.1 → 6.0.2 - Mend

@snoirtrom/electron-vite 6.0.1 → 6.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/bin/bytecode-compiler.cjs +15 -0
package/bin/electron-bytecode-main.cjs +107 -0
package/bin/electron-bytecode-preload.cjs +10 -0
package/bin/rpc-peer.cjs +89 -0
package/dist/chunks/{lib-B8n2vQeG.js → lib-DaHzt8UE.js} +4 -4
package/dist/chunks/{lib-CzmB3HUY.js → lib-DyA1RI3R.js} +3 -3
package/dist/chunks/{lib-FYrM-Sbc.js → lib-ShkGlprt.js} +4 -4
package/dist/chunks/{lib-CbKPgmtQ.js → lib-wmKiubLV.js} +451 -302
package/dist/cli.js +4 -4
package/dist/index.js +7 -7
package/package.json +19 -20

package/bin/bytecode-compiler.cjs ADDED Viewed

@@ -0,0 +1,15 @@
+const vm = require('node:vm')
+const v8 = require('node:v8')
+v8.setFlagsFromString('--no-lazy')
+v8.setFlagsFromString('--no-flush-bytecode')
+const params = ['exports', 'require', 'module', '__filename', '__dirname']
+module.exports = function compile(code) {
+  if (typeof code !== 'string') throw new TypeError('Compilation source must be a string')
+  const { cachedData } = vm.compileFunction(code, params, { produceCachedData: true })
+  if (!Buffer.isBuffer(cachedData)) throw new Error('V8 did not produce cached data')
+  // Explicit wire format works across both Node IPC and Electron structured clone.
+  return { sourceLength: code.length, cachedData: cachedData.toString('base64') }
+}

package/bin/electron-bytecode-main.cjs ADDED Viewed

@@ -0,0 +1,107 @@
+const { app, BrowserWindow, ipcMain } = require('electron')
+const path = require('node:path')
+const RpcPeer = require('./rpc-peer.cjs')
+const compile = require('./bytecode-compiler.cjs')
+if (process.platform === 'darwin') {
+  app.dock.hide()
+}
+const channel = 'electron-vite:bytecode:rpc'
+const readyChannel = 'electron-vite:bytecode:ready'
+let win
+let rendererRPC
+let stopping = false
+function fail(error) {
+  console.error(error)
+  parentRPC.close(error)
+  rendererRPC?.close(error)
+  app.exit(1)
+}
+const parentRPC = new RpcPeer(
+  message =>
+    new Promise((resolve, reject) => {
+      if (!process.connected || !process.send) return reject(new Error('Parent IPC is disconnected'))
+      process.send(message, error => (error ? reject(error) : resolve()))
+    })
+)
+function createRenderer() {
+  return new Promise((resolve, reject) => {
+    let ready = false
+    const timer = setTimeout(() => finish(new Error('Compiler preload readiness timed out')), 30000)
+    function finish(error) {
+      clearTimeout(timer)
+      ipcMain.removeListener(readyChannel, onReady)
+      if (error) reject(error)
+      else {
+        ready = true
+        resolve()
+      }
+    }
+    function onReady(event) {
+      if (event.sender === win.webContents) finish()
+    }
+    function onFailure(error) {
+      if (stopping) return
+      if (ready) fail(error)
+      else finish(error)
+    }
+    ipcMain.on(readyChannel, onReady)
+    win = new BrowserWindow({
+      show: false,
+      webPreferences: {
+        preload: path.join(__dirname, 'electron-bytecode-preload.cjs'),
+        sandbox: false,
+        contextIsolation: true
+      }
+    })
+    rendererRPC = new RpcPeer(message => {
+      if (win.isDestroyed()) throw new Error('Compiler window is closed')
+      win.webContents.send(channel, message)
+    })
+    ipcMain.on(channel, (event, message) => {
+      if (!win.isDestroyed() && event.sender === win.webContents) void rendererRPC.receive(message)
+    })
+    win.webContents.on('preload-error', (_event, _path, error) => onFailure(error))
+    win.webContents.on('render-process-gone', (_event, details) => {
+      onFailure(new Error(`Compiler renderer exited: ${details.reason}`))
+    })
+    win.on('closed', () => onFailure(new Error('Compiler window closed unexpectedly')))
+    win.loadURL('data:text/html,<!doctype html><html></html>').catch(onFailure)
+  })
+}
+// Register readiness immediately, but only resolve it after the selected backend is usable.
+const initialized = app.whenReady().then(async () => {
+  if (process.env.ELECTRON_VITE_RENDERER === '1' || process.env.ELECTRON_VITE_RENDERER === 'true') {
+    await createRenderer()
+    parentRPC.register('compile', (...args) => rendererRPC.request('compile', ...args))
+  } else {
+    parentRPC.register('compile', compile)
+  }
+  return true
+})
+parentRPC.register('ready', () => initialized)
+initialized.catch(fail)
+process.on('message', message => {
+  if (message?.type === 'shutdown') {
+    stopping = true
+    app.quit()
+  } else {
+    void parentRPC.receive(message)
+  }
+})
+process.on('disconnect', () => {
+  stopping = true
+  app.quit()
+})
+app.on('before-quit', () => {
+  stopping = true
+  parentRPC.close()
+  rendererRPC?.close()
+})
+if (!process.send) fail(new Error('Bytecode compiler must be launched with an IPC channel'))

package/bin/electron-bytecode-preload.cjs ADDED Viewed

@@ -0,0 +1,10 @@
+const { ipcRenderer } = require('electron')
+const RpcPeer = require('./rpc-peer.cjs')
+const compile = require('./bytecode-compiler.cjs')
+const channel = 'electron-vite:bytecode:rpc'
+const rpc = new RpcPeer(message => ipcRenderer.send(channel, message))
+rpc.register('ready', () => true)
+rpc.register('compile', compile)
+ipcRenderer.on(channel, (_event, message) => void rpc.receive(message))
+ipcRenderer.send('electron-vite:bytecode:ready')

package/bin/rpc-peer.cjs ADDED Viewed

@@ -0,0 +1,89 @@
+// Transport-independent peer. Messages must be JSON serializable.
+class RpcPeer {
+  constructor(send, timeout = 30000) {
+    this.send = send
+    this.timeout = timeout
+    this.methods = new Map()
+    this.pending = new Map()
+    this.nextId = 0
+    this.closed = false
+  }
+  register(cmd, method) {
+    this.methods.set(cmd, method)
+    return this
+  }
+  request(cmd, ...args) {
+    if (this.closed) return Promise.reject(new Error('RPC connection is closed'))
+    const invocationId = this.nextId++
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(invocationId)
+        reject(new Error(`RPC request timed out: ${cmd}`))
+      }, this.timeout)
+      this.pending.set(invocationId, { resolve, reject, timer })
+      Promise.resolve()
+        .then(() => this.send({ type: 'request', invocationId, cmd, args }))
+        .catch(error => {
+          const pending = this.pending.get(invocationId)
+          if (!pending) return
+          clearTimeout(timer)
+          this.pending.delete(invocationId)
+          reject(error)
+        })
+    })
+  }
+  async receive(message) {
+    if (this.closed || !message || !Number.isSafeInteger(message.invocationId)) return
+    const { type, invocationId } = message
+    if (type === 'response') {
+      const pending = this.pending.get(invocationId)
+      if (!pending) return
+      this.pending.delete(invocationId)
+      clearTimeout(pending.timer)
+      if (message.error) {
+        const error = new Error(message.error.message)
+        error.name = message.error.name || 'Error'
+        if (message.error.stack) error.stack = message.error.stack
+        pending.reject(error)
+      } else {
+        pending.resolve(message.result)
+      }
+      return
+    }
+    if (type !== 'request' || typeof message.cmd !== 'string' || !Array.isArray(message.args)) return
+    const response = { type: 'response', invocationId }
+    try {
+      const method = this.methods.get(message.cmd)
+      if (!method) throw new Error(`Invalid method: ${message.cmd}`)
+      response.result = await method(...message.args)
+    } catch (error) {
+      response.error = {
+        name: error instanceof Error ? error.name : 'Error',
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined
+      }
+    }
+    if (!this.closed) {
+      try {
+        await this.send(response)
+      } catch (error) {
+        this.close(error)
+      }
+    }
+  }
+  close(error = new Error('RPC connection is closed')) {
+    this.closed = true
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer)
+      pending.reject(error)
+    }
+    this.pending.clear()
+    this.methods.clear()
+  }
+}
+module.exports = RpcPeer

package/dist/chunks/{lib-B8n2vQeG.js → lib-DaHzt8UE.js} RENAMED Viewed

@@ -1,16 +1,16 @@
 import { build as build$1 } from 'vite';
-import { r as resolveConfig } from './lib-CbKPgmtQ.js';
+import { r as resolveConfig } from './lib-wmKiubLV.js';
 import 'node:path';
+import 'picocolors';
 import 'node:fs';
-import 'node:url';
 import 'node:module';
-import 'picocolors';
-import 'esbuild';
 import 'node:child_process';
 import 'node:crypto';
 import 'node:fs/promises';
 import 'magic-string';
 import '@babel/core';
+import 'node:url';
+import 'rolldown';
 /**
  * Bundles the electron app for production.

package/dist/chunks/{lib-CzmB3HUY.js → lib-DyA1RI3R.js} RENAMED Viewed

@@ -1,16 +1,16 @@
 import { createLogger, createServer as createServer$1, mergeConfig, build } from 'vite';
 import colors from 'picocolors';
-import { r as resolveConfig, c as resolveHostname, s as startElectron } from './lib-CbKPgmtQ.js';
+import { r as resolveConfig, c as resolveHostname, s as startElectron } from './lib-wmKiubLV.js';
 import 'node:path';
 import 'node:fs';
-import 'node:url';
 import 'node:module';
-import 'esbuild';
 import 'node:child_process';
 import 'node:crypto';
 import 'node:fs/promises';
 import 'magic-string';
 import '@babel/core';
+import 'node:url';
+import 'rolldown';
 async function createServer(inlineConfig = {}, options) {
     process.env.NODE_ENV_ELECTRON_VITE = 'development';

package/dist/chunks/{lib-FYrM-Sbc.js → lib-ShkGlprt.js} RENAMED Viewed

@@ -1,17 +1,17 @@
 import colors from 'picocolors';
 import { createLogger } from 'vite';
-import { s as startElectron } from './lib-CbKPgmtQ.js';
-import { build } from './lib-B8n2vQeG.js';
+import { s as startElectron } from './lib-wmKiubLV.js';
+import { build } from './lib-DaHzt8UE.js';
 import 'node:path';
 import 'node:fs';
-import 'node:url';
 import 'node:module';
-import 'esbuild';
 import 'node:child_process';
 import 'node:crypto';
 import 'node:fs/promises';
 import 'magic-string';
 import '@babel/core';
+import 'node:url';
+import 'rolldown';
 async function preview(inlineConfig = {}, options) {
     if (!options.skipBuild) {

package/dist/chunks/{lib-CbKPgmtQ.js → lib-wmKiubLV.js} RENAMED Viewed

@@ -1,15 +1,15 @@
 import path from 'node:path';
-import fs from 'node:fs';
-import { pathToFileURL } from 'node:url';
-import { createRequire, builtinModules } from 'node:module';
 import colors from 'picocolors';
 import { loadEnv as loadEnv$1, mergeConfig, normalizePath, version, build, createLogger } from 'vite';
-import { build as build$1 } from 'esbuild';
+import fs from 'node:fs';
+import { createRequire, builtinModules } from 'node:module';
 import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import fs$1 from 'node:fs/promises';
 import MagicString from 'magic-string';
 import * as babel from '@babel/core';
+import { pathToFileURL } from 'node:url';
+import { rolldown } from 'rolldown';
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-function-type */
 function isObject(value) {
@@ -69,27 +69,54 @@ function isFilePathESM(filePath) {
         return pkg?.type === 'module';
     }
 }
-function deepClone(value) {
-    if (Array.isArray(value)) {
-        return value.map(v => deepClone(v));
-    }
-    if (isObject(value)) {
-        const cloned = {};
-        for (const key in value) {
-            cloned[key] = deepClone(value[key]);
+/**
+ * Isolate configuration data without cloning plugins or runtime instances.
+ * Plugins may capture their own object in hooks, so their identity must survive.
+ */
+function cloneConfig(config) {
+    const seen = new WeakMap();
+    const pluginArrays = new WeakMap();
+    function clone(value, plugins = false) {
+        if (value === null || typeof value !== 'object')
+            return value;
+        const cache = plugins ? pluginArrays : seen;
+        if (cache.has(value))
+            return cache.get(value);
+        if (Array.isArray(value)) {
+            const result = new Array(value.length);
+            cache.set(value, result);
+            value.forEach((item, index) => {
+                result[index] = clone(item, plugins);
+            });
+            return result;
         }
-        return cloned;
-    }
-    if (typeof value === 'function') {
-        return value;
-    }
-    if (value instanceof RegExp) {
-        return new RegExp(value);
-    }
-    if (typeof value === 'object' && value != null) {
-        throw new Error('Cannot deep clone non-plain object');
+        // Preserve plugin objects, promises and other opaque plugin options.
+        if (plugins)
+            return value;
+        if (value instanceof RegExp) {
+            const result = new RegExp(value);
+            result.lastIndex = value.lastIndex;
+            cache.set(value, result);
+            return result;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            return value;
+        const result = Object.create(prototype);
+        cache.set(value, result);
+        for (const key of Reflect.ownKeys(value)) {
+            if (!Object.prototype.propertyIsEnumerable.call(value, key))
+                continue;
+            Object.defineProperty(result, key, {
+                value: clone(value[key], key === 'plugins'),
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
+        return result;
     }
-    return value;
+    return clone(config);
 }
 async function asyncFlatten(arr) {
     do {
@@ -160,6 +187,7 @@ function getElectronPath() {
 function getElectronNodeTarget() {
     const electronVer = getElectronMajorVer();
     const nodeVer = {
+        '45': '24.21',
         '44': '24.20',
         '41': '24.14',
         '40': '24.14',
@@ -193,6 +221,7 @@ function getElectronNodeTarget() {
 function getElectronChromeTarget() {
     const electronVer = getElectronMajorVer();
     const chromeVer = {
+        '45': '156',
         '44': '152',
         '41': '146',
         '40': '144',
@@ -1165,124 +1194,223 @@ function externalizeDepsPlugin(options = {}) {
     };
 }
-// Inspired by https://github.com/bytenode/bytenode
-const _require$1 = createRequire(import.meta.url);
-function getBytecodeCompilerPath() {
-    return path.join(path.dirname(_require$1.resolve('electron-vite/package.json')), 'bin', 'electron-bytecode.cjs');
-}
-function compileToBytecode(code) {
-    return new Promise((resolve, reject) => {
-        let data = Buffer.from([]);
-        const electronPath = getElectronPath();
-        const bytecodePath = getBytecodeCompilerPath();
-        const proc = spawn(electronPath, [bytecodePath], {
-            env: { ELECTRON_RUN_AS_NODE: '1' },
-            stdio: ['pipe', 'pipe', 'pipe', 'ipc']
+class ElectronCompiler {
+    options;
+    ps;
+    rpcMap = new Map();
+    invocationId = 0;
+    starting;
+    stopping;
+    ready = false;
+    constructor(options) {
+        this.options = options;
+        for (const timeout of [options.timeout, options.shutdownTimeout]) {
+            if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0)) {
+                throw new RangeError('ElectronCompiler timeouts must be positive finite numbers');
+            }
+        }
+    }
+    start() {
+        if (this.stopping)
+            return Promise.reject(new Error('ElectronCompiler is stopping'));
+        if (this.starting)
+            return this.starting;
+        if (this.ready)
+            return Promise.resolve();
+        if (this.ps)
+            return Promise.reject(new Error('Previous Electron process has not closed; await stop() first'));
+        this.starting = this.initialize().finally(() => {
+            this.starting = undefined;
+        });
+        return this.starting;
+    }
+    async initialize() {
+        const env = { ...process.env, ...this.options.env, ELECTRON_VITE_RPC: 'true' };
+        delete env.ELECTRON_RUN_AS_NODE;
+        const ps = spawn(this.options.path, this.options.args, {
+            stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+            windowsHide: true,
+            env
         });
-        if (proc.stdin) {
-            proc.stdin.write(code);
-            proc.stdin.end();
+        this.ps = ps;
+        ps.on('message', (message) => {
+            if (this.ps !== ps || !message || message.type !== 'response')
+                return;
+            const pending = this.rpcMap.get(message.invocationId);
+            if (!pending)
+                return;
+            clearTimeout(pending.timer);
+            this.rpcMap.delete(message.invocationId);
+            if (message.error) {
+                const error = new Error(message.error.message);
+                error.name = message.error.name;
+                if (message.error.stack)
+                    error.stack = message.error.stack;
+                pending.reject(error);
+            }
+            else
+                pending.resolve(message.result);
+        });
+        ps.on('error', error => {
+            if (this.ps === ps)
+                this.rejectPending(error);
+        });
+        ps.on('disconnect', () => {
+            if (this.ps === ps)
+                this.rejectPending(new Error('Electron IPC disconnected'));
+        });
+        ps.on('exit', (code, signal) => {
+            if (this.ps === ps)
+                this.rejectPending(new Error('Electron exited (code ' + code + ', signal ' + signal + ')'));
+        });
+        ps.on('close', () => {
+            if (this.ps === ps) {
+                this.rejectPending(new Error('Electron process closed'));
+                this.ps = undefined;
+            }
+        });
+        try {
+            await this.sendRequest('ready', []);
+            if (!ps.connected || this.stopping)
+                throw new Error('Electron stopped during initialization');
+            this.ready = true;
         }
-        if (proc.stdout) {
-            proc.stdout.on('data', chunk => {
-                data = Buffer.concat([data, chunk]);
-            });
-            proc.stdout.on('error', err => {
-                console.error(err);
-            });
-            proc.stdout.on('end', () => {
-                resolve(data);
-            });
+        catch (error) {
+            await this.stop();
+            throw error;
         }
-        if (proc.stderr) {
-            proc.stderr.on('data', chunk => {
-                console.error('Error: ', chunk.toString());
-            });
-            proc.stderr.on('error', err => {
-                console.error('Error: ', err);
-            });
+    }
+    compile(code) {
+        return this.request('compile', code);
+    }
+    async request(cmd, ...args) {
+        if (!this.ready || this.stopping)
+            throw new Error('ElectronCompiler is not ready; await start() first');
+        return this.sendRequest(cmd, args);
+    }
+    sendRequest(cmd, args) {
+        const ps = this.ps;
+        if (!ps?.connected)
+            return Promise.reject(new Error('Electron IPC is not connected'));
+        const invocationId = this.invocationId++;
+        return new Promise((resolve, reject) => {
+            const fail = (error) => {
+                const pending = this.rpcMap.get(invocationId);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                this.rpcMap.delete(invocationId);
+                reject(error);
+            };
+            const timer = setTimeout(() => fail(new Error('Electron RPC timed out: ' + cmd)), this.options.timeout ?? 30000);
+            this.rpcMap.set(invocationId, { resolve, reject, timer });
+            try {
+                ps.send({ type: 'request', invocationId, cmd, args }, error => {
+                    if (error)
+                        fail(error);
+                });
+            }
+            catch (error) {
+                fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    rejectPending(error) {
+        this.ready = false;
+        for (const pending of this.rpcMap.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
         }
-        proc.addListener('message', message => console.log(message));
-        proc.addListener('error', err => console.error(err));
-        proc.on('error', err => reject(err));
-        proc.on('exit', () => {
-            resolve(data);
+        this.rpcMap.clear();
+    }
+    stop() {
+        if (this.stopping)
+            return this.stopping;
+        this.rejectPending(new Error('ElectronCompiler stopped'));
+        const ps = this.ps;
+        if (!ps)
+            return Promise.resolve();
+        this.stopping = new Promise(resolve => {
+            const timer = setTimeout(() => ps.kill('SIGKILL'), this.options.shutdownTimeout ?? 3000);
+            ps.once('close', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            if (ps.connected) {
+                try {
+                    ps.send({ type: 'shutdown' }, error => {
+                        if (error)
+                            ps.kill();
+                    });
+                }
+                catch {
+                    ps.kill();
+                }
+            }
+            else
+                ps.kill();
+        }).finally(() => {
+            this.stopping = undefined;
         });
-    });
+        return this.stopping;
+    }
+}
+// Inspired by https://github.com/bytenode/bytenode
+const _require$1 = createRequire(import.meta.url);
+function getBytecodeCompilerPath() {
+    return path.join(path.dirname(_require$1.resolve('electron-vite/package.json')), 'bin', 'electron-bytecode-main.cjs');
+}
+// Versioned envelope: magic/version (8), UTF-16 source length (4), module ID (16), V8 cache.
+// Keep our metadata separate from the private V8 cache header.
+async function compileToBytecode(compiler, code) {
+    const id = randomBytes(16);
+    // Reserve enough source space for an untruncated, per-artifact placeholder identity.
+    const source = code + '\n/*' + id.toString('hex') + '*/';
+    const result = await compiler.compile(source);
+    const header = Buffer.alloc(28);
+    header.write('EVBC0001', 0, 'ascii');
+    header.writeUInt32LE(result.sourceLength, 8);
+    id.copy(header, 12);
+    return Buffer.concat([header, Buffer.from(result.cachedData, 'base64')]);
 }
 const bytecodeModuleLoaderCode = [
-    `"use strict";`,
-    `const fs = require("fs");`,
-    `const path = require("path");`,
-    `const vm = require("vm");`,
-    `const v8 = require("v8");`,
-    `const Module = require("module");`,
-    `v8.setFlagsFromString("--no-lazy");`,
-    `v8.setFlagsFromString("--no-flush-bytecode");`,
-    `const FLAG_HASH_OFFSET = 12;`,
-    `const SOURCE_HASH_OFFSET = 8;`,
-    `let dummyBytecode;`,
-    `function setFlagHashHeader(bytecodeBuffer) {`,
-    `  if (!dummyBytecode) {`,
-    `    const script = new vm.Script("", {`,
-    `      produceCachedData: true`,
-    `    });`,
-    `    dummyBytecode = script.createCachedData();`,
-    `  }`,
-    `  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);`,
-    `};`,
-    `function getSourceHashHeader(bytecodeBuffer) {`,
-    `  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);`,
-    `};`,
-    `function buffer2Number(buffer) {`,
-    `  let ret = 0;`,
-    `  ret |= buffer[3] << 24;`,
-    `  ret |= buffer[2] << 16;`,
-    `  ret |= buffer[1] << 8;`,
-    `  ret |= buffer[0];`,
-    `  return ret;`,
-    `};`,
-    `Module._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {`,
-    `  const bytecodeBuffer = fs.readFileSync(filename);`,
-    `  if (!Buffer.isBuffer(bytecodeBuffer)) {`,
-    `    throw new Error("BytecodeBuffer must be a buffer object.");`,
-    `  }`,
-    `  setFlagHashHeader(bytecodeBuffer);`,
-    `  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));`,
-    `  let dummyCode = "";`,
-    `  if (length > 1) {`,
-    `    dummyCode = "\\"" + "\\u200b".repeat(length - 2) + "\\"";`,
-    `  }`,
-    `  const script = new vm.Script(dummyCode, {`,
-    `    filename: filename,`,
-    `    lineOffset: 0,`,
-    `    displayErrors: true,`,
-    `    cachedData: bytecodeBuffer`,
-    `  });`,
-    `  if (script.cachedDataRejected) {`,
-    `    throw new Error("Invalid or incompatible cached data (cachedDataRejected)");`,
-    `  }`,
-    `  const require = function (id) {`,
-    `    return module.require(id);`,
-    `  };`,
-    `  require.resolve = function (request, options) {`,
-    `    return Module._resolveFilename(request, module, false, options);`,
-    `  };`,
-    `  if (process.mainModule) {`,
-    `    require.main = process.mainModule;`,
-    `  }`,
-    `  require.extensions = Module._extensions;`,
-    `  require.cache = Module._cache;`,
-    `  const compiledWrapper = script.runInThisContext({`,
-    `    filename: filename,`,
-    `    lineOffset: 0,`,
-    `    columnOffset: 0,`,
-    `    displayErrors: true`,
-    `  });`,
-    `  const dirname = path.dirname(filename);`,
-    `  const args = [module.exports, require, module, filename, dirname, process, global];`,
-    `  return compiledWrapper.apply(module.exports, args);`,
-    `};`
+    '"use strict";',
+    'const fs = require("node:fs");',
+    'const path = require("node:path");',
+    'const vm = require("node:vm");',
+    'const v8 = require("node:v8");',
+    'const Module = require("node:module");',
+    'v8.setFlagsFromString("--no-lazy");',
+    'v8.setFlagsFromString("--no-flush-bytecode");',
+    'const params = ["exports", "require", "module", "__filename", "__dirname"];',
+    'Module._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {',
+    '  const data = fs.readFileSync(filename);',
+    '  if (data.length <= 28 || data.toString("ascii", 0, 8) !== "EVBC0001") {',
+    '    throw new Error("Invalid electron-vite bytecode format; rebuild the application: " + filename);',
+    '  }',
+    '  const length = data.readUInt32LE(8);',
+    '  const tag = "/*" + data.subarray(12, 28).toString("hex") + "*/";',
+    '  if (length < tag.length || length > 0x1fffffff) {',
+    '    throw new Error("Invalid bytecode source length: " + filename);',
+    '  }',
+    '  const placeholder = tag + " ".repeat(length - tag.length);',
+    '  const compiledWrapper = vm.compileFunction(placeholder, params, {',
+    '    filename,',
+    '    cachedData: data.subarray(28)',
+    '  });',
+    '  if (compiledWrapper.cachedDataRejected) {',
+    '    throw new Error("Invalid or incompatible cached data (cachedDataRejected): " + filename);',
+    '  }',
+    '  const require = function (id) { return module.require(id); };',
+    '  require.resolve = function (request, options) {',
+    '    return Module._resolveFilename(request, module, false, options);',
+    '  };',
+    '  if (process.mainModule) require.main = process.mainModule;',
+    '  require.extensions = Module._extensions;',
+    '  require.cache = Module._cache;',
+    '  return compiledWrapper.call(module.exports, module.exports, require, module, filename, path.dirname(filename));',
+    '};'
 ];
 const bytecodeChunkExtensionRE = /.(jsc|cjsc)$/;
 /**
@@ -1309,12 +1437,13 @@ function bytecodePlugin(options = {}) {
     }
     const shouldTransformBytecodeChunk = plugins.length !== 0;
     const _transform = (code, sourceMaps = false) => {
-        const re = babel.transform(code, { plugins, sourceMaps });
+        const re = babel.transformSync(code, { plugins, sourceMaps });
         return re ? { code: re.code || '', map: re.map } : null;
     };
     const useStrict = '"use strict";';
     const bytecodeModuleLoader = 'bytecode-loader.cjs';
     let supported = false;
+    let isPreload = false;
     return {
         name: 'vite:bytecode',
         apply: 'build',
@@ -1323,7 +1452,8 @@ function bytecodePlugin(options = {}) {
             if (supported) {
                 return;
             }
-            const useInRenderer = config.plugins.some(p => p.name === 'vite:electron-renderer-preset-config');
+            isPreload = config.plugins.some(p => p.name === 'vite:electron-preload-config-preset');
+            const useInRenderer = config.plugins.some(p => p.name === 'vite:electron-renderer-config-preset');
             if (useInRenderer) {
                 config.logger.warn(colors.yellow('bytecodePlugin does not support renderer.'));
                 return;
@@ -1364,76 +1494,91 @@ function bytecodePlugin(options = {}) {
             };
             let bytecodeChunkCount = 0;
             const bundles = Object.keys(output);
-            await Promise.all(bundles.map(async (name) => {
-                const chunk = output[name];
-                if (chunk.type === 'chunk') {
-                    let _code = chunk.code;
-                    if (bytecodeRE) {
-                        let match;
-                        let s;
-                        while ((match = bytecodeRE.exec(_code))) {
-                            s ||= new MagicString(_code);
-                            const [prefix, chunkName] = match;
-                            const len = prefix.length + chunkName.length;
-                            s.overwrite(match.index, match.index + len, prefix + chunkName + 'c', {
-                                contentOnly: true
-                            });
-                        }
-                        if (s) {
-                            _code = s.toString();
+            const compiler = new ElectronCompiler({
+                path: getElectronPath(),
+                args: [getBytecodeCompilerPath()],
+                env: { ELECTRON_VITE_RENDERER: isPreload ? '1' : '0' }
+            });
+            try {
+                await compiler.start();
+                for (const name of bundles) {
+                    const chunk = output[name];
+                    if (chunk.type === 'chunk') {
+                        let _code = chunk.code;
+                        if (bytecodeRE) {
+                            let match;
+                            let s;
+                            while ((match = bytecodeRE.exec(_code))) {
+                                s ||= new MagicString(_code);
+                                const [prefix, chunkName] = match;
+                                const len = prefix.length + chunkName.length;
+                                s.overwrite(match.index, match.index + len, prefix + chunkName + 'c', {
+                                    contentOnly: true
+                                });
+                            }
+                            if (s) {
+                                _code = s.toString();
+                            }
                         }
-                    }
-                    if (bytecodeChunks.includes(name)) {
-                        const bytecodeBuffer = await compileToBytecode(_code);
-                        this.emitFile({
-                            type: 'asset',
-                            fileName: name + 'c',
-                            source: bytecodeBuffer
-                        });
-                        if (!removeBundleJS) {
+                        if (bytecodeChunks.includes(name)) {
+                            const bytecodeBuffer = await compileToBytecode(compiler, _code);
                             this.emitFile({
                                 type: 'asset',
-                                fileName: '_' + chunk.fileName,
-                                source: chunk.code
+                                fileName: name + 'c',
+                                source: bytecodeBuffer
                             });
-                        }
-                        if (chunk.isEntry) {
-                            const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
-                            const bytecodeModuleBlock = `require("./${path.basename(name) + 'c'}");`;
-                            const code = `${useStrict}\n${bytecodeLoaderBlock}\n${bytecodeModuleBlock}\n`;
-                            chunk.code = code;
+                            if (!removeBundleJS) {
+                                this.emitFile({
+                                    type: 'asset',
+                                    fileName: '_' + chunk.fileName,
+                                    source: chunk.code
+                                });
+                            }
+                            if (chunk.isEntry) {
+                                const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
+                                const bytecodeModuleBlock = `require("./${path.basename(name) + 'c'}");`;
+                                const code = `${useStrict}\n${bytecodeLoaderBlock}\n${bytecodeModuleBlock}\n`;
+                                chunk.code = code;
+                            }
+                            else {
+                                delete output[chunk.fileName];
+                            }
+                            bytecodeChunkCount += 1;
                         }
                         else {
-                            delete output[chunk.fileName];
-                        }
-                        bytecodeChunkCount += 1;
-                    }
-                    else {
-                        if (chunk.isEntry) {
-                            let hasBytecodeMoudle = false;
-                            const idsToHandle = new Set([...chunk.imports, ...chunk.dynamicImports]);
-                            for (const moduleId of idsToHandle) {
-                                if (bytecodeChunks.includes(moduleId)) {
-                                    hasBytecodeMoudle = true;
-                                    break;
+                            if (chunk.isEntry) {
+                                let hasBytecodeMoudle = false;
+                                const idsToHandle = new Set([...chunk.imports, ...chunk.dynamicImports]);
+                                for (const moduleId of idsToHandle) {
+                                    if (bytecodeChunks.includes(moduleId)) {
+                                        hasBytecodeMoudle = true;
+                                        break;
+                                    }
+                                    const moduleInfo = this.getModuleInfo(moduleId);
+                                    if (moduleInfo) {
+                                        const { importers, dynamicImporters } = moduleInfo;
+                                        for (const importerId of importers)
+                                            idsToHandle.add(importerId);
+                                        for (const importerId of dynamicImporters)
+                                            idsToHandle.add(importerId);
+                                    }
                                 }
-                                const moduleInfo = this.getModuleInfo(moduleId);
-                                if (moduleInfo) {
-                                    const { importers, dynamicImporters } = moduleInfo;
-                                    for (const importerId of importers)
-                                        idsToHandle.add(importerId);
-                                    for (const importerId of dynamicImporters)
-                                        idsToHandle.add(importerId);
+                                if (hasBytecodeMoudle) {
+                                    const loader = getBytecodeLoaderBlock(chunk.fileName);
+                                    const strictRE = /^(#![^\n]*\n)?(["'])use strict\2;/;
+                                    _code = strictRE.test(_code)
+                                        ? _code.replace(strictRE, `$&\n${loader}`)
+                                        : _code.replace(/^(#![^\n]*\n)?/, `$&${loader}\n`);
                                 }
                             }
-                            _code = hasBytecodeMoudle
-                                ? _code.replace(/("use strict";)|('use strict';)/, `${useStrict}\n${getBytecodeLoaderBlock(chunk.fileName)}`)
-                                : _code;
+                            chunk.code = _code;
                         }
-                        chunk.code = _code;
                     }
                 }
-            }));
+            }
+            finally {
+                await compiler.stop();
+            }
             if (bytecodeChunkCount && !_chunks.some(ass => ass.type === 'asset' && ass.fileName === bytecodeModuleLoader)) {
                 this.emitFile({
                     type: 'asset',
@@ -1518,6 +1663,114 @@ function protectStringsPlugin(api) {
     };
 }
+const CONFIG_FILE_NAME = 'electron.vite.config';
+function findConfigFile(configRoot, extensions = ['js', 'ts', 'mjs', 'cjs', 'mts', 'cts']) {
+    for (const ext of extensions) {
+        const configFile = path.resolve(configRoot, `${CONFIG_FILE_NAME}.${ext}`);
+        if (fs.existsSync(configFile)) {
+            return configFile;
+        }
+    }
+    return '';
+}
+async function bundleConfigFile(fileName, isESM) {
+    const dirnameVarName = '__electron_vite_injected_dirname';
+    const filenameVarName = '__electron_vite_injected_filename';
+    const importMetaUrlVarName = '__electron_vite_injected_import_meta_url';
+    const bundle = await rolldown({
+        input: path.resolve(fileName),
+        platform: 'node',
+        transform: {
+            target: 'node20',
+            define: {
+                __dirname: dirnameVarName,
+                __filename: filenameVarName,
+                'import.meta.url': importMetaUrlVarName
+            }
+        },
+        plugins: [
+            {
+                name: 'externalize-deps',
+                resolveId(id) {
+                    if (id[0] !== '.' && !path.isAbsolute(id)) {
+                        return { id, external: true };
+                    }
+                    return null;
+                }
+            },
+            {
+                name: 'inject-file-scope-variables',
+                transform: {
+                    filter: { id: /\.[cm]?[jt]s$/ },
+                    handler(code, id) {
+                        const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};` +
+                            `const ${filenameVarName} = ${JSON.stringify(id)};` +
+                            `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};`;
+                        return { code: injectValues + code, map: null };
+                    }
+                }
+            }
+        ]
+    });
+    let result;
+    try {
+        result = await bundle.generate({
+            format: isESM ? 'esm' : 'cjs',
+            sourcemap: 'inline',
+            sourcemapPathTransform(relative, sourcemapPath) {
+                return path.resolve(path.dirname(sourcemapPath), relative);
+            },
+            codeSplitting: false
+        });
+    }
+    finally {
+        await bundle.close();
+    }
+    const entryChunk = result.output.find((chunk) => chunk.type === 'chunk' && chunk.isEntry);
+    if (!entryChunk) {
+        throw new Error(`Failed to bundle config file: ${fileName}`);
+    }
+    return {
+        code: entryChunk.code,
+        dependencies: entryChunk.moduleIds.filter(id => !id.startsWith('\0'))
+    };
+}
+const _require = createRequire(import.meta.url);
+async function loadConfigFormBundledFile(fileName, bundledCode, isESM) {
+    if (isESM) {
+        const fileNameTmp = `${fileName}.${Date.now()}-${Math.random().toString(16).slice(2)}.mjs`;
+        fs.writeFileSync(fileNameTmp, bundledCode);
+        const fileUrl = pathToFileURL(fileNameTmp);
+        try {
+            return (await import(fileUrl.href)).default;
+        }
+        finally {
+            try {
+                fs.unlinkSync(fileNameTmp);
+            }
+            catch { }
+        }
+    }
+    else {
+        const extension = path.extname(fileName);
+        const realFileName = fs.realpathSync(fileName);
+        const loaderExt = extension in _require.extensions ? extension : '.js';
+        const defaultLoader = _require.extensions[loaderExt];
+        _require.extensions[loaderExt] = (module, filename) => {
+            if (filename === realFileName) {
+                module._compile(bundledCode, filename);
+            }
+            else {
+                defaultLoader(module, filename);
+            }
+        };
+        delete _require.cache[_require.resolve(fileName)];
+        const raw = _require(fileName);
+        _require.extensions[loaderExt] = defaultLoader;
+        return raw.__esModule ? raw.default : raw;
+    }
+}
 function defineConfig(config) {
     return config;
 }
@@ -1574,7 +1827,7 @@ class ConfigFactory {
     }
     async build(cleanMode) {
         /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
-        const config = mergeConfig(deepClone(this.baseConfig), deepClone(this.inlineConfig));
+        const config = mergeConfig(cloneConfig(this.baseConfig), cloneConfig(this.inlineConfig));
         config.mode = this.inlineConfig.mode || config.mode || process.env.NODE_ENV;
         if (this.options.outDir) {
             resetOutDir(config, this.options.outDir, this.processType());
@@ -1687,14 +1940,11 @@ async function resolveConfigDrivenPlugins(config) {
 function isOptions(value) {
     return typeof value === 'object' && value !== null;
 }
-const CONFIG_FILE_NAME = 'electron.vite.config';
 async function loadConfigFromFile(configEnv, configFile, configRoot = process.cwd(), logLevel, ignoreConfigWarning = false) {
     if (configFile && /^vite.config.(js|ts|mjs|cjs|mts|cts)$/.test(configFile)) {
         throw new Error(`config file cannot be named ${configFile}.`);
     }
-    const resolvedPath = configFile
-        ? path.resolve(configFile)
-        : findConfigFile(configRoot, ['js', 'ts', 'mjs', 'cjs', 'mts', 'cts']);
+    const resolvedPath = configFile ? path.resolve(configFile) : findConfigFile(configRoot);
     if (!resolvedPath) {
         return {
             path: '',
@@ -1705,7 +1955,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
     const isESM = isFilePathESM(resolvedPath);
     try {
         const { code, dependencies } = await bundleConfigFile(resolvedPath, isESM);
-        const configExport = await loadConfigFormBundledFile(configRoot, resolvedPath, code, isESM);
+        const configExport = await loadConfigFormBundledFile(resolvedPath, code, isESM);
         const config = await (typeof configExport === 'function' ? configExport(configEnv) : configExport);
         if (!isObject(config)) {
             throw new Error(`config must export or return an object`);
@@ -1727,106 +1977,5 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         throw e;
     }
 }
-function findConfigFile(configRoot, extensions) {
-    for (const ext of extensions) {
-        const configFile = path.resolve(configRoot, `${CONFIG_FILE_NAME}.${ext}`);
-        if (fs.existsSync(configFile)) {
-            return configFile;
-        }
-    }
-    return '';
-}
-async function bundleConfigFile(fileName, isESM) {
-    const dirnameVarName = '__electron_vite_injected_dirname';
-    const filenameVarName = '__electron_vite_injected_filename';
-    const importMetaUrlVarName = '__electron_vite_injected_import_meta_url';
-    const result = await build$1({
-        absWorkingDir: process.cwd(),
-        entryPoints: [fileName],
-        write: false,
-        target: ['node20'],
-        platform: 'node',
-        bundle: true,
-        format: isESM ? 'esm' : 'cjs',
-        sourcemap: false,
-        metafile: true,
-        define: {
-            __dirname: dirnameVarName,
-            __filename: filenameVarName,
-            'import.meta.url': importMetaUrlVarName
-        },
-        plugins: [
-            {
-                name: 'externalize-deps',
-                setup(build) {
-                    build.onResolve({ filter: /.*/ }, args => {
-                        const id = args.path;
-                        if (id[0] !== '.' && !path.isAbsolute(id)) {
-                            return {
-                                external: true
-                            };
-                        }
-                        return null;
-                    });
-                }
-            },
-            {
-                name: 'replace-import-meta',
-                setup(build) {
-                    build.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
-                        const contents = await fs.promises.readFile(args.path, 'utf8');
-                        const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path.dirname(args.path))};` +
-                            `const ${filenameVarName} = ${JSON.stringify(args.path)};` +
-                            `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(args.path).href)};`;
-                        return {
-                            loader: args.path.endsWith('ts') ? 'ts' : 'js',
-                            contents: injectValues + contents
-                        };
-                    });
-                }
-            }
-        ]
-    });
-    const { text } = result.outputFiles[0];
-    return {
-        code: text,
-        dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
-    };
-}
-const _require = createRequire(import.meta.url);
-async function loadConfigFormBundledFile(configRoot, configFile, bundledCode, isESM) {
-    if (isESM) {
-        const fileNameTmp = path.resolve(configRoot, `${CONFIG_FILE_NAME}.${Date.now()}.mjs`);
-        fs.writeFileSync(fileNameTmp, bundledCode);
-        const fileUrl = pathToFileURL(fileNameTmp);
-        try {
-            return (await import(fileUrl.href)).default;
-        }
-        finally {
-            try {
-                fs.unlinkSync(fileNameTmp);
-            }
-            catch { }
-        }
-    }
-    else {
-        const extension = path.extname(configFile);
-        const realFileName = fs.realpathSync(configFile);
-        const loaderExt = extension in _require.extensions ? extension : '.js';
-        const defaultLoader = _require.extensions[loaderExt];
-        _require.extensions[loaderExt] = (module, filename) => {
-            if (filename === realFileName) {
-                module._compile(bundledCode, filename);
-            }
-            else {
-                defaultLoader(module, filename);
-            }
-        };
-        delete _require.cache[_require.resolve(configFile)];
-        const raw = _require(configFile);
-        _require.extensions[loaderExt] = defaultLoader;
-        return raw.__esModule ? raw.default : raw;
-    }
-}
 export { ConfigFactory as C, MainConfigFactory as M, PreloadConfigFactory as P, RendererConfigFactory as R, loadEnv as a, bytecodePlugin as b, resolveHostname as c, defineConfig as d, externalizeDepsPlugin as e, loadConfigFromFile as l, resolveConfig as r, startElectron as s };

package/dist/cli.js CHANGED Viewed

@@ -2,7 +2,7 @@ import { cac } from 'cac';
 import colors from 'picocolors';
 import { createLogger } from 'vite';
-var version = "6.0.1";
+var version = "6.0.2";
 const cli = cac('electron-vite');
 function createInlineConfig(root, options) {
@@ -61,7 +61,7 @@ cli
     if (options.entry) {
         process.env.ELECTRON_ENTRY = options.entry;
     }
-    const { createServer } = await import('./chunks/lib-CzmB3HUY.js');
+    const { createServer } = await import('./chunks/lib-DyA1RI3R.js');
     const inlineConfig = createInlineConfig(root, options);
     try {
         await createServer(inlineConfig, { rendererOnly: options.rendererOnly });
@@ -74,7 +74,7 @@ cli
 });
 // build
 cli.command('build [root]', 'build for production').action(async (root, options) => {
-    const { build } = await import('./chunks/lib-B8n2vQeG.js');
+    const { build } = await import('./chunks/lib-DaHzt8UE.js');
     const inlineConfig = createInlineConfig(root, options);
     if (options.entry) {
         process.env.ELECTRON_ENTRY = options.entry;
@@ -94,7 +94,7 @@ cli
     .option('--noSandbox', `[boolean] forces renderer process to run un-sandboxed`)
     .option('--skipBuild', `[boolean] skip build`)
     .action(async (root, options) => {
-    const { preview } = await import('./chunks/lib-FYrM-Sbc.js');
+    const { preview } = await import('./chunks/lib-ShkGlprt.js');
     const inlineConfig = createInlineConfig(root, options);
     if (options.noSandbox) {
         process.env.NO_SANDBOX = '1';

package/dist/index.js CHANGED Viewed

@@ -1,20 +1,20 @@
 import { createFilter } from 'vite';
 export { createLogger, defineConfig as defineViteConfig, mergeConfig } from 'vite';
-export { C as ConfigFactory, M as MainConfigFactory, P as PreloadConfigFactory, R as RendererConfigFactory, b as bytecodePlugin, d as defineConfig, e as externalizeDepsPlugin, l as loadConfigFromFile, a as loadEnv, r as resolveConfig } from './chunks/lib-CbKPgmtQ.js';
-export { createServer } from './chunks/lib-CzmB3HUY.js';
-export { build } from './chunks/lib-B8n2vQeG.js';
-export { preview } from './chunks/lib-FYrM-Sbc.js';
+export { C as ConfigFactory, M as MainConfigFactory, P as PreloadConfigFactory, R as RendererConfigFactory, b as bytecodePlugin, d as defineConfig, e as externalizeDepsPlugin, l as loadConfigFromFile, a as loadEnv, r as resolveConfig } from './chunks/lib-wmKiubLV.js';
+export { createServer } from './chunks/lib-DyA1RI3R.js';
+export { build } from './chunks/lib-DaHzt8UE.js';
+export { preview } from './chunks/lib-ShkGlprt.js';
 import { createRequire } from 'node:module';
 import 'node:path';
-import 'node:fs';
-import 'node:url';
 import 'picocolors';
-import 'esbuild';
+import 'node:fs';
 import 'node:child_process';
 import 'node:crypto';
 import 'node:fs/promises';
 import 'magic-string';
 import '@babel/core';
+import 'node:url';
+import 'rolldown';
 async function transformWithSWC(code, id, options) {
     const { sourcemap = false, minify = false } = options;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@snoirtrom/electron-vite",
-  "version": "6.0.1",
+  "version": "6.0.2",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -76,36 +76,35 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@swc/core": "^1.15.21",
+    "@swc/core": "^1.16.2",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^22.19.15",
-    "eslint": "^10.1.0",
+    "@types/node": "^22.20.4",
+    "eslint": "^10.11.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.5",
-    "globals": "^17.4.0",
-    "lint-staged": "^16.4.0",
-    "prettier": "^3.8.1",
-    "rollup": "^4.60.0",
-    "rollup-plugin-dts": "^6.4.1",
+    "eslint-plugin-prettier": "^5.5.6",
+    "globals": "^17.12.0",
+    "lint-staged": "^17.5.1",
+    "prettier": "^3.9.9",
+    "rollup": "^4.63.5",
+    "rollup-plugin-dts": "^6.5.1",
     "rollup-plugin-rm": "^1.0.2",
-    "simple-git-hooks": "^2.13.1",
+    "simple-git-hooks": "^2.14.0",
     "tslib": "^2.8.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.2",
-    "vite": "^8.0.3"
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.70.1",
+    "vite": "^8.3.1"
   },
   "dependencies": {
-    "@babel/core": "^7.29.0",
-    "@babel/plugin-transform-arrow-functions": "^7.27.1",
+    "@babel/core": "^7.29.7",
+    "@babel/plugin-transform-arrow-functions": "^7.29.7",
     "cac": "^7.0.0",
-    "esbuild": "^0.25.11",
-    "magic-string": "^0.30.21",
-    "picocolors": "^1.1.1"
+    "magic-string": "^1.4.2",
+    "picocolors": "^1.1.1",
+    "rolldown": "~1.2.10"
   },
   "pnpm": {
     "onlyBuiltDependencies": [
       "@swc/core",
-      "esbuild",
       "simple-git-hooks"
     ]
   }