@woosh/meep-engine 3.29.0 → 3.31.0

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA0PA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAykCd"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AAkRA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAwpCd"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -213,6 +213,30 @@ function binop_cmp(a, b, op) {
  * @param {function(number): number} op
  * @returns {*}
  */
+/**
+ * WGSL's `round`: the nearest whole number, and when there are two, the EVEN one.
+ *
+ * `Math.round` is "nearest, ties toward +Inf", which is a different function on every tie and
+ * asymmetric about zero — round(2.5) is 3 rather than 2, round(-1.5) is -1 rather than -2. This is
+ * the CPU oracle the chunk specs check GPU code against, so the divergence was invisible in tests
+ * and appeared only on a device: `round(x * scale)` on a quantised coordinate, a texel centre or a
+ * snapped grid index lands one cell off on exactly the half-integer inputs a grid produces most
+ * often. `chunk_texture_sample_nearest_uv` clamps against this rounding by name.
+ *
+ * @param {number} x
+ * @returns {number}
+ */
+function round_ties_to_even(x) {
+    // Math.round always takes a tie upward, so on a tie the other neighbour is one below
+    const r = Math.round(x);
+
+    if (Math.abs(x % 1) !== 0.5) {
+        return r;
+    }
+
+    return r % 2 === 0 ? r : r - 1;
+}
+
 function unop(a, op) {
     if (!is_vec(a)) {
         return op(a);
@@ -462,6 +486,32 @@ export const WGSLLanguageCore = {
     sub: (a, b) => binop(a, b, (x, y) => x - y),
     mul: (a, b) => binop(a, b, (x, y) => x * y),
     div: (a, b) => binop(a, b, (x, y) => x / y),
+
+    /*
+     The same four at f32, for a SCALAR whose type the compiler knows is f32.
+
+     A vector's lanes were always rounded — `binop` writes them into `new a.constructor(...)`,
+     which is a Float32Array — while the scalar path returned the raw f64 result. One function
+     therefore ran at two precisions, and the scalar one was MORE accurate than the device: an f32
+     `a + b` at (16777216, 1) came back 16777217, which the f32 mantissa cannot hold, and
+     `a * b` at (0.1, 0.2) came back 0.020000000000000004 rather than 0.020000001415610313 — the
+     fourth significant digit, six orders of magnitude above f32 epsilon. An f32 accumulation that
+     loses a term is precisely what an emulator test exists to catch, and it was the one thing the
+     emulator structurally could not see.
+
+     The integer wrapping helpers beside these exist for the mirror-image reason, and the compiler
+     picks between them the same way: only when the result type is KNOWN, so an AbstractFloat
+     const-expression — which WGSL really does evaluate at higher precision — keeps the plain one.
+
+     They go through `binop` rather than assuming a scalar, because the compiler picks them off a
+     STATIC type and a struct field it cannot see through reads as f32 while carrying a vec at
+     runtime. `Math.fround` of a vector is NaN, and binop is already idempotent here: a vec lane is
+     rounded and then stored into the Float32Array that would have rounded it anyway.
+    */
+    add_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x + y)),
+    sub_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x - y)),
+    mul_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x * y)),
+    div_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x / y)),
     rem: (a, b) => binop(a, b, (x, y) => x % y),
 
     // Integer division — truncates toward zero, matching WGSL `/` semantics on integer types.
@@ -543,9 +593,37 @@ export const WGSLLanguageCore = {
     /** `firstLeadingBit(e)` — index of the most significant set bit; `0xffffffff` for 0 (u32 reading). */
     firstLeadingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x))),
 
+    /** `firstLeadingBit(e: u32)` — as above; named so the compiler can pick it by operand type. */
+    firstLeadingBit_u32: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x >>> 0))),
+
+    /**
+     * `firstLeadingBit(e: i32)` — the position of the most significant bit DIFFERENT from the sign
+     * bit, and -1 when there is none.
+     *
+     * A different function from the u32 reading rather than the same one on other bits: that one
+     * answers 31 for every negative number, which is the sign bit and carries no information. The
+     * emulator used to give both readings the unsigned one.
+     */
+    firstLeadingBit_i32: (e) => unop(e, x => {
+        const v = x | 0;
+
+        if (v === 0 || v === -1) {
+            return -1;
+        }
+
+        // for a negative value the search is for the most significant ZERO
+        return 31 - Math.clz32((v < 0 ? ~v : v) >>> 0);
+    }),
+
     /** `firstTrailingBit(e)` — index of the least significant set bit; `0xffffffff` for 0. */
     firstTrailingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x & -x))),
 
+    /** `firstTrailingBit(e: u32)` — as above. */
+    firstTrailingBit_u32: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x & -x))),
+
+    /** `firstTrailingBit(e: i32)` — as above, but the "no bit" answer is -1, in this type's sign. */
+    firstTrailingBit_i32: (e) => unop(e, x => ((x | 0) === 0 ? -1 : 31 - Math.clz32(x & -x))),
+
     /** `reverseBits(e)` — reverse the order of all 32 bits. */
     reverseBits: (e) => unop(e, x => {
         let source = x >>> 0;
@@ -578,10 +656,20 @@ export const WGSLLanguageCore = {
     // ---------------------------------------------------------------------
 
     abs: (a) => unop(a, Math.abs),
+
+    /**
+     * `abs(e: i32)` — WGSL §17.5 ends "and when e is the most negative value, e itself", which is
+     * the wrap two's complement forces. `Math.abs` answers 2147483648 there, a value outside the
+     * type, which then compares and stores as something no device produces.
+     */
+    abs_i32: (a) => unop(a, x => (x < 0 ? (-x) | 0 : x | 0)),
+
+    /** `abs(e: u32)` — the identity; it exists so the compiler can pick by operand type. */
+    abs_u32: (a) => unop(a, x => x >>> 0),
     sign: (a) => unop(a, Math.sign),
     floor: (a) => unop(a, Math.floor),
     ceil: (a) => unop(a, Math.ceil),
-    round: (a) => unop(a, Math.round),
+    round: (a) => unop(a, round_ties_to_even),
     trunc: (a) => unop(a, Math.trunc),
     fract: (a) => unop(a, x => x - Math.floor(x)),
     sqrt: (a) => unop(a, Math.sqrt),
@@ -619,29 +707,44 @@ export const WGSLLanguageCore = {
     // Vector operations
     // ---------------------------------------------------------------------
 
+    /*
+     The reductions accumulate in f32, through Math.fround on every square and every partial sum.
+
+     They summed into a plain `let s = 0` — an f64 accumulator — so f32's RANGE never applied: below
+     about 1e-22 per component the squares flush to zero on a device and the length is zero, above
+     about 1.9e19 they saturate to Inf, and the emulator returned a clean finite answer for exactly
+     those inputs. Degenerate directions are the commonest source of NaN in this renderer's shading
+     and traversal — an interpolated normal that collapsed, a ray direction that went to zero, a
+     cluster sphere at the eye — so a missing guard passed this tier and showed up as black or
+     missing geometry in the browser.
+    */
     dot(a, b) {
         assert.equal(a.length, b.length, 'dot vector length mismatch');
         let s = 0;
-        for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+        for (let i = 0; i < a.length; i++) s = Math.fround(s + Math.fround(a[i] * b[i]));
         return s;
     },
 
     length(v) {
         if (!is_vec(v)) return Math.abs(v);
         let s = 0;
-        for (let i = 0; i < v.length; i++) s += v[i] * v[i];
-        return Math.sqrt(s);
+        for (let i = 0; i < v.length; i++) s = Math.fround(s + Math.fround(v[i] * v[i]));
+        return Math.fround(Math.sqrt(s));
     },
 
     distance(a, b) {
         return WGSLLanguageCore.length(WGSLLanguageCore.sub(a, b));
     },
 
+    /**
+     * WGSL leaves `normalize` of a zero-length vector indeterminate, and every driver produces
+     * `0/0` — NaN — for it. This used to return the zero vector instead, which is a clean answer
+     * a device never gives and the one shape a missing degenerate guard most needs to be told
+     * about. A caller that wants a defined answer has to test the length itself, which is what the
+     * shader has to do anyway.
+     */
     normalize(v) {
         const len = WGSLLanguageCore.length(v);
-        if (len === 0) {
-            return new v.constructor(v.length);
-        }
         const out = new v.constructor(v.length);
         for (let i = 0; i < v.length; i++) out[i] = v[i] / len;
         return out;

package/src/shade/wgsl/validate_wgsl_source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate_wgsl_source.d.ts","sourceRoot":"","sources":["../../../../src/shade/wgsl/validate_wgsl_source.js"],"names":[],"mappings":"AAmKA;;;;;;GAMG;AACH,6CAJW,MAAM,UACN,OAAO,iBAAiB,EAAE,UAAU,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAwJ7D"}
+{"version":3,"file":"validate_wgsl_source.d.ts","sourceRoot":"","sources":["../../../../src/shade/wgsl/validate_wgsl_source.js"],"names":[],"mappings":"AAuKA;;;;;;GAMG;AACH,6CAJW,MAAM,UACN,OAAO,iBAAiB,EAAE,UAAU,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CA6M7D"}

package/src/shade/wgsl/validate_wgsl_source.js

@@ -19,6 +19,10 @@ import { WGSLLanguageCore } from "./emulator/WGSLLanguageCore.js";
  *    emulator and only fail at `createShaderModule` on a device. Lexical, whole-word.
  *  - undeclared-call: a call to a function that is neither user-defined nor a known WGSL
  *    builtin / type constructor (catches missing chunk dependencies).
+ *  - const-initializer: a function-scope `const` whose initializer reads a runtime value — a
+ *    parameter, a `var` or a `let`. WGSL requires a const-declaration's initializer to be a
+ *    const-expression, so these are rejected at `createShaderModule`; the emulator does not
+ *    enforce const-ness, so a chunk written against it passes every spec and then cannot compile.
  *
  * NOT yet enforced (would need full type inference; tracked under REVIEW_002 9.1): scalar
  * type mixing (u32/i32/f32), AbstractInt conversion failures, const-evaluability of
@@ -200,6 +204,11 @@ export function validate_wgsl_source(source, parser) {
         const immutable = new Set();
         const mutable = new Set();
 
+        /** Function-scope `const` names — const-expressions may read each other. @type {Set<string>} */
+        const local_const = new Set();
+        /** Everything a const-expression may NOT read: parameters, `var`, `let`. @type {Set<string>} */
+        const runtime = new Set();
+
         // Value parameters are immutable; POINTER parameters are not — writing through a
         // pointer (`*p = …`, `p.x = …`, `memory[i] = …`) is the legal, common case in this
         // codebase, so excluding them is what keeps this rule free of false positives.
@@ -212,6 +221,8 @@ export function validate_wgsl_source(source, parser) {
                     const type = p.namedChildren.find(c => c.type === 'type_specifier');
                     const is_pointer = type !== undefined && /\bptr\b/.test(type.text);
                     if (!is_pointer) immutable.add(id.text.trim());
+
+                    runtime.add(id.text.trim());
                 }
             }
         }
@@ -229,9 +240,20 @@ export function validate_wgsl_source(source, parser) {
             if (is_var) {
                 mutable.add(name);
                 immutable.delete(name);
+                runtime.add(name);
                 continue;
             }
 
+            const is_const = /^\s*const\b/.test(decl.text);
+
+            if (is_const) {
+                local_const.add(name);
+                runtime.delete(name);
+            } else {
+                runtime.add(name);
+                local_const.delete(name);
+            }
+
             const init = decl.namedChildren.find(c => c.type === 'expression');
             const is_pointer_let = init !== undefined && init.text.trim().startsWith('&');
             if (is_pointer_let) {
@@ -267,6 +289,41 @@ export function validate_wgsl_source(source, parser) {
             }
         };
 
+        // ── const-initializer ──
+        //
+        // A const-declaration's initializer must be a const-expression: literals, other
+        // const-declarations, and const-evaluable builtins. Reading a parameter, a `var` or a
+        // `let` makes it a runtime value, and the declaration is rejected at module creation. The
+        // emulator does not model const-ness at all, so this is invisible to every spec written
+        // against it — and `const` is one keystroke from `let`.
+        for (const decl of descendantsOfType(fn, 'variable_or_value_statement')) {
+            if (!/^\s*const\b/.test(decl.text)) {
+                continue;
+            }
+
+            const init = decl.namedChildren.find(c => c.type === 'expression');
+
+            if (init === undefined) {
+                continue;
+            }
+
+            for (const ident of descendantsOfType(init, 'ident')) {
+                const name = ident.text.trim();
+
+                if (!runtime.has(name) || local_const.has(name)) {
+                    continue;
+                }
+
+                diagnostics.push({
+                    rule: 'const-initializer',
+                    message: `const '${firstIdentToken(decl.namedChildren.find(c => c.type === 'optionally_typed_ident')) ?? '?'}' is initialized from runtime value '${name}' (use let)`,
+                    line: decl.startPosition.row + 1,
+                });
+
+                break;
+            }
+        }
+
         for (const stmt of descendantsOfType(fn, 'assignment_statement')) flag_lhs(stmt, 'assignment');
         for (const stmt of descendantsOfType(fn, 'increment_statement')) flag_lhs(stmt, 'increment');
         for (const stmt of descendantsOfType(fn, 'decrement_statement')) flag_lhs(stmt, 'decrement');

package/src/view/asset/AssetLoaderStatusView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetLoaderStatusView.d.ts","sourceRoot":"","sources":["../../../../src/view/asset/AssetLoaderStatusView.js"],"names":[],"mappings":"AAOA;IACI;;;;;;OAMG;IACH;QAJiC,YAAY;QACZ,YAAY;OAqC5C;IA/BG,YAAiE;IAEjE,2BAAgC;IAGhC,2BAAsC;IAiBtC,gCAEC;IAED,kCAEC;CA4BR;iBA1EgB,YAAY;oBAET,4BAA4B"}
+{"version":3,"file":"AssetLoaderStatusView.d.ts","sourceRoot":"","sources":["../../../../src/view/asset/AssetLoaderStatusView.js"],"names":[],"mappings":"AAOA;IACI;;;;;;OAMG;IACH;QAJiC,YAAY;QACZ,YAAY;OAqC5C;IA/BG,YAAiE;IAEjE,2BAAgC;IAGhC,2BAAsC;IAiBtC,gCAEC;IAED,kCAEC;CAoCR;iBAlFgB,YAAY;oBAET,4BAA4B"}

package/src/view/asset/AssetLoaderStatusView.js

@@ -51,6 +51,10 @@ export class AssetLoaderStatusView extends View {
 
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         super.link();
 
         const self = this;
@@ -66,6 +70,10 @@ export class AssetLoaderStatusView extends View {
     }
 
     unlink() {
+        if (!this.isLinked) {
+            return;
+        }
+
         super.unlink();
 
 

package/src/view/common/LabelView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LabelView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/LabelView.js"],"names":[],"mappings":";AA2IA;IACI;;;;;;;OA+CC;IArCG,WAAkB;IASlB,gCAA4B;IAC5B,mDAA4B;IAC5B,gCAA4B;IAE5B,gBAAqC;IA0BzC;;;;OAIG;IACH,mBAEC;IAGD;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED,wBAYC;CAOJ;iBAlNgB,YAAY;qBAdR,6BAA6B;4BACtB,oCAAoC"}
+{"version":3,"file":"LabelView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/LabelView.js"],"names":[],"mappings":";AA2IA;IACI;;;;;;;OA+CC;IArCG,WAAkB;IASlB,gCAA4B;IAC5B,mDAA4B;IAC5B,gCAA4B;IAE5B,gBAAqC;IA0BzC;;;;OAIG;IACH,mBAEC;IAGD;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED,wBAYC;CAWJ;iBAtNgB,YAAY;qBAdR,6BAA6B;4BACtB,oCAAoC"}

package/src/view/common/LabelView.js

@@ -220,6 +220,10 @@ class LabelView extends View {
     }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         super.link();
 
         this.updateTransform();

package/src/view/common/ListView.d.ts

@@ -112,11 +112,15 @@ export class ListView extends View {
      */
     getChildIndexByElement(el: E): number;
     /**
+     * The view built for `el`, or `undefined` when there is none — which is the ordinary answer for
+     * an element `filter` excluded, not an error.
+     *
+     * The `@returns` here said `View|null`, which is part of why callers did not guard it.
      *
      * @param {E} el
-     * @returns {View|null}
+     * @returns {View|undefined}
      */
-    getChildByElement(el: E): View | null;
+    getChildByElement(el: E): View | undefined;
 }
 export default ListView;
 import View from "../View.js";

package/src/view/common/ListView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ListView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/ListView.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;IACI;;;OAGG;IACH,wBAWC;IAVG;;;OAGG;IACH,WAAkB;IAElB;;OAEG;IACH,QAFU,MAAM,CAEU;IAG9B;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,CAAC,GACA,OAAO,CAIlB;CACJ;AAED;IACI;;;;;;;;;;;;;OAaG;IACH;oBATW,MAAM,EAAE;qCACI,IAAI;kCACJ,IAAI,QAAE,MAAM;qCACZ,IAAI,QAAE,MAAM;8BACZ,OAAO;oBACnB,MAAM;mBACN,OAAO;OAwFjB;IA1EG;;;OAGG;IACH,gBAEE;IAEF;;;;OAIG;IACH,mBAA0B;IAS1B;;;OAGG;IACH,eAAkB;IAElB,6BA/CmB,IAAI,CA+Ca;IACpC,qBA7CmB,OAAO,CA6CN;IAEpB;6BAjDmB,IAAI,QAAE,MAAM;gCACZ,IAAI,QAAE,MAAM;MAmD9B;IAED,mBAAuC;IAYvC;;;OAGG;IACH,0BAA4B;IAwBhC;;;;OAIG;IACH,oBAFa,IAAI,CAwBhB;IAED;;;;OAIG;IACH,kBAeC;IAED;;;;;OAKG;IACH,eAgBC;IAED;;;;OAIG;IACH,kBA2BC;IAED;;;;OAIG;IACH,+BAFa,MAAM,CAUlB;IAED;;;;OAIG;IACH,0BAFa,IAAI,GAAC,IAAI,CAIrB;CACJ;;iBAnRgB,YAAY;iBAHZ,oCAAoC"}
+{"version":3,"file":"ListView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/ListView.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;IACI;;;OAGG;IACH,wBAWC;IAVG;;;OAGG;IACH,WAAkB;IAElB;;OAEG;IACH,QAFU,MAAM,CAEU;IAG9B;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,CAAC,GACA,OAAO,CAIlB;CACJ;AAED;IACI;;;;;;;;;;;;;OAaG;IACH;oBATW,MAAM,EAAE;qCACI,IAAI;kCACJ,IAAI,QAAE,MAAM;qCACZ,IAAI,QAAE,MAAM;8BACZ,OAAO;oBACnB,MAAM;mBACN,OAAO;OAwFjB;IA1EG;;;OAGG;IACH,gBAEE;IAEF;;;;OAIG;IACH,mBAA0B;IAS1B;;;OAGG;IACH,eAAkB;IAElB,6BA/CmB,IAAI,CA+Ca;IACpC,qBA7CmB,OAAO,CA6CN;IAEpB;6BAjDmB,IAAI,QAAE,MAAM;gCACZ,IAAI,QAAE,MAAM;MAmD9B;IAED,mBAAuC;IAYvC;;;OAGG;IACH,0BAA4B;IAwBhC;;;;OAIG;IACH,oBAFa,IAAI,CAwBhB;IAED;;;;OAIG;IACH,kBA+BC;IAED;;;;;OAKG;IACH,eAgBC;IAED;;;;OAIG;IACH,kBA2BC;IAED;;;;OAIG;IACH,+BAFa,MAAM,CAUlB;IAED;;;;;;;;OAQG;IACH,0BAFa,IAAI,GAAC,SAAS,CAI1B;CACJ;;iBAvSgB,YAAY;iBAHZ,oCAAoC"}

package/src/view/common/ListView.js

@@ -187,14 +187,30 @@ export class ListView extends View {
 
         const elementView = this.addOne(el, index);
 
-        if (this.model.length !== index + 1) {
-            //this is not the last element in the list, we need to patch it into the right place inside the DOM
-            const nextElement = this.model.get(index + 1);
-            const nextChild = this.getChildByElement(nextElement);
-
-            this.el.insertBefore(elementView.el, nextChild.el);
+        /*
+         Patch it into the right place in the DOM, ahead of the first element after it that HAS a
+         view.
+
+         This used to take the element at `index + 1` and go straight for its view's `el`.
+         `viewMapping` only ever holds elements that passed `filter` — both the link-time loop and
+         this method skip the rest — so a filtered-out neighbour answered `undefined` and the
+         dereference threw. The throw lands inside a `Signal` dispatch, which catches it and
+         console.errors, so the list kept the new view where `addOne` appended it: at the end, with
+         the DOM order silently no longer matching the model.
+        */
+        const model = this.model;
+
+        for (let i = index + 1; i < model.length; i++) {
+            const nextChild = this.getChildByElement(model.get(i));
+
+            if (nextChild !== undefined) {
+                this.el.insertBefore(elementView.el, nextChild.el);
+
+                return;
+            }
         }
 
+        // nothing after it is shown, so where addOne appended it is where it belongs
     }
 
     /**
@@ -271,9 +287,13 @@ export class ListView extends View {
     }
 
     /**
+     * The view built for `el`, or `undefined` when there is none — which is the ordinary answer for
+     * an element `filter` excluded, not an error.
+     *
+     * The `@returns` here said `View|null`, which is part of why callers did not guard it.
      *
      * @param {E} el
-     * @returns {View|null}
+     * @returns {View|undefined}
      */
     getChildByElement(el) {
         return this.viewMapping.get(el);

package/src/view/common/TabbedView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TabbedView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/TabbedView.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,+BAFU,MAAM,CAEmB;AAEnC;IAuBI;;;;;;;OAOG;IACH;QALyB,MAAM,EAApB,IAAI;QACU,KAAK,EAAnB,IAAI;QACc,MAAM,GAAxB,OAAO;QACL,aAAa,CAUzB;IAtCD;;OAEG;IACH,SAFU,eAAe,CAEW;IAEpC;;OAEG;IACH,QAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,QAFU,IAAI,CAEA;IAEd;;;OAGG;IACH,OAFU,IAAI,CAED;CAmBhB;AAED;;;GAGG;AACH;IAII;;;;OAIG;IACH;QAFwC,IAAI;OAoC3C;IAzCD,mBAAmC;IAU/B;;;OAGG;IACH,2BAAiB;IAOjB,4BAAyE;IAGzE,6BAAyE;IAMzE;;;;OAIG;IACH,0BAAkC;IAoBtC;;;OAGG;IACH,gBAFa,aAAa,GAAC,SAAS,CAInC;IAED;;;OAGG;IACH,qBAFW,aAAa,QAUvB;IAED,eAeC;IAED;;;OAGG;IACH,4BAkBC;IAGD;;;;OAIG;IACH,yBAkBC;IAED;;;;OAIG;IACH,2BAeC;CACJ;4BAhO2B,qCAAqC;iBADhD,YAAY;sBAIP,0BAA0B"}
+{"version":3,"file":"TabbedView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/TabbedView.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,+BAFU,MAAM,CAEmB;AAEnC;IAuBI;;;;;;;OAOG;IACH;QALyB,MAAM,EAApB,IAAI;QACU,KAAK,EAAnB,IAAI;QACc,MAAM,GAAxB,OAAO;QACL,aAAa,CAUzB;IAtCD;;OAEG;IACH,SAFU,eAAe,CAEW;IAEpC;;OAEG;IACH,QAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,QAFU,IAAI,CAEA;IAEd;;;OAGG;IACH,OAFU,IAAI,CAED;CAmBhB;AAED;;;GAGG;AACH;IAII;;;;OAIG;IACH;QAFwC,IAAI;OAoC3C;IAzCD,mBAAmC;IAU/B;;;OAGG;IACH,2BAAiB;IAOjB,4BAAyE;IAGzE,6BAAyE;IAMzE;;;;OAIG;IACH,0BAAkC;IA4BtC;;;OAGG;IACH,gBAFa,aAAa,GAAC,SAAS,CAInC;IAED;;;OAGG;IACH,qBAFW,aAAa,QAUvB;IAED,eAeC;IAED;;;OAGG;IACH,4BAkBC;IAGD;;;;OAIG;IACH,yBAkBC;IAED;;;;OAIG;IACH,2BAeC;CACJ;4BAxO2B,qCAAqC;iBADhD,YAAY;sBAIP,0BAA0B"}

package/src/view/common/TabbedView.js

@@ -102,12 +102,20 @@ export class TabbedView extends View {
     }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         super.link();
 
         this.model.forEach(this.__handleTabAdded, this);
     }
 
     unlink() {
+        if (!this.isLinked) {
+            return;
+        }
+
         this.model.forEach(this.__handleTabRemoved, this);
 
         super.unlink();

package/src/view/common/VirtualListView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualListView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/VirtualListView.js"],"names":[],"mappings":";;;;;;AAgBA;IACI;;;;;;;;;;OAUG;IACH,gHARW,MAAM,EAoGhB;IA/EG,cAAgB;IAahB,YAAkB;IAclB,yBAA+B;IAE/B,sBAAkC;IAElC,6BAA8B;IAC9B,4BAA6B;IAE7B,iCAAoC;IAEpC;;;;OAIG;IACH,oBAA2B;IAE3B;;;;OAIG;IACH,uBAAiC;IAEjC;;;;OAIG;IACH,0BAAuC;IAEvC;;;;OAIG;IACH,6BAA6C;IAG7C,+BAIE;IAGF,4BAAyD;IAS7D,gDASC;IAED,kDAOC;IAGD,eA4EC;IAED,qCAmBC;IAED;;;;;OAKG;IACH,kCAIC;IAED,gCAKC;IAED,oBAMC;CAeJ;iBAlRgB,YAAY;iBAPZ,oCAAoC;sBAD/B,2BAA2B"}
+{"version":3,"file":"VirtualListView.d.ts","sourceRoot":"","sources":["../../../../src/view/common/VirtualListView.js"],"names":[],"mappings":";;;;;;AAgBA;IACI;;;;;;;;;;OAUG;IACH,gHARW,MAAM,EAoGhB;IA/EG,cAAgB;IAahB,YAAkB;IAclB,yBAA+B;IAE/B,sBAAkC;IAElC,6BAA8B;IAC9B,4BAA6B;IAE7B,iCAAoC;IAEpC;;;;OAIG;IACH,oBAA2B;IAE3B;;;;OAIG;IACH,uBAAiC;IAEjC;;;;OAIG;IACH,0BAAuC;IAEvC;;;;OAIG;IACH,6BAA6C;IAG7C,+BAIE;IAGF,4BAAyD;IAS7D,gDASC;IAED,kDAOC;IAGD,eAoFC;IAED,qCAmBC;IAED;;;;;OAKG;IACH,kCAIC;IAED,gCAKC;IAED,oBAMC;CAuBJ;iBAlSgB,YAAY;iBAPZ,oCAAoC;sBAD/B,2BAA2B"}

package/src/view/common/VirtualListView.js

@@ -178,7 +178,15 @@ class VirtualListView extends View {
         this.renderedViews.reset();
 
         let rowWidth = this.size.x;
-        if (this.__first_visible_line === 0 && this.__last_visible_line === numTotalElements - 1 && row_height * (this.__last_visible_line - this.__first_visible_line) < this.size.y) {
+
+        // `maxLength` is what the rows actually occupy, which is the only thing
+        // "does it all fit" can be asked of. Deriving a span from the visible
+        // line indices measured `row_height * (last - first)` — the distance
+        // between the first and last row's ORIGINS — and was short by exactly
+        // one row, so a list overflowing by up to a row judged itself to fit:
+        // five 20 px rows in a 90 px viewport read as 80 < 90 while spanning
+        // 100 px, and the tail of the last row became unreachable.
+        if (maxLength <= this.size.y) {
             //entire set of data is visible, disable scroll bar
             this.__setScrollBar(false);
         } else {
@@ -268,6 +276,10 @@ class VirtualListView extends View {
     }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         super.link();
 
         this.size.onChanged.add(this.__throttledUpdate);
@@ -276,6 +288,10 @@ class VirtualListView extends View {
     }
 
     unlink() {
+        if (!this.isLinked) {
+            return;
+        }
+
         super.unlink();
 
         this.size.onChanged.remove(this.__throttledUpdate);

package/src/view/common/dnd/DropTarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DropTarget.d.ts","sourceRoot":"","sources":["../../../../../src/view/common/dnd/DropTarget.js"],"names":[],"mappings":"AAuGA;IACI;;;;;;OAMG;IACH,uEAH+B,OAAO,EA0IrC;IApIG,WAAgB;IAEhB;;;OAGG;IACH,iCAF+B,OAAO,CAEV;IAE5B,YAAoB;IAEpB;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEH;;;;QAIZ;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;MAEN;IA2DD,8BAA6C;IAgC7C;;;iCA5BW,SAAS;iCAeT,SAAS;MAkBnB;IAML,6BAQC;IAED,wBAEC;IAED,aAQC;IAED,eAQC;CACJ;mBAzRkB,uCAAuC"}
+{"version":3,"file":"DropTarget.d.ts","sourceRoot":"","sources":["../../../../../src/view/common/dnd/DropTarget.js"],"names":[],"mappings":"AAuGA;IACI;;;;;;OAMG;IACH,uEAH+B,OAAO,EA4JrC;IAtJG,WAAgB;IAEhB;;;OAGG;IACH,iCAF+B,OAAO,CAEV;IAE5B,YAAoB;IAEpB;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEH;;;;QAIZ;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;MAEN;IA2DD,8BAA6C;IAkD7C;;;iCA9CW,SAAS;iCAwBT,SAAS;MA2BnB;IAML,6BAQC;IAED,wBAEC;IAED,aAQC;IAED,eAQC;CACJ;mBA3SkB,uCAAuC"}

package/src/view/common/dnd/DropTarget.js

@@ -215,6 +215,15 @@ export class DropTarget {
             self.context.elements
                 .filter(e => e.getFlag(DraggableElementFlags.BeingDragged))
                 .forEach(e => {
+                    // Once per draggable, not once per enter: the browser fires
+                    // dragenter for every DESCENDANT crossed, not once per
+                    // target, so one pointer crossing of a target with child
+                    // elements delivers several — and the copies outlive the
+                    // single leave that follows.
+                    if (isInState_ENTER.indexOf(e) !== -1) {
+                        return;
+                    }
+
                     isInState_ENTER.push(e);
                     self.on.enter.send1(e)
                 });
@@ -230,6 +239,15 @@ export class DropTarget {
                 .filter(e => e.getFlag(DraggableElementFlags.BeingDragged))
                 .forEach(e => {
                     const i = isInState_ENTER.indexOf(e);
+
+                    // `splice` counts from the END for a negative index, so an
+                    // unguarded miss deletes the LAST entry instead of nothing
+                    // — evicting a draggable that IS still over the target, and
+                    // sending `exit` for one that never entered it.
+                    if (i === -1) {
+                        return;
+                    }
+
                     isInState_ENTER.splice(i, 1);
                     self.on.exit.send1(e)
                 });

package/src/view/elements/DropDownSelectionView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DropDownSelectionView.d.ts","sourceRoot":"","sources":["../../../../src/view/elements/DropDownSelectionView.js"],"names":[],"mappings":";AAIA;;GAEG;AACH;IACI;;;;;;OAMG;IACH;mCAHuB,MAAM;;OAoC5B;IA9BG,iBAAkB;IACH,sBAA0C;IAIrD,gDAXe,MAAM,EAWO;IAmBhC;;;;OAIG;IACH,gBAAwB;IAG5B;;;;OAIG;IACH,oBAaC;IAED;;;OAGG;IACH,sBAmBC;IAED,qBAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACL,CAAC,CAYZ;IAED;;;OAGG;IACH,oBAFY,CAAC,CAMZ;IAED;;;OAGG;IACH,oBAFW,CAAC,QAIX;CAaJ;iBA1JgB,YAAY;4BAFD,oCAAoC"}
+{"version":3,"file":"DropDownSelectionView.d.ts","sourceRoot":"","sources":["../../../../src/view/elements/DropDownSelectionView.js"],"names":[],"mappings":";AAIA;;GAEG;AACH;IACI;;;;;;OAMG;IACH;mCAHuB,MAAM;;OAoC5B;IA9BG,iBAAkB;IACH,sBAA0C;IAIrD,gDAXe,MAAM,EAWO;IAmBhC;;;;OAIG;IACH,gBAAwB;IAG5B;;;;OAIG;IACH,oBAaC;IAED;;;OAGG;IACH,sBAmBC;IAED,qBAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACL,CAAC,CAYZ;IAED;;;OAGG;IACH,oBAFY,CAAC,CAMZ;IAED;;;OAGG;IACH,oBAFW,CAAC,QAIX;CAqBJ;iBAlKgB,YAAY;4BAFD,oCAAoC"}

package/src/view/elements/DropDownSelectionView.js

@@ -144,12 +144,20 @@ class DropDownSelectionView extends View {
     }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         this.model.forEach(this.handleAdded, this);
 
         super.link();
     }
 
     unlink() {
+        if (!this.isLinked) {
+            return;
+        }
+
         super.unlink();
 
         this.clearOptions();

package/src/view/elements/image/SvgImageView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SvgImageView.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/image/SvgImageView.js"],"names":[],"mappings":";AAKA;IACI;;;;;;OAMG;IACH,iBALW,MAAM;QAEgB,YAAY;OAoD5C;IADG,YAAe;IAGnB,eAIK;CAUR;iBA3EgB,eAAe"}
+{"version":3,"file":"SvgImageView.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/image/SvgImageView.js"],"names":[],"mappings":";AAKA;IACI;;;;;;OAMG;IACH,iBALW,MAAM;QAEgB,YAAY;OAoD5C;IADG,YAAe;IAGnB,eAIK;CAkBR;iBAnFgB,eAAe"}

package/src/view/elements/image/SvgImageView.js

@@ -69,11 +69,19 @@ class SvgImageView extends View {
         }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         super.link();
         this.update();
     }
 
     unlink() {
+        if (!this.isLinked) {
+            return;
+        }
+
         super.unlink();
     }
 }

package/src/view/elements/navigation/ViewStack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewStack.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/navigation/ViewStack.js"],"names":[],"mappings":"AAwBA;IAuBQ,YAAiB;IAIjB,eAAiB;IACjB;;;;OAIG;IACH,sBAAyB;IAM7B;;OAEG;IACH,8BAKC;IAQD;;;OAGG;IACH,uBAsBC;IAED;;;;OAIG;IACH,WAHW,IAAI,SACJ,MAAM,QAQhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,UAAU,EAAE,CAQxB;IAED;;;OAGG;IACH,OAFa,UAAU,GAAC,SAAS,CAKhC;CACJ;iBA5IgB,eAAe;AAEhC;IACI;;;;;OAKG;IACH,kBAJW,IAAI,QACJ,MAAM,EAchB;IAVG;;;OAGG;IACH,MAFU,IAAI,CAEE;IAChB;;;OAGG;IACH,MAFU,MAAM,CAEA;CAEvB"}
+{"version":3,"file":"ViewStack.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/navigation/ViewStack.js"],"names":[],"mappings":"AAwBA;IAuBQ,YAAiB;IAIjB,eAAiB;IACjB;;;;OAIG;IACH,sBAAyB;IAM7B;;OAEG;IACH,8BAKC;IAYD;;;OAGG;IACH,uBAsBC;IAED;;;;OAIG;IACH,WAHW,IAAI,SACJ,MAAM,QAQhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,UAAU,EAAE,CAQxB;IAED;;;OAGG;IACH,OAFa,UAAU,GAAC,SAAS,CAKhC;CACJ;iBAhJgB,eAAe;AAEhC;IACI;;;;;OAKG;IACH,kBAJW,IAAI,QACJ,MAAM,EAchB;IAVG;;;OAGG;IACH,MAFU,IAAI,CAEE;IAChB;;;OAGG;IACH,MAFU,MAAM,CAEA;CAEvB"}

package/src/view/elements/navigation/ViewStack.js

@@ -72,6 +72,10 @@ export class ViewStack extends View {
     }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         super.link();
 
         this.updateActiveFrameSize();

package/src/view/elements/notify/NotificationView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationView.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/notify/NotificationView.js"],"names":[],"mappings":";AAKA;IACI;;;;OAIG;IACH,mBAHW,YAAY,EA8BtB;IArBG;;;OAGG;IACH,OAFU,YAAY,CAEJ;IAIlB,YAAkB;IAMlB,kBAAkE;IAGlE,mCAAwD;IACxD,yCAAoE;IAgBxE,oBAUC;CACJ;iBA5DgB,eAAe;sBACV,uBAAuB"}
+{"version":3,"file":"NotificationView.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/notify/NotificationView.js"],"names":[],"mappings":";AAKA;IACI;;;;OAIG;IACH,mBAHW,YAAY,EA8BtB;IArBG;;;OAGG;IACH,OAFU,YAAY,CAEJ;IAIlB,YAAkB;IAMlB,kBAAkE;IAGlE,mCAAwD;IACxD,yCAAoE;IAoBxE,oBAUC;CACJ;iBAhEgB,eAAe;sBACV,uBAAuB"}

package/src/view/elements/notify/NotificationView.js

@@ -39,6 +39,10 @@ class NotificationView extends View {
     }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
         super.link();
 
         const model = this.model;

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":"AAWA;IACI;;;;;;OAMG;IACH;QAJgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;OA6HlB;IAjHG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAGtB;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IAQvC,qBAAiE;IAGjE,2BAAuB;IASvB,sBAAyD;IAIzD,yBAAoC;IAMpC;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAqB/C,eAGC;IAED,qBAQC;IAED,wBAGC;IAED,uBAkGC;IAED,mBAyBC;CACJ;iBA1SgB,kBAAkB;iBALlB,0CAA0C;sBAOrC,oBAAoB;2BADf,qBAAqB;qBAH3B,6BAA6B;oBAF9B,kCAAkC"}
+{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AAWA;IACI;;;;;;OAMG;IACH;QAJgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;OA6HlB;IAjHG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAGtB;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IAQvC,qBAAiE;IAGjE,2BAAuB;IASvB,sBAAyD;IAIzD,yBAAoC;IAMpC;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IA6B/C,eAGC;IAED,qBAQC;IAED,wBAGC;IAED,uBAkGC;IAED,mBAyBC;CACJ;iBAlTgB,kBAAkB;iBALlB,0CAA0C;sBAOrC,oBAAoB;2BADf,qBAAqB;qBAH3B,6BAA6B;oBAF9B,kCAAkC"}

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

@@ -143,6 +143,10 @@ export class SegmentedResourceBarView extends View {
     }
 
     link() {
+        if (this.isLinked) {
+            return;
+        }
+
 
         super.link();
 
@@ -151,6 +155,10 @@ export class SegmentedResourceBarView extends View {
     }
 
     unlink() {
+        if (!this.isLinked) {
+            return;
+        }
+
         this.__sizeObserver.stop();
 
         super.unlink();

package/src/view/elements/radial/RadialMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RadialMenu.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/radial/RadialMenu.js"],"names":[],"mappings":";AAcA;IAmBI;;;;;;;;;;;;;OAaG;IACH,mBAZW,6BAA6B;QAEZ,OAAO,GAAxB,MAAM;QACW,WAAW,GAA5B,MAAM;QACW,WAAW,GAA5B,MAAM;QACW,UAAU,GAA3B,MAAM;QACW,mBAAmB,GAApC,MAAM;QACW,mBAAmB,GAApC,MAAM;QACW,eAAe,GAAhC,MAAM;QACa,SAAS,GAA5B,MAAM,EAAE;OA8HlB;IA3JD;;;OAGG;IACH,UAFU,KAAK,iBAAiB,CAAC,CAEX;IAEtB;;;OAGG;IACH,UAFU,MAAO,iBAAiB,CAAC,CAErB;IAEd;;;OAGG;IACH,oBAFU,MAAM,CAEO;IA4BnB;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEc;IAC9B;;;OAGG;IACH,aAFU,MAAM,CAEc;IAU9B;;OAEG;IACH,qBAFU,MAAM,CAE8B;IAC9C;;OAEG;IACH,qBAFU,MAAM,CAE8B;IAE9C;;;OAGG;IACH,kBAFU,MAAM,CAEqC;IACrD;;;OAGG;IACH,kBAFU,MAAM,CAEwB;IAExC;;;OAGG;IACH,OAFU,MAAM,CAEsB;IACtC;;;OAGG;IACH,QAFU,MAAM,CAEuB;IAE5B,mBAAuC;IAgClD,6BAA0C;IAO1C,sBAAqC;IAkBzC,eAIC;IAOD,8BAIC;IAED;;;OAGG;IACH,YAFW,6BAA6B,QA+BvC;IAED,mBAsBC;IAED,+BAKC;IAED,qCAeC;IAED,wBAMC;IAED;;;;OAIG;IACH,wBAHW,iBAAiB,QACjB,OAAO,QAmCjB;IAED,8BAQC;IAED;;;OAGG;IACH,qBAFW,MAAM,QA2ChB;IAED,oBAOC;CACJ;iBA5XgB,eAAe;iBAJf,uCAAuC;8BAO1B,wBAAwB;sBAFhC,iBAAiB;oBAJnB,+BAA+B"}
+{"version":3,"file":"RadialMenu.d.ts","sourceRoot":"","sources":["../../../../../src/view/elements/radial/RadialMenu.js"],"names":[],"mappings":";AAcA;IAmBI;;;;;;;;;;;;;OAaG;IACH,mBAZW,6BAA6B;QAEZ,OAAO,GAAxB,MAAM;QACW,WAAW,GAA5B,MAAM;QACW,WAAW,GAA5B,MAAM;QACW,UAAU,GAA3B,MAAM;QACW,mBAAmB,GAApC,MAAM;QACW,mBAAmB,GAApC,MAAM;QACW,eAAe,GAAhC,MAAM;QACa,SAAS,GAA5B,MAAM,EAAE;OA8HlB;IA3JD;;;OAGG;IACH,UAFU,KAAK,iBAAiB,CAAC,CAEX;IAEtB;;;OAGG;IACH,UAFU,MAAO,iBAAiB,CAAC,CAErB;IAEd;;;OAGG;IACH,oBAFU,MAAM,CAEO;IA4BnB;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEc;IAC9B;;;OAGG;IACH,aAFU,MAAM,CAEc;IAU9B;;OAEG;IACH,qBAFU,MAAM,CAE8B;IAC9C;;OAEG;IACH,qBAFU,MAAM,CAE8B;IAE9C;;;OAGG;IACH,kBAFU,MAAM,CAEqC;IACrD;;;OAGG;IACH,kBAFU,MAAM,CAEwB;IAExC;;;OAGG;IACH,OAFU,MAAM,CAEsB;IACtC;;;OAGG;IACH,QAFU,MAAM,CAEuB;IAE5B,mBAAuC;IAgClD,6BAA0C;IAO1C,sBAAqC;IAkBzC,eAIC;IAWD,8BAIC;IAED;;;OAGG;IACH,YAFW,6BAA6B,QA+BvC;IAED,mBAsBC;IAED,+BAKC;IAED,qCAeC;IAED,wBAMC;IAED;;;;OAIG;IACH,wBAHW,iBAAiB,QACjB,OAAO,QAmCjB;IAED,8BAQC;IAED;;;OAGG;IACH,qBAFW,MAAM,QA2ChB;IAED,oBAOC;CACJ;iBAhYgB,eAAe;iBAJf,uCAAuC;8BAO1B,wBAAwB;sBAFhC,iBAAiB;oBAJnB,+BAA+B"}