@fangzhongya/icons 0.0.20 → 0.0.22

package/dist/vite/index.js

@@ -1,6 +1,3 @@
-import {
-  runDev
-} from "../chunk-BKYM5ZD6.js";
 import {
   getIconifySVG,
   lineToLargeHump
@@ -8,11 +5,917 @@ import {
 import "../chunk-MOHILOKE.js";
 import {
   json_default
-} from "../chunk-7HXPUNMG.js";
+} from "../chunk-E432JW5M.js";
 import "../chunk-MLKGABMK.js";
 
-// packages/vite/index.ts
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-4CBOJSDB.js
+function getStartSames(str, val) {
+  let s = "";
+  const vs = [...val];
+  let index = 0;
+  for (; index < vs.length; index++) {
+    const element = vs[index];
+    if (element === str.charAt(index)) {
+      s += element;
+    } else {
+      break;
+    }
+  }
+  return [s, str.substring(index), val.substring(index)];
+}
+function getImportUrl(url, imp) {
+  const arr = getStartSames(url, imp);
+  const ts = arr[0];
+  if (!/[\\|\/]$/.test(ts)) {
+    const regs = ts.match(/[\\|\/]([^\\|\/]*)$/);
+    if (regs && regs.length > 0) {
+      const a = regs[1];
+      arr[0] = ts.substring(0, regs.index + 1);
+      arr[1] = a + arr[1];
+      arr[2] = a + arr[2];
+    }
+  }
+  const l = arr[1].split(/\\|\//).length - 1;
+  let ds = ["./"];
+  if (l > 0) {
+    ds = [];
+    for (let index = 0; index < l; index++) {
+      ds.push("../");
+    }
+  }
+  return ds.join("") + arr[2].replace(/\\/g, "/");
+}
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-3GUX6LOY.js
+function getImportUrlSuffix(url, imp) {
+  return getImportUrl(url, imp).replace(/\.([a-z|A-Z][a-z|A-Z|0-9]*)$/, "");
+}
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-I5KYQX4M.js
+import {
+  open,
+  readdir,
+  stat,
+  writeFile,
+  write,
+  mkdir,
+  readFile,
+  createReadStream,
+  access,
+  constants
+} from "fs";
 import { join } from "path";
+function getUrlCatalogueObj(str) {
+  const reg = /(\\|\/)([^\\|\/]+)\.([a-z|A-Z][a-z|A-Z|0-9]*)$/g;
+  const ml = str.replace(reg, "");
+  let name = "";
+  let suffix = "";
+  let apart = "";
+  const arr = reg.exec(str);
+  if (arr) {
+    apart = arr[1];
+    name = arr[2];
+    suffix = arr[3];
+  }
+  return {
+    catalogue: ml,
+    name,
+    suffix,
+    apart
+  };
+}
+function getNewFileName(url) {
+  const obj = getUrlCatalogueObj(url);
+  let wb = obj.name;
+  if (wb) {
+    const reg = /([0-9]+)$/g;
+    const regs = reg.exec(wb);
+    if (regs && regs.length > 0) {
+      const sl = Number(regs[1]) + 1;
+      const reg1 = new RegExp(regs[1] + "$");
+      wb = wb.replace(reg1, (sl + "").padStart(regs[1].length, "0"));
+    } else {
+      wb = wb + "1";
+    }
+    return obj.catalogue + obj.apart + wb + "." + obj.suffix;
+  } else {
+    return "";
+  }
+}
+function fsReadFile(url, type) {
+  if (!type || type === true) {
+    type = "utf-8";
+  }
+  return new Promise((resolve3, reject) => {
+    readFile(url, type, (err, dataStr) => {
+      if (err) {
+        console.log("2", err);
+        reject("");
+      } else {
+        resolve3(dataStr);
+      }
+    });
+  });
+}
+function fsCreateReadStream(url, type) {
+  if (!type || type === true) {
+    type = "utf-8";
+  }
+  return new Promise((resolve3) => {
+    const stream = createReadStream(url, {
+      start: 0,
+      end: 100,
+      encoding: type
+    });
+    let st = "";
+    stream.on("data", (data) => {
+      st += data;
+    });
+    stream.on("end", () => {
+      resolve3(st);
+    });
+    stream.on("error", () => {
+      resolve3("");
+    });
+  });
+}
+function fsAccess(reaPath) {
+  return new Promise((resolve3) => {
+    try {
+      access(reaPath, constants.F_OK, (err) => {
+        if (err) {
+          resolve3(false);
+        } else {
+          resolve3(true);
+        }
+      });
+    } catch (e) {
+      resolve3(false);
+    }
+  });
+}
+function fsReaddir(filePath) {
+  return new Promise((resolve3, reject) => {
+    readdir(filePath, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        const lg = files.length;
+        const dirs = [];
+        const file = [];
+        if (lg) {
+          let i = 0;
+          files.forEach((filename) => {
+            const filedir = join(filePath, filename);
+            stat(filedir, (err2, stats) => {
+              i++;
+              if (err2) {
+                console.log("4", err2);
+              } else {
+                const isFile = stats.isFile();
+                const isDir = stats.isDirectory();
+                if (isFile) {
+                  file.push(filename);
+                }
+                if (isDir) {
+                  dirs.push(filename);
+                }
+              }
+              if (i >= lg) {
+                resolve3({
+                  file,
+                  dirs
+                });
+              }
+            });
+          });
+        } else {
+          resolve3({
+            file,
+            dirs
+          });
+        }
+      }
+    });
+  });
+}
+function fsOpenStream(path, json, type = 0, cover, callback) {
+  open(path, "wx", async (err, fd) => {
+    if (err) {
+      if (err.code === "EEXIST") {
+        if (type == 1 || type == 0) {
+          const fwrite = () => {
+            writeFile(path, json, "utf-8", (err2) => {
+              if (err2) {
+                console.log("6", err2);
+                if (callback) {
+                  callback(path, cover ? 3 : 2, false, type);
+                }
+              } else {
+                if (callback) {
+                  callback(path, cover ? 3 : 2, true, type);
+                }
+              }
+            });
+          };
+          if (cover) {
+            const st = await fsCreateReadStream(path);
+            if (!st.includes("@config cover=true")) {
+              fwrite();
+            } else {
+              if (callback) callback(path, 3, false, type);
+            }
+          } else {
+            fwrite();
+          }
+        } else if (type == 3) {
+          path = getNewFileName(path);
+          if (path) {
+            fsOpenStream(path, json, type, cover, callback);
+          } else {
+            if (callback) {
+              callback(path, 3, false, type);
+            }
+          }
+        } else {
+          if (callback) {
+            callback(path, 2, false, type);
+          }
+        }
+      } else {
+        if (callback) {
+          callback(path, 0, false, type);
+        }
+      }
+    } else {
+      if (type != 1) {
+        write(fd, json, (err2) => {
+          if (err2) {
+            console.log("8", err2);
+            if (callback) {
+              callback(path, 1, false, type);
+            }
+          } else {
+            if (callback) {
+              callback(path, 1, true, type);
+            }
+          }
+        });
+      } else {
+        if (callback) {
+          callback(path, 1, false, type);
+        }
+      }
+    }
+  });
+}
+function fsMkdir(reaPath, callback) {
+  mkdir(reaPath, { recursive: true }, (err, path) => {
+    if (err) {
+      console.log("0", err);
+      if (callback) {
+        callback(reaPath, false);
+      }
+    } else {
+      if (callback) {
+        callback(reaPath, true, path);
+      }
+    }
+  });
+}
+function writeInit(url, callback, isDirs, isFile, issynch) {
+  return new Promise(async (resolve3) => {
+    if (url) {
+      const data = await fsReaddir(url);
+      const arr = await writeFileUrl(
+        url,
+        data,
+        callback,
+        isDirs,
+        isFile,
+        issynch
+      );
+      resolve3(arr);
+    } else {
+      resolve3([]);
+    }
+  });
+}
+function writeFileUrl(url, files, callback, isDirs, isFile, issynch) {
+  return new Promise(async (resolve3) => {
+    const arr = [];
+    const dirs = [];
+    if (files.dirs.length > 0) {
+      for (let i = 0; i < files.dirs.length; i++) {
+        const dir = files.dirs[i];
+        let is = true;
+        if (isDirs) {
+          is = isDirs(url, dir);
+        }
+        if (is) {
+          dirs.push(dir);
+          const urls = await writeInit(
+            join(url, dir),
+            callback,
+            isDirs,
+            isFile,
+            issynch
+          );
+          arr.push(...urls);
+        }
+      }
+    }
+    files.dirs = dirs;
+    const file = [];
+    if (files.file.length > 0) {
+      files.file.forEach((name) => {
+        let is = true;
+        if (isFile) {
+          is = isFile(url, name);
+        }
+        if (is) {
+          file.push(name);
+          arr.push(join(url, name));
+        }
+      });
+    }
+    files.file = file;
+    if (callback) {
+      if (issynch) {
+        await callback(url, files, arr);
+      } else {
+        callback(url, files, arr);
+      }
+    }
+    resolve3(arr);
+  });
+}
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-FWEGYLR7.js
+import { resolve, join as join2 } from "path";
+function styleLog(msg = "", obj) {
+  const arr = ["\x1B[0m"];
+  if (obj == null ? void 0 : obj.revert) {
+    arr.push("\x1B[4m");
+  }
+  if (obj == null ? void 0 : obj.lineThrough) {
+    arr.push("\x1B[9m");
+  }
+  if (obj == null ? void 0 : obj.italic) {
+    arr.push("\x1B[3m");
+  }
+  if (obj == null ? void 0 : obj.bold) {
+    arr.push("\x1B[1m");
+  }
+  if (obj == null ? void 0 : obj.bag) {
+    arr.push(`\x1B[4${obj == null ? void 0 : obj.bag}m`);
+  } else {
+    arr.push("\x1B[40m");
+  }
+  if (obj == null ? void 0 : obj.text) {
+    arr.push(`\x1B[3${obj == null ? void 0 : obj.text}m`);
+  } else {
+    arr.push("\x1B[30m");
+  }
+  arr.push(msg);
+  arr.push("\x1B[0m");
+  return arr.join("");
+}
+function getSuffix(url) {
+  const reg = /\.([a-z|A-Z][a-z|A-Z|0-9]*)$/;
+  const regs = reg.exec(url);
+  if (regs && regs.length > 0) {
+    return regs[1];
+  }
+  return "";
+}
+function matchsEnd(key, matchs) {
+  if (matchs && matchs.length > 0) {
+    for (const value of matchs) {
+      if (typeof value == "string") {
+        if (key.endsWith(value)) {
+          return true;
+        }
+      } else {
+        if (value.test(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } else {
+    return true;
+  }
+}
+function matchsStart(key, matchs) {
+  if (matchs && matchs.length > 0) {
+    for (const value of matchs) {
+      if (typeof value == "string") {
+        if (key.startsWith(value)) {
+          return true;
+        }
+      } else {
+        if (value.test(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } else {
+    return true;
+  }
+}
+function getUrlCatalogue(str) {
+  const reg = /((\\|\/)([^\\|\/]+)(\.[a-z|A-Z][a-z|A-Z|0-9]*))?$/g;
+  return str.replace(reg, "");
+}
+var defaultSuffixReg = /\\.[a-z|A-Z]+$/;
+var defaultConfig = {
+  name: "com",
+  /**
+   * 打包的文件地址
+   */
+  dir: "./packages/",
+  /**
+   * 文件后缀
+   */
+  extensions: ["js", "ts"],
+  suffixReg: defaultSuffixReg,
+  fileTongre: false,
+  /**
+   * 是否替换文件
+   */
+  fileCover: false,
+  /**
+   * 判断当前文件100个字节内存在 @config cover=true 就不写入
+   */
+  coverConfig: false,
+  /**
+   * 写入注释
+   */
+  writeNotes: false,
+  /**
+   * 读取当前文件，文件的编码类型，默认utf-8
+   */
+  read: false,
+  /**
+   * 匹配目录数组
+   * 从头开始匹配
+   */
+  matchs: [],
+  /**
+   * 匹配文件路径
+   * 从尾部开始匹配
+   */
+  matchexts: [],
+  forceUpdate: [],
+  /**
+   * 不匹配目录数组
+   * 从头开始匹配
+   */
+  nomatchs: [],
+  /**
+   * 不匹配文件路径
+   * 从尾部开始匹配
+   */
+  nomatchexts: [],
+  issort: false,
+  issynch: false
+};
+function getSuffixReg(ex = []) {
+  if (ex.length == 0) {
+    return defaultSuffixReg;
+  }
+  return new RegExp(`\\.(${ex.join("|")})$`);
+}
+var FangCom = class {
+  _configCallback;
+  _defaultConfig;
+  config;
+  constructor(config, callback) {
+    this.config = {};
+    this._configCallback = callback;
+    this._defaultConfig = defaultConfig;
+    this.initConfig(config);
+  }
+  async runDev(callback, configCallback, config, nosort) {
+    this.initConfig(config);
+    const call = configCallback || this._configCallback;
+    if (call) {
+      const c = call(this.config);
+      if (c) {
+        this.initConfig(c);
+      }
+    }
+    return await this.handle(callback, nosort);
+  }
+  /**
+   * 初始化
+   * @param config
+   * @returns
+   */
+  initConfig(config) {
+    if (config) {
+      this.config = config;
+      this.setDefaultConfig();
+      this.config.suffixReg = getSuffixReg(this.config.extensions);
+      if (!this.config.matchexts || this.config.matchexts.length == 0) {
+        this.config.matchexts = [this.config.suffixReg];
+      }
+    }
+    return this.config;
+  }
+  setDefaultConfig() {
+    Object.keys(this._defaultConfig).forEach((key) => {
+      if (typeof this.config[key] == "undefined") {
+        this.config[key] = this._defaultConfig[key];
+      }
+    });
+  }
+  getFileName(name) {
+    if (this.config.suffixReg) {
+      return name.replace(this.config.suffixReg, "");
+    } else {
+      return name.replace(defaultSuffixReg, "");
+    }
+  }
+  /**
+   * 获取当前位置
+   * @param dir
+   * @returns
+   */
+  getDirUrl(dir) {
+    const str = dir || this.config.dir;
+    if (str) {
+      return resolve(process.cwd(), str);
+    } else {
+      return "";
+    }
+  }
+  isForceUpdate(url) {
+    if (this.config.forceUpdate && this.config.forceUpdate.length > 0) {
+      return matchsEnd(url.replace(/\\/g, "/"), this.config.forceUpdate);
+    } else {
+      return false;
+    }
+  }
+  isMatchFile(url, name) {
+    const dirUrl = this.getDirUrl();
+    const dir = join2(url, name).replace(dirUrl, "").replace(/\\/g, "/");
+    const is = matchsEnd(dir, this.config.matchexts);
+    const nomatchexts = this.config.nomatchexts;
+    if (is && nomatchexts && nomatchexts.length > 0) {
+      if (matchsEnd(dir, nomatchexts)) {
+        return false;
+      } else {
+        return true;
+      }
+    } else {
+      return is;
+    }
+  }
+  isMatchDir(url, name) {
+    const dirUrl = this.getDirUrl();
+    const dir = join2(url, name).replace(dirUrl, "").replace(/\\/g, "/");
+    const is = matchsStart(dir, this.config.matchs);
+    const nomatchs = this.config.nomatchs;
+    if (is && nomatchs && nomatchs.length > 0) {
+      if (matchsStart(dir, nomatchs)) {
+        return false;
+      } else {
+        return true;
+      }
+    } else {
+      return is;
+    }
+  }
+  /**
+   * 处理方法
+   * @param callback
+   */
+  handle(callback, nosort) {
+    return new Promise(async (resolve22) => {
+      const url = this.getDirUrl();
+      if (url) {
+        const rarr = await writeInit(
+          url,
+          async (...arr) => {
+            if (callback) {
+              await callback(...arr);
+            }
+            return await this.writeCallback(...arr, nosort);
+          },
+          (...arr) => {
+            return this.isMatchDir(...arr);
+          },
+          (...arr) => {
+            return this.isMatchFile(...arr);
+          },
+          this.config.issynch
+        );
+        resolve22(rarr);
+      } else {
+        resolve22([]);
+      }
+    });
+  }
+  getFileNotes(url) {
+    const suffix = getSuffix(url);
+    const sz = [
+      `@config cover=false`,
+      `cover \u662F\u5426\u8986\u76D6\u5F53\u524D\u6587\u4EF6\uFF0C\u9ED8\u8BA4\u662Ffalse\uFF0C true \u8868\u793A\u4E0D\u8986\u76D6`,
+      `\u5F53\u524D\u5DF2\u7ECF\u7531@fangzhongya/create\u81EA\u52A8\u751F\u6210`,
+      `${(/* @__PURE__ */ new Date()).toString()}`
+    ];
+    const hy = ["md", "html", "vue"];
+    if (hy.includes(suffix)) {
+      const arr = ["<!--"];
+      sz.forEach((v) => {
+        arr.push(" - " + v);
+      });
+      arr.push("-->");
+      return arr;
+    } else {
+      const arr = ["/**"];
+      sz.forEach((v) => {
+        arr.push(" * " + v);
+      });
+      arr.push(" */");
+      return arr;
+    }
+  }
+  /**
+   * 输出文件，判断目录是否存在
+   * @param url
+   * @param sts
+   */
+  fileOpen(url, sts, fileUrls, type) {
+    fsMkdir(getUrlCatalogue(url), (reaPath, is, ml) => {
+      const logs = this.getLogs();
+      logs.push(styleLog("dir", {}));
+      if (is) {
+        if (ml) {
+          logs.push(
+            styleLog("add", {
+              text: 2,
+              italic: true
+            })
+          );
+          logs.push(
+            styleLog(reaPath, {
+              text: 2,
+              revert: true
+            })
+          );
+          console.log(logs.join(" "));
+        }
+      } else {
+        logs.push(
+          styleLog(reaPath, {
+            text: 1,
+            revert: true
+          })
+        );
+        console.log(logs.join(" "));
+      }
+      this.setOpen(url, sts, type, (kurl, _type, is2, _tn) => {
+        if (is2 && fileUrls) {
+          fileUrls.push(kurl);
+        }
+      });
+    });
+  }
+  /**
+   * 输出文件
+   * @param url
+   * @param str
+   * @param callback
+   */
+  setOpen(url, str, type, callback) {
+    let tn = this.config.fileTongre ? 3 : 2;
+    if (this.config.fileCover) {
+      tn = 0;
+    }
+    if (tn == 2) {
+      if (this.isForceUpdate(url)) {
+        tn = 0;
+      }
+    }
+    if (typeof type != "undefined") {
+      tn = type;
+    }
+    if (this.config.writeNotes && !/\.json$/.test(url)) {
+      str = this.getFileNotes(url).join("\n") + "\n" + str;
+    }
+    fsOpenStream(
+      url,
+      str,
+      tn,
+      this.config.coverConfig,
+      (kurl, type2, is) => {
+        if (!(tn == 2 && type2 == 2)) {
+          const logs = this.getLogs();
+          logs.push(styleLog("file", {}));
+          if (type2 == 1) {
+            logs.push(
+              styleLog("add", {
+                text: 2,
+                italic: true
+              })
+            );
+          } else if (type2 == 2) {
+            logs.push(
+              styleLog("update", {
+                italic: true,
+                text: 4
+              })
+            );
+          }
+          if (is) {
+            logs.push(
+              styleLog(kurl, {
+                text: 2,
+                revert: true
+              })
+            );
+          } else {
+            logs.push(
+              styleLog(kurl, {
+                text: 1,
+                revert: true
+              })
+            );
+          }
+          console.log(logs.join(" "));
+        }
+        if (callback) {
+          callback(kurl, type2, is, tn);
+        }
+      }
+    );
+  }
+  /**
+   * 获取日志头
+   */
+  getLogs() {
+    const logs = [];
+    logs.push(
+      styleLog("[@fangzhongya/create]", {
+        text: 3
+      })
+    );
+    logs.push(
+      styleLog(this._defaultConfig.name, {
+        text: 4
+      })
+    );
+    return logs;
+  }
+};
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-IMEZSVK5.js
+import { resolve as resolve2, join as join3 } from "path";
+var defaultConfig2 = Object.assign({}, defaultConfig, {
+  name: "file",
+  /**
+   * 生成的文件名称
+   */
+  gene: void 0,
+  /**
+   * 文件生成方法
+   */
+  fileSet: void 0
+});
+var FangFile = class extends FangCom {
+  constructor(config, callback) {
+    super();
+    this.config = {};
+    this._configCallback = callback;
+    this._defaultConfig = defaultConfig2;
+    this.initConfig(config || this.config);
+  }
+  getDefaultGene(name, url, _wj) {
+    return join3(url, name);
+  }
+  getDefaultFileSet(_name, _url, _text, _wjm, _imp, _surl) {
+    return [];
+  }
+  getGeneObj(url, name, outDir) {
+    return getUrlCatalogueObj(
+      join3(
+        resolve2(process.cwd(), outDir),
+        join3(url, name).replace(this.getDirUrl(), "")
+      )
+    );
+  }
+  /**
+   * 获取输出地址方法
+   * @param gene
+   * @returns
+   */
+  getGene(gene) {
+    gene = gene || this.config.gene;
+    if (!gene) {
+      return (...arr) => {
+        return this.getDefaultGene(...arr);
+      };
+    } else {
+      return gene;
+    }
+  }
+  fileRead(url, type) {
+    return new Promise((resolve22) => {
+      fsAccess(url).then(() => {
+        resolve22(fsReadFile(url, type));
+      });
+    });
+  }
+  getFileSet(fileSet) {
+    fileSet = fileSet || this.config.fileSet;
+    if (!fileSet) {
+      return (...arr) => {
+        return this.getDefaultFileSet(...arr);
+      };
+    } else {
+      return fileSet;
+    }
+  }
+  /**
+   * 回调方法
+   * @param url
+   * @param file
+   * @param urls
+   */
+  async writeCallback(url, readdir2, fileUrls) {
+    const gene = this.getGene();
+    const fileSet = this.getFileSet();
+    const read = this.config.read;
+    if (readdir2.file) {
+      for (let i = 0; i < readdir2.file.length; i++) {
+        const name = readdir2.file[i];
+        const furl = join3(url, name);
+        const wjmc = this.getFileName(name);
+        const gu = gene(name, url, wjmc);
+        const imp = getImportUrlSuffix(gu, furl);
+        const arr = [];
+        if (fileSet) {
+          let text = "";
+          if (read) {
+            text = await fsReadFile(furl, read);
+          }
+          arr.push(...fileSet(name, url, text, wjmc, imp, gu));
+        }
+        if (arr.length > 0) {
+          this.fileOpen(gu, arr.join("\n"), fileUrls);
+        }
+      }
+    }
+    return true;
+  }
+};
+
+// node_modules/.pnpm/@fangzhongya+create@0.2.49/node_modules/@fangzhongya/create/dist/chunk-3VPCYJWK.js
+import { join as join4 } from "path";
+var defaultConfig22 = Object.assign({}, defaultConfig2, {
+  name: "out",
+  outDir: "./",
+  isNeader: true
+});
+var FangOut = class extends FangFile {
+  constructor(config, callback) {
+    super();
+    this.config = {};
+    this._configCallback = callback;
+    this._defaultConfig = defaultConfig22;
+    this.initConfig(config || this.config);
+  }
+  getFileNeader(name, url) {
+    return [`/**`, ` * ${join4(url, name).replace(/\\/g, "/")}`, " */"];
+  }
+  /**
+   * 获取输出地址方法
+   * @param gene
+   * @returns
+   */
+  getDefaultGene(name, url, _wj) {
+    const obj = this.getGeneObj(url, name, this.config.outDir);
+    return join4(obj.catalogue, obj.name + "." + obj.suffix);
+  }
+  getDefaultFileSet(name, url, text, _wjm, _imp) {
+    const arr = [text];
+    if (this.config.isNeader) {
+      return [...this.getFileNeader(name, url), ...arr];
+    }
+    return arr;
+  }
+};
+function runDev(config, configCallback, callback) {
+  const fang = new FangOut(config);
+  fang.runDev(callback, configCallback);
+}
+
+// packages/vite/index.ts
+import { join as join5 } from "path";
 var runType = "svg";
 var virtualModuleId = "virtual:fang-icon";
 function simpleFangIcon(options = {}) {
@@ -26,7 +929,7 @@ function simpleFangIcon(options = {}) {
     customReplacement
   } = options;
   if (options.mobile) {
-    const outDir = join("./public/", directory);
+    const outDir = join5("./public/", directory);
     runDev({
       issort: true,
       dir: "./node_modules/@fangzhongya/icons/dist/svg",
@@ -40,8 +943,8 @@ function simpleFangIcon(options = {}) {
   const plugin = {
     name: "simple-fang-icon"
   };
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
   if (virtual) {
-    const resolvedVirtualModuleId = "\0" + virtualModuleId;
     const pub = `
 	import { defineComponent, h,} from 'vue'
 	import FangIcon from '@fangzhongya/icons/icon/index'
@@ -141,6 +1044,20 @@ function simpleFangIcon(options = {}) {
       }
       return null;
     };
+  } else {
+    plugin.resolveId = function(id) {
+      if (id === virtualModuleId) {
+        return resolvedVirtualModuleId;
+      }
+      return void 0;
+    };
+    plugin.load = function(id) {
+      if (id === resolvedVirtualModuleId) {
+        return `export const install = () => {};
+	export default {};`;
+      }
+      return null;
+    };
   }
   if (replaced) {
     const targetComponents = Array.isArray(name) ? name : [name];
@@ -164,7 +1081,7 @@ function simpleFangIcon(options = {}) {
         }
         for (let i = components.length - 1; i >= 0; i--) {
           const component = components[i];
-          if (component) {
+          if (isReplaced(component)) {
             const { text, imptext } = replaceComponent(
               component,
               type,
@@ -238,6 +1155,26 @@ function hasStringNameAttribute(attrString) {
 function isOnlyWhitespace(content) {
   return !content || /^\s*$/.test(content);
 }
+function isReplaced(m) {
+  if (!m) {
+    return false;
+  }
+  const { fullMatch, attributes } = m;
+  if (!hasStringNameAttribute(fullMatch)) {
+    return false;
+  }
+  if (!attributes.name) {
+    return false;
+  }
+  const content = fullMatch.slice(
+    fullMatch.indexOf(">") + 1,
+    fullMatch.indexOf("</")
+  );
+  if (!isOnlyWhitespace(content)) {
+    return false;
+  }
+  return true;
+}
 function findComponents(code, name) {
   const components = [];
   for (const componentName of name) {
@@ -252,15 +1189,7 @@ function findComponents(code, name) {
       if (tagEndIndex === -1) break;
       const startTag = code.slice(startTagIndex, tagEndIndex + 1);
       const attrString = startTag.slice(componentName.length + 1, -1).trim();
-      if (!hasStringNameAttribute(attrString)) {
-        currentIndex = startTagIndex + 1;
-        continue;
-      }
       const attributes = parseAttributes(attrString);
-      if (!attributes.name) {
-        currentIndex = startTagIndex + 1;
-        continue;
-      }
       const isSelfClosing = startTag.endsWith("/>");
       let endIndex;
       let fullMatch;
@@ -274,11 +1203,6 @@ function findComponents(code, name) {
           currentIndex = startTagIndex + 1;
           continue;
         }
-        const content = code.slice(tagEndIndex + 1, endTagIndex);
-        if (!isOnlyWhitespace(content)) {
-          currentIndex = startTagIndex + 1;
-          continue;
-        }
         endIndex = endTagIndex + endTag.length;
         fullMatch = code.slice(startTagIndex, endIndex);
       }