@deck.gl-community/infovis-layers 9.3.8 → 9.4.0-alpha.1

package/dist/index.cjs

@@ -69,7 +69,7 @@ __export(dist_exports, {
 module.exports = __toCommonJS(dist_exports);
 
 // dist/layers/time-delta-layer.js
-var import_core = require("@deck.gl/core");
+var import_core4 = require("@deck.gl/core");
 var import_layers = require("@deck.gl/layers");
 
 // dist/utils/format-utils.js
@@ -143,1098 +143,518 @@ function formatDayDuration(seconds) {
   return `${sign}${days}d${remainingHours}h`;
 }
 
-// dist/layers/time-delta-layer.js
-var TimeDeltaLayer = class extends import_core.CompositeLayer {
-  renderLayers() {
-    const { startTimeMs, endTimeMs, color: color3 = [0, 0, 0, 255], yMin, yMax } = this.props;
-    if (!this.props.header) {
-      const timeLines2 = [
-        {
-          sourcePosition: [startTimeMs, yMin],
-          targetPosition: [startTimeMs, yMax]
-        },
-        {
-          sourcePosition: [endTimeMs, yMin],
-          targetPosition: [endTimeMs, yMax]
-        }
-      ];
-      return [
-        // Interval end lines
-        new import_layers.LineLayer({
-          id: "time-delta-side-bars",
-          data: timeLines2,
-          getSourcePosition: (d) => d.sourcePosition,
-          getTargetPosition: (d) => d.targetPosition,
-          getColor: color3,
-          getWidth: 4,
-          widthUnits: "pixels"
-        })
-      ];
-    }
-    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, y],
-        targetPosition: [startTimeMs, y - 7]
-      },
-      {
-        sourcePosition: [endTimeMs, y],
-        targetPosition: [endTimeMs, y - 7]
-      }
-    ];
-    return [
-      // Interval end lines
-      new import_layers.LineLayer({
-        id: "header-time-delta-side-bars",
-        data: timeLines,
-        getSourcePosition: (d) => d.sourcePosition,
-        getTargetPosition: (d) => d.targetPosition,
-        getColor: color3,
-        getWidth: 4,
-        widthUnits: "pixels"
-      }),
-      // Interval center
-      new import_layers.LineLayer({
-        id: "header-time-delta-dotted-line",
-        data: [
-          {
-            sourcePosition: [startTimeMs, y - 7],
-            targetPosition: [endTimeMs, y - 7]
-          }
-        ],
-        getSourcePosition: (d) => d.sourcePosition,
-        getTargetPosition: (d) => d.targetPosition,
-        getColor: color3,
-        getWidth: 1,
-        widthUnits: "pixels"
-      }),
-      // Label
-      new import_layers.TextLayer({
-        id: "header-time-delta-label",
-        data: [{ position: timeDeltaPosition, text: timeDeltaLabel }],
-        getPosition: (d) => d.position,
-        getText: (d) => d.text,
-        characterSet: "-0123456789.dhms\xB5",
-        getSize: fontSize,
-        fontFamily,
-        fontSettings,
-        fontWeight,
-        getColor: color3,
-        getTextAnchor: "middle",
-        getAlignmentBaseline: "center",
-        background: true,
-        getBackgroundColor: [255 - color3[0], 255 - color3[1], 255 - color3[2], 255],
-        backgroundPadding: [4, 2]
-        // Horizontal and vertical padding
-      })
-    ];
-  }
-};
-__publicField(TimeDeltaLayer, "layerName", "TimeDeltaLayer");
-__publicField(TimeDeltaLayer, "defaultProps", {
-  header: false,
-  minTimeMs: 0,
-  maxTimeMs: 100,
-  startTimeMs: 0,
-  endTimeMs: 100,
-  y: 0,
-  color: [0, 0, 0, 255],
-  unit: "timestamp",
-  yMin: -1e6,
-  // Should cover full viewport height in most cases
-  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/layers/animation-layer/animation-layer.js
+// dist/layers/fast-text-layer/fast-text-layer.js
 var import_core2 = require("@deck.gl/core");
+var import_core3 = require("@luma.gl/core");
+var import_engine = require("@luma.gl/engine");
+var import_log = require("@probe.gl/log");
 
-// 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
-    };
+// dist/layers/fast-text-layer/fast-text-layout.js
+var import_core = 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 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;
+  const sourceChunks = [];
+  let rowOffset = 0;
+  for (const chunk of chunks) {
+    const valueOffsets = chunk.valueOffsets;
+    const values = chunk.values;
+    if (!valueOffsets || !values) {
+      return null;
     }
-    return { frames, duration: Math.max(0, current - baseStart) };
+    sourceChunks.push({
+      rowOffset,
+      rowCount: chunk.length,
+      valueOffsetIndex: 0,
+      valueOffsets,
+      values
+    });
+    rowOffset += chunk.length;
   }
-  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 };
+  return {
+    rowCount: utf8Column.length,
+    chunks: sourceChunks,
+    isValid: (rowIndex) => utf8Column.isValid(rowIndex)
+  };
+}
+function getArrowUtf8RowView(utf8Column, rowIndex, out) {
+  if (!Number.isInteger(rowIndex) || rowIndex < 0 || rowIndex >= utf8Column.length) {
+    return false;
   }
-  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;
+  if (!utf8Column.isValid(rowIndex)) {
+    return false;
   }
-  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;
+  const chunks = getArrowUtf8DataChunks(utf8Column);
+  if (!chunks || chunks.length === 0) {
+    return false;
   }
-  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
-    });
+  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 reversed;
+  return false;
 }
-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
-    };
+function getUtf8ColumnSourceRowView(source, rowIndex, out) {
+  if (!Number.isInteger(rowIndex) || rowIndex < 0 || rowIndex >= source.rowCount) {
+    return false;
   }
-  const state = prevState;
-  if (time < state.end) {
-    return state;
-  }
-  const iterationEnd = state.end;
-  const iterations = state.iterations + 1;
-  if (iterations > repeat) {
-    return state;
+  if (!source.isValid(rowIndex)) {
+    return false;
   }
-  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
-    };
+  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 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;
+function arrowFindUtf8(utf8Column, value, startRow = 0) {
+  const normalizedStartRow = Math.max(0, startRow);
+  const fastResult = arrowFindUtf8InDataChunks(utf8Column, value, normalizedStartRow);
+  if (fastResult !== null) {
+    return fastResult;
   }
-  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;
+  const expected = decodeUtf8StringView(value);
+  for (let rowIndex = normalizedStartRow; rowIndex < utf8Column.length; rowIndex += 1) {
+    if (utf8Column.get(rowIndex) === expected) {
+      return rowIndex;
     }
-    return out;
   }
-  return to;
+  return -1;
 }
-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;
+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;
     }
-    if (frame.from === void 0) {
-      const from = {};
-      for (const key of Object.keys(frame.to)) {
-        from[key] = getPropValue(key);
+    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;
       }
-      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;
-        }
+      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 nextProps;
+  return -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;
+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;
   }
-  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;
+  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;
   }
-  renderLayers() {
-    return this.state.layer;
+  for (let index = 0; index < valueLength; index += 1) {
+    if (data[start + index] !== value.data[value.start + index]) {
+      return false;
+    }
   }
-};
-__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;
+  return true;
+}
+function decodeUtf8StringView(value) {
+  return textDecoder.decode(value.data.subarray(value.start, value.end));
+}
 
-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;
+// 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_core.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);
+      }
     }
-  } else {
-    fragColor = vFillColor;
   }
-
-  DECKGL_FILTER_COLOR(fragColor, geometry);
+  return characterSet;
 }
-`;
-
-// 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"
+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");
   }
-};
-
-// 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;
+  if ((textUtf8Column || props.getTextUtf8) && !props.singleLine) {
+    throw new Error("FastTextLayer UTF-8 text sources require singleLine text layout");
   }
-  return project_size(size) * project.scale;
+  const glyphData = props.singleLine ? buildSingleLineGlyphData({
+    ...props,
+    textUtf8Column
+  }) : buildMultiLineGlyphData(props);
+  return withFastTextGlyphBuildStats(glyphData, {
+    columnNormalizeDurationMs,
+    totalDurationMs: performance.now() - buildStartTime
+  });
 }
-
-float clamp_signed_size(float size, float minPixels, float maxPixels) {
-  float clampedMagnitude = clamp(abs(size), minPixels, maxPixels);
-  if (size < 0.0) {
-    return -clampedMagnitude;
+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_core.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 {
+      writeSingleLineStringLabelGlyphs(props, object, objectInfo, writeState, writeTimings);
+    }
   }
-  return clampedMagnitude;
+  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
+  });
 }
-
-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);
+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_core.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
+  });
 }
-`;
-
-// dist/layers/block-layer/block-layer.js
+function updateFastTextDynamicGlyphAttributes(props) {
+  const updateStartTime = performance.now();
+  const glyphRecordViews = createFastTextGlyphRecordViews(props.glyphData.attributes.instanceGlyphData);
+  const { iterable, objectInfo } = (0, import_core.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_COLOR;
+    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_COLOR;
+      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);
+      }
+    }
+    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_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 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 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]
-    });
+var BASELINE_OFFSET_MULTIPLIER = {
+  top: 0,
+  center: -0.5,
+  bottom: -1
+};
+function countSingleLineFastTextGlyphs(props) {
+  if (props.textUtf8Column) {
+    return countSingleLineUtf8FastTextGlyphs(props, props.textUtf8Column);
   }
-  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;
+  if (props.getTextUtf8) {
+    return countSingleLineUtf8ViewFastTextGlyphs(props, props.getTextUtf8);
   }
-  return {
-    rowCount: utf8Column.length,
-    chunks: sourceChunks,
-    isValid: (rowIndex) => utf8Column.isValid(rowIndex)
-  };
+  return countSingleLineStringFastTextGlyphs(props);
 }
-function getArrowUtf8RowView(utf8Column, rowIndex, out) {
-  if (!Number.isInteger(rowIndex) || rowIndex < 0 || rowIndex >= utf8Column.length) {
-    return false;
-  }
-  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);
+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_core.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;
     }
-    rowOffset = chunkEnd;
+    glyphCount += textView.end - textView.start;
   }
-  return false;
+  return { glyphCount, rowCount, characterSet };
 }
-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;
+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_core.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 fillUtf8StringView(chunk.valueOffsets, chunk.values, chunk.valueOffsetIndex + rowIndex - chunk.rowOffset, out);
   }
-  return false;
+  return { glyphCount, rowCount, characterSet };
 }
-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;
+function countSingleLineStringFastTextGlyphs(props) {
+  let glyphCount = 0;
+  let rowCount = 0;
+  const characterSet = /* @__PURE__ */ new Set();
+  const { iterable, objectInfo } = (0, import_core.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 -1;
+  return { glyphCount, rowCount, characterSet };
 }
-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)) {
+function countMultiLineFastTextGlyphs(props) {
+  let glyphCount = 0;
+  let rowCount = 0;
+  const characterSet = /* @__PURE__ */ new Set();
+  const { iterable, objectInfo } = (0, import_core.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;
       }
-      const start = valueOffsets[chunkRow];
-      const end = valueOffsets[chunkRow + 1];
-      if (start !== void 0 && end !== void 0 && utf8BytesEqual(values, start, end, value)) {
-        return globalRow;
-      }
+      characterSet.add(character);
+      glyphCount++;
     }
-    globalRowOffset += chunk.length;
   }
-  return -1;
+  return { glyphCount, rowCount, characterSet };
 }
-function getArrowUtf8DataChunks(utf8Column) {
-  return utf8Column.data;
+function allocateFastTextGlyphAttributes(glyphCount) {
+  return {
+    instanceGlyphData: new Uint8Array(glyphCount * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE),
+    instancePositions: new Float32Array(glyphCount * 2)
+  };
 }
-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 createFastTextGlyphRecordViews(instanceGlyphData) {
+  return {
+    int16Values: new Int16Array(instanceGlyphData.buffer),
+    uint16Values: new Uint16Array(instanceGlyphData.buffer),
+    uint8Values: instanceGlyphData
+  };
 }
-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/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,
+function createFastTextGlyphData(countResult, startIndices, attributes, stats) {
+  const byteLength = startIndices.byteLength + attributes.instanceGlyphData.byteLength + attributes.instancePositions.byteLength;
+  return {
+    length: countResult.glyphCount,
     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 {
-      writeSingleLineStringLabelGlyphs(props, object, objectInfo, writeState, writeTimings);
+    characterSet: countResult.characterSet,
+    byteLength,
+    buildStats: {
+      ...stats,
+      rowCount: countResult.rowCount,
+      glyphCount: countResult.glyphCount,
+      attributeByteLength: byteLength
     }
-  }
-  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)
+function createFastTextGlyphWriteTimings() {
+  return {
+    textResolveDurationMs: 0,
+    styleAccessorDurationMs: 0,
+    layoutDurationMs: 0,
+    glyphWriteDurationMs: 0
   };
-  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);
-      }
-    }
-    writeDurationMs += performance.now() - writeStartTime;
-    glyphCount += rowGlyphEnd - rowGlyphStart;
-  }
+function withFastTextGlyphBuildStats(glyphData, stats) {
   return {
-    rowCount,
-    glyphCount,
-    attributeByteLength: props.glyphData.byteLength,
-    positionAccessorDurationMs,
-    colorAccessorDurationMs,
-    clipRectAccessorDurationMs,
-    writeDurationMs,
-    totalDurationMs: performance.now() - updateStartTime
+    ...glyphData,
+    buildStats: {
+      ...glyphData.buildStats,
+      ...stats
+    }
   };
 }
-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);
+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;
   }
-  if (props.getTextUtf8) {
-    return countSingleLineUtf8ViewFastTextGlyphs(props, props.getTextUtf8);
+  const styleAccessorStartTime = performance.now();
+  const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
+  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;
   }
-  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 { glyphCount, rowCount, characterSet };
-}
-function allocateFastTextGlyphAttributes(glyphCount) {
-  return {
-    instanceGlyphData: new Uint8Array(glyphCount * FAST_TEXT_GLYPH_VERTEX_BYTE_STRIDE),
-    instancePositions: new Float32Array(glyphCount * 2)
-  };
-}
-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;
+  timings.glyphWriteDurationMs += performance.now() - glyphWriteStartTime;
 }
 function writeSingleLineUtf8LabelGlyphs(props, textUtf8Column, byteLookup, textView, object, objectInfo, writeState, timings) {
   const textResolveStartTime = performance.now();
@@ -1249,7 +669,7 @@ function writeSingleLineUtf8LabelGlyphs(props, textUtf8Column, byteLookup, textV
   }
   const styleAccessorStartTime = performance.now();
   const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
-  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
   const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
   timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
   const layoutStartTime = performance.now();
@@ -1284,7 +704,7 @@ function writeSingleLineUtf8ViewLabelGlyphs(props, getTextUtf8, byteLookup, text
   }
   const styleAccessorStartTime = performance.now();
   const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
-  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
   const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
   timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
   const layoutStartTime = performance.now();
@@ -1319,7 +739,7 @@ function writeMultiLineLabelGlyphs(props, object, objectInfo, writeState, timing
   }
   const styleAccessorStartTime = performance.now();
   const position = resolveAccessor(props.getPosition, object, objectInfo) ?? DEFAULT_POSITION;
-  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR2;
+  const color3 = resolveAccessor(props.getColor, object, objectInfo) ?? DEFAULT_COLOR;
   const clipRect = resolveAccessor(props.getClipRect, object, objectInfo) ?? DEFAULT_CLIP_RECT;
   timings.styleAccessorDurationMs += performance.now() - styleAccessorStartTime;
   const layoutStartTime = performance.now();
@@ -1460,10 +880,10 @@ 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]);
+  target[offset] = clampByte(color3[0] ?? DEFAULT_COLOR[0]);
+  target[offset + 1] = clampByte(color3[1] ?? DEFAULT_COLOR[1]);
+  target[offset + 2] = clampByte(color3[2] ?? DEFAULT_COLOR[2]);
+  target[offset + 3] = clampByte(color3[3] ?? DEFAULT_COLOR[3]);
 }
 function clampByte(value) {
   return Math.max(0, Math.min(255, Math.round(value)));
@@ -1805,8 +1225,255 @@ function nextPowerOfTwo(value) {
   return Math.pow(2, Math.ceil(Math.log2(Math.max(1, value))));
 }
 
+// dist/layers/fast-text-layer/fast-text-layer.wgsl.js
+var fast_text_layer_wgsl_default = (
+  /* wgsl */
+  `
+struct FastTextUniforms {
+  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,
+};
+
+@group(0) @binding(auto) var<uniform> fastText: FastTextUniforms;
+@group(0) @binding(auto) var fontAtlasTexture: texture_2d<f32>;
+@group(0) @binding(auto) var fontAtlasTextureSampler: sampler;
+
+struct FastTextAttributes {
+  @location(0) positions: vec2<f32>,
+  @location(1) instancePositions: vec2<f32>,
+  @location(2) instanceGlyphOffsets: vec2<i32>,
+  @location(3) instanceGlyphFrames: vec4<u32>,
+  @location(4) instanceClipRects: vec4<i32>,
+  @location(5) instanceColors: vec4<f32>,
+};
+
+struct FastTextVaryings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) textureCoords: vec2<f32>,
+  @location(2) uv: vec2<f32>,
+};
+
+struct FastTextClipResult {
+  position: vec4<f32>,
+  pixelOffset: vec2<f32>,
+};
+
+fn fast_text_alignment_pixel_offset(
+  anchor: f32,
+  extent: f32,
+  clipStart: f32,
+  clipEnd: f32,
+  mode: i32
+) -> f32 {
+  if (clipEnd < clipStart) {
+    return 0.0;
+  }
+  if (mode == 1) {
+    return max(-(anchor + clipStart), 0.0);
+  }
+  if (mode == 2) {
+    let visibleMin = max(0.0, anchor + clipStart);
+    let visibleMax = min(extent, anchor + clipEnd);
+    return select(0.0, (visibleMin + visibleMax) * 0.5 - anchor, visibleMin < visibleMax);
+  }
+  if (mode == 3) {
+    return min(extent - (anchor + clipEnd), 0.0);
+  }
+  return 0.0;
+}
+
+fn fast_text_clip_glyph_vertex(
+  initialPixelOffset: vec2<f32>,
+  anchorPositionScreen: vec2<f32>,
+  clipRect: vec4<i32>,
+  initialPosition: vec4<f32>
+) -> FastTextClipResult {
+  var result: FastTextClipResult;
+  result.position = initialPosition;
+  result.pixelOffset = initialPixelOffset;
+
+  let clipRectFloat = vec4<f32>(clipRect);
+  var clipXY = project_size_vec2(clipRectFloat.xy) * project.scale;
+  let clipWH = project_size_vec2(clipRectFloat.zw) * project.scale;
+
+  if (fastText.flipY > 0.5) {
+    clipXY.y = -clipXY.y - clipWH.y;
+  }
+
+  if (fastText.contentAlign.x > 0 || fastText.contentAlign.y > 0) {
+    let viewportPixels = project.viewportSize / project.devicePixelRatio;
+    let scrollPixels = vec2<f32>(
+      fast_text_alignment_pixel_offset(
+        anchorPositionScreen.x,
+        viewportPixels.x,
+        clipXY.x,
+        clipXY.x + clipWH.x,
+        fastText.contentAlign.x
+      ),
+      -fast_text_alignment_pixel_offset(
+        anchorPositionScreen.y,
+        viewportPixels.y,
+        -clipXY.y - clipWH.y,
+        -clipXY.y,
+        fastText.contentAlign.y
+      )
+    );
+    result.pixelOffset += scrollPixels;
+    result.position = vec4<f32>(
+      result.position.xy + project_pixel_size_to_clipspace(scrollPixels),
+      result.position.zw
+    );
+  }
+
+  if (clipRectFloat.z >= 0.0) {
+    if (result.pixelOffset.x < clipXY.x || result.pixelOffset.x > clipXY.x + clipWH.x) {
+      result.position = vec4<f32>(0.0);
+    } else if (fastText.contentCutoffPixels.x > 0.0) {
+      let viewportWidth = project.viewportSize.x / project.devicePixelRatio;
+      let left = max(anchorPositionScreen.x + clipXY.x, 0.0);
+      let right = min(anchorPositionScreen.x + clipXY.x + clipWH.x, viewportWidth);
+      if (right - left < fastText.contentCutoffPixels.x) {
+        result.position = vec4<f32>(0.0);
+      }
+    }
+  }
+
+  if (clipRectFloat.w >= 0.0) {
+    if (result.pixelOffset.y < clipXY.y || result.pixelOffset.y > clipXY.y + clipWH.y) {
+      result.position = vec4<f32>(0.0);
+    } else if (fastText.contentCutoffPixels.y > 0.0) {
+      let viewportHeight = project.viewportSize.y / project.devicePixelRatio;
+      let top = max(anchorPositionScreen.y - clipXY.y - clipWH.y, 0.0);
+      let bottom = min(anchorPositionScreen.y - clipXY.y, viewportHeight);
+      if (bottom - top < fastText.contentCutoffPixels.y) {
+        result.position = vec4<f32>(0.0);
+      }
+    }
+  }
+
+  return result;
+}
+
+@vertex
+fn vertexMain(attributes: FastTextAttributes) -> FastTextVaryings {
+  let worldPosition = vec3<f32>(attributes.instancePositions, 0.0);
+  geometry.worldPosition = worldPosition;
+  geometry.uv = attributes.positions;
+
+  let glyphFrame = vec4<f32>(attributes.instanceGlyphFrames);
+  let glyphSize = glyphFrame.zw;
+  let sizePixels = clamp(
+    project_unit_size_to_pixel(fastText.size * fastText.sizeScale, fastText.sizeUnits),
+    fastText.sizeMinPixels,
+    fastText.sizeMaxPixels
+  );
+  let instanceScale = select(sizePixels / fastText.fontSize, 0.0, fastText.fontSize == 0.0);
+  var pixelOffset = vec2<f32>(attributes.instanceGlyphOffsets) + attributes.positions * glyphSize;
+  pixelOffset = pixelOffset * instanceScale + fastText.pixelOffset;
+  pixelOffset.y = -pixelOffset.y;
+
+  var clipPosition: vec4<f32>;
+  var anchorPositionClip: vec4<f32>;
+
+  if (fastText.billboard > 0.5) {
+    let projected = project_position_to_clipspace_and_commonspace(
+      worldPosition,
+      vec3<f32>(0.0),
+      vec3<f32>(0.0)
+    );
+    geometry.position = projected.commonPosition;
+    anchorPositionClip = projected.clipPosition;
+    clipPosition = vec4<f32>(
+      projected.clipPosition.xy + project_pixel_size_to_clipspace(pixelOffset),
+      projected.clipPosition.zw
+    );
+  } else {
+    var offsetCommon = vec3<f32>(project_pixel_size_vec2(pixelOffset), 0.0);
+    if (fastText.flipY > 0.5) {
+      offsetCommon.y = -offsetCommon.y;
+    }
+    let projected = project_position_to_clipspace_and_commonspace(
+      worldPosition,
+      vec3<f32>(0.0),
+      offsetCommon
+    );
+    geometry.position = projected.commonPosition;
+    anchorPositionClip = project_position_to_clipspace(
+      worldPosition,
+      vec3<f32>(0.0),
+      vec3<f32>(0.0)
+    );
+    clipPosition = projected.clipPosition;
+  }
+
+  let anchorPositionNdc = anchorPositionClip.xy / anchorPositionClip.w;
+  let anchorPositionScreen = vec2<f32>(
+    anchorPositionNdc.x + 1.0,
+    1.0 - anchorPositionNdc.y
+  ) * 0.5 * project.viewportSize / project.devicePixelRatio;
+  let clipped = fast_text_clip_glyph_vertex(
+    pixelOffset,
+    anchorPositionScreen,
+    attributes.instanceClipRects,
+    clipPosition
+  );
+
+  var varyings: FastTextVaryings;
+  varyings.position = clipped.position;
+  varyings.color = attributes.instanceColors;
+  varyings.textureCoords =
+    (glyphFrame.xy + attributes.positions * glyphSize) / fastText.fontAtlasSize;
+  varyings.uv = attributes.positions;
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: FastTextVaryings) -> @location(0) vec4<f32> {
+  geometry.uv = varyings.uv;
+
+  var alpha = textureSample(
+    fontAtlasTexture,
+    fontAtlasTextureSampler,
+    varyings.textureCoords
+  ).a;
+
+  if (fastText.sdfEnabled > 0.5) {
+    alpha = smoothstep(
+      fastText.sdfBuffer - fastText.sdfGamma,
+      fastText.sdfBuffer + fastText.sdfGamma,
+      alpha
+    );
+  }
+
+  let outputAlpha = alpha * varyings.color.a;
+  if (outputAlpha < fastText.alphaCutoff) {
+    discard;
+  }
+
+  return deckgl_premultiplied_alpha(
+    vec4<f32>(varyings.color.rgb, outputAlpha * layer.opacity)
+  );
+}
+`
+);
+
 // dist/layers/fast-text-layer/fast-text-layer.js
-var defaultProps2 = {
+var defaultProps = {
   billboard: true,
   sizeScale: { type: "number", value: 1, min: 0 },
   sizeUnits: "pixels",
@@ -1841,13 +1508,14 @@ var defaultProps2 = {
   contentAlignHorizontal: "none",
   contentAlignVertical: "none"
 };
-var FastTextLayer = class extends import_core5.Layer {
+var FastTextLayer = class extends import_core2.Layer {
   /** Return the shader set used by the direct glyph instance model. */
   getShaders() {
     return super.getShaders({
+      source: fast_text_layer_wgsl_default,
       vs: FAST_TEXT_VS,
       fs: FAST_TEXT_FS,
-      modules: [import_core5.project32, import_core5.color, fastTextUniforms]
+      modules: [import_core2.project32, import_core2.color, fastTextUniforms]
     });
   }
   /** Initialize the model and atlas manager. */
@@ -1895,7 +1563,7 @@ var FastTextLayer = class extends import_core5.Layer {
         sizeMaxPixels: this.props.sizeMaxPixels,
         pixelOffset: this.props.pixelOffset,
         billboard: this.props.billboard,
-        sizeUnits: import_core5.UNIT[this.props.sizeUnits],
+        sizeUnits: import_core2.UNIT[this.props.sizeUnits],
         alphaCutoff: this.props.alphaCutoff,
         sdfEnabled: this.resolveSdfEnabled(),
         sdfBuffer: FAST_TEXT_SDF_BUFFER,
@@ -1920,11 +1588,11 @@ var FastTextLayer = class extends import_core5.Layer {
   }
   /** Build a luma model for instanced glyph quads. */
   getModel() {
-    return new import_engine2.Model(this.context.device, {
+    return new import_engine.Model(this.context.device, {
       ...this.getShaders(),
       id: this.props.id,
       bufferLayout: FAST_TEXT_BUFFER_LAYOUT,
-      geometry: new import_engine2.Geometry({
+      geometry: new import_engine.Geometry({
         topology: "triangle-list",
         attributes: {
           positions: {
@@ -2088,7 +1756,7 @@ var FastTextLayer = class extends import_core5.Layer {
     });
   }
 };
-__publicField(FastTextLayer, "defaultProps", defaultProps2);
+__publicField(FastTextLayer, "defaultProps", defaultProps);
 __publicField(FastTextLayer, "layerName", "FastTextLayer");
 var FAST_TEXT_CONTENT_ALIGN = {
   none: 0,
@@ -2104,6 +1772,7 @@ 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",
+  source: "",
   vs: `layout(std140) uniform fastTextUniforms {
   vec2 fontAtlasSize;
   float fontSize;
@@ -2164,436 +1833,1187 @@ var fastTextUniforms = {
     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 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_core2.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_core3.Buffer.VERTEX | import_core3.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/layers/time-delta-layer.js
+var TimeDeltaLayer = class extends import_core4.CompositeLayer {
+  renderLayers() {
+    var _a, _b;
+    const { startTimeMs, endTimeMs, color: color3 = [0, 0, 0, 255], yMin, yMax } = this.props;
+    if (!this.props.header) {
+      const timeLines2 = [
+        {
+          sourcePosition: [startTimeMs, yMin],
+          targetPosition: [startTimeMs, yMax]
+        },
+        {
+          sourcePosition: [endTimeMs, yMin],
+          targetPosition: [endTimeMs, yMax]
+        }
+      ];
+      return [
+        // Interval end lines
+        new import_layers.LineLayer({
+          id: "time-delta-side-bars",
+          data: timeLines2,
+          getSourcePosition: (d) => d.sourcePosition,
+          getTargetPosition: (d) => d.targetPosition,
+          getColor: color3,
+          getWidth: 4,
+          widthUnits: "pixels"
+        })
+      ];
+    }
+    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 labelData = [{ position: timeDeltaPosition, text: timeDeltaLabel }];
+    const timeLines = [
+      {
+        sourcePosition: [startTimeMs, y],
+        targetPosition: [startTimeMs, y - 7]
+      },
+      {
+        sourcePosition: [endTimeMs, y],
+        targetPosition: [endTimeMs, y - 7]
+      }
+    ];
+    return [
+      // Interval end lines
+      new import_layers.LineLayer({
+        id: "header-time-delta-side-bars",
+        data: timeLines,
+        getSourcePosition: (d) => d.sourcePosition,
+        getTargetPosition: (d) => d.targetPosition,
+        getColor: color3,
+        getWidth: 4,
+        widthUnits: "pixels"
+      }),
+      // Interval center
+      new import_layers.LineLayer({
+        id: "header-time-delta-dotted-line",
+        data: [
+          {
+            sourcePosition: [startTimeMs, y - 7],
+            targetPosition: [endTimeMs, y - 7]
+          }
+        ],
+        getSourcePosition: (d) => d.sourcePosition,
+        getTargetPosition: (d) => d.targetPosition,
+        getColor: color3,
+        getWidth: 1,
+        widthUnits: "pixels"
+      }),
+      // Label
+      ((_b = (_a = this.context) == null ? void 0 : _a.device) == null ? void 0 : _b.type) === "webgpu" ? new FastTextLayer({
+        id: "header-time-delta-label",
+        data: labelData,
+        getPosition: (d) => d.position,
+        getText: (d) => d.text,
+        characterSet: "-0123456789.dhms\xB5",
+        size: fontSize,
+        fontFamily,
+        fontSettings,
+        fontWeight,
+        getColor: color3,
+        textAnchor: "middle",
+        alignmentBaseline: "center"
+      }) : new import_layers.TextLayer({
+        id: "header-time-delta-label",
+        data: labelData,
+        getPosition: (d) => d.position,
+        getText: (d) => d.text,
+        characterSet: "-0123456789.dhms\xB5",
+        getSize: fontSize,
+        fontFamily,
+        fontSettings,
+        fontWeight,
+        getColor: color3,
+        getTextAnchor: "middle",
+        getAlignmentBaseline: "center",
+        background: true,
+        getBackgroundColor: [255 - color3[0], 255 - color3[1], 255 - color3[2], 255],
+        backgroundPadding: [4, 2]
+      })
+    ];
+  }
+};
+__publicField(TimeDeltaLayer, "layerName", "TimeDeltaLayer");
+__publicField(TimeDeltaLayer, "defaultProps", {
+  header: false,
+  minTimeMs: 0,
+  maxTimeMs: 100,
+  startTimeMs: 0,
+  endTimeMs: 100,
+  y: 0,
+  color: [0, 0, 0, 255],
+  unit: "timestamp",
+  yMin: -1e6,
+  // Should cover full viewport height in most cases
+  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/layers/animation-layer/animation-layer.js
+var import_core5 = 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
+    };
+  }
+  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;
   }
-];
-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;
+  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
+    });
   }
-  if (mode == FAST_TEXT_ALIGN_MODE_START) {
-    return max(-(anchor + clipStart), 0.0);
+  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
+    };
   }
-  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;
+  const state = prevState;
+  if (time < state.end) {
+    return state;
   }
-  if (mode == FAST_TEXT_ALIGN_MODE_END) {
-    return min(extent - (anchor + clipEnd), 0.0);
+  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
+    };
   }
-  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;
+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 (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 (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;
   }
-
-  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);
+  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;
+        }
       }
     }
   }
-  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);
+  return nextProps;
+}
+
+// dist/layers/animation-layer/animation-layer.js
+var AnimationLayer = class extends import_core5.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;
   }
-}
-
-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);
+  renderLayers() {
+    return this.state.layer;
   }
+};
+__publicField(AnimationLayer, "layerName", "AnimationLayer");
 
-  anchorPosScreen = vec2(anchorPosScreen.x + 1.0, 1.0 - anchorPosScreen.y) / 2.0 *
-    project.viewportSize / project.devicePixelRatio;
-  fastTextClipGlyphVertex(pixelOffset, anchorPosScreen);
+// dist/layers/block-layer/block-layer.js
+var import_core6 = require("@deck.gl/core");
+var import_engine2 = require("@luma.gl/engine");
 
-  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
+// 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;
 
-uniform sampler2D fontAtlasTexture;
-
-in vec4 vColor;
-in vec2 vTextureCoords;
-in vec2 uv;
+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) {
-  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;
+  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;
   }
 
-  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;
+
+// dist/layers/block-layer/block-layer-uniforms.js
+var glslUniformBlock = `uniform blockLayerUniforms {
+  highp int sizeUnits;
+  highp float widthMinPixels;
+  highp float heightMinPixels;
+  highp float sizeMaxPixels;
+  highp int lineWidthUnits;
+} blockLayer;
+`;
+var blockUniforms = {
+  name: "blockLayer",
+  source: "",
+  vs: glslUniformBlock,
+  fs: glslUniformBlock,
+  uniformTypes: {
+    sizeUnits: "i32",
+    widthMinPixels: "f32",
+    heightMinPixels: "f32",
+    sizeMaxPixels: "f32",
+    lineWidthUnits: "i32"
   }
-  const { iterable } = (0, import_core5.createIterable)(data);
-  let rowCount = 0;
-  for (const _object of iterable) {
-    rowCount++;
+};
+
+// 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 rowCount;
+  return project_size(size) * project.scale;
 }
-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;
+
+float clamp_signed_size(float size, float minPixels, float maxPixels) {
+  float clampedMagnitude = clamp(abs(size), minPixels, maxPixels);
+  if (size < 0.0) {
+    return -clampedMagnitude;
   }
-  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));
+  return clampedMagnitude;
 }
-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 };
+
+void main(void) {
+  geometry.worldPosition = instancePositions;
+  geometry.pickingColor = instancePickingColors;
+  geometry.uv = positions.xy;
+
+  vec2 pixelSize = project_size_to_pixel(instanceSizes, blockLayer.sizeUnits);
+  pixelSize.x = clamp_signed_size(pixelSize.x, blockLayer.widthMinPixels, blockLayer.sizeMaxPixels);
+  pixelSize.y = clamp_signed_size(pixelSize.y, blockLayer.heightMinPixels, blockLayer.sizeMaxPixels);
+  unitPosition = positions.xy;
+  size = pixelSize;
+  lineWidth = project_size_to_pixel(vec2(instanceLineWidths, 0.0), blockLayer.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);
 }
-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;
+`;
+
+// dist/layers/block-layer/block-layer.wgsl.js
+var block_layer_wgsl_default = (
+  /* wgsl */
+  `
+struct BlockUniforms {
+  sizeUnits: i32,
+  widthMinPixels: f32,
+  heightMinPixels: f32,
+  sizeMaxPixels: f32,
+  lineWidthUnits: i32,
+};
+
+@group(0) @binding(auto) var<uniform> blockLayer: BlockUniforms;
+
+struct BlockAttributes {
+  @location(0) positions: vec3<f32>,
+  @location(1) instancePositions: vec3<f32>,
+  @location(2) instanceSizes: vec2<f32>,
+  @location(3) instanceLineWidths: f32,
+  @location(4) instanceLineColors: vec4<f32>,
+  @location(5) instanceFillColors: vec4<f32>,
+  @location(6) instancePickingColors: vec3<f32>,
+};
+
+struct BlockVaryings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) unitPosition: vec2<f32>,
+  @location(1) @interpolate(flat) fillColor: vec4<f32>,
+  @location(2) @interpolate(flat) lineColor: vec4<f32>,
+  @location(3) @interpolate(flat) lineWidth: f32,
+  @location(4) @interpolate(flat) size: vec2<f32>,
+  @location(5) @interpolate(flat) pickingColor: vec3<f32>,
+};
+
+fn block_size_to_pixels(size: vec2<f32>, unit: i32) -> vec2<f32> {
+  return vec2<f32>(
+    project_unit_size_to_pixel(size.x, unit),
+    project_unit_size_to_pixel(size.y, unit)
+  );
 }
-function normalizeFastTextUtf8ColumnForComparison(textUtf8Column) {
-  return isFastTextUtf8ColumnSource2(textUtf8Column) ? textUtf8Column : buildFastTextUtf8ColumnSource(textUtf8Column);
+
+fn block_clamp_signed_size(size: f32, minimum: f32, maximum: f32) -> f32 {
+  return select(1.0, -1.0, size < 0.0) * clamp(abs(size), minimum, maximum);
 }
-function isFastTextUtf8ColumnSource2(textUtf8Column) {
-  return "rowCount" in textUtf8Column && "chunks" in textUtf8Column;
+
+@vertex
+fn vertexMain(attributes: BlockAttributes) -> BlockVaryings {
+  geometry.worldPosition = attributes.instancePositions;
+  geometry.pickingColor = attributes.instancePickingColors;
+  geometry.uv = attributes.positions.xy;
+
+  var pixelSize = block_size_to_pixels(attributes.instanceSizes, blockLayer.sizeUnits);
+  pixelSize.x = block_clamp_signed_size(
+    pixelSize.x,
+    blockLayer.widthMinPixels,
+    blockLayer.sizeMaxPixels
+  );
+  pixelSize.y = block_clamp_signed_size(
+    pixelSize.y,
+    blockLayer.heightMinPixels,
+    blockLayer.sizeMaxPixels
+  );
+
+  let offset = vec3<f32>(
+    attributes.positions.xy * project_pixel_size_vec2(pixelSize),
+    0.0
+  );
+  let projected = project_position_to_clipspace_and_commonspace(
+    attributes.instancePositions,
+    vec3<f32>(0.0),
+    offset
+  );
+  geometry.position = projected.commonPosition;
+
+  var varyings: BlockVaryings;
+  varyings.position = projected.clipPosition;
+  varyings.unitPosition = attributes.positions.xy;
+  varyings.fillColor = vec4<f32>(
+    attributes.instanceFillColors.rgb,
+    attributes.instanceFillColors.a * layer.opacity
+  );
+  varyings.lineColor = vec4<f32>(
+    attributes.instanceLineColors.rgb,
+    attributes.instanceLineColors.a * layer.opacity
+  );
+  varyings.lineWidth = project_unit_size_to_pixel(
+    attributes.instanceLineWidths,
+    blockLayer.lineWidthUnits
+  );
+  varyings.size = pixelSize;
+  varyings.pickingColor = attributes.instancePickingColors;
+  return varyings;
 }
-function didFastTextAccessorPropChange(accessor, oldAccessor) {
-  if (typeof oldAccessor === "function") {
-    return false;
+
+@fragment
+fn fragmentMain(varyings: BlockVaryings) -> @location(0) vec4<f32> {
+  let relativePosition = varyings.unitPosition * varyings.size;
+  let distanceToBorder = min(
+    min(relativePosition.x, relativePosition.y),
+    min(varyings.size.x - relativePosition.x, varyings.size.y - relativePosition.y)
+  );
+  var fragColor = select(
+    varyings.fillColor,
+    varyings.lineColor,
+    varyings.lineWidth > 0.0 && distanceToBorder <= varyings.lineWidth
+  );
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(varyings.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(picking_normalizeColor(varyings.pickingColor), 1.0);
   }
-  if (typeof accessor === "function") {
-    return true;
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedColor = picking_normalizeColor(picking.highlightedObjectColor);
+    let objectColor = picking_normalizeColor(varyings.pickingColor);
+    if (picking_isColorZero(abs(objectColor - highlightedColor))) {
+      let highlightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highlightAlpha + fragColor.a * (1.0 - highlightAlpha);
+      if (blendedAlpha > 0.0) {
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highlightAlpha / blendedAlpha),
+          blendedAlpha
+        );
+      }
+    }
   }
-  return !areFastTextAccessorConstantsEqual(accessor, oldAccessor);
+
+  return deckgl_premultiplied_alpha(fragColor);
 }
-function areFastTextAccessorConstantsEqual(accessor, oldAccessor) {
-  if (accessor === oldAccessor) {
-    return true;
+`
+);
+
+// dist/layers/block-layer/block-layer.js
+var DEFAULT_COLOR2 = [0, 0, 0, 255];
+var defaultProps2 = {
+  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_COLOR2 },
+  getLineColor: { type: "accessor", value: DEFAULT_COLOR2 }
+};
+var BlockLayer = class extends import_core6.Layer {
+  state = {};
+  getShaders() {
+    return super.getShaders({
+      source: block_layer_wgsl_default,
+      vs: block_layer_vertex_glsl_default,
+      fs: block_layer_fragment_glsl_default,
+      modules: [import_core6.project32, import_core6.color, import_core6.picking, blockUniforms]
+    });
   }
-  if (!Array.isArray(accessor) || !Array.isArray(oldAccessor)) {
-    return false;
+  /** WebGPU consumes float32 positions directly, including external binary attributes. */
+  use64bitPositions() {
+    var _a, _b;
+    return ((_b = (_a = this.context) == null ? void 0 : _a.device) == null ? void 0 : _b.type) !== "webgpu" && super.use64bitPositions();
   }
-  if (accessor.length !== oldAccessor.length) {
-    return false;
+  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_COLOR2
+      },
+      instanceFillColors: {
+        size: this.props.colorFormat.length,
+        type: "unorm8",
+        transition: true,
+        accessor: "getFillColor",
+        defaultValue: DEFAULT_COLOR2
+      }
+    });
   }
-  for (let index = 0; index < accessor.length; index += 1) {
-    if (accessor[index] !== oldAccessor[index]) {
-      return false;
+  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();
     }
   }
-  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();
+  draw() {
+    const { sizeUnits, widthMinPixels, heightMinPixels, sizeMaxPixels, lineWidthUnits } = this.props;
+    const model = this.state.model;
+    const blockProps = {
+      sizeUnits: import_core6.UNIT[sizeUnits],
+      widthMinPixels,
+      heightMinPixels,
+      sizeMaxPixels,
+      lineWidthUnits: import_core6.UNIT[lineWidthUnits]
+    };
+    model.shaderInputs.setProps({ blockLayer: blockProps });
+    model.draw(this.context.renderPass);
   }
-}
-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);
+  _getModel() {
+    const positions = [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0];
+    const bufferLayout = this.getAttributeManager().getBufferLayouts();
+    const webgpuAttributes = /* @__PURE__ */ new Set([
+      "instancePositions",
+      "instanceSizes",
+      "instanceLineWidths",
+      "instanceLineColors",
+      "instanceFillColors",
+      "instancePickingColors"
+    ]);
+    const webgpuBufferLayout = bufferLayout.map((layout) => {
+      var _a;
+      return {
+        ...layout,
+        attributes: (_a = layout.attributes) == null ? void 0 : _a.filter(({ attribute }) => webgpuAttributes.has(attribute))
+      };
+    }).filter((layout) => !layout.attributes || layout.attributes.length > 0);
+    return new import_engine2.Model(this.context.device, {
+      ...this.getShaders(),
+      id: this.props.id,
+      bufferLayout: this.context.device.type === "webgpu" ? webgpuBufferLayout : bufferLayout,
+      geometry: new import_engine2.Geometry({
+        topology: "triangle-strip",
+        attributes: {
+          positions: new Float32Array(positions)
+        }
+      }),
+      isInstanced: true
+    });
   }
-}
-function getFastTextContentAlignUniform(mode) {
-  return FAST_TEXT_CONTENT_ALIGN[mode];
-}
+};
+__publicField(BlockLayer, "layerName", "BlockLayer");
+__publicField(BlockLayer, "defaultProps", defaultProps2);
 
 // dist/views/orthographic-utils.js
 function fitBoundsOrthographic(width, height, bounds, zoomMode = "per-axis") {