jtBaseApp/node_modules/unplugin-vue-components/dist/resolvers.mjs

import {
  camelCase,
  getPkgVersion,
  isSSR,
  kebabCase,
  pascalCase,
  resolveImportPath
} from "./chunk-IN2W2XFC.mjs";
import {
  __require,
  __spreadProps,
  __spreadValues
} from "./chunk-ZKNUHGJ4.mjs";

// src/core/resolvers/antdv.ts
var matchComponents = [
  {
    pattern: /^Avatar/,
    styleDir: "avatar"
  },
  {
    pattern: /^AutoComplete/,
    styleDir: "auto-complete"
  },
  {
    pattern: /^Anchor/,
    styleDir: "anchor"
  },
  {
    pattern: /^Badge/,
    styleDir: "badge"
  },
  {
    pattern: /^Breadcrumb/,
    styleDir: "breadcrumb"
  },
  {
    pattern: /^Button/,
    styleDir: "button"
  },
  {
    pattern: /^Checkbox/,
    styleDir: "checkbox"
  },
  {
    pattern: /^Card/,
    styleDir: "card"
  },
  {
    pattern: /^Collapse/,
    styleDir: "collapse"
  },
  {
    pattern: /^Descriptions/,
    styleDir: "descriptions"
  },
  {
    pattern: /^RangePicker|^WeekPicker|^MonthPicker/,
    styleDir: "date-picker"
  },
  {
    pattern: /^Dropdown/,
    styleDir: "dropdown"
  },
  {
    pattern: /^Form/,
    styleDir: "form"
  },
  {
    pattern: /^InputNumber/,
    styleDir: "input-number"
  },
  {
    pattern: /^Input|^Textarea/,
    styleDir: "input"
  },
  {
    pattern: /^Statistic/,
    styleDir: "statistic"
  },
  {
    pattern: /^CheckableTag/,
    styleDir: "tag"
  },
  {
    pattern: /^TimeRangePicker/,
    styleDir: "time-picker"
  },
  {
    pattern: /^Layout/,
    styleDir: "layout"
  },
  {
    pattern: /^Menu|^SubMenu/,
    styleDir: "menu"
  },
  {
    pattern: /^Table/,
    styleDir: "table"
  },
  {
    pattern: /^TimePicker|^TimeRangePicker/,
    styleDir: "time-picker"
  },
  {
    pattern: /^Radio/,
    styleDir: "radio"
  },
  {
    pattern: /^Image/,
    styleDir: "image"
  },
  {
    pattern: /^List/,
    styleDir: "list"
  },
  {
    pattern: /^Tab/,
    styleDir: "tabs"
  },
  {
    pattern: /^Mentions/,
    styleDir: "mentions"
  },
  {
    pattern: /^Step/,
    styleDir: "steps"
  },
  {
    pattern: /^Skeleton/,
    styleDir: "skeleton"
  },
  {
    pattern: /^Select/,
    styleDir: "select"
  },
  {
    pattern: /^TreeSelect/,
    styleDir: "tree-select"
  },
  {
    pattern: /^Tree|^DirectoryTree/,
    styleDir: "tree"
  },
  {
    pattern: /^Typography/,
    styleDir: "typography"
  },
  {
    pattern: /^Timeline/,
    styleDir: "timeline"
  },
  {
    pattern: /^Upload/,
    styleDir: "upload"
  }
];
function getStyleDir(compName) {
  let styleDir;
  const total = matchComponents.length;
  for (let i = 0; i < total; i++) {
    const matcher = matchComponents[i];
    if (compName.match(matcher.pattern)) {
      styleDir = matcher.styleDir;
      break;
    }
  }
  if (!styleDir)
    styleDir = kebabCase(compName);
  return styleDir;
}
function getSideEffects(compName, options) {
  const {
    importStyle = true,
    importLess = false
  } = options;
  if (!importStyle)
    return;
  const lib = options.cjs ? "lib" : "es";
  const packageName = (options == null ? void 0 : options.packageName) || "ant-design-vue";
  if (importStyle === "less" || importLess) {
    const styleDir = getStyleDir(compName);
    return `${packageName}/${lib}/${styleDir}/style`;
  } else {
    const styleDir = getStyleDir(compName);
    return `${packageName}/${lib}/${styleDir}/style/css`;
  }
}
var primitiveNames = ["Affix", "Anchor", "AnchorLink", "AutoComplete", "AutoCompleteOptGroup", "AutoCompleteOption", "Alert", "Avatar", "AvatarGroup", "BackTop", "Badge", "BadgeRibbon", "Breadcrumb", "BreadcrumbItem", "BreadcrumbSeparator", "Button", "ButtonGroup", "Calendar", "Card", "CardGrid", "CardMeta", "Collapse", "CollapsePanel", "Carousel", "Cascader", "Checkbox", "CheckboxGroup", "Col", "Comment", "ConfigProvider", "DatePicker", "MonthPicker", "WeekPicker", "RangePicker", "QuarterPicker", "Descriptions", "DescriptionsItem", "Divider", "Dropdown", "DropdownButton", "Drawer", "Empty", "Form", "FormItem", "FormItemRest", "Grid", "Input", "InputGroup", "InputPassword", "InputSearch", "Textarea", "Image", "ImagePreviewGroup", "InputNumber", "Layout", "LayoutHeader", "LayoutSider", "LayoutFooter", "LayoutContent", "List", "ListItem", "ListItemMeta", "Menu", "MenuDivider", "MenuItem", "MenuItemGroup", "SubMenu", "Mentions", "MentionsOption", "Modal", "Statistic", "StatisticCountdown", "PageHeader", "Pagination", "Popconfirm", "Popover", "Progress", "Radio", "RadioButton", "RadioGroup", "Rate", "Result", "Row", "Select", "SelectOptGroup", "SelectOption", "Skeleton", "SkeletonButton", "SkeletonAvatar", "SkeletonInput", "SkeletonImage", "Slider", "Space", "Spin", "Steps", "Step", "Switch", "Table", "TableColumn", "TableColumnGroup", "TableSummary", "TableSummaryRow", "TableSummaryCell", "Transfer", "Tree", "TreeNode", "DirectoryTree", "TreeSelect", "TreeSelectNode", "Tabs", "TabPane", "Tag", "CheckableTag", "TimePicker", "TimeRangePicker", "Timeline", "TimelineItem", "Tooltip", "Typography", "TypographyLink", "TypographyParagraph", "TypographyText", "TypographyTitle", "Upload", "UploadDragger", "LocaleProvider"];
var prefix = "A";
var antdvNames;
function genAntdNames(primitiveNames2) {
  antdvNames = new Set(primitiveNames2.map((name) => `${prefix}${name}`));
}
genAntdNames(primitiveNames);
function isAntdv(compName) {
  return antdvNames.has(compName);
}
function AntDesignVueResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      var _a;
      if (options.resolveIcons && name.match(/(Outlined|Filled|TwoTone)$/)) {
        return {
          name,
          from: "@ant-design/icons-vue"
        };
      }
      if (isAntdv(name) && !((_a = options == null ? void 0 : options.exclude) == null ? void 0 : _a.includes(name))) {
        const importName = name.slice(1);
        const { cjs = false, packageName = "ant-design-vue" } = options;
        const path = `${packageName}/${cjs ? "lib" : "es"}`;
        return {
          name: importName,
          from: path,
          sideEffects: getSideEffects(importName, options)
        };
      }
    }
  };
}

// node_modules/.pnpm/compare-versions@5.0.1/node_modules/compare-versions/lib/esm/index.js
var compareVersions = (v1, v2) => {
  const n1 = validateAndParse(v1);
  const n2 = validateAndParse(v2);
  const p1 = n1.pop();
  const p2 = n2.pop();
  const r = compareSegments(n1, n2);
  if (r !== 0)
    return r;
  if (p1 && p2) {
    return compareSegments(p1.split("."), p2.split("."));
  } else if (p1 || p2) {
    return p1 ? -1 : 1;
  }
  return 0;
};
var compare = (v1, v2, operator) => {
  assertValidOperator(operator);
  const res = compareVersions(v1, v2);
  return operatorResMap[operator].includes(res);
};
var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
var validateAndParse = (version) => {
  if (typeof version !== "string") {
    throw new TypeError("Invalid argument expected string");
  }
  const match = version.match(semver);
  if (!match) {
    throw new Error(`Invalid argument not valid semver ('${version}' received)`);
  }
  match.shift();
  return match;
};
var isWildcard = (s) => s === "*" || s === "x" || s === "X";
var tryParse = (v) => {
  const n = parseInt(v, 10);
  return isNaN(n) ? v : n;
};
var forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
var compareStrings = (a, b) => {
  if (isWildcard(a) || isWildcard(b))
    return 0;
  const [ap, bp] = forceType(tryParse(a), tryParse(b));
  if (ap > bp)
    return 1;
  if (ap < bp)
    return -1;
  return 0;
};
var compareSegments = (a, b) => {
  for (let i = 0; i < Math.max(a.length, b.length); i++) {
    const r = compareStrings(a[i] || "0", b[i] || "0");
    if (r !== 0)
      return r;
  }
  return 0;
};
var operatorResMap = {
  ">": [1],
  ">=": [0, 1],
  "=": [0],
  "<=": [-1, 0],
  "<": [-1]
};
var allowedOperators = Object.keys(operatorResMap);
var assertValidOperator = (op) => {
  if (typeof op !== "string") {
    throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);
  }
  if (allowedOperators.indexOf(op) === -1) {
    throw new Error(`Invalid operator, expected one of ${allowedOperators.join("|")}`);
  }
};

// src/core/resolvers/element-plus.ts
function getSideEffectsLegacy(partialName, options) {
  const { importStyle } = options;
  if (!importStyle)
    return;
  if (importStyle === "sass") {
    return [
      "element-plus/packages/theme-chalk/src/base.scss",
      `element-plus/packages/theme-chalk/src/${partialName}.scss`
    ];
  } else if (importStyle === true || importStyle === "css") {
    return [
      "element-plus/lib/theme-chalk/base.css",
      `element-plus/lib/theme-chalk/el-${partialName}.css`
    ];
  }
}
function getSideEffects2(dirName, options) {
  const { importStyle, ssr } = options;
  const themeFolder = "element-plus/theme-chalk";
  const esComponentsFolder = "element-plus/es/components";
  if (importStyle === "sass")
    return ssr ? `${themeFolder}/src/${dirName}.scss` : `${esComponentsFolder}/${dirName}/style/index`;
  else if (importStyle === true || importStyle === "css")
    return ssr ? `${themeFolder}/el-${dirName}.css` : `${esComponentsFolder}/${dirName}/style/css`;
}
function resolveComponent(name, options) {
  if (options.exclude && name.match(options.exclude))
    return;
  if (!name.match(/^El[A-Z]/))
    return;
  if (name.match(/^ElIcon.+/)) {
    return {
      name: name.replace(/^ElIcon/, ""),
      from: "@element-plus/icons-vue"
    };
  }
  const partialName = kebabCase(name.slice(2));
  const { version, ssr } = options;
  if (compare(version, "1.1.0-beta.1", ">=")) {
    return {
      name,
      from: `element-plus/${ssr ? "lib" : "es"}`,
      sideEffects: getSideEffects2(partialName, options)
    };
  } else if (compare(version, "1.0.2-beta.28", ">=")) {
    return {
      from: `element-plus/es/el-${partialName}`,
      sideEffects: getSideEffectsLegacy(partialName, options)
    };
  } else {
    return {
      from: `element-plus/lib/el-${partialName}`,
      sideEffects: getSideEffectsLegacy(partialName, options)
    };
  }
}
function resolveDirective(name, options) {
  if (!options.directives)
    return;
  const directives2 = {
    Loading: { importName: "ElLoadingDirective", styleName: "loading" },
    Popover: { importName: "ElPopoverDirective", styleName: "popover" },
    InfiniteScroll: { importName: "ElInfiniteScroll", styleName: "infinite-scroll" }
  };
  const directive = directives2[name];
  if (!directive)
    return;
  const { version, ssr } = options;
  if (compare(version, "1.1.0-beta.1", ">=")) {
    return {
      name: directive.importName,
      from: `element-plus/${ssr ? "lib" : "es"}`,
      sideEffects: getSideEffects2(directive.styleName, options)
    };
  }
}
var noStylesComponents = ["ElAutoResizer"];
function ElementPlusResolver(options = {}) {
  let optionsResolved;
  async function resolveOptions() {
    if (optionsResolved)
      return optionsResolved;
    optionsResolved = __spreadValues({
      ssr: false,
      version: await getPkgVersion("element-plus", "2.2.2"),
      importStyle: "css",
      directives: true,
      exclude: void 0,
      noStylesComponents: options.noStylesComponents || []
    }, options);
    return optionsResolved;
  }
  return [
    {
      type: "component",
      resolve: async (name) => {
        const options2 = await resolveOptions();
        if ([...options2.noStylesComponents, ...noStylesComponents].includes(name))
          return resolveComponent(name, __spreadProps(__spreadValues({}, options2), { importStyle: false }));
        else
          return resolveComponent(name, options2);
      }
    },
    {
      type: "directive",
      resolve: async (name) => {
        return resolveDirective(name, await resolveOptions());
      }
    }
  ];
}

// src/core/resolvers/element-ui.ts
function getSideEffects3(partialName, options) {
  const { importStyle = "css" } = options;
  if (!importStyle)
    return;
  if (importStyle === "sass") {
    return [
      "element-ui/packages/theme-chalk/src/base.scss",
      `element-ui/packages/theme-chalk/src/${partialName}.scss`
    ];
  } else {
    return [
      "element-ui/lib/theme-chalk/base.css",
      `element-ui/lib/theme-chalk/${partialName}.css`
    ];
  }
}
function ElementUiResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      if (options.exclude && name.match(options.exclude))
        return;
      if (/^El[A-Z]/.test(name)) {
        const compName = name.slice(2);
        const partialName = kebabCase(compName);
        if (partialName === "collapse-transition") {
          return {
            from: `element-ui/lib/transitions/${partialName}`
          };
        }
        return {
          from: `element-ui/lib/${partialName}`,
          sideEffects: getSideEffects3(partialName, options)
        };
      }
    }
  };
}

// src/core/resolvers/headless-ui.ts
var components = [
  "Combobox",
  "ComboboxButton",
  "ComboboxInput",
  "ComboboxLabel",
  "ComboboxOption",
  "ComboboxOptions",
  "Dialog",
  "DialogDescription",
  "DialogOverlay",
  "DialogTitle",
  "DialogPanel",
  "Disclosure",
  "DisclosureButton",
  "DisclosurePanel",
  "FocusTrap",
  "Listbox",
  "ListboxButton",
  "ListboxLabel",
  "ListboxOption",
  "ListboxOptions",
  "Menu",
  "MenuButton",
  "MenuItem",
  "MenuItems",
  "Popover",
  "PopoverButton",
  "PopoverGroup",
  "PopoverOverlay",
  "PopoverPanel",
  "Portal",
  "PortalGroup",
  "RadioGroup",
  "RadioGroupDescription",
  "RadioGroupLabel",
  "RadioGroupOption",
  "Switch",
  "SwitchDescription",
  "SwitchGroup",
  "SwitchLabel",
  "TransitionChild",
  "TransitionRoot",
  "TabGroup",
  "TabList",
  "Tab",
  "TabPanels",
  "TabPanel"
];
function HeadlessUiResolver(options = {}) {
  const { prefix: prefix2 = "" } = options;
  return {
    type: "component",
    resolve: (name) => {
      if (name.startsWith(prefix2)) {
        const componentName = name.substring(prefix2.length);
        if (components.includes(componentName)) {
          return {
            name: componentName,
            from: "@headlessui/vue"
          };
        }
      }
    }
  };
}

// src/core/resolvers/idux.ts
var specialComponents = {
  CdkVirtualScroll: "scroll",
  IxAutoComplete: "auto-complete",
  IxBackTop: "back-top",
  IxDatePicker: "date-picker",
  IxDateRangePicker: "date-picker",
  IxCol: "grid",
  IxRow: "grid",
  IxInputNumber: "input-number",
  IxTab: "tabs",
  IxTreeSelect: "tree-select",
  IxTimePicker: "time-picker",
  IxTimeRangePicker: "time-picker"
};
function IduxResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      const { importStyle, importStyleTheme = "default", exclude = [], scope = "@idux" } = options;
      if (exclude.includes(name))
        return;
      const packageName = getPackageName(name);
      if (!packageName)
        return;
      let dirname = specialComponents[name];
      if (!dirname) {
        const nameIndex = packageName === "pro" ? 2 : 1;
        dirname = kebabCase(name).split("-")[nameIndex];
      }
      const path = `${scope}/${packageName}/${dirname}`;
      let sideEffects;
      if (packageName !== "cdk" && importStyle)
        sideEffects = `${path}/style/themes/${importStyle === "css" ? `${importStyleTheme}_css` : importStyleTheme}`;
      return { name, from: path, sideEffects };
    }
  };
}
function getPackageName(name) {
  let packageName;
  if (name.match(/^Cdk[A-Z]/))
    packageName = "cdk";
  else if (name.match(/^IxPro[A-Z]/))
    packageName = "pro";
  else if (name.match(/^Ix[A-Z]/))
    packageName = "components";
  return packageName;
}

// src/core/resolvers/inkline.ts
function InklineResolver() {
  return {
    type: "component",
    resolve: (name) => {
      if (name.match(/^I[A-Z]/)) {
        return {
          name,
          from: "@inkline/inkline"
        };
      }
    }
  };
}

// src/core/resolvers/naive-ui.ts
function NaiveUiResolver() {
  return {
    type: "component",
    resolve: (name) => {
      if (name.match(/^(N[A-Z]|n-[a-z])/))
        return { name, from: "naive-ui" };
    }
  };
}

// src/core/resolvers/prime-vue.ts
var components2 = [
  "Accordion",
  "AccordionTab",
  "AutoComplete",
  "Avatar",
  "AvatarGroup",
  "Badge",
  "BlockUI",
  "Breadcrumb",
  "Button",
  "Calendar",
  "Card",
  "Carousel",
  "CascadeSelect",
  "Chart",
  "Checkbox",
  "Chip",
  "Chips",
  "ColorPicker",
  "Column",
  "ColumnGroup",
  "ContextMenu",
  "DataTable",
  "DataView",
  "DataViewLayoutOptions",
  "DeferredContent",
  "Dialog",
  "Divider",
  "Dock",
  "Dropdown",
  "Editor",
  "Fieldset",
  "FileUpload",
  "FullCalendar",
  "Galleria",
  "Image",
  "InlineMessage",
  "Inplace",
  "InputMask",
  "InputNumber",
  "InputSwitch",
  "InputText",
  "Knob",
  "Listbox",
  "MegaMenu",
  "Menu",
  "Menubar",
  "Message",
  "MultiSelect",
  "OrderList",
  "OrganizationChart",
  "OverlayPanel",
  "Paginator",
  "Panel",
  "PanelMenu",
  "Password",
  "PickList",
  "ProgressBar",
  "ProgressSpinner",
  "RadioButton",
  "Rating",
  "Row",
  "ScrollPanel",
  "ScrollTop",
  "SelectButton",
  "Sidebar",
  "Skeleton",
  "Slider",
  "SpeedDial",
  "SplitButton",
  "Splitter",
  "SplitterPanel",
  "Steps",
  "TabMenu",
  "TabPanel",
  "TabView",
  "Tag",
  "Terminal",
  "TerminalService",
  "Textarea",
  "TieredMenu",
  "Timeline",
  "Timelist",
  "ToggleButton",
  "Toolbar",
  "Tree",
  "TreeSelect",
  "TreeTable",
  "TriStateCheckbox",
  "VirtualScroller"
];
function PrimeVueResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      const sideEffects = [];
      if (options.importStyle)
        sideEffects.push("primevue/resources/primevue.min.css");
      if (options.importIcons)
        sideEffects.push("primeicons/primeicons.css");
      if (options.importTheme) {
        sideEffects.push(
          `primevue/resources/themes/${options.importTheme}/theme.css`
        );
      }
      if (options.prefix) {
        if (!name.startsWith(options.prefix))
          return;
        name = name.substring(options.prefix.length);
      }
      if (components2.includes(name)) {
        return {
          from: `primevue/${name.toLowerCase()}`,
          sideEffects
        };
      }
    }
  };
}

// src/core/resolvers/vant.ts
var moduleType = isSSR ? "lib" : "es";
function getSideEffects4(dirName, options) {
  const { importStyle = true } = options;
  if (!importStyle || isSSR)
    return;
  if (importStyle === "less")
    return `vant/${moduleType}/${dirName}/style/less`;
  if (importStyle === "css")
    return `vant/${moduleType}/${dirName}/style/index`;
  return `vant/${moduleType}/${dirName}/style/index`;
}
function VantResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      if (name.startsWith("Van")) {
        const partialName = name.slice(3);
        return {
          name: partialName,
          from: `vant/${moduleType}`,
          sideEffects: getSideEffects4(kebabCase(partialName), options)
        };
      }
    }
  };
}

// src/core/resolvers/varlet-ui.ts
var varFunctions = ["ImagePreview", "Snackbar", "Picker", "ActionSheet", "Dialog", "Locale", "StyleProvider", "LoadingBar"];
var varDirectives = ["Ripple", "Lazy"];
function getResolved(name, options) {
  const {
    importStyle = "css",
    importCss = true,
    importLess,
    autoImport = false,
    version = "vue3"
  } = options;
  const path = version === "vue2" ? "@varlet-vue2/ui" : "@varlet/ui";
  const sideEffects = [];
  if (importStyle || importCss) {
    if (importStyle === "less" || importLess)
      sideEffects.push(`${path}/es/${kebabCase(name)}/style/less.js`);
    else
      sideEffects.push(`${path}/es/${kebabCase(name)}/style`);
  }
  return {
    from: path,
    name: autoImport ? name : `_${name}Component`,
    sideEffects
  };
}
function VarletUIResolver(options = {}) {
  return [
    {
      type: "component",
      resolve: (name) => {
        const { autoImport = false } = options;
        if (autoImport && varFunctions.includes(name))
          return getResolved(name, options);
        if (name.startsWith("Var"))
          return getResolved(name.slice(3), options);
      }
    },
    {
      type: "directive",
      resolve: (name) => {
        const { directives: directives2 = true } = options;
        if (!directives2)
          return;
        if (!varDirectives.includes(name))
          return;
        return getResolved(name, options);
      }
    }
  ];
}

// src/core/resolvers/veui.ts
import { join, normalize } from "path";
var VEUI_PACKAGE_NAME = "veui";
var components3;
function VeuiResolver(options = {}) {
  const { alias = VEUI_PACKAGE_NAME } = options;
  if (!components3) {
    try {
      const componentsData = __require(`${alias}/components.json`);
      components3 = new Set(componentsData.map(({ name }) => name));
    } catch (e) {
      throw new Error("[unplugin-vue-components:veui] VEUI is not installed");
    }
  }
  return {
    type: "component",
    resolve: (name) => {
      if (name.match(/^Veui[A-Z]/)) {
        const componentName = name.slice(4);
        if (!components3.has(componentName))
          return;
        const sideEffects = getSideEffects5(componentName, options);
        return { name: componentName, from: alias, sideEffects };
      }
    }
  };
}
var formatters = {
  "kebab-case": kebabCase,
  "camelCase": camelCase,
  "PascalCase": pascalCase
};
var peerPaths = /* @__PURE__ */ new Map();
function assertPeerPath(peerPath) {
  if (!peerPaths.has(peerPath)) {
    try {
      resolveImportPath(peerPath);
      peerPaths.set(peerPath, true);
    } catch (e) {
      peerPaths.set(peerPath, false);
    }
  }
  return peerPaths.get(peerPath);
}
function getSideEffects5(name, {
  alias = VEUI_PACKAGE_NAME,
  modules = [],
  locale = "zh-Hans",
  global = []
}) {
  const localeModules = (locale ? Array.isArray(locale) ? locale : [locale] : []).map((locale2) => `${alias}/locale/${locale2}/${name}.js`);
  const peerModules = modules.map(
    ({
      package: pack,
      path = "components",
      fileName = "{module}.css",
      transform = "kebab-case"
    }) => {
      const peer = transform ? formatters[transform](name) : name;
      const file = fileName.replace(/\$?\{module\}/g, peer);
      return normalize(join(pack, path, file));
    }
  );
  return [...localeModules, ...global, ...peerModules].filter(assertPeerPath);
}

// src/core/resolvers/view-ui.ts
function getSideEffects6(componentName) {
  const sideEffects = [
    "view-design/dist/styles/iview.css",
    "popper.js/dist/umd/popper.js"
  ];
  if (/^Table|^Slider|^Tab/.test(componentName))
    sideEffects.push("element-resize-detector");
  if (componentName.startsWith("Date"))
    sideEffects.push("js-calendar");
  return sideEffects;
}
var matchComponents2 = [
  {
    pattern: /^List/,
    compDir: "list"
  }
];
function getCompDir(compName) {
  let compPath;
  const total = matchComponents2.length;
  for (let i = 0; i < total; i++) {
    const matcher = matchComponents2[i];
    if (compName.match(matcher.pattern)) {
      compPath = `${matcher.compDir}/${kebabCase(compName)}.vue`;
      break;
    }
  }
  if (!compPath)
    compPath = kebabCase(compName);
  return compPath;
}
function ViewUiResolver() {
  return {
    type: "component",
    resolve: (name) => {
      if (name.match(/^I[A-Z]/)) {
        const compName = name.slice(1);
        return {
          from: `view-design/src/components/${getCompDir(compName)}`,
          sideEffects: getSideEffects6(compName)
        };
      }
    }
  };
}

// src/core/resolvers/vuetify.ts
function VuetifyResolver() {
  return {
    type: "component",
    resolve: (name) => {
      if (name.match(/^V[A-Z]/))
        return { name, from: "vuetify/lib" };
    }
  };
}
function Vuetify3Resolver() {
  return {
    type: "component",
    resolve: (name) => {
      if (name.match(/^V[A-Z]/))
        return { name, from: "vuetify/components" };
    }
  };
}

// src/core/resolvers/vueuse.ts
import { readFileSync } from "fs";
import { resolveModule } from "local-pkg";
var components4;
function VueUseComponentsResolver() {
  return {
    type: "component",
    resolve: (name) => {
      if (!components4) {
        let indexesJson;
        try {
          const corePath = resolveModule("@vueuse/core") || process.cwd();
          const path = resolveModule("@vueuse/core/indexes.json") || resolveModule("@vueuse/metadata/index.json") || resolveModule("@vueuse/metadata/index.json", { paths: [corePath] });
          indexesJson = JSON.parse(readFileSync(path, "utf-8"));
          components4 = indexesJson.functions.filter((i) => i.component && i.name).map(({ name: name2 }) => name2[0].toUpperCase() + name2.slice(1));
        } catch (error) {
          console.error(error);
          throw new Error("[vue-components] failed to load @vueuse/core, have you installed it?");
        }
      }
      if (components4 && components4.includes(name))
        return { name, as: name, from: "@vueuse/components" };
    }
  };
}

// src/core/resolvers/vueuse-directive.ts
import { readFileSync as readFileSync2 } from "fs";
import { resolveModule as resolveModule2 } from "local-pkg";
var directives;
function VueUseDirectiveResolver() {
  return {
    type: "directive",
    resolve: (name) => {
      if (!directives) {
        let indexesJson;
        try {
          const corePath = resolveModule2("@vueuse/core") || process.cwd();
          const path = resolveModule2("@vueuse/core/indexes.json") || resolveModule2("@vueuse/metadata/index.json") || resolveModule2("@vueuse/metadata/index.json", { paths: [corePath] });
          indexesJson = JSON.parse(readFileSync2(path, "utf-8"));
          directives = indexesJson.functions.filter((i) => i.directive && i.name).map(({ name: name2 }) => name2[0].toUpperCase() + name2.slice(1)).map((name2) => name2.startsWith("Use") ? name2.slice(3) : name2);
        } catch (error) {
          console.error(error);
          throw new Error("[vue-components] failed to load @vueuse/core, have you installed it?");
        }
      }
      if (directives && directives.includes(name))
        return { name: `v${name}`, as: name, from: "@vueuse/components" };
    }
  };
}

// src/core/resolvers/quasar.ts
import { promises as fs } from "fs";
import { resolveModule as resolveModule3 } from "local-pkg";
function QuasarResolver() {
  let components5 = [];
  return {
    type: "component",
    resolve: async (name) => {
      if (!components5.length) {
        const quasarApiListPath = resolveModule3("quasar/dist/transforms/api-list.json");
        if (quasarApiListPath)
          components5 = JSON.parse(await fs.readFile(quasarApiListPath, "utf-8"));
      }
      if (components5.includes(name))
        return { name, from: "quasar" };
    }
  };
}

// src/core/resolvers/devui.ts
var LIB_NAME = "vue-devui";
var HARMLESS = ["ripple"];
function resolveDirectory(name, filename) {
  return `${LIB_NAME}/${name}/${filename}`;
}
function getSideEffects7(name) {
  if (HARMLESS.includes(name))
    return;
  if (["row", "col"].includes(name))
    return resolveDirectory("grid", "style.css");
  if (["aside", "content", "footer", "header", "layout"].includes(name))
    return resolveDirectory("layout", "style.css");
  if (["overlay", "fixed-overlay", "flexible-overlay"].includes(name))
    return resolveDirectory("overlay", "style.css");
  return resolveDirectory(name, "style.css");
}
function componentsResolver(name, { ssr }) {
  if (!name.match(/^D[A-Z]/))
    return;
  const resolveId = kebabCase(name = name.slice(1));
  return {
    name,
    sideEffects: getSideEffects7(resolveId),
    from: resolveDirectory(resolveId, `index.${ssr ? "umd" : "es"}.js`)
  };
}
function directivesResolver(name, { ssr }) {
  const resolveId = kebabCase(name);
  return {
    name: `${name}Directive`,
    sideEffects: getSideEffects7(resolveId),
    from: resolveDirectory(resolveId, `index.${ssr ? "umd" : "es"}.js`)
  };
}
function DevUiResolver(options = {}) {
  const config = __spreadValues({ directives: true, importStyle: true, ssr: false }, options);
  const resolvers = [
    {
      type: "component",
      resolve: (name) => componentsResolver(name, config)
    }
  ];
  if (config.directives) {
    resolvers.push({
      type: "directive",
      resolve: (name) => directivesResolver(name, config)
    });
  }
  return resolvers;
}

// src/core/resolvers/arco.ts
import Debug from "debug";
var debug = Debug("unplugin-vue-components:resolvers:arco");
var matchComponents3 = [
  {
    pattern: /^AnchorLink$/,
    componentDir: "anchor"
  },
  {
    pattern: /^AvatarGroup$/,
    componentDir: "avatar"
  },
  {
    pattern: /^BreadcrumbItem$/,
    componentDir: "breadcrumb"
  },
  {
    pattern: /^ButtonGroup$/,
    componentDir: "button"
  },
  {
    pattern: /^(CardMeta|CardGrid)$/,
    componentDir: "card"
  },
  {
    pattern: /^CarouselItem$/,
    componentDir: "carousel"
  },
  {
    pattern: /^CascaderPanel$/,
    componentDir: "cascader"
  },
  {
    pattern: /^CheckboxGroup$/,
    componentDir: "checkbox"
  },
  {
    pattern: /^CollapseItem$/,
    componentDir: "collapse"
  },
  {
    pattern: /^(WeekPicker|MonthPicker|YearPicker|QuarterPicker|RangePicker)$/,
    componentDir: "date-picker"
  },
  {
    pattern: /^DescriptionsItem$/,
    componentDir: "descriptions"
  },
  {
    pattern: /^(Doption|Dgroup|Dsubmenu|DropdownButton)$/,
    componentDir: "dropdown"
  },
  {
    pattern: /^FormItem$/,
    componentDir: "form"
  },
  {
    pattern: /^(Col|Row|GridItem)$/,
    componentDir: "grid"
  },
  {
    pattern: /^(ImagePreview|ImagePreviewGroup)$/,
    componentDir: "image"
  },
  {
    pattern: /^(InputGroup|InputSearch|InputPassword)$/,
    componentDir: "input"
  },
  {
    pattern: /^(LayoutHeader|LayoutContent|LayoutFooter|LayoutSider)$/,
    componentDir: "layout"
  },
  {
    pattern: /^(ListItem|ListItemMeta)$/,
    componentDir: "list"
  },
  {
    pattern: /^(MenuItem|MenuItemGroup|SubMenu)$/,
    componentDir: "menu"
  },
  {
    pattern: /^RadioGroup$/,
    componentDir: "radio"
  },
  {
    pattern: /^(Option|Optgroup)$/,
    componentDir: "select"
  },
  {
    pattern: /^(SkeletonLine|SkeletonShape)$/,
    componentDir: "skeleton"
  },
  {
    pattern: /^Countdown$/,
    componentDir: "statistic"
  },
  {
    pattern: /^Step$/,
    componentDir: "steps"
  },
  {
    pattern: /^(Thead|Td|Th|Tr|Tbody|TableColumn)$/,
    componentDir: "table"
  },
  {
    pattern: /^TagGroup$/,
    componentDir: "tag"
  },
  {
    pattern: /^TabPane$/,
    componentDir: "tabs"
  },
  {
    pattern: /^TimelineItem$/,
    componentDir: "timeline"
  },
  {
    pattern: /^(TypographyParagraph|TypographyTitle|TypographyText)$/,
    componentDir: "typography"
  }
];
function getComponentStyleDir(importName, importStyle) {
  if (["ConfigProvider", "Icon"].includes(importName))
    return void 0;
  let componentDir = kebabCase(importName);
  for (const item of matchComponents3) {
    if (item.pattern.test(importName)) {
      componentDir = item.componentDir;
      break;
    }
  }
  if (importStyle === "less")
    return `@arco-design/web-vue/es/${componentDir}/style/index.js`;
  if (importStyle === "css" || importStyle)
    return `@arco-design/web-vue/es/${componentDir}/style/css.js`;
}
function canResolveIcons(options) {
  if (options === void 0)
    return false;
  if (typeof options === "boolean")
    return options;
  else
    return options.enable;
}
function getResolveIconPrefix(options) {
  var _a;
  if (canResolveIcons(options)) {
    if (typeof options === "boolean" && options)
      return "";
    else if (options.enable)
      return (_a = options.iconPrefix) != null ? _a : "";
    else
      return "";
  }
  return "";
}
function ArcoResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      var _a;
      if (canResolveIcons(options.resolveIcons)) {
        const iconPrefix = pascalCase(getResolveIconPrefix(options.resolveIcons));
        const newNameRegexp = new RegExp(`^${iconPrefix}Icon`);
        if (newNameRegexp.test(name)) {
          debug("found icon component name %s", name);
          const rawComponentName = name.slice(iconPrefix.length);
          debug("found icon component raw name %s", rawComponentName);
          return {
            name: rawComponentName,
            as: name,
            from: "@arco-design/web-vue/es/icon"
          };
        }
      }
      if (name.match(/^A[A-Z]/)) {
        const importStyle = (_a = options.importStyle) != null ? _a : "css";
        const importName = name.slice(1);
        const config = {
          name: importName,
          from: "@arco-design/web-vue"
        };
        if (options.sideEffect !== false)
          config.sideEffects = getComponentStyleDir(importName, importStyle);
        return config;
      }
    }
  };
}

// src/core/resolvers/tdesign.ts
function getSideEffects8(importName, options) {
  const { library = "vue", importStyle = "css" } = options;
  let fileName = kebabCase(importName);
  if (!importStyle)
    return;
  if (["config-provider", "icon"].includes(fileName))
    return;
  if (fileName.includes("-") && fileName !== "input-number") {
    const prefix2 = fileName.slice(0, fileName.indexOf("-"));
    const container = ["anchor", "avatar", "breadcrumb", "checkbox", "dropdown", "form", "input", "list", "menu", "radio", "slider", "swiper", "color-picker", "text", "collapse", "timeline"];
    if (container.includes(prefix2))
      fileName = prefix2;
  }
  if (["row", "col"].includes(fileName))
    fileName = "grid";
  if (fileName === "addon")
    fileName = "input";
  if (["aside", "layout", "header", "footer", "content"].includes(fileName))
    fileName = "layout";
  if (["head-menu", "submenu"].includes(fileName))
    fileName = "menu";
  if (["option", "option-group"].includes(fileName))
    fileName = "select";
  if (["tab-nav", "tab-panel"].includes(fileName))
    fileName = "tabs";
  if (fileName === "step-item")
    fileName = "steps";
  if (fileName === "check-tag")
    fileName = "tag";
  if (["time-range-picker", "time-range-picker-panel", "time-picker-panel"].includes(fileName))
    fileName = "time-picker";
  if (["date-range-picker", "date-range-picker-panel", "date-picker-panel"].includes(fileName))
    fileName = "date-picker";
  if (["color-picker", "color-picker-panel"].includes(fileName))
    fileName = "color-picker";
  if (["enhanced-table", "base-table"].includes(fileName))
    fileName = "table";
  if (importStyle === "less")
    return `tdesign-${library}/esm/${fileName}/style`;
  return `tdesign-${library}/es/${fileName}/style`;
}
function TDesignResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      const { library = "vue", exclude } = options;
      const importFrom = options.esm ? "/esm" : "";
      if (options.exclude && isExclude(name, exclude))
        return;
      if (options.resolveIcons && name.match(/[a-z]Icon$/)) {
        return {
          name,
          from: `tdesign-icons-${library}${importFrom}`
        };
      }
      if (name.match(/^T[A-Z]/)) {
        const importName = name.slice(1);
        return {
          name: importName,
          from: `tdesign-${library}${importFrom}`,
          sideEffects: getSideEffects8(importName, options)
        };
      }
    }
  };
}
function isExclude(name, exclude) {
  if (typeof exclude === "string")
    return name === exclude;
  if (exclude instanceof RegExp)
    return !!name.match(exclude);
  if (Array.isArray(exclude)) {
    for (const item of exclude) {
      if (name === item || name.match(item))
        return true;
    }
  }
  return false;
}

// src/core/resolvers/layui-vue.ts
var matchComponents4 = [
  {
    pattern: /^LayAvatarList$/,
    styleDir: "avatar"
  },
  {
    pattern: /^LayBreadcrumbItem$/,
    styleDir: "breadcrumb"
  },
  {
    pattern: /^(LayCarouselItem)$/,
    styleDir: "carousel"
  },
  {
    pattern: /^(LayCheckboxGroup)$/,
    styleDir: "checkbox"
  },
  {
    pattern: /^LayCol$/,
    styleDir: "row"
  },
  {
    pattern: /^(LayCollapseItem)$/,
    styleDir: "collapse"
  },
  {
    pattern: /^LayConfigProvider$/,
    styleDir: void 0
  },
  {
    pattern: /^LayCountUp$/,
    styleDir: void 0
  },
  {
    pattern: /^(LayDropdownMenu|LayDropdownMenuItem|LayDropdownSubMenu)$/,
    styleDir: "dropdown"
  },
  {
    pattern: /^(LayFormItem)$/,
    styleDir: "form"
  },
  {
    pattern: /^(LayMenuItem|LaySubMenu)$/,
    styleDir: "menu"
  },
  {
    pattern: /^(LayRadioGroup)$/,
    styleDir: "radio"
  },
  {
    pattern: /^LaySelectOption$/,
    styleDir: "select"
  },
  {
    pattern: /^LaySkeletonItem$/,
    styleDir: "skeleton"
  },
  {
    pattern: /^LaySplitPanelItem$/,
    styleDir: "splitPanel"
  },
  {
    pattern: /^LayStepItem$/,
    styleDir: "step"
  },
  {
    pattern: /^(LayTabItem)$/,
    styleDir: "tab"
  },
  {
    pattern: /^LayTimelineItem$/,
    styleDir: "timeline"
  }
];
var layuiRE = /^Lay[A-Z]/;
var layerRE = /^(layer|LayLayer)$/;
var iconsRE = /^([A-Z][\w]+Icon|LayIcon)$/;
var libName = "@layui/layui-vue";
function lowerCamelCase(str) {
  return str.charAt(0).toLowerCase() + str.slice(1);
}
function getSideEffects9(importName, options) {
  const { importStyle = "css" } = options;
  if (!importStyle)
    return void 0;
  if (libName !== "@layui/layui-vue")
    return `${libName}/lib/index.css`;
  let styleDir = lowerCamelCase(importName.slice(3));
  for (const item of matchComponents4) {
    if (item.pattern.test(importName)) {
      styleDir = item.styleDir;
      break;
    }
  }
  if (importStyle === "css" || importStyle) {
    return styleDir ? [`@layui/layui-vue/es/${styleDir}/index.css`, "@layui/layui-vue/es/index/index.css"] : void 0;
  }
}
function resolveComponent2(importName, options) {
  let name;
  if (options.exclude && isExclude2(importName, options.exclude))
    return void 0;
  if (options.resolveIcons && importName.match(iconsRE)) {
    name = importName;
    libName = "@layui/icons-vue";
  } else if (importName.match(layerRE)) {
    name = importName;
    libName = "@layui/layer-vue";
  } else if (importName.match(layuiRE) && !importName.match(iconsRE)) {
    name = importName;
    libName = "@layui/layui-vue";
  }
  return name ? { name, from: libName, sideEffects: getSideEffects9(name, options) } : void 0;
}
function isExclude2(name, exclude) {
  for (const item of exclude) {
    if (name === item || name.match(item))
      return true;
  }
  return false;
}
function LayuiVueResolver(options = {}) {
  return {
    type: "component",
    resolve: (name) => {
      return resolveComponent2(name, options);
    }
  };
}

// src/core/resolvers/bootstrap-vue.ts
var COMPONENT_ALIASES = {
  BBtn: "BButton",
  BBtnClose: "BButtonClose",
  BBtnGroup: "BButtonGroup",
  BBtnToolbar: "BButtonToolbar",
  BCheck: "BFormCheckbox",
  BCheckbox: "BFormCheckbox",
  BCheckboxGroup: "BFormCheckboxGroup",
  BCheckGroup: "BFormCheckboxGroup",
  BDatalist: "BFormDatalist",
  BDd: "BDropdown",
  BDdDivider: "BDropdownDivider",
  BDdForm: "BDropdownForm",
  BDdGroup: "BDropdownGroup",
  BDdHeader: "BDropdownHeader",
  BDdItem: "BDropdownItem",
  BDdItemButton: "BDropdownItemButton",
  BDdItemBtn: "BDropdownItemButton",
  BDdText: "BDropdownText",
  BDropdownItemBtn: "BDropdownItemButton",
  BFile: "BFormFile",
  BDatepicker: "BFormDatepicker",
  BInput: "BFormInput",
  BNavDd: "BNavItemDropdown",
  BNavDropdown: "BNavItemDropdown",
  BNavItemDd: "BNavItemDropdown",
  BNavToggle: "BNavbarToggle",
  BRadio: "BFormRadio",
  BRadioGroup: "BFormRadioGroup",
  BRating: "BFormRating",
  BSelect: "BFormSelect",
  BSelectOption: "BFormSelectOption",
  BSelectOptionGroup: "BFormSelectOptionGroup",
  BSpinbutton: "BFormSpinbutton",
  BTag: "BFormTag",
  BTags: "BFormTags",
  BTextarea: "BFormTextarea",
  BTimepicker: "BFormTimepicker"
};
function BootstrapVueResolver(_options = {}) {
  const options = __spreadValues({ directives: true }, _options);
  const resolvers = [{
    type: "component",
    resolve: (name) => {
      if (name.match(/^B[A-Z]/)) {
        return {
          name: COMPONENT_ALIASES[name] || name,
          from: "bootstrap-vue"
        };
      }
    }
  }];
  if (options.directives) {
    resolvers.push({
      type: "directive",
      resolve: (name) => {
        if (name.match(/^B[A-Z]/)) {
          return {
            name: `V${name}`,
            from: "bootstrap-vue"
          };
        }
      }
    });
  }
  return resolvers;
}

// src/core/resolvers/bootstrap-vue-3.ts
var BootstrapVue3Resolver = (_options = {}) => {
  const options = __spreadValues({ directives: true }, _options);
  const resolvers = [{
    type: "component",
    resolve: (name) => {
      if (name.match(/^B[A-Z]/))
        return { name, from: "bootstrap-vue-3" };
    }
  }];
  if (options.directives) {
    resolvers.push({
      type: "directive",
      resolve: (name) => {
        if (name.match(/^B[A-Z]/))
          return { name: `V${name}`, from: "bootstrap-vue-3" };
      }
    });
  }
  return resolvers;
};

// src/core/resolvers/ionic.ts
function IonicResolver() {
  return {
    type: "component",
    resolve: (name) => {
      if (name.startsWith("Ion")) {
        return {
          name,
          from: "@ionic/vue"
        };
      }
    }
  };
}
export {
  AntDesignVueResolver,
  ArcoResolver,
  BootstrapVue3Resolver,
  BootstrapVueResolver,
  DevUiResolver,
  ElementPlusResolver,
  ElementUiResolver,
  HeadlessUiResolver,
  IduxResolver,
  InklineResolver,
  IonicResolver,
  LayuiVueResolver,
  NaiveUiResolver,
  PrimeVueResolver,
  QuasarResolver,
  TDesignResolver,
  VantResolver,
  VarletUIResolver,
  VeuiResolver,
  ViewUiResolver,
  VueUseComponentsResolver,
  VueUseDirectiveResolver,
  Vuetify3Resolver,
  VuetifyResolver,
  getResolved
};