@spatial-engine/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,295 @@
+export { LidarDoneMessage, LidarInitMessage, LidarReadyMessage, LidarSweepMessage, LidarWorkerInMessage, LidarWorkerOutMessage, createLidarProcessor } from './lidar-worker.js';
+
+/**
+ * AABB (Axis-Aligned Bounding Box) stored as a flat Float32Array slice.
+ * Layout: [minX, minY, minZ, maxX, maxY, maxZ]
+ */
+declare const AABB_STRIDE = 6;
+/**
+ * A pool-backed, zero-GC AABB store.
+ * Each AABB occupies AABB_STRIDE floats in the underlying buffer.
+ *
+ * When a `SharedArrayBuffer` is provided, the pool's data is accessible from
+ * multiple threads (e.g. a Web Worker) with no copying.
+ */
+declare class AABBPool {
+    private readonly buffer;
+    private count;
+    constructor(capacity: number, sharedBuffer?: SharedArrayBuffer);
+    /**
+     * Create an AABBPool backed by a new `SharedArrayBuffer`.
+     * Both the pool and the underlying `SharedArrayBuffer` are returned so the
+     * caller can transfer the buffer to a `Worker` via `postMessage`.
+     */
+    static createShared(capacity: number): {
+        pool: AABBPool;
+        sab: SharedArrayBuffer;
+    };
+    /** Allocate a new AABB slot and return its index. */
+    allocate(): number;
+    /** Set the bounds of an AABB at the given index. */
+    set(index: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+    /** Read a single component value from the buffer. */
+    get(index: number, component: number): number;
+    /** Returns the number of allocated AABBs. */
+    get size(): number;
+    /** Reset the pool (all allocations freed, no GC). */
+    reset(): void;
+}
+/**
+ * Expand AABB `a` in-place so it also fully contains AABB `b`.
+ */
+declare function aabbExpand(pool: AABBPool, a: number, b: number): void;
+/**
+ * Merge AABBs `a` and `b` into `dest` (a pre-allocated slot), storing their union.
+ */
+declare function aabbMerge(pool: AABBPool, dest: number, a: number, b: number): void;
+/**
+ * Test whether two AABBs (by index in the same pool) intersect.
+ */
+declare function aabbIntersects(pool: AABBPool, a: number, b: number): boolean;
+
+/**
+ * Ray stored as origin + direction (unit vector).
+ * Layout: [ox, oy, oz, dx, dy, dz]
+ */
+declare const RAY_STRIDE = 6;
+/** A pool-backed, zero-GC Ray store.
+ *
+ * When a `SharedArrayBuffer` is provided, the pool's data is accessible from
+ * multiple threads (e.g. a Web Worker) with no copying.
+ */
+declare class RayPool {
+    private readonly buffer;
+    private count;
+    constructor(capacity: number, sharedBuffer?: SharedArrayBuffer);
+    /**
+     * Create a RayPool backed by a new `SharedArrayBuffer`.
+     * Both the pool and the underlying `SharedArrayBuffer` are returned so the
+     * caller can transfer the buffer to a `Worker` via `postMessage`.
+     */
+    static createShared(capacity: number): {
+        pool: RayPool;
+        sab: SharedArrayBuffer;
+    };
+    /** Allocate a new Ray slot and return its index. */
+    allocate(): number;
+    /** Set origin and direction of a ray at the given index. */
+    set(index: number, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number): void;
+    /** Read a single component value from the buffer. */
+    get(index: number, component: number): number;
+    /** Returns the number of allocated Rays. */
+    get size(): number;
+    /** Reset the pool (all allocations freed, no GC). */
+    reset(): void;
+}
+/**
+ * Optimized branchless slab-method ray–AABB intersection test.
+ *
+ * Operates purely on flat Float32Arrays with no per-axis direction branches.
+ * When a direction component is zero, IEEE 754 produces ±Infinity for the
+ * reciprocal, which propagates correctly through the min/max slab computation:
+ *   - origin inside the slab  → [−∞, +∞] interval (no constraint)
+ *   - origin outside the slab → either [+∞, +∞] or [−∞, −∞] → forces a miss
+ *
+ * Returns the parametric hit distance `t` (>= 0) if the ray intersects the
+ * AABB, or -1 if there is no intersection (miss or box entirely behind origin).
+ */
+declare function rayIntersectsAABB(rayBuf: Float32Array, rayOffset: number, aabbBuf: Float32Array, aabbOffset: number): number;
+
+/**
+ * A generic Object Pool that manages a fixed set of integer indices.
+ *
+ * Pre-allocates a free-list on construction so that acquire() and release()
+ * operate without any heap allocation.
+ */
+declare class ObjectPool {
+    private readonly freeList;
+    private top;
+    /** Total number of slots in the pool. */
+    readonly capacity: number;
+    constructor(capacity: number);
+    /** Number of indices currently available for acquisition. */
+    get available(): number;
+    /**
+     * Acquire a free index from the pool.
+     * Returns the index, or `null` when the pool is exhausted.
+     */
+    acquire(): number | null;
+    /**
+     * Release a previously acquired index back to the pool.
+     * Throws if the index is out of range or the pool is already full.
+     */
+    release(index: number): void;
+}
+
+/**
+ * Flat Array Math Utilities
+ *
+ * Zero-allocation Vec3 math that reads directly from a Float32Array
+ * given a start index, without creating any Vector3 objects.
+ *
+ * All index parameters (`i`, `j`, `outOffset`) are raw flat-array offsets.
+ */
+/**
+ * Compute the dot product of two Vec3s stored in `buf` at offsets `i` and `j`.
+ */
+declare function vec3Dot(buf: Float32Array, i: number, j: number): number;
+/**
+ * Compute the squared distance between two Vec3s stored in `buf` at offsets `i` and `j`.
+ */
+declare function vec3DistanceSq(buf: Float32Array, i: number, j: number): number;
+/**
+ * Compute the Euclidean distance between two Vec3s stored in `buf` at offsets `i` and `j`.
+ */
+declare function vec3Distance(buf: Float32Array, i: number, j: number): number;
+/**
+ * Compute the cross product of two Vec3s in `buf` at offsets `i` and `j`,
+ * and write the result into `out` starting at `outOffset`.
+ */
+declare function vec3Cross(out: Float32Array, outOffset: number, buf: Float32Array, i: number, j: number): void;
+
+/**
+ * Octree node stored as a flat Float32Array slice.
+ *
+ * Layout per node (NODE_STRIDE floats):
+ *   [0..5]  – AABB   (minX, minY, minZ, maxX, maxY, maxZ)
+ *   [6]     – firstChild index  (-1 = leaf / no children)
+ *   [7]     – parent index      (-1 = root)
+ *   [8]     – object count
+ *   [9..]   – object indices    (MAX_OBJECTS_PER_NODE slots)
+ */
+declare const NODE_AABB_OFFSET = 0;
+declare const NODE_FIRST_CHILD_OFFSET = 6;
+declare const NODE_PARENT_OFFSET = 7;
+declare const NODE_OBJECT_COUNT_OFFSET = 8;
+declare const NODE_OBJECTS_OFFSET = 9;
+declare const MAX_OBJECTS_PER_NODE = 8;
+declare const NODE_STRIDE: number;
+/**
+ * A pool-backed, zero-GC Octree node store.
+ * Each node occupies NODE_STRIDE floats in the underlying Float32Array buffer.
+ *
+ * When a `SharedArrayBuffer` is provided, the pool's data is accessible from
+ * multiple threads (e.g. a Web Worker) with no copying.
+ */
+declare class OctreeNodePool {
+    private readonly buffer;
+    private count;
+    constructor(capacity: number, sharedBuffer?: SharedArrayBuffer);
+    /**
+     * Create an OctreeNodePool backed by a new `SharedArrayBuffer`.
+     * Both the pool and the underlying `SharedArrayBuffer` are returned so the
+     * caller can transfer the buffer to a `Worker` via `postMessage`.
+     */
+    static createShared(capacity: number): {
+        pool: OctreeNodePool;
+        sab: SharedArrayBuffer;
+    };
+    /** Allocate a new node slot, initialise sentinel values, and return its index. */
+    allocate(): number;
+    /** Returns the number of allocated nodes. */
+    get size(): number;
+    /** Reset the pool (all allocations freed, no GC). */
+    reset(): void;
+    /** Set the AABB bounds for the node at the given index. */
+    setAABB(index: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+    /** Read a single AABB component (0–5) from the node at the given index. */
+    getAABB(index: number, component: number): number;
+    /** Set the first-child index for the node (-1 = leaf). */
+    setFirstChild(index: number, childIndex: number): void;
+    /** Get the first-child index for the node (-1 = leaf). */
+    getFirstChild(index: number): number;
+    /** Set the parent index for the node (-1 = root). */
+    setParent(index: number, parentIndex: number): void;
+    /** Get the parent index for the node (-1 = root). */
+    getParent(index: number): number;
+    /** Return the number of objects stored in the node at the given index. */
+    getObjectCount(index: number): number;
+    /**
+     * Append an object index to the node's object list.
+     * Throws a RangeError when MAX_OBJECTS_PER_NODE is exceeded.
+     */
+    addObject(index: number, objectIndex: number): void;
+    /** Return the object index stored at slot `slot` in the given node. */
+    getObject(index: number, slot: number): number;
+    /** Reset the object count of the given node to zero (does not zero the slots). */
+    clearObjects(index: number): void;
+    /**
+     * Remove a single object index from the node's object list.
+     * Uses swap-with-last to avoid shifting. Returns true if found and removed.
+     */
+    removeObject(index: number, objectIndex: number): boolean;
+}
+
+/**
+ * Octree with insertion and automatic subdivision.
+ *
+ * - When a leaf node's object count reaches MAX_OBJECTS_PER_NODE it is
+ *   subdivided into 8 axis-aligned child octants.
+ * - An inserted AABB that fits entirely within a child octant is pushed down.
+ * - An AABB that straddles a boundary is kept in the nearest ancestor that
+ *   fully contains it.
+ */
+declare class Octree {
+    private readonly nodePool;
+    private readonly aabbPool;
+    private readonly root;
+    /** Tracks which node each object (by AABBPool index) is currently stored in. */
+    private readonly objectNodeMap;
+    /** Pre-allocated traversal stack reused across raycast calls to avoid GC pressure. */
+    private readonly _stack;
+    constructor(nodePool: OctreeNodePool, aabbPool: AABBPool);
+    /** The index of the root node in the underlying OctreeNodePool. */
+    get rootIndex(): number;
+    /** Set the world-space AABB that the root node covers. */
+    setBounds(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+    /** Insert the AABB at `objectIndex` (in the AABBPool) into the tree. */
+    insert(objectIndex: number): void;
+    /**
+     * Update the AABB at `objectIndex` with new bounds and reposition it in the
+     * tree without rebuilding. If the new bounds still fit in the current node
+     * the object stays there; otherwise it is removed and re-inserted from the
+     * lowest ancestor whose bounds fully contain the new AABB.
+     */
+    update(objectIndex: number, newMinX: number, newMinY: number, newMinZ: number, newMaxX: number, newMaxY: number, newMaxZ: number): void;
+    /**
+     * Cast a ray through the octree and return the closest intersecting object.
+     *
+     * Uses an iterative stack traversal (pre-allocated, no recursion) to avoid
+     * GC pressure. Only descends into child nodes whose AABBs are intersected by
+     * the ray, providing efficient pruning of non-intersecting subtrees.
+     *
+     * @param rayBuf   Float32Array containing the ray data [ox,oy,oz,dx,dy,dz].
+     * @param rayOffset Element offset (in floats) within `rayBuf` to the ray's origin.
+     * @returns The closest `{ objectIndex, t }` hit, or `null` if nothing is hit.
+     */
+    raycast(rayBuf: Float32Array, rayOffset: number): {
+        objectIndex: number;
+        t: number;
+    } | null;
+    /**
+     * Query the octree for all objects whose AABB overlaps the given axis-aligned
+     * box region and return their indices (in the AABBPool).
+     *
+     * Uses the same pre-allocated iterative stack as `raycast` to avoid GC
+     * pressure. Descends only into child nodes whose AABBs overlap the query box,
+     * pruning non-intersecting subtrees.
+     *
+     * @param minX  Minimum X of the query box.
+     * @param minY  Minimum Y of the query box.
+     * @param minZ  Minimum Z of the query box.
+     * @param maxX  Maximum X of the query box.
+     * @param maxY  Maximum Y of the query box.
+     * @param maxZ  Maximum Z of the query box.
+     * @returns Array of AABBPool indices for every object that overlaps the box.
+     */
+    queryBox(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): number[];
+    private insertIntoNode;
+    /** Split a leaf node into 8 children and redistribute its objects. */
+    private subdivide;
+    /** Returns true when the AABB at `objectIndex` is fully contained by `nodeIdx`. */
+    private fitsInNode;
+}
+
+export { AABBPool, AABB_STRIDE, MAX_OBJECTS_PER_NODE, NODE_AABB_OFFSET, NODE_FIRST_CHILD_OFFSET, NODE_OBJECTS_OFFSET, NODE_OBJECT_COUNT_OFFSET, NODE_PARENT_OFFSET, NODE_STRIDE, ObjectPool, Octree, OctreeNodePool, RAY_STRIDE, RayPool, aabbExpand, aabbIntersects, aabbMerge, rayIntersectsAABB, vec3Cross, vec3Distance, vec3DistanceSq, vec3Dot };

package/dist/index.js

@@ -0,0 +1,116 @@
+import {
+  AABBPool,
+  AABB_STRIDE,
+  MAX_OBJECTS_PER_NODE,
+  NODE_AABB_OFFSET,
+  NODE_FIRST_CHILD_OFFSET,
+  NODE_OBJECTS_OFFSET,
+  NODE_OBJECT_COUNT_OFFSET,
+  NODE_PARENT_OFFSET,
+  NODE_STRIDE,
+  Octree,
+  OctreeNodePool,
+  RAY_STRIDE,
+  RayPool,
+  aabbExpand,
+  aabbIntersects,
+  aabbMerge,
+  createLidarProcessor,
+  rayIntersectsAABB
+} from "./chunk-JF4RVZK3.js";
+
+// src/object-pool.ts
+var ObjectPool = class {
+  freeList;
+  top;
+  /** Total number of slots in the pool. */
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.freeList = new Int32Array(capacity);
+    for (let i = 0; i < capacity; i++) {
+      this.freeList[i] = capacity - 1 - i;
+    }
+    this.top = capacity;
+  }
+  /** Number of indices currently available for acquisition. */
+  get available() {
+    return this.top;
+  }
+  /**
+   * Acquire a free index from the pool.
+   * Returns the index, or `null` when the pool is exhausted.
+   */
+  acquire() {
+    if (this.top === 0) {
+      return null;
+    }
+    this.top -= 1;
+    return this.freeList[this.top];
+  }
+  /**
+   * Release a previously acquired index back to the pool.
+   * Throws if the index is out of range or the pool is already full.
+   */
+  release(index) {
+    if (index < 0 || index >= this.capacity) {
+      throw new RangeError(`ObjectPool.release: index ${index} is out of range [0, ${this.capacity})`);
+    }
+    if (this.top >= this.capacity) {
+      throw new RangeError("ObjectPool.release: pool is already at full capacity");
+    }
+    this.freeList[this.top] = index;
+    this.top += 1;
+  }
+};
+
+// src/flat-math.ts
+function vec3Dot(buf, i, j) {
+  return (buf[i] ?? 0) * (buf[j] ?? 0) + (buf[i + 1] ?? 0) * (buf[j + 1] ?? 0) + (buf[i + 2] ?? 0) * (buf[j + 2] ?? 0);
+}
+function vec3DistanceSq(buf, i, j) {
+  const dx = (buf[i] ?? 0) - (buf[j] ?? 0);
+  const dy = (buf[i + 1] ?? 0) - (buf[j + 1] ?? 0);
+  const dz = (buf[i + 2] ?? 0) - (buf[j + 2] ?? 0);
+  return dx * dx + dy * dy + dz * dz;
+}
+function vec3Distance(buf, i, j) {
+  return Math.sqrt(vec3DistanceSq(buf, i, j));
+}
+function vec3Cross(out, outOffset, buf, i, j) {
+  const ax = buf[i] ?? 0;
+  const ay = buf[i + 1] ?? 0;
+  const az = buf[i + 2] ?? 0;
+  const bx = buf[j] ?? 0;
+  const by = buf[j + 1] ?? 0;
+  const bz = buf[j + 2] ?? 0;
+  out[outOffset] = ay * bz - az * by;
+  out[outOffset + 1] = az * bx - ax * bz;
+  out[outOffset + 2] = ax * by - ay * bx;
+}
+export {
+  AABBPool,
+  AABB_STRIDE,
+  MAX_OBJECTS_PER_NODE,
+  NODE_AABB_OFFSET,
+  NODE_FIRST_CHILD_OFFSET,
+  NODE_OBJECTS_OFFSET,
+  NODE_OBJECT_COUNT_OFFSET,
+  NODE_PARENT_OFFSET,
+  NODE_STRIDE,
+  ObjectPool,
+  Octree,
+  OctreeNodePool,
+  RAY_STRIDE,
+  RayPool,
+  aabbExpand,
+  aabbIntersects,
+  aabbMerge,
+  createLidarProcessor,
+  rayIntersectsAABB,
+  vec3Cross,
+  vec3Distance,
+  vec3DistanceSq,
+  vec3Dot
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/object-pool.ts","../src/flat-math.ts"],"sourcesContent":["/**\n * A generic Object Pool that manages a fixed set of integer indices.\n *\n * Pre-allocates a free-list on construction so that acquire() and release()\n * operate without any heap allocation.\n */\nexport class ObjectPool {\n  private readonly freeList: Int32Array;\n  private top: number;\n\n  /** Total number of slots in the pool. */\n  readonly capacity: number;\n\n  constructor(capacity: number) {\n    this.capacity = capacity;\n    this.freeList = new Int32Array(capacity);\n    // Fill free-list in reverse so that the first acquire() returns index 0.\n    for (let i = 0; i < capacity; i++) {\n      this.freeList[i] = capacity - 1 - i;\n    }\n    this.top = capacity;\n  }\n\n  /** Number of indices currently available for acquisition. */\n  get available(): number {\n    return this.top;\n  }\n\n  /**\n   * Acquire a free index from the pool.\n   * Returns the index, or `null` when the pool is exhausted.\n   */\n  acquire(): number | null {\n    if (this.top === 0) {\n      return null;\n    }\n    this.top -= 1;\n    return this.freeList[this.top] as number;\n  }\n\n  /**\n   * Release a previously acquired index back to the pool.\n   * Throws if the index is out of range or the pool is already full.\n   */\n  release(index: number): void {\n    if (index < 0 || index >= this.capacity) {\n      throw new RangeError(`ObjectPool.release: index ${index} is out of range [0, ${this.capacity})`);\n    }\n    if (this.top >= this.capacity) {\n      throw new RangeError('ObjectPool.release: pool is already at full capacity');\n    }\n    this.freeList[this.top] = index;\n    this.top += 1;\n  }\n}\n","/**\n * Flat Array Math Utilities\n *\n * Zero-allocation Vec3 math that reads directly from a Float32Array\n * given a start index, without creating any Vector3 objects.\n *\n * All index parameters (`i`, `j`, `outOffset`) are raw flat-array offsets.\n */\n\n/**\n * Compute the dot product of two Vec3s stored in `buf` at offsets `i` and `j`.\n */\nexport function vec3Dot(buf: Float32Array, i: number, j: number): number {\n  return (buf[i] ?? 0) * (buf[j] ?? 0) +\n    (buf[i + 1] ?? 0) * (buf[j + 1] ?? 0) +\n    (buf[i + 2] ?? 0) * (buf[j + 2] ?? 0);\n}\n\n/**\n * Compute the squared distance between two Vec3s stored in `buf` at offsets `i` and `j`.\n */\nexport function vec3DistanceSq(buf: Float32Array, i: number, j: number): number {\n  const dx = (buf[i] ?? 0) - (buf[j] ?? 0);\n  const dy = (buf[i + 1] ?? 0) - (buf[j + 1] ?? 0);\n  const dz = (buf[i + 2] ?? 0) - (buf[j + 2] ?? 0);\n  return dx * dx + dy * dy + dz * dz;\n}\n\n/**\n * Compute the Euclidean distance between two Vec3s stored in `buf` at offsets `i` and `j`.\n */\nexport function vec3Distance(buf: Float32Array, i: number, j: number): number {\n  return Math.sqrt(vec3DistanceSq(buf, i, j));\n}\n\n/**\n * Compute the cross product of two Vec3s in `buf` at offsets `i` and `j`,\n * and write the result into `out` starting at `outOffset`.\n */\nexport function vec3Cross(\n  out: Float32Array,\n  outOffset: number,\n  buf: Float32Array,\n  i: number,\n  j: number,\n): void {\n  const ax = buf[i] ?? 0;\n  const ay = buf[i + 1] ?? 0;\n  const az = buf[i + 2] ?? 0;\n  const bx = buf[j] ?? 0;\n  const by = buf[j + 1] ?? 0;\n  const bz = buf[j + 2] ?? 0;\n  out[outOffset] = ay * bz - az * by;\n  out[outOffset + 1] = az * bx - ax * bz;\n  out[outOffset + 2] = ax * by - ay * bx;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAMO,IAAM,aAAN,MAAiB;AAAA,EACL;AAAA,EACT;AAAA;AAAA,EAGC;AAAA,EAET,YAAY,UAAkB;AAC5B,SAAK,WAAW;AAChB,SAAK,WAAW,IAAI,WAAW,QAAQ;AAEvC,aAAS,IAAI,GAAG,IAAI,UAAU,KAAK;AACjC,WAAK,SAAS,CAAC,IAAI,WAAW,IAAI;AAAA,IACpC;AACA,SAAK,MAAM;AAAA,EACb;AAAA;AAAA,EAGA,IAAI,YAAoB;AACtB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAyB;AACvB,QAAI,KAAK,QAAQ,GAAG;AAClB,aAAO;AAAA,IACT;AACA,SAAK,OAAO;AACZ,WAAO,KAAK,SAAS,KAAK,GAAG;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQ,OAAqB;AAC3B,QAAI,QAAQ,KAAK,SAAS,KAAK,UAAU;AACvC,YAAM,IAAI,WAAW,6BAA6B,KAAK,wBAAwB,KAAK,QAAQ,GAAG;AAAA,IACjG;AACA,QAAI,KAAK,OAAO,KAAK,UAAU;AAC7B,YAAM,IAAI,WAAW,sDAAsD;AAAA,IAC7E;AACA,SAAK,SAAS,KAAK,GAAG,IAAI;AAC1B,SAAK,OAAO;AAAA,EACd;AACF;;;AC1CO,SAAS,QAAQ,KAAmB,GAAW,GAAmB;AACvE,UAAQ,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,MAC/B,IAAI,IAAI,CAAC,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK,MAClC,IAAI,IAAI,CAAC,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK;AACvC;AAKO,SAAS,eAAe,KAAmB,GAAW,GAAmB;AAC9E,QAAM,MAAM,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK;AACtC,QAAM,MAAM,IAAI,IAAI,CAAC,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK;AAC9C,QAAM,MAAM,IAAI,IAAI,CAAC,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK;AAC9C,SAAO,KAAK,KAAK,KAAK,KAAK,KAAK;AAClC;AAKO,SAAS,aAAa,KAAmB,GAAW,GAAmB;AAC5E,SAAO,KAAK,KAAK,eAAe,KAAK,GAAG,CAAC,CAAC;AAC5C;AAMO,SAAS,UACd,KACA,WACA,KACA,GACA,GACM;AACN,QAAM,KAAK,IAAI,CAAC,KAAK;AACrB,QAAM,KAAK,IAAI,IAAI,CAAC,KAAK;AACzB,QAAM,KAAK,IAAI,IAAI,CAAC,KAAK;AACzB,QAAM,KAAK,IAAI,CAAC,KAAK;AACrB,QAAM,KAAK,IAAI,IAAI,CAAC,KAAK;AACzB,QAAM,KAAK,IAAI,IAAI,CAAC,KAAK;AACzB,MAAI,SAAS,IAAI,KAAK,KAAK,KAAK;AAChC,MAAI,YAAY,CAAC,IAAI,KAAK,KAAK,KAAK;AACpC,MAAI,YAAY,CAAC,IAAI,KAAK,KAAK,KAAK;AACtC;","names":[]}