kritzel-stencil 0.0.162 → 0.0.164

package/dist/esm/{default-line-tool.config-C35m-d1Y.js → default-line-tool.config-C35P3XfD.js}

@@ -121,6 +121,61 @@ class KritzelGeometryHelper {
         }
         return closestIntersection;
     }
+    /**
+     * Generates a polygon approximation of an ellipse.
+     * @param centerX - X coordinate of ellipse center
+     * @param centerY - Y coordinate of ellipse center
+     * @param rx - Horizontal radius
+     * @param ry - Vertical radius
+     * @param segments - Number of segments (more = smoother approximation)
+     * @param rotation - Optional rotation angle in radians
+     */
+    static getEllipsePolygonApproximation(centerX, centerY, rx, ry, segments = 32, rotation = 0) {
+        const points = [];
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        for (let i = 0; i < segments; i++) {
+            const angle = (2 * Math.PI * i) / segments;
+            // Point on unrotated ellipse
+            const px = rx * Math.cos(angle);
+            const py = ry * Math.sin(angle);
+            // Apply rotation around center
+            const rotatedX = centerX + px * cos - py * sin;
+            const rotatedY = centerY + px * sin + py * cos;
+            points.push({ x: rotatedX, y: rotatedY });
+        }
+        return points;
+    }
+    /**
+     * Finds the closest intersection point between a line segment and a polygon
+     * defined as an array of points. Returns the intersection closest to lineStart,
+     * or null if no intersection.
+     */
+    static getLinePointsArrayIntersection(lineStart, lineEnd, polygonPoints) {
+        let closestIntersection = null;
+        let closestDistance = Infinity;
+        for (let i = 0; i < polygonPoints.length; i++) {
+            const edgeStart = polygonPoints[i];
+            const edgeEnd = polygonPoints[(i + 1) % polygonPoints.length];
+            const intersection = this.getLineIntersectionPoint(lineStart, lineEnd, edgeStart, edgeEnd);
+            if (intersection) {
+                const distance = Math.sqrt(Math.pow(intersection.x - lineStart.x, 2) +
+                    Math.pow(intersection.y - lineStart.y, 2));
+                if (distance < closestDistance) {
+                    closestDistance = distance;
+                    closestIntersection = intersection;
+                }
+            }
+        }
+        return closestIntersection;
+    }
+    /**
+     * Checks if a point is inside a polygon defined as an array of points.
+     * This is a convenience wrapper that works with arbitrary polygon point arrays.
+     */
+    static isPointInPolygonPoints(point, polygonPoints) {
+        return this.isPointInPolygon(point, polygonPoints);
+    }
 }
 
 class KritzelBaseObject {
@@ -14439,6 +14494,91 @@ class KritzelPath extends KritzelBaseObject {
         const scaledHeight = this.boundingBox.height * viewportScale;
         return (scaledWidth * scaledHeight) < 500;
     }
+    /**
+     * Finds the point where a line from outsidePoint to the path's center
+     * intersects the stroke edge. Returns null if no intersection found.
+     * This is used for arrow clipping at the actual stroke edge.
+     */
+    getClipPoint(outsidePoint) {
+        const centerX = this.centerX;
+        const centerY = this.centerY;
+        const halfStroke = this.strokeWidth / this.scale / 2;
+        // Ensure adjusted points are computed
+        if (this._adjustedPoints === null) {
+            this._adjustedPoints = this.computeAdjustedPoints();
+        }
+        if (this._adjustedPoints.length < 1) {
+            return null;
+        }
+        // Sample along the line from outsidePoint to center to find stroke edge
+        const steps = 32;
+        let prevOutside = true;
+        for (let i = 1; i <= steps; i++) {
+            const t = i / steps;
+            const sampleX = outsidePoint.x + (centerX - outsidePoint.x) * t;
+            const sampleY = outsidePoint.y + (centerY - outsidePoint.y) * t;
+            // Check distance to path stroke
+            let minDistance = Infinity;
+            if (this._adjustedPoints.length === 1) {
+                const p = this._adjustedPoints[0];
+                const dx = sampleX - p[0];
+                const dy = sampleY - p[1];
+                minDistance = Math.sqrt(dx * dx + dy * dy);
+            }
+            else {
+                for (let j = 0; j < this._adjustedPoints.length - 1; j++) {
+                    const p1 = this._adjustedPoints[j];
+                    const p2 = this._adjustedPoints[j + 1];
+                    const dist = this.pointToLineSegmentDistance(sampleX, sampleY, p1[0], p1[1], p2[0], p2[1]);
+                    if (dist < minDistance) {
+                        minDistance = dist;
+                    }
+                }
+            }
+            const isInside = minDistance <= halfStroke;
+            // Found the edge: transition from outside to inside
+            if (prevOutside && isInside) {
+                // Refine the intersection point using binary search
+                let tLow = (i - 1) / steps;
+                let tHigh = t;
+                for (let k = 0; k < 8; k++) {
+                    const tMid = (tLow + tHigh) / 2;
+                    const midX = outsidePoint.x + (centerX - outsidePoint.x) * tMid;
+                    const midY = outsidePoint.y + (centerY - outsidePoint.y) * tMid;
+                    let midDist = Infinity;
+                    if (this._adjustedPoints.length === 1) {
+                        const p = this._adjustedPoints[0];
+                        const dx = midX - p[0];
+                        const dy = midY - p[1];
+                        midDist = Math.sqrt(dx * dx + dy * dy);
+                    }
+                    else {
+                        for (let j = 0; j < this._adjustedPoints.length - 1; j++) {
+                            const p1 = this._adjustedPoints[j];
+                            const p2 = this._adjustedPoints[j + 1];
+                            const dist = this.pointToLineSegmentDistance(midX, midY, p1[0], p1[1], p2[0], p2[1]);
+                            if (dist < midDist) {
+                                midDist = dist;
+                            }
+                        }
+                    }
+                    if (midDist <= halfStroke) {
+                        tHigh = tMid;
+                    }
+                    else {
+                        tLow = tMid;
+                    }
+                }
+                const finalT = (tLow + tHigh) / 2;
+                return {
+                    x: outsidePoint.x + (centerX - outsidePoint.x) * finalT,
+                    y: outsidePoint.y + (centerY - outsidePoint.y) * finalT,
+                };
+            }
+            prevOutside = !isInside;
+        }
+        return null;
+    }
 }
 
 class KritzelImage extends KritzelBaseObject {
@@ -15223,6 +15363,7 @@ class KritzelBrushTool extends KritzelBaseTool {
                     });
                     updatedPath.id = currentPath.id;
                     updatedPath.workspaceId = currentPath.workspaceId;
+                    updatedPath.zIndex = currentPath.zIndex;
                     updatedPath.isCompleted = false;
                     this._core.store.state.objects.update(updatedPath);
                 }
@@ -15245,6 +15386,7 @@ class KritzelBrushTool extends KritzelBaseTool {
                     });
                     updatedPath.id = currentPath.id;
                     updatedPath.workspaceId = currentPath.workspaceId;
+                    updatedPath.zIndex = currentPath.zIndex;
                     updatedPath.isCompleted = false;
                     this._core.store.state.objects.update(updatedPath);
                 }
@@ -15261,7 +15403,6 @@ class KritzelBrushTool extends KritzelBaseTool {
                 const currentPath = this._core.store.currentPath;
                 if (currentPath) {
                     currentPath.isCompleted = true;
-                    currentPath.zIndex = this._core.store.currentZIndex;
                     this._core.store.state.objects.update(currentPath);
                     this._core.engine.emitObjectsChange();
                 }
@@ -15273,7 +15414,6 @@ class KritzelBrushTool extends KritzelBaseTool {
                 const currentPath = this._core.store.currentPath;
                 if (currentPath) {
                     currentPath.isCompleted = true;
-                    currentPath.zIndex = this._core.store.currentZIndex;
                     this._core.store.state.objects.update(currentPath);
                     this._core.engine.emitObjectsChange();
                 }
@@ -15673,6 +15813,7 @@ class KritzelLineTool extends KritzelBaseTool {
                     });
                     updatedLine.id = currentLine.id;
                     updatedLine.workspaceId = currentLine.workspaceId;
+                    updatedLine.zIndex = currentLine.zIndex;
                     updatedLine.isCompleted = false;
                     this._core.store.state.objects.update(updatedLine);
                 }
@@ -15699,6 +15840,7 @@ class KritzelLineTool extends KritzelBaseTool {
                     });
                     updatedLine.id = currentLine.id;
                     updatedLine.workspaceId = currentLine.workspaceId;
+                    updatedLine.zIndex = currentLine.zIndex;
                     updatedLine.isCompleted = false;
                     this._core.store.state.objects.update(updatedLine);
                 }
@@ -15715,7 +15857,6 @@ class KritzelLineTool extends KritzelBaseTool {
                 const currentLine = this._core.store.currentLine;
                 if (currentLine) {
                     currentLine.isCompleted = true;
-                    currentLine.zIndex = this._core.store.currentZIndex;
                     this._core.store.state.objects.update(currentLine);
                     this._core.engine.emitObjectsChange();
                     // Switch to selection tool and select the drawn line
@@ -15729,7 +15870,6 @@ class KritzelLineTool extends KritzelBaseTool {
                 const currentLine = this._core.store.currentLine;
                 if (currentLine) {
                     currentLine.isCompleted = true;
-                    currentLine.zIndex = this._core.store.currentZIndex;
                     this._core.store.state.objects.update(currentLine);
                     this._core.engine.emitObjectsChange();
                     // Switch to selection tool and select the drawn line
@@ -16057,6 +16197,10 @@ KritzelIconRegistry.registerIcons({
     'highlighter': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-highlighter-icon lucide-highlighter"><path d="m9 11-6 6v3h9l3-3"/><path d="m22 12-4.6 4.6a2 2 0 0 1-2.8 0l-5.2-5.2a2 2 0 0 1 0-2.8L14 4"/></svg>',
     'eraser': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="m7 21-4.3-4.3c-1-1-1-2.5 0-3.4l9.6-9.6c1-1 2.5-1 3.4 0l5.6 5.6c1 1 1 2.5 0 3.4L13 21"/><path d="M22 21H7"/><path d="m5 11 9 9"/></svg>',
     'type': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><polyline points="4 7 4 4 20 4 20 7"/><line x1="9" x2="15" y1="20" y2="20"/><line x1="12" x2="12" y1="4" y2="20"/></svg>',
+    'shapes': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M8.3 10a.7.7 0 0 1-.626-1.079L11.4 3a.7.7 0 0 1 1.198-.043L16.3 8.9a.7.7 0 0 1-.572 1.1Z"/><rect x="3" y="14" width="7" height="7" rx="1"/><circle cx="17.5" cy="17.5" r="3.5"/></svg>',
+    'shape-rectangle': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="18" height="18" rx="2"/></svg>',
+    'shape-ellipse': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="12" rx="10" ry="8"/></svg>',
+    'shape-triangle': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 3L22 21H2L12 3Z"/></svg>',
     'image': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect width="18" height="18" x="3" y="3" rx="2" ry="2"/><circle cx="9" cy="9" r="2"/><path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"/></svg>',
     'chevron-down': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="m6 9 6 6 6-6"/></svg>',
     'chevron-up': '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="m18 15-6-6-6 6"/></svg>',
@@ -33134,7 +33278,34 @@ class KritzelAnchorManager {
         const reference = endpoint === 'start'
             ? this.lineLocalToWorld(line, line.endX, line.endY)
             : this.lineLocalToWorld(line, line.startX, line.startY);
-        const edgeIntersection = KritzelGeometryHelper.getLinePolygonIntersection(reference, { x: targetObject.centerX, y: targetObject.centerY }, targetObject.rotatedPolygon);
+        // Check for path object (uses stroke edge detection)
+        const pathClipPoint = this.getPathClipPoint(targetObject, reference);
+        if (pathClipPoint) {
+            const localEdge = this.lineWorldToLocal(line, pathClipPoint.x, pathClipPoint.y);
+            const totalLength = Math.sqrt(Math.pow(line.endX - line.startX, 2) +
+                Math.pow(line.endY - line.startY, 2));
+            const distanceFromStart = Math.sqrt(Math.pow(localEdge.x - line.startX, 2) +
+                Math.pow(localEdge.y - line.startY, 2));
+            const t = totalLength > 0 ? distanceFromStart / totalLength : endpoint === 'start' ? 0 : 1;
+            return {
+                localX: localEdge.x,
+                localY: localEdge.y,
+                worldX: pathClipPoint.x,
+                worldY: pathClipPoint.y,
+                t,
+            };
+        }
+        // Check for custom clip polygon (ellipse, triangle shapes)
+        const customClipPolygon = this.getClipPolygonForObject(targetObject);
+        let edgeIntersection;
+        if (customClipPolygon) {
+            // Use custom polygon for non-rectangular shapes
+            edgeIntersection = KritzelGeometryHelper.getLinePointsArrayIntersection(reference, { x: targetObject.centerX, y: targetObject.centerY }, customClipPolygon);
+        }
+        else {
+            // Fall back to bounding box for rectangles and other objects
+            edgeIntersection = KritzelGeometryHelper.getLinePolygonIntersection(reference, { x: targetObject.centerX, y: targetObject.centerY }, targetObject.rotatedPolygon);
+        }
         if (!edgeIntersection) {
             return null;
         }
@@ -33153,7 +33324,15 @@ class KritzelAnchorManager {
         };
     }
     computeCurvedClipInfo(line, endpoint, targetObject) {
-        const polygonPoints = this.getPolygonPoints(targetObject.rotatedPolygon);
+        // Check for path object (uses stroke edge detection via sampling)
+        if (KritzelClassHelper.isInstanceOf(targetObject, 'KritzelPath')) {
+            // For curved lines to paths, sample along the curve to find stroke edge
+            const path = targetObject;
+            return this.findCurveExitPointForPath(line, endpoint, path);
+        }
+        // Check for custom clip polygon (ellipse, triangle shapes)
+        const customClipPolygon = this.getClipPolygonForObject(targetObject);
+        const polygonPoints = customClipPolygon ?? this.getPolygonPoints(targetObject.rotatedPolygon);
         const exitPoint = this.findCurveExitPoint(line, endpoint, polygonPoints);
         if (exitPoint) {
             return exitPoint;
@@ -33161,7 +33340,13 @@ class KritzelAnchorManager {
         const reference = endpoint === 'start'
             ? this.lineLocalToWorld(line, line.endX, line.endY)
             : this.lineLocalToWorld(line, line.startX, line.startY);
-        const fallbackIntersection = KritzelGeometryHelper.getLinePolygonIntersection(reference, { x: targetObject.centerX, y: targetObject.centerY }, targetObject.rotatedPolygon);
+        let fallbackIntersection;
+        if (customClipPolygon) {
+            fallbackIntersection = KritzelGeometryHelper.getLinePointsArrayIntersection(reference, { x: targetObject.centerX, y: targetObject.centerY }, customClipPolygon);
+        }
+        else {
+            fallbackIntersection = KritzelGeometryHelper.getLinePolygonIntersection(reference, { x: targetObject.centerX, y: targetObject.centerY }, targetObject.rotatedPolygon);
+        }
         if (!fallbackIntersection) {
             return null;
         }
@@ -33201,6 +33386,119 @@ class KritzelAnchorManager {
         }
         return null;
     }
+    /**
+     * Finds the exit point for a curved line going to a Path object.
+     * Uses distance-to-stroke sampling instead of polygon containment.
+     */
+    findCurveExitPointForPath(line, endpoint, path) {
+        const steps = 64;
+        const initialT = endpoint === 'start' ? 0 : 1;
+        const halfStroke = path.strokeWidth / path.scale / 2;
+        // Ensure path has computed points
+        const pathPoints = this.getPathAdjustedPoints(path);
+        if (pathPoints.length < 1) {
+            return null;
+        }
+        // Check if starting point is inside the stroke
+        const initialSample = this.evaluateLineAtT(line, initialT);
+        let prevInside = this.isPointInPathStroke(initialSample.worldX, initialSample.worldY, pathPoints, halfStroke);
+        let prevT = initialT;
+        for (let i = 1; i <= steps; i++) {
+            const t = endpoint === 'start' ? i / steps : 1 - i / steps;
+            const sample = this.evaluateLineAtT(line, t);
+            const inside = this.isPointInPathStroke(sample.worldX, sample.worldY, pathPoints, halfStroke);
+            if (prevInside && !inside) {
+                // Refine using binary search
+                const refinedT = this.refineCurveExitParameterForPath(line, pathPoints, halfStroke, prevT, t);
+                const refinedPoint = this.evaluateLineAtT(line, refinedT);
+                return {
+                    localX: refinedPoint.localX,
+                    localY: refinedPoint.localY,
+                    worldX: refinedPoint.worldX,
+                    worldY: refinedPoint.worldY,
+                    t: refinedT,
+                };
+            }
+            prevInside = inside;
+            prevT = t;
+        }
+        return null;
+    }
+    refineCurveExitParameterForPath(line, pathPoints, halfStroke, insideT, outsideT) {
+        let tInside = insideT;
+        let tOutside = outsideT;
+        for (let i = 0; i < 8; i++) {
+            const mid = (tInside + tOutside) / 2;
+            const sample = this.evaluateLineAtT(line, mid);
+            const inside = this.isPointInPathStroke(sample.worldX, sample.worldY, pathPoints, halfStroke);
+            if (inside) {
+                tInside = mid;
+            }
+            else {
+                tOutside = mid;
+            }
+        }
+        return (tInside + tOutside) / 2;
+    }
+    getPathAdjustedPoints(path) {
+        // Access the path's adjusted points through its internal computation
+        // We'll need to manually compute them since they're private
+        return this.computePathAdjustedPoints(path);
+    }
+    computePathAdjustedPoints(path) {
+        if (!path.points?.length) {
+            return [];
+        }
+        const angle = path.rotation;
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        const xs = path.points.map(p => p[0]);
+        const ys = path.points.map(p => p[1]);
+        const pivot = {
+            x: (Math.min(...xs) + Math.max(...xs)) / 2,
+            y: (Math.min(...ys) + Math.max(...ys)) / 2,
+        };
+        const { x: cx, y: cy } = pivot;
+        const rotatedPoints = path.points.map(([x, y]) => {
+            const dx = x - cx;
+            const dy = y - cy;
+            return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
+        });
+        return rotatedPoints.map(([px, py]) => [
+            Math.abs(px - path.x) / path.scale + path.translateX,
+            Math.abs(py - path.y) / path.scale + path.translateY,
+        ]);
+    }
+    isPointInPathStroke(x, y, pathPoints, halfStroke) {
+        if (pathPoints.length === 1) {
+            const p = pathPoints[0];
+            const dx = x - p[0];
+            const dy = y - p[1];
+            return Math.sqrt(dx * dx + dy * dy) <= halfStroke;
+        }
+        for (let i = 0; i < pathPoints.length - 1; i++) {
+            const p1 = pathPoints[i];
+            const p2 = pathPoints[i + 1];
+            const dist = this.pointToSegmentDistance(x, y, p1[0], p1[1], p2[0], p2[1]);
+            if (dist <= halfStroke) {
+                return true;
+            }
+        }
+        return false;
+    }
+    pointToSegmentDistance(px, py, x1, y1, x2, y2) {
+        const dx = x2 - x1;
+        const dy = y2 - y1;
+        const lengthSquared = dx * dx + dy * dy;
+        if (lengthSquared === 0) {
+            return Math.sqrt((px - x1) * (px - x1) + (py - y1) * (py - y1));
+        }
+        let t = ((px - x1) * dx + (py - y1) * dy) / lengthSquared;
+        t = Math.max(0, Math.min(1, t));
+        const nearestX = x1 + t * dx;
+        const nearestY = y1 + t * dy;
+        return Math.sqrt((px - nearestX) * (px - nearestX) + (py - nearestY) * (py - nearestY));
+    }
     refineCurveExitParameter(line, polygonPoints, insideT, outsideT) {
         let tInside = insideT;
         let tOutside = outsideT;
@@ -33334,6 +33632,30 @@ class KritzelAnchorManager {
     getPolygonPoints(polygon) {
         return [polygon.topLeft, polygon.topRight, polygon.bottomRight, polygon.bottomLeft];
     }
+    /**
+     * Gets the custom clip polygon for an object if it has one.
+     * Returns null for objects that should use the default rotatedPolygon.
+     */
+    getClipPolygonForObject(object) {
+        // Check if the object is a KritzelShape with a custom clip polygon
+        if (KritzelClassHelper.isInstanceOf(object, 'KritzelShape')) {
+            const shape = object;
+            return shape.getClipPolygon();
+        }
+        // Path objects use getPathClipPoint instead of polygon
+        return null;
+    }
+    /**
+     * Gets the clip point for a Path object (stroke edge intersection).
+     * Returns null if the object is not a Path or no intersection found.
+     */
+    getPathClipPoint(object, outsidePoint) {
+        if (KritzelClassHelper.isInstanceOf(object, 'KritzelPath')) {
+            const path = object;
+            return path.getClipPoint(outsidePoint);
+        }
+        return null;
+    }
     /**
      * Converts local line coordinates to world coordinates.
      */
@@ -33511,7 +33833,7 @@ const DEFAULT_LINE_TOOL_CONFIG = {
     },
 };
 
-export { KritzelKeyboardHelper as $, isNode as A, min$2 as B, pow as C, HocuspocusProviderWebsocket as D, KritzelPath as E, KritzelImage as F, KritzelLine as G, HocuspocusProvider as H, KritzelBrushTool as I, KritzelLineTool as J, KritzelText as K, KritzelEraserTool as L, KritzelImageTool as M, KritzelTextTool as N, Observable$1 as O, KritzelCursorHelper as P, KritzelSelectionTool as Q, IndexedDBSyncProvider as R, KritzelAppStateMap as S, KritzelWorkspace as T, KritzelAnchorManager as U, DEFAULT_BRUSH_CONFIG as V, DEFAULT_TEXT_CONFIG as W, DEFAULT_LINE_TOOL_CONFIG as X, KritzelDevicesHelper as Y, KritzelMouseButton as Z, KritzelIconRegistry as _, writeVarUint8Array$2 as a, KritzelBaseHandler as a0, KritzelToolRegistry as a1, KritzelSelectionBox as a2, KritzelSelectionGroup as a3, KritzelBaseObject as a4, Doc as a5, DEFAULT_SYNC_CONFIG as a6, UndoManager as a7, ObjectHelper as a8, KritzelEventHelper as a9, KritzelBaseTool as aa, KritzelClassHelper as ab, readVarUint8Array$2 as b, applyUpdate as c, encodeStateVector as d, encodeStateAsUpdate as e, createEncoder$1 as f, createDecoder$1 as g, create$8 as h, fromBase64 as i, toBase64 as j, createUint8ArrayFromArrayBuffer as k, offChange as l, readVarString$2 as m, floor$2 as n, onChange as o, getUnixTime$1 as p, equalityDeep$1 as q, readVarUint$2 as r, setIfUndefined$1 as s, toUint8Array$1 as t, writeVarString$2 as u, varStorage as v, writeVarUint$2 as w, map as x, ObservableV2 as y, length$3 as z };
-//# sourceMappingURL=default-line-tool.config-C35m-d1Y.js.map
+export { Schema as $, isNode as A, min$2 as B, pow as C, HocuspocusProviderWebsocket as D, KritzelPath as E, KritzelImage as F, KritzelLine as G, HocuspocusProvider as H, KritzelBrushTool as I, KritzelLineTool as J, KritzelText as K, KritzelEraserTool as L, KritzelImageTool as M, KritzelTextTool as N, Observable$1 as O, KritzelCursorHelper as P, KritzelSelectionTool as Q, IndexedDBSyncProvider as R, KritzelAppStateMap as S, KritzelWorkspace as T, KritzelAnchorManager as U, DEFAULT_BRUSH_CONFIG as V, DEFAULT_TEXT_CONFIG as W, DEFAULT_LINE_TOOL_CONFIG as X, KritzelDevicesHelper as Y, KritzelMouseButton as Z, KritzelBaseObject as _, writeVarUint8Array$2 as a, schema as a0, addListNodes as a1, EditorView as a2, EditorState as a3, keymap as a4, TextSelection as a5, KritzelKeyboardHelper as a6, KritzelToolRegistry as a7, KritzelGeometryHelper as a8, baseKeymap as a9, KritzelBaseTool as aa, KritzelEventHelper as ab, KritzelIconRegistry as ac, KritzelBaseHandler as ad, KritzelSelectionBox as ae, KritzelSelectionGroup as af, Doc as ag, DEFAULT_SYNC_CONFIG as ah, UndoManager as ai, ObjectHelper as aj, KritzelClassHelper as ak, readVarUint8Array$2 as b, applyUpdate as c, encodeStateVector as d, encodeStateAsUpdate as e, createEncoder$1 as f, createDecoder$1 as g, create$8 as h, fromBase64 as i, toBase64 as j, createUint8ArrayFromArrayBuffer as k, offChange as l, readVarString$2 as m, floor$2 as n, onChange as o, getUnixTime$1 as p, equalityDeep$1 as q, readVarUint$2 as r, setIfUndefined$1 as s, toUint8Array$1 as t, writeVarString$2 as u, varStorage as v, writeVarUint$2 as w, map as x, ObservableV2 as y, length$3 as z };
+//# sourceMappingURL=default-line-tool.config-C35P3XfD.js.map
 
-//# sourceMappingURL=default-line-tool.config-C35m-d1Y.js.map
+//# sourceMappingURL=default-line-tool.config-C35P3XfD.js.map