ducjs 2.4.0 → 3.0.3

package/dist/technical/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./standards";
 export * from "./measurements";
 export * from "./scopes";

package/dist/technical/index.js

@@ -1,3 +1,2 @@
-export * from "./standards";
 export * from "./measurements";
 export * from "./scopes";

package/dist/technical/scopes.d.ts

@@ -1,4 +1,4 @@
-import { UNIT_SYSTEM } from "../flatbuffers/duc";
+import { UNIT_SYSTEM } from "../enums";
 import { PrecisionValue, RawValue, ScaledZoom, Scope, ScopedValue, ScopedZoomValue, ValueOf } from "../types";
 import { DucPoint } from "../types/elements";
 import { GeometricPoint } from "../types/geometryTypes";
@@ -9,7 +9,7 @@ export declare const MAX_ZOOM = 1e+32;
 export declare const NEUTRAL_SCOPE: SupportedMeasures;
 export declare const metricMeasures: readonly ["qm", "rm", "ym", "zm", "am", "fm", "pm", "Å", "nm", "µm", "mm", "cm", "dm", "m", "dam", "hm", "km", "Mm", "Gm", "Tm", "Pm", "Em", "Zm", "Ym", "Rm", "Qm"];
 export type MetricMeasure = typeof metricMeasures[number];
-export declare const imperialMeasures: readonly ["th", "ln", "in", "h", "ft", "yd", "rd", "ch", "fur", "mi", "lea"];
+export declare const imperialMeasures: readonly ["µin", "th", "mil", "ln", "in", "h", "ft", "yd", "rd", "ch", "fur", "mi", "lea", "au", "ly", "pc"];
 export type ImperialMeasure = typeof imperialMeasures[number];
 export type SupportedMeasures = MetricMeasure | ImperialMeasure;
 export type CombinedMeasure = SupportedMeasures;

package/dist/technical/scopes.js

@@ -1,4 +1,4 @@
-import { UNIT_SYSTEM } from "../flatbuffers/duc";
+import { UNIT_SYSTEM } from "../enums";
 export const MIN_ZOOM = 1e-32;
 export const MAX_ZOOM = 1e32;
 export const NEUTRAL_SCOPE = "m";
@@ -32,7 +32,9 @@ export const metricMeasures = [
     'Qm', // Quettameter
 ];
 export const imperialMeasures = [
-    'th', // Thou/mil
+    'µin', // Microinches
+    'th', // Thou
+    'mil', // Mils
     'ln', // Line
     'in', // Inches
     'h', // Hand
@@ -43,6 +45,9 @@ export const imperialMeasures = [
     'fur', // Furlongs
     'mi', // Miles
     'lea', // Leagues
+    'au', // Astronomical Unit
+    'ly', // Light Year
+    'pc', // Parsec
 ];
 // Define metric units - exponents represent powers of 10
 export const metricUnits = [
@@ -76,17 +81,22 @@ export const metricUnits = [
 // Define imperial units - exponents are now relative to meter as the base unit
 // These values are log10 of their meter equivalents
 export const imperialUnits = [
-    { prefix: 'th', unit: 'thou', full: 'thou', exponent: -4.595 }, // log10(0.0000254) ≈ -4.595
-    { prefix: 'ln', unit: 'line', full: 'line', exponent: -2.674 }, // log10(0.00211667) ≈ -2.674 
-    { prefix: 'in', unit: 'inch', full: 'inch', exponent: -1.595 }, // log10(0.0254) ≈ -1.595
-    { prefix: 'h', unit: 'hand', full: 'hand', exponent: -0.993 }, // log10(0.1016) ≈ -0.993
-    { prefix: 'ft', unit: 'foot', full: 'foot', exponent: -0.516 }, // log10(0.3048) ≈ -0.516
-    { prefix: 'yd', unit: 'yard', full: 'yard', exponent: -0.039 }, // log10(0.9144) ≈ -0.039
-    { prefix: 'rd', unit: 'rod', full: 'rod', exponent: 0.701 }, // log10(5.0292) ≈ 0.701
-    { prefix: 'ch', unit: 'chain', full: 'chain', exponent: 1.304 }, // log10(20.1168) ≈ 1.304
-    { prefix: 'fur', unit: 'furlong', full: 'furlong', exponent: 2.304 }, // log10(201.168) ≈ 2.304
-    { prefix: 'mi', unit: 'mile', full: 'mile', exponent: 3.207 }, // log10(1609.344) ≈ 3.207
-    { prefix: 'lea', unit: 'league', full: 'league', exponent: 3.684 } // log10(4828.032) ≈ 3.684
+    { prefix: 'µin', unit: 'microinch', full: 'microinch', exponent: -7.595 }, // log10(2.54e-8)
+    { prefix: 'th', unit: 'thou', full: 'thou', exponent: -4.595 }, // log10(0.0000254)
+    { prefix: 'mil', unit: 'mil', full: 'mil', exponent: -4.595 }, // log10(0.0000254)
+    { prefix: 'ln', unit: 'line', full: 'line', exponent: -2.674 }, // log10(0.00211667)
+    { prefix: 'in', unit: 'inch', full: 'inch', exponent: -1.595 }, // log10(0.0254)
+    { prefix: 'h', unit: 'hand', full: 'hand', exponent: -0.993 }, // log10(0.1016)
+    { prefix: 'ft', unit: 'foot', full: 'foot', exponent: -0.516 }, // log10(0.3048)
+    { prefix: 'yd', unit: 'yard', full: 'yard', exponent: -0.039 }, // log10(0.9144)
+    { prefix: 'rd', unit: 'rod', full: 'rod', exponent: 0.701 }, // log10(5.0292)
+    { prefix: 'ch', unit: 'chain', full: 'chain', exponent: 1.304 }, // log10(20.1168)
+    { prefix: 'fur', unit: 'furlong', full: 'furlong', exponent: 2.304 }, // log10(201.168)
+    { prefix: 'mi', unit: 'mile', full: 'mile', exponent: 3.207 }, // log10(1609.344)
+    { prefix: 'lea', unit: 'league', full: 'league', exponent: 3.684 }, // log10(4828.032)
+    { prefix: 'au', unit: 'au', full: 'Astronomical Unit', exponent: 11.175 }, // log10(1.496e11)
+    { prefix: 'ly', unit: 'ly', full: 'Light Year', exponent: 15.976 }, // log10(9.461e15)
+    { prefix: 'pc', unit: 'pc', full: 'Parsec', exponent: 16.489 }, // log10(3.086e16)
 ];
 // Scale factors for unit conversions - using meter as the base unit
 export const ScaleFactors = {
@@ -118,7 +128,9 @@ export const ScaleFactors = {
     Rm: 1e27,
     Qm: 1e30,
     // Imperial scales
-    th: 0.0000254, // 0.001 inch
+    'µin': 2.54e-8, // Microinch
+    th: 0.0000254, // Thou (0.001 inch)
+    mil: 0.0000254, // Mil (same as Thou)
     ln: 0.00211667, // 1/12 inch
     in: 0.0254,
     h: 0.1016, // 4 inches
@@ -129,6 +141,9 @@ export const ScaleFactors = {
     fur: 201.168,
     mi: 1609.344,
     lea: 4828.032, // 3 miles
+    au: 149597870700, // Astronomical Unit
+    ly: 9460730472580800, // Light Year
+    pc: 30856775814913670, // Parsec
 };
 /**
  * Determines if a measure belongs to the metric system.

package/dist/transform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Post-parse transformation: fix stack element nesting
+ * (move stackBase fields to top level for frame/plot elements).
+ *
+ * Also adds `type` discriminator to version graph entries.
+ */
+export declare function transformFromRust(data: any): any;
+/**
+ * Pre-serialize transformation: re-wrap stack element fields
+ * and flatten PrecisionValue objects to plain numbers for Rust.
+ */
+export declare function transformToRust(data: any): any;

package/dist/transform.js

@@ -0,0 +1,442 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * Post-parse transformation: fix stack element nesting
+ * (move stackBase fields to top level for frame/plot elements).
+ *
+ * Also adds `type` discriminator to version graph entries.
+ */
+export function transformFromRust(data) {
+    if (!data)
+        return data;
+    if (data.elements) {
+        data.elements = data.elements.map(fixElementFromRust);
+    }
+    if (data.versionGraph) {
+        const vg = data.versionGraph;
+        if (vg.checkpoints) {
+            vg.checkpoints = vg.checkpoints.map((c) => (Object.assign(Object.assign({}, c), { type: "checkpoint" })));
+        }
+        if (vg.deltas) {
+            vg.deltas = vg.deltas.map((d) => (Object.assign(Object.assign({}, d), { type: "delta" })));
+        }
+    }
+    if (data.layers) {
+        data.layers = data.layers.map((layer) => {
+            if (layer === null || layer === void 0 ? void 0 : layer.overrides) {
+                layer = Object.assign(Object.assign({}, layer), { overrides: fixLayerOverridesHatch(layer.overrides, true) });
+            }
+            return layer;
+        });
+    }
+    if (data.blockInstances) {
+        data.blockInstances = data.blockInstances.map((bi) => {
+            if (Array.isArray(bi === null || bi === void 0 ? void 0 : bi.elementOverrides)) {
+                const record = {};
+                for (const entry of bi.elementOverrides) {
+                    if ((entry === null || entry === void 0 ? void 0 : entry.key) !== undefined)
+                        record[entry.key] = entry.value;
+                }
+                return Object.assign(Object.assign({}, bi), { elementOverrides: record });
+            }
+            return bi;
+        });
+    }
+    if (data.blocks) {
+        data.blocks = data.blocks.map((block) => {
+            if (block === null || block === void 0 ? void 0 : block.metadata)
+                fixLocalizationFromRust(block.metadata);
+            return block;
+        });
+    }
+    if (data.blockCollections) {
+        data.blockCollections = data.blockCollections.map((collection) => {
+            if (collection === null || collection === void 0 ? void 0 : collection.metadata)
+                fixLocalizationFromRust(collection.metadata);
+            return collection;
+        });
+    }
+    return data;
+}
+/**
+ * Pre-serialize transformation: re-wrap stack element fields
+ * and flatten PrecisionValue objects to plain numbers for Rust.
+ */
+export function transformToRust(data) {
+    if (!data)
+        return data;
+    const result = Object.assign({}, data);
+    if (result.elements) {
+        result.elements = result.elements.map((el) => coerceElementIntegerFields(flattenPrecisionValues(fixElementToRust(el))));
+    }
+    if (result.localState) {
+        result.localState = normalizeLocalStateForRust(result.localState);
+    }
+    if (result.globalState) {
+        result.globalState = normalizeGlobalStateForRust(result.globalState);
+    }
+    if (result.versionGraph) {
+        const vg = Object.assign({}, result.versionGraph);
+        if (vg.checkpoints) {
+            vg.checkpoints = vg.checkpoints.map((_a) => {
+                var { type: _ } = _a, rest = __rest(_a, ["type"]);
+                return rest;
+            });
+        }
+        if (vg.deltas) {
+            vg.deltas = vg.deltas.map((_a) => {
+                var { type: _ } = _a, rest = __rest(_a, ["type"]);
+                return rest;
+            });
+        }
+        result.versionGraph = vg;
+    }
+    if (result.layers) {
+        result.layers = result.layers.map((layer) => {
+            let l = Object.assign({}, layer);
+            if (l.overrides) {
+                l.overrides = fixLayerOverridesHatch(l.overrides, false);
+            }
+            return flattenPrecisionValues(l);
+        });
+    }
+    if (result.blockInstances) {
+        result.blockInstances = result.blockInstances.map((bi) => {
+            let b = Object.assign({}, bi);
+            if (b.elementOverrides && !Array.isArray(b.elementOverrides) && typeof b.elementOverrides === "object") {
+                b.elementOverrides = Object.entries(b.elementOverrides).map(([key, value]) => ({ key, value: String(value) }));
+            }
+            return flattenPrecisionValues(b);
+        });
+    }
+    if (result.blocks) {
+        result.blocks = result.blocks.map((block) => {
+            let b = Object.assign({}, block);
+            if (b.metadata) {
+                b.metadata = Object.assign({}, b.metadata);
+                fixLocalizationToRust(b.metadata);
+            }
+            return b;
+        });
+    }
+    if (result.blockCollections) {
+        result.blockCollections = result.blockCollections.map((collection) => {
+            let c = Object.assign({}, collection);
+            if (c.metadata) {
+                c.metadata = Object.assign({}, c.metadata);
+                fixLocalizationToRust(c.metadata);
+            }
+            return c;
+        });
+    }
+    return result;
+}
+import { FREEDRAW_EASINGS } from "./utils/constants";
+const STACK_ELEMENT_TYPES = new Set(["frame", "plot"]);
+const LINEAR_ELEMENT_TYPES = new Set(["line", "arrow", "freedraw"]);
+const EASING_FN_TO_NAME = new Map(Object.entries(FREEDRAW_EASINGS).map(([name, fn]) => [fn, name]));
+const TEXT_STYLE_FIELDS = new Set([
+    "isLtr", "fontFamily", "bigFontFamily", "textAlign", "verticalAlign",
+    "lineHeight", "lineSpacing", "obliqueAngle", "fontSize", "widthFactor",
+    "isUpsideDown", "isBackwards",
+]);
+// --- Hatch pattern: Rust flat fields ↔ TS nested `pattern` object ---
+function fixHatchFromRust(hatch) {
+    if (!hatch || typeof hatch !== "object" || hatch.pattern)
+        return hatch;
+    const { patternName, patternScale, patternAngle, patternOrigin, patternDouble } = hatch, rest = __rest(hatch, ["patternName", "patternScale", "patternAngle", "patternOrigin", "patternDouble"]);
+    if (patternName === undefined)
+        return hatch;
+    return Object.assign(Object.assign({}, rest), { pattern: { name: patternName, scale: patternScale, angle: patternAngle, origin: patternOrigin, double: patternDouble } });
+}
+function fixHatchToRust(hatch) {
+    if (!(hatch === null || hatch === void 0 ? void 0 : hatch.pattern))
+        return hatch;
+    const { pattern } = hatch, rest = __rest(hatch, ["pattern"]);
+    return Object.assign(Object.assign({}, rest), { patternName: pattern.name, patternScale: pattern.scale, patternAngle: pattern.angle, patternOrigin: pattern.origin, patternDouble: pattern.double });
+}
+function fixContentHatch(content, fromRust) {
+    if (!(content === null || content === void 0 ? void 0 : content.hatch))
+        return content;
+    return Object.assign(Object.assign({}, content), { hatch: fromRust ? fixHatchFromRust(content.hatch) : fixHatchToRust(content.hatch) });
+}
+function fixStylesHatch(el, fromRust) {
+    var _a, _b, _c, _d;
+    if (Array.isArray(el === null || el === void 0 ? void 0 : el.background)) {
+        for (let i = 0; i < el.background.length; i++) {
+            if ((_b = (_a = el.background[i]) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.hatch) {
+                el.background[i] = Object.assign(Object.assign({}, el.background[i]), { content: fixContentHatch(el.background[i].content, fromRust) });
+            }
+        }
+    }
+    if (Array.isArray(el === null || el === void 0 ? void 0 : el.stroke)) {
+        for (let i = 0; i < el.stroke.length; i++) {
+            if ((_d = (_c = el.stroke[i]) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.hatch) {
+                el.stroke[i] = Object.assign(Object.assign({}, el.stroke[i]), { content: fixContentHatch(el.stroke[i].content, fromRust) });
+            }
+        }
+    }
+}
+function fixLayerOverridesHatch(overrides, fromRust) {
+    var _a, _b, _c, _d;
+    if (!overrides)
+        return overrides;
+    let result = overrides;
+    if ((_b = (_a = result.stroke) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.hatch) {
+        result = Object.assign(Object.assign({}, result), { stroke: Object.assign(Object.assign({}, result.stroke), { content: fixContentHatch(result.stroke.content, fromRust) }) });
+    }
+    if ((_d = (_c = result.background) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.hatch) {
+        result = Object.assign(Object.assign({}, result), { background: Object.assign(Object.assign({}, result.background), { content: fixContentHatch(result.background.content, fromRust) }) });
+    }
+    return result;
+}
+// --- Viewer3DGrid: Rust `value` key ↔ TS `planes` key for perPlane variant ---
+function fixViewer3DGridFromRust(grid) {
+    if ((grid === null || grid === void 0 ? void 0 : grid.type) === "perPlane" && "value" in grid && !("planes" in grid)) {
+        const { value } = grid, rest = __rest(grid, ["value"]);
+        return Object.assign(Object.assign({}, rest), { planes: value });
+    }
+    return grid;
+}
+function fixViewer3DGridToRust(grid) {
+    if ((grid === null || grid === void 0 ? void 0 : grid.type) === "perPlane" && "planes" in grid) {
+        const { planes } = grid, rest = __rest(grid, ["planes"]);
+        return Object.assign(Object.assign({}, rest), { value: planes });
+    }
+    return grid;
+}
+// --- customData: Rust `Option<String>` (JSON) ↔ TS `Record<string, any>` ---
+function fixCustomDataFromRust(el) {
+    if (typeof (el === null || el === void 0 ? void 0 : el.customData) === "string") {
+        try {
+            el.customData = JSON.parse(el.customData);
+        }
+        catch ( /* keep as string */_a) { /* keep as string */ }
+    }
+}
+function fixCustomDataToRust(el) {
+    if ((el === null || el === void 0 ? void 0 : el.customData) != null && typeof el.customData !== "string") {
+        el.customData = JSON.stringify(el.customData);
+    }
+}
+// --- Block metadata localization: Rust `Option<String>` (JSON) ↔ TS Record ---
+function fixLocalizationFromRust(metadata) {
+    if (typeof (metadata === null || metadata === void 0 ? void 0 : metadata.localization) === "string") {
+        try {
+            metadata.localization = JSON.parse(metadata.localization);
+        }
+        catch ( /* keep as string */_a) { /* keep as string */ }
+    }
+}
+function fixLocalizationToRust(metadata) {
+    if ((metadata === null || metadata === void 0 ? void 0 : metadata.localization) != null && typeof metadata.localization !== "string") {
+        metadata.localization = JSON.stringify(metadata.localization);
+    }
+}
+function fixElementFromRust(el) {
+    var _a, _b, _c;
+    if (!el)
+        return el;
+    fixStylesHatch(el, true);
+    fixCustomDataFromRust(el);
+    if (el.type === "model" && ((_b = (_a = el.viewerState) === null || _a === void 0 ? void 0 : _a.display) === null || _b === void 0 ? void 0 : _b.grid)) {
+        el.viewerState = Object.assign(Object.assign({}, el.viewerState), { display: Object.assign(Object.assign({}, el.viewerState.display), { grid: fixViewer3DGridFromRust(el.viewerState.display.grid) }) });
+    }
+    // Convert Rust DucLine structs { start, end } → TypeScript tuples [start, end]
+    if (LINEAR_ELEMENT_TYPES.has(el.type) && Array.isArray(el.lines)) {
+        el.lines = el.lines.map((line) => {
+            if (Array.isArray(line))
+                return line;
+            if (line && line.start !== undefined && line.end !== undefined) {
+                return [line.start, line.end];
+            }
+            return line;
+        });
+    }
+    // Convert easing string key → function for freedraw elements
+    if (el.type === "freedraw") {
+        el = convertEasingFromRust(el);
+    }
+    // Unwrap nested text style → flat fields for TS
+    if (el.type === "text" && el.style && typeof el.style === "object") {
+        const { style } = el, rest = __rest(el, ["style"]);
+        return Object.assign(Object.assign({}, rest), style);
+    }
+    // Remove empty style from table/doc elements
+    if ((el.type === "table" || el.type === "doc") && "style" in el) {
+        const { style: _ } = el, rest = __rest(el, ["style"]);
+        return rest;
+    }
+    if (!STACK_ELEMENT_TYPES.has(el.type))
+        return el;
+    // Stack elements (frame, plot) — unwrap stackBase, remove empty plot style
+    const { stackBase, style: _plotStyle } = el, rest = __rest(el, ["stackBase", "style"]);
+    if (!stackBase)
+        return el;
+    return Object.assign(Object.assign({}, rest), { isCollapsed: (_c = stackBase.isCollapsed) !== null && _c !== void 0 ? _c : false });
+}
+function fixElementToRust(el) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!el)
+        return el;
+    fixStylesHatch(el, false);
+    fixCustomDataToRust(el);
+    if (el.type === "model" && ((_b = (_a = el.viewerState) === null || _a === void 0 ? void 0 : _a.display) === null || _b === void 0 ? void 0 : _b.grid)) {
+        el.viewerState = Object.assign(Object.assign({}, el.viewerState), { display: Object.assign(Object.assign({}, el.viewerState.display), { grid: fixViewer3DGridToRust(el.viewerState.display.grid) }) });
+    }
+    // Convert TypeScript DucLine tuples [start, end] → Rust structs { start, end }
+    if (LINEAR_ELEMENT_TYPES.has(el.type) && Array.isArray(el.lines)) {
+        el.lines = el.lines.map((line) => {
+            if (Array.isArray(line)) {
+                return { start: line[0], end: line[1] };
+            }
+            return line;
+        });
+    }
+    // Convert easing function → string key for freedraw elements
+    if (el.type === "freedraw") {
+        el = convertEasingToRust(el);
+    }
+    // Wrap flat text style fields into nested `style` object for Rust serde
+    if (el.type === "text") {
+        const style = {};
+        const rest = {};
+        for (const key of Object.keys(el)) {
+            if (TEXT_STYLE_FIELDS.has(key)) {
+                style[key] = el[key];
+            }
+            else {
+                rest[key] = el[key];
+            }
+        }
+        return Object.assign(Object.assign({}, rest), { style });
+    }
+    // Add empty style for table/doc elements
+    if (el.type === "table" || el.type === "doc") {
+        return Object.assign(Object.assign({}, el), { style: {} });
+    }
+    if (!STACK_ELEMENT_TYPES.has(el.type))
+        return el;
+    const { isCollapsed } = el, rest = __rest(el, ["isCollapsed"]);
+    return Object.assign(Object.assign(Object.assign({}, rest), (el.type === "plot" ? { style: {} } : {})), { stackBase: {
+            label: (_c = el.label) !== null && _c !== void 0 ? _c : "",
+            description: (_d = el.description) !== null && _d !== void 0 ? _d : null,
+            isCollapsed: isCollapsed !== null && isCollapsed !== void 0 ? isCollapsed : false,
+            isPlot: (_e = el.isPlot) !== null && _e !== void 0 ? _e : false,
+            isVisible: (_f = el.isVisible) !== null && _f !== void 0 ? _f : true,
+            locked: (_g = el.locked) !== null && _g !== void 0 ? _g : false,
+            opacity: (_h = el.opacity) !== null && _h !== void 0 ? _h : 1.0,
+        } });
+}
+/**
+ * Recursively convert PrecisionValue objects ({value, scoped}) to plain
+ * numbers (extracting `.value` — the raw/unscoped value) so Rust's serde
+ * can deserialize them as f64.
+ */
+function flattenPrecisionValues(obj) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (isPrecisionValueLike(obj))
+        return obj.value;
+    if (Array.isArray(obj))
+        return obj.map(flattenPrecisionValues);
+    if (typeof obj === "object") {
+        const out = {};
+        for (const key in obj) {
+            if (!Object.prototype.hasOwnProperty.call(obj, key))
+                continue;
+            out[key] = flattenPrecisionValues(obj[key]);
+        }
+        return out;
+    }
+    return obj;
+}
+function isPrecisionValueLike(v) {
+    return (v !== null &&
+        typeof v === "object" &&
+        !Array.isArray(v) &&
+        typeof v.value === "number" &&
+        typeof v.scoped === "number" &&
+        Object.keys(v).length === 2);
+}
+function toNumberFromPrecisionLike(value, fallback) {
+    const flattened = flattenPrecisionValues(value);
+    if (typeof flattened === "number" && Number.isFinite(flattened)) {
+        return flattened;
+    }
+    return fallback;
+}
+function toInteger(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    return Math.trunc(value);
+}
+function coerceElementIntegerFields(el) {
+    if (!el || typeof el !== "object")
+        return el;
+    return Object.assign(Object.assign({}, el), { seed: toInteger(el.seed, 1), version: toInteger(el.version, 1), versionNonce: toInteger(el.versionNonce, 0) });
+}
+function normalizeLocalStateForRust(localState) {
+    if (!localState || typeof localState !== "object")
+        return localState;
+    return Object.assign(Object.assign({}, localState), { scrollX: toNumberFromPrecisionLike(localState.scrollX, 0), scrollY: toNumberFromPrecisionLike(localState.scrollY, 0), zoom: localState.zoom && typeof localState.zoom === "object"
+            ? toNumberFromPrecisionLike(localState.zoom.value, 1)
+            : toNumberFromPrecisionLike(localState.zoom, 1), currentItemStroke: flattenPrecisionValues(localState.currentItemStroke), currentItemBackground: flattenPrecisionValues(localState.currentItemBackground), currentItemFontSize: toNumberFromPrecisionLike(localState.currentItemFontSize, 16), currentItemRoundness: toNumberFromPrecisionLike(localState.currentItemRoundness, 0), currentItemTextAlign: toInteger(localState.currentItemTextAlign, 10), decimalPlaces: toInteger(localState.decimalPlaces, 2) });
+}
+function normalizeGlobalStateForRust(globalState) {
+    if (!globalState || typeof globalState !== "object")
+        return globalState;
+    return Object.assign(Object.assign({}, globalState), { scopeExponentThreshold: toInteger(globalState.scopeExponentThreshold, 4), pruningLevel: toInteger(globalState.pruningLevel, 20) });
+}
+function easingFnToName(fn) {
+    var _a;
+    if (typeof fn === "string")
+        return fn;
+    if (typeof fn === "function") {
+        return (_a = EASING_FN_TO_NAME.get(fn)) !== null && _a !== void 0 ? _a : "easeOutSine";
+    }
+    return "easeOutSine";
+}
+function easingNameToFn(name) {
+    if (typeof name === "function")
+        return name;
+    if (typeof name === "string" && name in FREEDRAW_EASINGS) {
+        return FREEDRAW_EASINGS[name];
+    }
+    return FREEDRAW_EASINGS.easeOutSine;
+}
+function convertEasingToRust(el) {
+    var _a, _b;
+    const result = Object.assign({}, el);
+    if (result.easing != null) {
+        result.easing = easingFnToName(result.easing);
+    }
+    if (((_a = result.start) === null || _a === void 0 ? void 0 : _a.easing) != null) {
+        result.start = Object.assign(Object.assign({}, result.start), { easing: easingFnToName(result.start.easing) });
+    }
+    if (((_b = result.end) === null || _b === void 0 ? void 0 : _b.easing) != null) {
+        result.end = Object.assign(Object.assign({}, result.end), { easing: easingFnToName(result.end.easing) });
+    }
+    return result;
+}
+function convertEasingFromRust(el) {
+    if (typeof el.easing === "string") {
+        el.easing = easingNameToFn(el.easing);
+    }
+    if (el.start && typeof el.start.easing === "string") {
+        el.start = Object.assign(Object.assign({}, el.start), { easing: easingNameToFn(el.start.easing) });
+    }
+    if (el.end && typeof el.end.easing === "string") {
+        el.end = Object.assign(Object.assign({}, el.end), { easing: easingNameToFn(el.end.easing) });
+    }
+    return el;
+}