unplugin-dingtalk 1006.0.0 → 1007.0.0

package/dist/nuxt.cjs

@@ -1,844 +1,478 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// node_modules/.pnpm/vite-plugin-vconsole@2.1.1/node_modules/vite-plugin-vconsole/dist/main.mjs
-var main_exports = {};
-__export(main_exports, {
-  default: () => main_default,
-  viteVConsole: () => viteVConsole
-});
-function viteVConsole(opt) {
-  const {
-    entry,
-    enabled = true,
-    config: config2 = {},
-    plugin,
-    customHide = false,
-    dynamicConfig = {},
-    eventListener = ""
-  } = opt;
-  let entryPath = Array.isArray(entry) ? entry : [entry];
-  if (process.platform === "win32")
-    entryPath = entryPath.map((item) => item.replace(/\\/g, "/"));
-  const enabledTruly = enabled;
-  return {
-    name: "vite:vconsole",
-    enforce: "pre",
-    transform(_source, id) {
-      if (entryPath.includes(id) && enabledTruly) {
-        const code = `/* eslint-disable */;
-        import VConsole from 'vconsole';
-        // config
-        const vConsole = new VConsole({${parseVConsoleOptions(
-          config2
-        )}});
-        window.vConsole = vConsole;
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+require('./__chrome_devtools-CJ3sXpVj.cjs');
+const require_src = require('./src-hLDO4Q22.cjs');
+const require_utils = require('./utils-CmfBxo4J.cjs');
+const require_vite = require('./vite-CKIDsKJ-.cjs');
+const http_proxy = require_chunk.__toESM(require("http-proxy"));
+const picocolors = require_chunk.__toESM(require("picocolors"));
+const __nuxt_kit = require_chunk.__toESM(require("@nuxt/kit"));
+require("@nuxt/schema");
 
-        // plugins
-        ${getPlugins(plugin)}
-
-        // dynamic config
-        window.vConsole.dynamicFunction = function() {
-          if (${getDynamicConfig(dynamicConfig).length > 0}) {
-            vConsole.setOption({${getDynamicConfig(dynamicConfig)}});
-          }
-        };
-        
-        window.vConsole.dynamicChange = {
-          value: new Date().getTime()
-        };
-
-        window.vConsole.dynamicFunction();
-
-        if (${customHide}) {
-          vConsole.hideSwitch();
-        }
-
-        // In order to be compatible with old equipment, I used defineProperty. In the future, when proxy covers enough devices, proxy will be used.
-        Object.defineProperty(window.vConsole.dynamicChange, 'value', {
-          get: function() {
-            return this._value;
-          },
-          set: function(newValue) {
-            window.vConsole.dynamicFunction();
-            this._value = newValue;
-          }
-        });
-
-        // eventListener
-        ${eventListener}
-        /* eslint-enable */${_source}`;
-        return {
-          code,
-          map: null
-          // support source map
-        };
-      }
-      return {
-        code: _source,
-        map: null
-        // support source map
-      };
-    }
-  };
+//#region node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject(value) && isPlainObject(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
 }
-var parseVConsoleOptions, getEventItems, getDynamicConfig, getPlugins, main_default;
-var init_main = __esm({
-  "node_modules/.pnpm/vite-plugin-vconsole@2.1.1/node_modules/vite-plugin-vconsole/dist/main.mjs"() {
-    "use strict";
-    parseVConsoleOptions = (config2) => Object.keys(config2).reduce((code, key) => {
-      const value = config2[key];
-      if (typeof value === "function") {
-        if (/^[(f]/.test(value.toString())) {
-          code += `${key}: ${value},`;
-          return code;
-        } else {
-          code += `${value},`;
-          return code;
-        }
-      }
-      code += `${key}: ${JSON.stringify(config2[key])},`;
-      return code;
-    }, "");
-    getEventItems = (event, id) => {
-      return event.map(
-        (ele) => `
-    ${id}.on('${ele.eventName}', ${ele.callback})
-    `
-      ).join(";");
-    };
-    getDynamicConfig = (dynamicConfig) => {
-      let configString = "";
-      if (!dynamicConfig) {
-        return configString;
-      }
-      for (const key in dynamicConfig) {
-        if (typeof dynamicConfig[key] === "string") {
-          configString += `${key}: ${dynamicConfig[key]},`;
-        }
-      }
-      return configString;
-    };
-    getPlugins = (plugin) => {
-      let plugins = "";
-      if (plugin && plugin.length) {
-        plugins = plugin.map(
-          (e) => `
-    const ${e.id} = new VConsole.VConsolePlugin('${e.id}', '${e.name}');
-    ${getEventItems(e.event, e.id)}
-    vConsole.addPlugin(${e.id})
-    `
-        ).join(";");
-      }
-      return plugins;
-    };
-    main_default = viteVConsole;
-  }
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c$1) => _defu(p, c$1, "", merger), {});
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue) => {
+	if (object[key] !== void 0 && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
 });
-
-// src/nuxt.ts
-var nuxt_exports = {};
-__export(nuxt_exports, {
-  default: () => nuxt_default
+const defuArrayFn = createDefu((object, key, currentValue) => {
+	if (Array.isArray(object[key]) && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
 });
-module.exports = __toCommonJS(nuxt_exports);
-var import_kit = require("@nuxt/kit");
-
-// src/vite.ts
-var import_unplugin2 = require("unplugin");
 
-// src/utils.ts
-async function interopDefault(m) {
-  const resolved = await m;
-  return resolved.default || resolved;
+//#endregion
+//#region node_modules/.pnpm/h3@1.15.4/node_modules/h3/dist/index.mjs
+function hasProp(obj, prop) {
+	try {
+		return prop in obj;
+	} catch {
+		return false;
+	}
 }
-
-// src/index.ts
-var import_node_process = __toESM(require("process"), 1);
-var import_node_http = require("http");
-var import_node_net2 = require("net");
-var import_unplugin = require("unplugin");
-var import_picocolors = __toESM(require("picocolors"), 1);
-var import_cookie = __toESM(require("cookie"), 1);
-var import_z_chii = require("z-chii");
-
-// node_modules/.pnpm/get-port-please@3.1.2/node_modules/get-port-please/dist/index.mjs
-var import_node_net = require("net");
-var import_node_os = require("os");
-var unsafePorts = /* @__PURE__ */ new Set([
-  1,
-  // tcpmux
-  7,
-  // echo
-  9,
-  // discard
-  11,
-  // systat
-  13,
-  // daytime
-  15,
-  // netstat
-  17,
-  // qotd
-  19,
-  // chargen
-  20,
-  // ftp data
-  21,
-  // ftp access
-  22,
-  // ssh
-  23,
-  // telnet
-  25,
-  // smtp
-  37,
-  // time
-  42,
-  // name
-  43,
-  // nicname
-  53,
-  // domain
-  69,
-  // tftp
-  77,
-  // priv-rjs
-  79,
-  // finger
-  87,
-  // ttylink
-  95,
-  // supdup
-  101,
-  // hostriame
-  102,
-  // iso-tsap
-  103,
-  // gppitnp
-  104,
-  // acr-nema
-  109,
-  // pop2
-  110,
-  // pop3
-  111,
-  // sunrpc
-  113,
-  // auth
-  115,
-  // sftp
-  117,
-  // uucp-path
-  119,
-  // nntp
-  123,
-  // NTP
-  135,
-  // loc-srv /epmap
-  137,
-  // netbios
-  139,
-  // netbios
-  143,
-  // imap2
-  161,
-  // snmp
-  179,
-  // BGP
-  389,
-  // ldap
-  427,
-  // SLP (Also used by Apple Filing Protocol)
-  465,
-  // smtp+ssl
-  512,
-  // print / exec
-  513,
-  // login
-  514,
-  // shell
-  515,
-  // printer
-  526,
-  // tempo
-  530,
-  // courier
-  531,
-  // chat
-  532,
-  // netnews
-  540,
-  // uucp
-  548,
-  // AFP (Apple Filing Protocol)
-  554,
-  // rtsp
-  556,
-  // remotefs
-  563,
-  // nntp+ssl
-  587,
-  // smtp (rfc6409)
-  601,
-  // syslog-conn (rfc3195)
-  636,
-  // ldap+ssl
-  989,
-  // ftps-data
-  990,
-  // ftps
-  993,
-  // ldap+ssl
-  995,
-  // pop3+ssl
-  1719,
-  // h323gatestat
-  1720,
-  // h323hostcall
-  1723,
-  // pptp
-  2049,
-  // nfs
-  3659,
-  // apple-sasl / PasswordServer
-  4045,
-  // lockd
-  5060,
-  // sip
-  5061,
-  // sips
-  6e3,
-  // X11
-  6566,
-  // sane-port
-  6665,
-  // Alternate IRC [Apple addition]
-  6666,
-  // Alternate IRC [Apple addition]
-  6667,
-  // Standard IRC [Apple addition]
-  6668,
-  // Alternate IRC [Apple addition]
-  6669,
-  // Alternate IRC [Apple addition]
-  6697,
-  // IRC + TLS
-  10080
-  // Amanda
-]);
-function isUnsafePort(port) {
-  return unsafePorts.has(port);
+var H3Error = class extends Error {
+	static __h3_error__ = true;
+	statusCode = 500;
+	fatal = false;
+	unhandled = false;
+	statusMessage;
+	data;
+	cause;
+	constructor(message, opts = {}) {
+		super(message, opts);
+		if (opts.cause && !this.cause) this.cause = opts.cause;
+	}
+	toJSON() {
+		const obj = {
+			message: this.message,
+			statusCode: sanitizeStatusCode(this.statusCode, 500)
+		};
+		if (this.statusMessage) obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
+		if (this.data !== void 0) obj.data = this.data;
+		return obj;
+	}
+};
+function createError(input) {
+	if (typeof input === "string") return new H3Error(input);
+	if (isError(input)) return input;
+	const err = new H3Error(input.message ?? input.statusMessage ?? "", { cause: input.cause || input });
+	if (hasProp(input, "stack")) try {
+		Object.defineProperty(err, "stack", { get() {
+			return input.stack;
+		} });
+	} catch {
+		try {
+			err.stack = input.stack;
+		} catch {}
+	}
+	if (input.data) err.data = input.data;
+	if (input.statusCode) err.statusCode = sanitizeStatusCode(input.statusCode, err.statusCode);
+	else if (input.status) err.statusCode = sanitizeStatusCode(input.status, err.statusCode);
+	if (input.statusMessage) err.statusMessage = input.statusMessage;
+	else if (input.statusText) err.statusMessage = input.statusText;
+	if (err.statusMessage) {
+		const originalMessage = err.statusMessage;
+		const sanitizedMessage = sanitizeStatusMessage(err.statusMessage);
+		if (sanitizedMessage !== originalMessage) console.warn("[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default.");
+	}
+	if (input.fatal !== void 0) err.fatal = input.fatal;
+	if (input.unhandled !== void 0) err.unhandled = input.unhandled;
+	return err;
 }
-function isSafePort(port) {
-  return !isUnsafePort(port);
+function isError(input) {
+	return input?.constructor?.__h3_error__ === true;
 }
-var __defProp2 = Object.defineProperty;
-var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var GetPortError = class extends Error {
-  constructor(message, opts) {
-    super(message, opts);
-    this.message = message;
-    __publicField(this, "name", "GetPortError");
-  }
-};
-function _log(verbose, message) {
-  if (verbose) {
-    console.log(`[get-port] ${message}`);
-  }
+function isMethod(event, expected, allowHead) {
+	if (allowHead && event.method === "HEAD") return true;
+	if (typeof expected === "string") {
+		if (event.method === expected) return true;
+	} else if (expected.includes(event.method)) return true;
+	return false;
 }
-function _tryPort(port, host) {
-  return new Promise((resolve) => {
-    const server = (0, import_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 assertMethod(event, expected, allowHead) {
+	if (!isMethod(event, expected, allowHead)) throw createError({
+		statusCode: 405,
+		statusMessage: "HTTP method is not allowed."
+	});
 }
-function _getLocalHosts(additional) {
-  const hosts = new Set(additional);
-  for (const _interface of Object.values((0, import_node_os.networkInterfaces)())) {
-    for (const config2 of _interface || []) {
-      if (config2.address && !config2.internal && !config2.address.startsWith("fe80::")) {
-        hosts.add(config2.address);
-      }
-    }
-  }
-  return [...hosts];
+function getRequestHeaders(event) {
+	const _headers = {};
+	for (const key in event.node.req.headers) {
+		const val = event.node.req.headers[key];
+		_headers[key] = Array.isArray(val) ? val.filter(Boolean).join(", ") : val;
+	}
+	return _headers;
 }
-function _fmtOnHost(hostname) {
-  return hostname ? `on host ${JSON.stringify(hostname)}` : "on any host";
+const RawBodySymbol = Symbol.for("h3RawBody");
+const ParsedBodySymbol = Symbol.for("h3ParsedBody");
+const PayloadMethods$1 = [
+	"PATCH",
+	"POST",
+	"PUT",
+	"DELETE"
+];
+function readRawBody(event, encoding = "utf8") {
+	assertMethod(event, PayloadMethods$1);
+	const _rawBody = event._requestBody || event.web?.request?.body || event.node.req[RawBodySymbol] || event.node.req.rawBody || event.node.req.body;
+	if (_rawBody) {
+		const promise2 = Promise.resolve(_rawBody).then((_resolved) => {
+			if (Buffer.isBuffer(_resolved)) return _resolved;
+			if (typeof _resolved.pipeTo === "function") return new Promise((resolve, reject) => {
+				const chunks = [];
+				_resolved.pipeTo(new WritableStream({
+					write(chunk) {
+						chunks.push(chunk);
+					},
+					close() {
+						resolve(Buffer.concat(chunks));
+					},
+					abort(reason) {
+						reject(reason);
+					}
+				})).catch(reject);
+			});
+			else if (typeof _resolved.pipe === "function") return new Promise((resolve, reject) => {
+				const chunks = [];
+				_resolved.on("data", (chunk) => {
+					chunks.push(chunk);
+				}).on("end", () => {
+					resolve(Buffer.concat(chunks));
+				}).on("error", reject);
+			});
+			if (_resolved.constructor === Object) return Buffer.from(JSON.stringify(_resolved));
+			if (_resolved instanceof URLSearchParams) return Buffer.from(_resolved.toString());
+			if (_resolved instanceof FormData) return new Response(_resolved).bytes().then((uint8arr) => Buffer.from(uint8arr));
+			return Buffer.from(_resolved);
+		});
+		return encoding ? promise2.then((buff) => buff.toString(encoding)) : promise2;
+	}
+	if (!Number.parseInt(event.node.req.headers["content-length"] || "") && !String(event.node.req.headers["transfer-encoding"] ?? "").split(",").map((e) => e.trim()).filter(Boolean).includes("chunked")) return Promise.resolve(void 0);
+	const promise = event.node.req[RawBodySymbol] = new Promise((resolve, reject) => {
+		const bodyData = [];
+		event.node.req.on("error", (err) => {
+			reject(err);
+		}).on("data", (chunk) => {
+			bodyData.push(chunk);
+		}).on("end", () => {
+			resolve(Buffer.concat(bodyData));
+		});
+	});
+	const result = encoding ? promise.then((buff) => buff.toString(encoding)) : promise;
+	return result;
 }
-var HOSTNAME_RE = new RegExp("^(?!-)[\\d.:A-Za-z-]{1,63}(?<!-)$");
-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;
+function getRequestWebStream(event) {
+	if (!PayloadMethods$1.includes(event.method)) return;
+	const bodyStream = event.web?.request?.body || event._requestBody;
+	if (bodyStream) return bodyStream;
+	const _hasRawBody = RawBodySymbol in event.node.req || "rawBody" in event.node.req || "body" in event.node.req || "__unenv__" in event.node.req;
+	if (_hasRawBody) return new ReadableStream({ async start(controller) {
+		const _rawBody = await readRawBody(event, false);
+		if (_rawBody) controller.enqueue(_rawBody);
+		controller.close();
+	} });
+	return new ReadableStream({ start: (controller) => {
+		event.node.req.on("data", (chunk) => {
+			controller.enqueue(chunk);
+		});
+		event.node.req.on("end", () => {
+			controller.close();
+		});
+		event.node.req.on("error", (err) => {
+			controller.error(err);
+		});
+	} });
 }
-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;
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+	return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
 }
-
-// src/index.ts
-var import_http_proxy = __toESM(require("http-proxy"), 1);
-
-// src/__chrome_devtools.ts
-function getChromeDevtoolsHtml(targetPort) {
-  return `<!DOCTYPE html>
-<html>
-
-<head>
-  <meta charset="utf-8">
-  <title>DevTools Targets</title>
-  <style>
-    body {
-      font-family: sans-serif;
-      padding: 2em;
-    }
-
-    ul {
-      padding: 0;
-    }
-
-    li {
-      margin-bottom: 1.2em;
-      list-style: none;
-      line-height: 1.5;
-    }
-
-    a.button {
-      display: inline-block;
-      background: #409eff;
-      color: #fff;
-      padding: 0.2em 0.5em;
-      text-decoration: none;
-      border-radius: 4px;
-      margin-top: 0.5em;
-      font-size: 14px;
-    }
-
-    a.button:hover {
-      background: #66b1ff;
-    }
-
-    #refresh {
-      margin-bottom: 1.5em;
-    }
-  </style>
-</head>
-
-<body>
-  <h2>\u53EF\u7528 DevTools Targets</h2><button id="refresh">\u5237\u65B0</button>
-  <ul id="target-list">
-    <li>\u52A0\u8F7D\u4E2D...</li>
-  </ul>
-  <script>
-    async function fetchTargets() {
-      const list = document.getElementById("target-list");
-      list.innerHTML = "<li>\u52A0\u8F7D\u4E2D...</li>";
-      try {
-        const resp = await fetch("/__chii_proxy/targets");
-        const data = await resp.json();
-        const targets = data.targets || [];
-        if (targets.length === 0) {
-          list.innerHTML = "<li>\u6682\u65E0\u53EF\u7528\u7684\u8C03\u8BD5\u76EE\u6807\u3002</li>";
-        } else {
-          list.innerHTML = "";
-          for (const target of targets) {
-            console.log(target)
-            const devToolsUrl = "http://localhost:${targetPort}/front_end/chii_app.html?ws=localhost:${targetPort}/client/" + Math.random().toString(20).substring(2, 8) + "?target=" + encodeURIComponent(target.id) + "&rtc=false";
-            const item = document.createElement("li");
-            item.innerHTML =
-              "<div><strong>" + (target.title) + "</strong></div>" +
-              "<div>URL: " + (target.url || "") + "</div>" +
-              "<div>UA: <code>" + (target.userAgent || "unknown") + "</code></div>" +
-              "<a href='" + devToolsUrl + "' target='_blank' class='button'>\u6253\u5F00\u8C03\u8BD5</a>";
-            list.appendChild(item);
-          }
-        }
-      } catch (e) {
-        list.innerHTML = "<li>\u83B7\u53D6\u8C03\u8BD5\u76EE\u6807\u5931\u8D25</li>";
-      }
-    }
-    document.getElementById("refresh").onclick = () => window.location.reload();
-    window.onload = fetchTargets;
-    document.addEventListener('visibilitychange', window.location.reload);
-  </script>
-</body>
-
-</html>`;
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+	if (!statusCode) return defaultStatusCode;
+	if (typeof statusCode === "string") statusCode = Number.parseInt(statusCode, 10);
+	if (statusCode < 100 || statusCode > 999) return defaultStatusCode;
+	return statusCode;
 }
-
-// src/index.ts
-var cwd = import_node_process.default.cwd();
-var config;
-var colorUrl = (url) => import_picocolors.default.green(url.replace(/:(\d+)\//, (_, port) => `:${import_picocolors.default.bold(port)}/`));
-var resovedInfo = {
-  availablePort: void 0,
-  targetURL: void 0
-};
-function createProxyMiddleware(debug) {
-  let proxy = null;
-  const handleUpgrade = (req, socket, head) => {
-    var _a;
-    if (proxy && ((_a = req.url) == null ? void 0 : _a.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) => {
-      var _a;
-      if (!proxy && resolvedInfo.availablePort) {
-        proxy = import_http_proxy.default.createProxyServer({
-          target: `http://localhost:${resolvedInfo.availablePort}`,
-          ws: true
-        });
-        proxy.on("error", (err, req2, res2) => {
-          console.error("Proxy error:", err);
-          if (res2 instanceof import_node_http.ServerResponse) {
-            if (!res2.headersSent) {
-              res2.writeHead(500, { "Content-Type": "text/plain" });
-            }
-            res2.end(`Proxy error: ${err.message}`);
-          } else if (res2 instanceof import_node_net2.Socket) {
-            res2.destroy();
-          }
-        });
-        if (req.socket.server) {
-          req.socket.server.on("upgrade", handleUpgrade);
-        }
-      }
-      if (proxy && ((_a = req.url) == null ? void 0 : _a.startsWith("/__chii_proxy"))) {
-        debug(req.url);
-        req.url = req.url.replace("/__chii_proxy", "");
-        proxy.web(req, res);
-      } else {
-        next();
-      }
-    };
-  };
+function splitCookiesString(cookiesString) {
+	if (Array.isArray(cookiesString)) return cookiesString.flatMap((c$1) => splitCookiesString(c$1));
+	if (typeof cookiesString !== "string") return [];
+	const cookiesStrings = [];
+	let pos = 0;
+	let start;
+	let ch;
+	let lastComma;
+	let nextStart;
+	let cookiesSeparatorFound;
+	const skipWhitespace = () => {
+		while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
+		return pos < cookiesString.length;
+	};
+	const notSpecialChar = () => {
+		ch = cookiesString.charAt(pos);
+		return ch !== "=" && ch !== ";" && ch !== ",";
+	};
+	while (pos < cookiesString.length) {
+		start = pos;
+		cookiesSeparatorFound = false;
+		while (skipWhitespace()) {
+			ch = cookiesString.charAt(pos);
+			if (ch === ",") {
+				lastComma = pos;
+				pos += 1;
+				skipWhitespace();
+				nextStart = pos;
+				while (pos < cookiesString.length && notSpecialChar()) pos += 1;
+				if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+					cookiesSeparatorFound = true;
+					pos = nextStart;
+					cookiesStrings.push(cookiesString.slice(start, lastComma));
+					start = pos;
+				} else pos = lastComma + 1;
+			} else pos += 1;
+		}
+		if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start));
+	}
+	return cookiesStrings;
 }
-var unpluginFactory = (options) => {
-  const {
-    chii
-  } = options || {};
-  const enableChii = (chii == null ? void 0 : chii.enable) !== false;
-  function debug(...args) {
-    if (options == null ? void 0 : options.debug) {
-      console.log(`  ${import_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) {
-      var _a, _b;
-      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";
-  ${((_a = options == null ? void 0 : options.chii) == null ? void 0 : _a.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";
-    ${((_b = options == null ? void 0 : options.chii) == null ? void 0 : _b.embedded) ? "script.setAttribute('embedded','true');" : ""}
-    document.body.appendChild(script);
-  });
+const PayloadMethods = /* @__PURE__ */ new Set([
+	"PATCH",
+	"POST",
+	"PUT",
+	"DELETE"
+]);
+const ignoredHeaders = /* @__PURE__ */ new Set([
+	"transfer-encoding",
+	"accept-encoding",
+	"connection",
+	"keep-alive",
+	"upgrade",
+	"expect",
+	"host",
+	"accept"
+]);
+async function proxyRequest(event, target, opts = {}) {
+	let body;
+	let duplex;
+	if (PayloadMethods.has(event.method)) if (opts.streamRequest) {
+		body = getRequestWebStream(event);
+		duplex = "half";
+	} else body = await readRawBody(event, false).catch(() => void 0);
+	const method = opts.fetchOptions?.method || event.method;
+	const fetchHeaders = mergeHeaders(getProxyRequestHeaders(event, { host: target.startsWith("/") }), opts.fetchOptions?.headers, opts.headers);
+	return sendProxy(event, target, {
+		...opts,
+		fetchOptions: {
+			method,
+			body,
+			duplex,
+			...opts.fetchOptions,
+			headers: fetchHeaders
+		}
+	});
 }
-        `;
-      }
-    },
-    transformInclude(id) {
-      return !!id.split("?")[0].match(/\.[t|j]s$/);
-    },
-    async transform(source, id) {
-      if ((options == null ? void 0 : options.enable) && enableChii && !resovedInfo.availablePort) {
-        resovedInfo.availablePort = await getRandomPort();
-        (0, import_z_chii.start)({ port: resovedInfo.availablePort });
-        debug(`chii server port: ${resovedInfo.availablePort}`);
-      }
-      if ((options == null ? void 0 : options.enable) && enableChii) {
-        const file = id.split("?")[0];
-        if (file.startsWith((config == null ? void 0 : config.root) || cwd) && !file.includes("node_modules") && file.match(/\.[t|j]s$/)) {
-          return {
-            code: `import 'chii-client';
-${source}`,
-            map: null
-          };
-        }
-      }
-      return { code: source, map: null };
-    },
-    vite: {
-      configResolved(_config) {
-        config = _config;
-      },
-      transformIndexHtml(html) {
-        if ((options == null ? void 0 : options.enable) && enableChii) {
-          const tag = `<script type="module">import 'chii-client';</script>`;
-          if (!html.includes(tag)) {
-            return html.replace(
-              "</body>",
-              `</body>${tag}
-`
-            );
-          }
-        }
-        return html;
-      },
-      async configureServer(server) {
-        var _a, _b;
-        if (!(options == null ? void 0 : options.enable)) {
-          return;
-        }
-        const _printUrls = server.printUrls.bind(server);
-        let source = `localhost:${config.server.port || 5173}`;
-        const url = (_a = server.resolvedUrls) == null ? void 0 : _a.local[0];
-        if (url) {
-          const u = new URL(url);
-          source = u.host;
-        }
-        const base = server.config.base || "/";
-        const _targetUrl = (_b = options == null ? void 0 : options.targetUrl) != null ? _b : `http://${source}${base}`;
-        server.printUrls = () => {
-          _printUrls();
-          console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold(
-            "Open in dingtalk"
-          )}: ${colorUrl(`http://${source}${base}open-dingtalk`)}`);
-          if (enableChii) {
-            console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold(
-              "Click to open chrome devtools"
-            )}: ${colorUrl(`http://${source}${base}__chrome_devtools`)}`);
-          }
-        };
-        const targetURL = new URL(_targetUrl);
-        targetURL.searchParams.append("ddtab", "true");
-        if (options == null ? void 0 : options.corpId) {
-          targetURL.searchParams.append("corpId", options.corpId);
-        }
-        if (options.debugCookies && options.debugCookies.length > 0) {
-          server.middlewares.use((req, res, next) => {
-            const cookies = import_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 = import_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(getChromeDevtoolsHtml(resovedInfo.availablePort));
-            res.end();
-          });
-          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) {
-      var _a, _b;
-      if (!(options == null ? void 0 : options.enable)) {
-        return;
-      }
-      const devServerOptions = __spreadValues(__spreadValues({
-        host: "localhost",
-        port: 8080
-      }, compiler.options.devServer), (_a = import_node_process.default.VUE_CLI_SERVICE) == null ? void 0 : _a.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 = (_b = options == null ? void 0 : options.targetUrl) != null ? _b : `http://${source}${base}`;
-      compiler.hooks.done.tap("unplugin-dingtalk", () => {
-        console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold(
-          "Open in dingtalk"
-        )}: ${colorUrl(`http://${source}${base}open-dingtalk`)}`);
-        if (enableChii) {
-          console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold(
-            "Click to open chrome devtools"
-          )}: ${colorUrl(`http://${source}${base}__chrome_devtools`)}`);
-        }
-      });
-      resovedInfo.targetURL = new URL(_targetUrl);
-      resovedInfo.targetURL.searchParams.append("ddtab", "true");
-      if (options == null ? void 0 : options.corpId) {
-        resovedInfo.targetURL.searchParams.append("corpId", options.corpId);
-      }
-    },
-    async rspack(compiler) {
-      var _a, _b, _c, _d;
-      if (!(options == null ? void 0 : options.enable)) {
-        return;
-      }
-      const devServerOptions = __spreadValues(__spreadValues({
-        host: "localhost",
-        port: 8080
-      }, compiler.options.devServer), (_c = (_b = await ((_a = await import("@rsbuild/core")) == null ? void 0 : _a.loadConfig({
-        cwd
-      }))) == null ? void 0 : _b.content) == null ? void 0 : _c.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 = (_d = options == null ? void 0 : options.targetUrl) != null ? _d : `http://${source}${base}`;
-      resovedInfo.targetURL = new URL(_targetUrl);
-      resovedInfo.targetURL.searchParams.append("ddtab", "true");
-      if (options == null ? void 0 : options.corpId) {
-        resovedInfo.targetURL.searchParams.append("corpId", options.corpId);
-      }
-      console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold(
-        "Open in dingtalk"
-      )}: ${colorUrl(`http://${source}${base}open-dingtalk`)}`);
-      if (enableChii) {
-        console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold(
-          "Click to open chrome devtools"
-        )}: ${colorUrl(`http://${source}${base}__chrome_devtools`)}`);
-      }
-    }
-  };
-  return unpluginDing;
-};
-
-// src/vite.ts
-var vite_default = async (options) => {
-  var _a;
-  const plugins = [(0, import_unplugin2.createVitePlugin)(unpluginFactory)(options)];
-  if ((options == null ? void 0 : options.enable) && ((_a = options == null ? void 0 : options.vconsole) == null ? void 0 : _a.enabled)) {
-    try {
-      const viteVConsilePlugin = await interopDefault(Promise.resolve().then(() => (init_main(), main_exports)));
-      plugins.push(viteVConsilePlugin(options == null ? void 0 : options.vconsole));
-    } catch (e) {
-      console.error("vite-plugin-vconsole not found");
-    }
-  }
-  return plugins;
-};
+async function sendProxy(event, target, opts = {}) {
+	let response;
+	try {
+		response = await _getFetch(opts.fetch)(target, {
+			headers: opts.headers,
+			ignoreResponseError: true,
+			...opts.fetchOptions
+		});
+	} catch (error) {
+		throw createError({
+			status: 502,
+			statusMessage: "Bad Gateway",
+			cause: error
+		});
+	}
+	event.node.res.statusCode = sanitizeStatusCode(response.status, event.node.res.statusCode);
+	event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
+	const cookies = [];
+	for (const [key, value] of response.headers.entries()) {
+		if (key === "content-encoding") continue;
+		if (key === "content-length") continue;
+		if (key === "set-cookie") {
+			cookies.push(...splitCookiesString(value));
+			continue;
+		}
+		event.node.res.setHeader(key, value);
+	}
+	if (cookies.length > 0) event.node.res.setHeader("set-cookie", cookies.map((cookie) => {
+		if (opts.cookieDomainRewrite) cookie = rewriteCookieProperty(cookie, opts.cookieDomainRewrite, "domain");
+		if (opts.cookiePathRewrite) cookie = rewriteCookieProperty(cookie, opts.cookiePathRewrite, "path");
+		return cookie;
+	}));
+	if (opts.onResponse) await opts.onResponse(event, response);
+	if (response._data !== void 0) return response._data;
+	if (event.handled) return;
+	if (opts.sendStream === false) {
+		const data = new Uint8Array(await response.arrayBuffer());
+		return event.node.res.end(data);
+	}
+	if (response.body) for await (const chunk of response.body) event.node.res.write(chunk);
+	return event.node.res.end();
+}
+function getProxyRequestHeaders(event, opts) {
+	const headers = /* @__PURE__ */ Object.create(null);
+	const reqHeaders = getRequestHeaders(event);
+	for (const name in reqHeaders) if (!ignoredHeaders.has(name) || name === "host" && opts?.host) headers[name] = reqHeaders[name];
+	return headers;
+}
+function _getFetch(_fetch) {
+	if (_fetch) return _fetch;
+	if (globalThis.fetch) return globalThis.fetch;
+	throw new Error("fetch is not available. Try importing `node-fetch-native/polyfill` for Node.js.");
+}
+function rewriteCookieProperty(header, map, property) {
+	const _map = typeof map === "string" ? { "*": map } : map;
+	return header.replace(new RegExp(`(;\\s*${property}=)([^;]+)`, "gi"), (match, prefix, previousValue) => {
+		let newValue;
+		if (previousValue in _map) newValue = _map[previousValue];
+		else if ("*" in _map) newValue = _map["*"];
+		else return match;
+		return newValue ? prefix + newValue : "";
+	});
+}
+function mergeHeaders(defaults, ...inputs) {
+	const _inputs = inputs.filter(Boolean);
+	if (_inputs.length === 0) return defaults;
+	const merged = new Headers(defaults);
+	for (const input of _inputs) {
+		const entries = Array.isArray(input) ? input : typeof input.entries === "function" ? input.entries() : Object.entries(input);
+		for (const [key, value] of entries) if (value !== void 0) merged.set(key, value);
+	}
+	return merged;
+}
+const getSessionPromise = Symbol("getSession");
+function defineEventHandler(handler) {
+	if (typeof handler === "function") {
+		handler.__is_handler__ = true;
+		return handler;
+	}
+	const _hooks = {
+		onRequest: _normalizeArray(handler.onRequest),
+		onBeforeResponse: _normalizeArray(handler.onBeforeResponse)
+	};
+	const _handler = (event) => {
+		return _callHandler(event, handler.handler, _hooks);
+	};
+	_handler.__is_handler__ = true;
+	_handler.__resolve__ = handler.handler.__resolve__;
+	_handler.__websocket__ = handler.websocket;
+	return _handler;
+}
+function _normalizeArray(input) {
+	return input ? Array.isArray(input) ? input : [input] : void 0;
+}
+async function _callHandler(event, handler, hooks) {
+	if (hooks.onRequest) for (const hook of hooks.onRequest) {
+		await hook(event);
+		if (event.handled) return;
+	}
+	const body = await handler(event);
+	const response = { body };
+	if (hooks.onBeforeResponse) for (const hook of hooks.onBeforeResponse) await hook(event, response);
+	return response.body;
+}
+const H3Headers = globalThis.Headers;
+const H3Response = globalThis.Response;
 
-// src/nuxt.ts
-var import_schema = require("@nuxt/schema");
-var nuxt_default = (0, import_kit.defineNuxtModule)({
-  meta: {
-    name: "nuxt-unplugin-dingtalk",
-    configKey: "unpluginStarter"
-  },
-  defaults: {
-    // ...default options
-  },
-  async setup(options, _nuxt) {
-    const vitePlugins = await vite_default(options);
-    (0, import_kit.addVitePlugin)(vitePlugins);
-  }
+//#endregion
+//#region src/nuxt.ts
+var nuxt_default = (0, __nuxt_kit.defineNuxtModule)({
+	meta: {
+		name: "nuxt-unplugin-dingtalk",
+		configKey: "unpluginDingtalk"
+	},
+	defaults: {},
+	async setup(options, _nuxt) {
+		if (!_nuxt.options.dev) return;
+		if (!options.enable) return;
+		function debug(...args) {
+			if (options?.debug) console.log(`  ${picocolors.default.yellow("DEBUG")}  `, ...args);
+		}
+		const { chii } = options || {};
+		const enableChii = chii?.enable !== false;
+		_nuxt.options.runtimeConfig.unpluginDingtalk = { chiiEmbedded: chii?.embedded ?? false };
+		if (enableChii) {
+			const resolver = (0, __nuxt_kit.createResolver)(require("url").pathToFileURL(__filename).href);
+			(0, __nuxt_kit.addServerPlugin)(resolver.resolve("./inject-script"));
+			let proxy = null;
+			(0, __nuxt_kit.addDevServerHandler)({
+				route: "/__chii_proxy",
+				handler: defineEventHandler(async (event) => {
+					if (require_src.resovedInfo.availablePort) return proxyRequest(event, `http://localhost:${require_src.resovedInfo.availablePort}${event.path}`);
+				})
+			});
+			_nuxt.hook("listen", (server) => {
+				const originalUpgradeListeners = server.listeners("upgrade").slice();
+				server.removeAllListeners("upgrade");
+				server.on("upgrade", (req, socket, head) => {
+					if (req.url?.startsWith("/__chii_proxy")) {
+						debug("WS upgrade:", req.url);
+						if (!proxy && require_src.resovedInfo.availablePort) {
+							proxy = http_proxy.default.createProxyServer({
+								target: `http://localhost:${require_src.resovedInfo.availablePort}`,
+								ws: true
+							});
+							proxy.on("error", (err) => {
+								debug("Proxy error:", err.message);
+							});
+						}
+						if (proxy) {
+							req.url = req.url.replace("/__chii_proxy", "");
+							socket.on("error", (err) => {
+								debug("Socket error:", err.message);
+							});
+							try {
+								proxy.ws(req, socket, head);
+							} catch (err) {
+								debug("WS upgrade failed:", err.message);
+								socket.destroy();
+							}
+							return;
+						}
+					}
+					for (const listener of originalUpgradeListeners) listener.call(server, req, socket, head);
+				});
+			});
+		}
+		const vitePlugins = await require_vite.vite_default(options);
+		(0, __nuxt_kit.addVitePlugin)(vitePlugins);
+		_nuxt.hook("listen", (_, listener) => {
+			const url = listener.url;
+			const source = new URL(url).host;
+			const base = _nuxt.options.app.baseURL || "/";
+			if (enableChii) console.log(`  ${picocolors.default.green("➜")}  ${picocolors.default.bold("Click to open chrome devtools")}: ${require_utils.colorUrl(`http://${source}${base}__chrome_devtools`)}`);
+		});
+	}
 });
-exports.default = module.exports;
+
+//#endregion
+module.exports = nuxt_default;