@pie-lib/mask-markup 3.1.5 → 3.1.6-beta.10

package/lib/__tests__/keyboard-coordinates.test.js

@@ -0,0 +1,449 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _core = require("@dnd-kit/core");
+var _keyboardCoordinates = require("../keyboard-coordinates");
+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; }
+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; }
+function rectsToContext(rects) {
+  var droppableRects = new Map(Object.entries(rects));
+  var droppableContainers = new Map(Object.keys(rects).map(function (id) {
+    return [id, {
+      disabled: false
+    }];
+  }));
+  return {
+    droppableRects: droppableRects,
+    droppableContainers: droppableContainers
+  };
+}
+function makeEvent(code) {
+  var shiftKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  return {
+    code: code,
+    preventDefault: function preventDefault() {},
+    shiftKey: shiftKey
+  };
+}
+
+// Mirrors dnd-kit's own KeyboardSensor, which always derives collisionRect's top-left
+// from the dragged item's current on-screen position on every keydown — so a test's
+// collisionRect must track currentCoordinates the same way on every simulated press,
+// not stay fixed while currentCoordinates changes across multiple presses.
+function press(rects, currentCoordinates, itemSize, event, active) {
+  var context = _objectSpread(_objectSpread({}, rectsToContext(rects)), {}, {
+    collisionRect: _objectSpread({
+      left: currentCoordinates.x,
+      top: currentCoordinates.y
+    }, itemSize)
+  });
+  return (0, _keyboardCoordinates.closestDroppableKeyboardCoordinates)(event, {
+    active: active,
+    context: context,
+    currentCoordinates: currentCoordinates
+  });
+}
+describe('closestDroppableKeyboardCoordinates', function () {
+  describe('arrow keys', function () {
+    it("nudges the dragged item by dnd-kit's own default step (25px), unchanged", function () {
+      var context = _objectSpread(_objectSpread({}, rectsToContext({})), {}, {
+        collisionRect: {
+          left: 0,
+          top: 0,
+          width: 100,
+          height: 40
+        }
+      });
+      var currentCoordinates = {
+        x: 10,
+        y: 20
+      };
+      expect((0, _keyboardCoordinates.closestDroppableKeyboardCoordinates)(makeEvent(_core.KeyboardCode.Down), {
+        context: context,
+        currentCoordinates: currentCoordinates
+      })).toEqual({
+        x: 10,
+        y: 45
+      });
+      expect((0, _keyboardCoordinates.closestDroppableKeyboardCoordinates)(makeEvent(_core.KeyboardCode.Up), {
+        context: context,
+        currentCoordinates: currentCoordinates
+      })).toEqual({
+        x: 10,
+        y: -5
+      });
+      expect((0, _keyboardCoordinates.closestDroppableKeyboardCoordinates)(makeEvent(_core.KeyboardCode.Right), {
+        context: context,
+        currentCoordinates: currentCoordinates
+      })).toEqual({
+        x: 35,
+        y: 20
+      });
+      expect((0, _keyboardCoordinates.closestDroppableKeyboardCoordinates)(makeEvent(_core.KeyboardCode.Left), {
+        context: context,
+        currentCoordinates: currentCoordinates
+      })).toEqual({
+        x: -15,
+        y: 20
+      });
+    });
+  });
+  describe('Tab / Shift+Tab', function () {
+    var blank0Rect = {
+      left: 0,
+      top: 0,
+      width: 120,
+      height: 40,
+      right: 120,
+      bottom: 40
+    };
+    var blank1Rect = {
+      left: 0,
+      top: 60,
+      width: 120,
+      height: 40,
+      right: 120,
+      bottom: 100
+    };
+    var boardRect = {
+      left: 0,
+      top: 120,
+      width: 400,
+      height: 300,
+      right: 400,
+      bottom: 420
+    };
+    var baseRects = {
+      'mask-blank-drop-0': blank0Rect,
+      'mask-blank-drop-1': blank1Rect,
+      'drag-in-the-blank-droppable': boardRect
+    };
+    it('jumps to the next droppable in top-to-bottom order, landing at its center-left point', function () {
+      var currentCoordinates = {
+        x: blank0Rect.left,
+        y: blank0Rect.top
+      };
+      var next = press(baseRects, currentCoordinates, {
+        width: 120,
+        height: 40
+      }, makeEvent('Tab'));
+      expect(next).toEqual({
+        x: blank1Rect.left,
+        y: blank1Rect.top + blank1Rect.height / 2
+      });
+    });
+    it('cycles backwards with Shift+Tab, wrapping to the choice board', function () {
+      var currentCoordinates = {
+        x: blank0Rect.left,
+        y: blank0Rect.top
+      };
+      var next = press(baseRects, currentCoordinates, {
+        width: 120,
+        height: 40
+      }, makeEvent('Tab', true));
+      expect(next).toEqual({
+        x: boardRect.left,
+        y: boardRect.top + boardRect.height / 2
+      });
+    });
+    it("excludes a dragged blank's own drop-zone from the cycle", function () {
+      // A blank is simultaneously draggable and droppable for its own slot (the same
+      // shape as match-list's placed "target" tiles). Without excluding it, containment
+      // would match the blank to itself and cycle relative to itself instead of its
+      // real neighbors — this test is constructed so the two behaviors give different,
+      // distinguishable results (not just coincidentally the same answer).
+      var blankARect = {
+        left: 0,
+        top: 0,
+        width: 120,
+        height: 40,
+        right: 120,
+        bottom: 40
+      };
+      var blankBRect = {
+        left: 0,
+        top: 60,
+        width: 120,
+        height: 40,
+        right: 120,
+        bottom: 100
+      };
+      var blankCRect = {
+        left: 0,
+        top: 120,
+        width: 120,
+        height: 40,
+        right: 120,
+        bottom: 160
+      };
+      var rects = {
+        'mask-blank-drop-a': blankARect,
+        'mask-blank-drop-b': blankBRect,
+        'mask-blank-drop-c': blankCRect
+      };
+      var active = {
+        data: {
+          current: {
+            id: 'b',
+            fromChoice: false,
+            type: 'MaskBlank'
+          }
+        }
+      };
+      // Sitting exactly at blank B's own position.
+      var currentCoordinates = {
+        x: blankBRect.left,
+        y: blankBRect.top
+      };
+      var next = press(rects, currentCoordinates, {
+        width: 120,
+        height: 40
+      }, makeEvent('Tab', true), active);
+
+      // With B's own slot excluded, Shift+Tab from B's position falls back to
+      // nearest-by-dropPosition among the remaining targets (A and C) — A is closer to
+      // B's actual position, making A the resolved "current", so reverse from there
+      // lands on C. Without the exclusion, containment would match B to itself
+      // directly (index 1 of [A, B, C] sorted by position), landing on A instead.
+      expect(next).toEqual({
+        x: blankCRect.left,
+        y: blankCRect.top + blankCRect.height / 2
+      });
+    });
+    it('keeps advancing on repeated Shift+Tab when the choice board is much wider than the dragged item', function () {
+      // Regression case for the bug already found and fixed in match-list/image-cloze-
+      // association: matching the "current" target by reconstructing a center from the
+      // dragged item's own small size (instead of checking which target's rect actually
+      // contains it) makes the *next* press re-match a completely different droppable
+      // once the item is actually sitting on a wide target, so it looks like the press
+      // does nothing.
+      var wideBlankRect = {
+        left: 0,
+        top: 0,
+        width: 900,
+        height: 40,
+        right: 900,
+        bottom: 40
+      };
+      var rects = {
+        'mask-blank-drop-0': wideBlankRect,
+        'drag-in-the-blank-droppable': boardRect
+      };
+      var itemSize = {
+        width: 100,
+        height: 40
+      };
+      var afterFirst = press(rects, {
+        x: boardRect.left,
+        y: boardRect.top
+      }, itemSize, makeEvent('Tab', true));
+      expect(afterFirst).toEqual({
+        x: 0,
+        y: 20
+      }); // wide blank's center-left point
+
+      var afterSecond = press(rects, afterFirst, itemSize, makeEvent('Tab', true));
+      expect(afterSecond).toEqual({
+        x: boardRect.left,
+        y: boardRect.top + boardRect.height / 2
+      });
+    });
+    it('correctly identifies the choice board as the current target when picking up an item positioned near its edge, close to a small neighboring blank', function () {
+      // Regression case for the OTHER failure mode: matching "current target" purely by
+      // nearest-dropPosition (instead of containment first) can misidentify a large
+      // droppable as some small, unrelated nearby one, because a large droppable's
+      // dropPosition is anchored at its own vertical middle.
+      var tallBoardRect = {
+        left: 0,
+        top: 0,
+        width: 400,
+        height: 600,
+        right: 400,
+        bottom: 600
+      };
+      var smallBlankRect = {
+        left: 0,
+        top: -60,
+        width: 100,
+        height: 40,
+        right: 100,
+        bottom: -20
+      };
+      var rects = {
+        'mask-blank-drop-0': smallBlankRect,
+        'drag-in-the-blank-droppable': tallBoardRect
+      };
+      var itemSize = {
+        width: 100,
+        height: 40
+      };
+      var currentCoordinates = {
+        x: 0,
+        y: 10
+      };
+      var next = press(rects, currentCoordinates, itemSize, makeEvent('Tab'));
+      expect(next).toEqual({
+        x: smallBlankRect.left,
+        y: smallBlankRect.top + smallBlankRect.height / 2
+      });
+    });
+    it('keeps the choice board as a fixed last stop instead of sorting it in by its own center, when the board spans multiple blank rows', function () {
+      // Regression case for a real bug found via manual browser testing: with 3
+      // choices stacked beside wrapped inline text (`choicePosition: 'right'`), the
+      // tall choice board's own center fell numerically BETWEEN blank 2 and blank 3's
+      // rows. Sorting it by position the same way as a blank interleaved it into the
+      // middle of the cycle, so the very first Tab press after picking up a pool
+      // choice jumped straight to blank 3, skipping blanks 1 and 2 entirely.
+      var blank0Rect = {
+        left: 0,
+        top: 200,
+        width: 50,
+        height: 50,
+        right: 50,
+        bottom: 250
+      };
+      var blank1Rect = {
+        left: 0,
+        top: 250,
+        width: 50,
+        height: 50,
+        right: 50,
+        bottom: 300
+      };
+      var blank2Rect = {
+        left: 0,
+        top: 285,
+        width: 50,
+        height: 50,
+        right: 50,
+        bottom: 335
+      };
+      // Spans all three choices stacked beside the text — its center (287.5) falls
+      // between blank1's (275) and blank2's (310), more than 10px from either, so the
+      // old position-based sort placed it between them.
+      var tallBoardRect = {
+        left: 400,
+        top: 195,
+        width: 80,
+        height: 185,
+        right: 480,
+        bottom: 380
+      };
+      var rects = {
+        'mask-blank-drop-0': blank0Rect,
+        'mask-blank-drop-1': blank1Rect,
+        'mask-blank-drop-2': blank2Rect,
+        'drag-in-the-blank-droppable': tallBoardRect
+      };
+      var active = {
+        data: {
+          current: {
+            fromChoice: true,
+            choice: {
+              id: 'x'
+            },
+            type: 'MaskBlank'
+          }
+        }
+      };
+      var itemSize = {
+        width: 48,
+        height: 50
+      };
+      // Picking up a choice from within the board — its own current position, before
+      // any movement, sits inside the board's rect.
+      var currentCoordinates = {
+        x: 415,
+        y: 205
+      };
+      var next = press(rects, currentCoordinates, itemSize, makeEvent('Tab'), active);
+      expect(next).toEqual({
+        x: blank0Rect.left,
+        y: blank0Rect.top + blank0Rect.height / 2
+      });
+    });
+    it('cycles through every blank in position order, then the board, then wraps — even when the board would otherwise sort into the middle', function () {
+      var blank0Rect = {
+        left: 0,
+        top: 200,
+        width: 50,
+        height: 50,
+        right: 50,
+        bottom: 250
+      };
+      var blank1Rect = {
+        left: 0,
+        top: 250,
+        width: 50,
+        height: 50,
+        right: 50,
+        bottom: 300
+      };
+      var blank2Rect = {
+        left: 0,
+        top: 285,
+        width: 50,
+        height: 50,
+        right: 50,
+        bottom: 335
+      };
+      var tallBoardRect = {
+        left: 400,
+        top: 195,
+        width: 80,
+        height: 185,
+        right: 480,
+        bottom: 380
+      };
+      var rects = {
+        'mask-blank-drop-0': blank0Rect,
+        'mask-blank-drop-1': blank1Rect,
+        'mask-blank-drop-2': blank2Rect,
+        'drag-in-the-blank-droppable': tallBoardRect
+      };
+      var active = {
+        data: {
+          current: {
+            fromChoice: true,
+            choice: {
+              id: 'x'
+            },
+            type: 'MaskBlank'
+          }
+        }
+      };
+      var itemSize = {
+        width: 48,
+        height: 50
+      };
+      var coords = {
+        x: 415,
+        y: 205
+      };
+      var visited = [];
+      for (var i = 0; i < 5; i++) {
+        coords = press(rects, coords, itemSize, makeEvent('Tab'), active);
+        visited.push(coords);
+      }
+      expect(visited).toEqual([{
+        x: blank0Rect.left,
+        y: blank0Rect.top + blank0Rect.height / 2
+      }, {
+        x: blank1Rect.left,
+        y: blank1Rect.top + blank1Rect.height / 2
+      }, {
+        x: blank2Rect.left,
+        y: blank2Rect.top + blank2Rect.height / 2
+      }, {
+        x: tallBoardRect.left,
+        y: tallBoardRect.top + tallBoardRect.height / 2
+      }, {
+        x: blank0Rect.left,
+        y: blank0Rect.top + blank0Rect.height / 2
+      } // wraps
+      ]);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_core","require","_keyboardCoordinates","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","rectsToContext","rects","droppableRects","Map","entries","droppableContainers","map","id","disabled","makeEvent","code","shiftKey","undefined","preventDefault","press","currentCoordinates","itemSize","event","active","context","collisionRect","left","x","top","y","closestDroppableKeyboardCoordinates","describe","it","width","height","expect","KeyboardCode","Down","toEqual","Up","Right","Left","blank0Rect","right","bottom","blank1Rect","boardRect","baseRects","next","blankARect","blankBRect","blankCRect","data","current","fromChoice","type","wideBlankRect","afterFirst","afterSecond","tallBoardRect","smallBlankRect","blank2Rect","choice","coords","visited","i"],"sources":["../../src/__tests__/keyboard-coordinates.test.js"],"sourcesContent":["import { KeyboardCode } from '@dnd-kit/core';\nimport { closestDroppableKeyboardCoordinates } from '../keyboard-coordinates';\n\nfunction rectsToContext(rects) {\n  const droppableRects = new Map(Object.entries(rects));\n  const droppableContainers = new Map(Object.keys(rects).map((id) => [id, { disabled: false }]));\n\n  return { droppableRects, droppableContainers };\n}\n\nfunction makeEvent(code, shiftKey = false) {\n  return { code, preventDefault: () => {}, shiftKey };\n}\n\n// Mirrors dnd-kit's own KeyboardSensor, which always derives collisionRect's top-left\n// from the dragged item's current on-screen position on every keydown — so a test's\n// collisionRect must track currentCoordinates the same way on every simulated press,\n// not stay fixed while currentCoordinates changes across multiple presses.\nfunction press(rects, currentCoordinates, itemSize, event, active) {\n  const context = {\n    ...rectsToContext(rects),\n    collisionRect: { left: currentCoordinates.x, top: currentCoordinates.y, ...itemSize },\n  };\n\n  return closestDroppableKeyboardCoordinates(event, { active, context, currentCoordinates });\n}\n\ndescribe('closestDroppableKeyboardCoordinates', () => {\n  describe('arrow keys', () => {\n    it(\"nudges the dragged item by dnd-kit's own default step (25px), unchanged\", () => {\n      const context = { ...rectsToContext({}), collisionRect: { left: 0, top: 0, width: 100, height: 40 } };\n      const currentCoordinates = { x: 10, y: 20 };\n\n      expect(\n        closestDroppableKeyboardCoordinates(makeEvent(KeyboardCode.Down), { context, currentCoordinates }),\n      ).toEqual({ x: 10, y: 45 });\n      expect(\n        closestDroppableKeyboardCoordinates(makeEvent(KeyboardCode.Up), { context, currentCoordinates }),\n      ).toEqual({ x: 10, y: -5 });\n      expect(\n        closestDroppableKeyboardCoordinates(makeEvent(KeyboardCode.Right), { context, currentCoordinates }),\n      ).toEqual({ x: 35, y: 20 });\n      expect(\n        closestDroppableKeyboardCoordinates(makeEvent(KeyboardCode.Left), { context, currentCoordinates }),\n      ).toEqual({ x: -15, y: 20 });\n    });\n  });\n\n  describe('Tab / Shift+Tab', () => {\n    const blank0Rect = { left: 0, top: 0, width: 120, height: 40, right: 120, bottom: 40 };\n    const blank1Rect = { left: 0, top: 60, width: 120, height: 40, right: 120, bottom: 100 };\n    const boardRect = { left: 0, top: 120, width: 400, height: 300, right: 400, bottom: 420 };\n    const baseRects = {\n      'mask-blank-drop-0': blank0Rect,\n      'mask-blank-drop-1': blank1Rect,\n      'drag-in-the-blank-droppable': boardRect,\n    };\n\n    it('jumps to the next droppable in top-to-bottom order, landing at its center-left point', () => {\n      const currentCoordinates = { x: blank0Rect.left, y: blank0Rect.top };\n\n      const next = press(baseRects, currentCoordinates, { width: 120, height: 40 }, makeEvent('Tab'));\n\n      expect(next).toEqual({ x: blank1Rect.left, y: blank1Rect.top + blank1Rect.height / 2 });\n    });\n\n    it('cycles backwards with Shift+Tab, wrapping to the choice board', () => {\n      const currentCoordinates = { x: blank0Rect.left, y: blank0Rect.top };\n\n      const next = press(baseRects, currentCoordinates, { width: 120, height: 40 }, makeEvent('Tab', true));\n\n      expect(next).toEqual({ x: boardRect.left, y: boardRect.top + boardRect.height / 2 });\n    });\n\n    it(\"excludes a dragged blank's own drop-zone from the cycle\", () => {\n      // A blank is simultaneously draggable and droppable for its own slot (the same\n      // shape as match-list's placed \"target\" tiles). Without excluding it, containment\n      // would match the blank to itself and cycle relative to itself instead of its\n      // real neighbors — this test is constructed so the two behaviors give different,\n      // distinguishable results (not just coincidentally the same answer).\n      const blankARect = { left: 0, top: 0, width: 120, height: 40, right: 120, bottom: 40 };\n      const blankBRect = { left: 0, top: 60, width: 120, height: 40, right: 120, bottom: 100 };\n      const blankCRect = { left: 0, top: 120, width: 120, height: 40, right: 120, bottom: 160 };\n      const rects = {\n        'mask-blank-drop-a': blankARect,\n        'mask-blank-drop-b': blankBRect,\n        'mask-blank-drop-c': blankCRect,\n      };\n      const active = { data: { current: { id: 'b', fromChoice: false, type: 'MaskBlank' } } };\n      // Sitting exactly at blank B's own position.\n      const currentCoordinates = { x: blankBRect.left, y: blankBRect.top };\n\n      const next = press(rects, currentCoordinates, { width: 120, height: 40 }, makeEvent('Tab', true), active);\n\n      // With B's own slot excluded, Shift+Tab from B's position falls back to\n      // nearest-by-dropPosition among the remaining targets (A and C) — A is closer to\n      // B's actual position, making A the resolved \"current\", so reverse from there\n      // lands on C. Without the exclusion, containment would match B to itself\n      // directly (index 1 of [A, B, C] sorted by position), landing on A instead.\n      expect(next).toEqual({ x: blankCRect.left, y: blankCRect.top + blankCRect.height / 2 });\n    });\n\n    it('keeps advancing on repeated Shift+Tab when the choice board is much wider than the dragged item', () => {\n      // Regression case for the bug already found and fixed in match-list/image-cloze-\n      // association: matching the \"current\" target by reconstructing a center from the\n      // dragged item's own small size (instead of checking which target's rect actually\n      // contains it) makes the *next* press re-match a completely different droppable\n      // once the item is actually sitting on a wide target, so it looks like the press\n      // does nothing.\n      const wideBlankRect = { left: 0, top: 0, width: 900, height: 40, right: 900, bottom: 40 };\n      const rects = { 'mask-blank-drop-0': wideBlankRect, 'drag-in-the-blank-droppable': boardRect };\n      const itemSize = { width: 100, height: 40 };\n\n      const afterFirst = press(rects, { x: boardRect.left, y: boardRect.top }, itemSize, makeEvent('Tab', true));\n\n      expect(afterFirst).toEqual({ x: 0, y: 20 }); // wide blank's center-left point\n\n      const afterSecond = press(rects, afterFirst, itemSize, makeEvent('Tab', true));\n\n      expect(afterSecond).toEqual({ x: boardRect.left, y: boardRect.top + boardRect.height / 2 });\n    });\n\n    it('correctly identifies the choice board as the current target when picking up an item positioned near its edge, close to a small neighboring blank', () => {\n      // Regression case for the OTHER failure mode: matching \"current target\" purely by\n      // nearest-dropPosition (instead of containment first) can misidentify a large\n      // droppable as some small, unrelated nearby one, because a large droppable's\n      // dropPosition is anchored at its own vertical middle.\n      const tallBoardRect = { left: 0, top: 0, width: 400, height: 600, right: 400, bottom: 600 };\n      const smallBlankRect = { left: 0, top: -60, width: 100, height: 40, right: 100, bottom: -20 };\n      const rects = { 'mask-blank-drop-0': smallBlankRect, 'drag-in-the-blank-droppable': tallBoardRect };\n      const itemSize = { width: 100, height: 40 };\n\n      const currentCoordinates = { x: 0, y: 10 };\n\n      const next = press(rects, currentCoordinates, itemSize, makeEvent('Tab'));\n\n      expect(next).toEqual({ x: smallBlankRect.left, y: smallBlankRect.top + smallBlankRect.height / 2 });\n    });\n\n    it('keeps the choice board as a fixed last stop instead of sorting it in by its own center, when the board spans multiple blank rows', () => {\n      // Regression case for a real bug found via manual browser testing: with 3\n      // choices stacked beside wrapped inline text (`choicePosition: 'right'`), the\n      // tall choice board's own center fell numerically BETWEEN blank 2 and blank 3's\n      // rows. Sorting it by position the same way as a blank interleaved it into the\n      // middle of the cycle, so the very first Tab press after picking up a pool\n      // choice jumped straight to blank 3, skipping blanks 1 and 2 entirely.\n      const blank0Rect = { left: 0, top: 200, width: 50, height: 50, right: 50, bottom: 250 };\n      const blank1Rect = { left: 0, top: 250, width: 50, height: 50, right: 50, bottom: 300 };\n      const blank2Rect = { left: 0, top: 285, width: 50, height: 50, right: 50, bottom: 335 };\n      // Spans all three choices stacked beside the text — its center (287.5) falls\n      // between blank1's (275) and blank2's (310), more than 10px from either, so the\n      // old position-based sort placed it between them.\n      const tallBoardRect = { left: 400, top: 195, width: 80, height: 185, right: 480, bottom: 380 };\n      const rects = {\n        'mask-blank-drop-0': blank0Rect,\n        'mask-blank-drop-1': blank1Rect,\n        'mask-blank-drop-2': blank2Rect,\n        'drag-in-the-blank-droppable': tallBoardRect,\n      };\n      const active = { data: { current: { fromChoice: true, choice: { id: 'x' }, type: 'MaskBlank' } } };\n      const itemSize = { width: 48, height: 50 };\n      // Picking up a choice from within the board — its own current position, before\n      // any movement, sits inside the board's rect.\n      const currentCoordinates = { x: 415, y: 205 };\n\n      const next = press(rects, currentCoordinates, itemSize, makeEvent('Tab'), active);\n\n      expect(next).toEqual({ x: blank0Rect.left, y: blank0Rect.top + blank0Rect.height / 2 });\n    });\n\n    it('cycles through every blank in position order, then the board, then wraps — even when the board would otherwise sort into the middle', () => {\n      const blank0Rect = { left: 0, top: 200, width: 50, height: 50, right: 50, bottom: 250 };\n      const blank1Rect = { left: 0, top: 250, width: 50, height: 50, right: 50, bottom: 300 };\n      const blank2Rect = { left: 0, top: 285, width: 50, height: 50, right: 50, bottom: 335 };\n      const tallBoardRect = { left: 400, top: 195, width: 80, height: 185, right: 480, bottom: 380 };\n      const rects = {\n        'mask-blank-drop-0': blank0Rect,\n        'mask-blank-drop-1': blank1Rect,\n        'mask-blank-drop-2': blank2Rect,\n        'drag-in-the-blank-droppable': tallBoardRect,\n      };\n      const active = { data: { current: { fromChoice: true, choice: { id: 'x' }, type: 'MaskBlank' } } };\n      const itemSize = { width: 48, height: 50 };\n\n      let coords = { x: 415, y: 205 };\n      const visited = [];\n\n      for (let i = 0; i < 5; i++) {\n        coords = press(rects, coords, itemSize, makeEvent('Tab'), active);\n        visited.push(coords);\n      }\n\n      expect(visited).toEqual([\n        { x: blank0Rect.left, y: blank0Rect.top + blank0Rect.height / 2 },\n        { x: blank1Rect.left, y: blank1Rect.top + blank1Rect.height / 2 },\n        { x: blank2Rect.left, y: blank2Rect.top + blank2Rect.height / 2 },\n        { x: tallBoardRect.left, y: tallBoardRect.top + tallBoardRect.height / 2 },\n        { x: blank0Rect.left, y: blank0Rect.top + blank0Rect.height / 2 }, // wraps\n      ]);\n    });\n  });\n});\n"],"mappings":";;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,oBAAA,GAAAD,OAAA;AAA8E,SAAAE,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;AAE9E,SAASoB,cAAcA,CAACC,KAAK,EAAE;EAC7B,IAAMC,cAAc,GAAG,IAAIC,GAAG,CAACpB,MAAM,CAACqB,OAAO,CAACH,KAAK,CAAC,CAAC;EACrD,IAAMI,mBAAmB,GAAG,IAAIF,GAAG,CAACpB,MAAM,CAACC,IAAI,CAACiB,KAAK,CAAC,CAACK,GAAG,CAAC,UAACC,EAAE;IAAA,OAAK,CAACA,EAAE,EAAE;MAAEC,QAAQ,EAAE;IAAM,CAAC,CAAC;EAAA,EAAC,CAAC;EAE9F,OAAO;IAAEN,cAAc,EAAdA,cAAc;IAAEG,mBAAmB,EAAnBA;EAAoB,CAAC;AAChD;AAEA,SAASI,SAASA,CAACC,IAAI,EAAoB;EAAA,IAAlBC,QAAQ,GAAAlB,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAmB,SAAA,GAAAnB,SAAA,MAAG,KAAK;EACvC,OAAO;IAAEiB,IAAI,EAAJA,IAAI;IAAEG,cAAc,EAAE,SAAhBA,cAAcA,CAAA,EAAQ,CAAC,CAAC;IAAEF,QAAQ,EAARA;EAAS,CAAC;AACrD;;AAEA;AACA;AACA;AACA;AACA,SAASG,KAAKA,CAACb,KAAK,EAAEc,kBAAkB,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,MAAM,EAAE;EACjE,IAAMC,OAAO,GAAA3B,aAAA,CAAAA,aAAA,KACRQ,cAAc,CAACC,KAAK,CAAC;IACxBmB,aAAa,EAAA5B,aAAA;MAAI6B,IAAI,EAAEN,kBAAkB,CAACO,CAAC;MAAEC,GAAG,EAAER,kBAAkB,CAACS;IAAC,GAAKR,QAAQ;EAAE,EACtF;EAED,OAAO,IAAAS,wDAAmC,EAACR,KAAK,EAAE;IAAEC,MAAM,EAANA,MAAM;IAAEC,OAAO,EAAPA,OAAO;IAAEJ,kBAAkB,EAAlBA;EAAmB,CAAC,CAAC;AAC5F;AAEAW,QAAQ,CAAC,qCAAqC,EAAE,YAAM;EACpDA,QAAQ,CAAC,YAAY,EAAE,YAAM;IAC3BC,EAAE,CAAC,yEAAyE,EAAE,YAAM;MAClF,IAAMR,OAAO,GAAA3B,aAAA,CAAAA,aAAA,KAAQQ,cAAc,CAAC,CAAC,CAAC,CAAC;QAAEoB,aAAa,EAAE;UAAEC,IAAI,EAAE,CAAC;UAAEE,GAAG,EAAE,CAAC;UAAEK,KAAK,EAAE,GAAG;UAAEC,MAAM,EAAE;QAAG;MAAC,EAAE;MACrG,IAAMd,kBAAkB,GAAG;QAAEO,CAAC,EAAE,EAAE;QAAEE,CAAC,EAAE;MAAG,CAAC;MAE3CM,MAAM,CACJ,IAAAL,wDAAmC,EAAChB,SAAS,CAACsB,kBAAY,CAACC,IAAI,CAAC,EAAE;QAAEb,OAAO,EAAPA,OAAO;QAAEJ,kBAAkB,EAAlBA;MAAmB,CAAC,CACnG,CAAC,CAACkB,OAAO,CAAC;QAAEX,CAAC,EAAE,EAAE;QAAEE,CAAC,EAAE;MAAG,CAAC,CAAC;MAC3BM,MAAM,CACJ,IAAAL,wDAAmC,EAAChB,SAAS,CAACsB,kBAAY,CAACG,EAAE,CAAC,EAAE;QAAEf,OAAO,EAAPA,OAAO;QAAEJ,kBAAkB,EAAlBA;MAAmB,CAAC,CACjG,CAAC,CAACkB,OAAO,CAAC;QAAEX,CAAC,EAAE,EAAE;QAAEE,CAAC,EAAE,CAAC;MAAE,CAAC,CAAC;MAC3BM,MAAM,CACJ,IAAAL,wDAAmC,EAAChB,SAAS,CAACsB,kBAAY,CAACI,KAAK,CAAC,EAAE;QAAEhB,OAAO,EAAPA,OAAO;QAAEJ,kBAAkB,EAAlBA;MAAmB,CAAC,CACpG,CAAC,CAACkB,OAAO,CAAC;QAAEX,CAAC,EAAE,EAAE;QAAEE,CAAC,EAAE;MAAG,CAAC,CAAC;MAC3BM,MAAM,CACJ,IAAAL,wDAAmC,EAAChB,SAAS,CAACsB,kBAAY,CAACK,IAAI,CAAC,EAAE;QAAEjB,OAAO,EAAPA,OAAO;QAAEJ,kBAAkB,EAAlBA;MAAmB,CAAC,CACnG,CAAC,CAACkB,OAAO,CAAC;QAAEX,CAAC,EAAE,CAAC,EAAE;QAAEE,CAAC,EAAE;MAAG,CAAC,CAAC;IAC9B,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFE,QAAQ,CAAC,iBAAiB,EAAE,YAAM;IAChC,IAAMW,UAAU,GAAG;MAAEhB,IAAI,EAAE,CAAC;MAAEE,GAAG,EAAE,CAAC;MAAEK,KAAK,EAAE,GAAG;MAAEC,MAAM,EAAE,EAAE;MAAES,KAAK,EAAE,GAAG;MAAEC,MAAM,EAAE;IAAG,CAAC;IACtF,IAAMC,UAAU,GAAG;MAAEnB,IAAI,EAAE,CAAC;MAAEE,GAAG,EAAE,EAAE;MAAEK,KAAK,EAAE,GAAG;MAAEC,MAAM,EAAE,EAAE;MAAES,KAAK,EAAE,GAAG;MAAEC,MAAM,EAAE;IAAI,CAAC;IACxF,IAAME,SAAS,GAAG;MAAEpB,IAAI,EAAE,CAAC;MAAEE,GAAG,EAAE,GAAG;MAAEK,KAAK,EAAE,GAAG;MAAEC,MAAM,EAAE,GAAG;MAAES,KAAK,EAAE,GAAG;MAAEC,MAAM,EAAE;IAAI,CAAC;IACzF,IAAMG,SAAS,GAAG;MAChB,mBAAmB,EAAEL,UAAU;MAC/B,mBAAmB,EAAEG,UAAU;MAC/B,6BAA6B,EAAEC;IACjC,CAAC;IAEDd,EAAE,CAAC,sFAAsF,EAAE,YAAM;MAC/F,IAAMZ,kBAAkB,GAAG;QAAEO,CAAC,EAAEe,UAAU,CAAChB,IAAI;QAAEG,CAAC,EAAEa,UAAU,CAACd;MAAI,CAAC;MAEpE,IAAMoB,IAAI,GAAG7B,KAAK,CAAC4B,SAAS,EAAE3B,kBAAkB,EAAE;QAAEa,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAG,CAAC,EAAEpB,SAAS,CAAC,KAAK,CAAC,CAAC;MAE/FqB,MAAM,CAACa,IAAI,CAAC,CAACV,OAAO,CAAC;QAAEX,CAAC,EAAEkB,UAAU,CAACnB,IAAI;QAAEG,CAAC,EAAEgB,UAAU,CAACjB,GAAG,GAAGiB,UAAU,CAACX,MAAM,GAAG;MAAE,CAAC,CAAC;IACzF,CAAC,CAAC;IAEFF,EAAE,CAAC,+DAA+D,EAAE,YAAM;MACxE,IAAMZ,kBAAkB,GAAG;QAAEO,CAAC,EAAEe,UAAU,CAAChB,IAAI;QAAEG,CAAC,EAAEa,UAAU,CAACd;MAAI,CAAC;MAEpE,IAAMoB,IAAI,GAAG7B,KAAK,CAAC4B,SAAS,EAAE3B,kBAAkB,EAAE;QAAEa,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAG,CAAC,EAAEpB,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;MAErGqB,MAAM,CAACa,IAAI,CAAC,CAACV,OAAO,CAAC;QAAEX,CAAC,EAAEmB,SAAS,CAACpB,IAAI;QAAEG,CAAC,EAAEiB,SAAS,CAAClB,GAAG,GAAGkB,SAAS,CAACZ,MAAM,GAAG;MAAE,CAAC,CAAC;IACtF,CAAC,CAAC;IAEFF,EAAE,CAAC,yDAAyD,EAAE,YAAM;MAClE;MACA;MACA;MACA;MACA;MACA,IAAMiB,UAAU,GAAG;QAAEvB,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,CAAC;QAAEK,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAG,CAAC;MACtF,IAAMM,UAAU,GAAG;QAAExB,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,EAAE;QAAEK,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAI,CAAC;MACxF,IAAMO,UAAU,GAAG;QAAEzB,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAI,CAAC;MACzF,IAAMtC,KAAK,GAAG;QACZ,mBAAmB,EAAE2C,UAAU;QAC/B,mBAAmB,EAAEC,UAAU;QAC/B,mBAAmB,EAAEC;MACvB,CAAC;MACD,IAAM5B,MAAM,GAAG;QAAE6B,IAAI,EAAE;UAAEC,OAAO,EAAE;YAAEzC,EAAE,EAAE,GAAG;YAAE0C,UAAU,EAAE,KAAK;YAAEC,IAAI,EAAE;UAAY;QAAE;MAAE,CAAC;MACvF;MACA,IAAMnC,kBAAkB,GAAG;QAAEO,CAAC,EAAEuB,UAAU,CAACxB,IAAI;QAAEG,CAAC,EAAEqB,UAAU,CAACtB;MAAI,CAAC;MAEpE,IAAMoB,IAAI,GAAG7B,KAAK,CAACb,KAAK,EAAEc,kBAAkB,EAAE;QAAEa,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAG,CAAC,EAAEpB,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,EAAES,MAAM,CAAC;;MAEzG;MACA;MACA;MACA;MACA;MACAY,MAAM,CAACa,IAAI,CAAC,CAACV,OAAO,CAAC;QAAEX,CAAC,EAAEwB,UAAU,CAACzB,IAAI;QAAEG,CAAC,EAAEsB,UAAU,CAACvB,GAAG,GAAGuB,UAAU,CAACjB,MAAM,GAAG;MAAE,CAAC,CAAC;IACzF,CAAC,CAAC;IAEFF,EAAE,CAAC,iGAAiG,EAAE,YAAM;MAC1G;MACA;MACA;MACA;MACA;MACA;MACA,IAAMwB,aAAa,GAAG;QAAE9B,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,CAAC;QAAEK,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAG,CAAC;MACzF,IAAMtC,KAAK,GAAG;QAAE,mBAAmB,EAAEkD,aAAa;QAAE,6BAA6B,EAAEV;MAAU,CAAC;MAC9F,IAAMzB,QAAQ,GAAG;QAAEY,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAG,CAAC;MAE3C,IAAMuB,UAAU,GAAGtC,KAAK,CAACb,KAAK,EAAE;QAAEqB,CAAC,EAAEmB,SAAS,CAACpB,IAAI;QAAEG,CAAC,EAAEiB,SAAS,CAAClB;MAAI,CAAC,EAAEP,QAAQ,EAAEP,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;MAE1GqB,MAAM,CAACsB,UAAU,CAAC,CAACnB,OAAO,CAAC;QAAEX,CAAC,EAAE,CAAC;QAAEE,CAAC,EAAE;MAAG,CAAC,CAAC,CAAC,CAAC;;MAE7C,IAAM6B,WAAW,GAAGvC,KAAK,CAACb,KAAK,EAAEmD,UAAU,EAAEpC,QAAQ,EAAEP,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;MAE9EqB,MAAM,CAACuB,WAAW,CAAC,CAACpB,OAAO,CAAC;QAAEX,CAAC,EAAEmB,SAAS,CAACpB,IAAI;QAAEG,CAAC,EAAEiB,SAAS,CAAClB,GAAG,GAAGkB,SAAS,CAACZ,MAAM,GAAG;MAAE,CAAC,CAAC;IAC7F,CAAC,CAAC;IAEFF,EAAE,CAAC,kJAAkJ,EAAE,YAAM;MAC3J;MACA;MACA;MACA;MACA,IAAM2B,aAAa,GAAG;QAAEjC,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,CAAC;QAAEK,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE,GAAG;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAI,CAAC;MAC3F,IAAMgB,cAAc,GAAG;QAAElC,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,CAAC,EAAE;QAAEK,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE,CAAC;MAAG,CAAC;MAC7F,IAAMtC,KAAK,GAAG;QAAE,mBAAmB,EAAEsD,cAAc;QAAE,6BAA6B,EAAED;MAAc,CAAC;MACnG,IAAMtC,QAAQ,GAAG;QAAEY,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAG,CAAC;MAE3C,IAAMd,kBAAkB,GAAG;QAAEO,CAAC,EAAE,CAAC;QAAEE,CAAC,EAAE;MAAG,CAAC;MAE1C,IAAMmB,IAAI,GAAG7B,KAAK,CAACb,KAAK,EAAEc,kBAAkB,EAAEC,QAAQ,EAAEP,SAAS,CAAC,KAAK,CAAC,CAAC;MAEzEqB,MAAM,CAACa,IAAI,CAAC,CAACV,OAAO,CAAC;QAAEX,CAAC,EAAEiC,cAAc,CAAClC,IAAI;QAAEG,CAAC,EAAE+B,cAAc,CAAChC,GAAG,GAAGgC,cAAc,CAAC1B,MAAM,GAAG;MAAE,CAAC,CAAC;IACrG,CAAC,CAAC;IAEFF,EAAE,CAAC,kIAAkI,EAAE,YAAM;MAC3I;MACA;MACA;MACA;MACA;MACA;MACA,IAAMU,UAAU,GAAG;QAAEhB,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAI,CAAC;MACvF,IAAMC,UAAU,GAAG;QAAEnB,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAI,CAAC;MACvF,IAAMiB,UAAU,GAAG;QAAEnC,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAI,CAAC;MACvF;MACA;MACA;MACA,IAAMe,aAAa,GAAG;QAAEjC,IAAI,EAAE,GAAG;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,GAAG;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAI,CAAC;MAC9F,IAAMtC,KAAK,GAAG;QACZ,mBAAmB,EAAEoC,UAAU;QAC/B,mBAAmB,EAAEG,UAAU;QAC/B,mBAAmB,EAAEgB,UAAU;QAC/B,6BAA6B,EAAEF;MACjC,CAAC;MACD,IAAMpC,MAAM,GAAG;QAAE6B,IAAI,EAAE;UAAEC,OAAO,EAAE;YAAEC,UAAU,EAAE,IAAI;YAAEQ,MAAM,EAAE;cAAElD,EAAE,EAAE;YAAI,CAAC;YAAE2C,IAAI,EAAE;UAAY;QAAE;MAAE,CAAC;MAClG,IAAMlC,QAAQ,GAAG;QAAEY,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAG,CAAC;MAC1C;MACA;MACA,IAAMd,kBAAkB,GAAG;QAAEO,CAAC,EAAE,GAAG;QAAEE,CAAC,EAAE;MAAI,CAAC;MAE7C,IAAMmB,IAAI,GAAG7B,KAAK,CAACb,KAAK,EAAEc,kBAAkB,EAAEC,QAAQ,EAAEP,SAAS,CAAC,KAAK,CAAC,EAAES,MAAM,CAAC;MAEjFY,MAAM,CAACa,IAAI,CAAC,CAACV,OAAO,CAAC;QAAEX,CAAC,EAAEe,UAAU,CAAChB,IAAI;QAAEG,CAAC,EAAEa,UAAU,CAACd,GAAG,GAAGc,UAAU,CAACR,MAAM,GAAG;MAAE,CAAC,CAAC;IACzF,CAAC,CAAC;IAEFF,EAAE,CAAC,qIAAqI,EAAE,YAAM;MAC9I,IAAMU,UAAU,GAAG;QAAEhB,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAI,CAAC;MACvF,IAAMC,UAAU,GAAG;QAAEnB,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAI,CAAC;MACvF,IAAMiB,UAAU,GAAG;QAAEnC,IAAI,EAAE,CAAC;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,EAAE;QAAES,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAI,CAAC;MACvF,IAAMe,aAAa,GAAG;QAAEjC,IAAI,EAAE,GAAG;QAAEE,GAAG,EAAE,GAAG;QAAEK,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE,GAAG;QAAES,KAAK,EAAE,GAAG;QAAEC,MAAM,EAAE;MAAI,CAAC;MAC9F,IAAMtC,KAAK,GAAG;QACZ,mBAAmB,EAAEoC,UAAU;QAC/B,mBAAmB,EAAEG,UAAU;QAC/B,mBAAmB,EAAEgB,UAAU;QAC/B,6BAA6B,EAAEF;MACjC,CAAC;MACD,IAAMpC,MAAM,GAAG;QAAE6B,IAAI,EAAE;UAAEC,OAAO,EAAE;YAAEC,UAAU,EAAE,IAAI;YAAEQ,MAAM,EAAE;cAAElD,EAAE,EAAE;YAAI,CAAC;YAAE2C,IAAI,EAAE;UAAY;QAAE;MAAE,CAAC;MAClG,IAAMlC,QAAQ,GAAG;QAAEY,KAAK,EAAE,EAAE;QAAEC,MAAM,EAAE;MAAG,CAAC;MAE1C,IAAI6B,MAAM,GAAG;QAAEpC,CAAC,EAAE,GAAG;QAAEE,CAAC,EAAE;MAAI,CAAC;MAC/B,IAAMmC,OAAO,GAAG,EAAE;MAElB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAEA,CAAC,EAAE,EAAE;QAC1BF,MAAM,GAAG5C,KAAK,CAACb,KAAK,EAAEyD,MAAM,EAAE1C,QAAQ,EAAEP,SAAS,CAAC,KAAK,CAAC,EAAES,MAAM,CAAC;QACjEyC,OAAO,CAACrE,IAAI,CAACoE,MAAM,CAAC;MACtB;MAEA5B,MAAM,CAAC6B,OAAO,CAAC,CAAC1B,OAAO,CAAC,CACtB;QAAEX,CAAC,EAAEe,UAAU,CAAChB,IAAI;QAAEG,CAAC,EAAEa,UAAU,CAACd,GAAG,GAAGc,UAAU,CAACR,MAAM,GAAG;MAAE,CAAC,EACjE;QAAEP,CAAC,EAAEkB,UAAU,CAACnB,IAAI;QAAEG,CAAC,EAAEgB,UAAU,CAACjB,GAAG,GAAGiB,UAAU,CAACX,MAAM,GAAG;MAAE,CAAC,EACjE;QAAEP,CAAC,EAAEkC,UAAU,CAACnC,IAAI;QAAEG,CAAC,EAAEgC,UAAU,CAACjC,GAAG,GAAGiC,UAAU,CAAC3B,MAAM,GAAG;MAAE,CAAC,EACjE;QAAEP,CAAC,EAAEgC,aAAa,CAACjC,IAAI;QAAEG,CAAC,EAAE8B,aAAa,CAAC/B,GAAG,GAAG+B,aAAa,CAACzB,MAAM,GAAG;MAAE,CAAC,EAC1E;QAAEP,CAAC,EAAEe,UAAU,CAAChB,IAAI;QAAEG,CAAC,EAAEa,UAAU,CAACd,GAAG,GAAGc,UAAU,CAACR,MAAM,GAAG;MAAE,CAAC,CAAE;MAAA,CACpE,CAAC;IACJ,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}