@weasel-js/core 0.5.0

package/dist/pointSnapToGrid-D7s7QmOF.d.ts

@@ -0,0 +1,185 @@
+import { R as ResizePose, b as RotatedPose, c as ResizeAnchor, B as BoundsConstraint, P as PointSnapBehavior, d as PointSnapFrame, M as ModifierState } from './types-BjUi2vA-.js';
+import { B as Bounds } from './fitViewToBounds-evGsnR8Q.js';
+import { D as DebugSink } from './types-BJ8_cyT7.js';
+
+/**
+ * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.
+ * The hook reads bounds via `getBounds`, runs anchor-relative math on those
+ * bounds, then asks `remapBounds` to project the result back into TPose.
+ *
+ * `remapBounds(pose, src, dst)` is a single operation that subsumes both
+ * "set my own AABB to dst" (single-leaf resize) and "scale me as a leaf
+ * inside parent's src→dst rect" (group resize) — they're the same affine
+ * map. For rect-shaped poses the default geometry interprets the pose as
+ * its own bounds; for Path or polygon poses the consumer supplies a
+ * projection that knows how to read and rewrite the underlying geometry.
+ */
+interface PoseProjection<TPose> {
+    getBounds(pose: TPose): ResizePose;
+    remapBounds(pose: TPose, src: ResizePose, dst: ResizePose): TPose;
+    /** Translate the pose by (dx, dy). Optional — when omitted, callers fall
+     *  back to a translation derived from `remapBounds` (origin shifted, no
+     *  scale). Path-shaped poses should provide this for performance. */
+    translate?(pose: TPose, dx: number, dy: number): TPose;
+    /** True iff any portion of the pose's geometry intersects `rect`. Optional
+     *  — when omitted, area-select and similar callers test against `getBounds`
+     *  AABB (looser, but correct for axis-aligned rect poses). */
+    intersectsRect?(pose: TPose, rect: ResizePose): boolean;
+    /** Interpolate between two poses. Optional — animation helpers fall back to
+     *  rect-shape lerp when omitted (which fails for non-rect poses). */
+    lerp?(a: TPose, b: TPose, t: number): TPose;
+    /** Read the pose's rotation in radians. Pivot is the AABB center
+     *  (`getBounds(pose)` center). Default 0 when omitted — descriptor
+     *  declares "this pose has no rotation." When supplied and non-zero,
+     *  `useResize` projects the drag delta into the leaf's local frame,
+     *  runs anchor math there, and translates the resulting pose so the
+     *  diagonally opposite world-space corner is pinned. */
+    getRotation?(pose: TPose): number;
+    /** True iff this pose shape can carry a rotation. Consulted by the
+     *  rotation affordance to decide whether to render the rotate cursor /
+     *  drag-band over a selection. When omitted, the kit assumes `true` for
+     *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`
+     *  fields (e.g. polygon Paths) should return `false` so the affordance
+     *  hides instead of exposing a non-functional rotate cursor. */
+    supportsRotation?(pose: TPose): boolean;
+}
+/** Identity geometry for `TPose extends ResizePose`. Treats the pose as its
+ *  own bounds and remaps via affine scale against `src`/`dst`. */
+declare const RECT_POSE_DESCRIPTOR: PoseProjection<ResizePose>;
+/** Identity geometry for `RotatedPose`. Inherits rect-shape projection
+ *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends ResizePose`
+ *  subtype lets the rect descriptor's methods apply directly; `remapBounds`
+ *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so
+ *  `useResize` knows to take the rotation-aware math path. */
+declare const ROTATED_POSE_DESCRIPTOR: PoseProjection<RotatedPose>;
+
+/** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */
+interface CornerHandle {
+    cx: number;
+    cy: number;
+    anchor: ResizeAnchor;
+}
+/** Which AABB edge a corner sits on, per axis. `'min'` = the x/y origin
+ *  edge; `'max'` = the origin + extent edge. */
+type CornerEdge = 'min' | 'max';
+/** One entry of the canonical 4-corner resize layout. The single source of
+ *  truth for "which corner maps to which anchor / handle-kind". */
+interface CornerAnchor {
+    /** Which x-edge the corner sits on (`'min'` = left, `'max'` = right). */
+    xEdge: CornerEdge;
+    /** Which y-edge the corner sits on (`'min'` = top, `'max'` = bottom). */
+    yEdge: CornerEdge;
+    /** Anchor that pins the diagonally-opposite (fixed) corner. Always the
+     *  axis-wise opposite of `{xEdge, yEdge}`. */
+    anchor: ResizeAnchor;
+    /** Affordance/handle discriminator string for this corner. */
+    kind: string;
+    /** Short positional tag (`'<xEdge>-<yEdge>'`), e.g. `'min-max'`. */
+    tag: string;
+}
+/**
+ * The single ordered corner→anchor table. Order is **load-bearing**: every
+ * consumer iterates it in this sequence (TL, TR, BL, BR) so positional
+ * meaning (the i-th handle / `kind` / `tag`) stays consistent across the
+ * resize-handle affordance, the affordance-hit classifier, and
+ * `cornerResizeHandles`. Each corner's `anchor` names the diagonally
+ * opposite corner, so dragging the corner scales the box from that fixed
+ * point.
+ */
+declare const CORNER_ANCHORS: readonly CornerAnchor[];
+/** Resolve a corner's world-space position for the given bounds. `xEdge`
+ *  `'max'` → `x + width`; `yEdge` `'max'` → `y + height`. */
+declare function cornerPoint(bounds: Bounds, entry: Pick<CornerAnchor, 'xEdge' | 'yEdge'>): {
+    x: number;
+    y: number;
+};
+/** Standard 4-corner resize-handle layout: each corner pins the opposite
+ *  corner via an anchor of `{x: 'min'|'max', y: 'min'|'max'}` so dragging it
+ *  scales the box from the fixed opposite corner. Decodes {@link CORNER_ANCHORS}
+ *  against `bounds`. */
+declare function cornerResizeHandles(bounds: Bounds): CornerHandle[];
+/** Square hit-test for a handle: returns true if `(px, py)` is within
+ *  `radius` of the handle center on both axes. */
+declare function hitCornerHandle(handle: CornerHandle, px: number, py: number, radius: number): boolean;
+/** The corner that does NOT move under a resize gesture with the given
+ *  anchor. Used by the rotated-resize math to pin a world-space invariant.
+ *
+ *  Convention: `anchor.x === 'min'` means the min-x (left) edge is the
+ *  fixed anchor, so the fixed corner sits at `x = bounds.x` (min-x).
+ *  `anchor.x === 'max'` means the max-x (right) edge is fixed, so the
+ *  fixed corner sits at `x = bounds.x + bounds.width`. `'free'` on an
+ *  axis means that axis doesn't move; the fixed coord is the bounds
+ *  origin on that axis. */
+declare function fixedCornerOf(bounds: Bounds, anchor: ResizeAnchor): {
+    x: number;
+    y: number;
+};
+
+/** Option surface for the `resize` action.
+ *
+ *  Lives in a sibling file (not `resize.ts`) so the type contract stays stable
+ *  even after the legacy `useResize` hook is gone.
+ *  Consumers should import from here directly; `resize.ts` re-exports the
+ *  same symbol for back-compat. */
+
+interface UseResizeOptions<TPose> {
+    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. When
+     *  `TPose` is non-rect, pass `geometry` to project pose↔bounds; behaviors
+     *  in that case are typed `never` because none in the kit's library would
+     *  understand the pose shape. */
+    behaviors?: TPose extends ResizePose ? BoundsConstraint<TPose>[] : never;
+    resizeLabel?: string;
+    /** Reserved; resize is never transient in practice. Ignored. */
+    transient?: boolean;
+    onGestureStart?: (id: string) => void;
+    onGestureEnd?: (committed: boolean) => void;
+    /** Optional: expand the incoming id into leaf ids before pose lookups.
+     *  Mirrors `useMove`'s `expandIds`. Used for group expansion: when the
+     *  gesture is started against a group id, the kit
+     *  resizes by computing the union AABB of the leaves' origin bounds,
+     *  running the compute pipeline on that union rect (group bounds), and
+     *  remapping each leaf via `geometry.remapBounds(leaf, originGroupBounds,
+     *  proposedGroupBounds)`.
+     *
+     *  When `expandIds` is omitted or returns the original single id, the
+     *  gesture takes the single-leaf path (the leaf's own bounds become both
+     *  the origin and the target of the same `remapBounds` call).
+     *
+     *  Called once at `start()`. Returning `[]` aborts the gesture cleanly. */
+    expandIds?: (ids: string[]) => string[];
+    /** Projection from `TPose` to bounds and back. Defaults to rect identity
+     *  when `TPose extends ResizePose`. Required for non-rect TPose (Path,
+     *  polygon, etc.). */
+    geometry?: PoseProjection<TPose>;
+    /** Behaviors that operate on world-space anchor points. Fire after
+     *  `behaviors[]` (bounds-frame). Each behavior receives a `PointSnapContext`
+     *  with world-space frame points and returns at most one `PointSnapResult`;
+     *  the hook back-solves the local pose so the chosen frame's world point
+     *  lands on the snap target. First non-null result wins. */
+    pointSnapBehaviors?: TPose extends ResizePose ? PointSnapBehavior<TPose>[] : never;
+    /** Optional debug sink. When supplied, records corner-handle positions +
+     *  circular hitboxes when the gesture starts (covers the on-screen
+     *  handles for the resized target). Tree-shakes via optional-chain
+     *  when omitted. */
+    debug?: DebugSink;
+    /** Hit-test radius for corner handles, in screen pixels. Used purely for
+     *  the recorded debug hitbox circle radius — does not affect actual hit
+     *  math (which lives in `usePointerGestures`). Default `8`. */
+    handleHitRadius?: number;
+    /** Per-node resizability predicate. Returns `false` for nodes that should
+     *  never show resize handles (and thus can't start a resize gesture) — e.g.
+     *  fixed-footprint icons, locked layers. `<SceneCanvas>` folds this over the
+     *  current selection into the `selectionResizable` rule-ctx flag, so the
+     *  default `selection.resize-handles` chrome rule hides handles whenever any
+     *  selected node is non-resizable (which also disables the affordance, since
+     *  visible==hittable). Default: every node resizable. */
+    resizable?: (id: string) => boolean;
+}
+
+declare function pointSnapToGrid<TPose extends ResizePose>(args: {
+    spacing: number;
+    frame?: PointSnapFrame;
+    bypassKey?: keyof ModifierState;
+}): PointSnapBehavior<TPose>;
+
+export { CORNER_ANCHORS as C, type PoseProjection as P, RECT_POSE_DESCRIPTOR as R, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, ROTATED_POSE_DESCRIPTOR as c, cornerPoint as d, cornerResizeHandles as e, fixedCornerOf as f, type CornerEdge as g, hitCornerHandle as h, pointSnapToGrid as p };

package/dist/registerFont-CP-wCsrz.d.ts

@@ -0,0 +1,109 @@
+import { M as Mat3 } from './DrawCommand-Dl0bXNfS.js';
+
+/**
+ * GL texture upload cache for ImageBitmap objects.
+ *
+ * Key: ImageBitmap (or pattern source object) identity (WeakMap) — lets GC
+ * reclaim unreferenced bitmaps. The GL textures are NOT freed when the source
+ * is gc'd; deferred to v2.
+ *
+ * Wrapping is set once at upload time per the `repetition` parameter:
+ *   - undefined / 'no-repeat' → CLAMP_TO_EDGE
+ *   - 'repeat'   → REPEAT (both axes)
+ *   - 'repeat-x' → REPEAT on S, CLAMP on T
+ *   - 'repeat-y' → CLAMP on S, REPEAT on T
+ *
+ * Convention §2: texels stored straight; shader premultiplies.
+ */
+type PatternRepetition = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+/** MIN_FILTER strategy for uploaded textures. */
+type ImageMinification = 'linear' | 'mipmap';
+type TexSource = ImageBitmap | ImageData | HTMLCanvasElement | HTMLImageElement;
+declare class GLImageCache {
+    private readonly gl;
+    private readonly minification;
+    private readonly map;
+    /** `minification` selects the MIN_FILTER strategy for uploaded textures.
+     *  `'linear'` (default) is the screen path's existing behavior. `'mipmap'`
+     *  generates mipmaps and filters LINEAR_MIPMAP_LINEAR — required for
+     *  quality minification when a large source bitmap is drawn small (the
+     *  headless print/export path); bilinear-only minification undersamples
+     *  and produces moiré. */
+    constructor(gl: WebGL2RenderingContext, minification?: ImageMinification);
+    upload(key: object, source: TexSource, repetition?: PatternRepetition): WebGLTexture;
+    bind(key: object, unit: number): void;
+}
+
+/**
+ * View → Mat3 helper for layer `draw` implementations on world-space layers.
+ *
+ * The kit's main package ships a `View` type at
+ * `src/core/viewport/view.ts`; we re-declare a structurally compatible
+ * shape here to avoid a runtime cross-package import. Exported as
+ * `ViewLike` from the package barrel.
+ */
+
+/** A weasel View — `{x, y, scale: {x, y}}`. Local type to avoid a cross-package import. */
+interface View {
+    x: number;
+    y: number;
+    scale: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Build the world→screen transform matrix for a `View`.
+ * Use as the `transform` field of a `kind: 'group'` DrawCommand to wrap
+ * world-space content emitted from a layer `draw` implementation.
+ *
+ * Mapping: `screen = (world − {view.x, view.y}) × {view.scale.x, view.scale.y}`.
+ *
+ * Column-major layout (matches `mat3.identity()`):
+ * `[scale.x, 0, 0,  0, scale.y, 0,  -view.x*scale.x, -view.y*scale.y, 1]`.
+ */
+declare function viewToMat3(view: View): Mat3;
+
+/**
+ * DynamicGlyphAtlas — runtime single-channel SDF glyphs for canvas-sourced
+ * (installed machine) fonts. TinySDF technique: canvas fillText at 48 px →
+ * Euclidean distance transform → shelf-packed R8 pages (1024², max 4).
+ *
+ * Baked MSDF atlases always win: this tier only serves families registered
+ * via `registerCanvasFont` that have no baked entry (see resolveFontVariant).
+ *
+ * Faces expose a BmFont-shaped `font` whose charMap grows as glyphs are
+ * requested, so `layoutRuns` consumes them through the same code path as
+ * baked atlases. A char's advance is valid immediately (measureText); its
+ * atlas rect fills in when the bake lands (width 0 / page -1 until then, so
+ * layout advances the pen but emits no quad).
+ */
+
+/** Mark `family` as canvas-sourced: when no baked atlas covers it,
+ *  resolveFontVariant serves it from this dynamic atlas. */
+declare function registerCanvasFont(family: string): void;
+declare function isCanvasFont(family: string): boolean;
+/** Remove a canvas family. Its faces are dropped; already-baked glyph
+ *  pixels stay in their pages (no eviction in v1). */
+declare function unregisterCanvasFont(family: string): void;
+/** Subscribe to deferred-bake completion (fires after each flush batch).
+ *  `<SceneCanvas>` subscribes and requests a redraw, mirroring
+ *  `subscribeImageReady`. Returns an unsubscribe. */
+declare function subscribeGlyphReady(cb: () => void): () => void;
+
+/**
+ * FontRegistry and registerFont() public API.
+ *
+ * Variants are keyed by (family, weight, style). registerFont() takes a
+ * FontVariant alongside the family and the two URLs; the registry stores
+ * entries in a two-level Map so resolveFontVariant() can iterate a family's
+ * variants for the fallback chain.
+ */
+
+interface FontVariant {
+    weight?: number;
+    style?: 'normal' | 'italic';
+}
+declare function registerFont(family: string, variant: FontVariant, metricsUrl: string, atlasUrl: string): Promise<void>;
+
+export { type FontVariant as F, GLImageCache as G, type ImageMinification as I, type View as V, registerFont as a, isCanvasFont as i, registerCanvasFont as r, subscribeGlyphReady as s, unregisterCanvasFont as u, viewToMat3 as v };

package/dist/registerTexture-BzHTLhD9.d.ts

@@ -0,0 +1,25 @@
+/**
+ * registerTexture — accepts an image source, assigns an opaque id, stores in
+ * a module-level registry. Actual GL upload happens lazily at draw time in
+ * drawShader() via GLTextureCache.upload (which is idempotent).
+ *
+ * Lifecycle: textures live for the renderer's lifetime. No unregister in v1.
+ *
+ * Convention §9: this registry stores image data only — no per-renderer state.
+ * Each WeaselRenderer's GLTextureCache does its own dedup via has(id).
+ */
+interface TextureHandle {
+    readonly id: string;
+}
+/**
+ * Register an image for use as a shader texture uniform.
+ *
+ * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.
+ * The handle is valid for the lifetime of the renderer it will be used with.
+ *
+ * @param image  The image to register. HTMLImageElement must be fully loaded.
+ * @returns      Opaque TextureHandle.
+ */
+declare function registerTexture(image: HTMLImageElement | ImageBitmap): TextureHandle;
+
+export { type TextureHandle as T, registerTexture as r };

package/dist/renderer.css

@@ -0,0 +1,121 @@
+/* src/tools/routing/reflection/ToolDebugOverlay.module.css */
+.overlay {
+  position: absolute;
+  bottom: 12px;
+  right: 12px;
+  min-width: 180px;
+  padding: 8px 10px;
+  background: rgba(20, 20, 24, 0.86);
+  color: #eaeaea;
+  font:
+    11px/1.4 ui-monospace,
+    "SF Mono",
+    Menlo,
+    monospace;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  border-radius: 4px;
+  pointer-events: none;
+  user-select: none;
+}
+.row {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+}
+.label {
+  color: #888;
+}
+.value {
+  color: #f5f5f5;
+}
+.empty {
+  color: #888;
+  font-style: italic;
+}
+
+/* src/canvas/PickHud.module.css */
+.hud {
+  position: fixed;
+  z-index: 10000;
+  background: rgba(0, 0, 0, 0.7);
+  color: #e8e8e8;
+  font:
+    11px ui-monospace,
+    SFMono-Regular,
+    Menlo,
+    monospace;
+  padding: 6px 8px;
+  border-radius: 4px;
+  pointer-events: none;
+  line-height: 1.4;
+  text-align: right;
+  min-width: 120px;
+  max-width: 260px;
+}
+.header {
+  color: #888;
+  margin-bottom: 2px;
+}
+.empty {
+  color: #888;
+  font-style: italic;
+}
+.list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+.item {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.itemBest {
+  font-weight: 700;
+}
+
+/* src/canvas/ModalityHud.module.css */
+.hud {
+  position: fixed;
+  z-index: 10000;
+  background: rgba(0, 0, 0, 0.7);
+  color: #e8e8e8;
+  font:
+    11px ui-monospace,
+    SFMono-Regular,
+    Menlo,
+    monospace;
+  padding: 6px 8px;
+  border-radius: 4px;
+  pointer-events: none;
+  line-height: 1.4;
+  text-align: right;
+  min-width: 120px;
+  max-width: 260px;
+}
+.row {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+  white-space: nowrap;
+}
+.label {
+  color: #888;
+}
+.value {
+  color: #e8e8e8;
+}
+.valueMuted {
+  color: #888;
+  font-style: italic;
+}
+.stack {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  align-items: flex-end;
+}
+/*# sourceMappingURL=renderer.css.map */

package/dist/renderer.css.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tools/routing/reflection/ToolDebugOverlay.module.css","../src/canvas/PickHud.module.css","../src/canvas/ModalityHud.module.css"],"sourcesContent":["/* src/tools/routing/reflection/ToolDebugOverlay.module.css */\n.overlay {\n  position: absolute;\n  bottom: 12px;\n  right: 12px;\n  min-width: 180px;\n  padding: 8px 10px;\n  background: rgba(20, 20, 24, 0.86);\n  color: #eaeaea;\n  font: 11px/1.4 ui-monospace, \"SF Mono\", Menlo, monospace;\n  border: 1px solid rgba(255, 255, 255, 0.1);\n  border-radius: 4px;\n  pointer-events: none;\n  user-select: none;\n}\n\n.row {\n  display: flex;\n  justify-content: space-between;\n  gap: 12px;\n}\n\n.label {\n  color: #888;\n}\n\n.value {\n  color: #f5f5f5;\n}\n\n.empty {\n  color: #888;\n  font-style: italic;\n}\n",".hud {\n  position: fixed;\n  z-index: 10000;\n  background: rgba(0, 0, 0, 0.7);\n  color: #e8e8e8;\n  font: 11px ui-monospace, SFMono-Regular, Menlo, monospace;\n  padding: 6px 8px;\n  border-radius: 4px;\n  pointer-events: none;\n  line-height: 1.4;\n  text-align: right;\n  min-width: 120px;\n  max-width: 260px;\n}\n\n.header {\n  color: #888;\n  margin-bottom: 2px;\n}\n\n.empty {\n  color: #888;\n  font-style: italic;\n}\n\n.list {\n  list-style: none;\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex-direction: column;\n  gap: 1px;\n}\n\n.item {\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n}\n\n.itemBest {\n  font-weight: 700;\n}\n",".hud {\n  position: fixed;\n  z-index: 10000;\n  background: rgba(0, 0, 0, 0.7);\n  color: #e8e8e8;\n  font: 11px ui-monospace, SFMono-Regular, Menlo, monospace;\n  padding: 6px 8px;\n  border-radius: 4px;\n  pointer-events: none;\n  line-height: 1.4;\n  text-align: right;\n  min-width: 120px;\n  max-width: 260px;\n}\n\n.row {\n  display: flex;\n  gap: 8px;\n  justify-content: flex-end;\n  white-space: nowrap;\n}\n\n.label {\n  color: #888;\n}\n\n.value {\n  color: #e8e8e8;\n}\n\n.valueMuted {\n  color: #888;\n  font-style: italic;\n}\n\n.stack {\n  display: flex;\n  flex-direction: column;\n  gap: 0;\n  align-items: flex-end;\n}\n"],"mappings":";AACA,CAAC;AACC,YAAU;AACV,UAAQ;AACR,SAAO;AACP,aAAW;AACX,WAAS,IAAI;AACb,cAAY,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;AAC7B,SAAO;AACP;AAAA,IAAM,IAAI,CAAC,IAAI,YAAY;AAAA,IAAE,SAAS;AAAA,IAAE,KAAK;AAAA,IAAE;AAC/C,UAAQ,IAAI,MAAM,KAAK,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;AACtC,iBAAe;AACf,kBAAgB;AAChB,eAAa;AACf;AAEA,CAAC;AACC,WAAS;AACT,mBAAiB;AACjB,OAAK;AACP;AAEA,CAAC;AACC,SAAO;AACT;AAEA,CAAC;AACC,SAAO;AACT;AAEA,CAAC;AACC,SAAO;AACP,cAAY;AACd;;;ACjCA,CAAC;AACC,YAAU;AACV,WAAS;AACT,cAAY,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;AAC1B,SAAO;AACP;AAAA,IAAM,KAAK,YAAY;AAAA,IAAE,cAAc;AAAA,IAAE,KAAK;AAAA,IAAE;AAChD,WAAS,IAAI;AACb,iBAAe;AACf,kBAAgB;AAChB,eAAa;AACb,cAAY;AACZ,aAAW;AACX,aAAW;AACb;AAEA,CAAC;AACC,SAAO;AACP,iBAAe;AACjB;AAEA,CAAC;AACC,SAAO;AACP,cAAY;AACd;AAEA,CAAC;AACC,cAAY;AACZ,UAAQ;AACR,WAAS;AACT,WAAS;AACT,kBAAgB;AAChB,OAAK;AACP;AAEA,CAAC;AACC,eAAa;AACb,YAAU;AACV,iBAAe;AACjB;AAEA,CAAC;AACC,eAAa;AACf;;;AC1CA,CAAC;AACC,YAAU;AACV,WAAS;AACT,cAAY,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;AAC1B,SAAO;AACP;AAAA,IAAM,KAAK,YAAY;AAAA,IAAE,cAAc;AAAA,IAAE,KAAK;AAAA,IAAE;AAChD,WAAS,IAAI;AACb,iBAAe;AACf,kBAAgB;AAChB,eAAa;AACb,cAAY;AACZ,aAAW;AACX,aAAW;AACb;AAEA,CAAC;AACC,WAAS;AACT,OAAK;AACL,mBAAiB;AACjB,eAAa;AACf;AAEA,CAAC;AACC,SAAO;AACT;AAEA,CAAC;AACC,SAAO;AACT;AAEA,CAAC;AACC,SAAO;AACP,cAAY;AACd;AAEA,CAAC;AACC,WAAS;AACT,kBAAgB;AAChB,OAAK;AACL,eAAa;AACf;","names":[]}