@deck.gl-community/infovis-layers 9.3.2 → 9.3.7

package/dist/index.cjs

@@ -24,18 +24,46 @@ var __publicField = (obj, key, value) => {
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  AnimationLayer: () => AnimationLayer,
+  BlockLayer: () => BlockLayer,
+  DEFAULT_BOUNDS_EPSILON: () => DEFAULT_BOUNDS_EPSILON,
+  DEFAULT_FAST_TEXT_FONT_SETTINGS: () => DEFAULT_FAST_TEXT_FONT_SETTINGS,
+  FastTextFontAtlasManager: () => FastTextFontAtlasManager,
+  FastTextLayer: () => FastTextLayer,
   HEADER_VIEW_HEIGHT: () => HEADER_VIEW_HEIGHT,
   LEGEND_VIEW_WIDTH: () => LEGEND_VIEW_WIDTH,
   SYNCHRONIZED_VIEWS: () => SYNCHRONIZED_VIEWS,
   SYNCHRONIZED_VIEW_STATE_CONSTRAINTS: () => SYNCHRONIZED_VIEW_STATE_CONSTRAINTS,
   TimeDeltaLayer: () => TimeDeltaLayer,
+  ViewLayoutItem: () => ViewLayoutItem,
+  arrowFindUtf8: () => arrowFindUtf8,
+  boundsAreEqual: () => boundsAreEqual,
+  buildFastTextCharacterMapping: () => buildFastTextCharacterMapping,
+  buildFastTextGlyphData: () => buildFastTextGlyphData,
+  buildFastTextUtf8ColumnSource: () => buildFastTextUtf8ColumnSource,
+  buildMultiLineGlyphData: () => buildMultiLineGlyphData,
+  buildSingleLineGlyphData: () => buildSingleLineGlyphData,
+  buildViewsFromViewLayout: () => buildViewsFromViewLayout,
+  collectFastTextCharacterSet: () => collectFastTextCharacterSet,
+  combineLayerFilters: () => combineLayerFilters,
+  createFastTextFontAtlas: () => createFastTextFontAtlas,
+  createViewportBoundsFilter: () => createViewportBoundsFilter,
   fitBoundsOrthographic: () => fitBoundsOrthographic,
   fitSynchronizedViewStatesToBounds: () => fitSynchronizedViewStatesToBounds,
   formatTimeMs: () => formatTimeMs,
   formatTimeRangeMs: () => formatTimeRangeMs,
+  getArrowUtf8ColumnSource: () => getArrowUtf8ColumnSource,
+  getArrowUtf8RowView: () => getArrowUtf8RowView,
+  getBoundsOrthographic: () => getBoundsOrthographic,
+  getPaddedBlockBounds: () => getPaddedBlockBounds,
   getSynchronizedViewStates: () => getSynchronizedViewStates,
+  getUtf8ColumnSourceRowView: () => getUtf8ColumnSourceRowView,
+  getViewportBoundsForViewState: () => getViewportBoundsForViewState,
+  isBoundsCompletelyOutside: () => isBoundsCompletelyOutside,
   makeLayerFilter: () => makeLayerFilter,
+  makeUtf8StringView: () => makeUtf8StringView,
   mergeViewStates: () => mergeViewStates,
+  updateFastTextDynamicGlyphAttributes: () => updateFastTextDynamicGlyphAttributes,
   validateViewState: () => validateViewState
 });
 module.exports = __toCommonJS(dist_exports);
@@ -45,57 +73,80 @@ var import_core = require("@deck.gl/core");
 var import_layers = require("@deck.gl/layers");
 
 // dist/utils/format-utils.js
-function formatTimeMs(timeMs, space = true) {
+function formatTimeMs(timeMs, options = {}) {
+  const normalizedOptions = typeof options === "boolean" ? { space: options } : options;
+  const { space = true, roundDigits = 5 } = normalizedOptions;
   const sep = space ? " " : "";
   const us = timeMs * 1e3;
   if (us === 0) {
     return "0s";
   }
   if (Math.abs(us) < 1e3) {
-    return `${floatToStr(us)}${sep}\xB5s`;
+    return `${floatToStr(us, roundDigits)}${sep}\xB5s`;
   }
   const ms = us / 1e3;
   if (Math.abs(ms) < 1e3) {
-    return `${floatToStr(ms)}${sep} ms`;
+    return `${floatToStr(ms, roundDigits)}${sep}ms`;
   }
   const s = ms / 1e3;
   if (Math.abs(s) < 60) {
-    return `${floatToStr(s)}${sep} s`;
+    return `${floatToStr(s, roundDigits)}${sep}s`;
   }
   const m = s / 60;
   if (Math.abs(m) < 60) {
-    return `${floatToStr(m)}${sep} min`;
+    return formatMinuteDuration(s);
   }
   const h = m / 60;
   if (Math.abs(h) < 24) {
-    return `${floatToStr(h)}${sep} hrs`;
+    return formatHourDuration(s);
   }
-  const d = h / 24;
-  return `${floatToStr(d)}${sep} days`;
+  return formatDayDuration(s);
 }
 function formatTimeRangeMs(startMs, endMs) {
   return `${formatTimeMs(startMs)} - ${formatTimeMs(endMs)}`;
 }
 function floatToStr(f, roundDigits = 5) {
-  if (Number.isInteger(f)) {
+  if (roundDigits < 1 || Number.isInteger(f)) {
     return f.toString();
   }
-  for (let i = 1; i < roundDigits - 1; i++) {
-    const rounded = parseFloat(f.toPrecision(i));
-    if (rounded === f) {
-      return rounded.toPrecision(i);
-    }
+  const precision = f.toPrecision(roundDigits);
+  return parseFloat(precision).toString();
+}
+function formatMinuteDuration(seconds) {
+  const sign = seconds < 0 ? "-" : "";
+  const totalSeconds = Math.floor(Math.abs(seconds));
+  const minutes = Math.floor(totalSeconds / 60);
+  const remainingSeconds = totalSeconds % 60;
+  if (remainingSeconds === 0) {
+    return `${sign}${minutes}m`;
+  }
+  return `${sign}${minutes}m${remainingSeconds}s`;
+}
+function formatHourDuration(seconds) {
+  const sign = seconds < 0 ? "-" : "";
+  const totalMinutes = Math.floor(Math.abs(seconds) / 60);
+  const hours = Math.floor(totalMinutes / 60);
+  const remainingMinutes = totalMinutes % 60;
+  if (remainingMinutes === 0) {
+    return `${sign}${hours}h`;
   }
-  return f.toPrecision(roundDigits);
+  return `${sign}${hours}h${remainingMinutes}m`;
+}
+function formatDayDuration(seconds) {
+  const sign = seconds < 0 ? "-" : "";
+  const totalHours = Math.floor(Math.abs(seconds) / 3600);
+  const days = Math.floor(totalHours / 24);
+  const remainingHours = totalHours % 24;
+  if (remainingHours === 0) {
+    return `${sign}${days}d`;
+  }
+  return `${sign}${days}d${remainingHours}h`;
 }
 
 // dist/layers/time-delta-layer.js
 var TimeDeltaLayer = class extends import_core.CompositeLayer {
   renderLayers() {
-    const { startTimeMs, endTimeMs, color = [0, 0, 0, 255], yMin, yMax } = this.props;
-    const timeDeltaPosition = [(startTimeMs + endTimeMs) / 2, 10];
-    const timeDeltaMs = Math.abs(endTimeMs - startTimeMs);
-    const timeDeltaLabel = formatTimeMs(timeDeltaMs, false);
+    const { startTimeMs, endTimeMs, color: color3 = [0, 0, 0, 255], yMin, yMax } = this.props;
     if (!this.props.header) {
       const timeLines2 = [
         {
@@ -114,21 +165,24 @@ var TimeDeltaLayer = class extends import_core.CompositeLayer {
           data: timeLines2,
           getSourcePosition: (d) => d.sourcePosition,
           getTargetPosition: (d) => d.targetPosition,
-          getColor: color,
+          getColor: color3,
           getWidth: 4,
           widthUnits: "pixels"
         })
       ];
     }
-    const HEADER_Y = 12;
+    const { y, fontSize, fontFamily, fontSettings, fontWeight } = this.props;
+    const timeDeltaPosition = [(startTimeMs + endTimeMs) / 2, y - 10];
+    const timeDeltaMs = Math.abs(endTimeMs - startTimeMs);
+    const timeDeltaLabel = formatTimeMs(timeDeltaMs, { space: false });
     const timeLines = [
       {
-        sourcePosition: [startTimeMs, -100],
-        targetPosition: [startTimeMs, HEADER_Y]
+        sourcePosition: [startTimeMs, y],
+        targetPosition: [startTimeMs, y - 7]
       },
       {
-        sourcePosition: [endTimeMs, -100],
-        targetPosition: [endTimeMs, HEADER_Y]
+        sourcePosition: [endTimeMs, y],
+        targetPosition: [endTimeMs, y - 7]
       }
     ];
     return [
@@ -138,7 +192,7 @@ var TimeDeltaLayer = class extends import_core.CompositeLayer {
         data: timeLines,
         getSourcePosition: (d) => d.sourcePosition,
         getTargetPosition: (d) => d.targetPosition,
-        getColor: color,
+        getColor: color3,
         getWidth: 4,
         widthUnits: "pixels"
       }),
@@ -147,13 +201,13 @@ var TimeDeltaLayer = class extends import_core.CompositeLayer {
         id: "header-time-delta-dotted-line",
         data: [
           {
-            sourcePosition: [startTimeMs, HEADER_Y - 7],
-            targetPosition: [endTimeMs, HEADER_Y - 7]
+            sourcePosition: [startTimeMs, y - 7],
+            targetPosition: [endTimeMs, y - 7]
           }
         ],
         getSourcePosition: (d) => d.sourcePosition,
         getTargetPosition: (d) => d.targetPosition,
-        getColor: color,
+        getColor: color3,
         getWidth: 1,
         widthUnits: "pixels"
       }),
@@ -163,13 +217,16 @@ var TimeDeltaLayer = class extends import_core.CompositeLayer {
         data: [{ position: timeDeltaPosition, text: timeDeltaLabel }],
         getPosition: (d) => d.position,
         getText: (d) => d.text,
-        getSize: 12,
-        getColor: color,
+        characterSet: "-0123456789.dhms\xB5",
+        getSize: fontSize,
+        fontFamily,
+        fontSettings,
+        fontWeight,
+        getColor: color3,
         getTextAnchor: "middle",
-        getAlignmentBaseline: "top",
+        getAlignmentBaseline: "center",
         background: true,
-        getBackgroundColor: [255, 255, 255, 255],
-        // Solid green background
+        getBackgroundColor: [255 - color3[0], 255 - color3[1], 255 - color3[2], 255],
         backgroundPadding: [4, 2]
         // Horizontal and vertical padding
       })
@@ -188,114 +245,2941 @@ __publicField(TimeDeltaLayer, "defaultProps", {
   unit: "timestamp",
   yMin: -1e6,
   // Should cover full viewport height in most cases
-  yMax: 1e6
+  yMax: 1e6,
   // Should cover full viewport height in most cases
+  fontSize: 12,
+  fontFamily: import_layers.TextLayer.defaultProps.fontFamily,
+  fontSettings: import_layers.TextLayer.defaultProps.fontSettings,
+  fontWeight: import_layers.TextLayer.defaultProps.fontWeight
 });
 
-// dist/views/orthographic-utils.js
-function fitBoundsOrthographic(width, height, bounds, zoomMode = "per-axis") {
-  const [[minX, minY], [maxX, maxY]] = bounds;
-  const centerX = (minX + maxX) / 2;
-  const centerY = (minY + maxY) / 2;
-  const boxW = maxX - minX;
-  const boxH = maxY - minY;
-  const scaleX = width / boxW;
-  const scaleY = height / boxH;
-  const scale = Math.min(scaleX, scaleY);
-  const zoom = Math.log2(scale);
-  const zoomX = Math.log2(scaleX);
-  const zoomY = Math.log2(scaleY);
-  if (Number.isNaN(zoom) || Number.isNaN(zoomX) || Number.isNaN(zoom)) {
-    console.warn("Invalid zoom values:", { zoom, zoomX, zoomY });
+// dist/layers/animation-layer/animation-layer.js
+var import_core2 = require("@deck.gl/core");
+
+// dist/layers/animation-layer/animation.js
+var LINEAR_EASING = (t) => t;
+function resolveFramesGroup(group, baseStart) {
+  if ("props" in group) {
+    const delay2 = group.delay ?? 0;
+    const start = baseStart + delay2;
+    const end = start + group.duration;
+    return {
+      frames: [
+        {
+          from: void 0,
+          to: group.props,
+          start,
+          end,
+          easing: group.easing ?? LINEAR_EASING
+        }
+      ],
+      duration: delay2 + group.duration
+    };
   }
-  return {
-    target: [centerX, centerY],
-    zoom: zoomMode === "single" ? zoom : [zoomX, zoomY]
-  };
+  const delay = group.delay ?? 0;
+  const frames = [];
+  if (group.type === "sequence") {
+    let current = baseStart;
+    for (let i = 0; i < group.frames.length; i += 1) {
+      const child = group.frames[i];
+      const childResult = resolveFramesGroup(child, current);
+      frames.push(...childResult.frames);
+      current += childResult.duration;
+      if (i < group.frames.length - 1)
+        current += delay;
+    }
+    return { frames, duration: Math.max(0, current - baseStart) };
+  }
+  if (group.type === "concurrence") {
+    const start = baseStart + delay;
+    let maxDuration = 0;
+    for (const child of group.frames) {
+      const childResult = resolveFramesGroup(child, start);
+      frames.push(...childResult.frames);
+      if (childResult.duration > maxDuration)
+        maxDuration = childResult.duration;
+    }
+    return { frames, duration: delay + maxDuration };
+  }
+  let maxEnd = baseStart;
+  for (let i = 0; i < group.frames.length; i += 1) {
+    const child = group.frames[i];
+    const childResult = resolveFramesGroup(child, baseStart + i * delay);
+    frames.push(...childResult.frames);
+    const childEnd = baseStart + i * delay + childResult.duration;
+    if (childEnd > maxEnd)
+      maxEnd = childEnd;
+  }
+  frames.sort((f1, f2) => f1.end - f2.end);
+  return { frames, duration: Math.max(0, maxEnd - baseStart) };
+}
+function getFramesDuration(frames) {
+  let maxEnd = 0;
+  for (const frame of frames) {
+    if (frame.end > maxEnd)
+      maxEnd = frame.end;
+  }
+  return maxEnd;
+}
+function reverseResolvedFrames(frames) {
+  const duration = getFramesDuration(frames);
+  const reversed = [];
+  for (let i = frames.length - 1; i >= 0; i -= 1) {
+    const frame = frames[i];
+    reversed.push({
+      from: void 0,
+      to: frame.from ?? frame.to,
+      start: duration - frame.end,
+      end: duration - frame.start,
+      easing: frame.easing
+    });
+  }
+  return reversed;
+}
+function resolveAnimationFrames(time, opts, prevState) {
+  const { frames, repeat = 0, repeatType = "loop", repeatDelay = 0 } = opts;
+  if (!prevState) {
+    const resolved = resolveFramesGroup(frames, 0);
+    return {
+      start: time,
+      end: time + resolved.duration,
+      inProgress: true,
+      iterations: 0,
+      frames: resolved.frames
+    };
+  }
+  const state = prevState;
+  if (time < state.end) {
+    return state;
+  }
+  const iterationEnd = state.end;
+  const iterations = state.iterations + 1;
+  if (iterations > repeat) {
+    return state;
+  }
+  const start = iterationEnd + repeatDelay;
+  if (repeatType === "reverse" && iterations % 2 === 1) {
+    const duration = state.end - state.start;
+    return {
+      start,
+      end: start + duration,
+      iterations,
+      frames: reverseResolvedFrames(state.frames),
+      inProgress: true
+    };
+  } else {
+    const resolved = resolveFramesGroup(frames, 0);
+    return {
+      start,
+      end: start + resolved.duration,
+      inProgress: true,
+      iterations,
+      frames: resolved.frames
+    };
+  }
+}
+function interpolateProp(from, to, ratio) {
+  if (from === void 0 || to === void 0)
+    return to;
+  if (typeof to === "string" || typeof to === "function")
+    return to;
+  if (typeof to === "number" && typeof from === "number") {
+    return from + (to - from) * ratio;
+  }
+  if (Array.isArray(to) && Array.isArray(from)) {
+    const len = to.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; i += 1) {
+      const toValue = to[i];
+      const fromValue = from[i];
+      out[i] = typeof toValue === "number" && typeof fromValue === "number" ? fromValue + (toValue - fromValue) * ratio : toValue;
+    }
+    return out;
+  }
+  return to;
+}
+function resolveProps(layer, frames, timeSinceStart) {
+  if (timeSinceStart < 0 || frames.length === 0)
+    return {};
+  const baseProps = layer.props;
+  const nextProps = {};
+  let transitions = baseProps.transitions ? { ...baseProps.transitions } : void 0;
+  const updateTriggers = { ...baseProps.updateTriggers };
+  const getPropValue = (key) => Object.prototype.hasOwnProperty.call(nextProps, key) ? nextProps[key] : baseProps[key];
+  for (const frame of frames) {
+    if (timeSinceStart < frame.start)
+      continue;
+    const duration = frame.end - frame.start;
+    if (duration <= 0) {
+      Object.assign(nextProps, frame.to);
+      continue;
+    }
+    if (frame.from === void 0) {
+      const from = {};
+      for (const key of Object.keys(frame.to)) {
+        from[key] = getPropValue(key);
+      }
+      frame.from = from;
+    }
+    if (timeSinceStart >= frame.end) {
+      Object.assign(nextProps, frame.to);
+      continue;
+    }
+    const t = frame.easing((timeSinceStart - frame.start) / duration);
+    for (const key of Object.keys(frame.to)) {
+      const toValue = frame.to[key];
+      const fromValue = frame.from[key];
+      if (String(key).startsWith("get") && (typeof fromValue === "function" || typeof toValue === "function")) {
+        nextProps[key] = toValue;
+        updateTriggers[key] = { ...updateTriggers[key], animation: toValue };
+        transitions ??= {};
+        transitions[key] = {
+          duration: frame.end - frame.start,
+          easing: frame.easing
+        };
+      } else {
+        const value = interpolateProp(fromValue, toValue, t);
+        if (value !== void 0) {
+          nextProps[key] = value;
+        }
+      }
+    }
+  }
+  return nextProps;
 }
 
-// dist/views/view-state-utils.js
-function mergeViewStates(viewState1, viewState2) {
-  var _a, _b, _c, _d;
-  const target1 = viewState1.target ?? [0, 0];
-  const zoom1 = viewState1.zoom ?? [1, 1];
-  const mergedViewState = {
-    ...viewState1,
-    ...viewState2,
-    target: [((_a = viewState2.target) == null ? void 0 : _a[0]) ?? target1[0], ((_b = viewState2.target) == null ? void 0 : _b[1]) ?? target1[1]],
-    zoom: [
-      // ts-expect-error view state typing is awfully optional
-      ((_c = viewState2.zoom) == null ? void 0 : _c[0]) ?? zoom1[0],
-      // ts-expect-error view state typing is awfully optional
-      ((_d = viewState2.zoom) == null ? void 0 : _d[1]) ?? zoom1[1]
-    ]
+// dist/layers/animation-layer/animation-layer.js
+var AnimationLayer = class extends import_core2.CompositeLayer {
+  state = {};
+  // Hack - hijacking another flag to force updates
+  hasUniformTransition() {
+    if (!this.props.visible)
+      return false;
+    const { animationState } = this.state;
+    return !animationState || animationState.inProgress;
+  }
+  updateState() {
+    if (!this.props.visible) {
+      this.state.animationState = void 0;
+      this.state.layer = void 0;
+      return;
+    }
+    const time = this.context.timeline.getTime();
+    const baseLayer = this.props.layer.clone({
+      parameters: {
+        ...this.props.layer.props.parameters,
+        ...this.props.parameters
+      }
+    });
+    let { animationState } = this.state;
+    let layer = baseLayer;
+    while (true) {
+      if (animationState == null ? void 0 : animationState.inProgress) {
+        const nextProps = resolveProps(layer, animationState.frames, time - animationState.start);
+        nextProps["id"] = `${this.id}-animation-layer`;
+        layer = baseLayer.clone(nextProps);
+        animationState.inProgress = time < animationState.end;
+        this.setNeedsRedraw();
+      }
+      const nextState = resolveAnimationFrames(time, this.props, animationState);
+      if (nextState === animationState)
+        break;
+      animationState = nextState;
+    }
+    this.state.animationState = animationState;
+    this.state.layer = layer;
+  }
+  renderLayers() {
+    return this.state.layer;
+  }
+};
+__publicField(AnimationLayer, "layerName", "AnimationLayer");
+
+// dist/layers/block-layer/block-layer.js
+var import_core3 = require("@deck.gl/core");
+var import_engine = require("@luma.gl/engine");
+
+// dist/layers/block-layer/block-layer-fragment.glsl.js
+var block_layer_fragment_glsl_default = `#version 300 es
+#define SHADER_NAME block-layer-fragment-shader
+
+precision highp float;
+
+in vec2 unitPosition;
+flat in vec4 vFillColor;
+flat in vec4 vLineColor;
+flat in float lineWidth;
+flat in vec2 size;
+
+out vec4 fragColor;
+
+void main(void) {
+  if (lineWidth > 0.0) {
+    vec2 relPosition = unitPosition * size;
+    float distToBorder =
+      min(
+        min(
+          min(relPosition.x, relPosition.y),
+          size.x - relPosition.x
+        ),
+        size.y - relPosition.y
+      );
+    if (distToBorder <= lineWidth) {
+      fragColor = vLineColor;
+    } else {
+      fragColor = vFillColor;
+    }
+  } else {
+    fragColor = vFillColor;
+  }
+
+  DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;
+
+// dist/layers/block-layer/block-layer-uniforms.js
+var glslUniformBlock = `uniform blockUniforms {
+  highp int sizeUnits;
+  highp float widthMinPixels;
+  highp float heightMinPixels;
+  highp float sizeMaxPixels;
+  highp int lineWidthUnits;
+} block;
+`;
+var blockUniforms = {
+  name: "block",
+  vs: glslUniformBlock,
+  fs: glslUniformBlock,
+  uniformTypes: {
+    sizeUnits: "i32",
+    widthMinPixels: "f32",
+    heightMinPixels: "f32",
+    sizeMaxPixels: "f32",
+    lineWidthUnits: "i32"
+  }
+};
+
+// dist/layers/block-layer/block-layer-vertex.glsl.js
+var block_layer_vertex_glsl_default = `#version 300 es
+#define SHADER_NAME block-layer-vertex-shader
+
+in vec3 positions;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in vec2 instanceSizes;
+in float instanceLineWidths;
+in vec4 instanceFillColors;
+in vec4 instanceLineColors;
+in vec3 instancePickingColors;
+
+out vec2 unitPosition;
+flat out vec4 vFillColor;
+flat out vec4 vLineColor;
+flat out float lineWidth;
+flat out vec2 size;
+
+// This needs to be added back to the project module
+vec2 project_size_to_pixel(vec2 size, int unit) {
+  if (unit == UNIT_PIXELS) return size;
+  if (unit == UNIT_COMMON && project.projectionMode != PROJECTION_MODE_IDENTITY) {
+    return size * project.scale;
+  }
+  return project_size(size) * project.scale;
+}
+
+float clamp_signed_size(float size, float minPixels, float maxPixels) {
+  float clampedMagnitude = clamp(abs(size), minPixels, maxPixels);
+  if (size < 0.0) {
+    return -clampedMagnitude;
+  }
+  return clampedMagnitude;
+}
+
+void main(void) {
+  geometry.worldPosition = instancePositions;
+  geometry.pickingColor = instancePickingColors;
+  geometry.uv = positions.xy;
+
+  vec2 pixelSize = project_size_to_pixel(instanceSizes, block.sizeUnits);
+  pixelSize.x = clamp_signed_size(pixelSize.x, block.widthMinPixels, block.sizeMaxPixels);
+  pixelSize.y = clamp_signed_size(pixelSize.y, block.heightMinPixels, block.sizeMaxPixels);
+  unitPosition = positions.xy;
+  size = pixelSize;
+  lineWidth = project_size_to_pixel(vec2(instanceLineWidths, 0.0), block.lineWidthUnits).x;
+
+  // Find the center of the point and add the current vertex
+  vec3 offset = vec3(unitPosition * project_pixel_size(pixelSize), 0.0);
+  DECKGL_FILTER_SIZE(offset, geometry);
+
+  gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset, geometry.position);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  // Apply opacity to instance color, or return instance picking color
+  vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * layer.opacity);
+  DECKGL_FILTER_COLOR(vFillColor, geometry);
+
+  vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * layer.opacity);
+  DECKGL_FILTER_COLOR(vLineColor, geometry);
+}
+`;
+
+// dist/layers/block-layer/block-layer.js
+var DEFAULT_COLOR = [0, 0, 0, 255];
+var defaultProps = {
+  sizeUnits: "meters",
+  widthMinPixels: { type: "number", min: 0, value: 0 },
+  heightMinPixels: { type: "number", min: 0, value: 0 },
+  sizeMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER },
+  lineWidthUnits: "pixels",
+  getPosition: { type: "accessor", value: (x) => x.position },
+  getSize: { type: "accessor", value: [10, 10] },
+  getLineWidth: { type: "accessor", value: 1 },
+  getFillColor: { type: "accessor", value: DEFAULT_COLOR },
+  getLineColor: { type: "accessor", value: DEFAULT_COLOR }
+};
+var BlockLayer = class extends import_core3.Layer {
+  state = {};
+  getShaders() {
+    return super.getShaders({
+      vs: block_layer_vertex_glsl_default,
+      fs: block_layer_fragment_glsl_default,
+      modules: [import_core3.project32, import_core3.color, import_core3.picking, blockUniforms]
+    });
+  }
+  initializeState() {
+    this.getAttributeManager().addInstanced({
+      instancePositions: {
+        size: 3,
+        type: "float64",
+        fp64: this.use64bitPositions(),
+        transition: true,
+        accessor: "getPosition"
+      },
+      instanceSizes: {
+        size: 2,
+        transition: true,
+        accessor: "getSize"
+      },
+      instanceLineWidths: {
+        size: 1,
+        transition: true,
+        accessor: "getLineWidth"
+      },
+      instanceLineColors: {
+        size: this.props.colorFormat.length,
+        type: "unorm8",
+        transition: true,
+        accessor: "getLineColor",
+        defaultValue: DEFAULT_COLOR
+      },
+      instanceFillColors: {
+        size: this.props.colorFormat.length,
+        type: "unorm8",
+        transition: true,
+        accessor: "getFillColor",
+        defaultValue: DEFAULT_COLOR
+      }
+    });
+  }
+  updateState(params) {
+    var _a;
+    const { changeFlags } = params;
+    super.updateState(params);
+    if (changeFlags.extensionsChanged) {
+      (_a = this.state.model) == null ? void 0 : _a.destroy();
+      this.state.model = this._getModel();
+      this.getAttributeManager().invalidateAll();
+    }
+  }
+  draw() {
+    const { sizeUnits, widthMinPixels, heightMinPixels, sizeMaxPixels, lineWidthUnits } = this.props;
+    const model = this.state.model;
+    const blockProps = {
+      sizeUnits: import_core3.UNIT[sizeUnits],
+      widthMinPixels,
+      heightMinPixels,
+      sizeMaxPixels,
+      lineWidthUnits: import_core3.UNIT[lineWidthUnits]
+    };
+    model.shaderInputs.setProps({ block: blockProps });
+    model.draw(this.context.renderPass);
+  }
+  _getModel() {
+    const positions = [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0];
+    return new import_engine.Model(this.context.device, {
+      ...this.getShaders(),
+      id: this.props.id,
+      bufferLayout: this.getAttributeManager().getBufferLayouts(),
+      geometry: new import_engine.Geometry({
+        topology: "triangle-strip",
+        attributes: {
+          positions: new Float32Array(positions)
+        }
+      }),
+      isInstanced: true
+    });
+  }
+};
+__publicField(BlockLayer, "layerName", "BlockLayer");
+__publicField(BlockLayer, "defaultProps", defaultProps);
+
+// dist/layers/fast-text-layer/fast-text-layer.js
+var import_core5 = require("@deck.gl/core");
+var import_core6 = require("@luma.gl/core");
+var import_engine2 = require("@luma.gl/engine");
+var import_log = require("@probe.gl/log");
+
+// dist/layers/fast-text-layer/fast-text-layout.js
+var import_core4 = require("@deck.gl/core");
+
+// dist/utils/utf8-string-view.js
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function makeUtf8StringView(value) {
+  const data = textEncoder.encode(value);
+  return { data, start: 0, end: data.length };
+}
+function getArrowUtf8ColumnSource(utf8Column) {
+  const chunks = getArrowUtf8DataChunks(utf8Column);
+  if (!chunks || chunks.length === 0) {
+    return null;
+  }
+  const sourceChunks = [];
+  let rowOffset = 0;
+  for (const chunk of chunks) {
+    const valueOffsets = chunk.valueOffsets;
+    const values = chunk.values;
+    if (!valueOffsets || !values) {
+      return null;
+    }
+    sourceChunks.push({
+      rowOffset,
+      rowCount: chunk.length,
+      valueOffsetIndex: 0,
+      valueOffsets,
+      values
+    });
+    rowOffset += chunk.length;
+  }
+  return {
+    rowCount: utf8Column.length,
+    chunks: sourceChunks,
+    isValid: (rowIndex) => utf8Column.isValid(rowIndex)
   };
-  validateViewState(mergedViewState);
-  return mergedViewState;
 }
-function validateViewState(viewState) {
-  const isTargetValid = Array.isArray(viewState.target) && viewState.target[0] !== void 0 && !Number.isNaN(viewState.target[0]) && viewState.target[1] !== void 0 && !Number.isNaN(viewState.target[1]);
-  const isZoomValid = Array.isArray(viewState.zoom) && viewState.zoom[0] !== void 0 && !Number.isNaN(viewState.zoom[0]) && viewState.zoom[1] !== void 0 && !Number.isNaN(viewState.zoom[1]);
-  if (!isTargetValid || !isZoomValid) {
-    console.warn("Invalid viewState:", viewState);
+function getArrowUtf8RowView(utf8Column, rowIndex, out) {
+  if (!Number.isInteger(rowIndex) || rowIndex < 0 || rowIndex >= utf8Column.length) {
+    return false;
   }
-  return isTargetValid && isZoomValid;
+  if (!utf8Column.isValid(rowIndex)) {
+    return false;
+  }
+  const chunks = getArrowUtf8DataChunks(utf8Column);
+  if (!chunks || chunks.length === 0) {
+    return false;
+  }
+  let rowOffset = 0;
+  for (const chunk of chunks) {
+    const chunkEnd = rowOffset + chunk.length;
+    if (rowIndex >= rowOffset && rowIndex < chunkEnd) {
+      const valueOffsets = chunk.valueOffsets;
+      const values = chunk.values;
+      if (!valueOffsets || !values) {
+        return false;
+      }
+      return fillUtf8StringView(valueOffsets, values, rowIndex - rowOffset, out);
+    }
+    rowOffset = chunkEnd;
+  }
+  return false;
+}
+function getUtf8ColumnSourceRowView(source, rowIndex, out) {
+  if (!Number.isInteger(rowIndex) || rowIndex < 0 || rowIndex >= source.rowCount) {
+    return false;
+  }
+  if (!source.isValid(rowIndex)) {
+    return false;
+  }
+  for (const chunk of source.chunks) {
+    const chunkEnd = chunk.rowOffset + chunk.rowCount;
+    if (rowIndex < chunk.rowOffset || rowIndex >= chunkEnd) {
+      continue;
+    }
+    return fillUtf8StringView(chunk.valueOffsets, chunk.values, chunk.valueOffsetIndex + rowIndex - chunk.rowOffset, out);
+  }
+  return false;
+}
+function arrowFindUtf8(utf8Column, value, startRow = 0) {
+  const normalizedStartRow = Math.max(0, startRow);
+  const fastResult = arrowFindUtf8InDataChunks(utf8Column, value, normalizedStartRow);
+  if (fastResult !== null) {
+    return fastResult;
+  }
+  const expected = decodeUtf8StringView(value);
+  for (let rowIndex = normalizedStartRow; rowIndex < utf8Column.length; rowIndex += 1) {
+    if (utf8Column.get(rowIndex) === expected) {
+      return rowIndex;
+    }
+  }
+  return -1;
+}
+function arrowFindUtf8InDataChunks(utf8Column, value, startRow) {
+  const chunks = getArrowUtf8DataChunks(utf8Column);
+  if (!chunks || chunks.length === 0) {
+    return null;
+  }
+  let globalRowOffset = 0;
+  for (const chunk of chunks) {
+    const valueOffsets = chunk.valueOffsets;
+    const values = chunk.values;
+    if (!valueOffsets || !values) {
+      return null;
+    }
+    const chunkStartRow = Math.max(0, startRow - globalRowOffset);
+    for (let chunkRow = chunkStartRow; chunkRow < chunk.length; chunkRow += 1) {
+      const globalRow = globalRowOffset + chunkRow;
+      if (!utf8Column.isValid(globalRow)) {
+        continue;
+      }
+      const start = valueOffsets[chunkRow];
+      const end = valueOffsets[chunkRow + 1];
+      if (start !== void 0 && end !== void 0 && utf8BytesEqual(values, start, end, value)) {
+        return globalRow;
+      }
+    }
+    globalRowOffset += chunk.length;
+  }
+  return -1;
+}
+function getArrowUtf8DataChunks(utf8Column) {
+  return utf8Column.data;
+}
+function fillUtf8StringView(valueOffsets, values, offsetIndex, out) {
+  const start = valueOffsets[offsetIndex];
+  const end = valueOffsets[offsetIndex + 1];
+  if (start === void 0 || end === void 0) {
+    return false;
+  }
+  out.data = values;
+  out.start = start;
+  out.end = end;
+  return true;
+}
+function utf8BytesEqual(data, start, end, value) {
+  const valueLength = value.end - value.start;
+  if (end - start !== valueLength) {
+    return false;
+  }
+  for (let index = 0; index < valueLength; index += 1) {
+    if (data[start + index] !== value.data[value.start + index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function decodeUtf8StringView(value) {
+  return textDecoder.decode(value.data.subarray(value.start, value.end));
 }
 
-// dist/views/layer-filter.js
-function makeLayerFilter(filters) {
-  const regexpFilters = {};
-  for (const [key, value] of Object.entries(filters)) {
-    if ("include" in value) {
-      regexpFilters[key] = {
-        include: value.include.map((v) => new RegExp(v))
-      };
+// dist/layers/fast-text-layer/fast-text-layout.js
+var FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE = Int16Array.BYTES_PER_ELEMENT * 10 + Uint8Array.BYTES_PER_ELEMENT * 4;
+function buildFastTextUtf8ColumnSource(utf8Column) {
+  return getArrowUtf8ColumnSource(utf8Column);
+}
+function collectFastTextCharacterSet(props) {
+  const characterSet = /* @__PURE__ */ new Set();
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  for (const object of iterable) {
+    objectInfo.index++;
+    const text = resolveAccessor(props.getText, object, objectInfo) ?? "";
+    for (const character of Array.from(text)) {
+      if (character !== "\n") {
+        characterSet.add(character);
+      }
+    }
+  }
+  return characterSet;
+}
+function buildFastTextGlyphData(props) {
+  const buildStartTime = performance.now();
+  const columnNormalizeStartTime = performance.now();
+  const textUtf8Column = resolveFastTextUtf8ColumnSource(props.textUtf8Column);
+  const columnNormalizeDurationMs = performance.now() - columnNormalizeStartTime;
+  if (props.textUtf8Column && !textUtf8Column) {
+    throw new Error("FastTextLayer textUtf8Column must expose Arrow Utf8 buffers");
+  }
+  if ((textUtf8Column || props.getTextUtf8) && !props.singleLine) {
+    throw new Error("FastTextLayer UTF-8 text sources require singleLine text layout");
+  }
+  const glyphData = props.singleLine ? buildSingleLineGlyphData({
+    ...props,
+    textUtf8Column
+  }) : buildMultiLineGlyphData(props);
+  return withFastTextGlyphBuildStats(glyphData, {
+    columnNormalizeDurationMs,
+    totalDurationMs: performance.now() - buildStartTime
+  });
+}
+function buildSingleLineGlyphData(props) {
+  const buildStartTime = performance.now();
+  const countStartTime = performance.now();
+  const countResult = countSingleLineFastTextGlyphs(props);
+  const countDurationMs = performance.now() - countStartTime;
+  const allocateStartTime = performance.now();
+  const attributes = allocateFastTextGlyphAttributes(countResult.glyphCount);
+  const startIndices = new Uint32Array(countResult.rowCount + 1);
+  const allocateDurationMs = performance.now() - allocateStartTime;
+  const writeState = {
+    glyphIndex: 0,
+    startIndices,
+    attributes,
+    glyphRecordViews: createFastTextGlyphRecordViews(attributes.instanceGlyphData)
+  };
+  const writeTimings = createFastTextGlyphWriteTimings();
+  const byteLookup = props.textUtf8Column || props.getTextUtf8 ? buildFastTextByteGlyphLookup(props.mapping) : null;
+  const scratchUtf8View = { data: EMPTY_BYTES, start: 0, end: 0 };
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  const writeStartTime = performance.now();
+  for (const object of iterable) {
+    objectInfo.index++;
+    startIndices[objectInfo.index] = writeState.glyphIndex;
+    if (props.textUtf8Column && byteLookup) {
+      writeSingleLineUtf8LabelGlyphs(props, props.textUtf8Column, byteLookup, scratchUtf8View, object, objectInfo, writeState, writeTimings);
+    } else if (props.getTextUtf8 && byteLookup) {
+      writeSingleLineUtf8ViewLabelGlyphs(props, props.getTextUtf8, byteLookup, scratchUtf8View, object, objectInfo, writeState, writeTimings);
     } else {
-      regexpFilters[key] = {
-        exclude: value.exclude.map((v) => new RegExp(v))
-      };
+      writeSingleLineStringLabelGlyphs(props, object, objectInfo, writeState, writeTimings);
     }
   }
-  return ({ viewport, layer }) => {
-    let visible = true;
-    const viewFilters = regexpFilters[viewport.id] || {};
-    if ("include" in viewFilters) {
-      if (!viewFilters.include.some((regexp) => regexp.test(layer.id))) {
-        visible = false;
+  startIndices[countResult.rowCount] = writeState.glyphIndex;
+  const writeDurationMs = performance.now() - writeStartTime;
+  return createFastTextGlyphData(countResult, startIndices, attributes, {
+    sourceMode: props.textUtf8Column ? "utf8-column" : props.getTextUtf8 ? "utf8-view" : "string",
+    layoutMode: "single-line",
+    columnNormalizeDurationMs: 0,
+    countDurationMs,
+    allocateDurationMs,
+    writeDurationMs,
+    ...writeTimings,
+    totalDurationMs: performance.now() - buildStartTime
+  });
+}
+function buildMultiLineGlyphData(props) {
+  const buildStartTime = performance.now();
+  const countStartTime = performance.now();
+  const countResult = countMultiLineFastTextGlyphs(props);
+  const countDurationMs = performance.now() - countStartTime;
+  const allocateStartTime = performance.now();
+  const attributes = allocateFastTextGlyphAttributes(countResult.glyphCount);
+  const startIndices = new Uint32Array(countResult.rowCount + 1);
+  const allocateDurationMs = performance.now() - allocateStartTime;
+  const writeState = {
+    glyphIndex: 0,
+    startIndices,
+    attributes,
+    glyphRecordViews: createFastTextGlyphRecordViews(attributes.instanceGlyphData)
+  };
+  const writeTimings = createFastTextGlyphWriteTimings();
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  const writeStartTime = performance.now();
+  for (const object of iterable) {
+    objectInfo.index++;
+    startIndices[objectInfo.index] = writeState.glyphIndex;
+    writeMultiLineLabelGlyphs(props, object, objectInfo, writeState, writeTimings);
+  }
+  startIndices[countResult.rowCount] = writeState.glyphIndex;
+  const writeDurationMs = performance.now() - writeStartTime;
+  return createFastTextGlyphData(countResult, startIndices, attributes, {
+    sourceMode: "string",
+    layoutMode: "multi-line",
+    columnNormalizeDurationMs: 0,
+    countDurationMs,
+    allocateDurationMs,
+    writeDurationMs,
+    ...writeTimings,
+    totalDurationMs: performance.now() - buildStartTime
+  });
+}
+function updateFastTextDynamicGlyphAttributes(props) {
+  const updateStartTime = performance.now();
+  const glyphRecordViews = createFastTextGlyphRecordViews(props.glyphData.attributes.instanceGlyphData);
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  let rowCount = 0;
+  let glyphCount = 0;
+  let positionAccessorDurationMs = 0;
+  let colorAccessorDurationMs = 0;
+  let clipRectAccessorDurationMs = 0;
+  let writeDurationMs = 0;
+  for (const object of iterable) {
+    objectInfo.index++;
+    rowCount++;
+    const rowGlyphStart = props.glyphData.startIndices[objectInfo.index] ?? 0;
+    const rowGlyphEnd = props.glyphData.startIndices[objectInfo.index + 1] ?? rowGlyphStart;
+    if (rowGlyphEnd <= rowGlyphStart) {
+      continue;
+    }
+    let position = DEFAULT_POSITION;
+    let color3 = DEFAULT_COLOR2;
+    let clipRect = DEFAULT_CLIP_RECT;
+    if (props.updatePositions) {
+      const accessorStartTime = performance.now();
+      position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+      positionAccessorDurationMs += performance.now() - accessorStartTime;
+    }
+    if (props.updateColors) {
+      const accessorStartTime = performance.now();
+      color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+      colorAccessorDurationMs += performance.now() - accessorStartTime;
+    }
+    if (props.updateClipRects) {
+      const accessorStartTime = performance.now();
+      clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+      clipRectAccessorDurationMs += performance.now() - accessorStartTime;
+    }
+    const writeStartTime = performance.now();
+    for (let glyphIndex = rowGlyphStart; glyphIndex < rowGlyphEnd; glyphIndex += 1) {
+      if (props.updatePositions) {
+        writeFastTextGlyphPosition(props.glyphData.attributes, glyphIndex, position);
+      }
+      if (props.updateClipRects) {
+        writeFastTextGlyphClipRect(glyphRecordViews, glyphIndex, clipRect);
+      }
+      if (props.updateColors) {
+        writeFastTextGlyphColor(glyphRecordViews, glyphIndex, color3);
       }
     }
-    if ("exclude" in viewFilters) {
-      if (viewFilters.exclude.some((regexp) => regexp.test(layer.id))) {
-        visible = false;
+    writeDurationMs += performance.now() - writeStartTime;
+    glyphCount += rowGlyphEnd - rowGlyphStart;
+  }
+  return {
+    rowCount,
+    glyphCount,
+    attributeByteLength: props.glyphData.byteLength,
+    positionAccessorDurationMs,
+    colorAccessorDurationMs,
+    clipRectAccessorDurationMs,
+    writeDurationMs,
+    totalDurationMs: performance.now() - updateStartTime
+  };
+}
+var MISSING_CHARACTER_ADVANCE = 32;
+var FAST_TEXT_BYTE_LOOKUP_SIZE = 256;
+var EMPTY_BYTES = new Uint8Array();
+var DEFAULT_COLOR2 = [0, 0, 0, 255];
+var DEFAULT_POSITION = [0, 0, 0];
+var DEFAULT_CLIP_RECT = [0, 0, -1, -1];
+var ANCHOR_OFFSET_MULTIPLIER = {
+  start: 0,
+  middle: -0.5,
+  end: -1
+};
+var BASELINE_OFFSET_MULTIPLIER = {
+  top: 0,
+  center: -0.5,
+  bottom: -1
+};
+function countSingleLineFastTextGlyphs(props) {
+  if (props.textUtf8Column) {
+    return countSingleLineUtf8FastTextGlyphs(props, props.textUtf8Column);
+  }
+  if (props.getTextUtf8) {
+    return countSingleLineUtf8ViewFastTextGlyphs(props, props.getTextUtf8);
+  }
+  return countSingleLineStringFastTextGlyphs(props);
+}
+function countSingleLineUtf8FastTextGlyphs(props, textUtf8Column) {
+  let glyphCount = 0;
+  let rowCount = 0;
+  const characterSet = /* @__PURE__ */ new Set();
+  const textView = { data: EMPTY_BYTES, start: 0, end: 0 };
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  for (const object of iterable) {
+    objectInfo.index++;
+    rowCount++;
+    const rowIndex = resolveTextUtf8Row(props.getTextUtf8Row, object, objectInfo);
+    if (rowIndex == null || !getUtf8ColumnSourceRowView(textUtf8Column, rowIndex, textView)) {
+      continue;
+    }
+    glyphCount += textView.end - textView.start;
+  }
+  return { glyphCount, rowCount, characterSet };
+}
+function countSingleLineUtf8ViewFastTextGlyphs(props, getTextUtf8) {
+  let glyphCount = 0;
+  let rowCount = 0;
+  const characterSet = /* @__PURE__ */ new Set();
+  const textView = { data: EMPTY_BYTES, start: 0, end: 0 };
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  for (const object of iterable) {
+    objectInfo.index++;
+    rowCount++;
+    if (getTextUtf8(object, textView, objectInfo)) {
+      glyphCount += Math.max(0, textView.end - textView.start);
+    }
+  }
+  return { glyphCount, rowCount, characterSet };
+}
+function countSingleLineStringFastTextGlyphs(props) {
+  let glyphCount = 0;
+  let rowCount = 0;
+  const characterSet = /* @__PURE__ */ new Set();
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  for (const object of iterable) {
+    objectInfo.index++;
+    rowCount++;
+    const text = resolveAccessor(props.getText, object, objectInfo) ?? "";
+    glyphCount += text.length;
+    for (let index = 0; index < text.length; index += 1) {
+      characterSet.add(text[index]);
+    }
+  }
+  return { glyphCount, rowCount, characterSet };
+}
+function countMultiLineFastTextGlyphs(props) {
+  let glyphCount = 0;
+  let rowCount = 0;
+  const characterSet = /* @__PURE__ */ new Set();
+  const { iterable, objectInfo } = (0, import_core4.createIterable)(props.data);
+  for (const object of iterable) {
+    objectInfo.index++;
+    rowCount++;
+    const text = resolveAccessor(props.getText, object, objectInfo) ?? "";
+    for (const character of Array.from(text)) {
+      if (character === "\n") {
+        continue;
       }
+      characterSet.add(character);
+      glyphCount++;
     }
-    return visible;
+  }
+  return { glyphCount, rowCount, characterSet };
+}
+function allocateFastTextGlyphAttributes(glyphCount) {
+  return {
+    instanceGlyphData: new Uint8Array(glyphCount * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE),
+    instancePositions: new Float32Array(glyphCount * 2)
   };
 }
-
-// dist/synchronized-views/synchronized-views.js
-var import_core2 = require("@deck.gl/core");
-var HEADER_VIEW_HEIGHT = 50;
-var LEGEND_VIEW_WIDTH = 150;
-var SYNCHRONIZED_VIEWS = [
-  new import_core2.OrthographicView({
-    id: "main",
-    flipY: false,
-    clear: true,
-    // [1, 1, 1, 1],
-    x: LEGEND_VIEW_WIDTH,
-    width: `calc(100% - ${LEGEND_VIEW_WIDTH}px`,
+function createFastTextGlyphRecordViews(instanceGlyphData) {
+  return {
+    int16Values: new Int16Array(instanceGlyphData.buffer),
+    uint16Values: new Uint16Array(instanceGlyphData.buffer),
+    uint8Values: instanceGlyphData
+  };
+}
+function createFastTextGlyphData(countResult, startIndices, attributes, stats) {
+  const byteLength = startIndices.byteLength + attributes.instanceGlyphData.byteLength + attributes.instancePositions.byteLength;
+  return {
+    length: countResult.glyphCount,
+    startIndices,
+    attributes,
+    characterSet: countResult.characterSet,
+    byteLength,
+    buildStats: {
+      ...stats,
+      rowCount: countResult.rowCount,
+      glyphCount: countResult.glyphCount,
+      attributeByteLength: byteLength
+    }
+  };
+}
+function createFastTextGlyphWriteTimings() {
+  return {
+    textResolveDurationMs: 0,
+    styleAccessorDurationMs: 0,
+    layoutDurationMs: 0,
+    glyphWriteDurationMs: 0
+  };
+}
+function withFastTextGlyphBuildStats(glyphData, stats) {
+  return {
+    ...glyphData,
+    buildStats: {
+      ...glyphData.buildStats,
+      ...stats
+    }
+  };
+}
+function writeSingleLineStringLabelGlyphs(props, object, objectInfo, writeState, timings) {
+  const textResolveStartTime = performance.now();
+  const text = resolveAccessor(props.getText, object, objectInfo) ?? "";
+  timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+  if (!text) {
+    return;
+  }
+  const styleAccessorStartTime = performance.now();
+  const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+  const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+  timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+  const layoutStartTime = performance.now();
+  const width = getSingleLineStringWidth(text, props.mapping);
+  const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * width;
+  const rowBaselineY = getSingleLineBaselineY(props);
+  timings.layoutDurationMs += performance.now() - layoutStartTime;
+  let cursorX = 0;
+  const glyphWriteStartTime = performance.now();
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const frame = props.mapping[character];
+    writeFastTextGlyphRecord({
+      frame,
+      lineOffsetX,
+      cursorX,
+      rowBaselineY,
+      position,
+      color: color3,
+      clipRect,
+      writeState
+    });
+    cursorX += (frame == null ? void 0 : frame.advance) ?? MISSING_CHARACTER_ADVANCE;
+  }
+  timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+function writeSingleLineUtf8LabelGlyphs(props, textUtf8Column, byteLookup, textView, object, objectInfo, writeState, timings) {
+  const textResolveStartTime = performance.now();
+  const rowIndex = resolveTextUtf8Row(props.getTextUtf8Row, object, objectInfo);
+  const hasTextView = rowIndex != null && getUtf8ColumnSourceRowView(textUtf8Column, rowIndex, textView);
+  timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+  if (!hasTextView) {
+    return;
+  }
+  if (textView.end <= textView.start) {
+    return;
+  }
+  const styleAccessorStartTime = performance.now();
+  const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+  const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+  timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+  const layoutStartTime = performance.now();
+  const width = getSingleLineUtf8Width(textView, byteLookup);
+  const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * width;
+  const rowBaselineY = getSingleLineBaselineY(props);
+  timings.layoutDurationMs += performance.now() - layoutStartTime;
+  let cursorX = 0;
+  const glyphWriteStartTime = performance.now();
+  for (let byteIndex = textView.start; byteIndex < textView.end; byteIndex += 1) {
+    const frame = byteLookup[textView.data[byteIndex] ?? -1];
+    writeFastTextGlyphRecord({
+      frame,
+      lineOffsetX,
+      cursorX,
+      rowBaselineY,
+      position,
+      color: color3,
+      clipRect,
+      writeState
+    });
+    cursorX += (frame == null ? void 0 : frame.advance) ?? MISSING_CHARACTER_ADVANCE;
+  }
+  timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+function writeSingleLineUtf8ViewLabelGlyphs(props, getTextUtf8, byteLookup, textView, object, objectInfo, writeState, timings) {
+  const textResolveStartTime = performance.now();
+  const hasTextView = getTextUtf8(object, textView, objectInfo);
+  timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+  if (!hasTextView || textView.end <= textView.start) {
+    return;
+  }
+  const styleAccessorStartTime = performance.now();
+  const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+  const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+  timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+  const layoutStartTime = performance.now();
+  const width = getSingleLineUtf8Width(textView, byteLookup);
+  const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * width;
+  const rowBaselineY = getSingleLineBaselineY(props);
+  timings.layoutDurationMs += performance.now() - layoutStartTime;
+  let cursorX = 0;
+  const glyphWriteStartTime = performance.now();
+  for (let byteIndex = textView.start; byteIndex < textView.end; byteIndex += 1) {
+    const frame = byteLookup[textView.data[byteIndex] ?? -1];
+    writeFastTextGlyphRecord({
+      frame,
+      lineOffsetX,
+      cursorX,
+      rowBaselineY,
+      position,
+      color: color3,
+      clipRect,
+      writeState
+    });
+    cursorX += (frame == null ? void 0 : frame.advance) ?? MISSING_CHARACTER_ADVANCE;
+  }
+  timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+function writeMultiLineLabelGlyphs(props, object, objectInfo, writeState, timings) {
+  const textResolveStartTime = performance.now();
+  const text = resolveAccessor(props.getText, object, objectInfo) ?? "";
+  timings.textResolveDurationMs += performance.now() - textResolveStartTime;
+  if (!text) {
+    return;
+  }
+  const styleAccessorStartTime = performance.now();
+  const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+  const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
+  timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
+  const layoutStartTime = performance.now();
+  const lines = buildFastTextLineLayouts(text, props.mapping);
+  const lineHeightPixels = props.lineHeight * props.fontSize;
+  const labelHeight = lines.length * lineHeightPixels;
+  const blockOffsetY = BASELINE_OFFSET_MULTIPLIER[props.alignmentBaseline] * labelHeight;
+  timings.layoutDurationMs += performance.now() - layoutStartTime;
+  const glyphWriteStartTime = performance.now();
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const lineOffsetX = ANCHOR_OFFSET_MULTIPLIER[props.textAnchor] * line.width;
+    const rowBaselineY = blockOffsetY + props.baselineOffset + lineHeightPixels / 2 + lineIndex * lineHeightPixels;
+    let cursorX = 0;
+    for (const character of line.characters) {
+      const frame = props.mapping[character];
+      writeFastTextGlyphRecord({
+        frame,
+        lineOffsetX,
+        cursorX,
+        rowBaselineY,
+        position,
+        color: color3,
+        clipRect,
+        writeState
+      });
+      cursorX += (frame == null ? void 0 : frame.advance) ?? MISSING_CHARACTER_ADVANCE;
+    }
+  }
+  timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
+}
+function buildFastTextLineLayouts(text, mapping) {
+  const lines = [];
+  let currentCharacters = [];
+  let currentWidth = 0;
+  let currentGlyphCount = 0;
+  for (const character of Array.from(text)) {
+    if (character === "\n") {
+      lines.push({
+        characters: currentCharacters,
+        width: currentWidth,
+        glyphCount: currentGlyphCount
+      });
+      currentCharacters = [];
+      currentWidth = 0;
+      currentGlyphCount = 0;
+      continue;
+    }
+    const frame = mapping[character];
+    currentCharacters.push(character);
+    currentWidth += (frame == null ? void 0 : frame.advance) ?? MISSING_CHARACTER_ADVANCE;
+    if (frame) {
+      currentGlyphCount++;
+    }
+  }
+  lines.push({
+    characters: currentCharacters,
+    width: currentWidth,
+    glyphCount: currentGlyphCount
+  });
+  return lines;
+}
+function resolveFastTextUtf8ColumnSource(textUtf8Column) {
+  if (!textUtf8Column) {
+    return null;
+  }
+  return isFastTextUtf8ColumnSource(textUtf8Column) ? textUtf8Column : buildFastTextUtf8ColumnSource(textUtf8Column);
+}
+function isFastTextUtf8ColumnSource(textUtf8Column) {
+  return "rowCount" in textUtf8Column && "chunks" in textUtf8Column;
+}
+function buildFastTextByteGlyphLookup(mapping) {
+  const lookup = new Array(FAST_TEXT_BYTE_LOOKUP_SIZE);
+  for (let byte = 0; byte < 128; byte += 1) {
+    lookup[byte] = mapping[String.fromCharCode(byte)];
+  }
+  return lookup;
+}
+function resolveTextUtf8Row(getTextUtf8Row, object, objectInfo) {
+  return getTextUtf8Row === void 0 ? objectInfo.index : resolveAccessor(getTextUtf8Row, object, objectInfo);
+}
+function getSingleLineStringWidth(text, mapping) {
+  var _a;
+  let width = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    width += ((_a = mapping[text[index]]) == null ? void 0 : _a.advance) ?? MISSING_CHARACTER_ADVANCE;
+  }
+  return width;
+}
+function getSingleLineUtf8Width(textView, byteLookup) {
+  var _a;
+  let width = 0;
+  for (let byteIndex = textView.start; byteIndex < textView.end; byteIndex += 1) {
+    width += ((_a = byteLookup[textView.data[byteIndex] ?? -1]) == null ? void 0 : _a.advance) ?? MISSING_CHARACTER_ADVANCE;
+  }
+  return width;
+}
+function getSingleLineBaselineY(props) {
+  const lineHeightPixels = props.lineHeight * props.fontSize;
+  const blockOffsetY = BASELINE_OFFSET_MULTIPLIER[props.alignmentBaseline] * lineHeightPixels;
+  return blockOffsetY + props.baselineOffset + lineHeightPixels / 2;
+}
+function writeFastTextGlyphRecord(params) {
+  const frame = params.frame;
+  const glyphIndex = params.writeState.glyphIndex;
+  const recordInt16Index = glyphIndex * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE / Int16Array.BYTES_PER_ELEMENT;
+  const glyphX = params.lineOffsetX + params.cursorX + ((frame == null ? void 0 : frame.anchorX) ?? 0) - ((frame == null ? void 0 : frame.width) ?? 0) / 2;
+  const glyphY = params.rowBaselineY - ((frame == null ? void 0 : frame.anchorY) ?? 0);
+  const writeState = params.writeState;
+  writeFastTextGlyphPosition(writeState.attributes, glyphIndex, params.position);
+  writeState.glyphRecordViews.int16Values[recordInt16Index] = toInt16(glyphX);
+  writeState.glyphRecordViews.int16Values[recordInt16Index + 1] = toInt16(glyphY);
+  writeState.glyphRecordViews.uint16Values[recordInt16Index + 2] = toUint16((frame == null ? void 0 : frame.x) ?? 0);
+  writeState.glyphRecordViews.uint16Values[recordInt16Index + 3] = toUint16((frame == null ? void 0 : frame.y) ?? 0);
+  writeState.glyphRecordViews.uint16Values[recordInt16Index + 4] = toUint16((frame == null ? void 0 : frame.width) ?? 0);
+  writeState.glyphRecordViews.uint16Values[recordInt16Index + 5] = toUint16((frame == null ? void 0 : frame.height) ?? 0);
+  writeFastTextGlyphClipRect(writeState.glyphRecordViews, glyphIndex, params.clipRect);
+  writeFastTextGlyphColor(writeState.glyphRecordViews, glyphIndex, params.color);
+  writeState.glyphIndex++;
+}
+function writeFastTextGlyphPosition(attributes, glyphIndex, position) {
+  const positionOffset = glyphIndex * 2;
+  attributes.instancePositions[positionOffset] = position[0] ?? 0;
+  attributes.instancePositions[positionOffset + 1] = position[1] ?? 0;
+}
+function writeFastTextGlyphClipRect(glyphRecordViews, glyphIndex, clipRect) {
+  const recordInt16Index = glyphIndex * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE / Int16Array.BYTES_PER_ELEMENT;
+  glyphRecordViews.int16Values[recordInt16Index + 6] = toInt16(clipRect[0] ?? 0);
+  glyphRecordViews.int16Values[recordInt16Index + 7] = toInt16(clipRect[1] ?? 0);
+  glyphRecordViews.int16Values[recordInt16Index + 8] = toInt16ClipDimension(clipRect[2] ?? -1);
+  glyphRecordViews.int16Values[recordInt16Index + 9] = toInt16ClipDimension(clipRect[3] ?? -1);
+}
+function writeFastTextGlyphColor(glyphRecordViews, glyphIndex, color3) {
+  const recordByteIndex = glyphIndex * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE;
+  writeColor(glyphRecordViews.uint8Values, recordByteIndex + Int16Array.BYTES_PER_ELEMENT * 10, color3);
+}
+function resolveAccessor(accessor, object, objectInfo) {
+  return typeof accessor === "function" ? accessor(object, objectInfo) : accessor;
+}
+function writeColor(target, offset, color3) {
+  target[offset] = clampByte(color3[0] ?? DEFAULT_COLOR2[0]);
+  target[offset + 1] = clampByte(color3[1] ?? DEFAULT_COLOR2[1]);
+  target[offset + 2] = clampByte(color3[2] ?? DEFAULT_COLOR2[2]);
+  target[offset + 3] = clampByte(color3[3] ?? DEFAULT_COLOR2[3]);
+}
+function clampByte(value) {
+  return Math.max(0, Math.min(255, Math.round(value)));
+}
+function toInt16(value) {
+  const integerValue = Math.round(value);
+  if (integerValue < -32768 || integerValue > 32767) {
+    throw new Error(`FastTextLayer value ${value} is outside the signed 16-bit range`);
+  }
+  return integerValue;
+}
+function toInt16ClipDimension(value) {
+  const integerValue = value > 0 ? Math.max(1, Math.round(value)) : Math.round(value);
+  if (integerValue < -32768 || integerValue > 32767) {
+    throw new Error(`FastTextLayer value ${value} is outside the signed 16-bit range`);
+  }
+  return integerValue;
+}
+function toUint16(value) {
+  const integerValue = Math.round(value);
+  if (integerValue < 0 || integerValue > 65535) {
+    throw new Error(`FastTextLayer glyph frame value ${value} is outside the unsigned 16-bit range`);
+  }
+  return integerValue;
+}
+
+// dist/layers/fast-text-layer/font-atlas.js
+var DEFAULT_FAST_TEXT_FONT_SETTINGS = {
+  fontFamily: "Monaco, monospace",
+  fontWeight: "normal",
+  characterSet: getDefaultCharacterSet(),
+  fontSize: 64,
+  buffer: 4,
+  sdf: true,
+  cutoff: 0.25,
+  radius: 12,
+  smoothing: 0.1
+};
+function createFastTextFontAtlas(settings = {}) {
+  if (typeof document === "undefined") {
+    throw new Error("FastTextLayer font atlas generation requires document.createElement");
+  }
+  const resolvedSettings = {
+    ...DEFAULT_FAST_TEXT_FONT_SETTINGS,
+    ...settings,
+    characterSet: normalizeCharacterSet(settings.characterSet ?? DEFAULT_FAST_TEXT_FONT_SETTINGS.characterSet)
+  };
+  const canvas = document.createElement("canvas");
+  canvas.width = MAX_CANVAS_WIDTH;
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) {
+    throw new Error("FastTextLayer font atlas generation requires a 2D canvas context");
+  }
+  setTextStyle(context, resolvedSettings);
+  const sdfRenderer = resolvedSettings.sdf ? createFastTextSdfRenderer(resolvedSettings) : void 0;
+  const mappingResult = buildFastTextCharacterMapping({
+    characterSet: resolvedSettings.characterSet,
+    measureText: (character) => measureFastText(context, resolvedSettings.fontSize, character),
+    buffer: resolvedSettings.buffer,
+    maxCanvasWidth: MAX_CANVAS_WIDTH
+  });
+  canvas.height = mappingResult.canvasHeight;
+  setTextStyle(context, resolvedSettings);
+  for (const character of resolvedSettings.characterSet) {
+    const frame = mappingResult.mapping[character];
+    if (frame) {
+      if (sdfRenderer) {
+        drawFastTextSdfCharacter(context, sdfRenderer, character, frame, resolvedSettings.buffer);
+      } else {
+        context.fillText(character, frame.x, frame.y + frame.anchorY);
+      }
+    }
+  }
+  const fontMetrics = measureFastText(context, resolvedSettings.fontSize);
+  return {
+    baselineOffset: (fontMetrics.ascent - fontMetrics.descent) / 2,
+    mapping: mappingResult.mapping,
+    data: canvas,
+    width: canvas.width,
+    height: canvas.height
+  };
+}
+function buildFastTextCharacterMapping({ characterSet, measureText, buffer, maxCanvasWidth }) {
+  const mapping = {};
+  let x = 0;
+  let yMin = 0;
+  let yMax = 0;
+  for (const character of characterSet) {
+    const { advance, width, ascent, descent } = measureText(character);
+    const height = ascent + descent;
+    if (x + width + buffer * 2 > maxCanvasWidth) {
+      x = 0;
+      yMin = yMax;
+    }
+    mapping[character] = {
+      x: x + buffer,
+      y: yMin + buffer,
+      width,
+      height,
+      advance,
+      anchorX: width / 2,
+      anchorY: ascent
+    };
+    x += width + buffer * 2;
+    yMax = Math.max(yMax, yMin + height + buffer * 2);
+  }
+  return {
+    mapping,
+    canvasHeight: Math.max(1, nextPowerOfTwo(yMax))
+  };
+}
+var FastTextFontAtlasManager = class {
+  /** Current resolved font settings. */
+  props = { ...DEFAULT_FAST_TEXT_FONT_SETTINGS };
+  currentAtlas;
+  currentKey;
+  /** Current atlas, if one has been built. */
+  get atlas() {
+    return this.currentAtlas;
+  }
+  /** Current character mapping, if an atlas has been built. */
+  get mapping() {
+    var _a;
+    return (_a = this.currentAtlas) == null ? void 0 : _a.mapping;
+  }
+  /** Update font settings and return whether the atlas was rebuilt. */
+  setProps(props = {}) {
+    this.props = {
+      ...this.props,
+      ...props,
+      characterSet: normalizeCharacterSet(props.characterSet ?? this.props.characterSet)
+    };
+    const nextKey = getFontAtlasKey(this.props);
+    if (this.currentAtlas && this.currentKey === nextKey) {
+      return false;
+    }
+    this.currentAtlas = createFastTextFontAtlas(this.props);
+    this.currentKey = nextKey;
+    return true;
+  }
+};
+var MAX_CANVAS_WIDTH = 1024;
+var DEFAULT_ASCENT = 0.9;
+var DEFAULT_DESCENT = 0.3;
+function getDefaultCharacterSet() {
+  const characterSet = [];
+  for (let code = 32; code < 128; code++) {
+    characterSet.push(String.fromCharCode(code));
+  }
+  return characterSet;
+}
+function normalizeCharacterSet(characterSet) {
+  return typeof characterSet === "string" ? new Set(Array.from(characterSet)) : new Set(characterSet);
+}
+function getFontAtlasKey(settings) {
+  const characters = Array.from(settings.characterSet).sort().join("");
+  return [
+    settings.fontFamily,
+    settings.fontWeight,
+    settings.fontSize,
+    settings.buffer,
+    settings.sdf,
+    settings.cutoff,
+    settings.radius,
+    characters
+  ].join("\n");
+}
+function setTextStyle(context, settings) {
+  context.font = `${settings.fontWeight} ${settings.fontSize}px ${settings.fontFamily}`;
+  context.fillStyle = "#000";
+  context.textBaseline = "alphabetic";
+  context.textAlign = "left";
+}
+function measureFastText(context, fontSize, character) {
+  if (character === void 0) {
+    const fontMetrics = context.measureText("A");
+    if (fontMetrics.fontBoundingBoxAscent) {
+      return {
+        advance: 0,
+        width: 0,
+        ascent: Math.ceil(fontMetrics.fontBoundingBoxAscent),
+        descent: Math.ceil(fontMetrics.fontBoundingBoxDescent)
+      };
+    }
+    return {
+      advance: 0,
+      width: 0,
+      ascent: fontSize * DEFAULT_ASCENT,
+      descent: fontSize * DEFAULT_DESCENT
+    };
+  }
+  const metrics = context.measureText(character);
+  if (!metrics.actualBoundingBoxAscent) {
+    return {
+      advance: metrics.width,
+      width: metrics.width,
+      ascent: fontSize * DEFAULT_ASCENT,
+      descent: fontSize * DEFAULT_DESCENT
+    };
+  }
+  return {
+    advance: metrics.width,
+    width: Math.ceil(metrics.actualBoundingBoxRight - metrics.actualBoundingBoxLeft),
+    ascent: Math.ceil(metrics.actualBoundingBoxAscent),
+    descent: Math.ceil(metrics.actualBoundingBoxDescent)
+  };
+}
+function createFastTextSdfRenderer(settings) {
+  const buffer = Math.ceil(settings.buffer);
+  const size = Math.ceil(settings.fontSize + buffer * 4);
+  const scratchSize = size + buffer;
+  const canvas = document.createElement("canvas");
+  canvas.width = size;
+  canvas.height = size;
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) {
+    throw new Error("FastTextLayer SDF generation requires a 2D canvas context");
+  }
+  setTextStyle(context, settings);
+  const gridOuter = new Float64Array(scratchSize * scratchSize);
+  const gridInner = new Float64Array(scratchSize * scratchSize);
+  const f = new Float64Array(scratchSize);
+  const z = new Float64Array(scratchSize + 1);
+  const v = new Uint16Array(scratchSize);
+  return {
+    draw: (character) => drawFastTextSdfGlyph({
+      character,
+      context,
+      fontSize: settings.fontSize,
+      buffer,
+      cutoff: settings.cutoff,
+      radius: settings.radius,
+      size,
+      gridOuter,
+      gridInner,
+      f,
+      z,
+      v
+    })
+  };
+}
+function drawFastTextSdfCharacter(context, sdfRenderer, character, frame, buffer) {
+  const { data, width, height } = sdfRenderer.draw(character);
+  const imageData = context.createImageData(width, height);
+  populateAlphaChannel(data, imageData);
+  const x = frame.x - buffer;
+  const y = frame.y - buffer;
+  const x0 = Math.max(0, Math.round(x));
+  const y0 = Math.max(0, Math.round(y));
+  const w = Math.min(width, context.canvas.width - x0);
+  const h = Math.min(height, context.canvas.height - y0);
+  context.putImageData(imageData, x0, y0, 0, 0, w, h);
+  frame.x += x0 - x;
+  frame.y += y0 - y;
+}
+function populateAlphaChannel(alphaChannel, imageData) {
+  for (let index = 0; index < alphaChannel.length; index++) {
+    imageData.data[4 * index + 3] = alphaChannel[index];
+  }
+}
+var FAST_TEXT_SDF_INF = 1e20;
+function drawFastTextSdfGlyph({ character, context, fontSize, buffer, cutoff, radius, size, gridOuter, gridInner, f, z, v }) {
+  const metrics = context.measureText(character);
+  const glyphTop = Math.ceil(metrics.actualBoundingBoxAscent ?? fontSize * DEFAULT_ASCENT);
+  const glyphWidth = Math.max(0, Math.min(size - buffer, Math.ceil((metrics.actualBoundingBoxRight ?? metrics.width) - (metrics.actualBoundingBoxLeft ?? 0))));
+  const glyphHeight = Math.min(size - buffer, glyphTop + Math.ceil(metrics.actualBoundingBoxDescent ?? fontSize * DEFAULT_DESCENT));
+  const width = glyphWidth + 2 * buffer;
+  const height = glyphHeight + 2 * buffer;
+  const data = new Uint8ClampedArray(Math.max(width * height, 0));
+  if (glyphWidth === 0 || glyphHeight === 0) {
+    return { data, width, height };
+  }
+  context.clearRect(buffer, buffer, glyphWidth, glyphHeight);
+  context.fillText(character, buffer, buffer + glyphTop);
+  const imageData = context.getImageData(buffer, buffer, glyphWidth, glyphHeight);
+  gridOuter.fill(FAST_TEXT_SDF_INF, 0, data.length);
+  gridInner.fill(0, 0, data.length);
+  for (let y = 0; y < glyphHeight; y++) {
+    for (let x = 0; x < glyphWidth; x++) {
+      const alpha = imageData.data[4 * (y * glyphWidth + x) + 3] / 255;
+      if (alpha === 0) {
+        continue;
+      }
+      const gridIndex = (y + buffer) * width + x + buffer;
+      if (alpha === 1) {
+        gridOuter[gridIndex] = 0;
+        gridInner[gridIndex] = FAST_TEXT_SDF_INF;
+      } else {
+        const distance = 0.5 - alpha;
+        gridOuter[gridIndex] = distance > 0 ? distance * distance : 0;
+        gridInner[gridIndex] = distance < 0 ? distance * distance : 0;
+      }
+    }
+  }
+  transformFastTextSdfGrid(gridOuter, 0, 0, width, height, width, f, v, z);
+  transformFastTextSdfGrid(gridInner, buffer, buffer, glyphWidth, glyphHeight, width, f, v, z);
+  for (let index = 0; index < data.length; index++) {
+    const distance = Math.sqrt(gridOuter[index]) - Math.sqrt(gridInner[index]);
+    data[index] = Math.round(255 - 255 * (distance / radius + cutoff));
+  }
+  return { data, width, height };
+}
+function transformFastTextSdfGrid(data, x0, y0, width, height, gridSize, f, v, z) {
+  for (let x = x0; x < x0 + width; x++) {
+    transformFastTextSdfGrid1d(data, y0 * gridSize + x, gridSize, height, f, v, z);
+  }
+  for (let y = y0; y < y0 + height; y++) {
+    transformFastTextSdfGrid1d(data, y * gridSize + x0, 1, width, f, v, z);
+  }
+}
+function transformFastTextSdfGrid1d(grid, offset, stride, length, f, v, z) {
+  v[0] = 0;
+  z[0] = -FAST_TEXT_SDF_INF;
+  z[1] = FAST_TEXT_SDF_INF;
+  f[0] = grid[offset];
+  for (let q = 1, k = 0; q < length; q++) {
+    f[q] = grid[offset + q * stride];
+    const q2 = q * q;
+    let s = 0;
+    do {
+      const r = v[k];
+      s = (f[q] - f[r] + q2 - r * r) / (q - r) / 2;
+    } while (s <= z[k] && --k > -1);
+    k++;
+    v[k] = q;
+    z[k] = s;
+    z[k + 1] = FAST_TEXT_SDF_INF;
+  }
+  for (let q = 0, k = 0; q < length; q++) {
+    while (z[k + 1] < q) {
+      k++;
+    }
+    const r = v[k];
+    const qr = q - r;
+    grid[offset + q * stride] = f[r] + qr * qr;
+  }
+}
+function nextPowerOfTwo(value) {
+  return Math.pow(2, Math.ceil(Math.log2(Math.max(1, value))));
+}
+
+// dist/layers/fast-text-layer/fast-text-layer.js
+var defaultProps2 = {
+  billboard: true,
+  sizeScale: { type: "number", value: 1, min: 0 },
+  sizeUnits: "pixels",
+  sizeMinPixels: { type: "number", value: 0, min: 0 },
+  sizeMaxPixels: { type: "number", value: Number.MAX_SAFE_INTEGER, min: 0 },
+  alphaCutoff: { type: "number", value: 1e-3, min: 0, max: 1 },
+  characterSet: { type: "object", value: DEFAULT_FAST_TEXT_FONT_SETTINGS.characterSet },
+  fontFamily: DEFAULT_FAST_TEXT_FONT_SETTINGS.fontFamily,
+  fontWeight: DEFAULT_FAST_TEXT_FONT_SETTINGS.fontWeight,
+  lineHeight: { type: "number", value: 1, min: 0 },
+  size: { type: "number", value: 32, min: 0 },
+  pixelOffset: { type: "array", value: [0, 0] },
+  getPixelOffset: { type: "array", value: [0, 0] },
+  fontSettings: { type: "object", value: {}, compare: 1 },
+  characterMapping: { type: "object", value: null, optional: true },
+  fontAtlas: { type: "object", value: null, optional: true },
+  getText: { type: "accessor", value: (datum) => datum.text },
+  textUtf8Column: { type: "object", value: null, optional: true },
+  getTextUtf8Row: {
+    type: "accessor",
+    value: (_datum, objectInfo) => objectInfo.index
+  },
+  getTextUtf8: { type: "accessor", value: null },
+  singleLine: true,
+  getPosition: { type: "accessor", value: (datum) => datum.position },
+  getColor: { type: "accessor", value: [0, 0, 0, 255] },
+  textAnchor: "middle",
+  alignmentBaseline: "center",
+  getClipRect: { type: "accessor", value: [0, 0, -1, -1] },
+  getContentBox: { type: "accessor", value: [0, 0, -1, -1] },
+  contentCutoffPixels: { type: "array", value: [0, 0] },
+  contentAlignHorizontal: "none",
+  contentAlignVertical: "none"
+};
+var FastTextLayer = class extends import_core5.Layer {
+  /** Return the shader set used by the direct glyph instance model. */
+  getShaders() {
+    return super.getShaders({
+      vs: FAST_TEXT_VS,
+      fs: FAST_TEXT_FS,
+      modules: [import_core5.project32, import_core5.color, fastTextUniforms]
+    });
+  }
+  /** Initialize the model and atlas manager. */
+  initializeState() {
+    this.state = {
+      fontAtlasManager: new FastTextFontAtlasManager()
+    };
+    this.state.model = this.getModel();
+  }
+  /** Rebuild text layout or update dynamic glyph attributes when inputs change. */
+  updateState(params) {
+    var _a, _b;
+    super.updateState(params);
+    if (params.changeFlags.extensionsChanged) {
+      (_a = this.state.model) == null ? void 0 : _a.destroy();
+      this.state.model = this.getModel();
+      if (this.state.buffers) {
+        this.state.model.setAttributes(this.state.buffers);
+        this.state.model.setInstanceCount(((_b = this.state.glyphData) == null ? void 0 : _b.length) ?? 0);
+      }
+    }
+    if (shouldRebuildFastText(params) || this.hasMutableLayoutSourceChanged()) {
+      this.rebuildGlyphState();
+    } else {
+      const dynamicUpdate = getFastTextDynamicUpdate(params);
+      if (dynamicUpdate) {
+        this.updateDynamicGlyphState(dynamicUpdate);
+      }
+    }
+  }
+  /** Draw the glyph model when atlas texture and glyph buffers are ready. */
+  draw() {
+    const { atlasTexture, glyphData, model, fontSize } = this.state;
+    if (!model || !atlasTexture || !glyphData || glyphData.length === 0 || !fontSize) {
+      return;
+    }
+    model.shaderInputs.setProps({
+      fastText: {
+        fontAtlasTexture: atlasTexture,
+        fontAtlasSize: [atlasTexture.width, atlasTexture.height],
+        fontSize,
+        size: this.props.size,
+        sizeScale: this.props.sizeScale,
+        sizeMinPixels: this.props.sizeMinPixels,
+        sizeMaxPixels: this.props.sizeMaxPixels,
+        pixelOffset: this.props.pixelOffset,
+        billboard: this.props.billboard,
+        sizeUnits: import_core5.UNIT[this.props.sizeUnits],
+        alphaCutoff: this.props.alphaCutoff,
+        sdfEnabled: this.resolveSdfEnabled(),
+        sdfBuffer: FAST_TEXT_SDF_BUFFER,
+        sdfGamma: this.resolveSdfSmoothing(),
+        contentCutoffPixels: this.props.contentCutoffPixels,
+        contentAlign: [
+          getFastTextContentAlignUniform(this.props.contentAlignHorizontal),
+          getFastTextContentAlignUniform(this.props.contentAlignVertical)
+        ],
+        flipY: Boolean(this.context.viewport.flipY)
+      }
+    });
+    model.draw(this.context.renderPass);
+  }
+  /** Release GPU buffers, atlas texture, and the luma model. */
+  finalizeState(context) {
+    var _a, _b;
+    destroyFastTextBuffers(this.state.buffers);
+    (_a = this.state.atlasTexture) == null ? void 0 : _a.destroy();
+    (_b = this.state.model) == null ? void 0 : _b.destroy();
+    super.finalizeState(context);
+  }
+  /** Build a luma model for instanced glyph quads. */
+  getModel() {
+    return new import_engine2.Model(this.context.device, {
+      ...this.getShaders(),
+      id: this.props.id,
+      bufferLayout: FAST_TEXT_BUFFER_LAYOUT,
+      geometry: new import_engine2.Geometry({
+        topology: "triangle-list",
+        attributes: {
+          positions: {
+            size: 2,
+            value: new Float32Array([0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1])
+          }
+        }
+      }),
+      isInstanced: true
+    });
+  }
+  /** Rebuild CPU glyph data, GPU vertex buffers, and the font atlas texture. */
+  rebuildGlyphState() {
+    var _a, _b;
+    const rebuildStartTime = performance.now();
+    const atlasStartTime = performance.now();
+    const atlas = this.resolveFontAtlas();
+    const atlasDurationMs = performance.now() - atlasStartTime;
+    const mapping = this.props.characterMapping ?? atlas.mapping;
+    const glyphDataStartTime = performance.now();
+    const glyphData = buildFastTextGlyphData({
+      data: this.props.data,
+      getText: this.props.getText,
+      textUtf8Column: this.props.textUtf8Column,
+      getTextUtf8Row: this.props.getTextUtf8Row,
+      getTextUtf8: this.props.getTextUtf8,
+      singleLine: this.props.singleLine,
+      getPosition: this.props.getPosition,
+      getColor: this.props.getColor,
+      textAnchor: this.props.textAnchor,
+      alignmentBaseline: this.props.alignmentBaseline,
+      getClipRect: this.props.getClipRect,
+      mapping,
+      baselineOffset: atlas.baselineOffset,
+      fontSize: this.resolveFontSize(),
+      lineHeight: this.props.lineHeight
+    });
+    const glyphDataDurationMs = performance.now() - glyphDataStartTime;
+    const bufferStartTime = performance.now();
+    const buffers = createFastTextBuffers(this.context.device, glyphData);
+    const bufferCreateDurationMs = performance.now() - bufferStartTime;
+    destroyFastTextBuffers(this.state.buffers);
+    (_a = this.state.model) == null ? void 0 : _a.setAttributes(buffers);
+    (_b = this.state.model) == null ? void 0 : _b.setInstanceCount(glyphData.length);
+    this.setState({
+      glyphData,
+      buffers,
+      layoutSourceSignature: getFastTextLayoutSourceSignature(this.props)
+    });
+    logFastTextAttributeBuildProbe({
+      atlasDurationMs,
+      bufferCreateDurationMs,
+      glyphDataDurationMs,
+      glyphStats: glyphData.buildStats,
+      layerId: this.props.id,
+      totalDurationMs: performance.now() - rebuildStartTime
+    });
+    this.setNeedsRedraw();
+  }
+  /** Rewrite dynamic glyph attributes in place without rebuilding text layout. */
+  updateDynamicGlyphState(update) {
+    const { glyphData, buffers } = this.state;
+    if (!glyphData || !buffers) {
+      this.rebuildGlyphState();
+      return;
+    }
+    const updateStartTime = performance.now();
+    const dynamicStats = updateFastTextDynamicGlyphAttributes({
+      data: this.props.data,
+      glyphData,
+      getPosition: this.props.getPosition,
+      getColor: this.props.getColor,
+      getClipRect: this.props.getClipRect,
+      updatePositions: update.positions,
+      updateColors: update.colors,
+      updateClipRects: update.clipRects
+    });
+    if (dynamicStats.rowCount !== glyphData.startIndices.length - 1) {
+      this.rebuildGlyphState();
+      return;
+    }
+    const bufferUploadStartTime = performance.now();
+    if (update.positions) {
+      buffers.instancePositions.write(glyphData.attributes.instancePositions);
+    }
+    if (update.colors || update.clipRects) {
+      buffers.instanceGlyphData.write(glyphData.attributes.instanceGlyphData);
+    }
+    const bufferUploadDurationMs = performance.now() - bufferUploadStartTime;
+    logFastTextDynamicAttributeUpdateProbe({
+      bufferUploadDurationMs,
+      dynamicStats,
+      layerId: this.props.id,
+      totalDurationMs: performance.now() - updateStartTime,
+      update
+    });
+    this.setNeedsRedraw();
+  }
+  /** Return whether source data or UTF-8 column growth invalidated the current glyph layout. */
+  hasMutableLayoutSourceChanged() {
+    const { glyphData, layoutSourceSignature } = this.state;
+    if (!glyphData || !layoutSourceSignature) {
+      return true;
+    }
+    return !areFastTextLayoutSourceSignaturesEqual(getFastTextLayoutSourceSignature(this.props), layoutSourceSignature);
+  }
+  /** Resolve a caller-supplied atlas or rebuild the local generated atlas. */
+  resolveFontAtlas() {
+    const { characterMapping, fontAtlas } = this.props;
+    if ((this.props.textUtf8Column || this.props.getTextUtf8) && this.props.characterSet === "auto") {
+      throw new Error('FastTextLayer characterSet="auto" is not supported with UTF-8 text sources');
+    }
+    if (characterMapping || fontAtlas) {
+      if (!characterMapping || !fontAtlas) {
+        throw new Error("FastTextLayer requires characterMapping and fontAtlas to be supplied together");
+      }
+      this.syncAtlasTexture(fontAtlas);
+      return fontAtlas;
+    }
+    const characterSet = this.props.characterSet === "auto" ? collectFastTextCharacterSet({
+      data: this.props.data,
+      getText: this.props.getText
+    }) : this.props.characterSet;
+    this.state.fontAtlasManager.setProps({
+      ...this.props.fontSettings,
+      fontFamily: this.props.fontFamily,
+      fontWeight: this.props.fontWeight,
+      characterSet
+    });
+    const atlas = this.state.fontAtlasManager.atlas;
+    if (!atlas) {
+      throw new Error("FastTextLayer failed to build a font atlas");
+    }
+    this.syncAtlasTexture(atlas);
+    return atlas;
+  }
+  /** Resolve the atlas pixel size used by glyph offsets. */
+  resolveFontSize() {
+    return this.props.fontAtlas ? this.props.fontSettings.fontSize ?? DEFAULT_FAST_TEXT_FONT_SETTINGS.fontSize : this.state.fontAtlasManager.props.fontSize;
+  }
+  /** Resolve whether the current atlas should be sampled as SDF data. */
+  resolveSdfEnabled() {
+    return this.props.fontAtlas ? this.props.fontSettings.sdf ?? DEFAULT_FAST_TEXT_FONT_SETTINGS.sdf : this.state.fontAtlasManager.props.sdf;
+  }
+  /** Resolve the SDF smoothing width for the current atlas. */
+  resolveSdfSmoothing() {
+    return this.props.fontAtlas ? this.props.fontSettings.smoothing ?? DEFAULT_FAST_TEXT_FONT_SETTINGS.smoothing : this.state.fontAtlasManager.props.smoothing;
+  }
+  /** Upload a new atlas texture when the atlas object changes. */
+  syncAtlasTexture(atlas) {
+    var _a;
+    if (this.state.textureAtlas === atlas && this.state.atlasTexture) {
+      return;
+    }
+    (_a = this.state.atlasTexture) == null ? void 0 : _a.destroy();
+    const texture = createFastTextAtlasTexture(this.context.device, atlas);
+    this.setState({
+      textureAtlas: atlas,
+      atlasTexture: texture,
+      fontSize: this.resolveFontSize()
+    });
+  }
+};
+__publicField(FastTextLayer, "defaultProps", defaultProps2);
+__publicField(FastTextLayer, "layerName", "FastTextLayer");
+var FAST_TEXT_CONTENT_ALIGN = {
+  none: 0,
+  start: 1,
+  center: 2,
+  end: 3
+};
+var FAST_TEXT_ALIGN_START = FAST_TEXT_CONTENT_ALIGN.start;
+var FAST_TEXT_ALIGN_CENTER = FAST_TEXT_CONTENT_ALIGN.center;
+var FAST_TEXT_ALIGN_END = FAST_TEXT_CONTENT_ALIGN.end;
+var FAST_TEXT_SDF_BUFFER = 192 / 256;
+var fastTextLog = new import_log.Log({ id: "trace-layers" });
+var FAST_TEXT_PROBE_LABEL_STYLE = "background:#f59e0b;color:#111827;font-weight:700;padding:2px 8px;border-radius:6px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;";
+var fastTextUniforms = {
+  name: "fastText",
+  vs: `layout(std140) uniform fastTextUniforms {
+  vec2 fontAtlasSize;
+  float fontSize;
+  float size;
+  float sizeScale;
+  float sizeMinPixels;
+  float sizeMaxPixels;
+  vec2 pixelOffset;
+  bool billboard;
+  highp int sizeUnits;
+  float alphaCutoff;
+  bool sdfEnabled;
+  float sdfBuffer;
+  float sdfGamma;
+  vec2 contentCutoffPixels;
+  highp ivec2 contentAlign;
+  bool flipY;
+} fastText;
+
+#define FAST_TEXT_ALIGN_MODE_START ${FAST_TEXT_ALIGN_START}
+#define FAST_TEXT_ALIGN_MODE_CENTER ${FAST_TEXT_ALIGN_CENTER}
+#define FAST_TEXT_ALIGN_MODE_END ${FAST_TEXT_ALIGN_END}
+`,
+  fs: `layout(std140) uniform fastTextUniforms {
+  vec2 fontAtlasSize;
+  float fontSize;
+  float size;
+  float sizeScale;
+  float sizeMinPixels;
+  float sizeMaxPixels;
+  vec2 pixelOffset;
+  bool billboard;
+  highp int sizeUnits;
+  float alphaCutoff;
+  bool sdfEnabled;
+  float sdfBuffer;
+  float sdfGamma;
+  vec2 contentCutoffPixels;
+  highp ivec2 contentAlign;
+  bool flipY;
+} fastText;
+`,
+  uniformTypes: {
+    fontAtlasSize: "vec2<f32>",
+    fontSize: "f32",
+    size: "f32",
+    sizeScale: "f32",
+    sizeMinPixels: "f32",
+    sizeMaxPixels: "f32",
+    pixelOffset: "vec2<f32>",
+    billboard: "f32",
+    sizeUnits: "i32",
+    alphaCutoff: "f32",
+    sdfEnabled: "f32",
+    sdfBuffer: "f32",
+    sdfGamma: "f32",
+    contentCutoffPixels: "vec2<f32>",
+    contentAlign: "vec2<i32>",
+    flipY: "f32"
+  }
+};
+var FAST_TEXT_BUFFER_LAYOUT = [
+  { name: "instancePositions", stepMode: "instance", format: "float32x2" },
+  {
+    name: "instanceGlyphData",
+    stepMode: "instance",
+    byteStride: FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE,
+    attributes: [
+      { attribute: "instanceGlyphOffsets", format: "sint16x2", byteOffset: 0 },
+      {
+        attribute: "instanceGlyphFrames",
+        format: "uint16x4",
+        byteOffset: Int16Array.BYTES_PER_ELEMENT * 2
+      },
+      {
+        attribute: "instanceClipRects",
+        format: "sint16x4",
+        byteOffset: Int16Array.BYTES_PER_ELEMENT * 6
+      },
+      {
+        attribute: "instanceColors",
+        format: "unorm8x4",
+        byteOffset: Int16Array.BYTES_PER_ELEMENT * 10
+      }
+    ]
+  }
+];
+var DEFAULT_SAMPLER_PARAMETERS = {
+  minFilter: "linear",
+  mipmapFilter: "linear",
+  magFilter: "linear",
+  addressModeU: "clamp-to-edge",
+  addressModeV: "clamp-to-edge"
+};
+var FAST_TEXT_VS = `#version 300 es
+#define SHADER_NAME fast-text-layer-vertex-shader
+
+in vec2 positions;
+in vec2 instancePositions;
+in ivec2 instanceGlyphOffsets;
+in uvec4 instanceGlyphFrames;
+in ivec4 instanceClipRects;
+in vec4 instanceColors;
+
+out vec4 vColor;
+out vec2 vTextureCoords;
+out vec2 uv;
+
+float fastTextGetAlignmentPixelOffset(float anchor, float extent, float clipStart, float clipEnd, int mode) {
+  if (clipEnd < clipStart) {
+    return 0.0;
+  }
+  if (mode == FAST_TEXT_ALIGN_MODE_START) {
+    return max(-(anchor + clipStart), 0.0);
+  }
+  if (mode == FAST_TEXT_ALIGN_MODE_CENTER) {
+    float visibleMin = max(0.0, anchor + clipStart);
+    float visibleMax = min(extent, anchor + clipEnd);
+    return visibleMin < visibleMax ? (visibleMin + visibleMax) / 2.0 - anchor : 0.0;
+  }
+  if (mode == FAST_TEXT_ALIGN_MODE_END) {
+    return min(extent - (anchor + clipEnd), 0.0);
+  }
+  return 0.0;
+}
+
+void fastTextClipGlyphVertex(vec2 pixelOffset, vec2 anchorPosScreen) {
+  vec4 clipRect = vec4(instanceClipRects);
+  vec2 clipXY = project_size_to_pixel(clipRect.xy);
+  vec2 clipWH = project_size_to_pixel(clipRect.zw);
+  if (fastText.flipY) {
+    clipXY.y = -clipXY.y - clipWH.y;
+  }
+
+  if (fastText.contentAlign.x > 0 || fastText.contentAlign.y > 0) {
+    vec2 viewportPixels = project.viewportSize / project.devicePixelRatio;
+    vec2 scrollPixels = vec2(
+      fastTextGetAlignmentPixelOffset(
+        anchorPosScreen.x,
+        viewportPixels.x,
+        clipXY.x,
+        clipXY.x + clipWH.x,
+        fastText.contentAlign.x
+      ),
+      -fastTextGetAlignmentPixelOffset(
+        anchorPosScreen.y,
+        viewportPixels.y,
+        -clipXY.y - clipWH.y,
+        -clipXY.y,
+        fastText.contentAlign.y
+      )
+    );
+    pixelOffset += scrollPixels;
+    gl_Position.xy += project_pixel_size_to_clipspace(scrollPixels);
+  }
+
+  if (clipRect.z >= 0.0) {
+    if (pixelOffset.x < clipXY.x || pixelOffset.x > clipXY.x + clipWH.x) {
+      gl_Position = vec4(0.0);
+    } else if (fastText.contentCutoffPixels.x > 0.0) {
+      float viewportWidth = project.viewportSize.x / project.devicePixelRatio;
+      float left = max(anchorPosScreen.x + clipXY.x, 0.0);
+      float right = min(anchorPosScreen.x + clipXY.x + clipWH.x, viewportWidth);
+      if (right - left < fastText.contentCutoffPixels.x) {
+        gl_Position = vec4(0.0);
+      }
+    }
+  }
+  if (clipRect.w >= 0.0) {
+    if (pixelOffset.y < clipXY.y || pixelOffset.y > clipXY.y + clipWH.y) {
+      gl_Position = vec4(0.0);
+    } else if (fastText.contentCutoffPixels.y > 0.0) {
+      float viewportHeight = project.viewportSize.y / project.devicePixelRatio;
+      float top = max(anchorPosScreen.y - clipXY.y - clipWH.y, 0.0);
+      float bottom = min(anchorPosScreen.y - clipXY.y, viewportHeight);
+      if (bottom - top < fastText.contentCutoffPixels.y) {
+        gl_Position = vec4(0.0);
+      }
+    }
+  }
+}
+
+void main(void) {
+  vec3 worldPosition = vec3(instancePositions, 0.0);
+  geometry.worldPosition = worldPosition;
+  geometry.uv = positions;
+  uv = positions;
+
+  vec4 glyphFrame = vec4(instanceGlyphFrames);
+  vec2 glyphSize = glyphFrame.zw;
+  float sizePixels = clamp(
+    project_size_to_pixel(fastText.size * fastText.sizeScale, fastText.sizeUnits),
+    fastText.sizeMinPixels,
+    fastText.sizeMaxPixels
+  );
+  float instanceScale = fastText.fontSize == 0.0 ? 0.0 : sizePixels / fastText.fontSize;
+  vec2 pixelOffset = vec2(instanceGlyphOffsets) + positions * glyphSize;
+  pixelOffset = pixelOffset * instanceScale + fastText.pixelOffset;
+  pixelOffset.y *= -1.0;
+
+  vec2 anchorPosScreen;
+  if (fastText.billboard) {
+    gl_Position = project_position_to_clipspace(
+      worldPosition,
+      vec3(0.0),
+      vec3(0.0),
+      geometry.position
+    );
+    anchorPosScreen = gl_Position.xy / gl_Position.w;
+    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+    vec3 offset = vec3(pixelOffset, 0.0);
+    DECKGL_FILTER_SIZE(offset, geometry);
+    gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);
+  } else {
+    vec3 offsetCommon = vec3(project_pixel_size(pixelOffset), 0.0);
+    if (fastText.flipY) {
+      offsetCommon.y *= -1.0;
+    }
+    DECKGL_FILTER_SIZE(offsetCommon, geometry);
+    vec4 anchorPosition = project_position_to_clipspace(worldPosition, vec3(0.0), vec3(0.0));
+    anchorPosScreen = anchorPosition.xy / anchorPosition.w;
+    gl_Position = project_position_to_clipspace(
+      worldPosition,
+      vec3(0.0),
+      offsetCommon,
+      geometry.position
+    );
+    DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+  }
+
+  anchorPosScreen = vec2(anchorPosScreen.x + 1.0, 1.0 - anchorPosScreen.y) / 2.0 *
+    project.viewportSize / project.devicePixelRatio;
+  fastTextClipGlyphVertex(pixelOffset, anchorPosScreen);
+
+  vTextureCoords = (glyphFrame.xy + positions * glyphSize) / fastText.fontAtlasSize;
+  vColor = instanceColors;
+  DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;
+var FAST_TEXT_FS = `#version 300 es
+#define SHADER_NAME fast-text-layer-fragment-shader
+
+precision highp float;
+
+uniform sampler2D fontAtlasTexture;
+
+in vec4 vColor;
+in vec2 vTextureCoords;
+in vec2 uv;
+
+out vec4 fragColor;
+
+void main(void) {
+  geometry.uv = uv;
+
+  float alpha = texture(fontAtlasTexture, vTextureCoords).a;
+  if (fastText.sdfEnabled) {
+    alpha = smoothstep(fastText.sdfBuffer - fastText.sdfGamma, fastText.sdfBuffer + fastText.sdfGamma, alpha);
+  }
+  float outputAlpha = alpha * vColor.a;
+
+  if (outputAlpha < fastText.alphaCutoff) {
+    discard;
+  }
+
+  fragColor = vec4(vColor.rgb, outputAlpha * layer.opacity);
+
+  DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;
+function getFastTextLayoutSourceSignature(props) {
+  const textUtf8ColumnSignature = getFastTextUtf8ColumnSourceSignature(props.textUtf8Column);
+  return {
+    dataRowCount: getFastTextDataRowCount(props.data),
+    hasTextUtf8Accessor: Boolean(props.getTextUtf8),
+    textUtf8ColumnRowCount: textUtf8ColumnSignature.rowCount,
+    textUtf8ColumnChunkCount: textUtf8ColumnSignature.chunkCount,
+    textUtf8ColumnOffsetCount: textUtf8ColumnSignature.offsetCount,
+    textUtf8ColumnValueByteLength: textUtf8ColumnSignature.valueByteLength
+  };
+}
+function areFastTextLayoutSourceSignaturesEqual(signature, oldSignature) {
+  return signature.dataRowCount === oldSignature.dataRowCount && signature.hasTextUtf8Accessor === oldSignature.hasTextUtf8Accessor && signature.textUtf8ColumnRowCount === oldSignature.textUtf8ColumnRowCount && signature.textUtf8ColumnChunkCount === oldSignature.textUtf8ColumnChunkCount && signature.textUtf8ColumnOffsetCount === oldSignature.textUtf8ColumnOffsetCount && signature.textUtf8ColumnValueByteLength === oldSignature.textUtf8ColumnValueByteLength;
+}
+function getFastTextDataRowCount(data) {
+  const arrayLikeLength = data.length;
+  if (typeof arrayLikeLength === "number") {
+    return arrayLikeLength;
+  }
+  const tableLikeNumRows = data.numRows;
+  if (typeof tableLikeNumRows === "number") {
+    return tableLikeNumRows;
+  }
+  const { iterable } = (0, import_core5.createIterable)(data);
+  let rowCount = 0;
+  for (const _object of iterable) {
+    rowCount++;
+  }
+  return rowCount;
+}
+function getFastTextUtf8ColumnSourceSignature(textUtf8Column) {
+  if (!textUtf8Column) {
+    return { rowCount: 0, chunkCount: 0, offsetCount: 0, valueByteLength: 0 };
+  }
+  const source = normalizeFastTextUtf8ColumnForComparison(textUtf8Column);
+  if (!source) {
+    return { rowCount: -1, chunkCount: -1, offsetCount: -1, valueByteLength: -1 };
+  }
+  let offsetCount = 0;
+  let valueByteLength = 0;
+  for (const chunk of source.chunks) {
+    offsetCount += chunk.valueOffsets.length;
+    valueByteLength += chunk.values.byteLength;
+  }
+  return {
+    rowCount: source.rowCount,
+    chunkCount: source.chunks.length,
+    offsetCount,
+    valueByteLength
+  };
+}
+function shouldRebuildFastText(layerParams) {
+  const { props, oldProps, changeFlags } = layerParams;
+  const updateTriggersChanged = changeFlags.updateTriggersChanged;
+  return Boolean(changeFlags.dataChanged) || didFastTextAccessorPropChange(props.getText, oldProps.getText) || !areFastTextUtf8ColumnsEqual(props.textUtf8Column, oldProps.textUtf8Column) || didFastTextAccessorPropChange(props.getTextUtf8Row, oldProps.getTextUtf8Row) || didFastTextAccessorPropChange(props.getTextUtf8, oldProps.getTextUtf8) || props.singleLine !== oldProps.singleLine || props.textAnchor !== oldProps.textAnchor || props.alignmentBaseline !== oldProps.alignmentBaseline || props.characterSet !== oldProps.characterSet || props.fontFamily !== oldProps.fontFamily || props.fontWeight !== oldProps.fontWeight || props.lineHeight !== oldProps.lineHeight || props.fontSettings !== oldProps.fontSettings || props.characterMapping !== oldProps.characterMapping || props.fontAtlas !== oldProps.fontAtlas || Boolean(updateTriggersChanged && (updateTriggersChanged.all || updateTriggersChanged.getText || updateTriggersChanged.getTextUtf8 || updateTriggersChanged.getTextUtf8Row));
+}
+function getFastTextDynamicUpdate(layerParams) {
+  const { props, oldProps, changeFlags } = layerParams;
+  const updateTriggersChanged = changeFlags.updateTriggersChanged;
+  const positions = didFastTextAccessorPropChange(props.getPosition, oldProps.getPosition) || Boolean(updateTriggersChanged && updateTriggersChanged.getPosition);
+  const colors = didFastTextAccessorPropChange(props.getColor, oldProps.getColor) || Boolean(updateTriggersChanged && updateTriggersChanged.getColor);
+  const clipRects = didFastTextAccessorPropChange(props.getClipRect, oldProps.getClipRect) || Boolean(updateTriggersChanged && updateTriggersChanged.getClipRect);
+  if (!positions && !colors && !clipRects) {
+    return null;
+  }
+  return { positions, colors, clipRects };
+}
+function areFastTextUtf8ColumnsEqual(textUtf8Column, oldTextUtf8Column) {
+  if (textUtf8Column === oldTextUtf8Column) {
+    return true;
+  }
+  if (!textUtf8Column || !oldTextUtf8Column) {
+    return false;
+  }
+  const source = normalizeFastTextUtf8ColumnForComparison(textUtf8Column);
+  const oldSource = normalizeFastTextUtf8ColumnForComparison(oldTextUtf8Column);
+  if (!source || !oldSource || source.rowCount !== oldSource.rowCount) {
+    return false;
+  }
+  if (source.chunks.length !== oldSource.chunks.length) {
+    return false;
+  }
+  for (let index = 0; index < source.chunks.length; index += 1) {
+    const chunk = source.chunks[index];
+    const oldChunk = oldSource.chunks[index];
+    if (chunk.rowOffset !== oldChunk.rowOffset || chunk.rowCount !== oldChunk.rowCount || chunk.valueOffsetIndex !== oldChunk.valueOffsetIndex || chunk.valueOffsets !== oldChunk.valueOffsets || chunk.values !== oldChunk.values) {
+      return false;
+    }
+  }
+  return true;
+}
+function normalizeFastTextUtf8ColumnForComparison(textUtf8Column) {
+  return isFastTextUtf8ColumnSource2(textUtf8Column) ? textUtf8Column : buildFastTextUtf8ColumnSource(textUtf8Column);
+}
+function isFastTextUtf8ColumnSource2(textUtf8Column) {
+  return "rowCount" in textUtf8Column && "chunks" in textUtf8Column;
+}
+function didFastTextAccessorPropChange(accessor, oldAccessor) {
+  if (typeof oldAccessor === "function") {
+    return false;
+  }
+  if (typeof accessor === "function") {
+    return true;
+  }
+  return !areFastTextAccessorConstantsEqual(accessor, oldAccessor);
+}
+function areFastTextAccessorConstantsEqual(accessor, oldAccessor) {
+  if (accessor === oldAccessor) {
+    return true;
+  }
+  if (!Array.isArray(accessor) || !Array.isArray(oldAccessor)) {
+    return false;
+  }
+  if (accessor.length !== oldAccessor.length) {
+    return false;
+  }
+  for (let index = 0; index < accessor.length; index += 1) {
+    if (accessor[index] !== oldAccessor[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function logFastTextAttributeBuildProbe(params) {
+  getFastTextProbeLog().probe(0, `%cFastTextLayer%c ${params.glyphStats.rowCount} rows in ${formatFastTextDurationMs(params.totalDurationMs)} ${params.layerId}`, FAST_TEXT_PROBE_LABEL_STYLE, "", {
+    layerId: params.layerId,
+    updateMode: "full",
+    sourceMode: params.glyphStats.sourceMode,
+    layoutMode: params.glyphStats.layoutMode,
+    rowCount: params.glyphStats.rowCount,
+    glyphCount: params.glyphStats.glyphCount,
+    attributeByteLength: params.glyphStats.attributeByteLength,
+    atlasDurationMs: params.atlasDurationMs,
+    glyphDataDurationMs: params.glyphDataDurationMs,
+    columnNormalizeDurationMs: params.glyphStats.columnNormalizeDurationMs,
+    countDurationMs: params.glyphStats.countDurationMs,
+    allocateDurationMs: params.glyphStats.allocateDurationMs,
+    writeDurationMs: params.glyphStats.writeDurationMs,
+    textResolveDurationMs: params.glyphStats.textResolveDurationMs,
+    styleAccessorDurationMs: params.glyphStats.styleAccessorDurationMs,
+    layoutDurationMs: params.glyphStats.layoutDurationMs,
+    glyphWriteDurationMs: params.glyphStats.glyphWriteDurationMs,
+    bufferCreateDurationMs: params.bufferCreateDurationMs,
+    totalDurationMs: params.totalDurationMs
+  })();
+}
+function logFastTextDynamicAttributeUpdateProbe(params) {
+  getFastTextProbeLog().probe(0, `%cFastTextLayer%c dynamic ${params.dynamicStats.rowCount} rows in ${formatFastTextDurationMs(params.totalDurationMs)} ${params.layerId}`, FAST_TEXT_PROBE_LABEL_STYLE, "", {
+    layerId: params.layerId,
+    updateMode: "dynamic",
+    updatePositions: params.update.positions,
+    updateColors: params.update.colors,
+    updateClipRects: params.update.clipRects,
+    rowCount: params.dynamicStats.rowCount,
+    glyphCount: params.dynamicStats.glyphCount,
+    attributeByteLength: params.dynamicStats.attributeByteLength,
+    positionAccessorDurationMs: params.dynamicStats.positionAccessorDurationMs,
+    colorAccessorDurationMs: params.dynamicStats.colorAccessorDurationMs,
+    clipRectAccessorDurationMs: params.dynamicStats.clipRectAccessorDurationMs,
+    writeDurationMs: params.dynamicStats.writeDurationMs,
+    bufferUploadDurationMs: params.bufferUploadDurationMs,
+    totalDurationMs: params.totalDurationMs
+  })();
+}
+function formatFastTextDurationMs(durationMs) {
+  return `${durationMs.toFixed(durationMs < 10 ? 2 : 1)}ms`;
+}
+function getFastTextProbeLog() {
+  var _a;
+  const globalLog = (_a = globalThis.traceLayers) == null ? void 0 : _a.log;
+  return globalLog ?? fastTextLog;
+}
+function createFastTextBuffers(device, glyphData) {
+  const { attributes } = glyphData;
+  return {
+    instanceGlyphData: createVertexBuffer(device, attributes.instanceGlyphData, new Uint8Array(FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE)),
+    instancePositions: createVertexBuffer(device, attributes.instancePositions, new Float32Array(2))
+  };
+}
+function createVertexBuffer(device, data, fallback) {
+  return device.createBuffer({
+    data: data.byteLength > 0 ? data : fallback,
+    usage: import_core6.Buffer.VERTEX | import_core6.Buffer.COPY_DST
+  });
+}
+function destroyFastTextBuffers(buffers) {
+  if (!buffers) {
+    return;
+  }
+  for (const buffer of Object.values(buffers)) {
+    buffer.destroy();
+  }
+}
+function createFastTextAtlasTexture(device, atlas) {
+  const texture = device.createTexture({
+    format: "rgba8unorm",
+    data: null,
+    width: atlas.width,
+    height: atlas.height,
+    sampler: DEFAULT_SAMPLER_PARAMETERS,
+    mipLevels: device.getMipLevelCount(atlas.width, atlas.height)
+  });
+  texture.copyExternalImage({
+    image: atlas.data,
+    width: atlas.width,
+    height: atlas.height
+  });
+  regenerateMipmaps(texture);
+  return texture;
+}
+function regenerateMipmaps(texture) {
+  if (texture.device.type === "webgl") {
+    texture.generateMipmapsWebGL();
+  } else if (texture.device.type === "webgpu") {
+    texture.device.generateMipmapsWebGPU(texture);
+  }
+}
+function getFastTextContentAlignUniform(mode) {
+  return FAST_TEXT_CONTENT_ALIGN[mode];
+}
+
+// dist/views/orthographic-utils.js
+function fitBoundsOrthographic(width, height, bounds, zoomMode = "per-axis") {
+  const [[minX, minY], [maxX, maxY]] = bounds;
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  const boxW = Math.max(0, maxX - minX);
+  const boxH = Math.max(0, maxY - minY);
+  const scaleX = boxW ? Math.max(1, width) / boxW : 1;
+  const scaleY = boxH ? Math.max(1, height) / boxH : 1;
+  const scale = Math.min(scaleX, scaleY);
+  const zoom = Math.log2(scale);
+  const zoomX = Math.log2(scaleX);
+  const zoomY = Math.log2(scaleY);
+  if (Number.isNaN(zoom) || Number.isNaN(zoomX) || Number.isNaN(zoomY)) {
+    console.warn("Invalid zoom values:", { zoom, zoomX, zoomY });
+  }
+  return {
+    target: [centerX, centerY],
+    zoom: zoomMode === "single" ? zoom : [zoomX, zoomY],
+    zoomX: zoomMode === "single" ? zoom : zoomX,
+    zoomY: zoomMode === "single" ? zoom : zoomY
+  };
+}
+function getBoundsOrthographic(width, height, zoom, target) {
+  const [centerX, centerY] = target;
+  const scaleX = Array.isArray(zoom) ? 2 ** zoom[0] : 2 ** zoom;
+  const scaleY = Array.isArray(zoom) ? 2 ** zoom[1] : 2 ** zoom;
+  const worldW = width / scaleX;
+  const worldH = height / scaleY;
+  return [
+    [centerX - worldW / 2, centerY - worldH / 2],
+    [centerX + worldW / 2, centerY + worldH / 2]
+  ];
+}
+
+// dist/views/view-layout/view-layout-item.js
+var import_core7 = require("@deck.gl/core");
+var ViewLayoutItem = class {
+  /** Validated props backing this layout node. */
+  props;
+  /**
+   * Creates one validated layout item from discriminated-union props.
+   *
+   * @param props - Layout item props keyed by `type`.
+   */
+  constructor(props) {
+    assertViewLayoutItemProps(props);
+    this.props = props;
+  }
+};
+function assertViewLayoutItemProps(props) {
+  if (!props || typeof props !== "object") {
+    throw new Error("ViewLayoutItem props must be an object.");
+  }
+  switch (props.type) {
+    case "row":
+    case "column":
+    case "overlay":
+      if (!Array.isArray(props.children)) {
+        throw new Error(`ViewLayoutItem "${props.type}" requires a children array.`);
+      }
+      break;
+    case "view":
+      if (!(props.view instanceof import_core7.View)) {
+        throw new Error('ViewLayoutItem "view" requires a deck.gl View instance.');
+      }
+      break;
+    case "spacer":
+      break;
+    default: {
+      const exhaustiveCheck = props;
+      throw new Error(`Unsupported view layout item: ${String(exhaustiveCheck)}`);
+    }
+  }
+}
+
+// dist/views/view-layout/build-views-from-view-layout.js
+function buildViewsFromViewLayout(args) {
+  var _a;
+  const rootRect = {
+    x: 0,
+    y: 0,
+    width: Math.max(1, args.width),
+    height: Math.max(1, args.height)
+  };
+  const previousViewsById = new Map((((_a = args.previous) == null ? void 0 : _a.views) ?? []).map((view) => [getViewId(view), view]).filter((entry) => Boolean(entry[0])));
+  const outputViews = [];
+  const rectsById = {};
+  compileLayoutItem({
+    item: args.layout,
+    rect: rootRect,
+    outputViews,
+    rectsById,
+    previousViewsById
+  });
+  return {
+    views: outputViews,
+    rectsById
+  };
+}
+function compileLayoutItem(args) {
+  const { item } = args;
+  switch (item.props.type) {
+    case "row":
+      compileStackLayout({ ...args, orientation: "row", children: item.props.children });
+      return;
+    case "column":
+      compileStackLayout({ ...args, orientation: "column", children: item.props.children });
+      return;
+    case "overlay":
+      compileOverlayLayout({ ...args, children: item.props.children });
+      return;
+    case "view":
+      compileResolvedView({
+        view: item.props.view,
+        rect: applyInsets(args.rect, item.props.inset),
+        outputViews: args.outputViews,
+        rectsById: args.rectsById,
+        previousViewsById: args.previousViewsById
+      });
+      return;
+    case "spacer":
+      return;
+  }
+}
+function compileStackLayout(args) {
+  const containerRect = applyInsets(args.rect, args.item.props.inset);
+  const children = args.children.filter(isPresentChild);
+  if (children.length === 0) {
+    return;
+  }
+  const containerAxisLength = args.orientation === "row" ? containerRect.width : containerRect.height;
+  const explicitLengths = children.map((child) => resolveStackChildAxisLength(child, args.orientation, containerAxisLength));
+  const fixedLength = explicitLengths.reduce((sum, length) => sum + (length ?? 0), 0);
+  const flexibleChildCount = explicitLengths.filter((length) => length === void 0).length;
+  const flexibleLength = flexibleChildCount > 0 ? Math.max(containerAxisLength - fixedLength, 0) / flexibleChildCount : 0;
+  let cursor = args.orientation === "row" ? containerRect.x : containerRect.y;
+  children.forEach((child, index) => {
+    const childAxisLength = explicitLengths[index] ?? flexibleLength;
+    const childRect = args.orientation === "row" ? {
+      x: cursor,
+      y: containerRect.y,
+      width: childAxisLength,
+      height: containerRect.height
+    } : {
+      x: containerRect.x,
+      y: cursor,
+      width: containerRect.width,
+      height: childAxisLength
+    };
+    cursor += childAxisLength;
+    compileLayoutChild({
+      child,
+      rect: childRect,
+      outputViews: args.outputViews,
+      rectsById: args.rectsById,
+      previousViewsById: args.previousViewsById
+    });
+  });
+}
+function compileOverlayLayout(args) {
+  const containerRect = applyInsets(args.rect, args.item.props.inset);
+  args.children.filter(isPresentChild).forEach((child) => compileLayoutChild({
+    child,
+    rect: containerRect,
+    outputViews: args.outputViews,
+    rectsById: args.rectsById,
+    previousViewsById: args.previousViewsById
+  }));
+}
+function compileLayoutChild(args) {
+  if (args.child instanceof ViewLayoutItem) {
+    compileLayoutItem({
+      item: args.child,
+      rect: args.rect,
+      outputViews: args.outputViews,
+      rectsById: args.rectsById,
+      previousViewsById: args.previousViewsById
+    });
+    return;
+  }
+  compileResolvedView({
+    view: args.child,
+    rect: args.rect,
+    outputViews: args.outputViews,
+    rectsById: args.rectsById,
+    previousViewsById: args.previousViewsById
+  });
+}
+function compileResolvedView(args) {
+  const resolvedRect = resolveViewRectWithinParent(args.view, args.rect);
+  const viewId = getRequiredViewId(args.view);
+  args.rectsById[viewId] = resolvedRect;
+  const nextProps = {
+    ...args.view.props,
+    x: resolvedRect.x,
+    y: resolvedRect.y,
+    width: resolvedRect.width,
+    height: resolvedRect.height
+  };
+  const previousView = args.previousViewsById.get(viewId);
+  const nextView = previousView && previousView.constructor === args.view.constructor && arePropsEqual(previousView.props, nextProps) ? previousView : instantiateView(args.view, nextProps);
+  args.outputViews.push(nextView);
+}
+function resolveStackChildAxisLength(child, orientation, parentAxisLength) {
+  const axisValue = getAxisLengthValue(child, orientation);
+  if (axisValue === void 0) {
+    return void 0;
+  }
+  return resolveLength(axisValue, parentAxisLength);
+}
+function resolveViewRectWithinParent(view, parentRect) {
+  const props = view.props;
+  const x = parentRect.x + resolveOffset(props.x, parentRect.width);
+  const y = parentRect.y + resolveOffset(props.y, parentRect.height);
+  const width = resolveDimension(props.width, parentRect.width, parentRect.width);
+  const height = resolveDimension(props.height, parentRect.height, parentRect.height);
+  return {
+    x,
+    y,
+    width,
+    height
+  };
+}
+function instantiateView(view, props) {
+  const ViewConstructor = view.constructor;
+  return new ViewConstructor(props);
+}
+function getAxisLengthValue(child, orientation) {
+  if (child instanceof ViewLayoutItem) {
+    return orientation === "row" ? child.props.width : child.props.height;
+  }
+  const props = child.props;
+  return orientation === "row" ? props.width : props.height;
+}
+function applyInsets(rect, inset) {
+  if (!inset) {
+    return rect;
+  }
+  const top = inset.top ?? 0;
+  const right = inset.right ?? 0;
+  const bottom = inset.bottom ?? 0;
+  const left = inset.left ?? 0;
+  return {
+    x: rect.x + left,
+    y: rect.y + top,
+    width: Math.max(0, rect.width - left - right),
+    height: Math.max(0, rect.height - top - bottom)
+  };
+}
+function resolveOffset(value, parentLength) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  return resolveLength(value, parentLength);
+}
+function resolveDimension(value, parentLength, fallback) {
+  if (value === void 0 || value === null) {
+    return fallback;
+  }
+  return resolveLength(value, parentLength);
+}
+function resolveLength(value, parentLength) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    throw new Error("View layout length must not be empty.");
+  }
+  if (normalized.startsWith("calc(") && normalized.endsWith(")")) {
+    return resolveCalcExpression(normalized.slice(5, -1), parentLength);
+  }
+  return resolveLengthTerm(normalized, parentLength);
+}
+function resolveCalcExpression(expression, parentLength) {
+  const sanitized = expression.replace(/\s+/g, "");
+  const terms = sanitized.match(/[+-]?[^+-]+/g);
+  if (!terms) {
+    throw new Error(`Unsupported calc expression: calc(${expression})`);
+  }
+  return terms.reduce((sum, term) => sum + resolveLengthTerm(term, parentLength), 0);
+}
+function resolveLengthTerm(term, parentLength) {
+  if (term.endsWith("%")) {
+    return Number.parseFloat(term.slice(0, -1)) / 100 * parentLength;
+  }
+  if (term.endsWith("px")) {
+    return Number.parseFloat(term.slice(0, -2));
+  }
+  return Number.parseFloat(term);
+}
+function getViewId(view) {
+  const viewId = view.props.id;
+  return typeof viewId === "string" && viewId.length > 0 ? viewId : null;
+}
+function getRequiredViewId(view) {
+  const viewId = getViewId(view);
+  if (!viewId) {
+    throw new Error("Every compiled deck view must have a string id.");
+  }
+  return viewId;
+}
+function arePropsEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  return leftKeys.every((key) => areValuesEqual(left[key], right[key]));
+}
+function areValuesEqual(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => areValuesEqual(value, right[index]));
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftEntries = Object.keys(left);
+    const rightEntries = Object.keys(right);
+    return leftEntries.length === rightEntries.length && leftEntries.every((key) => areValuesEqual(left[key], right[key]));
+  }
+  return false;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
+function isPresentChild(child) {
+  return Boolean(child);
+}
+
+// dist/views/bounds-utils.js
+function getPaddedBlockBounds(geometry, options) {
+  const bounds = getGeometryBounds(geometry);
+  if (!bounds) {
+    return null;
+  }
+  const paddingFraction = (options == null ? void 0 : options.paddingFraction) ?? 0.1;
+  const minimumPadding = (options == null ? void 0 : options.minimumPadding) ?? 1;
+  return padBounds(bounds, paddingFraction, minimumPadding);
+}
+function getGeometryBounds(geometry) {
+  if (!geometry || geometry.length < 2) {
+    return null;
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let index = 0; index < geometry.length; index += 2) {
+    const x = geometry[index];
+    const y = geometry[index + 1];
+    if (x < minX)
+      minX = x;
+    if (y < minY)
+      minY = y;
+    if (x > maxX)
+      maxX = x;
+    if (y > maxY)
+      maxY = y;
+  }
+  if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(maxX) || !Number.isFinite(maxY)) {
+    return null;
+  }
+  return [
+    [minX, minY],
+    [maxX, maxY]
+  ];
+}
+function padBounds(bounds, paddingFraction, minimumPadding) {
+  const [[minX, minY], [maxX, maxY]] = bounds;
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const paddingX = Math.max(width * paddingFraction, minimumPadding);
+  const paddingY = Math.max(height * paddingFraction, minimumPadding);
+  return [
+    [minX - paddingX, minY - paddingY],
+    [maxX + paddingX, maxY + paddingY]
+  ];
+}
+
+// dist/views/view-state-utils.js
+function mergeViewStates(viewState1, viewState2) {
+  var _a, _b, _c, _d;
+  const target1 = viewState1.target ?? [0, 0];
+  const zoom1 = viewState1.zoom ?? [1, 1];
+  const mergedViewState = {
+    ...viewState1,
+    ...viewState2,
+    target: [((_a = viewState2.target) == null ? void 0 : _a[0]) ?? target1[0], ((_b = viewState2.target) == null ? void 0 : _b[1]) ?? target1[1]],
+    zoom: [
+      // ts-expect-error view state typing is awfully optional
+      ((_c = viewState2.zoom) == null ? void 0 : _c[0]) ?? zoom1[0],
+      // ts-expect-error view state typing is awfully optional
+      ((_d = viewState2.zoom) == null ? void 0 : _d[1]) ?? zoom1[1]
+    ]
+  };
+  validateViewState(mergedViewState);
+  return mergedViewState;
+}
+function validateViewState(viewState) {
+  const isTargetValid = Array.isArray(viewState.target) && viewState.target[0] !== void 0 && !Number.isNaN(viewState.target[0]) && viewState.target[1] !== void 0 && !Number.isNaN(viewState.target[1]);
+  const isZoomValid = Array.isArray(viewState.zoom) && viewState.zoom[0] !== void 0 && !Number.isNaN(viewState.zoom[0]) && viewState.zoom[1] !== void 0 && !Number.isNaN(viewState.zoom[1]);
+  if (!isTargetValid || !isZoomValid) {
+    console.warn("Invalid viewState:", viewState);
+  }
+  return isTargetValid && isZoomValid;
+}
+
+// dist/views/layer-filter.js
+function makeLayerFilter(filters) {
+  const regexpFilters = {};
+  for (const [key, value] of Object.entries(filters)) {
+    if ("include" in value) {
+      regexpFilters[key] = {
+        include: value.include.map((v) => new RegExp(v))
+      };
+    } else {
+      regexpFilters[key] = {
+        exclude: value.exclude.map((v) => new RegExp(v))
+      };
+    }
+  }
+  return ({ viewport, layer }) => {
+    let visible = true;
+    const viewFilters = regexpFilters[viewport.id] || {};
+    if ("include" in viewFilters) {
+      if (!viewFilters.include.some((regexp) => regexp.test(layer.id))) {
+        visible = false;
+      }
+    }
+    if ("exclude" in viewFilters) {
+      if (viewFilters.exclude.some((regexp) => regexp.test(layer.id))) {
+        visible = false;
+      }
+    }
+    return visible;
+  };
+}
+
+// dist/views/viewport-bounds-utils.js
+var DEFAULT_BOUNDS_EPSILON = 1e-6;
+function boundsAreEqual(a, b, options) {
+  const epsilon = (options == null ? void 0 : options.epsilon) ?? DEFAULT_BOUNDS_EPSILON;
+  let [ax, ay] = a[0];
+  let [bx, by] = b[0];
+  if (Math.abs(ax - bx) > epsilon || Math.abs(ay - by) > epsilon) {
+    return false;
+  }
+  [ax, ay] = a[1];
+  [bx, by] = b[1];
+  if (Math.abs(ax - bx) > epsilon || Math.abs(ay - by) > epsilon) {
+    return false;
+  }
+  return true;
+}
+function getViewportBoundsForViewState(view, deckDimensions) {
+  const target = view.target ?? [0, 0];
+  const zoomValue = view.zoom;
+  const zoomArray = Array.isArray(zoomValue) ? zoomValue : typeof zoomValue === "number" ? [zoomValue, zoomValue] : [0, 0];
+  const zoomX = zoomArray[0] ?? 0;
+  const zoomY = zoomArray[1] ?? zoomArray[0] ?? 0;
+  const scaleX = 2 ** zoomX || 1;
+  const scaleY = 2 ** zoomY || 1;
+  const halfWidth = deckDimensions.width / scaleX / 2;
+  const halfHeight = deckDimensions.height / scaleY / 2;
+  return {
+    minX: target[0] - halfWidth,
+    maxX: target[0] + halfWidth,
+    minY: target[1] - halfHeight,
+    maxY: target[1] + halfHeight
+  };
+}
+function isBoundsCompletelyOutside(bounds, viewport) {
+  const [[minX, minY], [maxX, maxY]] = bounds;
+  return maxX < viewport.minX || minX > viewport.maxX || maxY < viewport.minY || minY > viewport.maxY;
+}
+
+// dist/views/layer-bounds-filter.js
+function combineLayerFilters(filters) {
+  const definedFilters = filters.filter(Boolean);
+  if (!definedFilters.length) {
+    return null;
+  }
+  if (definedFilters.length === 1) {
+    return definedFilters[0];
+  }
+  return (context) => definedFilters.every((filter) => filter(context));
+}
+function createViewportBoundsFilter(options) {
+  const layerBoundsCache = /* @__PURE__ */ new WeakMap();
+  const viewportBoundsCache = /* @__PURE__ */ new WeakMap();
+  return (context) => {
+    var _a, _b, _c;
+    const { layer, viewport } = context;
+    let layerBounds = layerBoundsCache.get(layer);
+    if (layerBounds === void 0) {
+      layerBounds = getLayerBounds(layer);
+      layerBoundsCache.set(layer, layerBounds);
+    }
+    if (!layerBounds) {
+      (_a = options == null ? void 0 : options.onDecision) == null ? void 0 : _a.call(options, { decision: "missing-layer-bounds", context });
+      return true;
+    }
+    let viewportBounds = viewportBoundsCache.get(viewport);
+    if (viewportBounds === void 0) {
+      viewportBounds = getViewportBounds(viewport);
+      viewportBoundsCache.set(viewport, viewportBounds);
+    }
+    if (!viewportBounds) {
+      (_b = options == null ? void 0 : options.onDecision) == null ? void 0 : _b.call(options, { decision: "missing-viewport-bounds", context, layerBounds });
+      return true;
+    }
+    const shouldRender = boundsOverlap(layerBounds, viewportBounds);
+    if (!shouldRender) {
+      (_c = options == null ? void 0 : options.onDecision) == null ? void 0 : _c.call(options, { decision: "filter", context, layerBounds, viewportBounds });
+    }
+    return shouldRender;
+  };
+}
+function getLayerBounds(layer) {
+  const bounds = layer.getBounds();
+  if (!bounds || bounds.length < 2) {
+    return null;
+  }
+  return normalizeBounds(bounds[0], bounds[1]);
+}
+function getViewportBounds(viewport) {
+  const bounds = viewport.getBounds();
+  if (!bounds || bounds.length < 4) {
+    return null;
+  }
+  const [minX, minY, maxX, maxY] = bounds;
+  if (!isFiniteNumber(minX) || !isFiniteNumber(minY) || !isFiniteNumber(maxX) || !isFiniteNumber(maxY)) {
+    return null;
+  }
+  return normalizeBounds([minX, minY], [maxX, maxY]);
+}
+function normalizeBounds(min, max) {
+  if (!min || !max || min.length < 2 || max.length < 2) {
+    return null;
+  }
+  const minX = Math.min(min[0], max[0]);
+  const minY = Math.min(min[1], max[1]);
+  const maxX = Math.max(min[0], max[0]);
+  const maxY = Math.max(min[1], max[1]);
+  if (!isFiniteNumber(minX) || !isFiniteNumber(minY) || !isFiniteNumber(maxX) || !isFiniteNumber(maxY)) {
+    return null;
+  }
+  return [minX, minY, maxX, maxY];
+}
+function boundsOverlap(a, b) {
+  return !(a[2] < b[0] || b[2] < a[0] || a[3] < b[1] || b[3] < a[1]);
+}
+function isFiniteNumber(value) {
+  return Number.isFinite(value);
+}
+
+// dist/synchronized-views/synchronized-views.js
+var import_core8 = require("@deck.gl/core");
+var HEADER_VIEW_HEIGHT = 50;
+var LEGEND_VIEW_WIDTH = 150;
+var SYNCHRONIZED_VIEWS = [
+  new import_core8.OrthographicView({
+    id: "main",
+    flipY: false,
+    clear: true,
+    // [1, 1, 1, 1],
+    x: LEGEND_VIEW_WIDTH,
+    width: `calc(100% - ${LEGEND_VIEW_WIDTH}px)`,
     y: HEADER_VIEW_HEIGHT,
     height: `calc(100% - ${HEADER_VIEW_HEIGHT}px)`,
     controller: {
-      type: import_core2.OrthographicController,
+      type: import_core8.OrthographicController,
       // @ts-expect-error Specific to OrthographicController
       zoomAxis: "X",
       inertia: false,
       scrollZoom: true
     }
   }),
-  new import_core2.OrthographicView({
+  new import_core8.OrthographicView({
     id: "header",
     flipY: false,
     clear: true,
@@ -305,7 +3189,7 @@ var SYNCHRONIZED_VIEWS = [
     height: 50,
     controller: false
   }),
-  new import_core2.OrthographicView({
+  new import_core8.OrthographicView({
     id: "legend",
     flipY: false,
     clear: true,