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