/div>';
26 |
27 | return wrapper.firstChild;
28 | }
29 |
--------------------------------------------------------------------------------
/client/api/show-message/show-message.css:
--------------------------------------------------------------------------------
1 | .deepword-msg {
2 | z-index: 1;
3 | background-color: #7285b7;
4 | color: #d1f1a9;
5 | position: fixed;
6 | left: 40%;
7 | top: 25px;
8 | padding: 5px;
9 | opacity: 0.9;
10 | transition: ease 0.5s;
11 | }
12 |
--------------------------------------------------------------------------------
/client/api/story.js:
--------------------------------------------------------------------------------
1 | import {promisify} from 'es6-promisify';
2 | import {read} from 'restafary/client';
3 |
4 | export default function Story() {
5 | if (!(this instanceof Story))
6 | return new Story();
7 | }
8 |
9 | Story.prototype.checkHash = async function(name) {
10 | const loadHash = await this.loadHash(name);
11 | const nameHash = `${name}-hash`;
12 | const storeHash = localStorage.getItem(nameHash);
13 |
14 | return loadHash === storeHash;
15 | };
16 |
17 | Story.prototype.loadHash = promisify(function(name, callback) {
18 | const query = '?hash';
19 |
20 | read(name + query, callback);
21 |
22 | return this;
23 | });
24 |
25 | Story.prototype.setData = function(name, data) {
26 | const nameData = `${name}-data`;
27 |
28 | localStorage.setItem(nameData, data);
29 |
30 | return this;
31 | };
32 |
33 | Story.prototype.setHash = function(name, hash) {
34 | const nameHash = `${name}-hash`;
35 |
36 | localStorage.setItem(nameHash, hash);
37 |
38 | return this;
39 | };
40 |
41 | Story.prototype.getData = (name) => {
42 | const nameData = `${name}-data`;
43 | const data = localStorage.getItem(nameData);
44 |
45 | return data || '';
46 | };
47 |
48 | Story.prototype.getHash = (name) => {
49 | const item = `${name}-hash`;
50 | const data = localStorage.getItem(item);
51 |
52 | return data || '';
53 | };
54 |
--------------------------------------------------------------------------------
/client/api/vim.js:
--------------------------------------------------------------------------------
1 | import {initVimMode} from 'monaco-vim';
2 |
3 | let vimMode;
4 |
5 | export const disableVim = () => {
6 | if (!vimMode)
7 | return;
8 |
9 | vimMode.dispose();
10 | };
11 |
12 | export const enableVim = (editor, el) => {
13 | const statusEl = el.querySelector('#deepword-vim');
14 |
15 | statusEl.innerHTML = '';
16 |
17 | vimMode = initVimMode(editor, statusEl);
18 | };
19 |
--------------------------------------------------------------------------------
/client/index.js:
--------------------------------------------------------------------------------
1 | import {default as api} from './api/index.js';
2 | import {promisify} from 'es6-promisify';
3 | import currify from 'currify';
4 | import load from 'load.js';
5 |
6 | const isString = (a) => typeof a === 'string';
7 | const isFn = (a) => typeof a === 'function';
8 |
9 | const transformName = currify((prefix, name) => {
10 | return `${prefix}/monaco/${name}`;
11 | });
12 |
13 | const noArg = (fn) => () => fn(null);
14 |
15 | export default (el, options, callback = options) => {
16 | if (isFn(options))
17 | options = {};
18 |
19 | if (isString(el))
20 | el = document.querySelector(el);
21 |
22 | const {prefix = '/deepword'} = options;
23 |
24 | /*eslint no-console: ["error", { allow: ["error"] }] */
25 | const log = (e) => console.error(e);
26 |
27 | createStatus(el);
28 |
29 | const getElement = () => el;
30 | const getPrefix = () => prefix;
31 | const monaco = promisify(loadMonaco);
32 | const deepword = api(parseElement(el), options);
33 |
34 | loadAll(prefix)
35 | .then(getPrefix)
36 | .then(monaco)
37 | .then(getElement)
38 | .then(parseElement)
39 | .then(init(prefix))
40 | .then(deepword)
41 | .then(callback)
42 | .catch(log);
43 | };
44 |
45 | function createStatus(parent) {
46 | const el = document.createElement('div');
47 |
48 | el.id = 'deepword-vim';
49 |
50 | parent.appendChild(el);
51 | }
52 |
53 | async function loadSocket(prefix) {
54 | if (window.io)
55 | return;
56 |
57 | await load.js(`${prefix}/dist/socket.io.js`);
58 | }
59 |
60 | async function loadLoader(prefix) {
61 | await load(transformName(prefix, 'min/vs/loader.js'));
62 | }
63 |
64 | async function loadAll(prefix) {
65 | await loadSocket(prefix);
66 | await loadLoader(prefix);
67 | }
68 |
69 | function loadMonaco(prefix, fn) {
70 | const {require} = window;
71 | const vs = transformName(prefix, 'min/vs');
72 |
73 | require.config({
74 | paths: {
75 | vs,
76 | },
77 | });
78 |
79 | require(['vs/editor/editor.main'], noArg(fn));
80 | }
81 |
82 | const init = currify(async (prefix, el) => {
83 | const {monaco} = window;
84 | const {theme = 'vs', ...options} = await load(`${prefix}/edit.json`);
85 | const editor = monaco.editor.create(el, {
86 | minimap: {
87 | enabled: false,
88 | },
89 | value: '',
90 | scrollBeyondLastLine: false,
91 | renderWhitespace: 'all',
92 | contextmenu: false,
93 | folding: true,
94 | // when slow use editor.layout
95 | automaticLayout: true,
96 | theme,
97 | });
98 |
99 | editor.updateOptions(options);
100 |
101 | return editor;
102 | });
103 |
104 | function parseElement(el) {
105 | if (isString(el))
106 | return document.querySelector(el);
107 |
108 | return el;
109 | }
110 |
--------------------------------------------------------------------------------
/common/mode-for-ext.js:
--------------------------------------------------------------------------------
1 | import currify from 'currify';
2 |
3 | const isString = (a) => typeof a === 'string';
4 |
5 | const byExtension = currify((ext, options) => {
6 | const {extensions} = options;
7 | return extensions?.includes(ext);
8 | });
9 |
10 | export default (ext, langs) => {
11 | check(ext, langs);
12 |
13 | const empty = {
14 | id: '',
15 | };
16 |
17 | const mode = langs
18 | .filter(byExtension(ext))
19 | .pop();
20 |
21 | return (mode || empty).id;
22 | };
23 |
24 | function check(ext, langs) {
25 | if (!isString(ext))
26 | throw Error('ext should be string!');
27 |
28 | if (!Array.isArray(langs))
29 | throw Error('langs should be an array!');
30 | }
31 |
--------------------------------------------------------------------------------
/common/mode-for-ext.spec.js:
--------------------------------------------------------------------------------
1 | import tryCatch from 'try-catch';
2 | import modeForExt from './mode-for-ext.js';
3 | import test from 'supertape';
4 |
5 | test('mode-for-ext: args: ext', (t) => {
6 | const [error] = tryCatch(modeForExt);
7 |
8 | t.equal(error.message, 'ext should be string!', 'should throw when ext not string ');
9 | t.end();
10 | });
11 |
12 | test('mode-for-ext: args: langs', (t) => {
13 | const [error] = tryCatch(modeForExt, '');
14 |
15 | t.equal(error.message, 'langs should be an array!', 'should throw when langs not array');
16 | t.end();
17 | });
18 |
19 | test('mode-for-ext: found', (t) => {
20 | const langs = [{
21 | id: 'javascript',
22 | extensions: ['.js'],
23 | }];
24 |
25 | t.equal(modeForExt('.js', langs), 'javascript', 'should return name of a language');
26 | t.end();
27 | });
28 |
29 | test('mode-for-ext: not found', (t) => {
30 | const langs = [{
31 | id: 'c',
32 | extensions: ['.cpp'],
33 | }];
34 |
35 | t.equal(modeForExt('.js', langs), '', 'should return empty string');
36 | t.end();
37 | });
38 |
--------------------------------------------------------------------------------
/html/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
Deepword
7 |
35 |
36 |
37 |
38 |
39 |
57 |
58 |
59 |
--------------------------------------------------------------------------------
/img/deepword.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudcmd/deepword/3a58e038225e3e3a9777e7c6b0ccb414716f2633/img/deepword.png
--------------------------------------------------------------------------------
/json/bin.json:
--------------------------------------------------------------------------------
1 | {
2 | "-h, --help ": "display this help and exit",
3 | "-v, --version ": "output version information and exit"
4 | }
5 |
--------------------------------------------------------------------------------
/json/edit.json:
--------------------------------------------------------------------------------
1 | {
2 | "theme": "vs"
3 | }
4 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "deepword",
3 | "version": "10.0.0",
4 | "description": "Web editor based on Monaco",
5 | "main": "server/index.js",
6 | "type": "module",
7 | "bin": {
8 | "deepword": "bin/deepword.js"
9 | },
10 | "scripts": {
11 | "start": "madrun start",
12 | "start:dev": "madrun start:dev",
13 | "test": "madrun test",
14 | "coverage": "madrun coverage",
15 | "report": "madrun report",
16 | "watcher:test": "madrun watcher:test",
17 | "lint": "madrun lint",
18 | "fix:lint": "madrun fix:lint",
19 | "wisdom": "madrun wisdom",
20 | "build": "madrun build",
21 | "cp:socket.io:dist": "madrun cp:socket.io:dist",
22 | "cp:socket.io:dist-dev": "madrun cp:socket.io:dist-dev",
23 | "cp:socket.io.map:dist": "madrun cp:socket.io.map:dist",
24 | "cp:socket.io.map:dist-dev": "madrun cp:socket.io.map:dist-dev",
25 | "build-progress": "madrun build-progress",
26 | "build:client": "madrun build:client",
27 | "build:start": "madrun build:start",
28 | "build:client:dev": "madrun build:client:dev",
29 | "build:start:dev": "madrun build:start:dev",
30 | "watch:client": "madrun watch:client",
31 | "watch:client:dev": "madrun watch:client:dev",
32 | "mkdir": "madrun mkdir",
33 | "clean": "madrun clean"
34 | },
35 | "repository": {
36 | "type": "git",
37 | "url": "https://github.com/cloudcmd/deepword"
38 | },
39 | "keywords": [
40 | "editor",
41 | "express",
42 | "middleware",
43 | "monaco",
44 | "patch",
45 | "diff",
46 | "ide",
47 | "text"
48 | ],
49 | "author": "coderaiser",
50 | "license": "MIT",
51 | "bugs": {
52 | "url": "https://github.com/cloudcmd/deepword/issues"
53 | },
54 | "homepage": "https://github.com/cloudcmd/deepword",
55 | "dependencies": {
56 | "currify": "^4.0.0",
57 | "express": "^4.14.0",
58 | "monaco-editor": "^0.47.0",
59 | "readjson": "^2.0.1",
60 | "restafary": "^12.0.0",
61 | "restbox": "^4.0.1",
62 | "socket-file": "^7.0.0",
63 | "socket.io": "^4.7.4",
64 | "try-to-catch": "^3.0.0"
65 | },
66 | "devDependencies": {
67 | "@babel/core": "^7.0.0",
68 | "@babel/plugin-proposal-numeric-separator": "^7.12.1",
69 | "@babel/preset-env": "^7.0.0",
70 | "babel-loader": "^9.1.3",
71 | "c8": "^9.1.0",
72 | "clean-css-loader": "^4.2.1",
73 | "css-loader": "^6.10.0",
74 | "cssnano": "^6.0.3",
75 | "daffy": "^1.0.3",
76 | "emitify": "^4.0.1",
77 | "es6-promise": "^4.0.5",
78 | "es6-promisify": "^7.0.0",
79 | "eslint": "^8.56.0",
80 | "eslint-plugin-n": "^16.6.2",
81 | "eslint-plugin-putout": "^22.3.1",
82 | "fast-async": "^6.3.7",
83 | "file-loader": "^6.0.0",
84 | "jssha": "^3.1.0",
85 | "load.js": "^3.0.2",
86 | "madrun": "^10.0.1",
87 | "mini-css-extract-plugin": "^2.8.0",
88 | "mkdirp": "^3.0.1",
89 | "monaco-vim": "^0.4.1",
90 | "nodemon": "^3.0.3",
91 | "path-browserify": "^1.0.1",
92 | "putout": "^35.0.4",
93 | "rimraf": "^5.0.5",
94 | "smalltalk": "^4.0.2",
95 | "socket.io-client": "^4.7.4",
96 | "style-loader": "^3.3.4",
97 | "supertape": "^10.0.0",
98 | "try-catch": "^3.0.0",
99 | "url-loader": "^4.0.0",
100 | "util": "^0.12.3",
101 | "webpack": "^5.90.1",
102 | "webpack-cli": "^5.1.4",
103 | "zipio": "^1.0.2"
104 | },
105 | "engines": {
106 | "node": ">=18"
107 | },
108 | "publishConfig": {
109 | "access": "public"
110 | }
111 | }
112 |
--------------------------------------------------------------------------------
/server/edit.js:
--------------------------------------------------------------------------------
1 | import {createRequire} from 'node:module';
2 | import os from 'node:os';
3 | import readjson from 'readjson';
4 | import tryToCatch from 'try-to-catch';
5 |
6 | const require = createRequire(import.meta.url);
7 | const Edit = require('../json/edit.json');
8 | const HOME = os.homedir();
9 |
10 | export default async (req, res, next) => {
11 | if (req.url !== '/edit.json')
12 | return next();
13 |
14 | const [error, data] = await tryToCatch(readEdit);
15 |
16 | if (error)
17 | return res
18 | .status(404)
19 | .send(error.message);
20 |
21 | res
22 | .type('json')
23 | .send(data);
24 | };
25 |
26 | async function readEdit() {
27 | const homePath = `${HOME}/.deepword.json`;
28 | const [error, edit] = await tryToCatch(readjson, homePath);
29 |
30 | if (!error)
31 | return {
32 | ...Edit,
33 | ...edit,
34 | };
35 |
36 | if (error.code !== 'ENOENT')
37 | throw Error(`deepword --config ${homePath}: ${error.message}`);
38 |
39 | return Edit;
40 | }
41 |
--------------------------------------------------------------------------------
/server/index.js:
--------------------------------------------------------------------------------
1 | import path, {dirname} from 'node:path';
2 | import {fileURLToPath} from 'node:url';
3 | import process from 'node:process';
4 | import restafary from 'restafary';
5 | import restbox from 'restbox';
6 | import socketFile from 'socket-file';
7 | import {Router} from 'express';
8 | import currify from 'currify';
9 | import resolvePath from './resolve-path.js';
10 | import editFn from './edit.js';
11 |
12 | const {assign} = Object;
13 |
14 | const __filename = fileURLToPath(import.meta.url);
15 | const __dirname = dirname(__filename);
16 | const isUndefined = (a) => typeof a === 'undefined';
17 | const DIR_ROOT = `${__dirname}/..`;
18 | const deepwordMiddleware = currify(_deepwordMiddleware);
19 | const optionsFn = currify(configFn);
20 | const restboxFn = currify(_restboxFn);
21 | const restafaryFn = currify(_restafaryFn);
22 |
23 | const isFn = (a) => typeof a === 'function';
24 | const maybe = (fn) => {
25 | if (isFn(fn))
26 | return fn();
27 |
28 | return fn;
29 | };
30 |
31 | const isDev = process.env.NODE_ENV === 'development';
32 |
33 | const cut = currify((prefix, req, res, next) => {
34 | req.url = req.url.replace(prefix, '');
35 | next();
36 | });
37 |
38 | export default deepword;
39 |
40 | function deepword(options) {
41 | options = options || {};
42 |
43 | const router = Router();
44 | const {
45 | prefix = '/deepword',
46 | dropbox,
47 | dropboxToken,
48 | root,
49 | } = options;
50 |
51 | router
52 | .route(`${prefix}/*`)
53 | .all(cut(prefix))
54 | .get(deepwordMiddleware(prefix))
55 | .get(optionsFn(options))
56 | .get(monaco)
57 | .get(editFn)
58 | .get(restboxFn({
59 | root,
60 | dropbox,
61 | dropboxToken,
62 | }))
63 | .get(restafaryFn(root))
64 | .get(staticFn)
65 | .put(restboxFn({
66 | root,
67 | dropbox,
68 | dropboxToken,
69 | }))
70 | .put(restafaryFn(root));
71 |
72 | return router;
73 | }
74 |
75 | export const listen = (socket, options) => {
76 | options = options || {};
77 |
78 | const {
79 | root = '/',
80 | auth,
81 | prefixSocket = '/deepword',
82 | } = options;
83 |
84 | return socketFile(socket, {
85 | root: maybe(root),
86 | auth,
87 | prefix: prefixSocket,
88 | });
89 | };
90 |
91 | assign(deepword, {
92 | listen,
93 | });
94 |
95 | function checkOption(isOption) {
96 | if (isFn(isOption))
97 | return isOption();
98 |
99 | if (isUndefined(isOption))
100 | return true;
101 |
102 | return isOption;
103 | }
104 |
105 | function _deepwordMiddleware(prefix, req, res, next) {
106 | const regExp = /^\/deepword\.js(\.map)?$/;
107 |
108 | if (regExp.test(req.url))
109 | req.url = '/dist' + req.url;
110 |
111 | if (isDev)
112 | req.url = req.url.replace(/^\/dist\//, '/dist-dev/');
113 |
114 | next();
115 | }
116 |
117 | function configFn(o, req, res, next) {
118 | const online = checkOption(o.online);
119 | const diff = checkOption(o.diff);
120 | const zip = checkOption(o.zip);
121 |
122 | if (req.url.indexOf('/options.json'))
123 | return next();
124 |
125 | res
126 | .type('json')
127 | .send({
128 | diff,
129 | zip,
130 | online,
131 | });
132 | }
133 |
134 | function _restboxFn({root, dropbox, dropboxToken}, req, res, next) {
135 | if (!dropbox)
136 | return next();
137 |
138 | const {url} = req;
139 | const prefix = '/api/v1';
140 | const indexOf = url.indexOf.bind(url);
141 | const not = (fn) => (a) => !fn(a);
142 |
143 | const is = [`/api/v1`].some(not(indexOf));
144 |
145 | if (!is)
146 | return next();
147 |
148 | const middle = restbox({
149 | prefix,
150 | token: dropboxToken,
151 | root: maybe(root),
152 | });
153 |
154 | middle(req, res, next);
155 | }
156 |
157 | function _restafaryFn(root, req, res, next) {
158 | const {url} = req;
159 | const api = '/api/v1/fs';
160 |
161 | if (url.indexOf(api))
162 | return next();
163 |
164 | const restafaryFunc = restafary({
165 | prefix: api,
166 | root: maybe(root),
167 | });
168 |
169 | restafaryFunc(req, res, next);
170 | }
171 |
172 | function monaco(req, res, next) {
173 | if (req.url.indexOf('/monaco'))
174 | return next();
175 |
176 | const sendFile = res.sendFile.bind(res);
177 |
178 | const replace = (path) => req.url.replace('/monaco', path);
179 | const sendError = (error) => res.status(404).send(error);
180 |
181 | resolvePath('monaco-editor')
182 | .then(replace)
183 | .then(sendFile)
184 | .catch(sendError);
185 | }
186 |
187 | function staticFn(req, res) {
188 | const file = path.normalize(DIR_ROOT + req.url);
189 | res.sendFile(file);
190 | }
191 |
192 |
--------------------------------------------------------------------------------
/server/resolve-path.js:
--------------------------------------------------------------------------------
1 | import {fileURLToPath} from 'node:url';
2 | import path, {dirname} from 'node:path';
3 | import {stat as _stat} from 'node:fs/promises';
4 |
5 | import tryToCatch from 'try-to-catch';
6 |
7 | const __filename = fileURLToPath(import.meta.url);
8 | const __dirname = dirname(__filename);
9 | const isString = (a) => typeof a === 'string';
10 |
11 | export default async (name, {stat = _stat} = {}) => {
12 | check(name);
13 |
14 | const dir = `node_modules/${name}`;
15 | const [e, inner] = await tryToCatch(resolveModule, [__dirname, '../', dir], stat);
16 |
17 | if (!e)
18 | return inner;
19 |
20 | return await resolveModule([__dirname, '../../', name], stat);
21 | };
22 |
23 | function check(name) {
24 | if (!isString(name))
25 | throw Error('name should be string!');
26 | }
27 |
28 | async function resolveModule(dirs, stat) {
29 | const dir = path.resolve(...dirs);
30 |
31 | await stat(dir);
32 |
33 | return dir;
34 | }
35 |
--------------------------------------------------------------------------------
/server/resolve-path.spec.js:
--------------------------------------------------------------------------------
1 | import path, {dirname} from 'node:path';
2 | import {promisify} from 'node:util';
3 | import tryToCatch from 'try-to-catch';
4 | import test from 'supertape';
5 | import {fileURLToPath} from 'node:url';
6 | import resolvePath from './resolve-path.js';
7 |
8 | const __filename = fileURLToPath(import.meta.url);
9 | const __dirname = dirname(__filename);
10 |
11 | test('resolve-path: args', async (t) => {
12 | const [e] = await tryToCatch(resolvePath);
13 |
14 | t.equal(e.message, 'name should be string!');
15 | t.end();
16 | });
17 |
18 | test('resolve-path: module installed in inner directory', async (t) => {
19 | const expect = path.resolve(__dirname, '..', 'node_modules/monaco-editor');
20 | const stat = promisify((name, fn) => {
21 | fn();
22 | });
23 |
24 | const name = await resolvePath('monaco-editor', {
25 | stat,
26 | });
27 |
28 | t.equal(name, expect, 'should return path in inner directory');
29 | t.end();
30 | });
31 |
32 | test('resolve-path: module installed in outer directory', async (t) => {
33 | let onceError = false;
34 |
35 | const stat = promisify((name, fn) => {
36 | if (onceError) {
37 | fn();
38 | } else {
39 | onceError = true;
40 | fn(Error('some error'));
41 | }
42 | });
43 |
44 | const name = await resolvePath('monaco', {
45 | stat,
46 | });
47 |
48 | t.ok(name, 'should return path in outer directory');
49 | t.end();
50 | });
51 |
52 | test('resolve-path: module not installed', async (t) => {
53 | const stat = promisify((name, fn) => {
54 | fn(Error());
55 | });
56 |
57 | const [e] = await tryToCatch(resolvePath, 'monaco', {
58 | stat,
59 | });
60 |
61 | t.ok(e, 'should reject when module not found');
62 | t.end();
63 | });
64 |
65 |
--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
1 | import {createRequire} from 'node:module';
2 | import path, {dirname} from 'node:path';
3 | import {fileURLToPath} from 'node:url';
4 | import process, {env} from 'node:process';
5 | import webpack from 'webpack';
6 |
7 | const __filename = fileURLToPath(import.meta.url);
8 | const __dirname = dirname(__filename);
9 | const dir = './client';
10 | const isDev = env.NODE_ENV === 'development';
11 |
12 | const dist = path.resolve(__dirname, 'dist');
13 | const distDev = path.resolve(__dirname, 'dist-dev');
14 | const devtool = isDev ? 'eval' : 'source-map';
15 | const notEmpty = (a) => a;
16 | const clean = (array) => array.filter(notEmpty);
17 | const {resolve} = createRequire(import.meta.url);
18 |
19 | const {NODE_ENV} = process.env;
20 |
21 | process.env.NODE_DEBUG = '';
22 | process.env.NODE_ENV = NODE_ENV || '';
23 |
24 | const rules = clean([{
25 | test: /\.js$/,
26 | exclude: /node_modules/,
27 | loader: 'babel-loader',
28 | }, {
29 | test: /\.css$/,
30 | use: [
31 | 'style-loader',
32 | 'css-loader',
33 | 'clean-css-loader',
34 | ],
35 | }, {
36 | test: /\.(png|gif|svg|woff|woff2|eot|ttf)$/,
37 | use: {
38 | loader: 'url-loader',
39 | options: {
40 | limit: 50_000,
41 | },
42 | },
43 | }]);
44 |
45 | export default {
46 | devtool,
47 | entry: {
48 | deepword: `${dir}/index.js`,
49 | },
50 | output: {
51 | library: {
52 | name: 'deepword',
53 | export: 'default',
54 | type: 'var',
55 | },
56 | filename: '[name].js',
57 | path: isDev ? distDev : dist,
58 | pathinfo: isDev,
59 | devtoolModuleFilenameTemplate,
60 | },
61 | module: {
62 | rules,
63 | },
64 | resolve: {
65 | fallback: {
66 | path: resolve('path-browserify'),
67 | util: resolve('util'),
68 | },
69 | },
70 | plugins: [
71 | new webpack.NormalModuleReplacementPlugin(/node:/, (resource) => {
72 | resource.request = resource.request.replace(/^node:/, '');
73 | }),
74 | new webpack.EnvironmentPlugin([
75 | 'NODE_ENV',
76 | 'NODE_DEBUG',
77 | ]),
78 | ],
79 | };
80 |
81 | function devtoolModuleFilenameTemplate(info) {
82 | const resource = info.absoluteResourcePath.replace(__dirname + path.sep, '');
83 | return `file://deepword/${resource}`;
84 | }
85 |
--------------------------------------------------------------------------------