minista 2.6.2 → 2.7.2

package/README.md

@@ -18,7 +18,7 @@ https://minista.qranoko.jp
 
 ## About
 
-minista（ミニスタ）は、React の JSX で書けるスタティックサイトジェネレーターです。Next.js 風の快適な環境で開発しながら 100% 静的な出力を行えます。SaaS の web テンプレートコーディング業務を想定しているため、ビルド後のデータが綺麗（ヒューマンリーダブル）です。
+minista（ミニスタ）は、React の JSX で書けるスタティックサイトジェネレーターです。Next.js 風の快適な環境で開発しながら 100% 静的に出力できます。SaaS の web テンプレートコーディング業務を想定しているため、ビルド後のデータが綺麗（ヒューマンリーダブル）です。
 
 ## How To Use
 
@@ -165,6 +165,24 @@ export default defineConfig({
       rehypePlugins: [], // https://mdxjs.com/packages/mdx/#optionsrehypeplugins
     },
   },
+  search: {
+    useJson: false, // boolean
+    cache: false, // boolean
+    outDir: "assets", // string
+    outName: "search", // string
+    include: ["**/*"], // string[]
+    exclude: ["404"], // string[]
+    trimTitle: "", // string
+    targetSelector: "[data-search]", // string
+    hit: {
+      minLength: 3, // number
+      number: false, // boolean
+      english: true, // boolean
+      hiragana: false, // boolean
+      katakana: true, // boolean
+      kanji: true, // boolean
+    },
+  },
   beautify: {
     useHtml: true, // boolean
     useAssets: false, // boolean

package/dist/build.d.ts

@@ -10,18 +10,38 @@ export declare function buildTempPages(entryPoints: string[], buildOptions: {
     svgrOptions: SvgrOptions;
     cssOptions: CssOptions;
 }): Promise<void>;
-export declare function buildStaticPages(entryPoints: string[], tempRootFilePath: string, buildOptions: {
+export declare function buildStaticPages({ entryPoints, tempRootFilePath, outBase, outDir, assetsTagStr, showLog, }: {
+    entryPoints: string[];
+    tempRootFilePath: string;
     outBase: string;
     outDir: string;
-}, assetsTagStr: string): Promise<void>;
+    assetsTagStr: string;
+    showLog: boolean;
+}): Promise<void>;
 export declare function buildRootEsmContent(tempRootFilePath: string): Promise<{
     component: RootJsxContent;
     staticData: GlobalStaticData;
 }>;
 export declare function buildGlobalStaticData(getGlobalStaticData: GetGlobalStaticData): Promise<GlobalStaticData>;
-export declare function buildStaticPage(entryPoint: string, outFile: string, rootStaticContent: RootStaticContent, assetsTagStr: string, outDir: string): Promise<void>;
+export declare function buildStaticPage({ entryPoint, outFile, rootStaticContent, assetsTagStr, outDir, showLog, }: {
+    entryPoint: string;
+    outFile: string;
+    rootStaticContent: RootStaticContent;
+    assetsTagStr: string;
+    outDir: string;
+    showLog: boolean;
+}): Promise<void>;
 export declare function buildStaticData(getStaticData: GetStaticData): Promise<StaticData>;
-export declare function buildHtmlPage(pageJsxContent: PageJsxContent, staticDataItem: StaticDataItem, routePath: string, rootStaticContent: RootStaticContent, assetsTagStr: string, frontmatter: any, outDir: string): Promise<void>;
+export declare function buildHtmlPage({ pageJsxContent, staticDataItem, routePath, rootStaticContent, assetsTagStr, frontmatter, outDir, showLog, }: {
+    pageJsxContent: PageJsxContent;
+    staticDataItem: StaticDataItem;
+    routePath: string;
+    rootStaticContent: RootStaticContent;
+    assetsTagStr: string;
+    frontmatter: any;
+    outDir: string;
+    showLog: boolean;
+}): Promise<void>;
 export declare function buildTempAssets(viteConfig: InlineConfig, buildOptions: {
     input: string;
     bundleOutName: string;
@@ -62,4 +82,12 @@ export declare function buildPartialHydrateAssets(viteConfig: InlineConfig, buil
     assetDir: string;
     usePreact: boolean;
 }): Promise<void>;
+export declare function buildSearchJson({ config, useCacheExists, entryPoints, entryBase, outFile, showLog, }: {
+    config: MinistaResolveConfig;
+    useCacheExists: boolean;
+    entryPoints: string[];
+    entryBase: string;
+    outFile: string;
+    showLog: boolean;
+}): Promise<void>;
 export declare function buildCopyDir(targetDir: string, outDir: string, log?: "public" | "assets"): Promise<void>;

package/dist/build.js

@@ -30,6 +30,8 @@ import {
   defineConfig as defineViteConfig,
   mergeConfig as mergeViteConfig
 } from "vite";
+import { parse } from "node-html-parser";
+import mojigiri from "mojigiri";
 import { systemConfig } from "./system.js";
 import { getFilePath } from "./path.js";
 import {
@@ -100,15 +102,29 @@ async function buildTempPages(entryPoints, buildOptions) {
     ]
   }).catch(() => process.exit(1));
 }
-async function buildStaticPages(entryPoints, tempRootFilePath, buildOptions, assetsTagStr) {
+async function buildStaticPages({
+  entryPoints,
+  tempRootFilePath,
+  outBase,
+  outDir,
+  assetsTagStr,
+  showLog
+}) {
   const rootStaticContent = await buildRootEsmContent(tempRootFilePath);
-  const winOutBase = buildOptions.outBase.replaceAll("/", "\\");
+  const winOutBase = outBase.replaceAll("/", "\\");
   await Promise.all(entryPoints.map(async (entryPoint) => {
     const extname = path.extname(entryPoint);
     const basename = path.basename(entryPoint, extname);
-    const dirname = path.dirname(entryPoint).replace(buildOptions.outBase, buildOptions.outDir).replace(winOutBase, buildOptions.outDir);
+    const dirname = path.dirname(entryPoint).replace(outBase, outDir).replace(winOutBase, outDir);
     const filename = path.join(dirname, basename + ".html");
-    await buildStaticPage(entryPoint, filename, rootStaticContent, assetsTagStr, buildOptions.outDir);
+    await buildStaticPage({
+      entryPoint,
+      outFile: filename,
+      rootStaticContent,
+      assetsTagStr,
+      outDir,
+      showLog
+    });
   }));
 }
 async function buildRootEsmContent(tempRootFilePath) {
@@ -130,7 +146,14 @@ async function buildGlobalStaticData(getGlobalStaticData) {
   const response = await getGlobalStaticData();
   return response;
 }
-async function buildStaticPage(entryPoint, outFile, rootStaticContent, assetsTagStr, outDir) {
+async function buildStaticPage({
+  entryPoint,
+  outFile,
+  rootStaticContent,
+  assetsTagStr,
+  outDir,
+  showLog
+}) {
   const targetFilePath = url.pathToFileURL(entryPoint).href;
   const pageEsmContent = await import(targetFilePath);
   const pageJsxContent = pageEsmContent.default;
@@ -139,11 +162,29 @@ async function buildStaticPage(entryPoint, outFile, rootStaticContent, assetsTag
   const staticData = pageEsmContent.getStaticData ? await buildStaticData(pageEsmContent.getStaticData) : void 0;
   if (!staticData) {
     const staticDataItem = defaultStaticDataItem;
-    return await buildHtmlPage(pageJsxContent, staticDataItem, outFile, rootStaticContent, assetsTagStr, frontmatter, outDir);
+    return await buildHtmlPage({
+      pageJsxContent,
+      staticDataItem,
+      routePath: outFile,
+      rootStaticContent,
+      assetsTagStr,
+      frontmatter,
+      outDir,
+      showLog
+    });
   }
   if ("props" in staticData && "paths" in staticData === false) {
     const staticDataItem = __spreadValues(__spreadValues({}, defaultStaticDataItem), staticData);
-    return await buildHtmlPage(pageJsxContent, staticDataItem, outFile, rootStaticContent, assetsTagStr, frontmatter, outDir);
+    return await buildHtmlPage({
+      pageJsxContent,
+      staticDataItem,
+      routePath: outFile,
+      rootStaticContent,
+      assetsTagStr,
+      frontmatter,
+      outDir,
+      showLog
+    });
   }
   if ("paths" in staticData) {
     const staticDataItem = __spreadValues(__spreadValues({}, defaultStaticDataItem), staticData);
@@ -152,7 +193,16 @@ async function buildStaticPage(entryPoint, outFile, rootStaticContent, assetsTag
       const reg = new RegExp("\\[" + key + "\\]", "g");
       fixedOutfile = fixedOutfile.replace(reg, `${value}`);
     }
-    return await buildHtmlPage(pageJsxContent, staticDataItem, fixedOutfile, rootStaticContent, assetsTagStr, frontmatter, outDir);
+    return await buildHtmlPage({
+      pageJsxContent,
+      staticDataItem,
+      routePath: fixedOutfile,
+      rootStaticContent,
+      assetsTagStr,
+      frontmatter,
+      outDir,
+      showLog
+    });
   }
   if (Array.isArray(staticData) && staticData.length > 0) {
     const entryPoints = staticData;
@@ -163,7 +213,16 @@ async function buildStaticPage(entryPoint, outFile, rootStaticContent, assetsTag
         const reg = new RegExp("\\[" + key + "\\]", "g");
         fixedOutfile = fixedOutfile.replace(reg, `${value}`);
       }
-      return await buildHtmlPage(pageJsxContent, staticDataItem, fixedOutfile, rootStaticContent, assetsTagStr, frontmatter, outDir);
+      return await buildHtmlPage({
+        pageJsxContent,
+        staticDataItem,
+        routePath: fixedOutfile,
+        rootStaticContent,
+        assetsTagStr,
+        frontmatter,
+        outDir,
+        showLog
+      });
     }));
   }
 }
@@ -171,7 +230,16 @@ async function buildStaticData(getStaticData) {
   const response = await getStaticData();
   return response;
 }
-async function buildHtmlPage(pageJsxContent, staticDataItem, routePath, rootStaticContent, assetsTagStr, frontmatter, outDir) {
+async function buildHtmlPage({
+  pageJsxContent,
+  staticDataItem,
+  routePath,
+  rootStaticContent,
+  assetsTagStr,
+  frontmatter,
+  outDir,
+  showLog
+}) {
   if (frontmatter == null ? void 0 : frontmatter.draft) {
     return;
   }
@@ -227,7 +295,7 @@ async function buildHtmlPage(pageJsxContent, staticDataItem, routePath, rootStat
   }
   const replacedHtml = html[0].replace(/<div class="minista-comment" hidden="">(.+?)<\/div>/g, "\n<!-- $1 -->");
   await fs.outputFile(routePath, replacedHtml).then(() => {
-    console.log(`${pc.bold(pc.green("BUILD"))} ${pc.bold(routePath)}`);
+    showLog && console.log(`${pc.bold(pc.green("BUILD"))} ${pc.bold(routePath)}`);
   }).catch((err) => {
     console.error(err);
   });
@@ -525,7 +593,7 @@ async function buildPartialHydrateAssets(viteConfig, buildOptions) {
     resolve: {
       alias: activePreact ? resolveAliasPreact : {}
     },
-    customLogger: viteConfig.customLogger
+    logLevel: "error"
   });
   const mergedConfig = mergeViteConfig({}, customConfig);
   const result = await viteBuild(mergedConfig);
@@ -545,6 +613,134 @@ async function buildPartialHydrateAssets(viteConfig, buildOptions) {
     });
   }
 }
+async function buildSearchJson({
+  config,
+  useCacheExists,
+  entryPoints,
+  entryBase,
+  outFile,
+  showLog
+}) {
+  if (useCacheExists) {
+    return;
+  }
+  const { trimTitle, targetSelector, hit } = config.search;
+  const tempWords = [];
+  const tempPages = [];
+  await Promise.all(entryPoints.map(async (filePath) => {
+    const html = await fs.readFile(filePath, { encoding: "utf-8" });
+    const parsedHtml = parse(html, {
+      blockTextElements: { script: false, style: false, pre: false }
+    });
+    const regTrimPath = new RegExp(`^${entryBase}|index|.html`, "g");
+    const path2 = filePath.replace(regTrimPath, "");
+    const regTrimTitle = new RegExp(trimTitle);
+    const pTitle = parsedHtml.querySelector("title");
+    const title = pTitle ? pTitle.rawText.replace(regTrimTitle, "") : "";
+    const titleArray = mojigiri(title);
+    const targetContent = parsedHtml.querySelector(targetSelector);
+    if (!targetContent) {
+      tempWords.push(title);
+      tempPages.push({
+        path: path2,
+        toc: [],
+        title: titleArray,
+        content: []
+      });
+      return;
+    }
+    const contents = [];
+    async function getContent(element) {
+      if (element.id) {
+        contents.push({ type: "id", value: [element.id] });
+      }
+      if (element._rawText) {
+        const text = element._rawText.replace(/\n/g, "").replace(/\s{2,}/g, " ").trim();
+        const words2 = mojigiri(text);
+        if (words2.length > 0) {
+          contents.push({ type: "words", value: words2 });
+        }
+      }
+      if (element.childNodes) {
+        await Promise.all(element.childNodes.map(async (childNode) => {
+          return await getContent(childNode);
+        }));
+      }
+      return;
+    }
+    await getContent(targetContent);
+    const toc = [];
+    const contentArray = [];
+    let contentCount = 0;
+    contents.forEach((content) => {
+      if (content.type === "id") {
+        toc.push([contentCount, content.value[0]]);
+        return;
+      } else if (content.type === "words") {
+        contentArray.push(content.value);
+        contentCount = contentCount + content.value.length;
+        return;
+      }
+    });
+    const body = targetContent.rawText.replace(/\n/g, "").replace(/\s{2,}/g, " ").trim();
+    tempWords.push(title);
+    tempWords.push(body);
+    tempPages.push({
+      path: path2,
+      toc,
+      title: titleArray,
+      content: contentArray.flat()
+    });
+  }));
+  const words = mojigiri(tempWords.join(" "));
+  const sortedWords = [...new Set(words)].sort();
+  const regHitsArray = [
+    hit.number && "[0-9]",
+    hit.english && "[a-zA-Z]",
+    hit.hiragana && "[\u3041-\u3093]",
+    hit.katakana && "[\u30A1-\u30F4]",
+    hit.kanji && "[\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u3005\u3007\u3021-\u3029\u3038-\u303B\u3400-\u4DB5\u4E00-\u9FC3\uF900-\uFA2D\uFA30-\uFA6A\uFA70-\uFAD9]"
+  ].filter((reg) => reg);
+  const regHits = new RegExp(`(${regHitsArray.join("|")})`);
+  const tempHits = sortedWords.filter((word) => word.length >= hit.minLength && regHits.test(word) && word !== "...");
+  const hits = tempHits.map((word) => {
+    return sortedWords.indexOf(word);
+  });
+  const pages = [];
+  await Promise.all(tempPages.map(async (page) => {
+    const path2 = page.path;
+    const toc = page.toc;
+    const title = page.title.map((word) => {
+      return sortedWords.indexOf(word);
+    });
+    const content = page.content.map((word) => {
+      return sortedWords.indexOf(word);
+    });
+    pages.push({ path: path2, title, toc, content });
+  }));
+  const sortedPages = pages.sort((a, b) => {
+    const pathA = a.path.toUpperCase();
+    const pathB = b.path.toUpperCase();
+    if (pathA < pathB) {
+      return -1;
+    }
+    if (pathA > pathB) {
+      return 1;
+    }
+    return 0;
+  });
+  const template = {
+    words: sortedWords,
+    hits,
+    pages: sortedPages
+  };
+  await fs.outputJson(outFile, template).then(() => {
+    showLog && console.log(`${pc.bold(pc.green("BUILD"))} ${pc.bold(outFile)}`);
+  }).catch((err) => {
+    console.error(err);
+  });
+  return;
+}
 async function buildCopyDir(targetDir, outDir, log) {
   const checkTargetDir = await fs.pathExists(targetDir);
   if (checkTargetDir) {
@@ -574,6 +770,7 @@ export {
   buildPartialStringIndex,
   buildPartialStringInitial,
   buildRootEsmContent,
+  buildSearchJson,
   buildStaticData,
   buildStaticPage,
   buildStaticPages,

package/dist/cli.js

@@ -23,7 +23,7 @@ import { systemConfig } from "./system.js";
 import { getViteConfig } from "./vite.js";
 import { getMdxConfig } from "./mdx.js";
 import { emptyResolveDir } from "./empty.js";
-import { createDevServer } from "./server.js";
+import { createDevServer, createDevServerAssets } from "./server.js";
 import { previewLocal } from "./preview.js";
 import {
   generateViteImporters,
@@ -36,6 +36,7 @@ import {
   generateAssets,
   generatePublic,
   generateDownload,
+  generateSearchJson,
   generateBeautify
 } from "./generate.js";
 const cli = cac("minista");
@@ -58,11 +59,18 @@ cli.command("[root]", "start dev server").alias("dev").option("--host [host]", `
     const mdxConfig = await getMdxConfig(config);
     const viteConfig = await getViteConfig(config, mdxConfig, cliOptions);
     await Promise.all([
+      emptyResolveDir(systemConfig.temp.root.outDir),
+      emptyResolveDir(systemConfig.temp.assets.outDir),
+      emptyResolveDir(systemConfig.temp.pages.outDir),
       emptyResolveDir(systemConfig.temp.viteImporter.outDir),
-      emptyResolveDir(systemConfig.temp.icons.outDir)
+      emptyResolveDir(systemConfig.temp.icons.outDir),
+      emptyResolveDir(systemConfig.temp.partialHydration.outDir)
     ]);
     await generateViteImporters(config, viteConfig);
-    await createDevServer(viteConfig);
+    await Promise.all([
+      createDevServer(viteConfig),
+      createDevServerAssets(config, mdxConfig)
+    ]);
   } catch (err) {
     console.log(err);
     process.exit(1);
@@ -94,11 +102,11 @@ cli.command("build [root]", "build for production").action(async () => {
       generatePartialHydration(config, mdxConfig, viteConfig)
     ]);
     await Promise.all([
-      generateHtmlPages(config),
+      generateHtmlPages(config, config.pagesOutDir, true),
       generateAssets(config),
       generatePublic(config)
     ]);
-    await Promise.all([generateDownload(config)]);
+    await Promise.all([generateDownload(config), generateSearchJson(config)]);
     await Promise.all([
       generateBeautify(config, "html"),
       generateBeautify(config, "css"),

package/dist/config.js

@@ -109,6 +109,24 @@ const defaultConfig = {
       rehypePlugins: []
     }
   },
+  search: {
+    useJson: false,
+    cache: false,
+    outDir: "assets",
+    outName: "search",
+    include: ["**/*"],
+    exclude: ["404"],
+    trimTitle: "",
+    targetSelector: "[data-search]",
+    hit: {
+      minLength: 3,
+      number: false,
+      english: true,
+      hiragana: false,
+      katakana: true,
+      kanji: true
+    }
+  },
   beautify: {
     useHtml: true,
     useAssets: false,
@@ -171,12 +189,15 @@ async function resolveConfig(config) {
     assetsOutHref: slashEnd(config.base) + noSlashEnd(config.assets.outDir),
     downloadOutDir: slashEnd(config.out) + noSlashEnd(config.assets.download.outDir),
     downloadOutHref: slashEnd(config.base) + noSlashEnd(config.assets.download.outDir),
+    searchJsonOutput: slashEnd(config.out) + slashEnd(config.search.outDir) + noSlashEnd(config.search.outName) + ".json",
     viteAssetsOutput: slashEnd(config.assets.outDir) + noSlashEnd(config.assets.outName) + ".[ext]",
     viteAssetsImagesOutput: slashEnd(config.assets.images.outDir) + noSlashEnd(config.assets.images.outName) + ".[ext]",
     viteAssetsFontsOutput: slashEnd(config.assets.fonts.outDir) + noSlashEnd(config.assets.fonts.outName) + ".[ext]",
     vitePluginSvgSpriteIconsSrcDir: noSlashEnd(config.assets.icons.srcDir),
     vitePluginSvgSpriteIconsOutput: slashEnd("/") + slashEnd(config.assets.icons.outDir) + noSlashEnd(config.assets.icons.outName) + ".svg",
-    vitePluginSvgSpriteIconsTempOutput: slashEnd(systemConfig.temp.icons.outDir) + slashEnd(config.assets.icons.outDir) + noSlashEnd(config.assets.icons.outName) + ".svg"
+    vitePluginSvgSpriteIconsTempOutput: slashEnd(systemConfig.temp.icons.outDir) + slashEnd(config.assets.icons.outDir) + noSlashEnd(config.assets.icons.outName) + ".svg",
+    vitePluginSearchJsonOutput: slashEnd("/") + slashEnd(config.search.outDir) + noSlashEnd(config.search.outName) + ".json",
+    vitePluginSearchJsonTempOutput: slashEnd(systemConfig.temp.search.outDir) + slashEnd(config.search.outDir) + noSlashEnd(config.search.outName) + ".json"
   });
   return resolvedConfig;
 }

package/dist/esbuild.js

@@ -28,9 +28,9 @@ function getEsbuildResolvePath(args, alias) {
   }
   const aliasKeys = Object.keys(aliasObject);
   const aliasReg = new RegExp(`^(${aliasKeys.map((x) => escapeRegExp(x)).join("|")})`);
-  const aliasPath = args.path.replace(aliasReg, function(match) {
+  const aliasPath = alias.length ? args.path.replace(aliasReg, function(match) {
     return aliasObject[match];
-  });
+  }) : args.path;
   const absolutePath = path.isAbsolute(aliasPath) ? aliasPath : path.join(args.resolveDir, aliasPath);
   const replacedPath = absolutePath.replaceAll("\\", "/");
   return replacedPath;

package/dist/generate.d.ts

@@ -7,8 +7,9 @@ export declare function generateTempPages(config: MinistaResolveConfig, mdxConfi
 export declare function generateTempAssets(config: MinistaResolveConfig, viteConfig: InlineConfig): Promise<void>;
 export declare function generatePartialHydration(config: MinistaResolveConfig, mdxConfig: MdxOptions, viteConfig: InlineConfig): Promise<void>;
 export declare function generateNoStyleTemp(targetDir: string): Promise<void>;
-export declare function generateHtmlPages(config: MinistaResolveConfig): Promise<void>;
+export declare function generateHtmlPages(config: MinistaResolveConfig, outDir: string, showLog: boolean): Promise<void>;
 export declare function generateAssets(config: MinistaResolveConfig): Promise<void>;
 export declare function generatePublic(config: MinistaResolveConfig): Promise<void>;
 export declare function generateDownload(config: MinistaResolveConfig): Promise<void>;
+export declare function generateSearchJson(config: MinistaResolveConfig): Promise<void>;
 export declare function generateBeautify(config: MinistaResolveConfig, target: "html" | "css" | "js"): Promise<void>;

package/dist/generate.js

@@ -3,7 +3,12 @@ import fs from "fs-extra";
 import path from "path";
 import url from "url";
 import { systemConfig } from "./system.js";
-import { getFilePath, getFilePaths, getSameFilePaths } from "./path.js";
+import {
+  getFilePath,
+  getFilePaths,
+  getFilterFilePaths,
+  getSameFilePaths
+} from "./path.js";
 import { slashEnd, noSlashEnd } from "./utils.js";
 import {
   buildTempPages,
@@ -20,7 +25,8 @@ import {
   buildPartialStringBundle,
   buildPartialStringInitial,
   buildPartialHydrateIndex,
-  buildPartialHydrateAssets
+  buildPartialHydrateAssets,
+  buildSearchJson
 } from "./build.js";
 import { optimizeCommentOutStyleImport } from "./optimize.js";
 import { downloadFiles } from "./download.js";
@@ -119,7 +125,7 @@ async function generateNoStyleTemp(targetDir) {
     await optimizeCommentOutStyleImport(targetFiles);
   }
 }
-async function generateHtmlPages(config) {
+async function generateHtmlPages(config, outDir, showLog) {
   const tempRootName = config.root.srcName;
   const tempRootOutDir = systemConfig.temp.root.outDir;
   const tempPagesOutDir = systemConfig.temp.pages.outDir;
@@ -134,10 +140,14 @@ async function generateHtmlPages(config) {
     outBase: tempAssetsOutDir,
     outDir: config.assetsOutHref
   });
-  await buildStaticPages(tempPageFilePaths, tempRootFilePath, {
+  await buildStaticPages({
+    entryPoints: tempPageFilePaths,
+    tempRootFilePath,
     outBase: tempPagesOutDir,
-    outDir: config.pagesOutDir
-  }, assetsTagStr);
+    outDir,
+    assetsTagStr,
+    showLog
+  });
 }
 async function generateAssets(config) {
   await buildCopyDir(systemConfig.temp.assets.outDir, slashEnd(config.out) + noSlashEnd(config.assets.outDir), "assets");
@@ -152,6 +162,26 @@ async function generateDownload(config) {
   }
   return;
 }
+async function generateSearchJson(config) {
+  if (config.search.useJson) {
+    const entryPoints = await getFilterFilePaths({
+      targetDir: config.out,
+      include: config.search.include,
+      exclude: config.search.exclude,
+      exts: "html"
+    });
+    const outFile = config.searchJsonOutput;
+    await buildSearchJson({
+      config,
+      useCacheExists: false,
+      entryPoints,
+      entryBase: config.out,
+      outFile,
+      showLog: true
+    });
+  }
+  return;
+}
 async function generateBeautify(config, target) {
   switch (target) {
     case "html":
@@ -187,6 +217,7 @@ export {
   generateNoStyleTemp,
   generatePartialHydration,
   generatePublic,
+  generateSearchJson,
   generateTempAssets,
   generateTempPages,
   generateTempRoot,

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * from "./define.js";
 export * from "./head.js";
 export * from "./link.js";
 export * from "./comment.js";
+export * from "./search.js";
 export * from "./migrate.js";

package/dist/index.js

@@ -4,4 +4,5 @@ export * from "./define.js";
 export * from "./head.js";
 export * from "./link.js";
 export * from "./comment.js";
+export * from "./search.js";
 export * from "./migrate.js";

package/dist/main.d.ts

@@ -2,4 +2,5 @@ export * from "./define.js";
 export * from "./head.js";
 export * from "./link.js";
 export * from "./comment.js";
+export * from "./search.js";
 export * from "./migrate.js";

package/dist/main.js

@@ -3,4 +3,5 @@ export * from "./define.js";
 export * from "./head.js";
 export * from "./link.js";
 export * from "./comment.js";
+export * from "./search.js";
 export * from "./migrate.js";

package/dist/path.d.ts

@@ -1,3 +1,9 @@
-export declare function getFilePath(targetDir: string, fileName: string, extension: string): string;
-export declare function getFilePaths(targetDir: string, extensions: string | string[]): Promise<string[]>;
-export declare function getSameFilePaths(targetDir: string, fileName: string, extensions: string | string[]): Promise<string[]>;
+export declare function getFilePath(targetDir: string, fileName: string, ext: string): string;
+export declare function getFilePaths(targetDir: string, exts: string | string[]): Promise<string[]>;
+export declare function getFilterFilePaths({ targetDir, include, exclude, exts, }: {
+    targetDir?: string;
+    include: string[];
+    exclude?: string[];
+    exts?: string | string[];
+}): Promise<string[]>;
+export declare function getSameFilePaths(targetDir: string, fileName: string, exts: string | string[]): Promise<string[]>;

package/dist/path.js

@@ -2,25 +2,41 @@ import React from "react";
 import fs from "fs-extra";
 import fg from "fast-glob";
 import path from "path";
-function getFilePath(targetDir, fileName, extension) {
-  const filePath = `${targetDir}/${fileName}.${extension}`;
+import { slashEnd } from "./utils.js";
+function getFilePath(targetDir, fileName, ext) {
+  const filePath = `${targetDir}/${fileName}.${ext}`;
   const file = fs.existsSync(path.resolve(filePath)) ? path.resolve(filePath) : "";
   return file;
 }
-async function getFilePaths(targetDir, extensions) {
-  const strExtension = typeof extensions === "string" ? extensions : extensions.join("|");
-  const globPattern = `${targetDir}/**/*.+(${strExtension})`;
+async function getFilePaths(targetDir, exts) {
+  const strExt = typeof exts === "string" ? exts : exts.join("|");
+  const globPattern = `${targetDir}/**/*.+(${strExt})`;
   const files = await fg(globPattern, { extglob: true });
   return files;
 }
-async function getSameFilePaths(targetDir, fileName, extensions) {
-  const strExtension = typeof extensions === "string" ? extensions : extensions.join("|");
-  const globPattern = `${targetDir}/${fileName}.+(${strExtension})`;
+async function getFilterFilePaths({
+  targetDir,
+  include,
+  exclude,
+  exts
+}) {
+  const fixDir = targetDir ? slashEnd(targetDir) : "";
+  const fixExt = exts ? typeof exts === "string" ? `.${exts.replace(/^\./, "")}` : `.+(${exts.map((ext) => ext.replace(/^\./, "")).join("|")})` : "";
+  const includes = include.map((str) => `${fixDir}${str}${fixExt}`);
+  const excludes = exclude ? exclude.map((str) => `!${fixDir}${str}${fixExt}`) : [];
+  const globPattern = [includes, excludes].flat();
+  const files = await fg(globPattern, { extglob: fixExt ? true : false });
+  return files;
+}
+async function getSameFilePaths(targetDir, fileName, exts) {
+  const strExt = typeof exts === "string" ? exts : exts.join("|");
+  const globPattern = `${targetDir}/${fileName}.+(${strExt})`;
   const files = await fg(globPattern, { extglob: true });
   return files;
 }
 export {
   getFilePath,
   getFilePaths,
+  getFilterFilePaths,
   getSameFilePaths
 };

package/dist/search.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="react" />
+export declare type SearchData = {
+    words: string[];
+    hits: number[];
+    pages: SearchPage[];
+};
+export declare type SearchPage = {
+    path: string;
+    title: number[];
+    toc: [number, string][];
+    content: number[];
+};
+export declare type SearchResult = {
+    path: string;
+    content: string;
+};
+export interface SearchProps extends React.HTMLAttributes<HTMLElement> {
+    jsonPath: string;
+    placeholder?: string;
+    minHitLength?: number;
+    maxHitPages?: number;
+    maxHitWords?: number;
+    searchFieldClassName?: string;
+    searchFieldInsertBeforeElement?: React.ReactElement;
+    searchFieldInsertAfterElement?: React.ReactElement;
+    searchListClassName?: string;
+    attributes?: React.HTMLAttributes<HTMLElement>;
+}
+export interface SearchFieldProps extends React.HTMLAttributes<HTMLElement> {
+    jsonPath: string;
+    placeholder?: string;
+    minHitLength?: number;
+    maxHitPages?: number;
+    maxHitWords?: number;
+    insertBeforeElement?: React.ReactElement;
+    insertAfterElement?: React.ReactElement;
+    setSearchValues?: React.Dispatch<React.SetStateAction<string[]>>;
+    setSearchHitValues?: React.Dispatch<React.SetStateAction<string[]>>;
+    setSearchResults?: React.Dispatch<React.SetStateAction<SearchResult[]>>;
+    attributes?: React.HTMLAttributes<HTMLElement>;
+}
+export interface SearchListProps extends React.HTMLAttributes<HTMLElement> {
+    searchValues?: string[];
+    searchHitValues?: string[];
+    searchResults?: SearchResult[];
+    attributes?: React.HTMLAttributes<HTMLElement>;
+}
+export declare const Search: (props: SearchProps) => JSX.Element;
+export declare const SearchField: (props: SearchFieldProps) => JSX.Element;
+export declare const SearchList: (props: SearchListProps) => JSX.Element;

package/dist/search.js

@@ -0,0 +1,288 @@
+var __defProp = Object.defineProperty;
+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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import React from "react";
+import { useState, useEffect } from "react";
+function compNum(a, b) {
+  return a - b;
+}
+const Search = (props) => {
+  const _a = props, {
+    jsonPath,
+    placeholder = props.placeholder || "",
+    minHitLength = props.minHitLength || 2,
+    maxHitPages = props.maxHitPages || 5,
+    maxHitWords = props.maxHitWords || 20,
+    searchFieldInsertBeforeElement,
+    searchFieldInsertAfterElement,
+    searchFieldClassName,
+    searchListClassName
+  } = _a, attributes = __objRest(_a, [
+    "jsonPath",
+    "placeholder",
+    "minHitLength",
+    "maxHitPages",
+    "maxHitWords",
+    "searchFieldInsertBeforeElement",
+    "searchFieldInsertAfterElement",
+    "searchFieldClassName",
+    "searchListClassName"
+  ]);
+  const [searchValues, setSearchValues] = useState([]);
+  const [searchHitValues, setSearchHitValues] = useState([]);
+  const [searchResults, setSearchResults] = useState([]);
+  return /* @__PURE__ */ React.createElement("div", __spreadValues({}, attributes), /* @__PURE__ */ React.createElement(SearchField, {
+    className: searchFieldClassName,
+    jsonPath,
+    placeholder,
+    minHitLength,
+    maxHitPages,
+    maxHitWords,
+    insertBeforeElement: searchFieldInsertBeforeElement,
+    insertAfterElement: searchFieldInsertAfterElement,
+    setSearchValues,
+    setSearchHitValues,
+    setSearchResults
+  }), /* @__PURE__ */ React.createElement(SearchList, {
+    className: searchListClassName,
+    searchValues,
+    searchHitValues,
+    searchResults
+  }));
+};
+const SearchField = (props) => {
+  const _a = props, {
+    jsonPath,
+    placeholder = props.placeholder || "",
+    minHitLength = props.minHitLength || 2,
+    maxHitPages = props.maxHitPages || 5,
+    maxHitWords = props.maxHitWords || 20,
+    insertBeforeElement,
+    insertAfterElement,
+    setSearchValues,
+    setSearchHitValues,
+    setSearchResults
+  } = _a, attributes = __objRest(_a, [
+    "jsonPath",
+    "placeholder",
+    "minHitLength",
+    "maxHitPages",
+    "maxHitWords",
+    "insertBeforeElement",
+    "insertAfterElement",
+    "setSearchValues",
+    "setSearchHitValues",
+    "setSearchResults"
+  ]);
+  const [callSearchData, setCallSearchData] = useState(false);
+  const [searchData, setSearchData] = useState({
+    words: [],
+    hits: [],
+    pages: []
+  });
+  const [searchHits, setSearchHits] = useState([]);
+  const [searchPages, setSearchPages] = useState([]);
+  const searchHandler = (event) => {
+    if (!callSearchData) {
+      setCallSearchData(true);
+    }
+    if (!searchData || !searchHits || !searchPages) {
+      return;
+    }
+    const inputValues = event.target.value.split(" ");
+    const mergedInputValues = [...new Set(inputValues)].sort();
+    const hitValues = mergedInputValues.map((value) => {
+      if (value.length >= minHitLength) {
+        return searchHits.filter((hit) => {
+          return new RegExp(value, "i").test(hit);
+        });
+      } else {
+        return [];
+      }
+    });
+    const mergedHitValues = [...new Set(hitValues.flat())].sort();
+    const hitIndexes = mergedHitValues.map((value) => {
+      return searchData.words.indexOf(value);
+    });
+    const hitPages = searchPages.flatMap((page) => {
+      const titleIndexs = page.title.filter((i) => hitIndexes.indexOf(i) !== -1);
+      const contentIndexs = page.content.filter((i) => hitIndexes.indexOf(i) !== -1);
+      if (titleIndexs.length || contentIndexs.length) {
+        return {
+          path: page.path,
+          title: titleIndexs,
+          toc: page.toc,
+          content: contentIndexs
+        };
+      } else {
+        return [];
+      }
+    });
+    const sortedHitPages = [...new Set(hitPages)].sort((a, b) => {
+      if (a.title.length !== b.title.length) {
+        return (a.title.length - b.title.length) * -1;
+      }
+      if (a.content.length !== b.content.length) {
+        return (a.content.length - b.content.length) * -1;
+      }
+      return 0;
+    }).slice(0, maxHitPages);
+    const resultHitPages = sortedHitPages.map((page) => {
+      const targetPage = searchData.pages.find((dataPage) => dataPage.path === page.path);
+      if (page.title.length) {
+        const targetContent = targetPage.title.map((num) => searchData.words[num]).join(" ");
+        return {
+          path: targetPage.path,
+          content: targetContent
+        };
+      } else {
+        let getTargetId = function(targetIndex2, toc) {
+          if (!toc.length) {
+            return "";
+          }
+          const targetToc = page.toc.filter((item) => targetIndex2 >= item[0]).slice(-1)[0];
+          const targetId2 = targetToc ? "#" + targetToc[1] : "";
+          return targetId2;
+        };
+        const targetWord = page.content[0];
+        const targetIndex = targetPage.content.indexOf(targetWord);
+        const targetIndexes = targetPage.content.slice(targetIndex, targetIndex + maxHitWords);
+        const targetWords = targetIndexes.map((num) => searchData.words[num]).join("");
+        const targetContent = "..." + targetWords + "...";
+        const targetId = getTargetId(targetIndex, page.toc);
+        return {
+          path: targetPage.path + targetId,
+          content: targetContent
+        };
+      }
+    });
+    if (setSearchValues) {
+      const filterdInputValues = mergedInputValues.filter((value) => value && !value.includes(" "));
+      setSearchValues(filterdInputValues);
+    }
+    if (setSearchHitValues) {
+      setSearchHitValues(mergedHitValues);
+    }
+    if (setSearchResults) {
+      setSearchResults(resultHitPages);
+    }
+    return;
+  };
+  useEffect(() => {
+    if (callSearchData) {
+      const getSearchData = async () => {
+        const response = await fetch(jsonPath);
+        const data = await response.json();
+        setSearchData(data);
+        if (data.words && data.hits) {
+          const hitWords = [];
+          await Promise.all(data.hits.map(async (hit) => {
+            return hitWords.push(data.words[hit]);
+          }));
+          setSearchHits(hitWords);
+        }
+        if (data.words && data.pages) {
+          const optimizePages = [];
+          await Promise.all(data.pages.map(async (page) => {
+            return optimizePages.push({
+              path: page.path,
+              title: [...new Set(page.title)].sort(compNum),
+              toc: page.toc,
+              content: [...new Set(page.content)].sort(compNum)
+            });
+          }));
+          setSearchPages(optimizePages);
+        }
+      };
+      getSearchData();
+    }
+  }, [callSearchData]);
+  return /* @__PURE__ */ React.createElement("div", __spreadValues({}, attributes), insertBeforeElement, /* @__PURE__ */ React.createElement("input", {
+    type: "search",
+    placeholder,
+    onChange: searchHandler
+  }), insertAfterElement);
+};
+const SearchList = (props) => {
+  const _a = props, { searchValues, searchHitValues, searchResults } = _a, attributes = __objRest(_a, ["searchValues", "searchHitValues", "searchResults"]);
+  const checkValues = searchValues && searchValues.length;
+  const checkHitValues = searchHitValues && searchHitValues.length;
+  const checkResults = searchResults && searchResults.length;
+  if (checkValues && checkHitValues && checkResults) {
+    const regValues = new RegExp(`(${searchValues.join("|")})`, "ig");
+    const regHitValues = new RegExp(`(${searchHitValues.join("|")})`, "ig");
+    return /* @__PURE__ */ React.createElement("ul", __spreadValues({}, attributes), searchResults.map((item, index) => {
+      const words = item.content.split(regHitValues);
+      const filteredWords = words.filter((word) => word && word.length > 0);
+      const renderdWords = filteredWords.map((word, wordIndex) => {
+        if (word.match(regHitValues)) {
+          const glyphs = word.split(regValues);
+          const renderdGlyphs = glyphs.map((glyph, glyphIndex) => {
+            if (glyph.match(regValues)) {
+              return /* @__PURE__ */ React.createElement("mark", {
+                key: glyphIndex
+              }, glyph);
+            } else {
+              return /* @__PURE__ */ React.createElement("span", {
+                key: glyphIndex
+              }, glyph);
+            }
+          });
+          return /* @__PURE__ */ React.createElement("span", {
+            key: wordIndex
+          }, renderdGlyphs);
+        } else {
+          return /* @__PURE__ */ React.createElement("span", {
+            key: wordIndex
+          }, word);
+        }
+      });
+      const content = renderdWords;
+      return /* @__PURE__ */ React.createElement("li", {
+        key: index
+      }, /* @__PURE__ */ React.createElement("a", {
+        href: item.path
+      }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("strong", null, content)), /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("small", null, item.path)))));
+    }));
+  } else if (checkResults) {
+    return /* @__PURE__ */ React.createElement("ul", __spreadValues({}, attributes), searchResults.map((item, index) => {
+      return /* @__PURE__ */ React.createElement("li", {
+        key: index
+      }, /* @__PURE__ */ React.createElement("a", {
+        href: item.path
+      }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("strong", null, item.content)), /* @__PURE__ */ React.createElement("p", null, /* @__PURE__ */ React.createElement("small", null, item.path)))));
+    }));
+  } else {
+    return /* @__PURE__ */ React.createElement(React.Fragment, null);
+  }
+};
+export {
+  Search,
+  SearchField,
+  SearchList
+};

package/dist/server.d.ts

@@ -1,2 +1,5 @@
 import type { InlineConfig } from "vite";
+import type { Options as MdxOptions } from "@mdx-js/esbuild";
+import type { MinistaResolveConfig } from "./types.js";
 export declare function createDevServer(viteConfig: InlineConfig): Promise<void>;
+export declare function createDevServerAssets(config: MinistaResolveConfig, mdxConfig: MdxOptions): Promise<void>;

package/dist/server.js

@@ -1,10 +1,64 @@
 import React from "react";
+import fs from "fs-extra";
+import path from "path";
 import { createServer } from "vite";
+import { systemConfig } from "./system.js";
+import { getFilterFilePaths } from "./path.js";
+import { emptyResolveDir } from "./empty.js";
+import {
+  generateTempRoot,
+  generateTempPages,
+  generateNoStyleTemp,
+  generateHtmlPages
+} from "./generate.js";
+import { buildSearchJson } from "./build.js";
 async function createDevServer(viteConfig) {
   const server = await createServer(viteConfig);
   await server.listen();
   server.printUrls();
 }
+async function createDevServerAssets(config, mdxConfig) {
+  const stopUseTriggers = [!config.search.useJson];
+  const stopUseTrigger = stopUseTriggers.every((trigger) => trigger);
+  if (stopUseTrigger) {
+    return;
+  }
+  const searchFile = config.vitePluginSearchJsonTempOutput;
+  const searchFileRelative = path.relative(".", searchFile);
+  const searchFileExists = fs.existsSync(searchFileRelative);
+  const searchUseCacheExists = config.search.cache && searchFileExists;
+  const stopCacheTriggers = [searchUseCacheExists];
+  const stopCacheTrigger = stopCacheTriggers.every((cache) => cache);
+  if (stopCacheTrigger) {
+    return;
+  }
+  await emptyResolveDir(systemConfig.temp.html.outDir);
+  await Promise.all([
+    generateTempRoot(config, mdxConfig),
+    generateTempPages(config, mdxConfig)
+  ]);
+  await Promise.all([
+    generateNoStyleTemp(systemConfig.temp.root.outDir),
+    generateNoStyleTemp(systemConfig.temp.pages.outDir)
+  ]);
+  await generateHtmlPages(config, systemConfig.temp.html.outDir, false);
+  const searchEntryPoints = await getFilterFilePaths({
+    targetDir: systemConfig.temp.html.outDir,
+    include: config.search.include,
+    exclude: config.search.exclude,
+    exts: "html"
+  });
+  await buildSearchJson({
+    config,
+    useCacheExists: searchUseCacheExists,
+    entryPoints: searchEntryPoints,
+    entryBase: systemConfig.temp.html.outDir,
+    outFile: searchFile,
+    showLog: false
+  });
+  return;
+}
 export {
-  createDevServer
+  createDevServer,
+  createDevServerAssets
 };

package/dist/system.js

@@ -22,6 +22,12 @@ const systemConfig = {
     },
     icons: {
       outDir: "node_modules/.minista/svg-sprite-icons"
+    },
+    html: {
+      outDir: "node_modules/.minista/temp-html-pages"
+    },
+    search: {
+      outDir: "node_modules/.minista/temp-search"
     }
   }
 };

package/dist/types.d.ts

@@ -78,6 +78,24 @@ export declare type MinistaConfig = {
         highlightOptions: HighlightOptions;
         mdxOptions: MdxOptions;
     };
+    search: {
+        useJson: boolean;
+        cache: boolean;
+        outDir: string;
+        outName: string;
+        include: string[];
+        exclude: string[];
+        trimTitle: string;
+        targetSelector: string;
+        hit: {
+            minLength: number;
+            number: boolean;
+            english: boolean;
+            hiragana: boolean;
+            katakana: boolean;
+            kanji: boolean;
+        };
+    };
     beautify: {
         useHtml: boolean;
         useAssets: boolean;
@@ -157,6 +175,24 @@ export declare type MinistaUserConfig = {
         highlightOptions?: HighlightOptions;
         mdxOptions?: MdxOptions;
     };
+    search?: {
+        useJson?: boolean;
+        cache?: boolean;
+        outDir?: string;
+        outName?: string;
+        include?: string[];
+        exclude?: string[];
+        trimTitle?: string;
+        targetSelector?: string;
+        hit?: {
+            minLength?: number;
+            number?: boolean;
+            english?: boolean;
+            hiragana?: boolean;
+            katakana?: boolean;
+            kanji?: boolean;
+        };
+    };
     beautify?: {
         useHtml?: boolean;
         useAssets?: boolean;
@@ -178,12 +214,15 @@ export declare type MinistaResolvePathConfig = {
     assetsOutHref: string;
     downloadOutDir: string;
     downloadOutHref: string;
+    searchJsonOutput: string;
     viteAssetsOutput: string;
     viteAssetsImagesOutput: string;
     viteAssetsFontsOutput: string;
     vitePluginSvgSpriteIconsSrcDir: string;
     vitePluginSvgSpriteIconsOutput: string;
     vitePluginSvgSpriteIconsTempOutput: string;
+    vitePluginSearchJsonOutput: string;
+    vitePluginSearchJsonTempOutput: string;
 };
 export declare type MinistaSystemConfig = {
     temp: {
@@ -209,6 +248,12 @@ export declare type MinistaSystemConfig = {
         icons: {
             outDir: string;
         };
+        html: {
+            outDir: string;
+        };
+        search: {
+            outDir: string;
+        };
     };
 };
 export declare type MinistaCliDevOptions = {

package/dist/vite.js

@@ -108,6 +108,13 @@ async function getViteConfig(config, mdxConfig, cliOptions) {
     mergedViteConfig.plugins.push(iconsPlugin);
     mergedViteConfig.resolve.alias.push(iconsResolveAlias);
   }
+  if (config.search.useJson) {
+    const searchResolveAlias = {
+      find: config.vitePluginSearchJsonOutput,
+      replacement: path.resolve(config.vitePluginSearchJsonTempOutput)
+    };
+    mergedViteConfig.resolve.alias.push(searchResolveAlias);
+  }
   const mdxPlugin = mdx(mdxConfig);
   mergedViteConfig.plugins.push(mdxPlugin);
   return cliOptions ? mergeViteConfig(mergedViteConfig, { server: cliOptions }) : mergedViteConfig;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minista",
   "description": "Next.js Like Development with 100% Static Generate",
-  "version": "2.6.2",
+  "version": "2.7.2",
   "bin": {
     "minista": "./bin/minista.js"
   },
@@ -97,6 +97,7 @@
     "fs-extra": "^10.1.0",
     "js-beautify": "^1.14.3",
     "mime-types": "^2.1.35",
+    "mojigiri": "^0.3.0",
     "node-fetch": "^3.2.5",
     "node-html-parser": "^5.3.3",
     "picocolors": "^1.0.0",