@sakuzu/maplibre-gl-draw 2.1.3 → 2.1.4

package/CHANGELOG.md

@@ -6,6 +6,33 @@ the project follows semantic versioning.
 
 ## [Unreleased]
 
+## [2.1.4] - 2026-10-07
+
+Two fixes to how sizes follow the zoom: the paths of a dataset that drew
+at a fixed size, and sizes below one pixel that never disappeared.
+
+### Fixed in 2.1.4
+
+- A dataset applies the draw factors of its `zoomScale` (size and
+  opacity) on every path it draws through. The selection highlight and
+  the selected feature drawn on top of it, dashed and dotted lines and
+  polygon outlines, and shapes that go through immediate mode used to be
+  drawn at their stored size, so a selected point or a dashed line did
+  not change with the zoom. The dash pattern is now made from the scaled
+  width. `BatchManager.beginFrame` and `DisplayBatchTarget.beginFrame`
+  take an optional `factors` that is combined with the layer factors
+  ([#28](https://github.com/sakuzu/maplibre-gl-draw/issues/28)).
+- Sizes below one pixel are drawn so that the ink on screen follows the
+  real size and fades out smoothly. A point whose diameter is below
+  1 px is drawn at 1 px with its alpha multiplied by the ratio of the
+  areas, and a line or a polygon outline thinner than 1 px is drawn at
+  1 px with its alpha multiplied by the width, on the flat map and on
+  the terrain drape alike. Before, a shrinking point kept a faint blob
+  of about the antialiasing width until its size was exactly 0. This
+  applies to datasets and hand-drawn features. Nothing changes at 1 px
+  and above, and no minimum or maximum size is added
+  ([#28](https://github.com/sakuzu/maplibre-gl-draw/issues/28)).
+
 ## [2.1.3] - 2026-10-04
 
 Two fixes: the snap indicator that stayed after its input, and the

package/dist/dataset/chunk-set.js

@@ -313,11 +313,10 @@ export class DisplayChunkSet {
             }
             drawChunkBatches(state.batches, renderers, zoom, projectionData, factors);
             // The features that cannot be retained are drawn immediately, right after the retained
-            // batches of the chunk, the points last (the immediate-mode path is not multiplied by the
-            // factors)
+            // batches of the chunk, the points last (with the same factors as the retained batches)
             const { fallback, pointFallback } = state.batches;
             if (fallback.length > 0 || pointFallback.length > 0) {
-                target.beginFrame(projectionData, zoom);
+                target.beginFrame(projectionData, zoom, undefined, factors);
                 for (const feature of fallback)
                     target.processFeature(feature, false);
                 for (const feature of pointFallback)

package/dist/dataset/dataset.js

@@ -608,12 +608,13 @@ export class DatasetImpl {
             this.chunks.draw({ target, renderers, terrain, projectionData, zoom, bounds, factors });
         }
         else {
-            this.drawImmediate(target, projectionData, zoom, bounds);
+            this.drawImmediate(target, projectionData, zoom, bounds, factors);
         }
         drawSelectionHighlight({
             target,
             projectionData,
             zoom,
+            factors,
             bounds,
             selected: this.selected,
             styles: this.chunks.retainedRenderers?.styles,
@@ -710,9 +711,10 @@ export class DatasetImpl {
      * Draws in immediate mode (the path for an environment without the retained-mode renderers)
      *
      * The frame of the batch is started without passing a layer. The rules have already been
-     * evaluated here, so the rule evaluation of the rendering side (FeatureDrawer) is not used.
+     * evaluated here, so the rule evaluation of the rendering side (FeatureDrawer) is not used. The
+     * factors of the frame are passed, the same as to the retained batches.
      */
-    drawImmediate(target, projectionData, zoom, bounds) {
+    drawImmediate(target, projectionData, zoom, bounds, factors) {
         const rows = this.source.index.search(bounds).filter((row) => this.thinning.isDrawnRow(row));
         let visible = this.styler.prepareAll(this.featuresOf(rows));
         // A point drawn by an external renderer is not drawn by core (without a predicate it passes
@@ -722,7 +724,7 @@ export class DatasetImpl {
         }
         if (visible.length === 0)
             return;
-        target.beginFrame(projectionData, zoom);
+        target.beginFrame(projectionData, zoom, undefined, factors);
         for (const feature of visible) {
             target.processFeature(feature, false);
         }

package/dist/dataset/retained.js

@@ -812,7 +812,7 @@ function collectPoint(feature, coord, draft, styles, isExternallyRenderedPoint)
     const style = styles.getPointStyle(feature);
     const shape = toInstancedPointShape(style.shape);
     if (!shape) {
-        // The path that goes to immediate mode is not multiplied by the factors of zoomScale
+        // The immediate-mode path gets the same factors of zoomScale (DisplayBatchTarget.beginFrame)
         pushFallback(draft, feature);
         return;
     }
@@ -836,7 +836,7 @@ function collectLine(feature, coords, draft, styles, skipDraped = false) {
     if (skipDraped && strokeStyle.opacity > 0 && strokeStyle.width > 0)
         return;
     if (strokeStyle.lineStyle !== 'solid') {
-        // The path that goes to immediate mode is not multiplied by the factors of zoomScale
+        // The immediate-mode path gets the same factors of zoomScale (DisplayBatchTarget.beginFrame)
         pushFallback(draft, feature);
         return;
     }
@@ -870,7 +870,7 @@ function collectPolygon(feature, rings, draft, styles, partIndex = 0, skipDraped
     if (skipDraped)
         return;
     if (hasStroke && strokeStyle.lineStyle !== 'solid') {
-        // The path that goes to immediate mode is not multiplied by the factors of zoomScale
+        // The immediate-mode path gets the same factors of zoomScale (DisplayBatchTarget.beginFrame)
         pushFallback(draft, feature);
         return;
     }

package/dist/dataset/selection.js

@@ -39,7 +39,7 @@ export function drawSelectionHighlight(input) {
     const visible = input.selected.filter((feature) => feature.visible && boundsIntersect(getBoundingBox(feature), bounds));
     if (visible.length === 0)
         return;
-    target.beginFrame(projectionData, zoom);
+    target.beginFrame(projectionData, zoom, undefined, input.factors);
     for (const feature of visible) {
         const prepared = input.prepare(feature);
         // The hand-over decision (drapedFills) switches a few frames late, so looking only at it

package/dist/view/renderers/batch-manager.js

@@ -6,7 +6,7 @@ import { getCircleRadius, getCreatedZoom } from '../../shared/utils/property.js'
 import { densifyPathForGlobe } from '../globe-subdivision.js';
 import { TerrainContext } from '../terrain/context.js';
 import { anchorGhostOpacity } from '../terrain/occlusion.js';
-import { layerDrawFactors, NEUTRAL_DRAW_FACTORS, } from './draw-factors.js';
+import { combineDrawFactors, layerDrawFactors, NEUTRAL_DRAW_FACTORS, } from './draw-factors.js';
 import { getStrokeDashPattern, splitIntoDashes } from './line/dash.js';
 import { toInstancedPointShape, } from './point/point-instance.js';
 /**
@@ -310,12 +310,15 @@ export class BatchManager {
      *
      * @param layer The layer to draw (used to evaluate the style rules, and its opacity is
      *   multiplied into everything the frame draws; no factor when omitted)
+     * @param factors The draw factors of the frame itself (a dataset passes those of its
+     *   `zoomScale`). They are combined with the factors of the layer and multiplied into
+     *   everything the frame draws, the same as on the retained path; no factor when omitted
      */
-    beginFrame(projectionData, zoom, layer) {
+    beginFrame(projectionData, zoom, layer, factors = NEUTRAL_DRAW_FACTORS) {
         this.projectionData = projectionData;
         this.zoom = zoom;
         this.layer = layer;
-        this.factors = layerDrawFactors(layer);
+        this.factors = combineDrawFactors(layerDrawFactors(layer), factors);
         this.currentBatchType = null;
     }
     /**
@@ -408,7 +411,7 @@ export class BatchManager {
             }
             // Shapes that do not support instancing are drawn individually, one point at a time
             // (MultiPoint comes into this function part by part, so they are drawn per point)
-            this.featureDrawer.drawPointShape(coord, this.withLayerOpacity(style), this.zoom, feature.id);
+            this.featureDrawer.drawPointShape(coord, this.withFrameFactors(style), this.zoom, feature.id);
         }
         else {
             // Color, size and stroke are instance attributes, so the batch key only needs the shape
@@ -474,8 +477,9 @@ export class BatchManager {
         // the look does not change).
         const fixedWidth = getCreatedZoom(feature) === undefined;
         const createdZoom = getCreatedZoom(feature) ?? this.zoom;
-        // Compute the effective line width at the current zoom level
-        const effectiveStrokeWidth = strokeStyle.width * 2 ** (this.zoom - createdZoom);
+        // Compute the effective line width at the current zoom level (with the size factor of the
+        // frame, which the shader multiplies into the width, so the dashes follow the drawn width)
+        const effectiveStrokeWidth = strokeStyle.width * 2 ** (this.zoom - createdZoom) * this.factors.scale;
         // For dashed/dotted lines the dashes are computed on the CPU side
         const dashPattern = getStrokeDashPattern(strokeStyle.lineStyle, effectiveStrokeWidth);
         if (dashPattern) {
@@ -588,7 +592,8 @@ export class BatchManager {
         // convention as withFixedWidth; collectPolygons in retained mode does the same).
         const fixedWidth = getCreatedZoom(feature) === undefined;
         const createdZoom = getCreatedZoom(feature) ?? this.zoom;
-        const effectiveStrokeWidth = strokeStyle.width * 2 ** (this.zoom - createdZoom);
+        // The drawn width of the outline (with the size factor of the frame; the dashes follow it)
+        const effectiveStrokeWidth = strokeStyle.width * 2 ** (this.zoom - createdZoom) * this.factors.scale;
         const isDashed = strokeStyle.lineStyle !== 'solid';
         if (strokeStyle.opacity > 0 && !isDashed) {
             // For a solid line: drawn all at once by SDFPolygonRenderer
@@ -618,7 +623,7 @@ export class BatchManager {
             if (fillColor[3] > 0) {
                 this.polygonFillBatch.push({
                     coordinates: rings,
-                    color: this.colorWithLayerOpacity(fillColor),
+                    color: this.colorWithFrameOpacity(fillColor),
                     featureId: feature.id,
                     partIndex,
                 });
@@ -634,7 +639,7 @@ export class BatchManager {
         if (fillColor[3] > 0) {
             this.polygonFillBatch.push({
                 coordinates: rings,
-                color: this.colorWithLayerOpacity(fillColor),
+                color: this.colorWithFrameOpacity(fillColor),
                 featureId,
                 partIndex,
             });
@@ -678,23 +683,26 @@ export class BatchManager {
         }
     }
     /**
-     * A color with the opacity of the layer multiplied into its alpha (for the fill-only polygon
-     * batch, whose colors are per vertex and which has no factor uniform)
+     * A color with the opacity factor of the frame multiplied into its alpha (for the fill-only
+     * polygon batch, whose colors are per vertex and which has no factor uniform)
      */
-    colorWithLayerOpacity(color) {
+    colorWithFrameOpacity(color) {
         const opacity = this.factors.opacity;
         return opacity === 1 ? color : [color[0], color[1], color[2], color[3] * opacity];
     }
     /**
-     * A point style with the opacity of the layer multiplied in (for the per-point renderer, which
-     * has no factor uniform)
+     * A point style with the factors of the frame multiplied in (for the per-point renderer, which
+     * has no factor uniform): the size and the stroke width by the size factor, the opacities by
+     * the opacity factor
      */
-    withLayerOpacity(style) {
-        const opacity = this.factors.opacity;
-        if (opacity === 1)
+    withFrameFactors(style) {
+        const { scale, opacity } = this.factors;
+        if (scale === 1 && opacity === 1)
             return style;
         return {
             ...style,
+            size: style.size * scale,
+            strokeWidth: style.strokeWidth * scale,
             fillOpacity: style.fillOpacity * opacity,
             strokeOpacity: style.strokeOpacity * opacity,
         };

package/dist/view/renderers/draw-factors.d.ts

@@ -10,8 +10,11 @@
  * Conventions:
  *
  * - The default is `NEUTRAL_DRAW_FACTORS` (1x scale, opacity 1), so calls that
- *   pass no factors (Store rendering, immediate mode) look exactly as before,
+ *   pass no factors (the Store rendering, for example) look exactly as before,
  *   down to the pixel
+ * - The immediate-mode frame of a dataset takes its factors through
+ *   `BatchManager.beginFrame`, which combines them with the factors of the layer
+ *   (`combineDrawFactors`)
  * - A uniform is per-program residual state, so even rendering paths that do
  *   not use the factors must write 1 (a value left over from a previous draw
  *   makes another draw come out thinner; this is the same family of accident as
@@ -58,3 +61,10 @@ export declare function sanitizeDrawFactors(factors: {
 export declare function layerDrawFactors(layer: {
     readonly opacity?: number;
 } | null | undefined): RetainedDrawFactors;
+/**
+ * The product of two sets of factors (the frame's own factors over those of the layer)
+ *
+ * Both are taken as already rounded (`sanitizeDrawFactors`, `layerDrawFactors`). Neutral
+ * factors on either side give the other set itself.
+ */
+export declare function combineDrawFactors(a: RetainedDrawFactors, b: RetainedDrawFactors): RetainedDrawFactors;

package/dist/view/renderers/draw-factors.js

@@ -33,3 +33,16 @@ export function layerDrawFactors(layer) {
         return NEUTRAL_DRAW_FACTORS;
     return sanitizeDrawFactors({ scale: 1, opacity });
 }
+/**
+ * The product of two sets of factors (the frame's own factors over those of the layer)
+ *
+ * Both are taken as already rounded (`sanitizeDrawFactors`, `layerDrawFactors`). Neutral
+ * factors on either side give the other set itself.
+ */
+export function combineDrawFactors(a, b) {
+    if (b === NEUTRAL_DRAW_FACTORS || (b.scale === 1 && b.opacity === 1))
+        return a;
+    if (a === NEUTRAL_DRAW_FACTORS || (a.scale === 1 && a.opacity === 1))
+        return b;
+    return { scale: a.scale * b.scale, opacity: a.opacity * b.opacity };
+}

package/dist/view/renderers/line/line-shader.js

@@ -254,6 +254,11 @@ void main() {
     float lineWidth = (strokeWidth > 0.0
         ? strokeWidth * pow(2.0, u_zoom - createdZoom)
         : (strokeWidth < 0.0 ? -strokeWidth : u_width)) * u_size_scale;
+    // Below one pixel the line is drawn one pixel wide and fainter by its width, so the ink per
+    // unit of length follows the width and goes to nothing with it (the caps of every dash
+    // included, which would otherwise keep a blob of a fixed size)
+    float ink = clamp(lineWidth, 0.0, 1.0);
+    lineWidth = max(lineWidth, 1.0);
     float halfWidth = lineWidth / 2.0;
 
     // HHAA: expand by w+1 so that partially covered pixels are included too
@@ -298,7 +303,7 @@ void main() {
     v_linesofar = segmentStart + t * screenSegmentLength;  // cumulative distance (for dashes)
     v_line_pos = linePos;                  // position along the line
     v_seg_length = screenSegmentLength;    // segment length (computed on the GPU)
-    v_color = a_color;                     // line color (instance attribute)
+    v_color = a_color * ink;               // line color (instance attribute), by the ink
 }`;
 }
 /**

package/dist/view/renderers/point/point-instance.d.ts

@@ -55,6 +55,15 @@ export interface PointInstanceData {
  * Cutting the billboard exactly at the outer radius loses the outer half of the antialiasing.
  */
 export declare const POINT_AA_PADDING_PX = 1;
+/**
+ * The smallest outer radius a point is drawn at (device pixels): a diameter of one pixel
+ *
+ * A smaller point cannot be drawn smaller, since the antialiasing band alone is a pixel wide: its
+ * coverage would tend to a blob of a fixed size as the radius goes to 0, and the point would never
+ * fade. Below this radius the shape is drawn at it, fainter by the ratio of the areas
+ * (`pointInkFactor`), so the ink it leaves follows its area and goes to nothing with it.
+ */
+export declare const POINT_MIN_OUTER_PX = 0.5;
 /**
  * SDF boundaries of one instance (device pixels)
  */
@@ -85,6 +94,16 @@ export interface PointSdfEdges {
  * @param sizeScale Size factor at draw time (default 1)
  */
 export declare function pointSdfEdges(fillSizePx: number, strokeWidthPx: number, sizeScale?: number): PointSdfEdges;
+/**
+ * The factor the alpha of a point is multiplied by (the same computation as the shader)
+ *
+ * 1 at an outer radius of `POINT_MIN_OUTER_PX` and above. Below it the point is drawn at that
+ * radius (`pointSdfEdges`), and the factor is the ratio of its true area to the area drawn, so the
+ * ink it leaves follows its area and goes to 0 with it. A radius of 0 or below draws nothing (0).
+ *
+ * @param outerPx The outer radius (radius + stroke width, with the size factor; device pixels)
+ */
+export declare function pointInkFactor(outerPx: number): number;
 /**
  * Point batch of the retained mode (GPU resources)
  *

package/dist/view/renderers/point/point-instance.js

@@ -34,6 +34,15 @@ const AA_HALF_WIDTH_PX = 0.5;
  * Cutting the billboard exactly at the outer radius loses the outer half of the antialiasing.
  */
 export const POINT_AA_PADDING_PX = 1;
+/**
+ * The smallest outer radius a point is drawn at (device pixels): a diameter of one pixel
+ *
+ * A smaller point cannot be drawn smaller, since the antialiasing band alone is a pixel wide: its
+ * coverage would tend to a blob of a fixed size as the radius goes to 0, and the point would never
+ * fade. Below this radius the shape is drawn at it, fainter by the ratio of the areas
+ * (`pointInkFactor`), so the ink it leaves follows its area and goes to nothing with it.
+ */
+export const POINT_MIN_OUTER_PX = 0.5;
 // Stride of the instance data (floats per instance)
 // position(2) + fillColor(4) + strokeColor(4) + size(1) + strokeWidth(1)
 //   + elevation(1) = 13 floats
@@ -58,8 +67,34 @@ const SHAPE_UNIFORM = POINT_SHAPE_CODE;
 export function pointSdfEdges(fillSizePx, strokeWidthPx, sizeScale = 1) {
     const radius = Math.max(0, fillSizePx) * sizeScale;
     const outer = radius + Math.max(0, strokeWidthPx) * sizeScale;
+    // Below a diameter of one pixel the shape is drawn at that diameter (pointInkFactor)
+    if (outer > 0 && outer < POINT_MIN_OUTER_PX) {
+        const grow = POINT_MIN_OUTER_PX / outer;
+        return {
+            radius: radius * grow,
+            outer: POINT_MIN_OUTER_PX,
+            extent: POINT_MIN_OUTER_PX + POINT_AA_PADDING_PX,
+        };
+    }
     return { radius, outer, extent: outer + POINT_AA_PADDING_PX };
 }
+/**
+ * The factor the alpha of a point is multiplied by (the same computation as the shader)
+ *
+ * 1 at an outer radius of `POINT_MIN_OUTER_PX` and above. Below it the point is drawn at that
+ * radius (`pointSdfEdges`), and the factor is the ratio of its true area to the area drawn, so the
+ * ink it leaves follows its area and goes to 0 with it. A radius of 0 or below draws nothing (0).
+ *
+ * @param outerPx The outer radius (radius + stroke width, with the size factor; device pixels)
+ */
+export function pointInkFactor(outerPx) {
+    if (!(outerPx > 0))
+        return 0;
+    if (outerPx >= POINT_MIN_OUTER_PX)
+        return 1;
+    const ratio = outerPx / POINT_MIN_OUTER_PX;
+    return ratio * ratio;
+}
 /**
  * Rounds the origin of the relative coordinates to Float32
  */
@@ -326,6 +361,7 @@ flat out vec4 v_stroke_color;
 out vec2 v_offset_px;
 flat out float v_radius_px;
 flat out float v_outer_px;
+flat out float v_ink;
 
 void main() {
     // The anchor elevation comes from the CPU (the same source as hit testing).
@@ -338,6 +374,15 @@ void main() {
 
     float radius = max(a_instance_size, 0.0) * u_size_scale;
     float outer = radius + max(a_instance_stroke_width, 0.0) * u_size_scale;
+    // Below a diameter of one pixel the shape is drawn at that diameter, fainter by the ratio of
+    // the areas, so the ink it leaves follows its area (pointSdfEdges, pointInkFactor)
+    v_ink = 1.0;
+    if (outer > 0.0 && outer < ${POINT_MIN_OUTER_PX.toFixed(1)}) {
+        float grow = ${POINT_MIN_OUTER_PX.toFixed(1)} / outer;
+        v_ink = 1.0 / (grow * grow);
+        radius *= grow;
+        outer = ${POINT_MIN_OUTER_PX.toFixed(1)};
+    }
     // The billboard is sized as the outer radius plus the antialiasing padding
     // (so that the edge is not clipped)
     vec2 offsetPx = a_quad * (outer + ${POINT_AA_PADDING_PX.toFixed(1)});
@@ -357,6 +402,7 @@ flat in vec4 v_stroke_color;
 in vec2 v_offset_px;
 flat in float v_radius_px;
 flat in float v_outer_px;
+flat in float v_ink;          // the factor of a point below one pixel (1 otherwise)
 uniform float u_opacity;      // opacity factor at draw time (default 1)
 uniform float u_shape;        // shape (0 = circle, 1 = square, 2 = triangle, 3 = star)
 out vec4 fragColor;
@@ -384,7 +430,7 @@ void main() {
     vec4 color = mix(v_stroke_color, v_fill_color, fillMix);
 
     // Blending is non-premultiplied, so the factors are applied to the alpha only
-    fragColor = vec4(color.rgb, color.a * u_opacity * coverage);
+    fragColor = vec4(color.rgb, color.a * u_opacity * coverage * v_ink);
 }`;
         return createProgram(this.gl, vertexSource, fragmentSource);
     }

package/dist/view/renderers/polygon/sdf-polygon.js

@@ -376,6 +376,10 @@ void main() {
         float lineWidth = (strokeWidth >= 0.0
             ? strokeWidth * pow(2.0, u_zoom - createdZoom)
             : -strokeWidth) * u_size_scale;
+        // Below one pixel the outline is drawn one pixel wide and fainter by its width, so the
+        // ink per unit of length follows the width and goes to nothing with it
+        float ink = clamp(lineWidth, 0.0, 1.0);
+        lineWidth = max(lineWidth, 1.0);
         float halfWidth = lineWidth / 2.0;
 
         // Expand by 1 pixel for HHAA
@@ -389,7 +393,7 @@ void main() {
         vec2 finalNdc = (finalScreenPos / u_viewport) * 2.0 - 1.0;
         gl_Position = vec4(finalNdc * clipPos.w, clipPos.z, clipPos.w);
 
-        v_color = a_color;
+        v_color = vec4(a_color.rgb, a_color.a * ink);
         v_type = 1.0;
         v_dist = a_side * expandedHalfWidth;
         v_halfWidth = halfWidth;

package/dist/view/terrain/drape/renderer.js

@@ -207,6 +207,15 @@ float dashDistance(vec2 sa, vec2 sb, float start, float len, float dash, float p
     return best;
 }
 
+// The coverage of an outline of a half width at a screen distance from it. Below one
+// pixel of width the outline is drawn one pixel wide and fainter by its width, so the ink
+// per unit of length follows the width and goes to nothing with it (the rule of the
+// vertex path's line and outline shaders)
+float strokeCoverage(float halfWidth, float dist) {
+    float ink = clamp(2.0 * halfWidth, 0.0, 1.0);
+    return clamp(max(halfWidth, 0.5) + 0.5 - dist, 0.0, 1.0) * ink;
+}
+
 // Compose on top (premultiplied alpha)
 vec4 over(vec4 below, vec3 rgb, float a) {
     return vec4(rgb * a + below.rgb * (1.0 - a), a + below.a * (1.0 - a));
@@ -342,7 +351,7 @@ void main() {
         }
 
         if (paints && halfWidth > 0.0 && stroke.a > 0.0) {
-            float coverage = clamp(halfWidth + 0.5 - strokeDist, 0.0, 1.0);
+            float coverage = strokeCoverage(halfWidth, strokeDist);
             if (coverage > 0.0) acc = over(acc, stroke.rgb, stroke.a * coverage * factors.x);
         }
 
@@ -367,7 +376,7 @@ void main() {
             // for features that have no outline (the same as the immediate mode), and
             // it is solid under a dashed outline too
             float selHalf = halfWidth + u_selection_stroke_extra * 0.5;
-            selStroke = max(selStroke, clamp(selHalf + 0.5 - minDist, 0.0, 1.0) * factors.x);
+            selStroke = max(selStroke, strokeCoverage(selHalf, minDist) * factors.x);
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sakuzu/maplibre-gl-draw",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "description": "WebGL2 drawing and editing engine for MapLibre GL JS: points, lines, and polygons rendered in a custom layer, with selection, hit testing, and geometry utilities.",
   "keywords": [
     "maplibre",