@netless/appliance-plugin 1.1.43 → 1.1.44-beta.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.
Files changed (63) hide show
  1. package/dist/appliance-plugin.js +1 -1
  2. package/dist/appliance-plugin.mjs +12 -12
  3. package/dist/{bridge-GmRa7-tp.js → bridge-CskJoX5M.js} +1 -1
  4. package/dist/{bridge-D30E9dr6.mjs → bridge-rKHCYJ6m.mjs} +1 -1
  5. package/dist/bridge.js +1 -1
  6. package/dist/bridge.mjs +1 -1
  7. package/dist/collector/types.d.ts +3 -0
  8. package/dist/component/textEditor/types.d.ts +5 -0
  9. package/dist/core/mainEngine.d.ts +10 -2
  10. package/dist/core/mainThread/snapshotThread.d.ts +3 -2
  11. package/dist/core/mainThread/subLocalThread.d.ts +5 -2
  12. package/dist/core/mainThread/subServiceThread.d.ts +1 -0
  13. package/dist/core/mainThread/subTopThread.d.ts +2 -2
  14. package/dist/core/tools/arrow.d.ts +423 -1
  15. package/dist/core/tools/base.d.ts +444 -2
  16. package/dist/core/tools/ellipse.d.ts +423 -1
  17. package/dist/core/tools/eraser.d.ts +846 -2
  18. package/dist/core/tools/eraserFaces.d.ts +2 -0
  19. package/dist/core/tools/laserPen.d.ts +846 -2
  20. package/dist/core/tools/pencil.d.ts +848 -2
  21. package/dist/core/tools/pencilEraser.d.ts +1692 -4
  22. package/dist/core/tools/pencilEraserBitMap.d.ts +2115 -5
  23. package/dist/core/tools/polygon.d.ts +423 -1
  24. package/dist/core/tools/rectangle.d.ts +423 -1
  25. package/dist/core/tools/selector.d.ts +2121 -7
  26. package/dist/core/tools/speechBalloon.d.ts +423 -1
  27. package/dist/core/tools/star.d.ts +423 -1
  28. package/dist/core/tools/straight.d.ts +423 -1
  29. package/dist/core/tools/text.d.ts +3 -3
  30. package/dist/core/tools/utils.d.ts +2 -2
  31. package/dist/core/types.d.ts +9 -0
  32. package/dist/core/utils/affineMatrix.d.ts +33 -0
  33. package/dist/core/utils/fontFamily.d.ts +8 -0
  34. package/dist/core/utils/index.d.ts +2 -0
  35. package/dist/core/utils/selectorMatrix.d.ts +4 -0
  36. package/dist/core/utils/selectorRefresh.d.ts +8 -0
  37. package/dist/core/utils/textRaster.d.ts +2 -0
  38. package/dist/core/vNodeManager.d.ts +1 -1
  39. package/dist/core/worker/base.d.ts +1 -1
  40. package/dist/core/worker/fullWorkerLocal.d.ts +1 -0
  41. package/dist/core/worker/fullWorkerService.d.ts +2 -1
  42. package/dist/core/worker/simpleWorker.d.ts +1 -1
  43. package/dist/core/worker/subWorkerTopLayer.d.ts +2 -2
  44. package/dist/fullWorker.js +148 -147
  45. package/dist/index-B0SB7Efu.js +570 -0
  46. package/dist/index-BIVRfc_x.js +570 -0
  47. package/dist/{index-CQuJ6lL1.mjs → index-BbBSxLGe.mjs} +473 -442
  48. package/dist/index-Bzg5OMdP.js +1 -0
  49. package/dist/{index-Ct5ShjRI.js → index-C-tBYq0K.js} +1 -1
  50. package/dist/{index-CatWUcZt.mjs → index-Ca2t53R7.mjs} +1 -1
  51. package/dist/{index-rDe1jjPM.mjs → index-ConirzkM.mjs} +1 -1
  52. package/dist/index-CsNG_bzI.js +1 -0
  53. package/dist/{index-C-pO2InQ.mjs → index-DWevrjrE.mjs} +12001 -11664
  54. package/dist/{index-DYDy0dd5.mjs → index-LcCU1tMV.mjs} +473 -442
  55. package/dist/{index-DGdruTPt.js → index-ZMuKk-bl.js} +1 -1
  56. package/dist/{index-CrJWLjuD.mjs → index-_3yxgNoj.mjs} +19490 -19158
  57. package/dist/plugin/baseApplianceManager.d.ts +2 -2
  58. package/dist/subWorker.js +133 -132
  59. package/package.json +58 -56
  60. package/dist/index-B44Av4kp.js +0 -1
  61. package/dist/index-CKtpWZ9L.js +0 -1
  62. package/dist/index-DLzvL8jo.js +0 -570
  63. package/dist/index-LmgcnMI8.js +0 -570
package/dist/core/tools/pencilEraserBitMap.d.ts CHANGED
@@ -60,7 +60,429 @@ export declare class BitMapEraserShape extends BaseShapeTool {
60
60
  }): {
61
61
  workId: string;
62
62
  toolsType: EToolsKey;
63
- opt: import("./utils").ShapeOptions;
63
+ opt: {
64
+ matrix: import("../utils").AffineMatrix;
65
+ fontColor: string;
66
+ fontSize: number;
67
+ text: string;
68
+ textAlign: import("../../component/textEditor").TextAlignType;
69
+ verticalAlign: import("../../component/textEditor").VerticalAlignType;
70
+ lineHeight?: number;
71
+ fontFamily?: string;
72
+ bold?: import("../../component/textEditor").FontWeightType;
73
+ italic?: import("../../component/textEditor").FontStyleType;
74
+ fontBgColor?: string;
75
+ underline?: boolean;
76
+ lineThrough?: boolean;
77
+ boxPoint?: [number, number];
78
+ boxSize?: [number, number];
79
+ workState?: import("..").EventWorkState;
80
+ uid?: string;
81
+ isOpacity?: boolean;
82
+ strokeColor?: string;
83
+ fillColor?: string;
84
+ vertex?: string;
85
+ fragment?: string;
86
+ syncUnitTime?: number;
87
+ zIndex?: number;
88
+ scale?: [number, number];
89
+ rotate?: number;
90
+ thickness?: number;
91
+ textOpt?: import("../../component/textEditor").TextOptions;
92
+ translate?: [number, number];
93
+ eraserlines?: SerializerEraserLines;
94
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
95
+ doingLines?: SerializerEraserLines;
96
+ lineCap?: "square" | "round";
97
+ lineDash?: [number, number];
98
+ } | {
99
+ matrix: import("../utils").AffineMatrix;
100
+ thickness: number;
101
+ strokeColor: string;
102
+ strokeType: import("../..").EStrokeType;
103
+ autoShape?: boolean;
104
+ previewLocalOnly?: boolean;
105
+ isOpacity?: boolean;
106
+ fontColor?: string;
107
+ fontBgColor?: string;
108
+ fillColor?: string;
109
+ vertex?: string;
110
+ fragment?: string;
111
+ syncUnitTime?: number;
112
+ zIndex?: number;
113
+ scale?: [number, number];
114
+ rotate?: number;
115
+ textOpt?: import("../../component/textEditor").TextOptions;
116
+ translate?: [number, number];
117
+ eraserlines?: SerializerEraserLines;
118
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
119
+ doingLines?: SerializerEraserLines;
120
+ lineCap?: "square" | "round";
121
+ lineDash?: [number, number];
122
+ } | {
123
+ matrix: import("../utils").AffineMatrix;
124
+ thickness: number;
125
+ duration: number;
126
+ strokeColor: string;
127
+ strokeType: Omit<import("../..").EStrokeType, "Stroke">;
128
+ isOpacity?: boolean;
129
+ fontColor?: string;
130
+ fontBgColor?: string;
131
+ fillColor?: string;
132
+ vertex?: string;
133
+ fragment?: string;
134
+ syncUnitTime?: number;
135
+ zIndex?: number;
136
+ scale?: [number, number];
137
+ rotate?: number;
138
+ textOpt?: import("../../component/textEditor").TextOptions;
139
+ translate?: [number, number];
140
+ eraserlines?: SerializerEraserLines;
141
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
142
+ doingLines?: SerializerEraserLines;
143
+ lineCap?: "square" | "round";
144
+ lineDash?: [number, number];
145
+ } | {
146
+ matrix: import("../utils").AffineMatrix;
147
+ thickness: number;
148
+ isOpacity?: boolean;
149
+ fontColor?: string;
150
+ fontBgColor?: string;
151
+ strokeColor?: string;
152
+ fillColor?: string;
153
+ vertex?: string;
154
+ fragment?: string;
155
+ syncUnitTime?: number;
156
+ zIndex?: number;
157
+ scale?: [number, number];
158
+ rotate?: number;
159
+ textOpt?: import("../../component/textEditor").TextOptions;
160
+ translate?: [number, number];
161
+ eraserlines?: SerializerEraserLines;
162
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
163
+ doingLines?: SerializerEraserLines;
164
+ lineCap?: "square" | "round";
165
+ lineDash?: [number, number];
166
+ } | {
167
+ matrix: import("../utils").AffineMatrix;
168
+ thickness: number;
169
+ maxImageWidth?: number;
170
+ maxImageHeight?: number;
171
+ removeOnDone?: boolean;
172
+ isOpacity?: boolean;
173
+ fontColor?: string;
174
+ fontBgColor?: string;
175
+ strokeColor?: string;
176
+ fillColor?: string;
177
+ vertex?: string;
178
+ fragment?: string;
179
+ syncUnitTime?: number;
180
+ zIndex?: number;
181
+ scale?: [number, number];
182
+ rotate?: number;
183
+ textOpt?: import("../../component/textEditor").TextOptions;
184
+ translate?: [number, number];
185
+ eraserlines?: SerializerEraserLines;
186
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
187
+ doingLines?: SerializerEraserLines;
188
+ lineCap?: "square" | "round";
189
+ lineDash?: [number, number];
190
+ } | {
191
+ matrix: import("../utils").AffineMatrix;
192
+ thickness: number;
193
+ isOpacity?: boolean;
194
+ fontColor?: string;
195
+ fontBgColor?: string;
196
+ strokeColor?: string;
197
+ fillColor?: string;
198
+ vertex?: string;
199
+ fragment?: string;
200
+ syncUnitTime?: number;
201
+ zIndex?: number;
202
+ scale?: [number, number];
203
+ rotate?: number;
204
+ textOpt?: import("../../component/textEditor").TextOptions;
205
+ translate?: [number, number];
206
+ eraserlines?: SerializerEraserLines;
207
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
208
+ doingLines?: SerializerEraserLines;
209
+ lineCap?: "square" | "round";
210
+ lineDash?: [number, number];
211
+ } | {
212
+ matrix: import("../utils").AffineMatrix;
213
+ thickness: number;
214
+ vertices: number;
215
+ innerVerticeStep: number;
216
+ innerRatio: number;
217
+ strokeColor: string;
218
+ fillColor: string;
219
+ strokeType: import("../..").EStrokeType;
220
+ isOpacity?: boolean;
221
+ fontColor?: string;
222
+ fontBgColor?: string;
223
+ vertex?: string;
224
+ fragment?: string;
225
+ syncUnitTime?: number;
226
+ zIndex?: number;
227
+ scale?: [number, number];
228
+ rotate?: number;
229
+ textOpt?: import("../../component/textEditor").TextOptions;
230
+ translate?: [number, number];
231
+ eraserlines?: SerializerEraserLines;
232
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
233
+ doingLines?: SerializerEraserLines;
234
+ lineCap?: "square" | "round";
235
+ lineDash?: [number, number];
236
+ } | {
237
+ matrix: import("../utils").AffineMatrix;
238
+ isOpacity?: boolean;
239
+ fontColor?: string;
240
+ fontBgColor?: string;
241
+ strokeColor?: string;
242
+ fillColor?: string;
243
+ vertex?: string;
244
+ fragment?: string;
245
+ syncUnitTime?: number;
246
+ zIndex?: number;
247
+ scale?: [number, number];
248
+ rotate?: number;
249
+ thickness?: number;
250
+ textOpt?: import("../../component/textEditor").TextOptions;
251
+ translate?: [number, number];
252
+ eraserlines?: SerializerEraserLines;
253
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
254
+ doingLines?: SerializerEraserLines;
255
+ lineCap?: "square" | "round";
256
+ lineDash?: [number, number];
257
+ } | {
258
+ matrix: import("../utils").AffineMatrix;
259
+ thickness: number;
260
+ strokeColor: string;
261
+ strokeType: import("../..").EStrokeType;
262
+ isOpacity?: boolean;
263
+ fontColor?: string;
264
+ fontBgColor?: string;
265
+ fillColor?: string;
266
+ vertex?: string;
267
+ fragment?: string;
268
+ syncUnitTime?: number;
269
+ zIndex?: number;
270
+ scale?: [number, number];
271
+ rotate?: number;
272
+ textOpt?: import("../../component/textEditor").TextOptions;
273
+ translate?: [number, number];
274
+ eraserlines?: SerializerEraserLines;
275
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
276
+ doingLines?: SerializerEraserLines;
277
+ lineCap?: "square" | "round";
278
+ lineDash?: [number, number];
279
+ } | {
280
+ matrix: import("../utils").AffineMatrix;
281
+ thickness: number;
282
+ strokeColor: string;
283
+ fillColor: string;
284
+ strokeType: import("../..").EStrokeType;
285
+ isOpacity?: boolean;
286
+ fontColor?: string;
287
+ fontBgColor?: string;
288
+ vertex?: string;
289
+ fragment?: string;
290
+ syncUnitTime?: number;
291
+ zIndex?: number;
292
+ scale?: [number, number];
293
+ rotate?: number;
294
+ textOpt?: import("../../component/textEditor").TextOptions;
295
+ translate?: [number, number];
296
+ eraserlines?: SerializerEraserLines;
297
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
298
+ doingLines?: SerializerEraserLines;
299
+ lineCap?: "square" | "round";
300
+ lineDash?: [number, number];
301
+ } | {
302
+ matrix: import("../utils").AffineMatrix;
303
+ thickness: number;
304
+ strokeColor: string;
305
+ fillColor: string;
306
+ strokeType: import("../..").EStrokeType;
307
+ isOpacity?: boolean;
308
+ fontColor?: string;
309
+ fontBgColor?: string;
310
+ vertex?: string;
311
+ fragment?: string;
312
+ syncUnitTime?: number;
313
+ zIndex?: number;
314
+ scale?: [number, number];
315
+ rotate?: number;
316
+ textOpt?: import("../../component/textEditor").TextOptions;
317
+ translate?: [number, number];
318
+ eraserlines?: SerializerEraserLines;
319
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
320
+ doingLines?: SerializerEraserLines;
321
+ lineCap?: "square" | "round";
322
+ lineDash?: [number, number];
323
+ } | {
324
+ matrix: import("../utils").AffineMatrix;
325
+ thickness: number;
326
+ vertices: number;
327
+ strokeColor: string;
328
+ fillColor: string;
329
+ strokeType: import("../..").EStrokeType;
330
+ isOpacity?: boolean;
331
+ fontColor?: string;
332
+ fontBgColor?: string;
333
+ vertex?: string;
334
+ fragment?: string;
335
+ syncUnitTime?: number;
336
+ zIndex?: number;
337
+ scale?: [number, number];
338
+ rotate?: number;
339
+ textOpt?: import("../../component/textEditor").TextOptions;
340
+ translate?: [number, number];
341
+ eraserlines?: SerializerEraserLines;
342
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
343
+ doingLines?: SerializerEraserLines;
344
+ lineCap?: "square" | "round";
345
+ lineDash?: [number, number];
346
+ } | {
347
+ matrix: import("../utils").AffineMatrix;
348
+ thickness: number;
349
+ strokeColor: string;
350
+ strokeType: import("../..").EStrokeType;
351
+ isOpacity?: boolean;
352
+ fontColor?: string;
353
+ fontBgColor?: string;
354
+ fillColor?: string;
355
+ vertex?: string;
356
+ fragment?: string;
357
+ syncUnitTime?: number;
358
+ zIndex?: number;
359
+ scale?: [number, number];
360
+ rotate?: number;
361
+ textOpt?: import("../../component/textEditor").TextOptions;
362
+ translate?: [number, number];
363
+ eraserlines?: SerializerEraserLines;
364
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
365
+ doingLines?: SerializerEraserLines;
366
+ lineCap?: "square" | "round";
367
+ lineDash?: [number, number];
368
+ } | {
369
+ matrix: import("../utils").AffineMatrix;
370
+ thickness: number;
371
+ placement: import("../..").SpeechBalloonPlacement;
372
+ strokeColor: string;
373
+ fillColor: string;
374
+ strokeType: import("../..").EStrokeType;
375
+ isOpacity?: boolean;
376
+ fontColor?: string;
377
+ fontBgColor?: string;
378
+ vertex?: string;
379
+ fragment?: string;
380
+ syncUnitTime?: number;
381
+ zIndex?: number;
382
+ scale?: [number, number];
383
+ rotate?: number;
384
+ textOpt?: import("../../component/textEditor").TextOptions;
385
+ translate?: [number, number];
386
+ eraserlines?: SerializerEraserLines;
387
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
388
+ doingLines?: SerializerEraserLines;
389
+ lineCap?: "square" | "round";
390
+ lineDash?: [number, number];
391
+ } | {
392
+ matrix: import("../utils").AffineMatrix;
393
+ src: string;
394
+ type: import("..").EImageType;
395
+ uuid: string;
396
+ centerX: number;
397
+ centerY: number;
398
+ width: number;
399
+ height: number;
400
+ locked: boolean;
401
+ uniformScale?: boolean;
402
+ crossOrigin?: boolean | string;
403
+ isOpacity?: boolean;
404
+ fontColor?: string;
405
+ fontBgColor?: string;
406
+ strokeColor?: string;
407
+ fillColor?: string;
408
+ vertex?: string;
409
+ fragment?: string;
410
+ syncUnitTime?: number;
411
+ zIndex?: number;
412
+ scale?: [number, number];
413
+ rotate?: number;
414
+ thickness?: number;
415
+ textOpt?: import("../../component/textEditor").TextOptions;
416
+ translate?: [number, number];
417
+ eraserlines?: SerializerEraserLines;
418
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
419
+ doingLines?: SerializerEraserLines;
420
+ lineCap?: "square" | "round";
421
+ lineDash?: [number, number];
422
+ } | {
423
+ matrix: import("../utils").AffineMatrix;
424
+ type: import("..").ESVGType.url;
425
+ src: string;
426
+ crossOrigin: boolean | string;
427
+ uuid: string;
428
+ centerX: number;
429
+ centerY: number;
430
+ width: number;
431
+ height: number;
432
+ locked: boolean;
433
+ uniformScale: boolean;
434
+ state?: unknown;
435
+ isOpacity?: boolean;
436
+ fontColor?: string;
437
+ fontBgColor?: string;
438
+ strokeColor?: string;
439
+ fillColor?: string;
440
+ vertex?: string;
441
+ fragment?: string;
442
+ syncUnitTime?: number;
443
+ zIndex?: number;
444
+ scale?: [number, number];
445
+ rotate?: number;
446
+ thickness?: number;
447
+ textOpt?: import("../../component/textEditor").TextOptions;
448
+ translate?: [number, number];
449
+ eraserlines?: SerializerEraserLines;
450
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
451
+ doingLines?: SerializerEraserLines;
452
+ lineCap?: "square" | "round";
453
+ lineDash?: [number, number];
454
+ } | {
455
+ matrix: import("../utils").AffineMatrix;
456
+ type: import("..").ESVGType.markmap;
457
+ data: string;
458
+ uuid: string;
459
+ centerX: number;
460
+ centerY: number;
461
+ width: number;
462
+ height: number;
463
+ locked: boolean;
464
+ uniformScale: boolean;
465
+ state?: unknown;
466
+ isOpacity?: boolean;
467
+ fontColor?: string;
468
+ fontBgColor?: string;
469
+ strokeColor?: string;
470
+ fillColor?: string;
471
+ vertex?: string;
472
+ fragment?: string;
473
+ syncUnitTime?: number;
474
+ zIndex?: number;
475
+ scale?: [number, number];
476
+ rotate?: number;
477
+ thickness?: number;
478
+ textOpt?: import("../../component/textEditor").TextOptions;
479
+ translate?: [number, number];
480
+ eraserlines?: SerializerEraserLines;
481
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
482
+ doingLines?: SerializerEraserLines;
483
+ lineCap?: "square" | "round";
484
+ lineDash?: [number, number];
485
+ };
64
486
  type: EPostMessageType;
65
487
  };
66
488
  consumeAll(props: {
@@ -68,7 +490,429 @@ export declare class BitMapEraserShape extends BaseShapeTool {
68
490
  }): Promise<{
69
491
  workId: string;
70
492
  toolsType: EToolsKey;
71
- opt: import("./utils").ShapeOptions;
493
+ opt: {
494
+ matrix: import("../utils").AffineMatrix;
495
+ fontColor: string;
496
+ fontSize: number;
497
+ text: string;
498
+ textAlign: import("../../component/textEditor").TextAlignType;
499
+ verticalAlign: import("../../component/textEditor").VerticalAlignType;
500
+ lineHeight?: number;
501
+ fontFamily?: string;
502
+ bold?: import("../../component/textEditor").FontWeightType;
503
+ italic?: import("../../component/textEditor").FontStyleType;
504
+ fontBgColor?: string;
505
+ underline?: boolean;
506
+ lineThrough?: boolean;
507
+ boxPoint?: [number, number];
508
+ boxSize?: [number, number];
509
+ workState?: import("..").EventWorkState;
510
+ uid?: string;
511
+ isOpacity?: boolean;
512
+ strokeColor?: string;
513
+ fillColor?: string;
514
+ vertex?: string;
515
+ fragment?: string;
516
+ syncUnitTime?: number;
517
+ zIndex?: number;
518
+ scale?: [number, number];
519
+ rotate?: number;
520
+ thickness?: number;
521
+ textOpt?: import("../../component/textEditor").TextOptions;
522
+ translate?: [number, number];
523
+ eraserlines?: SerializerEraserLines;
524
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
525
+ doingLines?: SerializerEraserLines;
526
+ lineCap?: "square" | "round";
527
+ lineDash?: [number, number];
528
+ } | {
529
+ matrix: import("../utils").AffineMatrix;
530
+ thickness: number;
531
+ strokeColor: string;
532
+ strokeType: import("../..").EStrokeType;
533
+ autoShape?: boolean;
534
+ previewLocalOnly?: boolean;
535
+ isOpacity?: boolean;
536
+ fontColor?: string;
537
+ fontBgColor?: string;
538
+ fillColor?: string;
539
+ vertex?: string;
540
+ fragment?: string;
541
+ syncUnitTime?: number;
542
+ zIndex?: number;
543
+ scale?: [number, number];
544
+ rotate?: number;
545
+ textOpt?: import("../../component/textEditor").TextOptions;
546
+ translate?: [number, number];
547
+ eraserlines?: SerializerEraserLines;
548
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
549
+ doingLines?: SerializerEraserLines;
550
+ lineCap?: "square" | "round";
551
+ lineDash?: [number, number];
552
+ } | {
553
+ matrix: import("../utils").AffineMatrix;
554
+ thickness: number;
555
+ duration: number;
556
+ strokeColor: string;
557
+ strokeType: Omit<import("../..").EStrokeType, "Stroke">;
558
+ isOpacity?: boolean;
559
+ fontColor?: string;
560
+ fontBgColor?: string;
561
+ fillColor?: string;
562
+ vertex?: string;
563
+ fragment?: string;
564
+ syncUnitTime?: number;
565
+ zIndex?: number;
566
+ scale?: [number, number];
567
+ rotate?: number;
568
+ textOpt?: import("../../component/textEditor").TextOptions;
569
+ translate?: [number, number];
570
+ eraserlines?: SerializerEraserLines;
571
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
572
+ doingLines?: SerializerEraserLines;
573
+ lineCap?: "square" | "round";
574
+ lineDash?: [number, number];
575
+ } | {
576
+ matrix: import("../utils").AffineMatrix;
577
+ thickness: number;
578
+ isOpacity?: boolean;
579
+ fontColor?: string;
580
+ fontBgColor?: string;
581
+ strokeColor?: string;
582
+ fillColor?: string;
583
+ vertex?: string;
584
+ fragment?: string;
585
+ syncUnitTime?: number;
586
+ zIndex?: number;
587
+ scale?: [number, number];
588
+ rotate?: number;
589
+ textOpt?: import("../../component/textEditor").TextOptions;
590
+ translate?: [number, number];
591
+ eraserlines?: SerializerEraserLines;
592
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
593
+ doingLines?: SerializerEraserLines;
594
+ lineCap?: "square" | "round";
595
+ lineDash?: [number, number];
596
+ } | {
597
+ matrix: import("../utils").AffineMatrix;
598
+ thickness: number;
599
+ maxImageWidth?: number;
600
+ maxImageHeight?: number;
601
+ removeOnDone?: boolean;
602
+ isOpacity?: boolean;
603
+ fontColor?: string;
604
+ fontBgColor?: string;
605
+ strokeColor?: string;
606
+ fillColor?: string;
607
+ vertex?: string;
608
+ fragment?: string;
609
+ syncUnitTime?: number;
610
+ zIndex?: number;
611
+ scale?: [number, number];
612
+ rotate?: number;
613
+ textOpt?: import("../../component/textEditor").TextOptions;
614
+ translate?: [number, number];
615
+ eraserlines?: SerializerEraserLines;
616
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
617
+ doingLines?: SerializerEraserLines;
618
+ lineCap?: "square" | "round";
619
+ lineDash?: [number, number];
620
+ } | {
621
+ matrix: import("../utils").AffineMatrix;
622
+ thickness: number;
623
+ isOpacity?: boolean;
624
+ fontColor?: string;
625
+ fontBgColor?: string;
626
+ strokeColor?: string;
627
+ fillColor?: string;
628
+ vertex?: string;
629
+ fragment?: string;
630
+ syncUnitTime?: number;
631
+ zIndex?: number;
632
+ scale?: [number, number];
633
+ rotate?: number;
634
+ textOpt?: import("../../component/textEditor").TextOptions;
635
+ translate?: [number, number];
636
+ eraserlines?: SerializerEraserLines;
637
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
638
+ doingLines?: SerializerEraserLines;
639
+ lineCap?: "square" | "round";
640
+ lineDash?: [number, number];
641
+ } | {
642
+ matrix: import("../utils").AffineMatrix;
643
+ thickness: number;
644
+ vertices: number;
645
+ innerVerticeStep: number;
646
+ innerRatio: number;
647
+ strokeColor: string;
648
+ fillColor: string;
649
+ strokeType: import("../..").EStrokeType;
650
+ isOpacity?: boolean;
651
+ fontColor?: string;
652
+ fontBgColor?: string;
653
+ vertex?: string;
654
+ fragment?: string;
655
+ syncUnitTime?: number;
656
+ zIndex?: number;
657
+ scale?: [number, number];
658
+ rotate?: number;
659
+ textOpt?: import("../../component/textEditor").TextOptions;
660
+ translate?: [number, number];
661
+ eraserlines?: SerializerEraserLines;
662
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
663
+ doingLines?: SerializerEraserLines;
664
+ lineCap?: "square" | "round";
665
+ lineDash?: [number, number];
666
+ } | {
667
+ matrix: import("../utils").AffineMatrix;
668
+ isOpacity?: boolean;
669
+ fontColor?: string;
670
+ fontBgColor?: string;
671
+ strokeColor?: string;
672
+ fillColor?: string;
673
+ vertex?: string;
674
+ fragment?: string;
675
+ syncUnitTime?: number;
676
+ zIndex?: number;
677
+ scale?: [number, number];
678
+ rotate?: number;
679
+ thickness?: number;
680
+ textOpt?: import("../../component/textEditor").TextOptions;
681
+ translate?: [number, number];
682
+ eraserlines?: SerializerEraserLines;
683
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
684
+ doingLines?: SerializerEraserLines;
685
+ lineCap?: "square" | "round";
686
+ lineDash?: [number, number];
687
+ } | {
688
+ matrix: import("../utils").AffineMatrix;
689
+ thickness: number;
690
+ strokeColor: string;
691
+ strokeType: import("../..").EStrokeType;
692
+ isOpacity?: boolean;
693
+ fontColor?: string;
694
+ fontBgColor?: string;
695
+ fillColor?: string;
696
+ vertex?: string;
697
+ fragment?: string;
698
+ syncUnitTime?: number;
699
+ zIndex?: number;
700
+ scale?: [number, number];
701
+ rotate?: number;
702
+ textOpt?: import("../../component/textEditor").TextOptions;
703
+ translate?: [number, number];
704
+ eraserlines?: SerializerEraserLines;
705
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
706
+ doingLines?: SerializerEraserLines;
707
+ lineCap?: "square" | "round";
708
+ lineDash?: [number, number];
709
+ } | {
710
+ matrix: import("../utils").AffineMatrix;
711
+ thickness: number;
712
+ strokeColor: string;
713
+ fillColor: string;
714
+ strokeType: import("../..").EStrokeType;
715
+ isOpacity?: boolean;
716
+ fontColor?: string;
717
+ fontBgColor?: string;
718
+ vertex?: string;
719
+ fragment?: string;
720
+ syncUnitTime?: number;
721
+ zIndex?: number;
722
+ scale?: [number, number];
723
+ rotate?: number;
724
+ textOpt?: import("../../component/textEditor").TextOptions;
725
+ translate?: [number, number];
726
+ eraserlines?: SerializerEraserLines;
727
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
728
+ doingLines?: SerializerEraserLines;
729
+ lineCap?: "square" | "round";
730
+ lineDash?: [number, number];
731
+ } | {
732
+ matrix: import("../utils").AffineMatrix;
733
+ thickness: number;
734
+ strokeColor: string;
735
+ fillColor: string;
736
+ strokeType: import("../..").EStrokeType;
737
+ isOpacity?: boolean;
738
+ fontColor?: string;
739
+ fontBgColor?: string;
740
+ vertex?: string;
741
+ fragment?: string;
742
+ syncUnitTime?: number;
743
+ zIndex?: number;
744
+ scale?: [number, number];
745
+ rotate?: number;
746
+ textOpt?: import("../../component/textEditor").TextOptions;
747
+ translate?: [number, number];
748
+ eraserlines?: SerializerEraserLines;
749
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
750
+ doingLines?: SerializerEraserLines;
751
+ lineCap?: "square" | "round";
752
+ lineDash?: [number, number];
753
+ } | {
754
+ matrix: import("../utils").AffineMatrix;
755
+ thickness: number;
756
+ vertices: number;
757
+ strokeColor: string;
758
+ fillColor: string;
759
+ strokeType: import("../..").EStrokeType;
760
+ isOpacity?: boolean;
761
+ fontColor?: string;
762
+ fontBgColor?: string;
763
+ vertex?: string;
764
+ fragment?: string;
765
+ syncUnitTime?: number;
766
+ zIndex?: number;
767
+ scale?: [number, number];
768
+ rotate?: number;
769
+ textOpt?: import("../../component/textEditor").TextOptions;
770
+ translate?: [number, number];
771
+ eraserlines?: SerializerEraserLines;
772
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
773
+ doingLines?: SerializerEraserLines;
774
+ lineCap?: "square" | "round";
775
+ lineDash?: [number, number];
776
+ } | {
777
+ matrix: import("../utils").AffineMatrix;
778
+ thickness: number;
779
+ strokeColor: string;
780
+ strokeType: import("../..").EStrokeType;
781
+ isOpacity?: boolean;
782
+ fontColor?: string;
783
+ fontBgColor?: string;
784
+ fillColor?: string;
785
+ vertex?: string;
786
+ fragment?: string;
787
+ syncUnitTime?: number;
788
+ zIndex?: number;
789
+ scale?: [number, number];
790
+ rotate?: number;
791
+ textOpt?: import("../../component/textEditor").TextOptions;
792
+ translate?: [number, number];
793
+ eraserlines?: SerializerEraserLines;
794
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
795
+ doingLines?: SerializerEraserLines;
796
+ lineCap?: "square" | "round";
797
+ lineDash?: [number, number];
798
+ } | {
799
+ matrix: import("../utils").AffineMatrix;
800
+ thickness: number;
801
+ placement: import("../..").SpeechBalloonPlacement;
802
+ strokeColor: string;
803
+ fillColor: string;
804
+ strokeType: import("../..").EStrokeType;
805
+ isOpacity?: boolean;
806
+ fontColor?: string;
807
+ fontBgColor?: string;
808
+ vertex?: string;
809
+ fragment?: string;
810
+ syncUnitTime?: number;
811
+ zIndex?: number;
812
+ scale?: [number, number];
813
+ rotate?: number;
814
+ textOpt?: import("../../component/textEditor").TextOptions;
815
+ translate?: [number, number];
816
+ eraserlines?: SerializerEraserLines;
817
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
818
+ doingLines?: SerializerEraserLines;
819
+ lineCap?: "square" | "round";
820
+ lineDash?: [number, number];
821
+ } | {
822
+ matrix: import("../utils").AffineMatrix;
823
+ src: string;
824
+ type: import("..").EImageType;
825
+ uuid: string;
826
+ centerX: number;
827
+ centerY: number;
828
+ width: number;
829
+ height: number;
830
+ locked: boolean;
831
+ uniformScale?: boolean;
832
+ crossOrigin?: boolean | string;
833
+ isOpacity?: boolean;
834
+ fontColor?: string;
835
+ fontBgColor?: string;
836
+ strokeColor?: string;
837
+ fillColor?: string;
838
+ vertex?: string;
839
+ fragment?: string;
840
+ syncUnitTime?: number;
841
+ zIndex?: number;
842
+ scale?: [number, number];
843
+ rotate?: number;
844
+ thickness?: number;
845
+ textOpt?: import("../../component/textEditor").TextOptions;
846
+ translate?: [number, number];
847
+ eraserlines?: SerializerEraserLines;
848
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
849
+ doingLines?: SerializerEraserLines;
850
+ lineCap?: "square" | "round";
851
+ lineDash?: [number, number];
852
+ } | {
853
+ matrix: import("../utils").AffineMatrix;
854
+ type: import("..").ESVGType.url;
855
+ src: string;
856
+ crossOrigin: boolean | string;
857
+ uuid: string;
858
+ centerX: number;
859
+ centerY: number;
860
+ width: number;
861
+ height: number;
862
+ locked: boolean;
863
+ uniformScale: boolean;
864
+ state?: unknown;
865
+ isOpacity?: boolean;
866
+ fontColor?: string;
867
+ fontBgColor?: string;
868
+ strokeColor?: string;
869
+ fillColor?: string;
870
+ vertex?: string;
871
+ fragment?: string;
872
+ syncUnitTime?: number;
873
+ zIndex?: number;
874
+ scale?: [number, number];
875
+ rotate?: number;
876
+ thickness?: number;
877
+ textOpt?: import("../../component/textEditor").TextOptions;
878
+ translate?: [number, number];
879
+ eraserlines?: SerializerEraserLines;
880
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
881
+ doingLines?: SerializerEraserLines;
882
+ lineCap?: "square" | "round";
883
+ lineDash?: [number, number];
884
+ } | {
885
+ matrix: import("../utils").AffineMatrix;
886
+ type: import("..").ESVGType.markmap;
887
+ data: string;
888
+ uuid: string;
889
+ centerX: number;
890
+ centerY: number;
891
+ width: number;
892
+ height: number;
893
+ locked: boolean;
894
+ uniformScale: boolean;
895
+ state?: unknown;
896
+ isOpacity?: boolean;
897
+ fontColor?: string;
898
+ fontBgColor?: string;
899
+ strokeColor?: string;
900
+ fillColor?: string;
901
+ vertex?: string;
902
+ fragment?: string;
903
+ syncUnitTime?: number;
904
+ zIndex?: number;
905
+ scale?: [number, number];
906
+ rotate?: number;
907
+ thickness?: number;
908
+ textOpt?: import("../../component/textEditor").TextOptions;
909
+ translate?: [number, number];
910
+ eraserlines?: SerializerEraserLines;
911
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
912
+ doingLines?: SerializerEraserLines;
913
+ lineCap?: "square" | "round";
914
+ lineDash?: [number, number];
915
+ };
72
916
  type: EPostMessageType;
73
917
  } | {
74
918
  rect: IRectType | undefined;
@@ -76,7 +920,429 @@ export declare class BitMapEraserShape extends BaseShapeTool {
76
920
  eraseTxnCommitStatus: "applied";
77
921
  workId: string;
78
922
  toolsType: EToolsKey;
79
- opt: import("./utils").ShapeOptions;
923
+ opt: {
924
+ matrix: import("../utils").AffineMatrix;
925
+ fontColor: string;
926
+ fontSize: number;
927
+ text: string;
928
+ textAlign: import("../../component/textEditor").TextAlignType;
929
+ verticalAlign: import("../../component/textEditor").VerticalAlignType;
930
+ lineHeight?: number;
931
+ fontFamily?: string;
932
+ bold?: import("../../component/textEditor").FontWeightType;
933
+ italic?: import("../../component/textEditor").FontStyleType;
934
+ fontBgColor?: string;
935
+ underline?: boolean;
936
+ lineThrough?: boolean;
937
+ boxPoint?: [number, number];
938
+ boxSize?: [number, number];
939
+ workState?: import("..").EventWorkState;
940
+ uid?: string;
941
+ isOpacity?: boolean;
942
+ strokeColor?: string;
943
+ fillColor?: string;
944
+ vertex?: string;
945
+ fragment?: string;
946
+ syncUnitTime?: number;
947
+ zIndex?: number;
948
+ scale?: [number, number];
949
+ rotate?: number;
950
+ thickness?: number;
951
+ textOpt?: import("../../component/textEditor").TextOptions;
952
+ translate?: [number, number];
953
+ eraserlines?: SerializerEraserLines;
954
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
955
+ doingLines?: SerializerEraserLines;
956
+ lineCap?: "square" | "round";
957
+ lineDash?: [number, number];
958
+ } | {
959
+ matrix: import("../utils").AffineMatrix;
960
+ thickness: number;
961
+ strokeColor: string;
962
+ strokeType: import("../..").EStrokeType;
963
+ autoShape?: boolean;
964
+ previewLocalOnly?: boolean;
965
+ isOpacity?: boolean;
966
+ fontColor?: string;
967
+ fontBgColor?: string;
968
+ fillColor?: string;
969
+ vertex?: string;
970
+ fragment?: string;
971
+ syncUnitTime?: number;
972
+ zIndex?: number;
973
+ scale?: [number, number];
974
+ rotate?: number;
975
+ textOpt?: import("../../component/textEditor").TextOptions;
976
+ translate?: [number, number];
977
+ eraserlines?: SerializerEraserLines;
978
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
979
+ doingLines?: SerializerEraserLines;
980
+ lineCap?: "square" | "round";
981
+ lineDash?: [number, number];
982
+ } | {
983
+ matrix: import("../utils").AffineMatrix;
984
+ thickness: number;
985
+ duration: number;
986
+ strokeColor: string;
987
+ strokeType: Omit<import("../..").EStrokeType, "Stroke">;
988
+ isOpacity?: boolean;
989
+ fontColor?: string;
990
+ fontBgColor?: string;
991
+ fillColor?: string;
992
+ vertex?: string;
993
+ fragment?: string;
994
+ syncUnitTime?: number;
995
+ zIndex?: number;
996
+ scale?: [number, number];
997
+ rotate?: number;
998
+ textOpt?: import("../../component/textEditor").TextOptions;
999
+ translate?: [number, number];
1000
+ eraserlines?: SerializerEraserLines;
1001
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1002
+ doingLines?: SerializerEraserLines;
1003
+ lineCap?: "square" | "round";
1004
+ lineDash?: [number, number];
1005
+ } | {
1006
+ matrix: import("../utils").AffineMatrix;
1007
+ thickness: number;
1008
+ isOpacity?: boolean;
1009
+ fontColor?: string;
1010
+ fontBgColor?: string;
1011
+ strokeColor?: string;
1012
+ fillColor?: string;
1013
+ vertex?: string;
1014
+ fragment?: string;
1015
+ syncUnitTime?: number;
1016
+ zIndex?: number;
1017
+ scale?: [number, number];
1018
+ rotate?: number;
1019
+ textOpt?: import("../../component/textEditor").TextOptions;
1020
+ translate?: [number, number];
1021
+ eraserlines?: SerializerEraserLines;
1022
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1023
+ doingLines?: SerializerEraserLines;
1024
+ lineCap?: "square" | "round";
1025
+ lineDash?: [number, number];
1026
+ } | {
1027
+ matrix: import("../utils").AffineMatrix;
1028
+ thickness: number;
1029
+ maxImageWidth?: number;
1030
+ maxImageHeight?: number;
1031
+ removeOnDone?: boolean;
1032
+ isOpacity?: boolean;
1033
+ fontColor?: string;
1034
+ fontBgColor?: string;
1035
+ strokeColor?: string;
1036
+ fillColor?: string;
1037
+ vertex?: string;
1038
+ fragment?: string;
1039
+ syncUnitTime?: number;
1040
+ zIndex?: number;
1041
+ scale?: [number, number];
1042
+ rotate?: number;
1043
+ textOpt?: import("../../component/textEditor").TextOptions;
1044
+ translate?: [number, number];
1045
+ eraserlines?: SerializerEraserLines;
1046
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1047
+ doingLines?: SerializerEraserLines;
1048
+ lineCap?: "square" | "round";
1049
+ lineDash?: [number, number];
1050
+ } | {
1051
+ matrix: import("../utils").AffineMatrix;
1052
+ thickness: number;
1053
+ isOpacity?: boolean;
1054
+ fontColor?: string;
1055
+ fontBgColor?: string;
1056
+ strokeColor?: string;
1057
+ fillColor?: string;
1058
+ vertex?: string;
1059
+ fragment?: string;
1060
+ syncUnitTime?: number;
1061
+ zIndex?: number;
1062
+ scale?: [number, number];
1063
+ rotate?: number;
1064
+ textOpt?: import("../../component/textEditor").TextOptions;
1065
+ translate?: [number, number];
1066
+ eraserlines?: SerializerEraserLines;
1067
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1068
+ doingLines?: SerializerEraserLines;
1069
+ lineCap?: "square" | "round";
1070
+ lineDash?: [number, number];
1071
+ } | {
1072
+ matrix: import("../utils").AffineMatrix;
1073
+ thickness: number;
1074
+ vertices: number;
1075
+ innerVerticeStep: number;
1076
+ innerRatio: number;
1077
+ strokeColor: string;
1078
+ fillColor: string;
1079
+ strokeType: import("../..").EStrokeType;
1080
+ isOpacity?: boolean;
1081
+ fontColor?: string;
1082
+ fontBgColor?: string;
1083
+ vertex?: string;
1084
+ fragment?: string;
1085
+ syncUnitTime?: number;
1086
+ zIndex?: number;
1087
+ scale?: [number, number];
1088
+ rotate?: number;
1089
+ textOpt?: import("../../component/textEditor").TextOptions;
1090
+ translate?: [number, number];
1091
+ eraserlines?: SerializerEraserLines;
1092
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1093
+ doingLines?: SerializerEraserLines;
1094
+ lineCap?: "square" | "round";
1095
+ lineDash?: [number, number];
1096
+ } | {
1097
+ matrix: import("../utils").AffineMatrix;
1098
+ isOpacity?: boolean;
1099
+ fontColor?: string;
1100
+ fontBgColor?: string;
1101
+ strokeColor?: string;
1102
+ fillColor?: string;
1103
+ vertex?: string;
1104
+ fragment?: string;
1105
+ syncUnitTime?: number;
1106
+ zIndex?: number;
1107
+ scale?: [number, number];
1108
+ rotate?: number;
1109
+ thickness?: number;
1110
+ textOpt?: import("../../component/textEditor").TextOptions;
1111
+ translate?: [number, number];
1112
+ eraserlines?: SerializerEraserLines;
1113
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1114
+ doingLines?: SerializerEraserLines;
1115
+ lineCap?: "square" | "round";
1116
+ lineDash?: [number, number];
1117
+ } | {
1118
+ matrix: import("../utils").AffineMatrix;
1119
+ thickness: number;
1120
+ strokeColor: string;
1121
+ strokeType: import("../..").EStrokeType;
1122
+ isOpacity?: boolean;
1123
+ fontColor?: string;
1124
+ fontBgColor?: string;
1125
+ fillColor?: string;
1126
+ vertex?: string;
1127
+ fragment?: string;
1128
+ syncUnitTime?: number;
1129
+ zIndex?: number;
1130
+ scale?: [number, number];
1131
+ rotate?: number;
1132
+ textOpt?: import("../../component/textEditor").TextOptions;
1133
+ translate?: [number, number];
1134
+ eraserlines?: SerializerEraserLines;
1135
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1136
+ doingLines?: SerializerEraserLines;
1137
+ lineCap?: "square" | "round";
1138
+ lineDash?: [number, number];
1139
+ } | {
1140
+ matrix: import("../utils").AffineMatrix;
1141
+ thickness: number;
1142
+ strokeColor: string;
1143
+ fillColor: string;
1144
+ strokeType: import("../..").EStrokeType;
1145
+ isOpacity?: boolean;
1146
+ fontColor?: string;
1147
+ fontBgColor?: string;
1148
+ vertex?: string;
1149
+ fragment?: string;
1150
+ syncUnitTime?: number;
1151
+ zIndex?: number;
1152
+ scale?: [number, number];
1153
+ rotate?: number;
1154
+ textOpt?: import("../../component/textEditor").TextOptions;
1155
+ translate?: [number, number];
1156
+ eraserlines?: SerializerEraserLines;
1157
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1158
+ doingLines?: SerializerEraserLines;
1159
+ lineCap?: "square" | "round";
1160
+ lineDash?: [number, number];
1161
+ } | {
1162
+ matrix: import("../utils").AffineMatrix;
1163
+ thickness: number;
1164
+ strokeColor: string;
1165
+ fillColor: string;
1166
+ strokeType: import("../..").EStrokeType;
1167
+ isOpacity?: boolean;
1168
+ fontColor?: string;
1169
+ fontBgColor?: string;
1170
+ vertex?: string;
1171
+ fragment?: string;
1172
+ syncUnitTime?: number;
1173
+ zIndex?: number;
1174
+ scale?: [number, number];
1175
+ rotate?: number;
1176
+ textOpt?: import("../../component/textEditor").TextOptions;
1177
+ translate?: [number, number];
1178
+ eraserlines?: SerializerEraserLines;
1179
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1180
+ doingLines?: SerializerEraserLines;
1181
+ lineCap?: "square" | "round";
1182
+ lineDash?: [number, number];
1183
+ } | {
1184
+ matrix: import("../utils").AffineMatrix;
1185
+ thickness: number;
1186
+ vertices: number;
1187
+ strokeColor: string;
1188
+ fillColor: string;
1189
+ strokeType: import("../..").EStrokeType;
1190
+ isOpacity?: boolean;
1191
+ fontColor?: string;
1192
+ fontBgColor?: string;
1193
+ vertex?: string;
1194
+ fragment?: string;
1195
+ syncUnitTime?: number;
1196
+ zIndex?: number;
1197
+ scale?: [number, number];
1198
+ rotate?: number;
1199
+ textOpt?: import("../../component/textEditor").TextOptions;
1200
+ translate?: [number, number];
1201
+ eraserlines?: SerializerEraserLines;
1202
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1203
+ doingLines?: SerializerEraserLines;
1204
+ lineCap?: "square" | "round";
1205
+ lineDash?: [number, number];
1206
+ } | {
1207
+ matrix: import("../utils").AffineMatrix;
1208
+ thickness: number;
1209
+ strokeColor: string;
1210
+ strokeType: import("../..").EStrokeType;
1211
+ isOpacity?: boolean;
1212
+ fontColor?: string;
1213
+ fontBgColor?: string;
1214
+ fillColor?: string;
1215
+ vertex?: string;
1216
+ fragment?: string;
1217
+ syncUnitTime?: number;
1218
+ zIndex?: number;
1219
+ scale?: [number, number];
1220
+ rotate?: number;
1221
+ textOpt?: import("../../component/textEditor").TextOptions;
1222
+ translate?: [number, number];
1223
+ eraserlines?: SerializerEraserLines;
1224
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1225
+ doingLines?: SerializerEraserLines;
1226
+ lineCap?: "square" | "round";
1227
+ lineDash?: [number, number];
1228
+ } | {
1229
+ matrix: import("../utils").AffineMatrix;
1230
+ thickness: number;
1231
+ placement: import("../..").SpeechBalloonPlacement;
1232
+ strokeColor: string;
1233
+ fillColor: string;
1234
+ strokeType: import("../..").EStrokeType;
1235
+ isOpacity?: boolean;
1236
+ fontColor?: string;
1237
+ fontBgColor?: string;
1238
+ vertex?: string;
1239
+ fragment?: string;
1240
+ syncUnitTime?: number;
1241
+ zIndex?: number;
1242
+ scale?: [number, number];
1243
+ rotate?: number;
1244
+ textOpt?: import("../../component/textEditor").TextOptions;
1245
+ translate?: [number, number];
1246
+ eraserlines?: SerializerEraserLines;
1247
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1248
+ doingLines?: SerializerEraserLines;
1249
+ lineCap?: "square" | "round";
1250
+ lineDash?: [number, number];
1251
+ } | {
1252
+ matrix: import("../utils").AffineMatrix;
1253
+ src: string;
1254
+ type: import("..").EImageType;
1255
+ uuid: string;
1256
+ centerX: number;
1257
+ centerY: number;
1258
+ width: number;
1259
+ height: number;
1260
+ locked: boolean;
1261
+ uniformScale?: boolean;
1262
+ crossOrigin?: boolean | string;
1263
+ isOpacity?: boolean;
1264
+ fontColor?: string;
1265
+ fontBgColor?: string;
1266
+ strokeColor?: string;
1267
+ fillColor?: string;
1268
+ vertex?: string;
1269
+ fragment?: string;
1270
+ syncUnitTime?: number;
1271
+ zIndex?: number;
1272
+ scale?: [number, number];
1273
+ rotate?: number;
1274
+ thickness?: number;
1275
+ textOpt?: import("../../component/textEditor").TextOptions;
1276
+ translate?: [number, number];
1277
+ eraserlines?: SerializerEraserLines;
1278
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1279
+ doingLines?: SerializerEraserLines;
1280
+ lineCap?: "square" | "round";
1281
+ lineDash?: [number, number];
1282
+ } | {
1283
+ matrix: import("../utils").AffineMatrix;
1284
+ type: import("..").ESVGType.url;
1285
+ src: string;
1286
+ crossOrigin: boolean | string;
1287
+ uuid: string;
1288
+ centerX: number;
1289
+ centerY: number;
1290
+ width: number;
1291
+ height: number;
1292
+ locked: boolean;
1293
+ uniformScale: boolean;
1294
+ state?: unknown;
1295
+ isOpacity?: boolean;
1296
+ fontColor?: string;
1297
+ fontBgColor?: string;
1298
+ strokeColor?: string;
1299
+ fillColor?: string;
1300
+ vertex?: string;
1301
+ fragment?: string;
1302
+ syncUnitTime?: number;
1303
+ zIndex?: number;
1304
+ scale?: [number, number];
1305
+ rotate?: number;
1306
+ thickness?: number;
1307
+ textOpt?: import("../../component/textEditor").TextOptions;
1308
+ translate?: [number, number];
1309
+ eraserlines?: SerializerEraserLines;
1310
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1311
+ doingLines?: SerializerEraserLines;
1312
+ lineCap?: "square" | "round";
1313
+ lineDash?: [number, number];
1314
+ } | {
1315
+ matrix: import("../utils").AffineMatrix;
1316
+ type: import("..").ESVGType.markmap;
1317
+ data: string;
1318
+ uuid: string;
1319
+ centerX: number;
1320
+ centerY: number;
1321
+ width: number;
1322
+ height: number;
1323
+ locked: boolean;
1324
+ uniformScale: boolean;
1325
+ state?: unknown;
1326
+ isOpacity?: boolean;
1327
+ fontColor?: string;
1328
+ fontBgColor?: string;
1329
+ strokeColor?: string;
1330
+ fillColor?: string;
1331
+ vertex?: string;
1332
+ fragment?: string;
1333
+ syncUnitTime?: number;
1334
+ zIndex?: number;
1335
+ scale?: [number, number];
1336
+ rotate?: number;
1337
+ thickness?: number;
1338
+ textOpt?: import("../../component/textEditor").TextOptions;
1339
+ translate?: [number, number];
1340
+ eraserlines?: SerializerEraserLines;
1341
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1342
+ doingLines?: SerializerEraserLines;
1343
+ lineCap?: "square" | "round";
1344
+ lineDash?: [number, number];
1345
+ };
80
1346
  type: EPostMessageType;
81
1347
  } | {
82
1348
  type: EPostMessageType;
@@ -89,7 +1355,429 @@ export declare class BitMapEraserShape extends BaseShapeTool {
89
1355
  eraseTxnCommitStatus: "applied";
90
1356
  workId: string;
91
1357
  toolsType: EToolsKey;
92
- opt: import("./utils").ShapeOptions;
1358
+ opt: {
1359
+ matrix: import("../utils").AffineMatrix;
1360
+ fontColor: string;
1361
+ fontSize: number;
1362
+ text: string;
1363
+ textAlign: import("../../component/textEditor").TextAlignType;
1364
+ verticalAlign: import("../../component/textEditor").VerticalAlignType;
1365
+ lineHeight?: number;
1366
+ fontFamily?: string;
1367
+ bold?: import("../../component/textEditor").FontWeightType;
1368
+ italic?: import("../../component/textEditor").FontStyleType;
1369
+ fontBgColor?: string;
1370
+ underline?: boolean;
1371
+ lineThrough?: boolean;
1372
+ boxPoint?: [number, number];
1373
+ boxSize?: [number, number];
1374
+ workState?: import("..").EventWorkState;
1375
+ uid?: string;
1376
+ isOpacity?: boolean;
1377
+ strokeColor?: string;
1378
+ fillColor?: string;
1379
+ vertex?: string;
1380
+ fragment?: string;
1381
+ syncUnitTime?: number;
1382
+ zIndex?: number;
1383
+ scale?: [number, number];
1384
+ rotate?: number;
1385
+ thickness?: number;
1386
+ textOpt?: import("../../component/textEditor").TextOptions;
1387
+ translate?: [number, number];
1388
+ eraserlines?: SerializerEraserLines;
1389
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1390
+ doingLines?: SerializerEraserLines;
1391
+ lineCap?: "square" | "round";
1392
+ lineDash?: [number, number];
1393
+ } | {
1394
+ matrix: import("../utils").AffineMatrix;
1395
+ thickness: number;
1396
+ strokeColor: string;
1397
+ strokeType: import("../..").EStrokeType;
1398
+ autoShape?: boolean;
1399
+ previewLocalOnly?: boolean;
1400
+ isOpacity?: boolean;
1401
+ fontColor?: string;
1402
+ fontBgColor?: string;
1403
+ fillColor?: string;
1404
+ vertex?: string;
1405
+ fragment?: string;
1406
+ syncUnitTime?: number;
1407
+ zIndex?: number;
1408
+ scale?: [number, number];
1409
+ rotate?: number;
1410
+ textOpt?: import("../../component/textEditor").TextOptions;
1411
+ translate?: [number, number];
1412
+ eraserlines?: SerializerEraserLines;
1413
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1414
+ doingLines?: SerializerEraserLines;
1415
+ lineCap?: "square" | "round";
1416
+ lineDash?: [number, number];
1417
+ } | {
1418
+ matrix: import("../utils").AffineMatrix;
1419
+ thickness: number;
1420
+ duration: number;
1421
+ strokeColor: string;
1422
+ strokeType: Omit<import("../..").EStrokeType, "Stroke">;
1423
+ isOpacity?: boolean;
1424
+ fontColor?: string;
1425
+ fontBgColor?: string;
1426
+ fillColor?: string;
1427
+ vertex?: string;
1428
+ fragment?: string;
1429
+ syncUnitTime?: number;
1430
+ zIndex?: number;
1431
+ scale?: [number, number];
1432
+ rotate?: number;
1433
+ textOpt?: import("../../component/textEditor").TextOptions;
1434
+ translate?: [number, number];
1435
+ eraserlines?: SerializerEraserLines;
1436
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1437
+ doingLines?: SerializerEraserLines;
1438
+ lineCap?: "square" | "round";
1439
+ lineDash?: [number, number];
1440
+ } | {
1441
+ matrix: import("../utils").AffineMatrix;
1442
+ thickness: number;
1443
+ isOpacity?: boolean;
1444
+ fontColor?: string;
1445
+ fontBgColor?: string;
1446
+ strokeColor?: string;
1447
+ fillColor?: string;
1448
+ vertex?: string;
1449
+ fragment?: string;
1450
+ syncUnitTime?: number;
1451
+ zIndex?: number;
1452
+ scale?: [number, number];
1453
+ rotate?: number;
1454
+ textOpt?: import("../../component/textEditor").TextOptions;
1455
+ translate?: [number, number];
1456
+ eraserlines?: SerializerEraserLines;
1457
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1458
+ doingLines?: SerializerEraserLines;
1459
+ lineCap?: "square" | "round";
1460
+ lineDash?: [number, number];
1461
+ } | {
1462
+ matrix: import("../utils").AffineMatrix;
1463
+ thickness: number;
1464
+ maxImageWidth?: number;
1465
+ maxImageHeight?: number;
1466
+ removeOnDone?: boolean;
1467
+ isOpacity?: boolean;
1468
+ fontColor?: string;
1469
+ fontBgColor?: string;
1470
+ strokeColor?: string;
1471
+ fillColor?: string;
1472
+ vertex?: string;
1473
+ fragment?: string;
1474
+ syncUnitTime?: number;
1475
+ zIndex?: number;
1476
+ scale?: [number, number];
1477
+ rotate?: number;
1478
+ textOpt?: import("../../component/textEditor").TextOptions;
1479
+ translate?: [number, number];
1480
+ eraserlines?: SerializerEraserLines;
1481
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1482
+ doingLines?: SerializerEraserLines;
1483
+ lineCap?: "square" | "round";
1484
+ lineDash?: [number, number];
1485
+ } | {
1486
+ matrix: import("../utils").AffineMatrix;
1487
+ thickness: number;
1488
+ isOpacity?: boolean;
1489
+ fontColor?: string;
1490
+ fontBgColor?: string;
1491
+ strokeColor?: string;
1492
+ fillColor?: string;
1493
+ vertex?: string;
1494
+ fragment?: string;
1495
+ syncUnitTime?: number;
1496
+ zIndex?: number;
1497
+ scale?: [number, number];
1498
+ rotate?: number;
1499
+ textOpt?: import("../../component/textEditor").TextOptions;
1500
+ translate?: [number, number];
1501
+ eraserlines?: SerializerEraserLines;
1502
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1503
+ doingLines?: SerializerEraserLines;
1504
+ lineCap?: "square" | "round";
1505
+ lineDash?: [number, number];
1506
+ } | {
1507
+ matrix: import("../utils").AffineMatrix;
1508
+ thickness: number;
1509
+ vertices: number;
1510
+ innerVerticeStep: number;
1511
+ innerRatio: number;
1512
+ strokeColor: string;
1513
+ fillColor: string;
1514
+ strokeType: import("../..").EStrokeType;
1515
+ isOpacity?: boolean;
1516
+ fontColor?: string;
1517
+ fontBgColor?: string;
1518
+ vertex?: string;
1519
+ fragment?: string;
1520
+ syncUnitTime?: number;
1521
+ zIndex?: number;
1522
+ scale?: [number, number];
1523
+ rotate?: number;
1524
+ textOpt?: import("../../component/textEditor").TextOptions;
1525
+ translate?: [number, number];
1526
+ eraserlines?: SerializerEraserLines;
1527
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1528
+ doingLines?: SerializerEraserLines;
1529
+ lineCap?: "square" | "round";
1530
+ lineDash?: [number, number];
1531
+ } | {
1532
+ matrix: import("../utils").AffineMatrix;
1533
+ isOpacity?: boolean;
1534
+ fontColor?: string;
1535
+ fontBgColor?: string;
1536
+ strokeColor?: string;
1537
+ fillColor?: string;
1538
+ vertex?: string;
1539
+ fragment?: string;
1540
+ syncUnitTime?: number;
1541
+ zIndex?: number;
1542
+ scale?: [number, number];
1543
+ rotate?: number;
1544
+ thickness?: number;
1545
+ textOpt?: import("../../component/textEditor").TextOptions;
1546
+ translate?: [number, number];
1547
+ eraserlines?: SerializerEraserLines;
1548
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1549
+ doingLines?: SerializerEraserLines;
1550
+ lineCap?: "square" | "round";
1551
+ lineDash?: [number, number];
1552
+ } | {
1553
+ matrix: import("../utils").AffineMatrix;
1554
+ thickness: number;
1555
+ strokeColor: string;
1556
+ strokeType: import("../..").EStrokeType;
1557
+ isOpacity?: boolean;
1558
+ fontColor?: string;
1559
+ fontBgColor?: string;
1560
+ fillColor?: string;
1561
+ vertex?: string;
1562
+ fragment?: string;
1563
+ syncUnitTime?: number;
1564
+ zIndex?: number;
1565
+ scale?: [number, number];
1566
+ rotate?: number;
1567
+ textOpt?: import("../../component/textEditor").TextOptions;
1568
+ translate?: [number, number];
1569
+ eraserlines?: SerializerEraserLines;
1570
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1571
+ doingLines?: SerializerEraserLines;
1572
+ lineCap?: "square" | "round";
1573
+ lineDash?: [number, number];
1574
+ } | {
1575
+ matrix: import("../utils").AffineMatrix;
1576
+ thickness: number;
1577
+ strokeColor: string;
1578
+ fillColor: string;
1579
+ strokeType: import("../..").EStrokeType;
1580
+ isOpacity?: boolean;
1581
+ fontColor?: string;
1582
+ fontBgColor?: string;
1583
+ vertex?: string;
1584
+ fragment?: string;
1585
+ syncUnitTime?: number;
1586
+ zIndex?: number;
1587
+ scale?: [number, number];
1588
+ rotate?: number;
1589
+ textOpt?: import("../../component/textEditor").TextOptions;
1590
+ translate?: [number, number];
1591
+ eraserlines?: SerializerEraserLines;
1592
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1593
+ doingLines?: SerializerEraserLines;
1594
+ lineCap?: "square" | "round";
1595
+ lineDash?: [number, number];
1596
+ } | {
1597
+ matrix: import("../utils").AffineMatrix;
1598
+ thickness: number;
1599
+ strokeColor: string;
1600
+ fillColor: string;
1601
+ strokeType: import("../..").EStrokeType;
1602
+ isOpacity?: boolean;
1603
+ fontColor?: string;
1604
+ fontBgColor?: string;
1605
+ vertex?: string;
1606
+ fragment?: string;
1607
+ syncUnitTime?: number;
1608
+ zIndex?: number;
1609
+ scale?: [number, number];
1610
+ rotate?: number;
1611
+ textOpt?: import("../../component/textEditor").TextOptions;
1612
+ translate?: [number, number];
1613
+ eraserlines?: SerializerEraserLines;
1614
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1615
+ doingLines?: SerializerEraserLines;
1616
+ lineCap?: "square" | "round";
1617
+ lineDash?: [number, number];
1618
+ } | {
1619
+ matrix: import("../utils").AffineMatrix;
1620
+ thickness: number;
1621
+ vertices: number;
1622
+ strokeColor: string;
1623
+ fillColor: string;
1624
+ strokeType: import("../..").EStrokeType;
1625
+ isOpacity?: boolean;
1626
+ fontColor?: string;
1627
+ fontBgColor?: string;
1628
+ vertex?: string;
1629
+ fragment?: string;
1630
+ syncUnitTime?: number;
1631
+ zIndex?: number;
1632
+ scale?: [number, number];
1633
+ rotate?: number;
1634
+ textOpt?: import("../../component/textEditor").TextOptions;
1635
+ translate?: [number, number];
1636
+ eraserlines?: SerializerEraserLines;
1637
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1638
+ doingLines?: SerializerEraserLines;
1639
+ lineCap?: "square" | "round";
1640
+ lineDash?: [number, number];
1641
+ } | {
1642
+ matrix: import("../utils").AffineMatrix;
1643
+ thickness: number;
1644
+ strokeColor: string;
1645
+ strokeType: import("../..").EStrokeType;
1646
+ isOpacity?: boolean;
1647
+ fontColor?: string;
1648
+ fontBgColor?: string;
1649
+ fillColor?: string;
1650
+ vertex?: string;
1651
+ fragment?: string;
1652
+ syncUnitTime?: number;
1653
+ zIndex?: number;
1654
+ scale?: [number, number];
1655
+ rotate?: number;
1656
+ textOpt?: import("../../component/textEditor").TextOptions;
1657
+ translate?: [number, number];
1658
+ eraserlines?: SerializerEraserLines;
1659
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1660
+ doingLines?: SerializerEraserLines;
1661
+ lineCap?: "square" | "round";
1662
+ lineDash?: [number, number];
1663
+ } | {
1664
+ matrix: import("../utils").AffineMatrix;
1665
+ thickness: number;
1666
+ placement: import("../..").SpeechBalloonPlacement;
1667
+ strokeColor: string;
1668
+ fillColor: string;
1669
+ strokeType: import("../..").EStrokeType;
1670
+ isOpacity?: boolean;
1671
+ fontColor?: string;
1672
+ fontBgColor?: string;
1673
+ vertex?: string;
1674
+ fragment?: string;
1675
+ syncUnitTime?: number;
1676
+ zIndex?: number;
1677
+ scale?: [number, number];
1678
+ rotate?: number;
1679
+ textOpt?: import("../../component/textEditor").TextOptions;
1680
+ translate?: [number, number];
1681
+ eraserlines?: SerializerEraserLines;
1682
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1683
+ doingLines?: SerializerEraserLines;
1684
+ lineCap?: "square" | "round";
1685
+ lineDash?: [number, number];
1686
+ } | {
1687
+ matrix: import("../utils").AffineMatrix;
1688
+ src: string;
1689
+ type: import("..").EImageType;
1690
+ uuid: string;
1691
+ centerX: number;
1692
+ centerY: number;
1693
+ width: number;
1694
+ height: number;
1695
+ locked: boolean;
1696
+ uniformScale?: boolean;
1697
+ crossOrigin?: boolean | string;
1698
+ isOpacity?: boolean;
1699
+ fontColor?: string;
1700
+ fontBgColor?: string;
1701
+ strokeColor?: string;
1702
+ fillColor?: string;
1703
+ vertex?: string;
1704
+ fragment?: string;
1705
+ syncUnitTime?: number;
1706
+ zIndex?: number;
1707
+ scale?: [number, number];
1708
+ rotate?: number;
1709
+ thickness?: number;
1710
+ textOpt?: import("../../component/textEditor").TextOptions;
1711
+ translate?: [number, number];
1712
+ eraserlines?: SerializerEraserLines;
1713
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1714
+ doingLines?: SerializerEraserLines;
1715
+ lineCap?: "square" | "round";
1716
+ lineDash?: [number, number];
1717
+ } | {
1718
+ matrix: import("../utils").AffineMatrix;
1719
+ type: import("..").ESVGType.url;
1720
+ src: string;
1721
+ crossOrigin: boolean | string;
1722
+ uuid: string;
1723
+ centerX: number;
1724
+ centerY: number;
1725
+ width: number;
1726
+ height: number;
1727
+ locked: boolean;
1728
+ uniformScale: boolean;
1729
+ state?: unknown;
1730
+ isOpacity?: boolean;
1731
+ fontColor?: string;
1732
+ fontBgColor?: string;
1733
+ strokeColor?: string;
1734
+ fillColor?: string;
1735
+ vertex?: string;
1736
+ fragment?: string;
1737
+ syncUnitTime?: number;
1738
+ zIndex?: number;
1739
+ scale?: [number, number];
1740
+ rotate?: number;
1741
+ thickness?: number;
1742
+ textOpt?: import("../../component/textEditor").TextOptions;
1743
+ translate?: [number, number];
1744
+ eraserlines?: SerializerEraserLines;
1745
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1746
+ doingLines?: SerializerEraserLines;
1747
+ lineCap?: "square" | "round";
1748
+ lineDash?: [number, number];
1749
+ } | {
1750
+ matrix: import("../utils").AffineMatrix;
1751
+ type: import("..").ESVGType.markmap;
1752
+ data: string;
1753
+ uuid: string;
1754
+ centerX: number;
1755
+ centerY: number;
1756
+ width: number;
1757
+ height: number;
1758
+ locked: boolean;
1759
+ uniformScale: boolean;
1760
+ state?: unknown;
1761
+ isOpacity?: boolean;
1762
+ fontColor?: string;
1763
+ fontBgColor?: string;
1764
+ strokeColor?: string;
1765
+ fillColor?: string;
1766
+ vertex?: string;
1767
+ fragment?: string;
1768
+ syncUnitTime?: number;
1769
+ zIndex?: number;
1770
+ scale?: [number, number];
1771
+ rotate?: number;
1772
+ thickness?: number;
1773
+ textOpt?: import("../../component/textEditor").TextOptions;
1774
+ translate?: [number, number];
1775
+ eraserlines?: SerializerEraserLines;
1776
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1777
+ doingLines?: SerializerEraserLines;
1778
+ lineCap?: "square" | "round";
1779
+ lineDash?: [number, number];
1780
+ };
93
1781
  } | {
94
1782
  rect: IRectType | undefined;
95
1783
  willUpdateNodes: Map<string, BaseNodeMapItem>;
@@ -99,7 +1787,429 @@ export declare class BitMapEraserShape extends BaseShapeTool {
99
1787
  eraseTxnCommitStatus: "failed";
100
1788
  workId: string;
101
1789
  toolsType: EToolsKey;
102
- opt: import("./utils").ShapeOptions;
1790
+ opt: {
1791
+ matrix: import("../utils").AffineMatrix;
1792
+ fontColor: string;
1793
+ fontSize: number;
1794
+ text: string;
1795
+ textAlign: import("../../component/textEditor").TextAlignType;
1796
+ verticalAlign: import("../../component/textEditor").VerticalAlignType;
1797
+ lineHeight?: number;
1798
+ fontFamily?: string;
1799
+ bold?: import("../../component/textEditor").FontWeightType;
1800
+ italic?: import("../../component/textEditor").FontStyleType;
1801
+ fontBgColor?: string;
1802
+ underline?: boolean;
1803
+ lineThrough?: boolean;
1804
+ boxPoint?: [number, number];
1805
+ boxSize?: [number, number];
1806
+ workState?: import("..").EventWorkState;
1807
+ uid?: string;
1808
+ isOpacity?: boolean;
1809
+ strokeColor?: string;
1810
+ fillColor?: string;
1811
+ vertex?: string;
1812
+ fragment?: string;
1813
+ syncUnitTime?: number;
1814
+ zIndex?: number;
1815
+ scale?: [number, number];
1816
+ rotate?: number;
1817
+ thickness?: number;
1818
+ textOpt?: import("../../component/textEditor").TextOptions;
1819
+ translate?: [number, number];
1820
+ eraserlines?: SerializerEraserLines;
1821
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1822
+ doingLines?: SerializerEraserLines;
1823
+ lineCap?: "square" | "round";
1824
+ lineDash?: [number, number];
1825
+ } | {
1826
+ matrix: import("../utils").AffineMatrix;
1827
+ thickness: number;
1828
+ strokeColor: string;
1829
+ strokeType: import("../..").EStrokeType;
1830
+ autoShape?: boolean;
1831
+ previewLocalOnly?: boolean;
1832
+ isOpacity?: boolean;
1833
+ fontColor?: string;
1834
+ fontBgColor?: string;
1835
+ fillColor?: string;
1836
+ vertex?: string;
1837
+ fragment?: string;
1838
+ syncUnitTime?: number;
1839
+ zIndex?: number;
1840
+ scale?: [number, number];
1841
+ rotate?: number;
1842
+ textOpt?: import("../../component/textEditor").TextOptions;
1843
+ translate?: [number, number];
1844
+ eraserlines?: SerializerEraserLines;
1845
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1846
+ doingLines?: SerializerEraserLines;
1847
+ lineCap?: "square" | "round";
1848
+ lineDash?: [number, number];
1849
+ } | {
1850
+ matrix: import("../utils").AffineMatrix;
1851
+ thickness: number;
1852
+ duration: number;
1853
+ strokeColor: string;
1854
+ strokeType: Omit<import("../..").EStrokeType, "Stroke">;
1855
+ isOpacity?: boolean;
1856
+ fontColor?: string;
1857
+ fontBgColor?: string;
1858
+ fillColor?: string;
1859
+ vertex?: string;
1860
+ fragment?: string;
1861
+ syncUnitTime?: number;
1862
+ zIndex?: number;
1863
+ scale?: [number, number];
1864
+ rotate?: number;
1865
+ textOpt?: import("../../component/textEditor").TextOptions;
1866
+ translate?: [number, number];
1867
+ eraserlines?: SerializerEraserLines;
1868
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1869
+ doingLines?: SerializerEraserLines;
1870
+ lineCap?: "square" | "round";
1871
+ lineDash?: [number, number];
1872
+ } | {
1873
+ matrix: import("../utils").AffineMatrix;
1874
+ thickness: number;
1875
+ isOpacity?: boolean;
1876
+ fontColor?: string;
1877
+ fontBgColor?: string;
1878
+ strokeColor?: string;
1879
+ fillColor?: string;
1880
+ vertex?: string;
1881
+ fragment?: string;
1882
+ syncUnitTime?: number;
1883
+ zIndex?: number;
1884
+ scale?: [number, number];
1885
+ rotate?: number;
1886
+ textOpt?: import("../../component/textEditor").TextOptions;
1887
+ translate?: [number, number];
1888
+ eraserlines?: SerializerEraserLines;
1889
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1890
+ doingLines?: SerializerEraserLines;
1891
+ lineCap?: "square" | "round";
1892
+ lineDash?: [number, number];
1893
+ } | {
1894
+ matrix: import("../utils").AffineMatrix;
1895
+ thickness: number;
1896
+ maxImageWidth?: number;
1897
+ maxImageHeight?: number;
1898
+ removeOnDone?: boolean;
1899
+ isOpacity?: boolean;
1900
+ fontColor?: string;
1901
+ fontBgColor?: string;
1902
+ strokeColor?: string;
1903
+ fillColor?: string;
1904
+ vertex?: string;
1905
+ fragment?: string;
1906
+ syncUnitTime?: number;
1907
+ zIndex?: number;
1908
+ scale?: [number, number];
1909
+ rotate?: number;
1910
+ textOpt?: import("../../component/textEditor").TextOptions;
1911
+ translate?: [number, number];
1912
+ eraserlines?: SerializerEraserLines;
1913
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1914
+ doingLines?: SerializerEraserLines;
1915
+ lineCap?: "square" | "round";
1916
+ lineDash?: [number, number];
1917
+ } | {
1918
+ matrix: import("../utils").AffineMatrix;
1919
+ thickness: number;
1920
+ isOpacity?: boolean;
1921
+ fontColor?: string;
1922
+ fontBgColor?: string;
1923
+ strokeColor?: string;
1924
+ fillColor?: string;
1925
+ vertex?: string;
1926
+ fragment?: string;
1927
+ syncUnitTime?: number;
1928
+ zIndex?: number;
1929
+ scale?: [number, number];
1930
+ rotate?: number;
1931
+ textOpt?: import("../../component/textEditor").TextOptions;
1932
+ translate?: [number, number];
1933
+ eraserlines?: SerializerEraserLines;
1934
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1935
+ doingLines?: SerializerEraserLines;
1936
+ lineCap?: "square" | "round";
1937
+ lineDash?: [number, number];
1938
+ } | {
1939
+ matrix: import("../utils").AffineMatrix;
1940
+ thickness: number;
1941
+ vertices: number;
1942
+ innerVerticeStep: number;
1943
+ innerRatio: number;
1944
+ strokeColor: string;
1945
+ fillColor: string;
1946
+ strokeType: import("../..").EStrokeType;
1947
+ isOpacity?: boolean;
1948
+ fontColor?: string;
1949
+ fontBgColor?: string;
1950
+ vertex?: string;
1951
+ fragment?: string;
1952
+ syncUnitTime?: number;
1953
+ zIndex?: number;
1954
+ scale?: [number, number];
1955
+ rotate?: number;
1956
+ textOpt?: import("../../component/textEditor").TextOptions;
1957
+ translate?: [number, number];
1958
+ eraserlines?: SerializerEraserLines;
1959
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1960
+ doingLines?: SerializerEraserLines;
1961
+ lineCap?: "square" | "round";
1962
+ lineDash?: [number, number];
1963
+ } | {
1964
+ matrix: import("../utils").AffineMatrix;
1965
+ isOpacity?: boolean;
1966
+ fontColor?: string;
1967
+ fontBgColor?: string;
1968
+ strokeColor?: string;
1969
+ fillColor?: string;
1970
+ vertex?: string;
1971
+ fragment?: string;
1972
+ syncUnitTime?: number;
1973
+ zIndex?: number;
1974
+ scale?: [number, number];
1975
+ rotate?: number;
1976
+ thickness?: number;
1977
+ textOpt?: import("../../component/textEditor").TextOptions;
1978
+ translate?: [number, number];
1979
+ eraserlines?: SerializerEraserLines;
1980
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1981
+ doingLines?: SerializerEraserLines;
1982
+ lineCap?: "square" | "round";
1983
+ lineDash?: [number, number];
1984
+ } | {
1985
+ matrix: import("../utils").AffineMatrix;
1986
+ thickness: number;
1987
+ strokeColor: string;
1988
+ strokeType: import("../..").EStrokeType;
1989
+ isOpacity?: boolean;
1990
+ fontColor?: string;
1991
+ fontBgColor?: string;
1992
+ fillColor?: string;
1993
+ vertex?: string;
1994
+ fragment?: string;
1995
+ syncUnitTime?: number;
1996
+ zIndex?: number;
1997
+ scale?: [number, number];
1998
+ rotate?: number;
1999
+ textOpt?: import("../../component/textEditor").TextOptions;
2000
+ translate?: [number, number];
2001
+ eraserlines?: SerializerEraserLines;
2002
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2003
+ doingLines?: SerializerEraserLines;
2004
+ lineCap?: "square" | "round";
2005
+ lineDash?: [number, number];
2006
+ } | {
2007
+ matrix: import("../utils").AffineMatrix;
2008
+ thickness: number;
2009
+ strokeColor: string;
2010
+ fillColor: string;
2011
+ strokeType: import("../..").EStrokeType;
2012
+ isOpacity?: boolean;
2013
+ fontColor?: string;
2014
+ fontBgColor?: string;
2015
+ vertex?: string;
2016
+ fragment?: string;
2017
+ syncUnitTime?: number;
2018
+ zIndex?: number;
2019
+ scale?: [number, number];
2020
+ rotate?: number;
2021
+ textOpt?: import("../../component/textEditor").TextOptions;
2022
+ translate?: [number, number];
2023
+ eraserlines?: SerializerEraserLines;
2024
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2025
+ doingLines?: SerializerEraserLines;
2026
+ lineCap?: "square" | "round";
2027
+ lineDash?: [number, number];
2028
+ } | {
2029
+ matrix: import("../utils").AffineMatrix;
2030
+ thickness: number;
2031
+ strokeColor: string;
2032
+ fillColor: string;
2033
+ strokeType: import("../..").EStrokeType;
2034
+ isOpacity?: boolean;
2035
+ fontColor?: string;
2036
+ fontBgColor?: string;
2037
+ vertex?: string;
2038
+ fragment?: string;
2039
+ syncUnitTime?: number;
2040
+ zIndex?: number;
2041
+ scale?: [number, number];
2042
+ rotate?: number;
2043
+ textOpt?: import("../../component/textEditor").TextOptions;
2044
+ translate?: [number, number];
2045
+ eraserlines?: SerializerEraserLines;
2046
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2047
+ doingLines?: SerializerEraserLines;
2048
+ lineCap?: "square" | "round";
2049
+ lineDash?: [number, number];
2050
+ } | {
2051
+ matrix: import("../utils").AffineMatrix;
2052
+ thickness: number;
2053
+ vertices: number;
2054
+ strokeColor: string;
2055
+ fillColor: string;
2056
+ strokeType: import("../..").EStrokeType;
2057
+ isOpacity?: boolean;
2058
+ fontColor?: string;
2059
+ fontBgColor?: string;
2060
+ vertex?: string;
2061
+ fragment?: string;
2062
+ syncUnitTime?: number;
2063
+ zIndex?: number;
2064
+ scale?: [number, number];
2065
+ rotate?: number;
2066
+ textOpt?: import("../../component/textEditor").TextOptions;
2067
+ translate?: [number, number];
2068
+ eraserlines?: SerializerEraserLines;
2069
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2070
+ doingLines?: SerializerEraserLines;
2071
+ lineCap?: "square" | "round";
2072
+ lineDash?: [number, number];
2073
+ } | {
2074
+ matrix: import("../utils").AffineMatrix;
2075
+ thickness: number;
2076
+ strokeColor: string;
2077
+ strokeType: import("../..").EStrokeType;
2078
+ isOpacity?: boolean;
2079
+ fontColor?: string;
2080
+ fontBgColor?: string;
2081
+ fillColor?: string;
2082
+ vertex?: string;
2083
+ fragment?: string;
2084
+ syncUnitTime?: number;
2085
+ zIndex?: number;
2086
+ scale?: [number, number];
2087
+ rotate?: number;
2088
+ textOpt?: import("../../component/textEditor").TextOptions;
2089
+ translate?: [number, number];
2090
+ eraserlines?: SerializerEraserLines;
2091
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2092
+ doingLines?: SerializerEraserLines;
2093
+ lineCap?: "square" | "round";
2094
+ lineDash?: [number, number];
2095
+ } | {
2096
+ matrix: import("../utils").AffineMatrix;
2097
+ thickness: number;
2098
+ placement: import("../..").SpeechBalloonPlacement;
2099
+ strokeColor: string;
2100
+ fillColor: string;
2101
+ strokeType: import("../..").EStrokeType;
2102
+ isOpacity?: boolean;
2103
+ fontColor?: string;
2104
+ fontBgColor?: string;
2105
+ vertex?: string;
2106
+ fragment?: string;
2107
+ syncUnitTime?: number;
2108
+ zIndex?: number;
2109
+ scale?: [number, number];
2110
+ rotate?: number;
2111
+ textOpt?: import("../../component/textEditor").TextOptions;
2112
+ translate?: [number, number];
2113
+ eraserlines?: SerializerEraserLines;
2114
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2115
+ doingLines?: SerializerEraserLines;
2116
+ lineCap?: "square" | "round";
2117
+ lineDash?: [number, number];
2118
+ } | {
2119
+ matrix: import("../utils").AffineMatrix;
2120
+ src: string;
2121
+ type: import("..").EImageType;
2122
+ uuid: string;
2123
+ centerX: number;
2124
+ centerY: number;
2125
+ width: number;
2126
+ height: number;
2127
+ locked: boolean;
2128
+ uniformScale?: boolean;
2129
+ crossOrigin?: boolean | string;
2130
+ isOpacity?: boolean;
2131
+ fontColor?: string;
2132
+ fontBgColor?: string;
2133
+ strokeColor?: string;
2134
+ fillColor?: string;
2135
+ vertex?: string;
2136
+ fragment?: string;
2137
+ syncUnitTime?: number;
2138
+ zIndex?: number;
2139
+ scale?: [number, number];
2140
+ rotate?: number;
2141
+ thickness?: number;
2142
+ textOpt?: import("../../component/textEditor").TextOptions;
2143
+ translate?: [number, number];
2144
+ eraserlines?: SerializerEraserLines;
2145
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2146
+ doingLines?: SerializerEraserLines;
2147
+ lineCap?: "square" | "round";
2148
+ lineDash?: [number, number];
2149
+ } | {
2150
+ matrix: import("../utils").AffineMatrix;
2151
+ type: import("..").ESVGType.url;
2152
+ src: string;
2153
+ crossOrigin: boolean | string;
2154
+ uuid: string;
2155
+ centerX: number;
2156
+ centerY: number;
2157
+ width: number;
2158
+ height: number;
2159
+ locked: boolean;
2160
+ uniformScale: boolean;
2161
+ state?: unknown;
2162
+ isOpacity?: boolean;
2163
+ fontColor?: string;
2164
+ fontBgColor?: string;
2165
+ strokeColor?: string;
2166
+ fillColor?: string;
2167
+ vertex?: string;
2168
+ fragment?: string;
2169
+ syncUnitTime?: number;
2170
+ zIndex?: number;
2171
+ scale?: [number, number];
2172
+ rotate?: number;
2173
+ thickness?: number;
2174
+ textOpt?: import("../../component/textEditor").TextOptions;
2175
+ translate?: [number, number];
2176
+ eraserlines?: SerializerEraserLines;
2177
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2178
+ doingLines?: SerializerEraserLines;
2179
+ lineCap?: "square" | "round";
2180
+ lineDash?: [number, number];
2181
+ } | {
2182
+ matrix: import("../utils").AffineMatrix;
2183
+ type: import("..").ESVGType.markmap;
2184
+ data: string;
2185
+ uuid: string;
2186
+ centerX: number;
2187
+ centerY: number;
2188
+ width: number;
2189
+ height: number;
2190
+ locked: boolean;
2191
+ uniformScale: boolean;
2192
+ state?: unknown;
2193
+ isOpacity?: boolean;
2194
+ fontColor?: string;
2195
+ fontBgColor?: string;
2196
+ strokeColor?: string;
2197
+ fillColor?: string;
2198
+ vertex?: string;
2199
+ fragment?: string;
2200
+ syncUnitTime?: number;
2201
+ zIndex?: number;
2202
+ scale?: [number, number];
2203
+ rotate?: number;
2204
+ thickness?: number;
2205
+ textOpt?: import("../../component/textEditor").TextOptions;
2206
+ translate?: [number, number];
2207
+ eraserlines?: SerializerEraserLines;
2208
+ eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
2209
+ doingLines?: SerializerEraserLines;
2210
+ lineCap?: "square" | "round";
2211
+ lineDash?: [number, number];
2212
+ };
103
2213
  type: EPostMessageType;
104
2214
  }>;
105
2215
  clearTmpPoints(): void;