@flighthq/interaction 0.2.0 → 0.2.1-next.410.a23f189

package/src/interactionSpatialIndex.test.ts

@@ -0,0 +1,103 @@
+import { createDisplayObject, createDisplayObjectGeneric } from '@flighthq/displayobject';
+import { setRectangle } from '@flighthq/geometry';
+import { addNodeChild, getNodeLocalBoundsRectangle, invalidateNodeLocalTransform } from '@flighthq/node';
+import { createSpatialIndex, createUniformGridSpatialBackend } from '@flighthq/spatial';
+import { DisplayObjectKind } from '@flighthq/types';
+
+import { hitTestGraphLocalBounds, registerHitTest } from './hitTests';
+import { createInteractionManager } from './interactionManager';
+import { findSpatialInteractionTarget, refreshInteractionSpatialIndex } from './interactionSpatialIndex';
+import { setNodeHitArea, setNodeHitTestEnabled } from './nodeInteractionState';
+
+function candidate(x: number, y: number, w: number, h: number) {
+  const obj = createDisplayObjectGeneric(DisplayObjectKind);
+  obj.x = x;
+  obj.y = y;
+  invalidateNodeLocalTransform(obj);
+  setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, w, h);
+  setNodeHitTestEnabled(obj, true);
+  return obj;
+}
+
+function managedScene() {
+  registerHitTest(DisplayObjectKind, hitTestGraphLocalBounds);
+  const root = createDisplayObject();
+  const index = createSpatialIndex(createUniformGridSpatialBackend(64));
+  const manager = createInteractionManager(root, { spatialIndex: index });
+  return { manager, root };
+}
+
+describe('findSpatialInteractionTarget', () => {
+  it('returns the candidate whose region contains the point', () => {
+    const { manager, root } = managedScene();
+    const a = candidate(0, 0, 50, 50);
+    const b = candidate(200, 200, 50, 50);
+    addNodeChild(root, a);
+    addNodeChild(root, b);
+    refreshInteractionSpatialIndex(manager);
+
+    expect(findSpatialInteractionTarget(manager, 25, 25)).toBe(a);
+    expect(findSpatialInteractionTarget(manager, 225, 225)).toBe(b);
+    expect(findSpatialInteractionTarget(manager, 500, 500)).toBeNull();
+  });
+
+  it('returns the topmost (last-drawn) candidate when regions overlap', () => {
+    const { manager, root } = managedScene();
+    const under = candidate(0, 0, 100, 100);
+    const over = candidate(0, 0, 100, 100);
+    addNodeChild(root, under);
+    addNodeChild(root, over);
+    refreshInteractionSpatialIndex(manager);
+
+    expect(findSpatialInteractionTarget(manager, 50, 50)).toBe(over);
+  });
+
+  it('returns null before the index is refreshed', () => {
+    const { manager, root } = managedScene();
+    addNodeChild(root, candidate(0, 0, 50, 50));
+    expect(findSpatialInteractionTarget(manager, 25, 25)).toBeNull();
+  });
+});
+
+describe('refreshInteractionSpatialIndex', () => {
+  it('indexes only opted-in nodes', () => {
+    const { manager, root } = managedScene();
+    const inert = createDisplayObjectGeneric(DisplayObjectKind);
+    setRectangle(getNodeLocalBoundsRectangle(inert), 0, 0, 50, 50);
+    addNodeChild(root, inert);
+    refreshInteractionSpatialIndex(manager);
+
+    expect(findSpatialInteractionTarget(manager, 25, 25)).toBeNull();
+
+    setNodeHitTestEnabled(inert, true);
+    refreshInteractionSpatialIndex(manager);
+    expect(findSpatialInteractionTarget(manager, 25, 25)).toBe(inert);
+  });
+
+  it('indexes an atomic hitArea unit without descending into its children', () => {
+    const { manager, root } = managedScene();
+    const unit = candidate(0, 0, 100, 100);
+    setNodeHitArea(unit, 'bounds');
+    const child = candidate(0, 0, 20, 20);
+    addNodeChild(root, unit);
+    addNodeChild(unit, child);
+    refreshInteractionSpatialIndex(manager);
+
+    // The child sits inside the unit, but the atomic unit is what resolves.
+    expect(findSpatialInteractionTarget(manager, 10, 10)).toBe(unit);
+  });
+
+  it('agrees with the linear pick after a transform change is re-synced', () => {
+    const { manager, root } = managedScene();
+    const a = candidate(0, 0, 50, 50);
+    addNodeChild(root, a);
+    refreshInteractionSpatialIndex(manager);
+    expect(findSpatialInteractionTarget(manager, 25, 25)).toBe(a);
+
+    a.x = 300;
+    invalidateNodeLocalTransform(a);
+    refreshInteractionSpatialIndex(manager);
+    expect(findSpatialInteractionTarget(manager, 25, 25)).toBeNull();
+    expect(findSpatialInteractionTarget(manager, 325, 25)).toBe(a);
+  });
+});

package/src/nodeInteractionState.test.ts

@@ -0,0 +1,141 @@
+import { createDisplayObject } from '@flighthq/displayobject';
+import { createRectangle } from '@flighthq/geometry';
+
+import {
+  createNodeInteractionState,
+  enableNodeInteractionState,
+  getNodeCursor,
+  getNodeHitArea,
+  getNodeInteractionState,
+  getNodeTabIndex,
+  isNodeFocusable,
+  isNodeHitTestEnabled,
+  setNodeCursor,
+  setNodeFocusable,
+  setNodeHitArea,
+  setNodeHitTestEnabled,
+  setNodeTabIndex,
+} from './nodeInteractionState';
+
+describe('createNodeInteractionState', () => {
+  it('returns a cell with every field at its default', () => {
+    expect(createNodeInteractionState()).toEqual({
+      cursor: null,
+      focusable: false,
+      hitArea: null,
+      hitTestEnabled: false,
+      tabIndex: -1,
+    });
+  });
+});
+
+describe('enableNodeInteractionState', () => {
+  it('creates the cell on first use and returns the same instance thereafter', () => {
+    const obj = createDisplayObject();
+    const first = enableNodeInteractionState(obj);
+    expect(getNodeInteractionState(obj)).toBe(first);
+    expect(enableNodeInteractionState(obj)).toBe(first);
+  });
+});
+
+describe('getNodeCursor', () => {
+  it('is null by default and returns the set cursor', () => {
+    const obj = createDisplayObject();
+    expect(getNodeCursor(obj)).toBeNull();
+    setNodeCursor(obj, 'pointer');
+    expect(getNodeCursor(obj)).toBe('pointer');
+  });
+});
+
+describe('getNodeHitArea', () => {
+  it('is null by default and returns the set proxy', () => {
+    const obj = createDisplayObject();
+    const area = createRectangle(0, 0, 10, 10);
+    expect(getNodeHitArea(obj)).toBeNull();
+    setNodeHitArea(obj, area);
+    expect(getNodeHitArea(obj)).toBe(area);
+  });
+});
+
+describe('getNodeInteractionState', () => {
+  it('is null until a field is set', () => {
+    const obj = createDisplayObject();
+    expect(getNodeInteractionState(obj)).toBeNull();
+    setNodeFocusable(obj, true);
+    expect(getNodeInteractionState(obj)).not.toBeNull();
+  });
+});
+
+describe('getNodeTabIndex', () => {
+  it('defaults to -1 and returns the set value', () => {
+    const obj = createDisplayObject();
+    expect(getNodeTabIndex(obj)).toBe(-1);
+    setNodeTabIndex(obj, 3);
+    expect(getNodeTabIndex(obj)).toBe(3);
+  });
+});
+
+describe('isNodeFocusable', () => {
+  it('defaults to false and reflects the setter', () => {
+    const obj = createDisplayObject();
+    expect(isNodeFocusable(obj)).toBe(false);
+    setNodeFocusable(obj, true);
+    expect(isNodeFocusable(obj)).toBe(true);
+  });
+});
+
+describe('isNodeHitTestEnabled', () => {
+  it('defaults to false (opt-in) and reflects the setter', () => {
+    const obj = createDisplayObject();
+    expect(isNodeHitTestEnabled(obj)).toBe(false);
+    setNodeHitTestEnabled(obj, true);
+    expect(isNodeHitTestEnabled(obj)).toBe(true);
+  });
+});
+
+describe('setNodeCursor', () => {
+  it('assigns and clears the cursor', () => {
+    const obj = createDisplayObject();
+    setNodeCursor(obj, 'grab');
+    expect(getNodeCursor(obj)).toBe('grab');
+    setNodeCursor(obj, null);
+    expect(getNodeCursor(obj)).toBeNull();
+  });
+});
+
+describe('setNodeFocusable', () => {
+  it('assigns focusability', () => {
+    const obj = createDisplayObject();
+    setNodeFocusable(obj, true);
+    expect(isNodeFocusable(obj)).toBe(true);
+  });
+});
+
+describe('setNodeHitArea', () => {
+  it('assigns and clears the hit-area proxy', () => {
+    const obj = createDisplayObject();
+    const area = createRectangle(0, 0, 5, 5);
+    setNodeHitArea(obj, area);
+    expect(getNodeHitArea(obj)).toBe(area);
+    setNodeHitArea(obj, null);
+    expect(getNodeHitArea(obj)).toBeNull();
+  });
+});
+
+describe('setNodeHitTestEnabled', () => {
+  it('opts the node in and out of hit testing', () => {
+    const obj = createDisplayObject();
+    setNodeHitTestEnabled(obj, true);
+    expect(isNodeHitTestEnabled(obj)).toBe(true);
+    setNodeHitTestEnabled(obj, false);
+    expect(isNodeHitTestEnabled(obj)).toBe(false);
+  });
+});
+
+describe('setNodeTabIndex', () => {
+  it('assigns the focus-order key', () => {
+    const obj = createDisplayObject();
+    setNodeTabIndex(obj, 7);
+    expect(getNodeTabIndex(obj)).toBe(7);
+  });
+});

package/src/registerBitmapHitTest.test.ts

@@ -0,0 +1,22 @@
+import { createBitmap } from '@flighthq/displayobject';
+import { setRectangle } from '@flighthq/geometry';
+import { getNodeLocalBoundsRectangle } from '@flighthq/node';
+
+import { findGraphHitTargetPrecise } from './hitTests';
+import { setNodeHitTestEnabled } from './nodeInteractionState';
+import { registerBitmapHitTest } from './registerBitmapHitTest';
+
+describe('registerBitmapHitTest', () => {
+  // Positive alpha-accuracy is exercised by the functional suite (jsdom cannot rasterize pixels); this
+  // covers the wiring and the documented bounds fallback when no readable image is present.
+  it('installs a precise Bitmap provider with a no-image bounds fallback', () => {
+    registerBitmapHitTest();
+    const bitmap = createBitmap();
+    setRectangle(getNodeLocalBoundsRectangle(bitmap), 0, 0, 100, 100);
+    setNodeHitTestEnabled(bitmap, true);
+
+    // No image → the exact provider falls back to a bounds hit inside the box, miss outside.
+    expect(findGraphHitTargetPrecise(bitmap, 50, 50)).toBe(bitmap);
+    expect(findGraphHitTargetPrecise(bitmap, 200, 200)).toBeNull();
+  });
+});

package/src/{registerDefaultHitTestPoints.test.ts → registerDefaultHitTests.test.ts}

@@ -4,26 +4,29 @@ import { getNodeLocalBoundsRectangle } from '@flighthq/node';
 import { createShape } from '@flighthq/shape';
 
 import { findGraphHitTarget } from './hitTests';
-import { registerDefaultHitTestPoints } from './registerDefaultHitTestPoints';
+import { setNodeHitTestEnabled } from './nodeInteractionState';
+import { registerDefaultHitTests } from './registerDefaultHitTests';
 
-describe('registerDefaultHitTestPoints', () => {
+describe('registerDefaultHitTests', () => {
   it('registers all built-in kinds so findGraphHitTarget resolves them', () => {
-    registerDefaultHitTestPoints();
+    registerDefaultHitTests();
 
     const bitmap = createBitmap();
     setRectangle(getNodeLocalBoundsRectangle(bitmap), 0, 0, 100, 100);
+    setNodeHitTestEnabled(bitmap, true);
     expect(findGraphHitTarget(bitmap, 50, 50)).toBe(bitmap);
 
     const shape = createShape();
     setRectangle(getNodeLocalBoundsRectangle(shape), 0, 0, 100, 100);
+    setNodeHitTestEnabled(shape, true);
     expect(findGraphHitTarget(shape, 50, 50)).toBe(shape);
   });
 
   it('containers return null for self hit', () => {
-    registerDefaultHitTestPoints();
+    registerDefaultHitTests();
 
-    const stage = createStage();
-    setRectangle(getNodeLocalBoundsRectangle(stage), 0, 0, 100, 100);
-    expect(findGraphHitTarget(stage, 50, 50)).toBeNull();
+    const root = createStage().root;
+    setRectangle(getNodeLocalBoundsRectangle(root), 0, 0, 100, 100);
+    expect(findGraphHitTarget(root, 50, 50)).toBeNull();
   });
 });

package/src/registerShapeHitTest.test.ts

@@ -0,0 +1,27 @@
+import { setRectangle } from '@flighthq/geometry';
+import { getNodeLocalBoundsRectangle } from '@flighthq/node';
+import { appendShapeBeginFill, appendShapeCircle, appendShapeEndFill, createShape } from '@flighthq/shape';
+import { ShapeKind } from '@flighthq/types';
+
+import { findGraphHitTargetPrecise, hitTestGraphLocalBounds, hitTestGraphPoint, registerHitTest } from './hitTests';
+import { setNodeHitTestEnabled } from './nodeInteractionState';
+import { registerShapeHitTest } from './registerShapeHitTest';
+
+describe('registerShapeHitTest', () => {
+  it('winding-tests the actual fill for precise queries, so a bbox corner outside the circle misses', () => {
+    registerHitTest(ShapeKind, hitTestGraphLocalBounds);
+    registerShapeHitTest();
+    const shape = createShape();
+    appendShapeBeginFill(shape, 0xff0000ff, 1);
+    appendShapeCircle(shape, 50, 50, 40);
+    appendShapeEndFill(shape);
+    setRectangle(getNodeLocalBoundsRectangle(shape), 10, 10, 80, 80);
+    setNodeHitTestEnabled(shape, true);
+
+    // Center is inside the fill; (85,85) is inside the bounding box but outside the circle.
+    expect(findGraphHitTargetPrecise(shape, 50, 50)).toBe(shape);
+    expect(findGraphHitTargetPrecise(shape, 85, 85)).toBeNull();
+    // The coarse query still counts (85,85) as a hit.
+    expect(hitTestGraphPoint(shape, 85, 85)).toBe(true);
+  });
+});

package/src/registerTextHitTest.test.ts

@@ -0,0 +1,54 @@
+import { setRectangle } from '@flighthq/geometry';
+import { getNodeLocalBoundsRectangle } from '@flighthq/node';
+import { createTextLabel, setTextLabelString } from '@flighthq/text';
+import { setTextLayoutMeasureProvider } from '@flighthq/textlayout';
+import type { HitTestResult, TextLabel } from '@flighthq/types';
+import { TextLabelKind } from '@flighthq/types';
+
+import { describeGraphHit, findGraphHitTargetPrecise, hitTestGraphLocalBounds, registerHitTest } from './hitTests';
+import { setNodeHitTestEnabled } from './nodeInteractionState';
+import { registerTextHitTest } from './registerTextHitTest';
+
+function hittableLabel(text: string): TextLabel {
+  const label = createTextLabel();
+  setTextLabelString(label, text);
+  setRectangle(getNodeLocalBoundsRectangle(label), 0, 0, 200, 30);
+  setNodeHitTestEnabled(label, true);
+  return label;
+}
+
+function emptyResult(node: TextLabel): HitTestResult {
+  return { localX: 0, localY: 0, node, subIndex: -99 };
+}
+
+beforeAll(() => {
+  registerHitTest(TextLabelKind, hitTestGraphLocalBounds);
+  registerTextHitTest();
+});
+
+afterEach(() => {
+  setTextLayoutMeasureProvider(null);
+});
+
+describe('registerTextHitTest', () => {
+  it('hits the whole box precisely, and describes subIndex 0 when no layout is available', () => {
+    setTextLayoutMeasureProvider(null);
+    const label = hittableLabel('hello');
+    expect(findGraphHitTargetPrecise(label, 5, 10)).toBe(label);
+    const out = emptyResult(label);
+    describeGraphHit(label, 5, 10, out);
+    expect(out.subIndex).toBe(0);
+  });
+
+  it('describes the character index under the pointer via the layout', () => {
+    // Fixed 7px-per-character measure — a real layout without a renderer.
+    setTextLayoutMeasureProvider((t) => t.length * 7);
+    const label = hittableLabel('ABCDE');
+    const left = emptyResult(label);
+    const right = emptyResult(label);
+    describeGraphHit(label, 1, 10, left);
+    describeGraphHit(label, 30, 10, right);
+    expect(left.subIndex).toBe(0);
+    expect(right.subIndex).toBeGreaterThan(left.subIndex);
+  });
+});

package/src/spriteHitTests.test.ts

@@ -3,9 +3,9 @@ import { addNodeChild, getNodeLocalBoundsRectangle } from '@flighthq/node';
 import { createQuadBatch, createSprite, createTilemap } from '@flighthq/sprite';
 
 import {
-  defaultQuadBatchHitTestPointHandler,
-  defaultSpriteHitTestPointHandler,
-  defaultTilemapHitTestPointHandler,
+  defaultQuadBatchHitTestHandler,
+  defaultSpriteHitTestHandler,
+  defaultTilemapHitTestHandler,
 } from './spriteHitTests';
 
 function makeSprite(boundsW = 100, boundsH = 100) {
@@ -16,13 +16,13 @@ function makeSprite(boundsW = 100, boundsH = 100) {
   return sprite;
 }
 
-describe('defaultQuadBatchHitTestPointHandler', () => {
+describe('defaultQuadBatchHitTestHandler', () => {
   it('returns true inside bounds', () => {
     const parent = createSprite();
     const qb = createQuadBatch();
     addNodeChild(parent, qb);
     setRectangle(getNodeLocalBoundsRectangle(qb), 0, 0, 100, 100);
-    expect(defaultQuadBatchHitTestPointHandler(qb, 50, 50, false)).toBe(true);
+    expect(defaultQuadBatchHitTestHandler(qb, 50, 50)).toBe(true);
   });
 
   it('returns false outside bounds', () => {
@@ -30,40 +30,40 @@ describe('defaultQuadBatchHitTestPointHandler', () => {
     const qb = createQuadBatch();
     addNodeChild(parent, qb);
     setRectangle(getNodeLocalBoundsRectangle(qb), 0, 0, 100, 100);
-    expect(defaultQuadBatchHitTestPointHandler(qb, 200, 200, false)).toBe(false);
+    expect(defaultQuadBatchHitTestHandler(qb, 200, 200)).toBe(false);
   });
 });
 
-describe('defaultSpriteHitTestPointHandler', () => {
+describe('defaultSpriteHitTestHandler', () => {
   it('returns true when point is inside local bounds', () => {
     const sprite = makeSprite();
-    expect(defaultSpriteHitTestPointHandler(sprite, 50, 50, false)).toBe(true);
+    expect(defaultSpriteHitTestHandler(sprite, 50, 50)).toBe(true);
   });
 
   it('returns false when point is outside local bounds', () => {
     const sprite = makeSprite();
-    expect(defaultSpriteHitTestPointHandler(sprite, 200, 200, false)).toBe(false);
+    expect(defaultSpriteHitTestHandler(sprite, 200, 200)).toBe(false);
   });
 
   it('returns false for a zero-size sprite', () => {
     const sprite = makeSprite(0, 0);
-    expect(defaultSpriteHitTestPointHandler(sprite, 0, 0, false)).toBe(false);
+    expect(defaultSpriteHitTestHandler(sprite, 0, 0)).toBe(false);
   });
 
   it('ignores shapeFlag', () => {
     const sprite = makeSprite();
-    expect(defaultSpriteHitTestPointHandler(sprite, 10, 10, true)).toBe(true);
-    expect(defaultSpriteHitTestPointHandler(sprite, 200, 200, true)).toBe(false);
+    expect(defaultSpriteHitTestHandler(sprite, 10, 10)).toBe(true);
+    expect(defaultSpriteHitTestHandler(sprite, 200, 200)).toBe(false);
   });
 });
 
-describe('defaultTilemapHitTestPointHandler', () => {
+describe('defaultTilemapHitTestHandler', () => {
   it('returns true inside bounds', () => {
     const parent = createSprite();
     const tilemap = createTilemap();
     addNodeChild(parent, tilemap);
     setRectangle(getNodeLocalBoundsRectangle(tilemap), 0, 0, 100, 100);
-    expect(defaultTilemapHitTestPointHandler(tilemap, 10, 10, false)).toBe(true);
+    expect(defaultTilemapHitTestHandler(tilemap, 10, 10)).toBe(true);
   });
 
   it('returns false outside bounds', () => {
@@ -71,6 +71,6 @@ describe('defaultTilemapHitTestPointHandler', () => {
     const tilemap = createTilemap();
     addNodeChild(parent, tilemap);
     setRectangle(getNodeLocalBoundsRectangle(tilemap), 0, 0, 100, 100);
-    expect(defaultTilemapHitTestPointHandler(tilemap, 999, 999, false)).toBe(false);
+    expect(defaultTilemapHitTestHandler(tilemap, 999, 999)).toBe(false);
   });
 });

package/dist/registerDefaultHitTestPoints.d.ts

@@ -1,2 +0,0 @@
-export declare function registerDefaultHitTestPoints(): void;
-//# sourceMappingURL=registerDefaultHitTestPoints.d.ts.map

package/dist/registerDefaultHitTestPoints.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerDefaultHitTestPoints.d.ts","sourceRoot":"","sources":["../src/registerDefaultHitTestPoints.ts"],"names":[],"mappings":"AAoCA,wBAAgB,4BAA4B,IAAI,IAAI,CAenD"}

package/dist/registerDefaultHitTestPoints.js

@@ -1,21 +0,0 @@
-import { BitmapKind, DisplayObjectKind, HtmlViewKind, MovieClipKind, QuadBatchKind, RenderViewKind, RichTextKind, Scale9ShapeKind, ShapeKind, SpriteKind, StageKind, TextLabelKind, TilemapKind, VideoKind, } from '@flighthq/types';
-import { defaultBitmapHitTestPointHandler, defaultDisplayObjectHitTestPointHandler, defaultHtmlViewHitTestPointHandler, defaultMovieClipHitTestPointHandler, defaultRenderViewHitTestPointHandler, defaultRichTextHitTestPointHandler, defaultShapeHitTestPointHandler, defaultStageHitTestPointHandler, defaultTextHitTestPointHandler, defaultVideoHitTestPointHandler, } from './displayHitTests';
-import { registerHitTestPoint } from './hitTests';
-import { defaultQuadBatchHitTestPointHandler, defaultSpriteHitTestPointHandler, defaultTilemapHitTestPointHandler, } from './spriteHitTests';
-export function registerDefaultHitTestPoints() {
-    registerHitTestPoint(BitmapKind, defaultBitmapHitTestPointHandler);
-    registerHitTestPoint(DisplayObjectKind, defaultDisplayObjectHitTestPointHandler);
-    registerHitTestPoint(HtmlViewKind, defaultHtmlViewHitTestPointHandler);
-    registerHitTestPoint(MovieClipKind, defaultMovieClipHitTestPointHandler);
-    registerHitTestPoint(QuadBatchKind, defaultQuadBatchHitTestPointHandler);
-    registerHitTestPoint(RenderViewKind, defaultRenderViewHitTestPointHandler);
-    registerHitTestPoint(RichTextKind, defaultRichTextHitTestPointHandler);
-    registerHitTestPoint(Scale9ShapeKind, defaultShapeHitTestPointHandler);
-    registerHitTestPoint(ShapeKind, defaultShapeHitTestPointHandler);
-    registerHitTestPoint(SpriteKind, defaultSpriteHitTestPointHandler);
-    registerHitTestPoint(StageKind, defaultStageHitTestPointHandler);
-    registerHitTestPoint(TextLabelKind, defaultTextHitTestPointHandler);
-    registerHitTestPoint(TilemapKind, defaultTilemapHitTestPointHandler);
-    registerHitTestPoint(VideoKind, defaultVideoHitTestPointHandler);
-}
-//# sourceMappingURL=registerDefaultHitTestPoints.js.map

package/dist/registerDefaultHitTestPoints.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerDefaultHitTestPoints.js","sourceRoot":"","sources":["../src/registerDefaultHitTestPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,aAAa,EACb,cAAc,EACd,YAAY,EACZ,eAAe,EACf,SAAS,EACT,UAAU,EACV,SAAS,EACT,aAAa,EACb,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,gCAAgC,EAChC,uCAAuC,EACvC,kCAAkC,EAClC,mCAAmC,EACnC,oCAAoC,EACpC,kCAAkC,EAClC,+BAA+B,EAC/B,+BAA+B,EAC/B,8BAA8B,EAC9B,+BAA+B,GAChC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EACL,mCAAmC,EACnC,gCAAgC,EAChC,iCAAiC,GAClC,MAAM,kBAAkB,CAAC;AAE1B,MAAM,UAAU,4BAA4B;IAC1C,oBAAoB,CAAC,UAAU,EAAE,gCAAgC,CAAC,CAAC;IACnE,oBAAoB,CAAC,iBAAiB,EAAE,uCAAuC,CAAC,CAAC;IACjF,oBAAoB,CAAC,YAAY,EAAE,kCAAkC,CAAC,CAAC;IACvE,oBAAoB,CAAC,aAAa,EAAE,mCAAmC,CAAC,CAAC;IACzE,oBAAoB,CAAC,aAAa,EAAE,mCAAmC,CAAC,CAAC;IACzE,oBAAoB,CAAC,cAAc,EAAE,oCAAoC,CAAC,CAAC;IAC3E,oBAAoB,CAAC,YAAY,EAAE,kCAAkC,CAAC,CAAC;IACvE,oBAAoB,CAAC,eAAe,EAAE,+BAA+B,CAAC,CAAC;IACvE,oBAAoB,CAAC,SAAS,EAAE,+BAA+B,CAAC,CAAC;IACjE,oBAAoB,CAAC,UAAU,EAAE,gCAAgC,CAAC,CAAC;IACnE,oBAAoB,CAAC,SAAS,EAAE,+BAA+B,CAAC,CAAC;IACjE,oBAAoB,CAAC,aAAa,EAAE,8BAA8B,CAAC,CAAC;IACpE,oBAAoB,CAAC,WAAW,EAAE,iCAAiC,CAAC,CAAC;IACrE,oBAAoB,CAAC,SAAS,EAAE,+BAA+B,CAAC,CAAC;AACnE,CAAC"}