tsparticles 1.37.0 → 1.37.1

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 (27) hide show
  1. package/Core/InteractionManager.d.ts +1 -0
  2. package/Core/InteractionManager.js +4 -1
  3. package/Core/Particles.d.ts +1 -1
  4. package/Core/Particles.js +3 -1
  5. package/Utils/Plugins.d.ts +2 -2
  6. package/Utils/Plugins.js +4 -4
  7. package/browser/Core/InteractionManager.d.ts +1 -0
  8. package/browser/Core/InteractionManager.js +4 -1
  9. package/browser/Core/Particles.d.ts +1 -1
  10. package/browser/Core/Particles.js +3 -1
  11. package/browser/Plugins/PolygonMask/plugin.js +1 -1
  12. package/browser/Utils/Plugins.d.ts +2 -2
  13. package/browser/Utils/Plugins.js +4 -4
  14. package/esm/Core/InteractionManager.d.ts +1 -0
  15. package/esm/Core/InteractionManager.js +4 -1
  16. package/esm/Core/Particles.d.ts +1 -1
  17. package/esm/Core/Particles.js +3 -1
  18. package/esm/Utils/Plugins.d.ts +2 -2
  19. package/esm/Utils/Plugins.js +4 -4
  20. package/package.json +1 -1
  21. package/report.html +2 -2
  22. package/report.slim.html +2 -2
  23. package/tsparticles.js +433 -371
  24. package/tsparticles.min.js +2 -2
  25. package/tsparticles.slim.js +405 -180
  26. package/tsparticles.slim.min.js +2 -2
  27. package/tsparticles.pathseg.js +0 -1472
package/tsparticles.pathseg.js DELETED
@@ -1,1472 +0,0 @@
1
- "use strict";
2
-
3
- (this["webpackChunktsparticles"] = this["webpackChunktsparticles"] || []).push([ [ 917 ], {
4
- 167: () => {
5
- (function() {
6
- "use strict";
7
- try {
8
- if (typeof window === "undefined") return;
9
- if (!("SVGPathSeg" in window)) {
10
- window.SVGPathSeg = function(type, typeAsLetter, owningPathSegList) {
11
- this.pathSegType = type;
12
- this.pathSegTypeAsLetter = typeAsLetter;
13
- this._owningPathSegList = owningPathSegList;
14
- };
15
- window.SVGPathSeg.prototype.classname = "SVGPathSeg";
16
- window.SVGPathSeg.PATHSEG_UNKNOWN = 0;
17
- window.SVGPathSeg.PATHSEG_CLOSEPATH = 1;
18
- window.SVGPathSeg.PATHSEG_MOVETO_ABS = 2;
19
- window.SVGPathSeg.PATHSEG_MOVETO_REL = 3;
20
- window.SVGPathSeg.PATHSEG_LINETO_ABS = 4;
21
- window.SVGPathSeg.PATHSEG_LINETO_REL = 5;
22
- window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6;
23
- window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7;
24
- window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8;
25
- window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9;
26
- window.SVGPathSeg.PATHSEG_ARC_ABS = 10;
27
- window.SVGPathSeg.PATHSEG_ARC_REL = 11;
28
- window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12;
29
- window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13;
30
- window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14;
31
- window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15;
32
- window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16;
33
- window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17;
34
- window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;
35
- window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;
36
- window.SVGPathSeg.prototype._segmentChanged = function() {
37
- if (this._owningPathSegList) this._owningPathSegList.segmentChanged(this);
38
- };
39
- window.SVGPathSegClosePath = function(owningPathSegList) {
40
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CLOSEPATH, "z", owningPathSegList);
41
- };
42
- window.SVGPathSegClosePath.prototype = Object.create(window.SVGPathSeg.prototype);
43
- window.SVGPathSegClosePath.prototype.toString = function() {
44
- return "[object SVGPathSegClosePath]";
45
- };
46
- window.SVGPathSegClosePath.prototype._asPathString = function() {
47
- return this.pathSegTypeAsLetter;
48
- };
49
- window.SVGPathSegClosePath.prototype.clone = function() {
50
- return new window.SVGPathSegClosePath(undefined);
51
- };
52
- window.SVGPathSegMovetoAbs = function(owningPathSegList, x, y) {
53
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_MOVETO_ABS, "M", owningPathSegList);
54
- this._x = x;
55
- this._y = y;
56
- };
57
- window.SVGPathSegMovetoAbs.prototype = Object.create(window.SVGPathSeg.prototype);
58
- window.SVGPathSegMovetoAbs.prototype.toString = function() {
59
- return "[object SVGPathSegMovetoAbs]";
60
- };
61
- window.SVGPathSegMovetoAbs.prototype._asPathString = function() {
62
- return this.pathSegTypeAsLetter + " " + this._x + " " + this._y;
63
- };
64
- window.SVGPathSegMovetoAbs.prototype.clone = function() {
65
- return new window.SVGPathSegMovetoAbs(undefined, this._x, this._y);
66
- };
67
- Object.defineProperty(window.SVGPathSegMovetoAbs.prototype, "x", {
68
- get: function() {
69
- return this._x;
70
- },
71
- set: function(x) {
72
- this._x = x;
73
- this._segmentChanged();
74
- },
75
- enumerable: true
76
- });
77
- Object.defineProperty(window.SVGPathSegMovetoAbs.prototype, "y", {
78
- get: function() {
79
- return this._y;
80
- },
81
- set: function(y) {
82
- this._y = y;
83
- this._segmentChanged();
84
- },
85
- enumerable: true
86
- });
87
- window.SVGPathSegMovetoRel = function(owningPathSegList, x, y) {
88
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_MOVETO_REL, "m", owningPathSegList);
89
- this._x = x;
90
- this._y = y;
91
- };
92
- window.SVGPathSegMovetoRel.prototype = Object.create(window.SVGPathSeg.prototype);
93
- window.SVGPathSegMovetoRel.prototype.toString = function() {
94
- return "[object SVGPathSegMovetoRel]";
95
- };
96
- window.SVGPathSegMovetoRel.prototype._asPathString = function() {
97
- return this.pathSegTypeAsLetter + " " + this._x + " " + this._y;
98
- };
99
- window.SVGPathSegMovetoRel.prototype.clone = function() {
100
- return new window.SVGPathSegMovetoRel(undefined, this._x, this._y);
101
- };
102
- Object.defineProperty(window.SVGPathSegMovetoRel.prototype, "x", {
103
- get: function() {
104
- return this._x;
105
- },
106
- set: function(x) {
107
- this._x = x;
108
- this._segmentChanged();
109
- },
110
- enumerable: true
111
- });
112
- Object.defineProperty(window.SVGPathSegMovetoRel.prototype, "y", {
113
- get: function() {
114
- return this._y;
115
- },
116
- set: function(y) {
117
- this._y = y;
118
- this._segmentChanged();
119
- },
120
- enumerable: true
121
- });
122
- window.SVGPathSegLinetoAbs = function(owningPathSegList, x, y) {
123
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_LINETO_ABS, "L", owningPathSegList);
124
- this._x = x;
125
- this._y = y;
126
- };
127
- window.SVGPathSegLinetoAbs.prototype = Object.create(window.SVGPathSeg.prototype);
128
- window.SVGPathSegLinetoAbs.prototype.toString = function() {
129
- return "[object SVGPathSegLinetoAbs]";
130
- };
131
- window.SVGPathSegLinetoAbs.prototype._asPathString = function() {
132
- return this.pathSegTypeAsLetter + " " + this._x + " " + this._y;
133
- };
134
- window.SVGPathSegLinetoAbs.prototype.clone = function() {
135
- return new window.SVGPathSegLinetoAbs(undefined, this._x, this._y);
136
- };
137
- Object.defineProperty(window.SVGPathSegLinetoAbs.prototype, "x", {
138
- get: function() {
139
- return this._x;
140
- },
141
- set: function(x) {
142
- this._x = x;
143
- this._segmentChanged();
144
- },
145
- enumerable: true
146
- });
147
- Object.defineProperty(window.SVGPathSegLinetoAbs.prototype, "y", {
148
- get: function() {
149
- return this._y;
150
- },
151
- set: function(y) {
152
- this._y = y;
153
- this._segmentChanged();
154
- },
155
- enumerable: true
156
- });
157
- window.SVGPathSegLinetoRel = function(owningPathSegList, x, y) {
158
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_LINETO_REL, "l", owningPathSegList);
159
- this._x = x;
160
- this._y = y;
161
- };
162
- window.SVGPathSegLinetoRel.prototype = Object.create(window.SVGPathSeg.prototype);
163
- window.SVGPathSegLinetoRel.prototype.toString = function() {
164
- return "[object SVGPathSegLinetoRel]";
165
- };
166
- window.SVGPathSegLinetoRel.prototype._asPathString = function() {
167
- return this.pathSegTypeAsLetter + " " + this._x + " " + this._y;
168
- };
169
- window.SVGPathSegLinetoRel.prototype.clone = function() {
170
- return new window.SVGPathSegLinetoRel(undefined, this._x, this._y);
171
- };
172
- Object.defineProperty(window.SVGPathSegLinetoRel.prototype, "x", {
173
- get: function() {
174
- return this._x;
175
- },
176
- set: function(x) {
177
- this._x = x;
178
- this._segmentChanged();
179
- },
180
- enumerable: true
181
- });
182
- Object.defineProperty(window.SVGPathSegLinetoRel.prototype, "y", {
183
- get: function() {
184
- return this._y;
185
- },
186
- set: function(y) {
187
- this._y = y;
188
- this._segmentChanged();
189
- },
190
- enumerable: true
191
- });
192
- window.SVGPathSegCurvetoCubicAbs = function(owningPathSegList, x, y, x1, y1, x2, y2) {
193
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, "C", owningPathSegList);
194
- this._x = x;
195
- this._y = y;
196
- this._x1 = x1;
197
- this._y1 = y1;
198
- this._x2 = x2;
199
- this._y2 = y2;
200
- };
201
- window.SVGPathSegCurvetoCubicAbs.prototype = Object.create(window.SVGPathSeg.prototype);
202
- window.SVGPathSegCurvetoCubicAbs.prototype.toString = function() {
203
- return "[object SVGPathSegCurvetoCubicAbs]";
204
- };
205
- window.SVGPathSegCurvetoCubicAbs.prototype._asPathString = function() {
206
- return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y;
207
- };
208
- window.SVGPathSegCurvetoCubicAbs.prototype.clone = function() {
209
- return new window.SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2);
210
- };
211
- Object.defineProperty(window.SVGPathSegCurvetoCubicAbs.prototype, "x", {
212
- get: function() {
213
- return this._x;
214
- },
215
- set: function(x) {
216
- this._x = x;
217
- this._segmentChanged();
218
- },
219
- enumerable: true
220
- });
221
- Object.defineProperty(window.SVGPathSegCurvetoCubicAbs.prototype, "y", {
222
- get: function() {
223
- return this._y;
224
- },
225
- set: function(y) {
226
- this._y = y;
227
- this._segmentChanged();
228
- },
229
- enumerable: true
230
- });
231
- Object.defineProperty(window.SVGPathSegCurvetoCubicAbs.prototype, "x1", {
232
- get: function() {
233
- return this._x1;
234
- },
235
- set: function(x1) {
236
- this._x1 = x1;
237
- this._segmentChanged();
238
- },
239
- enumerable: true
240
- });
241
- Object.defineProperty(window.SVGPathSegCurvetoCubicAbs.prototype, "y1", {
242
- get: function() {
243
- return this._y1;
244
- },
245
- set: function(y1) {
246
- this._y1 = y1;
247
- this._segmentChanged();
248
- },
249
- enumerable: true
250
- });
251
- Object.defineProperty(window.SVGPathSegCurvetoCubicAbs.prototype, "x2", {
252
- get: function() {
253
- return this._x2;
254
- },
255
- set: function(x2) {
256
- this._x2 = x2;
257
- this._segmentChanged();
258
- },
259
- enumerable: true
260
- });
261
- Object.defineProperty(window.SVGPathSegCurvetoCubicAbs.prototype, "y2", {
262
- get: function() {
263
- return this._y2;
264
- },
265
- set: function(y2) {
266
- this._y2 = y2;
267
- this._segmentChanged();
268
- },
269
- enumerable: true
270
- });
271
- window.SVGPathSegCurvetoCubicRel = function(owningPathSegList, x, y, x1, y1, x2, y2) {
272
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, "c", owningPathSegList);
273
- this._x = x;
274
- this._y = y;
275
- this._x1 = x1;
276
- this._y1 = y1;
277
- this._x2 = x2;
278
- this._y2 = y2;
279
- };
280
- window.SVGPathSegCurvetoCubicRel.prototype = Object.create(window.SVGPathSeg.prototype);
281
- window.SVGPathSegCurvetoCubicRel.prototype.toString = function() {
282
- return "[object SVGPathSegCurvetoCubicRel]";
283
- };
284
- window.SVGPathSegCurvetoCubicRel.prototype._asPathString = function() {
285
- return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y;
286
- };
287
- window.SVGPathSegCurvetoCubicRel.prototype.clone = function() {
288
- return new window.SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2);
289
- };
290
- Object.defineProperty(window.SVGPathSegCurvetoCubicRel.prototype, "x", {
291
- get: function() {
292
- return this._x;
293
- },
294
- set: function(x) {
295
- this._x = x;
296
- this._segmentChanged();
297
- },
298
- enumerable: true
299
- });
300
- Object.defineProperty(window.SVGPathSegCurvetoCubicRel.prototype, "y", {
301
- get: function() {
302
- return this._y;
303
- },
304
- set: function(y) {
305
- this._y = y;
306
- this._segmentChanged();
307
- },
308
- enumerable: true
309
- });
310
- Object.defineProperty(window.SVGPathSegCurvetoCubicRel.prototype, "x1", {
311
- get: function() {
312
- return this._x1;
313
- },
314
- set: function(x1) {
315
- this._x1 = x1;
316
- this._segmentChanged();
317
- },
318
- enumerable: true
319
- });
320
- Object.defineProperty(window.SVGPathSegCurvetoCubicRel.prototype, "y1", {
321
- get: function() {
322
- return this._y1;
323
- },
324
- set: function(y1) {
325
- this._y1 = y1;
326
- this._segmentChanged();
327
- },
328
- enumerable: true
329
- });
330
- Object.defineProperty(window.SVGPathSegCurvetoCubicRel.prototype, "x2", {
331
- get: function() {
332
- return this._x2;
333
- },
334
- set: function(x2) {
335
- this._x2 = x2;
336
- this._segmentChanged();
337
- },
338
- enumerable: true
339
- });
340
- Object.defineProperty(window.SVGPathSegCurvetoCubicRel.prototype, "y2", {
341
- get: function() {
342
- return this._y2;
343
- },
344
- set: function(y2) {
345
- this._y2 = y2;
346
- this._segmentChanged();
347
- },
348
- enumerable: true
349
- });
350
- window.SVGPathSegCurvetoQuadraticAbs = function(owningPathSegList, x, y, x1, y1) {
351
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS, "Q", owningPathSegList);
352
- this._x = x;
353
- this._y = y;
354
- this._x1 = x1;
355
- this._y1 = y1;
356
- };
357
- window.SVGPathSegCurvetoQuadraticAbs.prototype = Object.create(window.SVGPathSeg.prototype);
358
- window.SVGPathSegCurvetoQuadraticAbs.prototype.toString = function() {
359
- return "[object SVGPathSegCurvetoQuadraticAbs]";
360
- };
361
- window.SVGPathSegCurvetoQuadraticAbs.prototype._asPathString = function() {
362
- return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x + " " + this._y;
363
- };
364
- window.SVGPathSegCurvetoQuadraticAbs.prototype.clone = function() {
365
- return new window.SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1, this._y1);
366
- };
367
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticAbs.prototype, "x", {
368
- get: function() {
369
- return this._x;
370
- },
371
- set: function(x) {
372
- this._x = x;
373
- this._segmentChanged();
374
- },
375
- enumerable: true
376
- });
377
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticAbs.prototype, "y", {
378
- get: function() {
379
- return this._y;
380
- },
381
- set: function(y) {
382
- this._y = y;
383
- this._segmentChanged();
384
- },
385
- enumerable: true
386
- });
387
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticAbs.prototype, "x1", {
388
- get: function() {
389
- return this._x1;
390
- },
391
- set: function(x1) {
392
- this._x1 = x1;
393
- this._segmentChanged();
394
- },
395
- enumerable: true
396
- });
397
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticAbs.prototype, "y1", {
398
- get: function() {
399
- return this._y1;
400
- },
401
- set: function(y1) {
402
- this._y1 = y1;
403
- this._segmentChanged();
404
- },
405
- enumerable: true
406
- });
407
- window.SVGPathSegCurvetoQuadraticRel = function(owningPathSegList, x, y, x1, y1) {
408
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL, "q", owningPathSegList);
409
- this._x = x;
410
- this._y = y;
411
- this._x1 = x1;
412
- this._y1 = y1;
413
- };
414
- window.SVGPathSegCurvetoQuadraticRel.prototype = Object.create(window.SVGPathSeg.prototype);
415
- window.SVGPathSegCurvetoQuadraticRel.prototype.toString = function() {
416
- return "[object SVGPathSegCurvetoQuadraticRel]";
417
- };
418
- window.SVGPathSegCurvetoQuadraticRel.prototype._asPathString = function() {
419
- return this.pathSegTypeAsLetter + " " + this._x1 + " " + this._y1 + " " + this._x + " " + this._y;
420
- };
421
- window.SVGPathSegCurvetoQuadraticRel.prototype.clone = function() {
422
- return new window.SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1, this._y1);
423
- };
424
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticRel.prototype, "x", {
425
- get: function() {
426
- return this._x;
427
- },
428
- set: function(x) {
429
- this._x = x;
430
- this._segmentChanged();
431
- },
432
- enumerable: true
433
- });
434
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticRel.prototype, "y", {
435
- get: function() {
436
- return this._y;
437
- },
438
- set: function(y) {
439
- this._y = y;
440
- this._segmentChanged();
441
- },
442
- enumerable: true
443
- });
444
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticRel.prototype, "x1", {
445
- get: function() {
446
- return this._x1;
447
- },
448
- set: function(x1) {
449
- this._x1 = x1;
450
- this._segmentChanged();
451
- },
452
- enumerable: true
453
- });
454
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticRel.prototype, "y1", {
455
- get: function() {
456
- return this._y1;
457
- },
458
- set: function(y1) {
459
- this._y1 = y1;
460
- this._segmentChanged();
461
- },
462
- enumerable: true
463
- });
464
- window.SVGPathSegArcAbs = function(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
465
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_ARC_ABS, "A", owningPathSegList);
466
- this._x = x;
467
- this._y = y;
468
- this._r1 = r1;
469
- this._r2 = r2;
470
- this._angle = angle;
471
- this._largeArcFlag = largeArcFlag;
472
- this._sweepFlag = sweepFlag;
473
- };
474
- window.SVGPathSegArcAbs.prototype = Object.create(window.SVGPathSeg.prototype);
475
- window.SVGPathSegArcAbs.prototype.toString = function() {
476
- return "[object SVGPathSegArcAbs]";
477
- };
478
- window.SVGPathSegArcAbs.prototype._asPathString = function() {
479
- return this.pathSegTypeAsLetter + " " + this._r1 + " " + this._r2 + " " + this._angle + " " + (this._largeArcFlag ? "1" : "0") + " " + (this._sweepFlag ? "1" : "0") + " " + this._x + " " + this._y;
480
- };
481
- window.SVGPathSegArcAbs.prototype.clone = function() {
482
- return new window.SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag);
483
- };
484
- Object.defineProperty(window.SVGPathSegArcAbs.prototype, "x", {
485
- get: function() {
486
- return this._x;
487
- },
488
- set: function(x) {
489
- this._x = x;
490
- this._segmentChanged();
491
- },
492
- enumerable: true
493
- });
494
- Object.defineProperty(window.SVGPathSegArcAbs.prototype, "y", {
495
- get: function() {
496
- return this._y;
497
- },
498
- set: function(y) {
499
- this._y = y;
500
- this._segmentChanged();
501
- },
502
- enumerable: true
503
- });
504
- Object.defineProperty(window.SVGPathSegArcAbs.prototype, "r1", {
505
- get: function() {
506
- return this._r1;
507
- },
508
- set: function(r1) {
509
- this._r1 = r1;
510
- this._segmentChanged();
511
- },
512
- enumerable: true
513
- });
514
- Object.defineProperty(window.SVGPathSegArcAbs.prototype, "r2", {
515
- get: function() {
516
- return this._r2;
517
- },
518
- set: function(r2) {
519
- this._r2 = r2;
520
- this._segmentChanged();
521
- },
522
- enumerable: true
523
- });
524
- Object.defineProperty(window.SVGPathSegArcAbs.prototype, "angle", {
525
- get: function() {
526
- return this._angle;
527
- },
528
- set: function(angle) {
529
- this._angle = angle;
530
- this._segmentChanged();
531
- },
532
- enumerable: true
533
- });
534
- Object.defineProperty(window.SVGPathSegArcAbs.prototype, "largeArcFlag", {
535
- get: function() {
536
- return this._largeArcFlag;
537
- },
538
- set: function(largeArcFlag) {
539
- this._largeArcFlag = largeArcFlag;
540
- this._segmentChanged();
541
- },
542
- enumerable: true
543
- });
544
- Object.defineProperty(window.SVGPathSegArcAbs.prototype, "sweepFlag", {
545
- get: function() {
546
- return this._sweepFlag;
547
- },
548
- set: function(sweepFlag) {
549
- this._sweepFlag = sweepFlag;
550
- this._segmentChanged();
551
- },
552
- enumerable: true
553
- });
554
- window.SVGPathSegArcRel = function(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
555
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_ARC_REL, "a", owningPathSegList);
556
- this._x = x;
557
- this._y = y;
558
- this._r1 = r1;
559
- this._r2 = r2;
560
- this._angle = angle;
561
- this._largeArcFlag = largeArcFlag;
562
- this._sweepFlag = sweepFlag;
563
- };
564
- window.SVGPathSegArcRel.prototype = Object.create(window.SVGPathSeg.prototype);
565
- window.SVGPathSegArcRel.prototype.toString = function() {
566
- return "[object SVGPathSegArcRel]";
567
- };
568
- window.SVGPathSegArcRel.prototype._asPathString = function() {
569
- return this.pathSegTypeAsLetter + " " + this._r1 + " " + this._r2 + " " + this._angle + " " + (this._largeArcFlag ? "1" : "0") + " " + (this._sweepFlag ? "1" : "0") + " " + this._x + " " + this._y;
570
- };
571
- window.SVGPathSegArcRel.prototype.clone = function() {
572
- return new window.SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag);
573
- };
574
- Object.defineProperty(window.SVGPathSegArcRel.prototype, "x", {
575
- get: function() {
576
- return this._x;
577
- },
578
- set: function(x) {
579
- this._x = x;
580
- this._segmentChanged();
581
- },
582
- enumerable: true
583
- });
584
- Object.defineProperty(window.SVGPathSegArcRel.prototype, "y", {
585
- get: function() {
586
- return this._y;
587
- },
588
- set: function(y) {
589
- this._y = y;
590
- this._segmentChanged();
591
- },
592
- enumerable: true
593
- });
594
- Object.defineProperty(window.SVGPathSegArcRel.prototype, "r1", {
595
- get: function() {
596
- return this._r1;
597
- },
598
- set: function(r1) {
599
- this._r1 = r1;
600
- this._segmentChanged();
601
- },
602
- enumerable: true
603
- });
604
- Object.defineProperty(window.SVGPathSegArcRel.prototype, "r2", {
605
- get: function() {
606
- return this._r2;
607
- },
608
- set: function(r2) {
609
- this._r2 = r2;
610
- this._segmentChanged();
611
- },
612
- enumerable: true
613
- });
614
- Object.defineProperty(window.SVGPathSegArcRel.prototype, "angle", {
615
- get: function() {
616
- return this._angle;
617
- },
618
- set: function(angle) {
619
- this._angle = angle;
620
- this._segmentChanged();
621
- },
622
- enumerable: true
623
- });
624
- Object.defineProperty(window.SVGPathSegArcRel.prototype, "largeArcFlag", {
625
- get: function() {
626
- return this._largeArcFlag;
627
- },
628
- set: function(largeArcFlag) {
629
- this._largeArcFlag = largeArcFlag;
630
- this._segmentChanged();
631
- },
632
- enumerable: true
633
- });
634
- Object.defineProperty(window.SVGPathSegArcRel.prototype, "sweepFlag", {
635
- get: function() {
636
- return this._sweepFlag;
637
- },
638
- set: function(sweepFlag) {
639
- this._sweepFlag = sweepFlag;
640
- this._segmentChanged();
641
- },
642
- enumerable: true
643
- });
644
- window.SVGPathSegLinetoHorizontalAbs = function(owningPathSegList, x) {
645
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS, "H", owningPathSegList);
646
- this._x = x;
647
- };
648
- window.SVGPathSegLinetoHorizontalAbs.prototype = Object.create(window.SVGPathSeg.prototype);
649
- window.SVGPathSegLinetoHorizontalAbs.prototype.toString = function() {
650
- return "[object SVGPathSegLinetoHorizontalAbs]";
651
- };
652
- window.SVGPathSegLinetoHorizontalAbs.prototype._asPathString = function() {
653
- return this.pathSegTypeAsLetter + " " + this._x;
654
- };
655
- window.SVGPathSegLinetoHorizontalAbs.prototype.clone = function() {
656
- return new window.SVGPathSegLinetoHorizontalAbs(undefined, this._x);
657
- };
658
- Object.defineProperty(window.SVGPathSegLinetoHorizontalAbs.prototype, "x", {
659
- get: function() {
660
- return this._x;
661
- },
662
- set: function(x) {
663
- this._x = x;
664
- this._segmentChanged();
665
- },
666
- enumerable: true
667
- });
668
- window.SVGPathSegLinetoHorizontalRel = function(owningPathSegList, x) {
669
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL, "h", owningPathSegList);
670
- this._x = x;
671
- };
672
- window.SVGPathSegLinetoHorizontalRel.prototype = Object.create(window.SVGPathSeg.prototype);
673
- window.SVGPathSegLinetoHorizontalRel.prototype.toString = function() {
674
- return "[object SVGPathSegLinetoHorizontalRel]";
675
- };
676
- window.SVGPathSegLinetoHorizontalRel.prototype._asPathString = function() {
677
- return this.pathSegTypeAsLetter + " " + this._x;
678
- };
679
- window.SVGPathSegLinetoHorizontalRel.prototype.clone = function() {
680
- return new window.SVGPathSegLinetoHorizontalRel(undefined, this._x);
681
- };
682
- Object.defineProperty(window.SVGPathSegLinetoHorizontalRel.prototype, "x", {
683
- get: function() {
684
- return this._x;
685
- },
686
- set: function(x) {
687
- this._x = x;
688
- this._segmentChanged();
689
- },
690
- enumerable: true
691
- });
692
- window.SVGPathSegLinetoVerticalAbs = function(owningPathSegList, y) {
693
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, "V", owningPathSegList);
694
- this._y = y;
695
- };
696
- window.SVGPathSegLinetoVerticalAbs.prototype = Object.create(window.SVGPathSeg.prototype);
697
- window.SVGPathSegLinetoVerticalAbs.prototype.toString = function() {
698
- return "[object SVGPathSegLinetoVerticalAbs]";
699
- };
700
- window.SVGPathSegLinetoVerticalAbs.prototype._asPathString = function() {
701
- return this.pathSegTypeAsLetter + " " + this._y;
702
- };
703
- window.SVGPathSegLinetoVerticalAbs.prototype.clone = function() {
704
- return new window.SVGPathSegLinetoVerticalAbs(undefined, this._y);
705
- };
706
- Object.defineProperty(window.SVGPathSegLinetoVerticalAbs.prototype, "y", {
707
- get: function() {
708
- return this._y;
709
- },
710
- set: function(y) {
711
- this._y = y;
712
- this._segmentChanged();
713
- },
714
- enumerable: true
715
- });
716
- window.SVGPathSegLinetoVerticalRel = function(owningPathSegList, y) {
717
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, "v", owningPathSegList);
718
- this._y = y;
719
- };
720
- window.SVGPathSegLinetoVerticalRel.prototype = Object.create(window.SVGPathSeg.prototype);
721
- window.SVGPathSegLinetoVerticalRel.prototype.toString = function() {
722
- return "[object SVGPathSegLinetoVerticalRel]";
723
- };
724
- window.SVGPathSegLinetoVerticalRel.prototype._asPathString = function() {
725
- return this.pathSegTypeAsLetter + " " + this._y;
726
- };
727
- window.SVGPathSegLinetoVerticalRel.prototype.clone = function() {
728
- return new window.SVGPathSegLinetoVerticalRel(undefined, this._y);
729
- };
730
- Object.defineProperty(window.SVGPathSegLinetoVerticalRel.prototype, "y", {
731
- get: function() {
732
- return this._y;
733
- },
734
- set: function(y) {
735
- this._y = y;
736
- this._segmentChanged();
737
- },
738
- enumerable: true
739
- });
740
- window.SVGPathSegCurvetoCubicSmoothAbs = function(owningPathSegList, x, y, x2, y2) {
741
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, "S", owningPathSegList);
742
- this._x = x;
743
- this._y = y;
744
- this._x2 = x2;
745
- this._y2 = y2;
746
- };
747
- window.SVGPathSegCurvetoCubicSmoothAbs.prototype = Object.create(window.SVGPathSeg.prototype);
748
- window.SVGPathSegCurvetoCubicSmoothAbs.prototype.toString = function() {
749
- return "[object SVGPathSegCurvetoCubicSmoothAbs]";
750
- };
751
- window.SVGPathSegCurvetoCubicSmoothAbs.prototype._asPathString = function() {
752
- return this.pathSegTypeAsLetter + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y;
753
- };
754
- window.SVGPathSegCurvetoCubicSmoothAbs.prototype.clone = function() {
755
- return new window.SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2, this._y2);
756
- };
757
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothAbs.prototype, "x", {
758
- get: function() {
759
- return this._x;
760
- },
761
- set: function(x) {
762
- this._x = x;
763
- this._segmentChanged();
764
- },
765
- enumerable: true
766
- });
767
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothAbs.prototype, "y", {
768
- get: function() {
769
- return this._y;
770
- },
771
- set: function(y) {
772
- this._y = y;
773
- this._segmentChanged();
774
- },
775
- enumerable: true
776
- });
777
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothAbs.prototype, "x2", {
778
- get: function() {
779
- return this._x2;
780
- },
781
- set: function(x2) {
782
- this._x2 = x2;
783
- this._segmentChanged();
784
- },
785
- enumerable: true
786
- });
787
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothAbs.prototype, "y2", {
788
- get: function() {
789
- return this._y2;
790
- },
791
- set: function(y2) {
792
- this._y2 = y2;
793
- this._segmentChanged();
794
- },
795
- enumerable: true
796
- });
797
- window.SVGPathSegCurvetoCubicSmoothRel = function(owningPathSegList, x, y, x2, y2) {
798
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL, "s", owningPathSegList);
799
- this._x = x;
800
- this._y = y;
801
- this._x2 = x2;
802
- this._y2 = y2;
803
- };
804
- window.SVGPathSegCurvetoCubicSmoothRel.prototype = Object.create(window.SVGPathSeg.prototype);
805
- window.SVGPathSegCurvetoCubicSmoothRel.prototype.toString = function() {
806
- return "[object SVGPathSegCurvetoCubicSmoothRel]";
807
- };
808
- window.SVGPathSegCurvetoCubicSmoothRel.prototype._asPathString = function() {
809
- return this.pathSegTypeAsLetter + " " + this._x2 + " " + this._y2 + " " + this._x + " " + this._y;
810
- };
811
- window.SVGPathSegCurvetoCubicSmoothRel.prototype.clone = function() {
812
- return new window.SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2, this._y2);
813
- };
814
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothRel.prototype, "x", {
815
- get: function() {
816
- return this._x;
817
- },
818
- set: function(x) {
819
- this._x = x;
820
- this._segmentChanged();
821
- },
822
- enumerable: true
823
- });
824
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothRel.prototype, "y", {
825
- get: function() {
826
- return this._y;
827
- },
828
- set: function(y) {
829
- this._y = y;
830
- this._segmentChanged();
831
- },
832
- enumerable: true
833
- });
834
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothRel.prototype, "x2", {
835
- get: function() {
836
- return this._x2;
837
- },
838
- set: function(x2) {
839
- this._x2 = x2;
840
- this._segmentChanged();
841
- },
842
- enumerable: true
843
- });
844
- Object.defineProperty(window.SVGPathSegCurvetoCubicSmoothRel.prototype, "y2", {
845
- get: function() {
846
- return this._y2;
847
- },
848
- set: function(y2) {
849
- this._y2 = y2;
850
- this._segmentChanged();
851
- },
852
- enumerable: true
853
- });
854
- window.SVGPathSegCurvetoQuadraticSmoothAbs = function(owningPathSegList, x, y) {
855
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, "T", owningPathSegList);
856
- this._x = x;
857
- this._y = y;
858
- };
859
- window.SVGPathSegCurvetoQuadraticSmoothAbs.prototype = Object.create(window.SVGPathSeg.prototype);
860
- window.SVGPathSegCurvetoQuadraticSmoothAbs.prototype.toString = function() {
861
- return "[object SVGPathSegCurvetoQuadraticSmoothAbs]";
862
- };
863
- window.SVGPathSegCurvetoQuadraticSmoothAbs.prototype._asPathString = function() {
864
- return this.pathSegTypeAsLetter + " " + this._x + " " + this._y;
865
- };
866
- window.SVGPathSegCurvetoQuadraticSmoothAbs.prototype.clone = function() {
867
- return new window.SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y);
868
- };
869
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticSmoothAbs.prototype, "x", {
870
- get: function() {
871
- return this._x;
872
- },
873
- set: function(x) {
874
- this._x = x;
875
- this._segmentChanged();
876
- },
877
- enumerable: true
878
- });
879
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticSmoothAbs.prototype, "y", {
880
- get: function() {
881
- return this._y;
882
- },
883
- set: function(y) {
884
- this._y = y;
885
- this._segmentChanged();
886
- },
887
- enumerable: true
888
- });
889
- window.SVGPathSegCurvetoQuadraticSmoothRel = function(owningPathSegList, x, y) {
890
- window.SVGPathSeg.call(this, window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, "t", owningPathSegList);
891
- this._x = x;
892
- this._y = y;
893
- };
894
- window.SVGPathSegCurvetoQuadraticSmoothRel.prototype = Object.create(window.SVGPathSeg.prototype);
895
- window.SVGPathSegCurvetoQuadraticSmoothRel.prototype.toString = function() {
896
- return "[object SVGPathSegCurvetoQuadraticSmoothRel]";
897
- };
898
- window.SVGPathSegCurvetoQuadraticSmoothRel.prototype._asPathString = function() {
899
- return this.pathSegTypeAsLetter + " " + this._x + " " + this._y;
900
- };
901
- window.SVGPathSegCurvetoQuadraticSmoothRel.prototype.clone = function() {
902
- return new window.SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y);
903
- };
904
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticSmoothRel.prototype, "x", {
905
- get: function() {
906
- return this._x;
907
- },
908
- set: function(x) {
909
- this._x = x;
910
- this._segmentChanged();
911
- },
912
- enumerable: true
913
- });
914
- Object.defineProperty(window.SVGPathSegCurvetoQuadraticSmoothRel.prototype, "y", {
915
- get: function() {
916
- return this._y;
917
- },
918
- set: function(y) {
919
- this._y = y;
920
- this._segmentChanged();
921
- },
922
- enumerable: true
923
- });
924
- window.SVGPathElement.prototype.createSVGPathSegClosePath = function() {
925
- return new window.SVGPathSegClosePath(undefined);
926
- };
927
- window.SVGPathElement.prototype.createSVGPathSegMovetoAbs = function(x, y) {
928
- return new window.SVGPathSegMovetoAbs(undefined, x, y);
929
- };
930
- window.SVGPathElement.prototype.createSVGPathSegMovetoRel = function(x, y) {
931
- return new window.SVGPathSegMovetoRel(undefined, x, y);
932
- };
933
- window.SVGPathElement.prototype.createSVGPathSegLinetoAbs = function(x, y) {
934
- return new window.SVGPathSegLinetoAbs(undefined, x, y);
935
- };
936
- window.SVGPathElement.prototype.createSVGPathSegLinetoRel = function(x, y) {
937
- return new window.SVGPathSegLinetoRel(undefined, x, y);
938
- };
939
- window.SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function(x, y, x1, y1, x2, y2) {
940
- return new window.SVGPathSegCurvetoCubicAbs(undefined, x, y, x1, y1, x2, y2);
941
- };
942
- window.SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function(x, y, x1, y1, x2, y2) {
943
- return new window.SVGPathSegCurvetoCubicRel(undefined, x, y, x1, y1, x2, y2);
944
- };
945
- window.SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs = function(x, y, x1, y1) {
946
- return new window.SVGPathSegCurvetoQuadraticAbs(undefined, x, y, x1, y1);
947
- };
948
- window.SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel = function(x, y, x1, y1) {
949
- return new window.SVGPathSegCurvetoQuadraticRel(undefined, x, y, x1, y1);
950
- };
951
- window.SVGPathElement.prototype.createSVGPathSegArcAbs = function(x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
952
- return new window.SVGPathSegArcAbs(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag);
953
- };
954
- window.SVGPathElement.prototype.createSVGPathSegArcRel = function(x, y, r1, r2, angle, largeArcFlag, sweepFlag) {
955
- return new window.SVGPathSegArcRel(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag);
956
- };
957
- window.SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs = function(x) {
958
- return new window.SVGPathSegLinetoHorizontalAbs(undefined, x);
959
- };
960
- window.SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel = function(x) {
961
- return new window.SVGPathSegLinetoHorizontalRel(undefined, x);
962
- };
963
- window.SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs = function(y) {
964
- return new window.SVGPathSegLinetoVerticalAbs(undefined, y);
965
- };
966
- window.SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel = function(y) {
967
- return new window.SVGPathSegLinetoVerticalRel(undefined, y);
968
- };
969
- window.SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs = function(x, y, x2, y2) {
970
- return new window.SVGPathSegCurvetoCubicSmoothAbs(undefined, x, y, x2, y2);
971
- };
972
- window.SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel = function(x, y, x2, y2) {
973
- return new window.SVGPathSegCurvetoCubicSmoothRel(undefined, x, y, x2, y2);
974
- };
975
- window.SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs = function(x, y) {
976
- return new window.SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x, y);
977
- };
978
- window.SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel = function(x, y) {
979
- return new window.SVGPathSegCurvetoQuadraticSmoothRel(undefined, x, y);
980
- };
981
- if (!("getPathSegAtLength" in window.SVGPathElement.prototype)) {
982
- window.SVGPathElement.prototype.getPathSegAtLength = function(distance) {
983
- if (distance === undefined || !isFinite(distance)) throw "Invalid arguments.";
984
- var measurementElement = document.createElementNS("http://www.w3.org/2000/svg", "path");
985
- measurementElement.setAttribute("d", this.getAttribute("d"));
986
- var lastPathSegment = measurementElement.pathSegList.numberOfItems - 1;
987
- if (lastPathSegment <= 0) return 0;
988
- do {
989
- measurementElement.pathSegList.removeItem(lastPathSegment);
990
- if (distance > measurementElement.getTotalLength()) break;
991
- lastPathSegment--;
992
- } while (lastPathSegment > 0);
993
- return lastPathSegment;
994
- };
995
- }
996
- }
997
- if (!("SVGPathSegList" in window) || !("appendItem" in window.SVGPathSegList.prototype)) {
998
- window.SVGPathSegList = function(pathElement) {
999
- this._pathElement = pathElement;
1000
- this._list = this._parsePath(this._pathElement.getAttribute("d"));
1001
- this._mutationObserverConfig = {
1002
- attributes: true,
1003
- attributeFilter: [ "d" ]
1004
- };
1005
- this._pathElementMutationObserver = new MutationObserver(this._updateListFromPathMutations.bind(this));
1006
- this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);
1007
- };
1008
- window.SVGPathSegList.prototype.classname = "SVGPathSegList";
1009
- Object.defineProperty(window.SVGPathSegList.prototype, "numberOfItems", {
1010
- get: function() {
1011
- this._checkPathSynchronizedToList();
1012
- return this._list.length;
1013
- },
1014
- enumerable: true
1015
- });
1016
- Object.defineProperty(window.SVGPathSegList.prototype, "length", {
1017
- get: function() {
1018
- this._checkPathSynchronizedToList();
1019
- return this._list.length;
1020
- },
1021
- enumerable: true
1022
- });
1023
- Object.defineProperty(window.SVGPathElement.prototype, "pathSegList", {
1024
- get: function() {
1025
- if (!this._pathSegList) this._pathSegList = new window.SVGPathSegList(this);
1026
- return this._pathSegList;
1027
- },
1028
- enumerable: true
1029
- });
1030
- Object.defineProperty(window.SVGPathElement.prototype, "normalizedPathSegList", {
1031
- get: function() {
1032
- return this.pathSegList;
1033
- },
1034
- enumerable: true
1035
- });
1036
- Object.defineProperty(window.SVGPathElement.prototype, "animatedPathSegList", {
1037
- get: function() {
1038
- return this.pathSegList;
1039
- },
1040
- enumerable: true
1041
- });
1042
- Object.defineProperty(window.SVGPathElement.prototype, "animatedNormalizedPathSegList", {
1043
- get: function() {
1044
- return this.pathSegList;
1045
- },
1046
- enumerable: true
1047
- });
1048
- window.SVGPathSegList.prototype._checkPathSynchronizedToList = function() {
1049
- this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords());
1050
- };
1051
- window.SVGPathSegList.prototype._updateListFromPathMutations = function(mutationRecords) {
1052
- if (!this._pathElement) return;
1053
- var hasPathMutations = false;
1054
- mutationRecords.forEach((function(record) {
1055
- if (record.attributeName == "d") hasPathMutations = true;
1056
- }));
1057
- if (hasPathMutations) this._list = this._parsePath(this._pathElement.getAttribute("d"));
1058
- };
1059
- window.SVGPathSegList.prototype._writeListToPath = function() {
1060
- this._pathElementMutationObserver.disconnect();
1061
- this._pathElement.setAttribute("d", window.SVGPathSegList._pathSegArrayAsString(this._list));
1062
- this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);
1063
- };
1064
- window.SVGPathSegList.prototype.segmentChanged = function(pathSeg) {
1065
- this._writeListToPath();
1066
- };
1067
- window.SVGPathSegList.prototype.clear = function() {
1068
- this._checkPathSynchronizedToList();
1069
- this._list.forEach((function(pathSeg) {
1070
- pathSeg._owningPathSegList = null;
1071
- }));
1072
- this._list = [];
1073
- this._writeListToPath();
1074
- };
1075
- window.SVGPathSegList.prototype.initialize = function(newItem) {
1076
- this._checkPathSynchronizedToList();
1077
- this._list = [ newItem ];
1078
- newItem._owningPathSegList = this;
1079
- this._writeListToPath();
1080
- return newItem;
1081
- };
1082
- window.SVGPathSegList.prototype._checkValidIndex = function(index) {
1083
- if (isNaN(index) || index < 0 || index >= this.numberOfItems) throw "INDEX_SIZE_ERR";
1084
- };
1085
- window.SVGPathSegList.prototype.getItem = function(index) {
1086
- this._checkPathSynchronizedToList();
1087
- this._checkValidIndex(index);
1088
- return this._list[index];
1089
- };
1090
- window.SVGPathSegList.prototype.insertItemBefore = function(newItem, index) {
1091
- this._checkPathSynchronizedToList();
1092
- if (index > this.numberOfItems) index = this.numberOfItems;
1093
- if (newItem._owningPathSegList) {
1094
- newItem = newItem.clone();
1095
- }
1096
- this._list.splice(index, 0, newItem);
1097
- newItem._owningPathSegList = this;
1098
- this._writeListToPath();
1099
- return newItem;
1100
- };
1101
- window.SVGPathSegList.prototype.replaceItem = function(newItem, index) {
1102
- this._checkPathSynchronizedToList();
1103
- if (newItem._owningPathSegList) {
1104
- newItem = newItem.clone();
1105
- }
1106
- this._checkValidIndex(index);
1107
- this._list[index] = newItem;
1108
- newItem._owningPathSegList = this;
1109
- this._writeListToPath();
1110
- return newItem;
1111
- };
1112
- window.SVGPathSegList.prototype.removeItem = function(index) {
1113
- this._checkPathSynchronizedToList();
1114
- this._checkValidIndex(index);
1115
- var item = this._list[index];
1116
- this._list.splice(index, 1);
1117
- this._writeListToPath();
1118
- return item;
1119
- };
1120
- window.SVGPathSegList.prototype.appendItem = function(newItem) {
1121
- this._checkPathSynchronizedToList();
1122
- if (newItem._owningPathSegList) {
1123
- newItem = newItem.clone();
1124
- }
1125
- this._list.push(newItem);
1126
- newItem._owningPathSegList = this;
1127
- this._writeListToPath();
1128
- return newItem;
1129
- };
1130
- window.SVGPathSegList._pathSegArrayAsString = function(pathSegArray) {
1131
- var string = "";
1132
- var first = true;
1133
- pathSegArray.forEach((function(pathSeg) {
1134
- if (first) {
1135
- first = false;
1136
- string += pathSeg._asPathString();
1137
- } else {
1138
- string += " " + pathSeg._asPathString();
1139
- }
1140
- }));
1141
- return string;
1142
- };
1143
- window.SVGPathSegList.prototype._parsePath = function(string) {
1144
- if (!string || string.length == 0) return [];
1145
- var owningPathSegList = this;
1146
- var Builder = function() {
1147
- this.pathSegList = [];
1148
- };
1149
- Builder.prototype.appendSegment = function(pathSeg) {
1150
- this.pathSegList.push(pathSeg);
1151
- };
1152
- var Source = function(string) {
1153
- this._string = string;
1154
- this._currentIndex = 0;
1155
- this._endIndex = this._string.length;
1156
- this._previousCommand = window.SVGPathSeg.PATHSEG_UNKNOWN;
1157
- this._skipOptionalSpaces();
1158
- };
1159
- Source.prototype._isCurrentSpace = function() {
1160
- var character = this._string[this._currentIndex];
1161
- return character <= " " && (character == " " || character == "\n" || character == "\t" || character == "\r" || character == "\f");
1162
- };
1163
- Source.prototype._skipOptionalSpaces = function() {
1164
- while (this._currentIndex < this._endIndex && this._isCurrentSpace()) this._currentIndex++;
1165
- return this._currentIndex < this._endIndex;
1166
- };
1167
- Source.prototype._skipOptionalSpacesOrDelimiter = function() {
1168
- if (this._currentIndex < this._endIndex && !this._isCurrentSpace() && this._string.charAt(this._currentIndex) != ",") return false;
1169
- if (this._skipOptionalSpaces()) {
1170
- if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == ",") {
1171
- this._currentIndex++;
1172
- this._skipOptionalSpaces();
1173
- }
1174
- }
1175
- return this._currentIndex < this._endIndex;
1176
- };
1177
- Source.prototype.hasMoreData = function() {
1178
- return this._currentIndex < this._endIndex;
1179
- };
1180
- Source.prototype.peekSegmentType = function() {
1181
- var lookahead = this._string[this._currentIndex];
1182
- return this._pathSegTypeFromChar(lookahead);
1183
- };
1184
- Source.prototype._pathSegTypeFromChar = function(lookahead) {
1185
- switch (lookahead) {
1186
- case "Z":
1187
- case "z":
1188
- return window.SVGPathSeg.PATHSEG_CLOSEPATH;
1189
-
1190
- case "M":
1191
- return window.SVGPathSeg.PATHSEG_MOVETO_ABS;
1192
-
1193
- case "m":
1194
- return window.SVGPathSeg.PATHSEG_MOVETO_REL;
1195
-
1196
- case "L":
1197
- return window.SVGPathSeg.PATHSEG_LINETO_ABS;
1198
-
1199
- case "l":
1200
- return window.SVGPathSeg.PATHSEG_LINETO_REL;
1201
-
1202
- case "C":
1203
- return window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS;
1204
-
1205
- case "c":
1206
- return window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL;
1207
-
1208
- case "Q":
1209
- return window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS;
1210
-
1211
- case "q":
1212
- return window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL;
1213
-
1214
- case "A":
1215
- return window.SVGPathSeg.PATHSEG_ARC_ABS;
1216
-
1217
- case "a":
1218
- return window.SVGPathSeg.PATHSEG_ARC_REL;
1219
-
1220
- case "H":
1221
- return window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS;
1222
-
1223
- case "h":
1224
- return window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL;
1225
-
1226
- case "V":
1227
- return window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS;
1228
-
1229
- case "v":
1230
- return window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL;
1231
-
1232
- case "S":
1233
- return window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
1234
-
1235
- case "s":
1236
- return window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
1237
-
1238
- case "T":
1239
- return window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
1240
-
1241
- case "t":
1242
- return window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
1243
-
1244
- default:
1245
- return window.SVGPathSeg.PATHSEG_UNKNOWN;
1246
- }
1247
- };
1248
- Source.prototype._nextCommandHelper = function(lookahead, previousCommand) {
1249
- if ((lookahead == "+" || lookahead == "-" || lookahead == "." || lookahead >= "0" && lookahead <= "9") && previousCommand != window.SVGPathSeg.PATHSEG_CLOSEPATH) {
1250
- if (previousCommand == window.SVGPathSeg.PATHSEG_MOVETO_ABS) return window.SVGPathSeg.PATHSEG_LINETO_ABS;
1251
- if (previousCommand == window.SVGPathSeg.PATHSEG_MOVETO_REL) return window.SVGPathSeg.PATHSEG_LINETO_REL;
1252
- return previousCommand;
1253
- }
1254
- return window.SVGPathSeg.PATHSEG_UNKNOWN;
1255
- };
1256
- Source.prototype.initialCommandIsMoveTo = function() {
1257
- if (!this.hasMoreData()) return true;
1258
- var command = this.peekSegmentType();
1259
- return command == window.SVGPathSeg.PATHSEG_MOVETO_ABS || command == window.SVGPathSeg.PATHSEG_MOVETO_REL;
1260
- };
1261
- Source.prototype._parseNumber = function() {
1262
- var exponent = 0;
1263
- var integer = 0;
1264
- var frac = 1;
1265
- var decimal = 0;
1266
- var sign = 1;
1267
- var expsign = 1;
1268
- var startIndex = this._currentIndex;
1269
- this._skipOptionalSpaces();
1270
- if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == "+") this._currentIndex++; else if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == "-") {
1271
- this._currentIndex++;
1272
- sign = -1;
1273
- }
1274
- if (this._currentIndex == this._endIndex || (this._string.charAt(this._currentIndex) < "0" || this._string.charAt(this._currentIndex) > "9") && this._string.charAt(this._currentIndex) != ".") return undefined;
1275
- var startIntPartIndex = this._currentIndex;
1276
- while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= "0" && this._string.charAt(this._currentIndex) <= "9") this._currentIndex++;
1277
- if (this._currentIndex != startIntPartIndex) {
1278
- var scanIntPartIndex = this._currentIndex - 1;
1279
- var multiplier = 1;
1280
- while (scanIntPartIndex >= startIntPartIndex) {
1281
- integer += multiplier * (this._string.charAt(scanIntPartIndex--) - "0");
1282
- multiplier *= 10;
1283
- }
1284
- }
1285
- if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) == ".") {
1286
- this._currentIndex++;
1287
- if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < "0" || this._string.charAt(this._currentIndex) > "9") return undefined;
1288
- while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= "0" && this._string.charAt(this._currentIndex) <= "9") {
1289
- frac *= 10;
1290
- decimal += (this._string.charAt(this._currentIndex) - "0") / frac;
1291
- this._currentIndex += 1;
1292
- }
1293
- }
1294
- if (this._currentIndex != startIndex && this._currentIndex + 1 < this._endIndex && (this._string.charAt(this._currentIndex) == "e" || this._string.charAt(this._currentIndex) == "E") && this._string.charAt(this._currentIndex + 1) != "x" && this._string.charAt(this._currentIndex + 1) != "m") {
1295
- this._currentIndex++;
1296
- if (this._string.charAt(this._currentIndex) == "+") {
1297
- this._currentIndex++;
1298
- } else if (this._string.charAt(this._currentIndex) == "-") {
1299
- this._currentIndex++;
1300
- expsign = -1;
1301
- }
1302
- if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < "0" || this._string.charAt(this._currentIndex) > "9") return undefined;
1303
- while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= "0" && this._string.charAt(this._currentIndex) <= "9") {
1304
- exponent *= 10;
1305
- exponent += this._string.charAt(this._currentIndex) - "0";
1306
- this._currentIndex++;
1307
- }
1308
- }
1309
- var number = integer + decimal;
1310
- number *= sign;
1311
- if (exponent) number *= Math.pow(10, expsign * exponent);
1312
- if (startIndex == this._currentIndex) return undefined;
1313
- this._skipOptionalSpacesOrDelimiter();
1314
- return number;
1315
- };
1316
- Source.prototype._parseArcFlag = function() {
1317
- if (this._currentIndex >= this._endIndex) return undefined;
1318
- var flag = false;
1319
- var flagChar = this._string.charAt(this._currentIndex++);
1320
- if (flagChar == "0") flag = false; else if (flagChar == "1") flag = true; else return undefined;
1321
- this._skipOptionalSpacesOrDelimiter();
1322
- return flag;
1323
- };
1324
- Source.prototype.parseSegment = function() {
1325
- var lookahead = this._string[this._currentIndex];
1326
- var command = this._pathSegTypeFromChar(lookahead);
1327
- if (command == window.SVGPathSeg.PATHSEG_UNKNOWN) {
1328
- if (this._previousCommand == window.SVGPathSeg.PATHSEG_UNKNOWN) return null;
1329
- command = this._nextCommandHelper(lookahead, this._previousCommand);
1330
- if (command == window.SVGPathSeg.PATHSEG_UNKNOWN) return null;
1331
- } else {
1332
- this._currentIndex++;
1333
- }
1334
- this._previousCommand = command;
1335
- switch (command) {
1336
- case window.SVGPathSeg.PATHSEG_MOVETO_REL:
1337
- return new window.SVGPathSegMovetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());
1338
-
1339
- case window.SVGPathSeg.PATHSEG_MOVETO_ABS:
1340
- return new window.SVGPathSegMovetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
1341
-
1342
- case window.SVGPathSeg.PATHSEG_LINETO_REL:
1343
- return new window.SVGPathSegLinetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());
1344
-
1345
- case window.SVGPathSeg.PATHSEG_LINETO_ABS:
1346
- return new window.SVGPathSegLinetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
1347
-
1348
- case window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:
1349
- return new window.SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber());
1350
-
1351
- case window.SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:
1352
- return new window.SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber());
1353
-
1354
- case window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL:
1355
- return new window.SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber());
1356
-
1357
- case window.SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS:
1358
- return new window.SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber());
1359
-
1360
- case window.SVGPathSeg.PATHSEG_CLOSEPATH:
1361
- this._skipOptionalSpaces();
1362
- return new window.SVGPathSegClosePath(owningPathSegList);
1363
-
1364
- case window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL:
1365
- var points = {
1366
- x1: this._parseNumber(),
1367
- y1: this._parseNumber(),
1368
- x2: this._parseNumber(),
1369
- y2: this._parseNumber(),
1370
- x: this._parseNumber(),
1371
- y: this._parseNumber()
1372
- };
1373
- return new window.SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);
1374
-
1375
- case window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS:
1376
- var points = {
1377
- x1: this._parseNumber(),
1378
- y1: this._parseNumber(),
1379
- x2: this._parseNumber(),
1380
- y2: this._parseNumber(),
1381
- x: this._parseNumber(),
1382
- y: this._parseNumber()
1383
- };
1384
- return new window.SVGPathSegCurvetoCubicAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);
1385
-
1386
- case window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL:
1387
- var points = {
1388
- x2: this._parseNumber(),
1389
- y2: this._parseNumber(),
1390
- x: this._parseNumber(),
1391
- y: this._parseNumber()
1392
- };
1393
- return new window.SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, points.x, points.y, points.x2, points.y2);
1394
-
1395
- case window.SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS:
1396
- var points = {
1397
- x2: this._parseNumber(),
1398
- y2: this._parseNumber(),
1399
- x: this._parseNumber(),
1400
- y: this._parseNumber()
1401
- };
1402
- return new window.SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, points.x, points.y, points.x2, points.y2);
1403
-
1404
- case window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL:
1405
- var points = {
1406
- x1: this._parseNumber(),
1407
- y1: this._parseNumber(),
1408
- x: this._parseNumber(),
1409
- y: this._parseNumber()
1410
- };
1411
- return new window.SVGPathSegCurvetoQuadraticRel(owningPathSegList, points.x, points.y, points.x1, points.y1);
1412
-
1413
- case window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS:
1414
- var points = {
1415
- x1: this._parseNumber(),
1416
- y1: this._parseNumber(),
1417
- x: this._parseNumber(),
1418
- y: this._parseNumber()
1419
- };
1420
- return new window.SVGPathSegCurvetoQuadraticAbs(owningPathSegList, points.x, points.y, points.x1, points.y1);
1421
-
1422
- case window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:
1423
- return new window.SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(), this._parseNumber());
1424
-
1425
- case window.SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:
1426
- return new window.SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(), this._parseNumber());
1427
-
1428
- case window.SVGPathSeg.PATHSEG_ARC_REL:
1429
- var points = {
1430
- x1: this._parseNumber(),
1431
- y1: this._parseNumber(),
1432
- arcAngle: this._parseNumber(),
1433
- arcLarge: this._parseArcFlag(),
1434
- arcSweep: this._parseArcFlag(),
1435
- x: this._parseNumber(),
1436
- y: this._parseNumber()
1437
- };
1438
- return new window.SVGPathSegArcRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);
1439
-
1440
- case window.SVGPathSeg.PATHSEG_ARC_ABS:
1441
- var points = {
1442
- x1: this._parseNumber(),
1443
- y1: this._parseNumber(),
1444
- arcAngle: this._parseNumber(),
1445
- arcLarge: this._parseArcFlag(),
1446
- arcSweep: this._parseArcFlag(),
1447
- x: this._parseNumber(),
1448
- y: this._parseNumber()
1449
- };
1450
- return new window.SVGPathSegArcAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);
1451
-
1452
- default:
1453
- throw "Unknown path seg type.";
1454
- }
1455
- };
1456
- var builder = new Builder;
1457
- var source = new Source(string);
1458
- if (!source.initialCommandIsMoveTo()) return [];
1459
- while (source.hasMoreData()) {
1460
- var pathSeg = source.parseSegment();
1461
- if (!pathSeg) return [];
1462
- builder.appendSegment(pathSeg);
1463
- }
1464
- return builder.pathSegList;
1465
- };
1466
- }
1467
- } catch (e) {
1468
- console.warn("An error occurred in tsParticles pathseg polyfill. If the Polygon Mask is not working, please open an issue here: https://github.com/matteobruni/tsparticles", e);
1469
- }
1470
- })();
1471
- }
1472
- } ]);