@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/selector.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import { BaseConsumeResultType, BaseShapeOptions, BaseShapeTool, BaseShapeToolProps } from "./base";
2
- import { EDataType, EPostMessageType, EScaleType, EToolsKey, EventWorkState } from "../enum";
2
+ import { EDataType, EPostMessageType, EScaleType, EToolsKey } 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,10 +34,6 @@ 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?;
41
37
  constructor(props: BaseShapeToolProps);
42
38
  private computSelector;
43
39
  private updateTempPoints;
@@ -55,429 +51,7 @@ export declare class SelectorShape extends BaseShapeTool {
55
51
  } | {
56
52
  workId: string;
57
53
  toolsType: EToolsKey;
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
- };
54
+ opt: import("./utils").ShapeOptions;
481
55
  rect: IRectType | undefined;
482
56
  type: EPostMessageType;
483
57
  dataType: EDataType;
@@ -485,429 +59,7 @@ export declare class SelectorShape extends BaseShapeTool {
485
59
  consumeAll(): {
486
60
  workId: string;
487
61
  toolsType: EToolsKey;
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
- };
62
+ opt: import("./utils").ShapeOptions;
911
63
  type: EPostMessageType;
912
64
  dataType: EDataType;
913
65
  rect: IRectType | undefined;
@@ -932,429 +84,7 @@ export declare class SelectorShape extends BaseShapeTool {
932
84
  } | {
933
85
  workId: string;
934
86
  toolsType: EToolsKey;
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
- };
87
+ opt: import("./utils").ShapeOptions;
1358
88
  type: EPostMessageType;
1359
89
  dataType: EDataType;
1360
90
  };
@@ -1372,429 +102,7 @@ export declare class SelectorShape extends BaseShapeTool {
1372
102
  } | {
1373
103
  workId: string;
1374
104
  toolsType: EToolsKey;
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
- };
105
+ opt: import("./utils").ShapeOptions;
1798
106
  rect: IRectType | undefined;
1799
107
  type: EPostMessageType;
1800
108
  dataType: EDataType;
@@ -1805,429 +113,7 @@ export declare class SelectorShape extends BaseShapeTool {
1805
113
  }): {
1806
114
  workId: string;
1807
115
  toolsType: EToolsKey;
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
- };
116
+ opt: import("./utils").ShapeOptions;
2231
117
  rect: IRectType | undefined;
2232
118
  type: EPostMessageType;
2233
119
  dataType: EDataType;
@@ -2248,8 +134,8 @@ export declare class SelectorShape extends BaseShapeTool {
2248
134
  selectIds?: string[];
2249
135
  willSerializeData?: boolean;
2250
136
  worker?: LocalWorkForFullWorker | SubLocalMainThreadImpl;
137
+ offset?: [number, number];
2251
138
  }): Promise<IMainMessage | undefined>;
2252
- private captureSelectorScaleCenter;
2253
139
  blurSelector(): {
2254
140
  type: EPostMessageType;
2255
141
  dataType: EDataType;