sliced-areas 1.0.0

package/dist/sliced-areas.d.ts

@@ -0,0 +1,1067 @@
+/**
+ * Stable identifier used by the layout graph to reference an area.
+ */
+export type AreaId = string;
+/**
+ * External tag used by the host to map content into areas.
+ */
+export type AreaTag = string;
+/**
+ * Corner identifiers used for drag docking gestures.
+ */
+export type CornerId = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/**
+ * Normalized rectangle in layout space (0..1).
+ */
+export type AreaRect = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+/**
+ * Internal vertex identifier in the planar graph.
+ */
+type VertId = string;
+/**
+ * Internal edge identifier in the planar graph.
+ */
+type EdgeId = string;
+/**
+ * Graph vertex with normalized coordinates.
+ */
+export type GraphVert = {
+    id: VertId;
+    x: number;
+    y: number;
+};
+/**
+ * Graph edge connecting two vertices, optionally on the border.
+ */
+export type GraphEdge = {
+    id: EdgeId;
+    v1: VertId;
+    v2: VertId;
+    border: boolean;
+};
+/**
+ * Area represented by four ordered vertices.
+ */
+export type GraphArea = {
+    id: AreaId;
+    v1: VertId;
+    v2: VertId;
+    v3: VertId;
+    v4: VertId;
+};
+/**
+ * Full planar graph for the layout.
+ */
+export type AreasGraph = {
+    verts: Record<VertId, GraphVert>;
+    edges: Record<EdgeId, GraphEdge>;
+    areas: Record<AreaId, GraphArea>;
+};
+/**
+ * Serializable layout payload used by the host.
+ */
+export type AreasLayout = {
+    areas: Array<{
+        tag: AreaTag;
+        rect: AreaRect;
+    }>;
+};
+/**
+ * Payload emitted when a corner click is detected.
+ */
+export type CornerClickDetail = {
+    areaId: AreaId;
+    corner: CornerId;
+    clientX: number;
+    clientY: number;
+};
+/**
+ * Alias for normalized rectangle geometry.
+ */
+type Rect = AreaRect;
+/**
+ * Resolves host content for an area tag.
+ */
+export type AreaResolver = (tag: AreaTag) => HTMLElement | null | undefined;
+/**
+ * Web component implementing Blender-like area layout behavior.
+ */
+export declare class SlicedAreasElement extends HTMLElement {
+    /**
+     * Current graph model, or null when no layout is active.
+     */
+    private graph;
+    /**
+     * Root container for generated layout nodes.
+     */
+    private rootEl;
+    /**
+     * Hidden container used to stash detached area nodes.
+     */
+    private stashEl;
+    /**
+     * Resize observer to re-render on host size changes.
+     */
+    private resizeObserver;
+    /**
+     * Active resize drag state for splitters.
+     */
+    private dragState;
+    /**
+     * Active area drag state for move/split/join/swap.
+     */
+    private areaDragState;
+    /**
+     * Last pointer position seen during area drag.
+     */
+    private lastPointer;
+    /**
+     * Overlay element used to preview drop zones.
+     */
+    private dropOverlay;
+    /**
+     * Dimmed overlay used to preview join results.
+     */
+    private dropShade;
+    /**
+     * Floating label used during drag interactions.
+     */
+    private dragLabel;
+    /**
+     * Snapshot used to revert canceled resize drags.
+     */
+    private dragSnapshot;
+    /**
+     * Cached cursor style so it can be restored.
+     */
+    private dragCursor;
+    /**
+     * Stored graph when an area is maximized.
+     */
+    private storedGraph;
+    /**
+     * Stored tag mapping when an area is maximized.
+     */
+    private storedTags;
+    /**
+     * Resolver used to materialize area content.
+     */
+    private areaResolver;
+    /**
+     * Cache of resolved area nodes by id.
+     */
+    private resolvedNodes;
+    /**
+     * Tag mapping for areas in the current graph.
+     */
+    private areaTags;
+    /**
+     * Counter for generating unique vertex ids.
+     */
+    private vertCounter;
+    /**
+     * Counter for generating unique edge ids.
+     */
+    private edgeCounter;
+    /**
+     * Counter for generating unique area ids.
+     */
+    private areaCounter;
+    /**
+     * Returns the current serialized layout.
+     *
+     * @returns Current layout or null when empty.
+     */
+    get layout(): AreasLayout | null;
+    /**
+     * Applies a serialized layout to the component.
+     *
+     * @param value Layout to apply, or null to clear.
+     */
+    set layout(value: AreasLayout | null);
+    /**
+     * Sets a resolver for auto-providing area content.
+     *
+     * @param resolver Callback for resolving an area tag to a node.
+     */
+    setResolver(resolver: AreaResolver | null): void;
+    /**
+     * Initializes internal DOM and observers when connected.
+     */
+    connectedCallback(): void;
+    /**
+     * Cleans up observers and listeners when disconnected.
+     */
+    disconnectedCallback(): void;
+    /**
+     * Splits an area by zone, optionally using a pointer position.
+     *
+     * @param sourceAreaId Area to split.
+     * @param zone Split direction.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     */
+    split(sourceAreaId: AreaId, zone?: 'left' | 'right' | 'top' | 'bottom', clientX?: number, clientY?: number): void;
+    /**
+     * Joins two adjacent areas when alignment permits.
+     *
+     * @param sourceAreaId Area being merged into the target.
+     * @param targetAreaId Area that remains after the join.
+     */
+    join(sourceAreaId: AreaId, targetAreaId: AreaId): void;
+    /**
+     * Replaces the target area with the source area content.
+     *
+     * @param sourceAreaId Area providing the content.
+     * @param targetAreaId Area to remove.
+     */
+    replace(sourceAreaId: AreaId, targetAreaId: AreaId): void;
+    /**
+     * Swaps the ids (and therefore content) between two areas.
+     *
+     * @param sourceAreaId First area id.
+     * @param targetAreaId Second area id.
+     */
+    swap(sourceAreaId: AreaId, targetAreaId: AreaId): void;
+    /**
+     * Moves one area into another, producing overlay and remainder areas.
+     *
+     * @param sourceAreaId Area being moved.
+     * @param targetAreaId Area being split to receive the move.
+     * @param overlay Target rectangle for the moved area.
+     * @param remainder Remaining rectangle for the target area.
+     */
+    move(sourceAreaId: AreaId, targetAreaId: AreaId, overlay: Rect, remainder: Rect): void;
+    /**
+     * Removes an area from the layout if possible.
+     *
+     * @param areaId Area to close.
+     */
+    close(areaId: AreaId): void;
+    /**
+     * Updates the tag for a specific area.
+     *
+     * @param areaId Area to retag.
+     * @param tag New tag value.
+     */
+    retag(areaId: AreaId, tag: AreaTag): void;
+    /**
+     * Maximizes a single area and stores the previous layout.
+     *
+     * @param areaId Area to maximize.
+     */
+    maximize(areaId: AreaId): void;
+    /**
+     * Restores the layout from a previous maximize action.
+     */
+    restore(): void;
+    /**
+     * Creates the root container element if it does not exist.
+     */
+    private ensureRoot;
+    /**
+     * Creates the stash container used to hold detached nodes.
+     */
+    private ensureStash;
+    /**
+     * Attaches a ResizeObserver to trigger re-rendering.
+     */
+    private ensureResizeObserver;
+    /**
+     * Emits a layout change event with serialized data.
+     */
+    private emitLayoutChange;
+    /**
+     * Emits a corner click event for docking actions.
+     *
+     * @param detail Corner click payload.
+     */
+    private emitCornerClick;
+    /**
+     * Renders the current graph into positioned DOM nodes.
+     */
+    private render;
+    /**
+     * Collects host-provided area nodes keyed by area id.
+     *
+     * @returns Map of area ids to nodes.
+     */
+    private collectAreaNodes;
+    /**
+     * Ensures a DOM node exists for a newly created area.
+     *
+     * @param newAreaId Area id needing a node.
+     * @param sourceAreaId Area id to clone or inherit from.
+     * @param cloneSource Whether to clone the source node when possible.
+     */
+    private ensureAreaNode;
+    /**
+     * Copies a tag from an existing area when creating a new one.
+     *
+     * @param newAreaId Area id to assign a tag to.
+     * @param sourceAreaId Area id to inherit the tag from.
+     */
+    private inheritAreaTag;
+    /**
+     * Builds a graph from a serialized layout payload.
+     *
+     * @param layout Serialized layout data.
+     * @returns Graph representation of the layout.
+     */
+    private buildGraphFromLayout;
+    /**
+     * Converts the graph into a serialized layout payload.
+     *
+     * @param graph Graph to serialize.
+     * @returns Layout payload for events.
+     */
+    private serializeLayout;
+    /**
+     * Removes tags for areas that no longer exist.
+     *
+     * @param graph Current graph for validation.
+     */
+    private pruneAreaTags;
+    /**
+     * Handles bubbled retag events from area content.
+     *
+     * @param event Retag event from child content.
+     */
+    private onRetagRequest;
+    /**
+     * Normalizes rectangles so the layout spans the unit square.
+     *
+     * @param rects Rectangles to normalize.
+     * @returns Normalized rectangles.
+     */
+    private normalizeRectsToUnit;
+    /**
+     * Builds a graph from normalized rectangles.
+     *
+     * @param rects Rectangles that describe areas.
+     * @returns Graph built from the rectangles.
+     */
+    private buildGraphFromRects;
+    /**
+     * Creates a single-area graph spanning the full layout.
+     *
+     * @param areaId Area id for the base graph.
+     * @returns Graph with a single area.
+     */
+    private createBaseGraph;
+    /**
+     * Splits an area by a zone using a ratio.
+     *
+     * @param graph Graph to update.
+     * @param areaId Area to split.
+     * @param zone Split direction.
+     * @param ratio Split ratio within the area.
+     * @param newAreaId Id for the new area.
+     * @returns Updated graph or null when split is invalid.
+     */
+    private splitAreaByZone;
+    /**
+     * Splits an area using a pointer position inside the component.
+     *
+     * @param graph Graph to update.
+     * @param areaId Area to split.
+     * @param zone Split direction.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @param newAreaId Id for the new area.
+     * @returns Updated graph or null when split is invalid.
+     */
+    private splitAreaAtPointer;
+    /**
+     * Splits an area along a coordinate on a given axis.
+     *
+     * @param graph Graph to update.
+     * @param areaId Area to split.
+     * @param axis Axis to split along.
+     * @param splitCoord Coordinate for the split.
+     * @param newAreaId Id for the new area.
+     * @param keep Which side keeps the original area id.
+     * @returns Updated graph or null when split is invalid.
+     */
+    private splitAreaAt;
+    /**
+     * Joins two areas, trimming to overlapping ranges as needed.
+     *
+     * @param graph Graph to update.
+     * @param areaAId First area id.
+     * @param areaBId Second area id.
+     * @returns Updated graph or null when join is invalid.
+     */
+    private joinAreas;
+    /**
+     * Trims an area to a range and records created remainder areas.
+     *
+     * @param graph Graph to update.
+     * @param areaId Area to trim.
+     * @param axis Axis to trim along.
+     * @param rangeStart Range start coordinate.
+     * @param rangeEnd Range end coordinate.
+     * @returns Updated graph, kept area id, and created remainders.
+     */
+    private trimAreaToRange;
+    /**
+     * Applies remainder areas created during a join.
+     *
+     * @param graph Graph to update.
+     * @param remainders Remainder areas created during trimming.
+     * @param targetAreaId Target area being joined.
+     * @returns Updated graph with remainders processed.
+     */
+    private processRemainders;
+    /**
+     * Replaces an area with a new rectangle in the graph.
+     *
+     * @param graph Graph to update.
+     * @param areaId Area to update.
+     * @param rect New rectangle.
+     * @returns Updated graph.
+     */
+    private setAreaRect;
+    /**
+     * Moves an area into an overlay region and shrinks the target.
+     *
+     * @param graph Graph to update.
+     * @param sourceAreaId Area being moved.
+     * @param targetAreaId Area receiving the move.
+     * @param overlay Rectangle for the moved area.
+     * @param remainder Rectangle for the remainder of target.
+     * @returns Updated graph or null when invalid.
+     */
+    private moveArea;
+    /**
+     * Replaces the target area with the source area rectangle.
+     *
+     * @param graph Graph to update.
+     * @param sourceAreaId Area providing the rectangle.
+     * @param targetAreaId Area to remove.
+     * @returns Updated graph or null when invalid.
+     */
+    private replaceArea;
+    /**
+     * Renames an area id and updates DOM references.
+     *
+     * @param graph Graph to update.
+     * @param fromId Existing area id.
+     * @param toId New area id.
+     * @returns Updated graph.
+     */
+    private renameAreaId;
+    /**
+     * Removes an area node and its cached metadata.
+     *
+     * @param areaId Area to remove.
+     */
+    private removeAreaNode;
+    /**
+     * Detaches an area node without altering tags.
+     *
+     * @param areaId Area to detach.
+     */
+    private detachAreaNode;
+    /**
+     * Joins two areas that are already aligned.
+     *
+     * @param graph Graph to update.
+     * @param areaAId First area id.
+     * @param areaBId Second area id.
+     * @returns Updated graph or null when join is invalid.
+     */
+    private joinAreasAligned;
+    /**
+     * Swaps the ids of two areas in the graph.
+     *
+     * @param graph Graph to update.
+     * @param areaAId First area id.
+     * @param areaBId Second area id.
+     * @returns Updated graph or null when invalid.
+     */
+    private swapAreaIds;
+    /**
+     * Checks whether two areas can be joined.
+     *
+     * @param areaAId First area id.
+     * @param areaBId Second area id.
+     * @returns True when join is possible.
+     */
+    private canJoin;
+    /**
+     * Checks if two areas align for a join operation.
+     *
+     * @param graph Graph containing the areas.
+     * @param areaA First area.
+     * @param areaB Second area.
+     * @param dir Expected orientation between areas.
+     * @returns True when aligned within tolerance.
+     */
+    private areAreasAligned;
+    /**
+     * Determines the orientation between two areas.
+     *
+     * @param graph Graph containing the areas.
+     * @param areaA First area.
+     * @param areaB Second area.
+     * @returns Orientation of areaB relative to areaA.
+     */
+    private getOrientation;
+    /**
+     * Computes alignment offsets between two areas by orientation.
+     *
+     * @param graph Graph containing the areas.
+     * @param areaA First area.
+     * @param areaB Second area.
+     * @param dir Orientation between the areas.
+     * @returns Offset values or null when invalid.
+     */
+    private getOffsets;
+    /**
+     * Builds draggable splitter handles for shared edges.
+     *
+     * @param graph Graph to inspect.
+     * @param width Render width in pixels.
+     * @param height Render height in pixels.
+     * @returns Array of handle elements.
+     */
+    private buildResizeHandles;
+    /**
+     * Registers an edge segment for shared edge detection.
+     *
+     * @param map Edge aggregation map.
+     * @param axis Axis of the edge.
+     * @param coord Constant coordinate for the edge.
+     * @param start Segment start.
+     * @param end Segment end.
+     */
+    private registerEdge;
+    /**
+     * Computes overlapping segments shared by at least two areas.
+     *
+     * @param segments Segments to analyze.
+     * @returns Shared segments.
+     */
+    private computeSharedSegments;
+    /**
+     * Handles pointer down on resize handles and drag targets.
+     *
+     * @param event Pointer event.
+     */
+    private onPointerDown;
+    /**
+     * Handles pointer movement for resize and area drag operations.
+     *
+     * @param event Pointer event.
+     */
+    private onPointerMove;
+    /**
+     * Finalizes drag operations on pointer release.
+     *
+     * @param event Pointer event.
+     */
+    private onPointerUp;
+    /**
+     * Handles key presses for drag modifiers and cancel.
+     *
+     * @param event Keyboard event.
+     */
+    private onKeyDown;
+    /**
+     * Handles key releases for drag modifiers.
+     *
+     * @param event Keyboard event.
+     */
+    private onKeyUp;
+    /**
+     * Cancels an area drag and resets UI state.
+     */
+    private cancelAreaDrag;
+    /**
+     * Cancels a resize drag and restores the snapshot.
+     */
+    private cancelResizeDrag;
+    /**
+     * Re-evaluates the area drag UI at the last pointer.
+     */
+    private refreshAreaDrag;
+    /**
+     * Sets a temporary cursor during drag operations.
+     *
+     * @param cursor CSS cursor value.
+     */
+    private setDragCursor;
+    /**
+     * Restores the cursor to its previous value.
+     *
+     * @param force Whether to restore even if no cursor is tracked.
+     */
+    private resetDragCursor;
+    /**
+     * Deep clones the graph for safe mutation.
+     *
+     * @param graph Graph to clone.
+     * @returns Cloned graph.
+     */
+    private cloneGraph;
+    /**
+     * Detaches pointer drag listeners.
+     */
+    private detachDragListeners;
+    /**
+     * Detaches keyboard listeners used during drag.
+     */
+    private detachKeyListener;
+    /**
+     * Starts an area drag for move/split/join actions.
+     *
+     * @param event Pointer event.
+     * @param areaId Source area id.
+     * @param corner Optional corner id for corner drag.
+     */
+    private startAreaDrag;
+    /**
+     * Updates area drag state from a pointer event.
+     *
+     * @param event Pointer event.
+     */
+    private updateAreaDrag;
+    /**
+     * Updates area drag state at a specific pointer position.
+     *
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     */
+    private updateAreaDragAt;
+    /**
+     * Commits the last area drag action if valid.
+     */
+    private finishAreaDrag;
+    /**
+     * Tracks the latest drop target preview for area drag.
+     */
+    private lastDropTarget;
+    /**
+     * Shows the drop overlay for join/split/move/replace/swap.
+     *
+     * @param target Target area and rect.
+     * @param zone Zone to highlight.
+     * @param mode Drop mode being previewed.
+     * @param overlayRect Optional overlay rect override.
+     * @param direction Optional join direction.
+     */
+    private showDropOverlay;
+    /**
+     * Shows a split overlay with both resulting regions.
+     *
+     * @param target Target area and rect.
+     * @param zone Split zone.
+     * @param overlayRect Primary overlay rectangle.
+     */
+    private showSplitOverlay;
+    /**
+     * Computes overlay and remainder rectangles for move preview.
+     *
+     * @param targetRect Target area rectangle.
+     * @param zone Move zone.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @returns Overlay and remainder rectangles plus replace flag.
+     */
+    private getMovePreview;
+    /**
+     * Hides the drop overlay and clears target state.
+     */
+    private hideDropOverlay;
+    /**
+     * Shows shaded regions that would be removed after a join.
+     *
+     * @param result Resulting rectangle after join.
+     * @param sourceRect Source area rectangle.
+     * @param targetRect Target area rectangle.
+     */
+    private showJoinShade;
+    /**
+     * Hides the join shading overlay.
+     */
+    private hideJoinShade;
+    /**
+     * Displays a drag label at the pointer.
+     *
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @param label Label text.
+     */
+    private showDragLabel;
+    /**
+     * Hides the drag label.
+     */
+    private hideDragLabel;
+    /**
+     * Returns the split label for a given zone.
+     *
+     * @param zone Split zone.
+     * @returns Label text.
+     */
+    private getSplitLabel;
+    /**
+     * Returns the join label for a given direction.
+     *
+     * @param direction Join direction.
+     * @returns Label text.
+     */
+    private getJoinLabel;
+    /**
+     * Finds a join target under the pointer, if any.
+     *
+     * @param sourceAreaId Source area id.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @returns Join target details or null.
+     */
+    private findJoinTargetAtPoint;
+    /**
+     * Computes the overlay rectangle for a join preview.
+     *
+     * @param source Source area rectangle.
+     * @param target Target area rectangle.
+     * @param orientation Orientation between the areas.
+     * @returns Overlay rectangle.
+     */
+    private getJoinOverlayRect;
+    /**
+     * Computes the resulting rectangle of a join.
+     *
+     * @param source Source area rectangle.
+     * @param target Target area rectangle.
+     * @param orientation Orientation between the areas.
+     * @returns Result rectangle.
+     */
+    private getJoinResultRect;
+    /**
+     * Subtracts a rectangle from another and returns remaining pieces.
+     *
+     * @param outer Outer rectangle.
+     * @param inner Inner rectangle to subtract.
+     * @returns Remaining rectangles.
+     */
+    private subtractRect;
+    /**
+     * Finds the area under the given pointer coordinates.
+     *
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @returns Area id and rect or null when not found.
+     */
+    private findAreaAtPoint;
+    /**
+     * Resolves the move zone inside a rectangle by pointer position.
+     *
+     * @param rect Target rectangle.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @returns Move zone.
+     */
+    private getMoveZone;
+    /**
+     * Determines split axis from a drag gesture.
+     *
+     * @param state Area drag state.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @returns Gesture axis or null when undecided.
+     */
+    private resolveSplitGesture;
+    /**
+     * Determines the split zone from a resolved gesture.
+     *
+     * @param rect Target rectangle.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @param gesture Resolved split gesture.
+     * @returns Split zone.
+     */
+    private getSplitZone;
+    /**
+     * Determines the split zone given a fixed axis.
+     *
+     * @param rect Target rectangle.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @param axis Split axis.
+     * @returns Split zone.
+     */
+    private getSplitZoneByAxis;
+    /**
+     * Checks if a rectangle can be split along an axis.
+     *
+     * @param rect Target rectangle.
+     * @param axis Split axis.
+     * @returns True when split is possible.
+     */
+    private canSplitRect;
+    /**
+     * Returns the zone rectangle for previews.
+     *
+     * @param rect Target rectangle.
+     * @param zone Zone to extract.
+     * @param mode Drop mode.
+     * @returns Zone rectangle.
+     */
+    private getZoneRect;
+    /**
+     * Computes the overlay rectangle for a split preview.
+     *
+     * @param rect Target rectangle.
+     * @param zone Split zone.
+     * @param clientX Pointer X position.
+     * @param clientY Pointer Y position.
+     * @returns Overlay rectangle.
+     */
+    private getSplitOverlayRect;
+    /**
+     * Moves all connected vertices on an edge to a new coordinate.
+     *
+     * @param graph Graph to update.
+     * @param axis Axis of movement.
+     * @param fromCoord Current coordinate.
+     * @param toCoord Target coordinate.
+     * @param rangeStart Range start.
+     * @param rangeEnd Range end.
+     * @returns Updated graph or null when no movement.
+     */
+    private moveEdge;
+    /**
+     * Computes min/max bounds for a draggable edge segment.
+     *
+     * @param graph Graph to inspect.
+     * @param axis Axis of the edge.
+     * @param coord Edge coordinate.
+     * @param rangeStart Segment start.
+     * @param rangeEnd Segment end.
+     * @returns Bounds or null when invalid.
+     */
+    private getEdgeDragBounds;
+    /**
+     * Computes the rectangle for a graph area.
+     *
+     * @param graph Graph containing the area.
+     * @param area Area to compute.
+     * @returns Normalized rectangle.
+     */
+    private getAreaRect;
+    /**
+     * Adds a vertex to the vertex map.
+     *
+     * @param verts Vertex map to update.
+     * @param x X coordinate.
+     * @param y Y coordinate.
+     * @returns New vertex id.
+     */
+    private addVert;
+    /**
+     * Adds an edge to the edge map.
+     *
+     * @param edges Edge map to update.
+     * @param v1 First vertex id.
+     * @param v2 Second vertex id.
+     * @returns New edge id.
+     */
+    private addEdge;
+    /**
+     * Generates the next unique vertex id.
+     *
+     * @param verts Existing vertex map.
+     * @returns Unique vertex id.
+     */
+    private nextVertId;
+    /**
+     * Generates the next unique edge id.
+     *
+     * @param edges Existing edge map.
+     * @returns Unique edge id.
+     */
+    private nextEdgeId;
+    /**
+     * Generates the next unique area id.
+     *
+     * @returns Unique area id.
+     */
+    private nextAreaId;
+    /**
+     * Normalizes the graph and fills any holes.
+     *
+     * @param graph Graph to normalize.
+     * @returns Normalized graph.
+     */
+    private normalizeGraph;
+    /**
+     * Normalizes vertices and edges by merging duplicates.
+     *
+     * @param graph Graph to normalize.
+     * @returns Normalized graph.
+     */
+    private normalizeGraphInternal;
+    /**
+     * Attempts to fill any uncovered holes in the layout.
+     *
+     * @param graph Graph to update.
+     * @returns Graph with holes filled.
+     */
+    private fillHoles;
+    /**
+     * Finds uncovered grid cells in the layout.
+     *
+     * @param graph Graph to inspect.
+     * @returns Hole rectangles.
+     */
+    private findHoleCells;
+    /**
+     * Collects and de-duplicates axis coordinates for grid scan.
+     *
+     * @param rects Rectangles to inspect.
+     * @param axis Axis to collect.
+     * @returns Sorted coordinates.
+     */
+    private collectAxisCoords;
+    /**
+     * Merges adjacent hole cells into larger rectangles.
+     *
+     * @param cells Hole cells to merge.
+     * @returns Merged hole rectangles.
+     */
+    private mergeHoleCells;
+    /**
+     * Attempts to align neighbors to cover a hole.
+     *
+     * @param graph Graph to update.
+     * @param hole Hole rectangle.
+     * @returns Updated graph and change flag.
+     */
+    private tryAlignHoleNeighbors;
+    /**
+     * Collects adjacent neighbors along one side of a hole.
+     *
+     * @param graph Graph to inspect.
+     * @param hole Hole rectangle.
+     * @param side Side to check.
+     * @returns Neighbor areas and rectangles.
+     */
+    private collectAdjacentNeighbors;
+    /**
+     * Splits or trims a neighbor to align with a hole.
+     *
+     * @param graph Graph to update.
+     * @param areaId Neighbor area id.
+     * @param hole Hole rectangle.
+     * @param side Side of the hole.
+     * @returns Updated graph and change flag.
+     */
+    private alignNeighborToHole;
+    /**
+     * Checks if a cell is covered by any rectangle.
+     *
+     * @param rects Rectangles to check.
+     * @param cell Cell rectangle.
+     * @returns True when covered.
+     */
+    private isCellCovered;
+    /**
+     * Finds a plan to fill a hole by expanding neighbors.
+     *
+     * @param graph Graph to inspect.
+     * @param hole Hole rectangle.
+     * @returns Fill plan or null when impossible.
+     */
+    private findHoleFillPlan;
+    /**
+     * Collects neighbor areas that fully cover one side of a hole.
+     *
+     * @param graph Graph to inspect.
+     * @param hole Hole rectangle.
+     * @param side Side to check.
+     * @returns Neighbor data or null when none found.
+     */
+    private collectHoleNeighbors;
+    /**
+     * Checks whether a hole side is fully covered by segments.
+     *
+     * @param hole Hole rectangle.
+     * @param side Side to check.
+     * @param segments Coverage segments.
+     * @returns True when side is covered.
+     */
+    private isHoleSideCovered;
+    /**
+     * Merges overlapping or touching segments.
+     *
+     * @param segments Segments to merge.
+     * @returns Merged segments.
+     */
+    private mergeSegments;
+    /**
+     * Expands a rectangle into a hole from a given side.
+     *
+     * @param rect Neighbor rectangle.
+     * @param hole Hole rectangle.
+     * @param side Side to expand from.
+     * @returns Expanded rectangle.
+     */
+    private expandRectIntoHole;
+    /**
+     * Detects overlapping areas in the graph.
+     *
+     * @param graph Graph to inspect.
+     * @returns List of overlaps.
+     */
+    private findOverlaps;
+    /**
+     * Throws a detailed error for overlapping areas.
+     *
+     * @param graph Graph containing overlaps.
+     * @param overlaps Overlap data.
+     * @throws Error when overlaps are found.
+     */
+    private throwOverlapError;
+    /**
+     * Throws a detailed error for unfillable holes.
+     *
+     * @param graph Graph containing holes.
+     * @param holes Hole rectangles.
+     * @throws Error when holes are found.
+     */
+    private throwHoleError;
+    /**
+     * Formats a rectangle to fixed precision for diagnostics.
+     *
+     * @param rect Rectangle to format.
+     * @returns Formatted rectangle.
+     */
+    private formatRect;
+    /**
+     * Collects vertices connected along a straight edge segment.
+     *
+     * @param graph Graph to inspect.
+     * @param axis Axis of the edge.
+     * @param coord Edge coordinate.
+     * @param rangeStart Segment start.
+     * @param rangeEnd Segment end.
+     * @returns Set of connected vertex ids.
+     */
+    private collectConnectedVerts;
+}
+/**
+ * Global tag name mapping for the custom element.
+ */
+declare global {
+    interface HTMLElementTagNameMap {
+        'sliced-areas': SlicedAreasElement;
+    }
+}
+export {};