@lvce-editor/editor-worker 19.24.1 → 19.26.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/editorWorkerMain.js +417 -358
- package/package.json +1 -1
package/dist/editorWorkerMain.js
CHANGED
|
@@ -1,248 +1,58 @@
|
|
|
1
|
-
const
|
|
2
|
-
|
|
3
|
-
|
|
1
|
+
const normalizeLine = line => {
|
|
2
|
+
if (line.startsWith('Error: ')) {
|
|
3
|
+
return line.slice('Error: '.length);
|
|
4
|
+
}
|
|
5
|
+
if (line.startsWith('VError: ')) {
|
|
6
|
+
return line.slice('VError: '.length);
|
|
7
|
+
}
|
|
8
|
+
return line;
|
|
4
9
|
};
|
|
5
|
-
const
|
|
6
|
-
const
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
10
|
+
const getCombinedMessage = (error, message) => {
|
|
11
|
+
const stringifiedError = normalizeLine(`${error}`);
|
|
12
|
+
if (message) {
|
|
13
|
+
return `${message}: ${stringifiedError}`;
|
|
14
|
+
}
|
|
15
|
+
return stringifiedError;
|
|
16
|
+
};
|
|
17
|
+
const NewLine$3 = '\n';
|
|
18
|
+
const getNewLineIndex$1 = (string, startIndex = undefined) => {
|
|
19
|
+
return string.indexOf(NewLine$3, startIndex);
|
|
20
|
+
};
|
|
21
|
+
const mergeStacks = (parent, child) => {
|
|
22
|
+
if (!child) {
|
|
23
|
+
return parent;
|
|
24
|
+
}
|
|
25
|
+
const parentNewLineIndex = getNewLineIndex$1(parent);
|
|
26
|
+
const childNewLineIndex = getNewLineIndex$1(child);
|
|
27
|
+
if (childNewLineIndex === -1) {
|
|
28
|
+
return parent;
|
|
29
|
+
}
|
|
30
|
+
const parentFirstLine = parent.slice(0, parentNewLineIndex);
|
|
31
|
+
const childRest = child.slice(childNewLineIndex);
|
|
32
|
+
const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
|
|
33
|
+
if (parentFirstLine.includes(childFirstLine)) {
|
|
34
|
+
return parentFirstLine + childRest;
|
|
35
|
+
}
|
|
36
|
+
return child;
|
|
37
|
+
};
|
|
38
|
+
class VError extends Error {
|
|
39
|
+
constructor(error, message) {
|
|
40
|
+
const combinedMessage = getCombinedMessage(error, message);
|
|
41
|
+
super(combinedMessage);
|
|
42
|
+
this.name = 'VError';
|
|
43
|
+
if (error instanceof Error) {
|
|
44
|
+
this.stack = mergeStacks(this.stack, error.stack);
|
|
26
45
|
}
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
let latestState = states[uid].newState;
|
|
31
|
-
return {
|
|
32
|
-
getState: () => {
|
|
33
|
-
if (isCurrentGeneration(uid, generation)) {
|
|
34
|
-
latestState = states[uid].newState;
|
|
35
|
-
}
|
|
36
|
-
return latestState;
|
|
37
|
-
},
|
|
38
|
-
updateState: async updater => {
|
|
39
|
-
latestState = await updateState(uid, generation, latestState, updater);
|
|
40
|
-
return latestState;
|
|
41
|
-
}
|
|
42
|
-
};
|
|
43
|
-
};
|
|
44
|
-
const enqueueCommand = async (uid, command) => {
|
|
45
|
-
const previous = commandQueues.get(uid) || Promise.resolve();
|
|
46
|
-
const run = async () => {
|
|
47
|
-
try {
|
|
48
|
-
await previous;
|
|
49
|
-
} catch {
|
|
50
|
-
// The previous caller receives its error; later commands must still run.
|
|
51
|
-
}
|
|
52
|
-
await command();
|
|
53
|
-
};
|
|
54
|
-
const current = run();
|
|
55
|
-
commandQueues.set(uid, current);
|
|
56
|
-
try {
|
|
57
|
-
await current;
|
|
58
|
-
} finally {
|
|
59
|
-
if (commandQueues.get(uid) === current) {
|
|
60
|
-
commandQueues.delete(uid);
|
|
61
|
-
}
|
|
46
|
+
if (error.codeFrame) {
|
|
47
|
+
// @ts-ignore
|
|
48
|
+
this.codeFrame = error.codeFrame;
|
|
62
49
|
}
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
commandQueues.clear();
|
|
67
|
-
for (const key of Object.keys(states)) {
|
|
68
|
-
delete states[key];
|
|
69
|
-
}
|
|
70
|
-
},
|
|
71
|
-
diff(uid, modules, numbers) {
|
|
72
|
-
const {
|
|
73
|
-
oldState,
|
|
74
|
-
scheduledState
|
|
75
|
-
} = states[uid];
|
|
76
|
-
const diffResult = [];
|
|
77
|
-
for (let i = 0; i < modules.length; i++) {
|
|
78
|
-
const fn = modules[i];
|
|
79
|
-
if (!fn(oldState, scheduledState)) {
|
|
80
|
-
diffResult.push(numbers[i]);
|
|
81
|
-
}
|
|
82
|
-
}
|
|
83
|
-
return diffResult;
|
|
84
|
-
},
|
|
85
|
-
dispose(uid) {
|
|
86
|
-
commandQueues.delete(uid);
|
|
87
|
-
delete states[uid];
|
|
88
|
-
},
|
|
89
|
-
get(uid) {
|
|
90
|
-
return states[uid];
|
|
91
|
-
},
|
|
92
|
-
getCommandIds() {
|
|
93
|
-
const keys = Object.keys(commandMapRef);
|
|
94
|
-
const ids = keys.map(toCommandId);
|
|
95
|
-
return ids;
|
|
96
|
-
},
|
|
97
|
-
getKeys() {
|
|
98
|
-
return Object.keys(states).map(Number);
|
|
99
|
-
},
|
|
100
|
-
registerCommands(commandMap) {
|
|
101
|
-
Object.assign(commandMapRef, commandMap);
|
|
102
|
-
},
|
|
103
|
-
set(uid, oldState, newState, scheduledState) {
|
|
104
|
-
const current = states[uid];
|
|
105
|
-
if (!current || oldState === newState && newState !== current.newState) {
|
|
106
|
-
generations[uid] = getGeneration(uid) + 1;
|
|
107
|
-
}
|
|
108
|
-
states[uid] = {
|
|
109
|
-
newState,
|
|
110
|
-
oldState,
|
|
111
|
-
scheduledState: scheduledState ?? newState
|
|
112
|
-
};
|
|
113
|
-
},
|
|
114
|
-
wrapAsyncCommand(fn) {
|
|
115
|
-
const wrapped = async (uid, ...args) => {
|
|
116
|
-
const generation = getGeneration(uid);
|
|
117
|
-
const context = createAsyncCommandContext(uid, generation);
|
|
118
|
-
await fn(context, ...args);
|
|
119
|
-
};
|
|
120
|
-
return wrapped;
|
|
121
|
-
},
|
|
122
|
-
wrapCommand(fn) {
|
|
123
|
-
const wrapped = async (uid, ...args) => {
|
|
124
|
-
const generation = getGeneration(uid);
|
|
125
|
-
const {
|
|
126
|
-
newState,
|
|
127
|
-
oldState
|
|
128
|
-
} = states[uid];
|
|
129
|
-
const newerState = await fn(newState, ...args);
|
|
130
|
-
if (oldState === newerState || newState === newerState) {
|
|
131
|
-
return;
|
|
132
|
-
}
|
|
133
|
-
if (!isCurrentGeneration(uid, generation)) {
|
|
134
|
-
return;
|
|
135
|
-
}
|
|
136
|
-
const latestOld = states[uid];
|
|
137
|
-
const latestNew = {
|
|
138
|
-
...latestOld.newState,
|
|
139
|
-
...newerState
|
|
140
|
-
};
|
|
141
|
-
states[uid] = {
|
|
142
|
-
newState: latestNew,
|
|
143
|
-
oldState: latestOld.oldState,
|
|
144
|
-
scheduledState: latestNew
|
|
145
|
-
};
|
|
146
|
-
};
|
|
147
|
-
return wrapped;
|
|
148
|
-
},
|
|
149
|
-
wrapGetter(fn) {
|
|
150
|
-
const wrapped = (uid, ...args) => {
|
|
151
|
-
const {
|
|
152
|
-
newState
|
|
153
|
-
} = states[uid];
|
|
154
|
-
return fn(newState, ...args);
|
|
155
|
-
};
|
|
156
|
-
return wrapped;
|
|
157
|
-
},
|
|
158
|
-
wrapLoadContent(fn) {
|
|
159
|
-
const wrapped = async (uid, ...args) => {
|
|
160
|
-
const generation = getGeneration(uid);
|
|
161
|
-
const {
|
|
162
|
-
newState,
|
|
163
|
-
oldState
|
|
164
|
-
} = states[uid];
|
|
165
|
-
const result = await fn(newState, ...args);
|
|
166
|
-
const {
|
|
167
|
-
error,
|
|
168
|
-
state
|
|
169
|
-
} = result;
|
|
170
|
-
if (oldState === state || newState === state) {
|
|
171
|
-
return {
|
|
172
|
-
error
|
|
173
|
-
};
|
|
174
|
-
}
|
|
175
|
-
if (!isCurrentGeneration(uid, generation)) {
|
|
176
|
-
return {
|
|
177
|
-
error
|
|
178
|
-
};
|
|
179
|
-
}
|
|
180
|
-
const latestOld = states[uid];
|
|
181
|
-
const latestNew = {
|
|
182
|
-
...latestOld.newState,
|
|
183
|
-
...state
|
|
184
|
-
};
|
|
185
|
-
states[uid] = {
|
|
186
|
-
newState: latestNew,
|
|
187
|
-
oldState: latestOld.oldState,
|
|
188
|
-
scheduledState: latestNew
|
|
189
|
-
};
|
|
190
|
-
return {
|
|
191
|
-
error
|
|
192
|
-
};
|
|
193
|
-
};
|
|
194
|
-
return wrapped;
|
|
195
|
-
},
|
|
196
|
-
wrapSerialAsyncCommand(fn) {
|
|
197
|
-
const wrapped = async (uid, ...args) => {
|
|
198
|
-
await enqueueCommand(uid, async () => {
|
|
199
|
-
if (!states[uid]) {
|
|
200
|
-
return;
|
|
201
|
-
}
|
|
202
|
-
const generation = getGeneration(uid);
|
|
203
|
-
const context = createAsyncCommandContext(uid, generation);
|
|
204
|
-
await fn(context, ...args);
|
|
205
|
-
});
|
|
206
|
-
};
|
|
207
|
-
return wrapped;
|
|
208
|
-
},
|
|
209
|
-
wrapSerialCommand(fn) {
|
|
210
|
-
const wrapped = async (uid, ...args) => {
|
|
211
|
-
await enqueueCommand(uid, async () => {
|
|
212
|
-
if (!states[uid]) {
|
|
213
|
-
return;
|
|
214
|
-
}
|
|
215
|
-
const generation = getGeneration(uid);
|
|
216
|
-
const {
|
|
217
|
-
newState,
|
|
218
|
-
oldState
|
|
219
|
-
} = states[uid];
|
|
220
|
-
const newerState = await fn(newState, ...args);
|
|
221
|
-
if (oldState === newerState || newState === newerState) {
|
|
222
|
-
return;
|
|
223
|
-
}
|
|
224
|
-
if (!isCurrentGeneration(uid, generation)) {
|
|
225
|
-
return;
|
|
226
|
-
}
|
|
227
|
-
const latestOld = states[uid];
|
|
228
|
-
const latestNew = {
|
|
229
|
-
...latestOld.newState,
|
|
230
|
-
...newerState
|
|
231
|
-
};
|
|
232
|
-
states[uid] = {
|
|
233
|
-
newState: latestNew,
|
|
234
|
-
oldState: latestOld.oldState,
|
|
235
|
-
scheduledState: latestNew
|
|
236
|
-
};
|
|
237
|
-
});
|
|
238
|
-
};
|
|
239
|
-
return wrapped;
|
|
50
|
+
if (error.code) {
|
|
51
|
+
// @ts-ignore
|
|
52
|
+
this.code = error.code;
|
|
240
53
|
}
|
|
241
|
-
}
|
|
242
|
-
}
|
|
243
|
-
const terminate = () => {
|
|
244
|
-
globalThis.close();
|
|
245
|
-
};
|
|
54
|
+
}
|
|
55
|
+
}
|
|
246
56
|
|
|
247
57
|
class AssertionError extends Error {
|
|
248
58
|
constructor(message) {
|
|
@@ -311,62 +121,6 @@ const boolean = value => {
|
|
|
311
121
|
}
|
|
312
122
|
};
|
|
313
123
|
|
|
314
|
-
const normalizeLine = line => {
|
|
315
|
-
if (line.startsWith('Error: ')) {
|
|
316
|
-
return line.slice('Error: '.length);
|
|
317
|
-
}
|
|
318
|
-
if (line.startsWith('VError: ')) {
|
|
319
|
-
return line.slice('VError: '.length);
|
|
320
|
-
}
|
|
321
|
-
return line;
|
|
322
|
-
};
|
|
323
|
-
const getCombinedMessage = (error, message) => {
|
|
324
|
-
const stringifiedError = normalizeLine(`${error}`);
|
|
325
|
-
if (message) {
|
|
326
|
-
return `${message}: ${stringifiedError}`;
|
|
327
|
-
}
|
|
328
|
-
return stringifiedError;
|
|
329
|
-
};
|
|
330
|
-
const NewLine$3 = '\n';
|
|
331
|
-
const getNewLineIndex$1 = (string, startIndex = undefined) => {
|
|
332
|
-
return string.indexOf(NewLine$3, startIndex);
|
|
333
|
-
};
|
|
334
|
-
const mergeStacks = (parent, child) => {
|
|
335
|
-
if (!child) {
|
|
336
|
-
return parent;
|
|
337
|
-
}
|
|
338
|
-
const parentNewLineIndex = getNewLineIndex$1(parent);
|
|
339
|
-
const childNewLineIndex = getNewLineIndex$1(child);
|
|
340
|
-
if (childNewLineIndex === -1) {
|
|
341
|
-
return parent;
|
|
342
|
-
}
|
|
343
|
-
const parentFirstLine = parent.slice(0, parentNewLineIndex);
|
|
344
|
-
const childRest = child.slice(childNewLineIndex);
|
|
345
|
-
const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
|
|
346
|
-
if (parentFirstLine.includes(childFirstLine)) {
|
|
347
|
-
return parentFirstLine + childRest;
|
|
348
|
-
}
|
|
349
|
-
return child;
|
|
350
|
-
};
|
|
351
|
-
class VError extends Error {
|
|
352
|
-
constructor(error, message) {
|
|
353
|
-
const combinedMessage = getCombinedMessage(error, message);
|
|
354
|
-
super(combinedMessage);
|
|
355
|
-
this.name = 'VError';
|
|
356
|
-
if (error instanceof Error) {
|
|
357
|
-
this.stack = mergeStacks(this.stack, error.stack);
|
|
358
|
-
}
|
|
359
|
-
if (error.codeFrame) {
|
|
360
|
-
// @ts-ignore
|
|
361
|
-
this.codeFrame = error.codeFrame;
|
|
362
|
-
}
|
|
363
|
-
if (error.code) {
|
|
364
|
-
// @ts-ignore
|
|
365
|
-
this.code = error.code;
|
|
366
|
-
}
|
|
367
|
-
}
|
|
368
|
-
}
|
|
369
|
-
|
|
370
124
|
const isMessagePort = value => {
|
|
371
125
|
return value && value instanceof MessagePort;
|
|
372
126
|
};
|
|
@@ -1058,7 +812,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
|
|
|
1058
812
|
const errorProperty = getErrorProperty(error, prettyError);
|
|
1059
813
|
return create$1$1(id, errorProperty);
|
|
1060
814
|
};
|
|
1061
|
-
const create$
|
|
815
|
+
const create$j = (message, result) => {
|
|
1062
816
|
return {
|
|
1063
817
|
id: message.id,
|
|
1064
818
|
jsonrpc: Two$1,
|
|
@@ -1067,7 +821,7 @@ const create$i = (message, result) => {
|
|
|
1067
821
|
};
|
|
1068
822
|
const getSuccessResponse = (message, result) => {
|
|
1069
823
|
const resultProperty = result ?? null;
|
|
1070
|
-
return create$
|
|
824
|
+
return create$j(message, resultProperty);
|
|
1071
825
|
};
|
|
1072
826
|
const getErrorResponseSimple = (id, error) => {
|
|
1073
827
|
return {
|
|
@@ -1161,7 +915,7 @@ const handleJsonRpcMessage = async (...args) => {
|
|
|
1161
915
|
|
|
1162
916
|
const Two = '2.0';
|
|
1163
917
|
|
|
1164
|
-
const create$
|
|
918
|
+
const create$i = (method, params) => {
|
|
1165
919
|
return {
|
|
1166
920
|
jsonrpc: Two,
|
|
1167
921
|
method,
|
|
@@ -1169,7 +923,7 @@ const create$h = (method, params) => {
|
|
|
1169
923
|
};
|
|
1170
924
|
};
|
|
1171
925
|
|
|
1172
|
-
const create$
|
|
926
|
+
const create$h = (id, method, params) => {
|
|
1173
927
|
const message = {
|
|
1174
928
|
id,
|
|
1175
929
|
jsonrpc: Two,
|
|
@@ -1180,12 +934,12 @@ const create$g = (id, method, params) => {
|
|
|
1180
934
|
};
|
|
1181
935
|
|
|
1182
936
|
let id = 0;
|
|
1183
|
-
const create$
|
|
937
|
+
const create$g = () => {
|
|
1184
938
|
return ++id;
|
|
1185
939
|
};
|
|
1186
940
|
|
|
1187
941
|
const registerPromise = map => {
|
|
1188
|
-
const id = create$
|
|
942
|
+
const id = create$g();
|
|
1189
943
|
const {
|
|
1190
944
|
promise,
|
|
1191
945
|
resolve
|
|
@@ -1202,7 +956,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
|
|
|
1202
956
|
id,
|
|
1203
957
|
promise
|
|
1204
958
|
} = registerPromise(callbacks);
|
|
1205
|
-
const message = create$
|
|
959
|
+
const message = create$h(id, method, params);
|
|
1206
960
|
if (useSendAndTransfer && ipc.sendAndTransfer) {
|
|
1207
961
|
ipc.sendAndTransfer(message);
|
|
1208
962
|
} else {
|
|
@@ -1238,7 +992,7 @@ const createRpc = ipc => {
|
|
|
1238
992
|
* @deprecated
|
|
1239
993
|
*/
|
|
1240
994
|
send(method, ...params) {
|
|
1241
|
-
const message = create$
|
|
995
|
+
const message = create$i(method, params);
|
|
1242
996
|
ipc.send(message);
|
|
1243
997
|
}
|
|
1244
998
|
};
|
|
@@ -1278,7 +1032,7 @@ const listen$1 = async (module, options) => {
|
|
|
1278
1032
|
return ipc;
|
|
1279
1033
|
};
|
|
1280
1034
|
|
|
1281
|
-
const create$
|
|
1035
|
+
const create$f = async ({
|
|
1282
1036
|
commandMap,
|
|
1283
1037
|
isMessagePortOpen = true,
|
|
1284
1038
|
messagePort
|
|
@@ -1296,7 +1050,7 @@ const create$e = async ({
|
|
|
1296
1050
|
return rpc;
|
|
1297
1051
|
};
|
|
1298
1052
|
|
|
1299
|
-
const create$
|
|
1053
|
+
const create$e = async ({
|
|
1300
1054
|
commandMap,
|
|
1301
1055
|
isMessagePortOpen,
|
|
1302
1056
|
send
|
|
@@ -1306,7 +1060,7 @@ const create$d = async ({
|
|
|
1306
1060
|
port2
|
|
1307
1061
|
} = new MessageChannel();
|
|
1308
1062
|
await send(port1);
|
|
1309
|
-
return create$
|
|
1063
|
+
return create$f({
|
|
1310
1064
|
commandMap,
|
|
1311
1065
|
isMessagePortOpen,
|
|
1312
1066
|
messagePort: port2
|
|
@@ -1341,13 +1095,13 @@ const createSharedLazyRpc = factory => {
|
|
|
1341
1095
|
};
|
|
1342
1096
|
};
|
|
1343
1097
|
|
|
1344
|
-
const create$
|
|
1098
|
+
const create$d = async ({
|
|
1345
1099
|
commandMap,
|
|
1346
1100
|
isMessagePortOpen,
|
|
1347
1101
|
send
|
|
1348
1102
|
}) => {
|
|
1349
1103
|
return createSharedLazyRpc(() => {
|
|
1350
|
-
return create$
|
|
1104
|
+
return create$e({
|
|
1351
1105
|
commandMap,
|
|
1352
1106
|
isMessagePortOpen,
|
|
1353
1107
|
send
|
|
@@ -1355,17 +1109,17 @@ const create$c = async ({
|
|
|
1355
1109
|
});
|
|
1356
1110
|
};
|
|
1357
1111
|
|
|
1358
|
-
const create$
|
|
1112
|
+
const create$c = async ({
|
|
1359
1113
|
commandMap,
|
|
1360
1114
|
messagePort
|
|
1361
1115
|
}) => {
|
|
1362
|
-
return create$
|
|
1116
|
+
return create$f({
|
|
1363
1117
|
commandMap,
|
|
1364
1118
|
messagePort
|
|
1365
1119
|
});
|
|
1366
1120
|
};
|
|
1367
1121
|
|
|
1368
|
-
const create$
|
|
1122
|
+
const create$b = async ({
|
|
1369
1123
|
commandMap
|
|
1370
1124
|
}) => {
|
|
1371
1125
|
// TODO create a commandMap per rpc instance
|
|
@@ -1397,7 +1151,7 @@ const createMockRpc = ({
|
|
|
1397
1151
|
};
|
|
1398
1152
|
|
|
1399
1153
|
const rpcs = Object.create(null);
|
|
1400
|
-
const set$
|
|
1154
|
+
const set$i = (id, rpc) => {
|
|
1401
1155
|
rpcs[id] = rpc;
|
|
1402
1156
|
};
|
|
1403
1157
|
const get$8 = id => {
|
|
@@ -1408,7 +1162,7 @@ const remove$8 = id => {
|
|
|
1408
1162
|
};
|
|
1409
1163
|
|
|
1410
1164
|
/* eslint-disable @typescript-eslint/explicit-function-return-type */
|
|
1411
|
-
const create$
|
|
1165
|
+
const create$a = rpcId => {
|
|
1412
1166
|
return {
|
|
1413
1167
|
async dispose() {
|
|
1414
1168
|
const rpc = get$8(rpcId);
|
|
@@ -1430,7 +1184,7 @@ const create$9 = rpcId => {
|
|
|
1430
1184
|
const mockRpc = createMockRpc({
|
|
1431
1185
|
commandMap
|
|
1432
1186
|
});
|
|
1433
|
-
set$
|
|
1187
|
+
set$i(rpcId, mockRpc);
|
|
1434
1188
|
// @ts-ignore
|
|
1435
1189
|
mockRpc[Symbol.dispose] = () => {
|
|
1436
1190
|
remove$8(rpcId);
|
|
@@ -1439,7 +1193,7 @@ const create$9 = rpcId => {
|
|
|
1439
1193
|
return mockRpc;
|
|
1440
1194
|
},
|
|
1441
1195
|
set(rpc) {
|
|
1442
|
-
set$
|
|
1196
|
+
set$i(rpcId, rpc);
|
|
1443
1197
|
}
|
|
1444
1198
|
};
|
|
1445
1199
|
};
|
|
@@ -1679,6 +1433,7 @@ const Electron = 2;
|
|
|
1679
1433
|
|
|
1680
1434
|
const CompletionWorker = 301;
|
|
1681
1435
|
const DebugWorker = 55;
|
|
1436
|
+
const DialogWorker = 7014;
|
|
1682
1437
|
const EditorWorker = 99;
|
|
1683
1438
|
const ErrorWorker = 3308;
|
|
1684
1439
|
const ExtensionHostWorker = 44;
|
|
@@ -1695,15 +1450,20 @@ const SetPatches = 'Viewlet.setPatches';
|
|
|
1695
1450
|
|
|
1696
1451
|
const FocusEditorText$1 = 12;
|
|
1697
1452
|
|
|
1453
|
+
const {
|
|
1454
|
+
invoke: invoke$h,
|
|
1455
|
+
set: set$h
|
|
1456
|
+
} = create$a(DialogWorker);
|
|
1457
|
+
|
|
1698
1458
|
const {
|
|
1699
1459
|
invoke: invoke$g,
|
|
1700
1460
|
set: set$g
|
|
1701
|
-
} = create$
|
|
1461
|
+
} = create$a(ErrorWorker);
|
|
1702
1462
|
|
|
1703
1463
|
const {
|
|
1704
1464
|
invoke: invoke$f,
|
|
1705
1465
|
set: set$f
|
|
1706
|
-
} = create$
|
|
1466
|
+
} = create$a(ExtensionHostWorker);
|
|
1707
1467
|
|
|
1708
1468
|
const ExtensionHost = {
|
|
1709
1469
|
__proto__: null,
|
|
@@ -1714,15 +1474,88 @@ const ExtensionHost = {
|
|
|
1714
1474
|
const {
|
|
1715
1475
|
invoke: invoke$e,
|
|
1716
1476
|
set: set$e
|
|
1717
|
-
} = create$
|
|
1477
|
+
} = create$a(ExtensionManagementWorker);
|
|
1718
1478
|
const getLanguages$1 = (platform, assetDir) => {
|
|
1719
1479
|
return invoke$e('Extensions.getLanguages', platform, assetDir);
|
|
1720
1480
|
};
|
|
1721
1481
|
|
|
1482
|
+
const createLazyRpc = rpcId => {
|
|
1483
|
+
let activeRpc;
|
|
1484
|
+
let factory;
|
|
1485
|
+
let generation = 0;
|
|
1486
|
+
let rpcPromise;
|
|
1487
|
+
const resetListeners = new Set();
|
|
1488
|
+
const createRpc = async expectedGeneration => {
|
|
1489
|
+
const rpc = await factory();
|
|
1490
|
+
if (generation !== expectedGeneration) {
|
|
1491
|
+
await rpc.dispose();
|
|
1492
|
+
throw new Error('Lazy RPC launch was superseded');
|
|
1493
|
+
}
|
|
1494
|
+
activeRpc = rpc;
|
|
1495
|
+
set$i(rpcId, rpc);
|
|
1496
|
+
return rpc;
|
|
1497
|
+
};
|
|
1498
|
+
const ensureRpc = async () => {
|
|
1499
|
+
if (activeRpc) {
|
|
1500
|
+
return activeRpc;
|
|
1501
|
+
}
|
|
1502
|
+
if (!rpcPromise) {
|
|
1503
|
+
const pending = createRpc(generation);
|
|
1504
|
+
rpcPromise = pending;
|
|
1505
|
+
void pending.catch(() => {
|
|
1506
|
+
if (rpcPromise === pending) {
|
|
1507
|
+
rpcPromise = undefined;
|
|
1508
|
+
}
|
|
1509
|
+
});
|
|
1510
|
+
}
|
|
1511
|
+
return rpcPromise;
|
|
1512
|
+
};
|
|
1513
|
+
const clear = async (reason, notify) => {
|
|
1514
|
+
generation++;
|
|
1515
|
+
const rpc = activeRpc;
|
|
1516
|
+
activeRpc = undefined;
|
|
1517
|
+
rpcPromise = undefined;
|
|
1518
|
+
if (rpc && get$8(rpcId) === rpc) {
|
|
1519
|
+
remove$8(rpcId);
|
|
1520
|
+
}
|
|
1521
|
+
if (notify) {
|
|
1522
|
+
for (const listener of resetListeners) {
|
|
1523
|
+
listener(reason);
|
|
1524
|
+
}
|
|
1525
|
+
}
|
|
1526
|
+
await rpc?.dispose();
|
|
1527
|
+
};
|
|
1528
|
+
return {
|
|
1529
|
+
dispose() {
|
|
1530
|
+
return clear(undefined, false);
|
|
1531
|
+
},
|
|
1532
|
+
async invoke(method, ...params) {
|
|
1533
|
+
const rpc = await ensureRpc();
|
|
1534
|
+
return rpc.invoke(method, ...params);
|
|
1535
|
+
},
|
|
1536
|
+
async invokeAndTransfer(method, ...params) {
|
|
1537
|
+
const rpc = await ensureRpc();
|
|
1538
|
+
return rpc.invokeAndTransfer(method, ...params);
|
|
1539
|
+
},
|
|
1540
|
+
onDidReset(listener) {
|
|
1541
|
+
resetListeners.add(listener);
|
|
1542
|
+
return () => {
|
|
1543
|
+
resetListeners.delete(listener);
|
|
1544
|
+
};
|
|
1545
|
+
},
|
|
1546
|
+
reset(reason) {
|
|
1547
|
+
return clear(reason, true);
|
|
1548
|
+
},
|
|
1549
|
+
setFactory(value) {
|
|
1550
|
+
factory = value;
|
|
1551
|
+
}
|
|
1552
|
+
};
|
|
1553
|
+
};
|
|
1554
|
+
|
|
1722
1555
|
const {
|
|
1723
1556
|
invoke: invoke$d,
|
|
1724
1557
|
set: set$d
|
|
1725
|
-
} = create$
|
|
1558
|
+
} = create$a(OpenerWorker);
|
|
1726
1559
|
const openUrl = async (url, platform) => {
|
|
1727
1560
|
return invoke$d('Open.openUrl', url, platform);
|
|
1728
1561
|
};
|
|
@@ -1730,13 +1563,13 @@ const openUrl = async (url, platform) => {
|
|
|
1730
1563
|
const {
|
|
1731
1564
|
invoke: invoke$c,
|
|
1732
1565
|
set: set$c
|
|
1733
|
-
} = create$
|
|
1566
|
+
} = create$a(IconThemeWorker);
|
|
1734
1567
|
|
|
1735
1568
|
const {
|
|
1736
1569
|
invoke: invoke$b,
|
|
1737
1570
|
invokeAndTransfer,
|
|
1738
1571
|
set: set$b
|
|
1739
|
-
} = create$
|
|
1572
|
+
} = create$a(RendererWorker$1);
|
|
1740
1573
|
const showContextMenu2 = async (uid, menuId, x, y, args) => {
|
|
1741
1574
|
number(uid);
|
|
1742
1575
|
number(menuId);
|
|
@@ -1748,6 +1581,10 @@ const sendMessagePortToOpenerWorker = async (port, rpcId) => {
|
|
|
1748
1581
|
const command = 'HandleMessagePort.handleMessagePort';
|
|
1749
1582
|
await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
|
|
1750
1583
|
};
|
|
1584
|
+
const sendMessagePortToDialogWorker = async port => {
|
|
1585
|
+
const command = 'HandleMessagePort.handleMessagePort';
|
|
1586
|
+
await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker', port, command);
|
|
1587
|
+
};
|
|
1751
1588
|
const sendMessagePortToErrorWorker = async (port, rpcId) => {
|
|
1752
1589
|
const command = 'Errors.handleMessagePort';
|
|
1753
1590
|
await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
|
|
@@ -1799,6 +1636,7 @@ const RendererWorker = {
|
|
|
1799
1636
|
openUri,
|
|
1800
1637
|
readClipBoardText,
|
|
1801
1638
|
readFile,
|
|
1639
|
+
sendMessagePortToDialogWorker,
|
|
1802
1640
|
sendMessagePortToErrorWorker,
|
|
1803
1641
|
sendMessagePortToExtensionHostWorker,
|
|
1804
1642
|
sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker$1,
|
|
@@ -1813,7 +1651,7 @@ const RendererWorker = {
|
|
|
1813
1651
|
const {
|
|
1814
1652
|
invoke: invoke$a,
|
|
1815
1653
|
set: set$a
|
|
1816
|
-
} = create$
|
|
1654
|
+
} = create$a(MarkdownWorker);
|
|
1817
1655
|
|
|
1818
1656
|
const SyntaxHighlightingWorker = {
|
|
1819
1657
|
__proto__: null,
|
|
@@ -1821,35 +1659,251 @@ const SyntaxHighlightingWorker = {
|
|
|
1821
1659
|
set: set$a
|
|
1822
1660
|
};
|
|
1823
1661
|
|
|
1824
|
-
const
|
|
1825
|
-
|
|
1826
|
-
|
|
1827
|
-
|
|
1828
|
-
|
|
1829
|
-
|
|
1662
|
+
const toCommandId = key => {
|
|
1663
|
+
const dotIndex = key.indexOf('.');
|
|
1664
|
+
return key.slice(dotIndex + 1);
|
|
1665
|
+
};
|
|
1666
|
+
const create$9 = () => {
|
|
1667
|
+
const commandQueues = new Map();
|
|
1668
|
+
const generations = Object.create(null);
|
|
1669
|
+
const states = Object.create(null);
|
|
1670
|
+
const commandMapRef = {};
|
|
1671
|
+
const getGeneration = uid => generations[uid] || 0;
|
|
1672
|
+
const isCurrentGeneration = (uid, generation) => {
|
|
1673
|
+
return states[uid] !== undefined && getGeneration(uid) === generation;
|
|
1830
1674
|
};
|
|
1831
|
-
const
|
|
1832
|
-
if (!
|
|
1833
|
-
|
|
1675
|
+
const updateState = (uid, generation, fallbackState, updater) => {
|
|
1676
|
+
if (!isCurrentGeneration(uid, generation)) {
|
|
1677
|
+
return Promise.resolve(fallbackState);
|
|
1678
|
+
}
|
|
1679
|
+
const current = states[uid];
|
|
1680
|
+
const updatedState = updater(current.newState);
|
|
1681
|
+
if (updatedState !== current.newState) {
|
|
1682
|
+
states[uid] = {
|
|
1683
|
+
newState: updatedState,
|
|
1684
|
+
oldState: current.oldState,
|
|
1685
|
+
scheduledState: updatedState
|
|
1686
|
+
};
|
|
1687
|
+
}
|
|
1688
|
+
return Promise.resolve(updatedState);
|
|
1689
|
+
};
|
|
1690
|
+
const createAsyncCommandContext = (uid, generation) => {
|
|
1691
|
+
let latestState = states[uid].newState;
|
|
1692
|
+
return {
|
|
1693
|
+
getState: () => {
|
|
1694
|
+
if (isCurrentGeneration(uid, generation)) {
|
|
1695
|
+
latestState = states[uid].newState;
|
|
1696
|
+
}
|
|
1697
|
+
return latestState;
|
|
1698
|
+
},
|
|
1699
|
+
updateState: async updater => {
|
|
1700
|
+
latestState = await updateState(uid, generation, latestState, updater);
|
|
1701
|
+
return latestState;
|
|
1702
|
+
}
|
|
1703
|
+
};
|
|
1704
|
+
};
|
|
1705
|
+
const enqueueCommand = async (uid, command) => {
|
|
1706
|
+
const previous = commandQueues.get(uid) || Promise.resolve();
|
|
1707
|
+
const run = async () => {
|
|
1708
|
+
try {
|
|
1709
|
+
await previous;
|
|
1710
|
+
} catch {
|
|
1711
|
+
// The previous caller receives its error; later commands must still run.
|
|
1712
|
+
}
|
|
1713
|
+
await command();
|
|
1714
|
+
};
|
|
1715
|
+
const current = run();
|
|
1716
|
+
commandQueues.set(uid, current);
|
|
1717
|
+
try {
|
|
1718
|
+
await current;
|
|
1719
|
+
} finally {
|
|
1720
|
+
if (commandQueues.get(uid) === current) {
|
|
1721
|
+
commandQueues.delete(uid);
|
|
1722
|
+
}
|
|
1834
1723
|
}
|
|
1835
|
-
await rpcPromise;
|
|
1836
1724
|
};
|
|
1837
1725
|
return {
|
|
1838
|
-
|
|
1839
|
-
|
|
1840
|
-
const
|
|
1841
|
-
|
|
1726
|
+
clear() {
|
|
1727
|
+
commandQueues.clear();
|
|
1728
|
+
for (const key of Object.keys(states)) {
|
|
1729
|
+
delete states[key];
|
|
1730
|
+
}
|
|
1842
1731
|
},
|
|
1843
|
-
|
|
1844
|
-
|
|
1845
|
-
|
|
1846
|
-
|
|
1732
|
+
diff(uid, modules, numbers) {
|
|
1733
|
+
const {
|
|
1734
|
+
oldState,
|
|
1735
|
+
scheduledState
|
|
1736
|
+
} = states[uid];
|
|
1737
|
+
const diffResult = [];
|
|
1738
|
+
for (let i = 0; i < modules.length; i++) {
|
|
1739
|
+
const fn = modules[i];
|
|
1740
|
+
if (!fn(oldState, scheduledState)) {
|
|
1741
|
+
diffResult.push(numbers[i]);
|
|
1742
|
+
}
|
|
1743
|
+
}
|
|
1744
|
+
return diffResult;
|
|
1847
1745
|
},
|
|
1848
|
-
|
|
1849
|
-
|
|
1746
|
+
dispose(uid) {
|
|
1747
|
+
commandQueues.delete(uid);
|
|
1748
|
+
delete states[uid];
|
|
1749
|
+
},
|
|
1750
|
+
get(uid) {
|
|
1751
|
+
return states[uid];
|
|
1752
|
+
},
|
|
1753
|
+
getCommandIds() {
|
|
1754
|
+
const keys = Object.keys(commandMapRef);
|
|
1755
|
+
const ids = keys.map(toCommandId);
|
|
1756
|
+
return ids;
|
|
1757
|
+
},
|
|
1758
|
+
getKeys() {
|
|
1759
|
+
return Object.keys(states).map(Number);
|
|
1760
|
+
},
|
|
1761
|
+
registerCommands(commandMap) {
|
|
1762
|
+
Object.assign(commandMapRef, commandMap);
|
|
1763
|
+
},
|
|
1764
|
+
set(uid, oldState, newState, scheduledState) {
|
|
1765
|
+
const current = states[uid];
|
|
1766
|
+
if (!current || oldState === newState && newState !== current.newState) {
|
|
1767
|
+
generations[uid] = getGeneration(uid) + 1;
|
|
1768
|
+
}
|
|
1769
|
+
states[uid] = {
|
|
1770
|
+
newState,
|
|
1771
|
+
oldState,
|
|
1772
|
+
scheduledState: scheduledState ?? newState
|
|
1773
|
+
};
|
|
1774
|
+
},
|
|
1775
|
+
wrapAsyncCommand(fn) {
|
|
1776
|
+
const wrapped = async (uid, ...args) => {
|
|
1777
|
+
const generation = getGeneration(uid);
|
|
1778
|
+
const context = createAsyncCommandContext(uid, generation);
|
|
1779
|
+
await fn(context, ...args);
|
|
1780
|
+
};
|
|
1781
|
+
return wrapped;
|
|
1782
|
+
},
|
|
1783
|
+
wrapCommand(fn) {
|
|
1784
|
+
const wrapped = async (uid, ...args) => {
|
|
1785
|
+
const generation = getGeneration(uid);
|
|
1786
|
+
const {
|
|
1787
|
+
newState,
|
|
1788
|
+
oldState
|
|
1789
|
+
} = states[uid];
|
|
1790
|
+
const newerState = await fn(newState, ...args);
|
|
1791
|
+
if (oldState === newerState || newState === newerState) {
|
|
1792
|
+
return;
|
|
1793
|
+
}
|
|
1794
|
+
if (!isCurrentGeneration(uid, generation)) {
|
|
1795
|
+
return;
|
|
1796
|
+
}
|
|
1797
|
+
const latestOld = states[uid];
|
|
1798
|
+
const latestNew = {
|
|
1799
|
+
...latestOld.newState,
|
|
1800
|
+
...newerState
|
|
1801
|
+
};
|
|
1802
|
+
states[uid] = {
|
|
1803
|
+
newState: latestNew,
|
|
1804
|
+
oldState: latestOld.oldState,
|
|
1805
|
+
scheduledState: latestNew
|
|
1806
|
+
};
|
|
1807
|
+
};
|
|
1808
|
+
return wrapped;
|
|
1809
|
+
},
|
|
1810
|
+
wrapGetter(fn) {
|
|
1811
|
+
const wrapped = (uid, ...args) => {
|
|
1812
|
+
const {
|
|
1813
|
+
newState
|
|
1814
|
+
} = states[uid];
|
|
1815
|
+
return fn(newState, ...args);
|
|
1816
|
+
};
|
|
1817
|
+
return wrapped;
|
|
1818
|
+
},
|
|
1819
|
+
wrapLoadContent(fn) {
|
|
1820
|
+
const wrapped = async (uid, ...args) => {
|
|
1821
|
+
const generation = getGeneration(uid);
|
|
1822
|
+
const {
|
|
1823
|
+
newState,
|
|
1824
|
+
oldState
|
|
1825
|
+
} = states[uid];
|
|
1826
|
+
const result = await fn(newState, ...args);
|
|
1827
|
+
const {
|
|
1828
|
+
error,
|
|
1829
|
+
state
|
|
1830
|
+
} = result;
|
|
1831
|
+
if (oldState === state || newState === state) {
|
|
1832
|
+
return {
|
|
1833
|
+
error
|
|
1834
|
+
};
|
|
1835
|
+
}
|
|
1836
|
+
if (!isCurrentGeneration(uid, generation)) {
|
|
1837
|
+
return {
|
|
1838
|
+
error
|
|
1839
|
+
};
|
|
1840
|
+
}
|
|
1841
|
+
const latestOld = states[uid];
|
|
1842
|
+
const latestNew = {
|
|
1843
|
+
...latestOld.newState,
|
|
1844
|
+
...state
|
|
1845
|
+
};
|
|
1846
|
+
states[uid] = {
|
|
1847
|
+
newState: latestNew,
|
|
1848
|
+
oldState: latestOld.oldState,
|
|
1849
|
+
scheduledState: latestNew
|
|
1850
|
+
};
|
|
1851
|
+
return {
|
|
1852
|
+
error
|
|
1853
|
+
};
|
|
1854
|
+
};
|
|
1855
|
+
return wrapped;
|
|
1856
|
+
},
|
|
1857
|
+
wrapSerialAsyncCommand(fn) {
|
|
1858
|
+
const wrapped = async (uid, ...args) => {
|
|
1859
|
+
await enqueueCommand(uid, async () => {
|
|
1860
|
+
if (!states[uid]) {
|
|
1861
|
+
return;
|
|
1862
|
+
}
|
|
1863
|
+
const generation = getGeneration(uid);
|
|
1864
|
+
const context = createAsyncCommandContext(uid, generation);
|
|
1865
|
+
await fn(context, ...args);
|
|
1866
|
+
});
|
|
1867
|
+
};
|
|
1868
|
+
return wrapped;
|
|
1869
|
+
},
|
|
1870
|
+
wrapSerialCommand(fn) {
|
|
1871
|
+
const wrapped = async (uid, ...args) => {
|
|
1872
|
+
await enqueueCommand(uid, async () => {
|
|
1873
|
+
if (!states[uid]) {
|
|
1874
|
+
return;
|
|
1875
|
+
}
|
|
1876
|
+
const generation = getGeneration(uid);
|
|
1877
|
+
const {
|
|
1878
|
+
newState,
|
|
1879
|
+
oldState
|
|
1880
|
+
} = states[uid];
|
|
1881
|
+
const newerState = await fn(newState, ...args);
|
|
1882
|
+
if (oldState === newerState || newState === newerState) {
|
|
1883
|
+
return;
|
|
1884
|
+
}
|
|
1885
|
+
if (!isCurrentGeneration(uid, generation)) {
|
|
1886
|
+
return;
|
|
1887
|
+
}
|
|
1888
|
+
const latestOld = states[uid];
|
|
1889
|
+
const latestNew = {
|
|
1890
|
+
...latestOld.newState,
|
|
1891
|
+
...newerState
|
|
1892
|
+
};
|
|
1893
|
+
states[uid] = {
|
|
1894
|
+
newState: latestNew,
|
|
1895
|
+
oldState: latestOld.oldState,
|
|
1896
|
+
scheduledState: latestNew
|
|
1897
|
+
};
|
|
1898
|
+
});
|
|
1899
|
+
};
|
|
1900
|
+
return wrapped;
|
|
1850
1901
|
}
|
|
1851
1902
|
};
|
|
1852
1903
|
};
|
|
1904
|
+
const terminate = () => {
|
|
1905
|
+
globalThis.close();
|
|
1906
|
+
};
|
|
1853
1907
|
|
|
1854
1908
|
// TODO add tests for this
|
|
1855
1909
|
const activateByEvent = async (event, assetDir, platform) => {
|
|
@@ -1867,7 +1921,7 @@ const codeGeneratorAccept = state => {
|
|
|
1867
1921
|
const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
|
|
1868
1922
|
|
|
1869
1923
|
const launchWorker = async (name, url, intializeCommand) => {
|
|
1870
|
-
const rpc = await create$
|
|
1924
|
+
const rpc = await create$e({
|
|
1871
1925
|
commandMap: {},
|
|
1872
1926
|
isMessagePortOpen: true,
|
|
1873
1927
|
async send(port) {
|
|
@@ -1922,7 +1976,7 @@ const loadContent$3 = async (state, parentUid) => {
|
|
|
1922
1976
|
};
|
|
1923
1977
|
};
|
|
1924
1978
|
|
|
1925
|
-
const editorStates = create$
|
|
1979
|
+
const editorStates = create$9();
|
|
1926
1980
|
const {
|
|
1927
1981
|
dispose: dispose$1,
|
|
1928
1982
|
getCommandIds,
|
|
@@ -5275,7 +5329,7 @@ const isPermissionDeniedError = error => {
|
|
|
5275
5329
|
};
|
|
5276
5330
|
const showSaveErrorDialog = async error => {
|
|
5277
5331
|
if (isPermissionDeniedError(error)) {
|
|
5278
|
-
await invoke$
|
|
5332
|
+
await invoke$h('ElectronDialog.showMessageBox', {
|
|
5279
5333
|
buttons: ['OK'],
|
|
5280
5334
|
defaultId: 0,
|
|
5281
5335
|
message: "You don't have permission to save changes to this file.",
|
|
@@ -5284,7 +5338,7 @@ const showSaveErrorDialog = async error => {
|
|
|
5284
5338
|
});
|
|
5285
5339
|
return;
|
|
5286
5340
|
}
|
|
5287
|
-
await invoke$
|
|
5341
|
+
await invoke$h('ElectronDialog.showMessageBox', {
|
|
5288
5342
|
buttons: ['OK'],
|
|
5289
5343
|
defaultId: 0,
|
|
5290
5344
|
detail: error.message,
|
|
@@ -8260,7 +8314,7 @@ const launch = async () => {
|
|
|
8260
8314
|
return;
|
|
8261
8315
|
}
|
|
8262
8316
|
const rpc = await launchFindWidgetWorker();
|
|
8263
|
-
set$
|
|
8317
|
+
set$i(rpcId, rpc);
|
|
8264
8318
|
};
|
|
8265
8319
|
const invoke$3 = async (method, ...params) => {
|
|
8266
8320
|
const rpc = get$8(rpcId);
|
|
@@ -11675,12 +11729,12 @@ const handleBeforeInput = (editor, inputType, data) => {
|
|
|
11675
11729
|
};
|
|
11676
11730
|
|
|
11677
11731
|
const handleMessagePort = async (port, rpcId) => {
|
|
11678
|
-
const rpc = await create$
|
|
11732
|
+
const rpc = await create$c({
|
|
11679
11733
|
commandMap: {},
|
|
11680
11734
|
messagePort: port
|
|
11681
11735
|
});
|
|
11682
11736
|
if (rpcId) {
|
|
11683
|
-
set$
|
|
11737
|
+
set$i(rpcId, rpc);
|
|
11684
11738
|
}
|
|
11685
11739
|
};
|
|
11686
11740
|
|
|
@@ -11953,7 +12007,7 @@ const sendMessagePortToSyntaxHighlightingWorker = async port => {
|
|
|
11953
12007
|
|
|
11954
12008
|
const createSyntaxHighlightingWorkerRpc = async () => {
|
|
11955
12009
|
try {
|
|
11956
|
-
const rpc = await create$
|
|
12010
|
+
const rpc = await create$e({
|
|
11957
12011
|
commandMap: {},
|
|
11958
12012
|
send: sendMessagePortToSyntaxHighlightingWorker
|
|
11959
12013
|
});
|
|
@@ -13606,7 +13660,7 @@ for (const [key, value] of Object.entries(commandMap)) {
|
|
|
13606
13660
|
}
|
|
13607
13661
|
|
|
13608
13662
|
const initializeErrorWorker = async () => {
|
|
13609
|
-
const rpc = await create$
|
|
13663
|
+
const rpc = await create$d({
|
|
13610
13664
|
commandMap: {},
|
|
13611
13665
|
send(port) {
|
|
13612
13666
|
return sendMessagePortToErrorWorker(port, EditorWorker);
|
|
@@ -13617,7 +13671,7 @@ const initializeErrorWorker = async () => {
|
|
|
13617
13671
|
|
|
13618
13672
|
const createExtensionHostRpc = async () => {
|
|
13619
13673
|
const initialCommand = 'HandleMessagePort.handleMessagePort2';
|
|
13620
|
-
const rpc = await create$
|
|
13674
|
+
const rpc = await create$d({
|
|
13621
13675
|
commandMap: {},
|
|
13622
13676
|
async send(port) {
|
|
13623
13677
|
await sendMessagePortToExtensionHostWorker2(port, initialCommand, EditorWorker);
|
|
@@ -13632,7 +13686,7 @@ const initializeExtensionHost = async () => {
|
|
|
13632
13686
|
};
|
|
13633
13687
|
|
|
13634
13688
|
const createExtensionManagementWorkerRpc = async () => {
|
|
13635
|
-
const rpc = await create$
|
|
13689
|
+
const rpc = await create$d({
|
|
13636
13690
|
commandMap: {},
|
|
13637
13691
|
async send(port) {
|
|
13638
13692
|
await sendMessagePortToExtensionManagementWorker$1(port, EditorWorker);
|
|
@@ -13655,7 +13709,7 @@ const send$1 = port => {
|
|
|
13655
13709
|
return sendMessagePortToOpenerWorker(port);
|
|
13656
13710
|
};
|
|
13657
13711
|
const initializeOpenerWorker = async () => {
|
|
13658
|
-
const rpc = await create$
|
|
13712
|
+
const rpc = await create$d({
|
|
13659
13713
|
commandMap: {},
|
|
13660
13714
|
send: send$1
|
|
13661
13715
|
});
|
|
@@ -13663,7 +13717,7 @@ const initializeOpenerWorker = async () => {
|
|
|
13663
13717
|
};
|
|
13664
13718
|
|
|
13665
13719
|
const initializeRendererWorker = async () => {
|
|
13666
|
-
const rpc = await create$
|
|
13720
|
+
const rpc = await create$b({
|
|
13667
13721
|
commandMap: commandMap
|
|
13668
13722
|
});
|
|
13669
13723
|
set$b(rpc);
|
|
@@ -13673,7 +13727,7 @@ const send = port => {
|
|
|
13673
13727
|
return sendMessagePortToTextMeasurementWorker(port);
|
|
13674
13728
|
};
|
|
13675
13729
|
const initializeTextMeasurementWorker = async () => {
|
|
13676
|
-
const rpc = await create$
|
|
13730
|
+
const rpc = await create$d({
|
|
13677
13731
|
commandMap: {},
|
|
13678
13732
|
send
|
|
13679
13733
|
});
|
|
@@ -13683,6 +13737,11 @@ const initializeTextMeasurementWorker = async () => {
|
|
|
13683
13737
|
const listen = async () => {
|
|
13684
13738
|
registerCommands(commandMap);
|
|
13685
13739
|
await Promise.all([initializeRendererWorker(), initializeErrorWorker(), initializeExtensionHost(), initializeExtensionManagementWorker(), initializeTextMeasurementWorker(), initializeOpenerWorker()]);
|
|
13740
|
+
const dialogRpc = await create$d({
|
|
13741
|
+
commandMap: {},
|
|
13742
|
+
send: sendMessagePortToDialogWorker
|
|
13743
|
+
});
|
|
13744
|
+
set$h(dialogRpc);
|
|
13686
13745
|
};
|
|
13687
13746
|
|
|
13688
13747
|
const CodeGeneratorInput = 'CodeGeneratorInput';
|