@genome-spy/core 0.78.0 → 0.79.1

package/dist/src/marks/mark.js

@@ -9,7 +9,7 @@ import {
     setUniformBlock,
     setUniforms,
 } from "twgl.js";
-import { isContinuous, isDiscrete } from "vega-scale";
+import { isContinuous, isDiscrete, isDiscretizing } from "vega-scale";
 import createEncoders, {
     findChannelDefWithScale,
     getSecondaryChannel,
@@ -29,6 +29,7 @@ import {
     generateDynamicValueGlslAndUniform,
     splitLargeHighPrecision,
     getRangeForGlsl,
+    getDiscretizingDomainForGlsl,
     getAttributeAndArrayTypes,
     generateDataGlsl,
     generateDatumGlslAndUniform,
@@ -65,6 +66,11 @@ export const SAMPLE_FACET_TEXTURE = "SAMPLE_FACET_TEXTURE";
 
 export const SELECTION_TEXTURE_PREFIX = "uSelectionTexture_";
 
+/**
+ * @typedef {import("../types/rendering.js").ClipOptions} ClipOptions
+ * @typedef {import("../view/layout/rectangle.js").default} Rectangle
+ */
+
 /**
  *
  * @typedef {import("../types/rendering.js").RenderingOptions} RenderingOptions
@@ -80,6 +86,14 @@ export const SELECTION_TEXTURE_PREFIX = "uSelectionTexture_";
  * @typedef {"intersects" | "encloses" | "endpoints"} HitTestMode
  */
 
+/**
+ * @typedef {object} MarkDebugState
+ * @prop {boolean} markUniformsAltered
+ * @prop {number | undefined} vertexCount
+ * @prop {number | undefined} allocatedVertices
+ * @prop {Record<string, any>} properties
+ */
+
 /**
  * @template {MarkProps} [P=MarkProps]
  */
@@ -184,19 +198,22 @@ export default class Mark {
             get clip() {
                 return getCachedOrCall(mark, "defaultClip", () => {
                     // TODO: Only check channels that are used
-                    // TODO: provide more fine-grained xClip and yClip props
-                    for (const channel of /** @type {import("../spec/channel.js").PositionalChannel[]} */ ([
-                        "x",
-                        "y",
-                    ])) {
-                        if (
-                            unitView.getScaleResolution(channel)?.isZoomable()
-                        ) {
-                            return true;
-                        }
+                    const clipX = unitView
+                        .getScaleResolution("x")
+                        ?.isZoomable();
+                    const clipY = unitView
+                        .getScaleResolution("y")
+                        ?.isZoomable();
+
+                    if (clipX && clipY) {
+                        return true;
+                    } else if (clipX) {
+                        return "x";
+                    } else if (clipY) {
+                        return "y";
+                    } else {
+                        return false;
                     }
-
-                    return false;
                 });
             },
             xOffset: 0,
@@ -493,9 +510,15 @@ export default class Mark {
         const shaderChannels = this.getAttributes();
         const encoders = this.encoders;
         const sampleFacetMode = this.getSampleFacetMode();
+        const useVisibleRangeCulling = Boolean(
+            this.properties.cullByVisibleRange
+        );
         if (sampleFacetMode) {
             extraHeaders.push(`#define ${sampleFacetMode}`);
         }
+        if (useVisibleRangeCulling) {
+            extraHeaders.push("#define VISIBLE_RANGE_CULLING");
+        }
 
         // For debugging
         const debugHeader = "// view: " + this.unitView.getPathString();
@@ -884,9 +907,14 @@ export default class Mark {
                         const domainSetter =
                             this.createMarkUniformSetter(domainUniformName);
                         const set = () => {
-                            const domain = isDiscrete(scale.type)
-                                ? [0, scale.domain().length]
-                                : scale.domain();
+                            let domain;
+                            if (isDiscrete(scale.type)) {
+                                domain = [0, scale.domain().length];
+                            } else if (isDiscretizing(scale.type)) {
+                                domain = getDiscretizingDomainForGlsl(scale);
+                            } else {
+                                domain = scale.domain();
+                            }
 
                             domainSetter(
                                 isHighPrecisionScale(scale.type)
@@ -1212,6 +1240,34 @@ export default class Mark {
         return true;
     }
 
+    /**
+     * @returns {MarkDebugState}
+     */
+    getDebugState() {
+        const specProperties =
+            typeof this.unitView.spec.mark == "object"
+                ? this.unitView.spec.mark
+                : {};
+        const propertyKeys = new Set([
+            ...Object.keys(this.defaultProperties),
+            ...Object.keys(specProperties),
+        ]);
+        /** @type {Record<string, any>} */
+        const properties = {};
+        for (const key of propertyKeys) {
+            properties[key] = /** @type {Record<string, any>} */ (
+                this.properties
+            )[key];
+        }
+
+        return {
+            markUniformsAltered: this.markUniformsAltered,
+            vertexCount: this.bufferInfo?.numElements,
+            allocatedVertices: this.bufferInfo?.allocatedVertices,
+            properties,
+        };
+    }
+
     /**
      * @protected
      */
@@ -1437,10 +1493,11 @@ export default class Mark {
      * @param {{width: number, height: number}} canvasSize Size of the canvas in logical pixels
      * @param {number} dpr Device pixel ratio
      * @param {import("../view/layout/rectangle.js").default} coords
-     * @param {import("../view/layout/rectangle.js").default} [clipRect]
+     * @param {ClipOptions} [clip]
+     * @param {ClipOptions} [cullClip]
      * @returns {boolean} true if the viewport is renderable (size > 0)
      */
-    setViewport(canvasSize, dpr, coords, clipRect) {
+    setViewport(canvasSize, dpr, coords, clip, cullClip) {
         coords = coords.flatten();
 
         const gl = this.gl;
@@ -1457,41 +1514,24 @@ export default class Mark {
         /** @type {object} */
         let uniforms;
 
-        let clippedCoords = coords;
-
-        if (props.clip !== "never" && (props.clip || clipRect)) {
-            let xClipOffset = 0;
-            let yClipOffset = 0;
-
-            /** @type {[number, number]} */
-            let uViewScale;
-
-            if (clipRect) {
-                // The following fails with axes that are handled by a GridView
-                // that itself is scrollable. The axes are clipped to the viewport
-                // but also to the axis view, resulting in clipped axes where
-                // not necessary.
-                clippedCoords = coords.intersect(clipRect).flatten();
-                if (!clippedCoords.isDefined()) {
-                    return false;
-                }
-
-                uViewScale = [
-                    coords.width / clippedCoords.width,
-                    coords.height / clippedCoords.height,
-                ];
+        const viewportScope = createViewportScope(
+            canvasSize,
+            coords,
+            props.clip === "never" ? undefined : clip,
+            false
+        );
+        const scopedCoords = viewportScope.coords;
 
-                yClipOffset = Math.max(0, coords.y2 - clipRect.y2);
-                xClipOffset = Math.min(0, coords.x - clipRect.x);
-            } else {
-                uViewScale = [1, 1];
+        if (viewportScope.requiresScissor) {
+            if (!scopedCoords.isDefined()) {
+                return false;
             }
 
             const physicalGlCoords = [
-                clippedCoords.x,
-                canvasSize.height - clippedCoords.y2,
-                clippedCoords.width,
-                clippedCoords.height,
+                scopedCoords.x,
+                canvasSize.height - scopedCoords.y2,
+                scopedCoords.width,
+                scopedCoords.height,
             ].map((x) => x * dpr);
 
             // Because glViewport accepts only integers, we subtract the rounding
@@ -1510,12 +1550,15 @@ export default class Mark {
 
             uniforms = {
                 uViewOffset: [
-                    (xOffset + xClipOffset + xError / dpr) /
-                        clippedCoords.width,
-                    -(yOffset + yClipOffset - yError / dpr) /
-                        clippedCoords.height,
+                    (coords.x - scopedCoords.x + xOffset + xError / dpr) /
+                        scopedCoords.width,
+                    (scopedCoords.y2 - coords.y2 - yOffset + yError / dpr) /
+                        scopedCoords.height,
+                ],
+                uViewScale: [
+                    coords.width / scopedCoords.width,
+                    coords.height / scopedCoords.height,
                 ],
-                uViewScale,
             };
         } else {
             if (!coords.isDefined()) {
@@ -1548,6 +1591,17 @@ export default class Mark {
         setBlockUniforms(this.viewUniformInfo, {
             ...uniforms,
             uViewportSize: [coords.width, coords.height],
+            uLogicalVisibleRect: createLogicalVisibleRect(coords, cullClip),
+            uCullByVisibleRange: [
+                props.cullByVisibleRange === true ||
+                props.cullByVisibleRange === "x"
+                    ? 1
+                    : 0,
+                props.cullByVisibleRange === true ||
+                props.cullByVisibleRange === "y"
+                    ? 1
+                    : 0,
+            ],
             uDevicePixelRatio: dpr,
         });
 
@@ -1617,3 +1671,53 @@ class RangeMap extends InternMap {
         }
     }
 }
+
+/**
+ * @param {{ width: number, height: number }} canvasSize
+ * @param {Rectangle} coords
+ * @param {ClipOptions | undefined} clip
+ * @param {boolean} [clipSelf]
+ */
+export function createViewportScope(canvasSize, coords, clip, clipSelf = true) {
+    if (!clip || (!clip.clipX && !clip.clipY)) {
+        return {
+            requiresScissor: false,
+            coords,
+        };
+    }
+
+    let clippedCoords = clipSelf ? coords.intersect(clip.rect) : clip.rect;
+
+    if (!clip.clipX) {
+        clippedCoords = clippedCoords.modify({
+            x: 0,
+            width: canvasSize.width,
+        });
+    }
+
+    if (!clip.clipY) {
+        clippedCoords = clippedCoords.modify({
+            y: 0,
+            height: canvasSize.height,
+        });
+    }
+
+    return {
+        requiresScissor: true,
+        coords: clippedCoords.flatten(),
+    };
+}
+
+/**
+ * @param {Rectangle} coords
+ * @param {ClipOptions | undefined} clip
+ * @returns {[number, number, number, number]}
+ */
+export function createLogicalVisibleRect(coords, clip) {
+    const x1 = clip?.clipX ? (clip.rect.x - coords.x) / coords.width : 0;
+    const x2 = clip?.clipX ? (clip.rect.x2 - coords.x) / coords.width : 1;
+    const y1 = clip?.clipY ? (coords.y2 - clip.rect.y2) / coords.height : 0;
+    const y2 = clip?.clipY ? (coords.y2 - clip.rect.y) / coords.height : 1;
+
+    return [x1, y1, x2, y2];
+}

package/dist/src/marks/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/marks/point.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH;IAGI;;OAEG;IACH,sBAFW,OAAO,qBAAqB,EAAE,OAAO,EAyB/C;IA6EO,iDAMC;IAkET,+BAkBC;;CAgDJ;iBAhQgB,WAAW"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/marks/point.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH;IAGI;;OAEG;IACH,sBAFW,OAAO,qBAAqB,EAAE,OAAO,EAyB/C;IA6EO,iDAMC;IAkET,+BAsBC;;CAgDJ;iBApQgB,WAAW"}

package/dist/src/marks/point.js

@@ -201,6 +201,10 @@ export default class PointMark extends Mark {
 
     getSemanticThreshold() {
         if (this.sampledSemanticScores) {
+            if (this.sampledSemanticScores.length === 0) {
+                return -1;
+            }
+
             const p = Math.max(
                 0,
                 1 - this.#semanticZoomFraction() * this.unitView.getZoomLevel()

package/dist/src/marks/point.vertex.glsl.js

@@ -1,2 +1,2 @@
-const shader = "flat out float vRadius;flat out float vRadiusWithPadding;flat out lowp vec4 vFillColor;flat out lowp vec4 vStrokeColor;flat out lowp float vShape;flat out lowp float vHalfStrokeWidth;flat out mat2 vRotationMatrix;const float CIRCLE=0.0;const float SQUARE=1.0;const float CROSS=2.0;const float DIAMOND=3.0;const float TRIANGLE_UP=4.0;const float TRIANGLE_RIGHT=5.0;const float TRIANGLE_DOWN=6.0;const float TRIANGLE_LEFT=7.0;const float TICK_UP=8.0;const float TICK_RIGHT=9.0;const float TICK_DOWN=10.0;const float TICK_LEFT=11.0;float computeSemanticThresholdFactor(){return getScaled_semanticScore()>=uSemanticThreshold ? 1.0 : 0.0;}vec2 getDxDy(){\n#if defined(dx_DEFINED) || defined(dy_DEFINED)\nreturn vec2(getScaled_dx(),getScaled_dy())/uViewportSize;\n#else\nreturn vec2(0.0,0.0);\n#endif\n}void main(void){float shapeAngle=0.0;float semanticThresholdFactor=isPointSelected()? 1.0: computeSemanticThresholdFactor();if(semanticThresholdFactor<=0.0){gl_PointSize=0.0;gl_Position=vec4(100.0,0.0,0.0,0.0);return;}float size=getScaled_size();vec2 pos=vec2(getScaled_x(),getScaled_y())+getDxDy();gl_Position=unitToNdc(applySampleFacet(pos));float strokeWidth=getScaled_strokeWidth();float diameter=sqrt(size)*uScaleFactor*semanticThresholdFactor;float opacity=uViewOpacity;if(strokeWidth<=0.0||uInwardStroke){float minDiameter=1.0/uDevicePixelRatio;if(diameter<minDiameter){opacity*=pow(diameter/minDiameter,2.5);diameter=minDiameter;}}float fillOpa=getScaled_fillOpacity()*opacity;float strokeOpa=getScaled_strokeOpacity()*opacity;vShape=getScaled_shape();bool circle=vShape==0.0;if(vShape>TICK_UP&&vShape<=TICK_LEFT){shapeAngle=(vShape-TICK_UP)*90.0;vShape=TICK_UP;}else if(vShape>TRIANGLE_UP&&vShape<=TRIANGLE_LEFT){shapeAngle=(vShape-TRIANGLE_UP)*90.0;vShape=TRIANGLE_UP;}float angleInDegrees=getScaled_angle();float angle=-(shapeAngle+angleInDegrees)*PI/180.0;float sinTheta=sin(angle);float cosTheta=cos(angle);vRotationMatrix=mat2(cosTheta,sinTheta,-sinTheta,cosTheta);float roomForRotation=circle ? 1.0 : sin(mod(angle,PI/2.0)+PI/4.0)/sin(PI/4.0);float aaPadding=1.0/uDevicePixelRatio;float rotationPadding=(diameter*roomForRotation)-diameter;float strokePadding=uInwardStroke ? 0.0 : strokeWidth*(circle ? 1.0 : sqrt(3.0));float padding=rotationPadding+strokePadding+aaPadding;gl_PointSize=max((diameter+padding),uPickingEnabled ? uMinPickingSize : 0.0)*uDevicePixelRatio;vRadius=diameter/2.0;vRadiusWithPadding=vRadius+padding/2.0;vHalfStrokeWidth=strokeWidth/2.0;vFillColor=vec4(getScaled_fill()*fillOpa,fillOpa);vStrokeColor=vec4(getScaled_stroke()*strokeOpa,strokeOpa);setupPicking();}";
+const shader = "flat out float vRadius;flat out float vRadiusWithPadding;flat out lowp vec4 vFillColor;flat out lowp vec4 vStrokeColor;flat out lowp float vShape;flat out lowp float vHalfStrokeWidth;flat out mat2 vRotationMatrix;const float CIRCLE=0.0;const float SQUARE=1.0;const float CROSS=2.0;const float DIAMOND=3.0;const float TRIANGLE_UP=4.0;const float TRIANGLE_RIGHT=5.0;const float TRIANGLE_DOWN=6.0;const float TRIANGLE_LEFT=7.0;const float TICK_UP=8.0;const float TICK_RIGHT=9.0;const float TICK_DOWN=10.0;const float TICK_LEFT=11.0;float computeSemanticThresholdFactor(){return getScaled_semanticScore()>=uSemanticThreshold ? 1.0 : 0.0;}vec2 getDxDy(){\n#if defined(dx_DEFINED) || defined(dy_DEFINED)\nreturn vec2(getScaled_dx(),getScaled_dy())/uViewportSize;\n#else\nreturn vec2(0.0,0.0);\n#endif\n}void main(void){float shapeAngle=0.0;float semanticThresholdFactor=isPointSelected()? 1.0: computeSemanticThresholdFactor();if(semanticThresholdFactor<=0.0){gl_PointSize=0.0;gl_Position=vec4(100.0,0.0,0.0,0.0);return;}float size=getScaled_size();vec2 pos=vec2(getScaled_x(),getScaled_y())+getDxDy();vec2 facetedPos=applySampleFacet(pos);\n#ifdef VISIBLE_RANGE_CULLING\nif(isOutsideVisibleRange(facetedPos)){gl_PointSize=0.0;gl_Position=vec4(100.0,0.0,0.0,0.0);return;}\n#endif\ngl_Position=unitToNdc(facetedPos);float strokeWidth=getScaled_strokeWidth();float diameter=sqrt(size)*uScaleFactor*semanticThresholdFactor;float opacity=uViewOpacity;if(strokeWidth<=0.0||uInwardStroke){float minDiameter=1.0/uDevicePixelRatio;if(diameter<minDiameter){opacity*=pow(diameter/minDiameter,2.5);diameter=minDiameter;}}float fillOpa=getScaled_fillOpacity()*opacity;float strokeOpa=getScaled_strokeOpacity()*opacity;vShape=getScaled_shape();bool circle=vShape==0.0;if(vShape>TICK_UP&&vShape<=TICK_LEFT){shapeAngle=(vShape-TICK_UP)*90.0;vShape=TICK_UP;}else if(vShape>TRIANGLE_UP&&vShape<=TRIANGLE_LEFT){shapeAngle=(vShape-TRIANGLE_UP)*90.0;vShape=TRIANGLE_UP;}float angleInDegrees=getScaled_angle();float angle=-(shapeAngle+angleInDegrees)*PI/180.0;float sinTheta=sin(angle);float cosTheta=cos(angle);vRotationMatrix=mat2(cosTheta,sinTheta,-sinTheta,cosTheta);float roomForRotation=circle ? 1.0 : sin(mod(angle,PI/2.0)+PI/4.0)/sin(PI/4.0);float aaPadding=1.0/uDevicePixelRatio;float rotationPadding=(diameter*roomForRotation)-diameter;float strokePadding=uInwardStroke ? 0.0 : strokeWidth*(circle ? 1.0 : sqrt(3.0));float padding=rotationPadding+strokePadding+aaPadding;gl_PointSize=max((diameter+padding),uPickingEnabled ? uMinPickingSize : 0.0)*uDevicePixelRatio;vRadius=diameter/2.0;vRadiusWithPadding=vRadius+padding/2.0;vHalfStrokeWidth=strokeWidth/2.0;vFillColor=vec4(getScaled_fill()*fillOpa,fillOpa);vStrokeColor=vec4(getScaled_stroke()*strokeOpa,strokeOpa);setupPicking();}";
 export default shader;

package/dist/src/marks/text.d.ts

@@ -16,7 +16,7 @@ export default class TextMark extends Mark<import("../spec/mark.js").TextProps>
      * @param {import("../view/unitView.js").default} unitView
      */
     constructor(unitView: import("../view/unitView.js").default);
-    font: import("../fonts/bmFontManager.js").FontEntry;
+    font: import("../fonts/textMetrics.js").FontEntryLike;
 }
 import Mark from "./mark.js";
 //# sourceMappingURL=text.d.ts.map

package/dist/src/marks/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/marks/text.js"],"names":[],"mappings":"AAiCA;;;;;;;;;GASG;AACH;IACI;;OAEG;IACH;;OAEG;IACH,sBAFW,OAAO,qBAAqB,EAAE,OAAO,EAiB/C;IAbG,oDAMmD;CAyM1D;iBAtPgB,WAAW"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/marks/text.js"],"names":[],"mappings":"AAkCA;;;;;;;;;GASG;AACH;IACI;;OAEG;IACH;;OAEG;IACH,sBAFW,OAAO,qBAAqB,EAAE,OAAO,EAW/C;IAPG,sDAAsE;CAyM7E;iBAjPgB,WAAW"}

package/dist/src/marks/text.js

@@ -14,6 +14,7 @@ import { TextVertexBuilder } from "../gl/dataToVertices.js";
 import Mark from "./mark.js";
 import { fixCoveragePositional, fixHalfOpenRangedText } from "./markUtils.js";
 import { primaryPositionalChannels } from "../encoder/encoder.js";
+import { requestFont } from "../fonts/textMetrics.js";
 
 /** For GLSL uniforms */
 const alignments = {
@@ -50,13 +51,7 @@ export default class TextMark extends Mark {
      */
     constructor(unitView) {
         super(unitView);
-        this.font = this.properties.font
-            ? unitView.context.fontManager.getFont(
-                  this.properties.font,
-                  this.properties.fontStyle,
-                  this.properties.fontWeight
-              )
-            : unitView.context.fontManager.getDefaultFont();
+        this.font = requestFont(unitView.context.fontManager, this.properties);
 
         this.setupExprRefsNeedingGraphicsUpdate([
             "text",

package/dist/src/marks/text.vertex.glsl.js

@@ -1,2 +1,2 @@
-const shader = "in mediump vec2 vertexCoord;in lowp vec2 textureCoord;in float width;out vec2 vTexCoord;out float vEdgeFadeOpacity;flat out vec4 vColor;flat out float vSlope;flat out float vGamma;struct RangeResult{float pos;float scale;};float minValue(vec4 v){return min(min(v.x,v.y),min(v.z,v.w));}float maxValue(vec4 v){return max(max(v.x,v.y),max(v.z,v.w));}/***All measures are in[0,1]*/RangeResult positionInsideRange(float a,float b,float width,float padding,int align,bool flush){float span=b-a;float paddedWidth=width+2.0*padding;if(a>1.0||b<0.0){return RangeResult(0.0,0.0);}float extra=max(0.0,span-paddedWidth);float pos;if(align==0){float centre=a+b;if(flush){float leftOver=max(0.0,paddedWidth-centre);centre+=min(leftOver,extra);float rightOver=max(0.0,paddedWidth+centre-2.0);centre-=min(rightOver,extra);}pos=centre/2.0;}else if(align<0){float edge=a;if(flush){float over=max(0.0,-edge);edge+=min(over,extra);}pos=edge+padding;}else{float edge=b;if(flush){float over=max(0.0,edge-1.0);edge-=min(over,extra);}pos=edge-padding;}float scale=clamp((span-padding)/paddedWidth,0.0,1.0);return RangeResult(pos,scale);}vec2 calculateRotatedDimensions(float width,mat2 rotationMatrix){vec2 a=abs(rotationMatrix*vec2(width/2.0,0.5));vec2 b=abs(rotationMatrix*vec2(width/2.0,-0.5));return vec2(max(a.x,b.x),max(a.y,b.y))*2.0;}ivec2 fixAlignForAngle(ivec2 align,float angleInDegrees){float a=mod(angleInDegrees+45.0,360.0);int x=align.x;int y=-align.y;if(a<90.0){return ivec2(x,y);}else if(a<180.0){return ivec2(y,-x);}else if(a<270.0){return ivec2(-x,y);}else{return ivec2(-y,x);}}void main(void){float opacity=getScaled_opacity()*uViewOpacity;vec2 size=vec2(getScaled_size());float x=getScaled_x();float y=getScaled_y();float scale=1.0;float angleInDegrees=getScaled_angle();float angle=-angleInDegrees*PI/180.0;float sinTheta=sin(angle);float cosTheta=cos(angle);mat2 rotationMatrix=mat2(cosTheta,sinTheta,-sinTheta,cosTheta);vec2 flushSize=calculateRotatedDimensions(width,rotationMatrix);\n#if defined(x2_DEFINED) || defined(y2_DEFINED)\nivec2 align=fixAlignForAngle(uAlign,angleInDegrees);\n#else\nivec2 align=uAlign;\n#endif\n#ifdef x2_DEFINED\nfloat x2=getScaled_x2();if(uLogoLetter){size.x=(x2-x)*uViewportSize.x;x+=(x2-x)/2.0;}else{float x2=getScaled_x2();RangeResult result=positionInsideRange(min(x,x2),max(x,x2),size.x*scale*flushSize.x/uViewportSize.x,uPaddingX/uViewportSize.x,align.x,uFlushX);x=result.pos;scale*=result.scale;}\n#endif\nvec2 pos=applySampleFacet(vec2(x,y));\n#ifdef y2_DEFINED\nfloat y2=getScaled_y2();vec2 pos2=applySampleFacet(vec2(x,y2));if(uLogoLetter){size.y=(pos2.y-pos.y)*uViewportSize.y;pos.y+=(pos2.y-pos.y)/2.0;}else{RangeResult result=positionInsideRange(min(pos.y,pos2.y),max(pos.y,pos2.y),size.y*scale*flushSize.y/uViewportSize.y,uPaddingY/uViewportSize.y,align.y,uFlushY);pos.y=result.pos;scale*=result.scale;}\n#endif\nif(scale<1.0){if(uSqueeze){vec2 scaleFadeExtent=vec2(3.0,6.0)/size;if(scale<scaleFadeExtent[0]){gl_Position=vec4(0.0);return;}size*=scale;opacity*=linearstep(scaleFadeExtent[0],scaleFadeExtent[1],scale);}else if(scale<1.0){gl_Position=vec4(0.0);return;}}vec2 charPos=rotationMatrix*(vertexCoord*size+uD);vec2 unitPos=pos+charPos/uViewportSize;gl_Position=unitToNdc(unitPos);vSlope=max(1.0,min(size.x,size.y)/uSdfNumerator*uDevicePixelRatio);vec3 color=getScaled_color();vColor=vec4(color*opacity,opacity);vGamma=getGammaForColor(color);vTexCoord=textureCoord;if(maxValue(uViewportEdgeFadeDistance)>-pow(10.0,10.0)){vEdgeFadeOpacity=minValue(((vec4(1.0,1.0,0.0,0.0)+vec4(-1.0,-1.0,1.0,1.0)*unitPos.yxyx)*uViewportSize.yxyx-uViewportEdgeFadeDistance)/uViewportEdgeFadeWidth);}else{vEdgeFadeOpacity=1.0;}setupPicking();}";
+const shader = "in mediump vec2 vertexCoord;in lowp vec2 textureCoord;in float width;out vec2 vTexCoord;out float vEdgeFadeOpacity;flat out vec4 vColor;flat out float vSlope;flat out float vGamma;struct RangeResult{float pos;float scale;};float minValue(vec4 v){return min(min(v.x,v.y),min(v.z,v.w));}float maxValue(vec4 v){return max(max(v.x,v.y),max(v.z,v.w));}/***All measures are in[0,1]*/RangeResult positionInsideRange(float a,float b,float width,float padding,int align,bool flush){float span=b-a;float paddedWidth=width+2.0*padding;if(a>1.0||b<0.0){return RangeResult(0.0,0.0);}float extra=max(0.0,span-paddedWidth);float pos;if(align==0){float centre=a+b;if(flush){float leftOver=max(0.0,paddedWidth-centre);centre+=min(leftOver,extra);float rightOver=max(0.0,paddedWidth+centre-2.0);centre-=min(rightOver,extra);}pos=centre/2.0;}else if(align<0){float edge=a;if(flush){float over=max(0.0,-edge);edge+=min(over,extra);}pos=edge+padding;}else{float edge=b;if(flush){float over=max(0.0,edge-1.0);edge-=min(over,extra);}pos=edge-padding;}float scale=clamp((span-padding)/paddedWidth,0.0,1.0);return RangeResult(pos,scale);}vec2 calculateRotatedDimensions(float width,mat2 rotationMatrix){vec2 a=abs(rotationMatrix*vec2(width/2.0,0.5));vec2 b=abs(rotationMatrix*vec2(width/2.0,-0.5));return vec2(max(a.x,b.x),max(a.y,b.y))*2.0;}ivec2 fixAlignForAngle(ivec2 align,float angleInDegrees){float a=mod(angleInDegrees+45.0,360.0);int x=align.x;int y=-align.y;if(a<90.0){return ivec2(x,y);}else if(a<180.0){return ivec2(y,-x);}else if(a<270.0){return ivec2(-x,y);}else{return ivec2(-y,x);}}void main(void){float opacity=getScaled_opacity()*uViewOpacity;vec2 size=vec2(getScaled_size());float x=getScaled_x();float y=getScaled_y();float scale=1.0;float angleInDegrees=getScaled_angle();float angle=-angleInDegrees*PI/180.0;float sinTheta=sin(angle);float cosTheta=cos(angle);mat2 rotationMatrix=mat2(cosTheta,sinTheta,-sinTheta,cosTheta);vec2 flushSize=calculateRotatedDimensions(width,rotationMatrix);\n#if defined(x2_DEFINED) || defined(y2_DEFINED)\nivec2 align=fixAlignForAngle(uAlign,angleInDegrees);\n#else\nivec2 align=uAlign;\n#endif\n#ifdef x2_DEFINED\nfloat x2=getScaled_x2();if(uLogoLetter){size.x=(x2-x)*uViewportSize.x;x+=(x2-x)/2.0;}else{float x2=getScaled_x2();RangeResult result=positionInsideRange(min(x,x2),max(x,x2),size.x*scale*flushSize.x/uViewportSize.x,uPaddingX/uViewportSize.x,align.x,uFlushX);x=result.pos;scale*=result.scale;}\n#endif\nvec2 pos=applySampleFacet(vec2(x,y));\n#ifdef y2_DEFINED\nfloat y2=getScaled_y2();vec2 pos2=applySampleFacet(vec2(x,y2));if(uLogoLetter){size.y=(pos2.y-pos.y)*uViewportSize.y;pos.y+=(pos2.y-pos.y)/2.0;}else{RangeResult result=positionInsideRange(min(pos.y,pos2.y),max(pos.y,pos2.y),size.y*scale*flushSize.y/uViewportSize.y,uPaddingY/uViewportSize.y,align.y,uFlushY);pos.y=result.pos;scale*=result.scale;}\n#endif\n#ifdef VISIBLE_RANGE_CULLING\nif(isOutsideVisibleRange(pos)){gl_Position=vec4(0.0);return;}\n#endif\nif(scale<1.0){if(uSqueeze){vec2 scaleFadeExtent=vec2(3.0,6.0)/size;if(scale<scaleFadeExtent[0]){gl_Position=vec4(0.0);return;}size*=scale;opacity*=linearstep(scaleFadeExtent[0],scaleFadeExtent[1],scale);}else if(scale<1.0){gl_Position=vec4(0.0);return;}}vec2 charPos=rotationMatrix*(vertexCoord*size+uD);vec2 unitPos=pos+charPos/uViewportSize;gl_Position=unitToNdc(unitPos);vSlope=max(1.0,min(size.x,size.y)/uSdfNumerator*uDevicePixelRatio);vec3 color=getScaled_color();vColor=vec4(color*opacity,opacity);vGamma=getGammaForColor(color);vTexCoord=textureCoord;if(maxValue(uViewportEdgeFadeDistance)>-pow(10.0,10.0)){vEdgeFadeOpacity=minValue(((vec4(1.0,1.0,0.0,0.0)+vec4(-1.0,-1.0,1.0,1.0)*unitPos.yxyx)*uViewportSize.yxyx-uViewportEdgeFadeDistance)/uViewportEdgeFadeWidth);}else{vEdgeFadeOpacity=1.0;}setupPicking();}";
 export default shader;

package/dist/src/paramRuntime/paramUtils.d.ts

@@ -5,6 +5,23 @@
  *   identifier: () => string
  * }} ExprRefFunction
  */
+/**
+ * @typedef {{
+ *   scopeOwned?: boolean,
+ *   registerDisposer?: (disposer: () => void) => void
+ * }} WatchExpressionOptions
+ */
+/**
+ * @typedef {{
+ *   createExpression: (expr: string) => ExprRefFunction,
+ *   watchExpression?: (
+ *     expr: string,
+ *     listener: () => void,
+ *     options?: WatchExpressionOptions
+ *   ) => ExprRefFunction,
+ *   whenPropagated?: () => Promise<void>
+ * }} ExprRefRuntime
+ */
 /**
  * @param {any} x
  * @returns {x is import("../spec/parameter.js").ExprRef}
@@ -53,7 +70,7 @@ export function getDefaultParamValue(param: import("../spec/parameter.js").Param
  * ExprRefs to getters and setups a listener that is called when any of the
  * expressions (upstream parameters) change.
  *
- * @param {{ createExpression: (expr: string) => ExprRefFunction, watchExpression?: (expr: string, listener: () => void, options?: { scopeOwned?: boolean, registerDisposer?: (disposer: () => void) => void }) => ExprRefFunction, whenPropagated?: () => Promise<void> }} paramRuntime
+ * @param {ExprRefRuntime} paramRuntime
  * @param {T} props The properties object
  * @param {(props: ReadonlySet<keyof T>) => void} [listener] Listener to be called when any of the expressions change
  * @param {(disposer: () => void) => void} [registerDisposer]
@@ -61,16 +78,24 @@ export function getDefaultParamValue(param: import("../spec/parameter.js").Param
  * @returns T
  * @template {Record<string, any | import("../spec/parameter.js").ExprRef>} T
  */
-export function activateExprRefProps<T extends Record<string, any | import("../spec/parameter.js").ExprRef>>(paramRuntime: {
-    createExpression: (expr: string) => ExprRefFunction;
-    watchExpression?: (expr: string, listener: () => void, options?: {
-        scopeOwned?: boolean;
-        registerDisposer?: (disposer: () => void) => void;
-    }) => ExprRefFunction;
-    whenPropagated?: () => Promise<void>;
-}, props: T, listener?: (props: ReadonlySet<keyof T>) => void, registerDisposer?: (disposer: () => void) => void, options?: {
+export function activateExprRefProps<T extends Record<string, any | import("../spec/parameter.js").ExprRef>>(paramRuntime: ExprRefRuntime, props: T, listener?: (props: ReadonlySet<keyof T>) => void, registerDisposer?: (disposer: () => void) => void, options?: {
     batchMode?: "microtask" | "whenPropagated";
 }): T;
+/**
+ * Resolves a literal or ExprRef for properties that may be parameterized during
+ * view construction but are not safe to update reactively. This is intended for
+ * structural options, such as layout regions or view ownership, where a later
+ * value change would require rebuilding part of the view hierarchy. ExprRefs
+ * are evaluated once and subscribed with a fail-fast listener.
+ *
+ * @param {ExprRefRuntime} paramRuntime
+ * @param {T | import("../spec/parameter.js").ExprRef} value
+ * @param {string} errorMessage Error thrown if an ExprRef changes after initialization
+ * @param {(disposer: () => void) => void} [registerDisposer]
+ * @returns {T}
+ * @template T
+ */
+export function resolveInitOnlyExprRef<T>(paramRuntime: ExprRefRuntime, value: T | import("../spec/parameter.js").ExprRef, errorMessage: string, registerDisposer?: (disposer: () => void) => void): T;
 /**
  * Creates a function that always returns the same value.
  *
@@ -83,4 +108,13 @@ export type ExprRefFunction = import("../utils/expression.js").ExpressionFunctio
     invalidate: () => void;
     identifier: () => string;
 };
+export type WatchExpressionOptions = {
+    scopeOwned?: boolean;
+    registerDisposer?: (disposer: () => void) => void;
+};
+export type ExprRefRuntime = {
+    createExpression: (expr: string) => ExprRefFunction;
+    watchExpression?: (expr: string, listener: () => void, options?: WatchExpressionOptions) => ExprRefFunction;
+    whenPropagated?: () => Promise<void>;
+};
 //# sourceMappingURL=paramUtils.d.ts.map

package/dist/src/paramRuntime/paramUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paramUtils.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/paramUtils.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AAEH;;;GAGG;AACH,6BAHW,GAAG,GACD,CAAC,IAAI,OAAO,sBAAsB,EAAE,OAAO,CAIvD;AAED;;;;;;;GAOG;AACH,+BAHa,CAAC,KADH,CAAC,GAAG,OAAO,sBAAsB,EAAE,OAAO,GAExC,CAAC,CAWb;AAED;;;GAGG;AACH,2CAHW,OAAO,sBAAsB,EAAE,SAAS,GACtC,KAAK,IAAI,OAAO,sBAAsB,EAAE,iBAAiB,CAIrE;AAED;;;GAGG;AACH,4CAHW,OAAO,sBAAsB,EAAE,SAAS,GACtC,KAAK,IAAI,OAAO,sBAAsB,EAAE,kBAAkB,CAItE;AAED;;;;;;GAMG;AACH,4CAHW,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;GAOG;AACH,4CALW,OAAO,sBAAsB,EAAE,SAAS,iBACxC;IAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAA;CAAE,WACvD,eAAe,GACb,GAAG,CA0Cf;AAED;;;;;;;;;;;;GAYG;AACH,qCAF4E,CAAC,SAA/D,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,sBAAsB,EAAE,OAAO,CAAE,gBANhE;IAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IAAC,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;KAAE,KAAK,eAAe,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,SAC/P,CAAC,aACD,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,qBACrC,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,YAC9B;IAAE,SAAS,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAA;CAAE,GAkHnC,CAAC,CACtB;AAED;;;;;GAKG;AACH,2CAHW,GAAG,GACD,eAAe,CAW3B;8BApQY,OAAO,wBAAwB,EAAE,kBAAkB,GAAG;IAC9D,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,MAAM,CAAA;CACzB"}
+{"version":3,"file":"paramUtils.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/paramUtils.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,6BAHW,GAAG,GACD,CAAC,IAAI,OAAO,sBAAsB,EAAE,OAAO,CAIvD;AAED;;;;;;;GAOG;AACH,+BAHa,CAAC,KADH,CAAC,GAAG,OAAO,sBAAsB,EAAE,OAAO,GAExC,CAAC,CAWb;AAED;;;GAGG;AACH,2CAHW,OAAO,sBAAsB,EAAE,SAAS,GACtC,KAAK,IAAI,OAAO,sBAAsB,EAAE,iBAAiB,CAIrE;AAED;;;GAGG;AACH,4CAHW,OAAO,sBAAsB,EAAE,SAAS,GACtC,KAAK,IAAI,OAAO,sBAAsB,EAAE,kBAAkB,CAItE;AAED;;;;;;GAMG;AACH,4CAHW,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;GAOG;AACH,4CALW,OAAO,sBAAsB,EAAE,SAAS,iBACxC;IAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAA;CAAE,WACvD,eAAe,GACb,GAAG,CA0Cf;AAED;;;;;;;;;;;;GAYG;AACH,qCAF4E,CAAC,SAA/D,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,sBAAsB,EAAE,OAAO,CAAE,gBANhE,cAAc,SACd,CAAC,aACD,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,qBACrC,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,YAC9B;IAAE,SAAS,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAA;CAAE,GAkHnC,CAAC,CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,uCAFa,CAAC,gBALH,cAAc,SACd,CAAC,GAAG,OAAO,sBAAsB,EAAE,OAAO,gBAC1C,MAAM,qBACN,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,GAC5B,CAAC,CA4Bb;AAED;;;;;GAKG;AACH,2CAHW,GAAG,GACD,eAAe,CAW3B;8BAhUY,OAAO,wBAAwB,EAAE,kBAAkB,GAAG;IAC9D,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,MAAM,CAAA;CACzB;qCAIS;IACR,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CAClD;6BAIS;IACR,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IACpD,eAAe,CAAC,EAAE,CAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,IAAI,EACpB,OAAO,CAAC,EAAE,sBAAsB,KAC7B,eAAe,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACrC"}

package/dist/src/paramRuntime/paramUtils.js

@@ -16,6 +16,25 @@ import {
  * }} ExprRefFunction
  */
 
+/**
+ * @typedef {{
+ *   scopeOwned?: boolean,
+ *   registerDisposer?: (disposer: () => void) => void
+ * }} WatchExpressionOptions
+ */
+
+/**
+ * @typedef {{
+ *   createExpression: (expr: string) => ExprRefFunction,
+ *   watchExpression?: (
+ *     expr: string,
+ *     listener: () => void,
+ *     options?: WatchExpressionOptions
+ *   ) => ExprRefFunction,
+ *   whenPropagated?: () => Promise<void>
+ * }} ExprRefRuntime
+ */
+
 /**
  * @param {any} x
  * @returns {x is import("../spec/parameter.js").ExprRef}
@@ -133,7 +152,7 @@ export function getDefaultParamValue(param, paramRuntime, exprFn) {
  * ExprRefs to getters and setups a listener that is called when any of the
  * expressions (upstream parameters) change.
  *
- * @param {{ createExpression: (expr: string) => ExprRefFunction, watchExpression?: (expr: string, listener: () => void, options?: { scopeOwned?: boolean, registerDisposer?: (disposer: () => void) => void }) => ExprRefFunction, whenPropagated?: () => Promise<void> }} paramRuntime
+ * @param {ExprRefRuntime} paramRuntime
  * @param {T} props The properties object
  * @param {(props: ReadonlySet<keyof T>) => void} [listener] Listener to be called when any of the expressions change
  * @param {(disposer: () => void) => void} [registerDisposer]
@@ -254,6 +273,47 @@ export function activateExprRefProps(
     return /** @type {T} */ (activatedProps);
 }
 
+/**
+ * Resolves a literal or ExprRef for properties that may be parameterized during
+ * view construction but are not safe to update reactively. This is intended for
+ * structural options, such as layout regions or view ownership, where a later
+ * value change would require rebuilding part of the view hierarchy. ExprRefs
+ * are evaluated once and subscribed with a fail-fast listener.
+ *
+ * @param {ExprRefRuntime} paramRuntime
+ * @param {T | import("../spec/parameter.js").ExprRef} value
+ * @param {string} errorMessage Error thrown if an ExprRef changes after initialization
+ * @param {(disposer: () => void) => void} [registerDisposer]
+ * @returns {T}
+ * @template T
+ */
+export function resolveInitOnlyExprRef(
+    paramRuntime,
+    value,
+    errorMessage,
+    registerDisposer
+) {
+    if (!isExprRef(value)) {
+        return value;
+    }
+
+    const throwUnsupportedChange = () => {
+        throw new Error(errorMessage);
+    };
+    const fn = paramRuntime.watchExpression
+        ? paramRuntime.watchExpression(value.expr, throwUnsupportedChange, {
+              scopeOwned: false,
+              registerDisposer,
+          })
+        : paramRuntime.createExpression(value.expr);
+    if (!paramRuntime.watchExpression) {
+        const unsubscribe = fn.subscribe(throwUnsupportedChange);
+        registerDisposer?.(unsubscribe);
+    }
+
+    return fn();
+}
+
 /**
  * Creates a function that always returns the same value.
  *

package/dist/src/paramRuntime/viewParamRuntime.d.ts

@@ -1,3 +1,18 @@
+/**
+ * @typedef {object} ViewParamRuntimeDebugState
+ * @prop {string} scopeId
+ * @prop {boolean} disposed
+ * @prop {ViewParamDebugState[]} params
+ */
+/**
+ * @typedef {object} ViewParamDebugState
+ * @prop {string} name
+ * @prop {"auto" | "base" | "derived" | "selection" | "push"} kind
+ * @prop {any} value
+ * @prop {boolean} writable
+ * @prop {boolean} configured
+ * @prop {import("../spec/parameter.js").Parameter | undefined} config
+ */
 /**
  * A class that manages parameters and expressions.
  * Supports nesting and scoped parameters through a shared runtime graph.
@@ -97,6 +112,10 @@ export default class ViewParamRuntime {
      * @returns {ViewParamRuntime}
      */
     findRuntimeForParam(paramName: string): ViewParamRuntime;
+    /**
+     * @returns {ViewParamRuntimeDebugState}
+     */
+    getDebugState(): ViewParamRuntimeDebugState;
     /**
      * Parse expr and return a function that returns the value of the parameter.
      *
@@ -168,6 +187,19 @@ export default class ViewParamRuntime {
     hasPointSelections(): boolean;
     #private;
 }
+export type ViewParamRuntimeDebugState = {
+    scopeId: string;
+    disposed: boolean;
+    params: ViewParamDebugState[];
+};
+export type ViewParamDebugState = {
+    name: string;
+    kind: "auto" | "base" | "derived" | "selection" | "push";
+    value: any;
+    writable: boolean;
+    configured: boolean;
+    config: import("../spec/parameter.js").Parameter | undefined;
+};
 /**
  * A class that manages parameters and expressions.
  * Supports nesting and scoped parameters through a shared runtime graph.

package/dist/src/paramRuntime/viewParamRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viewParamRuntime.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/viewParamRuntime.js"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH;IAwCI;;;;;;OAMG;IACH,2BANW,MAAM,gBAAgB,4BACtB,CAAC,OAAO,EAAE,OAAO,oBAAoB,EAAE,gBAAgB,KAAK,OAAO,8BAA8B,EAAE,OAAO,GAAG,SAAS,EAkBhI;IAED;;;;;;;;;;;OAWG;IACH,wEAvEqB,GAAG,KAAK,IAAI,CAkKhC;IAED;;;;;;;OAOG;IACH,eAFa,CAAC,aAJH,MAAM,gBACN,CAAC,YACD,OAAO,GACL,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAgC9B;IAED;;;;;;;;OAQG;IACH,oBAHW,MAAM,SACN,GAAG,QAWb;IAED;;;OAGG;IACH,oBAFW,MAAM,OAIhB;IAED;;;;;;;;OAQG;IACH,qBAJW,MAAM,YACN,MAAM,IAAI,GACR,MAAM,IAAI,CAiBtB;IAED;;;OAGG;IACH,qBAFW,MAAM,OAKhB;IAED;;OAEG;IACH,oBACsB,WAAW,CAAC,MAAM,2CAAY,CAGnD;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,OAAO,CAKnB;IAED;;;;;;;;;;OAUG;IACH,0CAHW,MAAM,GACJ,OAAO,CAanB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,gBAAgB,CAQ5B;IAKD;;;;OAIG;IACH,uBAFW,MAAM,wCAMhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBALW,MAAM,YACN,MAAM,IAAI;;;;;;;qBA3VX,OAAO;;;;;;2BAKP,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI;QAwV3B,eAAe,CAY3B;IA0BD;;;;OAIG;IACH,qBAFW,MAAM,OAKhB;IAED;;;;OAIG;IACH,iBAJa,CAAC,MACH,MAAM,CAAC,GACL,CAAC,CAIb;IAED,iBAEC;IAED;;;;;OAKG;IACH,yBAFW;QAAE,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,iBAItD;IAED,gBAUC;IAED;;;;;OAKG;IACH,sBAFa,OAAO,CAiBnB;;CACJ;;;;;;;;8BA9cY,OAAO,wBAAwB,EAAE,kBAAkB,GAAG;IAAE,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,MAAM,CAAA;CAAC"}
+{"version":3,"file":"viewParamRuntime.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/viewParamRuntime.js"],"names":[],"mappings":"AAmBA;;;;;GAKG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH;IAwCI;;;;;;OAMG;IACH,2BANW,MAAM,gBAAgB,4BACtB,CAAC,OAAO,EAAE,OAAO,oBAAoB,EAAE,gBAAgB,KAAK,OAAO,8BAA8B,EAAE,OAAO,GAAG,SAAS,EAkBhI;IAED;;;;;;;;;;;OAWG;IACH,wEAvEqB,GAAG,KAAK,IAAI,CAkKhC;IAED;;;;;;;OAOG;IACH,eAFa,CAAC,aAJH,MAAM,gBACN,CAAC,YACD,OAAO,GACL,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAgC9B;IAED;;;;;;;;OAQG;IACH,oBAHW,MAAM,SACN,GAAG,QAWb;IAED;;;OAGG;IACH,oBAFW,MAAM,OAIhB;IAED;;;;;;;;OAQG;IACH,qBAJW,MAAM,YACN,MAAM,IAAI,GACR,MAAM,IAAI,CAiBtB;IAED;;;OAGG;IACH,qBAFW,MAAM,OAKhB;IAED;;OAEG;IACH,oBACsB,WAAW,CAAC,MAAM,2CAAY,CAGnD;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,OAAO,CAKnB;IAED;;;;;;;;;;OAUG;IACH,0CAHW,MAAM,GACJ,OAAO,CAanB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,gBAAgB,CAQ5B;IAED;;OAEG;IACH,iBAFa,0BAA0B,CAuBtC;IAKD;;;;OAIG;IACH,uBAFW,MAAM,wCAMhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBALW,MAAM,YACN,MAAM,IAAI;;;;;;;qBArXX,OAAO;;;;;;2BAKP,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI;QAkX3B,eAAe,CAY3B;IA0BD;;;;OAIG;IACH,qBAFW,MAAM,OAKhB;IAED;;;;OAIG;IACH,iBAJa,CAAC,MACH,MAAM,CAAC,GACL,CAAC,CAIb;IAED,iBAEC;IAED;;;;;OAKG;IACH,yBAFW;QAAE,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,iBAItD;IAED,gBAUC;IAED;;;;;OAKG;IACH,sBAFa,OAAO,CAiBnB;;CACJ;;aA9fS,MAAM;cACN,OAAO;YACP,mBAAmB,EAAE;;;UAKrB,MAAM;UACN,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM;WAClD,GAAG;cACH,OAAO;gBACP,OAAO;YACP,OAAO,sBAAsB,EAAE,SAAS,GAAG,SAAS;;;;;;;;;8BAUjD,OAAO,wBAAwB,EAAE,kBAAkB,GAAG;IAAE,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,MAAM,CAAA;CAAC"}