@woosh/meep-engine 3.60.0 → 3.60.2

package/src/view/elements/progress/segmented/GhostTrail.js

@@ -1,98 +1,294 @@
-import { smoothStep } from "../../../../core/math/smoothStep.js";
-
-/**
- * A value that trails another one down: the "ghost" behind a bar's fill that shows how much was just lost.
- *
- * When the target drops, the trail holds where it was for {@link delay_ms}, then eases down to the target over
- * {@link duration_ms}. A further drop while it holds or eases restarts the hold from wherever the trail is. When
- * the target rises above the trail, the trail jumps to it at once.
- *
- * Time is passed in, in milliseconds on any monotonic clock, so the trail can be driven and checked without one.
- */
-export class GhostTrail {
-    /**
-     * How long the trail holds after a drop before it starts to move
-     * @type {number}
-     */
-    delay_ms = 450;
-
-    /**
-     * How long the ease from the held value down to the target takes; 0 snaps once the hold ends
-     * @type {number}
-     */
-    duration_ms = 350;
-
-    /**
-     * @type {number}
-     * @private
-     */
-    __from = 0;
-
-    /**
-     * @type {number}
-     * @private
-     */
-    __to = 0;
-
-    /**
-     * When the current hold began
-     * @type {number}
-     * @private
-     */
-    __drop_time = 0;
-
-    /**
-     * Tell the trail its target's new value.
-     * @param {number} target
-     * @param {number} time_ms
-     */
-    set(target, time_ms) {
-        const current = this.sample(time_ms);
-
-        if (target >= current) {
-            this.__from = target;
-            this.__to = target;
-        } else {
-            this.__from = current;
-            this.__to = target;
-            this.__drop_time = time_ms;
-        }
-    }
-
-    /**
-     * Where the trail is at a given time; never below its target.
-     * @param {number} time_ms
-     * @returns {number}
-     */
-    sample(time_ms) {
-        const from = this.__from;
-        const to = this.__to;
-
-        if (from === to) {
-            return to;
-        }
-
-        const start = this.__drop_time + this.delay_ms;
-
-        if (time_ms < start) {
-            return from;
-        }
-
-        const end = start + this.duration_ms;
-
-        if (time_ms >= end) {
-            return to;
-        }
-
-        return from + (to - from) * smoothStep(start, end, time_ms);
-    }
-
-    /**
-     * Whether the trail has reached its target and will not move until {@link set} is called again
-     * @param {number} time_ms
-     * @returns {boolean}
-     */
-    is_settled(time_ms) {
-        return this.__from === this.__to || time_ms >= this.__drop_time + this.delay_ms + this.duration_ms;
-    }
-}
+import { assert } from "../../../../core/assert.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+
+/**
+ * Floats per loss in {@link GhostTrail}'s store: [start, duration, low, amplitude]. A loss's trail is
+ * `low + amplitude * u²`, where u runs from 1 (held, and at the start of the ease) to 0 (the ease is over).
+ * @type {number}
+ */
+const LOSS_STRIDE = 4;
+
+/**
+ * A value that trails another one down: the "ghost" behind a bar's fill that shows how much was just lost.
+ *
+ * The knobs are the three Dota 2 exposes for its hero bars as console variables: a short hold after a drop
+ * (`dota_health_hurt_delay`) and a decay whose length sits between a floor and a ceiling
+ * (`dota_health_hurt_decay_time_min` / `_max`). The defaults, 0.1 s / 0.3 s / 0.8 s, are the values players'
+ * published configs list as Dota's own; Valve does not document them. Everything else here is this class's own
+ * choice, not known Dota behaviour: the decay's length growing linearly with the loss (the whole bar takes the
+ * ceiling), the ease-out curve, and how losses that overlap combine.
+ *
+ * Every drop is a loss with a trail of its own: it holds at the value from before the drop for {@link delay_ms},
+ * then eases down over a length sized by that loss alone. The trail shows the highest of the live losses' trails,
+ * and never less than the target. Because no loss looks at another, a drop is drawn the same whether the trail
+ * was at rest or still moving when it came: a damage tick that lands just before or just after the previous one
+ * has faded looks the same, where a single trail that re-plans has to pick one side of that line.
+ *
+ * Each loss eases toward the lowest the target has been since it happened, never toward the target itself, so a
+ * rise that stays under the trail (regeneration after a hit) cannot lift it. When a later drop lowers that floor,
+ * the rest of the loss's ease is rescaled toward the new floor from where it is, so it does not jump. The trail
+ * is continuous in time and never rises unless the target rises above it; when it does, the trail jumps to the
+ * target and every loss is forgotten.
+ *
+ * A target that is not a finite number is ignored: the trail carries on with what it had, so one bad value cannot
+ * leave it NaN, and its owner animating it forever, for every value after.
+ *
+ * Each loss's start and length are fixed when it happens, so changing the knobs never revives or reshapes a trail
+ * already under way.
+ *
+ * Time is passed in, in milliseconds on any monotonic clock, so the trail can be driven and checked without one.
+ */
+export class GhostTrail {
+    /**
+     * How long a loss's trail holds before it starts to ease down
+     * @type {number}
+     */
+    delay_ms = 100;
+
+    /**
+     * Length of the ease for the smallest loss; 0 with {@link duration_max_ms} 0 snaps once the hold ends
+     * @type {number}
+     */
+    duration_min_ms = 300;
+
+    /**
+     * Length of the ease for a loss of the whole bar (1); smaller losses take proportionally less, down to
+     * {@link duration_min_ms}
+     * @type {number}
+     */
+    duration_max_ms = 800;
+
+    /**
+     * The target, as last set
+     * @type {number}
+     * @private
+     */
+    __to = 0;
+
+    /**
+     * Live losses, {@link LOSS_STRIDE} floats each: when the ease starts (after the hold), the ease's length, the
+     * lowest the target has been since the loss, and how far above that the trail is while u is 1
+     * @type {Float64Array}
+     * @private
+     */
+    __losses = new Float64Array(LOSS_STRIDE * 8);
+
+    /**
+     * @type {number}
+     * @private
+     */
+    __loss_count = 0;
+
+    /**
+     * Length of the ease for a loss of `gap`, a fraction of the bar
+     * @param {number} gap
+     * @returns {number}
+     * @private
+     */
+    __duration_for(gap) {
+        const min = this.duration_min_ms;
+
+        return min + (this.duration_max_ms - min) * clamp01(gap);
+    }
+
+    /**
+     * How much of one loss's ease is left at `time_ms`: 1 while it holds, falling to 0 when the ease is over
+     * @param {number} index
+     * @param {number} time_ms
+     * @returns {number}
+     * @private
+     */
+    __loss_u(index, time_ms) {
+        const losses = this.__losses;
+        const offset = index * LOSS_STRIDE;
+
+        const elapsed = time_ms - losses[offset];
+        const duration = losses[offset + 1];
+
+        if (elapsed < 0) {
+            return 1;
+        }
+
+        if (elapsed >= duration) {
+            return 0;
+        }
+
+        return 1 - elapsed / duration;
+    }
+
+    /**
+     * Where one loss's trail is at `time_ms`; an ease-out, fastest at the start of the ease
+     * @param {number} index
+     * @param {number} time_ms
+     * @returns {number}
+     * @private
+     */
+    __loss_at(index, time_ms) {
+        const offset = index * LOSS_STRIDE;
+        const u = this.__loss_u(index, time_ms);
+
+        return this.__losses[offset + 2] + this.__losses[offset + 3] * u * u;
+    }
+
+    /**
+     * @param {number} start
+     * @param {number} duration
+     * @param {number} low
+     * @param {number} amplitude
+     * @private
+     */
+    __add_loss(start, duration, low, amplitude) {
+        const count = this.__loss_count;
+
+        if ((count + 1) * LOSS_STRIDE > this.__losses.length) {
+            const grown = new Float64Array(this.__losses.length * 2);
+
+            grown.set(this.__losses);
+
+            this.__losses = grown;
+        }
+
+        const losses = this.__losses;
+        const offset = count * LOSS_STRIDE;
+
+        losses[offset] = start;
+        losses[offset + 1] = duration;
+        losses[offset + 2] = low;
+        losses[offset + 3] = amplitude;
+
+        this.__loss_count = count + 1;
+    }
+
+    /**
+     * Tell the trail its target's new value.
+     * @param {number} target
+     * @param {number} time_ms
+     */
+    set(target, time_ms) {
+        // the knobs are public and may change between calls, so they are checked where they are read
+        assert.isFinite(this.delay_ms, 'delay_ms');
+        assert.greaterThanOrEqual(this.delay_ms, 0, 'delay_ms must not be negative');
+        assert.isFinite(this.duration_max_ms, 'duration_max_ms');
+        assert.greaterThanOrEqual(this.duration_min_ms, 0, 'duration_min_ms must not be negative');
+        assert.greaterThanOrEqual(this.duration_max_ms, this.duration_min_ms, 'duration_max_ms must not be under duration_min_ms');
+        assert.isFinite(time_ms, 'time_ms');
+
+        if (!Number.isFinite(target)) {
+            return;
+        }
+
+        if (target >= this.sample(time_ms)) {
+            // a rise to or above the trail: jump to it, and forget every loss
+            this.__to = target;
+            this.__loss_count = 0;
+
+            return;
+        }
+
+        // drop the losses whose ease is over (each rests at its low, which is never above the target); for the rest,
+        // if the target went under the low, lower it and rescale what is left of the ease so the trail is where it was
+        const losses = this.__losses;
+        const count = this.__loss_count;
+
+        let kept = 0;
+
+        for (let i = 0; i < count; i++) {
+            const offset = i * LOSS_STRIDE;
+
+            const u = this.__loss_u(i, time_ms);
+
+            if (u <= 0) {
+                continue;
+            }
+
+            let low = losses[offset + 2];
+            let amplitude = losses[offset + 3];
+
+            if (target < low) {
+                // where the trail is now, kept: low + amplitude * u² before and after. u > 0 here, and the
+                // product amplitude * u² stays at most the trail's height over the new low however small u is
+                const value = low + amplitude * u * u;
+
+                low = target;
+                amplitude = (value - low) / (u * u);
+            }
+
+            const kept_offset = kept * LOSS_STRIDE;
+
+            losses[kept_offset] = losses[offset];
+            losses[kept_offset + 1] = losses[offset + 1];
+            losses[kept_offset + 2] = low;
+            losses[kept_offset + 3] = amplitude;
+
+            kept++;
+        }
+
+        this.__loss_count = kept;
+
+        const before = this.__to;
+
+        if (target < before) {
+            this.__add_loss(time_ms + this.delay_ms, this.__duration_for(before - target), target, before - target);
+        }
+
+        this.__to = target;
+    }
+
+    /**
+     * Stand the trail at `target` with nothing lost: every loss forgotten, whatever was showing. For a target that
+     * moved without anything being lost, such as the same amount out of a raised maximum.
+     * @param {number} target
+     */
+    reset(target) {
+        if (!Number.isFinite(target)) {
+            return;
+        }
+
+        this.__to = target;
+        this.__loss_count = 0;
+    }
+
+    /**
+     * Where the trail is at a given time: the highest of the live losses' trails, and never below the target.
+     * @param {number} time_ms
+     * @returns {number}
+     */
+    sample(time_ms) {
+        let value = this.__to;
+
+        const count = this.__loss_count;
+
+        for (let i = 0; i < count; i++) {
+            const v = this.__loss_at(i, time_ms);
+
+            if (v > value) {
+                value = v;
+            }
+        }
+
+        return value;
+    }
+
+    /**
+     * Whether the trail shows the target and will not move until {@link set} is called again
+     * @param {number} time_ms
+     * @returns {boolean}
+     */
+    is_settled(time_ms) {
+        const to = this.__to;
+        const losses = this.__losses;
+        const count = this.__loss_count;
+
+        for (let i = 0; i < count; i++) {
+            const offset = i * LOSS_STRIDE;
+
+            // a loss still easing and still above the target; one at or under it stays there, since its trail
+            // only falls and the target holds until the next set
+            if (time_ms < losses[offset] + losses[offset + 1] && this.__loss_at(i, time_ms) > to) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

package/src/view/elements/progress/segmented/SegmentedResourceBarView.d.ts

@@ -3,11 +3,18 @@
  * a ghost behind the fill trails a drop so the loss stays readable for a moment.
  *
  * Two modes:
- * - notches (default): a continuous fill, with a notch at every multiple of each {@link SegmentTier}'s unit;
- * - cells (`cells` given): `count` separate cells with exact, identical gaps, for counting rounds and the like.
+ * - notches (default): a continuous fill, with a notch at every multiple of each {@link SegmentTier}'s unit. Each
+ *   tier is one layer the width of the bar (`.notch.<class_name>`), which CSS paints — colour, height — and a mask
+ *   cuts to that tier's notches;
+ * - cells (`cells` given): `count` separate cells with exact, identical gaps, for counting rounds and the like. One
+ *   strip (`.cell-strip`, the empty cells' colour) holding a `.cell-ghost` and a `.cell-fill`, cut into cells by a
+ *   mask; the fill and ghost end on a cell's edge, or part way across one that is filling.
  *
- * Notches and cells sit on whole device pixels at any pixel ratio and under a CSS scale. Colours, notch heights
- * and the ghost are styled by `segmented-resource-bar.css` through `--segmented-bar-*` custom properties.
+ * The masks are drawn in whole device pixels and the layers they cut placed so those pixels land on the screen's,
+ * at any pixel ratio and under a CSS scale: every notch of a tier is the same width and every gap the same, at
+ * 125% as at 100%. Colours, notch heights and the ghost are styled by `segmented-resource-bar.css` through
+ * `--segmented-bar-*` custom properties. Where masks cannot be drawn (no canvas, as under jsdom) the layers are
+ * placed but uncut.
  */
 export class SegmentedResourceBarView extends View {
     /**
@@ -18,10 +25,12 @@ export class SegmentedResourceBarView extends View {
      * @param {string[]} [options.classList]
      * @param {{unit:number, class_name:string, width_px:number, min_spacing_px:number}[]} [options.tiers] notch tiers, finest first; see {@link SegmentTier}
      * @param {{count:number, group:number}|null} [options.cells] draw `count` cells instead of notches, in groups of `group` (0 for none)
-     * @param {number} [options.ghost_delay_ms=450] how long the ghost holds after a drop
-     * @param {number} [options.ghost_duration_ms=350] how long the ghost then takes to catch up; 0 under prefers-reduced-motion
+     * @param {number} [options.ghost_delay_ms=100] how long the ghost holds after a drop; see {@link GhostTrail}
+     * @param {number} [options.ghost_duration_min_ms=300] how long the ghost takes to close the smallest loss
+     * @param {number} [options.ghost_duration_max_ms=800] how long it takes to close a loss of the whole bar; both
+     *  durations are 0 under prefers-reduced-motion, so the ghost holds, then snaps
      */
-    constructor({ values, max, classList, tiers, cells, ghost_delay_ms, ghost_duration_ms }: {
+    constructor({ values, max, classList, tiers, cells, ghost_delay_ms, ghost_duration_min_ms, ghost_duration_max_ms }: {
         values: (Vector1 | ObservedInteger)[];
         max?: Vector1 | ObservedInteger | ReactiveExpression;
         classList?: string[];
@@ -36,7 +45,8 @@ export class SegmentedResourceBarView extends View {
             group: number;
         } | null;
         ghost_delay_ms?: number;
-        ghost_duration_ms?: number;
+        ghost_duration_min_ms?: number;
+        ghost_duration_max_ms?: number;
     });
     /**
      *
@@ -69,7 +79,12 @@ export class SegmentedResourceBarView extends View {
      * @type {number}
      * @private
      */
-    private __ghost_duration_ms;
+    private __ghost_duration_min_ms;
+    /**
+     * @type {number}
+     * @private
+     */
+    private __ghost_duration_max_ms;
     /**
      * Total fill as a fraction of max, as last drawn
      * @type {number}
@@ -97,16 +112,34 @@ export class SegmentedResourceBarView extends View {
      * @private
      */
     private __animate_ghost;
+    /**
+     * The max moved since the fill was last drawn: the next fill resets the ghost rather than trailing a loss
+     * @type {boolean}
+     * @private
+     */
+    private __max_moved;
     __built_max: number;
     __built_width: number;
     __built_ratio: number;
     __built_origin_phase: number;
     /**
-     * scratch for {@link segment_notch_place}
-     * @type {Float64Array}
+     * Cell mode: the cells as last laid out across {@link __el_strip}, or null before the bar has been measured
+     * @type {SegmentCellLayout|null}
+     * @private
+     */
+    private __cell_layout;
+    /**
+     * Device pixels per CSS pixel the cells were laid out at
+     * @type {number}
      * @private
      */
-    private __place;
+    private __cell_ratio;
+    /**
+     * scratch: [x, width, ...] device-pixel columns for a mask
+     * @type {number[]}
+     * @private
+     */
+    private __columns;
     /**
      *
      * @type {List<NumericInterval>}
@@ -124,20 +157,19 @@ export class SegmentedResourceBarView extends View {
      */
     private __value_fills;
     /**
+     * Notch mode: one layer per tier, the whole bar wide, styled by the tier's class and masked to its notches
      * @type {HTMLElement[]}
      * @private
      */
-    private __notch_elements;
+    private __tier_layers;
     /**
-     * @type {HTMLElement[]}
+     * Cell mode: the strip the cells are cut from by a mask, and the ghost and fill drawn along it
+     * @type {HTMLElement|null}
      * @private
      */
-    private __cell_elements;
-    __cell_fill_elements: HTMLDivElement[];
-    __cell_ghost_elements: HTMLDivElement[];
-    __cell_states: Uint8Array;
-    __cell_fill_drawn: Float64Array;
-    __cell_ghost_drawn: Float64Array;
+    private __el_strip;
+    __el_cell_ghost: HTMLDivElement;
+    __el_cell_fill: HTMLDivElement;
     /**
      * The notches' own box; what they are positioned in and what is measured to place them
      * @type {HTMLElement}
@@ -160,19 +192,31 @@ export class SegmentedResourceBarView extends View {
     /**
      * Place the notches or cells again, if the max, the bar's width (by {@link REBUILD_WIDTH_THRESHOLD_PX} or more),
      * its pixel ratio or the device-pixel phase of its left edge has moved since they were last placed.
+     *
+     * Both are drawn as a mask in whole device pixels over a layer CSS paints (see {@link segment_mask_url}): a DOM
+     * box per notch or cell cannot be put on the device-pixel grid at a fractional pixel ratio, where Chrome paints
+     * a row of equal 1 px gaps as 1, 2, 1, 2... whatever positions it is given (measured at 125% and 150%).
      */
     updateSegments(): void;
+    /**
+     * @param {HTMLElement} el
+     * @param {number} width_device
+     * @param {number} shift_px
+     * @param {number} ratio
+     * @private
+     */
+    private __place_layer;
     /**
      * @param {number} max
-     * @param {number} width
-     * @param {number} left
+     * @param {number} width_device
+     * @param {number} shift_px
      * @param {number} ratio
      * @private
      */
     private __place_notches;
     /**
-     * @param {number} width
-     * @param {number} left
+     * @param {number} width_device
+     * @param {number} shift_px
      * @param {number} ratio
      * @private
      */

package/src/view/elements/progress/segmented/SegmentedResourceBarView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;GAUG;AACH;IACI;;;;;;;;;;OAUG;IACH;QARgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;QAC6E,KAAK,GAA1F;YAAC,IAAI,EAAC,MAAM,CAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,QAAQ,EAAC,MAAM,CAAC;YAAC,cAAc,EAAC,MAAM,CAAA;SAAC,EAAE;QAC9B,KAAK,GAAjD;YAAC,KAAK,EAAC,MAAM,CAAC;YAAC,KAAK,EAAC,MAAM,CAAA;SAAC,GAAC,IAAI;QAChB,cAAc,GAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OAsQhB;IA9OG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAEtB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAA+B;IAG/B;;;OAGG;IACH,4BAA4C;IAE5C;;;;OAIG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,yBAAgH;IAEhH;;;;OAIG;IACH,oBAAuB;IAie3B;;OAEG;IACH,4BASC;IAzeG,yBAA4B;IAC5B,mBAAmB;IA8bvB;;OAEG;IACH,wBAQC;IArcG,oBAAsB;IACtB,sBAAwB;IACxB,sBAAwB;IACxB,6BAA+B;IAE/B;;;;OAIG;IACH,gBAAkC;IAElC;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IASvC;;;OAGG;IACH,mBAA+C;IAG/C;;;OAGG;IACH,sBAAuB;IAEvB;;;OAGG;IACH,yBAA0B;IAE1B;;;OAGG;IACH,wBAAyB;IACzB,uCAA8B;IAC9B,wCAA+B;IAC/B,0BAAqE;IAGrE,gCAA2E;IAC3E,iCAA4E;IAkBxE;;;;OAIG;IACH,oBAAgD;IA8BpD;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAuC/C,eAGC;IAED,wBAGC;IAED;;;OAGG;IACH,uBAmDC;IAED;;;;;;OAMG;IACH,wBAoCC;IAED;;;;;OAKG;IACH,sBAkBC;IAED,mBAwCC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,qBA6BC;IAeD;;;;OAIG;IACH,mCAUC;CAeJ;iBAxnBgB,kBAAkB;iBALlB,0CAA0C;qBAGtC,6BAA6B;oBAF9B,kCAAkC"}
+{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACI;;;;;;;;;;;;OAYG;IACH;QAVgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;QAC6E,KAAK,GAA1F;YAAC,IAAI,EAAC,MAAM,CAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,QAAQ,EAAC,MAAM,CAAC;YAAC,cAAc,EAAC,MAAM,CAAA;SAAC,EAAE;QAC9B,KAAK,GAAjD;YAAC,KAAK,EAAC,MAAM,CAAC;YAAC,KAAK,EAAC,MAAM,CAAA;SAAC,GAAC,IAAI;QAChB,cAAc,GAA/B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QACW,qBAAqB,GAAtC,MAAM;OAyShB;IA5QG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAEtB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAA+B;IAG/B;;;OAGG;IACH,gCAAoD;IAEpD;;;OAGG;IACH,gCAAoD;IAEpD;;;;OAIG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,yBAAgH;IAEhH;;;;OAIG;IACH,oBAAuB;IAgiB3B;;OAEG;IACH,4BASC;IAxiBG,yBAA4B;IAC5B,mBAAmB;IA6fvB;;OAEG;IACH,wBAQC;IArgBG;;;;OAIG;IACH,oBAAwB;IAGxB,oBAAsB;IACtB,sBAAwB;IACxB,sBAAwB;IACxB,6BAA+B;IAE/B;;;;OAIG;IACH,sBAAyB;IAEzB;;;;OAIG;IACH,qBAAqB;IAErB;;;;OAIG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IASvC;;;OAGG;IACH,mBAA+C;IAG/C;;;OAGG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,mBAAsB;IACtB,gCAA2B;IAC3B,+BAA0B;IAkBtB;;;;OAIG;IACH,oBAAgD;IAoCpD;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAuC/C,eAGC;IAED,wBAMC;IAED;;;;;;;OAOG;IACH,uBA4DC;IAED;;;;;;OAMG;IACH,sBAKC;IAED;;;;;;OAMG;IACH,wBA2CC;IAED;;;;;OAKG;IACH,sBAoBC;IAED,mBAiDC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,qBAoBC;IAeD;;;;OAIG;IACH,mCAUC;CAeJ;iBA5rBgB,kBAAkB;iBALlB,0CAA0C;qBAGtC,6BAA6B;oBAF9B,kCAAkC"}