@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/pencilEraser.d.ts CHANGED
@@ -37,429 +37,7 @@ export declare class PencilEraserShape extends BaseShapeTool {
37
37
  }): {
38
38
  workId: string;
39
39
  toolsType: EToolsKey;
40
- opt: {
41
- matrix: import("../utils").AffineMatrix;
42
- fontColor: string;
43
- fontSize: number;
44
- text: string;
45
- textAlign: import("../../component/textEditor").TextAlignType;
46
- verticalAlign: import("../../component/textEditor").VerticalAlignType;
47
- lineHeight?: number;
48
- fontFamily?: string;
49
- bold?: import("../../component/textEditor").FontWeightType;
50
- italic?: import("../../component/textEditor").FontStyleType;
51
- fontBgColor?: string;
52
- underline?: boolean;
53
- lineThrough?: boolean;
54
- boxPoint?: [number, number];
55
- boxSize?: [number, number];
56
- workState?: import("..").EventWorkState;
57
- uid?: string;
58
- isOpacity?: boolean;
59
- strokeColor?: string;
60
- fillColor?: string;
61
- vertex?: string;
62
- fragment?: string;
63
- syncUnitTime?: number;
64
- zIndex?: number;
65
- scale?: [number, number];
66
- rotate?: number;
67
- thickness?: number;
68
- textOpt?: import("../../component/textEditor").TextOptions;
69
- translate?: [number, number];
70
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
71
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
72
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
73
- lineCap?: "square" | "round";
74
- lineDash?: [number, number];
75
- } | {
76
- matrix: import("../utils").AffineMatrix;
77
- thickness: number;
78
- strokeColor: string;
79
- strokeType: import("../..").EStrokeType;
80
- autoShape?: boolean;
81
- previewLocalOnly?: boolean;
82
- isOpacity?: boolean;
83
- fontColor?: string;
84
- fontBgColor?: string;
85
- fillColor?: string;
86
- vertex?: string;
87
- fragment?: string;
88
- syncUnitTime?: number;
89
- zIndex?: number;
90
- scale?: [number, number];
91
- rotate?: number;
92
- textOpt?: import("../../component/textEditor").TextOptions;
93
- translate?: [number, number];
94
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
95
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
96
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
97
- lineCap?: "square" | "round";
98
- lineDash?: [number, number];
99
- } | {
100
- matrix: import("../utils").AffineMatrix;
101
- thickness: number;
102
- duration: number;
103
- strokeColor: string;
104
- strokeType: Omit<import("../..").EStrokeType, "Stroke">;
105
- isOpacity?: boolean;
106
- fontColor?: string;
107
- fontBgColor?: string;
108
- fillColor?: string;
109
- vertex?: string;
110
- fragment?: string;
111
- syncUnitTime?: number;
112
- zIndex?: number;
113
- scale?: [number, number];
114
- rotate?: number;
115
- textOpt?: import("../../component/textEditor").TextOptions;
116
- translate?: [number, number];
117
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
118
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
119
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
120
- lineCap?: "square" | "round";
121
- lineDash?: [number, number];
122
- } | {
123
- matrix: import("../utils").AffineMatrix;
124
- thickness: number;
125
- isOpacity?: boolean;
126
- fontColor?: string;
127
- fontBgColor?: string;
128
- strokeColor?: string;
129
- fillColor?: string;
130
- vertex?: string;
131
- fragment?: string;
132
- syncUnitTime?: number;
133
- zIndex?: number;
134
- scale?: [number, number];
135
- rotate?: number;
136
- textOpt?: import("../../component/textEditor").TextOptions;
137
- translate?: [number, number];
138
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
139
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
140
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
141
- lineCap?: "square" | "round";
142
- lineDash?: [number, number];
143
- } | {
144
- matrix: import("../utils").AffineMatrix;
145
- thickness: number;
146
- maxImageWidth?: number;
147
- maxImageHeight?: number;
148
- removeOnDone?: boolean;
149
- isOpacity?: boolean;
150
- fontColor?: string;
151
- fontBgColor?: string;
152
- strokeColor?: string;
153
- fillColor?: string;
154
- vertex?: string;
155
- fragment?: string;
156
- syncUnitTime?: number;
157
- zIndex?: number;
158
- scale?: [number, number];
159
- rotate?: number;
160
- textOpt?: import("../../component/textEditor").TextOptions;
161
- translate?: [number, number];
162
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
163
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
164
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
165
- lineCap?: "square" | "round";
166
- lineDash?: [number, number];
167
- } | {
168
- matrix: import("../utils").AffineMatrix;
169
- thickness: number;
170
- isOpacity?: boolean;
171
- fontColor?: string;
172
- fontBgColor?: string;
173
- strokeColor?: string;
174
- fillColor?: string;
175
- vertex?: string;
176
- fragment?: string;
177
- syncUnitTime?: number;
178
- zIndex?: number;
179
- scale?: [number, number];
180
- rotate?: number;
181
- textOpt?: import("../../component/textEditor").TextOptions;
182
- translate?: [number, number];
183
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
184
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
185
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
186
- lineCap?: "square" | "round";
187
- lineDash?: [number, number];
188
- } | {
189
- matrix: import("../utils").AffineMatrix;
190
- thickness: number;
191
- vertices: number;
192
- innerVerticeStep: number;
193
- innerRatio: number;
194
- strokeColor: string;
195
- fillColor: string;
196
- strokeType: import("../..").EStrokeType;
197
- isOpacity?: boolean;
198
- fontColor?: string;
199
- fontBgColor?: string;
200
- vertex?: string;
201
- fragment?: string;
202
- syncUnitTime?: number;
203
- zIndex?: number;
204
- scale?: [number, number];
205
- rotate?: number;
206
- textOpt?: import("../../component/textEditor").TextOptions;
207
- translate?: [number, number];
208
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
209
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
210
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
211
- lineCap?: "square" | "round";
212
- lineDash?: [number, number];
213
- } | {
214
- matrix: import("../utils").AffineMatrix;
215
- isOpacity?: boolean;
216
- fontColor?: string;
217
- fontBgColor?: string;
218
- strokeColor?: string;
219
- fillColor?: string;
220
- vertex?: string;
221
- fragment?: string;
222
- syncUnitTime?: number;
223
- zIndex?: number;
224
- scale?: [number, number];
225
- rotate?: number;
226
- thickness?: number;
227
- textOpt?: import("../../component/textEditor").TextOptions;
228
- translate?: [number, number];
229
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
230
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
231
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
232
- lineCap?: "square" | "round";
233
- lineDash?: [number, number];
234
- } | {
235
- matrix: import("../utils").AffineMatrix;
236
- thickness: number;
237
- strokeColor: string;
238
- strokeType: import("../..").EStrokeType;
239
- isOpacity?: boolean;
240
- fontColor?: string;
241
- fontBgColor?: string;
242
- fillColor?: string;
243
- vertex?: string;
244
- fragment?: string;
245
- syncUnitTime?: number;
246
- zIndex?: number;
247
- scale?: [number, number];
248
- rotate?: number;
249
- textOpt?: import("../../component/textEditor").TextOptions;
250
- translate?: [number, number];
251
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
252
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
253
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
254
- lineCap?: "square" | "round";
255
- lineDash?: [number, number];
256
- } | {
257
- matrix: import("../utils").AffineMatrix;
258
- thickness: number;
259
- strokeColor: string;
260
- fillColor: string;
261
- strokeType: import("../..").EStrokeType;
262
- isOpacity?: boolean;
263
- fontColor?: string;
264
- fontBgColor?: string;
265
- vertex?: string;
266
- fragment?: string;
267
- syncUnitTime?: number;
268
- zIndex?: number;
269
- scale?: [number, number];
270
- rotate?: number;
271
- textOpt?: import("../../component/textEditor").TextOptions;
272
- translate?: [number, number];
273
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
274
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
275
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
276
- lineCap?: "square" | "round";
277
- lineDash?: [number, number];
278
- } | {
279
- matrix: import("../utils").AffineMatrix;
280
- thickness: number;
281
- strokeColor: string;
282
- fillColor: string;
283
- strokeType: import("../..").EStrokeType;
284
- isOpacity?: boolean;
285
- fontColor?: string;
286
- fontBgColor?: string;
287
- vertex?: string;
288
- fragment?: string;
289
- syncUnitTime?: number;
290
- zIndex?: number;
291
- scale?: [number, number];
292
- rotate?: number;
293
- textOpt?: import("../../component/textEditor").TextOptions;
294
- translate?: [number, number];
295
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
296
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
297
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
298
- lineCap?: "square" | "round";
299
- lineDash?: [number, number];
300
- } | {
301
- matrix: import("../utils").AffineMatrix;
302
- thickness: number;
303
- vertices: number;
304
- strokeColor: string;
305
- fillColor: string;
306
- strokeType: import("../..").EStrokeType;
307
- isOpacity?: boolean;
308
- fontColor?: string;
309
- fontBgColor?: string;
310
- vertex?: string;
311
- fragment?: string;
312
- syncUnitTime?: number;
313
- zIndex?: number;
314
- scale?: [number, number];
315
- rotate?: number;
316
- textOpt?: import("../../component/textEditor").TextOptions;
317
- translate?: [number, number];
318
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
319
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
320
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
321
- lineCap?: "square" | "round";
322
- lineDash?: [number, number];
323
- } | {
324
- matrix: import("../utils").AffineMatrix;
325
- thickness: number;
326
- strokeColor: string;
327
- strokeType: import("../..").EStrokeType;
328
- isOpacity?: boolean;
329
- fontColor?: string;
330
- fontBgColor?: string;
331
- fillColor?: string;
332
- vertex?: string;
333
- fragment?: string;
334
- syncUnitTime?: number;
335
- zIndex?: number;
336
- scale?: [number, number];
337
- rotate?: number;
338
- textOpt?: import("../../component/textEditor").TextOptions;
339
- translate?: [number, number];
340
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
341
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
342
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
343
- lineCap?: "square" | "round";
344
- lineDash?: [number, number];
345
- } | {
346
- matrix: import("../utils").AffineMatrix;
347
- thickness: number;
348
- placement: import("../..").SpeechBalloonPlacement;
349
- strokeColor: string;
350
- fillColor: string;
351
- strokeType: import("../..").EStrokeType;
352
- isOpacity?: boolean;
353
- fontColor?: string;
354
- fontBgColor?: string;
355
- vertex?: string;
356
- fragment?: string;
357
- syncUnitTime?: number;
358
- zIndex?: number;
359
- scale?: [number, number];
360
- rotate?: number;
361
- textOpt?: import("../../component/textEditor").TextOptions;
362
- translate?: [number, number];
363
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
364
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
365
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
366
- lineCap?: "square" | "round";
367
- lineDash?: [number, number];
368
- } | {
369
- matrix: import("../utils").AffineMatrix;
370
- src: string;
371
- type: import("..").EImageType;
372
- uuid: string;
373
- centerX: number;
374
- centerY: number;
375
- width: number;
376
- height: number;
377
- locked: boolean;
378
- uniformScale?: boolean;
379
- crossOrigin?: boolean | string;
380
- isOpacity?: boolean;
381
- fontColor?: string;
382
- fontBgColor?: string;
383
- strokeColor?: string;
384
- fillColor?: string;
385
- vertex?: string;
386
- fragment?: string;
387
- syncUnitTime?: number;
388
- zIndex?: number;
389
- scale?: [number, number];
390
- rotate?: number;
391
- thickness?: number;
392
- textOpt?: import("../../component/textEditor").TextOptions;
393
- translate?: [number, number];
394
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
395
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
396
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
397
- lineCap?: "square" | "round";
398
- lineDash?: [number, number];
399
- } | {
400
- matrix: import("../utils").AffineMatrix;
401
- type: import("..").ESVGType.url;
402
- src: string;
403
- crossOrigin: boolean | string;
404
- uuid: string;
405
- centerX: number;
406
- centerY: number;
407
- width: number;
408
- height: number;
409
- locked: boolean;
410
- uniformScale: boolean;
411
- state?: unknown;
412
- isOpacity?: boolean;
413
- fontColor?: string;
414
- fontBgColor?: string;
415
- strokeColor?: string;
416
- fillColor?: string;
417
- vertex?: string;
418
- fragment?: string;
419
- syncUnitTime?: number;
420
- zIndex?: number;
421
- scale?: [number, number];
422
- rotate?: number;
423
- thickness?: number;
424
- textOpt?: import("../../component/textEditor").TextOptions;
425
- translate?: [number, number];
426
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
427
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
428
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
429
- lineCap?: "square" | "round";
430
- lineDash?: [number, number];
431
- } | {
432
- matrix: import("../utils").AffineMatrix;
433
- type: import("..").ESVGType.markmap;
434
- data: string;
435
- uuid: string;
436
- centerX: number;
437
- centerY: number;
438
- width: number;
439
- height: number;
440
- locked: boolean;
441
- uniformScale: boolean;
442
- state?: unknown;
443
- isOpacity?: boolean;
444
- fontColor?: string;
445
- fontBgColor?: string;
446
- strokeColor?: string;
447
- fillColor?: string;
448
- vertex?: string;
449
- fragment?: string;
450
- syncUnitTime?: number;
451
- zIndex?: number;
452
- scale?: [number, number];
453
- rotate?: number;
454
- thickness?: number;
455
- textOpt?: import("../../component/textEditor").TextOptions;
456
- translate?: [number, number];
457
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
458
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
459
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
460
- lineCap?: "square" | "round";
461
- lineDash?: [number, number];
462
- };
40
+ opt: import("./utils").ShapeOptions;
463
41
  type: EPostMessageType;
464
42
  };
465
43
  private computEraserPointLines;
@@ -468,857 +46,13 @@ export declare class PencilEraserShape extends BaseShapeTool {
468
46
  }): {
469
47
  workId: string;
470
48
  toolsType: EToolsKey;
471
- opt: {
472
- matrix: import("../utils").AffineMatrix;
473
- fontColor: string;
474
- fontSize: number;
475
- text: string;
476
- textAlign: import("../../component/textEditor").TextAlignType;
477
- verticalAlign: import("../../component/textEditor").VerticalAlignType;
478
- lineHeight?: number;
479
- fontFamily?: string;
480
- bold?: import("../../component/textEditor").FontWeightType;
481
- italic?: import("../../component/textEditor").FontStyleType;
482
- fontBgColor?: string;
483
- underline?: boolean;
484
- lineThrough?: boolean;
485
- boxPoint?: [number, number];
486
- boxSize?: [number, number];
487
- workState?: import("..").EventWorkState;
488
- uid?: string;
489
- isOpacity?: boolean;
490
- strokeColor?: string;
491
- fillColor?: string;
492
- vertex?: string;
493
- fragment?: string;
494
- syncUnitTime?: number;
495
- zIndex?: number;
496
- scale?: [number, number];
497
- rotate?: number;
498
- thickness?: number;
499
- textOpt?: import("../../component/textEditor").TextOptions;
500
- translate?: [number, number];
501
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
502
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
503
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
504
- lineCap?: "square" | "round";
505
- lineDash?: [number, number];
506
- } | {
507
- matrix: import("../utils").AffineMatrix;
508
- thickness: number;
509
- strokeColor: string;
510
- strokeType: import("../..").EStrokeType;
511
- autoShape?: boolean;
512
- previewLocalOnly?: boolean;
513
- isOpacity?: boolean;
514
- fontColor?: string;
515
- fontBgColor?: string;
516
- fillColor?: string;
517
- vertex?: string;
518
- fragment?: string;
519
- syncUnitTime?: number;
520
- zIndex?: number;
521
- scale?: [number, number];
522
- rotate?: number;
523
- textOpt?: import("../../component/textEditor").TextOptions;
524
- translate?: [number, number];
525
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
526
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
527
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
528
- lineCap?: "square" | "round";
529
- lineDash?: [number, number];
530
- } | {
531
- matrix: import("../utils").AffineMatrix;
532
- thickness: number;
533
- duration: number;
534
- strokeColor: string;
535
- strokeType: Omit<import("../..").EStrokeType, "Stroke">;
536
- isOpacity?: boolean;
537
- fontColor?: string;
538
- fontBgColor?: string;
539
- fillColor?: string;
540
- vertex?: string;
541
- fragment?: string;
542
- syncUnitTime?: number;
543
- zIndex?: number;
544
- scale?: [number, number];
545
- rotate?: number;
546
- textOpt?: import("../../component/textEditor").TextOptions;
547
- translate?: [number, number];
548
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
549
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
550
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
551
- lineCap?: "square" | "round";
552
- lineDash?: [number, number];
553
- } | {
554
- matrix: import("../utils").AffineMatrix;
555
- thickness: number;
556
- isOpacity?: boolean;
557
- fontColor?: string;
558
- fontBgColor?: string;
559
- strokeColor?: string;
560
- fillColor?: string;
561
- vertex?: string;
562
- fragment?: string;
563
- syncUnitTime?: number;
564
- zIndex?: number;
565
- scale?: [number, number];
566
- rotate?: number;
567
- textOpt?: import("../../component/textEditor").TextOptions;
568
- translate?: [number, number];
569
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
570
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
571
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
572
- lineCap?: "square" | "round";
573
- lineDash?: [number, number];
574
- } | {
575
- matrix: import("../utils").AffineMatrix;
576
- thickness: number;
577
- maxImageWidth?: number;
578
- maxImageHeight?: number;
579
- removeOnDone?: boolean;
580
- isOpacity?: boolean;
581
- fontColor?: string;
582
- fontBgColor?: string;
583
- strokeColor?: string;
584
- fillColor?: string;
585
- vertex?: string;
586
- fragment?: string;
587
- syncUnitTime?: number;
588
- zIndex?: number;
589
- scale?: [number, number];
590
- rotate?: number;
591
- textOpt?: import("../../component/textEditor").TextOptions;
592
- translate?: [number, number];
593
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
594
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
595
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
596
- lineCap?: "square" | "round";
597
- lineDash?: [number, number];
598
- } | {
599
- matrix: import("../utils").AffineMatrix;
600
- thickness: number;
601
- isOpacity?: boolean;
602
- fontColor?: string;
603
- fontBgColor?: string;
604
- strokeColor?: string;
605
- fillColor?: string;
606
- vertex?: string;
607
- fragment?: string;
608
- syncUnitTime?: number;
609
- zIndex?: number;
610
- scale?: [number, number];
611
- rotate?: number;
612
- textOpt?: import("../../component/textEditor").TextOptions;
613
- translate?: [number, number];
614
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
615
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
616
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
617
- lineCap?: "square" | "round";
618
- lineDash?: [number, number];
619
- } | {
620
- matrix: import("../utils").AffineMatrix;
621
- thickness: number;
622
- vertices: number;
623
- innerVerticeStep: number;
624
- innerRatio: number;
625
- strokeColor: string;
626
- fillColor: string;
627
- strokeType: import("../..").EStrokeType;
628
- isOpacity?: boolean;
629
- fontColor?: string;
630
- fontBgColor?: string;
631
- vertex?: string;
632
- fragment?: string;
633
- syncUnitTime?: number;
634
- zIndex?: number;
635
- scale?: [number, number];
636
- rotate?: number;
637
- textOpt?: import("../../component/textEditor").TextOptions;
638
- translate?: [number, number];
639
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
640
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
641
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
642
- lineCap?: "square" | "round";
643
- lineDash?: [number, number];
644
- } | {
645
- matrix: import("../utils").AffineMatrix;
646
- isOpacity?: boolean;
647
- fontColor?: string;
648
- fontBgColor?: string;
649
- strokeColor?: string;
650
- fillColor?: string;
651
- vertex?: string;
652
- fragment?: string;
653
- syncUnitTime?: number;
654
- zIndex?: number;
655
- scale?: [number, number];
656
- rotate?: number;
657
- thickness?: number;
658
- textOpt?: import("../../component/textEditor").TextOptions;
659
- translate?: [number, number];
660
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
661
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
662
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
663
- lineCap?: "square" | "round";
664
- lineDash?: [number, number];
665
- } | {
666
- matrix: import("../utils").AffineMatrix;
667
- thickness: number;
668
- strokeColor: string;
669
- strokeType: import("../..").EStrokeType;
670
- isOpacity?: boolean;
671
- fontColor?: string;
672
- fontBgColor?: string;
673
- fillColor?: string;
674
- vertex?: string;
675
- fragment?: string;
676
- syncUnitTime?: number;
677
- zIndex?: number;
678
- scale?: [number, number];
679
- rotate?: number;
680
- textOpt?: import("../../component/textEditor").TextOptions;
681
- translate?: [number, number];
682
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
683
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
684
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
685
- lineCap?: "square" | "round";
686
- lineDash?: [number, number];
687
- } | {
688
- matrix: import("../utils").AffineMatrix;
689
- thickness: number;
690
- strokeColor: string;
691
- fillColor: string;
692
- strokeType: import("../..").EStrokeType;
693
- isOpacity?: boolean;
694
- fontColor?: string;
695
- fontBgColor?: string;
696
- vertex?: string;
697
- fragment?: string;
698
- syncUnitTime?: number;
699
- zIndex?: number;
700
- scale?: [number, number];
701
- rotate?: number;
702
- textOpt?: import("../../component/textEditor").TextOptions;
703
- translate?: [number, number];
704
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
705
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
706
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
707
- lineCap?: "square" | "round";
708
- lineDash?: [number, number];
709
- } | {
710
- matrix: import("../utils").AffineMatrix;
711
- thickness: number;
712
- strokeColor: string;
713
- fillColor: string;
714
- strokeType: import("../..").EStrokeType;
715
- isOpacity?: boolean;
716
- fontColor?: string;
717
- fontBgColor?: string;
718
- vertex?: string;
719
- fragment?: string;
720
- syncUnitTime?: number;
721
- zIndex?: number;
722
- scale?: [number, number];
723
- rotate?: number;
724
- textOpt?: import("../../component/textEditor").TextOptions;
725
- translate?: [number, number];
726
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
727
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
728
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
729
- lineCap?: "square" | "round";
730
- lineDash?: [number, number];
731
- } | {
732
- matrix: import("../utils").AffineMatrix;
733
- thickness: number;
734
- vertices: number;
735
- strokeColor: string;
736
- fillColor: string;
737
- strokeType: import("../..").EStrokeType;
738
- isOpacity?: boolean;
739
- fontColor?: string;
740
- fontBgColor?: string;
741
- vertex?: string;
742
- fragment?: string;
743
- syncUnitTime?: number;
744
- zIndex?: number;
745
- scale?: [number, number];
746
- rotate?: number;
747
- textOpt?: import("../../component/textEditor").TextOptions;
748
- translate?: [number, number];
749
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
750
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
751
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
752
- lineCap?: "square" | "round";
753
- lineDash?: [number, number];
754
- } | {
755
- matrix: import("../utils").AffineMatrix;
756
- thickness: number;
757
- strokeColor: string;
758
- strokeType: import("../..").EStrokeType;
759
- isOpacity?: boolean;
760
- fontColor?: string;
761
- fontBgColor?: string;
762
- fillColor?: string;
763
- vertex?: string;
764
- fragment?: string;
765
- syncUnitTime?: number;
766
- zIndex?: number;
767
- scale?: [number, number];
768
- rotate?: number;
769
- textOpt?: import("../../component/textEditor").TextOptions;
770
- translate?: [number, number];
771
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
772
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
773
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
774
- lineCap?: "square" | "round";
775
- lineDash?: [number, number];
776
- } | {
777
- matrix: import("../utils").AffineMatrix;
778
- thickness: number;
779
- placement: import("../..").SpeechBalloonPlacement;
780
- strokeColor: string;
781
- fillColor: string;
782
- strokeType: import("../..").EStrokeType;
783
- isOpacity?: boolean;
784
- fontColor?: string;
785
- fontBgColor?: string;
786
- vertex?: string;
787
- fragment?: string;
788
- syncUnitTime?: number;
789
- zIndex?: number;
790
- scale?: [number, number];
791
- rotate?: number;
792
- textOpt?: import("../../component/textEditor").TextOptions;
793
- translate?: [number, number];
794
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
795
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
796
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
797
- lineCap?: "square" | "round";
798
- lineDash?: [number, number];
799
- } | {
800
- matrix: import("../utils").AffineMatrix;
801
- src: string;
802
- type: import("..").EImageType;
803
- uuid: string;
804
- centerX: number;
805
- centerY: number;
806
- width: number;
807
- height: number;
808
- locked: boolean;
809
- uniformScale?: boolean;
810
- crossOrigin?: boolean | string;
811
- isOpacity?: boolean;
812
- fontColor?: string;
813
- fontBgColor?: string;
814
- strokeColor?: string;
815
- fillColor?: string;
816
- vertex?: string;
817
- fragment?: string;
818
- syncUnitTime?: number;
819
- zIndex?: number;
820
- scale?: [number, number];
821
- rotate?: number;
822
- thickness?: number;
823
- textOpt?: import("../../component/textEditor").TextOptions;
824
- translate?: [number, number];
825
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
826
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
827
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
828
- lineCap?: "square" | "round";
829
- lineDash?: [number, number];
830
- } | {
831
- matrix: import("../utils").AffineMatrix;
832
- type: import("..").ESVGType.url;
833
- src: string;
834
- crossOrigin: boolean | string;
835
- uuid: string;
836
- centerX: number;
837
- centerY: number;
838
- width: number;
839
- height: number;
840
- locked: boolean;
841
- uniformScale: boolean;
842
- state?: unknown;
843
- isOpacity?: boolean;
844
- fontColor?: string;
845
- fontBgColor?: string;
846
- strokeColor?: string;
847
- fillColor?: string;
848
- vertex?: string;
849
- fragment?: string;
850
- syncUnitTime?: number;
851
- zIndex?: number;
852
- scale?: [number, number];
853
- rotate?: number;
854
- thickness?: number;
855
- textOpt?: import("../../component/textEditor").TextOptions;
856
- translate?: [number, number];
857
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
858
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
859
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
860
- lineCap?: "square" | "round";
861
- lineDash?: [number, number];
862
- } | {
863
- matrix: import("../utils").AffineMatrix;
864
- type: import("..").ESVGType.markmap;
865
- data: string;
866
- uuid: string;
867
- centerX: number;
868
- centerY: number;
869
- width: number;
870
- height: number;
871
- locked: boolean;
872
- uniformScale: boolean;
873
- state?: unknown;
874
- isOpacity?: boolean;
875
- fontColor?: string;
876
- fontBgColor?: string;
877
- strokeColor?: string;
878
- fillColor?: string;
879
- vertex?: string;
880
- fragment?: string;
881
- syncUnitTime?: number;
882
- zIndex?: number;
883
- scale?: [number, number];
884
- rotate?: number;
885
- thickness?: number;
886
- textOpt?: import("../../component/textEditor").TextOptions;
887
- translate?: [number, number];
888
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
889
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
890
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
891
- lineCap?: "square" | "round";
892
- lineDash?: [number, number];
893
- };
49
+ opt: import("./utils").ShapeOptions;
894
50
  type: EPostMessageType;
895
51
  } | {
896
52
  rect: IRectType | undefined;
897
53
  workId: string;
898
54
  toolsType: EToolsKey;
899
- opt: {
900
- matrix: import("../utils").AffineMatrix;
901
- fontColor: string;
902
- fontSize: number;
903
- text: string;
904
- textAlign: import("../../component/textEditor").TextAlignType;
905
- verticalAlign: import("../../component/textEditor").VerticalAlignType;
906
- lineHeight?: number;
907
- fontFamily?: string;
908
- bold?: import("../../component/textEditor").FontWeightType;
909
- italic?: import("../../component/textEditor").FontStyleType;
910
- fontBgColor?: string;
911
- underline?: boolean;
912
- lineThrough?: boolean;
913
- boxPoint?: [number, number];
914
- boxSize?: [number, number];
915
- workState?: import("..").EventWorkState;
916
- uid?: string;
917
- isOpacity?: boolean;
918
- strokeColor?: string;
919
- fillColor?: string;
920
- vertex?: string;
921
- fragment?: string;
922
- syncUnitTime?: number;
923
- zIndex?: number;
924
- scale?: [number, number];
925
- rotate?: number;
926
- thickness?: number;
927
- textOpt?: import("../../component/textEditor").TextOptions;
928
- translate?: [number, number];
929
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
930
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
931
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
932
- lineCap?: "square" | "round";
933
- lineDash?: [number, number];
934
- } | {
935
- matrix: import("../utils").AffineMatrix;
936
- thickness: number;
937
- strokeColor: string;
938
- strokeType: import("../..").EStrokeType;
939
- autoShape?: boolean;
940
- previewLocalOnly?: boolean;
941
- isOpacity?: boolean;
942
- fontColor?: string;
943
- fontBgColor?: string;
944
- fillColor?: string;
945
- vertex?: string;
946
- fragment?: string;
947
- syncUnitTime?: number;
948
- zIndex?: number;
949
- scale?: [number, number];
950
- rotate?: number;
951
- textOpt?: import("../../component/textEditor").TextOptions;
952
- translate?: [number, number];
953
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
954
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
955
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
956
- lineCap?: "square" | "round";
957
- lineDash?: [number, number];
958
- } | {
959
- matrix: import("../utils").AffineMatrix;
960
- thickness: number;
961
- duration: number;
962
- strokeColor: string;
963
- strokeType: Omit<import("../..").EStrokeType, "Stroke">;
964
- isOpacity?: boolean;
965
- fontColor?: string;
966
- fontBgColor?: string;
967
- fillColor?: string;
968
- vertex?: string;
969
- fragment?: string;
970
- syncUnitTime?: number;
971
- zIndex?: number;
972
- scale?: [number, number];
973
- rotate?: number;
974
- textOpt?: import("../../component/textEditor").TextOptions;
975
- translate?: [number, number];
976
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
977
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
978
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
979
- lineCap?: "square" | "round";
980
- lineDash?: [number, number];
981
- } | {
982
- matrix: import("../utils").AffineMatrix;
983
- thickness: number;
984
- isOpacity?: boolean;
985
- fontColor?: string;
986
- fontBgColor?: string;
987
- strokeColor?: string;
988
- fillColor?: string;
989
- vertex?: string;
990
- fragment?: string;
991
- syncUnitTime?: number;
992
- zIndex?: number;
993
- scale?: [number, number];
994
- rotate?: number;
995
- textOpt?: import("../../component/textEditor").TextOptions;
996
- translate?: [number, number];
997
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
998
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
999
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1000
- lineCap?: "square" | "round";
1001
- lineDash?: [number, number];
1002
- } | {
1003
- matrix: import("../utils").AffineMatrix;
1004
- thickness: number;
1005
- maxImageWidth?: number;
1006
- maxImageHeight?: number;
1007
- removeOnDone?: boolean;
1008
- isOpacity?: boolean;
1009
- fontColor?: string;
1010
- fontBgColor?: string;
1011
- strokeColor?: string;
1012
- fillColor?: string;
1013
- vertex?: string;
1014
- fragment?: string;
1015
- syncUnitTime?: number;
1016
- zIndex?: number;
1017
- scale?: [number, number];
1018
- rotate?: number;
1019
- textOpt?: import("../../component/textEditor").TextOptions;
1020
- translate?: [number, number];
1021
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1022
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1023
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1024
- lineCap?: "square" | "round";
1025
- lineDash?: [number, number];
1026
- } | {
1027
- matrix: import("../utils").AffineMatrix;
1028
- thickness: number;
1029
- isOpacity?: boolean;
1030
- fontColor?: string;
1031
- fontBgColor?: string;
1032
- strokeColor?: string;
1033
- fillColor?: string;
1034
- vertex?: string;
1035
- fragment?: string;
1036
- syncUnitTime?: number;
1037
- zIndex?: number;
1038
- scale?: [number, number];
1039
- rotate?: number;
1040
- textOpt?: import("../../component/textEditor").TextOptions;
1041
- translate?: [number, number];
1042
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1043
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1044
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1045
- lineCap?: "square" | "round";
1046
- lineDash?: [number, number];
1047
- } | {
1048
- matrix: import("../utils").AffineMatrix;
1049
- thickness: number;
1050
- vertices: number;
1051
- innerVerticeStep: number;
1052
- innerRatio: number;
1053
- strokeColor: string;
1054
- fillColor: string;
1055
- strokeType: import("../..").EStrokeType;
1056
- isOpacity?: boolean;
1057
- fontColor?: string;
1058
- fontBgColor?: string;
1059
- vertex?: string;
1060
- fragment?: string;
1061
- syncUnitTime?: number;
1062
- zIndex?: number;
1063
- scale?: [number, number];
1064
- rotate?: number;
1065
- textOpt?: import("../../component/textEditor").TextOptions;
1066
- translate?: [number, number];
1067
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1068
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1069
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1070
- lineCap?: "square" | "round";
1071
- lineDash?: [number, number];
1072
- } | {
1073
- matrix: import("../utils").AffineMatrix;
1074
- isOpacity?: boolean;
1075
- fontColor?: string;
1076
- fontBgColor?: string;
1077
- strokeColor?: string;
1078
- fillColor?: string;
1079
- vertex?: string;
1080
- fragment?: string;
1081
- syncUnitTime?: number;
1082
- zIndex?: number;
1083
- scale?: [number, number];
1084
- rotate?: number;
1085
- thickness?: number;
1086
- textOpt?: import("../../component/textEditor").TextOptions;
1087
- translate?: [number, number];
1088
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1089
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1090
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1091
- lineCap?: "square" | "round";
1092
- lineDash?: [number, number];
1093
- } | {
1094
- matrix: import("../utils").AffineMatrix;
1095
- thickness: number;
1096
- strokeColor: string;
1097
- strokeType: import("../..").EStrokeType;
1098
- isOpacity?: boolean;
1099
- fontColor?: string;
1100
- fontBgColor?: string;
1101
- fillColor?: string;
1102
- vertex?: string;
1103
- fragment?: string;
1104
- syncUnitTime?: number;
1105
- zIndex?: number;
1106
- scale?: [number, number];
1107
- rotate?: number;
1108
- textOpt?: import("../../component/textEditor").TextOptions;
1109
- translate?: [number, number];
1110
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1111
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1112
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1113
- lineCap?: "square" | "round";
1114
- lineDash?: [number, number];
1115
- } | {
1116
- matrix: import("../utils").AffineMatrix;
1117
- thickness: number;
1118
- strokeColor: string;
1119
- fillColor: string;
1120
- strokeType: import("../..").EStrokeType;
1121
- isOpacity?: boolean;
1122
- fontColor?: string;
1123
- fontBgColor?: string;
1124
- vertex?: string;
1125
- fragment?: string;
1126
- syncUnitTime?: number;
1127
- zIndex?: number;
1128
- scale?: [number, number];
1129
- rotate?: number;
1130
- textOpt?: import("../../component/textEditor").TextOptions;
1131
- translate?: [number, number];
1132
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1133
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1134
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1135
- lineCap?: "square" | "round";
1136
- lineDash?: [number, number];
1137
- } | {
1138
- matrix: import("../utils").AffineMatrix;
1139
- thickness: number;
1140
- strokeColor: string;
1141
- fillColor: string;
1142
- strokeType: import("../..").EStrokeType;
1143
- isOpacity?: boolean;
1144
- fontColor?: string;
1145
- fontBgColor?: string;
1146
- vertex?: string;
1147
- fragment?: string;
1148
- syncUnitTime?: number;
1149
- zIndex?: number;
1150
- scale?: [number, number];
1151
- rotate?: number;
1152
- textOpt?: import("../../component/textEditor").TextOptions;
1153
- translate?: [number, number];
1154
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1155
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1156
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1157
- lineCap?: "square" | "round";
1158
- lineDash?: [number, number];
1159
- } | {
1160
- matrix: import("../utils").AffineMatrix;
1161
- thickness: number;
1162
- vertices: number;
1163
- strokeColor: string;
1164
- fillColor: string;
1165
- strokeType: import("../..").EStrokeType;
1166
- isOpacity?: boolean;
1167
- fontColor?: string;
1168
- fontBgColor?: string;
1169
- vertex?: string;
1170
- fragment?: string;
1171
- syncUnitTime?: number;
1172
- zIndex?: number;
1173
- scale?: [number, number];
1174
- rotate?: number;
1175
- textOpt?: import("../../component/textEditor").TextOptions;
1176
- translate?: [number, number];
1177
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1178
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1179
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1180
- lineCap?: "square" | "round";
1181
- lineDash?: [number, number];
1182
- } | {
1183
- matrix: import("../utils").AffineMatrix;
1184
- thickness: number;
1185
- strokeColor: string;
1186
- strokeType: import("../..").EStrokeType;
1187
- isOpacity?: boolean;
1188
- fontColor?: string;
1189
- fontBgColor?: string;
1190
- fillColor?: string;
1191
- vertex?: string;
1192
- fragment?: string;
1193
- syncUnitTime?: number;
1194
- zIndex?: number;
1195
- scale?: [number, number];
1196
- rotate?: number;
1197
- textOpt?: import("../../component/textEditor").TextOptions;
1198
- translate?: [number, number];
1199
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1200
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1201
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1202
- lineCap?: "square" | "round";
1203
- lineDash?: [number, number];
1204
- } | {
1205
- matrix: import("../utils").AffineMatrix;
1206
- thickness: number;
1207
- placement: import("../..").SpeechBalloonPlacement;
1208
- strokeColor: string;
1209
- fillColor: string;
1210
- strokeType: import("../..").EStrokeType;
1211
- isOpacity?: boolean;
1212
- fontColor?: string;
1213
- fontBgColor?: string;
1214
- vertex?: string;
1215
- fragment?: string;
1216
- syncUnitTime?: number;
1217
- zIndex?: number;
1218
- scale?: [number, number];
1219
- rotate?: number;
1220
- textOpt?: import("../../component/textEditor").TextOptions;
1221
- translate?: [number, number];
1222
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1223
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1224
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1225
- lineCap?: "square" | "round";
1226
- lineDash?: [number, number];
1227
- } | {
1228
- matrix: import("../utils").AffineMatrix;
1229
- src: string;
1230
- type: import("..").EImageType;
1231
- uuid: string;
1232
- centerX: number;
1233
- centerY: number;
1234
- width: number;
1235
- height: number;
1236
- locked: boolean;
1237
- uniformScale?: boolean;
1238
- crossOrigin?: boolean | string;
1239
- isOpacity?: boolean;
1240
- fontColor?: string;
1241
- fontBgColor?: string;
1242
- strokeColor?: string;
1243
- fillColor?: string;
1244
- vertex?: string;
1245
- fragment?: string;
1246
- syncUnitTime?: number;
1247
- zIndex?: number;
1248
- scale?: [number, number];
1249
- rotate?: number;
1250
- thickness?: number;
1251
- textOpt?: import("../../component/textEditor").TextOptions;
1252
- translate?: [number, number];
1253
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1254
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1255
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1256
- lineCap?: "square" | "round";
1257
- lineDash?: [number, number];
1258
- } | {
1259
- matrix: import("../utils").AffineMatrix;
1260
- type: import("..").ESVGType.url;
1261
- src: string;
1262
- crossOrigin: boolean | string;
1263
- uuid: string;
1264
- centerX: number;
1265
- centerY: number;
1266
- width: number;
1267
- height: number;
1268
- locked: boolean;
1269
- uniformScale: boolean;
1270
- state?: unknown;
1271
- isOpacity?: boolean;
1272
- fontColor?: string;
1273
- fontBgColor?: string;
1274
- strokeColor?: string;
1275
- fillColor?: string;
1276
- vertex?: string;
1277
- fragment?: string;
1278
- syncUnitTime?: number;
1279
- zIndex?: number;
1280
- scale?: [number, number];
1281
- rotate?: number;
1282
- thickness?: number;
1283
- textOpt?: import("../../component/textEditor").TextOptions;
1284
- translate?: [number, number];
1285
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1286
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1287
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1288
- lineCap?: "square" | "round";
1289
- lineDash?: [number, number];
1290
- } | {
1291
- matrix: import("../utils").AffineMatrix;
1292
- type: import("..").ESVGType.markmap;
1293
- data: string;
1294
- uuid: string;
1295
- centerX: number;
1296
- centerY: number;
1297
- width: number;
1298
- height: number;
1299
- locked: boolean;
1300
- uniformScale: boolean;
1301
- state?: unknown;
1302
- isOpacity?: boolean;
1303
- fontColor?: string;
1304
- fontBgColor?: string;
1305
- strokeColor?: string;
1306
- fillColor?: string;
1307
- vertex?: string;
1308
- fragment?: string;
1309
- syncUnitTime?: number;
1310
- zIndex?: number;
1311
- scale?: [number, number];
1312
- rotate?: number;
1313
- thickness?: number;
1314
- textOpt?: import("../../component/textEditor").TextOptions;
1315
- translate?: [number, number];
1316
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1317
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1318
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1319
- lineCap?: "square" | "round";
1320
- lineDash?: [number, number];
1321
- };
55
+ opt: import("./utils").ShapeOptions;
1322
56
  type: EPostMessageType;
1323
57
  } | {
1324
58
  type: EPostMessageType;
@@ -1329,429 +63,7 @@ export declare class PencilEraserShape extends BaseShapeTool {
1329
63
  willDeleteNodes: Set<string>;
1330
64
  workId: string;
1331
65
  toolsType: EToolsKey;
1332
- opt: {
1333
- matrix: import("../utils").AffineMatrix;
1334
- fontColor: string;
1335
- fontSize: number;
1336
- text: string;
1337
- textAlign: import("../../component/textEditor").TextAlignType;
1338
- verticalAlign: import("../../component/textEditor").VerticalAlignType;
1339
- lineHeight?: number;
1340
- fontFamily?: string;
1341
- bold?: import("../../component/textEditor").FontWeightType;
1342
- italic?: import("../../component/textEditor").FontStyleType;
1343
- fontBgColor?: string;
1344
- underline?: boolean;
1345
- lineThrough?: boolean;
1346
- boxPoint?: [number, number];
1347
- boxSize?: [number, number];
1348
- workState?: import("..").EventWorkState;
1349
- uid?: string;
1350
- isOpacity?: boolean;
1351
- strokeColor?: string;
1352
- fillColor?: string;
1353
- vertex?: string;
1354
- fragment?: string;
1355
- syncUnitTime?: number;
1356
- zIndex?: number;
1357
- scale?: [number, number];
1358
- rotate?: number;
1359
- thickness?: number;
1360
- textOpt?: import("../../component/textEditor").TextOptions;
1361
- translate?: [number, number];
1362
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1363
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1364
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1365
- lineCap?: "square" | "round";
1366
- lineDash?: [number, number];
1367
- } | {
1368
- matrix: import("../utils").AffineMatrix;
1369
- thickness: number;
1370
- strokeColor: string;
1371
- strokeType: import("../..").EStrokeType;
1372
- autoShape?: boolean;
1373
- previewLocalOnly?: boolean;
1374
- isOpacity?: boolean;
1375
- fontColor?: string;
1376
- fontBgColor?: string;
1377
- fillColor?: string;
1378
- vertex?: string;
1379
- fragment?: string;
1380
- syncUnitTime?: number;
1381
- zIndex?: number;
1382
- scale?: [number, number];
1383
- rotate?: number;
1384
- textOpt?: import("../../component/textEditor").TextOptions;
1385
- translate?: [number, number];
1386
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1387
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1388
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1389
- lineCap?: "square" | "round";
1390
- lineDash?: [number, number];
1391
- } | {
1392
- matrix: import("../utils").AffineMatrix;
1393
- thickness: number;
1394
- duration: number;
1395
- strokeColor: string;
1396
- strokeType: Omit<import("../..").EStrokeType, "Stroke">;
1397
- isOpacity?: boolean;
1398
- fontColor?: string;
1399
- fontBgColor?: string;
1400
- fillColor?: string;
1401
- vertex?: string;
1402
- fragment?: string;
1403
- syncUnitTime?: number;
1404
- zIndex?: number;
1405
- scale?: [number, number];
1406
- rotate?: number;
1407
- textOpt?: import("../../component/textEditor").TextOptions;
1408
- translate?: [number, number];
1409
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1410
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1411
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1412
- lineCap?: "square" | "round";
1413
- lineDash?: [number, number];
1414
- } | {
1415
- matrix: import("../utils").AffineMatrix;
1416
- thickness: number;
1417
- isOpacity?: boolean;
1418
- fontColor?: string;
1419
- fontBgColor?: string;
1420
- strokeColor?: string;
1421
- fillColor?: string;
1422
- vertex?: string;
1423
- fragment?: string;
1424
- syncUnitTime?: number;
1425
- zIndex?: number;
1426
- scale?: [number, number];
1427
- rotate?: number;
1428
- textOpt?: import("../../component/textEditor").TextOptions;
1429
- translate?: [number, number];
1430
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1431
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1432
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1433
- lineCap?: "square" | "round";
1434
- lineDash?: [number, number];
1435
- } | {
1436
- matrix: import("../utils").AffineMatrix;
1437
- thickness: number;
1438
- maxImageWidth?: number;
1439
- maxImageHeight?: number;
1440
- removeOnDone?: boolean;
1441
- isOpacity?: boolean;
1442
- fontColor?: string;
1443
- fontBgColor?: string;
1444
- strokeColor?: string;
1445
- fillColor?: string;
1446
- vertex?: string;
1447
- fragment?: string;
1448
- syncUnitTime?: number;
1449
- zIndex?: number;
1450
- scale?: [number, number];
1451
- rotate?: number;
1452
- textOpt?: import("../../component/textEditor").TextOptions;
1453
- translate?: [number, number];
1454
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1455
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1456
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1457
- lineCap?: "square" | "round";
1458
- lineDash?: [number, number];
1459
- } | {
1460
- matrix: import("../utils").AffineMatrix;
1461
- thickness: number;
1462
- isOpacity?: boolean;
1463
- fontColor?: string;
1464
- fontBgColor?: string;
1465
- strokeColor?: string;
1466
- fillColor?: string;
1467
- vertex?: string;
1468
- fragment?: string;
1469
- syncUnitTime?: number;
1470
- zIndex?: number;
1471
- scale?: [number, number];
1472
- rotate?: number;
1473
- textOpt?: import("../../component/textEditor").TextOptions;
1474
- translate?: [number, number];
1475
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1476
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1477
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1478
- lineCap?: "square" | "round";
1479
- lineDash?: [number, number];
1480
- } | {
1481
- matrix: import("../utils").AffineMatrix;
1482
- thickness: number;
1483
- vertices: number;
1484
- innerVerticeStep: number;
1485
- innerRatio: number;
1486
- strokeColor: string;
1487
- fillColor: string;
1488
- strokeType: import("../..").EStrokeType;
1489
- isOpacity?: boolean;
1490
- fontColor?: string;
1491
- fontBgColor?: string;
1492
- vertex?: string;
1493
- fragment?: string;
1494
- syncUnitTime?: number;
1495
- zIndex?: number;
1496
- scale?: [number, number];
1497
- rotate?: number;
1498
- textOpt?: import("../../component/textEditor").TextOptions;
1499
- translate?: [number, number];
1500
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1501
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1502
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1503
- lineCap?: "square" | "round";
1504
- lineDash?: [number, number];
1505
- } | {
1506
- matrix: import("../utils").AffineMatrix;
1507
- isOpacity?: boolean;
1508
- fontColor?: string;
1509
- fontBgColor?: string;
1510
- strokeColor?: string;
1511
- fillColor?: string;
1512
- vertex?: string;
1513
- fragment?: string;
1514
- syncUnitTime?: number;
1515
- zIndex?: number;
1516
- scale?: [number, number];
1517
- rotate?: number;
1518
- thickness?: number;
1519
- textOpt?: import("../../component/textEditor").TextOptions;
1520
- translate?: [number, number];
1521
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1522
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1523
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1524
- lineCap?: "square" | "round";
1525
- lineDash?: [number, number];
1526
- } | {
1527
- matrix: import("../utils").AffineMatrix;
1528
- thickness: number;
1529
- strokeColor: string;
1530
- strokeType: import("../..").EStrokeType;
1531
- isOpacity?: boolean;
1532
- fontColor?: string;
1533
- fontBgColor?: string;
1534
- fillColor?: string;
1535
- vertex?: string;
1536
- fragment?: string;
1537
- syncUnitTime?: number;
1538
- zIndex?: number;
1539
- scale?: [number, number];
1540
- rotate?: number;
1541
- textOpt?: import("../../component/textEditor").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
- thickness: number;
1551
- strokeColor: string;
1552
- fillColor: string;
1553
- strokeType: import("../..").EStrokeType;
1554
- isOpacity?: boolean;
1555
- fontColor?: string;
1556
- fontBgColor?: string;
1557
- vertex?: string;
1558
- fragment?: string;
1559
- syncUnitTime?: number;
1560
- zIndex?: number;
1561
- scale?: [number, number];
1562
- rotate?: number;
1563
- textOpt?: import("../../component/textEditor").TextOptions;
1564
- translate?: [number, number];
1565
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1566
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1567
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1568
- lineCap?: "square" | "round";
1569
- lineDash?: [number, number];
1570
- } | {
1571
- matrix: import("../utils").AffineMatrix;
1572
- thickness: number;
1573
- strokeColor: string;
1574
- fillColor: string;
1575
- strokeType: import("../..").EStrokeType;
1576
- isOpacity?: boolean;
1577
- fontColor?: string;
1578
- fontBgColor?: string;
1579
- vertex?: string;
1580
- fragment?: string;
1581
- syncUnitTime?: number;
1582
- zIndex?: number;
1583
- scale?: [number, number];
1584
- rotate?: number;
1585
- textOpt?: import("../../component/textEditor").TextOptions;
1586
- translate?: [number, number];
1587
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1588
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1589
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1590
- lineCap?: "square" | "round";
1591
- lineDash?: [number, number];
1592
- } | {
1593
- matrix: import("../utils").AffineMatrix;
1594
- thickness: number;
1595
- vertices: number;
1596
- strokeColor: string;
1597
- fillColor: string;
1598
- strokeType: import("../..").EStrokeType;
1599
- isOpacity?: boolean;
1600
- fontColor?: string;
1601
- fontBgColor?: string;
1602
- vertex?: string;
1603
- fragment?: string;
1604
- syncUnitTime?: number;
1605
- zIndex?: number;
1606
- scale?: [number, number];
1607
- rotate?: number;
1608
- textOpt?: import("../../component/textEditor").TextOptions;
1609
- translate?: [number, number];
1610
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1611
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1612
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1613
- lineCap?: "square" | "round";
1614
- lineDash?: [number, number];
1615
- } | {
1616
- matrix: import("../utils").AffineMatrix;
1617
- thickness: number;
1618
- strokeColor: string;
1619
- strokeType: import("../..").EStrokeType;
1620
- isOpacity?: boolean;
1621
- fontColor?: string;
1622
- fontBgColor?: string;
1623
- fillColor?: string;
1624
- vertex?: string;
1625
- fragment?: string;
1626
- syncUnitTime?: number;
1627
- zIndex?: number;
1628
- scale?: [number, number];
1629
- rotate?: number;
1630
- textOpt?: import("../../component/textEditor").TextOptions;
1631
- translate?: [number, number];
1632
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1633
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1634
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1635
- lineCap?: "square" | "round";
1636
- lineDash?: [number, number];
1637
- } | {
1638
- matrix: import("../utils").AffineMatrix;
1639
- thickness: number;
1640
- placement: import("../..").SpeechBalloonPlacement;
1641
- strokeColor: string;
1642
- fillColor: string;
1643
- strokeType: import("../..").EStrokeType;
1644
- isOpacity?: boolean;
1645
- fontColor?: string;
1646
- fontBgColor?: string;
1647
- vertex?: string;
1648
- fragment?: string;
1649
- syncUnitTime?: number;
1650
- zIndex?: number;
1651
- scale?: [number, number];
1652
- rotate?: number;
1653
- textOpt?: import("../../component/textEditor").TextOptions;
1654
- translate?: [number, number];
1655
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1656
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1657
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1658
- lineCap?: "square" | "round";
1659
- lineDash?: [number, number];
1660
- } | {
1661
- matrix: import("../utils").AffineMatrix;
1662
- src: string;
1663
- type: import("..").EImageType;
1664
- uuid: string;
1665
- centerX: number;
1666
- centerY: number;
1667
- width: number;
1668
- height: number;
1669
- locked: boolean;
1670
- uniformScale?: boolean;
1671
- crossOrigin?: boolean | string;
1672
- isOpacity?: boolean;
1673
- fontColor?: string;
1674
- fontBgColor?: string;
1675
- strokeColor?: string;
1676
- fillColor?: string;
1677
- vertex?: string;
1678
- fragment?: string;
1679
- syncUnitTime?: number;
1680
- zIndex?: number;
1681
- scale?: [number, number];
1682
- rotate?: number;
1683
- thickness?: number;
1684
- textOpt?: import("../../component/textEditor").TextOptions;
1685
- translate?: [number, number];
1686
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1687
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1688
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1689
- lineCap?: "square" | "round";
1690
- lineDash?: [number, number];
1691
- } | {
1692
- matrix: import("../utils").AffineMatrix;
1693
- type: import("..").ESVGType.url;
1694
- src: string;
1695
- crossOrigin: boolean | string;
1696
- uuid: string;
1697
- centerX: number;
1698
- centerY: number;
1699
- width: number;
1700
- height: number;
1701
- locked: boolean;
1702
- uniformScale: boolean;
1703
- state?: unknown;
1704
- isOpacity?: boolean;
1705
- fontColor?: string;
1706
- fontBgColor?: string;
1707
- strokeColor?: string;
1708
- fillColor?: string;
1709
- vertex?: string;
1710
- fragment?: string;
1711
- syncUnitTime?: number;
1712
- zIndex?: number;
1713
- scale?: [number, number];
1714
- rotate?: number;
1715
- thickness?: number;
1716
- textOpt?: import("../../component/textEditor").TextOptions;
1717
- translate?: [number, number];
1718
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1719
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1720
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1721
- lineCap?: "square" | "round";
1722
- lineDash?: [number, number];
1723
- } | {
1724
- matrix: import("../utils").AffineMatrix;
1725
- type: import("..").ESVGType.markmap;
1726
- data: string;
1727
- uuid: string;
1728
- centerX: number;
1729
- centerY: number;
1730
- width: number;
1731
- height: number;
1732
- locked: boolean;
1733
- uniformScale: boolean;
1734
- state?: unknown;
1735
- isOpacity?: boolean;
1736
- fontColor?: string;
1737
- fontBgColor?: string;
1738
- strokeColor?: string;
1739
- fillColor?: string;
1740
- vertex?: string;
1741
- fragment?: string;
1742
- syncUnitTime?: number;
1743
- zIndex?: number;
1744
- scale?: [number, number];
1745
- rotate?: number;
1746
- thickness?: number;
1747
- textOpt?: import("../../component/textEditor").TextOptions;
1748
- translate?: [number, number];
1749
- eraserlines?: import("./pencilEraserBitMap").SerializerEraserLines;
1750
- eraserFaces?: import("./eraserFaces").SerializedEraserFaces | null;
1751
- doingLines?: import("./pencilEraserBitMap").SerializerEraserLines;
1752
- lineCap?: "square" | "round";
1753
- lineDash?: [number, number];
1754
- };
66
+ opt: import("./utils").ShapeOptions;
1755
67
  };
1756
68
  clearTmpPoints(): void;
1757
69
  }