ducjs 1.0.0

package/dist/legacy/v1/utils/restore.js

@@ -0,0 +1,1255 @@
+import { isElbowArrow, isLinearElement, isTextElement } from "ducjs/legacy/v1/types/elements/typeChecks";
+import { arrayToMap, getUpdatedTimestamp, isFiniteNumber, updateActiveTool, } from "ducjs/legacy/v1/utils";
+import { getContainerElement } from "ducjs/legacy/v1/utils/bounds";
+import { BEZIER_MIRRORING, BLENDING, DEFAULT_ELEMENT_PROPS, DEFAULT_ELLIPSE_ELEMENT, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FREEDRAW_ELEMENT, DEFAULT_POLYGON_SIDES, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, DEFAULT_ZOOM_STEP, ELEMENT_CONTENT_PREFERENCE, ELEMENT_SUBSET, FONT_FAMILY, IMAGE_STATUS, LINE_CONFIRM_THRESHOLD, LINE_HEAD, MAX_ZOOM_STEP, MIN_ZOOM_STEP, STROKE_CAP, STROKE_JOIN, STROKE_PLACEMENT, STROKE_PREFERENCE, STROKE_SIDE_PREFERENCE, TEXT_ALIGN, VERTICAL_ALIGN } from "ducjs/legacy/v1/utils/constants";
+import { bumpVersion, getDefaultStackProperties, getNonDeletedElements, isInvisiblySmallElement, migratePoints } from "ducjs/legacy/v1/utils/elements";
+import { getNormalizedPoints, mergeOverlappingPoints, validateClosedPath } from "ducjs/legacy/v1/utils/elements/linearElement";
+import { detectLineHeight, refreshTextDimensions } from "ducjs/legacy/v1/utils/elements/textElement";
+import { getSizeFromPoints } from "ducjs/legacy/v1/utils/math";
+import { randomId } from "ducjs/legacy/v1/utils/math/random";
+import { getPrecisionScope, ScaleFactors } from "ducjs/legacy/v1/utils/measurements";
+import { getNormalizedDimensions, getNormalizedGridSize, getNormalizedGridStep, getNormalizedZoom, normalizeFixedPoint, } from "ducjs/legacy/v1/utils/normalize";
+import { getPrecisionValueFromRaw, getPrecisionValueFromScoped, getScaledZoomValueForScope, getScopedBezierPointFromDucPoint, getScopedZoomValue, NEUTRAL_SCOPE } from "ducjs/legacy/v1/utils/scopes";
+import { DESIGN_STANDARD } from "ducjs/legacy/v1/utils/standards";
+import { getDefaultDucState } from "ducjs/legacy/v1/utils/state";
+import { normalizeLink } from "ducjs/legacy/v1/utils/url";
+import tinycolor from "tinycolor2";
+export const AllowedDucActiveTools = {
+    selection: true,
+    text: true,
+    rectangle: true,
+    polygon: true,
+    ellipse: true,
+    line: true,
+    image: true,
+    arrow: true,
+    freedraw: true,
+    eraser: false,
+    custom: true,
+    frame: true,
+    embeddable: true,
+    hand: true,
+    laser: false,
+    ruler: false,
+    magicframe: false,
+    lasso: true,
+    table: true,
+};
+export const isValidElementScopeValue = (value, appState) => {
+    var _a;
+    // Only check if the provided value is valid
+    if (value !== undefined && Object.keys(ScaleFactors).includes(value)) {
+        return value;
+    }
+    return (_a = appState === null || appState === void 0 ? void 0 : appState.mainScope) !== null && _a !== void 0 ? _a : NEUTRAL_SCOPE;
+};
+export const isValidAppStateScopeValue = (value) => {
+    // Only check if the provided value is valid
+    if (value !== undefined && Object.keys(ScaleFactors).includes(value)) {
+        return value;
+    }
+    return NEUTRAL_SCOPE;
+};
+export const isValidAppStateScopeExponentThresholdValue = (value, defaultValue) => {
+    const finite = isValidFinitePositiveByteValue(value, defaultValue);
+    if (finite >= 1 && finite <= 36) {
+        return finite;
+    }
+    return defaultValue;
+};
+export const isValidPrecisionScopeValue = (zoom, mainScope, scopeExponentThreshold) => {
+    return getPrecisionScope(zoom, mainScope, scopeExponentThreshold);
+};
+const createHeadOnlyBinding = (head, currentScope) => {
+    return {
+        elementId: "",
+        focus: 0,
+        gap: getPrecisionValueFromRaw(0, currentScope, currentScope),
+        fixedPoint: null,
+        point: null,
+        head: isValidLineHeadValue(head),
+    };
+};
+const restoreElementWithProperties = (element, extra, appState) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const _element = Object.assign(Object.assign({}, element), extra);
+    const elementScope = isValidElementScopeValue(_element.scope, appState);
+    const currentScope = isValidElementScopeValue(appState === null || appState === void 0 ? void 0 : appState.scope, appState);
+    // Handle legacy stroke properties first
+    let stroke = [DEFAULT_ELEMENT_PROPS.stroke];
+    if (_element.strokeColor) {
+        // Legacy strokeColor property
+        stroke = [Object.assign(Object.assign({}, DEFAULT_ELEMENT_PROPS.stroke), { content: validateDeprecatedElementContent(_element.strokeColor, DEFAULT_ELEMENT_PROPS.stroke.content), width: restorePrecisionValue((_element.strokeWidth) || DEFAULT_ELEMENT_PROPS.stroke.width.value, elementScope, currentScope, DEFAULT_ELEMENT_PROPS.stroke.width.value) })];
+    }
+    else if (_element.stroke) {
+        // New stroke array property
+        stroke = _element.stroke.map(s => validateStroke(s, elementScope, currentScope));
+    }
+    // Handle legacy background properties
+    let background = [DEFAULT_ELEMENT_PROPS.background];
+    if (_element.backgroundColor) {
+        // Legacy backgroundColor property
+        background = [Object.assign(Object.assign({}, DEFAULT_ELEMENT_PROPS.background), { content: validateDeprecatedElementContent(_element.backgroundColor, DEFAULT_ELEMENT_PROPS.background.content) })];
+    }
+    else if (_element.background) {
+        // New background array property
+        background = _element.background.map(bg => validateBackground(bg));
+    }
+    const base = {
+        type: _element.type,
+        id: _element.id || randomId(),
+        version: _element.version || 1,
+        versionNonce: (_a = _element.versionNonce) !== null && _a !== void 0 ? _a : 0,
+        index: (_b = _element.index) !== null && _b !== void 0 ? _b : null,
+        isDeleted: isValidBoolean(_element.isDeleted, false),
+        blending: isValidBlendingValue(_element.blending),
+        stroke,
+        background,
+        opacity: isValidPercentageValue(_element.opacity, DEFAULT_ELEMENT_PROPS.opacity),
+        angle: isValidRadianValue(_element.angle, DEFAULT_ELEMENT_PROPS.angle),
+        x: restorePrecisionValue(_element.x, elementScope, currentScope, 0),
+        y: restorePrecisionValue(_element.y, elementScope, currentScope, 0),
+        scope: elementScope,
+        subset: isValidSubsetValue(_element.subset),
+        label: (_c = _element.label) !== null && _c !== void 0 ? _c : "Lost Element Label",
+        isVisible: isValidBoolean(_element.isVisible, DEFAULT_ELEMENT_PROPS.isVisible),
+        width: restorePrecisionValue(_element.width, elementScope, currentScope, 0),
+        height: restorePrecisionValue(_element.height, elementScope, currentScope, 0),
+        seed: (_d = _element.seed) !== null && _d !== void 0 ? _d : 1,
+        groupIds: (_e = _element.groupIds) !== null && _e !== void 0 ? _e : [],
+        frameId: (_f = _element.frameId) !== null && _f !== void 0 ? _f : null,
+        roundness: restorePrecisionValue(_element.roundness, elementScope, currentScope, DEFAULT_ELEMENT_PROPS.roundness.value),
+        boundElements: (_g = _element.boundElements) !== null && _g !== void 0 ? _g : [],
+        updated: (_h = _element.updated) !== null && _h !== void 0 ? _h : getUpdatedTimestamp(),
+        link: _element.link ? normalizeLink(_element.link) : null,
+        locked: isValidBoolean(_element.locked, false),
+    };
+    if ("customData" in element || "customData" in extra) {
+        base.customData = _element.customData;
+    }
+    const normalizedRaw = getNormalizedDimensions(base);
+    const normalized = {
+        x: restorePrecisionValue(normalizedRaw.x, elementScope, currentScope, 0, true),
+        y: restorePrecisionValue(normalizedRaw.y, elementScope, currentScope, 0, true),
+        width: restorePrecisionValue(normalizedRaw.width, elementScope, currentScope, 0, true),
+        height: restorePrecisionValue(normalizedRaw.height, elementScope, currentScope, 0, true),
+    };
+    return Object.assign(Object.assign(Object.assign({}, _element), base), normalized);
+};
+const restoreElement = (element, currentScope, appState) => {
+    var _a, _b;
+    // Migration: convert deprecated 'diamond' to 'polygon' with 4 sides
+    if (element.type === "diamond") {
+        const migrated = Object.assign(Object.assign({}, element), { type: "polygon", sides: 4 });
+        return restoreElement(migrated, currentScope, appState);
+    }
+    switch (element.type) {
+        case "text": {
+            let fontSize = element.fontSize;
+            let fontFamily = element.fontFamily;
+            if ("font" in element) {
+                try {
+                    const fontParts = String(element.font).split(" ");
+                    if (fontParts.length === 2) {
+                        const [fontSizeStr, fontFamilyName] = fontParts;
+                        const parsedSize = parseFloat(fontSizeStr);
+                        if (!isNaN(parsedSize) && Number.isFinite(parsedSize)) {
+                            fontSize = parsedSize;
+                            fontFamily = getFontFamilyByName(fontFamilyName);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("Failed to parse legacy font value:", error);
+                    fontSize = DEFAULT_FONT_SIZE;
+                    fontFamily = DEFAULT_FONT_FAMILY;
+                }
+            }
+            const text = (typeof element.text === "string" && element.text) || "";
+            const lineHeight = element.lineHeight && Number.isFinite(element.lineHeight)
+                ? element.lineHeight
+                : element.height && Number.isFinite(element.height)
+                    ? detectLineHeight(element)
+                    // : getLineHeight(element.fontFamily);
+                    : 1; // FIXME: We need better handling to get the font line height
+            const textElementScope = isValidElementScopeValue(element.scope, appState);
+            const finalFontSize = restorePrecisionValue(fontSize, textElementScope, currentScope, DEFAULT_FONT_SIZE);
+            const textElement = restoreElementWithProperties(element, {
+                fontSize: finalFontSize,
+                fontFamily,
+                text,
+                textAlign: isValidTextAlignValue(element.textAlign),
+                verticalAlign: isValidVerticalAlignValue(element.verticalAlign),
+                containerId: (_a = element.containerId) !== null && _a !== void 0 ? _a : null,
+                originalText: element.originalText || text,
+                autoResize: isValidBoolean(element.autoResize, true),
+                lineHeight,
+            }, appState);
+            // if empty text, mark as deleted. We keep in array
+            // for data integrity purposes (collab etc.)
+            if (!text && !isValidBoolean(element.isDeleted, false)) {
+                element = Object.assign(Object.assign({}, element), { originalText: text, isDeleted: true });
+                element = bumpVersion(element);
+            }
+            return textElement;
+        }
+        case "freedraw": {
+            const elementScope = isValidElementScopeValue(element.scope, appState);
+            const points = restoreElementPoints({
+                points: element.points,
+                x: element.x,
+                y: element.y,
+                width: element.width,
+                height: element.height,
+                elementScope,
+                currentScope,
+            });
+            return restoreElementWithProperties(element, {
+                points,
+                size: restorePrecisionValue(element.size, elementScope, currentScope, DEFAULT_FREEDRAW_ELEMENT.size),
+                lastCommittedPoint: element.lastCommittedPoint
+                    ? restorePoint(element.lastCommittedPoint, elementScope, currentScope)
+                    : null,
+                simulatePressure: isValidBoolean(element.simulatePressure, false),
+                pressures: Array.isArray(element.pressures) ? element.pressures : [],
+                thinning: isValidPercentageValue(element.thinning, DEFAULT_FREEDRAW_ELEMENT.thinning, true),
+                smoothing: isValidPercentageValue(element.smoothing, DEFAULT_FREEDRAW_ELEMENT.smoothing),
+                streamline: isValidPercentageValue(element.streamline, DEFAULT_FREEDRAW_ELEMENT.streamline),
+                easing: isValidFreeDrawEasingValue(element.easing),
+                start: restoreFreeDrawEnds(element.start),
+                end: restoreFreeDrawEnds(element.end),
+            }, appState);
+        }
+        case "image":
+            return restoreElementWithProperties(element, {
+                status: isValidImageStatusValue(element.status),
+                fileId: element.fileId,
+                scale: isValidImageScaleValue(element.scale),
+            }, appState);
+        case "line": {
+            // Don't normalize points if there are bindings
+            const hasBindings = !!(element.startBinding || element.endBinding);
+            const elementScope = isValidElementScopeValue(element.scope, appState);
+            const { points, lines } = restoreLinearElementPointsAndLines({
+                points: element.points,
+                lines: element.lines,
+                x: element.x,
+                y: element.y,
+                width: element.width,
+                height: element.height,
+                elementScope,
+                currentScope,
+                skipNormalization: hasBindings,
+            });
+            const isEditing = false; // TODO: Handle editingLinearElement properly
+            let finalPoints = points;
+            // Ensure we have at least 2 points for visibility check
+            if (finalPoints.length < 2 && !isEditing) {
+                const elementWidth = restorePrecisionValue(element.width, elementScope, currentScope, 0);
+                const elementHeight = restorePrecisionValue(element.height, elementScope, currentScope, 0);
+                finalPoints = [
+                    {
+                        x: getPrecisionValueFromRaw(0, elementScope, currentScope),
+                        y: getPrecisionValueFromRaw(0, elementScope, currentScope),
+                        mirroring: undefined,
+                    },
+                    {
+                        x: elementWidth,
+                        y: elementHeight,
+                        mirroring: undefined,
+                    }
+                ];
+            }
+            // Handle bindings, with special case for head-only bindings
+            const startBinding = element.startBinding;
+            const endBinding = element.endBinding;
+            // Process bindings
+            const processedStartBinding = startBinding && startBinding.head !== undefined &&
+                (!startBinding.elementId || startBinding.elementId === "")
+                ? createHeadOnlyBinding(startBinding.head, currentScope)
+                : repairBinding(element, startBinding, currentScope);
+            const processedEndBinding = endBinding && endBinding.head !== undefined &&
+                (!endBinding.elementId || endBinding.elementId === "")
+                ? createHeadOnlyBinding(endBinding.head, currentScope)
+                : repairBinding(element, endBinding, currentScope);
+            // Create the base restored element
+            const sizeFromPoints = !hasBindings && getSizeFromPoints(finalPoints.map(getScopedBezierPointFromDucPoint));
+            let restoredElement = restoreElementWithProperties(element, Object.assign({ points: finalPoints, lines, lastCommittedPoint: element.lastCommittedPoint ? restorePoint(element.lastCommittedPoint, element.scope, currentScope) : null, startBinding: processedStartBinding, endBinding: processedEndBinding, x: element.x, y: element.y }, (!sizeFromPoints ? {} : {
+                width: getPrecisionValueFromScoped(sizeFromPoints.width, element.scope, currentScope),
+                height: getPrecisionValueFromScoped(sizeFromPoints.height, element.scope, currentScope),
+            })), appState);
+            const { points: updatedPoints, lines: updatedLines } = mergeOverlappingPoints(finalPoints, lines, LINE_CONFIRM_THRESHOLD);
+            restoredElement = Object.assign(Object.assign({}, restoredElement), { points: updatedPoints, lines: updatedLines });
+            // Validate path overrides after we have the final points and lines
+            const validatedPathOverrides = validatePathOverrides(element.pathOverrides, restoredElement, elementScope, currentScope);
+            return Object.assign(Object.assign({}, restoredElement), { pathOverrides: validatedPathOverrides });
+        }
+        case "arrow": {
+            // since arrow is deprecated, we convert it to line
+            return restoreElement(Object.assign(Object.assign({}, element), { type: "line" }), currentScope, appState);
+        }
+        case "ellipse": {
+            const ratio = isValidPercentageValue(element.ratio, DEFAULT_ELLIPSE_ELEMENT.ratio);
+            const startAngle = isValidCutAngleValue(element.startAngle, DEFAULT_ELLIPSE_ELEMENT.startAngle);
+            const endAngle = isValidCutAngleValue(element.endAngle, DEFAULT_ELLIPSE_ELEMENT.endAngle);
+            const showAuxCrosshair = (_b = element.showAuxCrosshair) !== null && _b !== void 0 ? _b : DEFAULT_ELLIPSE_ELEMENT.showAuxCrosshair;
+            return restoreElementWithProperties(element, {
+                ratio,
+                startAngle,
+                endAngle,
+                showAuxCrosshair,
+            }, appState);
+        }
+        case "rectangle":
+        case "embeddable":
+            return restoreElementWithProperties(element, {}, appState);
+        case "polygon": {
+            const sides = isValidPolygonSides(element.sides);
+            return restoreElementWithProperties(Object.assign(Object.assign({}, element), { sides }), {}, appState);
+        }
+        case "frame": {
+            const frameElement = element;
+            return restoreElementWithProperties(frameElement, Object.assign({}, restoreDucStackProperties(frameElement, currentScope)), appState);
+        }
+        case "table": {
+            const tableElement = element;
+            return restoreElementWithProperties(tableElement, {
+                columnOrder: tableElement.columnOrder || [],
+                rowOrder: tableElement.rowOrder || [],
+                columns: restoreTableColumns(tableElement.columns, element.scope, currentScope),
+                rows: restoreTableRows(tableElement.rows, element.scope, currentScope),
+                cells: restoreTableCells(tableElement.cells, element.scope, currentScope),
+                style: tableElement.style ? restoreTableStyleProps(tableElement.style, element.scope, currentScope) : undefined,
+            }, appState);
+        }
+        case "doc": {
+            const docElement = element;
+            return restoreElementWithProperties(docElement, {
+                content: docElement.content || "",
+            }, appState);
+        }
+    }
+    return null;
+};
+/**
+ * Converts a plain number or legacy value to a PrecisionValue object
+ * @param value - The value to convert (can be a raw number or legacy value)
+ * @param elementScope - The scope to use for the precision value
+ * @returns A properly formatted PrecisionValue object
+ */
+export const restorePrecisionValue = (value, elementScope, currentScope, defaultValue, fromScoped = false) => {
+    const fallbackValue = getPrecisionValueFromRaw((defaultValue !== null && defaultValue !== void 0 ? defaultValue : 0), currentScope, currentScope);
+    if (value === undefined || value === null) {
+        // Return default value with given scope
+        return fallbackValue;
+    }
+    if (typeof value === 'number') {
+        // If value is a number, check if it's finite. Otherwise, use fallback.
+        if (!Number.isFinite(value)) {
+            return fallbackValue;
+        }
+        // Legacy value (finite number), convert to PrecisionValue
+        return fromScoped
+            ? getPrecisionValueFromScoped(value, elementScope, currentScope)
+            : getPrecisionValueFromRaw(value, elementScope, currentScope);
+    }
+    return getPrecisionValueFromRaw(value.value, elementScope, currentScope);
+};
+/**
+ * Restores a point that might have legacy format (x,y as numbers)
+ * @param point - The point to restore
+ * @param elementScope - The scope to use for the precision values
+ * @returns A properly formatted DucPoint
+ */
+export const restorePoint = (point, elementScope, currentScope) => {
+    if (!point) {
+        return null;
+    }
+    // Handle x and y conversion
+    const xValue = restorePrecisionValue(point.x, elementScope, currentScope);
+    const yValue = restorePrecisionValue(point.y, elementScope, currentScope);
+    if (!xValue || !yValue) {
+        return null;
+    }
+    // Only keep the new DucPoint structure, ignore legacy properties
+    return {
+        x: xValue,
+        y: yValue,
+        mirroring: isValidBezierMirroringValue(point.mirroring),
+    };
+};
+const restoreElementPoints = ({ points: oldPoints, x, y, width, height, elementScope, currentScope, }) => {
+    // Convert input parameters to plain numbers if they're precision values
+    const validatedWidth = restorePrecisionValue(width, elementScope, currentScope, 0);
+    const validatedHeight = restorePrecisionValue(height, elementScope, currentScope, 0);
+    // Process the points array with proper conversion
+    let points = [];
+    if (typeof oldPoints === "object" && Array.isArray(oldPoints)) {
+        const migratedPoints = migratePoints(oldPoints);
+        points = migratedPoints
+            .map((point) => {
+            const restoredPoint = restorePoint(point, elementScope, currentScope);
+            if (!restoredPoint) {
+                return null;
+            }
+            return restoredPoint;
+        })
+            .filter(Boolean);
+        // Ensure we have at least 2 points for linear elements
+        if (points.length === 1) {
+            points.push({
+                x: validatedWidth,
+                y: validatedHeight,
+                mirroring: undefined,
+            });
+        }
+    }
+    else {
+        // Default two points
+        points = [
+            {
+                x: getPrecisionValueFromRaw(0, elementScope, currentScope),
+                y: getPrecisionValueFromRaw(0, elementScope, currentScope),
+                mirroring: undefined,
+            },
+            {
+                x: validatedWidth,
+                y: validatedHeight,
+                mirroring: undefined,
+            },
+        ];
+    }
+    if (points.length === 2 &&
+        points[1] && // Should always be true if points.length === 2
+        points[1].x.value === 0 &&
+        points[1].y.value === 0 &&
+        (validatedWidth.value !== 0 || validatedHeight.value !== 0)) {
+        points[1] = Object.assign(Object.assign({}, points[1]), { x: validatedWidth, y: validatedHeight });
+    }
+    return points;
+};
+const restoreLinearElementPointsAndLines = ({ points: oldPoints, lines: oldLines, x, y, width, height, elementScope, currentScope, skipNormalization, }) => {
+    const validatedX = restorePrecisionValue(x, elementScope, currentScope, 0);
+    const validatedY = restorePrecisionValue(y, elementScope, currentScope, 0);
+    const validatedWidth = restorePrecisionValue(width, elementScope, currentScope, 0);
+    const validatedHeight = restorePrecisionValue(height, elementScope, currentScope, 0);
+    let points = restoreElementPoints({
+        points: oldPoints,
+        x,
+        y,
+        width,
+        height,
+        elementScope,
+        currentScope,
+    });
+    let lines = oldLines;
+    if (lines === undefined || lines === null) {
+        lines = [];
+        for (let i = 0; i < points.length - 1; i++) {
+            lines.push([
+                { index: i, handle: null },
+                { index: i + 1, handle: null },
+            ]);
+        }
+    }
+    else {
+        lines = lines.map((line) => {
+            return [
+                {
+                    index: line[0].index,
+                    handle: line[0].handle
+                        ? restorePoint(line[0].handle, elementScope, currentScope)
+                        : null,
+                },
+                {
+                    index: line[1].index,
+                    handle: line[1].handle
+                        ? restorePoint(line[1].handle, elementScope, currentScope)
+                        : null,
+                },
+            ];
+        });
+    }
+    if (!skipNormalization &&
+        points.length >= 2 &&
+        (points[0].x.value !== 0 || points[0].y.value !== 0)) {
+        const normalizedResult = getNormalizedPoints({
+            points,
+            lines,
+            x: validatedX,
+            y: validatedY,
+            scope: elementScope,
+        }, currentScope);
+        const firstPoint = points[0];
+        const lastPoint = points[points.length - 1];
+        points = normalizedResult.points;
+        lines = normalizedResult.lines;
+        if (oldPoints && oldPoints.length === points.length) {
+            if (firstPoint.x.value !== 0 || firstPoint.y.value !== 0) {
+                points[0] = Object.assign({}, points[0]);
+            }
+            if (lastPoint.x.value !== validatedWidth.value ||
+                lastPoint.y.value !== validatedHeight.value) {
+                points[points.length - 1] = Object.assign({}, points[points.length - 1]);
+            }
+        }
+    }
+    return { points, lines };
+};
+/**
+ * Repairs container element's boundElements array by removing duplicates and
+ * fixing containerId of bound elements if not present. Also removes any
+ * bound elements that do not exist in the elements array.
+ *
+ * NOTE mutates elements.
+ */
+const repairContainerElement = (container, elementsMap) => {
+    if (container.boundElements) {
+        const boundElements = container.boundElements.slice();
+        const boundIds = new Set();
+        container.boundElements = boundElements.reduce((acc, binding) => {
+            const boundElement = elementsMap.get(binding.id);
+            if (boundElement && !boundIds.has(binding.id)) {
+                boundIds.add(binding.id);
+                if (boundElement.isDeleted) {
+                    return acc;
+                }
+                acc.push(binding);
+                if (isTextElement(boundElement) &&
+                    !boundElement.containerId) {
+                    boundElement.containerId =
+                        container.id;
+                }
+            }
+            return acc;
+        }, []);
+    }
+};
+/**
+ * Repairs target bound element's container's boundElements array,
+ * or removes contaienrId if container does not exist.
+ *
+ * NOTE mutates elements.
+ */
+const repairBoundElement = (boundElement, elementsMap) => {
+    const container = boundElement.containerId
+        ? elementsMap.get(boundElement.containerId)
+        : null;
+    if (!container) {
+        boundElement.containerId = null;
+        return;
+    }
+    if (boundElement.isDeleted) {
+        return;
+    }
+    if (container.boundElements &&
+        !container.boundElements.find((binding) => binding.id === boundElement.id)) {
+        const boundElements = (container.boundElements || (container.boundElements = [])).slice();
+        boundElements.push({ type: "text", id: boundElement.id });
+        container.boundElements = boundElements;
+    }
+};
+/**
+ * Remove an element's frameId if its containing frame is non-existent
+ *
+ * NOTE mutates elements.
+ */
+const repairFrameMembership = (element, elementsMap) => {
+    if (element.frameId) {
+        const containingFrame = elementsMap.get(element.frameId);
+        if (!containingFrame) {
+            element.frameId = null;
+        }
+    }
+};
+// Add this function to handle migrating from array-based ordering to explicit z-index
+/**
+ * Assigns z-index values to elements based on their position in the array.
+ * This recreates the original visual stacking that was implied by array order
+ * before explicit z-index support was added.
+ */
+export const migrateArrayOrderToZIndex = (elements) => {
+    // Check if we need to do a migration (if any element lacks z-index)
+    const needsMigration = elements.some(el => el.zIndex === undefined || el.zIndex === null);
+    if (!needsMigration) {
+        return elements;
+    }
+    // Create a new array with explicit z-index values
+    return elements.map((element, index) => {
+        // Only update elements that don't already have a valid z-index
+        if (element.zIndex === undefined || element.zIndex === null) {
+            return Object.assign(Object.assign({}, element), { zIndex: index });
+        }
+        return element;
+    });
+};
+// Now update the restoreElements function to use our migration function
+export const restoreElements = (elements, currentScope, 
+/** NOTE doesn't serve for reconciliation */
+localElements, opts) => {
+    const existingIds = new Set();
+    const localElementsMap = localElements ? arrayToMap(localElements) : null;
+    // First restore all elements with their original properties
+    const restored = (elements || []).reduce((elements, element) => {
+        if (element.type !== "selection") {
+            let migratedElement = restoreElement(element, currentScope, opts === null || opts === void 0 ? void 0 : opts.appState);
+            const isEditing = false; // TODO: Handle editingLinearElement properly
+            if (migratedElement &&
+                (!isInvisiblySmallElement(migratedElement) || isEditing)) {
+                const localElement = localElementsMap === null || localElementsMap === void 0 ? void 0 : localElementsMap.get(element.id);
+                if (localElement && localElement.version > migratedElement.version) {
+                    migratedElement = bumpVersion(migratedElement, localElement.version);
+                }
+                if (existingIds.has(migratedElement.id)) {
+                    migratedElement = Object.assign(Object.assign({}, migratedElement), { id: randomId() });
+                }
+                existingIds.add(migratedElement.id);
+                elements.push(migratedElement);
+            }
+        }
+        return elements;
+    }, []);
+    let restoredElements = (opts === null || opts === void 0 ? void 0 : opts.syncInvalidIndices)
+        ? opts.syncInvalidIndices(restored, currentScope)
+        : restored;
+    // Migrate array ordering to explicit z-index values if needed
+    restoredElements = migrateArrayOrderToZIndex(restoredElements);
+    if (!(opts === null || opts === void 0 ? void 0 : opts.repairBindings)) {
+        return restoredElements;
+    }
+    const restoredElementsMap = arrayToMap(restoredElements);
+    for (const element of restoredElements) {
+        if (element.frameId) {
+            repairFrameMembership(element, restoredElementsMap);
+        }
+        if (isTextElement(element) && element.containerId) {
+            repairBoundElement(element, restoredElementsMap);
+        }
+        else if (element.boundElements) {
+            repairContainerElement(element, restoredElementsMap);
+        }
+        if (opts.refreshDimensions && isTextElement(element)) {
+            Object.assign(element, refreshTextDimensions(element, getContainerElement(element, restoredElementsMap), restoredElementsMap, currentScope));
+        }
+        if (isLinearElement(element)) {
+            // Helper function to check if we should keep a binding
+            const shouldKeepBinding = (binding) => {
+                if (!binding)
+                    return true; // No binding, nothing to remove
+                // Keep head-only bindings
+                if (binding.head !== undefined && (!binding.elementId || binding.elementId === "")) {
+                    return true;
+                }
+                // If binding has an elementId, check if it points to a valid element
+                const elementExists = restoredElementsMap.has(binding.elementId);
+                // For linear-to-linear bindings, ensure the point attribute is valid
+                if (binding.point && elementExists) {
+                    const targetElement = restoredElementsMap.get(binding.elementId);
+                    if (isLinearElement(targetElement)) {
+                        // Check if the point index is within bounds of the target element's points
+                        if (binding.point.index >= 0 &&
+                            binding.point.index < targetElement.points.length &&
+                            Math.abs(binding.point.offset) <= 1) {
+                            return true;
+                        }
+                    }
+                }
+                return elementExists;
+            };
+            // Process start binding
+            if (element.startBinding && !shouldKeepBinding(element.startBinding)) {
+                element.startBinding = null;
+            }
+            // Process end binding
+            if (element.endBinding && !shouldKeepBinding(element.endBinding)) {
+                element.endBinding = null;
+            }
+            // Update the bound elements reference for each valid binding
+            // This ensures both sides of the binding relationship are updated
+            const updateBoundElementsRef = (binding) => {
+                var _a;
+                if (!binding || !binding.elementId)
+                    return;
+                const targetElement = restoredElementsMap.get(binding.elementId);
+                if (targetElement && !targetElement.isDeleted) {
+                    // Add the linear element to the target's boundElements if not already there
+                    if (!((_a = targetElement.boundElements) === null || _a === void 0 ? void 0 : _a.some((be) => be.id === element.id))) {
+                        const boundElements = targetElement.boundElements || [];
+                        targetElement.boundElements = [...boundElements, {
+                                id: element.id,
+                                type: element.type
+                            }];
+                    }
+                }
+            };
+            // Update bound elements references
+            updateBoundElementsRef(element.startBinding);
+            updateBoundElementsRef(element.endBinding);
+        }
+    }
+    return restoredElements;
+};
+export const restoreDucState = (ducState, localDucState) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    ducState = ducState || {};
+    const defaultDucState = getDefaultDucState();
+    const scopeExponentThreshold = isValidAppStateScopeExponentThresholdValue(ducState.scopeExponentThreshold, defaultDucState.scopeExponentThreshold);
+    const mainScope = isValidAppStateScopeValue(ducState.mainScope);
+    const zoomValue = getNormalizedZoom(isFiniteNumber(ducState.zoom)
+        ? ducState.zoom
+        : (_b = (_a = ducState.zoom) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : defaultDucState.zoom.value);
+    const scope = isValidPrecisionScopeValue(zoomValue, mainScope, scopeExponentThreshold);
+    const scopedZoom = getScopedZoomValue(zoomValue, scope);
+    return Object.assign(Object.assign({}, defaultDucState), { viewBackgroundColor: (_c = ducState.viewBackgroundColor) !== null && _c !== void 0 ? _c : defaultDucState.viewBackgroundColor, scope,
+        mainScope, standard: (_d = isValidStandard(ducState.standard)) !== null && _d !== void 0 ? _d : defaultDucState.standard, scrollX: ducState.scrollX ?
+            restorePrecisionValue(ducState.scrollX, NEUTRAL_SCOPE, scope) :
+            getPrecisionValueFromRaw(defaultDucState.scrollX.value, NEUTRAL_SCOPE, scope), scrollY: ducState.scrollY ?
+            restorePrecisionValue(ducState.scrollY, NEUTRAL_SCOPE, scope) :
+            getPrecisionValueFromRaw(defaultDucState.scrollY.value, NEUTRAL_SCOPE, scope), zoom: {
+            value: zoomValue,
+            scoped: scopedZoom,
+            scaled: getScaledZoomValueForScope(scopedZoom, scope),
+        }, name: (_e = ducState.name) !== null && _e !== void 0 ? _e : defaultDucState.name, scrolledOutside: isValidBoolean(ducState.scrolledOutside, defaultDucState.scrolledOutside), selectedElementIds: (_f = ducState.selectedElementIds) !== null && _f !== void 0 ? _f : defaultDucState.selectedElementIds, selectedGroupIds: (_g = ducState.selectedGroupIds) !== null && _g !== void 0 ? _g : defaultDucState.selectedGroupIds, displayAllPointDistances: isValidBoolean(ducState.displayAllPointDistances, defaultDucState.displayAllPointDistances), displayDistanceOnDrawing: isValidBoolean(ducState.displayDistanceOnDrawing, defaultDucState.displayDistanceOnDrawing), displayAllPointCoordinates: isValidBoolean(ducState.displayAllPointCoordinates, defaultDucState.displayAllPointCoordinates), displayAllPointInfoSelected: isValidBoolean(ducState.displayAllPointInfoSelected, defaultDucState.displayAllPointInfoSelected), displayRootAxis: isValidBoolean(ducState.displayRootAxis, defaultDucState.displayRootAxis), lineBendingMode: isValidBoolean(ducState.lineBendingMode, defaultDucState.lineBendingMode), coordDecimalPlaces: isValidFinitePositiveByteValue(ducState.coordDecimalPlaces, defaultDucState.coordDecimalPlaces), activeGridSettings: (_h = ducState.activeGridSettings) !== null && _h !== void 0 ? _h : defaultDucState.activeGridSettings, activeSnapSettings: (_j = ducState.activeSnapSettings) !== null && _j !== void 0 ? _j : defaultDucState.activeSnapSettings, gridSize: getNormalizedGridSize(isFiniteNumber(ducState.gridSize) ? ducState.gridSize : defaultDucState.gridSize), gridStep: getNormalizedGridStep(isFiniteNumber(ducState.gridStep) ? ducState.gridStep : defaultDucState.gridStep), debugRendering: isValidBoolean(ducState.debugRendering, defaultDucState.debugRendering), editingLinearElement: (_k = ducState.editingLinearElement) !== null && _k !== void 0 ? _k : defaultDucState.editingLinearElement, scopeExponentThreshold, elementHovered: (_l = ducState.elementHovered) !== null && _l !== void 0 ? _l : defaultDucState.elementHovered, elementsPendingErasure: (_m = ducState.elementsPendingErasure) !== null && _m !== void 0 ? _m : defaultDucState.elementsPendingErasure, suggestedBindings: (_o = ducState.suggestedBindings) !== null && _o !== void 0 ? _o : defaultDucState.suggestedBindings, isBindingEnabled: isValidBoolean(ducState.isBindingEnabled, defaultDucState.isBindingEnabled), penMode: isValidBoolean(ducState.penMode, defaultDucState.penMode), activeTool: Object.assign(Object.assign({}, updateActiveTool(defaultDucState, ((_p = ducState.activeTool) === null || _p === void 0 ? void 0 : _p.type) && AllowedDucActiveTools[ducState.activeTool.type]
+            ? ducState.activeTool
+            : { type: "selection" })), { lastActiveTool: null, locked: isValidBoolean((_q = ducState.activeTool) === null || _q === void 0 ? void 0 : _q.locked, false) }), currentItemBackground: validateBackground(ducState.currentItemBackground), currentItemStroke: validateStroke(ducState.currentItemStroke, scope, scope), currentItemStartLineHead: isValidLineHeadValue(ducState.currentItemStartLineHead), currentItemEndLineHead: isValidLineHeadValue(ducState.currentItemEndLineHead), currentItemOpacity: isValidPercentageValue(ducState.currentItemOpacity, DEFAULT_ELEMENT_PROPS.opacity) });
+};
+/**
+ * Creates an extended AppState restorer function that can be provided as a prop.
+ * This handles restoration of extended AppState that wraps around DucState.
+ *
+ * @param restoreExtendedProps - Function to restore extended properties beyond DucState
+ * @returns A function that can restore the full extended AppState
+ */
+export const createExtendedAppStateRestorer = (restoreExtendedProps) => {
+    return (extendedAppState, localExtendedAppState, restoredDucState) => {
+        // Restore the extended properties
+        const extendedProps = restoreExtendedProps(extendedAppState, localExtendedAppState, restoredDucState);
+        // Combine DucState with extended properties
+        return Object.assign(Object.assign({}, restoredDucState), extendedProps);
+    };
+};
+// Old restore function
+// export const restore = (
+//   data: Pick<ImportedDataState, "appState" | "elements" | "files" | "rendererState" | "blocks" | "groups"> | null,
+//   /**
+//    * Local DucState (`this.state` or initial state from localStorage) so that we
+//    * don't overwrite local state with default values (when values not
+//    * explicitly specified).
+//    * Supply `null` if you can't get access to it.
+//    */
+//   localDucState: Partial<DucState> | null | undefined,
+//   localElements: readonly DucElement[] | null | undefined,
+//   elementsConfig?: ElementsConfig,
+// ): RestoredDataState => {
+//   const restoredDucState = restoreDucState(data?.appState, localDucState || null);
+//   const restoredBlocks = restoreBlocks(data?.blocks, restoredDucState.scope);
+//   const restoredGroups = restoreGroups(data?.groups, restoredDucState.scope);
+//   return {
+//     elements: restoreElements(data?.elements, restoredDucState.scope, localElements, {
+//       ...elementsConfig,
+//       appState: restoredDucState
+//     }),
+//     appState: restoredDucState,
+//     files: data?.files || {},
+//     rendererState: data?.rendererState || null,
+//     blocks: restoredBlocks,
+//     groups: restoredGroups,
+//   };
+// };
+export const noopExtendedAppStateRestorer = (extendedAppState, localExtendedAppState, restoredDucState) => {
+    return restoredDucState;
+};
+/**
+ * Extended restore function that supports restoring extended AppState.
+ * This allows users of the library to provide their own AppState restoration logic.
+ */
+export function restore(data, 
+/**
+ * Local extended AppState for fallback values.
+ * Supply `null` if you can't get access to it.
+ */
+localExtendedAppState, localElements, 
+/**
+ * Extended AppState restorer function that handles the extended properties.
+ * This should be created using `createExtendedAppStateRestorer`.
+ */
+extendedAppStateRestorer, elementsConfig) {
+    // First restore the DucState portion
+    const restoredDucState = restoreDucState(data === null || data === void 0 ? void 0 : data.appState, localExtendedAppState);
+    // Use the provided restorer to handle the full extended AppState
+    const restoredExtendedAppState = extendedAppStateRestorer(data === null || data === void 0 ? void 0 : data.appState, localExtendedAppState, restoredDucState);
+    const restoredBlocks = restoreBlocks(data === null || data === void 0 ? void 0 : data.blocks, restoredDucState.scope);
+    const restoredGroups = restoreGroups(data === null || data === void 0 ? void 0 : data.groups, restoredDucState.scope);
+    return {
+        elements: restoreElements(data === null || data === void 0 ? void 0 : data.elements, restoredDucState.scope, localElements, Object.assign(Object.assign({}, elementsConfig), { appState: restoredDucState })),
+        appState: restoredExtendedAppState,
+        files: (data === null || data === void 0 ? void 0 : data.files) || {},
+        rendererState: (data === null || data === void 0 ? void 0 : data.rendererState) || null,
+        blocks: restoredBlocks,
+        groups: restoredGroups,
+    };
+}
+const restoreLibraryItem = (libraryItem, currentScope) => {
+    const elements = restoreElements(getNonDeletedElements(libraryItem.elements), currentScope, null);
+    return elements.length ? Object.assign(Object.assign({}, libraryItem), { elements }) : null;
+};
+export const restoreLibraryItems = (libraryItems = [], defaultStatus, currentScope) => {
+    const restoredItems = [];
+    for (const item of libraryItems) {
+        if (Array.isArray(item)) {
+            const restoredItem = restoreLibraryItem({
+                status: defaultStatus,
+                elements: item,
+                id: randomId(),
+                created: Date.now(),
+            }, currentScope);
+            if (restoredItem) {
+                restoredItems.push(restoredItem);
+            }
+        }
+        else {
+            const _item = item;
+            const restoredItem = restoreLibraryItem(Object.assign(Object.assign({}, _item), { id: _item.id || randomId(), status: _item.status || defaultStatus, created: _item.created || Date.now() }), currentScope);
+            if (restoredItem) {
+                restoredItems.push(restoredItem);
+            }
+        }
+    }
+    return restoredItems;
+};
+export const isValidFillStyleValue = (value) => {
+    if (value === undefined || !Object.values(ELEMENT_CONTENT_PREFERENCE).includes(value))
+        return ELEMENT_CONTENT_PREFERENCE.solid;
+    return value;
+};
+export const isValidStrokePreferenceValue = (value) => {
+    if (value === undefined || !Object.values(STROKE_PREFERENCE).includes(value))
+        return STROKE_PREFERENCE.solid;
+    return value;
+};
+export const isValidVerticalAlignValue = (value) => {
+    if (value === undefined || !Object.values(VERTICAL_ALIGN).includes(value))
+        return DEFAULT_VERTICAL_ALIGN;
+    return value;
+};
+export const isValidTextAlignValue = (value) => {
+    if (value === undefined || !Object.values(TEXT_ALIGN).includes(value))
+        return DEFAULT_TEXT_ALIGN;
+    return value;
+};
+export const isValidScopeValue = (value, appState) => {
+    // First check if the provided value is valid
+    if (value !== undefined && Object.keys(ScaleFactors).includes(value)) {
+        return value;
+    }
+    // Then check appState.mainScope if available
+    if ((appState === null || appState === void 0 ? void 0 : appState.mainScope) && Object.keys(ScaleFactors).includes(appState.mainScope)) {
+        return appState.mainScope;
+    }
+    // Then check appState.scope if available
+    if ((appState === null || appState === void 0 ? void 0 : appState.scope) && Object.keys(ScaleFactors).includes(appState.scope)) {
+        return appState.scope;
+    }
+    // Finally, use the default scope as last resort
+    return NEUTRAL_SCOPE;
+};
+export const isValidImageStatusValue = (value) => {
+    if (value === undefined || !Object.values(IMAGE_STATUS).includes(value))
+        return IMAGE_STATUS.pending;
+    return value;
+};
+export const isValidLineHeadValue = (value) => {
+    if (value === undefined || value === null || !Object.values(LINE_HEAD).includes(value))
+        return null;
+    return value;
+};
+export const isValidZoomStepValue = (value) => {
+    if (value === undefined || value < MIN_ZOOM_STEP || value > MAX_ZOOM_STEP)
+        return DEFAULT_ZOOM_STEP;
+    return value;
+};
+export const isValidImageScaleValue = (value) => {
+    if (value === undefined || value[0] === 0 || value[1] === 0)
+        return [1, 1];
+    return value;
+};
+export const isValidBezierMirroringValue = (value) => {
+    if (value === undefined || !Object.values(BEZIER_MIRRORING).includes(value))
+        return undefined;
+    return value;
+};
+export const isValidSubsetValue = (value) => {
+    if (value === undefined || value === null || !Object.values(ELEMENT_SUBSET).includes(value))
+        return null;
+    return value;
+};
+export const isValidStrokeSidePreferenceValue = (value) => {
+    if (value === undefined || !Object.values(STROKE_SIDE_PREFERENCE).includes(value))
+        return STROKE_SIDE_PREFERENCE.top;
+    return value;
+};
+export const isValidStrokeCapValue = (value) => {
+    if (value === undefined || !Object.values(STROKE_CAP).includes(value))
+        return STROKE_CAP.butt;
+    return value;
+};
+export const isValidStrokeJoinValue = (value) => {
+    if (value === undefined || !Object.values(STROKE_JOIN).includes(value))
+        return STROKE_JOIN.miter;
+    return value;
+};
+export const isValidStrokeDashValue = (value) => {
+    if (!value || !Array.isArray(value))
+        return [];
+    return value;
+};
+export const isValidStrokeMiterLimitValue = (value) => {
+    if (value === undefined || value < 0 || value > 100)
+        return 4;
+    return value;
+};
+export const isValidBlendingValue = (value) => {
+    if (value === undefined || !Object.values(BLENDING).includes(value))
+        return undefined;
+    return value;
+};
+const getFontFamilyByName = (fontFamilyName) => {
+    if (Object.keys(FONT_FAMILY).includes(fontFamilyName)) {
+        return FONT_FAMILY[fontFamilyName];
+    }
+    return DEFAULT_FONT_FAMILY;
+};
+const repairBinding = (element, binding, currentScope) => {
+    var _a;
+    if (!binding) {
+        return null;
+    }
+    // If this is a head-only binding, normalize it
+    if (binding.head !== undefined && (!binding.elementId || binding.elementId === "")) {
+        return createHeadOnlyBinding(binding.head, currentScope);
+    }
+    // Get the element's scope for conversion
+    const elementScope = element.scope;
+    // Ensure we preserve the point attribute for linear-to-linear bindings
+    const pointData = binding.point ? {
+        point: {
+            index: typeof binding.point.index === 'number' ? binding.point.index : 0,
+            offset: typeof binding.point.offset === 'number' ?
+                // Clamp offset between -1 and 1
+                Math.max(-1, Math.min(1, binding.point.offset)) :
+                0
+        }
+    } : { point: null };
+    return Object.assign({ elementId: binding.elementId || "", focus: typeof binding.focus === 'number' ? binding.focus : 0, gap: restorePrecisionValue(typeof binding.gap === 'number' ? Math.max(0, binding.gap) : 0, elementScope, currentScope), head: isValidLineHeadValue(binding.head), fixedPoint: isElbowArrow(element)
+            ? normalizeFixedPoint((_a = binding.fixedPoint) !== null && _a !== void 0 ? _a : { x: 0.5, y: 0.5 })
+            : null }, pointData);
+};
+const validateElementContent = ({ content, defaultContent, }) => {
+    var _a;
+    return {
+        preference: isValidFillStyleValue(content === null || content === void 0 ? void 0 : content.preference),
+        src: (_a = content === null || content === void 0 ? void 0 : content.src) !== null && _a !== void 0 ? _a : defaultContent.src,
+        visible: isValidBoolean(content === null || content === void 0 ? void 0 : content.visible, defaultContent.visible),
+        opacity: isValidPercentageValue(content === null || content === void 0 ? void 0 : content.opacity, defaultContent.opacity),
+        tiling: (content === null || content === void 0 ? void 0 : content.tiling) || defaultContent.tiling,
+    };
+};
+const validateDeprecatedElementContent = (color, defaultContent) => {
+    const oldContent = tinycolor(color);
+    return Object.assign(Object.assign({}, defaultContent), { src: isValidColor(oldContent.toHexString(), defaultContent.src), opacity: oldContent.getAlpha() });
+};
+const validateStrokeStyle = (style) => {
+    if (!style) {
+        return {
+            preference: STROKE_PREFERENCE.solid,
+            cap: STROKE_CAP.butt,
+            join: STROKE_JOIN.miter,
+            dash: [],
+            miterLimit: 4,
+        };
+    }
+    return {
+        preference: isValidStrokePreferenceValue(style.preference),
+        cap: isValidStrokeCapValue(style.cap),
+        join: isValidStrokeJoinValue(style.join),
+        dash: isValidStrokeDashValue(style.dash),
+        miterLimit: isValidStrokeMiterLimitValue(style.miterLimit),
+    };
+};
+const validateStrokeSides = (sides) => {
+    if (!sides)
+        return undefined;
+    return {
+        preference: isValidStrokeSidePreferenceValue(sides.preference),
+        values: sides.values || undefined,
+    };
+};
+const validateStroke = (stroke, elementScope, currentScope) => {
+    var _a;
+    return {
+        content: validateElementContent({
+            content: stroke === null || stroke === void 0 ? void 0 : stroke.content,
+            defaultContent: DEFAULT_ELEMENT_PROPS.stroke.content,
+        }),
+        placement: (_a = stroke === null || stroke === void 0 ? void 0 : stroke.placement) !== null && _a !== void 0 ? _a : STROKE_PLACEMENT.center,
+        width: restorePrecisionValue(stroke === null || stroke === void 0 ? void 0 : stroke.width, elementScope, currentScope, DEFAULT_ELEMENT_PROPS.stroke.width.value),
+        style: validateStrokeStyle(stroke === null || stroke === void 0 ? void 0 : stroke.style),
+        strokeSides: validateStrokeSides(stroke === null || stroke === void 0 ? void 0 : stroke.strokeSides),
+    };
+};
+const validateBackground = (bg) => {
+    return {
+        content: validateElementContent({
+            content: bg === null || bg === void 0 ? void 0 : bg.content,
+            defaultContent: DEFAULT_ELEMENT_PROPS.background.content,
+        }),
+    };
+};
+/**
+ * Validates a DucPath object and ensures its line indices form a valid closed path
+ */
+const validateDucPath = (path, element, elementScope, currentScope) => {
+    if (!path || !path.lineIndices || !Array.isArray(path.lineIndices)) {
+        return null;
+    }
+    // Validate line indices are numbers and within valid range
+    const validLineIndices = path.lineIndices.filter((index) => typeof index === 'number' &&
+        Number.isInteger(index) &&
+        index >= 0 &&
+        index < element.lines.length);
+    if (validLineIndices.length === 0) {
+        return null;
+    }
+    // Check if the line indices form a valid closed path
+    const isValidClosedPath = validateClosedPath(element, validLineIndices);
+    if (!isValidClosedPath) {
+        return null;
+    }
+    return {
+        lineIndices: validLineIndices,
+        background: path.background ? validateBackground(path.background) : null,
+        stroke: path.stroke ? validateStroke(path.stroke, elementScope, currentScope) : null,
+    };
+};
+/**
+ * Validates and filters path overrides for a linear element
+ */
+const validatePathOverrides = (pathOverrides, element, elementScope, currentScope) => {
+    if (!pathOverrides || !Array.isArray(pathOverrides)) {
+        return [];
+    }
+    const validPaths = [];
+    const usedLineIndices = new Set();
+    for (const pathOverride of pathOverrides) {
+        const validatedPath = validateDucPath(pathOverride, element, elementScope, currentScope);
+        if (validatedPath) {
+            // Check for overlapping line indices with previously validated paths
+            const hasOverlap = validatedPath.lineIndices.some(index => usedLineIndices.has(index));
+            if (!hasOverlap) {
+                // Mark these line indices as used
+                validatedPath.lineIndices.forEach(index => usedLineIndices.add(index));
+                validPaths.push(validatedPath);
+            }
+        }
+    }
+    return validPaths;
+};
+export const isValidFinitePositiveByteValue = (value, defaultValue) => {
+    // Return default if value is undefined or not a finite number
+    if (value === undefined || !Number.isFinite(value)) {
+        return defaultValue;
+    }
+    // Round the value to the nearest integer
+    const roundedValue = Math.round(value);
+    // Clamp the rounded value to the byte range [0, 255]
+    return Math.max(0, Math.min(255, roundedValue));
+};
+/**
+ * Validates and returns a DesignStandard value, or the default if invalid.
+ */
+export const isValidStandard = (value) => {
+    const validValues = Object.values(DESIGN_STANDARD);
+    if (validValues.includes(value))
+        return value;
+    return DESIGN_STANDARD.DUC;
+};
+// Utility to validate polygon sides
+export const isValidPolygonSides = (sides) => {
+    // Validate sides: integer >= 3
+    if (sides >= 3) {
+        if (Number.isInteger(sides)) {
+            return sides;
+        }
+        else {
+            return Math.round(sides);
+        }
+    }
+    return DEFAULT_POLYGON_SIDES;
+};
+/**
+ * Restores the groups array for AppState, ensuring correct structure and types.
+ */
+export const restoreGroups = (groups, currentScope) => {
+    if (!Array.isArray(groups))
+        return [];
+    return groups
+        .filter((g) => g && typeof g === "object" && typeof g.id === "string" && typeof g.type === "string" && g.type === "group")
+        .map((g) => (Object.assign(Object.assign({ id: g.id, type: "group" }, restoreDucStackProperties(g, currentScope)), { clip: isValidBoolean(g.clip, false) })));
+};
+/**
+ * Restores common properties for elements leveraging _DucStackBase.
+ */
+export const restoreDucStackProperties = (stack, currentScope) => {
+    const defaultStackProperties = getDefaultStackProperties();
+    return {
+        label: typeof stack.label === "string" ? stack.label : "",
+        description: typeof stack.description === "string" ? stack.description : null,
+        isCollapsed: isValidBoolean(stack.isCollapsed, defaultStackProperties.isCollapsed),
+        noPlot: isValidBoolean(stack.noPlot, defaultStackProperties.noPlot),
+        locked: isValidBoolean(stack.locked, defaultStackProperties.locked),
+        isVisible: isValidBoolean(stack.isVisible, defaultStackProperties.isVisible),
+        opacity: isValidPercentageValue(stack.opacity, defaultStackProperties.opacity),
+        labelingColor: isValidColor(stack.labelingColor, defaultStackProperties.labelingColor),
+        strokeOverride: stack.strokeOverride ? validateStroke(stack.strokeOverride, currentScope, currentScope) : defaultStackProperties.strokeOverride,
+        backgroundOverride: stack.backgroundOverride ? validateBackground(stack.backgroundOverride) : defaultStackProperties.backgroundOverride,
+        clip: isValidBoolean(stack.clip, defaultStackProperties.clip),
+    };
+};
+/**
+ * Restores the blocks array, ensuring correct structure and types.
+ */
+export const restoreBlocks = (blocks, currentScope) => {
+    if (!Array.isArray(blocks))
+        return [];
+    return blocks
+        .filter((b) => b && typeof b === "object" && typeof b.id === "string")
+        .map((b) => ({
+        id: b.id,
+        label: typeof b.label === "string" ? b.label : "",
+        description: typeof b.description === "string" ? b.description : undefined,
+        version: typeof b.version === "number" ? b.version : 1,
+        elements: restoreElements(b.elements, currentScope, null),
+        attributes: b.attributes || undefined,
+    }));
+};
+const restoreTableStyleProps = (style, elementScope, currentScope) => {
+    if (!style)
+        return undefined;
+    const border = style.border ? {
+        width: style.border.width ? restorePrecisionValue(style.border.width, elementScope, currentScope, 1) : undefined,
+        dashes: style.border.dashes || undefined,
+        color: style.border.color ? isValidColor(style.border.color) : undefined,
+    } : undefined;
+    const text = style.text ? {
+        color: style.text.color ? isValidColor(style.text.color) : undefined,
+        size: style.text.size ? restorePrecisionValue(style.text.size, elementScope, currentScope, DEFAULT_FONT_SIZE) : undefined,
+        font: style.text.font || undefined,
+        align: isValidTextAlignValue(style.text.align) || DEFAULT_TEXT_ALIGN,
+    } : undefined;
+    const restoredStyle = {};
+    if (style.background)
+        restoredStyle.background = style.background;
+    if (border && Object.values(border).some(v => v !== undefined))
+        restoredStyle.border = border;
+    if (text && Object.values(text).some(v => v !== undefined))
+        restoredStyle.text = text;
+    return Object.keys(restoredStyle).length > 0 ? restoredStyle : undefined;
+};
+const restoreTableColumns = (columns, elementScope, currentScope) => {
+    if (!columns)
+        return {};
+    const restoredColumns = {};
+    for (const colId in columns) {
+        const col = columns[colId];
+        restoredColumns[colId] = {
+            id: col.id,
+            width: col.width ? restorePrecisionValue(col.width, elementScope, currentScope) : undefined,
+            style: col.style ? restoreTableStyleProps(col.style, elementScope, currentScope) : undefined,
+        };
+    }
+    return restoredColumns;
+};
+const restoreTableRows = (rows, elementScope, currentScope) => {
+    if (!rows)
+        return {};
+    const restoredRows = {};
+    for (const rowId in rows) {
+        const row = rows[rowId];
+        restoredRows[rowId] = {
+            id: row.id,
+            height: row.height ? restorePrecisionValue(row.height, elementScope, currentScope) : undefined,
+            style: row.style ? restoreTableStyleProps(row.style, elementScope, currentScope) : undefined,
+        };
+    }
+    return restoredRows;
+};
+const restoreTableCells = (cells, elementScope, currentScope) => {
+    if (!cells)
+        return {};
+    const restoredCells = {};
+    for (const cellKey in cells) {
+        const cell = cells[cellKey];
+        restoredCells[cellKey] = {
+            rowId: cell.rowId,
+            columnId: cell.columnId,
+            data: cell.data || "",
+            style: cell.style ? restoreTableStyleProps(cell.style, elementScope, currentScope) : undefined,
+        };
+    }
+    return restoredCells;
+};
+export const isValidRadianValue = (value, defaultValue) => {
+    if (value === undefined || !Number.isFinite(value)) {
+        return defaultValue;
+    }
+    if (value > Math.PI * 2 || value < -Math.PI * 2) {
+        return defaultValue;
+    }
+    return value;
+};
+/**
+ * Validates a Percentage value.
+ * Returns a clamped value within the <0,1> range or a provided default.
+ */
+export const isValidPercentageValue = (value, defaultValue, allowNegative = false) => {
+    if (value === undefined || !Number.isFinite(value)) {
+        return defaultValue;
+    }
+    // If the value is between 1 and 100, assume it's a percentage that needs to be divided by 100
+    if (value > 1 && value <= 100) {
+        value /= 100;
+    }
+    return Math.max(allowNegative ? -1 : 0, Math.min(1, value));
+};
+/**
+ * Ensures the supplied easing function is valid. Falls back to the default easing otherwise.
+ */
+export const isValidFreeDrawEasingValue = (value) => {
+    return typeof value === "function" ? value : DEFAULT_FREEDRAW_ELEMENT.easing;
+};
+/**
+ * Restores the FreeDrawEnds structure validating its members.
+ */
+const restoreFreeDrawEnds = (ends) => {
+    if (!ends)
+        return null;
+    return {
+        cap: isValidBoolean(ends.cap, false),
+        taper: isValidPercentageValue(ends.taper, 0),
+        easing: isValidFreeDrawEasingValue(ends.easing),
+    };
+};
+const isValidCutAngleValue = (value, defaultValue) => {
+    const radian = isValidRadianValue(value, defaultValue);
+    if (radian < 0) {
+        return defaultValue;
+    }
+    return radian;
+};
+export const isValidBoolean = (value, defaultValue = false) => {
+    return typeof value === "boolean" ? value : defaultValue;
+};
+export const isValidColor = (value, defaultValue = "#000000") => {
+    const color = tinycolor(value);
+    return color.isValid() ? color.toHexString() : defaultValue;
+};