unplugin-dingtalk 1005.0.0 → 1007.0.0

package/dist/src-hLDO4Q22.cjs

@@ -0,0 +1,394 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require___chrome_devtools = require('./__chrome_devtools-CJ3sXpVj.cjs');
+const require_utils = require('./utils-CmfBxo4J.cjs');
+const node_http = require_chunk.__toESM(require("node:http"));
+const node_net = require_chunk.__toESM(require("node:net"));
+const node_process = require_chunk.__toESM(require("node:process"));
+const cookie = require_chunk.__toESM(require("cookie"));
+const node_os = require_chunk.__toESM(require("node:os"));
+const http_proxy = require_chunk.__toESM(require("http-proxy"));
+const picocolors = require_chunk.__toESM(require("picocolors"));
+const unplugin = require_chunk.__toESM(require("unplugin"));
+const z_chii = require_chunk.__toESM(require("z-chii"));
+
+//#region node_modules/.pnpm/get-port-please@3.2.0/node_modules/get-port-please/dist/index.mjs
+const unsafePorts = /* @__PURE__ */ new Set([
+	1,
+	7,
+	9,
+	11,
+	13,
+	15,
+	17,
+	19,
+	20,
+	21,
+	22,
+	23,
+	25,
+	37,
+	42,
+	43,
+	53,
+	69,
+	77,
+	79,
+	87,
+	95,
+	101,
+	102,
+	103,
+	104,
+	109,
+	110,
+	111,
+	113,
+	115,
+	117,
+	119,
+	123,
+	135,
+	137,
+	139,
+	143,
+	161,
+	179,
+	389,
+	427,
+	465,
+	512,
+	513,
+	514,
+	515,
+	526,
+	530,
+	531,
+	532,
+	540,
+	548,
+	554,
+	556,
+	563,
+	587,
+	601,
+	636,
+	989,
+	990,
+	993,
+	995,
+	1719,
+	1720,
+	1723,
+	2049,
+	3659,
+	4045,
+	5060,
+	5061,
+	6e3,
+	6566,
+	6665,
+	6666,
+	6667,
+	6668,
+	6669,
+	6697,
+	10080
+]);
+function isUnsafePort(port) {
+	return unsafePorts.has(port);
+}
+function isSafePort(port) {
+	return !isUnsafePort(port);
+}
+var GetPortError = class extends Error {
+	constructor(message, opts) {
+		super(message, opts);
+		this.message = message;
+	}
+	name = "GetPortError";
+};
+function _log(verbose, message) {
+	if (verbose) console.log(`[get-port] ${message}`);
+}
+function _tryPort(port, host) {
+	return new Promise((resolve) => {
+		const server = (0, node_net.createServer)();
+		server.unref();
+		server.on("error", () => {
+			resolve(false);
+		});
+		server.listen({
+			port,
+			host
+		}, () => {
+			const { port: port2 } = server.address();
+			server.close(() => {
+				resolve(isSafePort(port2) && port2);
+			});
+		});
+	});
+}
+function _getLocalHosts(additional) {
+	const hosts = new Set(additional);
+	for (const _interface of Object.values((0, node_os.networkInterfaces)())) for (const config$1 of _interface || []) if (config$1.address && !config$1.internal && !config$1.address.startsWith("fe80::") && !config$1.address.startsWith("169.254")) hosts.add(config$1.address);
+	return [...hosts];
+}
+function _fmtOnHost(hostname) {
+	return hostname ? `on host ${JSON.stringify(hostname)}` : "on any host";
+}
+async function getRandomPort(host) {
+	const port = await checkPort(0, host);
+	if (port === false) throw new GetPortError(`Unable to find a random port ${_fmtOnHost(host)}`);
+	return port;
+}
+async function checkPort(port, host = process.env.HOST, verbose) {
+	if (!host) host = _getLocalHosts([void 0, "0.0.0.0"]);
+	if (!Array.isArray(host)) return _tryPort(port, host);
+	for (const _host of host) {
+		const _port = await _tryPort(port, _host);
+		if (_port === false) {
+			if (port < 1024 && verbose) _log(verbose, `Unable to listen to the privileged port ${port} ${_fmtOnHost(_host)}`);
+			return false;
+		}
+		if (port === 0 && _port !== 0) port = _port;
+	}
+	return port;
+}
+
+//#endregion
+//#region src/index.ts
+const cwd = node_process.default.cwd();
+let config;
+const resovedInfo = {
+	availablePort: void 0,
+	targetURL: void 0
+};
+function createProxyMiddleware(debug) {
+	let proxy = null;
+	const handleUpgrade = (req, socket, head) => {
+		if (proxy && req.url?.startsWith("/__chii_proxy")) {
+			debug("WS upgrade:", req.url);
+			req.url = req.url.replace("/__chii_proxy", "");
+			proxy.ws(req, socket, head);
+		}
+	};
+	return (resolvedInfo) => {
+		return (req, res, next) => {
+			if (req.url?.startsWith("/__chii_proxy")) req._skip_transform = true;
+			if (!proxy && resolvedInfo.availablePort) {
+				proxy = http_proxy.default.createProxyServer({
+					target: `http://localhost:${resolvedInfo.availablePort}`,
+					ws: true
+				});
+				proxy.on("error", (err, req$1, res$1) => {
+					console.error("Proxy error:", err);
+					if (res$1 instanceof node_http.ServerResponse) {
+						if (!res$1.headersSent) res$1.writeHead(500, { "Content-Type": "text/plain" });
+						res$1.end(`Proxy error: ${err.message}`);
+					} else if (res$1 instanceof node_net.Socket) res$1.destroy();
+				});
+				if (req.socket.server) req.socket.server.on("upgrade", handleUpgrade);
+			}
+			if (proxy && req.url?.startsWith("/__chii_proxy")) {
+				debug(req.url);
+				req.url = req.url.replace("/__chii_proxy", "");
+				proxy.web(req, res);
+			} else next();
+		};
+	};
+}
+const unpluginFactory = (options) => {
+	const { chii } = options || {};
+	const enableChii = chii?.enable !== false;
+	function debug(...args) {
+		if (options?.debug) console.log(`  ${picocolors.default.yellow("DEBUG")}  `, ...args);
+	}
+	const unpluginDing = {
+		name: "unplugin-dingtalk",
+		enforce: "pre",
+		resolveId(source) {
+			if (source === "chii-client") return source;
+		},
+		loadInclude(id) {
+			return id === "chii-client";
+		},
+		load(id) {
+			if (id === "chii-client") return `
+;(function(){
+  if (document.getElementById('__chii_client')) return;
+  const script = document.createElement('script');
+  script.id = '__chii_client';
+  script.src="/__chii_proxy/target.js";
+  ${options?.chii?.embedded ? "script.setAttribute('embedded','true');" : ""}
+  document.body.appendChild(script);
+})();
+if (import.meta.hot) {
+  import.meta.hot.accept(() => {
+    const old = document.getElementById('__chii_client');
+    if (old) old.remove();
+    const script = document.createElement('script');
+    script.id = '__chii_client';
+    script.src="/__chii_proxy/target.js";
+    ${options?.chii?.embedded ? "script.setAttribute('embedded','true');" : ""}
+    document.body.appendChild(script);
+  });
+}
+        `;
+		},
+		transformInclude(id) {
+			return !!id.split("?")[0].match(/\.[t|j]s$/);
+		},
+		async transform(source, id) {
+			if (options?.enable && enableChii && !resovedInfo.availablePort) {
+				resovedInfo.availablePort = await getRandomPort();
+				(0, z_chii.start)({ port: resovedInfo.availablePort });
+				debug(`chii server port: ${resovedInfo.availablePort}`);
+			}
+			if (options?.enable && enableChii) {
+				const file = id.split("?")[0];
+				if (file.startsWith(config?.root || cwd) && !file.includes("node_modules") && file.match(/\.[t|j]s$/)) return {
+					code: `import 'chii-client';\n${source}`,
+					map: null
+				};
+			}
+			return {
+				code: source,
+				map: null
+			};
+		},
+		vite: {
+			configResolved(_config) {
+				config = _config;
+			},
+			transformIndexHtml(html) {
+				if (options?.enable && enableChii) {
+					const tag = "<script type=\"module\">import 'chii-client';<\/script>";
+					if (!html.includes(tag)) return html.replace("</body>", `</body>${tag}\n`);
+				}
+				return html;
+			},
+			async configureServer(server) {
+				if (!options?.enable) return;
+				const _printUrls = server.printUrls.bind(server);
+				let source = `localhost:${config.server.port || 5173}`;
+				const url = server.resolvedUrls?.local[0];
+				if (url) {
+					const u = new URL(url);
+					source = u.host;
+				}
+				const base = server.config.base || "/";
+				const _targetUrl = options?.targetUrl ?? `http://${source}${base}`;
+				server.printUrls = () => {
+					_printUrls();
+					console.log(`  ${picocolors.default.green("➜")}  ${picocolors.default.bold("Open in dingtalk")}: ${require_utils.colorUrl(`http://${source}${base}open-dingtalk`)}`);
+					if (enableChii) console.log(`  ${picocolors.default.green("➜")}  ${picocolors.default.bold("Click to open chrome devtools")}: ${require_utils.colorUrl(`http://${source}${base}__chrome_devtools`)}`);
+				};
+				const targetURL = new URL(_targetUrl);
+				targetURL.searchParams.append("ddtab", "true");
+				if (options?.corpId) targetURL.searchParams.append("corpId", options.corpId);
+				if (options.debugCookies && options.debugCookies.length > 0) server.middlewares.use((req, res, next) => {
+					const cookies = cookie.default.parse(req.headers.cookie || "");
+					for (const [name, value] of Object.entries(cookies)) if (value && options.debugCookies && options.debugCookies.length > 0 && options.debugCookies.includes(name)) {
+						const serializedCookie = cookie.default.serialize(name, value, { httpOnly: false });
+						res.setHeader("Set-Cookie", serializedCookie);
+					}
+					next();
+				});
+				if (enableChii) {
+					server.middlewares.use("/__chrome_devtools", async (_req, res) => {
+						if (!resovedInfo.availablePort) {
+							res.writeHead(500, { "Content-Type": "text/plain" });
+							res.end("Server not started");
+							return;
+						}
+						res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+						res.write(require___chrome_devtools.getChromeDevtoolsHtml(resovedInfo.availablePort));
+						res.end();
+					});
+					const isNuxt = require_utils.isNuxtProject();
+					console.log("isNuxt", isNuxt);
+					if (!isNuxt) {
+						const proxyMiddleware = createProxyMiddleware(debug);
+						server.middlewares.use(proxyMiddleware(resovedInfo));
+					}
+				}
+				server.middlewares.use("/open-dingtalk", (req, res) => {
+					debug(targetURL.toString());
+					res.writeHead(302, { Location: `dingtalk://dingtalkclient/page/link?url=${encodeURIComponent(targetURL.toString())}` });
+					res.end();
+				});
+			}
+		},
+		webpack(compiler) {
+			if (!options?.enable) return;
+			const devServerOptions = {
+				host: "localhost",
+				port: 8080,
+				...compiler.options.devServer,
+				...node_process.default.VUE_CLI_SERVICE?.projectOptions.devServer
+			};
+			const source = `${devServerOptions.host === "0.0.0.0" ? "127.0.0.1" : devServerOptions.host}:${devServerOptions.port}`;
+			const base = compiler.options.output.publicPath || "/";
+			const _targetUrl = options?.targetUrl ?? `http://${source}${base}`;
+			compiler.hooks.done.tap("unplugin-dingtalk", () => {
+				console.log(`  ${picocolors.default.green("➜")}  ${picocolors.default.bold("Open in dingtalk")}: ${require_utils.colorUrl(`http://${source}${base}open-dingtalk`)}`);
+				if (enableChii) console.log(`  ${picocolors.default.green("➜")}  ${picocolors.default.bold("Click to open chrome devtools")}: ${require_utils.colorUrl(`http://${source}${base}__chrome_devtools`)}`);
+			});
+			resovedInfo.targetURL = new URL(_targetUrl);
+			resovedInfo.targetURL.searchParams.append("ddtab", "true");
+			if (options?.corpId) resovedInfo.targetURL.searchParams.append("corpId", options.corpId);
+		},
+		async rspack(compiler) {
+			if (!options?.enable) return;
+			const devServerOptions = {
+				host: "localhost",
+				port: 8080,
+				...compiler.options.devServer,
+				...(await (await import("@rsbuild/core"))?.loadConfig({ cwd }))?.content?.server
+			};
+			const source = `${devServerOptions.host === "0.0.0.0" ? "127.0.0.1" : devServerOptions.host}:${devServerOptions.port}`;
+			const base = compiler.options.output.publicPath || "/";
+			const _targetUrl = options?.targetUrl ?? `http://${source}${base}`;
+			resovedInfo.targetURL = new URL(_targetUrl);
+			resovedInfo.targetURL.searchParams.append("ddtab", "true");
+			if (options?.corpId) resovedInfo.targetURL.searchParams.append("corpId", options.corpId);
+			console.log(`  ${picocolors.default.green("➜")}  ${picocolors.default.bold("Open in dingtalk")}: ${require_utils.colorUrl(`http://${source}${base}open-dingtalk`)}`);
+			if (enableChii) console.log(`  ${picocolors.default.green("➜")}  ${picocolors.default.bold("Click to open chrome devtools")}: ${require_utils.colorUrl(`http://${source}${base}__chrome_devtools`)}`);
+		}
+	};
+	return unpluginDing;
+};
+const unplugin$1 = /* @__PURE__ */ (0, unplugin.createUnplugin)(unpluginFactory);
+var src_default = unplugin$1;
+
+//#endregion
+Object.defineProperty(exports, 'createProxyMiddleware', {
+  enumerable: true,
+  get: function () {
+    return createProxyMiddleware;
+  }
+});
+Object.defineProperty(exports, 'resovedInfo', {
+  enumerable: true,
+  get: function () {
+    return resovedInfo;
+  }
+});
+Object.defineProperty(exports, 'src_default', {
+  enumerable: true,
+  get: function () {
+    return src_default;
+  }
+});
+Object.defineProperty(exports, 'unplugin', {
+  enumerable: true,
+  get: function () {
+    return unplugin$1;
+  }
+});
+Object.defineProperty(exports, 'unpluginFactory', {
+  enumerable: true,
+  get: function () {
+    return unpluginFactory;
+  }
+});

package/dist/types-D6mfGNG_.d.ts

@@ -0,0 +1,38 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import * as webpack_dev_server0 from "webpack-dev-server";
+import { viteVConsoleOptions } from "vite-plugin-vconsole";
+
+//#region src/types.d.ts
+interface Options {
+  enable?: boolean;
+  targetUrl?: string;
+  corpId?: string;
+  debug?: boolean;
+  /** only support vite */
+  vconsole?: viteVConsoleOptions;
+  chii?: {
+    /** default true */
+    enable?: boolean;
+    /**
+     * default false
+     * @link [chii embedded](https://chii.liriliri.io/docs/#usage)
+     */
+    embedded?: boolean;
+  };
+  debugCookies?: string[];
+}
+type SetupMiddlewares = (middlewares: webpack_dev_server0.Middleware[], devServer: webpack_dev_server0) => webpack_dev_server0.Middleware[];
+type NextFunction = () => void;
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
+interface ServerAPIs {
+  sockWrite: (type: string, data?: string | boolean | Record<string, any>) => void;
+}
+type RspackSetupMiddlewares = (/** Order: `unshift` => internal middlewares => `push` */
+middlewares: {
+  /** Use the `unshift` method if you want to run a middleware before all other middlewares */
+  unshift: (...handlers: RequestHandler[]) => void;
+  /** Use the `push` method if you want to run a middleware after all other middlewares */
+  push: (...handlers: RequestHandler[]) => void;
+}, server: ServerAPIs) => void;
+//#endregion
+export { Options, RspackSetupMiddlewares, SetupMiddlewares };

package/dist/types-DodDHiEA.d.cts

@@ -0,0 +1,38 @@
+import * as webpack_dev_server0 from "webpack-dev-server";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { viteVConsoleOptions } from "vite-plugin-vconsole";
+
+//#region src/types.d.ts
+interface Options {
+  enable?: boolean;
+  targetUrl?: string;
+  corpId?: string;
+  debug?: boolean;
+  /** only support vite */
+  vconsole?: viteVConsoleOptions;
+  chii?: {
+    /** default true */
+    enable?: boolean;
+    /**
+     * default false
+     * @link [chii embedded](https://chii.liriliri.io/docs/#usage)
+     */
+    embedded?: boolean;
+  };
+  debugCookies?: string[];
+}
+type SetupMiddlewares = (middlewares: webpack_dev_server0.Middleware[], devServer: webpack_dev_server0) => webpack_dev_server0.Middleware[];
+type NextFunction = () => void;
+type RequestHandler = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
+interface ServerAPIs {
+  sockWrite: (type: string, data?: string | boolean | Record<string, any>) => void;
+}
+type RspackSetupMiddlewares = (/** Order: `unshift` => internal middlewares => `push` */
+middlewares: {
+  /** Use the `unshift` method if you want to run a middleware before all other middlewares */
+  unshift: (...handlers: RequestHandler[]) => void;
+  /** Use the `push` method if you want to run a middleware after all other middlewares */
+  push: (...handlers: RequestHandler[]) => void;
+}, server: ServerAPIs) => void;
+//#endregion
+export { Options, RspackSetupMiddlewares, SetupMiddlewares };

package/dist/types.d.cts

@@ -0,0 +1,2 @@
+import { Options, RspackSetupMiddlewares, SetupMiddlewares } from "./types-DodDHiEA.cjs";
+export { Options, RspackSetupMiddlewares, SetupMiddlewares };

package/dist/types.d.ts

@@ -1,38 +1,2 @@
-import * as webpack_dev_server from 'webpack-dev-server';
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { viteVConsoleOptions } from 'vite-plugin-vconsole';
-
-interface Options {
-    enable?: boolean;
-    targetUrl?: string;
-    corpId?: string;
-    debug?: boolean;
-    /** only support vite */
-    vconsole?: viteVConsoleOptions;
-    chii?: {
-        /** default true */
-        enable?: boolean;
-        /**
-         * default false
-         * @link [chii embedded](https://chii.liriliri.io/docs/#usage)
-         */
-        embedded?: boolean;
-    };
-    debugCookies?: string[];
-}
-type SetupMiddlewares = (middlewares: webpack_dev_server.Middleware[], devServer: webpack_dev_server) => webpack_dev_server.Middleware[];
-type NextFunction = () => void;
-type RequestHandler = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
-interface ServerAPIs {
-    sockWrite: (type: string, data?: string | boolean | Record<string, any>) => void;
-}
-type RspackSetupMiddlewares = (
-/** Order: `unshift` => internal middlewares => `push` */
-middlewares: {
-    /** Use the `unshift` method if you want to run a middleware before all other middlewares */
-    unshift: (...handlers: RequestHandler[]) => void;
-    /** Use the `push` method if you want to run a middleware after all other middlewares */
-    push: (...handlers: RequestHandler[]) => void;
-}, server: ServerAPIs) => void;
-
-export type { Options, RspackSetupMiddlewares, SetupMiddlewares };
+import { Options, RspackSetupMiddlewares, SetupMiddlewares } from "./types-D6mfGNG_.js";
+export { Options, RspackSetupMiddlewares, SetupMiddlewares };

package/dist/types.js

@@ -0,0 +1 @@
+export {  };

package/dist/utils-Chlbb6jf.js

@@ -0,0 +1,23 @@
+import process from "node:process";
+import c from "picocolors";
+import { existsSync } from "node:fs";
+
+//#region src/utils.ts
+async function interopDefault(m) {
+	const resolved = await m;
+	return resolved.default || resolved;
+}
+const colorUrl = (url) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
+function isNuxtProject() {
+	const names = ["nuxt.config.ts", "nuxt.config.js"];
+	for (const name of names) {
+		const path = `${process.cwd()}/${name}`;
+		const result = existsSync(path);
+		if (result) return true;
+		else continue;
+	}
+	return false;
+}
+
+//#endregion
+export { colorUrl, interopDefault, isNuxtProject };

package/dist/utils-CmfBxo4J.cjs

@@ -0,0 +1,41 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const node_process = require_chunk.__toESM(require("node:process"));
+const picocolors = require_chunk.__toESM(require("picocolors"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+
+//#region src/utils.ts
+async function interopDefault(m) {
+	const resolved = await m;
+	return resolved.default || resolved;
+}
+const colorUrl = (url) => picocolors.default.green(url.replace(/:(\d+)\//, (_, port) => `:${picocolors.default.bold(port)}/`));
+function isNuxtProject() {
+	const names = ["nuxt.config.ts", "nuxt.config.js"];
+	for (const name of names) {
+		const path = `${node_process.default.cwd()}/${name}`;
+		const result = (0, node_fs.existsSync)(path);
+		if (result) return true;
+		else continue;
+	}
+	return false;
+}
+
+//#endregion
+Object.defineProperty(exports, 'colorUrl', {
+  enumerable: true,
+  get: function () {
+    return colorUrl;
+  }
+});
+Object.defineProperty(exports, 'interopDefault', {
+  enumerable: true,
+  get: function () {
+    return interopDefault;
+  }
+});
+Object.defineProperty(exports, 'isNuxtProject', {
+  enumerable: true,
+  get: function () {
+    return isNuxtProject;
+  }
+});

package/dist/utils.cjs

@@ -0,0 +1,5 @@
+const require_utils = require('./utils-CmfBxo4J.cjs');
+
+exports.colorUrl = require_utils.colorUrl;
+exports.interopDefault = require_utils.interopDefault;
+exports.isNuxtProject = require_utils.isNuxtProject;

package/dist/utils.d.cts

@@ -0,0 +1,9 @@
+//#region src/utils.d.ts
+type Awaitable<T> = T | Promise<T>;
+declare function interopDefault<T>(m: Awaitable<T>): Promise<T extends {
+  default: infer U;
+} ? U : T>;
+declare const colorUrl: (url: string) => string;
+declare function isNuxtProject(): boolean;
+//#endregion
+export { Awaitable, colorUrl, interopDefault, isNuxtProject };

package/dist/utils.d.ts

@@ -1,6 +1,9 @@
+//#region src/utils.d.ts
 type Awaitable<T> = T | Promise<T>;
 declare function interopDefault<T>(m: Awaitable<T>): Promise<T extends {
-    default: infer U;
+  default: infer U;
 } ? U : T>;
-
-export { type Awaitable, interopDefault };
+declare const colorUrl: (url: string) => string;
+declare function isNuxtProject(): boolean;
+//#endregion
+export { Awaitable, colorUrl, interopDefault, isNuxtProject };

package/dist/utils.js

@@ -1,7 +1,3 @@
-import {
-  interopDefault
-} from "./chunk-KQOHODTC.js";
-import "./chunk-5JBD5THX.js";
-export {
-  interopDefault
-};
+import { colorUrl, interopDefault, isNuxtProject } from "./utils-Chlbb6jf.js";
+
+export { colorUrl, interopDefault, isNuxtProject };

package/dist/vite-CKIDsKJ-.cjs

@@ -0,0 +1,24 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_src = require('./src-hLDO4Q22.cjs');
+const require_utils = require('./utils-CmfBxo4J.cjs');
+const unplugin = require_chunk.__toESM(require("unplugin"));
+
+//#region src/vite.ts
+var vite_default = async (options) => {
+	const plugins = [(0, unplugin.createVitePlugin)(require_src.unpluginFactory)(options)];
+	if (options?.enable && options?.vconsole?.enabled) try {
+		const viteVConsilePlugin = await require_utils.interopDefault(Promise.resolve().then(() => require("./main-DQgEHuwp.cjs")));
+		plugins.push(viteVConsilePlugin(options?.vconsole));
+	} catch (e) {
+		console.error("vite-plugin-vconsole not found");
+	}
+	return plugins;
+};
+
+//#endregion
+Object.defineProperty(exports, 'vite_default', {
+  enumerable: true,
+  get: function () {
+    return vite_default;
+  }
+});

package/dist/vite-DoBUfGyY.js

@@ -0,0 +1,18 @@
+import { unpluginFactory } from "./src-BVX_Roo9.js";
+import { interopDefault } from "./utils-Chlbb6jf.js";
+import { createVitePlugin } from "unplugin";
+
+//#region src/vite.ts
+var vite_default = async (options) => {
+	const plugins = [createVitePlugin(unpluginFactory)(options)];
+	if (options?.enable && options?.vconsole?.enabled) try {
+		const viteVConsilePlugin = await interopDefault(import("./main-BvTybYko.js"));
+		plugins.push(viteVConsilePlugin(options?.vconsole));
+	} catch (e) {
+		console.error("vite-plugin-vconsole not found");
+	}
+	return plugins;
+};
+
+//#endregion
+export { vite_default };

package/dist/vite.cjs

@@ -0,0 +1,6 @@
+require('./__chrome_devtools-CJ3sXpVj.cjs');
+require('./src-hLDO4Q22.cjs');
+require('./utils-CmfBxo4J.cjs');
+const require_vite = require('./vite-CKIDsKJ-.cjs');
+
+module.exports = require_vite.vite_default;