@pie-lib/plot 4.0.22-beta.1 → 4.0.22-beta.11

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.
@@ -0,0 +1,738 @@
1
+ "use strict";
2
+
3
+ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
4
+ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
5
+ var _react = require("@testing-library/react");
6
+ var _react2 = _interopRequireDefault(require("react"));
7
+ var _gridDraggable = require("../grid-draggable");
8
+ var _utils = require("../utils");
9
+ var _d3Selection = require("d3-selection");
10
+ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
11
+ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
12
+ jest.mock('d3-selection', function () {
13
+ return {
14
+ pointer: jest.fn().mockReturnValue([0, 0])
15
+ };
16
+ });
17
+ var mockDraggableCoreProps;
18
+ jest.mock('../draggable', function () {
19
+ return {
20
+ DraggableCore: function DraggableCore(props) {
21
+ // Store the props so tests can call the handlers
22
+ mockDraggableCoreProps = props;
23
+ return props.children;
24
+ }
25
+ };
26
+ });
27
+
28
+ // Reusable mock start event with a target that supports addEventListener/removeEventListener
29
+ var mockStartEvent = function mockStartEvent() {
30
+ var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
31
+ return _objectSpread({
32
+ clientX: 0,
33
+ clientY: 0,
34
+ target: {
35
+ addEventListener: jest.fn(),
36
+ removeEventListener: jest.fn()
37
+ }
38
+ }, overrides);
39
+ };
40
+ jest.mock('../utils', function () {
41
+ return {
42
+ getDelta: jest.fn()
43
+ };
44
+ });
45
+ var xyFn = function xyFn() {
46
+ var out = jest.fn(function (n) {
47
+ return n;
48
+ });
49
+ out.invert = jest.fn(function (n) {
50
+ return n;
51
+ });
52
+ return out;
53
+ };
54
+ var getGraphProps = function getGraphProps() {
55
+ return {
56
+ scale: {
57
+ x: xyFn(),
58
+ y: xyFn()
59
+ },
60
+ snap: {
61
+ x: xyFn(),
62
+ y: xyFn()
63
+ },
64
+ domain: {
65
+ min: 0,
66
+ max: 1,
67
+ step: 1
68
+ },
69
+ range: {
70
+ min: 0,
71
+ max: 1,
72
+ step: 1
73
+ },
74
+ size: {
75
+ width: 500,
76
+ height: 500
77
+ },
78
+ getRootNode: function getRootNode() {
79
+ return {
80
+ ownerSVGElement: null,
81
+ getBoundingClientRect: function getBoundingClientRect() {
82
+ return {
83
+ left: 0,
84
+ top: 0,
85
+ right: 100,
86
+ bottom: 100
87
+ };
88
+ }
89
+ };
90
+ }
91
+ };
92
+ };
93
+ describe('gridDraggable', function () {
94
+ var defaultOptions;
95
+ var defaultProps;
96
+ beforeEach(function () {
97
+ mockDraggableCoreProps = null;
98
+ defaultOptions = {
99
+ anchorPoint: jest.fn().mockReturnValue({
100
+ x: 0,
101
+ y: 0
102
+ }),
103
+ bounds: jest.fn().mockReturnValue({
104
+ left: 0,
105
+ top: 0,
106
+ bottom: 0,
107
+ right: 0
108
+ }),
109
+ fromDelta: jest.fn()
110
+ };
111
+ defaultProps = {
112
+ graphProps: getGraphProps()
113
+ };
114
+ });
115
+ it('renders regular component', function () {
116
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
117
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
118
+ });
119
+ var _render = (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, defaultProps)),
120
+ container = _render.container;
121
+ expect(container.firstChild).toBeInTheDocument();
122
+ });
123
+ it('renders with decimal domain and range', function () {
124
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
125
+ graphProps: _objectSpread(_objectSpread({}, getGraphProps()), {}, {
126
+ domain: {
127
+ min: -1.5,
128
+ max: 1.6,
129
+ step: 0.3
130
+ },
131
+ range: {
132
+ min: -2,
133
+ max: 3,
134
+ step: 0.2
135
+ }
136
+ })
137
+ });
138
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
139
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
140
+ });
141
+ var _render2 = (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props)),
142
+ container = _render2.container;
143
+ expect(container.firstChild).toBeInTheDocument();
144
+ });
145
+ describe('logic', function () {
146
+ describe('grid calculation', function () {
147
+ it('passes correct grid to DraggableCore based on domain and range step', function () {
148
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
149
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
150
+ });
151
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, defaultProps));
152
+
153
+ // Grid is calculated as: scale.x(domain.step) - scale.x(0)
154
+ // With our mock xyFn that returns n, this is: step - 0 = step
155
+ expect(mockDraggableCoreProps.grid).toEqual([1, 1]);
156
+ });
157
+ it('calculates grid with decimal steps', function () {
158
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
159
+ graphProps: _objectSpread(_objectSpread({}, getGraphProps()), {}, {
160
+ domain: {
161
+ min: -1.5,
162
+ max: 1.6,
163
+ step: 0.3
164
+ },
165
+ range: {
166
+ min: -2,
167
+ max: 3,
168
+ step: 0.2
169
+ }
170
+ })
171
+ });
172
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
173
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
174
+ });
175
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
176
+ expect(mockDraggableCoreProps.grid).toEqual([0.3, 0.2]);
177
+ });
178
+ });
179
+ describe('onStart', function () {
180
+ it('calls onDragStart handler when drag starts', function () {
181
+ var onDragStart = jest.fn();
182
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
183
+ onDragStart: onDragStart
184
+ });
185
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
186
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
187
+ });
188
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
189
+
190
+ // Simulate drag start
191
+ mockDraggableCoreProps.onStart(mockStartEvent({
192
+ clientX: 100,
193
+ clientY: 100
194
+ }));
195
+ expect(onDragStart).toHaveBeenCalled();
196
+ });
197
+ });
198
+ describe('onDrag', function () {
199
+ it('calls onDrag callback with result from fromDelta', function () {
200
+ var onDrag = jest.fn();
201
+ var fromDelta = jest.fn().mockReturnValue('delta-result');
202
+ var bounds = jest.fn().mockReturnValue({
203
+ left: -100,
204
+ top: -100,
205
+ bottom: 100,
206
+ right: 100
207
+ });
208
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
209
+ fromDelta: fromDelta,
210
+ bounds: bounds
211
+ });
212
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
213
+ onDrag: onDrag
214
+ });
215
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
216
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
217
+ });
218
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
219
+
220
+ // Set up drag start state
221
+ mockDraggableCoreProps.onStart(mockStartEvent());
222
+
223
+ // Simulate drag
224
+ mockDraggableCoreProps.onDrag({}, {
225
+ deltaX: 10,
226
+ deltaY: 10
227
+ });
228
+ expect(fromDelta).toHaveBeenCalled();
229
+ expect(onDrag).toHaveBeenCalledWith('delta-result');
230
+ });
231
+ it('does not call onDrag when no onDrag handler is provided', function () {
232
+ var fromDelta = jest.fn();
233
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
234
+ fromDelta: fromDelta
235
+ });
236
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
237
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
238
+ });
239
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, defaultProps));
240
+ mockDraggableCoreProps.onStart(mockStartEvent());
241
+ mockDraggableCoreProps.onDrag({}, {
242
+ deltaX: 10,
243
+ deltaY: 10
244
+ });
245
+ expect(fromDelta).not.toHaveBeenCalled();
246
+ });
247
+ describe('bounds checking', function () {
248
+ it('does not call onDrag when dragging left beyond left bound', function () {
249
+ var onDrag = jest.fn();
250
+ var bounds = jest.fn().mockReturnValue({
251
+ left: 0,
252
+ top: 0,
253
+ bottom: 0,
254
+ right: 0
255
+ });
256
+ var fromDelta = jest.fn().mockReturnValue('result');
257
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
258
+ bounds: bounds,
259
+ fromDelta: fromDelta
260
+ });
261
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
262
+ onDrag: onDrag
263
+ });
264
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
265
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
266
+ });
267
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
268
+ mockDraggableCoreProps.onStart(mockStartEvent());
269
+ // deltaX < 0 and deltaX < scaled bounds.left (0), so -10 < 0 triggers early return
270
+ mockDraggableCoreProps.onDrag({}, {
271
+ deltaX: -10,
272
+ deltaY: 0
273
+ });
274
+ expect(onDrag).not.toHaveBeenCalled();
275
+ });
276
+ it('does not call onDrag when dragging right beyond right bound', function () {
277
+ var onDrag = jest.fn();
278
+ var bounds = jest.fn().mockReturnValue({
279
+ left: 0,
280
+ top: 0,
281
+ bottom: 0,
282
+ right: 0
283
+ });
284
+ var fromDelta = jest.fn().mockReturnValue('result');
285
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
286
+ bounds: bounds,
287
+ fromDelta: fromDelta
288
+ });
289
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
290
+ onDrag: onDrag
291
+ });
292
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
293
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
294
+ });
295
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
296
+ mockDraggableCoreProps.onStart(mockStartEvent());
297
+ // deltaX > 0 and deltaX > scaled bounds.right (0), so 10 > 0 triggers early return
298
+ mockDraggableCoreProps.onDrag({}, {
299
+ deltaX: 10,
300
+ deltaY: 0
301
+ });
302
+ expect(onDrag).not.toHaveBeenCalled();
303
+ });
304
+ it('does not call onDrag when dragging up beyond top bound', function () {
305
+ var onDrag = jest.fn();
306
+ var bounds = jest.fn().mockReturnValue({
307
+ left: -100,
308
+ top: 0,
309
+ bottom: 0,
310
+ right: 100
311
+ });
312
+ var fromDelta = jest.fn().mockReturnValue('result');
313
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
314
+ bounds: bounds,
315
+ fromDelta: fromDelta
316
+ });
317
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
318
+ onDrag: onDrag
319
+ });
320
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
321
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
322
+ });
323
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
324
+ mockDraggableCoreProps.onStart(mockStartEvent());
325
+ // deltaY < 0 and deltaY < scaled bounds.top (0), so -10 < 0 triggers early return
326
+ mockDraggableCoreProps.onDrag({}, {
327
+ deltaX: 0,
328
+ deltaY: -10
329
+ });
330
+ expect(onDrag).not.toHaveBeenCalled();
331
+ });
332
+ it('does not call onDrag when dragging down beyond bottom bound', function () {
333
+ var onDrag = jest.fn();
334
+ var bounds = jest.fn().mockReturnValue({
335
+ left: -100,
336
+ top: -100,
337
+ bottom: 0,
338
+ right: 100
339
+ });
340
+ var fromDelta = jest.fn().mockReturnValue('result');
341
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
342
+ bounds: bounds,
343
+ fromDelta: fromDelta
344
+ });
345
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
346
+ onDrag: onDrag
347
+ });
348
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
349
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
350
+ });
351
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
352
+ mockDraggableCoreProps.onStart(mockStartEvent());
353
+ // deltaY > 0 and deltaY > scaled bounds.bottom (0), so 10 > 0 triggers early return
354
+ mockDraggableCoreProps.onDrag({}, {
355
+ deltaX: 0,
356
+ deltaY: 10
357
+ });
358
+ expect(onDrag).not.toHaveBeenCalled();
359
+ });
360
+ it('calls onDrag when dragging within bounds', function () {
361
+ var onDrag = jest.fn();
362
+ var bounds = jest.fn().mockReturnValue({
363
+ left: -100,
364
+ top: -100,
365
+ bottom: 100,
366
+ right: 100
367
+ });
368
+ var fromDelta = jest.fn().mockReturnValue('result');
369
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
370
+ bounds: bounds,
371
+ fromDelta: fromDelta
372
+ });
373
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
374
+ onDrag: onDrag
375
+ });
376
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
377
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
378
+ });
379
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
380
+ mockDraggableCoreProps.onStart(mockStartEvent());
381
+ // All bound checks pass: deltaX (-10) is NOT < bounds.left (-100) and NOT > bounds.right (100)
382
+ // Similarly for deltaY
383
+ mockDraggableCoreProps.onDrag({}, {
384
+ deltaX: -10,
385
+ deltaY: 10
386
+ });
387
+ expect(onDrag).toHaveBeenCalled();
388
+ });
389
+ });
390
+ describe('skipDragOutsideOfBounds', function () {
391
+ it('skips drag when moving left and x is below domain.min', function () {
392
+ var onDrag = jest.fn();
393
+ var graphProps = _objectSpread(_objectSpread({}, getGraphProps()), {}, {
394
+ domain: {
395
+ min: -5,
396
+ max: 5,
397
+ step: 1
398
+ },
399
+ range: {
400
+ min: -5,
401
+ max: 5,
402
+ step: 1
403
+ }
404
+ });
405
+ graphProps.scale.x.invert = jest.fn().mockReturnValue(-6); // Below min
406
+
407
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
408
+ graphProps: graphProps,
409
+ onDrag: onDrag
410
+ });
411
+ var bounds = jest.fn().mockReturnValue({
412
+ left: 100,
413
+ top: 100,
414
+ bottom: 100,
415
+ right: 100
416
+ });
417
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
418
+ bounds: bounds
419
+ });
420
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
421
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
422
+ });
423
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
424
+ mockDraggableCoreProps.onStart(mockStartEvent());
425
+ mockDraggableCoreProps.onDrag({}, {
426
+ deltaX: 1,
427
+ deltaY: 0
428
+ });
429
+ expect(onDrag).not.toHaveBeenCalled();
430
+ });
431
+ it('skips drag when moving right and x is above domain.max', function () {
432
+ var onDrag = jest.fn();
433
+ var graphProps = _objectSpread(_objectSpread({}, getGraphProps()), {}, {
434
+ domain: {
435
+ min: -5,
436
+ max: 5,
437
+ step: 1
438
+ },
439
+ range: {
440
+ min: -5,
441
+ max: 5,
442
+ step: 1
443
+ }
444
+ });
445
+ graphProps.scale.x.invert = jest.fn().mockReturnValue(6); // Above max
446
+
447
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
448
+ graphProps: graphProps,
449
+ onDrag: onDrag
450
+ });
451
+ var bounds = jest.fn().mockReturnValue({
452
+ left: 100,
453
+ top: 100,
454
+ bottom: 100,
455
+ right: 100
456
+ });
457
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
458
+ bounds: bounds
459
+ });
460
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
461
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
462
+ });
463
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
464
+ mockDraggableCoreProps.onStart(mockStartEvent());
465
+ mockDraggableCoreProps.onDrag({}, {
466
+ deltaX: -1,
467
+ deltaY: 0
468
+ });
469
+ expect(onDrag).not.toHaveBeenCalled();
470
+ });
471
+ it('skips drag when moving up and y is above range.max', function () {
472
+ var onDrag = jest.fn();
473
+ var graphProps = _objectSpread(_objectSpread({}, getGraphProps()), {}, {
474
+ domain: {
475
+ min: -5,
476
+ max: 5,
477
+ step: 1
478
+ },
479
+ range: {
480
+ min: -5,
481
+ max: 5,
482
+ step: 1
483
+ }
484
+ });
485
+ graphProps.scale.y.invert = jest.fn().mockReturnValue(6); // Above max
486
+
487
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
488
+ graphProps: graphProps,
489
+ onDrag: onDrag
490
+ });
491
+ var bounds = jest.fn().mockReturnValue({
492
+ left: 100,
493
+ top: 100,
494
+ bottom: 100,
495
+ right: 100
496
+ });
497
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
498
+ bounds: bounds
499
+ });
500
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
501
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
502
+ });
503
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
504
+ mockDraggableCoreProps.onStart(mockStartEvent());
505
+ mockDraggableCoreProps.onDrag({}, {
506
+ deltaX: 0,
507
+ deltaY: 1
508
+ });
509
+ expect(onDrag).not.toHaveBeenCalled();
510
+ });
511
+ it('skips drag when moving down and y is below range.min', function () {
512
+ var onDrag = jest.fn();
513
+ var graphProps = _objectSpread(_objectSpread({}, getGraphProps()), {}, {
514
+ domain: {
515
+ min: -5,
516
+ max: 5,
517
+ step: 1
518
+ },
519
+ range: {
520
+ min: -5,
521
+ max: 5,
522
+ step: 1
523
+ }
524
+ });
525
+ graphProps.scale.y.invert = jest.fn().mockReturnValue(-6); // Below min
526
+
527
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
528
+ graphProps: graphProps,
529
+ onDrag: onDrag
530
+ });
531
+ var bounds = jest.fn().mockReturnValue({
532
+ left: 100,
533
+ top: 100,
534
+ bottom: 100,
535
+ right: 100
536
+ });
537
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
538
+ bounds: bounds
539
+ });
540
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
541
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
542
+ });
543
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
544
+ mockDraggableCoreProps.onStart(mockStartEvent());
545
+ mockDraggableCoreProps.onDrag({}, {
546
+ deltaX: 0,
547
+ deltaY: -1
548
+ });
549
+ expect(onDrag).not.toHaveBeenCalled();
550
+ });
551
+ it('allows drag when within domain and range', function () {
552
+ var onDrag = jest.fn();
553
+ var graphProps = _objectSpread(_objectSpread({}, getGraphProps()), {}, {
554
+ domain: {
555
+ min: -5,
556
+ max: 5,
557
+ step: 1
558
+ },
559
+ range: {
560
+ min: -5,
561
+ max: 5,
562
+ step: 1
563
+ }
564
+ });
565
+ graphProps.scale.x.invert = jest.fn().mockReturnValue(3); // Within bounds
566
+ graphProps.scale.y.invert = jest.fn().mockReturnValue(2); // Within bounds
567
+
568
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
569
+ graphProps: graphProps,
570
+ onDrag: onDrag
571
+ });
572
+ var bounds = jest.fn().mockReturnValue({
573
+ left: -100,
574
+ top: -100,
575
+ bottom: 100,
576
+ right: 100
577
+ });
578
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
579
+ bounds: bounds
580
+ });
581
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
582
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
583
+ });
584
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
585
+ mockDraggableCoreProps.onStart(mockStartEvent());
586
+ mockDraggableCoreProps.onDrag({}, {
587
+ deltaX: 1,
588
+ deltaY: -1
589
+ });
590
+ expect(onDrag).toHaveBeenCalled();
591
+ });
592
+ });
593
+ });
594
+ describe('getDelta and applyDelta', function () {
595
+ it('calls utils.getDelta when processing drag', function () {
596
+ _utils.getDelta.mockClear();
597
+ var onDrag = jest.fn();
598
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
599
+ onDrag: onDrag
600
+ });
601
+ var bounds = jest.fn().mockReturnValue({
602
+ left: -100,
603
+ top: -100,
604
+ bottom: 100,
605
+ right: 100
606
+ });
607
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
608
+ bounds: bounds
609
+ });
610
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
611
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
612
+ });
613
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
614
+ mockDraggableCoreProps.onStart(mockStartEvent());
615
+ mockDraggableCoreProps.onDrag({}, {
616
+ deltaX: 10,
617
+ deltaY: 10
618
+ });
619
+ expect(_utils.getDelta).toHaveBeenCalled();
620
+ });
621
+ it('calls fromDelta with result from getDelta', function () {
622
+ var fromDelta = jest.fn();
623
+ _utils.getDelta.mockReturnValue({
624
+ x: 5,
625
+ y: 5
626
+ });
627
+ var bounds = jest.fn().mockReturnValue({
628
+ left: -100,
629
+ top: -100,
630
+ bottom: 100,
631
+ right: 100
632
+ });
633
+ var options = _objectSpread(_objectSpread({}, defaultOptions), {}, {
634
+ fromDelta: fromDelta,
635
+ bounds: bounds
636
+ });
637
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
638
+ onDrag: jest.fn()
639
+ });
640
+ var Comp = (0, _gridDraggable.gridDraggable)(options)(function () {
641
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
642
+ });
643
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
644
+ mockDraggableCoreProps.onStart(mockStartEvent());
645
+ mockDraggableCoreProps.onDrag({}, {
646
+ deltaX: 10,
647
+ deltaY: 10
648
+ });
649
+ expect(fromDelta).toHaveBeenCalled();
650
+ });
651
+ });
652
+ describe('onStop', function () {
653
+ it('calls onDragStop when drag stops', function () {
654
+ var onDragStop = jest.fn();
655
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
656
+ onDragStop: onDragStop
657
+ });
658
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
659
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
660
+ });
661
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
662
+
663
+ // Start to set up state
664
+ mockDraggableCoreProps.onStart(mockStartEvent());
665
+
666
+ // Stop with large movement (not tiny)
667
+ mockDraggableCoreProps.onStop({
668
+ clientX: 100,
669
+ clientY: 100,
670
+ stopPropagation: jest.fn()
671
+ }, {});
672
+ expect(onDragStop).toHaveBeenCalled();
673
+ });
674
+ it('calls onClick instead of onDragStop when movement is tiny', function () {
675
+ var onClick = jest.fn();
676
+ var onDragStop = jest.fn();
677
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
678
+ onClick: onClick,
679
+ onDragStop: onDragStop
680
+ });
681
+ _d3Selection.pointer.mockReturnValue([0, 0]);
682
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
683
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
684
+ });
685
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, props));
686
+
687
+ // Start and stop at almost the same position (tiny movement)
688
+ // Grid is 1x1, tiny threshold is grid/10 = 0.1
689
+ mockDraggableCoreProps.onStart(mockStartEvent());
690
+ mockDraggableCoreProps.onStop({
691
+ clientX: 0.05,
692
+ clientY: 0.05,
693
+ target: {},
694
+ stopPropagation: jest.fn()
695
+ }, {});
696
+ expect(onClick).toHaveBeenCalledWith({
697
+ x: 0,
698
+ y: 0
699
+ });
700
+ });
701
+ it('calls onClick with snapped coordinates', function () {
702
+ var onClick = jest.fn();
703
+ var props = _objectSpread(_objectSpread({}, defaultProps), {}, {
704
+ onClick: onClick
705
+ });
706
+ var graphProps = getGraphProps();
707
+ graphProps.scale.x.invert = jest.fn().mockReturnValue(1.7);
708
+ graphProps.scale.y.invert = jest.fn().mockReturnValue(2.3);
709
+ graphProps.snap.x = jest.fn().mockReturnValue(2);
710
+ graphProps.snap.y = jest.fn().mockReturnValue(2);
711
+ _d3Selection.pointer.mockReturnValue([1.7, 2.3]);
712
+ var propsWithGraphProps = _objectSpread(_objectSpread({}, props), {}, {
713
+ graphProps: graphProps
714
+ });
715
+ var Comp = (0, _gridDraggable.gridDraggable)(defaultOptions)(function () {
716
+ return /*#__PURE__*/_react2["default"].createElement("div", null, "Test");
717
+ });
718
+ (0, _react.render)(/*#__PURE__*/_react2["default"].createElement(Comp, propsWithGraphProps));
719
+
720
+ // Start and stop at almost the same position (tiny movement)
721
+ mockDraggableCoreProps.onStart(mockStartEvent());
722
+ mockDraggableCoreProps.onStop({
723
+ clientX: 0.05,
724
+ clientY: 0.05,
725
+ target: {},
726
+ stopPropagation: jest.fn()
727
+ }, {});
728
+ expect(graphProps.snap.x).toHaveBeenCalledWith(1.7);
729
+ expect(graphProps.snap.y).toHaveBeenCalledWith(2.3);
730
+ expect(onClick).toHaveBeenCalledWith({
731
+ x: 2,
732
+ y: 2
733
+ });
734
+ });
735
+ });
736
+ });
737
+ });
738
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_react2","_interopRequireDefault","_gridDraggable","_utils","_d3Selection","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","pointer","fn","mockReturnValue","mockDraggableCoreProps","DraggableCore","props","children","mockStartEvent","overrides","undefined","clientX","clientY","target","addEventListener","removeEventListener","getDelta","xyFn","out","n","invert","getGraphProps","scale","x","y","snap","domain","min","max","step","range","size","width","height","getRootNode","ownerSVGElement","getBoundingClientRect","left","top","right","bottom","describe","defaultOptions","defaultProps","beforeEach","anchorPoint","bounds","fromDelta","graphProps","it","Comp","gridDraggable","createElement","_render","render","container","expect","firstChild","toBeInTheDocument","_render2","grid","toEqual","onDragStart","onStart","toHaveBeenCalled","onDrag","options","deltaX","deltaY","toHaveBeenCalledWith","not","mockClear","onDragStop","onStop","stopPropagation","onClick","propsWithGraphProps"],"sources":["../../src/__tests__/grid-draggable.test.jsx"],"sourcesContent":["import { render } from '@testing-library/react';\nimport React from 'react';\nimport { gridDraggable } from '../grid-draggable';\nimport { getDelta } from '../utils';\nimport { pointer } from 'd3-selection';\n\njest.mock('d3-selection', () => ({\n  pointer: jest.fn().mockReturnValue([0, 0]),\n}));\n\nlet mockDraggableCoreProps;\njest.mock('../draggable', () => ({\n  DraggableCore: (props) => {\n    // Store the props so tests can call the handlers\n    mockDraggableCoreProps = props;\n    return props.children;\n  },\n}));\n\n// Reusable mock start event with a target that supports addEventListener/removeEventListener\nconst mockStartEvent = (overrides = {}) => ({\n  clientX: 0,\n  clientY: 0,\n  target: { addEventListener: jest.fn(), removeEventListener: jest.fn() },\n  ...overrides,\n});\n\njest.mock('../utils', () => ({\n  getDelta: jest.fn(),\n}));\n\nconst xyFn = () => {\n  const out = jest.fn((n) => n);\n  out.invert = jest.fn((n) => n);\n  return out;\n};\n\nconst getGraphProps = () => ({\n  scale: {\n    x: xyFn(),\n    y: xyFn(),\n  },\n  snap: {\n    x: xyFn(),\n    y: xyFn(),\n  },\n  domain: {\n    min: 0,\n    max: 1,\n    step: 1,\n  },\n  range: {\n    min: 0,\n    max: 1,\n    step: 1,\n  },\n  size: {\n    width: 500,\n    height: 500,\n  },\n  getRootNode: () => ({\n    ownerSVGElement: null,\n    getBoundingClientRect: () => ({\n      left: 0,\n      top: 0,\n      right: 100,\n      bottom: 100,\n    }),\n  }),\n});\n\ndescribe('gridDraggable', () => {\n  let defaultOptions;\n  let defaultProps;\n\n  beforeEach(() => {\n    mockDraggableCoreProps = null;\n    defaultOptions = {\n      anchorPoint: jest.fn().mockReturnValue({ x: 0, y: 0 }),\n      bounds: jest.fn().mockReturnValue({ left: 0, top: 0, bottom: 0, right: 0 }),\n      fromDelta: jest.fn(),\n    };\n\n    defaultProps = {\n      graphProps: getGraphProps(),\n    };\n  });\n\n  it('renders regular component', () => {\n    const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n    const { container } = render(<Comp {...defaultProps} />);\n    expect(container.firstChild).toBeInTheDocument();\n  });\n\n  it('renders with decimal domain and range', () => {\n    const props = {\n      ...defaultProps,\n      graphProps: {\n        ...getGraphProps(),\n        domain: {\n          min: -1.5,\n          max: 1.6,\n          step: 0.3,\n        },\n        range: {\n          min: -2,\n          max: 3,\n          step: 0.2,\n        },\n      },\n    };\n    const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n    const { container } = render(<Comp {...props} />);\n    expect(container.firstChild).toBeInTheDocument();\n  });\n\n  describe('logic', () => {\n    describe('grid calculation', () => {\n      it('passes correct grid to DraggableCore based on domain and range step', () => {\n        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n        render(<Comp {...defaultProps} />);\n\n        // Grid is calculated as: scale.x(domain.step) - scale.x(0)\n        // With our mock xyFn that returns n, this is: step - 0 = step\n        expect(mockDraggableCoreProps.grid).toEqual([1, 1]);\n      });\n\n      it('calculates grid with decimal steps', () => {\n        const props = {\n          ...defaultProps,\n          graphProps: {\n            ...getGraphProps(),\n            domain: { min: -1.5, max: 1.6, step: 0.3 },\n            range: { min: -2, max: 3, step: 0.2 },\n          },\n        };\n        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n        render(<Comp {...props} />);\n\n        expect(mockDraggableCoreProps.grid).toEqual([0.3, 0.2]);\n      });\n    });\n\n    describe('onStart', () => {\n      it('calls onDragStart handler when drag starts', () => {\n        const onDragStart = jest.fn();\n        const props = { ...defaultProps, onDragStart };\n        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n        render(<Comp {...props} />);\n\n        // Simulate drag start\n        mockDraggableCoreProps.onStart(mockStartEvent({ clientX: 100, clientY: 100 }));\n\n        expect(onDragStart).toHaveBeenCalled();\n      });\n    });\n\n    describe('onDrag', () => {\n      it('calls onDrag callback with result from fromDelta', () => {\n        const onDrag = jest.fn();\n        const fromDelta = jest.fn().mockReturnValue('delta-result');\n        const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });\n        const options = { ...defaultOptions, fromDelta, bounds };\n        const props = { ...defaultProps, onDrag };\n\n        const Comp = gridDraggable(options)(() => <div>Test</div>);\n        render(<Comp {...props} />);\n\n        // Set up drag start state\n        mockDraggableCoreProps.onStart(mockStartEvent());\n\n        // Simulate drag\n        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });\n\n        expect(fromDelta).toHaveBeenCalled();\n        expect(onDrag).toHaveBeenCalledWith('delta-result');\n      });\n\n      it('does not call onDrag when no onDrag handler is provided', () => {\n        const fromDelta = jest.fn();\n        const options = { ...defaultOptions, fromDelta };\n        const Comp = gridDraggable(options)(() => <div>Test</div>);\n        render(<Comp {...defaultProps} />);\n\n        mockDraggableCoreProps.onStart(mockStartEvent());\n        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });\n\n        expect(fromDelta).not.toHaveBeenCalled();\n      });\n\n      describe('bounds checking', () => {\n        it('does not call onDrag when dragging left beyond left bound', () => {\n          const onDrag = jest.fn();\n          const bounds = jest.fn().mockReturnValue({ left: 0, top: 0, bottom: 0, right: 0 });\n          const fromDelta = jest.fn().mockReturnValue('result');\n          const options = { ...defaultOptions, bounds, fromDelta };\n          const props = { ...defaultProps, onDrag };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          // deltaX < 0 and deltaX < scaled bounds.left (0), so -10 < 0 triggers early return\n          mockDraggableCoreProps.onDrag({}, { deltaX: -10, deltaY: 0 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('does not call onDrag when dragging right beyond right bound', () => {\n          const onDrag = jest.fn();\n          const bounds = jest.fn().mockReturnValue({ left: 0, top: 0, bottom: 0, right: 0 });\n          const fromDelta = jest.fn().mockReturnValue('result');\n          const options = { ...defaultOptions, bounds, fromDelta };\n          const props = { ...defaultProps, onDrag };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          // deltaX > 0 and deltaX > scaled bounds.right (0), so 10 > 0 triggers early return\n          mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 0 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('does not call onDrag when dragging up beyond top bound', () => {\n          const onDrag = jest.fn();\n          const bounds = jest.fn().mockReturnValue({ left: -100, top: 0, bottom: 0, right: 100 });\n          const fromDelta = jest.fn().mockReturnValue('result');\n          const options = { ...defaultOptions, bounds, fromDelta };\n          const props = { ...defaultProps, onDrag };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          // deltaY < 0 and deltaY < scaled bounds.top (0), so -10 < 0 triggers early return\n          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: -10 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('does not call onDrag when dragging down beyond bottom bound', () => {\n          const onDrag = jest.fn();\n          const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 0, right: 100 });\n          const fromDelta = jest.fn().mockReturnValue('result');\n          const options = { ...defaultOptions, bounds, fromDelta };\n          const props = { ...defaultProps, onDrag };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          // deltaY > 0 and deltaY > scaled bounds.bottom (0), so 10 > 0 triggers early return\n          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: 10 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('calls onDrag when dragging within bounds', () => {\n          const onDrag = jest.fn();\n          const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });\n          const fromDelta = jest.fn().mockReturnValue('result');\n          const options = { ...defaultOptions, bounds, fromDelta };\n          const props = { ...defaultProps, onDrag };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          // All bound checks pass: deltaX (-10) is NOT < bounds.left (-100) and NOT > bounds.right (100)\n          // Similarly for deltaY\n          mockDraggableCoreProps.onDrag({}, { deltaX: -10, deltaY: 10 });\n\n          expect(onDrag).toHaveBeenCalled();\n        });\n      });\n\n      describe('skipDragOutsideOfBounds', () => {\n        it('skips drag when moving left and x is below domain.min', () => {\n          const onDrag = jest.fn();\n          const graphProps = {\n            ...getGraphProps(),\n            domain: { min: -5, max: 5, step: 1 },\n            range: { min: -5, max: 5, step: 1 },\n          };\n          graphProps.scale.x.invert = jest.fn().mockReturnValue(-6); // Below min\n\n          const props = { ...defaultProps, graphProps, onDrag };\n          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });\n          const options = { ...defaultOptions, bounds };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          mockDraggableCoreProps.onDrag({}, { deltaX: 1, deltaY: 0 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('skips drag when moving right and x is above domain.max', () => {\n          const onDrag = jest.fn();\n          const graphProps = {\n            ...getGraphProps(),\n            domain: { min: -5, max: 5, step: 1 },\n            range: { min: -5, max: 5, step: 1 },\n          };\n          graphProps.scale.x.invert = jest.fn().mockReturnValue(6); // Above max\n\n          const props = { ...defaultProps, graphProps, onDrag };\n          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });\n          const options = { ...defaultOptions, bounds };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          mockDraggableCoreProps.onDrag({}, { deltaX: -1, deltaY: 0 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('skips drag when moving up and y is above range.max', () => {\n          const onDrag = jest.fn();\n          const graphProps = {\n            ...getGraphProps(),\n            domain: { min: -5, max: 5, step: 1 },\n            range: { min: -5, max: 5, step: 1 },\n          };\n          graphProps.scale.y.invert = jest.fn().mockReturnValue(6); // Above max\n\n          const props = { ...defaultProps, graphProps, onDrag };\n          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });\n          const options = { ...defaultOptions, bounds };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: 1 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('skips drag when moving down and y is below range.min', () => {\n          const onDrag = jest.fn();\n          const graphProps = {\n            ...getGraphProps(),\n            domain: { min: -5, max: 5, step: 1 },\n            range: { min: -5, max: 5, step: 1 },\n          };\n          graphProps.scale.y.invert = jest.fn().mockReturnValue(-6); // Below min\n\n          const props = { ...defaultProps, graphProps, onDrag };\n          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });\n          const options = { ...defaultOptions, bounds };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: -1 });\n\n          expect(onDrag).not.toHaveBeenCalled();\n        });\n\n        it('allows drag when within domain and range', () => {\n          const onDrag = jest.fn();\n          const graphProps = {\n            ...getGraphProps(),\n            domain: { min: -5, max: 5, step: 1 },\n            range: { min: -5, max: 5, step: 1 },\n          };\n          graphProps.scale.x.invert = jest.fn().mockReturnValue(3); // Within bounds\n          graphProps.scale.y.invert = jest.fn().mockReturnValue(2); // Within bounds\n\n          const props = { ...defaultProps, graphProps, onDrag };\n          const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });\n          const options = { ...defaultOptions, bounds };\n\n          const Comp = gridDraggable(options)(() => <div>Test</div>);\n          render(<Comp {...props} />);\n\n          mockDraggableCoreProps.onStart(mockStartEvent());\n          mockDraggableCoreProps.onDrag({}, { deltaX: 1, deltaY: -1 });\n\n          expect(onDrag).toHaveBeenCalled();\n        });\n      });\n    });\n\n    describe('getDelta and applyDelta', () => {\n      it('calls utils.getDelta when processing drag', () => {\n        getDelta.mockClear();\n        const onDrag = jest.fn();\n        const props = { ...defaultProps, onDrag };\n        const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });\n        const options = { ...defaultOptions, bounds };\n\n        const Comp = gridDraggable(options)(() => <div>Test</div>);\n        render(<Comp {...props} />);\n\n        mockDraggableCoreProps.onStart(mockStartEvent());\n        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });\n\n        expect(getDelta).toHaveBeenCalled();\n      });\n\n      it('calls fromDelta with result from getDelta', () => {\n        const fromDelta = jest.fn();\n        getDelta.mockReturnValue({ x: 5, y: 5 });\n        const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });\n        const options = { ...defaultOptions, fromDelta, bounds };\n        const props = { ...defaultProps, onDrag: jest.fn() };\n\n        const Comp = gridDraggable(options)(() => <div>Test</div>);\n        render(<Comp {...props} />);\n\n        mockDraggableCoreProps.onStart(mockStartEvent());\n        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });\n\n        expect(fromDelta).toHaveBeenCalled();\n      });\n    });\n\n    describe('onStop', () => {\n      it('calls onDragStop when drag stops', () => {\n        const onDragStop = jest.fn();\n        const props = { ...defaultProps, onDragStop };\n\n        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n        render(<Comp {...props} />);\n\n        // Start to set up state\n        mockDraggableCoreProps.onStart(mockStartEvent());\n\n        // Stop with large movement (not tiny)\n        mockDraggableCoreProps.onStop({ clientX: 100, clientY: 100, stopPropagation: jest.fn() }, {});\n\n        expect(onDragStop).toHaveBeenCalled();\n      });\n\n      it('calls onClick instead of onDragStop when movement is tiny', () => {\n        const onClick = jest.fn();\n        const onDragStop = jest.fn();\n        const props = { ...defaultProps, onClick, onDragStop };\n\n        pointer.mockReturnValue([0, 0]);\n\n        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n        render(<Comp {...props} />);\n\n        // Start and stop at almost the same position (tiny movement)\n        // Grid is 1x1, tiny threshold is grid/10 = 0.1\n        mockDraggableCoreProps.onStart(mockStartEvent());\n        mockDraggableCoreProps.onStop({ clientX: 0.05, clientY: 0.05, target: {}, stopPropagation: jest.fn() }, {});\n\n        expect(onClick).toHaveBeenCalledWith({ x: 0, y: 0 });\n      });\n\n      it('calls onClick with snapped coordinates', () => {\n        const onClick = jest.fn();\n        const props = { ...defaultProps, onClick };\n        const graphProps = getGraphProps();\n        graphProps.scale.x.invert = jest.fn().mockReturnValue(1.7);\n        graphProps.scale.y.invert = jest.fn().mockReturnValue(2.3);\n        graphProps.snap.x = jest.fn().mockReturnValue(2);\n        graphProps.snap.y = jest.fn().mockReturnValue(2);\n\n        pointer.mockReturnValue([1.7, 2.3]);\n\n        const propsWithGraphProps = { ...props, graphProps };\n        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);\n        render(<Comp {...propsWithGraphProps} />);\n\n        // Start and stop at almost the same position (tiny movement)\n        mockDraggableCoreProps.onStart(mockStartEvent());\n        mockDraggableCoreProps.onStop({ clientX: 0.05, clientY: 0.05, target: {}, stopPropagation: jest.fn() }, {});\n\n        expect(graphProps.snap.x).toHaveBeenCalledWith(1.7);\n        expect(graphProps.snap.y).toHaveBeenCalledWith(2.3);\n        expect(onClick).toHaveBeenCalledWith({ x: 2, y: 2 });\n      });\n    });\n  });\n});\n"],"mappings":";;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,cAAA,GAAAH,OAAA;AACA,IAAAI,MAAA,GAAAJ,OAAA;AACA,IAAAK,YAAA,GAAAL,OAAA;AAAuC,SAAAM,QAAAC,CAAA,EAAAC,CAAA,QAAAC,CAAA,GAAAC,MAAA,CAAAC,IAAA,CAAAJ,CAAA,OAAAG,MAAA,CAAAE,qBAAA,QAAAC,CAAA,GAAAH,MAAA,CAAAE,qBAAA,CAAAL,CAAA,GAAAC,CAAA,KAAAK,CAAA,GAAAA,CAAA,CAAAC,MAAA,WAAAN,CAAA,WAAAE,MAAA,CAAAK,wBAAA,CAAAR,CAAA,EAAAC,CAAA,EAAAQ,UAAA,OAAAP,CAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,CAAA,EAAAI,CAAA,YAAAJ,CAAA;AAAA,SAAAU,cAAAZ,CAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAY,SAAA,CAAAC,MAAA,EAAAb,CAAA,UAAAC,CAAA,WAAAW,SAAA,CAAAZ,CAAA,IAAAY,SAAA,CAAAZ,CAAA,QAAAA,CAAA,OAAAF,OAAA,CAAAI,MAAA,CAAAD,CAAA,OAAAa,OAAA,WAAAd,CAAA,QAAAe,gBAAA,aAAAhB,CAAA,EAAAC,CAAA,EAAAC,CAAA,CAAAD,CAAA,SAAAE,MAAA,CAAAc,yBAAA,GAAAd,MAAA,CAAAe,gBAAA,CAAAlB,CAAA,EAAAG,MAAA,CAAAc,yBAAA,CAAAf,CAAA,KAAAH,OAAA,CAAAI,MAAA,CAAAD,CAAA,GAAAa,OAAA,WAAAd,CAAA,IAAAE,MAAA,CAAAgB,cAAA,CAAAnB,CAAA,EAAAC,CAAA,EAAAE,MAAA,CAAAK,wBAAA,CAAAN,CAAA,EAAAD,CAAA,iBAAAD,CAAA;AAEvCoB,IAAI,CAACC,IAAI,CAAC,cAAc,EAAE;EAAA,OAAO;IAC/BC,OAAO,EAAEF,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;EAC3C,CAAC;AAAA,CAAC,CAAC;AAEH,IAAIC,sBAAsB;AAC1BL,IAAI,CAACC,IAAI,CAAC,cAAc,EAAE;EAAA,OAAO;IAC/BK,aAAa,EAAE,SAAfA,aAAaA,CAAGC,KAAK,EAAK;MACxB;MACAF,sBAAsB,GAAGE,KAAK;MAC9B,OAAOA,KAAK,CAACC,QAAQ;IACvB;EACF,CAAC;AAAA,CAAC,CAAC;;AAEH;AACA,IAAMC,cAAc,GAAG,SAAjBA,cAAcA,CAAA;EAAA,IAAIC,SAAS,GAAAjB,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAkB,SAAA,GAAAlB,SAAA,MAAG,CAAC,CAAC;EAAA,OAAAD,aAAA;IACpCoB,OAAO,EAAE,CAAC;IACVC,OAAO,EAAE,CAAC;IACVC,MAAM,EAAE;MAAEC,gBAAgB,EAAEf,IAAI,CAACG,EAAE,CAAC,CAAC;MAAEa,mBAAmB,EAAEhB,IAAI,CAACG,EAAE,CAAC;IAAE;EAAC,GACpEO,SAAS;AAAA,CACZ;AAEFV,IAAI,CAACC,IAAI,CAAC,UAAU,EAAE;EAAA,OAAO;IAC3BgB,QAAQ,EAAEjB,IAAI,CAACG,EAAE,CAAC;EACpB,CAAC;AAAA,CAAC,CAAC;AAEH,IAAMe,IAAI,GAAG,SAAPA,IAAIA,CAAA,EAAS;EACjB,IAAMC,GAAG,GAAGnB,IAAI,CAACG,EAAE,CAAC,UAACiB,CAAC;IAAA,OAAKA,CAAC;EAAA,EAAC;EAC7BD,GAAG,CAACE,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,UAACiB,CAAC;IAAA,OAAKA,CAAC;EAAA,EAAC;EAC9B,OAAOD,GAAG;AACZ,CAAC;AAED,IAAMG,aAAa,GAAG,SAAhBA,aAAaA,CAAA;EAAA,OAAU;IAC3BC,KAAK,EAAE;MACLC,CAAC,EAAEN,IAAI,CAAC,CAAC;MACTO,CAAC,EAAEP,IAAI,CAAC;IACV,CAAC;IACDQ,IAAI,EAAE;MACJF,CAAC,EAAEN,IAAI,CAAC,CAAC;MACTO,CAAC,EAAEP,IAAI,CAAC;IACV,CAAC;IACDS,MAAM,EAAE;MACNC,GAAG,EAAE,CAAC;MACNC,GAAG,EAAE,CAAC;MACNC,IAAI,EAAE;IACR,CAAC;IACDC,KAAK,EAAE;MACLH,GAAG,EAAE,CAAC;MACNC,GAAG,EAAE,CAAC;MACNC,IAAI,EAAE;IACR,CAAC;IACDE,IAAI,EAAE;MACJC,KAAK,EAAE,GAAG;MACVC,MAAM,EAAE;IACV,CAAC;IACDC,WAAW,EAAE,SAAbA,WAAWA,CAAA;MAAA,OAAS;QAClBC,eAAe,EAAE,IAAI;QACrBC,qBAAqB,EAAE,SAAvBA,qBAAqBA,CAAA;UAAA,OAAS;YAC5BC,IAAI,EAAE,CAAC;YACPC,GAAG,EAAE,CAAC;YACNC,KAAK,EAAE,GAAG;YACVC,MAAM,EAAE;UACV,CAAC;QAAA;MACH,CAAC;IAAA;EACH,CAAC;AAAA,CAAC;AAEFC,QAAQ,CAAC,eAAe,EAAE,YAAM;EAC9B,IAAIC,cAAc;EAClB,IAAIC,YAAY;EAEhBC,UAAU,CAAC,YAAM;IACfxC,sBAAsB,GAAG,IAAI;IAC7BsC,cAAc,GAAG;MACfG,WAAW,EAAE9C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;QAAEoB,CAAC,EAAE,CAAC;QAAEC,CAAC,EAAE;MAAE,CAAC,CAAC;MACtDsB,MAAM,EAAE/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;QAAEkC,IAAI,EAAE,CAAC;QAAEC,GAAG,EAAE,CAAC;QAAEE,MAAM,EAAE,CAAC;QAAED,KAAK,EAAE;MAAE,CAAC,CAAC;MAC3EQ,SAAS,EAAEhD,IAAI,CAACG,EAAE,CAAC;IACrB,CAAC;IAEDyC,YAAY,GAAG;MACbK,UAAU,EAAE3B,aAAa,CAAC;IAC5B,CAAC;EACH,CAAC,CAAC;EAEF4B,EAAE,CAAC,2BAA2B,EAAE,YAAM;IACpC,IAAMC,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;MAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;IAAA,EAAC;IACjE,IAAAC,OAAA,GAAsB,IAAAC,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAKP,YAAe,CAAC,CAAC;MAAhDY,SAAS,GAAAF,OAAA,CAATE,SAAS;IACjBC,MAAM,CAACD,SAAS,CAACE,UAAU,CAAC,CAACC,iBAAiB,CAAC,CAAC;EAClD,CAAC,CAAC;EAEFT,EAAE,CAAC,uCAAuC,EAAE,YAAM;IAChD,IAAM3C,KAAK,GAAAf,aAAA,CAAAA,aAAA,KACNoD,YAAY;MACfK,UAAU,EAAAzD,aAAA,CAAAA,aAAA,KACL8B,aAAa,CAAC,CAAC;QAClBK,MAAM,EAAE;UACNC,GAAG,EAAE,CAAC,GAAG;UACTC,GAAG,EAAE,GAAG;UACRC,IAAI,EAAE;QACR,CAAC;QACDC,KAAK,EAAE;UACLH,GAAG,EAAE,CAAC,CAAC;UACPC,GAAG,EAAE,CAAC;UACNC,IAAI,EAAE;QACR;MAAC;IACF,EACF;IACD,IAAMqB,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;MAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;IAAA,EAAC;IACjE,IAAAO,QAAA,GAAsB,IAAAL,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;MAAzCiD,SAAS,GAAAI,QAAA,CAATJ,SAAS;IACjBC,MAAM,CAACD,SAAS,CAACE,UAAU,CAAC,CAACC,iBAAiB,CAAC,CAAC;EAClD,CAAC,CAAC;EAEFjB,QAAQ,CAAC,OAAO,EAAE,YAAM;IACtBA,QAAQ,CAAC,kBAAkB,EAAE,YAAM;MACjCQ,EAAE,CAAC,qEAAqE,EAAE,YAAM;QAC9E,IAAMC,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;UAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QACjE,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAKP,YAAe,CAAC,CAAC;;QAElC;QACA;QACAa,MAAM,CAACpD,sBAAsB,CAACwD,IAAI,CAAC,CAACC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;MACrD,CAAC,CAAC;MAEFZ,EAAE,CAAC,oCAAoC,EAAE,YAAM;QAC7C,IAAM3C,KAAK,GAAAf,aAAA,CAAAA,aAAA,KACNoD,YAAY;UACfK,UAAU,EAAAzD,aAAA,CAAAA,aAAA,KACL8B,aAAa,CAAC,CAAC;YAClBK,MAAM,EAAE;cAAEC,GAAG,EAAE,CAAC,GAAG;cAAEC,GAAG,EAAE,GAAG;cAAEC,IAAI,EAAE;YAAI,CAAC;YAC1CC,KAAK,EAAE;cAAEH,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAI;UAAC;QACtC,EACF;QACD,IAAMqB,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;UAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QACjE,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;QAE3BkD,MAAM,CAACpD,sBAAsB,CAACwD,IAAI,CAAC,CAACC,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;MACzD,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFpB,QAAQ,CAAC,SAAS,EAAE,YAAM;MACxBQ,EAAE,CAAC,4CAA4C,EAAE,YAAM;QACrD,IAAMa,WAAW,GAAG/D,IAAI,CAACG,EAAE,CAAC,CAAC;QAC7B,IAAMI,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;UAAEmB,WAAW,EAAXA;QAAW,EAAE;QAC9C,IAAMZ,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;UAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QACjE,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;;QAE3B;QACAF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC;UAAEG,OAAO,EAAE,GAAG;UAAEC,OAAO,EAAE;QAAI,CAAC,CAAC,CAAC;QAE9E4C,MAAM,CAACM,WAAW,CAAC,CAACE,gBAAgB,CAAC,CAAC;MACxC,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFvB,QAAQ,CAAC,QAAQ,EAAE,YAAM;MACvBQ,EAAE,CAAC,kDAAkD,EAAE,YAAM;QAC3D,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;QACxB,IAAM6C,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,cAAc,CAAC;QAC3D,IAAM2C,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;UAAEkC,IAAI,EAAE,CAAC,GAAG;UAAEC,GAAG,EAAE,CAAC,GAAG;UAAEE,MAAM,EAAE,GAAG;UAAED,KAAK,EAAE;QAAI,CAAC,CAAC;QAC5F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;UAAEK,SAAS,EAATA,SAAS;UAAED,MAAM,EAANA;QAAM,EAAE;QACxD,IAAMxC,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;UAAEsB,MAAM,EAANA;QAAM,EAAE;QAEzC,IAAMf,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;UAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;;QAE3B;QACAF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;;QAEhD;QACAJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;UAAEE,MAAM,EAAE,EAAE;UAAEC,MAAM,EAAE;QAAG,CAAC,CAAC;QAE7DZ,MAAM,CAACT,SAAS,CAAC,CAACiB,gBAAgB,CAAC,CAAC;QACpCR,MAAM,CAACS,MAAM,CAAC,CAACI,oBAAoB,CAAC,cAAc,CAAC;MACrD,CAAC,CAAC;MAEFpB,EAAE,CAAC,yDAAyD,EAAE,YAAM;QAClE,IAAMF,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC;QAC3B,IAAMgE,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;UAAEK,SAAS,EAATA;QAAS,EAAE;QAChD,IAAMG,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;UAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAKP,YAAe,CAAC,CAAC;QAElCvC,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;QAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;UAAEE,MAAM,EAAE,EAAE;UAAEC,MAAM,EAAE;QAAG,CAAC,CAAC;QAE7DZ,MAAM,CAACT,SAAS,CAAC,CAACuB,GAAG,CAACN,gBAAgB,CAAC,CAAC;MAC1C,CAAC,CAAC;MAEFvB,QAAQ,CAAC,iBAAiB,EAAE,YAAM;QAChCQ,EAAE,CAAC,2DAA2D,EAAE,YAAM;UACpE,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM4C,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,CAAC;YAAEC,GAAG,EAAE,CAAC;YAAEE,MAAM,EAAE,CAAC;YAAED,KAAK,EAAE;UAAE,CAAC,CAAC;UAClF,IAAMQ,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,QAAQ,CAAC;UACrD,IAAM+D,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA,MAAM;YAAEC,SAAS,EAATA;UAAS,EAAE;UACxD,IAAMzC,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEsB,MAAM,EAANA;UAAM,EAAE;UAEzC,IAAMf,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChD;UACAJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC,EAAE;YAAEC,MAAM,EAAE;UAAE,CAAC,CAAC;UAE7DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,6DAA6D,EAAE,YAAM;UACtE,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM4C,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,CAAC;YAAEC,GAAG,EAAE,CAAC;YAAEE,MAAM,EAAE,CAAC;YAAED,KAAK,EAAE;UAAE,CAAC,CAAC;UAClF,IAAMQ,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,QAAQ,CAAC;UACrD,IAAM+D,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA,MAAM;YAAEC,SAAS,EAATA;UAAS,EAAE;UACxD,IAAMzC,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEsB,MAAM,EAANA;UAAM,EAAE;UAEzC,IAAMf,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChD;UACAJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,EAAE;YAAEC,MAAM,EAAE;UAAE,CAAC,CAAC;UAE5DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,wDAAwD,EAAE,YAAM;UACjE,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM4C,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,CAAC,GAAG;YAAEC,GAAG,EAAE,CAAC;YAAEE,MAAM,EAAE,CAAC;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UACvF,IAAMQ,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,QAAQ,CAAC;UACrD,IAAM+D,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA,MAAM;YAAEC,SAAS,EAATA;UAAS,EAAE;UACxD,IAAMzC,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEsB,MAAM,EAANA;UAAM,EAAE;UAEzC,IAAMf,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChD;UACAJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC;YAAEC,MAAM,EAAE,CAAC;UAAG,CAAC,CAAC;UAE7DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,6DAA6D,EAAE,YAAM;UACtE,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM4C,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,CAAC,GAAG;YAAEC,GAAG,EAAE,CAAC,GAAG;YAAEE,MAAM,EAAE,CAAC;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UAC1F,IAAMQ,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,QAAQ,CAAC;UACrD,IAAM+D,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA,MAAM;YAAEC,SAAS,EAATA;UAAS,EAAE;UACxD,IAAMzC,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEsB,MAAM,EAANA;UAAM,EAAE;UAEzC,IAAMf,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChD;UACAJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC;YAAEC,MAAM,EAAE;UAAG,CAAC,CAAC;UAE5DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,0CAA0C,EAAE,YAAM;UACnD,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM4C,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,CAAC,GAAG;YAAEC,GAAG,EAAE,CAAC,GAAG;YAAEE,MAAM,EAAE,GAAG;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UAC5F,IAAMQ,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,QAAQ,CAAC;UACrD,IAAM+D,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA,MAAM;YAAEC,SAAS,EAATA;UAAS,EAAE;UACxD,IAAMzC,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEsB,MAAM,EAANA;UAAM,EAAE;UAEzC,IAAMf,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChD;UACA;UACAJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC,EAAE;YAAEC,MAAM,EAAE;UAAG,CAAC,CAAC;UAE9DZ,MAAM,CAACS,MAAM,CAAC,CAACD,gBAAgB,CAAC,CAAC;QACnC,CAAC,CAAC;MACJ,CAAC,CAAC;MAEFvB,QAAQ,CAAC,yBAAyB,EAAE,YAAM;QACxCQ,EAAE,CAAC,uDAAuD,EAAE,YAAM;UAChE,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM8C,UAAU,GAAAzD,aAAA,CAAAA,aAAA,KACX8B,aAAa,CAAC,CAAC;YAClBK,MAAM,EAAE;cAAEC,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE,CAAC;YACpCC,KAAK,EAAE;cAAEH,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE;UAAC,EACpC;UACDmB,UAAU,CAAC1B,KAAK,CAACC,CAAC,CAACH,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;UAE3D,IAAMG,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEK,UAAU,EAAVA,UAAU;YAAEiB,MAAM,EAANA;UAAM,EAAE;UACrD,IAAMnB,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,GAAG;YAAEC,GAAG,EAAE,GAAG;YAAEE,MAAM,EAAE,GAAG;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UAC1F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA;UAAM,EAAE;UAE7C,IAAMI,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC;YAAEC,MAAM,EAAE;UAAE,CAAC,CAAC;UAE3DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,wDAAwD,EAAE,YAAM;UACjE,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM8C,UAAU,GAAAzD,aAAA,CAAAA,aAAA,KACX8B,aAAa,CAAC,CAAC;YAClBK,MAAM,EAAE;cAAEC,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE,CAAC;YACpCC,KAAK,EAAE;cAAEH,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE;UAAC,EACpC;UACDmB,UAAU,CAAC1B,KAAK,CAACC,CAAC,CAACH,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;;UAE1D,IAAMG,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEK,UAAU,EAAVA,UAAU;YAAEiB,MAAM,EAANA;UAAM,EAAE;UACrD,IAAMnB,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,GAAG;YAAEC,GAAG,EAAE,GAAG;YAAEE,MAAM,EAAE,GAAG;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UAC1F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA;UAAM,EAAE;UAE7C,IAAMI,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC,CAAC;YAAEC,MAAM,EAAE;UAAE,CAAC,CAAC;UAE5DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,oDAAoD,EAAE,YAAM;UAC7D,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM8C,UAAU,GAAAzD,aAAA,CAAAA,aAAA,KACX8B,aAAa,CAAC,CAAC;YAClBK,MAAM,EAAE;cAAEC,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE,CAAC;YACpCC,KAAK,EAAE;cAAEH,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE;UAAC,EACpC;UACDmB,UAAU,CAAC1B,KAAK,CAACE,CAAC,CAACJ,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;;UAE1D,IAAMG,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEK,UAAU,EAAVA,UAAU;YAAEiB,MAAM,EAANA;UAAM,EAAE;UACrD,IAAMnB,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,GAAG;YAAEC,GAAG,EAAE,GAAG;YAAEE,MAAM,EAAE,GAAG;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UAC1F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA;UAAM,EAAE;UAE7C,IAAMI,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC;YAAEC,MAAM,EAAE;UAAE,CAAC,CAAC;UAE3DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,sDAAsD,EAAE,YAAM;UAC/D,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM8C,UAAU,GAAAzD,aAAA,CAAAA,aAAA,KACX8B,aAAa,CAAC,CAAC;YAClBK,MAAM,EAAE;cAAEC,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE,CAAC;YACpCC,KAAK,EAAE;cAAEH,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE;UAAC,EACpC;UACDmB,UAAU,CAAC1B,KAAK,CAACE,CAAC,CAACJ,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;UAE3D,IAAMG,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEK,UAAU,EAAVA,UAAU;YAAEiB,MAAM,EAANA;UAAM,EAAE;UACrD,IAAMnB,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,GAAG;YAAEC,GAAG,EAAE,GAAG;YAAEE,MAAM,EAAE,GAAG;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UAC1F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA;UAAM,EAAE;UAE7C,IAAMI,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC;YAAEC,MAAM,EAAE,CAAC;UAAE,CAAC,CAAC;UAE5DZ,MAAM,CAACS,MAAM,CAAC,CAACK,GAAG,CAACN,gBAAgB,CAAC,CAAC;QACvC,CAAC,CAAC;QAEFf,EAAE,CAAC,0CAA0C,EAAE,YAAM;UACnD,IAAMgB,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;UACxB,IAAM8C,UAAU,GAAAzD,aAAA,CAAAA,aAAA,KACX8B,aAAa,CAAC,CAAC;YAClBK,MAAM,EAAE;cAAEC,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE,CAAC;YACpCC,KAAK,EAAE;cAAEH,GAAG,EAAE,CAAC,CAAC;cAAEC,GAAG,EAAE,CAAC;cAAEC,IAAI,EAAE;YAAE;UAAC,EACpC;UACDmB,UAAU,CAAC1B,KAAK,CAACC,CAAC,CAACH,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;UAC1D6C,UAAU,CAAC1B,KAAK,CAACE,CAAC,CAACJ,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;;UAE1D,IAAMG,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;YAAEK,UAAU,EAAVA,UAAU;YAAEiB,MAAM,EAANA;UAAM,EAAE;UACrD,IAAMnB,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;YAAEkC,IAAI,EAAE,CAAC,GAAG;YAAEC,GAAG,EAAE,CAAC,GAAG;YAAEE,MAAM,EAAE,GAAG;YAAED,KAAK,EAAE;UAAI,CAAC,CAAC;UAC5F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;YAAEI,MAAM,EAANA;UAAM,EAAE;UAE7C,IAAMI,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;YAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;UAAA,EAAC;UAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;UAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;UAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;YAAEE,MAAM,EAAE,CAAC;YAAEC,MAAM,EAAE,CAAC;UAAE,CAAC,CAAC;UAE5DZ,MAAM,CAACS,MAAM,CAAC,CAACD,gBAAgB,CAAC,CAAC;QACnC,CAAC,CAAC;MACJ,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFvB,QAAQ,CAAC,yBAAyB,EAAE,YAAM;MACxCQ,EAAE,CAAC,2CAA2C,EAAE,YAAM;QACpDjC,eAAQ,CAACuD,SAAS,CAAC,CAAC;QACpB,IAAMN,MAAM,GAAGlE,IAAI,CAACG,EAAE,CAAC,CAAC;QACxB,IAAMI,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;UAAEsB,MAAM,EAANA;QAAM,EAAE;QACzC,IAAMnB,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;UAAEkC,IAAI,EAAE,CAAC,GAAG;UAAEC,GAAG,EAAE,CAAC,GAAG;UAAEE,MAAM,EAAE,GAAG;UAAED,KAAK,EAAE;QAAI,CAAC,CAAC;QAC5F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;UAAEI,MAAM,EAANA;QAAM,EAAE;QAE7C,IAAMI,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;UAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;QAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;QAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;UAAEE,MAAM,EAAE,EAAE;UAAEC,MAAM,EAAE;QAAG,CAAC,CAAC;QAE7DZ,MAAM,CAACxC,eAAQ,CAAC,CAACgD,gBAAgB,CAAC,CAAC;MACrC,CAAC,CAAC;MAEFf,EAAE,CAAC,2CAA2C,EAAE,YAAM;QACpD,IAAMF,SAAS,GAAGhD,IAAI,CAACG,EAAE,CAAC,CAAC;QAC3Bc,eAAQ,CAACb,eAAe,CAAC;UAAEoB,CAAC,EAAE,CAAC;UAAEC,CAAC,EAAE;QAAE,CAAC,CAAC;QACxC,IAAMsB,MAAM,GAAG/C,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC;UAAEkC,IAAI,EAAE,CAAC,GAAG;UAAEC,GAAG,EAAE,CAAC,GAAG;UAAEE,MAAM,EAAE,GAAG;UAAED,KAAK,EAAE;QAAI,CAAC,CAAC;QAC5F,IAAM2B,OAAO,GAAA3E,aAAA,CAAAA,aAAA,KAAQmD,cAAc;UAAEK,SAAS,EAATA,SAAS;UAAED,MAAM,EAANA;QAAM,EAAE;QACxD,IAAMxC,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;UAAEsB,MAAM,EAAElE,IAAI,CAACG,EAAE,CAAC;QAAC,EAAE;QAEpD,IAAMgD,IAAI,GAAG,IAAAC,4BAAa,EAACe,OAAO,CAAC,CAAC;UAAA,oBAAM7F,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QAC1D,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;QAE3BF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;QAChDJ,sBAAsB,CAAC6D,MAAM,CAAC,CAAC,CAAC,EAAE;UAAEE,MAAM,EAAE,EAAE;UAAEC,MAAM,EAAE;QAAG,CAAC,CAAC;QAE7DZ,MAAM,CAACT,SAAS,CAAC,CAACiB,gBAAgB,CAAC,CAAC;MACtC,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFvB,QAAQ,CAAC,QAAQ,EAAE,YAAM;MACvBQ,EAAE,CAAC,kCAAkC,EAAE,YAAM;QAC3C,IAAMuB,UAAU,GAAGzE,IAAI,CAACG,EAAE,CAAC,CAAC;QAC5B,IAAMI,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;UAAE6B,UAAU,EAAVA;QAAU,EAAE;QAE7C,IAAMtB,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;UAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QACjE,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;;QAE3B;QACAF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;;QAEhD;QACAJ,sBAAsB,CAACqE,MAAM,CAAC;UAAE9D,OAAO,EAAE,GAAG;UAAEC,OAAO,EAAE,GAAG;UAAE8D,eAAe,EAAE3E,IAAI,CAACG,EAAE,CAAC;QAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE7FsD,MAAM,CAACgB,UAAU,CAAC,CAACR,gBAAgB,CAAC,CAAC;MACvC,CAAC,CAAC;MAEFf,EAAE,CAAC,2DAA2D,EAAE,YAAM;QACpE,IAAM0B,OAAO,GAAG5E,IAAI,CAACG,EAAE,CAAC,CAAC;QACzB,IAAMsE,UAAU,GAAGzE,IAAI,CAACG,EAAE,CAAC,CAAC;QAC5B,IAAMI,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;UAAEgC,OAAO,EAAPA,OAAO;UAAEH,UAAU,EAAVA;QAAU,EAAE;QAEtDvE,oBAAO,CAACE,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAE/B,IAAM+C,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;UAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QACjE,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK5C,KAAQ,CAAC,CAAC;;QAE3B;QACA;QACAF,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;QAChDJ,sBAAsB,CAACqE,MAAM,CAAC;UAAE9D,OAAO,EAAE,IAAI;UAAEC,OAAO,EAAE,IAAI;UAAEC,MAAM,EAAE,CAAC,CAAC;UAAE6D,eAAe,EAAE3E,IAAI,CAACG,EAAE,CAAC;QAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE3GsD,MAAM,CAACmB,OAAO,CAAC,CAACN,oBAAoB,CAAC;UAAE9C,CAAC,EAAE,CAAC;UAAEC,CAAC,EAAE;QAAE,CAAC,CAAC;MACtD,CAAC,CAAC;MAEFyB,EAAE,CAAC,wCAAwC,EAAE,YAAM;QACjD,IAAM0B,OAAO,GAAG5E,IAAI,CAACG,EAAE,CAAC,CAAC;QACzB,IAAMI,KAAK,GAAAf,aAAA,CAAAA,aAAA,KAAQoD,YAAY;UAAEgC,OAAO,EAAPA;QAAO,EAAE;QAC1C,IAAM3B,UAAU,GAAG3B,aAAa,CAAC,CAAC;QAClC2B,UAAU,CAAC1B,KAAK,CAACC,CAAC,CAACH,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,GAAG,CAAC;QAC1D6C,UAAU,CAAC1B,KAAK,CAACE,CAAC,CAACJ,MAAM,GAAGrB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,GAAG,CAAC;QAC1D6C,UAAU,CAACvB,IAAI,CAACF,CAAC,GAAGxB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC;QAChD6C,UAAU,CAACvB,IAAI,CAACD,CAAC,GAAGzB,IAAI,CAACG,EAAE,CAAC,CAAC,CAACC,eAAe,CAAC,CAAC,CAAC;QAEhDF,oBAAO,CAACE,eAAe,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QAEnC,IAAMyE,mBAAmB,GAAArF,aAAA,CAAAA,aAAA,KAAQe,KAAK;UAAE0C,UAAU,EAAVA;QAAU,EAAE;QACpD,IAAME,IAAI,GAAG,IAAAC,4BAAa,EAACT,cAAc,CAAC,CAAC;UAAA,oBAAMrE,OAAA,YAAA+E,aAAA,cAAK,MAAS,CAAC;QAAA,EAAC;QACjE,IAAAE,aAAM,eAACjF,OAAA,YAAA+E,aAAA,CAACF,IAAI,EAAK0B,mBAAsB,CAAC,CAAC;;QAEzC;QACAxE,sBAAsB,CAAC2D,OAAO,CAACvD,cAAc,CAAC,CAAC,CAAC;QAChDJ,sBAAsB,CAACqE,MAAM,CAAC;UAAE9D,OAAO,EAAE,IAAI;UAAEC,OAAO,EAAE,IAAI;UAAEC,MAAM,EAAE,CAAC,CAAC;UAAE6D,eAAe,EAAE3E,IAAI,CAACG,EAAE,CAAC;QAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE3GsD,MAAM,CAACR,UAAU,CAACvB,IAAI,CAACF,CAAC,CAAC,CAAC8C,oBAAoB,CAAC,GAAG,CAAC;QACnDb,MAAM,CAACR,UAAU,CAACvB,IAAI,CAACD,CAAC,CAAC,CAAC6C,oBAAoB,CAAC,GAAG,CAAC;QACnDb,MAAM,CAACmB,OAAO,CAAC,CAACN,oBAAoB,CAAC;UAAE9C,CAAC,EAAE,CAAC;UAAEC,CAAC,EAAE;QAAE,CAAC,CAAC;MACtD,CAAC,CAAC;IACJ,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}