@ckpack/markdown-wx 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ckvv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+@ckpack/markdown-wx
+
+将 Markdown 转换为微信小程序富文本格式(https://developers.weixin.qq.com/miniprogram/dev/component/rich-text.html)
+
+# client
+通过 [markdown-exit](https://markdown-exit.pages.dev/guide/introduction.html) 将 markdown 字符串 转为 html
+
+## 通过插件支持数学公式支持
+行内公式 用 单个 $ 包起来：`$E = mc^2$`
+块级公式 用 双 $$ 包起来：`$$E = mc^2$$`
+通过插件请求 server 接口 渲染公式内容为 svg
+
+# server
+通过 [katex](https://katex.org/docs/node) 将 公式 转为 svg 图片
+
+# API
+
+## client
+
+### createMarkdownWx(options?)
+创建一个渲染器。
+
+参数:
+- options.markdown: MarkdownExitOptions，透传给 markdown-exit
+- options.math: MathPluginOptions，开启数学公式插件
+
+返回:
+- { render: (src, env?) => Promise<string> }
+
+示例:
+```ts
+import { createMarkdownWx } from '@ckpack/markdown-wx';
+
+const renderer = createMarkdownWx({
+  math: { endpoint: 'http://localhost:3000/katex' }
+});
+
+const html = await renderer.render('# Hello $E=mc^2$');
+```
+
+### renderMarkdownToWx(src, options?)
+一键渲染。
+
+参数:
+- src: markdown 字符串
+- options: 同 createMarkdownWx
+
+返回:
+- Promise<string> (HTML)
+
+示例:
+```ts
+import { renderMarkdownToWx } from '@ckpack/markdown-wx';
+
+const html = await renderMarkdownToWx('$$E=mc^2$$', {
+  math: { endpoint: 'http://localhost:3000/katex' }
+});
+```
+
+### mathPlugin(options?)
+数学公式插件。
+
+MathPluginOptions:
+- render?: (context) => Promise<string> | string
+  直接提供渲染函数，返回 svg 字符串
+- endpoint?: string
+  公式渲染服务地址 (POST JSON 或 GET query)
+- fetch?: FetchLike
+  自定义 fetch 实现 (微信小程序可用 createWxRequestFetchLike)
+- requestInit?: FetchInit | ((context) => FetchInit)
+  自定义请求参数
+- output?: 'img' | 'svg'
+  输出为 img(data uri) 或直接嵌入 svg，默认 'img'
+- svgToDataUri?: (svg) => string
+  自定义 svg -> data uri
+- inlineClassName?: string
+  行内公式 class
+- blockClassName?: string
+  块级公式 class
+
+MathRenderContext:
+- formula: string
+- displayMode: boolean
+
+示例(自定义 render):
+```ts
+import { createMarkdownWx } from '@ckpack/markdown-wx';
+
+const renderer = createMarkdownWx({
+  math: {
+    render: ({ formula, displayMode }) =>
+      `<svg xmlns="http://www.w3.org/2000/svg"><text>${displayMode ? 'block:' : 'inline:'}${formula}</text></svg>`
+  }
+});
+```
+
+### createWxRequestFetchLike(wxRequest?, options?)
+将微信小程序的 wx.request 封装成 FetchLike。
+
+参数:
+- wxRequest?: WxRequest (默认使用全局 wx.request)
+- options.dataType?: string (默认 'text')
+- options.responseType?: string
+- options.timeout?: number
+
+返回:
+- FetchLike
+
+示例:
+```ts
+import { createMarkdownWx, createWxRequestFetchLike } from '@ckpack/markdown-wx';
+
+const fetchLike = createWxRequestFetchLike();
+
+const html = await createMarkdownWx({
+  math: {
+    endpoint: 'https://example.com/katex',
+    fetch: fetchLike
+  }
+}).render('$E=mc^2$');
+```
+
+## server
+
+### renderFormulaToSvg(formula, options?)
+将公式渲染为 svg 字符串。
+
+参数:
+- formula: string
+- options: RenderFormulaOptions (katex 选项 + displayMode? + css?)
+
+示例:
+```ts
+import { renderFormulaToSvg } from '@ckpack/markdown-wx';
+
+const svg = renderFormulaToSvg('E = mc^2', { displayMode: true });
+```
+
+### createMathSvgHandler(options?)
+创建一个 Node HTTP handler，处理公式渲染请求。
+
+参数:
+- path?: string (默认 '/katex')
+- cors?: boolean (默认 true)
+- maxBodySize?: number (默认 1MB)
+- 其余字段同 RenderFormulaOptions
+
+请求格式:
+- GET /katex?formula=...&displayMode=true
+- POST /katex { "formula": "...", "displayMode": true }
+
+### createMathSvgServer(options?)
+快速创建 HTTP Server。
+
+示例:
+```ts
+import { createMathSvgServer } from '@ckpack/markdown-wx/server';
+
+const server = createMathSvgServer({ path: '/katex' });
+server.listen(3000);
+```
+
+### getKatexCss()
+返回内置的 KaTeX CSS 字符串，可复用或缓存。

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+import { MarkdownExit, MarkdownExitOptions } from "markdown-exit";
+
+//#region src/math.d.ts
+interface FetchInit {
+  method?: string;
+  headers?: Record<string, string>;
+  body?: string;
+}
+interface FetchResponseLike {
+  ok: boolean;
+  status: number;
+  statusText: string;
+  text: () => Promise<string>;
+}
+type FetchLike = (input: string | URL, init?: FetchInit) => Promise<FetchResponseLike>;
+interface MathRenderContext {
+  formula: string;
+  displayMode: boolean;
+}
+type MathRenderer = (context: MathRenderContext) => Promise<string> | string;
+interface MathPluginOptions {
+  render?: MathRenderer;
+  endpoint?: string;
+  fetch?: FetchLike;
+  requestInit?: FetchInit | ((context: MathRenderContext) => FetchInit);
+  output?: 'img' | 'svg';
+  svgToDataUri?: (svg: string) => string;
+  inlineClassName?: string;
+  blockClassName?: string;
+}
+declare function mathPlugin(options?: MathPluginOptions): (md: MarkdownExit) => void;
+//#endregion
+//#region src/wx-fetch.d.ts
+interface WxRequestSuccessResult {
+  data: unknown;
+  statusCode: number;
+  header: Record<string, string>;
+  cookies?: string[];
+  errMsg: string;
+}
+interface WxRequestFailResult {
+  errMsg: string;
+}
+interface WxRequestOptions {
+  url: string;
+  data?: unknown;
+  header?: Record<string, string>;
+  method?: string;
+  dataType?: string;
+  responseType?: string;
+  timeout?: number;
+  success?: (res: WxRequestSuccessResult) => void;
+  fail?: (res: WxRequestFailResult) => void;
+  complete?: (res: WxRequestSuccessResult | WxRequestFailResult) => void;
+}
+interface WxRequestTask {
+  abort: () => void;
+}
+type WxRequest = (options: WxRequestOptions) => WxRequestTask;
+interface WxFetchOptions {
+  dataType?: string;
+  responseType?: string;
+  timeout?: number;
+}
+declare function createWxRequestFetchLike(wxRequest?: WxRequest | undefined, options?: WxFetchOptions): FetchLike;
+//#endregion
+//#region src/index.d.ts
+interface MarkdownWxOptions {
+  markdown?: MarkdownExitOptions;
+  math?: MathPluginOptions;
+}
+interface MarkdownWxRenderer {
+  render: (src: string, env?: Record<string, unknown>) => Promise<string>;
+}
+declare function createMarkdownWx(options?: MarkdownWxOptions): MarkdownWxRenderer;
+declare function renderMarkdownToWx(src: string, options?: MarkdownWxOptions): Promise<string>;
+//#endregion
+export { type FetchInit, type FetchLike, type FetchResponseLike, MarkdownWxOptions, MarkdownWxRenderer, type MathPluginOptions, type MathRenderContext, type MathRenderer, type WxFetchOptions, type WxRequest, createMarkdownWx, createWxRequestFetchLike, mathPlugin, renderMarkdownToWx };

package/dist/index.js

@@ -0,0 +1,215 @@
+import { createMarkdownExit } from "markdown-exit";
+
+//#region src/math.ts
+function resolveRenderer(options) {
+	if (options.render) return options.render;
+	if (!options.endpoint) return async () => {
+		throw new Error("Math renderer is not configured. Provide render() or endpoint.");
+	};
+	const fetcher = options.fetch ?? globalThis.fetch;
+	if (!fetcher) return async () => {
+		throw new Error("fetch is not available. Provide a fetch implementation.");
+	};
+	return async (context) => {
+		const payload = {
+			formula: context.formula,
+			displayMode: context.displayMode
+		};
+		const init = typeof options.requestInit === "function" ? options.requestInit(context) : options.requestInit ?? {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(payload)
+		};
+		const response = await fetcher(options.endpoint, init);
+		if (!response.ok) throw new Error(`Math render request failed: ${response.status} ${response.statusText}`);
+		return response.text();
+	};
+}
+function svgToDataUri(svg) {
+	const cleaned = svg.replace(/[\n\r\t]+/g, " ").trim();
+	return `data:image/svg+xml;utf8,${encodeURIComponent(cleaned).replace(/%20/g, " ").replace(/%3D/g, "=").replace(/%3A/g, ":").replace(/%2F/g, "/")}`;
+}
+function normalizeFormula(content) {
+	return content.replace(/\s+$/g, "").replace(/^\s+/g, "");
+}
+function buildResolvedOptions(options) {
+	return {
+		render: resolveRenderer(options),
+		output: options.output ?? "img",
+		svgToDataUri: options.svgToDataUri ?? svgToDataUri,
+		inlineClassName: options.inlineClassName,
+		blockClassName: options.blockClassName
+	};
+}
+function renderImg(svg, formula, displayMode, md, resolved) {
+	const dataUri = resolved.svgToDataUri(svg);
+	const alt = md.utils.escapeHtml(formula);
+	const className = displayMode ? resolved.blockClassName : resolved.inlineClassName;
+	return `<img${className ? ` class="${md.utils.escapeHtml(className)}"` : ""} data-math="${displayMode ? "block" : "inline"}" style="${displayMode ? "display:block;max-width:100%;margin:0.5em 0;" : "display:inline-block;vertical-align:middle;"}" alt="${alt}" src="${dataUri}">`;
+}
+function renderSvg(svg, displayMode, md, resolved) {
+	const className = displayMode ? resolved.blockClassName : resolved.inlineClassName;
+	const classAttr = className ? ` class="${md.utils.escapeHtml(className)}"` : "";
+	const wrapper = displayMode ? "div" : "span";
+	return `<${wrapper}${classAttr} data-math="${displayMode ? "block" : "inline"}">${svg}</${wrapper}>`;
+}
+function createRenderRule(md, resolved, displayMode) {
+	return async (tokens, idx, _options, _env) => {
+		const formula = normalizeFormula(tokens[idx].content);
+		const svg = await resolved.render({
+			formula,
+			displayMode
+		});
+		return resolved.output === "svg" ? renderSvg(svg, displayMode, md, resolved) : renderImg(svg, formula, displayMode, md, resolved);
+	};
+}
+function mathInlineRule(state, silent) {
+	const start = state.pos;
+	const max = state.posMax;
+	if (state.src.charCodeAt(start) !== 36) return false;
+	if (start + 1 < max && state.src.charCodeAt(start + 1) === 36) return false;
+	if (start > 0 && state.src.charCodeAt(start - 1) === 92) return false;
+	let pos = start + 1;
+	while (pos < max) {
+		const match = state.src.indexOf("$", pos);
+		if (match === -1) return false;
+		if (state.src.charCodeAt(match - 1) !== 92) {
+			pos = match;
+			break;
+		}
+		pos = match + 1;
+	}
+	if (pos >= max) return false;
+	if (pos === start + 1) return false;
+	if (!silent) {
+		const token = state.push("math_inline", "span", 0);
+		token.markup = "$";
+		token.content = state.src.slice(start + 1, pos);
+	}
+	state.pos = pos + 1;
+	return true;
+}
+function mathBlockRule(state, startLine, endLine, silent) {
+	let pos = state.bMarks[startLine] + state.tShift[startLine];
+	let max = state.eMarks[startLine];
+	if (pos + 2 > max) return false;
+	if (state.src.slice(pos, pos + 2) !== "$$") return false;
+	if (silent) return true;
+	let nextLine = startLine;
+	let content = "";
+	let lineText = state.src.slice(pos + 2, max);
+	if (lineText.trim().endsWith("$$")) {
+		const lastIndex = lineText.lastIndexOf("$$");
+		content = lineText.slice(0, lastIndex).trim();
+		state.line = startLine + 1;
+	} else {
+		let found = false;
+		content += `${lineText}\n`;
+		while (true) {
+			nextLine += 1;
+			if (nextLine >= endLine) break;
+			pos = state.bMarks[nextLine] + state.tShift[nextLine];
+			max = state.eMarks[nextLine];
+			lineText = state.src.slice(pos, max);
+			const endIndex = lineText.indexOf("$$");
+			if (endIndex !== -1) {
+				content += lineText.slice(0, endIndex);
+				state.line = nextLine + 1;
+				found = true;
+				break;
+			}
+			content += `${lineText}\n`;
+		}
+		if (!found) state.line = nextLine;
+	}
+	const token = state.push("math_block", "div", 0);
+	token.block = true;
+	token.content = content;
+	token.map = [startLine, state.line];
+	token.markup = "$$";
+	return true;
+}
+function mathPlugin(options = {}) {
+	return (md) => {
+		const resolved = buildResolvedOptions(options);
+		md.inline.ruler.after("escape", "math_inline", mathInlineRule);
+		md.block.ruler.after("blockquote", "math_block", mathBlockRule, { alt: [
+			"paragraph",
+			"reference",
+			"blockquote",
+			"list"
+		] });
+		md.renderer.rules.math_inline = createRenderRule(md, resolved, false);
+		md.renderer.rules.math_block = createRenderRule(md, resolved, true);
+	};
+}
+
+//#endregion
+//#region src/wx-fetch.ts
+function getDefaultWxRequest() {
+	return globalThis.wx?.request;
+}
+function normalizeText(data) {
+	if (typeof data === "string") return data;
+	try {
+		return JSON.stringify(data);
+	} catch {
+		return String(data);
+	}
+}
+function getHeaderValue(headers, name) {
+	const lower = name.toLowerCase();
+	for (const key of Object.keys(headers)) if (key.toLowerCase() === lower) return headers[key];
+}
+function createWxRequestFetchLike(wxRequest = getDefaultWxRequest(), options = {}) {
+	if (!wxRequest) return async () => {
+		throw new Error("wx.request is not available. Provide wxRequest explicitly.");
+	};
+	return (input, init) => {
+		const url = typeof input === "string" ? input : input.toString();
+		const method = init?.method ?? "GET";
+		const headers = init?.headers ?? {};
+		let data = init?.body;
+		const contentType = getHeaderValue(headers, "content-type");
+		if (typeof data === "string" && contentType?.toLowerCase().includes("application/json")) try {
+			data = JSON.parse(data);
+		} catch {}
+		return new Promise((resolve, reject) => {
+			wxRequest({
+				url,
+				method,
+				data,
+				header: headers,
+				dataType: options.dataType ?? "text",
+				responseType: options.responseType,
+				timeout: options.timeout,
+				success: (res) => {
+					const status = res.statusCode ?? 0;
+					resolve({
+						ok: status >= 200 && status < 300,
+						status,
+						statusText: res.errMsg ?? "",
+						text: async () => normalizeText(res.data)
+					});
+				},
+				fail: (err) => {
+					reject(new Error(err?.errMsg ?? "wx.request failed"));
+				}
+			});
+		});
+	};
+}
+
+//#endregion
+//#region src/index.ts
+function createMarkdownWx(options = {}) {
+	const md = createMarkdownExit(options.markdown);
+	if (options.math) md.use(mathPlugin(options.math));
+	return { render: (src, env) => md.renderAsync(src, env) };
+}
+async function renderMarkdownToWx(src, options = {}) {
+	return createMarkdownWx(options).render(src);
+}
+
+//#endregion
+export { createMarkdownWx, createWxRequestFetchLike, mathPlugin, renderMarkdownToWx };

package/dist/server/index.d.mts

@@ -0,0 +1,20 @@
+import * as http from "node:http";
+import { IncomingMessage, ServerResponse } from "node:http";
+import * as katex from "katex";
+
+//#region src/server/index.d.ts
+interface RenderFormulaOptions extends katex.KatexOptions {
+  displayMode?: boolean;
+  css?: string;
+}
+interface MathSvgServerOptions extends RenderFormulaOptions {
+  path?: string;
+  cors?: boolean;
+  maxBodySize?: number;
+}
+declare function getKatexCss(): string;
+declare function renderFormulaToSvg(formula: string, options?: RenderFormulaOptions): string;
+declare function createMathSvgHandler(options?: MathSvgServerOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+declare function createMathSvgServer(options?: MathSvgServerOptions): http.Server;
+//#endregion
+export { MathSvgServerOptions, RenderFormulaOptions, createMathSvgHandler, createMathSvgServer, getKatexCss, renderFormulaToSvg };

package/dist/server/index.mjs

@@ -0,0 +1,121 @@
+import { createRequire } from "node:module";
+import { Buffer } from "node:buffer";
+import { readFileSync } from "node:fs";
+import * as http from "node:http";
+import * as katex from "katex";
+
+//#region src/server/index.ts
+let cachedKatexCss = null;
+function getKatexCss() {
+	if (cachedKatexCss) return cachedKatexCss;
+	cachedKatexCss = readFileSync(createRequire(import.meta.url).resolve("katex/dist/katex.css"), "utf8");
+	return cachedKatexCss;
+}
+function renderFormulaToSvg(formula, options = {}) {
+	const { displayMode = false, css = getKatexCss(), ...katexOptions } = options;
+	const html = katex.renderToString(formula, {
+		displayMode,
+		throwOnError: false,
+		...katexOptions
+	});
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" overflow="visible">
+  <foreignObject x="0" y="0" width="100%" height="100%">
+    ${`
+<div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;line-height:1;">
+  ${css ? `<style>${css}</style>` : ""}
+  ${html}
+</div>`}
+  </foreignObject>
+</svg>`;
+}
+function parseBoolean(value) {
+	if (!value) return false;
+	return value === "1" || value.toLowerCase() === "true";
+}
+async function readRequestBody(req, maxBodySize) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > maxBodySize) {
+				reject(/* @__PURE__ */ new Error("Request body too large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+function createMathSvgHandler(options = {}) {
+	const { path = "/katex", cors = true, maxBodySize = 1024 * 1024, ...renderOptions } = options;
+	return async (req, res) => {
+		const host = req.headers.host ?? "localhost";
+		const url = new URL(req.url ?? "/", `http://${host}`);
+		if (url.pathname !== path) {
+			res.statusCode = 404;
+			res.end("Not Found");
+			return;
+		}
+		if (cors) {
+			res.setHeader("Access-Control-Allow-Origin", "*");
+			res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+			res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+		}
+		if (req.method === "OPTIONS") {
+			res.statusCode = 204;
+			res.end();
+			return;
+		}
+		let formula = "";
+		let displayMode = false;
+		if (req.method === "GET") {
+			formula = url.searchParams.get("formula") ?? "";
+			displayMode = parseBoolean(url.searchParams.get("displayMode"));
+		} else if (req.method === "POST") {
+			const body = await readRequestBody(req, maxBodySize);
+			try {
+				const payload = JSON.parse(body);
+				formula = payload.formula ?? "";
+				displayMode = Boolean(payload.displayMode);
+			} catch {
+				res.statusCode = 400;
+				res.end("Invalid JSON payload");
+				return;
+			}
+		} else {
+			res.statusCode = 405;
+			res.end("Method Not Allowed");
+			return;
+		}
+		if (!formula.trim()) {
+			res.statusCode = 400;
+			res.end("Missing formula");
+			return;
+		}
+		try {
+			const svg = renderFormulaToSvg(formula, {
+				displayMode,
+				...renderOptions
+			});
+			res.statusCode = 200;
+			res.setHeader("Content-Type", "image/svg+xml; charset=utf-8");
+			res.end(svg);
+		} catch (error) {
+			res.statusCode = 500;
+			res.end(error instanceof Error ? error.message : "Render failed");
+		}
+	};
+}
+function createMathSvgServer(options = {}) {
+	const handler = createMathSvgHandler(options);
+	return http.createServer((req, res) => {
+		handler(req, res);
+	});
+}
+
+//#endregion
+export { createMathSvgHandler, createMathSvgServer, getKatexCss, renderFormulaToSvg };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@ckpack/markdown-wx",
+  "type": "module",
+  "version": "1.0.0",
+  "private": false,
+  "packageManager": "pnpm@10.12.1+sha512.f0dda8580f0ee9481c5c79a1d927b9164f2c478e90992ad268bbb2465a736984391d6333d2c327913578b2804af33474ca554ba29c04a8b13060a717675ae3ac",
+  "description": "将 Markdown 转换为微信小程序富文本格式.",
+  "author": "ckvv",
+  "license": "MIT",
+  "repository": "https://github.com/ckpack/markdown-wx",
+  "exports": {
+    ".": "./dist/index.js",
+    "./server": "./dist/server/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "node --import=tsx src/index.ts",
+    "build": "tsdown",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint --fix",
+    "publish:npm": "npm run build && npm publish --registry https://registry.npmjs.org/ --access public"
+  },
+  "dependencies": {
+    "katex": "^0.16.28",
+    "markdown-exit": "1.0.0-beta.7"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^7.2.0",
+    "@types/node": "^25.0.10",
+    "eslint": "^9.39.2",
+    "lint-staged": "^16.2.7",
+    "simple-git-hooks": "^2.13.1",
+    "tsdown": "^0.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "npx lint-staged"
+  },
+  "lint-staged": {
+    "*.{js,ts,mjs,cjs,tsx,jsx,vue,md}": [
+      "eslint --fix"
+    ]
+  }
+}