@netless/appliance-plugin 1.1.44-beta.0 → 1.1.44

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 (64) hide show
  1. package/dist/appliance-plugin.js +1 -1
  2. package/dist/appliance-plugin.mjs +12 -12
  3. package/dist/{bridge-CskJoX5M.js → bridge-B7BW1lpB.js} +1 -1
  4. package/dist/{bridge-rKHCYJ6m.mjs → bridge-DQud78k4.mjs} +1 -1
  5. package/dist/bridge.js +1 -1
  6. package/dist/bridge.mjs +1 -1
  7. package/dist/collector/types.d.ts +0 -3
  8. package/dist/component/textEditor/types.d.ts +0 -5
  9. package/dist/core/mainThread/base.d.ts +5 -1
  10. package/dist/core/mainThread/snapshotThread.d.ts +2 -3
  11. package/dist/core/mainThread/subLocalThread.d.ts +2 -5
  12. package/dist/core/mainThread/subServiceThread.d.ts +2 -1
  13. package/dist/core/mainThread/subTopThread.d.ts +2 -2
  14. package/dist/core/tools/arrow.d.ts +1 -423
  15. package/dist/core/tools/base.d.ts +2 -444
  16. package/dist/core/tools/ellipse.d.ts +1 -423
  17. package/dist/core/tools/eraser.d.ts +2 -846
  18. package/dist/core/tools/eraserFaces.d.ts +0 -2
  19. package/dist/core/tools/image.d.ts +1 -0
  20. package/dist/core/tools/laserPen.d.ts +2 -846
  21. package/dist/core/tools/pencil.d.ts +2 -848
  22. package/dist/core/tools/pencilEraser.d.ts +4 -1692
  23. package/dist/core/tools/pencilEraserBitMap.d.ts +5 -2115
  24. package/dist/core/tools/polygon.d.ts +1 -423
  25. package/dist/core/tools/rectangle.d.ts +1 -423
  26. package/dist/core/tools/selector.d.ts +7 -2121
  27. package/dist/core/tools/speechBalloon.d.ts +1 -423
  28. package/dist/core/tools/star.d.ts +1 -423
  29. package/dist/core/tools/straight.d.ts +1 -423
  30. package/dist/core/tools/text.d.ts +3 -3
  31. package/dist/core/tools/utils.d.ts +2 -2
  32. package/dist/core/types.d.ts +0 -9
  33. package/dist/core/utils/index.d.ts +0 -2
  34. package/dist/core/utils/serviceImageRecovery.d.ts +9 -0
  35. package/dist/core/vNodeManager.d.ts +1 -1
  36. package/dist/core/worker/base.d.ts +6 -2
  37. package/dist/core/worker/fullWorkerLocal.d.ts +0 -1
  38. package/dist/core/worker/fullWorkerService.d.ts +4 -2
  39. package/dist/core/worker/simpleWorker.d.ts +2 -2
  40. package/dist/core/worker/subWorkerTopLayer.d.ts +2 -2
  41. package/dist/fullWorker.js +148 -149
  42. package/dist/{index-Ca2t53R7.mjs → index-4ZI3GxVI.mjs} +1 -1
  43. package/dist/{index-ZMuKk-bl.js → index-AJCkfnUu.js} +1 -1
  44. package/dist/{index-ConirzkM.mjs → index-B8Ls8sf_.mjs} +1 -1
  45. package/dist/{index-BbBSxLGe.mjs → index-BBtV40zU.mjs} +563 -490
  46. package/dist/{index-C-tBYq0K.js → index-BOzOWS7h.js} +1 -1
  47. package/dist/index-BQiBrpib.js +1 -0
  48. package/dist/index-BYriQtGa.js +1 -0
  49. package/dist/{index-_3yxgNoj.mjs → index-C2tUvh2a.mjs} +11964 -12224
  50. package/dist/{index-DWevrjrE.mjs → index-DSFxl2wM.mjs} +11917 -12168
  51. package/dist/index-DnJkIouU.js +570 -0
  52. package/dist/index-DptnZ-h8.js +570 -0
  53. package/dist/{index-LcCU1tMV.mjs → index-ZUpKkvbD.mjs} +563 -490
  54. package/dist/subWorker.js +132 -133
  55. package/package.json +3 -4
  56. package/dist/core/utils/affineMatrix.d.ts +0 -33
  57. package/dist/core/utils/fontFamily.d.ts +0 -8
  58. package/dist/core/utils/selectorMatrix.d.ts +0 -4
  59. package/dist/core/utils/selectorRefresh.d.ts +0 -8
  60. package/dist/core/utils/textRaster.d.ts +0 -2
  61. package/dist/index-B0SB7Efu.js +0 -570
  62. package/dist/index-BIVRfc_x.js +0 -570
  63. package/dist/index-Bzg5OMdP.js +0 -1
  64. package/dist/index-CsNG_bzI.js +0 -1
package/dist/core/tools/pencilEraserBitMap.d.ts CHANGED
@@ -60,429 +60,7 @@ export declare class BitMapEraserShape extends BaseShapeTool {
60
60
  }): {
61
61
  workId: string;
62
62
  toolsType: EToolsKey;
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
- };
63
+ opt: import("./utils").ShapeOptions;
486
64
  type: EPostMessageType;
487
65
  };
488
66
  consumeAll(props: {
@@ -490,429 +68,7 @@ export declare class BitMapEraserShape extends BaseShapeTool {
490
68
  }): Promise<{
491
69
  workId: string;
492
70
  toolsType: EToolsKey;
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
- };
71
+ opt: import("./utils").ShapeOptions;
916
72
  type: EPostMessageType;
917
73
  } | {
918
74
  rect: IRectType | undefined;
@@ -920,429 +76,7 @@ export declare class BitMapEraserShape extends BaseShapeTool {
920
76
  eraseTxnCommitStatus: "applied";
921
77
  workId: string;
922
78
  toolsType: EToolsKey;
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
- };
79
+ opt: import("./utils").ShapeOptions;
1346
80
  type: EPostMessageType;
1347
81
  } | {
1348
82
  type: EPostMessageType;
@@ -1355,429 +89,7 @@ export declare class BitMapEraserShape extends BaseShapeTool {
1355
89
  eraseTxnCommitStatus: "applied";
1356
90
  workId: string;
1357
91
  toolsType: EToolsKey;
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
- };
92
+ opt: import("./utils").ShapeOptions;
1781
93
  } | {
1782
94
  rect: IRectType | undefined;
1783
95
  willUpdateNodes: Map<string, BaseNodeMapItem>;
@@ -1787,429 +99,7 @@ export declare class BitMapEraserShape extends BaseShapeTool {
1787
99
  eraseTxnCommitStatus: "failed";
1788
100
  workId: string;
1789
101
  toolsType: EToolsKey;
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
- };
102
+ opt: import("./utils").ShapeOptions;
2213
103
  type: EPostMessageType;
2214
104
  }>;
2215
105
  clearTmpPoints(): void;