kritzel-stencil 0.0.162 → 0.0.164

package/dist/cjs/{default-line-tool.config-D1Ns0NmM.js → default-line-tool.config-DJMYrkSu.js}

@@ -123,6 +123,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 {
@@ -14441,6 +14496,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 {
@@ -15225,6 +15365,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);
                 }
@@ -15247,6 +15388,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);
                 }
@@ -15263,7 +15405,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();
                 }
@@ -15275,7 +15416,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();
                 }
@@ -15675,6 +15815,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);
                 }
@@ -15701,6 +15842,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);
                 }
@@ -15717,7 +15859,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
@@ -15731,7 +15872,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
@@ -16059,6 +16199,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>',
@@ -33136,7 +33280,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;
         }
@@ -33155,7 +33326,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;
@@ -33163,7 +33342,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;
         }
@@ -33203,6 +33388,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;
@@ -33336,6 +33634,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.
      */
@@ -33518,6 +33840,8 @@ exports.DEFAULT_LINE_TOOL_CONFIG = DEFAULT_LINE_TOOL_CONFIG;
 exports.DEFAULT_SYNC_CONFIG = DEFAULT_SYNC_CONFIG;
 exports.DEFAULT_TEXT_CONFIG = DEFAULT_TEXT_CONFIG;
 exports.Doc = Doc;
+exports.EditorState = EditorState;
+exports.EditorView = EditorView;
 exports.HocuspocusProvider = HocuspocusProvider;
 exports.HocuspocusProviderWebsocket = HocuspocusProviderWebsocket;
 exports.IndexedDBSyncProvider = IndexedDBSyncProvider;
@@ -33532,6 +33856,7 @@ exports.KritzelCursorHelper = KritzelCursorHelper;
 exports.KritzelDevicesHelper = KritzelDevicesHelper;
 exports.KritzelEraserTool = KritzelEraserTool;
 exports.KritzelEventHelper = KritzelEventHelper;
+exports.KritzelGeometryHelper = KritzelGeometryHelper;
 exports.KritzelIconRegistry = KritzelIconRegistry;
 exports.KritzelImage = KritzelImage;
 exports.KritzelImageTool = KritzelImageTool;
@@ -33549,8 +33874,12 @@ exports.KritzelWorkspace = KritzelWorkspace;
 exports.ObjectHelper = ObjectHelper;
 exports.Observable = Observable$1;
 exports.ObservableV2 = ObservableV2;
+exports.Schema = Schema;
+exports.TextSelection = TextSelection;
 exports.UndoManager = UndoManager;
+exports.addListNodes = addListNodes;
 exports.applyUpdate = applyUpdate;
+exports.baseKeymap = baseKeymap;
 exports.create = create$8;
 exports.createDecoder = createDecoder$1;
 exports.createEncoder = createEncoder$1;
@@ -33562,6 +33891,7 @@ exports.floor = floor$2;
 exports.fromBase64 = fromBase64;
 exports.getUnixTime = getUnixTime$1;
 exports.isNode = isNode;
+exports.keymap = keymap;
 exports.length = length$3;
 exports.map = map;
 exports.min = min$2;
@@ -33571,6 +33901,7 @@ exports.pow = pow;
 exports.readVarString = readVarString$2;
 exports.readVarUint = readVarUint$2;
 exports.readVarUint8Array = readVarUint8Array$2;
+exports.schema = schema;
 exports.setIfUndefined = setIfUndefined$1;
 exports.toBase64 = toBase64;
 exports.toUint8Array = toUint8Array$1;
@@ -33578,6 +33909,6 @@ exports.varStorage = varStorage;
 exports.writeVarString = writeVarString$2;
 exports.writeVarUint = writeVarUint$2;
 exports.writeVarUint8Array = writeVarUint8Array$2;
-//# sourceMappingURL=default-line-tool.config-D1Ns0NmM.js.map
+//# sourceMappingURL=default-line-tool.config-DJMYrkSu.js.map
 
-//# sourceMappingURL=default-line-tool.config-D1Ns0NmM.js.map
+//# sourceMappingURL=default-line-tool.config-DJMYrkSu.js.map