初始化

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/chunk-6F4PWJZI.js

@@ -0,0 +1 @@
+"use strict";

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/chunk-BPHJA2FM.mjs

@@ -0,0 +1,195 @@
+// src/core/utils.ts
+import { parse } from "path";
+import minimatch from "minimatch";
+import resolve from "resolve";
+import { slash, toArray } from "@antfu/utils";
+import {
+  getPackageInfo,
+  isPackageExists
+} from "local-pkg";
+
+// src/core/constants.ts
+var DISABLE_COMMENT = "/* unplugin-vue-components disabled */";
+var DIRECTIVE_IMPORT_PREFIX = "v";
+
+// src/core/utils.ts
+var isSSR = Boolean(process.env.SSR || process.env.SSG || process.env.VITE_SSR || process.env.VITE_SSG);
+function pascalCase(str) {
+  return capitalize(camelCase(str));
+}
+function camelCase(str) {
+  return str.replace(/-(\w)/g, (_, c) => c ? c.toUpperCase() : "");
+}
+function kebabCase(key) {
+  const result = key.replace(/([A-Z])/g, " $1").trim();
+  return result.split(" ").join("-").toLowerCase();
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function parseId(id) {
+  const index = id.indexOf("?");
+  if (index < 0) {
+    return { path: id, query: {} };
+  } else {
+    const query = Object.fromEntries(new URLSearchParams(id.slice(index)));
+    return {
+      path: id.slice(0, index),
+      query
+    };
+  }
+}
+function isEmpty(value) {
+  if (!value || value === null || value === void 0 || Array.isArray(value) && Object.keys(value).length <= 0)
+    return true;
+  else
+    return false;
+}
+function matchGlobs(filepath, globs) {
+  for (const glob of globs) {
+    if (minimatch(slash(filepath), glob))
+      return true;
+  }
+  return false;
+}
+function getTransformedPath(path, importPathTransform) {
+  if (importPathTransform) {
+    const result = importPathTransform(path);
+    if (result != null)
+      path = result;
+  }
+  return path;
+}
+function stringifyImport(info) {
+  if (typeof info === "string")
+    return `import '${info}'`;
+  if (!info.as)
+    return `import '${info.from}'`;
+  else if (info.name)
+    return `import { ${info.name} as ${info.as} } from '${info.from}'`;
+  else
+    return `import ${info.as} from '${info.from}'`;
+}
+function normalizeComponetInfo(info) {
+  if ("path" in info) {
+    return {
+      from: info.path,
+      as: info.name,
+      name: info.importName,
+      sideEffects: info.sideEffects
+    };
+  }
+  return info;
+}
+function stringifyComponentImport({ as: name, from: path, name: importName, sideEffects }, ctx) {
+  path = getTransformedPath(path, ctx.options.importPathTransform);
+  const imports = [
+    stringifyImport({ as: name, from: path, name: importName })
+  ];
+  if (sideEffects)
+    toArray(sideEffects).forEach((i) => imports.push(stringifyImport(i)));
+  return imports.join(";");
+}
+function getNameFromFilePath(filePath, options) {
+  const { resolvedDirs, directoryAsNamespace, globalNamespaces, collapseSamePrefixes, root } = options;
+  const parsedFilePath = parse(slash(filePath));
+  let strippedPath = "";
+  for (const dir of resolvedDirs) {
+    if (parsedFilePath.dir.startsWith(dir)) {
+      strippedPath = parsedFilePath.dir.slice(dir.length);
+      break;
+    }
+  }
+  let folders = strippedPath.slice(1).split("/").filter(Boolean);
+  let filename = parsedFilePath.name;
+  if (filename === "index" && !directoryAsNamespace) {
+    if (isEmpty(folders))
+      folders = parsedFilePath.dir.slice(root.length + 1).split("/").filter(Boolean);
+    filename = `${folders.slice(-1)[0]}`;
+    return filename;
+  }
+  if (directoryAsNamespace) {
+    if (globalNamespaces.some((name) => folders.includes(name)))
+      folders = folders.filter((f) => !globalNamespaces.includes(f));
+    folders = folders.map((f) => f.replace(/[^a-zA-Z0-9\-]/g, ""));
+    if (filename.toLowerCase() === "index")
+      filename = "";
+    if (!isEmpty(folders)) {
+      let namespaced = [...folders, filename];
+      if (collapseSamePrefixes) {
+        const collapsed = [];
+        for (const fileOrFolderName of namespaced) {
+          let cumulativePrefix = "";
+          let didCollapse = false;
+          for (const parentFolder of [...collapsed].reverse()) {
+            cumulativePrefix = `${capitalize(parentFolder)}${cumulativePrefix}`;
+            if (pascalCase(fileOrFolderName).startsWith(pascalCase(cumulativePrefix))) {
+              const collapseSamePrefix = fileOrFolderName.slice(cumulativePrefix.length);
+              collapsed.push(collapseSamePrefix);
+              didCollapse = true;
+              break;
+            }
+          }
+          if (!didCollapse)
+            collapsed.push(fileOrFolderName);
+        }
+        namespaced = collapsed;
+      }
+      filename = namespaced.filter(Boolean).join("-");
+    }
+    return filename;
+  }
+  return filename;
+}
+function resolveAlias(filepath, alias) {
+  const result = filepath;
+  if (Array.isArray(alias)) {
+    for (const { find, replacement } of alias)
+      result.replace(find, replacement);
+  }
+  return result;
+}
+async function getPkgVersion(pkgName, defaultVersion) {
+  var _a;
+  try {
+    const isExist = isPackageExists(pkgName);
+    if (isExist) {
+      const pkg = await getPackageInfo(pkgName);
+      return (_a = pkg == null ? void 0 : pkg.version) != null ? _a : defaultVersion;
+    } else {
+      return defaultVersion;
+    }
+  } catch (err) {
+    console.error(err);
+    return defaultVersion;
+  }
+}
+function shouldTransform(code) {
+  if (code.includes(DISABLE_COMMENT))
+    return false;
+  return true;
+}
+function resolveImportPath(importName) {
+  return resolve.sync(importName, {
+    preserveSymlinks: false
+  });
+}
+
+export {
+  DISABLE_COMMENT,
+  DIRECTIVE_IMPORT_PREFIX,
+  isSSR,
+  pascalCase,
+  camelCase,
+  kebabCase,
+  parseId,
+  matchGlobs,
+  getTransformedPath,
+  normalizeComponetInfo,
+  stringifyComponentImport,
+  getNameFromFilePath,
+  resolveAlias,
+  getPkgVersion,
+  shouldTransform,
+  resolveImportPath
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/chunk-BTQOTIPQ.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+
+
+
+
+exports.__spreadValues = __spreadValues; exports.__spreadProps = __spreadProps; exports.__require = __require;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/chunk-HCIFGIWS.js

@@ -0,0 +1,195 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/core/utils.ts
+var _path = require('path');
+var _minimatch = require('minimatch'); var _minimatch2 = _interopRequireDefault(_minimatch);
+var _resolve = require('resolve'); var _resolve2 = _interopRequireDefault(_resolve);
+var _utils = require('@antfu/utils');
+
+
+
+var _localpkg = require('local-pkg');
+
+// src/core/constants.ts
+var DISABLE_COMMENT = "/* unplugin-vue-components disabled */";
+var DIRECTIVE_IMPORT_PREFIX = "v";
+
+// src/core/utils.ts
+var isSSR = Boolean(process.env.SSR || process.env.SSG || process.env.VITE_SSR || process.env.VITE_SSG);
+function pascalCase(str) {
+  return capitalize(camelCase(str));
+}
+function camelCase(str) {
+  return str.replace(/-(\w)/g, (_, c) => c ? c.toUpperCase() : "");
+}
+function kebabCase(key) {
+  const result = key.replace(/([A-Z])/g, " $1").trim();
+  return result.split(" ").join("-").toLowerCase();
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function parseId(id) {
+  const index = id.indexOf("?");
+  if (index < 0) {
+    return { path: id, query: {} };
+  } else {
+    const query = Object.fromEntries(new URLSearchParams(id.slice(index)));
+    return {
+      path: id.slice(0, index),
+      query
+    };
+  }
+}
+function isEmpty(value) {
+  if (!value || value === null || value === void 0 || Array.isArray(value) && Object.keys(value).length <= 0)
+    return true;
+  else
+    return false;
+}
+function matchGlobs(filepath, globs) {
+  for (const glob of globs) {
+    if (_minimatch2.default.call(void 0, _utils.slash.call(void 0, filepath), glob))
+      return true;
+  }
+  return false;
+}
+function getTransformedPath(path, importPathTransform) {
+  if (importPathTransform) {
+    const result = importPathTransform(path);
+    if (result != null)
+      path = result;
+  }
+  return path;
+}
+function stringifyImport(info) {
+  if (typeof info === "string")
+    return `import '${info}'`;
+  if (!info.as)
+    return `import '${info.from}'`;
+  else if (info.name)
+    return `import { ${info.name} as ${info.as} } from '${info.from}'`;
+  else
+    return `import ${info.as} from '${info.from}'`;
+}
+function normalizeComponetInfo(info) {
+  if ("path" in info) {
+    return {
+      from: info.path,
+      as: info.name,
+      name: info.importName,
+      sideEffects: info.sideEffects
+    };
+  }
+  return info;
+}
+function stringifyComponentImport({ as: name, from: path, name: importName, sideEffects }, ctx) {
+  path = getTransformedPath(path, ctx.options.importPathTransform);
+  const imports = [
+    stringifyImport({ as: name, from: path, name: importName })
+  ];
+  if (sideEffects)
+    _utils.toArray.call(void 0, sideEffects).forEach((i) => imports.push(stringifyImport(i)));
+  return imports.join(";");
+}
+function getNameFromFilePath(filePath, options) {
+  const { resolvedDirs, directoryAsNamespace, globalNamespaces, collapseSamePrefixes, root } = options;
+  const parsedFilePath = _path.parse.call(void 0, _utils.slash.call(void 0, filePath));
+  let strippedPath = "";
+  for (const dir of resolvedDirs) {
+    if (parsedFilePath.dir.startsWith(dir)) {
+      strippedPath = parsedFilePath.dir.slice(dir.length);
+      break;
+    }
+  }
+  let folders = strippedPath.slice(1).split("/").filter(Boolean);
+  let filename = parsedFilePath.name;
+  if (filename === "index" && !directoryAsNamespace) {
+    if (isEmpty(folders))
+      folders = parsedFilePath.dir.slice(root.length + 1).split("/").filter(Boolean);
+    filename = `${folders.slice(-1)[0]}`;
+    return filename;
+  }
+  if (directoryAsNamespace) {
+    if (globalNamespaces.some((name) => folders.includes(name)))
+      folders = folders.filter((f) => !globalNamespaces.includes(f));
+    folders = folders.map((f) => f.replace(/[^a-zA-Z0-9\-]/g, ""));
+    if (filename.toLowerCase() === "index")
+      filename = "";
+    if (!isEmpty(folders)) {
+      let namespaced = [...folders, filename];
+      if (collapseSamePrefixes) {
+        const collapsed = [];
+        for (const fileOrFolderName of namespaced) {
+          let cumulativePrefix = "";
+          let didCollapse = false;
+          for (const parentFolder of [...collapsed].reverse()) {
+            cumulativePrefix = `${capitalize(parentFolder)}${cumulativePrefix}`;
+            if (pascalCase(fileOrFolderName).startsWith(pascalCase(cumulativePrefix))) {
+              const collapseSamePrefix = fileOrFolderName.slice(cumulativePrefix.length);
+              collapsed.push(collapseSamePrefix);
+              didCollapse = true;
+              break;
+            }
+          }
+          if (!didCollapse)
+            collapsed.push(fileOrFolderName);
+        }
+        namespaced = collapsed;
+      }
+      filename = namespaced.filter(Boolean).join("-");
+    }
+    return filename;
+  }
+  return filename;
+}
+function resolveAlias(filepath, alias) {
+  const result = filepath;
+  if (Array.isArray(alias)) {
+    for (const { find, replacement } of alias)
+      result.replace(find, replacement);
+  }
+  return result;
+}
+async function getPkgVersion(pkgName, defaultVersion) {
+  var _a;
+  try {
+    const isExist = _localpkg.isPackageExists.call(void 0, pkgName);
+    if (isExist) {
+      const pkg = await _localpkg.getPackageInfo.call(void 0, pkgName);
+      return (_a = pkg == null ? void 0 : pkg.version) != null ? _a : defaultVersion;
+    } else {
+      return defaultVersion;
+    }
+  } catch (err) {
+    console.error(err);
+    return defaultVersion;
+  }
+}
+function shouldTransform(code) {
+  if (code.includes(DISABLE_COMMENT))
+    return false;
+  return true;
+}
+function resolveImportPath(importName) {
+  return _resolve2.default.sync(importName, {
+    preserveSymlinks: false
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DISABLE_COMMENT = DISABLE_COMMENT; exports.DIRECTIVE_IMPORT_PREFIX = DIRECTIVE_IMPORT_PREFIX; exports.isSSR = isSSR; exports.pascalCase = pascalCase; exports.camelCase = camelCase; exports.kebabCase = kebabCase; exports.parseId = parseId; exports.matchGlobs = matchGlobs; exports.getTransformedPath = getTransformedPath; exports.normalizeComponetInfo = normalizeComponetInfo; exports.stringifyComponentImport = stringifyComponentImport; exports.getNameFromFilePath = getNameFromFilePath; exports.resolveAlias = resolveAlias; exports.getPkgVersion = getPkgVersion; exports.shouldTransform = shouldTransform; exports.resolveImportPath = resolveImportPath;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/chunk-WVTE3GCL.mjs

@@ -0,0 +1,751 @@
+import {
+  DIRECTIVE_IMPORT_PREFIX,
+  DISABLE_COMMENT,
+  getNameFromFilePath,
+  getTransformedPath,
+  matchGlobs,
+  normalizeComponetInfo,
+  parseId,
+  pascalCase,
+  resolveAlias,
+  shouldTransform,
+  stringifyComponentImport
+} from "./chunk-BPHJA2FM.mjs";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-ZKNUHGJ4.mjs";
+
+// src/core/unplugin.ts
+import { existsSync as existsSync2 } from "fs";
+import { createUnplugin } from "unplugin";
+import { createFilter } from "@rollup/pluginutils";
+import chokidar from "chokidar";
+
+// src/core/context.ts
+import { relative as relative2 } from "path";
+import Debug5 from "debug";
+import { slash as slash3, throttle, toArray as toArray2 } from "@antfu/utils";
+
+// src/core/options.ts
+import { join, resolve } from "path";
+import { slash, toArray } from "@antfu/utils";
+import { getPackageInfoSync, isPackageExists as isPackageExists2 } from "local-pkg";
+
+// src/core/type-imports/detect.ts
+import { isPackageExists } from "local-pkg";
+import { notNullish } from "@antfu/utils";
+
+// src/core/type-imports/index.ts
+var TypeImportPresets = [
+  {
+    from: "vue-router",
+    names: [
+      "RouterView",
+      "RouterLink"
+    ]
+  },
+  {
+    from: "vue-starport",
+    names: [
+      "Starport",
+      "StarportCarrier"
+    ]
+  }
+];
+
+// src/core/type-imports/detect.ts
+function detectTypeImports() {
+  return TypeImportPresets.map((i) => isPackageExists(i.from) ? i : void 0).filter(notNullish);
+}
+function resolveTypeImports(imports) {
+  return imports.flatMap((i) => i.names.map((n) => ({ from: i.from, name: n, as: n })));
+}
+
+// src/core/options.ts
+var defaultOptions = {
+  dirs: "src/components",
+  extensions: "vue",
+  deep: true,
+  dts: isPackageExists2("typescript"),
+  directoryAsNamespace: false,
+  collapseSamePrefixes: false,
+  globalNamespaces: [],
+  resolvers: [],
+  importPathTransform: (v) => v,
+  allowOverrides: false
+};
+function normalizeResolvers(resolvers) {
+  return toArray(resolvers).flat().map((r) => typeof r === "function" ? { resolve: r, type: "component" } : r);
+}
+function resolveOptions(options, root) {
+  var _a;
+  const resolved = Object.assign({}, defaultOptions, options);
+  resolved.resolvers = normalizeResolvers(resolved.resolvers);
+  resolved.extensions = toArray(resolved.extensions);
+  if (resolved.globs) {
+    resolved.globs = toArray(resolved.globs).map((glob) => slash(resolve(root, glob)));
+    resolved.resolvedDirs = [];
+  } else {
+    const extsGlob = resolved.extensions.length === 1 ? resolved.extensions : `{${resolved.extensions.join(",")}}`;
+    resolved.dirs = toArray(resolved.dirs);
+    resolved.resolvedDirs = resolved.dirs.map((i) => slash(resolve(root, i)));
+    resolved.globs = resolved.resolvedDirs.map(
+      (i) => resolved.deep ? slash(join(i, `**/*.${extsGlob}`)) : slash(join(i, `*.${extsGlob}`))
+    );
+    if (!resolved.extensions.length)
+      throw new Error("[unplugin-vue-components] `extensions` option is required to search for components");
+  }
+  resolved.dts = !resolved.dts ? false : resolve(
+    root,
+    typeof resolved.dts === "string" ? resolved.dts : "components.d.ts"
+  );
+  if (!resolved.types && resolved.dts)
+    resolved.types = detectTypeImports();
+  resolved.types = resolved.types || [];
+  resolved.root = root;
+  resolved.version = (_a = resolved.version) != null ? _a : getVueVersion(root);
+  if (resolved.version < 2 || resolved.version >= 4)
+    throw new Error(`[unplugin-vue-components] unsupported version: ${resolved.version}`);
+  resolved.transformer = options.transformer || `vue${Math.trunc(resolved.version)}`;
+  resolved.directives = typeof options.directives === "boolean" ? options.directives : !resolved.resolvers.some((i) => i.type === "directive") ? false : resolved.version >= 3;
+  return resolved;
+}
+function getVueVersion(root) {
+  var _a;
+  const raw = ((_a = getPackageInfoSync("vue", { paths: [root] })) == null ? void 0 : _a.version) || "3";
+  const version = +raw.split(".").slice(0, 2).join(".");
+  if (version === 2.7)
+    return 2.7;
+  else if (version < 2.7)
+    return 2;
+  return 3;
+}
+
+// src/core/fs/glob.ts
+import fg from "fast-glob";
+import Debug from "debug";
+var debug = Debug("unplugin-vue-components:glob");
+function searchComponents(ctx) {
+  var _a;
+  debug(`started with: [${ctx.options.globs.join(", ")}]`);
+  const root = ctx.root;
+  const files = fg.sync(ctx.options.globs, {
+    ignore: ["node_modules"],
+    onlyFiles: true,
+    cwd: root,
+    absolute: true
+  });
+  if (!files.length && !((_a = ctx.options.resolvers) == null ? void 0 : _a.length))
+    console.warn("[unplugin-vue-components] no components found");
+  debug(`${files.length} components found.`);
+  ctx.addComponents(files);
+}
+
+// src/core/declaration.ts
+import { dirname, isAbsolute, relative } from "path";
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile as writeFile_ } from "fs/promises";
+import { notNullish as notNullish2, slash as slash2 } from "@antfu/utils";
+var multilineCommentsRE = new RegExp("\\/\\*.*?\\*\\/", "gms");
+var singlelineCommentsRE = /\/\/.*$/gm;
+function extractImports(code) {
+  return Object.fromEntries(Array.from(code.matchAll(/['"]?([^\s'"]+)['"]?\s*:\s*(.+?)[,;\n]/g)).map((i) => [i[1], i[2]]));
+}
+function parseDeclaration(code) {
+  var _a, _b;
+  if (!code)
+    return;
+  code = code.replace(multilineCommentsRE, "").replace(singlelineCommentsRE, "");
+  const imports = {
+    component: {},
+    directive: {}
+  };
+  const componentDeclaration = (_a = new RegExp("export\\s+interface\\s+GlobalComponents\\s*{(.*?)}", "s").exec(code)) == null ? void 0 : _a[0];
+  if (componentDeclaration)
+    imports.component = extractImports(componentDeclaration);
+  const directiveDeclaration = (_b = new RegExp("export\\s+interface\\s+ComponentCustomProperties\\s*{(.*?)}", "s").exec(code)) == null ? void 0 : _b[0];
+  if (directiveDeclaration)
+    imports.directive = extractImports(directiveDeclaration);
+  return imports;
+}
+function stringifyComponentInfo(filepath, { from: path, as: name, name: importName }, importPathTransform) {
+  if (!name)
+    return void 0;
+  path = getTransformedPath(path, importPathTransform);
+  const related = isAbsolute(path) ? `./${relative(dirname(filepath), path)}` : path;
+  const entry = `typeof import('${slash2(related)}')['${importName || "default"}']`;
+  return [name, entry];
+}
+function stringifyComponentsInfo(filepath, components, importPathTransform) {
+  return Object.fromEntries(
+    components.map((info) => stringifyComponentInfo(filepath, info, importPathTransform)).filter(notNullish2)
+  );
+}
+function getDeclarationImports(ctx, filepath) {
+  const component = stringifyComponentsInfo(filepath, [
+    ...Object.values(__spreadValues(__spreadValues({}, ctx.componentNameMap), ctx.componentCustomMap)),
+    ...resolveTypeImports(ctx.options.types)
+  ], ctx.options.importPathTransform);
+  const directive = stringifyComponentsInfo(
+    filepath,
+    Object.values(ctx.directiveCustomMap),
+    ctx.options.importPathTransform
+  );
+  if (Object.keys(component).length + Object.keys(directive).length === 0)
+    return;
+  return { component, directive };
+}
+function stringifyDeclarationImports(imports) {
+  return Object.entries(imports).sort(([a], [b]) => a.localeCompare(b)).map(([name, v]) => {
+    if (!/^\w+$/.test(name))
+      name = `'${name}'`;
+    return `${name}: ${v}`;
+  });
+}
+function getDeclaration(ctx, filepath, originalImports) {
+  const imports = getDeclarationImports(ctx, filepath);
+  if (!imports)
+    return;
+  const declarations = {
+    component: stringifyDeclarationImports(__spreadValues(__spreadValues({}, originalImports == null ? void 0 : originalImports.component), imports.component)),
+    directive: stringifyDeclarationImports(__spreadValues(__spreadValues({}, originalImports == null ? void 0 : originalImports.directive), imports.directive))
+  };
+  const head = ctx.options.version === 2.7 ? `export {}
+
+declare module 'vue' {` : `import '@vue/runtime-core'
+
+export {}
+
+declare module '@vue/runtime-core' {`;
+  let code = `/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// Generated by unplugin-vue-components
+// Read more: https://github.com/vuejs/core/pull/3399
+${head}`;
+  if (Object.keys(declarations.component).length > 0) {
+    code += `
+  export interface GlobalComponents {
+    ${declarations.component.join("\n    ")}
+  }`;
+  }
+  if (Object.keys(declarations.directive).length > 0) {
+    code += `
+  export interface ComponentCustomProperties {
+    ${declarations.directive.join("\n    ")}
+  }`;
+  }
+  code += "\n}\n";
+  return code;
+}
+async function writeFile(filePath, content) {
+  await mkdir(dirname(filePath), { recursive: true });
+  return await writeFile_(filePath, content, "utf-8");
+}
+async function writeDeclaration(ctx, filepath, removeUnused = false) {
+  const originalContent = existsSync(filepath) ? await readFile(filepath, "utf-8") : "";
+  const originalImports = removeUnused ? void 0 : parseDeclaration(originalContent);
+  const code = getDeclaration(ctx, filepath, originalImports);
+  if (!code)
+    return;
+  if (code !== originalContent)
+    await writeFile(filepath, code);
+}
+
+// src/core/transformer.ts
+import Debug4 from "debug";
+import MagicString from "magic-string";
+
+// src/core/transforms/component.ts
+import Debug2 from "debug";
+var debug2 = Debug2("unplugin-vue-components:transform:component");
+var resolveVue2 = (code, s) => {
+  const results = [];
+  for (const match of code.matchAll(/\b(_c|h)\([\s\n\t]*['"](.+?)["']([,)])/g)) {
+    const [full, renderFunctionName, matchedName, append] = match;
+    if (match.index != null && matchedName && !matchedName.startsWith("_")) {
+      const start = match.index;
+      const end = start + full.length;
+      results.push({
+        rawName: matchedName,
+        replace: (resolved) => s.overwrite(start, end, `${renderFunctionName}(${resolved}${append}`)
+      });
+    }
+  }
+  return results;
+};
+var resolveVue3 = (code, s) => {
+  const results = [];
+  for (const match of code.matchAll(/_resolveComponent[0-9]*\("(.+?)"\)/g)) {
+    const matchedName = match[1];
+    if (match.index != null && matchedName && !matchedName.startsWith("_")) {
+      const start = match.index;
+      const end = start + match[0].length;
+      results.push({
+        rawName: matchedName,
+        replace: (resolved) => s.overwrite(start, end, resolved)
+      });
+    }
+  }
+  return results;
+};
+async function transformComponent(code, transformer2, s, ctx, sfcPath) {
+  let no = 0;
+  const results = transformer2 === "vue2" ? resolveVue2(code, s) : resolveVue3(code, s);
+  for (const { rawName, replace } of results) {
+    debug2(`| ${rawName}`);
+    const name = pascalCase(rawName);
+    ctx.updateUsageMap(sfcPath, [name]);
+    const component = await ctx.findComponent(name, "component", [sfcPath]);
+    if (component) {
+      const varName = `__unplugin_components_${no}`;
+      s.prepend(`${stringifyComponentImport(__spreadProps(__spreadValues({}, component), { as: varName }), ctx)};
+`);
+      no += 1;
+      replace(varName);
+    }
+  }
+  debug2(`^ (${no})`);
+}
+
+// src/core/transforms/directive/index.ts
+import Debug3 from "debug";
+
+// src/core/transforms/directive/vue2.ts
+import { importModule, isPackageExists as isPackageExists3 } from "local-pkg";
+var getRenderFnStart = (program) => {
+  var _a, _b;
+  const renderFn = program.body.find(
+    (node) => node.type === "VariableDeclaration" && node.declarations[0].id.type === "Identifier" && ["render", "_sfc_render"].includes(node.declarations[0].id.name)
+  );
+  const start = (_b = (_a = renderFn == null ? void 0 : renderFn.declarations[0].init) == null ? void 0 : _a.body) == null ? void 0 : _b.start;
+  if (start === null || start === void 0)
+    throw new Error("[unplugin-vue-components:directive] Cannot find render function position.");
+  return start + 1;
+};
+async function resolveVue22(code, s) {
+  var _a, _b, _c;
+  if (!isPackageExists3("@babel/parser"))
+    throw new Error('[unplugin-vue-components:directive] To use Vue 2 directive you will need to install Babel first: "npm install -D @babel/parser"');
+  const { parse } = await importModule("@babel/parser");
+  const { program } = parse(code, {
+    sourceType: "module"
+  });
+  const nodes = [];
+  const { walk } = await import("./src-EJAVKJEF.mjs");
+  walk(program, {
+    enter(node) {
+      if (node.type === "CallExpression")
+        nodes.push(node);
+    }
+  });
+  if (nodes.length === 0)
+    return [];
+  let _renderStart;
+  const getRenderStart = () => {
+    if (_renderStart !== void 0)
+      return _renderStart;
+    return _renderStart = getRenderFnStart(program);
+  };
+  const results = [];
+  for (const node of nodes) {
+    const { callee, arguments: args } = node;
+    if (callee.type !== "Identifier" || callee.name !== "_c" || ((_a = args[1]) == null ? void 0 : _a.type) !== "ObjectExpression")
+      continue;
+    const directives = (_b = args[1].properties.find(
+      (property) => property.type === "ObjectProperty" && property.key.type === "Identifier" && property.key.name === "directives"
+    )) == null ? void 0 : _b.value;
+    if (!directives || directives.type !== "ArrayExpression")
+      continue;
+    for (const directive of directives.elements) {
+      if ((directive == null ? void 0 : directive.type) !== "ObjectExpression")
+        continue;
+      const nameNode = (_c = directive.properties.find(
+        (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "name"
+      )) == null ? void 0 : _c.value;
+      if ((nameNode == null ? void 0 : nameNode.type) !== "StringLiteral")
+        continue;
+      const name = nameNode.value;
+      if (!name || name.startsWith("_"))
+        continue;
+      results.push({
+        rawName: name,
+        replace: (resolved) => {
+          s.prependLeft(getRenderStart(), `
+this.$options.directives["${name}"] = ${resolved};`);
+        }
+      });
+    }
+  }
+  return results;
+}
+
+// src/core/transforms/directive/vue3.ts
+function resolveVue32(code, s) {
+  const results = [];
+  for (const match of code.matchAll(/_resolveDirective\("(.+?)"\)/g)) {
+    const matchedName = match[1];
+    if (match.index != null && matchedName && !matchedName.startsWith("_")) {
+      const start = match.index;
+      const end = start + match[0].length;
+      results.push({
+        rawName: matchedName,
+        replace: (resolved) => s.overwrite(start, end, resolved)
+      });
+    }
+  }
+  return results;
+}
+
+// src/core/transforms/directive/index.ts
+var debug3 = Debug3("unplugin-vue-components:transform:directive");
+async function transformDirective(code, transformer2, s, ctx, sfcPath) {
+  let no = 0;
+  const results = await (transformer2 === "vue2" ? resolveVue22(code, s) : resolveVue32(code, s));
+  for (const { rawName, replace } of results) {
+    debug3(`| ${rawName}`);
+    const name = `${DIRECTIVE_IMPORT_PREFIX}${pascalCase(rawName)}`;
+    ctx.updateUsageMap(sfcPath, [name]);
+    const directive = await ctx.findComponent(name, "directive", [sfcPath]);
+    if (!directive)
+      continue;
+    const varName = `__unplugin_directives_${no}`;
+    s.prepend(`${stringifyComponentImport(__spreadProps(__spreadValues({}, directive), { as: varName }), ctx)};
+`);
+    no += 1;
+    replace(varName);
+  }
+  debug3(`^ (${no})`);
+}
+
+// src/core/transformer.ts
+var debug4 = Debug4("unplugin-vue-components:transformer");
+function transformer(ctx, transformer2) {
+  return async (code, id, path) => {
+    ctx.searchGlob();
+    const sfcPath = ctx.normalizePath(path);
+    debug4(sfcPath);
+    const s = new MagicString(code);
+    await transformComponent(code, transformer2, s, ctx, sfcPath);
+    if (ctx.options.directives)
+      await transformDirective(code, transformer2, s, ctx, sfcPath);
+    s.prepend(DISABLE_COMMENT);
+    const result = { code: s.toString() };
+    if (ctx.sourcemap)
+      result.map = s.generateMap({ source: id, includeContent: true });
+    return result;
+  };
+}
+
+// src/core/context.ts
+var debug5 = {
+  components: Debug5("unplugin-vue-components:context:components"),
+  search: Debug5("unplugin-vue-components:context:search"),
+  hmr: Debug5("unplugin-vue-components:context:hmr"),
+  decleration: Debug5("unplugin-vue-components:decleration"),
+  env: Debug5("unplugin-vue-components:env")
+};
+var Context = class {
+  constructor(rawOptions) {
+    this.rawOptions = rawOptions;
+    this.transformer = void 0;
+    this._componentPaths = /* @__PURE__ */ new Set();
+    this._componentNameMap = {};
+    this._componentUsageMap = {};
+    this._componentCustomMap = {};
+    this._directiveCustomMap = {};
+    this.root = process.cwd();
+    this.sourcemap = true;
+    this.alias = {};
+    this._searched = false;
+    this.options = resolveOptions(rawOptions, this.root);
+    this.generateDeclaration = throttle(500, this._generateDeclaration.bind(this), { noLeading: false });
+    this.setTransformer(this.options.transformer);
+  }
+  setRoot(root) {
+    if (this.root === root)
+      return;
+    debug5.env("root", root);
+    this.root = root;
+    this.options = resolveOptions(this.rawOptions, this.root);
+  }
+  setTransformer(name) {
+    debug5.env("transformer", name);
+    this.transformer = transformer(this, name || "vue3");
+  }
+  transform(code, id) {
+    const { path, query } = parseId(id);
+    return this.transformer(code, id, path, query);
+  }
+  setupViteServer(server) {
+    if (this._server === server)
+      return;
+    this._server = server;
+    this.setupWatcher(server.watcher);
+  }
+  setupWatcher(watcher) {
+    const { globs } = this.options;
+    watcher.on("unlink", (path) => {
+      if (!matchGlobs(path, globs))
+        return;
+      path = slash3(path);
+      this.removeComponents(path);
+      this.onUpdate(path);
+    });
+    watcher.on("add", (path) => {
+      if (!matchGlobs(path, globs))
+        return;
+      path = slash3(path);
+      this.addComponents(path);
+      this.onUpdate(path);
+    });
+  }
+  /**
+   * start watcher for webpack
+   */
+  setupWatcherWebpack(watcher, emitUpdate) {
+    const { globs } = this.options;
+    watcher.on("unlink", (path) => {
+      if (!matchGlobs(path, globs))
+        return;
+      path = slash3(path);
+      this.removeComponents(path);
+      emitUpdate(path, "unlink");
+    });
+    watcher.on("add", (path) => {
+      if (!matchGlobs(path, globs))
+        return;
+      path = slash3(path);
+      this.addComponents(path);
+      emitUpdate(path, "add");
+    });
+  }
+  /**
+   * Record the usage of components
+   * @param path
+   * @param paths paths of used components
+   */
+  updateUsageMap(path, paths) {
+    if (!this._componentUsageMap[path])
+      this._componentUsageMap[path] = /* @__PURE__ */ new Set();
+    paths.forEach((p) => {
+      this._componentUsageMap[path].add(p);
+    });
+  }
+  addComponents(paths) {
+    debug5.components("add", paths);
+    const size = this._componentPaths.size;
+    toArray2(paths).forEach((p) => this._componentPaths.add(p));
+    if (this._componentPaths.size !== size) {
+      this.updateComponentNameMap();
+      return true;
+    }
+    return false;
+  }
+  addCustomComponents(info) {
+    if (info.as)
+      this._componentCustomMap[info.as] = info;
+  }
+  addCustomDirectives(info) {
+    if (info.as)
+      this._directiveCustomMap[info.as] = info;
+  }
+  removeComponents(paths) {
+    debug5.components("remove", paths);
+    const size = this._componentPaths.size;
+    toArray2(paths).forEach((p) => this._componentPaths.delete(p));
+    if (this._componentPaths.size !== size) {
+      this.updateComponentNameMap();
+      return true;
+    }
+    return false;
+  }
+  onUpdate(path) {
+    this.generateDeclaration();
+    if (!this._server)
+      return;
+    const payload = {
+      type: "update",
+      updates: []
+    };
+    const timestamp = +/* @__PURE__ */ new Date();
+    const name = pascalCase(getNameFromFilePath(path, this.options));
+    Object.entries(this._componentUsageMap).forEach(([key, values]) => {
+      if (values.has(name)) {
+        const r = `/${slash3(relative2(this.root, key))}`;
+        payload.updates.push({
+          acceptedPath: r,
+          path: r,
+          timestamp,
+          type: "js-update"
+        });
+      }
+    });
+    if (payload.updates.length)
+      this._server.ws.send(payload);
+  }
+  updateComponentNameMap() {
+    this._componentNameMap = {};
+    Array.from(this._componentPaths).forEach((path) => {
+      const name = pascalCase(getNameFromFilePath(path, this.options));
+      if (this._componentNameMap[name] && !this.options.allowOverrides) {
+        console.warn(`[unplugin-vue-components] component "${name}"(${path}) has naming conflicts with other components, ignored.`);
+        return;
+      }
+      this._componentNameMap[name] = {
+        as: name,
+        from: path
+      };
+    });
+  }
+  async findComponent(name, type, excludePaths = []) {
+    let info = this._componentNameMap[name];
+    if (info && !excludePaths.includes(info.from) && !excludePaths.includes(info.from.slice(1)))
+      return info;
+    for (const resolver of this.options.resolvers) {
+      if (resolver.type !== type)
+        continue;
+      const result = await resolver.resolve(type === "directive" ? name.slice(DIRECTIVE_IMPORT_PREFIX.length) : name);
+      if (!result)
+        continue;
+      if (typeof result === "string") {
+        info = {
+          as: name,
+          from: result
+        };
+      } else {
+        info = __spreadValues({
+          as: name
+        }, normalizeComponetInfo(result));
+      }
+      if (type === "component")
+        this.addCustomComponents(info);
+      else if (type === "directive")
+        this.addCustomDirectives(info);
+      return info;
+    }
+    return void 0;
+  }
+  normalizePath(path) {
+    var _a, _b, _c;
+    return resolveAlias(path, ((_b = (_a = this.viteConfig) == null ? void 0 : _a.resolve) == null ? void 0 : _b.alias) || ((_c = this.viteConfig) == null ? void 0 : _c.alias) || []);
+  }
+  relative(path) {
+    if (path.startsWith("/") && !path.startsWith(this.root))
+      return slash3(path.slice(1));
+    return slash3(relative2(this.root, path));
+  }
+  /**
+   * This search for components in with the given options.
+   * Will be called multiple times to ensure file loaded,
+   * should normally run only once.
+   */
+  searchGlob() {
+    if (this._searched)
+      return;
+    searchComponents(this);
+    debug5.search(this._componentNameMap);
+    this._searched = true;
+  }
+  _generateDeclaration(removeUnused = !this._server) {
+    if (!this.options.dts)
+      return;
+    debug5.decleration("generating");
+    return writeDeclaration(this, this.options.dts, removeUnused);
+  }
+  get componentNameMap() {
+    return this._componentNameMap;
+  }
+  get componentCustomMap() {
+    return this._componentCustomMap;
+  }
+  get directiveCustomMap() {
+    return this._directiveCustomMap;
+  }
+};
+
+// src/core/unplugin.ts
+var PLUGIN_NAME = "unplugin:webpack";
+var unplugin_default = createUnplugin((options = {}) => {
+  const filter = createFilter(
+    options.include || [/\.vue$/, /\.vue\?vue/, /\.vue\?v=/],
+    options.exclude || [/[\\/]node_modules[\\/]/, /[\\/]\.git[\\/]/, /[\\/]\.nuxt[\\/]/]
+  );
+  const ctx = new Context(options);
+  const api = {
+    async findComponent(name, filename) {
+      return await ctx.findComponent(name, "component", filename ? [filename] : []);
+    },
+    stringifyImport(info) {
+      return stringifyComponentImport(info, ctx);
+    }
+  };
+  return {
+    name: "unplugin-vue-components",
+    enforce: "post",
+    api,
+    transformInclude(id) {
+      return filter(id);
+    },
+    async transform(code, id) {
+      if (!shouldTransform(code))
+        return null;
+      try {
+        const result = await ctx.transform(code, id);
+        ctx.generateDeclaration();
+        return result;
+      } catch (e) {
+        this.error(e);
+      }
+    },
+    vite: {
+      configResolved(config) {
+        ctx.setRoot(config.root);
+        ctx.sourcemap = true;
+        if (config.plugins.find((i) => i.name === "vite-plugin-vue2"))
+          ctx.setTransformer("vue2");
+        if (ctx.options.dts) {
+          ctx.searchGlob();
+          if (!existsSync2(ctx.options.dts))
+            ctx.generateDeclaration();
+        }
+        if (config.build.watch && config.command === "build")
+          ctx.setupWatcher(chokidar.watch(ctx.options.globs));
+      },
+      configureServer(server) {
+        ctx.setupViteServer(server);
+      }
+    },
+    webpack(compiler) {
+      let watcher;
+      let fileDepQueue = [];
+      compiler.hooks.watchRun.tap(PLUGIN_NAME, () => {
+        if (!watcher && compiler.watching) {
+          watcher = compiler.watching;
+          ctx.setupWatcherWebpack(chokidar.watch(ctx.options.globs), (path, type) => {
+            fileDepQueue.push({ path, type });
+            process.nextTick(() => {
+              watcher.invalidate();
+            });
+          });
+        }
+      });
+      compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+        if (fileDepQueue.length) {
+          fileDepQueue.forEach(({ path, type }) => {
+            if (type === "unlink")
+              compilation.fileDependencies.delete(path);
+            else
+              compilation.fileDependencies.add(path);
+          });
+          fileDepQueue = [];
+        }
+      });
+    }
+  };
+});
+
+export {
+  unplugin_default
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/chunk-Z3TQFCNG.js

@@ -0,0 +1,751 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+
+
+
+
+
+
+
+
+
+var _chunkHCIFGIWSjs = require('./chunk-HCIFGIWS.js');
+
+
+
+var _chunkBTQOTIPQjs = require('./chunk-BTQOTIPQ.js');
+
+// src/core/unplugin.ts
+var _fs = require('fs');
+var _unplugin = require('unplugin');
+var _pluginutils = require('@rollup/pluginutils');
+var _chokidar = require('chokidar'); var _chokidar2 = _interopRequireDefault(_chokidar);
+
+// src/core/context.ts
+var _path = require('path');
+var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
+var _utils = require('@antfu/utils');
+
+// src/core/options.ts
+
+
+var _localpkg = require('local-pkg');
+
+// src/core/type-imports/detect.ts
+
+
+
+// src/core/type-imports/index.ts
+var TypeImportPresets = [
+  {
+    from: "vue-router",
+    names: [
+      "RouterView",
+      "RouterLink"
+    ]
+  },
+  {
+    from: "vue-starport",
+    names: [
+      "Starport",
+      "StarportCarrier"
+    ]
+  }
+];
+
+// src/core/type-imports/detect.ts
+function detectTypeImports() {
+  return TypeImportPresets.map((i) => _localpkg.isPackageExists.call(void 0, i.from) ? i : void 0).filter(_utils.notNullish);
+}
+function resolveTypeImports(imports) {
+  return imports.flatMap((i) => i.names.map((n) => ({ from: i.from, name: n, as: n })));
+}
+
+// src/core/options.ts
+var defaultOptions = {
+  dirs: "src/components",
+  extensions: "vue",
+  deep: true,
+  dts: _localpkg.isPackageExists.call(void 0, "typescript"),
+  directoryAsNamespace: false,
+  collapseSamePrefixes: false,
+  globalNamespaces: [],
+  resolvers: [],
+  importPathTransform: (v) => v,
+  allowOverrides: false
+};
+function normalizeResolvers(resolvers) {
+  return _utils.toArray.call(void 0, resolvers).flat().map((r) => typeof r === "function" ? { resolve: r, type: "component" } : r);
+}
+function resolveOptions(options, root) {
+  var _a;
+  const resolved = Object.assign({}, defaultOptions, options);
+  resolved.resolvers = normalizeResolvers(resolved.resolvers);
+  resolved.extensions = _utils.toArray.call(void 0, resolved.extensions);
+  if (resolved.globs) {
+    resolved.globs = _utils.toArray.call(void 0, resolved.globs).map((glob) => _utils.slash.call(void 0, _path.resolve.call(void 0, root, glob)));
+    resolved.resolvedDirs = [];
+  } else {
+    const extsGlob = resolved.extensions.length === 1 ? resolved.extensions : `{${resolved.extensions.join(",")}}`;
+    resolved.dirs = _utils.toArray.call(void 0, resolved.dirs);
+    resolved.resolvedDirs = resolved.dirs.map((i) => _utils.slash.call(void 0, _path.resolve.call(void 0, root, i)));
+    resolved.globs = resolved.resolvedDirs.map(
+      (i) => resolved.deep ? _utils.slash.call(void 0, _path.join.call(void 0, i, `**/*.${extsGlob}`)) : _utils.slash.call(void 0, _path.join.call(void 0, i, `*.${extsGlob}`))
+    );
+    if (!resolved.extensions.length)
+      throw new Error("[unplugin-vue-components] `extensions` option is required to search for components");
+  }
+  resolved.dts = !resolved.dts ? false : _path.resolve.call(void 0, 
+    root,
+    typeof resolved.dts === "string" ? resolved.dts : "components.d.ts"
+  );
+  if (!resolved.types && resolved.dts)
+    resolved.types = detectTypeImports();
+  resolved.types = resolved.types || [];
+  resolved.root = root;
+  resolved.version = (_a = resolved.version) != null ? _a : getVueVersion(root);
+  if (resolved.version < 2 || resolved.version >= 4)
+    throw new Error(`[unplugin-vue-components] unsupported version: ${resolved.version}`);
+  resolved.transformer = options.transformer || `vue${Math.trunc(resolved.version)}`;
+  resolved.directives = typeof options.directives === "boolean" ? options.directives : !resolved.resolvers.some((i) => i.type === "directive") ? false : resolved.version >= 3;
+  return resolved;
+}
+function getVueVersion(root) {
+  var _a;
+  const raw = ((_a = _localpkg.getPackageInfoSync.call(void 0, "vue", { paths: [root] })) == null ? void 0 : _a.version) || "3";
+  const version = +raw.split(".").slice(0, 2).join(".");
+  if (version === 2.7)
+    return 2.7;
+  else if (version < 2.7)
+    return 2;
+  return 3;
+}
+
+// src/core/fs/glob.ts
+var _fastglob = require('fast-glob'); var _fastglob2 = _interopRequireDefault(_fastglob);
+
+var debug = _debug2.default.call(void 0, "unplugin-vue-components:glob");
+function searchComponents(ctx) {
+  var _a;
+  debug(`started with: [${ctx.options.globs.join(", ")}]`);
+  const root = ctx.root;
+  const files = _fastglob2.default.sync(ctx.options.globs, {
+    ignore: ["node_modules"],
+    onlyFiles: true,
+    cwd: root,
+    absolute: true
+  });
+  if (!files.length && !((_a = ctx.options.resolvers) == null ? void 0 : _a.length))
+    console.warn("[unplugin-vue-components] no components found");
+  debug(`${files.length} components found.`);
+  ctx.addComponents(files);
+}
+
+// src/core/declaration.ts
+
+
+var _promises = require('fs/promises');
+
+var multilineCommentsRE = new RegExp("\\/\\*.*?\\*\\/", "gms");
+var singlelineCommentsRE = /\/\/.*$/gm;
+function extractImports(code) {
+  return Object.fromEntries(Array.from(code.matchAll(/['"]?([^\s'"]+)['"]?\s*:\s*(.+?)[,;\n]/g)).map((i) => [i[1], i[2]]));
+}
+function parseDeclaration(code) {
+  var _a, _b;
+  if (!code)
+    return;
+  code = code.replace(multilineCommentsRE, "").replace(singlelineCommentsRE, "");
+  const imports = {
+    component: {},
+    directive: {}
+  };
+  const componentDeclaration = (_a = new RegExp("export\\s+interface\\s+GlobalComponents\\s*{(.*?)}", "s").exec(code)) == null ? void 0 : _a[0];
+  if (componentDeclaration)
+    imports.component = extractImports(componentDeclaration);
+  const directiveDeclaration = (_b = new RegExp("export\\s+interface\\s+ComponentCustomProperties\\s*{(.*?)}", "s").exec(code)) == null ? void 0 : _b[0];
+  if (directiveDeclaration)
+    imports.directive = extractImports(directiveDeclaration);
+  return imports;
+}
+function stringifyComponentInfo(filepath, { from: path, as: name, name: importName }, importPathTransform) {
+  if (!name)
+    return void 0;
+  path = _chunkHCIFGIWSjs.getTransformedPath.call(void 0, path, importPathTransform);
+  const related = _path.isAbsolute.call(void 0, path) ? `./${_path.relative.call(void 0, _path.dirname.call(void 0, filepath), path)}` : path;
+  const entry = `typeof import('${_utils.slash.call(void 0, related)}')['${importName || "default"}']`;
+  return [name, entry];
+}
+function stringifyComponentsInfo(filepath, components, importPathTransform) {
+  return Object.fromEntries(
+    components.map((info) => stringifyComponentInfo(filepath, info, importPathTransform)).filter(_utils.notNullish)
+  );
+}
+function getDeclarationImports(ctx, filepath) {
+  const component = stringifyComponentsInfo(filepath, [
+    ...Object.values(_chunkBTQOTIPQjs.__spreadValues.call(void 0, _chunkBTQOTIPQjs.__spreadValues.call(void 0, {}, ctx.componentNameMap), ctx.componentCustomMap)),
+    ...resolveTypeImports(ctx.options.types)
+  ], ctx.options.importPathTransform);
+  const directive = stringifyComponentsInfo(
+    filepath,
+    Object.values(ctx.directiveCustomMap),
+    ctx.options.importPathTransform
+  );
+  if (Object.keys(component).length + Object.keys(directive).length === 0)
+    return;
+  return { component, directive };
+}
+function stringifyDeclarationImports(imports) {
+  return Object.entries(imports).sort(([a], [b]) => a.localeCompare(b)).map(([name, v]) => {
+    if (!/^\w+$/.test(name))
+      name = `'${name}'`;
+    return `${name}: ${v}`;
+  });
+}
+function getDeclaration(ctx, filepath, originalImports) {
+  const imports = getDeclarationImports(ctx, filepath);
+  if (!imports)
+    return;
+  const declarations = {
+    component: stringifyDeclarationImports(_chunkBTQOTIPQjs.__spreadValues.call(void 0, _chunkBTQOTIPQjs.__spreadValues.call(void 0, {}, originalImports == null ? void 0 : originalImports.component), imports.component)),
+    directive: stringifyDeclarationImports(_chunkBTQOTIPQjs.__spreadValues.call(void 0, _chunkBTQOTIPQjs.__spreadValues.call(void 0, {}, originalImports == null ? void 0 : originalImports.directive), imports.directive))
+  };
+  const head = ctx.options.version === 2.7 ? `export {}
+
+declare module 'vue' {` : `import '@vue/runtime-core'
+
+export {}
+
+declare module '@vue/runtime-core' {`;
+  let code = `/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// Generated by unplugin-vue-components
+// Read more: https://github.com/vuejs/core/pull/3399
+${head}`;
+  if (Object.keys(declarations.component).length > 0) {
+    code += `
+  export interface GlobalComponents {
+    ${declarations.component.join("\n    ")}
+  }`;
+  }
+  if (Object.keys(declarations.directive).length > 0) {
+    code += `
+  export interface ComponentCustomProperties {
+    ${declarations.directive.join("\n    ")}
+  }`;
+  }
+  code += "\n}\n";
+  return code;
+}
+async function writeFile(filePath, content) {
+  await _promises.mkdir.call(void 0, _path.dirname.call(void 0, filePath), { recursive: true });
+  return await _promises.writeFile.call(void 0, filePath, content, "utf-8");
+}
+async function writeDeclaration(ctx, filepath, removeUnused = false) {
+  const originalContent = _fs.existsSync.call(void 0, filepath) ? await _promises.readFile.call(void 0, filepath, "utf-8") : "";
+  const originalImports = removeUnused ? void 0 : parseDeclaration(originalContent);
+  const code = getDeclaration(ctx, filepath, originalImports);
+  if (!code)
+    return;
+  if (code !== originalContent)
+    await writeFile(filepath, code);
+}
+
+// src/core/transformer.ts
+
+var _magicstring = require('magic-string'); var _magicstring2 = _interopRequireDefault(_magicstring);
+
+// src/core/transforms/component.ts
+
+var debug2 = _debug2.default.call(void 0, "unplugin-vue-components:transform:component");
+var resolveVue2 = (code, s) => {
+  const results = [];
+  for (const match of code.matchAll(/\b(_c|h)\([\s\n\t]*['"](.+?)["']([,)])/g)) {
+    const [full, renderFunctionName, matchedName, append] = match;
+    if (match.index != null && matchedName && !matchedName.startsWith("_")) {
+      const start = match.index;
+      const end = start + full.length;
+      results.push({
+        rawName: matchedName,
+        replace: (resolved) => s.overwrite(start, end, `${renderFunctionName}(${resolved}${append}`)
+      });
+    }
+  }
+  return results;
+};
+var resolveVue3 = (code, s) => {
+  const results = [];
+  for (const match of code.matchAll(/_resolveComponent[0-9]*\("(.+?)"\)/g)) {
+    const matchedName = match[1];
+    if (match.index != null && matchedName && !matchedName.startsWith("_")) {
+      const start = match.index;
+      const end = start + match[0].length;
+      results.push({
+        rawName: matchedName,
+        replace: (resolved) => s.overwrite(start, end, resolved)
+      });
+    }
+  }
+  return results;
+};
+async function transformComponent(code, transformer2, s, ctx, sfcPath) {
+  let no = 0;
+  const results = transformer2 === "vue2" ? resolveVue2(code, s) : resolveVue3(code, s);
+  for (const { rawName, replace } of results) {
+    debug2(`| ${rawName}`);
+    const name = _chunkHCIFGIWSjs.pascalCase.call(void 0, rawName);
+    ctx.updateUsageMap(sfcPath, [name]);
+    const component = await ctx.findComponent(name, "component", [sfcPath]);
+    if (component) {
+      const varName = `__unplugin_components_${no}`;
+      s.prepend(`${_chunkHCIFGIWSjs.stringifyComponentImport.call(void 0, _chunkBTQOTIPQjs.__spreadProps.call(void 0, _chunkBTQOTIPQjs.__spreadValues.call(void 0, {}, component), { as: varName }), ctx)};
+`);
+      no += 1;
+      replace(varName);
+    }
+  }
+  debug2(`^ (${no})`);
+}
+
+// src/core/transforms/directive/index.ts
+
+
+// src/core/transforms/directive/vue2.ts
+
+var getRenderFnStart = (program) => {
+  var _a, _b;
+  const renderFn = program.body.find(
+    (node) => node.type === "VariableDeclaration" && node.declarations[0].id.type === "Identifier" && ["render", "_sfc_render"].includes(node.declarations[0].id.name)
+  );
+  const start = (_b = (_a = renderFn == null ? void 0 : renderFn.declarations[0].init) == null ? void 0 : _a.body) == null ? void 0 : _b.start;
+  if (start === null || start === void 0)
+    throw new Error("[unplugin-vue-components:directive] Cannot find render function position.");
+  return start + 1;
+};
+async function resolveVue22(code, s) {
+  var _a, _b, _c;
+  if (!_localpkg.isPackageExists.call(void 0, "@babel/parser"))
+    throw new Error('[unplugin-vue-components:directive] To use Vue 2 directive you will need to install Babel first: "npm install -D @babel/parser"');
+  const { parse } = await _localpkg.importModule.call(void 0, "@babel/parser");
+  const { program } = parse(code, {
+    sourceType: "module"
+  });
+  const nodes = [];
+  const { walk } = await Promise.resolve().then(() => require("./src-FZTNZZMC.js"));
+  walk(program, {
+    enter(node) {
+      if (node.type === "CallExpression")
+        nodes.push(node);
+    }
+  });
+  if (nodes.length === 0)
+    return [];
+  let _renderStart;
+  const getRenderStart = () => {
+    if (_renderStart !== void 0)
+      return _renderStart;
+    return _renderStart = getRenderFnStart(program);
+  };
+  const results = [];
+  for (const node of nodes) {
+    const { callee, arguments: args } = node;
+    if (callee.type !== "Identifier" || callee.name !== "_c" || ((_a = args[1]) == null ? void 0 : _a.type) !== "ObjectExpression")
+      continue;
+    const directives = (_b = args[1].properties.find(
+      (property) => property.type === "ObjectProperty" && property.key.type === "Identifier" && property.key.name === "directives"
+    )) == null ? void 0 : _b.value;
+    if (!directives || directives.type !== "ArrayExpression")
+      continue;
+    for (const directive of directives.elements) {
+      if ((directive == null ? void 0 : directive.type) !== "ObjectExpression")
+        continue;
+      const nameNode = (_c = directive.properties.find(
+        (p) => p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "name"
+      )) == null ? void 0 : _c.value;
+      if ((nameNode == null ? void 0 : nameNode.type) !== "StringLiteral")
+        continue;
+      const name = nameNode.value;
+      if (!name || name.startsWith("_"))
+        continue;
+      results.push({
+        rawName: name,
+        replace: (resolved) => {
+          s.prependLeft(getRenderStart(), `
+this.$options.directives["${name}"] = ${resolved};`);
+        }
+      });
+    }
+  }
+  return results;
+}
+
+// src/core/transforms/directive/vue3.ts
+function resolveVue32(code, s) {
+  const results = [];
+  for (const match of code.matchAll(/_resolveDirective\("(.+?)"\)/g)) {
+    const matchedName = match[1];
+    if (match.index != null && matchedName && !matchedName.startsWith("_")) {
+      const start = match.index;
+      const end = start + match[0].length;
+      results.push({
+        rawName: matchedName,
+        replace: (resolved) => s.overwrite(start, end, resolved)
+      });
+    }
+  }
+  return results;
+}
+
+// src/core/transforms/directive/index.ts
+var debug3 = _debug2.default.call(void 0, "unplugin-vue-components:transform:directive");
+async function transformDirective(code, transformer2, s, ctx, sfcPath) {
+  let no = 0;
+  const results = await (transformer2 === "vue2" ? resolveVue22(code, s) : resolveVue32(code, s));
+  for (const { rawName, replace } of results) {
+    debug3(`| ${rawName}`);
+    const name = `${_chunkHCIFGIWSjs.DIRECTIVE_IMPORT_PREFIX}${_chunkHCIFGIWSjs.pascalCase.call(void 0, rawName)}`;
+    ctx.updateUsageMap(sfcPath, [name]);
+    const directive = await ctx.findComponent(name, "directive", [sfcPath]);
+    if (!directive)
+      continue;
+    const varName = `__unplugin_directives_${no}`;
+    s.prepend(`${_chunkHCIFGIWSjs.stringifyComponentImport.call(void 0, _chunkBTQOTIPQjs.__spreadProps.call(void 0, _chunkBTQOTIPQjs.__spreadValues.call(void 0, {}, directive), { as: varName }), ctx)};
+`);
+    no += 1;
+    replace(varName);
+  }
+  debug3(`^ (${no})`);
+}
+
+// src/core/transformer.ts
+var debug4 = _debug2.default.call(void 0, "unplugin-vue-components:transformer");
+function transformer(ctx, transformer2) {
+  return async (code, id, path) => {
+    ctx.searchGlob();
+    const sfcPath = ctx.normalizePath(path);
+    debug4(sfcPath);
+    const s = new (0, _magicstring2.default)(code);
+    await transformComponent(code, transformer2, s, ctx, sfcPath);
+    if (ctx.options.directives)
+      await transformDirective(code, transformer2, s, ctx, sfcPath);
+    s.prepend(_chunkHCIFGIWSjs.DISABLE_COMMENT);
+    const result = { code: s.toString() };
+    if (ctx.sourcemap)
+      result.map = s.generateMap({ source: id, includeContent: true });
+    return result;
+  };
+}
+
+// src/core/context.ts
+var debug5 = {
+  components: _debug2.default.call(void 0, "unplugin-vue-components:context:components"),
+  search: _debug2.default.call(void 0, "unplugin-vue-components:context:search"),
+  hmr: _debug2.default.call(void 0, "unplugin-vue-components:context:hmr"),
+  decleration: _debug2.default.call(void 0, "unplugin-vue-components:decleration"),
+  env: _debug2.default.call(void 0, "unplugin-vue-components:env")
+};
+var Context = class {
+  constructor(rawOptions) {
+    this.rawOptions = rawOptions;
+    this.transformer = void 0;
+    this._componentPaths = /* @__PURE__ */ new Set();
+    this._componentNameMap = {};
+    this._componentUsageMap = {};
+    this._componentCustomMap = {};
+    this._directiveCustomMap = {};
+    this.root = process.cwd();
+    this.sourcemap = true;
+    this.alias = {};
+    this._searched = false;
+    this.options = resolveOptions(rawOptions, this.root);
+    this.generateDeclaration = _utils.throttle.call(void 0, 500, this._generateDeclaration.bind(this), { noLeading: false });
+    this.setTransformer(this.options.transformer);
+  }
+  setRoot(root) {
+    if (this.root === root)
+      return;
+    debug5.env("root", root);
+    this.root = root;
+    this.options = resolveOptions(this.rawOptions, this.root);
+  }
+  setTransformer(name) {
+    debug5.env("transformer", name);
+    this.transformer = transformer(this, name || "vue3");
+  }
+  transform(code, id) {
+    const { path, query } = _chunkHCIFGIWSjs.parseId.call(void 0, id);
+    return this.transformer(code, id, path, query);
+  }
+  setupViteServer(server) {
+    if (this._server === server)
+      return;
+    this._server = server;
+    this.setupWatcher(server.watcher);
+  }
+  setupWatcher(watcher) {
+    const { globs } = this.options;
+    watcher.on("unlink", (path) => {
+      if (!_chunkHCIFGIWSjs.matchGlobs.call(void 0, path, globs))
+        return;
+      path = _utils.slash.call(void 0, path);
+      this.removeComponents(path);
+      this.onUpdate(path);
+    });
+    watcher.on("add", (path) => {
+      if (!_chunkHCIFGIWSjs.matchGlobs.call(void 0, path, globs))
+        return;
+      path = _utils.slash.call(void 0, path);
+      this.addComponents(path);
+      this.onUpdate(path);
+    });
+  }
+  /**
+   * start watcher for webpack
+   */
+  setupWatcherWebpack(watcher, emitUpdate) {
+    const { globs } = this.options;
+    watcher.on("unlink", (path) => {
+      if (!_chunkHCIFGIWSjs.matchGlobs.call(void 0, path, globs))
+        return;
+      path = _utils.slash.call(void 0, path);
+      this.removeComponents(path);
+      emitUpdate(path, "unlink");
+    });
+    watcher.on("add", (path) => {
+      if (!_chunkHCIFGIWSjs.matchGlobs.call(void 0, path, globs))
+        return;
+      path = _utils.slash.call(void 0, path);
+      this.addComponents(path);
+      emitUpdate(path, "add");
+    });
+  }
+  /**
+   * Record the usage of components
+   * @param path
+   * @param paths paths of used components
+   */
+  updateUsageMap(path, paths) {
+    if (!this._componentUsageMap[path])
+      this._componentUsageMap[path] = /* @__PURE__ */ new Set();
+    paths.forEach((p) => {
+      this._componentUsageMap[path].add(p);
+    });
+  }
+  addComponents(paths) {
+    debug5.components("add", paths);
+    const size = this._componentPaths.size;
+    _utils.toArray.call(void 0, paths).forEach((p) => this._componentPaths.add(p));
+    if (this._componentPaths.size !== size) {
+      this.updateComponentNameMap();
+      return true;
+    }
+    return false;
+  }
+  addCustomComponents(info) {
+    if (info.as)
+      this._componentCustomMap[info.as] = info;
+  }
+  addCustomDirectives(info) {
+    if (info.as)
+      this._directiveCustomMap[info.as] = info;
+  }
+  removeComponents(paths) {
+    debug5.components("remove", paths);
+    const size = this._componentPaths.size;
+    _utils.toArray.call(void 0, paths).forEach((p) => this._componentPaths.delete(p));
+    if (this._componentPaths.size !== size) {
+      this.updateComponentNameMap();
+      return true;
+    }
+    return false;
+  }
+  onUpdate(path) {
+    this.generateDeclaration();
+    if (!this._server)
+      return;
+    const payload = {
+      type: "update",
+      updates: []
+    };
+    const timestamp = +/* @__PURE__ */ new Date();
+    const name = _chunkHCIFGIWSjs.pascalCase.call(void 0, _chunkHCIFGIWSjs.getNameFromFilePath.call(void 0, path, this.options));
+    Object.entries(this._componentUsageMap).forEach(([key, values]) => {
+      if (values.has(name)) {
+        const r = `/${_utils.slash.call(void 0, _path.relative.call(void 0, this.root, key))}`;
+        payload.updates.push({
+          acceptedPath: r,
+          path: r,
+          timestamp,
+          type: "js-update"
+        });
+      }
+    });
+    if (payload.updates.length)
+      this._server.ws.send(payload);
+  }
+  updateComponentNameMap() {
+    this._componentNameMap = {};
+    Array.from(this._componentPaths).forEach((path) => {
+      const name = _chunkHCIFGIWSjs.pascalCase.call(void 0, _chunkHCIFGIWSjs.getNameFromFilePath.call(void 0, path, this.options));
+      if (this._componentNameMap[name] && !this.options.allowOverrides) {
+        console.warn(`[unplugin-vue-components] component "${name}"(${path}) has naming conflicts with other components, ignored.`);
+        return;
+      }
+      this._componentNameMap[name] = {
+        as: name,
+        from: path
+      };
+    });
+  }
+  async findComponent(name, type, excludePaths = []) {
+    let info = this._componentNameMap[name];
+    if (info && !excludePaths.includes(info.from) && !excludePaths.includes(info.from.slice(1)))
+      return info;
+    for (const resolver of this.options.resolvers) {
+      if (resolver.type !== type)
+        continue;
+      const result = await resolver.resolve(type === "directive" ? name.slice(_chunkHCIFGIWSjs.DIRECTIVE_IMPORT_PREFIX.length) : name);
+      if (!result)
+        continue;
+      if (typeof result === "string") {
+        info = {
+          as: name,
+          from: result
+        };
+      } else {
+        info = _chunkBTQOTIPQjs.__spreadValues.call(void 0, {
+          as: name
+        }, _chunkHCIFGIWSjs.normalizeComponetInfo.call(void 0, result));
+      }
+      if (type === "component")
+        this.addCustomComponents(info);
+      else if (type === "directive")
+        this.addCustomDirectives(info);
+      return info;
+    }
+    return void 0;
+  }
+  normalizePath(path) {
+    var _a, _b, _c;
+    return _chunkHCIFGIWSjs.resolveAlias.call(void 0, path, ((_b = (_a = this.viteConfig) == null ? void 0 : _a.resolve) == null ? void 0 : _b.alias) || ((_c = this.viteConfig) == null ? void 0 : _c.alias) || []);
+  }
+  relative(path) {
+    if (path.startsWith("/") && !path.startsWith(this.root))
+      return _utils.slash.call(void 0, path.slice(1));
+    return _utils.slash.call(void 0, _path.relative.call(void 0, this.root, path));
+  }
+  /**
+   * This search for components in with the given options.
+   * Will be called multiple times to ensure file loaded,
+   * should normally run only once.
+   */
+  searchGlob() {
+    if (this._searched)
+      return;
+    searchComponents(this);
+    debug5.search(this._componentNameMap);
+    this._searched = true;
+  }
+  _generateDeclaration(removeUnused = !this._server) {
+    if (!this.options.dts)
+      return;
+    debug5.decleration("generating");
+    return writeDeclaration(this, this.options.dts, removeUnused);
+  }
+  get componentNameMap() {
+    return this._componentNameMap;
+  }
+  get componentCustomMap() {
+    return this._componentCustomMap;
+  }
+  get directiveCustomMap() {
+    return this._directiveCustomMap;
+  }
+};
+
+// src/core/unplugin.ts
+var PLUGIN_NAME = "unplugin:webpack";
+var unplugin_default = _unplugin.createUnplugin.call(void 0, (options = {}) => {
+  const filter = _pluginutils.createFilter.call(void 0, 
+    options.include || [/\.vue$/, /\.vue\?vue/, /\.vue\?v=/],
+    options.exclude || [/[\\/]node_modules[\\/]/, /[\\/]\.git[\\/]/, /[\\/]\.nuxt[\\/]/]
+  );
+  const ctx = new Context(options);
+  const api = {
+    async findComponent(name, filename) {
+      return await ctx.findComponent(name, "component", filename ? [filename] : []);
+    },
+    stringifyImport(info) {
+      return _chunkHCIFGIWSjs.stringifyComponentImport.call(void 0, info, ctx);
+    }
+  };
+  return {
+    name: "unplugin-vue-components",
+    enforce: "post",
+    api,
+    transformInclude(id) {
+      return filter(id);
+    },
+    async transform(code, id) {
+      if (!_chunkHCIFGIWSjs.shouldTransform.call(void 0, code))
+        return null;
+      try {
+        const result = await ctx.transform(code, id);
+        ctx.generateDeclaration();
+        return result;
+      } catch (e) {
+        this.error(e);
+      }
+    },
+    vite: {
+      configResolved(config) {
+        ctx.setRoot(config.root);
+        ctx.sourcemap = true;
+        if (config.plugins.find((i) => i.name === "vite-plugin-vue2"))
+          ctx.setTransformer("vue2");
+        if (ctx.options.dts) {
+          ctx.searchGlob();
+          if (!_fs.existsSync.call(void 0, ctx.options.dts))
+            ctx.generateDeclaration();
+        }
+        if (config.build.watch && config.command === "build")
+          ctx.setupWatcher(_chokidar2.default.watch(ctx.options.globs));
+      },
+      configureServer(server) {
+        ctx.setupViteServer(server);
+      }
+    },
+    webpack(compiler) {
+      let watcher;
+      let fileDepQueue = [];
+      compiler.hooks.watchRun.tap(PLUGIN_NAME, () => {
+        if (!watcher && compiler.watching) {
+          watcher = compiler.watching;
+          ctx.setupWatcherWebpack(_chokidar2.default.watch(ctx.options.globs), (path, type) => {
+            fileDepQueue.push({ path, type });
+            process.nextTick(() => {
+              watcher.invalidate();
+            });
+          });
+        }
+      });
+      compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+        if (fileDepQueue.length) {
+          fileDepQueue.forEach(({ path, type }) => {
+            if (type === "unlink")
+              compilation.fileDependencies.delete(path);
+            else
+              compilation.fileDependencies.add(path);
+          });
+          fileDepQueue = [];
+        }
+      });
+    }
+  };
+});
+
+
+
+exports.unplugin_default = unplugin_default;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/chunk-ZKNUHGJ4.mjs

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __require
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/esbuild.d.ts

@@ -0,0 +1,9 @@
+import * as esbuild from 'esbuild';
+import { Options } from './types.js';
+import '@rollup/pluginutils';
+import 'unplugin';
+import '@antfu/utils';
+
+declare const _default: (options: Options) => esbuild.Plugin;
+
+export { _default as default };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/esbuild.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkZ3TQFCNGjs = require('./chunk-Z3TQFCNG.js');
+require('./chunk-HCIFGIWS.js');
+require('./chunk-BTQOTIPQ.js');
+require('./chunk-6F4PWJZI.js');
+
+// src/esbuild.ts
+var esbuild_default = _chunkZ3TQFCNGjs.unplugin_default.esbuild;
+
+
+module.exports = esbuild_default;
+exports.default = module.exports;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/esbuild.mjs

@@ -0,0 +1,12 @@
+import {
+  unplugin_default
+} from "./chunk-WVTE3GCL.mjs";
+import "./chunk-BPHJA2FM.mjs";
+import "./chunk-ZKNUHGJ4.mjs";
+import "./chunk-WBQAMGXK.mjs";
+
+// src/esbuild.ts
+var esbuild_default = unplugin_default.esbuild;
+export {
+  esbuild_default as default
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { Options } from './types.js';
+export { ComponentInfo, ComponentResolveResult, ComponentResolver, ComponentResolverFunction, ComponentResolverObject, ComponentsImportMap, ImportInfo, ImportInfoLegacy, Matcher, PublicPluginAPI, ResolvedOptions, SideEffectsInfo, SupportedTransformer, Transformer, TypeImport } from './types.js';
+import * as unplugin from 'unplugin';
+import '@rollup/pluginutils';
+import '@antfu/utils';
+
+declare const _default: unplugin.UnpluginInstance<Options, boolean>;
+
+declare function pascalCase(str: string): string;
+declare function camelCase(str: string): string;
+declare function kebabCase(key: string): string;
+
+export { Options, camelCase, _default as default, kebabCase, pascalCase };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkZ3TQFCNGjs = require('./chunk-Z3TQFCNG.js');
+
+
+
+
+var _chunkHCIFGIWSjs = require('./chunk-HCIFGIWS.js');
+require('./chunk-BTQOTIPQ.js');
+require('./chunk-6F4PWJZI.js');
+
+
+
+
+
+exports.camelCase = _chunkHCIFGIWSjs.camelCase; exports.default = _chunkZ3TQFCNGjs.unplugin_default; exports.kebabCase = _chunkHCIFGIWSjs.kebabCase; exports.pascalCase = _chunkHCIFGIWSjs.pascalCase;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/index.mjs

@@ -0,0 +1,16 @@
+import {
+  unplugin_default
+} from "./chunk-WVTE3GCL.mjs";
+import {
+  camelCase,
+  kebabCase,
+  pascalCase
+} from "./chunk-BPHJA2FM.mjs";
+import "./chunk-ZKNUHGJ4.mjs";
+import "./chunk-WBQAMGXK.mjs";
+export {
+  camelCase,
+  unplugin_default as default,
+  kebabCase,
+  pascalCase
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/nuxt.d.ts

@@ -0,0 +1,9 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { Options } from './types.js';
+import '@rollup/pluginutils';
+import 'unplugin';
+import '@antfu/utils';
+
+declare const _default: _nuxt_schema.NuxtModule<Options>;
+
+export { _default as default };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/nuxt.js

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkZ3TQFCNGjs = require('./chunk-Z3TQFCNG.js');
+require('./chunk-HCIFGIWS.js');
+require('./chunk-BTQOTIPQ.js');
+require('./chunk-6F4PWJZI.js');
+
+// src/nuxt.ts
+var _kit = require('@nuxt/kit');
+var nuxt_default = _kit.defineNuxtModule.call(void 0, {
+  setup(options) {
+    _kit.addWebpackPlugin.call(void 0, _chunkZ3TQFCNGjs.unplugin_default.webpack(options));
+    _kit.addVitePlugin.call(void 0, _chunkZ3TQFCNGjs.unplugin_default.vite(options));
+  }
+});
+
+
+module.exports = nuxt_default;
+exports.default = module.exports;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/nuxt.mjs

@@ -0,0 +1,18 @@
+import {
+  unplugin_default
+} from "./chunk-WVTE3GCL.mjs";
+import "./chunk-BPHJA2FM.mjs";
+import "./chunk-ZKNUHGJ4.mjs";
+import "./chunk-WBQAMGXK.mjs";
+
+// src/nuxt.ts
+import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
+var nuxt_default = defineNuxtModule({
+  setup(options) {
+    addWebpackPlugin(unplugin_default.webpack(options));
+    addVitePlugin(unplugin_default.vite(options));
+  }
+});
+export {
+  nuxt_default as default
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/resolvers.d.ts

@@ -0,0 +1,525 @@
+import { ComponentResolver, ComponentResolveResult } from './types.js';
+import '@rollup/pluginutils';
+import 'unplugin';
+import '@antfu/utils';
+
+interface AntDesignVueResolverOptions {
+    /**
+     * exclude components that do not require automatic import
+     *
+     * @default []
+     */
+    exclude?: string[];
+    /**
+     * import style along with components
+     *
+     * @default 'css'
+     */
+    importStyle?: boolean | 'css' | 'less';
+    /**
+     * resolve `ant-design-vue' icons
+     *
+     * requires package `@ant-design/icons-vue`
+     *
+     * @default false
+     */
+    resolveIcons?: boolean;
+    /**
+     * @deprecated use `importStyle: 'css'` instead
+     */
+    importCss?: boolean;
+    /**
+     * @deprecated use `importStyle: 'less'` instead
+     */
+    importLess?: boolean;
+    /**
+     * use commonjs build default false
+     */
+    cjs?: boolean;
+    /**
+     * rename package
+     *
+     * @default 'ant-design-vue'
+     */
+    packageName?: string;
+}
+/**
+ * Resolver for Ant Design Vue
+ *
+ * Requires ant-design-vue@v2.2.0-beta.6 or later
+ *
+ * See https://github.com/antfu/unplugin-vue-components/issues/26#issuecomment-789767941 for more details
+ *
+ * @author @yangss3
+ * @link https://antdv.com/
+ */
+declare function AntDesignVueResolver(options?: AntDesignVueResolverOptions): ComponentResolver;
+
+interface ElementPlusResolverOptions {
+    /**
+     * import style css or sass with components
+     *
+     * @default 'css'
+     */
+    importStyle?: boolean | 'css' | 'sass';
+    /**
+     * use commonjs lib & source css or scss for ssr
+     */
+    ssr?: boolean;
+    /**
+     * specify element-plus version to load style
+     *
+     * @default installed version
+     */
+    version?: string;
+    /**
+     * auto import for directives
+     *
+     * @default true
+     */
+    directives?: boolean;
+    /**
+     * exclude component name, if match do not resolve the name
+     */
+    exclude?: RegExp;
+    /**
+     * a list of component names that have no styles, so resolving their styles file should be prevented
+     */
+    noStylesComponents?: string[];
+}
+/**
+ * Resolver for Element Plus
+ *
+ * See https://github.com/antfu/vite-plugin-components/pull/28 for more details
+ * See https://github.com/antfu/vite-plugin-components/issues/117 for more details
+ *
+ * @author @develar @nabaonan @sxzz
+ * @link https://element-plus.org/ for element-plus
+ *
+ */
+declare function ElementPlusResolver(options?: ElementPlusResolverOptions): ComponentResolver[];
+
+interface ElementUiResolverOptions {
+    /**
+     * import style css or sass with components
+     *
+     * @default 'css'
+     */
+    importStyle?: boolean | 'css' | 'sass';
+    /**
+     * exclude component name, if match do not resolve the name
+     */
+    exclude?: RegExp;
+}
+/**
+ * Resolver for Element-UI
+ * @link https://element.eleme.cn/#/zh-CN
+ * @version @element-ui ^2.15.3, @vue ^2.6.14
+ * @author @nabaonan
+ */
+declare function ElementUiResolver(options?: ElementUiResolverOptions): ComponentResolver;
+
+interface HeadlessUiResolverOptions {
+    /**
+     * prefix for headless ui components used in templates
+     *
+     * @default ""
+     */
+    prefix?: string;
+}
+/**
+ * Resolver for headlessui
+ *
+ * @link https://github.com/tailwindlabs/headlessui
+ */
+declare function HeadlessUiResolver(options?: HeadlessUiResolverOptions): ComponentResolver;
+
+interface IduxResolverOptions {
+    /**
+     * exclude components that do not require automatic import
+     *
+     * @default []
+     */
+    exclude?: string[];
+    /**
+     * import style along with components
+     */
+    importStyle?: 'css' | 'less';
+    /**
+     * theme for import style
+     *
+     * @default 'default'
+     */
+    importStyleTheme?: string;
+    /**
+     * The scope of the packages.
+     *
+     * @default '@idux'
+     */
+    scope?: string;
+}
+/**
+ * Resolver for `@idux/cdk`, `@idux/components` and ``@idux/pro``
+ *
+ * @link https://idux.site
+ */
+declare function IduxResolver(options?: IduxResolverOptions): ComponentResolver;
+
+/**
+ * Resolver for Inkline
+ *
+ * @author @alexgrozav
+ * @link https://github.com/inkline/inkline
+ */
+declare function InklineResolver(): ComponentResolver;
+
+/**
+ * Resolver for Naive UI
+ *
+ * @author @antfu
+ * @link https://www.naiveui.com/
+ */
+declare function NaiveUiResolver(): ComponentResolver;
+
+interface PrimeVueResolverOptions {
+    /**
+     * import style along with components
+     *
+     * @default true
+     */
+    importStyle?: boolean;
+    /**
+     * import `primeicons' icons
+     *
+     * requires package `primeicons`
+     *
+     * @default true
+     */
+    importIcons?: boolean;
+    /**
+     * imports a free theme - set theme name here (e.g. saga-blue)
+     *
+     * @default ''
+     */
+    importTheme?: string;
+    /**
+     * prefix for components (e.g. 'P' to resolve Menu from PMenu)
+     *
+     * @default ''
+     */
+    prefix?: string;
+}
+/**
+ * Resolver for PrimeVue - If you're using a component with the same tag as an native HTML element (e.g. button) the component must be in uppercase
+ *
+ * @link https://github.com/primefaces/primevue
+ */
+declare function PrimeVueResolver(options?: PrimeVueResolverOptions): ComponentResolver;
+
+interface VantResolverOptions {
+    /**
+     * import style css or less along with components
+     *
+     * @default true
+     */
+    importStyle?: boolean | 'css' | 'less';
+}
+/**
+ * Resolver for Vant
+ *
+ * @link https://github.com/youzan/vant
+ */
+declare function VantResolver(options?: VantResolverOptions): ComponentResolver;
+
+interface VarletUIResolverOptions {
+    /**
+     * support vue version
+     * vue3 use @varlet/ui, vue2 use @varlet-vue2/ui
+     *
+     * @default 'vue3'
+     */
+    version?: 'vue3' | 'vue2';
+    /**
+     * import style along with components
+     *
+     * @default 'css'
+     */
+    importStyle?: boolean | 'css' | 'less';
+    /**
+     * auto import for directives
+     *
+     * @default true
+     */
+    directives?: boolean;
+    /**
+     * compatible with unplugin-auto-import
+     *
+     * @default false
+     */
+    autoImport?: boolean;
+    /**
+     * @deprecated use `importStyle: 'css'` instead
+     */
+    importCss?: boolean;
+    /**
+     * @deprecated use `importStyle: 'less'` instead
+     */
+    importLess?: boolean;
+}
+declare function getResolved(name: string, options: VarletUIResolverOptions): ComponentResolveResult;
+/**
+ * Resolver for VarletUI
+ *
+ * @link https://github.com/varletjs/varlet
+ * @link https://github.com/varletjs/varlet-vue2
+ */
+declare function VarletUIResolver(options?: VarletUIResolverOptions): ComponentResolver[];
+
+interface VeuiPeerConfig {
+    /**
+     * The package name of the peer module.
+     */
+    package: string;
+    /**
+     * The directory path of the peer module.
+     * @default 'components'
+     */
+    path?: string;
+    /**
+     * The file name template for the peer module.
+     * @default '{module}.css'
+     */
+    fileName?: `${string}{module}${string}`;
+    /**
+     * The text transform to be applied to the '{module}' part of the file name.
+     * @default 'kebab-case'
+     */
+    transform?: 'kebab-case' | 'camelCase' | 'PascalCase' | false;
+}
+type SupportedLocale = 'en-US' | 'zh-Hans';
+interface VeuiResolverOptions {
+    /**
+     * The alias of 'veui` package.
+     * @default 'veui'
+     */
+    alias?: string;
+    /**
+     * Peer modules to be injected.
+     */
+    modules?: VeuiPeerConfig[];
+    /**
+     * Locale modules to be injected.
+     * @default 'zh-Hans'
+     */
+    locale?: SupportedLocale | SupportedLocale[] | false;
+    /**
+     * Global modules to be injected to all components.
+     * @default []
+     */
+    global?: string[];
+}
+/**
+ * Resolver for VEUI
+ *
+ * @link https://github.com/ecomfe/veui
+ */
+declare function VeuiResolver(options?: VeuiResolverOptions): ComponentResolver;
+
+/**
+ * Resolver for View UI
+ * @requires @originjs/vite-plugin-commonjs
+ * @author @nabaonan
+ * @link https://www.iviewui.com/
+ * @description has known problems list below
+ * - select component render error PR: https://github.com/view-design/ViewUI/pull/944,  choose can't display value,because click option trigger twice,at second time,select value turn into undefined.
+ * - scroll component has a template syntax called lang='html',it is require html-loader,but vite plugin not support yet,remove it can run. relate pr: https://github.com/view-design/ViewUI/pull/985
+ */
+declare function ViewUiResolver(): ComponentResolver;
+
+/**
+ * Resolver for Vuetify
+ *
+ * @link https://github.com/vuetifyjs/vuetify
+ */
+declare function VuetifyResolver(): ComponentResolver;
+/**
+ * Resolver for Vuetify 3 Beta
+ *
+ * @link https://github.com/vuetifyjs/vuetify
+ */
+declare function Vuetify3Resolver(): ComponentResolver;
+
+/**
+ * Resolver for VueUse
+ *
+ * @link https://github.com/vueuse/vueuse
+ */
+declare function VueUseComponentsResolver(): ComponentResolver;
+
+/**
+ * Resolver for VueUse
+ *
+ * @link https://github.com/vueuse/vueuse
+ */
+declare function VueUseDirectiveResolver(): ComponentResolver;
+
+/**
+ * Resolver for Quasar
+ *
+ * @link https://github.com/quasarframework/quasar
+ */
+declare function QuasarResolver(): ComponentResolver;
+
+interface DevResolverOptions {
+    /**
+     * bring in components and styles
+     *
+     * @default true
+     */
+    importStyle?: boolean;
+    /**
+     * auto import for directives
+     *
+     * @default true
+     */
+    directives?: boolean;
+    /**
+     * use umd lib file
+     */
+    ssr?: boolean;
+}
+declare function DevUiResolver(options?: DevResolverOptions): ComponentResolver[];
+
+type DisallowResolveIconOption = undefined | false | {
+    enable: false;
+};
+type AllowResolveIconOption = true | {
+    enable: true;
+    iconPrefix?: string;
+};
+type ResolveIconsOption = DisallowResolveIconOption | AllowResolveIconOption;
+interface ArcoResolverOptions {
+    /**
+     * import style css or less with components
+     *
+     * @default 'css'
+     */
+    importStyle?: boolean | 'css' | 'less';
+    /**
+     * resolve icons
+     *
+     * @default false
+     */
+    resolveIcons?: ResolveIconsOption;
+    /**
+     * Control style automatic import
+     *
+     * @default true
+     */
+    sideEffect?: boolean;
+}
+/**
+ * Resolver for Arco Design Vue
+ *
+ * Requires arco-design/web-vue@2.11.0 or later
+ *
+ * @author @flsion
+ * @link https://arco.design/ for arco-design
+ *
+ */
+declare function ArcoResolver(options?: ArcoResolverOptions): ComponentResolver;
+
+interface TDesignResolverOptions {
+    /**
+     * import style along with components
+     * @default 'css'
+     */
+    importStyle?: boolean | 'css' | 'less';
+    /**
+     * select the specified library
+     * @default 'vue'
+     */
+    library?: 'vue' | 'vue-next' | 'react' | 'mobile-vue' | 'mobile-react';
+    /**
+     * resolve `tdesign-icons'
+     * @default false
+     */
+    resolveIcons?: boolean;
+    /**
+     * whether to import ESM version
+     * @default false
+     */
+    esm?: boolean;
+    /**
+     * exclude component name, if match do not resolve the name
+     *
+     */
+    exclude?: string | RegExp | (string | RegExp)[];
+}
+declare function TDesignResolver(options?: TDesignResolverOptions): ComponentResolver;
+
+interface LayuiVueResolverOptions {
+    /**
+     * import style along with components
+     *
+     * @default 'css'
+     */
+    importStyle?: boolean | 'css';
+    /**
+     * resolve '@layui/layui-vue' icons
+     * requires package `@layui/icons-vue`
+     *
+     * @default false
+     */
+    resolveIcons?: boolean;
+    /**
+     * exclude components that do not require automatic import
+     *
+     */
+    exclude?: Array<string | RegExp>;
+}
+/**
+ * Resolver for layui-vue
+ *
+ * @link http://www.layui-vue.com/ for layui-vue
+ *
+ */
+declare function LayuiVueResolver(options?: LayuiVueResolverOptions): ComponentResolver;
+
+interface BootstrapVueResolverOptions {
+    /**
+     * Auto import for directives.
+     *
+     * @default true
+     */
+    directives?: boolean;
+}
+/**
+ * Resolver for BootstrapVue
+ *
+ * @link https://github.com/bootstrap-vue/bootstrap-vue
+ */
+declare const BootstrapVueResolver: (_options?: BootstrapVueResolverOptions) => ComponentResolver[];
+/**
+ * Resolver for BootstrapVueNext
+ *
+ * @link https://github.com/bootstrap-vue/bootstrap-vue-next
+ */
+declare const BootstrapVueNextResolver: (_options?: BootstrapVueResolverOptions) => Array<ComponentResolver>;
+/**
+ * Resolver for legacy BootstrapVue3 apps
+ *
+ * @deprecated use BootstrapVueNextResolver with https://github.com/bootstrap-vue/bootstrap-vue-next
+ * @link https://www.npmjs.com/package/bootstrap-vue-3
+ */
+declare const BootstrapVue3Resolver: (_options?: BootstrapVueResolverOptions) => Array<ComponentResolver>;
+
+/**
+ * Resolver for ionic framework
+ *
+ * @author @mathsgod
+ * @link https://github.com/mathsgod
+ */
+declare function IonicResolver(): ComponentResolver;
+
+export { AllowResolveIconOption, AntDesignVueResolver, AntDesignVueResolverOptions, ArcoResolver, ArcoResolverOptions, BootstrapVue3Resolver, BootstrapVueNextResolver, BootstrapVueResolver, BootstrapVueResolverOptions, DevResolverOptions, DevUiResolver, DisallowResolveIconOption, ElementPlusResolver, ElementPlusResolverOptions, ElementUiResolver, ElementUiResolverOptions, HeadlessUiResolver, HeadlessUiResolverOptions, IduxResolver, IduxResolverOptions, InklineResolver, IonicResolver, LayuiVueResolver, LayuiVueResolverOptions, NaiveUiResolver, PrimeVueResolver, PrimeVueResolverOptions, QuasarResolver, ResolveIconsOption, TDesignResolver, TDesignResolverOptions, VantResolver, VantResolverOptions, VarletUIResolver, VarletUIResolverOptions, VeuiResolver, VeuiResolverOptions, ViewUiResolver, VueUseComponentsResolver, VueUseDirectiveResolver, Vuetify3Resolver, VuetifyResolver, getResolved };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/rollup.d.ts

@@ -0,0 +1,9 @@
+import * as rollup from 'rollup';
+import { Options } from './types.js';
+import '@rollup/pluginutils';
+import 'unplugin';
+import '@antfu/utils';
+
+declare const _default: (options: Options) => rollup.Plugin | rollup.Plugin[];
+
+export { _default as default };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/rollup.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkZ3TQFCNGjs = require('./chunk-Z3TQFCNG.js');
+require('./chunk-HCIFGIWS.js');
+require('./chunk-BTQOTIPQ.js');
+require('./chunk-6F4PWJZI.js');
+
+// src/rollup.ts
+var rollup_default = _chunkZ3TQFCNGjs.unplugin_default.rollup;
+
+
+module.exports = rollup_default;
+exports.default = module.exports;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/rollup.mjs

@@ -0,0 +1,12 @@
+import {
+  unplugin_default
+} from "./chunk-WVTE3GCL.mjs";
+import "./chunk-BPHJA2FM.mjs";
+import "./chunk-ZKNUHGJ4.mjs";
+import "./chunk-WBQAMGXK.mjs";
+
+// src/rollup.ts
+var rollup_default = unplugin_default.rollup;
+export {
+  rollup_default as default
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/src-EJAVKJEF.mjs

@@ -0,0 +1,268 @@
+import "./chunk-ZKNUHGJ4.mjs";
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+var WalkerBase = class {
+  constructor() {
+    this.should_skip = false;
+    this.should_remove = false;
+    this.replacement = null;
+    this.context = {
+      skip: () => this.should_skip = true,
+      remove: () => this.should_remove = true,
+      replace: (node) => this.replacement = node
+    };
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Parent | null | undefined} parent
+   * @param {keyof Parent | null | undefined} prop
+   * @param {number | null | undefined} index
+   * @param {Node} node
+   */
+  replace(parent, prop, index, node) {
+    if (parent && prop) {
+      if (index != null) {
+        parent[prop][index] = node;
+      } else {
+        parent[prop] = node;
+      }
+    }
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Parent | null | undefined} parent
+   * @param {keyof Parent | null | undefined} prop
+   * @param {number | null | undefined} index
+   */
+  remove(parent, prop, index) {
+    if (parent && prop) {
+      if (index !== null && index !== void 0) {
+        parent[prop].splice(index, 1);
+      } else {
+        delete parent[prop];
+      }
+    }
+  }
+};
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+var SyncWalker = class extends WalkerBase {
+  /**
+   *
+   * @param {SyncHandler} [enter]
+   * @param {SyncHandler} [leave]
+   */
+  constructor(enter, leave) {
+    super();
+    this.should_skip = false;
+    this.should_remove = false;
+    this.replacement = null;
+    this.context = {
+      skip: () => this.should_skip = true,
+      remove: () => this.should_remove = true,
+      replace: (node) => this.replacement = node
+    };
+    this.enter = enter;
+    this.leave = leave;
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Node} node
+   * @param {Parent | null} parent
+   * @param {keyof Parent} [prop]
+   * @param {number | null} [index]
+   * @returns {Node | null}
+   */
+  visit(node, parent, prop, index) {
+    if (node) {
+      if (this.enter) {
+        const _should_skip = this.should_skip;
+        const _should_remove = this.should_remove;
+        const _replacement = this.replacement;
+        this.should_skip = false;
+        this.should_remove = false;
+        this.replacement = null;
+        this.enter.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const skipped = this.should_skip;
+        const removed = this.should_remove;
+        this.should_skip = _should_skip;
+        this.should_remove = _should_remove;
+        this.replacement = _replacement;
+        if (skipped)
+          return node;
+        if (removed)
+          return null;
+      }
+      let key;
+      for (key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          if (Array.isArray(value)) {
+            const nodes = (
+              /** @type {Array<unknown>} */
+              value
+            );
+            for (let i = 0; i < nodes.length; i += 1) {
+              const item = nodes[i];
+              if (isNode(item)) {
+                if (!this.visit(item, node, key, i)) {
+                  i--;
+                }
+              }
+            }
+          } else if (isNode(value)) {
+            this.visit(value, node, key, null);
+          }
+        }
+      }
+      if (this.leave) {
+        const _replacement = this.replacement;
+        const _should_remove = this.should_remove;
+        this.replacement = null;
+        this.should_remove = false;
+        this.leave.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const removed = this.should_remove;
+        this.replacement = _replacement;
+        this.should_remove = _should_remove;
+        if (removed)
+          return null;
+      }
+    }
+    return node;
+  }
+};
+function isNode(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/async.js
+var AsyncWalker = class extends WalkerBase {
+  /**
+   *
+   * @param {AsyncHandler} [enter]
+   * @param {AsyncHandler} [leave]
+   */
+  constructor(enter, leave) {
+    super();
+    this.should_skip = false;
+    this.should_remove = false;
+    this.replacement = null;
+    this.context = {
+      skip: () => this.should_skip = true,
+      remove: () => this.should_remove = true,
+      replace: (node) => this.replacement = node
+    };
+    this.enter = enter;
+    this.leave = leave;
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Node} node
+   * @param {Parent | null} parent
+   * @param {keyof Parent} [prop]
+   * @param {number | null} [index]
+   * @returns {Promise<Node | null>}
+   */
+  async visit(node, parent, prop, index) {
+    if (node) {
+      if (this.enter) {
+        const _should_skip = this.should_skip;
+        const _should_remove = this.should_remove;
+        const _replacement = this.replacement;
+        this.should_skip = false;
+        this.should_remove = false;
+        this.replacement = null;
+        await this.enter.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const skipped = this.should_skip;
+        const removed = this.should_remove;
+        this.should_skip = _should_skip;
+        this.should_remove = _should_remove;
+        this.replacement = _replacement;
+        if (skipped)
+          return node;
+        if (removed)
+          return null;
+      }
+      let key;
+      for (key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          if (Array.isArray(value)) {
+            const nodes = (
+              /** @type {Array<unknown>} */
+              value
+            );
+            for (let i = 0; i < nodes.length; i += 1) {
+              const item = nodes[i];
+              if (isNode2(item)) {
+                if (!await this.visit(item, node, key, i)) {
+                  i--;
+                }
+              }
+            }
+          } else if (isNode2(value)) {
+            await this.visit(value, node, key, null);
+          }
+        }
+      }
+      if (this.leave) {
+        const _replacement = this.replacement;
+        const _should_remove = this.should_remove;
+        this.replacement = null;
+        this.should_remove = false;
+        await this.leave.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const removed = this.should_remove;
+        this.replacement = _replacement;
+        this.should_remove = _should_remove;
+        if (removed)
+          return null;
+      }
+    }
+    return node;
+  }
+};
+function isNode2(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+function walk(ast, { enter, leave }) {
+  const instance = new SyncWalker(enter, leave);
+  return instance.visit(ast, null);
+}
+async function asyncWalk(ast, { enter, leave }) {
+  const instance = new AsyncWalker(enter, leave);
+  return await instance.visit(ast, null);
+}
+export {
+  asyncWalk,
+  walk
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/src-FZTNZZMC.js

@@ -0,0 +1,269 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-BTQOTIPQ.js');
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+var WalkerBase = class {
+  constructor() {
+    this.should_skip = false;
+    this.should_remove = false;
+    this.replacement = null;
+    this.context = {
+      skip: () => this.should_skip = true,
+      remove: () => this.should_remove = true,
+      replace: (node) => this.replacement = node
+    };
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Parent | null | undefined} parent
+   * @param {keyof Parent | null | undefined} prop
+   * @param {number | null | undefined} index
+   * @param {Node} node
+   */
+  replace(parent, prop, index, node) {
+    if (parent && prop) {
+      if (index != null) {
+        parent[prop][index] = node;
+      } else {
+        parent[prop] = node;
+      }
+    }
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Parent | null | undefined} parent
+   * @param {keyof Parent | null | undefined} prop
+   * @param {number | null | undefined} index
+   */
+  remove(parent, prop, index) {
+    if (parent && prop) {
+      if (index !== null && index !== void 0) {
+        parent[prop].splice(index, 1);
+      } else {
+        delete parent[prop];
+      }
+    }
+  }
+};
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+var SyncWalker = class extends WalkerBase {
+  /**
+   *
+   * @param {SyncHandler} [enter]
+   * @param {SyncHandler} [leave]
+   */
+  constructor(enter, leave) {
+    super();
+    this.should_skip = false;
+    this.should_remove = false;
+    this.replacement = null;
+    this.context = {
+      skip: () => this.should_skip = true,
+      remove: () => this.should_remove = true,
+      replace: (node) => this.replacement = node
+    };
+    this.enter = enter;
+    this.leave = leave;
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Node} node
+   * @param {Parent | null} parent
+   * @param {keyof Parent} [prop]
+   * @param {number | null} [index]
+   * @returns {Node | null}
+   */
+  visit(node, parent, prop, index) {
+    if (node) {
+      if (this.enter) {
+        const _should_skip = this.should_skip;
+        const _should_remove = this.should_remove;
+        const _replacement = this.replacement;
+        this.should_skip = false;
+        this.should_remove = false;
+        this.replacement = null;
+        this.enter.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const skipped = this.should_skip;
+        const removed = this.should_remove;
+        this.should_skip = _should_skip;
+        this.should_remove = _should_remove;
+        this.replacement = _replacement;
+        if (skipped)
+          return node;
+        if (removed)
+          return null;
+      }
+      let key;
+      for (key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          if (Array.isArray(value)) {
+            const nodes = (
+              /** @type {Array<unknown>} */
+              value
+            );
+            for (let i = 0; i < nodes.length; i += 1) {
+              const item = nodes[i];
+              if (isNode(item)) {
+                if (!this.visit(item, node, key, i)) {
+                  i--;
+                }
+              }
+            }
+          } else if (isNode(value)) {
+            this.visit(value, node, key, null);
+          }
+        }
+      }
+      if (this.leave) {
+        const _replacement = this.replacement;
+        const _should_remove = this.should_remove;
+        this.replacement = null;
+        this.should_remove = false;
+        this.leave.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const removed = this.should_remove;
+        this.replacement = _replacement;
+        this.should_remove = _should_remove;
+        if (removed)
+          return null;
+      }
+    }
+    return node;
+  }
+};
+function isNode(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/async.js
+var AsyncWalker = class extends WalkerBase {
+  /**
+   *
+   * @param {AsyncHandler} [enter]
+   * @param {AsyncHandler} [leave]
+   */
+  constructor(enter, leave) {
+    super();
+    this.should_skip = false;
+    this.should_remove = false;
+    this.replacement = null;
+    this.context = {
+      skip: () => this.should_skip = true,
+      remove: () => this.should_remove = true,
+      replace: (node) => this.replacement = node
+    };
+    this.enter = enter;
+    this.leave = leave;
+  }
+  /**
+   * @template {Node} Parent
+   * @param {Node} node
+   * @param {Parent | null} parent
+   * @param {keyof Parent} [prop]
+   * @param {number | null} [index]
+   * @returns {Promise<Node | null>}
+   */
+  async visit(node, parent, prop, index) {
+    if (node) {
+      if (this.enter) {
+        const _should_skip = this.should_skip;
+        const _should_remove = this.should_remove;
+        const _replacement = this.replacement;
+        this.should_skip = false;
+        this.should_remove = false;
+        this.replacement = null;
+        await this.enter.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const skipped = this.should_skip;
+        const removed = this.should_remove;
+        this.should_skip = _should_skip;
+        this.should_remove = _should_remove;
+        this.replacement = _replacement;
+        if (skipped)
+          return node;
+        if (removed)
+          return null;
+      }
+      let key;
+      for (key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          if (Array.isArray(value)) {
+            const nodes = (
+              /** @type {Array<unknown>} */
+              value
+            );
+            for (let i = 0; i < nodes.length; i += 1) {
+              const item = nodes[i];
+              if (isNode2(item)) {
+                if (!await this.visit(item, node, key, i)) {
+                  i--;
+                }
+              }
+            }
+          } else if (isNode2(value)) {
+            await this.visit(value, node, key, null);
+          }
+        }
+      }
+      if (this.leave) {
+        const _replacement = this.replacement;
+        const _should_remove = this.should_remove;
+        this.replacement = null;
+        this.should_remove = false;
+        await this.leave.call(this.context, node, parent, prop, index);
+        if (this.replacement) {
+          node = this.replacement;
+          this.replace(parent, prop, index, node);
+        }
+        if (this.should_remove) {
+          this.remove(parent, prop, index);
+        }
+        const removed = this.should_remove;
+        this.replacement = _replacement;
+        this.should_remove = _should_remove;
+        if (removed)
+          return null;
+      }
+    }
+    return node;
+  }
+};
+function isNode2(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+// node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+function walk(ast, { enter, leave }) {
+  const instance = new SyncWalker(enter, leave);
+  return instance.visit(ast, null);
+}
+async function asyncWalk(ast, { enter, leave }) {
+  const instance = new AsyncWalker(enter, leave);
+  return await instance.visit(ast, null);
+}
+
+
+
+exports.asyncWalk = asyncWalk; exports.walk = walk;
+exports.default = module.exports;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/types.d.ts

@@ -0,0 +1,168 @@
+import { FilterPattern } from '@rollup/pluginutils';
+import { TransformResult } from 'unplugin';
+import { Awaitable } from '@antfu/utils';
+
+interface ImportInfoLegacy {
+    /**
+     * @deprecated renamed to `as`
+     */
+    name?: string;
+    /**
+     * @deprecated renamed to `name`
+     */
+    importName?: string;
+    /**
+     * @deprecated renamed to `from`
+     */
+    path: string;
+    sideEffects?: SideEffectsInfo;
+}
+interface ImportInfo {
+    as?: string;
+    name?: string;
+    from: string;
+}
+type SideEffectsInfo = (ImportInfo | string)[] | ImportInfo | string | undefined;
+interface ComponentInfo extends ImportInfo {
+    sideEffects?: SideEffectsInfo;
+}
+type ComponentResolveResult = Awaitable<string | ComponentInfo | null | undefined | void>;
+type ComponentResolverFunction = (name: string) => ComponentResolveResult;
+interface ComponentResolverObject {
+    type: 'component' | 'directive';
+    resolve: ComponentResolverFunction;
+}
+type ComponentResolver = ComponentResolverFunction | ComponentResolverObject;
+type Matcher = (id: string) => boolean | null | undefined;
+type Transformer = (code: string, id: string, path: string, query: Record<string, string>) => Awaitable<TransformResult | null>;
+type SupportedTransformer = 'vue3' | 'vue2';
+interface PublicPluginAPI {
+    /**
+     * Resolves a component using the configured resolvers.
+     */
+    findComponent: (name: string, filename?: string) => Promise<ComponentInfo | undefined>;
+    /**
+     * Obtain an import statement for a resolved component.
+     */
+    stringifyImport: (info: ComponentInfo) => string;
+}
+/**
+ * Plugin options.
+ */
+interface Options {
+    /**
+     * RegExp or glob to match files to be transformed
+     */
+    include?: FilterPattern;
+    /**
+     * RegExp or glob to match files to NOT be transformed
+     */
+    exclude?: FilterPattern;
+    /**
+     * Relative paths to the directory to search for components.
+     * @default 'src/components'
+     */
+    dirs?: string | string[];
+    /**
+     * Valid file extensions for components.
+     * @default ['vue']
+     */
+    extensions?: string | string[];
+    /**
+     * Glob patterns to match file names to be detected as components.
+     *
+     * When specified, the `dirs` and `extensions` options will be ignored.
+     */
+    globs?: string | string[];
+    /**
+     * Search for subdirectories
+     * @default true
+     */
+    deep?: boolean;
+    /**
+     * Allow subdirectories as namespace prefix for components
+     * @default false
+     */
+    directoryAsNamespace?: boolean;
+    /**
+     * Collapse same prefixes (camel-sensitive) of folders and components
+     * to prevent duplication inside namespaced component name.
+     *
+     * Works when `directoryAsNamespace: true`
+     * @default false
+     */
+    collapseSamePrefixes?: boolean;
+    /**
+     * Subdirectory paths for ignoring namespace prefixes
+     *
+     * Works when `directoryAsNamespace: true`
+     * @default "[]"
+     */
+    globalNamespaces?: string[];
+    /**
+     * Pass a custom function to resolve the component importing path from the component name.
+     *
+     * The component names are always in PascalCase
+     */
+    resolvers?: (ComponentResolver | ComponentResolver[])[];
+    /**
+     * Apply custom transform over the path for importing
+     */
+    importPathTransform?: (path: string) => string | undefined;
+    /**
+     * Transformer to apply
+     *
+     * @default 'vue3'
+     */
+    transformer?: SupportedTransformer;
+    /**
+     * Generate TypeScript declaration for global components
+     *
+     * Accept boolean or a path related to project root
+     *
+     * @see https://github.com/vuejs/core/pull/3399
+     * @see https://github.com/johnsoncodehk/volar#using
+     * @default true
+     */
+    dts?: boolean | string;
+    /**
+     * Do not emit warning on component overriding
+     *
+     * @default false
+     */
+    allowOverrides?: boolean;
+    /**
+     * auto import for directives.
+     *
+     * default: `true` for Vue 3, `false` for Vue 2
+     *
+     * Babel is needed to do the transformation for Vue 2, it's disabled by default for performance concerns.
+     * To install Babel, run: `npm install -D @babel/parser`
+     * @default undefined
+     */
+    directives?: boolean;
+    /**
+     * Only provide types of components in library (registered globally)
+     **/
+    types?: TypeImport[];
+    /**
+     * Vue version of project. It will detect automatically if not specified.
+     */
+    version?: 2 | 2.7 | 3;
+}
+type ResolvedOptions = Omit<Required<Options>, 'resolvers' | 'extensions' | 'dirs' | 'globalComponentsDeclaration'> & {
+    resolvers: ComponentResolverObject[];
+    extensions: string[];
+    dirs: string[];
+    resolvedDirs: string[];
+    globs: string[];
+    dts: string | false;
+    root: string;
+};
+type ComponentsImportMap = Record<string, string[] | undefined>;
+interface TypeImport {
+    from: string;
+    names: string[];
+}
+
+export { ComponentInfo, ComponentResolveResult, ComponentResolver, ComponentResolverFunction, ComponentResolverObject, ComponentsImportMap, ImportInfo, ImportInfoLegacy, Matcher, Options, PublicPluginAPI, ResolvedOptions, SideEffectsInfo, SupportedTransformer, Transformer, TypeImport };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";require('./chunk-6F4PWJZI.js');
+exports.default = module.exports;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/types.mjs

@@ -0,0 +1 @@
+import "./chunk-WBQAMGXK.mjs";

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/vite.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from 'vite';
+import { Options, PublicPluginAPI } from './types.js';
+import '@rollup/pluginutils';
+import 'unplugin';
+import '@antfu/utils';
+
+declare const _default: (options?: Options | undefined) => Plugin & {
+    api: PublicPluginAPI;
+};
+
+export { _default as default };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/vite.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkZ3TQFCNGjs = require('./chunk-Z3TQFCNG.js');
+require('./chunk-HCIFGIWS.js');
+require('./chunk-BTQOTIPQ.js');
+require('./chunk-6F4PWJZI.js');
+
+// src/vite.ts
+var vite_default = _chunkZ3TQFCNGjs.unplugin_default.vite;
+
+
+module.exports = vite_default;
+exports.default = module.exports;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/vite.mjs

@@ -0,0 +1,12 @@
+import {
+  unplugin_default
+} from "./chunk-WVTE3GCL.mjs";
+import "./chunk-BPHJA2FM.mjs";
+import "./chunk-ZKNUHGJ4.mjs";
+import "./chunk-WBQAMGXK.mjs";
+
+// src/vite.ts
+var vite_default = unplugin_default.vite;
+export {
+  vite_default as default
+};

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/webpack.d.ts

@@ -0,0 +1,9 @@
+import * as webpack from 'webpack';
+import { Options } from './types.js';
+import '@rollup/pluginutils';
+import 'unplugin';
+import '@antfu/utils';
+
+declare const _default: (options: Options) => webpack.WebpackPluginInstance;
+
+export { _default as default };

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/webpack.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkZ3TQFCNGjs = require('./chunk-Z3TQFCNG.js');
+require('./chunk-HCIFGIWS.js');
+require('./chunk-BTQOTIPQ.js');
+require('./chunk-6F4PWJZI.js');
+
+// src/webpack.ts
+var webpack_default = _chunkZ3TQFCNGjs.unplugin_default.webpack;
+
+
+module.exports = webpack_default;
+exports.default = module.exports;

uni_modules/UniDevTools/node_modules/unplugin-vue-components/dist/webpack.mjs

@@ -0,0 +1,12 @@
+import {
+  unplugin_default
+} from "./chunk-WVTE3GCL.mjs";
+import "./chunk-BPHJA2FM.mjs";
+import "./chunk-ZKNUHGJ4.mjs";
+import "./chunk-WBQAMGXK.mjs";
+
+// src/webpack.ts
+var webpack_default = unplugin_default.webpack;
+export {
+  webpack_default as default
+};