@vvfx/ge-ir 0.0.1-beat.2

package/dist/index.mjs

@@ -0,0 +1,4790 @@
+/*!
+ * Name: @vvfx/ge-ir
+ * Description: Galacean Effects and animation IR bidirectional conversion package
+ * Author: Ant Group CO., Ltd.
+ * Contributors: 澄弈
+ * Version: v0.0.1-beat.2
+ */
+
+import { IRBlendMode, IRShapePrimitiveType, IRFillType, IRLineCap, IRLineJoin, IRShapeFillRule, IREndBehavior, validateIRCompositionWithWarnings } from '@vvfx/animation-ir';
+import { v4 } from 'uuid';
+import { BezierKeyframeType, ValueType, JSONSceneVersion } from '@galacean/effects-specification';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike) {
+        if (it) o = it;
+        var i = 0;
+        return function() {
+            if (i >= o.length) return {
+                done: true
+            };
+            return {
+                done: false,
+                value: o[i++]
+            };
+        };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var DEFAULT_CAMERA_Z = 8;
+var DEFAULT_CAMERA_FOV = 60;
+var DEFAULT_CLIP_MODE = 1;
+/** 2D pixel space -> GE 3D world unit ratio for a given canvas size. */ function get2dTo3dRatio(width, height) {
+    var ratio = 2 / height * DEFAULT_CAMERA_Z * Math.tan(DEFAULT_CAMERA_FOV / 2 * (Math.PI / 180)) + 1e-6;
+    {
+        ratio *= height / width;
+    }
+    return ratio;
+}
+/**
+ * Convert a 2D point in canvas pixel space (origin top-left) to a GE 3D world
+ * point (origin centered, Y flipped). The `z` parameter applies the GE camera
+ * adapter to stay perspective-correct for non-zero Z layers.
+ */ function convert2dTo3dPoint(x, y, z, width, height) {
+    var ratio = get2dTo3dRatio(width, height);
+    var adaptRatioZ = (DEFAULT_CAMERA_Z - z) / DEFAULT_CAMERA_Z;
+    var offsetX = (x - width / 2.0) * ratio * adaptRatioZ;
+    var offsetY = (height / 2.0 - y) * ratio * adaptRatioZ;
+    return [
+        offsetX,
+        offsetY,
+        z
+    ];
+}
+
+// ── IDs ──
+/** Generate a 32-char hex GE entity id (UUID v4 with dashes stripped). */ function createId() {
+    return v4().replace(/-/g, '');
+}
+/** Wrap an id into a `{ id }` GE DataPath reference. */ function toDataPath(id) {
+    return {
+        id: id
+    };
+}
+// ── Numbers ──
+/** Round a number to the given decimal precision (default 4). */ function roundNumber(value, precision) {
+    if (precision === void 0) precision = 4;
+    var factor = Math.pow(10, precision);
+    return Math.round(value * factor) / factor;
+}
+/** Linear interpolation between `a` and `b` by `factor` ∈ [0, 1]. */ function lerp(a, b, factor) {
+    return (1 - factor) * a + factor * b;
+}
+// ── Text metrics ──
+/**
+ * Rough text width estimate used when the IR layer does not record a
+ * measured width. Average character width ≈ 0.6 × fontSize.
+ */ function estimateTextWidth(text, fontSize, letterSpacing) {
+    if (text.length === 0) {
+        return 0;
+    }
+    var avgCharWidth = fontSize * 0.6;
+    var spacing = (letterSpacing != null ? letterSpacing : 0) * (text.length - 1);
+    return text.length * avgCharWidth + spacing;
+}
+
+/**
+ * Build the ObjectBindingTrack + Activation/Transform/SpriteColor child tracks
+ * for one VFX item. Shared by lottie2ge and dsl2ge generators.
+ *
+ * The SpriteColor track is omitted for null layers (itemType `'null'` or
+ * the GE numeric code `'3'`).
+ */ function buildTimelineTracks(collector, delay, duration, endBehavior, animation, itemType) {
+    var objectBindingTrackId = createId();
+    var childTrackIds = [];
+    childTrackIds.push(toDataPath(buildActivationTrack(collector, delay, duration, endBehavior)));
+    childTrackIds.push(toDataPath(buildTransformTrack(collector, delay, duration, endBehavior, animation)));
+    if (!isNullItemType(itemType)) {
+        childTrackIds.push(toDataPath(buildSpriteColorTrack(collector, delay, duration, endBehavior, animation)));
+    }
+    collector.miscs.push({
+        id: objectBindingTrackId,
+        dataType: 'ObjectBindingTrack',
+        children: childTrackIds,
+        clips: []
+    });
+    return objectBindingTrackId;
+}
+function isNullItemType(itemType) {
+    return itemType === 'null' || itemType === '3';
+}
+function buildActivationTrack(collector, delay, duration, endBehavior) {
+    var assetId = createId();
+    collector.miscs.push({
+        id: assetId,
+        dataType: 'ActivationPlayableAsset'
+    });
+    var trackId = createId();
+    var clip = {
+        start: roundNumber(delay, 4),
+        duration: roundNumber(duration, 4),
+        endBehavior: endBehavior,
+        asset: toDataPath(assetId)
+    };
+    collector.miscs.push({
+        id: trackId,
+        dataType: 'ActivationTrack',
+        children: [],
+        clips: [
+            clip
+        ]
+    });
+    return trackId;
+}
+function buildTransformTrack(collector, delay, duration, endBehavior, animation) {
+    var _animation_positionOverLifetime;
+    var assetId = createId();
+    var asset = {
+        id: assetId,
+        dataType: 'TransformPlayableAsset',
+        positionOverLifetime: (_animation_positionOverLifetime = animation.positionOverLifetime) != null ? _animation_positionOverLifetime : {}
+    };
+    if (animation.rotationOverLifetime != null) {
+        asset['rotationOverLifetime'] = animation.rotationOverLifetime;
+    }
+    if (animation.sizeOverLifetime != null) {
+        asset['sizeOverLifetime'] = animation.sizeOverLifetime;
+    }
+    collector.miscs.push(asset);
+    var trackId = createId();
+    collector.miscs.push({
+        id: trackId,
+        dataType: 'TransformTrack',
+        children: [],
+        clips: [
+            {
+                start: roundNumber(delay, 4),
+                duration: roundNumber(duration, 4),
+                endBehavior: endBehavior,
+                asset: toDataPath(assetId)
+            }
+        ]
+    });
+    return trackId;
+}
+function buildSpriteColorTrack(collector, delay, duration, endBehavior, animation) {
+    var assetId = createId();
+    var asset = {
+        id: assetId,
+        dataType: 'SpriteColorPlayableAsset',
+        startColor: [
+            1,
+            1,
+            1,
+            1
+        ]
+    };
+    if (animation.colorOverLifetime != null) {
+        asset['colorOverLifetime'] = animation.colorOverLifetime;
+    }
+    collector.miscs.push(asset);
+    var trackId = createId();
+    collector.miscs.push({
+        id: trackId,
+        dataType: 'SpriteColorTrack',
+        children: [],
+        clips: [
+            {
+                start: roundNumber(delay, 4),
+                duration: roundNumber(duration, 4),
+                endBehavior: endBehavior,
+                asset: toDataPath(assetId)
+            }
+        ]
+    });
+    return trackId;
+}
+
+var DEFAULT_OUT_TANGENT = {
+    x: 0.33,
+    y: 0.33
+};
+var DEFAULT_IN_TANGENT = {
+    x: 0.67,
+    y: 0.67
+};
+function normalizeTime(frameTime, startFrame, endFrame) {
+    var frames = Math.max(1, endFrame - startFrame);
+    return (frameTime - startFrame) / frames;
+}
+function getScalarValue(keyframe, dimensionIndex) {
+    var value = keyframe.value;
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (Array.isArray(value) && dimensionIndex != null) {
+        var _value_dimensionIndex;
+        return (_value_dimensionIndex = value[dimensionIndex]) != null ? _value_dimensionIndex : 0;
+    }
+    return 0;
+}
+/**
+ * Convert a 1D animated property (opacity / rotation) to GE BezierKeyframeValue[][].
+ * Returns a single-element outer array with the full curve.
+ */ function irScalarKeyframesToGE(property, timeContext) {
+    if (!property.keyframed || property.keyframes == null || property.keyframes.length < 2) {
+        return undefined;
+    }
+    var curve = buildCurveForDimension(property.keyframes, timeContext, undefined);
+    return curve != null ? [
+        curve
+    ] : undefined;
+}
+/**
+ * Convert a multi-dimensional animated property (scale / anchor) to GE BezierKeyframeValue[][].
+ * Returns one curve per dimension in the outer array.
+ */ function irVectorKeyframesToGE(property, timeContext) {
+    if (!property.keyframed || property.keyframes == null || property.keyframes.length < 2) {
+        return undefined;
+    }
+    var firstValue = property.keyframes[0].value;
+    var dimensions = Array.isArray(firstValue) ? firstValue.length : 1;
+    var curves = [];
+    for(var d = 0; d < dimensions; d++){
+        var curve = buildCurveForDimension(property.keyframes, timeContext, d);
+        curves.push(curve != null ? curve : []);
+    }
+    return curves.length > 0 ? curves : undefined;
+}
+/**
+ * Convert position keyframes to GE path animation format (pp/cp + timing curves).
+ */ function irPositionKeyframesToGE(property, timeContext) {
+    if (!property.keyframed || property.keyframes == null || property.keyframes.length < 2) {
+        return undefined;
+    }
+    var keyframes = property.keyframes;
+    var pathPoints = [];
+    var controlPoints = [];
+    var timingCurvePoints = [];
+    for(var i = 0; i < keyframes.length; i++){
+        var _kf_outTangent, _kf_inTangent;
+        var kf = keyframes[i];
+        var normalizedT = normalizeTime(kf.t, timeContext.startFrame, timeContext.endFrame);
+        timingCurvePoints.push({
+            t: normalizedT,
+            outTangent: (_kf_outTangent = kf.outTangent) != null ? _kf_outTangent : DEFAULT_OUT_TANGENT,
+            inTangent: (_kf_inTangent = kf.inTangent) != null ? _kf_inTangent : DEFAULT_IN_TANGENT
+        });
+        if (i < keyframes.length - 1) {
+            var _kf_value, _kf_endValue, _nextKf_value, _startPos_, _startPos_1, _stitchEnd_, _stitchEnd_1;
+            var nextKf = keyframes[i + 1];
+            var startPos = (_kf_value = kf.value) != null ? _kf_value : [
+                0,
+                0,
+                0
+            ];
+            // Lottie segment end value: kf.endValue is authoritative; falls back to kf.value (mirrors master's `e ?? s`).
+            // nextKf.value is only used later in the path-fixup pass to stitch adjacent segments.
+            var segmentEnd = kf.hold === true ? startPos : (_kf_endValue = kf.endValue) != null ? _kf_endValue : startPos;
+            var stitchEnd = kf.hold === true ? startPos : (_nextKf_value = nextKf.value) != null ? _nextKf_value : [
+                0,
+                0,
+                0
+            ];
+            pathPoints.push([
+                [
+                    (_startPos_ = startPos[0]) != null ? _startPos_ : 0,
+                    (_startPos_1 = startPos[1]) != null ? _startPos_1 : 0
+                ],
+                [
+                    (_stitchEnd_ = stitchEnd[0]) != null ? _stitchEnd_ : 0,
+                    (_stitchEnd_1 = stitchEnd[1]) != null ? _stitchEnd_1 : 0
+                ]
+            ]);
+            // Spatial control points (per IRKeyframe convention): outgoing CP from
+            // kf[i].spatialOut, incoming CP from kf[i+1].spatialIn. Without explicit
+            // spatial handles on either side, use linear one-third handles.
+            var toPoint = void 0;
+            var tiPoint = void 0;
+            if (kf.spatialOut != null && nextKf.spatialIn != null) {
+                var _kf_spatialOut_, _kf_spatialOut_1, _nextKf_spatialIn_, _nextKf_spatialIn_1;
+                toPoint = [
+                    (_kf_spatialOut_ = kf.spatialOut[0]) != null ? _kf_spatialOut_ : 0,
+                    (_kf_spatialOut_1 = kf.spatialOut[1]) != null ? _kf_spatialOut_1 : 0
+                ];
+                tiPoint = [
+                    (_nextKf_spatialIn_ = nextKf.spatialIn[0]) != null ? _nextKf_spatialIn_ : 0,
+                    (_nextKf_spatialIn_1 = nextKf.spatialIn[1]) != null ? _nextKf_spatialIn_1 : 0
+                ];
+            } else {
+                var _startPos_2, _startPos_3, _segmentEnd_, _segmentEnd_1;
+                var sx = (_startPos_2 = startPos[0]) != null ? _startPos_2 : 0;
+                var sy = (_startPos_3 = startPos[1]) != null ? _startPos_3 : 0;
+                var ex = (_segmentEnd_ = segmentEnd[0]) != null ? _segmentEnd_ : 0;
+                var ey = (_segmentEnd_1 = segmentEnd[1]) != null ? _segmentEnd_1 : 0;
+                toPoint = [
+                    -sx / 3 + ex / 3,
+                    -sy / 3 + ey / 3
+                ];
+                tiPoint = [
+                    sx / 3 - ex / 3,
+                    sy / 3 - ey / 3
+                ];
+            }
+            controlPoints.push([
+                toPoint,
+                tiPoint
+            ]);
+        }
+    }
+    // Fix up path points: adjacent segments should share endpoints
+    for(var i1 = 0; i1 < pathPoints.length - 1; i1++){
+        pathPoints[i1][1] = pathPoints[i1 + 1][0];
+    }
+    // Prepend a static segment if the first keyframe doesn't start at t=0.
+    // The bridge segment runs synthetic-at-t=0 → original-kf[0]; for it to be a
+    // flat hold the END-side tangent (which `buildPositionTimingCurves` reads as
+    // `next.inTangent`) must be {1, 1}. Override the original first kf's
+    // inTangent before unshifting (its previous value was either DEFAULT, since
+    // the IR convention leaves a first-kf inTangent undefined, or whatever the
+    // producer set as a no-op).
+    if (timingCurvePoints.length > 0 && timingCurvePoints[0].t > 0) {
+        var _ref, _ref1;
+        var _pathPoints_, _pathPoints_1;
+        timingCurvePoints[0].inTangent = {
+            x: 1,
+            y: 1
+        };
+        timingCurvePoints.unshift({
+            t: 0,
+            outTangent: {
+                x: 0,
+                y: 0
+            },
+            inTangent: {
+                x: 1,
+                y: 1
+            }
+        });
+        pathPoints.unshift([
+            (_ref = (_pathPoints_ = pathPoints[0]) == null ? void 0 : _pathPoints_[0]) != null ? _ref : [
+                0,
+                0
+            ],
+            (_ref1 = (_pathPoints_1 = pathPoints[0]) == null ? void 0 : _pathPoints_1[0]) != null ? _ref1 : [
+                0,
+                0
+            ]
+        ]);
+        controlPoints.unshift([
+            [
+                0,
+                0
+            ],
+            [
+                0,
+                0
+            ]
+        ]);
+    }
+    // Build timing-only bezier curves (in time-time domain)
+    var timingCurves = buildPositionTimingCurves(timingCurvePoints);
+    return {
+        curves: timingCurves != null ? [
+            timingCurves
+        ] : [
+            []
+        ],
+        pathPoints: pathPoints,
+        controlPoints: controlPoints
+    };
+}
+// ─── Internal helpers ───────────────────────────────────────
+function makeEaseOut(seg) {
+    return [
+        BezierKeyframeType.EASE_OUT,
+        [
+            roundNumber(seg[0], 4),
+            roundNumber(seg[1], 4),
+            roundNumber(seg[2], 4),
+            roundNumber(seg[3], 4)
+        ],
+        BezierKeyframeType.EASE_OUT
+    ];
+}
+function makeEaseIn(prevSeg) {
+    return [
+        BezierKeyframeType.EASE_IN,
+        [
+            roundNumber(prevSeg[4], 4),
+            roundNumber(prevSeg[5], 4),
+            roundNumber(prevSeg[6], 4),
+            roundNumber(prevSeg[7], 4)
+        ],
+        BezierKeyframeType.EASE_IN
+    ];
+}
+function makeEase(prevSeg, currSeg) {
+    return [
+        BezierKeyframeType.EASE,
+        [
+            roundNumber(prevSeg[4], 4),
+            roundNumber(prevSeg[5], 4),
+            roundNumber(prevSeg[6], 4),
+            roundNumber(prevSeg[7], 4),
+            roundNumber(currSeg[2], 4),
+            roundNumber(currSeg[3], 4)
+        ],
+        BezierKeyframeType.EASE
+    ];
+}
+function buildCurveForDimension(keyframes, timeContext, dimensionIndex) {
+    if (keyframes.length < 2) {
+        return undefined;
+    }
+    // Build intermediate bezier representation
+    var bezierCurves = [];
+    for(var i = 0; i < keyframes.length - 1; i++){
+        var _kf_outTangent, _nextKf_inTangent;
+        var kf = keyframes[i];
+        var nextKf = keyframes[i + 1];
+        var t0 = normalizeTime(kf.t, timeContext.startFrame, timeContext.endFrame);
+        var t1 = normalizeTime(nextKf.t, timeContext.startFrame, timeContext.endFrame);
+        var v0 = getScalarValue(kf, dimensionIndex);
+        var v1 = kf.hold === true ? v0 : getScalarValue(nextKf, dimensionIndex);
+        var outHandle = kf.hold === true ? {
+            x: 0,
+            y: 0
+        } : (_kf_outTangent = kf.outTangent) != null ? _kf_outTangent : DEFAULT_OUT_TANGENT;
+        // Per IR convention, the incoming tangent for segment i lives on kf[i+1].
+        var inHandle = kf.hold === true ? {
+            x: 1,
+            y: 1
+        } : (_nextKf_inTangent = nextKf.inTangent) != null ? _nextKf_inTangent : DEFAULT_IN_TANGENT;
+        var outCpX = lerp(t0, t1, outHandle.x);
+        var outCpY = lerp(v0, v1, outHandle.y);
+        var inCpX = lerp(t0, t1, inHandle.x);
+        var inCpY = lerp(v0, v1, inHandle.y);
+        bezierCurves.push([
+            t0,
+            v0,
+            outCpX,
+            outCpY,
+            inCpX,
+            inCpY,
+            t1,
+            v1
+        ]);
+    }
+    if (bezierCurves.length === 0) {
+        return undefined;
+    }
+    // Prepend a hold segment if first keyframe is not at t=0
+    var firstT = bezierCurves[0][0];
+    if (firstT > 0) {
+        var firstV = bezierCurves[0][1];
+        bezierCurves.unshift([
+            0,
+            firstV,
+            0,
+            firstV,
+            firstT,
+            firstV,
+            firstT,
+            firstV
+        ]);
+    }
+    // Convert to GE BezierKeyframeValue format
+    var result = [];
+    var totalPoints = bezierCurves.length + 1;
+    for(var i1 = 0; i1 < totalPoints; i1++){
+        if (i1 === 0) {
+            result.push(makeEaseOut(bezierCurves[0]));
+        } else if (i1 === totalPoints - 1) {
+            result.push(makeEaseIn(bezierCurves[i1 - 1]));
+        } else {
+            result.push(makeEase(bezierCurves[i1 - 1], bezierCurves[i1]));
+        }
+    }
+    return result;
+}
+function buildPositionTimingCurves(points) {
+    if (points.length < 2) {
+        return undefined;
+    }
+    // For position, the bezier curve is in time-time domain
+    var bezierCurves = [];
+    for(var i = 0; i < points.length - 1; i++){
+        var current = points[i];
+        var next = points[i + 1];
+        var t0 = current.t;
+        var t1 = next.t;
+        var outCpX = lerp(t0, t1, current.outTangent.x);
+        var outCpY = lerp(t0, t1, current.outTangent.y);
+        // Per IR convention: incoming tangent for segment current→next sits on next.
+        var inCpX = lerp(t0, t1, next.inTangent.x);
+        var inCpY = lerp(t0, t1, next.inTangent.y);
+        bezierCurves.push([
+            t0,
+            t0,
+            outCpX,
+            outCpY,
+            inCpX,
+            inCpY,
+            t1,
+            t1
+        ]);
+    }
+    if (bezierCurves.length === 0) {
+        return undefined;
+    }
+    var result = [];
+    var totalPoints = bezierCurves.length + 1;
+    for(var i1 = 0; i1 < totalPoints; i1++){
+        if (i1 === 0) {
+            result.push(makeEaseOut(bezierCurves[0]));
+        } else if (i1 === totalPoints - 1) {
+            result.push(makeEaseIn(bezierCurves[i1 - 1]));
+        } else {
+            result.push(makeEase(bezierCurves[i1 - 1], bezierCurves[i1]));
+        }
+    }
+    return result;
+}
+/**
+ * Determine if a property has enough keyframes to warrant keyframe mode (pkf/skf/rkf/okf).
+ */ function shouldUseKeyframeMode(property) {
+    return property.keyframed === true && property.keyframes != null && property.keyframes.length > 12;
+}
+
+/**
+ * True when the layer's parent only inherits transform — visibility and
+ * lifetime are independent of the parent's window.
+ *
+ * Reads `IRLayerReference.linkKind` directly. Producers that don't set the
+ * field (e.g. dsl2ge) effectively get `false` here, which is the correct
+ * default for "full" parent containment.
+ *
+ * Lottie's parser sets `linkKind: 'transform-only'` when a child's parent
+ * relationship comes from `layer.parent` rather than precomp expansion;
+ * `applyPostProcess` consumes this to decide whether to advance the parent's
+ * activation track when the child starts earlier.
+ */ function isTransformOnlyParentLink(layer) {
+    var _layer_parent;
+    return ((_layer_parent = layer.parent) == null ? void 0 : _layer_parent.linkKind) === 'transform-only';
+}
+
+/**
+ * Map an IR layer's time range to GE delay/duration in seconds, applying
+ * the time-stretch and offset semantics from `IRTimeContext`.
+ *
+ * dsl-source IRs leave `stretch` and `offsetFrame` undefined, in which case
+ * this collapses to `delay = startFrame / fr` and
+ * `duration = (endFrame - startFrame) / fr` — exactly what dsl2ge used to
+ * compute inline.
+ *
+ * Zero/negative durations are clamped to a 0.0001 epsilon so GE keeps the
+ * activation track alive for the (degenerate) layer.
+ */ function computeLayerTiming(layer, frameRate) {
+    var _time_stretch, _time_offsetFrame;
+    var time = layer.time;
+    var stretch = (_time_stretch = time.stretch) != null ? _time_stretch : 1;
+    var offsetFrame = (_time_offsetFrame = time.offsetFrame) != null ? _time_offsetFrame : 0;
+    var delay = roundNumber((offsetFrame + time.startFrame * stretch) / frameRate, 4);
+    var rawDuration = (time.endFrame - time.startFrame) * stretch / frameRate;
+    var layerDuration = rawDuration > 0 ? roundNumber(rawDuration, 4) : 0.0001;
+    return {
+        delay: delay,
+        layerDuration: layerDuration
+    };
+}
+
+function computeStaticPosition(layer, ctx, anchorOffsetX, anchorOffsetY) {
+    if (anchorOffsetX === void 0) anchorOffsetX = 0;
+    if (anchorOffsetY === void 0) anchorOffsetY = 0;
+    var _transform_position;
+    var transform = layer.transform;
+    if (transform == null ? void 0 : (_transform_position = transform.position) == null ? void 0 : _transform_position.keyframed) {
+        return convert2dTo3dPoint(ctx.width / 2 + anchorOffsetX, ctx.height / 2 + anchorOffsetY, 0, ctx.width, ctx.height);
+    }
+    var isNullType = layer.type === 'null' || layer.type === 'precomp';
+    if ((transform == null ? void 0 : transform.position) != null && Array.isArray(transform.position.value)) {
+        var _pos_, _pos_1, _pos_2;
+        var pos = transform.position.value;
+        return convert2dTo3dPoint(((_pos_ = pos[0]) != null ? _pos_ : 0) + anchorOffsetX, ((_pos_1 = pos[1]) != null ? _pos_1 : 0) + anchorOffsetY, isNullType ? 0 : (_pos_2 = pos[2]) != null ? _pos_2 : 0, ctx.width, ctx.height);
+    }
+    return convert2dTo3dPoint(ctx.width / 2 + anchorOffsetX, ctx.height / 2 + anchorOffsetY, 0, ctx.width, ctx.height);
+}
+function getStaticAnchor(layer) {
+    var _layer_transform;
+    var anchor = (_layer_transform = layer.transform) == null ? void 0 : _layer_transform.anchor;
+    if (anchor != null && !anchor.keyframed && Array.isArray(anchor.value) && anchor.value.length >= 2) {
+        return [
+            anchor.value[0],
+            anchor.value[1]
+        ];
+    }
+    if ((anchor == null ? void 0 : anchor.keyframed) && anchor.keyframes != null && anchor.keyframes.length > 0) {
+        var firstVal = anchor.keyframes[0].value;
+        if (Array.isArray(firstVal) && firstVal.length >= 2) {
+            return [
+                firstVal[0],
+                firstVal[1]
+            ];
+        }
+    }
+    return [
+        0,
+        0
+    ];
+}
+function getStaticScaleFromIR(layer) {
+    var _value_, _value_1;
+    var _layer_transform;
+    var scale = (_layer_transform = layer.transform) == null ? void 0 : _layer_transform.scale;
+    if (scale == null || scale.keyframed) {
+        return [
+            1,
+            1
+        ];
+    }
+    var value = scale.value;
+    if (!Array.isArray(value)) {
+        return [
+            1,
+            1
+        ];
+    }
+    return [
+        (_value_ = value[0]) != null ? _value_ : 1,
+        (_value_1 = value[1]) != null ? _value_1 : 1
+    ];
+}
+function applyScalePositionAdjust(position, layer, layerWidth, layerHeight, ratio) {
+    var staticScale = getStaticScaleFromIR(layer);
+    if (staticScale[0] === 1 && staticScale[1] === 1 || layerWidth <= 0 || layerHeight <= 0) {
+        return position;
+    }
+    var anchor = getStaticAnchor(layer);
+    var anchorDiffX = anchor[0] - layerWidth / 2;
+    var anchorDiffY = anchor[1] - layerHeight / 2;
+    if (Math.abs(anchorDiffX) <= 0.5 && Math.abs(anchorDiffY) <= 0.5) {
+        return position;
+    }
+    return [
+        position[0] + anchorDiffX * (1 - staticScale[0]) * ratio,
+        position[1] - anchorDiffY * (1 - staticScale[1]) * ratio,
+        position[2]
+    ];
+}
+function computeAnchorInfo(layer, layerWidth, layerHeight) {
+    var anchor = getStaticAnchor(layer);
+    var anchorScaleX = 0.5;
+    var anchorScaleY = 0.5;
+    var anchorOffsetX = 0;
+    var anchorOffsetY = 0;
+    if (layerWidth > 0 && layerHeight > 0) {
+        anchorScaleX = anchor[0] / layerWidth;
+        anchorScaleY = anchor[1] / layerHeight;
+        anchorOffsetX = -(anchor[0] - layerWidth / 2);
+        anchorOffsetY = -(anchor[1] - layerHeight / 2);
+    }
+    if (layer.type === 'text' && layer.text != null && layerWidth > 0 && layerHeight > 0) {
+        if (layer.text.anchorAdjust === true) {
+            if (layer.text.textAlign === 'left') {
+                anchorOffsetX = -(anchor[0] - layerWidth / 2);
+                anchorScaleX = anchor[0] / layerWidth - 0.5;
+            }
+            if (layer.text.textAlign === 'center') {
+                anchorOffsetX = -anchor[0];
+                anchorScaleX = anchor[0] / layerWidth + 0.5;
+            }
+            if (layer.text.textAlign === 'right') {
+                anchorOffsetX = -(anchor[0] + layerWidth / 2);
+                anchorScaleX = anchor[0] / layerWidth + 1.5;
+            }
+            // GE renders glyphs in the lower half of the quad, so offset by half the
+            // layer height to align the visible text center with Lottie's anchor.
+            var textHeight = layerHeight / 2;
+            anchorOffsetY = -(anchor[1] + textHeight);
+            anchorScaleY = -anchor[1] / textHeight;
+        }
+    }
+    var isSpriteForAnchor = layer.type === 'image' || layer.type === 'solid';
+    var staticRotationZ = getStaticRotationZ(layer);
+    var hasStaticRotation = staticRotationZ != null;
+    if (isSpriteForAnchor && hasStaticRotation && isTransformOnlyParentLink(layer) && (anchorOffsetX !== 0 || anchorOffsetY !== 0)) {
+        var rotValue = staticRotationZ != null ? staticRotationZ : 0;
+        if (rotValue !== 0) {
+            var rad = rotValue * Math.PI / 180;
+            var cosR = Math.cos(rad);
+            var sinR = Math.sin(rad);
+            var rotatedX = anchorOffsetX * cosR - anchorOffsetY * sinR;
+            var rotatedY = anchorOffsetX * sinR + anchorOffsetY * cosR;
+            anchorOffsetX = rotatedX;
+            anchorOffsetY = rotatedY;
+        }
+    }
+    return {
+        anchorScaleX: anchorScaleX,
+        anchorScaleY: anchorScaleY,
+        anchorOffsetX: anchorOffsetX,
+        anchorOffsetY: anchorOffsetY
+    };
+}
+function getStaticRotationZ(layer) {
+    var _layer_transform, _layer_transform_separatedRotation, _layer_transform1;
+    var rotation = (_layer_transform = layer.transform) == null ? void 0 : _layer_transform.rotation;
+    if (rotation != null && !rotation.keyframed && Array.isArray(rotation.value)) {
+        var _rotation_value_;
+        return (_rotation_value_ = rotation.value[2]) != null ? _rotation_value_ : 0;
+    }
+    var separatedRotationZ = (_layer_transform1 = layer.transform) == null ? void 0 : (_layer_transform_separatedRotation = _layer_transform1.separatedRotation) == null ? void 0 : _layer_transform_separatedRotation.z;
+    if (separatedRotationZ != null && !separatedRotationZ.keyframed && typeof separatedRotationZ.value === 'number') {
+        return separatedRotationZ.value;
+    }
+    return undefined;
+}
+function getTimeContext(layer) {
+    return {
+        startFrame: layer.time.startFrame,
+        endFrame: layer.time.endFrame
+    };
+}
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+
+function readGE2IRMetadata(ir, layer) {
+    if (ir.source !== 'ge') {
+        return undefined;
+    }
+    var metadata = layer.metadata;
+    if (metadata == null) {
+        return undefined;
+    }
+    var namespaced = metadata['ge2ir'];
+    if (isRecord$1(namespaced)) {
+        return namespaced;
+    }
+    var legacy = readLegacyGE2IRMetadata(metadata);
+    return Object.keys(legacy).length > 0 ? legacy : undefined;
+}
+function readLegacyGE2IRMetadata(metadata) {
+    var legacy = {};
+    var positionOverLifetime = metadata['positionOverLifetime'];
+    var rotationOverLifetime = metadata['rotationOverLifetime'];
+    var sizeOverLifetime = metadata['sizeOverLifetime'];
+    var colorOverLifetime = metadata['colorOverLifetime'];
+    var geComponentId = metadata['geComponentId'];
+    var geMask = metadata['geMask'];
+    if (isRecord$1(positionOverLifetime)) {
+        legacy.positionOverLifetime = positionOverLifetime;
+    }
+    if (isRecord$1(rotationOverLifetime)) {
+        legacy.rotationOverLifetime = rotationOverLifetime;
+    }
+    if (isRecord$1(sizeOverLifetime)) {
+        legacy.sizeOverLifetime = sizeOverLifetime;
+    }
+    if (isRecord$1(colorOverLifetime)) {
+        legacy.colorOverLifetime = colorOverLifetime;
+    }
+    if (typeof geComponentId === 'string') {
+        legacy.geComponentId = geComponentId;
+    }
+    if (isRecord$1(geMask)) {
+        legacy.geMask = geMask;
+    }
+    return legacy;
+}
+function isRecord$1(value) {
+    return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
+}
+
+function buildTransformAnimation(layer, ctx) {
+    var transform = layer.transform;
+    if (transform == null) {
+        return {};
+    }
+    var timeContext = getTimeContext(layer);
+    // Passthrough: ge2ir stores raw animation data in metadata to bypass the
+    // IR keyframe conversion pipeline. Raw GE data is used verbatim when
+    // available; otherwise the standard IR → GE conversion runs.
+    var ge2irMetadata = readGE2IRMetadata(ctx.ir, layer);
+    var passthroughPosition = ge2irMetadata == null ? void 0 : ge2irMetadata.positionOverLifetime;
+    var passthroughRotation = ge2irMetadata == null ? void 0 : ge2irMetadata.rotationOverLifetime;
+    var passthroughSize = ge2irMetadata == null ? void 0 : ge2irMetadata.sizeOverLifetime;
+    var positionOverLifetime = passthroughPosition != null ? passthroughPosition : buildPositionAnim(transform, timeContext, ctx);
+    var rotationOverLifetime = passthroughRotation != null ? passthroughRotation : buildRotationAnim(transform, timeContext);
+    var sizeOverLifetime = passthroughSize != null ? passthroughSize : buildSizeAnim(transform, timeContext);
+    return {
+        positionOverLifetime: positionOverLifetime,
+        rotationOverLifetime: rotationOverLifetime,
+        sizeOverLifetime: sizeOverLifetime
+    };
+}
+function buildPositionAnim(transform, timeContext, ctx) {
+    var _posResult_curves_;
+    if (transform.position == null || !transform.position.keyframed) {
+        return undefined;
+    }
+    var posResult = irPositionKeyframesToGE(transform.position, timeContext);
+    if (posResult == null) {
+        return undefined;
+    }
+    var pathPoints = [];
+    var controlPoints = [];
+    var useKeyframeMode = shouldUseKeyframeMode(transform.position);
+    for(var _iterator = _create_for_of_iterator_helper_loose(posResult.pathPoints), _step; !(_step = _iterator()).done;){
+        var pp = _step.value;
+        var point3d = convert2dTo3dPoint(pp[0][0], pp[0][1], 0, ctx.width, ctx.height);
+        pathPoints.push(point3d);
+    }
+    if (posResult.pathPoints.length > 0) {
+        var lastPp = posResult.pathPoints[posResult.pathPoints.length - 1];
+        var lastPoint3d = convert2dTo3dPoint(lastPp[1][0], lastPp[1][1], 0, ctx.width, ctx.height);
+        pathPoints.push(lastPoint3d);
+    }
+    for(var i = 0; i < posResult.controlPoints.length; i++){
+        var cp = posResult.controlPoints[i];
+        var pp1 = posResult.pathPoints[i];
+        if (useKeyframeMode) {
+            var dx = pp1[1][0] - pp1[0][0];
+            var dy = pp1[1][1] - pp1[0][1];
+            var cp1 = convert2dTo3dPoint(dx / 3 + pp1[0][0], dy / 3 + pp1[0][1], 0, ctx.width, ctx.height);
+            var cp2 = convert2dTo3dPoint(-dx / 3 + pp1[1][0], -dy / 3 + pp1[1][1], 0, ctx.width, ctx.height);
+            controlPoints.push(cp1, cp2);
+        } else {
+            var cp11 = convert2dTo3dPoint(cp[0][0] + pp1[0][0], cp[0][1] + pp1[0][1], 0, ctx.width, ctx.height);
+            var cp21 = convert2dTo3dPoint(cp[1][0] + pp1[1][0], cp[1][1] + pp1[1][1], 0, ctx.width, ctx.height);
+            controlPoints.push(cp11, cp21);
+        }
+    }
+    var curveData = (_posResult_curves_ = posResult.curves[0]) != null ? _posResult_curves_ : [];
+    var easingData = curveData.map(function(kf) {
+        return [
+            kf[0],
+            kf[1]
+        ];
+    });
+    var roundedPathPoints = pathPoints.map(function(p) {
+        return [
+            roundNumber(p[0], 4),
+            roundNumber(p[1], 4),
+            p[2]
+        ];
+    });
+    var roundedControlPoints = controlPoints.map(function(p) {
+        return [
+            roundNumber(p[0], 4),
+            roundNumber(p[1], 4),
+            p[2]
+        ];
+    });
+    var pathPayload = [
+        easingData,
+        roundedPathPoints
+    ];
+    if (roundedControlPoints.length > 0) {
+        pathPayload.push(roundedControlPoints);
+    }
+    return {
+        path: [
+            ValueType.BEZIER_CURVE_PATH,
+            pathPayload
+        ]
+    };
+}
+function buildRotationAnim(transform, timeContext) {
+    var result = {};
+    var hasZ = false;
+    var hasX = false;
+    var hasY = false;
+    var rotation = transform.rotation;
+    if (rotation != null) {
+        if (rotation.keyframed) {
+            var _curves_, _curves_1, _curves_2;
+            var curves = irVectorKeyframesToGE(rotation, timeContext);
+            if (curves != null && axisHasRotationValue(rotation, 0) && ((_curves_ = curves[0]) == null ? void 0 : _curves_.length)) {
+                result['x'] = [
+                    ValueType.BEZIER_CURVE,
+                    curves[0]
+                ];
+                hasX = true;
+            }
+            if (curves != null && axisHasRotationValue(rotation, 1) && ((_curves_1 = curves[1]) == null ? void 0 : _curves_1.length)) {
+                result['y'] = [
+                    ValueType.BEZIER_CURVE,
+                    curves[1]
+                ];
+                hasY = true;
+            }
+            if (curves != null && axisHasRotationValue(rotation, 2) && ((_curves_2 = curves[2]) == null ? void 0 : _curves_2.length)) {
+                result['z'] = [
+                    ValueType.BEZIER_CURVE,
+                    curves[2]
+                ];
+                hasZ = true;
+            }
+        } else if (rotation.value != null) {
+            var _rotation_value = rotation.value, tmp = _rotation_value[0], x = tmp === void 0 ? 0 : tmp, tmp1 = _rotation_value[1], y = tmp1 === void 0 ? 0 : tmp1, tmp2 = _rotation_value[2], z = tmp2 === void 0 ? 0 : tmp2;
+            if (Math.abs(x) > 0.0001) {
+                result['x'] = [
+                    ValueType.CONSTANT,
+                    x
+                ];
+                hasX = true;
+            }
+            if (Math.abs(y) > 0.0001) {
+                result['y'] = [
+                    ValueType.CONSTANT,
+                    y
+                ];
+                hasY = true;
+            }
+            if (Math.abs(z) > 0.0001) {
+                result['z'] = [
+                    ValueType.CONSTANT,
+                    z
+                ];
+                hasZ = true;
+            }
+        }
+    } else {
+        var _separated_x, _separated_x1, _separated_y, _separated_y1, _separated_z, _separated_z1;
+        var separated = transform.separatedRotation;
+        if (separated == null ? void 0 : (_separated_x = separated.x) == null ? void 0 : _separated_x.keyframed) {
+            var curves1 = irScalarKeyframesToGE(separated.x, timeContext);
+            if (curves1 != null) {
+                result['x'] = [
+                    ValueType.BEZIER_CURVE,
+                    curves1[0]
+                ];
+                hasX = true;
+            }
+        } else if ((separated == null ? void 0 : (_separated_x1 = separated.x) == null ? void 0 : _separated_x1.value) != null && separated.x.value !== 0) {
+            result['x'] = [
+                ValueType.CONSTANT,
+                separated.x.value
+            ];
+            hasX = true;
+        }
+        if (separated == null ? void 0 : (_separated_y = separated.y) == null ? void 0 : _separated_y.keyframed) {
+            var curves2 = irScalarKeyframesToGE(separated.y, timeContext);
+            if (curves2 != null) {
+                result['y'] = [
+                    ValueType.BEZIER_CURVE,
+                    curves2[0]
+                ];
+                hasY = true;
+            }
+        } else if ((separated == null ? void 0 : (_separated_y1 = separated.y) == null ? void 0 : _separated_y1.value) != null && separated.y.value !== 0) {
+            result['y'] = [
+                ValueType.CONSTANT,
+                separated.y.value
+            ];
+            hasY = true;
+        }
+        if (separated == null ? void 0 : (_separated_z = separated.z) == null ? void 0 : _separated_z.keyframed) {
+            var curves3 = irScalarKeyframesToGE(separated.z, timeContext);
+            if (curves3 != null) {
+                result['z'] = [
+                    ValueType.BEZIER_CURVE,
+                    curves3[0]
+                ];
+                hasZ = true;
+            }
+        } else if ((separated == null ? void 0 : (_separated_z1 = separated.z) == null ? void 0 : _separated_z1.value) != null && separated.z.value !== 0) {
+            result['z'] = [
+                ValueType.CONSTANT,
+                separated.z.value
+            ];
+            hasZ = true;
+        }
+    }
+    if (!hasZ && !hasX && !hasY) {
+        return undefined;
+    }
+    result['asRotation'] = true;
+    var axisCount = (hasX ? 1 : 0) + (hasY ? 1 : 0) + (hasZ ? 1 : 0);
+    if (axisCount > 1 || hasX || hasY) {
+        result['separateAxes'] = true;
+    }
+    return result;
+}
+function axisHasRotationValue(rotation, axis) {
+    var _ref;
+    var _rotation_keyframes;
+    if (!rotation.keyframed) {
+        var _ref1;
+        var _rotation_value;
+        return Math.abs((_ref1 = (_rotation_value = rotation.value) == null ? void 0 : _rotation_value[axis]) != null ? _ref1 : 0) > 0.0001;
+    }
+    return (_ref = (_rotation_keyframes = rotation.keyframes) == null ? void 0 : _rotation_keyframes.some(function(keyframe) {
+        var _keyframe_value_axis, _ref;
+        var _keyframe_endValue;
+        return Math.abs((_keyframe_value_axis = keyframe.value[axis]) != null ? _keyframe_value_axis : 0) > 0.0001 || Math.abs((_ref = (_keyframe_endValue = keyframe.endValue) == null ? void 0 : _keyframe_endValue[axis]) != null ? _ref : 0) > 0.0001;
+    })) != null ? _ref : false;
+}
+function buildSizeAnim(transform, timeContext) {
+    if (transform.scale == null) {
+        return undefined;
+    }
+    if (transform.scale.keyframed) {
+        var curves = irVectorKeyframesToGE(transform.scale, timeContext);
+        if (curves != null && curves.length >= 2) {
+            return _extends({
+                separateAxes: true,
+                x: [
+                    ValueType.BEZIER_CURVE,
+                    curves[0]
+                ],
+                y: [
+                    ValueType.BEZIER_CURVE,
+                    curves[1]
+                ]
+            }, curves.length >= 3 && {
+                z: [
+                    ValueType.BEZIER_CURVE,
+                    curves[2]
+                ]
+            });
+        }
+        return undefined;
+    }
+    var scale = transform.scale.value;
+    if (Array.isArray(scale) && (Math.abs(scale[0] - 1) > 0.0001 || Math.abs(scale[1] - 1) > 0.0001)) {
+        var _scale_;
+        return {
+            separateAxes: true,
+            x: [
+                ValueType.CONSTANT,
+                scale[0]
+            ],
+            y: [
+                ValueType.CONSTANT,
+                scale[1]
+            ],
+            z: [
+                ValueType.CONSTANT,
+                (_scale_ = scale[2]) != null ? _scale_ : 1
+            ]
+        };
+    }
+    return undefined;
+}
+function buildColorAnimation(layer, ir) {
+    var _readGE2IRMetadata;
+    var passthroughColor = (_readGE2IRMetadata = readGE2IRMetadata(ir, layer)) == null ? void 0 : _readGE2IRMetadata.colorOverLifetime;
+    if (passthroughColor != null) {
+        return passthroughColor;
+    }
+    var transform = layer.transform;
+    if ((transform == null ? void 0 : transform.opacity) == null) {
+        return undefined;
+    }
+    var timeContext = getTimeContext(layer);
+    if (timeContext.endFrame - timeContext.startFrame <= 0) {
+        return {
+            opacity: [
+                ValueType.CONSTANT,
+                0
+            ]
+        };
+    }
+    if (transform.opacity.keyframed) {
+        var curves = irScalarKeyframesToGE(transform.opacity, timeContext);
+        if (curves != null) {
+            return {
+                opacity: [
+                    ValueType.BEZIER_CURVE,
+                    curves[0]
+                ]
+            };
+        }
+        return undefined;
+    }
+    var opacityValue = transform.opacity.value;
+    if (typeof opacityValue === 'number' && opacityValue !== 1) {
+        return {
+            opacity: [
+                ValueType.CONSTANT,
+                opacityValue
+            ]
+        };
+    }
+    return undefined;
+}
+
+function buildGETransform(position, eulerHint, scale) {
+    return {
+        position: {
+            x: position[0],
+            y: position[1],
+            z: position[2]
+        },
+        eulerHint: {
+            x: eulerHint[0],
+            y: eulerHint[1],
+            z: eulerHint[2]
+        },
+        scale: {
+            x: scale[0],
+            y: scale[1],
+            z: scale[2]
+        }
+    };
+}
+function getGEItemType(type) {
+    switch(type){
+        case 'image':
+        case 'solid':
+            return 'sprite';
+        case 'text':
+            return 'text';
+        case 'shape':
+            return 'sprite';
+        default:
+            return 'null';
+    }
+}
+function getGEItemTypeCode(type) {
+    switch(type){
+        case 'image':
+        case 'solid':
+            return '1';
+        case 'text':
+            return 'text';
+        case 'shape':
+            return 'shape';
+        default:
+            return '3';
+    }
+}
+function registerTexture(collector, imageUrl, cache) {
+    var cached = cache.get(imageUrl);
+    if (cached != null) {
+        return cached;
+    }
+    var imageId = createId();
+    var textureId = createId();
+    collector.images.push({
+        id: imageId,
+        url: imageUrl
+    });
+    collector.textures.push({
+        id: textureId,
+        dataType: 'Texture',
+        source: toDataPath(imageId),
+        flipY: true
+    });
+    var dataPathRef = toDataPath(textureId);
+    cache.set(imageUrl, dataPathRef);
+    return dataPathRef;
+}
+var _obj$1;
+var GE_BLENDING_BY_IR_MODE = (_obj$1 = {}, _obj$1[IRBlendMode.Normal] = undefined, _obj$1[IRBlendMode.Multiply] = 6, _obj$1[IRBlendMode.Screen] = 9, _obj$1[IRBlendMode.Overlay] = 13, _obj$1[IRBlendMode.Darken] = 2, _obj$1[IRBlendMode.Lighten] = 3, _obj$1[IRBlendMode.ColorDodge] = 10, _obj$1[IRBlendMode.ColorBurn] = 7, _obj$1[IRBlendMode.HardLight] = 14, _obj$1[IRBlendMode.SoftLight] = 15, _obj$1[IRBlendMode.Difference] = 4, _obj$1[IRBlendMode.Exclusion] = 5, _obj$1[IRBlendMode.Hue] = 11, _obj$1[IRBlendMode.Saturation] = 12, _obj$1[IRBlendMode.Color] = 8, _obj$1[IRBlendMode.Luminosity] = 16, _obj$1[IRBlendMode.Add] = 1, _obj$1);
+function mapBlendingMode(blendMode) {
+    if (blendMode == null) {
+        return undefined;
+    }
+    return GE_BLENDING_BY_IR_MODE[blendMode];
+}
+
+var DEFAULT_DISPLAY_SIZE = {
+    width: 1,
+    height: 1
+};
+/**
+ * Read the producer-baked display size from an IR layer. When the producer
+ * did not resolve one, returns `fallback` (defaults to `{ 1, 1 }` — the
+ * value every existing call site was using inline).
+ */ function getLayerDisplaySize(layer, fallback) {
+    if (fallback === void 0) fallback = DEFAULT_DISPLAY_SIZE;
+    var _layer_displaySize;
+    return (_layer_displaySize = layer.displaySize) != null ? _layer_displaySize : fallback;
+}
+
+function buildComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
+    switch(layer.type){
+        case 'image':
+        case 'solid':
+            return buildSpriteComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx);
+        case 'text':
+            return buildTextComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx);
+        case 'shape':
+            return buildShapeComponent(layer, itemId, ctx);
+        default:
+            return undefined;
+    }
+}
+/**
+ * Copy the raw GE mask object (from ge2ir passthrough metadata) onto a freshly
+ * built component, as a top-level `mask` field matching GE's structure. For a
+ * mask SOURCE this carries `{isMask:true, alphaMaskEnabled}`; for a TARGET it
+ * carries `{isMask:false, reference, inverted}` where `reference.id` is still
+ * the stale GE1 component id — `applyGeMaskRemap` rewrites it in post-process.
+ * No-op for non-ge sources (Lottie masks go through the IRLayerNode.mask path).
+ */ function applyGeMask(ir, layer, component) {
+    var _readGE2IRMetadata;
+    var geMask = (_readGE2IRMetadata = readGE2IRMetadata(ir, layer)) == null ? void 0 : _readGE2IRMetadata.geMask;
+    if (geMask != null && component['mask'] == null) {
+        component['mask'] = _extends({}, geMask);
+    }
+}
+function buildSpriteComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
+    var _ref;
+    var _layer_asset, _layer_asset1;
+    var componentId = createId();
+    var blending = mapBlendingMode(layer.blendMode);
+    var startColor = layer.solidColor != null ? [
+        roundNumber(layer.solidColor[0], 4),
+        roundNumber(layer.solidColor[1], 4),
+        roundNumber(layer.solidColor[2], 4),
+        roundNumber(layer.solidColor[3], 4)
+    ] : [
+        1,
+        1,
+        1,
+        1
+    ];
+    var textureDataPath;
+    var textureUrl = (_ref = (_layer_asset = layer.asset) == null ? void 0 : _layer_asset.url) != null ? _ref : (_layer_asset1 = layer.asset) == null ? void 0 : _layer_asset1.refId;
+    if (textureUrl != null && textureUrl !== '' && textureUrl !== 'mask://placeholder') {
+        textureDataPath = registerTexture(ctx.collector, textureUrl, ctx.textureCache);
+    }
+    var component = {
+        id: componentId,
+        dataType: 'SpriteComponent',
+        item: toDataPath(itemId),
+        options: {
+            startColor: startColor
+        },
+        renderer: _extends({
+            renderMode: 1
+        }, blending !== undefined && {
+            blending: blending
+        }, textureDataPath != null && {
+            texture: textureDataPath
+        })
+    };
+    var isNonDefaultAnchor = Math.abs(anchorScaleX - 0.5) > 0.001 || Math.abs(anchorScaleY - 0.5) > 0.001;
+    if (isNonDefaultAnchor) {
+        component['renderer']['anchor'] = [
+            roundNumber(anchorScaleX, 4),
+            roundNumber(anchorScaleY, 4)
+        ];
+    }
+    applyGeMask(ctx.ir, layer, component);
+    ctx.collector.components.push(component);
+    return componentId;
+}
+function buildTextComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
+    var _textInfo_width, _textInfo_height;
+    var textInfo = layer.text;
+    if (textInfo == null) {
+        return undefined;
+    }
+    var componentId = createId();
+    var blending = mapBlendingMode(layer.blendMode);
+    var textColor = [
+        roundNumber(textInfo.color[0], 4),
+        roundNumber(textInfo.color[1], 4),
+        roundNumber(textInfo.color[2], 4),
+        textInfo.color[3]
+    ];
+    var textWidth = (_textInfo_width = textInfo.width) != null ? _textInfo_width : estimateTextWidth(textInfo.content, textInfo.fontSize, textInfo.letterSpacing);
+    var lineHeight = typeof textInfo.lineHeight === 'number' && textInfo.lineHeight > 0 ? textInfo.lineHeight : textInfo.fontSize;
+    var textHeight = Math.max((_textInfo_height = textInfo.height) != null ? _textInfo_height : textInfo.fontSize * 1.2, lineHeight);
+    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var textSizeW = roundNumber(ctx.ratio * layerWidth, 4);
+    var textSizeH = roundNumber(ctx.ratio * layerHeight, 4);
+    var component = {
+        id: componentId,
+        dataType: 'TextComponent',
+        item: toDataPath(itemId),
+        options: {
+            text: textInfo.content,
+            fontSize: textInfo.fontSize,
+            textColor: textColor,
+            fontFamily: textInfo.fontFamily || 'sans-serif',
+            fontWeight: textInfo.fontWeight,
+            textAlign: textInfo.textAlign === 'center' ? 1 : textInfo.textAlign === 'right' ? 2 : 0,
+            fontStyle: textInfo.fontStyle,
+            letterSpace: textInfo.letterSpacing,
+            lineHeight: lineHeight,
+            textWidth: textWidth,
+            textHeight: textHeight,
+            autoWidth: textInfo.autoWidth,
+            size: [
+                textSizeW,
+                textSizeH
+            ]
+        },
+        renderer: _extends({
+            renderMode: 1,
+            anchor: [
+                anchorScaleX,
+                anchorScaleY
+            ]
+        }, blending !== undefined && {
+            blending: blending
+        })
+    };
+    applyGeMask(ctx.ir, layer, component);
+    ctx.collector.components.push(component);
+    return componentId;
+}
+function buildShapeComponent(layer, itemId, ctx) {
+    if (layer.shapes == null || layer.shapes.length === 0) {
+        return undefined;
+    }
+    var shapeData = layer.shapes[0];
+    var componentId = createId();
+    var blending = mapBlendingMode(layer.blendMode);
+    var component = _extends({
+        id: componentId,
+        dataType: 'ShapeComponent',
+        item: toDataPath(itemId)
+    }, buildShapeOptions(shapeData, ctx.ratio, ctx), {
+        renderer: _extends({
+            renderMode: 1
+        }, blending !== undefined && {
+            blending: blending
+        })
+    });
+    applyGeMask(ctx.ir, layer, component);
+    ctx.collector.components.push(component);
+    return componentId;
+}
+function buildShapeOptions(shapeData, ratio, ctx) {
+    var options = {
+        type: mapShapePrimitiveType(shapeData.primitiveType)
+    };
+    if (shapeData.size != null) {
+        options['xSize'] = roundNumber(shapeData.size[0] * ratio, 4);
+        options['ySize'] = roundNumber(shapeData.size[1] * ratio, 4);
+    }
+    setScaledNumber(options, shapeData, 'xRadius', ratio);
+    setScaledNumber(options, shapeData, 'yRadius', ratio);
+    setScaledNumber(options, shapeData, 'width', ratio);
+    setScaledNumber(options, shapeData, 'height', ratio);
+    setScaledNumber(options, shapeData, 'innerRadius', ratio);
+    setScaledNumber(options, shapeData, 'outerRadius', ratio);
+    setScaledNumber(options, shapeData, 'radius', ratio);
+    setRawNumber(options, shapeData, 'roundness');
+    setRawNumber(options, shapeData, 'pointCount');
+    setRawNumber(options, shapeData, 'innerRoundness');
+    setRawNumber(options, shapeData, 'outerRoundness');
+    if (shapeData.fills != null && shapeData.fills.length > 0) {
+        options['fills'] = shapeData.fills.map(function(fill) {
+            return mapShapePaint(fill, ratio, ctx);
+        }).filter(function(fill) {
+            return fill != null;
+        });
+    } else {
+        options['fills'] = [];
+    }
+    if (shapeData.strokes != null && shapeData.strokes.length > 0) {
+        options['strokes'] = shapeData.strokes.map(function(stroke) {
+            return mapShapePaint(stroke, ratio, ctx);
+        }).filter(function(stroke) {
+            return stroke != null;
+        });
+    } else {
+        options['strokes'] = [];
+    }
+    if (typeof shapeData.strokeWidth === 'number') {
+        options['strokeWidth'] = roundNumber(shapeData.strokeWidth * ratio, 4);
+    }
+    if (shapeData.strokeCap != null) {
+        options['strokeCap'] = mapLineCap(shapeData.strokeCap);
+    }
+    if (shapeData.strokeJoin != null) {
+        options['strokeJoin'] = mapLineJoin(shapeData.strokeJoin);
+    }
+    if (shapeData.fillRule != null) {
+        options['fillRule'] = mapShapeFillRule(shapeData.fillRule);
+    }
+    if (shapeData.customPaths != null && shapeData.customPaths.length > 0) {
+        Object.assign(options, mapCustomPaths(shapeData.customPaths, ratio));
+    }
+    if (shapeData.trimPath != null) {
+        options['trimPath'] = shapeData.trimPath;
+    }
+    if (shapeData.repeater != null) {
+        options['repeater'] = shapeData.repeater;
+    }
+    return options;
+}
+var _obj;
+var SHAPE_PRIMITIVE_TYPE_TO_GE = (_obj = {}, _obj[IRShapePrimitiveType.Custom] = 0, _obj[IRShapePrimitiveType.Rectangle] = 1, _obj[IRShapePrimitiveType.Ellipse] = 2, _obj[IRShapePrimitiveType.Polygon] = 3, _obj[IRShapePrimitiveType.Star] = 4, _obj);
+var _obj1;
+var FILL_TYPE_TO_GE = (_obj1 = {}, _obj1[IRFillType.Solid] = 0, _obj1[IRFillType.LinearGradient] = 1, _obj1[IRFillType.RadialGradient] = 2, _obj1[IRFillType.AngularGradient] = 3, _obj1[IRFillType.Texture] = 4, _obj1);
+var _obj2;
+var LINE_CAP_TO_GE = (_obj2 = {}, _obj2[IRLineCap.Butt] = 0, _obj2[IRLineCap.Round] = 1, _obj2[IRLineCap.Square] = 2, _obj2);
+var _obj3;
+var LINE_JOIN_TO_GE = (_obj3 = {}, _obj3[IRLineJoin.Round] = 0, _obj3[IRLineJoin.Bevel] = 1, _obj3[IRLineJoin.Miter] = 2, _obj3);
+var _obj4;
+var SHAPE_FILL_RULE_TO_GE = (_obj4 = {}, _obj4[IRShapeFillRule.NonZero] = 0, _obj4[IRShapeFillRule.EvenOdd] = 1, _obj4);
+function mapShapePrimitiveType(primitiveType) {
+    return SHAPE_PRIMITIVE_TYPE_TO_GE[primitiveType];
+}
+function mapLineCap(lineCap) {
+    var _LINE_CAP_TO_GE_lineCap;
+    return (_LINE_CAP_TO_GE_lineCap = LINE_CAP_TO_GE[lineCap]) != null ? _LINE_CAP_TO_GE_lineCap : 0;
+}
+function mapLineJoin(lineJoin) {
+    var _LINE_JOIN_TO_GE_lineJoin;
+    return (_LINE_JOIN_TO_GE_lineJoin = LINE_JOIN_TO_GE[lineJoin]) != null ? _LINE_JOIN_TO_GE_lineJoin : 2;
+}
+function mapShapeFillRule(fillRule) {
+    var _SHAPE_FILL_RULE_TO_GE_fillRule;
+    return (_SHAPE_FILL_RULE_TO_GE_fillRule = SHAPE_FILL_RULE_TO_GE[fillRule]) != null ? _SHAPE_FILL_RULE_TO_GE_fillRule : 0;
+}
+function mapShapePaint(paint, ratio, ctx) {
+    if (paint.type === IRFillType.Solid) {
+        return {
+            type: FILL_TYPE_TO_GE[paint.type],
+            color: colorToGE(paint.color)
+        };
+    }
+    if (paint.type === IRFillType.LinearGradient || paint.type === IRFillType.RadialGradient || paint.type === IRFillType.AngularGradient) {
+        return _extends({
+            type: FILL_TYPE_TO_GE[paint.type],
+            gradientStops: [
+                ValueType.GRADIENT_COLOR,
+                paint.gradientStops
+            ],
+            startPoint: vec2ToGE(paint.gradientStart, ratio),
+            endPoint: vec2ToGE(paint.gradientEnd, ratio)
+        }, paint.color != null && {
+            color: colorToGE(paint.color)
+        });
+    }
+    if (paint.type === IRFillType.Texture) {
+        var _ref, _paint_texture_url, _paint_scaleMode;
+        var textureUrl = (_ref = (_paint_texture_url = paint.texture.url) != null ? _paint_texture_url : paint.texture.refId) != null ? _ref : paint.texture.id;
+        var texture = textureUrl != null && ctx != null ? registerTexture(ctx.collector, textureUrl, ctx.textureCache) : undefined;
+        return _extends({
+            type: FILL_TYPE_TO_GE[paint.type]
+        }, texture != null && {
+            texture: texture
+        }, {
+            scaleMode: (_paint_scaleMode = paint.scaleMode) != null ? _paint_scaleMode : 0
+        });
+    }
+    return undefined;
+}
+function colorToGE(color) {
+    return {
+        r: roundNumber(color[0], 4),
+        g: roundNumber(color[1], 4),
+        b: roundNumber(color[2], 4),
+        a: roundNumber(color[3], 4)
+    };
+}
+function vec2ToGE(value, ratio) {
+    var _ref, _ref1;
+    return {
+        x: roundNumber(((_ref = value == null ? void 0 : value[0]) != null ? _ref : 0) * ratio, 4),
+        y: roundNumber(-((_ref1 = value == null ? void 0 : value[1]) != null ? _ref1 : 0) * ratio, 4)
+    };
+}
+function mapCustomPaths(paths, ratio) {
+    var points = [];
+    var easingIns = [];
+    var easingOuts = [];
+    var shapes = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(paths), _step; !(_step = _iterator()).done;){
+        var path = _step.value;
+        var indexes = [];
+        for(var index = 0; index < path.points.length; index++){
+            var _ref, _ref1, _ref2, _ref3;
+            var point = path.points[index];
+            var easingIn = path.easingIns[index];
+            var easingOut = path.easingOuts[index];
+            var pointIndex = points.length;
+            points.push({
+                x: roundNumber(point.x * ratio, 4),
+                y: roundNumber(-point.y * ratio, 4)
+            });
+            easingIns.push({
+                x: roundNumber(((_ref = easingIn == null ? void 0 : easingIn.x) != null ? _ref : 0) * ratio, 4),
+                y: roundNumber(-((_ref1 = easingIn == null ? void 0 : easingIn.y) != null ? _ref1 : 0) * ratio, 4)
+            });
+            easingOuts.push({
+                x: roundNumber(((_ref2 = easingOut == null ? void 0 : easingOut.x) != null ? _ref2 : 0) * ratio, 4),
+                y: roundNumber(-((_ref3 = easingOut == null ? void 0 : easingOut.y) != null ? _ref3 : 0) * ratio, 4)
+            });
+            indexes.push({
+                point: pointIndex,
+                easingIn: pointIndex,
+                easingOut: pointIndex
+            });
+        }
+        shapes.push({
+            close: path.close,
+            indexes: indexes
+        });
+    }
+    return {
+        points: points,
+        easingIns: easingIns,
+        easingOuts: easingOuts,
+        shapes: shapes
+    };
+}
+function setScaledNumber(options, shapeData, key, ratio) {
+    var value = shapeData[key];
+    if (typeof value === 'number') {
+        options[key] = roundNumber(value * ratio, 4);
+    }
+}
+function setRawNumber(options, shapeData, key) {
+    var value = shapeData[key];
+    if (typeof value === 'number') {
+        options[key] = value;
+    }
+}
+
+function getStaticAnchorBehavior(ir, layer) {
+    if (layer.transformSplit === true) {
+        return {
+            kind: 'split-null-sprite'
+        };
+    }
+    // B-class real semantic difference — kept as source branch because pre-baking
+    // anchorScale/anchorOffset into the IR would require pulling computeAnchorInfo's
+    // full input set (text anchorAdjust, static-rotation anchor rotation, display
+    // size fallback) into the producer, at high cost with no readability benefit.
+    // The split gate itself is already pre-baked via `transformSplit` above.
+    //
+    // ge source shares the lottie inline-anchor math: ge2ir reverses GE's
+    // `renderer.anchor` into IRLayerNode.transform.anchor (px) + displaySize, so
+    // computeAnchorInfo reproduces the exact anchorScale/anchorOffset that GE had.
+    // Without this, ge layers fall through to the centered [0.5,0.5] default and
+    // their authored anchor (e.g. a top-anchored sweep) is lost on round-trip.
+    // ge never reaches the lottieNeedsTransformSplit geometry check — its split
+    // decision is pre-baked via `transformSplit` by the ge2ir null+sprite merger.
+    if (ir.source === 'lottie' || ir.source === 'ge') {
+        if (ir.source === 'lottie' && lottieNeedsTransformSplit(layer)) {
+            return {
+                kind: 'split-null-sprite'
+            };
+        }
+        // The inline-anchor math needs non-zero dimensions to avoid divide-by-zero
+        // in `computeAnchorInfo`; substitute the legacy {1, 1} fallback at the call site
+        // so the field-level default stays neutral.
+        var _getLayerDisplaySize = getLayerDisplaySize(layer), width = _getLayerDisplaySize.width, height = _getLayerDisplaySize.height;
+        var info = computeAnchorInfo(layer, width, height);
+        return {
+            kind: 'inline-anchor',
+            anchorScale: [
+                info.anchorScaleX,
+                info.anchorScaleY
+            ],
+            anchorOffset: [
+                info.anchorOffsetX,
+                info.anchorOffsetY
+            ]
+        };
+    }
+    // dsl layers with off-center anchor have `transformSplit = true` set by the
+    // producer, caught by the guard at the top. Any layer reaching here is
+    // centered — return the default inline-anchor.
+    return {
+        kind: 'inline-anchor',
+        anchorScale: [
+            0.5,
+            0.5
+        ],
+        anchorOffset: [
+            0,
+            0
+        ]
+    };
+}
+function lottieNeedsTransformSplit(layer) {
+    var _transform_rotation, _sep_x, _sep_y, _sep_z, _transform_scale;
+    if (layer.type !== 'image' && layer.type !== 'solid') {
+        return false;
+    }
+    // Without a producer-baked displaySize we cannot decide off-center;
+    // fall through to inline-anchor (matches the pre-displaySize behavior
+    // where missing dimensions returned the {1, 1} default and never split).
+    var size = layer.displaySize;
+    if (size == null) {
+        return false;
+    }
+    var width = size.width, height = size.height;
+    if (width <= 0 || height <= 0) {
+        return false;
+    }
+    var anchor = getStaticAnchor(layer);
+    var anchorOffCenter = Math.abs(anchor[0] - width / 2) > 0.5 || Math.abs(anchor[1] - height / 2) > 0.5;
+    if (!anchorOffCenter) {
+        return false;
+    }
+    var transform = layer.transform;
+    var sep = transform == null ? void 0 : transform.separatedRotation;
+    var hasRotationAnim = (transform == null ? void 0 : (_transform_rotation = transform.rotation) == null ? void 0 : _transform_rotation.keyframed) === true || (sep == null ? void 0 : (_sep_x = sep.x) == null ? void 0 : _sep_x.keyframed) === true || (sep == null ? void 0 : (_sep_y = sep.y) == null ? void 0 : _sep_y.keyframed) === true || (sep == null ? void 0 : (_sep_z = sep.z) == null ? void 0 : _sep_z.keyframed) === true;
+    var hasScaleAnim = (transform == null ? void 0 : (_transform_scale = transform.scale) == null ? void 0 : _transform_scale.keyframed) === true;
+    return hasRotationAnim || hasScaleAnim;
+}
+
+function processNullLayer(layer, ctx) {
+    var itemId = createId();
+    var layerIndex = layer.index;
+    ctx.layerToItemId[layerIndex] = itemId;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var animation = buildTransformAnimation(layer, ctx);
+    var position = computeStaticPosition(layer, ctx);
+    var objectBindingTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 4, animation, 'null');
+    var item = {
+        id: itemId,
+        dataType: 'VFXItemData',
+        name: layer.name,
+        duration: layerDuration,
+        type: '3',
+        visible: layer.visibility.enabled && !layer.visibility.hidden,
+        endBehavior: 4,
+        delay: delay,
+        renderLevel: 'B+',
+        content: {
+            options: {
+                startColor: [
+                    1,
+                    1,
+                    1,
+                    1
+                ]
+            }
+        },
+        components: [],
+        transform: buildGETransform(position, [
+            0,
+            0,
+            0
+        ], [
+            1,
+            1,
+            1
+        ])
+    };
+    ctx.collector.items.push(item);
+    ctx.processedItems.push({
+        itemId: itemId,
+        objectBindingTrackId: objectBindingTrackId,
+        layerIndex: layerIndex
+    });
+}
+/**
+ * Emit a null+sprite pair: the null carries the layer transform and sits at
+ * the layer's logical position; the sprite/text child carries the visual
+ * content offset by the anchor so the pivot is at the right point.
+ *
+ * Used by both `processParentLayer` (layers referenced as `parent` by others)
+ * and `processTransformSplitLayer` (layers with `transformSplit=true`). The
+ * only knob is `childScale` — parent-layer callers pass a text-aware scale
+ * while transformSplit always uses `[1, 1, 1]`.
+ */ function emitNullSpritePair(layer, ctx, childScale) {
+    var layerIndex = layer.index;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var nullItemId = createId();
+    ctx.layerToItemId[layerIndex] = nullItemId;
+    var nullAnimation = buildTransformAnimation(layer, ctx);
+    var nullPosition = computeStaticPosition(layer, ctx);
+    var nullTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 4, nullAnimation, 'null');
+    var nullItem = {
+        id: nullItemId,
+        dataType: 'VFXItemData',
+        name: layer.name,
+        duration: layerDuration,
+        type: '3',
+        visible: true,
+        endBehavior: 4,
+        delay: delay,
+        renderLevel: 'B+',
+        content: {
+            options: {
+                startColor: [
+                    1,
+                    1,
+                    1,
+                    1
+                ]
+            }
+        },
+        components: [],
+        transform: buildGETransform(nullPosition, [
+            0,
+            0,
+            0
+        ], [
+            1,
+            1,
+            1
+        ])
+    };
+    ctx.collector.items.push(nullItem);
+    ctx.processedItems.push({
+        itemId: nullItemId,
+        objectBindingTrackId: nullTrackId,
+        layerIndex: layerIndex
+    });
+    var childItemId = createId();
+    var anchor = getStaticAnchor(layer);
+    var childPosition = [
+        -ctx.ratio * (anchor[0] - layerWidth / 2),
+        ctx.ratio * (anchor[1] - layerHeight / 2),
+        0
+    ];
+    var childColorAnim = buildColorAnimation(layer, ctx.ir);
+    var childTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 0, {
+        colorOverLifetime: childColorAnim
+    }, getGEItemType(layer.type));
+    var componentId = buildComponent(layer, childItemId, 0.5, 0.5, ctx);
+    if (componentId != null) {
+        ctx.layerToComponentId[layerIndex] = componentId;
+    }
+    var scaledW = roundNumber(ctx.ratio * layerWidth, 4);
+    var scaledH = roundNumber(ctx.ratio * layerHeight, 4);
+    var childItem = {
+        id: childItemId,
+        dataType: 'VFXItemData',
+        name: layer.name,
+        duration: layerDuration,
+        type: getGEItemTypeCode(layer.type),
+        visible: layer.visibility.enabled && !layer.visibility.hidden,
+        endBehavior: 0,
+        delay: delay,
+        renderLevel: 'B+',
+        components: componentId != null ? [
+            toDataPath(componentId)
+        ] : [],
+        transform: _extends({}, buildGETransform(childPosition, [
+            0,
+            0,
+            0
+        ], childScale), {
+            anchor: {
+                x: 0,
+                y: 0
+            },
+            size: {
+                x: scaledW,
+                y: scaledH
+            }
+        }),
+        parentId: nullItemId
+    };
+    ctx.collector.items.push(childItem);
+    ctx.processedItems.push({
+        itemId: childItemId,
+        objectBindingTrackId: childTrackId,
+        layerIndex: layerIndex
+    });
+}
+function processParentLayer(layer, ctx) {
+    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var scaledW = roundNumber(ctx.ratio * layerWidth, 4);
+    var scaledH = roundNumber(ctx.ratio * layerHeight, 4);
+    var childScale = layer.type === 'text' ? [
+        scaledW,
+        scaledH,
+        1
+    ] : [
+        1,
+        1,
+        1
+    ];
+    emitNullSpritePair(layer, ctx, childScale);
+}
+function processVisualLayer(layer, ctx) {
+    if (layer.type === 'shape' && layer.shapes != null && layer.shapes.length > 0) {
+        processShapeLayerMultiItem(layer, ctx);
+        return;
+    }
+    var strategy = getStaticAnchorBehavior(ctx.ir, layer);
+    if (strategy.kind === 'split-null-sprite') {
+        processTransformSplitLayer(layer, ctx);
+        return;
+    }
+    var itemId = createId();
+    var layerIndex = layer.index;
+    ctx.layerToItemId[layerIndex] = itemId;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var scaledW = ctx.ratio * layerWidth;
+    var scaledH = ctx.ratio * layerHeight;
+    var _strategy_anchorScale = strategy.anchorScale, anchorScaleX = _strategy_anchorScale[0], anchorScaleY = _strategy_anchorScale[1];
+    var _strategy_anchorOffset = strategy.anchorOffset, anchorOffsetX = _strategy_anchorOffset[0], anchorOffsetY = _strategy_anchorOffset[1];
+    var animation = buildTransformAnimation(layer, ctx);
+    var colorAnimation = buildColorAnimation(layer, ctx.ir);
+    var fullAnimation = _extends({}, animation, {
+        colorOverLifetime: colorAnimation
+    });
+    var rawPosition = computeStaticPosition(layer, ctx, anchorOffsetX, anchorOffsetY);
+    var position = applyScalePositionAdjust(rawPosition, layer, layerWidth, layerHeight, ctx.ratio);
+    var itemType = getGEItemType(layer.type);
+    var objectBindingTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 0, fullAnimation, itemType);
+    var componentId = buildComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx);
+    if (componentId != null) {
+        ctx.layerToComponentId[layerIndex] = componentId;
+    }
+    // GE 2.x TextComponent.updateTexture overwrites transform.size to
+    // (textWidth × 0.0123, textHeight × 0.0123) regardless of what we emit,
+    // so the only knob left to control on-screen size is transform.scale.
+    // Pre-bake it so version36Migration's scaleFactor = (preScale / textWidth) / 0.0123
+    // resolves to ctx.ratio / 0.0123 — the correct ratio for this composition.
+    var itemScale = layer.type === 'text' ? [
+        scaledW,
+        scaledH,
+        1
+    ] : [
+        1,
+        1,
+        1
+    ];
+    var item = {
+        id: itemId,
+        dataType: 'VFXItemData',
+        name: layer.name,
+        duration: layerDuration,
+        type: getGEItemTypeCode(layer.type),
+        visible: layer.visibility.enabled && !layer.visibility.hidden,
+        endBehavior: 0,
+        delay: delay,
+        renderLevel: 'B+',
+        components: componentId != null ? [
+            toDataPath(componentId)
+        ] : [],
+        transform: _extends({}, buildGETransform(position, [
+            0,
+            0,
+            0
+        ], itemScale), {
+            anchor: {
+                x: 0,
+                y: 0
+            },
+            size: {
+                x: roundNumber(scaledW, 4),
+                y: roundNumber(scaledH, 4)
+            }
+        })
+    };
+    ctx.collector.items.push(item);
+    ctx.processedItems.push({
+        itemId: itemId,
+        objectBindingTrackId: objectBindingTrackId,
+        layerIndex: layerIndex
+    });
+}
+function processTransformSplitLayer(layer, ctx) {
+    emitNullSpritePair(layer, ctx, [
+        1,
+        1,
+        1
+    ]);
+}
+function processShapeLayerMultiItem(layer, ctx) {
+    var layerIndex = layer.index;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var anchor = getStaticAnchor(layer);
+    var _computeAnchorInfo = computeAnchorInfo(layer, layerWidth, layerHeight), anchorOffsetX = _computeAnchorInfo.anchorOffsetX, anchorOffsetY = _computeAnchorInfo.anchorOffsetY;
+    var animation = buildTransformAnimation(layer, ctx);
+    var colorAnimation = buildColorAnimation(layer, ctx.ir);
+    var fullAnimation = _extends({}, animation, {
+        colorOverLifetime: colorAnimation
+    });
+    var basePosition = computeStaticPosition(layer, ctx, anchorOffsetX, anchorOffsetY);
+    var blending = mapBlendingMode(layer.blendMode);
+    for(var shapeIdx = 0; shapeIdx < layer.shapes.length; shapeIdx++){
+        var shapeData = layer.shapes[shapeIdx];
+        var shapeItemId = createId();
+        if (shapeIdx === 0) {
+            ctx.layerToItemId[layerIndex] = shapeItemId;
+        }
+        var shapeOffsetX = ctx.ratio * (shapeData.position[0] - anchor[0]);
+        var shapeOffsetY = -ctx.ratio * (shapeData.position[1] - anchor[1]);
+        var shapePosition = [
+            basePosition[0] + shapeOffsetX,
+            basePosition[1] + shapeOffsetY,
+            basePosition[2]
+        ];
+        var shapeComponentId = createId();
+        var component = _extends({
+            id: shapeComponentId,
+            dataType: 'ShapeComponent',
+            item: toDataPath(shapeItemId)
+        }, buildShapeOptions(shapeData, ctx.ratio, ctx), {
+            renderer: _extends({
+                renderMode: 1
+            }, blending !== undefined && {
+                blending: blending
+            })
+        });
+        // Mask source shape (isMask:true) — copy onto the first shape item only.
+        if (shapeIdx === 0) {
+            applyGeMask(ctx.ir, layer, component);
+        }
+        ctx.collector.components.push(component);
+        if (shapeIdx === 0) {
+            ctx.layerToComponentId[layerIndex] = shapeComponentId;
+        }
+        var objectBindingTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 0, fullAnimation, 'shape');
+        var shapeItem = {
+            id: shapeItemId,
+            dataType: 'VFXItemData',
+            name: shapeIdx === 0 ? layer.name : layer.name + "_shape_" + shapeIdx,
+            duration: layerDuration,
+            type: 'shape',
+            visible: layer.visibility.enabled && !layer.visibility.hidden,
+            endBehavior: 0,
+            delay: delay,
+            renderLevel: 'B+',
+            components: [
+                toDataPath(shapeComponentId)
+            ],
+            transform: _extends({}, buildGETransform(shapePosition, [
+                0,
+                0,
+                0
+            ], [
+                1,
+                1,
+                1
+            ]), {
+                anchor: {
+                    x: 0,
+                    y: 0
+                }
+            })
+        };
+        ctx.collector.items.push(shapeItem);
+        ctx.processedItems.push({
+            itemId: shapeItemId,
+            objectBindingTrackId: objectBindingTrackId,
+            layerIndex: layerIndex
+        });
+    }
+}
+
+var DEFAULT_PLAYER_VERSION = {
+    web: '2.8.9',
+    native: '0.0.1.202311221223'
+};
+/**
+ * Assemble the top-level GE JSONScene wrapper from a populated collector.
+ *
+ * Reads composition-level properties (`name`, `width`/`height`, `endBehavior`,
+ * `backgroundColor`) directly from the IR. The optional `duration` arg is a
+ * caller override — when omitted, derived from `(outPoint - inPoint) / frameRate`.
+ */ function assembleScene(ir, collector, processedItems, duration) {
+    var finalDuration = duration != null ? duration : deriveDuration(ir);
+    var timelineAssetId = createId();
+    var objectBindingTrackRefs = processedItems.map(function(pi) {
+        return toDataPath(pi.objectBindingTrackId);
+    });
+    collector.miscs.push({
+        id: timelineAssetId,
+        dataType: 'TimelineAsset',
+        tracks: objectBindingTrackRefs
+    });
+    var compositionComponentId = createId();
+    var compositionId = createId();
+    var sceneBindings = processedItems.map(function(pi) {
+        return {
+            key: toDataPath(pi.objectBindingTrackId),
+            value: toDataPath(pi.itemId)
+        };
+    });
+    var allItemRefs = processedItems.map(function(pi) {
+        return toDataPath(pi.itemId);
+    });
+    collector.components.push({
+        id: compositionComponentId,
+        dataType: 'CompositionComponent',
+        item: toDataPath(compositionId),
+        items: allItemRefs,
+        timelineAsset: toDataPath(timelineAssetId),
+        sceneBindings: sceneBindings
+    });
+    var composition = {
+        id: compositionId,
+        name: ir.name,
+        duration: finalDuration,
+        startTime: 0,
+        endBehavior: mapCompositionEndBehavior(ir.endBehavior),
+        previewSize: [
+            ir.width,
+            ir.height
+        ],
+        camera: {
+            fov: DEFAULT_CAMERA_FOV,
+            far: 40,
+            near: 0.1,
+            clipMode: DEFAULT_CLIP_MODE,
+            position: [
+                0,
+                0,
+                DEFAULT_CAMERA_Z
+            ],
+            rotation: [
+                0,
+                0,
+                0
+            ]
+        },
+        components: [
+            toDataPath(compositionComponentId)
+        ]
+    };
+    if (ir.backgroundColor != null) {
+        composition['background'] = {
+            color: colorToRoundedRgba(ir.backgroundColor)
+        };
+    }
+    return {
+        version: JSONSceneVersion['3_6'],
+        playerVersion: DEFAULT_PLAYER_VERSION,
+        images: collector.images,
+        fonts: [],
+        plugins: [],
+        type: 'ge',
+        compositionId: compositionId,
+        compositions: [
+            composition
+        ],
+        components: collector.components,
+        geometries: [],
+        materials: [],
+        items: collector.items,
+        shaders: [],
+        bins: [],
+        textures: collector.textures,
+        animations: [],
+        miscs: collector.miscs
+    };
+}
+function deriveDuration(ir) {
+    return ir.frameRate > 0 ? (ir.outPoint - ir.inPoint) / ir.frameRate : 0;
+}
+/**
+ * Map IR composition end behavior to GE's numeric end-behavior.
+ * Lottie IR currently leaves this unset; treat undefined as Loop (5) so the
+ * legacy lottie behavior is preserved. dsl2ge writes either Loop or Stop.
+ */ function mapCompositionEndBehavior(eb) {
+    if (eb == null || eb === IREndBehavior.Loop) {
+        return 5;
+    }
+    if (eb === IREndBehavior.Hold) {
+        return 4;
+    }
+    return 0;
+}
+function colorToRoundedRgba(color) {
+    return [
+        roundNumber(color[0]),
+        roundNumber(color[1]),
+        roundNumber(color[2]),
+        roundNumber(color[3], 4)
+    ];
+}
+
+function applyParenting(layers, items, layerToItemId, ratio, width, height) {
+    var layerByIndex = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        layerByIndex.set(layer.index, layer);
+    }
+    var itemById = new Map();
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(items), _step1; !(_step1 = _iterator1()).done;){
+        var item = _step1.value;
+        itemById.set(item.id, item);
+    }
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(layers), _step2; !(_step2 = _iterator2()).done;){
+        var layer1 = _step2.value;
+        if (layer1.parent == null) {
+            continue;
+        }
+        var childItemId = layerToItemId[layer1.index];
+        var parentLayer = layerByIndex.get(layer1.parent.index);
+        if (parentLayer == null || childItemId == null) {
+            continue;
+        }
+        var parentItemId = layerToItemId[parentLayer.index];
+        if (parentItemId == null) {
+            continue;
+        }
+        var childItem = itemById.get(childItemId);
+        if (childItem == null) {
+            continue;
+        }
+        childItem.parentId = parentItemId;
+        var parentAnchor = getStaticAnchor(parentLayer);
+        var adjustX = -ratio * (parentAnchor[0] - width / 2);
+        var adjustY = ratio * (parentAnchor[1] - height / 2);
+        childItem.transform.position.x += adjustX;
+        childItem.transform.position.y += adjustY;
+    }
+}
+
+function applyMasks(ir, collector, processedItems, ratio, width, height, frameRate, lookup) {
+    var layers = ir.layers;
+    var maskSlotMeta = new Map();
+    var componentById = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(collector.components), _step; !(_step = _iterator()).done;){
+        var comp = _step.value;
+        componentById.set(comp['id'], comp);
+    }
+    for(var i = layers.length - 1; i >= 0; i--){
+        var layer = layers[i];
+        var maskData = layer.mask;
+        if (maskData == null) {
+            continue;
+        }
+        if (isMaskExactCrop(maskData, layer, width, height, lookup)) {
+            continue;
+        }
+        var layerItemId = lookup.getItemId(layer.index);
+        if (layerItemId == null) {
+            continue;
+        }
+        var layerComponentId = lookup.getComponentId(layer.index);
+        buildMaskForLayer(layer, layerItemId, layerComponentId, collector, processedItems, ratio, width, height, frameRate, lookup, maskSlotMeta, componentById, maskData);
+    }
+}
+function getPrimaryPath(mask) {
+    return mask.paths[0];
+}
+function buildMaskForLayer(layer, layerItemId, layerComponentId, collector, processedItems, ratio, width, height, frameRate, lookup, maskSlotMeta, componentById, maskData) {
+    var mask = maskData != null ? maskData : layer.mask;
+    var maskItemId = createId();
+    var maskComponentId = createId();
+    var maskBounds = getMaskBounds(mask);
+    var _getStaticAnchor = getStaticAnchor(layer), anchorX = _getStaticAnchor[0], anchorY = _getStaticAnchor[1];
+    var maskPosX = roundNumber((maskBounds.cx - anchorX) * ratio, 4);
+    var maskPosY = roundNumber(-(maskBounds.cy - anchorY) * ratio, 4);
+    var timing = computeLayerTiming(layer, frameRate);
+    var delay = timing.delay;
+    var maskDuration = timing.layerDuration;
+    var layerIsParent = lookup.isParentLayer(layer.index) || layer.type === 'null' || layer.type === 'precomp';
+    var isAutoMask = mask.isAutoMask === true;
+    var maskArea = maskBounds.width * maskBounds.height;
+    if (layerIsParent) {
+        var hasDescendants = hasClaimableRendererDescendants(collector.items, componentById, layerItemId, isAutoMask, maskArea, maskSlotMeta);
+        if (!hasDescendants) {
+            return;
+        }
+    }
+    var maskItem = {
+        id: maskItemId,
+        dataType: 'VFXItemData',
+        name: "" + layer.name + "_mask",
+        duration: maskDuration,
+        type: 'shape',
+        visible: true,
+        endBehavior: 0,
+        delay: roundNumber(delay, 4),
+        renderLevel: 'B+',
+        components: [
+            toDataPath(maskComponentId)
+        ],
+        transform: {
+            position: {
+                x: maskPosX,
+                y: maskPosY,
+                z: 0
+            },
+            eulerHint: {
+                x: 0,
+                y: 0,
+                z: 0
+            },
+            anchor: {
+                x: 0,
+                y: 0
+            },
+            scale: {
+                x: 1,
+                y: 1,
+                z: 1
+            }
+        },
+        parentId: layerItemId
+    };
+    var maskComponent = isSimpleRectMask(mask) ? {
+        id: maskComponentId,
+        item: toDataPath(maskItemId),
+        type: 1,
+        dataType: 'ShapeComponent',
+        width: roundNumber(maskBounds.width * ratio, 4),
+        height: roundNumber(maskBounds.height * ratio, 4),
+        roundness: 0,
+        fills: [
+            {
+                type: 0,
+                color: {
+                    r: 1,
+                    g: 1,
+                    b: 1,
+                    a: 0
+                }
+            }
+        ],
+        strokes: [],
+        strokeWidth: 0,
+        strokeCap: 0,
+        strokeJoin: 0,
+        renderer: {
+            renderMode: 1
+        },
+        mask: {
+            isMask: true,
+            alphaMaskEnabled: false
+        }
+    } : buildPolygonMaskComponent(maskComponentId, maskItemId, mask, maskBounds, ratio);
+    collector.items.push(maskItem);
+    collector.components.push(maskComponent);
+    componentById.set(maskComponentId, maskComponent);
+    if (layerIsParent) {
+        applyMaskReferenceToDescendants(collector.items, componentById, layerItemId, maskComponentId, isAutoMask, maskArea, maskSlotMeta);
+    } else if (layerComponentId != null) {
+        var targetComponent = componentById.get(layerComponentId);
+        if (targetComponent != null) {
+            targetComponent['mask'] = buildMaskRef(maskComponentId);
+            maskSlotMeta.set(layerComponentId, {
+                isAutoMask: isAutoMask,
+                area: maskArea
+            });
+        }
+    }
+    var maskTrackId = buildTimelineTracks(collector, delay, maskDuration, 0, {}, 'shape');
+    processedItems.push({
+        itemId: maskItemId,
+        objectBindingTrackId: maskTrackId,
+        layerIndex: -1
+    });
+}
+function buildMaskRef(maskComponentId) {
+    return {
+        isMask: false,
+        reference: toDataPath(maskComponentId),
+        inverted: false
+    };
+}
+function applyMaskReferenceToDescendants(items, componentById, parentItemId, maskComponentId, isAutoMask, maskArea, maskSlotMeta) {
+    function visit(targetParentId) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
+            var item = _step.value;
+            if (item.parentId !== targetParentId) {
+                continue;
+            }
+            if (item.type === 'shape' && item.name.endsWith('_mask')) {
+                continue;
+            }
+            var componentRefs = item.components;
+            if (componentRefs != null && componentRefs.length > 0) {
+                var compRef = componentRefs[0];
+                var component = componentById.get(compRef.id);
+                if (component != null && component['renderer'] != null && shouldClaimMaskSlot(component['mask'] != null, maskSlotMeta.get(compRef.id), isAutoMask, maskArea)) {
+                    component['mask'] = buildMaskRef(maskComponentId);
+                    maskSlotMeta.set(compRef.id, {
+                        isAutoMask: isAutoMask,
+                        area: maskArea
+                    });
+                }
+            }
+            visit(item.id);
+        }
+    }
+    visit(parentItemId);
+}
+/**
+ * Decide whether a propagating mask should take a renderer component's single
+ * mask slot. Preserves the original arbitration: an empty slot is always taken;
+ * an authored mask is never displaced; an auto mask yields to an authored mask
+ * or to a tighter (smaller-area) auto mask.
+ */ function shouldClaimMaskSlot(hasExistingMask, existing, isAutoMask, maskArea) {
+    if (!hasExistingMask) {
+        return true;
+    }
+    if ((existing == null ? void 0 : existing.isAutoMask) !== true) {
+        return false;
+    }
+    if (!isAutoMask) {
+        return true;
+    }
+    return maskArea < existing.area;
+}
+function hasClaimableRendererDescendants(items, componentById, parentItemId, isCurrentAutoMask, currentMaskArea, maskSlotMeta) {
+    function visit(targetParentId) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
+            var item = _step.value;
+            if (item.parentId !== targetParentId) {
+                continue;
+            }
+            var componentRefs = item.components;
+            if (componentRefs != null && componentRefs.length > 0) {
+                var compRef = componentRefs[0];
+                var component = componentById.get(compRef.id);
+                if (component != null && component['renderer'] != null && shouldClaimMaskSlot(component['mask'] != null, maskSlotMeta.get(compRef.id), isCurrentAutoMask, currentMaskArea)) {
+                    return true;
+                }
+            }
+            if (visit(item.id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return visit(parentItemId);
+}
+function computePointBounds(points) {
+    var minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for(var _iterator = _create_for_of_iterator_helper_loose(points), _step; !(_step = _iterator()).done;){
+        var point = _step.value;
+        minX = Math.min(minX, point.x);
+        minY = Math.min(minY, point.y);
+        maxX = Math.max(maxX, point.x);
+        maxY = Math.max(maxY, point.y);
+    }
+    return {
+        minX: minX,
+        minY: minY,
+        maxX: maxX,
+        maxY: maxY
+    };
+}
+function isMaskExactCrop(mask, layer, width, height, lookup) {
+    var path = getPrimaryPath(mask);
+    if (path == null || path.points.length === 0) {
+        return true;
+    }
+    var _computePointBounds = computePointBounds(path.points), minX = _computePointBounds.minX, minY = _computePointBounds.minY, maxX = _computePointBounds.maxX, maxY = _computePointBounds.maxY;
+    var maskW = maxX - minX;
+    var maskH = maxY - minY;
+    if (mask.isAutoMask === true) {
+        if (Math.abs(maskW - width) < 1 && Math.abs(maskH - height) < 1) {
+            return true;
+        }
+    }
+    var layerIsParent = lookup.isParentLayer(layer.index) || layer.type === 'null' || layer.type === 'precomp';
+    if (mask.isAutoMask !== true && layerIsParent && isSimpleRectMask(mask)) {
+        var _layer_asset, _layer_asset1;
+        var precompW = (_layer_asset = layer.asset) == null ? void 0 : _layer_asset.width;
+        var precompH = (_layer_asset1 = layer.asset) == null ? void 0 : _layer_asset1.height;
+        if (precompW != null && precompH != null && precompW > 0 && precompH > 0) {
+            if (minX <= 0 && minY <= 0 && maxX >= precompW && maxY >= precompH) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function getMaskBounds(mask) {
+    var path = getPrimaryPath(mask);
+    if (path == null || path.points.length === 0) {
+        return {
+            cx: 0,
+            cy: 0,
+            width: 0,
+            height: 0
+        };
+    }
+    var _computePointBounds = computePointBounds(path.points), minX = _computePointBounds.minX, minY = _computePointBounds.minY, maxX = _computePointBounds.maxX, maxY = _computePointBounds.maxY;
+    return {
+        cx: (minX + maxX) / 2,
+        cy: (minY + maxY) / 2,
+        width: maxX - minX,
+        height: maxY - minY
+    };
+}
+function isSimpleRectMask(mask) {
+    var path = getPrimaryPath(mask);
+    if (path == null) {
+        return false;
+    }
+    return path.points.length === 4 && path.easingIns.every(function(e) {
+        return Math.abs(e.x) < 0.01 && Math.abs(e.y) < 0.01;
+    }) && path.easingOuts.every(function(e) {
+        return Math.abs(e.x) < 0.01 && Math.abs(e.y) < 0.01;
+    });
+}
+function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ratio) {
+    var _ref;
+    var path = getPrimaryPath(mask);
+    var customPoints = [];
+    var customEasingIns = [];
+    var customEasingOuts = [];
+    var customIndexes = [];
+    if (path != null) {
+        for(var idx = 0; idx < path.points.length; idx++){
+            var _ref1, _ref2, _ref3, _ref4;
+            var pt = path.points[idx];
+            var ei = path.easingIns[idx];
+            var eo = path.easingOuts[idx];
+            customPoints.push({
+                x: roundNumber((pt.x - bounds.cx) * ratio, 4),
+                y: roundNumber(-(pt.y - bounds.cy) * ratio, 4)
+            });
+            customEasingIns.push({
+                x: roundNumber(((_ref1 = ei == null ? void 0 : ei.x) != null ? _ref1 : 0) * ratio, 4),
+                y: roundNumber(-((_ref2 = ei == null ? void 0 : ei.y) != null ? _ref2 : 0) * ratio, 4)
+            });
+            customEasingOuts.push({
+                x: roundNumber(((_ref3 = eo == null ? void 0 : eo.x) != null ? _ref3 : 0) * ratio, 4),
+                y: roundNumber(-((_ref4 = eo == null ? void 0 : eo.y) != null ? _ref4 : 0) * ratio, 4)
+            });
+            customIndexes.push({
+                point: idx,
+                easingIn: idx,
+                easingOut: idx
+            });
+        }
+    }
+    return {
+        id: maskComponentId,
+        item: toDataPath(maskItemId),
+        type: 0,
+        dataType: 'ShapeComponent',
+        points: customPoints,
+        easingIns: customEasingIns,
+        easingOuts: customEasingOuts,
+        shapes: [
+            {
+                close: (_ref = path == null ? void 0 : path.close) != null ? _ref : true,
+                indexes: customIndexes
+            }
+        ],
+        fills: [
+            {
+                type: 0,
+                color: {
+                    r: 1,
+                    g: 1,
+                    b: 1,
+                    a: 0
+                }
+            }
+        ],
+        strokes: [],
+        strokeWidth: 0,
+        strokeCap: 0,
+        strokeJoin: 0,
+        renderer: {
+            renderMode: 1
+        },
+        mask: {
+            isMask: true,
+            alphaMaskEnabled: false
+        }
+    };
+}
+
+/**
+ * Remap GE mask references after ge2ir round-trip.
+ *
+ * ge2ir carries each masked component's raw `mask` object verbatim (via
+ * `IRLayerNode.metadata.ge2ir.geMask`), but `mask.reference.id` still points at the
+ * ORIGINAL (GE1) mask-source component id, which ir2ge has regenerated. This
+ * pass rewrites every target's `reference.id` from the stale GE1 id to the
+ * freshly-minted GE2 component id, using the `geComponentId → newId` map built
+ * during the layer walk.
+ *
+ * Mirrors `applyParenting`: an IR-side reference (here the stale id stored in
+ * data) → map → regenerated id → written in place. Mask SOURCE components have
+ * no `reference` and are skipped. Dangling references (source not regenerated —
+ * e.g. dropped by the null+sprite merger) have their `mask` removed so the GE
+ * runtime doesn't choke on an id that resolves to nothing.
+ */ function applyGeMaskRemap(collector, geComponentIdToNewId) {
+    for(var _iterator = _create_for_of_iterator_helper_loose(collector.components), _step; !(_step = _iterator()).done;){
+        var component = _step.value;
+        var mask = component['mask'];
+        if (mask == null) {
+            continue;
+        }
+        var reference = mask['reference'];
+        var oldId = reference == null ? void 0 : reference.id;
+        if (oldId == null) {
+            continue;
+        }
+        var newId = geComponentIdToNewId[oldId];
+        if (newId == null) {
+            // Dangling: the referenced source was not regenerated. Drop the mask so
+            // the target renders unmasked rather than referencing a nonexistent id.
+            delete component['mask'];
+            continue;
+        }
+        mask['reference'] = toDataPath(newId);
+    }
+}
+
+/**
+ * Normalize child visibility delays so children never appear before their parent.
+ *
+ * Topologically sorts items (parent-first) so by the time we process any child
+ * its parent's delay/duration are already finalized. For transform-only
+ * parent-link children, we instead advance the parent's delay/duration so the
+ * child can render from its own start time (GE requires the parent to be active
+ * for transform inheritance, but the parent-link relationship does not propagate
+ * visibility). Only the ActivationTrack clip is updated; TransformTrack
+ * keyframes are normalized to the original time range and would hold their
+ * first frame value if the track started earlier.
+ */ function normalizeChildVisibilityByParentDelays(param) {
+    var items = param.items, miscs = param.miscs, processedItems = param.processedItems, _param_transformOnlyParentLinkItemIds = param.transformOnlyParentLinkItemIds, transformOnlyParentLinkItemIds = _param_transformOnlyParentLinkItemIds === void 0 ? new Set() : _param_transformOnlyParentLinkItemIds, roundNumber = param.roundNumber;
+    var itemById = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
+        var item = _step.value;
+        itemById.set(item['id'], item);
+    }
+    var processedByItemId = new Map();
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(processedItems), _step1; !(_step1 = _iterator1()).done;){
+        var pi = _step1.value;
+        processedByItemId.set(pi.itemId, pi);
+    }
+    var miscById = new Map();
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(miscs), _step2; !(_step2 = _iterator2()).done;){
+        var misc = _step2.value;
+        miscById.set(misc['id'], misc);
+    }
+    // Phase 1: Advance transform-only parent-link parents so their children can
+    // render from the child's own start time.
+    advanceTransformOnlyParentLinkParents(items, itemById, processedByItemId, miscById, transformOnlyParentLinkItemIds, roundNumber);
+    // Phase 2: Normalize precomp child visibility (unchanged).
+    var effectiveDelayCache = new Map();
+    function getEffectiveDelay(itemId, visited) {
+        if (visited === void 0) visited = new Set();
+        var _item_delay;
+        if (effectiveDelayCache.has(itemId)) {
+            return effectiveDelayCache.get(itemId);
+        }
+        if (visited.has(itemId)) {
+            return 0;
+        }
+        visited.add(itemId);
+        var item = itemById.get(itemId);
+        if (item == null) {
+            return 0;
+        }
+        var delay = (_item_delay = item['delay']) != null ? _item_delay : 0;
+        var parentId = item['parentId'];
+        if (parentId != null && parentId !== '') {
+            delay = Math.max(delay, getEffectiveDelay(parentId, visited));
+        }
+        effectiveDelayCache.set(itemId, delay);
+        return delay;
+    }
+    // Build topological order (parent-first) so that when processing any child,
+    // its parent's delay/duration are already finalized.
+    var sortedItems = topologicalSort(items, itemById);
+    for(var _iterator3 = _create_for_of_iterator_helper_loose(sortedItems), _step3; !(_step3 = _iterator3()).done;){
+        var item1 = _step3.value;
+        var _item_delay, _item_duration, _parentItem_duration;
+        var itemId = item1['id'];
+        var originalDelay = (_item_delay = item1['delay']) != null ? _item_delay : 0;
+        var originalDuration = (_item_duration = item1['duration']) != null ? _item_duration : 0;
+        var effectiveDelay = getEffectiveDelay(itemId);
+        if (effectiveDelay <= originalDelay) {
+            continue;
+        }
+        var parentId = item1['parentId'];
+        var parentItem = parentId != null && parentId !== '' ? itemById.get(parentId) : undefined;
+        var parentDuration = parentItem ? (_parentItem_duration = parentItem['duration']) != null ? _parentItem_duration : 0 : 0;
+        // Distinguish time-contained children from global-time parent-link children:
+        // Precomp children live entirely within the parent's time range (delay + duration <= parentDuration).
+        // Parent-link children share the global time coordinate with their parent.
+        var isPrecompChild = parentItem != null && originalDelay + originalDuration <= parentDuration + 0.001;
+        var newDuration = void 0;
+        if (isPrecompChild) {
+            // Precomp child: keep duration unchanged (clamped to parent boundary).
+            newDuration = Math.min(originalDuration, parentDuration - originalDelay);
+        } else {
+            // Parent-link child: trim the invisible portion before effectiveDelay.
+            var timeDiff = effectiveDelay - originalDelay;
+            newDuration = originalDuration - timeDiff;
+        }
+        if (newDuration <= 0) {
+            newDuration = 0.0001;
+        }
+        item1['delay'] = roundNumber(effectiveDelay, 4);
+        item1['duration'] = roundNumber(newDuration, 4);
+        syncTimelineClips(itemId, effectiveDelay, newDuration, processedByItemId, miscById, roundNumber);
+    }
+}
+function advanceTransformOnlyParentLinkParents(items, itemById, processedByItemId, miscById, transformOnlyParentLinkItemIds, roundNumber) {
+    if (transformOnlyParentLinkItemIds.size === 0) {
+        return;
+    }
+    // Collect the maximum advance (head) and extension (tail) needed per parent.
+    var parentAdvanceMap = new Map();
+    var parentExtendMap = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
+        var item = _step.value;
+        var _item_delay, _item_duration, _parentItem_delay, _parentItem_duration;
+        if (!transformOnlyParentLinkItemIds.has(item['id'])) {
+            continue;
+        }
+        var parentId = item['parentId'];
+        if (parentId == null || parentId === '') {
+            continue;
+        }
+        var parentItem = itemById.get(parentId);
+        if (parentItem == null) {
+            continue;
+        }
+        var childDelay = (_item_delay = item['delay']) != null ? _item_delay : 0;
+        var childDuration = (_item_duration = item['duration']) != null ? _item_duration : 0;
+        var parentDelay = (_parentItem_delay = parentItem['delay']) != null ? _parentItem_delay : 0;
+        var parentDuration = (_parentItem_duration = parentItem['duration']) != null ? _parentItem_duration : 0;
+        if (childDelay < parentDelay) {
+            var _parentAdvanceMap_get;
+            var advance = parentDelay - childDelay;
+            var existing = (_parentAdvanceMap_get = parentAdvanceMap.get(parentId)) != null ? _parentAdvanceMap_get : 0;
+            if (advance > existing) {
+                parentAdvanceMap.set(parentId, advance);
+            }
+        }
+        var childEnd = childDelay + childDuration;
+        var parentEnd = parentDelay + parentDuration;
+        if (childEnd > parentEnd + 0.001) {
+            var _parentExtendMap_get;
+            var extend = childEnd - parentEnd;
+            var existing1 = (_parentExtendMap_get = parentExtendMap.get(parentId)) != null ? _parentExtendMap_get : 0;
+            if (extend > existing1) {
+                parentExtendMap.set(parentId, extend);
+            }
+        }
+    }
+    // Merge all parent IDs that need adjustment.
+    var allParentIds = new Set([].concat(parentAdvanceMap.keys(), parentExtendMap.keys()));
+    // Apply adjustments: update parent item delay/duration and sync ActivationTrack clips.
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(allParentIds), _step1; !(_step1 = _iterator1()).done;){
+        var parentId1 = _step1.value;
+        var _parentAdvanceMap_get1, _parentExtendMap_get1, _parentItem_delay1, _parentItem_duration1;
+        var parentItem1 = itemById.get(parentId1);
+        if (parentItem1 == null) {
+            continue;
+        }
+        var advance1 = (_parentAdvanceMap_get1 = parentAdvanceMap.get(parentId1)) != null ? _parentAdvanceMap_get1 : 0;
+        var extend1 = (_parentExtendMap_get1 = parentExtendMap.get(parentId1)) != null ? _parentExtendMap_get1 : 0;
+        var parentDelay1 = (_parentItem_delay1 = parentItem1['delay']) != null ? _parentItem_delay1 : 0;
+        var parentDuration1 = (_parentItem_duration1 = parentItem1['duration']) != null ? _parentItem_duration1 : 0;
+        var newDelay = roundNumber(parentDelay1 - advance1, 4);
+        var newDuration = roundNumber(parentDuration1 + advance1 + extend1, 4);
+        parentItem1['delay'] = newDelay;
+        parentItem1['duration'] = newDuration;
+        // Only sync ActivationTrack — TransformTrack keyframes are normalized to
+        // the original time range and will hold their last frame value when the
+        // track extends beyond the original duration.
+        var processed = processedByItemId.get(parentId1);
+        if (processed != null) {
+            var obt = miscById.get(processed.objectBindingTrackId);
+            if (obt != null && Array.isArray(obt['children'])) {
+                for(var _iterator2 = _create_for_of_iterator_helper_loose(obt['children']), _step2; !(_step2 = _iterator2()).done;){
+                    var childRef = _step2.value;
+                    var childTrack = miscById.get(childRef.id);
+                    if ((childTrack == null ? void 0 : childTrack['dataType']) === 'ActivationTrack' && Array.isArray(childTrack['clips'])) {
+                        for(var _iterator3 = _create_for_of_iterator_helper_loose(childTrack['clips']), _step3; !(_step3 = _iterator3()).done;){
+                            var clip = _step3.value;
+                            clip.start = newDelay;
+                            clip.duration = newDuration;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Topological sort: parents are processed before their children.
+ * Falls back to original order for items without parent relationships.
+ */ function topologicalSort(items, itemById) {
+    var sorted = [];
+    var visited = new Set();
+    function visit(item) {
+        var itemId = item['id'];
+        if (visited.has(itemId)) {
+            return;
+        }
+        visited.add(itemId);
+        var parentId = item['parentId'];
+        if (parentId != null && parentId !== '') {
+            var parentItem = itemById.get(parentId);
+            if (parentItem != null) {
+                visit(parentItem);
+            }
+        }
+        sorted.push(item);
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
+        var item = _step.value;
+        visit(item);
+    }
+    return sorted;
+}
+function syncTimelineClips(itemId, delay, duration, processedByItemId, miscById, roundNumber) {
+    var processedItem = processedByItemId.get(itemId);
+    if (processedItem == null) {
+        return;
+    }
+    var obt = miscById.get(processedItem.objectBindingTrackId);
+    if (obt == null || !Array.isArray(obt['children'])) {
+        return;
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(obt['children']), _step; !(_step = _iterator()).done;){
+        var childRef = _step.value;
+        var childTrack = miscById.get(childRef.id);
+        if (childTrack == null || !Array.isArray(childTrack['clips'])) {
+            continue;
+        }
+        var trackType = childTrack['dataType'];
+        if (trackType !== 'ActivationTrack' && trackType !== 'TransformTrack' && trackType !== 'SpriteColorTrack') {
+            continue;
+        }
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(childTrack['clips']), _step1; !(_step1 = _iterator1()).done;){
+            var clip = _step1.value;
+            clip.start = roundNumber(delay, 4);
+            clip.duration = roundNumber(duration, 4);
+        }
+    }
+}
+
+/**
+ * Run post-emit mutations on the collector before `assembleScene`.
+ * Order: parenting → mask → visibility. Each step is gated on whether
+ * the pipeline supplied the required tracking state.
+ */ function applyPostProcess(ir, state) {
+    applyParentingStep(ir, state);
+    applySharedMaskPostProcess(ir, state);
+    applyGeMaskRemapStep(ir, state);
+    applyVisibilityStep(ir, state);
+}
+function applyGeMaskRemapStep(ir, state) {
+    // Only ge-sourced compositions carry passthrough mask references that need
+    // remapping. Lottie/dsl masks are built with correct ids by applyMasks and
+    // must not be touched (their reference ids are absent from the ge map, so a
+    // blind remap would wrongly delete them).
+    if (ir.source !== 'ge' || state.geComponentIdToNewId == null) {
+        return;
+    }
+    applyGeMaskRemap(state.collector, state.geComponentIdToNewId);
+}
+function applySharedMaskPostProcess(ir, state) {
+    if (state.maskLookup == null || state.ratio == null || state.width == null || state.height == null || state.frameRate == null) {
+        return;
+    }
+    applyMasks(ir, state.collector, state.processedItems, state.ratio, state.width, state.height, state.frameRate, state.maskLookup);
+}
+function applyParentingStep(ir, state) {
+    var collector = state.collector, layerToItemId = state.layerToItemId, ratio = state.ratio, width = state.width, height = state.height;
+    if (layerToItemId == null || ratio == null || width == null || height == null) {
+        return;
+    }
+    applyParenting(ir.layers, collector.items, layerToItemId, ratio, width, height);
+}
+function applyVisibilityStep(ir, state) {
+    var collector = state.collector, processedItems = state.processedItems, layerToItemId = state.layerToItemId;
+    if (layerToItemId == null) {
+        return;
+    }
+    var transformOnlyParentLinkItemIds = new Set();
+    for(var _iterator = _create_for_of_iterator_helper_loose(ir.layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        if (isTransformOnlyParentLink(layer)) {
+            var itemId = layerToItemId[layer.index];
+            if (itemId != null) {
+                transformOnlyParentLinkItemIds.add(itemId);
+            }
+        }
+    }
+    normalizeChildVisibilityByParentDelays({
+        items: collector.items,
+        miscs: collector.miscs,
+        processedItems: processedItems,
+        transformOnlyParentLinkItemIds: transformOnlyParentLinkItemIds,
+        roundNumber: roundNumber
+    });
+}
+
+/**
+ * Convert an IR composition to a GE JSONScene.
+ *
+ * All IR sources (lottie, dsl2ge, future) go through this single unified
+ * pipeline. Source-specific features are gated by data existence (e.g. mask,
+ * precomp, shape layers are absent in dsl IR and naturally skipped);
+ * `ir.source` branches are used only for B-class real semantic differences
+ * that cannot be expressed via data existence.
+ *
+ * The optional `duration` arg is a caller override; lottie2ge currently passes
+ * the duration computed from the raw json upstream. When omitted, the
+ * canonical assembler derives it from `(outPoint - inPoint) / frameRate`.
+ */ function convertIRToGE(ir, duration) {
+    validateIRCompositionWithWarnings(ir);
+    var width = ir.width, height = ir.height, frameRate = ir.frameRate;
+    var ratio = get2dTo3dRatio(width, height);
+    var collector = {
+        images: [],
+        components: [],
+        items: [],
+        textures: [],
+        miscs: []
+    };
+    var processedItems = [];
+    var layerToItemId = {};
+    var layerToComponentId = {};
+    var textureCache = new Map();
+    var parentIndexSet = new Set();
+    for(var _iterator = _create_for_of_iterator_helper_loose(ir.layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        if (layer.parent != null) {
+            parentIndexSet.add(layer.parent.index);
+        }
+    }
+    var workingIR = _extends({}, ir, {
+        layers: getLayersWithExtendedParentEndFrames(ir.layers, parentIndexSet)
+    });
+    var ctx = {
+        ir: workingIR,
+        collector: collector,
+        processedItems: processedItems,
+        layerToItemId: layerToItemId,
+        layerToComponentId: layerToComponentId,
+        textureCache: textureCache,
+        parentIndexSet: parentIndexSet,
+        ratio: ratio,
+        width: width,
+        height: height,
+        frameRate: frameRate
+    };
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(workingIR.layers), _step1; !(_step1 = _iterator1()).done;){
+        var layer1 = _step1.value;
+        processLayer(layer1, ctx);
+    }
+    // Build GE1-component-id → regenerated-component-id map for mask reference
+    // remapping (ge2ir round-trip). Keyed by the original GE component id that
+    // ge2ir stored in metadata; value is the component id this layer minted.
+    var geComponentIdToNewId = {};
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(workingIR.layers), _step2; !(_step2 = _iterator2()).done;){
+        var layer2 = _step2.value;
+        var _readGE2IRMetadata;
+        var geComponentId = (_readGE2IRMetadata = readGE2IRMetadata(workingIR, layer2)) == null ? void 0 : _readGE2IRMetadata.geComponentId;
+        var newId = layerToComponentId[layer2.index];
+        if (geComponentId != null && newId != null) {
+            geComponentIdToNewId[geComponentId] = newId;
+        }
+    }
+    applyPostProcess(workingIR, {
+        collector: collector,
+        processedItems: processedItems,
+        layerToItemId: layerToItemId,
+        ratio: ratio,
+        width: width,
+        height: height,
+        frameRate: frameRate,
+        geComponentIdToNewId: geComponentIdToNewId,
+        maskLookup: {
+            getItemId: function getItemId(idx) {
+                return layerToItemId[idx];
+            },
+            getComponentId: function getComponentId(idx) {
+                return layerToComponentId[idx];
+            },
+            isParentLayer: function isParentLayer(idx) {
+                return parentIndexSet.has(idx);
+            }
+        }
+    });
+    collector.items.reverse();
+    processedItems.reverse();
+    return assembleScene(workingIR, collector, processedItems, duration);
+}
+function processLayer(layer, ctx) {
+    if (layer.type === 'null' || layer.type === 'precomp') {
+        processNullLayer(layer, ctx);
+    } else if (ctx.parentIndexSet.has(layer.index)) {
+        processParentLayer(layer, ctx);
+    } else {
+        processVisualLayer(layer, ctx);
+    }
+}
+/**
+ * Extend parent layers' endFrame to cover transform-only children's time spans.
+ *
+ * In Lottie, child layers (linked via layer.parent) inherit the parent's transform
+ * even after the parent becomes invisible. GE requires the parent item to be active
+ * for transform inheritance to work, so we extend the parent's endFrame to cover
+ * the full lifetime of its transform-only children.
+ *
+ * Keyframes beyond the extended endFrame are NOT included — they represent animation
+ * that never plays in Lottie (layer is invisible and has no child needing it).
+ */ function getLayersWithExtendedParentEndFrames(layers, parentIndexSet) {
+    var clonedLayers = layers.map(function(layer) {
+        return _extends({}, layer, {
+            time: _extends({}, layer.time)
+        });
+    });
+    for(var _iterator = _create_for_of_iterator_helper_loose(clonedLayers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        if (!parentIndexSet.has(layer.index)) {
+            continue;
+        }
+        var maxEnd = layer.time.endFrame;
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(clonedLayers), _step1; !(_step1 = _iterator1()).done;){
+            var child = _step1.value;
+            var _child_parent;
+            if (((_child_parent = child.parent) == null ? void 0 : _child_parent.index) === layer.index && child.parent.linkKind === 'transform-only') {
+                if (child.time.endFrame > maxEnd) {
+                    maxEnd = child.time.endFrame;
+                }
+            }
+        }
+        if (maxEnd > layer.time.endFrame) {
+            layer.time.endFrame = maxEnd;
+        }
+    }
+    return clonedLayers;
+}
+
+function buildPoolIndex(pool) {
+    var map = new Map();
+    if (!Array.isArray(pool)) {
+        return map;
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(pool), _step; !(_step = _iterator()).done;){
+        var entry = _step.value;
+        var id = entry['id'];
+        if (typeof id === 'string') {
+            map.set(id, entry);
+        }
+    }
+    return map;
+}
+function resolveDataPath(pool, ref) {
+    if (ref == null || (typeof ref === "undefined" ? "undefined" : _type_of(ref)) !== 'object') {
+        return undefined;
+    }
+    var id = ref['id'];
+    if (typeof id !== 'string') {
+        return undefined;
+    }
+    return pool.get(id);
+}
+function resolveDataPathId(ref) {
+    if (ref == null || (typeof ref === "undefined" ? "undefined" : _type_of(ref)) !== 'object') {
+        return undefined;
+    }
+    var id = ref['id'];
+    return typeof id === 'string' ? id : undefined;
+}
+
+function reverseEndBehavior(geBehavior) {
+    if (geBehavior == null) {
+        return undefined;
+    }
+    switch(geBehavior){
+        case 0:
+            return IREndBehavior.Stop;
+        case 4:
+            return IREndBehavior.Hold;
+        case 5:
+            return IREndBehavior.Loop;
+        default:
+            return undefined;
+    }
+}
+function reverseCompositionEndBehavior(geBehavior) {
+    return reverseEndBehavior(geBehavior);
+}
+
+function buildSceneContext(scene, options) {
+    var _ref, _ref1, _composition_duration, _composition_name;
+    var compositionId = scene['compositionId'];
+    var compositions = scene['compositions'];
+    var composition = compositions == null ? void 0 : compositions.find(function(c) {
+        return c['id'] === compositionId;
+    });
+    if (composition == null) {
+        throw new Error("[ge2ir] composition not found for id: " + compositionId);
+    }
+    var previewSize = composition['previewSize'];
+    var width = (_ref = previewSize == null ? void 0 : previewSize[0]) != null ? _ref : 512;
+    var height = (_ref1 = previewSize == null ? void 0 : previewSize[1]) != null ? _ref1 : 512;
+    var duration = (_composition_duration = composition['duration']) != null ? _composition_duration : 1;
+    var frameRate = options.frameRate;
+    var ratio = get2dTo3dRatio(width, height);
+    var inPoint = 0;
+    var outPoint = Math.round(duration * frameRate);
+    var endBehavior = reverseCompositionEndBehavior(composition['endBehavior']);
+    var backgroundColor;
+    var bg = composition['background'];
+    if (bg != null) {
+        var color = bg['color'];
+        if (color != null && color.length >= 4) {
+            backgroundColor = [
+                color[0],
+                color[1],
+                color[2],
+                color[3]
+            ];
+        }
+    }
+    var compositionName = (_composition_name = composition['name']) != null ? _composition_name : 'Untitled';
+    var items = scene['items'];
+    var components = scene['components'];
+    var miscs = scene['miscs'];
+    var images = scene['images'];
+    var textures = scene['textures'];
+    var itemById = buildPoolIndex(items);
+    var componentById = buildPoolIndex(components);
+    var miscById = buildPoolIndex(miscs);
+    var imageById = buildPoolIndex(images);
+    var textureById = buildPoolIndex(textures);
+    var itemIdToTrackId = buildSceneBindings(componentById, miscById, composition);
+    return {
+        width: width,
+        height: height,
+        frameRate: frameRate,
+        ratio: ratio,
+        duration: duration,
+        inPoint: inPoint,
+        outPoint: outPoint,
+        compositionName: compositionName,
+        endBehavior: endBehavior,
+        backgroundColor: backgroundColor,
+        itemById: itemById,
+        componentById: componentById,
+        miscById: miscById,
+        imageById: imageById,
+        textureById: textureById,
+        itemIdToTrackId: itemIdToTrackId
+    };
+}
+function buildSceneBindings(componentById, miscById, composition) {
+    var map = new Map();
+    var compositionComponent = findCompositionComponent(componentById, composition);
+    if (compositionComponent == null) {
+        return map;
+    }
+    var bindings = compositionComponent['sceneBindings'];
+    if (bindings == null) {
+        return map;
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(bindings), _step; !(_step = _iterator()).done;){
+        var binding = _step.value;
+        var trackId = resolveDataPathId(binding.key);
+        var itemId = resolveDataPathId(binding.value);
+        if (trackId != null && itemId != null) {
+            map.set(itemId, trackId);
+        }
+    }
+    return map;
+}
+function findCompositionComponent(componentById, composition) {
+    var compRefs = composition['components'];
+    if (compRefs == null || compRefs.length === 0) {
+        return undefined;
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(compRefs), _step; !(_step = _iterator()).done;){
+        var ref = _step.value;
+        var component = resolveDataPath(componentById, ref);
+        if ((component == null ? void 0 : component['dataType']) === 'CompositionComponent') {
+            return component;
+        }
+    }
+    return undefined;
+}
+function getCompositionItemIds(scene) {
+    var compositionId = scene['compositionId'];
+    var compositions = scene['compositions'];
+    var composition = compositions == null ? void 0 : compositions.find(function(c) {
+        return c['id'] === compositionId;
+    });
+    if (composition == null) {
+        return [];
+    }
+    var componentById = buildPoolIndex(scene['components']);
+    var compositionComponent = findCompositionComponent(componentById, composition);
+    if (compositionComponent == null) {
+        return [];
+    }
+    var itemRefs = compositionComponent['items'];
+    if (itemRefs == null) {
+        return [];
+    }
+    return itemRefs.map(function(ref) {
+        return ref.id;
+    }).filter(function(id) {
+        return typeof id === 'string';
+    });
+}
+
+function parseTimeline(itemId, ctx) {
+    var trackId = ctx.itemIdToTrackId.get(itemId);
+    if (trackId == null) {
+        return undefined;
+    }
+    var objectBindingTrack = ctx.miscById.get(trackId);
+    if (objectBindingTrack == null) {
+        return undefined;
+    }
+    var childRefs = objectBindingTrack['children'];
+    if (childRefs == null) {
+        return undefined;
+    }
+    var delay = 0;
+    var duration = 0;
+    var endBehavior = 0;
+    var transformAsset;
+    var spriteColorAsset;
+    for(var _iterator = _create_for_of_iterator_helper_loose(childRefs), _step; !(_step = _iterator()).done;){
+        var ref = _step.value;
+        var childTrackId = resolveDataPathId(ref);
+        if (childTrackId == null) {
+            continue;
+        }
+        var childTrack = ctx.miscById.get(childTrackId);
+        if (childTrack == null) {
+            continue;
+        }
+        var dataType = childTrack['dataType'];
+        var clips = childTrack['clips'];
+        if (clips == null || clips.length === 0) {
+            continue;
+        }
+        var clip = clips[0];
+        if (dataType === 'ActivationTrack') {
+            var _clip_start, _clip_duration, _clip_endBehavior;
+            delay = (_clip_start = clip['start']) != null ? _clip_start : 0;
+            duration = (_clip_duration = clip['duration']) != null ? _clip_duration : 0;
+            endBehavior = (_clip_endBehavior = clip['endBehavior']) != null ? _clip_endBehavior : 0;
+        } else if (dataType === 'TransformTrack') {
+            var assetRef = clip['asset'];
+            if (assetRef != null) {
+                transformAsset = resolveDataPath(ctx.miscById, assetRef);
+            }
+        } else if (dataType === 'SpriteColorTrack') {
+            var assetRef1 = clip['asset'];
+            if (assetRef1 != null) {
+                spriteColorAsset = resolveDataPath(ctx.miscById, assetRef1);
+            }
+        }
+    }
+    return {
+        delay: delay,
+        duration: duration,
+        endBehavior: endBehavior,
+        transformAsset: transformAsset,
+        spriteColorAsset: spriteColorAsset
+    };
+}
+
+function convert3dTo2dPoint(x, y, z, width, height) {
+    var ratio = get2dTo3dRatio(width, height);
+    var adaptRatioZ = (DEFAULT_CAMERA_Z - z) / DEFAULT_CAMERA_Z;
+    var effectiveRatio = Math.abs(adaptRatioZ) > 1e-10 ? ratio * adaptRatioZ : ratio;
+    var px = x / effectiveRatio + width / 2;
+    var py = height / 2 - y / effectiveRatio;
+    return [
+        px,
+        py,
+        z
+    ];
+}
+
+function parseStaticTransform(itemTransform, ctx) {
+    var channels = {};
+    var position = itemTransform['position'];
+    if (position != null) {
+        var _position_z;
+        var pos2d = convert3dTo2dPoint(position.x, position.y, (_position_z = position.z) != null ? _position_z : 0, ctx.width, ctx.height);
+        channels.position = {
+            keyframed: false,
+            value: pos2d
+        };
+    }
+    var scale = itemTransform['scale'];
+    if (scale != null) {
+        var _scale_x, _scale_y, _scale_z;
+        var sv = [
+            (_scale_x = scale.x) != null ? _scale_x : 1,
+            (_scale_y = scale.y) != null ? _scale_y : 1,
+            (_scale_z = scale.z) != null ? _scale_z : 1
+        ];
+        var isDefault = Math.abs(sv[0] - 1) < 1e-6 && Math.abs(sv[1] - 1) < 1e-6 && Math.abs(sv[2] - 1) < 1e-6;
+        if (!isDefault) {
+            channels.scale = {
+                keyframed: false,
+                value: sv
+            };
+        }
+    }
+    var eulerHint = itemTransform['eulerHint'];
+    if (eulerHint != null) {
+        var hasRotation = Math.abs(eulerHint.x) > 1e-6 || Math.abs(eulerHint.y) > 1e-6 || Math.abs(eulerHint.z) > 1e-6;
+        if (hasRotation) {
+            channels.rotation = {
+                keyframed: false,
+                value: [
+                    eulerHint.x,
+                    eulerHint.y,
+                    eulerHint.z
+                ]
+            };
+        }
+    }
+    return channels;
+}
+
+function inverseLerp(a, b, value) {
+    var range = b - a;
+    if (Math.abs(range) < 1e-10) {
+        return 0;
+    }
+    return (value - a) / range;
+}
+function parseBezierKeyframes(curves, startFrame, endFrame) {
+    if (curves.length === 0) {
+        return [];
+    }
+    var segments = extractSegments(curves);
+    if (segments.length === 0) {
+        return [];
+    }
+    var frames = endFrame - startFrame;
+    var keyframes = [];
+    var firstSeg = segments[0];
+    var firstT = firstSeg[0];
+    var firstV = firstSeg[1];
+    if (segments.length > 0) {
+        var _segments_;
+        var hasPrependedHold = segments.length >= 2 && Math.abs(firstV - segments[0][7]) < 1e-6 && Math.abs(firstV - firstSeg[1]) < 1e-6 && Math.abs(firstT) < 1e-10;
+        if (hasPrependedHold && Math.abs(firstSeg[6] - ((_segments_ = segments[1]) == null ? void 0 : _segments_[0])) < 1e-6 && Math.abs(firstV - firstSeg[7]) < 1e-6) {
+            segments.shift();
+        }
+    }
+    for(var i = 0; i < segments.length; i++){
+        var seg = segments[i];
+        var t0 = seg[0];
+        var v0 = seg[1];
+        var outCpX = seg[2];
+        var outCpY = seg[3];
+        var t1 = seg[6];
+        var v1 = seg[7];
+        var frameTime = t0 * frames + startFrame;
+        var isHold = Math.abs(v0 - v1) < 1e-6 && Math.abs(outCpY - v0) < 1e-6 && Math.abs(seg[5] - v0) < 1e-6;
+        var outTangent = {
+            x: inverseLerp(t0, t1, outCpX),
+            y: inverseLerp(v0, v1, outCpY)
+        };
+        if (i === 0) {
+            keyframes.push(_extends({
+                t: frameTime,
+                value: v0
+            }, isHold ? {
+                hold: true
+            } : {
+                outTangent: outTangent
+            }));
+        } else {
+            var prevSeg = segments[i - 1];
+            var prevInCpX = prevSeg[4];
+            var prevInCpY = prevSeg[5];
+            var prevT0 = prevSeg[0];
+            var prevV0 = prevSeg[1];
+            var prevT1 = prevSeg[6];
+            var prevV1 = prevSeg[7];
+            var inTangent = {
+                x: inverseLerp(prevT0, prevT1, prevInCpX),
+                y: inverseLerp(prevV0, prevV1, prevInCpY)
+            };
+            keyframes.push(_extends({
+                t: frameTime,
+                value: v0,
+                inTangent: inTangent
+            }, isHold ? {
+                hold: true
+            } : {
+                outTangent: outTangent
+            }));
+        }
+    }
+    var lastSeg = segments[segments.length - 1];
+    var lastT1 = lastSeg[6];
+    var lastV1 = lastSeg[7];
+    var lastFrameTime = lastT1 * frames + startFrame;
+    var lastInTangent = {
+        x: inverseLerp(lastSeg[0], lastSeg[6], lastSeg[4]),
+        y: inverseLerp(lastSeg[1], lastSeg[7], lastSeg[5])
+    };
+    keyframes.push({
+        t: lastFrameTime,
+        value: lastV1,
+        inTangent: lastInTangent
+    });
+    return keyframes;
+}
+function extractSegments(curves) {
+    var segments = [];
+    for(var i = 0; i < curves.length; i++){
+        var entry = curves[i];
+        var type = entry[0];
+        var data = entry[1];
+        if (type === 3) {
+            // EASE_OUT: [t, v, out_cx, out_cy] — first keyframe of a segment
+            if (i + 1 < curves.length) {
+                var nextEntry = curves[i + 1];
+                var nextType = nextEntry[0];
+                var nextData = nextEntry[1];
+                if (nextType === 2) {
+                    // EASE_IN immediately follows: single segment
+                    segments.push([
+                        data[0],
+                        data[1],
+                        data[2],
+                        data[3],
+                        nextData[0],
+                        nextData[1],
+                        nextData[2],
+                        nextData[3]
+                    ]);
+                } else if (nextType === 1) {
+                    // EASE follows
+                    segments.push([
+                        data[0],
+                        data[1],
+                        data[2],
+                        data[3],
+                        nextData[0],
+                        nextData[1],
+                        nextData[2],
+                        nextData[3]
+                    ]);
+                }
+            }
+        } else if (type === 1 && i + 1 < curves.length) {
+            // EASE: [in_cx, in_cy, t, v, out_cx, out_cy] — middle keyframe
+            var nextEntry1 = curves[i + 1];
+            var nextType1 = nextEntry1[0];
+            var nextData1 = nextEntry1[1];
+            if (nextType1 === 2) {
+                segments.push([
+                    data[2],
+                    data[3],
+                    data[4],
+                    data[5],
+                    nextData1[0],
+                    nextData1[1],
+                    nextData1[2],
+                    nextData1[3]
+                ]);
+            } else if (nextType1 === 1) {
+                segments.push([
+                    data[2],
+                    data[3],
+                    data[4],
+                    data[5],
+                    nextData1[0],
+                    nextData1[1],
+                    nextData1[2],
+                    nextData1[3]
+                ]);
+            }
+        }
+    }
+    return segments;
+}
+function parsePositionTimingKeyframes(curves, startFrame, endFrame) {
+    var segments = extractSegments(curves);
+    if (segments.length === 0) {
+        return [];
+    }
+    var frames = endFrame - startFrame;
+    var result = [];
+    for(var i = 0; i < segments.length; i++){
+        var seg = segments[i];
+        var t0 = seg[0];
+        var outCpX = seg[2];
+        var outCpY = seg[3];
+        var t1 = seg[6];
+        var frameTime = t0 * frames + startFrame;
+        var outTangent = {
+            x: inverseLerp(t0, t1, outCpX),
+            y: inverseLerp(t0, t1, outCpY)
+        };
+        if (i === 0) {
+            result.push({
+                t: frameTime,
+                outTangent: outTangent
+            });
+        } else {
+            var prevSeg = segments[i - 1];
+            var inTangent = {
+                x: inverseLerp(prevSeg[0], prevSeg[6], prevSeg[4]),
+                y: inverseLerp(prevSeg[0], prevSeg[6], prevSeg[5])
+            };
+            result.push({
+                t: frameTime,
+                outTangent: outTangent,
+                inTangent: inTangent
+            });
+        }
+    }
+    var lastSeg = segments[segments.length - 1];
+    var lastFrameTime = lastSeg[6] * frames + startFrame;
+    var lastInTangent = {
+        x: inverseLerp(lastSeg[0], lastSeg[6], lastSeg[4]),
+        y: inverseLerp(lastSeg[0], lastSeg[6], lastSeg[5])
+    };
+    result.push({
+        t: lastFrameTime,
+        inTangent: lastInTangent
+    });
+    return result;
+}
+
+function parseTransformAnimation(asset, startFrame, endFrame, ctx) {
+    var channels = {};
+    var posOverLifetime = asset['positionOverLifetime'];
+    if (posOverLifetime != null) {
+        var posAnim = parsePositionAnimation(posOverLifetime, startFrame, endFrame, ctx);
+        if (posAnim != null) {
+            channels.position = posAnim;
+        }
+    }
+    var rotOverLifetime = asset['rotationOverLifetime'];
+    if (rotOverLifetime != null) {
+        var rotResult = parseRotationAnimation(rotOverLifetime, startFrame, endFrame);
+        if (rotResult.rotation != null) {
+            channels.rotation = rotResult.rotation;
+        }
+        if (rotResult.separatedRotation != null) {
+            channels.separatedRotation = rotResult.separatedRotation;
+        }
+    }
+    var sizeOverLifetime = asset['sizeOverLifetime'];
+    if (sizeOverLifetime != null) {
+        var scaleAnim = parseScaleAnimation(sizeOverLifetime, startFrame, endFrame);
+        if (scaleAnim != null) {
+            channels.scale = scaleAnim;
+        }
+    }
+    return channels;
+}
+function parseOpacityAnimation(asset, startFrame, endFrame) {
+    var colorOverLifetime = asset['colorOverLifetime'];
+    if (colorOverLifetime == null) {
+        return undefined;
+    }
+    var opacity = colorOverLifetime['opacity'];
+    if (opacity == null || !Array.isArray(opacity) || opacity.length < 2) {
+        return undefined;
+    }
+    var valueType = opacity[0];
+    if (valueType === 0) {
+        return {
+            keyframed: false,
+            value: opacity[1]
+        };
+    }
+    if (valueType === 13) {
+        var curves = opacity[1];
+        var keyframes = parseBezierKeyframes(curves, startFrame, endFrame);
+        if (keyframes.length >= 2) {
+            return {
+                keyframed: true,
+                keyframes: keyframes
+            };
+        }
+    }
+    return undefined;
+}
+function parsePositionAnimation(posOverLifetime, startFrame, endFrame, ctx) {
+    var pathData = posOverLifetime['path'];
+    if (pathData == null || !Array.isArray(pathData) || pathData.length < 2) {
+        return undefined;
+    }
+    var valueType = pathData[0];
+    if (valueType !== 22) {
+        return undefined;
+    }
+    var payload = pathData[1];
+    if (!Array.isArray(payload) || payload.length < 2) {
+        return undefined;
+    }
+    var easingData = payload[0];
+    var pathPoints = payload[1];
+    var controlPointsRaw = payload[2];
+    if (!Array.isArray(pathPoints) || pathPoints.length < 2) {
+        return undefined;
+    }
+    var timingKfs = parsePositionTimingKeyframes(easingData, startFrame, endFrame);
+    if (timingKfs.length < 2) {
+        return undefined;
+    }
+    // Detect and skip prepended hold segment
+    var startIdx = 0;
+    if (timingKfs.length > 2) {
+        var firstPP = pathPoints[0];
+        var secondPP = pathPoints[1];
+        if (firstPP != null && secondPP != null && Math.abs(firstPP[0] - secondPP[0]) < 1e-6 && Math.abs(firstPP[1] - secondPP[1]) < 1e-6) {
+            startIdx = 1;
+        }
+    }
+    var keyframes = [];
+    var pendingSpatialIn = new Map();
+    for(var i = startIdx; i < timingKfs.length; i++){
+        var _pp_;
+        var timing = timingKfs[i];
+        var pp = pathPoints[Math.min(i, pathPoints.length - 1)];
+        var pos2d = convert3dTo2dPoint(pp[0], pp[1], (_pp_ = pp[2]) != null ? _pp_ : 0, ctx.width, ctx.height);
+        var kf = {
+            t: timing.t,
+            value: pos2d
+        };
+        if (i > startIdx && timing.inTangent != null) {
+            kf.inTangent = timing.inTangent;
+        }
+        if (i < timingKfs.length - 1 && timing.outTangent != null) {
+            kf.outTangent = timing.outTangent;
+        }
+        var kfIndex = keyframes.length;
+        var pendingSI = pendingSpatialIn.get(kfIndex);
+        if (pendingSI != null) {
+            kf.spatialIn = pendingSI;
+        }
+        if (controlPointsRaw != null && i - startIdx < timingKfs.length - startIdx - 1) {
+            var segIdx = i - startIdx;
+            var cp1Idx = segIdx * 2;
+            var cp2Idx = segIdx * 2 + 1;
+            if (cp1Idx < controlPointsRaw.length && cp2Idx < controlPointsRaw.length) {
+                var _ppStart_, _ppEnd_, _cp1_, _cp2_;
+                var cp1 = controlPointsRaw[cp1Idx];
+                var cp2 = controlPointsRaw[cp2Idx];
+                var ppStart = pathPoints[i];
+                var ppEnd = pathPoints[Math.min(i + 1, pathPoints.length - 1)];
+                var ppStart2d = convert3dTo2dPoint(ppStart[0], ppStart[1], (_ppStart_ = ppStart[2]) != null ? _ppStart_ : 0, ctx.width, ctx.height);
+                var ppEnd2d = convert3dTo2dPoint(ppEnd[0], ppEnd[1], (_ppEnd_ = ppEnd[2]) != null ? _ppEnd_ : 0, ctx.width, ctx.height);
+                var cp1_2d = convert3dTo2dPoint(cp1[0], cp1[1], (_cp1_ = cp1[2]) != null ? _cp1_ : 0, ctx.width, ctx.height);
+                var cp2_2d = convert3dTo2dPoint(cp2[0], cp2[1], (_cp2_ = cp2[2]) != null ? _cp2_ : 0, ctx.width, ctx.height);
+                kf.spatialOut = [
+                    cp1_2d[0] - ppStart2d[0],
+                    cp1_2d[1] - ppStart2d[1]
+                ];
+                pendingSpatialIn.set(kfIndex + 1, [
+                    cp2_2d[0] - ppEnd2d[0],
+                    cp2_2d[1] - ppEnd2d[1]
+                ]);
+            }
+        }
+        keyframes.push(kf);
+    }
+    if (keyframes.length < 2) {
+        return undefined;
+    }
+    return {
+        keyframed: true,
+        keyframes: keyframes
+    };
+}
+function parseRotationAnimation(rotOverLifetime, startFrame, endFrame) {
+    var separateAxes = rotOverLifetime['separateAxes'];
+    var xData = rotOverLifetime['x'];
+    var yData = rotOverLifetime['y'];
+    var zData = rotOverLifetime['z'];
+    if (separateAxes === true) {
+        var x = parseScalarChannel(xData, startFrame, endFrame);
+        var y = parseScalarChannel(yData, startFrame, endFrame);
+        var z = parseScalarChannel(zData, startFrame, endFrame);
+        var hasMultiAxis = (x != null ? 1 : 0) + (y != null ? 1 : 0) + (z != null ? 1 : 0) > 1;
+        var hasXOrY = x != null || y != null;
+        if (hasMultiAxis || hasXOrY) {
+            return {
+                separatedRotation: _extends({}, x != null && {
+                    x: x
+                }, y != null && {
+                    y: y
+                }, z != null && {
+                    z: z
+                })
+            };
+        }
+        if (z != null) {
+            return {
+                separatedRotation: {
+                    z: z
+                }
+            };
+        }
+    }
+    // Single-axis z rotation (non-separated)
+    if (zData != null) {
+        var z1 = parseScalarChannel(zData, startFrame, endFrame);
+        if (z1 != null) {
+            if (z1.keyframed) {
+                var vecKeyframes = z1.keyframes.map(function(kf) {
+                    var result = {
+                        t: kf.t,
+                        value: [
+                            0,
+                            0,
+                            kf.value
+                        ]
+                    };
+                    if (kf.hold != null) {
+                        result.hold = kf.hold;
+                    }
+                    if (kf.inTangent != null) {
+                        result.inTangent = kf.inTangent;
+                    }
+                    if (kf.outTangent != null) {
+                        result.outTangent = kf.outTangent;
+                    }
+                    return result;
+                });
+                return {
+                    rotation: {
+                        keyframed: true,
+                        keyframes: vecKeyframes
+                    }
+                };
+            }
+            return {
+                rotation: {
+                    keyframed: false,
+                    value: [
+                        0,
+                        0,
+                        z1.value
+                    ]
+                }
+            };
+        }
+    }
+    return {};
+}
+function parseScaleAnimation(sizeOverLifetime, startFrame, endFrame) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8;
+    var xData = sizeOverLifetime['x'];
+    var yData = sizeOverLifetime['y'];
+    var zData = sizeOverLifetime['z'];
+    var x = parseScalarChannel(xData, startFrame, endFrame);
+    var y = parseScalarChannel(yData, startFrame, endFrame);
+    var z = parseScalarChannel(zData, startFrame, endFrame);
+    if (x == null && y == null && z == null) {
+        return undefined;
+    }
+    var xKeyframed = (x == null ? void 0 : x.keyframed) === true;
+    var yKeyframed = (y == null ? void 0 : y.keyframed) === true;
+    var zKeyframed = (z == null ? void 0 : z.keyframed) === true;
+    if (!xKeyframed && !yKeyframed && !zKeyframed) {
+        var _ref9, _ref10, _ref11;
+        return {
+            keyframed: false,
+            value: [
+                (_ref9 = x == null ? void 0 : x.value) != null ? _ref9 : 1,
+                (_ref10 = y == null ? void 0 : y.value) != null ? _ref10 : 1,
+                (_ref11 = z == null ? void 0 : z.value) != null ? _ref11 : 1
+            ]
+        };
+    }
+    var xKfs = (_ref = x == null ? void 0 : x.keyframes) != null ? _ref : [
+        {
+            t: startFrame,
+            value: (_ref1 = x == null ? void 0 : x.value) != null ? _ref1 : 1
+        },
+        {
+            t: endFrame,
+            value: (_ref2 = x == null ? void 0 : x.value) != null ? _ref2 : 1
+        }
+    ];
+    var yKfs = (_ref3 = y == null ? void 0 : y.keyframes) != null ? _ref3 : [
+        {
+            t: startFrame,
+            value: (_ref4 = y == null ? void 0 : y.value) != null ? _ref4 : 1
+        },
+        {
+            t: endFrame,
+            value: (_ref5 = y == null ? void 0 : y.value) != null ? _ref5 : 1
+        }
+    ];
+    var zKfs = (_ref6 = z == null ? void 0 : z.keyframes) != null ? _ref6 : [
+        {
+            t: startFrame,
+            value: (_ref7 = z == null ? void 0 : z.value) != null ? _ref7 : 1
+        },
+        {
+            t: endFrame,
+            value: (_ref8 = z == null ? void 0 : z.value) != null ? _ref8 : 1
+        }
+    ];
+    var allTimes = new Set();
+    for(var _iterator = _create_for_of_iterator_helper_loose(xKfs), _step; !(_step = _iterator()).done;){
+        var kf = _step.value;
+        allTimes.add(kf.t);
+    }
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(yKfs), _step1; !(_step1 = _iterator1()).done;){
+        var kf1 = _step1.value;
+        allTimes.add(kf1.t);
+    }
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(zKfs), _step2; !(_step2 = _iterator2()).done;){
+        var kf2 = _step2.value;
+        allTimes.add(kf2.t);
+    }
+    var sortedTimes = [].concat(allTimes).sort(function(a, b) {
+        return a - b;
+    });
+    var keyframes = sortedTimes.map(function(t) {
+        var _ref, _ref1, _ref2;
+        var xv = findValueAtTime(xKfs, t, (_ref = x == null ? void 0 : x.value) != null ? _ref : 1);
+        var yv = findValueAtTime(yKfs, t, (_ref1 = y == null ? void 0 : y.value) != null ? _ref1 : 1);
+        var zv = findValueAtTime(zKfs, t, (_ref2 = z == null ? void 0 : z.value) != null ? _ref2 : 1);
+        var kf = {
+            t: t,
+            value: [
+                xv.value,
+                yv.value,
+                zv.value
+            ]
+        };
+        if (xv.outTangent != null) {
+            kf.outTangent = xv.outTangent;
+        }
+        if (xv.inTangent != null) {
+            kf.inTangent = xv.inTangent;
+        }
+        if (xv.hold === true) {
+            kf.hold = true;
+        }
+        return kf;
+    });
+    return {
+        keyframed: true,
+        keyframes: keyframes
+    };
+}
+function parseScalarChannel(data, startFrame, endFrame) {
+    if (data == null || !Array.isArray(data) || data.length < 2) {
+        return undefined;
+    }
+    var valueType = data[0];
+    if (valueType === 0) {
+        return {
+            keyframed: false,
+            value: data[1]
+        };
+    }
+    if (valueType === 13) {
+        var curves = data[1];
+        var keyframes = parseBezierKeyframes(curves, startFrame, endFrame);
+        if (keyframes.length >= 2) {
+            return {
+                keyframed: true,
+                keyframes: keyframes
+            };
+        }
+    }
+    return undefined;
+}
+function findValueAtTime(keyframes, t, defaultValue) {
+    for(var _iterator = _create_for_of_iterator_helper_loose(keyframes), _step; !(_step = _iterator()).done;){
+        var kf = _step.value;
+        if (Math.abs(kf.t - t) < 1e-6) {
+            return {
+                value: kf.value,
+                outTangent: kf.outTangent,
+                inTangent: kf.inTangent,
+                hold: kf.hold
+            };
+        }
+    }
+    return {
+        value: defaultValue
+    };
+}
+
+var IR_BLEND_MODE_BY_GE = {
+    1: IRBlendMode.Add,
+    2: IRBlendMode.Darken,
+    3: IRBlendMode.Lighten,
+    4: IRBlendMode.Difference,
+    5: IRBlendMode.Exclusion,
+    6: IRBlendMode.Multiply,
+    7: IRBlendMode.ColorBurn,
+    8: IRBlendMode.Color,
+    9: IRBlendMode.Screen,
+    10: IRBlendMode.ColorDodge,
+    11: IRBlendMode.Hue,
+    12: IRBlendMode.Saturation,
+    13: IRBlendMode.Overlay,
+    14: IRBlendMode.HardLight,
+    15: IRBlendMode.SoftLight,
+    16: IRBlendMode.Luminosity
+};
+function reverseBlendMode(geCode) {
+    if (geCode == null) {
+        return undefined;
+    }
+    return IR_BLEND_MODE_BY_GE[geCode];
+}
+
+function parseComponent(item, ctx) {
+    var componentRefs = item['components'];
+    if (componentRefs == null || componentRefs.length === 0) {
+        return undefined;
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(componentRefs), _step; !(_step = _iterator()).done;){
+        var ref = _step.value;
+        var compId = resolveDataPathId(ref);
+        if (compId == null) {
+            continue;
+        }
+        var component = ctx.componentById.get(compId);
+        if (component == null) {
+            continue;
+        }
+        var dataType = component['dataType'];
+        var result = void 0;
+        if (dataType === 'SpriteComponent') {
+            result = parseSpriteComponent(component, ctx);
+        } else if (dataType === 'TextComponent') {
+            result = parseTextComponent(component);
+        } else if (dataType === 'ShapeComponent') {
+            result = parseShapeComponent(component, ctx);
+        }
+        if (result == null) {
+            continue;
+        }
+        result.geComponentId = component['id'];
+        var mask = component['mask'];
+        if (mask != null) {
+            result.rawMask = mask;
+        }
+        return result;
+    }
+    return undefined;
+}
+function parseSpriteComponent(component, ctx) {
+    var renderer = component['renderer'];
+    var options = component['options'];
+    var asset;
+    var solidColor;
+    var blendMode;
+    var anchorScale;
+    if (renderer != null) {
+        var textureRef = renderer['texture'];
+        if (textureRef != null) {
+            var texture = resolveDataPath(ctx.textureById, textureRef);
+            if (texture != null) {
+                var sourceRef = texture['source'];
+                var image = sourceRef != null ? resolveDataPath(ctx.imageById, sourceRef) : undefined;
+                if (image != null) {
+                    asset = {
+                        url: image['url']
+                    };
+                }
+            }
+        }
+        blendMode = reverseBlendMode(renderer['blending']);
+        var anchor = renderer['anchor'];
+        if (anchor != null && Array.isArray(anchor) && anchor.length >= 2) {
+            anchorScale = [
+                anchor[0],
+                anchor[1]
+            ];
+        }
+    }
+    if (options != null) {
+        var startColor = options['startColor'];
+        if (startColor != null && startColor.length >= 4) {
+            var isWhite = Math.abs(startColor[0] - 1) < 1e-4 && Math.abs(startColor[1] - 1) < 1e-4 && Math.abs(startColor[2] - 1) < 1e-4 && Math.abs(startColor[3] - 1) < 1e-4;
+            if (!isWhite) {
+                solidColor = [
+                    startColor[0],
+                    startColor[1],
+                    startColor[2],
+                    startColor[3]
+                ];
+            }
+        }
+    }
+    var type = asset != null ? 'image' : 'solid';
+    return {
+        type: type,
+        asset: asset,
+        solidColor: solidColor,
+        blendMode: blendMode,
+        anchorScale: anchorScale
+    };
+}
+function parseTextComponent(component) {
+    var _options_text, _options_fontSize, _options_fontFamily, _options_fontWeight, _options_fontStyle, _options_letterSpace, _options_autoWidth;
+    var options = component['options'];
+    var renderer = component['renderer'];
+    if (options == null) {
+        return {
+            type: 'text'
+        };
+    }
+    var textColor = options['textColor'];
+    var color = textColor != null && textColor.length >= 4 ? [
+        textColor[0],
+        textColor[1],
+        textColor[2],
+        textColor[3]
+    ] : [
+        0,
+        0,
+        0,
+        1
+    ];
+    var textAlignNum = options['textAlign'];
+    var textAlign = textAlignNum === 1 ? 'center' : textAlignNum === 2 ? 'right' : 'left';
+    var text = {
+        content: (_options_text = options['text']) != null ? _options_text : '',
+        fontSize: (_options_fontSize = options['fontSize']) != null ? _options_fontSize : 12,
+        color: color,
+        fontFamily: (_options_fontFamily = options['fontFamily']) != null ? _options_fontFamily : 'sans-serif',
+        fontWeight: (_options_fontWeight = options['fontWeight']) != null ? _options_fontWeight : 'normal',
+        textAlign: textAlign,
+        fontStyle: (_options_fontStyle = options['fontStyle']) != null ? _options_fontStyle : 'normal',
+        letterSpacing: (_options_letterSpace = options['letterSpace']) != null ? _options_letterSpace : 0,
+        lineHeight: options['lineHeight'],
+        autoWidth: (_options_autoWidth = options['autoWidth']) != null ? _options_autoWidth : true,
+        width: options['textWidth'],
+        height: options['textHeight']
+    };
+    var blendMode;
+    var anchorScale;
+    if (renderer != null) {
+        blendMode = reverseBlendMode(renderer['blending']);
+        var anchor = renderer['anchor'];
+        if (anchor != null && Array.isArray(anchor) && anchor.length >= 2) {
+            anchorScale = [
+                anchor[0],
+                anchor[1]
+            ];
+        }
+    }
+    return {
+        type: 'text',
+        text: text,
+        blendMode: blendMode,
+        anchorScale: anchorScale
+    };
+}
+function parseShapeComponent(component, ctx) {
+    var renderer = component['renderer'];
+    var blendMode;
+    if (renderer != null) {
+        blendMode = reverseBlendMode(renderer['blending']);
+    }
+    var shapeData = parseShapeOptions(component, ctx.ratio);
+    return {
+        type: 'shape',
+        shapes: shapeData != null ? [
+            shapeData
+        ] : undefined,
+        blendMode: blendMode
+    };
+}
+function parseShapeOptions(component, ratio) {
+    var geType = component['type'];
+    var primitiveType = reverseShapePrimitiveType(geType != null ? geType : 0);
+    var xSize = component['xSize'];
+    var ySize = component['ySize'];
+    var size = [
+        xSize != null ? xSize / ratio : 0,
+        ySize != null ? ySize / ratio : 0
+    ];
+    var shape = {
+        primitiveType: primitiveType,
+        position: [
+            0,
+            0
+        ],
+        size: size,
+        fills: [],
+        strokes: []
+    };
+    var shapeRec = shape;
+    reverseScaledNumber(shapeRec, component, 'xRadius', ratio);
+    reverseScaledNumber(shapeRec, component, 'yRadius', ratio);
+    reverseScaledNumber(shapeRec, component, 'width', ratio);
+    reverseScaledNumber(shapeRec, component, 'height', ratio);
+    reverseScaledNumber(shapeRec, component, 'innerRadius', ratio);
+    reverseScaledNumber(shapeRec, component, 'outerRadius', ratio);
+    reverseScaledNumber(shapeRec, component, 'radius', ratio);
+    reverseRawNumber(shapeRec, component, 'roundness');
+    reverseRawNumber(shapeRec, component, 'pointCount');
+    reverseRawNumber(shapeRec, component, 'innerRoundness');
+    reverseRawNumber(shapeRec, component, 'outerRoundness');
+    var geFills = component['fills'];
+    if (geFills != null) {
+        shape.fills = geFills.map(function(f) {
+            return reverseShapePaint(f, ratio);
+        }).filter(function(f) {
+            return f != null;
+        });
+    }
+    var geStrokes = component['strokes'];
+    if (geStrokes != null) {
+        shape.strokes = geStrokes.map(function(s) {
+            return reverseShapePaint(s, ratio);
+        }).filter(function(s) {
+            return s != null;
+        });
+    }
+    var geStrokeWidth = component['strokeWidth'];
+    if (geStrokeWidth != null) {
+        shape.strokeWidth = geStrokeWidth / ratio;
+    }
+    var geStrokeCap = component['strokeCap'];
+    if (geStrokeCap != null) {
+        shape.strokeCap = reverseLineCap(geStrokeCap);
+    }
+    var geStrokeJoin = component['strokeJoin'];
+    if (geStrokeJoin != null) {
+        shape.strokeJoin = reverseLineJoin(geStrokeJoin);
+    }
+    var geFillRule = component['fillRule'];
+    if (geFillRule != null) {
+        shape.fillRule = reverseShapeFillRule(geFillRule);
+    }
+    var geShapes = component['shapes'];
+    if (geShapes != null) {
+        var paths = reverseCustomPaths(component, ratio);
+        if (paths.length > 0) {
+            shape.customPaths = paths;
+        }
+    }
+    var trimPath = component['trimPath'];
+    if (trimPath != null) {
+        shape.trimPath = trimPath;
+    }
+    var repeater = component['repeater'];
+    if (repeater != null) {
+        shape.repeater = repeater;
+    }
+    return shape;
+}
+var GE_TO_SHAPE_PRIMITIVE_TYPE = {
+    0: IRShapePrimitiveType.Custom,
+    1: IRShapePrimitiveType.Rectangle,
+    2: IRShapePrimitiveType.Ellipse,
+    3: IRShapePrimitiveType.Polygon,
+    4: IRShapePrimitiveType.Star
+};
+function reverseShapePrimitiveType(geType) {
+    var _GE_TO_SHAPE_PRIMITIVE_TYPE_geType;
+    return (_GE_TO_SHAPE_PRIMITIVE_TYPE_geType = GE_TO_SHAPE_PRIMITIVE_TYPE[geType]) != null ? _GE_TO_SHAPE_PRIMITIVE_TYPE_geType : IRShapePrimitiveType.Custom;
+}
+function reverseShapePaint(paint, ratio) {
+    var geType = paint['type'];
+    if (geType === 0) {
+        var color = paint['color'];
+        if (color == null) {
+            return undefined;
+        }
+        return {
+            type: IRFillType.Solid,
+            color: [
+                color.r,
+                color.g,
+                color.b,
+                color.a
+            ]
+        };
+    }
+    if (geType === 1 || geType === 2 || geType === 3) {
+        var typeMap = {
+            1: IRFillType.LinearGradient,
+            2: IRFillType.RadialGradient,
+            3: IRFillType.AngularGradient
+        };
+        var gradientStopsRaw = paint['gradientStops'];
+        var stops = Array.isArray(gradientStopsRaw) && gradientStopsRaw.length >= 2 ? gradientStopsRaw[1] : [];
+        var startPoint = paint['startPoint'];
+        var endPoint = paint['endPoint'];
+        return {
+            type: typeMap[geType],
+            gradientStops: stops,
+            gradientStart: startPoint != null ? [
+                startPoint.x / ratio,
+                -startPoint.y / ratio
+            ] : undefined,
+            gradientEnd: endPoint != null ? [
+                endPoint.x / ratio,
+                -endPoint.y / ratio
+            ] : undefined
+        };
+    }
+    return undefined;
+}
+function reverseLineCap(geCode) {
+    var _map_geCode;
+    var map = {
+        0: IRLineCap.Butt,
+        1: IRLineCap.Round,
+        2: IRLineCap.Square
+    };
+    return (_map_geCode = map[geCode]) != null ? _map_geCode : IRLineCap.Butt;
+}
+function reverseLineJoin(geCode) {
+    var _map_geCode;
+    var map = {
+        0: IRLineJoin.Round,
+        1: IRLineJoin.Bevel,
+        2: IRLineJoin.Miter
+    };
+    return (_map_geCode = map[geCode]) != null ? _map_geCode : IRLineJoin.Miter;
+}
+function reverseShapeFillRule(geCode) {
+    var _map_geCode;
+    var map = {
+        0: IRShapeFillRule.NonZero,
+        1: IRShapeFillRule.EvenOdd
+    };
+    return (_map_geCode = map[geCode]) != null ? _map_geCode : IRShapeFillRule.NonZero;
+}
+function reverseCustomPaths(component, ratio) {
+    var points = component['points'];
+    var easingIns = component['easingIns'];
+    var easingOuts = component['easingOuts'];
+    var shapes = component['shapes'];
+    if (points == null || shapes == null) {
+        return [];
+    }
+    return shapes.map(function(shape) {
+        var pathPoints = [];
+        var pathEasingIns = [];
+        var pathEasingOuts = [];
+        for(var _iterator = _create_for_of_iterator_helper_loose(shape.indexes), _step; !(_step = _iterator()).done;){
+            var idx = _step.value;
+            var _ref, _ref1, _ref2, _ref3;
+            var pt = points[idx.point];
+            var ei = easingIns == null ? void 0 : easingIns[idx.easingIn];
+            var eo = easingOuts == null ? void 0 : easingOuts[idx.easingOut];
+            pathPoints.push({
+                x: pt.x / ratio,
+                y: -pt.y / ratio
+            });
+            pathEasingIns.push({
+                x: ((_ref = ei == null ? void 0 : ei.x) != null ? _ref : 0) / ratio,
+                y: -((_ref1 = ei == null ? void 0 : ei.y) != null ? _ref1 : 0) / ratio
+            });
+            pathEasingOuts.push({
+                x: ((_ref2 = eo == null ? void 0 : eo.x) != null ? _ref2 : 0) / ratio,
+                y: -((_ref3 = eo == null ? void 0 : eo.y) != null ? _ref3 : 0) / ratio
+            });
+        }
+        return {
+            points: pathPoints,
+            easingIns: pathEasingIns,
+            easingOuts: pathEasingOuts,
+            close: shape.close
+        };
+    });
+}
+function reverseScaledNumber(shape, component, key, ratio) {
+    var value = component[key];
+    if (typeof value === 'number') {
+        shape[key] = value / ratio;
+    }
+}
+function reverseRawNumber(shape, component, key) {
+    var value = component[key];
+    if (typeof value === 'number') {
+        shape[key] = value;
+    }
+}
+
+function reverseLayerTiming(delay, duration, frameRate) {
+    var startFrame = Math.round(delay * frameRate * 1000) / 1000;
+    var endFrame = Math.round((delay + duration) * frameRate * 1000) / 1000;
+    return {
+        startFrame: startFrame,
+        endFrame: endFrame
+    };
+}
+
+function mergeNullSpritePairs(descriptors, ctx) {
+    var childByParentId = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(descriptors), _step; !(_step = _iterator()).done;){
+        var desc = _step.value;
+        var parentId = desc.item['parentId'];
+        if (parentId != null) {
+            if (!childByParentId.has(parentId)) {
+                childByParentId.set(parentId, []);
+            }
+            childByParentId.get(parentId).push(desc);
+        }
+    }
+    // Pass 1: identify all merge pairs (null parent → sprite child)
+    var mergedChildIds = new Set();
+    var mergeMap = new Map();
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(descriptors), _step1; !(_step1 = _iterator1()).done;){
+        var desc1 = _step1.value;
+        var isNull = desc1.item['type'] === '3';
+        if (!isNull) {
+            continue;
+        }
+        var children = childByParentId.get(desc1.itemId);
+        if (children == null || children.length === 0) {
+            continue;
+        }
+        // Only merge an UNAMBIGUOUS emitNullSpritePair artifact: a null whose ONLY
+        // child is exactly one same-name visual sprite. ir2ge's emitNullSpritePair
+        // produces precisely this shape (null + one same-name child). If the null
+        // has any OTHER children, it is a genuine Lottie parent null — merging it
+        // into a transformSplit would change the anchor those other children are
+        // parented against, shifting them. Leave such nulls intact.
+        if (children.length !== 1) {
+            continue;
+        }
+        var onlyChild = children[0];
+        var childType = onlyChild.item['type'];
+        var isVisual = childType === '1' || childType === 'text' || childType === 'shape';
+        var sameName = onlyChild.item['name'] === desc1.item['name'];
+        if (!isVisual || !sameName || !hasNoComponents(desc1.item) || !hasVisualComponent(onlyChild, ctx) || !hasSplitPairTiming(desc1, onlyChild, ctx) || !hasParentTransformSignal(desc1, ctx) || !hasNoIndependentChildTransform(onlyChild, ctx)) {
+            continue;
+        }
+        var sameNameChild = onlyChild;
+        mergedChildIds.add(sameNameChild.itemId);
+        mergeMap.set(desc1.itemId, mergeNullAndSprite(desc1, sameNameChild, ctx));
+    }
+    // Pass 2: build result, replacing merged nulls and skipping merged children
+    var result = [];
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(descriptors), _step2; !(_step2 = _iterator2()).done;){
+        var desc2 = _step2.value;
+        if (mergedChildIds.has(desc2.itemId)) {
+            continue;
+        }
+        var merged = mergeMap.get(desc2.itemId);
+        if (merged != null) {
+            result.push(merged);
+        } else {
+            result.push(desc2);
+        }
+    }
+    return result;
+}
+function hasNoComponents(item) {
+    var components = item['components'];
+    return !Array.isArray(components) || components.length === 0;
+}
+function hasVisualComponent(desc, ctx) {
+    var components = desc.item['components'];
+    if (!Array.isArray(components) || components.length === 0) {
+        return false;
+    }
+    return components.some(function(ref) {
+        var componentId = resolveDataPathId(ref);
+        var component = componentId != null ? ctx.componentById.get(componentId) : undefined;
+        var dataType = component == null ? void 0 : component['dataType'];
+        return dataType === 'SpriteComponent' || dataType === 'TextComponent' || dataType === 'ShapeComponent';
+    });
+}
+function hasSplitPairTiming(parent, child, ctx) {
+    var _ref, _ref1;
+    var parentTimeline = parseTimeline(parent.itemId, ctx);
+    var childTimeline = parseTimeline(child.itemId, ctx);
+    var parentEndBehavior = (_ref = parentTimeline == null ? void 0 : parentTimeline.endBehavior) != null ? _ref : readItemEndBehavior(parent.item);
+    var childEndBehavior = (_ref1 = childTimeline == null ? void 0 : childTimeline.endBehavior) != null ? _ref1 : readItemEndBehavior(child.item);
+    if (parentEndBehavior !== 4 || childEndBehavior !== 0) {
+        return false;
+    }
+    if (parentTimeline == null || childTimeline == null) {
+        return true;
+    }
+    return nearlyEqual(parentTimeline.delay, childTimeline.delay) && nearlyEqual(parentTimeline.duration, childTimeline.duration);
+}
+function hasParentTransformSignal(desc, ctx) {
+    var timeline = parseTimeline(desc.itemId, ctx);
+    if (hasTransformPayload(timeline == null ? void 0 : timeline.transformAsset)) {
+        return true;
+    }
+    var transform = desc.item['transform'];
+    return isRecord(transform) && (hasNonDefaultScale(transform) || hasNonDefaultEulerHint(transform));
+}
+function hasNoIndependentChildTransform(desc, ctx) {
+    var timeline = parseTimeline(desc.itemId, ctx);
+    return (timeline == null ? void 0 : timeline.transformAsset) != null && !hasTransformPayload(timeline.transformAsset);
+}
+function hasTransformPayload(asset) {
+    if (asset == null) {
+        return false;
+    }
+    return hasNonEmptyRecord(asset['positionOverLifetime']) || hasNonEmptyRecord(asset['rotationOverLifetime']) || hasNonEmptyRecord(asset['sizeOverLifetime']);
+}
+function hasNonDefaultScale(transform) {
+    var scale = transform['scale'];
+    if (!isRecord(scale)) {
+        return false;
+    }
+    var x = typeof scale['x'] === 'number' ? scale['x'] : 1;
+    var y = typeof scale['y'] === 'number' ? scale['y'] : 1;
+    var z = typeof scale['z'] === 'number' ? scale['z'] : 1;
+    return Math.abs(x - 1) > 1e-6 || Math.abs(y - 1) > 1e-6 || Math.abs(z - 1) > 1e-6;
+}
+function hasNonDefaultEulerHint(transform) {
+    var eulerHint = transform['eulerHint'];
+    if (!isRecord(eulerHint)) {
+        return false;
+    }
+    var x = typeof eulerHint['x'] === 'number' ? eulerHint['x'] : 0;
+    var y = typeof eulerHint['y'] === 'number' ? eulerHint['y'] : 0;
+    var z = typeof eulerHint['z'] === 'number' ? eulerHint['z'] : 0;
+    return Math.abs(x) > 1e-6 || Math.abs(y) > 1e-6 || Math.abs(z) > 1e-6;
+}
+function hasNonEmptyRecord(value) {
+    return isRecord(value) && Object.keys(value).length > 0;
+}
+function readItemEndBehavior(item) {
+    var endBehavior = item['endBehavior'];
+    return typeof endBehavior === 'number' ? endBehavior : undefined;
+}
+function nearlyEqual(a, b) {
+    return Math.abs(a - b) < 1e-6;
+}
+function isRecord(value) {
+    return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
+}
+function mergeNullAndSprite(nullDesc, childDesc, ctx) {
+    var _childDesc_layer_transform;
+    var merged = _extends({}, nullDesc.layer);
+    // Take type from child
+    merged.type = childDesc.layer.type;
+    merged.asset = childDesc.layer.asset;
+    merged.text = childDesc.layer.text;
+    merged.shapes = childDesc.layer.shapes;
+    merged.shapeLayer = childDesc.layer.shapeLayer;
+    merged.solidColor = childDesc.layer.solidColor;
+    merged.blendMode = childDesc.layer.blendMode;
+    merged.transformSplit = true;
+    // Visibility from child
+    merged.visibility = childDesc.layer.visibility;
+    // Compute anchor from child position offset
+    var childTransform = childDesc.item['transform'];
+    var childPosition = childTransform == null ? void 0 : childTransform['position'];
+    var childSize = childTransform == null ? void 0 : childTransform['size'];
+    if (childPosition != null && childSize != null) {
+        var layerWidth = childSize.x / ctx.ratio;
+        var layerHeight = childSize.y / ctx.ratio;
+        var anchorX = -childPosition.x / ctx.ratio + layerWidth / 2;
+        var anchorY = childPosition.y / ctx.ratio + layerHeight / 2;
+        if (merged.transform == null) {
+            merged.transform = {};
+        }
+        merged.transform.anchor = {
+            keyframed: false,
+            value: [
+                anchorX,
+                anchorY,
+                0
+            ]
+        };
+        merged.displaySize = {
+            width: layerWidth,
+            height: layerHeight
+        };
+    }
+    // Opacity from child
+    if (((_childDesc_layer_transform = childDesc.layer.transform) == null ? void 0 : _childDesc_layer_transform.opacity) != null) {
+        if (merged.transform == null) {
+            merged.transform = {};
+        }
+        merged.transform.opacity = childDesc.layer.transform.opacity;
+    }
+    // The merged layer renders the child's visual component, but the parent owns
+    // transform animation passthrough. Deep-merge the ge2ir namespace so neither
+    // side overwrites the other's GE round-trip data.
+    if (childDesc.layer.metadata != null) {
+        var _merged_metadata;
+        var parentGE2IR = isRecord((_merged_metadata = merged.metadata) == null ? void 0 : _merged_metadata['ge2ir']) ? merged.metadata['ge2ir'] : undefined;
+        var childGE2IR = isRecord(childDesc.layer.metadata['ge2ir']) ? childDesc.layer.metadata['ge2ir'] : undefined;
+        merged.metadata = _extends({}, merged.metadata, childDesc.layer.metadata);
+        if (parentGE2IR != null || childGE2IR != null) {
+            merged.metadata['ge2ir'] = _extends({}, parentGE2IR != null ? parentGE2IR : {}, childGE2IR != null ? childGE2IR : {});
+        }
+    }
+    return {
+        itemId: nullDesc.itemId,
+        item: nullDesc.item,
+        layer: merged
+    };
+}
+function resolveHierarchy(descriptors, ctx) {
+    var idToIndex = new Map();
+    var idToDesc = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(descriptors), _step; !(_step = _iterator()).done;){
+        var desc = _step.value;
+        idToIndex.set(desc.itemId, desc.layer.index);
+        idToDesc.set(desc.itemId, desc);
+    }
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(descriptors), _step1; !(_step1 = _iterator1()).done;){
+        var desc1 = _step1.value;
+        var _desc_layer_transform;
+        var parentId = desc1.item['parentId'];
+        if (parentId == null) {
+            continue;
+        }
+        var parentIndex = idToIndex.get(parentId);
+        var parentDesc = idToDesc.get(parentId);
+        if (parentIndex == null || parentDesc == null) {
+            continue;
+        }
+        desc1.layer.parent = {
+            index: parentIndex,
+            name: parentDesc.layer.name
+        };
+        var parentAnchor = getAnchorFromDesc(parentDesc);
+        var pos = (_desc_layer_transform = desc1.layer.transform) == null ? void 0 : _desc_layer_transform.position;
+        if (pos != null && !pos.keyframed && pos.value != null) {
+            var _pos2d_;
+            var pos2d = pos.value;
+            desc1.layer.transform.position = {
+                keyframed: false,
+                value: [
+                    pos2d[0] + (parentAnchor[0] - ctx.width / 2),
+                    pos2d[1] + (parentAnchor[1] - ctx.height / 2),
+                    (_pos2d_ = pos2d[2]) != null ? _pos2d_ : 0
+                ]
+            };
+        }
+    }
+}
+function getAnchorFromDesc(desc) {
+    var _desc_layer_transform;
+    var anchor = (_desc_layer_transform = desc.layer.transform) == null ? void 0 : _desc_layer_transform.anchor;
+    if (anchor != null && !anchor.keyframed && Array.isArray(anchor.value) && anchor.value.length >= 2) {
+        return [
+            anchor.value[0],
+            anchor.value[1]
+        ];
+    }
+    return [
+        0,
+        0
+    ];
+}
+
+function convertGEToIR(scene, options) {
+    var ctx = buildSceneContext(scene, options);
+    var itemIds = getCompositionItemIds(scene);
+    // Reverse: GE items are in display order (ir2ge reverses at the end),
+    // IR layers need to be in push order so ir2ge's final reverse restores display order.
+    var reversedItemIds = [].concat(itemIds).reverse();
+    var descriptors = [];
+    var layerIndex = 0;
+    for(var _iterator = _create_for_of_iterator_helper_loose(reversedItemIds), _step; !(_step = _iterator()).done;){
+        var itemId = _step.value;
+        var item = ctx.itemById.get(itemId);
+        if (item == null) {
+            continue;
+        }
+        var layer = parseItemToLayer(item, itemId, layerIndex, ctx);
+        descriptors.push({
+            itemId: itemId,
+            item: item,
+            layer: layer
+        });
+        layerIndex++;
+    }
+    var merged = mergeNullSpritePairs(descriptors, ctx);
+    // Re-index after merge
+    for(var i = 0; i < merged.length; i++){
+        merged[i].layer.index = i;
+    }
+    resolveHierarchy(merged, ctx);
+    var layers = merged.map(function(d) {
+        return d.layer;
+    });
+    return {
+        source: 'ge',
+        name: ctx.compositionName,
+        width: ctx.width,
+        height: ctx.height,
+        frameRate: ctx.frameRate,
+        inPoint: ctx.inPoint,
+        outPoint: ctx.outPoint,
+        backgroundColor: ctx.backgroundColor,
+        endBehavior: ctx.endBehavior,
+        layers: layers
+    };
+}
+function parseItemToLayer(item, itemId, index, ctx) {
+    var _item_name, _item_visible, _ref, _item_delay, _ref1, _item_duration;
+    var _item_transform;
+    var name = (_item_name = item['name']) != null ? _item_name : "layer_" + index;
+    var geType = item['type'];
+    var visible = (_item_visible = item['visible']) != null ? _item_visible : true;
+    var rawTransformPassthrough;
+    var timeline = parseTimeline(itemId, ctx);
+    var delay = (_ref = timeline == null ? void 0 : timeline.delay) != null ? _ref : (_item_delay = item['delay']) != null ? _item_delay : 0;
+    var duration = (_ref1 = timeline == null ? void 0 : timeline.duration) != null ? _ref1 : (_item_duration = item['duration']) != null ? _item_duration : 0;
+    var time = reverseLayerTiming(delay, duration, ctx.frameRate);
+    var componentData = parseComponent(item, ctx);
+    var type;
+    if (geType === '3') {
+        type = 'null';
+    } else if ((componentData == null ? void 0 : componentData.type) === 'text' || geType === 'text') {
+        type = 'text';
+    } else if ((componentData == null ? void 0 : componentData.type) === 'shape' || geType === 'shape') {
+        type = 'shape';
+    } else if ((componentData == null ? void 0 : componentData.type) === 'image') {
+        type = 'image';
+    } else if ((componentData == null ? void 0 : componentData.solidColor) != null) {
+        type = 'solid';
+    } else if (geType === '1') {
+        type = 'solid';
+    } else {
+        type = 'null';
+    }
+    // Parse transforms
+    var itemTransform = item['transform'];
+    var transform;
+    if (itemTransform != null) {
+        var staticChannels = parseStaticTransform(itemTransform, ctx);
+        transform = _extends({}, staticChannels);
+        // Text layers carry their pixel-sizing scale on transform.scale
+        // (scale = ratio × displaySize). ir2ge RECOMPUTES this item scale from
+        // displaySize in processVisualLayer, so keeping it in the IR scale channel
+        // would make buildSizeAnim emit a duplicate sizeOverLifetime constant that
+        // double-scales the glyphs (garbled/stretched text). Drop the static scale
+        // for text; genuine text scale animation still rides through
+        // metadata.ge2ir.sizeOverLifetime passthrough.
+        if (type === 'text') {
+            delete transform.scale;
+        }
+    }
+    // Parse animation from timeline tracks — passthrough raw GE animation data
+    // via metadata. Converting to IR keyframes and back would lose data (ir2ge
+    // only handles specific ValueType variants and makes assumptions about
+    // static positions). The raw data is injected verbatim by ir2ge.
+    if ((timeline == null ? void 0 : timeline.transformAsset) != null) {
+        var asset = timeline.transformAsset;
+        var animChannels = parseTransformAnimation(asset, time.startFrame, time.endFrame, ctx);
+        if (transform == null) {
+            transform = {};
+        }
+        // Use parsed IR channels when available (CONSTANT/BEZIER_CURVE types),
+        // but also store raw data for passthrough of unsupported types (LINE_SEGMENTS etc.)
+        if (animChannels.rotation != null) {
+            transform.rotation = animChannels.rotation;
+        }
+        if (animChannels.separatedRotation != null) {
+            transform.separatedRotation = animChannels.separatedRotation;
+            delete transform.rotation;
+        }
+        if (animChannels.scale != null) {
+            transform.scale = animChannels.scale;
+        }
+        // Passthrough raw animation data for channels that can't round-trip through IR
+        var rawPassthrough = {};
+        var posOL = asset['positionOverLifetime'];
+        var rotOL = asset['rotationOverLifetime'];
+        var sizeOL = asset['sizeOverLifetime'];
+        if (posOL != null && posOL['path'] != null) {
+            rawPassthrough.positionOverLifetime = posOL;
+        }
+        if (rotOL != null && Object.keys(rotOL).length > 0) {
+            rawPassthrough.rotationOverLifetime = rotOL;
+        }
+        if (sizeOL != null && Object.keys(sizeOL).length > 0) {
+            rawPassthrough.sizeOverLifetime = sizeOL;
+        }
+        if (Object.keys(rawPassthrough).length > 0) {
+            rawTransformPassthrough = rawPassthrough;
+        }
+    }
+    // Parse opacity
+    var rawColorOverLifetime;
+    if ((timeline == null ? void 0 : timeline.spriteColorAsset) != null) {
+        var opacity = parseOpacityAnimation(timeline.spriteColorAsset, time.startFrame, time.endFrame);
+        if (opacity != null) {
+            if (transform == null) {
+                transform = {};
+            }
+            transform.opacity = opacity;
+        }
+        var col = timeline.spriteColorAsset['colorOverLifetime'];
+        if (col != null && Object.keys(col).length > 0) {
+            rawColorOverLifetime = col;
+        }
+    }
+    // Anchor from component — default to center (0.5, 0.5) when not explicitly set
+    if (type !== 'null') {
+        var _item_transform1;
+        var itemSize = (_item_transform1 = item['transform']) == null ? void 0 : _item_transform1['size'];
+        if (itemSize != null) {
+            var _ref2;
+            var layerWidth = itemSize.x / ctx.ratio;
+            var layerHeight = itemSize.y / ctx.ratio;
+            var anchorScale = (_ref2 = componentData == null ? void 0 : componentData.anchorScale) != null ? _ref2 : [
+                0.5,
+                0.5
+            ];
+            var anchorX = anchorScale[0] * layerWidth;
+            var anchorY = anchorScale[1] * layerHeight;
+            if (transform == null) {
+                transform = {};
+            }
+            transform.anchor = {
+                keyframed: false,
+                value: [
+                    anchorX,
+                    anchorY,
+                    0
+                ]
+            };
+            // Reverse the position adjustments ir2ge's processVisualLayer re-applies
+            // for non-centered anchors, so they don't double-apply on round-trip.
+            // Forward order (in 2D-px equivalent): pos += anchorOffset (computeStaticPosition),
+            // then pos += scaleAdjust (applyScalePositionAdjust). We subtract both.
+            var pos = transform.position;
+            if (pos != null && !pos.keyframed && pos.value != null) {
+                var _scale_, _scale_1;
+                var _transform_scale;
+                // anchorOffset = -(anchor - size/2), added to the raw 2D position.
+                var anchorOffsetX = -(anchorX - layerWidth / 2);
+                var anchorOffsetY = -(anchorY - layerHeight / 2);
+                // scaleAdjust (only when static scale != 1 and anchor off-center by >0.5px):
+                //   3D: x += anchorDiffX*(1-sx)*ratio ; y -= anchorDiffY*(1-sy)*ratio
+                // In 2D-px (÷ratio, y-axis flips sign): x2d += anchorDiffX*(1-sx) ;
+                //   y2d += anchorDiffY*(1-sy)   (the two sign flips cancel).
+                var scale = ((_transform_scale = transform.scale) == null ? void 0 : _transform_scale.keyframed) === false && Array.isArray(transform.scale.value) ? transform.scale.value : [
+                    1,
+                    1,
+                    1
+                ];
+                var sx = (_scale_ = scale[0]) != null ? _scale_ : 1;
+                var sy = (_scale_1 = scale[1]) != null ? _scale_1 : 1;
+                var anchorDiffX = anchorX - layerWidth / 2;
+                var anchorDiffY = anchorY - layerHeight / 2;
+                var anchorOffCenter = Math.abs(anchorDiffX) > 0.5 || Math.abs(anchorDiffY) > 0.5;
+                var hasStaticScale = !(sx === 1 && sy === 1);
+                var scaleAdjustX = 0;
+                var scaleAdjustY = 0;
+                if (hasStaticScale && anchorOffCenter && layerWidth > 0 && layerHeight > 0) {
+                    scaleAdjustX = anchorDiffX * (1 - sx);
+                    scaleAdjustY = anchorDiffY * (1 - sy);
+                }
+                var totalX = anchorOffsetX + scaleAdjustX;
+                var totalY = anchorOffsetY + scaleAdjustY;
+                if (Math.abs(totalX) > 1e-6 || Math.abs(totalY) > 1e-6) {
+                    var _pos_value_;
+                    transform.position = {
+                        keyframed: false,
+                        value: [
+                            pos.value[0] - totalX,
+                            pos.value[1] - totalY,
+                            (_pos_value_ = pos.value[2]) != null ? _pos_value_ : 0
+                        ]
+                    };
+                }
+            }
+        }
+    }
+    // Display size from item transform.size
+    var displaySize;
+    var itemSize1 = (_item_transform = item['transform']) == null ? void 0 : _item_transform['size'];
+    if (itemSize1 != null) {
+        displaySize = {
+            width: itemSize1.x / ctx.ratio,
+            height: itemSize1.y / ctx.ratio
+        };
+    }
+    var layer = {
+        index: index,
+        name: name,
+        type: type,
+        time: time,
+        visibility: {
+            hidden: !visible,
+            enabled: visible
+        },
+        transform: transform,
+        displaySize: displaySize
+    };
+    if ((componentData == null ? void 0 : componentData.asset) != null) {
+        layer.asset = componentData.asset;
+    }
+    if ((componentData == null ? void 0 : componentData.solidColor) != null) {
+        layer.solidColor = componentData.solidColor;
+    }
+    if ((componentData == null ? void 0 : componentData.text) != null) {
+        layer.text = componentData.text;
+    }
+    if ((componentData == null ? void 0 : componentData.shapes) != null) {
+        layer.shapes = componentData.shapes;
+    }
+    if ((componentData == null ? void 0 : componentData.blendMode) != null) {
+        layer.blendMode = componentData.blendMode;
+    }
+    var geComponentId = componentData == null ? void 0 : componentData.geComponentId;
+    var rawMask = componentData == null ? void 0 : componentData.rawMask;
+    if (rawTransformPassthrough != null || rawColorOverLifetime != null || geComponentId != null || rawMask != null) {
+        // Mask round-trip: geComponentId is the rendezvous key linking a target's
+        // mask.reference.id (a GE1 component id) to the regenerated GE2 component id.
+        // ir2ge copies ge2ir.geMask onto the rebuilt component and a post-process pass
+        // remaps the stale reference id.
+        var ge2irMetadata = _extends({}, rawTransformPassthrough != null ? rawTransformPassthrough : {}, rawColorOverLifetime != null && {
+            colorOverLifetime: rawColorOverLifetime
+        }, geComponentId != null && {
+            geComponentId: geComponentId
+        }, rawMask != null && {
+            geMask: rawMask
+        });
+        layer.metadata = _extends({}, layer.metadata, {
+            ge2ir: ge2irMetadata
+        });
+    }
+    return layer;
+}
+
+/**
+ * Read-side accessors for the `IRLayerNode.specific.lottie` slot.
+ *
+ * The shared generator must not branch on lottie semantics directly — every
+ * lottie-specific read goes through these helpers so the rest of `ir2ge` stays
+ * agnostic to the producing tool.
+ *
+ * `isTransformOnlyParentLink` used to live here, reading
+ * `specific.lottie.explicitParent`. It was promoted to a generic IR field
+ * (`IRLayerReference.linkKind`); the accessor now lives at `./parent-link.ts`.
+ */ function readLottieSpecific(layer) {
+    var _layer_specific;
+    return (_layer_specific = layer.specific) == null ? void 0 : _layer_specific.lottie;
+}
+
+export { DEFAULT_CAMERA_FOV, DEFAULT_CAMERA_Z, DEFAULT_CLIP_MODE, assembleScene, buildTimelineTracks, convert2dTo3dPoint, convertGEToIR, convertIRToGE, createId, estimateTextWidth, get2dTo3dRatio, irPositionKeyframesToGE, irScalarKeyframesToGE, irVectorKeyframesToGE, isTransformOnlyParentLink, lerp, normalizeChildVisibilityByParentDelays, readLottieSpecific, roundNumber, shouldUseKeyframeMode, toDataPath };
+//# sourceMappingURL=index.mjs.map