@vuu-ui/grid-layout 4.0.0-alpha.1

package/src/GridGeometry.js

@@ -0,0 +1,1298 @@
+const NO_TRACK_METRICS = {
+    measured: []
+};
+const trackMetrics = (measured)=>({
+        measured: [
+            ...measured
+        ]
+    });
+const NO_MEASUREMENTS = {};
+const ok = (value)=>({
+        ok: true,
+        value
+    });
+const failure = (code, message, trackType)=>({
+        error: {
+            code,
+            message,
+            trackType
+        },
+        ok: false
+    });
+const measurementRequired = (trackType)=>failure("MEASUREMENT_REQUIRED", `[GridGeometry] ${trackType} tracks must be measured before this transition`, trackType);
+const isFractionTrackSize = (size)=>"string" == typeof size && size.endsWith("fr");
+const isPixelTrackSize = (size)=>"string" == typeof size && size.endsWith("px");
+const fractionSize = (value)=>`${value}fr`;
+const pixelSize = (value)=>`${value}px`;
+const isFraction = ({ size })=>isFractionTrackSize(size);
+const isPixelValue = ({ size })=>isPixelTrackSize(size);
+const isMeasured = ({ measured })=>-1 !== measured;
+const hasNumericValue = (track)=>isPixelValue(track) || isMeasured(track);
+const numericValue = (track)=>isPixelValue(track) ? parseFloat(track.size) : track.measured;
+const sizedTrack = (size)=>({
+        measured: -1,
+        size
+    });
+const incrementTrack = (track, value, trackType)=>{
+    if (isFraction(track)) {
+        if (!isMeasured(track)) return measurementRequired(trackType);
+        return ok({
+            measured: track.measured,
+            size: pixelSize(track.measured + value)
+        });
+    }
+    return ok({
+        measured: track.measured,
+        size: pixelSize(parseFloat(track.size) + value)
+    });
+};
+const readTracks = (sizes, metrics = NO_TRACK_METRICS)=>sizes.map((size, index)=>({
+            measured: metrics.measured[index] ?? -1,
+            size
+        }));
+const trackSizes = (tracks)=>tracks.map(({ size })=>size);
+const geometryTracks = (geometry, trackType)=>"column" === trackType ? geometry.columns : geometry.rows;
+const identitySources = (length)=>Array.from({
+        length
+    }, (_, index)=>index);
+const transition = (tracks, sources)=>({
+        sources: [
+            ...sources
+        ],
+        tracks: [
+            ...tracks
+        ]
+    });
+const composeTransitions = (first, second)=>void 0 === first ? second : {
+        sources: second.sources.map((source)=>-1 === source ? -1 : first.sources[source] ?? -1),
+        tracks: second.tracks
+    };
+const splitTrack = (tracks, trackIndex, trackType)=>{
+    const targetTrack = tracks[trackIndex];
+    if (void 0 === targetTrack) return failure("TRACK_NOT_FOUND", `[GridGeometry] no ${trackType} track #${trackIndex}`);
+    const sources = identitySources(tracks.length);
+    if (isFraction(targetTrack)) {
+        const splitTrackSize = targetTrack.size;
+        const doubled = tracks.map((track)=>isFraction(track) ? sizedTrack(fractionSize(2 * parseFloat(track.size))) : track);
+        doubled[trackIndex] = sizedTrack(splitTrackSize);
+        return ok(transition([
+            ...doubled.slice(0, trackIndex),
+            {
+                measured: -1,
+                size: splitTrackSize
+            },
+            ...doubled.slice(trackIndex)
+        ], [
+            ...sources.slice(0, trackIndex),
+            -1,
+            ...sources.slice(trackIndex)
+        ]));
+    }
+    const sizeOfNewTrack = Math.floor(numericValue(targetTrack) / 2);
+    const reduced = incrementTrack(targetTrack, -sizeOfNewTrack, trackType);
+    if (!reduced.ok) return reduced;
+    const next = [
+        ...tracks
+    ];
+    next[trackIndex] = reduced.value;
+    return ok(transition([
+        ...next.slice(0, trackIndex),
+        {
+            measured: -1,
+            size: pixelSize(sizeOfNewTrack)
+        },
+        ...next.slice(trackIndex)
+    ], [
+        ...sources.slice(0, trackIndex),
+        -1,
+        ...sources.slice(trackIndex)
+    ]));
+};
+const findBisectingTrack = (tracks, startIndex, endIndex, trackType)=>{
+    const tracksInRange = tracks.slice(startIndex - 1, endIndex);
+    if (tracksInRange.every(isFraction)) {
+        const halfSize = tracksInRange.reduce((sum, track)=>sum + parseFloat(track.size), 0) / 2;
+        let size = 0;
+        for(let i = startIndex - 1; i < endIndex - 1; i++){
+            size += parseFloat(tracks[i].size);
+            if (Math.abs(halfSize - size) < Number.EPSILON) return ok(i + 2);
+        }
+        return ok(-1);
+    }
+    if (!tracksInRange.every(hasNumericValue)) return measurementRequired(trackType);
+    let size = 0;
+    for(let i = startIndex - 1; i < endIndex - 1; i++)size += numericValue(tracks[i]);
+    const halfSize = size / 2;
+    size = 0;
+    for(let i = startIndex - 1; i < endIndex - 1; i++){
+        size += numericValue(tracks[i]);
+        if (Math.abs(halfSize - size) < 1) return ok(i + 2);
+    }
+    return ok(-1);
+};
+const bisectTracks = (tracks, fromTrackLine, toTrackLine, trackType)=>{
+    const rangeStart = fromTrackLine - 1;
+    const rangeEnd = toTrackLine - 1;
+    const tracksInRange = tracks.slice(rangeStart, rangeEnd);
+    const sources = identitySources(tracks.length);
+    if (tracksInRange.every(isFraction)) {
+        const halfSize = tracksInRange.reduce((sum, track)=>sum + parseFloat(track.size), 0) / 2;
+        let size = 0;
+        for(let i = rangeStart; i < rangeEnd; i++){
+            const trackSize = parseFloat(tracks[i].size);
+            if (size + trackSize > halfSize) {
+                const firstSize = halfSize - size;
+                const secondSize = trackSize - firstSize;
+                return ok({
+                    newTrackIndex: i,
+                    transition: transition([
+                        ...tracks.slice(0, i),
+                        {
+                            measured: -1,
+                            size: fractionSize(firstSize)
+                        },
+                        {
+                            measured: -1,
+                            size: fractionSize(secondSize)
+                        },
+                        ...tracks.slice(i + 1)
+                    ], [
+                        ...sources.slice(0, i),
+                        -1,
+                        -1,
+                        ...sources.slice(i + 1)
+                    ])
+                });
+            }
+            size += trackSize;
+        }
+        return failure("GEOMETRY_ERROR", "[GridTracks] fractional tracks could not be bisected", trackType);
+    }
+    if (!tracksInRange.every(hasNumericValue)) return measurementRequired(trackType);
+    let newTrackIndex = 0;
+    const newTracks = [];
+    const newSources = [];
+    let size = 0;
+    for(let i = fromTrackLine - 1; i < toTrackLine - 1; i++)size += numericValue(tracks[i]);
+    let halfTrack = Math.floor(size / 2);
+    for(let i = 0; i < tracks.length; i++)if (i < fromTrackLine - 1) {
+        newTracks.push(tracks[i]);
+        newSources.push(i);
+    } else if (i < toTrackLine - 1) {
+        const trackValue = numericValue(tracks[i]);
+        if (trackValue < halfTrack) {
+            newTracks.push(tracks[i]);
+            newSources.push(i);
+            halfTrack -= trackValue;
+        } else if (halfTrack) {
+            newTrackIndex = newTracks.length;
+            newTracks.push({
+                measured: -1,
+                size: pixelSize(halfTrack)
+            });
+            newSources.push(-1);
+            newTracks.push({
+                measured: -1,
+                size: pixelSize(trackValue - halfTrack)
+            });
+            newSources.push(-1);
+            halfTrack = 0;
+        } else {
+            newTracks.push(tracks[i]);
+            newSources.push(i);
+        }
+    } else {
+        newTracks.push(tracks[i]);
+        newSources.push(i);
+    }
+    return ok({
+        newTrackIndex,
+        transition: transition(newTracks, newSources)
+    });
+};
+const insertTrack = (tracks, { index, position }, size, trackType)=>{
+    const reducedIndex = "before" === position ? index - 1 : index;
+    const reducedTrack = tracks[reducedIndex];
+    if (void 0 === reducedTrack) return ok(void 0);
+    const reduced = incrementTrack(reducedTrack, -size, trackType);
+    if (!reduced.ok) return reduced;
+    const next = [
+        ...tracks
+    ];
+    next[reducedIndex] = reduced.value;
+    const sources = identitySources(tracks.length);
+    return ok(transition([
+        ...next.slice(0, index),
+        {
+            measured: -1,
+            size: pixelSize(Math.abs(size))
+        },
+        ...next.slice(index)
+    ], [
+        ...sources.slice(0, index),
+        -1,
+        ...sources.slice(index)
+    ]));
+};
+const removeTrack = (tracks, index, assignDirection = "fwd", trackType = "column")=>{
+    const assignFwd = 0 === index || "fwd" === assignDirection;
+    const contraIndex = assignFwd ? index + 1 : index - 1;
+    const contraTrack = tracks[contraIndex];
+    const removedTrack = tracks[index];
+    if (void 0 === contraTrack || void 0 === removedTrack) return failure("TRACK_NOT_FOUND", `[GridGeometry] no ${trackType} track to absorb removal of track #${index}`, trackType);
+    const otherTracksAreFractions = tracks.some((track, i)=>i !== index && i !== contraIndex && isFraction(track));
+    let nextContraTrack = contraTrack;
+    if (isFraction(contraTrack) && isFraction(removedTrack)) {
+        if (otherTracksAreFractions) nextContraTrack = {
+            measured: contraTrack.measured,
+            size: fractionSize(parseFloat(contraTrack.size) + parseFloat(removedTrack.size))
+        };
+    } else if (isFraction(contraTrack)) {
+        if (otherTracksAreFractions) {
+            if (!isMeasured(contraTrack) || !hasNumericValue(removedTrack)) return measurementRequired(trackType);
+            const incremented = incrementTrack(contraTrack, numericValue(removedTrack), trackType);
+            if (!incremented.ok) return incremented;
+            nextContraTrack = incremented.value;
+        }
+    } else {
+        if (!hasNumericValue(removedTrack)) return measurementRequired(trackType);
+        const incremented = incrementTrack(contraTrack, numericValue(removedTrack), trackType);
+        if (!incremented.ok) return incremented;
+        nextContraTrack = incremented.value;
+    }
+    const next = [
+        ...tracks
+    ];
+    next[contraIndex] = nextContraTrack;
+    const sources = identitySources(tracks.length);
+    next.splice(index, 1);
+    sources.splice(index, 1);
+    return ok(transition(next, sources));
+};
+const resizeTrackTo = (tracks, trackIndex, size, trackType = "column")=>{
+    if (void 0 === tracks[trackIndex]) return failure("TRACK_NOT_FOUND", `[GridGeometry] no ${trackType} track #${trackIndex}`, trackType);
+    const next = [
+        ...tracks
+    ];
+    next[trackIndex] = sizedTrack(size);
+    return ok(transition(next, identitySources(tracks.length)));
+};
+const resizeTracksAdjacent = (tracks, { contraTrackIndex, delta, resizedTrackIndex }, trackType)=>{
+    const resizeTrack = tracks[resizedTrackIndex];
+    const contraTrack = tracks[contraTrackIndex];
+    if (void 0 === resizeTrack || void 0 === contraTrack) return failure("TRACK_NOT_FOUND", "[GridTracks] resize, no track at index position", trackType);
+    const resized = incrementTrack(resizeTrack, delta, trackType);
+    if (!resized.ok) return resized;
+    const contra = incrementTrack(contraTrack, -delta, trackType);
+    if (!contra.ok) return contra;
+    const next = [
+        ...tracks
+    ];
+    next[resizedTrackIndex] = resized.value;
+    next[contraTrackIndex] = contra.value;
+    return ok(transition(next, identitySources(tracks.length)));
+};
+const getMinimumConstrainedSizes = (trackIndices, constraints)=>{
+    const prefixSizes = Array.from({
+        length: trackIndices.length + 1
+    }, ()=>0);
+    for(let end = 1; end <= trackIndices.length; end += 1){
+        prefixSizes[end] = prefixSizes[end - 1];
+        for (const constraint of constraints){
+            const localIndices = constraint.trackIndices.map((trackIndex)=>trackIndices.indexOf(trackIndex)).filter((index)=>-1 !== index).sort((a, b)=>a - b);
+            if (localIndices.at(-1) === end - 1) prefixSizes[end] = Math.max(prefixSizes[end], prefixSizes[localIndices[0]] + constraint.minimum);
+        }
+    }
+    return trackIndices.map((_, index)=>prefixSizes[index + 1] - prefixSizes[index]);
+};
+const getConstrainedGroupReductions = (tracks, trackIndices, constraints, requestedReduction)=>{
+    const reductions = trackIndices.map(()=>0);
+    const initialSizes = trackIndices.map((trackIndex)=>numericValue(tracks[trackIndex]));
+    if (constraints.some((constraint)=>constraint.trackIndices.reduce((total, trackIndex)=>total + numericValue(tracks[trackIndex]), 0) < constraint.minimum - 0.001)) return reductions;
+    const minimumSizes = getMinimumConstrainedSizes(trackIndices, constraints);
+    const maximumReduction = Math.max(0, initialSizes.reduce((total, size)=>total + size, 0) - minimumSizes.reduce((total, size)=>total + size, 0));
+    const allConstraints = constraints.concat(trackIndices.map((trackIndex)=>({
+            minimum: 0,
+            trackIndices: [
+                trackIndex
+            ]
+        })));
+    let activeTrackIndices = [
+        ...trackIndices
+    ];
+    let remainingReduction = Math.min(requestedReduction, maximumReduction);
+    while(remainingReduction > 0.001 && activeTrackIndices.length > 0){
+        const activeSize = activeTrackIndices.reduce((total, trackIndex)=>total + numericValue(tracks[trackIndex]) - reductions[trackIndices.indexOf(trackIndex)], 0);
+        const proposedReductions = activeTrackIndices.map((trackIndex)=>{
+            const currentSize = numericValue(tracks[trackIndex]) - reductions[trackIndices.indexOf(trackIndex)];
+            return currentSize / activeSize * remainingReduction;
+        });
+        let appliedRatio = 1;
+        for (const constraint of allConstraints){
+            const constrainedActiveIndices = activeTrackIndices.filter((trackIndex)=>constraint.trackIndices.includes(trackIndex));
+            const proposedReduction = constrainedActiveIndices.reduce((total, trackIndex)=>total + proposedReductions[activeTrackIndices.indexOf(trackIndex)], 0);
+            if (0 === proposedReduction) continue;
+            const currentSize = constraint.trackIndices.reduce((total, trackIndex)=>total + numericValue(tracks[trackIndex]) - reductions[trackIndices.indexOf(trackIndex)], 0);
+            appliedRatio = Math.min(appliedRatio, Math.max(0, (currentSize - constraint.minimum) / proposedReduction));
+        }
+        let appliedReduction = 0;
+        activeTrackIndices.forEach((trackIndex, index)=>{
+            const reduction = proposedReductions[index] * appliedRatio;
+            reductions[trackIndices.indexOf(trackIndex)] += reduction;
+            appliedReduction += reduction;
+        });
+        remainingReduction -= appliedReduction;
+        if (1 === appliedRatio) break;
+        activeTrackIndices = activeTrackIndices.filter((trackIndex)=>allConstraints.every((constraint)=>{
+                if (!constraint.trackIndices.includes(trackIndex)) return true;
+                const currentSize = constraint.trackIndices.reduce((total, constrainedTrackIndex)=>total + numericValue(tracks[constrainedTrackIndex]) - reductions[trackIndices.indexOf(constrainedTrackIndex)], 0);
+                return currentSize - constraint.minimum > 0.001;
+            }));
+    }
+    if (remainingReduction > 0.001) {
+        const currentSizes = initialSizes.map((size, index)=>size - reductions[index]);
+        const availableReduction = currentSizes.reduce((total, size)=>total + size, 0) - minimumSizes.reduce((total, size)=>total + size, 0);
+        const interpolation = availableReduction > 0 ? Math.min(1, remainingReduction / availableReduction) : 0;
+        currentSizes.forEach((size, index)=>{
+            const finalSize = size + (minimumSizes[index] - size) * interpolation;
+            reductions[index] = initialSizes[index] - finalSize;
+        });
+    }
+    return reductions;
+};
+const getProportionalResizeAllowance = (tracks, trackIndices, constraints, trackType)=>{
+    if (trackIndices.some((index)=>!hasNumericValue(tracks[index]))) return measurementRequired(trackType);
+    const requestedReduction = trackIndices.reduce((total, index)=>total + numericValue(tracks[index]), 0);
+    return ok(getConstrainedGroupReductions(tracks, trackIndices, constraints, requestedReduction).reduce((total, reduction)=>total + reduction, 0));
+};
+const resizeTracksProportionally = (tracks, { afterConstraints = [], afterTrackIndices, beforeConstraints = [], beforeTrackIndices, delta, initialSizes }, trackType)=>{
+    const resizedIndices = [
+        ...beforeTrackIndices,
+        ...afterTrackIndices
+    ];
+    if (resizedIndices.some((index)=>void 0 === tracks[index])) return failure("TRACK_NOT_FOUND", "[GridTracks] proportional resize track not found", trackType);
+    const next = [
+        ...tracks
+    ];
+    if (initialSizes) resizedIndices.forEach((trackIndex)=>{
+        next[trackIndex] = sizedTrack(pixelSize(initialSizes[trackIndex]));
+    });
+    if (resizedIndices.some((index)=>!hasNumericValue(next[index]))) return measurementRequired(trackType);
+    const resizeGroup = (indices, constraints, totalChange)=>{
+        const groupTracks = indices.map((index)=>next[index]);
+        if (totalChange >= 0) {
+            const groupSize = groupTracks.reduce((total, track)=>total + numericValue(track), 0);
+            let appliedChange = 0;
+            for (const [index, trackIndex] of indices.entries()){
+                const change = index === indices.length - 1 ? totalChange - appliedChange : 0 === groupSize ? totalChange / indices.length : totalChange * (numericValue(next[trackIndex]) / groupSize);
+                const incremented = incrementTrack(next[trackIndex], change, trackType);
+                if (!incremented.ok) return incremented.error;
+                next[trackIndex] = incremented.value;
+                appliedChange += change;
+            }
+            return;
+        }
+        const reductions = getConstrainedGroupReductions(next, indices, constraints, -totalChange);
+        for (const [index, trackIndex] of indices.entries()){
+            const incremented = incrementTrack(next[trackIndex], -reductions[index], trackType);
+            if (!incremented.ok) return incremented.error;
+            next[trackIndex] = incremented.value;
+        }
+    };
+    const beforeError = resizeGroup(beforeTrackIndices, beforeConstraints, -delta);
+    if (beforeError) return {
+        error: beforeError,
+        ok: false
+    };
+    const afterError = resizeGroup(afterTrackIndices, afterConstraints, delta);
+    if (afterError) return {
+        error: afterError,
+        ok: false
+    };
+    return ok(transition(next, identitySources(tracks.length)));
+};
+const span = (start, end)=>({
+        end,
+        start
+    });
+const cloneItem = (item, { column, row })=>({
+        ...item,
+        column: column ? span(column.start, column.end) : item.column,
+        row: row ? span(row.start, row.end) : item.row
+    });
+const findGeometryItem = (geometry, itemId)=>geometry.items.find(({ id })=>id === itemId);
+const requireItem = (geometry, itemId)=>{
+    const item = findGeometryItem(geometry, itemId);
+    return item ? ok(item) : failure("ITEM_NOT_FOUND", `[GridModel] GridItem #${itemId} not found`);
+};
+const applyGeometryUpdates = (geometry, updates)=>{
+    if (0 === updates.length) return geometry;
+    const updatesById = new Map();
+    const addUpdate = (update)=>{
+        const existing = updatesById.get(update.id);
+        updatesById.set(update.id, existing ? {
+            ...existing,
+            ...update
+        } : update);
+    };
+    for (const update of updates){
+        addUpdate(update);
+        const item = findGeometryItem(geometry, update.id);
+        if (item?.type === "stacked-content") for (const { id } of stackedChildItems(geometry, update.id))addUpdate({
+            ...update,
+            id
+        });
+    }
+    return {
+        ...geometry,
+        items: geometry.items.map((item)=>{
+            const update = updatesById.get(item.id);
+            return update ? cloneItem(item, update) : item;
+        })
+    };
+};
+const applyGeometryAxisUpdates = (geometry, updates, axis)=>applyGeometryUpdates(geometry, updates.flatMap((update)=>update[axis] ? [
+            {
+                [axis]: update[axis],
+                id: update.id
+            }
+        ] : []));
+const withTracks = (geometry, trackType, tracks)=>"column" === trackType ? {
+        ...geometry,
+        columns: trackSizes(tracks)
+    } : {
+        ...geometry,
+        rows: trackSizes(tracks)
+    };
+const isFixedHeightItem = ({ resizeable })=>false === resizeable || void 0 === resizeable || "h" === resizeable;
+const isFixedWidthItem = ({ resizeable })=>false === resizeable || void 0 === resizeable || "v" === resizeable;
+const canSplitGridItem = (item, splitDirection)=>"east" === splitDirection || "west" === splitDirection ? !isFixedWidthItem(item) : !isFixedHeightItem(item);
+const gridResizeDirectionForSplit = (splitDirection)=>"north" === splitDirection || "south" === splitDirection ? "vertical" : "horizontal";
+const byColumnStart = (item1, item2)=>item1.column.start - item2.column.start;
+const byRowStart = (item1, item2)=>item1.row.start - item2.row.start;
+const positionComparator = (p1, p2)=>{
+    if (p1.start < p2.start) return -1;
+    if (p1.start > p2.start) return 1;
+    if (p1.end < p2.end) return -1;
+    if (p1.end > p2.end) return 1;
+    return 0;
+};
+const byColumnPosition = ({ column: pos1 }, { column: pos2 })=>positionComparator(pos1, pos2);
+const byRowPosition = ({ row: pos1 }, { row: pos2 })=>positionComparator(pos1, pos2);
+const itemsFillColumn = (items, pos)=>{
+    const sortedItems = [
+        ...items
+    ].sort(byColumnPosition);
+    const firstItem = sortedItems.at(0);
+    const lastItem = sortedItems.at(-1);
+    if (firstItem && lastItem) {
+        const { start } = firstItem.column;
+        const { end } = lastItem.column;
+        if (start === pos.start && end === pos.end) {
+            for(let i = 1; i < sortedItems.length; i++)if (sortedItems[i - 1].column.end !== sortedItems[i].column.start) return false;
+            return true;
+        }
+    }
+    return false;
+};
+const itemsFillRow = (items, pos)=>{
+    const sortedItems = [
+        ...items
+    ].sort(byRowPosition);
+    const firstItem = sortedItems.at(0);
+    const lastItem = sortedItems.at(-1);
+    if (firstItem && lastItem) {
+        const { start } = firstItem.row;
+        const { end } = lastItem.row;
+        if (start === pos.start && end === pos.end) {
+            for(let i = 1; i < sortedItems.length; i++)if (sortedItems[i - 1].row.end !== sortedItems[i].row.start) return false;
+            return true;
+        }
+    }
+    return false;
+};
+const findByColumnStart = (items, col)=>{
+    const matches = items.filter(({ column: { start } })=>start === col);
+    return 0 === matches.length ? void 0 : matches;
+};
+const findByColumnEnd = (items, col)=>{
+    const matches = items.filter(({ column: { end } })=>end === col);
+    return 0 === matches.length ? void 0 : matches;
+};
+const findByRowStart = (items, row)=>{
+    const matches = items.filter(({ row: { start } })=>start === row);
+    return 0 === matches.length ? void 0 : matches;
+};
+const findByRowEnd = (items, row)=>{
+    const matches = items.filter(({ row: { end } })=>end === row);
+    return 0 === matches.length ? void 0 : matches;
+};
+const stackedChildItems = (geometry, stackId)=>geometry.items.filter((item)=>item.stackId === stackId);
+const splitGridChildPosition = ({ column, row }, splitDirection, splitTrackIndex)=>{
+    const { start: colStart, end: colEnd } = column;
+    const { start: rowStart, end: rowEnd } = row;
+    switch(splitDirection){
+        case "north":
+            return [
+                {
+                    column: span(colStart, colEnd),
+                    row: span(rowStart, splitTrackIndex)
+                },
+                {
+                    column: span(colStart, colEnd),
+                    row: span(splitTrackIndex, rowEnd)
+                }
+            ];
+        case "east":
+            return [
+                {
+                    column: span(splitTrackIndex, colEnd),
+                    row: span(rowStart, rowEnd)
+                },
+                {
+                    column: span(colStart, splitTrackIndex),
+                    row: span(rowStart, rowEnd)
+                }
+            ];
+        case "south":
+            return [
+                {
+                    column: span(colStart, colEnd),
+                    row: span(splitTrackIndex, rowEnd)
+                },
+                {
+                    column: span(colStart, colEnd),
+                    row: span(rowStart, splitTrackIndex)
+                }
+            ];
+        case "west":
+            return [
+                {
+                    column: span(colStart, splitTrackIndex),
+                    row: span(rowStart, rowEnd)
+                },
+                {
+                    column: span(splitTrackIndex, colEnd),
+                    row: span(rowStart, rowEnd)
+                }
+            ];
+    }
+};
+const trackTransitionFor = (trackType, trackTransition)=>void 0 === trackTransition ? {} : "column" === trackType ? {
+        columns: trackTransition
+    } : {
+        rows: trackTransition
+    };
+const shiftItemsForNewTrack = (items, trackType, trackIndex)=>{
+    const gridPosition = trackIndex + 1;
+    const updates = [];
+    for (const item of items){
+        const { start, end } = item[trackType];
+        if (start > gridPosition) updates.push({
+            [trackType]: span(start + 1, end + 1),
+            id: item.id
+        });
+        else if (end > gridPosition) updates.push({
+            [trackType]: span(start, end + 1),
+            id: item.id
+        });
+    }
+    return updates;
+};
+const splitTargetUpdates = (geometry, droppedItemId, targetItemId, splitDirection, splitIndex, order)=>{
+    const targetItem = findGeometryItem(geometry, targetItemId);
+    if (void 0 === targetItem) return [];
+    const [droppedItemPosition, targetItemPosition] = splitGridChildPosition(targetItem, splitDirection, splitIndex);
+    const droppedUpdate = {
+        ...droppedItemPosition,
+        id: droppedItemId
+    };
+    const targetUpdate = {
+        ...targetItemPosition,
+        id: targetItemId
+    };
+    const updates = "target-first" === order ? [
+        targetUpdate,
+        droppedUpdate
+    ] : [
+        droppedUpdate,
+        targetUpdate
+    ];
+    if ("stacked-content" === targetItem.type) updates.push(...stackedChildItems(geometry, targetItemId).map(({ id })=>({
+            ...targetItemPosition,
+            id
+        })));
+    return updates;
+};
+const splitGridItem = (geometry, { droppedItemId, resizeDirection, splitDirection, targetItemId }, measurements = NO_MEASUREMENTS)=>{
+    const target = requireItem(geometry, targetItemId);
+    if (!target.ok) return target;
+    const droppedItem = requireItem(geometry, droppedItemId);
+    if (!droppedItem.ok) return droppedItem;
+    const targetGridItem = target.value;
+    if (!canSplitGridItem(targetGridItem, splitDirection)) return failure("NON_RESIZABLE", `Grid item #${targetItemId} cannot be split ${splitDirection}`);
+    const trackType = (resizeDirection ?? gridResizeDirectionForSplit(splitDirection)) === "vertical" ? "row" : "column";
+    const tracks = readTracks(geometryTracks(geometry, trackType), measurements[trackType]);
+    const resizeTrack = targetGridItem[trackType];
+    const splitAtNewTrack = (trackTransition, newTrackIndex, splitIndexFor)=>{
+        const silentUpdates = shiftItemsForNewTrack(geometry.items, trackType, newTrackIndex);
+        const accommodated = withTracks(applyGeometryUpdates(geometry, silentUpdates), trackType, trackTransition.tracks);
+        const updatedTarget = findGeometryItem(accommodated, targetItemId);
+        if (void 0 === updatedTarget) return failure("ITEM_NOT_FOUND", `[GridModel] GridItem #${targetItemId} not found`);
+        const updates = splitTargetUpdates(accommodated, droppedItemId, targetItemId, splitDirection, splitIndexFor(updatedTarget), "target-first");
+        return ok({
+            ...trackTransitionFor(trackType, trackTransition),
+            geometry: applyGeometryUpdates(accommodated, updates),
+            silentUpdates,
+            updates
+        });
+    };
+    if (resizeTrack.end - resizeTrack.start === 1) {
+        const newTrackIndex = resizeTrack.start - 1;
+        const trackTransition = splitTrack(tracks, newTrackIndex, trackType);
+        if (!trackTransition.ok) return trackTransition;
+        return splitAtNewTrack(trackTransition.value, newTrackIndex, (item)=>"row" === trackType ? item.row.end - 1 : item.column.end - 1);
+    }
+    const bisectingGridTrack = findBisectingTrack(tracks, resizeTrack.start, resizeTrack.end, trackType);
+    if (!bisectingGridTrack.ok) return bisectingGridTrack;
+    if (-1 !== bisectingGridTrack.value) {
+        const updates = splitTargetUpdates(geometry, droppedItemId, targetItemId, splitDirection, bisectingGridTrack.value, "dropped-first");
+        return ok({
+            geometry: applyGeometryUpdates(geometry, updates),
+            silentUpdates: [],
+            updates
+        });
+    }
+    const bisection = bisectTracks(tracks, resizeTrack.start, resizeTrack.end, trackType);
+    if (!bisection.ok) return bisection;
+    return splitAtNewTrack(bisection.value.transition, bisection.value.newTrackIndex, ()=>bisection.value.newTrackIndex + 2);
+};
+const replaceGridItem = (geometry, { droppedItemId, targetItemId })=>{
+    const dropped = requireItem(geometry, droppedItemId);
+    if (!dropped.ok) return dropped;
+    const target = requireItem(geometry, targetItemId);
+    if (!target.ok) return target;
+    const { column, row } = target.value;
+    const removals = [
+        {
+            id: targetItemId,
+            reason: "close"
+        }
+    ];
+    const silentUpdates = [
+        {
+            column,
+            id: droppedItemId,
+            row
+        }
+    ];
+    if ("stacked-content" === dropped.value.type) silentUpdates.push(...stackedChildItems(geometry, droppedItemId).map(({ id })=>({
+            column,
+            id,
+            row
+        })));
+    const next = applyGeometryUpdates({
+        ...geometry,
+        items: geometry.items.filter(({ id })=>id !== targetItemId)
+    }, silentUpdates);
+    return ok({
+        geometry: next,
+        removals,
+        silentUpdates,
+        updates: []
+    });
+};
+const findUnusedGridLines = (geometry)=>{
+    const colCount = geometry.columns.length;
+    const rowCount = geometry.rows.length;
+    const unusedStartPositions = [];
+    const unusedColLines = [];
+    const unusedRowLines = [];
+    const items = geometry.items.filter((item)=>!item.dragging);
+    for(let i = 1; i <= colCount; i++)if (!findByColumnStart(items, i)) unusedStartPositions.push(i);
+    for(let i = 2; i <= colCount + 1; i++)if (!findByColumnEnd(items, i) && unusedStartPositions.includes(i)) unusedColLines.push(i);
+    unusedStartPositions.length = 0;
+    for(let i = 1; i <= rowCount; i++)if (!findByRowStart(items, i)) unusedStartPositions.push(i);
+    for(let i = 2; i <= rowCount + 1; i++)if (!findByRowEnd(items, i) && unusedStartPositions.includes(i)) unusedRowLines.push(i);
+    return [
+        unusedColLines,
+        unusedRowLines
+    ];
+};
+const shiftItemsForInsertedTrack = (items, trackType, index, position)=>{
+    const gridPosition = index + 1;
+    const updates = [];
+    for (const item of items){
+        const { start, end } = item[trackType];
+        if ("before" === position) {
+            if (start >= gridPosition) updates.push({
+                [trackType]: span(start + 1, end + 1),
+                id: item.id
+            });
+            else if (end >= gridPosition) updates.push({
+                [trackType]: span(start, end + 1),
+                id: item.id
+            });
+        } else if (start > gridPosition) updates.push({
+            [trackType]: span(start + 1, end + 1),
+            id: item.id
+        });
+        else if (end > gridPosition) updates.push({
+            [trackType]: span(start, end + 1),
+            id: item.id
+        });
+    }
+    return updates;
+};
+const shiftItemsForRemovedTrack = (items, trackType, trackIndex)=>{
+    const gridPosition = trackIndex + 1;
+    const updates = [];
+    for (const item of items){
+        const { start, end } = item[trackType];
+        const nextStart = start > gridPosition ? start - 1 : start;
+        const nextEnd = end > gridPosition ? end - 1 : end;
+        if (nextStart !== start || nextEnd !== end) updates.push({
+            [trackType]: span(nextStart, nextEnd),
+            id: item.id
+        });
+    }
+    return updates;
+};
+const mergeUpdates = (target, additions)=>{
+    for (const update of additions){
+        const index = target.findIndex(({ id })=>id === update.id);
+        if (-1 === index) target.push(update);
+        else target[index] = {
+            ...target[index],
+            ...update
+        };
+    }
+};
+const updateContrasToOccupySpace = (geometry, { column, id, row })=>{
+    const { items } = geometry;
+    const adjacentItemsWithSameRowStart = findByRowStart(items, row.start)?.filter(({ column: { start, end }, stackId })=>void 0 === stackId && (end === column.start || start === column.end));
+    if (adjacentItemsWithSameRowStart) {
+        const itemsInSameRow = adjacentItemsWithSameRowStart.filter((item)=>item.row.end === row.end && item.id !== id);
+        if (1 === itemsInSameRow.length) {
+            const [itemInSameRow] = itemsInSameRow;
+            const { id: contraId, column: { start, end } } = itemInSameRow;
+            if (end === column.start || start === column.end) {
+                const nextColumn = end === column.start ? span(start, column.end) : span(column.start, end);
+                const updates = [
+                    {
+                        column: nextColumn,
+                        id: contraId
+                    }
+                ];
+                if ("stacked-content" === itemInSameRow.type) updates.push(...stackedChildItems(geometry, itemInSameRow.id).map(({ id: stackedId })=>({
+                        column: nextColumn,
+                        id: stackedId
+                    })));
+                return [
+                    updates,
+                    []
+                ];
+            }
+        } else if (2 === itemsInSameRow.length) {
+            const adjacentBefore = itemsInSameRow.filter((item)=>item.column.end === column.start);
+            if (1 === adjacentBefore.length) {
+                const { id: contraId, column: { start } } = adjacentBefore[0];
+                return [
+                    [
+                        {
+                            column: span(start, column.end),
+                            id: contraId
+                        }
+                    ],
+                    []
+                ];
+            }
+            const adjacentAfter = itemsInSameRow.filter((item)=>item.column.start === column.end);
+            if (1 === adjacentAfter.length) {
+                const { id: contraId, column: { end } } = adjacentAfter[0];
+                return [
+                    [
+                        {
+                            column: span(column.start, end),
+                            id: contraId
+                        }
+                    ],
+                    []
+                ];
+            }
+        } else if (row.end - row.start > 1) {
+            const itemsEndingWhereTargetStarts = findByColumnEnd(items, column.start)?.filter((item)=>void 0 === item.stackId && item.row.start >= row.start && item.row.end <= row.end);
+            if (itemsEndingWhereTargetStarts && itemsFillRow(itemsEndingWhereTargetStarts, row)) return [
+                itemsEndingWhereTargetStarts.map(({ id: contraId, column: { start } })=>({
+                        column: span(start, column.end),
+                        id: contraId
+                    })),
+                []
+            ];
+            const itemsStartingWhereTargetEnds = findByColumnStart(items, column.end)?.filter((item)=>void 0 === item.stackId && item.row.start >= row.start && item.row.end <= row.end);
+            if (itemsStartingWhereTargetEnds && itemsFillRow(itemsStartingWhereTargetEnds, row)) return [
+                itemsStartingWhereTargetEnds.map(({ id: contraId, column: { end } })=>({
+                        column: span(column.start, end),
+                        id: contraId
+                    })),
+                []
+            ];
+        }
+    }
+    const adjacentItemsWithSameColumnStart = findByColumnStart(items, column.start)?.filter(({ row: { start, end }, stackId })=>void 0 === stackId && (end === row.start || start === row.end));
+    if (adjacentItemsWithSameColumnStart) {
+        const itemsInSameColumn = adjacentItemsWithSameColumnStart.filter((item)=>item.column.end === column.end && item.id !== id);
+        if (1 === itemsInSameColumn.length) {
+            const [itemInSameColumn] = itemsInSameColumn;
+            const { id: contraId, row: { start, end } } = itemInSameColumn;
+            if (end === row.start || start === row.end) {
+                const nextRow = end === row.start ? span(start, row.end) : span(row.start, end);
+                const updates = [
+                    {
+                        id: contraId,
+                        row: nextRow
+                    }
+                ];
+                if ("stacked-content" === itemInSameColumn.type) updates.push(...stackedChildItems(geometry, itemInSameColumn.id).map(({ id: stackedId })=>({
+                        id: stackedId,
+                        row: nextRow
+                    })));
+                return [
+                    [],
+                    updates
+                ];
+            }
+        } else if (2 === itemsInSameColumn.length) {
+            const adjacentBefore = itemsInSameColumn.filter((item)=>item.row.end === row.start);
+            if (1 === adjacentBefore.length) {
+                const { id: contraId, row: { start } } = adjacentBefore[0];
+                return [
+                    [
+                        {
+                            id: contraId,
+                            row: span(start, row.end)
+                        }
+                    ],
+                    []
+                ];
+            }
+            const adjacentAfter = itemsInSameColumn.filter((item)=>item.row.start === row.end);
+            if (1 === adjacentAfter.length) {
+                const { id: contraId, row: { end } } = adjacentAfter[0];
+                return [
+                    [
+                        {
+                            id: contraId,
+                            row: span(row.start, end)
+                        }
+                    ],
+                    []
+                ];
+            }
+        } else if (column.end - column.start > 1) {
+            const itemsEndingWhereTargetStarts = findByRowEnd(items, row.start)?.filter((item)=>item.column.start >= column.start && item.column.end <= column.end);
+            if (itemsEndingWhereTargetStarts && itemsFillColumn(itemsEndingWhereTargetStarts, column)) return [
+                [],
+                itemsEndingWhereTargetStarts.map(({ id: contraId, row: { start } })=>({
+                        id: contraId,
+                        row: span(start, row.end)
+                    }))
+            ];
+            const itemsStartingWhereTargetEnds = findByRowStart(items, row.end)?.filter((item)=>item.column.start >= column.start && item.column.end <= column.end);
+            if (itemsStartingWhereTargetEnds && itemsFillColumn(itemsStartingWhereTargetEnds, column)) return [
+                [],
+                itemsStartingWhereTargetEnds.map(({ id: contraId, row: { end } })=>({
+                        id: contraId,
+                        row: span(row.start, end)
+                    }))
+            ];
+        }
+    }
+    return [
+        [],
+        []
+    ];
+};
+const removeGridItem = (geometry, { itemId, reason }, { createPlaceholderId, measurements = NO_MEASUREMENTS })=>{
+    const target = requireItem(geometry, itemId);
+    if (!target.ok) return target;
+    const gridItem = target.value;
+    const removals = [
+        {
+            id: itemId,
+            reason
+        }
+    ];
+    let current = "drag" === reason ? {
+        ...geometry,
+        items: geometry.items.map((item)=>item.id === itemId ? {
+                ...item,
+                dragging: true
+            } : item)
+    } : {
+        ...geometry,
+        items: geometry.items.filter(({ id })=>id !== itemId)
+    };
+    if (gridItem.stackId) return ok({
+        geometry: current,
+        notify: false,
+        removals,
+        silentUpdates: [],
+        stackMember: true,
+        updates: []
+    });
+    const [colItemUpdates, rowItemUpdates] = updateContrasToOccupySpace(current, gridItem);
+    current = applyGeometryAxisUpdates(current, colItemUpdates, "column");
+    current = applyGeometryAxisUpdates(current, rowItemUpdates, "row");
+    const [unusedColLines, unusedRowLines] = findUnusedGridLines(current);
+    let columnTracks = readTracks(current.columns, measurements.column);
+    let rowTracks = readTracks(current.rows, measurements.row);
+    let columns;
+    let rows;
+    for (const line of [
+        ...unusedColLines
+    ].sort((a, b)=>b - a)){
+        const shifts = shiftItemsForRemovedTrack(current.items, "column", line - 1);
+        mergeUpdates(colItemUpdates, shifts);
+        current = applyGeometryUpdates(current, shifts);
+        const removed = removeTrack(columnTracks, line - 1, "bwd", "column");
+        if (!removed.ok) return removed;
+        columnTracks = removed.value.tracks;
+        columns = composeTransitions(columns, removed.value);
+        current = withTracks(current, "column", columnTracks);
+    }
+    for (const line of [
+        ...unusedRowLines
+    ].sort((a, b)=>b - a)){
+        const shifts = shiftItemsForRemovedTrack(current.items, "row", line - 1);
+        mergeUpdates(rowItemUpdates, shifts);
+        current = applyGeometryUpdates(current, shifts);
+        const removed = removeTrack(rowTracks, line - 1, "bwd", "row");
+        if (!removed.ok) return removed;
+        rowTracks = removed.value.tracks;
+        rows = composeTransitions(rows, removed.value);
+        current = withTracks(current, "row", rowTracks);
+    }
+    const notify = colItemUpdates.length > 0 || rowItemUpdates.length > 0 || unusedColLines.length > 0 || unusedRowLines.length > 0;
+    const transitionResult = {
+        ...columns ? {
+            columns
+        } : {},
+        ...rows ? {
+            rows
+        } : {},
+        geometry: current,
+        notify,
+        removals,
+        silentUpdates: [],
+        stackMember: false,
+        updates: [
+            ...colItemUpdates,
+            ...rowItemUpdates
+        ]
+    };
+    if ("placeholder" === reason) return ok(transitionResult);
+    const placeholders = regeneratePlaceholders(current, createPlaceholderId);
+    return ok({
+        ...transitionResult,
+        geometry: placeholders.geometry,
+        placeholders: {
+            added: placeholders.added,
+            removedIds: placeholders.removedIds
+        }
+    });
+};
+const rowCellsAllEmpty = (fromIndex, toIndex, row)=>{
+    if (!row) return false;
+    for(let i = fromIndex; i < toIndex; i++)if (0 !== row[i]) return false;
+    return true;
+};
+const getGridMatrix = (items, rowCount, colCount)=>{
+    const grid = Array.from({
+        length: rowCount
+    }, ()=>new Array(colCount).fill(0));
+    for (const { column: { start: colStart, end: colEnd }, row: { start: rowStart, end: rowEnd } } of items)for(let row = rowStart - 1; row < rowEnd - 1; row++)for(let col = colStart - 1; col < colEnd - 1; col++)if (grid[row]?.[col] !== void 0) grid[row][col] += 1;
+    return grid;
+};
+const regeneratePlaceholders = (geometry, createPlaceholderId)=>{
+    const removedIds = geometry.items.filter(({ type })=>"placeholder" === type).map(({ id })=>id);
+    const items = geometry.items.filter(({ type })=>"placeholder" !== type);
+    const grid = getGridMatrix(items.filter(({ dragging })=>!dragging), geometry.rows.length, geometry.columns.length);
+    const added = [];
+    for(let i = 0; i < grid.length; i++){
+        const cols = grid[i];
+        for(let j = 0; j < cols.length; j++)if (0 === cols[j]) {
+            cols[j] = 1;
+            let nextRow = i + 1;
+            let nextCol = j + 1;
+            while(0 === cols[nextCol]){
+                cols[nextCol] = 1;
+                nextCol += 1;
+            }
+            while(rowCellsAllEmpty(j, nextCol, grid[nextRow])){
+                for(let col = j; col < nextCol; col++)grid[nextRow][col] = 1;
+                nextRow += 1;
+            }
+            added.push({
+                column: span(j + 1, nextCol + 1),
+                id: createPlaceholderId(),
+                resizeable: "hv",
+                row: span(i + 1, nextRow + 1),
+                type: "placeholder"
+            });
+        }
+    }
+    return {
+        added,
+        geometry: {
+            ...geometry,
+            items: [
+                ...items,
+                ...added
+            ]
+        },
+        removedIds
+    };
+};
+const getMatchingColspan = (targetGridItem, siblings, contras)=>{
+    const startCol = targetGridItem.column.start;
+    let siblingIndex = 0;
+    let contraIndex = 0;
+    const contrasOut = [];
+    const siblingsOut = [
+        targetGridItem
+    ];
+    const targetAndSiblings = [
+        targetGridItem,
+        ...siblings
+    ];
+    while(siblingIndex < targetAndSiblings.length && contraIndex < contras.length){
+        const sibling = targetAndSiblings[siblingIndex];
+        const contra = contras[contraIndex];
+        const end = Math.max(contra.column.end, sibling.column.end);
+        if (contra.column.end === end && sibling.column.end === end) {
+            contrasOut.push(contras[contraIndex]);
+            return {
+                contras: contrasOut,
+                position: span(startCol, end),
+                siblings: siblingsOut
+            };
+        }
+        if (contra.column.end < end) {
+            contrasOut.push(contras[contraIndex]);
+            contraIndex += 1;
+        } else {
+            siblingsOut.push(siblings[siblingIndex]);
+            siblingIndex += 1;
+        }
+    }
+};
+const getMatchingRowspan = (gridItem, siblings, contras)=>{
+    const startRow = gridItem.row.start;
+    let siblingIndex = 0;
+    let contraIndex = 0;
+    const contrasOut = [];
+    const siblingsOut = [
+        gridItem
+    ];
+    const targetAndSiblings = [
+        gridItem,
+        ...siblings
+    ];
+    while(siblingIndex < targetAndSiblings.length && contraIndex < contras.length){
+        const sibling = targetAndSiblings[siblingIndex];
+        const contra = contras[contraIndex];
+        const end = Math.max(contra.row.end, sibling.row.end);
+        if (contra.row.end === end && sibling.row.end === end) {
+            contrasOut.push(contras[contraIndex]);
+            return {
+                contras: contrasOut,
+                position: span(startRow, end),
+                siblings: siblingsOut
+            };
+        }
+        if (contra.row.end < end) {
+            contrasOut.push(contras[contraIndex]);
+            contraIndex += 1;
+        } else {
+            siblingsOut.push(siblings[siblingIndex]);
+            siblingIndex += 1;
+        }
+    }
+};
+const getContrasAbove = (items, { column, row })=>{
+    const allContrasAbove = findByRowEnd(items, row.start);
+    if (allContrasAbove) {
+        const indexOfAlignedContra = allContrasAbove.findIndex((item)=>item.column.start === column.start);
+        if (-1 !== indexOfAlignedContra) return [
+            ...allContrasAbove
+        ].sort(byColumnStart).slice(indexOfAlignedContra);
+    }
+    return [];
+};
+const getContrasBelow = (items, { column, row })=>{
+    const allContrasBelow = findByRowStart(items, row.end);
+    if (allContrasBelow) {
+        const indexOfAlignedContra = allContrasBelow.findIndex((item)=>item.column.start === column.start);
+        if (-1 !== indexOfAlignedContra) return [
+            ...allContrasBelow
+        ].sort(byColumnStart).slice(indexOfAlignedContra);
+    }
+    return [];
+};
+const getSiblingsRight = (items, { column, row })=>findByRowStart(items, row.start)?.filter((item)=>item.column.start > column.start) ?? [];
+const getContrasLeft = (items, { column, row })=>{
+    const allContrasLeft = findByColumnEnd(items, column.start);
+    if (allContrasLeft) {
+        const indexOfAlignedContra = allContrasLeft.findIndex((item)=>item.row.start === row.start);
+        if (-1 !== indexOfAlignedContra) return [
+            ...allContrasLeft
+        ].sort(byRowStart).slice(indexOfAlignedContra);
+    }
+    return [];
+};
+const getSiblingsBelow = (items, { column, row })=>findByColumnStart(items, column.start)?.filter((item)=>item.row.start > row.start) ?? [];
+const findColumnContrasAndSiblings = (items, childItem)=>{
+    const contrasLeft = getContrasLeft(items, childItem);
+    if (contrasLeft.length > 0) return getMatchingRowspan(childItem, getSiblingsBelow(items, childItem), contrasLeft);
+};
+const findRowContrasAndSiblings = (items, childItem)=>{
+    const contrasAbove = getContrasAbove(items, childItem);
+    if (contrasAbove.length > 0) if (!isFixedHeightItem(childItem)) return getMatchingColspan(childItem, getSiblingsRight(items, childItem), contrasAbove);
+    else {
+        const contrasBelow = getContrasBelow(items, childItem);
+        if (contrasBelow.length > 0) {
+            const [contra] = contrasBelow;
+            return getMatchingColspan(contra, getSiblingsRight(items, contra), contrasAbove);
+        }
+    }
+};
+const computeSplitters = (geometry)=>{
+    const { items } = geometry;
+    const layoutItems = items.filter(({ stackId })=>void 0 === stackId);
+    const splitters = [];
+    const horizontalSplitterItemIds = [];
+    const verticalSplitterItemIds = [];
+    for (const childItem of layoutItems){
+        const { column, id, row } = childItem;
+        if (!isFixedWidthItem(childItem)) {
+            const columnContrasAndSiblings = findColumnContrasAndSiblings(layoutItems, childItem);
+            if (columnContrasAndSiblings) {
+                const resizeTrackIndex = column.start - 1;
+                const contraTrackIndex = column.start - 2;
+                columnContrasAndSiblings.siblings.forEach((sibling)=>{
+                    verticalSplitterItemIds.push(sibling.id);
+                });
+                splitters.push({
+                    align: "start",
+                    ariaOrientation: "vertical",
+                    column,
+                    controls: id,
+                    id: `${id}-splitter-h`,
+                    orientation: "horizontal",
+                    resizedChildItems: {
+                        after: columnContrasAndSiblings.siblings.map((c)=>c.id),
+                        before: columnContrasAndSiblings.contras.map((c)=>c.id)
+                    },
+                    resizedGridTracks: [
+                        contraTrackIndex,
+                        resizeTrackIndex
+                    ],
+                    row: columnContrasAndSiblings.position
+                });
+            }
+        }
+        if (!isFixedHeightItem(childItem)) {
+            const rowContrasAndSiblings = findRowContrasAndSiblings(layoutItems, childItem);
+            if (rowContrasAndSiblings) {
+                const contraTrackIndex = row.start - 2;
+                let resizeTrackIndex = row.start - 1;
+                if (rowContrasAndSiblings.siblings[0].id !== childItem.id) resizeTrackIndex = rowContrasAndSiblings.siblings[0].row.start - 1;
+                rowContrasAndSiblings.siblings.forEach((sibling)=>{
+                    horizontalSplitterItemIds.push(sibling.id);
+                });
+                splitters.push({
+                    align: "start",
+                    ariaOrientation: "horizontal",
+                    column: rowContrasAndSiblings.position,
+                    controls: id,
+                    id: `${id}-splitter-v`,
+                    orientation: "vertical",
+                    resizedChildItems: {
+                        after: rowContrasAndSiblings.siblings.map((c)=>c.id),
+                        before: rowContrasAndSiblings.contras.map((c)=>c.id)
+                    },
+                    resizedGridTracks: [
+                        contraTrackIndex,
+                        resizeTrackIndex
+                    ],
+                    row
+                });
+            }
+        }
+    }
+    return {
+        horizontalSplitterItemIds,
+        splitters,
+        verticalSplitterItemIds
+    };
+};
+const doesResizeRequireNewTrack = (splitters, splitter)=>{
+    const potentialCandidates = splitters.filter(({ id, orientation })=>orientation === splitter.orientation && id !== splitter.id);
+    if (potentialCandidates.length > 0) {
+        const track = "horizontal" === splitter.orientation ? "column" : "row";
+        const splitterStart = splitter[track].start;
+        return potentialCandidates.some(({ [track]: { start } })=>start === splitterStart);
+    }
+    return false;
+};
+const insertTrackForResize = (geometry, { contraItemIds, index, position, resizeItemIds, size, trackType }, measurements = NO_MEASUREMENTS)=>{
+    const tracks = readTracks(geometryTracks(geometry, trackType), measurements[trackType]);
+    const inserted = insertTrack(tracks, {
+        index,
+        position
+    }, size, trackType);
+    if (!inserted.ok) return inserted;
+    const insertUpdates = shiftItemsForInsertedTrack(geometry.items, trackType, index, position);
+    let current = applyGeometryUpdates(geometry, insertUpdates);
+    if (inserted.value) current = withTracks(current, trackType, inserted.value.tracks);
+    const adjustment = "before" === position ? -1 : 1;
+    const anchorUpdates = [];
+    for (const id of resizeItemIds){
+        const item = findGeometryItem(current, id);
+        if (void 0 === item) return failure("ITEM_NOT_FOUND", `[GridModel] GridItem #${id} not found`);
+        const { start, end } = item[trackType];
+        anchorUpdates.push({
+            [trackType]: span(start + adjustment, end),
+            id
+        });
+    }
+    for (const id of contraItemIds){
+        const item = findGeometryItem(current, id);
+        if (void 0 === item) return failure("ITEM_NOT_FOUND", `[GridModel] GridItem #${id} not found`);
+        const { start, end } = item[trackType];
+        anchorUpdates.push({
+            [trackType]: span(start, end + adjustment),
+            id
+        });
+    }
+    return ok({
+        ...trackTransitionFor(trackType, inserted.value),
+        anchorUpdates,
+        geometry: applyGeometryUpdates(current, anchorUpdates),
+        insertUpdates
+    });
+};
+const removeGridTrack = (geometry, { assignDirection, trackIndex, trackType, updateItems = true }, measurements = NO_MEASUREMENTS)=>{
+    const tracks = readTracks(geometryTracks(geometry, trackType), measurements[trackType]);
+    const removed = removeTrack(tracks, trackIndex, assignDirection, trackType);
+    if (!removed.ok) return removed;
+    const updates = updateItems ? shiftItemsForRemovedTrack(geometry.items, trackType, trackIndex) : [];
+    return ok({
+        ...trackTransitionFor(trackType, removed.value),
+        geometry: withTracks(applyGeometryUpdates(geometry, updates), trackType, removed.value.tracks),
+        silentUpdates: [],
+        updates
+    });
+};
+export { NO_MEASUREMENTS, NO_TRACK_METRICS, applyGeometryUpdates, bisectTracks, canSplitGridItem, computeSplitters, doesResizeRequireNewTrack, findBisectingTrack, findGeometryItem, findUnusedGridLines, geometryTracks, getGridMatrix, getProportionalResizeAllowance, gridResizeDirectionForSplit, insertTrack, insertTrackForResize, isFixedHeightItem, isFixedWidthItem, isFractionTrackSize, isPixelTrackSize, itemsFillColumn, itemsFillRow, readTracks, regeneratePlaceholders, removeGridItem, removeGridTrack, removeTrack, replaceGridItem, resizeTrackTo, resizeTracksAdjacent, resizeTracksProportionally, shiftItemsForInsertedTrack, shiftItemsForNewTrack, shiftItemsForRemovedTrack, splitGridChildPosition, splitGridItem, splitTrack, trackMetrics, trackSizes };