xhs-mp-compiler-cli 1.5.0 → 1.6.0-beta.2

package/dist/compiler.d.ts

@@ -1,7 +1,5 @@
 /// <reference types="node/child_process" />
-/// <reference types=".pnpm/artifactory.devops.xiaohongshu.com+@types+node@20.12.2/node_modules/@types/node/child_process" />
 /// <reference types="node/stream" />
-/// <reference types=".pnpm/artifactory.devops.xiaohongshu.com+@types+node@20.12.2/node_modules/@types/node/stream" />
 /**
  * 在子进程执行编译
  */
@@ -31,24 +29,28 @@ export interface ICheckOptions {
     enableV2?: boolean;
     enableV1?: boolean;
 }
-declare abstract class AbstractCompiler extends EventEmitter {
+export declare abstract class AbstractCompiler extends EventEmitter {
     protected inspectPort: any;
-    private _cp;
+    private _impl;
+    protected _implType: 'thread_worker' | 'web_worker' | 'cp';
     private compilerOpts;
-    private cpArgs;
+    private implArgs;
     private logger;
     private _handlerMap;
     constructor(opts: ICompilerOption, args?: ICompilerArgs);
-    get cp(): any;
-    protected createSp: (passData?: {}) => any;
-    protected create: (passData?: {}) => ChildProcess;
+    get impl(): any;
+    protected createImpl: (passData?: {}) => any;
+    protected createCP: (passData?: {}) => ChildProcess;
+    protected createThreadWorker: (passData?: {}) => any;
+    protected createWebWorker: (passData?: {}) => any;
+    private postMessage;
     close(): void;
     kill(): void;
     private handleMessage;
     call: (method: any, data: any) => Promise<unknown>;
     send: (method: any, data: any) => void;
 }
-declare class MPPackDevCompiler extends AbstractCompiler {
+export declare class MPPackDevCompiler extends AbstractCompiler {
     private pending;
     private pendingPkgs;
     private readyPkgs;
@@ -62,17 +64,17 @@ declare class MPPackDevCompiler extends AbstractCompiler {
     makePkgsReady(opts: ICheckOptions): Promise<void>;
     reCompilePkgs(options: any): Promise<void>;
 }
-declare class WebPackDevCompiler extends AbstractCompiler {
+export declare class WebPackDevCompiler extends AbstractCompiler {
     private watching;
     private pendingTask?;
-    constructor(props: any);
+    constructor(props: any, args: any);
     makePkgsReady(opts: any): Promise<unknown>;
     reCompilePkgs(opts: any): Promise<void>;
 }
-declare class BuildCompiler extends AbstractCompiler {
+export declare class BuildCompiler extends AbstractCompiler {
     cps: any;
     constructor(props: any, args: any);
     build(option: ICheckOptions): Promise<unknown>;
 }
-export declare function getProcessCompilerClass(compilerType: any): typeof MPPackDevCompiler | typeof WebPackDevCompiler | typeof BuildCompiler;
+export declare function getProjectCompilerClass(compilerType: any): typeof MPPackDevCompiler | typeof WebPackDevCompiler | typeof BuildCompiler;
 export {};

package/dist/compiler.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProcessCompilerClass = void 0;
+exports.getProjectCompilerClass = exports.BuildCompiler = exports.WebPackDevCompiler = exports.MPPackDevCompiler = exports.AbstractCompiler = void 0;
 /**
  * 在子进程执行编译
  */
@@ -26,23 +26,42 @@ const isMac = process.platform === 'darwin';
 class AbstractCompiler extends stream_1.EventEmitter {
     constructor(opts, args = {}) {
         super();
+        // ide侧用web_worker，cli用thread_worker
+        this._implType = 'web_worker';
         this._handlerMap = {};
-        this.createSp = (passData = {}) => {
-            if (!this._cp) {
-                this._cp = this.create(Object.assign({}, passData));
-                this._cp.on('exit', code => {
-                    this._cp = null;
-                });
-                this._cp.on('message', this.handleMessage);
+        this.createImpl = (passData = {}) => {
+            if (!this._impl) {
+                if (this._implType === 'thread_worker') {
+                    this._impl = this.createThreadWorker(passData);
+                    this._impl.on('exit', code => {
+                        this._impl = null;
+                    });
+                    this._impl.on('message', this.handleMessage);
+                }
+                else if (this._implType === 'web_worker') {
+                    this._impl = this.createWebWorker(passData);
+                    this._impl.onerror = err => {
+                        console.error(err);
+                    };
+                    this._impl.onmessage = this.handleMessage;
+                }
+                else {
+                    this._impl = this.createCP(passData);
+                    this._impl.on('exit', code => {
+                        this._impl = null;
+                    });
+                    this._impl.on('message', this.handleMessage);
+                }
+                // console.log('create impl done:', this._impl)
             }
-            return this._cp;
+            return this._impl;
         };
-        this.create = (passData = {}) => {
+        this.createCP = (passData = {}) => {
             var _a, _b;
-            const { type = 'keepalive', inspectPort = this.inspectPort, maxSpaceSaze = 12288, nodeJsPath, } = this.cpArgs;
+            const { type = 'keepalive', inspectPort = this.inspectPort, maxSpaceSaze = 12288, nodeJsPath } = this.implArgs;
             // const presistent = type === 'keepalive'
-            const entry = (0, path_1.join)(__dirname, './compilerCP.js');
-            const execArgv = [`--max-old-space-size=${maxSpaceSaze}`, '--expose-gc'];
+            const entry = (0, path_1.join)(__dirname, './compilerImplChildProcess.js');
+            const execArgv = ['--expose-gc'];
             const customNodeJs = nodeJsPath && fs_extra_1.default.existsSync(nodeJsPath);
             if (process.env.DEV_IDE_SP) {
                 execArgv.push(`--inspect=${inspectPort}`);
@@ -59,7 +78,7 @@ class AbstractCompiler extends stream_1.EventEmitter {
                 stdio: 'pipe',
                 execArgv,
                 // detached: presistent,
-                windowsHide: true,
+                windowsHide: true
             };
             if (customNodeJs) {
                 options.execPath = nodeJsPath;
@@ -75,18 +94,36 @@ class AbstractCompiler extends stream_1.EventEmitter {
                 this.logger.error('[compiler stderr]', msg.toString());
             });
             child.on('error', err => {
-                this.logger.error('sp error:', err);
+                this.logger.error('impl error:', err);
             });
             child.on('exit', code => {
                 if (code !== 0 && code !== null) {
-                    this.logger.error('sp exit:', code);
+                    this.logger.error('impl exit:', code);
                     this.emit('unexpectedExit', code);
                 }
             });
             return child;
         };
+        this.createThreadWorker = (passData = {}) => {
+            const { Worker } = require('worker_threads');
+            const entry = (0, path_1.join)(__dirname, './compilerImplThreadWorker.js');
+            const worker = new Worker(entry, { workerData: passData });
+            return worker;
+        };
+        // electron渲染进程不能使用worker_threads
+        this.createWebWorker = (passData = {}) => {
+            const entry = (0, path_1.join)(__dirname, './compilerImplWebWorker.js');
+            // @ts-ignore
+            const worker = new Worker(entry);
+            worker.postMessage(JSON.stringify({ passData }));
+            return worker;
+        };
         this.handleMessage = msg => {
             var _a, _b, _c, _d;
+            if (this._implType === 'web_worker') {
+                msg = msg.data;
+            }
+            // console.log('handle compielr message', msg)
             let data = {};
             try {
                 data = JSON.parse(`${msg}`);
@@ -108,7 +145,7 @@ class AbstractCompiler extends stream_1.EventEmitter {
                 return;
             }
             if (method === 'debugger') {
-                console.log(`[debugger]:`, ...(data.data || []));
+                // console.log(`[debugger]:`, ...(data.data || []))
                 return;
             }
             this.emit(method, data);
@@ -118,40 +155,54 @@ class AbstractCompiler extends stream_1.EventEmitter {
             const final = {
                 uuid: id,
                 method,
-                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data),
+                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data)
             };
             this._handlerMap[id] = {
                 resolve,
-                reject,
+                reject
             };
-            this.cp.send(JSON.stringify(final));
+            this.postMessage(JSON.stringify(final));
         });
         this.send = (method, data) => {
             const final = {
                 method,
-                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data),
+                data: Object.assign(Object.assign({}, (this.compilerOpts || {})), data)
             };
-            this.cp.send(JSON.stringify(final));
+            this.postMessage(JSON.stringify(final));
         };
         this.compilerOpts = opts;
-        this.cpArgs = args;
+        this.implArgs = args;
         this.logger = args.logger || console;
     }
-    get cp() {
-        return this.createSp();
+    get impl() {
+        return this.createImpl();
+    }
+    postMessage(msg) {
+        if (this._implType === 'thread_worker' || this._implType === 'web_worker') {
+            this.impl.postMessage(msg);
+        }
+        else {
+            this.impl.send(msg);
+        }
     }
     close() {
-        if (this._cp) {
-            this._cp.send(JSON.stringify({ method: 'close' }));
+        if (this._impl) {
+            this.postMessage(JSON.stringify({ method: 'close' }));
         }
     }
     kill() {
-        if (this._cp) {
-            this._cp.kill();
-            this._cp = null;
+        if (this._impl) {
+            if (this._implType === 'cp') {
+                this._impl.kill();
+            }
+            else {
+                this._impl.terminate();
+            }
+            this._impl = null;
         }
     }
 }
+exports.AbstractCompiler = AbstractCompiler;
 class MPPackDevCompiler extends AbstractCompiler {
     constructor(props, args) {
         super(props, args);
@@ -159,8 +210,9 @@ class MPPackDevCompiler extends AbstractCompiler {
         this.pendingPkgs = {};
         this.readyPkgs = [];
         this.watching = false;
+        this._implType = (args === null || args === void 0 ? void 0 : args.implType) || 'web_worker';
         this.inspectPort = 9227;
-        this.createSp();
+        this.createImpl();
     }
     reset() {
         this.pendingPkgs = {};
@@ -169,7 +221,6 @@ class MPPackDevCompiler extends AbstractCompiler {
         this.pending = false;
     }
     doCompilePkgs(opts) {
-        // eslint-disable-next-line no-async-promise-executor
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             const { compilePkgs = [constant_config_1.MAIN_PKG_ROOT] } = opts;
             const todoPkgs = [];
@@ -187,7 +238,7 @@ class MPPackDevCompiler extends AbstractCompiler {
                 }
                 this.pendingPkgs[pkg] = {
                     resolve: [resolve],
-                    reject: [reject],
+                    reject: [reject]
                 };
                 todoPkgs.push(pkg);
             });
@@ -277,12 +328,14 @@ class MPPackDevCompiler extends AbstractCompiler {
         });
     }
 }
+exports.MPPackDevCompiler = MPPackDevCompiler;
 class WebPackDevCompiler extends AbstractCompiler {
-    constructor(props) {
+    constructor(props, args) {
         super(props);
         this.watching = false;
+        this._implType = (args === null || args === void 0 ? void 0 : args.implType) || 'web_worker';
         this.inspectPort = 9230;
-        this.createSp();
+        this.createImpl();
     }
     makePkgsReady(opts) {
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -303,12 +356,12 @@ class WebPackDevCompiler extends AbstractCompiler {
                 this.emit('buildStart');
                 yield this.call('runTask', Object.assign({ scene: 'watch', action: 'dev' }, opts));
                 this.watching = true;
-                (_c = this.pendingTask.resolve) === null || _c === void 0 ? void 0 : _c.forEach((fn) => fn());
+                (_c = this.pendingTask.resolve) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());
                 this.emit('buildSuccess');
             }
             catch (error) {
                 this.watching = false;
-                (_d = this.pendingTask.reject) === null || _d === void 0 ? void 0 : _d.forEach((fn) => fn());
+                (_d = this.pendingTask.reject) === null || _d === void 0 ? void 0 : _d.forEach(fn => fn());
                 this.kill();
                 this.emit('buildError', error);
             }
@@ -334,12 +387,14 @@ class WebPackDevCompiler extends AbstractCompiler {
         });
     }
 }
+exports.WebPackDevCompiler = WebPackDevCompiler;
 class BuildCompiler extends AbstractCompiler {
     constructor(props, args) {
         super(props, args);
         this.cps = [];
+        this._implType = (args === null || args === void 0 ? void 0 : args.implType) || 'cp';
         this.inspectPort = 9228;
-        this.createSp();
+        this.createImpl();
     }
     build(option) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -354,7 +409,8 @@ class BuildCompiler extends AbstractCompiler {
         });
     }
 }
-function getProcessCompilerClass(compilerType) {
+exports.BuildCompiler = BuildCompiler;
+function getProjectCompilerClass(compilerType) {
     const CompilerClass = compilerType === constant_config_1.COMPILER_TYPE.legacy_dev
         ? WebPackDevCompiler
         : compilerType === constant_config_1.COMPILER_TYPE.dev
@@ -362,4 +418,4 @@ function getProcessCompilerClass(compilerType) {
             : BuildCompiler;
     return CompilerClass;
 }
-exports.getProcessCompilerClass = getProcessCompilerClass;
+exports.getProjectCompilerClass = getProjectCompilerClass;

package/dist/compilerImpl.d.ts

@@ -0,0 +1 @@
+export declare function runCompilerImpl(initData: any, onMessage: any, _sendToMaster: any): void;

package/dist/{compilerCP.js → compilerImpl.js}

@@ -9,21 +9,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCompilerImpl = void 0;
 const packs_1 = require("./packs");
-let globalConfig = JSON.parse(process.argv[2]);
-let hadWatchBuilt = false;
+let globalConfig = {};
 let projectCompiler;
-/* 发送消息给父进程 */
-const sendToMaster = (method, data = {}) => {
-    var _a;
-    (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, JSON.stringify(Object.assign({ method }, data)));
-};
+let sendToMaster;
 const tryGC = () => {
     if (global.gc) {
         global.gc();
     }
 };
-function formatWebpackMessages(err, stats) {
+function formatOutputMessages(err, stats) {
     if (err) {
         return { errors: [err.message], warnings: [] };
     }
@@ -49,7 +45,7 @@ const handlers = {
             const hasError = err || ((_a = stats === null || stats === void 0 ? void 0 : stats.hasErrors) === null || _a === void 0 ? void 0 : _a.call(stats));
             if (hasError) {
                 sendToMaster('emitCompileStats', {
-                    stats: formatWebpackMessages(err, stats)
+                    stats: formatOutputMessages(err, stats)
                 });
                 return;
             }
@@ -61,11 +57,10 @@ const handlers = {
             sendToMaster('callback', {
                 uuid,
                 success: false,
-                stats: formatWebpackMessages(err, stats)
+                stats: formatOutputMessages(err, stats)
             });
         }
         else {
-            hadWatchBuilt = true;
             sendToMaster('callback', {
                 uuid,
                 success: true
@@ -87,11 +82,10 @@ const handlers = {
             sendToMaster('callback', {
                 uuid,
                 success: false,
-                stats: formatWebpackMessages(err, stats)
+                stats: formatOutputMessages(err, stats)
             });
         }
         else {
-            hadWatchBuilt = true;
             sendToMaster('callback', {
                 uuid,
                 success: true
@@ -104,17 +98,15 @@ const handlers = {
         if (!projectCompiler) {
             projectCompiler = (0, packs_1.createCompiler)(data);
         }
-        projectCompiler.on('progress', progress => {
-            sendToMaster('compilePercent', {
-                percentage: progress
-            });
+        projectCompiler.on('progress', (data) => {
+            sendToMaster('compilePercent', data);
         });
         projectCompiler.build((err, stats) => {
             var _a;
             const hasError = err || ((_a = stats === null || stats === void 0 ? void 0 : stats.hasErrors) === null || _a === void 0 ? void 0 : _a.call(stats));
             console.log('sp run build finish', stats);
             if (hasError) {
-                const statsInfo = formatWebpackMessages(err, stats);
+                const statsInfo = formatOutputMessages(err, stats);
                 sendToMaster('callback', {
                     uuid,
                     success: false,
@@ -148,28 +140,23 @@ const handlers = {
         projectCompiler = null;
     }
 };
-process.on('message', (message) => {
-    let objData = {};
-    try {
-        objData = JSON.parse(message);
-    }
-    catch (error) {
-        // do something
-    }
-    const { uuid, method, data = {} } = objData;
-    if (!handlers[method]) {
-        return;
-    }
-    handlers[method](objData);
-});
-process.on('uncaughtException', error => {
-    console.error(error);
-    sendToMaster('emitCompileStats', {
-        stats: {
-            errors: [error.message]
+function runCompilerImpl(initData, onMessage, _sendToMaster) {
+    globalConfig = initData;
+    sendToMaster = _sendToMaster;
+    const handleMessage = objData => {
+        objData = typeof objData === 'string' ? JSON.parse(objData) : objData;
+        const { passData, uuid, method, data = {} } = objData;
+        // 初始化数据
+        if (passData) {
+            globalConfig = passData;
+            return;
         }
-    });
-});
-process.on('disconnect', () => {
-    process.exit(-1);
-});
+        // call handler
+        if (!handlers[method]) {
+            return;
+        }
+        handlers[method](objData);
+    };
+    onMessage(handleMessage);
+}
+exports.runCompilerImpl = runCompilerImpl;

package/dist/compilerImplChildProcess.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compilerImpl_1 = require("./compilerImpl");
+let initData = JSON.parse(process.argv[2]);
+/* 发送消息给父进程 */
+const sendToMaster = (method, data = {}) => {
+    var _a;
+    (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, JSON.stringify(Object.assign({ method }, data)));
+};
+function onMessage(handler) {
+    process.on('message', (message) => {
+        let objData = {};
+        try {
+            objData = JSON.parse(message);
+        }
+        catch (error) {
+            // do something
+        }
+        handler(message);
+    });
+}
+process.on('uncaughtException', error => {
+    console.error(error);
+    sendToMaster('emitCompileStats', {
+        stats: {
+            errors: [error.message]
+        }
+    });
+});
+process.on('disconnect', () => {
+    process.exit(-1);
+});
+(0, compilerImpl_1.runCompilerImpl)(initData, onMessage, sendToMaster);

package/dist/compilerImplThreadWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compilerImplThreadWorker.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compilerImpl_1 = require("./compilerImpl");
+const { workerData, parentPort } = require('worker_threads');
+const initData = workerData || {};
+/* 发送消息主线程 */
+const sendToMaster = (method, data = {}) => {
+    parentPort.postMessage(JSON.stringify(Object.assign({ method }, data)));
+};
+const onMessage = handler => {
+    parentPort.on('message', (message) => {
+        let objData = {};
+        try {
+            objData = JSON.parse(message);
+        }
+        catch (error) {
+            // do something
+        }
+        handler(objData);
+    });
+};
+parentPort.on('uncaughtException', error => {
+    console.error(error);
+    sendToMaster('emitCompileStats', {
+        stats: {
+            errors: [error.message]
+        }
+    });
+});
+(0, compilerImpl_1.runCompilerImpl)(initData, onMessage, sendToMaster);

package/dist/compilerImplWebWorker.d.ts

@@ -0,0 +1,6 @@
+declare const runCompilerImpl: any;
+declare const createCompiler: any;
+declare let globalConfig: any;
+declare let projectCompiler: any;
+declare const sendToMaster: (method: any, data?: {}) => void;
+declare const onMessage: (handler: any) => void;

package/dist/compilerImplWebWorker.js

@@ -0,0 +1,25 @@
+"use strict";
+const { runCompilerImpl } = require('./compilerImpl');
+const { createCompiler } = require('./packs');
+let globalConfig = {};
+let projectCompiler;
+/* 发送消息主线程 */
+const sendToMaster = (method, data = {}) => {
+    // @ts-ignore
+    postMessage(JSON.stringify(Object.assign({ method }, data)));
+};
+const onMessage = handler => {
+    // @ts-ignore
+    onmessage = (e) => {
+        const message = e.data;
+        let objData = {};
+        try {
+            objData = JSON.parse(message);
+        }
+        catch (error) {
+            // do something
+        }
+        handler(objData);
+    };
+};
+runCompilerImpl(null, onMessage, sendToMaster);

package/dist/dev-server/compatibleAPI.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node/http.js" />
+/// <reference types="node/fs.js" />
+import { Response } from "./index.js";
+import { ReadStream, createReadStream as fsCreateReadStream } from "fs";
+import { ServerResponse } from "http";
+export interface ExpectedResponse {
+    status?: (status: number) => void;
+    send?: (data: any) => void;
+    pipeInto?: (data: any) => void;
+}
+declare function setStatusCode(res: ServerResponse & ExpectedResponse, code: number): void;
+declare function pipe(res: ServerResponse & ExpectedResponse, bufferOrStream: ReadStream): void;
+declare function send(res: Response, bufferOrStream: string | Buffer): void;
+interface OutputFileSystem {
+    createReadStream?: typeof fsCreateReadStream;
+    readFileSync?: (path: string | Buffer, options?: {
+        encoding?: null;
+        flag?: string;
+    }) => Buffer;
+}
+declare function createReadStreamOrReadFileSync(filename: string, outputFileSystem: OutputFileSystem, start: number, end: number): {
+    bufferOrStream: Buffer | ReadStream;
+    byteLength: number;
+};
+export { setStatusCode, send, pipe, createReadStreamOrReadFileSync };

package/dist/dev-server/compatibleAPI.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadStreamOrReadFileSync = exports.pipe = exports.send = exports.setStatusCode = void 0;
+// Function to set status code
+function setStatusCode(res, code) {
+    // Pseudo API
+    if (typeof res.status === "function") {
+        res.status(code);
+        return;
+    }
+    // Node.js API
+    res.statusCode = code;
+}
+exports.setStatusCode = setStatusCode;
+// Function to pipe data to response
+function pipe(res, bufferOrStream) {
+    // Pseudo API and Koa API
+    if (typeof res.pipeInto === "function") {
+        res.pipeInto(bufferOrStream);
+        return;
+    }
+    // Node.js API and Express API and Hapi API
+    bufferOrStream.pipe(res);
+}
+exports.pipe = pipe;
+// Function to send data to response
+function send(res, bufferOrStream) {
+    // Pseudo API and Express API and Koa API
+    if (typeof res.send === "function") {
+        res.send(bufferOrStream);
+        return;
+    }
+    res.end(bufferOrStream);
+}
+exports.send = send;
+// Function to create read stream or read file synchronously
+function createReadStreamOrReadFileSync(filename, outputFileSystem, start, end) {
+    let bufferOrStream;
+    let byteLength;
+    // Stream logic
+    const isFsSupportsStream = typeof outputFileSystem.createReadStream === "function";
+    if (isFsSupportsStream) {
+        bufferOrStream = outputFileSystem.createReadStream(filename, {
+            start,
+            end,
+        });
+        // Handle files with zero bytes
+        byteLength = end === 0 ? 0 : end - start + 1;
+    }
+    else {
+        bufferOrStream = outputFileSystem.readFileSync(filename);
+        byteLength = bufferOrStream.byteLength;
+    }
+    return { bufferOrStream, byteLength };
+}
+exports.createReadStreamOrReadFileSync = createReadStreamOrReadFileSync;

package/dist/dev-server/escapeHtml.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Escapes a string for use in HTML.
+ */
+declare function escapeHtml(string: string): string;
+export default escapeHtml;