@vvfx/lottie2ir 0.0.1-beta.10 → 0.0.1-beta.12

package/dist/index.mjs

@@ -3,7 +3,7 @@
  * Description: Lottie to Animation IR converter
  * Author: Ant Group CO., Ltd.
  * Contributors: 澄弈
- * Version: v0.0.1-beta.10
+ * Version: v0.0.1-beta.12
  */
 
 import { isIRId, IRMaskMode, IRShapePrimitiveType, IRPaintType, IRLineJoin, IRLineCap, IRBlendMode, IREndBehavior, IRMatteMode, ANIMATION_IR_SCHEMA_VERSION, assertIRScene } from '@vvfx/animation-ir';
@@ -230,41 +230,6 @@ function resolveLottieAssetPath(asset) {
     });
 }
 
-function resolveDiagnosticAction(code) {
-    switch(code){
-        case 'invalid-stretch-ratio':
-        case 'separated-position-fallback':
-        case 'animated-anchor-fallback':
-        case 'animated-gradient-fallback':
-        case 'missing-font':
-            return 'approximated';
-        case 'missing-image-asset':
-        case 'unsupported-mask':
-        case 'unsupported-track-matte':
-        case 'unsupported-shape-feature':
-        case 'unsupported-shape-type':
-        case 'missing-text-data':
-            return 'dropped';
-        case 'unsupported-layer-type':
-            return 'unsupported';
-    }
-}
-/** Creates a source-scoped warning for a normalized, approximated, or dropped Lottie feature. */ function createLottieDiagnostic(options) {
-    var _ref;
-    var _options_featureKinds;
-    return _extends({
-        code: "LOTTIE_" + options.code.replaceAll('-', '_').toUpperCase(),
-        severity: 'warning',
-        action: resolveDiagnosticAction(options.code),
-        path: '$.layers'
-    }, options.layerInd != null && {
-        sourceId: String(options.layerInd)
-    }, {
-        feature: (_ref = (_options_featureKinds = options.featureKinds) == null ? void 0 : _options_featureKinds.join(',')) != null ? _ref : options.code,
-        message: options.message
-    });
-}
-
 function isFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
 }
@@ -507,6 +472,257 @@ function mergeSeparatedPosition(pRecord) {
     };
 }
 
+function hasAnimatedAnchor(layer) {
+    var property = getPropertyRecord(layer, 'a');
+    return property != null && isKeyframedProperty(property);
+}
+function toStaticAnchor(layer) {
+    var _ref;
+    var _property_keyframes_;
+    var property = toAnimatedProperty(getPropertyRecord(layer, 'a'), readVector3);
+    if (property == null || property.type === 'static') {
+        return property;
+    }
+    return {
+        type: 'static',
+        value: (_ref = (_property_keyframes_ = property.keyframes[0]) == null ? void 0 : _property_keyframes_.value) != null ? _ref : [
+            0,
+            0,
+            0
+        ]
+    };
+}
+function readVector3(value) {
+    var _values_, _values_1, _values_2;
+    var values = toFiniteNumberArray(value);
+    if (values == null) {
+        return undefined;
+    }
+    return [
+        (_values_ = values[0]) != null ? _values_ : 0,
+        (_values_1 = values[1]) != null ? _values_1 : 0,
+        (_values_2 = values[2]) != null ? _values_2 : 0
+    ];
+}
+function readSpatialTangent(value) {
+    var values = toFiniteNumberArray(value);
+    if ((values == null ? void 0 : values.length) === 2) {
+        return [
+            values[0],
+            values[1]
+        ];
+    }
+    if ((values == null ? void 0 : values.length) === 3) {
+        return [
+            values[0],
+            values[1],
+            values[2]
+        ];
+    }
+    return undefined;
+}
+function readScaleVector(value) {
+    var _values_, _values_1, _values_2;
+    var _toFiniteNumberArray;
+    var values = (_toFiniteNumberArray = toFiniteNumberArray(value)) == null ? void 0 : _toFiniteNumberArray.map(function(item) {
+        return item / 100;
+    });
+    if (values == null) {
+        return undefined;
+    }
+    return [
+        (_values_ = values[0]) != null ? _values_ : 1,
+        (_values_1 = values[1]) != null ? _values_1 : 1,
+        (_values_2 = values[2]) != null ? _values_2 : 1
+    ];
+}
+function readOpacityNumber(value) {
+    var valueNumber = toFirstNumber(value);
+    return valueNumber != null ? valueNumber / 100 : undefined;
+}
+function getPropertyRecord(layer, key) {
+    var ks = asRecord(layer.ks);
+    var property = asRecord(ks == null ? void 0 : ks[key]);
+    if (property == null || !('k' in property)) {
+        return undefined;
+    }
+    return property;
+}
+function readBezierHandle(value) {
+    var record = asRecord(value);
+    var x = toFirstNumber(record == null ? void 0 : record['x']);
+    var y = toFirstNumber(record == null ? void 0 : record['y']);
+    if (x == null || y == null) {
+        return undefined;
+    }
+    return {
+        x: x,
+        y: y
+    };
+}
+function readKeyframes(property, reader) {
+    var rawKeyframes = property['k'];
+    if (!Array.isArray(rawKeyframes)) {
+        return undefined;
+    }
+    var keyframes = [];
+    var previousEndValue;
+    // Lottie stores segment tangents on the start keyframe; IR assigns them to their endpoints.
+    var pendingInTangent;
+    var pendingSpatialIn;
+    for(var _iterator = _create_for_of_iterator_helper_loose(rawKeyframes), _step; !(_step = _iterator()).done;){
+        var rawKeyframe = _step.value;
+        var keyframeRecord = asRecord(rawKeyframe);
+        var t = keyframeRecord == null ? void 0 : keyframeRecord['t'];
+        if (!isFiniteNumber(t)) {
+            continue;
+        }
+        // Terminal keyframes inherit the preceding `e` value.
+        var value = reader(keyframeRecord == null ? void 0 : keyframeRecord['s']);
+        if (value == null) {
+            if (previousEndValue != null) {
+                value = previousEndValue;
+            } else {
+                continue;
+            }
+        }
+        var endValue = reader(keyframeRecord == null ? void 0 : keyframeRecord['e']);
+        previousEndValue = endValue != null ? endValue : value;
+        var recordInTangent = readBezierHandle(keyframeRecord == null ? void 0 : keyframeRecord['i']);
+        var outTangent = readBezierHandle(keyframeRecord == null ? void 0 : keyframeRecord['o']);
+        var spatialOut = readSpatialTangent(keyframeRecord == null ? void 0 : keyframeRecord['to']);
+        var recordSpatialIn = readSpatialTangent(keyframeRecord == null ? void 0 : keyframeRecord['ti']);
+        var inTangent = pendingInTangent;
+        var spatialIn = pendingSpatialIn;
+        keyframes.push(_extends({
+            frame: t,
+            value: value
+        }, endValue != null && {
+            endValue: endValue
+        }, (keyframeRecord == null ? void 0 : keyframeRecord['h']) === 1 && {
+            hold: true
+        }, inTangent != null && {
+            inTangent: inTangent
+        }, outTangent != null && {
+            outTangent: outTangent
+        }, spatialOut != null && {
+            spatialOut: spatialOut
+        }, spatialIn != null && {
+            spatialIn: spatialIn
+        }));
+        // Incoming tangents belong to the next IR keyframe.
+        pendingInTangent = recordInTangent;
+        pendingSpatialIn = recordSpatialIn;
+    }
+    return keyframes.length > 0 ? keyframes : undefined;
+}
+function toAnimatedProperty(property, reader) {
+    if (property == null) {
+        return undefined;
+    }
+    if (isKeyframedProperty(property)) {
+        var _ref;
+        var _keyframes_;
+        var keyframes = readKeyframes(property, reader);
+        if (keyframes != null && keyframes.length >= 2) {
+            return {
+                type: 'keyframed',
+                keyframes: keyframes
+            };
+        }
+        var staticValue = (_ref = keyframes == null ? void 0 : (_keyframes_ = keyframes[0]) == null ? void 0 : _keyframes_.value) != null ? _ref : reader(property['k']);
+        return staticValue != null ? {
+            type: 'static',
+            value: staticValue
+        } : undefined;
+    }
+    var value = reader(property['k']);
+    return value != null ? {
+        type: 'static',
+        value: value
+    } : undefined;
+}
+/**
+ * Converts Lottie transform properties and keyframes to IR units and tangent ownership.
+ *
+ * Scale and opacity percentages become normalized factors. Animated anchors use their first keyframe because IR anchors
+ * are static.
+ */ function convertLottieTransform(layer) {
+    var _getPropertyRecord;
+    var transform = {};
+    var anchor = toStaticAnchor(layer);
+    var positionProperty = getPropertyRecord(layer, 'p');
+    var position = toAnimatedProperty(positionProperty, readVector3);
+    var scale = toAnimatedProperty(getPropertyRecord(layer, 's'), readScaleVector);
+    var rotationZ = toAnimatedProperty((_getPropertyRecord = getPropertyRecord(layer, 'rz')) != null ? _getPropertyRecord : getPropertyRecord(layer, 'r'), toFirstNumber);
+    var rotationX = toAnimatedProperty(getPropertyRecord(layer, 'rx'), toFirstNumber);
+    var rotationY = toAnimatedProperty(getPropertyRecord(layer, 'ry'), toFirstNumber);
+    var opacity = toAnimatedProperty(getPropertyRecord(layer, 'o'), readOpacityNumber);
+    if (anchor != null) {
+        transform.anchor = anchor;
+    }
+    if (position != null) {
+        transform.position = position;
+    }
+    if (scale != null) {
+        transform.scale = scale;
+    }
+    if (rotationX != null || rotationY != null || rotationZ != null) {
+        var rotation = {};
+        if (rotationX != null) {
+            rotation.x = rotationX;
+        }
+        if (rotationY != null) {
+            rotation.y = rotationY;
+        }
+        if (rotationZ != null) {
+            rotation.z = rotationZ;
+        }
+        transform.rotation = rotation;
+    }
+    if (opacity != null) {
+        transform.opacity = opacity;
+    }
+    return transform;
+}
+
+function resolveDiagnosticAction(code) {
+    switch(code){
+        case 'invalid-stretch-ratio':
+        case 'separated-position-fallback':
+        case 'animated-anchor-fallback':
+        case 'animated-gradient-fallback':
+        case 'duplicate-layer-index':
+        case 'unsupported-text-glyphs':
+        case 'missing-font':
+            return 'approximated';
+        case 'missing-image-asset':
+        case 'unsupported-mask':
+        case 'unsupported-track-matte':
+        case 'unsupported-shape-feature':
+        case 'unsupported-shape-type':
+        case 'missing-text-data':
+            return 'dropped';
+        case 'unsupported-layer-type':
+            return 'unsupported';
+    }
+}
+/** Creates a source-scoped warning for a normalized, approximated, or dropped Lottie feature. */ function createLottieDiagnostic(options) {
+    var _ref;
+    var _options_featureKinds;
+    return _extends({
+        code: "LOTTIE_" + options.code.replaceAll('-', '_').toUpperCase(),
+        severity: 'warning',
+        action: resolveDiagnosticAction(options.code),
+        path: '$.layers'
+    }, options.layerInd != null && {
+        sourceId: String(options.layerInd)
+    }, {
+        feature: (_ref = (_options_featureKinds = options.featureKinds) == null ? void 0 : _options_featureKinds.join(',')) != null ? _ref : options.code,
+        message: options.message
+    });
+}
+
 function hasFullStaticOpacity(mask) {
     var opacity = mask['o'];
     if (opacity == null) {
@@ -604,9 +820,10 @@ function collectMaskPathIssues(mask) {
         'open-mask-path'
     ];
 }
-/** Converts one supported authored Mask and reports features that prevent conversion. */ function convertLottieMask(maskInfo) {
+/** Converts the ordered authored Mask stack and reports features that prevent conversion. */ function convertLottieMasks(maskInfo) {
     if (!Array.isArray(maskInfo)) {
         return {
+            masks: [],
             unsupportedFeatures: [
                 'invalid-mask-data'
             ]
@@ -620,6 +837,7 @@ function collectMaskPathIssues(mask) {
     });
     if (activeMasks.length === 0) {
         return {
+            masks: [],
             unsupportedFeatures: hasInvalidEntry ? [
                 'invalid-mask-data'
             ] : []
@@ -629,9 +847,6 @@ function collectMaskPathIssues(mask) {
     if (hasInvalidEntry) {
         features.add('invalid-mask-data');
     }
-    if (activeMasks.length > 1) {
-        features.add('multiple-active-masks');
-    }
     for(var _iterator = _create_for_of_iterator_helper_loose(activeMasks), _step; !(_step = _iterator()).done;){
         var mask = _step.value;
         if (!isSupportedLottieMaskMode(mask['mode'])) {
@@ -646,20 +861,36 @@ function collectMaskPathIssues(mask) {
         }
     }
     var unsupportedFeatures = Array.from(features).sort();
-    if (unsupportedFeatures.length > 0 || activeMasks.length !== 1) {
+    if (unsupportedFeatures.length > 0) {
         return {
+            masks: [],
             unsupportedFeatures: unsupportedFeatures
         };
     }
-    var mask1 = activeMasks[0];
-    var pathData = resolveMaskPathData(mask1);
-    var mode = mapLottieMaskMode(mask1['mode']);
+    var masks = [];
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(activeMasks), _step2; !(_step2 = _iterator2()).done;){
+        var mask1 = _step2.value;
+        var converted = convertMaskEntry(mask1);
+        if (converted == null) {
+            return {
+                masks: [],
+                unsupportedFeatures: [
+                    'invalid-mask-data'
+                ]
+            };
+        }
+        masks.push(converted);
+    }
+    return {
+        masks: masks,
+        unsupportedFeatures: []
+    };
+}
+function convertMaskEntry(mask) {
+    var pathData = resolveMaskPathData(mask);
+    var mode = mapLottieMaskMode(mask['mode']);
     if (pathData == null || mode == null) {
-        return {
-            unsupportedFeatures: [
-                'invalid-mask-data'
-            ]
-        };
+        return undefined;
     }
     var vertices = pathData['v'];
     var relativeInTangents = pathData['i'];
@@ -688,15 +919,12 @@ function collectMaskPathIssues(mask) {
         outTangents: outTangents,
         closed: true
     };
-    return {
-        mask: _extends({
-            path: path,
-            mode: mode
-        }, mask1['inv'] === true && {
-            inverted: true
-        }),
-        unsupportedFeatures: []
-    };
+    return _extends({
+        path: path,
+        mode: mode
+    }, mask['inv'] === true && {
+        inverted: true
+    });
 }
 
 /** Stable diagnostic labels for unsupported Lottie shape operators. */ var SHAPE_FEATURE_LABELS = {
@@ -1306,18 +1534,195 @@ function buildCustomShapeData(shPaths, fills, strokes, transform) {
         strokes: strokes,
         position: position
     };
-    return shapeData;
-}
-
-/** Returns the first Text Document keyframe used for static text conversion. */ function parseLottieTextDocument(layer) {
-    var _asRecord;
-    if (layer.ty !== 5 || layer.t == null) {
+    return shapeData;
+}
+
+/** Returns the first Text Document keyframe used for static text conversion. */ function parseLottieTextDocument(layer) {
+    var _asRecord;
+    if (layer.ty !== 5 || layer.t == null) {
+        return undefined;
+    }
+    var textData = asRecord(layer.t);
+    var documentData = asRecord(textData == null ? void 0 : textData['d']);
+    var keyframes = documentData == null ? void 0 : documentData['k'];
+    return Array.isArray(keyframes) ? asRecord((_asRecord = asRecord(keyframes[0])) == null ? void 0 : _asRecord['s']) : undefined;
+}
+
+function isFiniteColor(value) {
+    return Array.isArray(value) && value.every(function(channel) {
+        return typeof channel === 'number' && Number.isFinite(channel);
+    });
+}
+function collectOutlinePaths(items) {
+    var paths = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
+        var item = _step.value;
+        if (item.hd === true) {
+            continue;
+        }
+        if (item.ty === 'gr') {
+            var _paths;
+            var _item_it;
+            var nested = collectOutlinePaths((_item_it = item.it) != null ? _item_it : []);
+            if (nested == null) {
+                return undefined;
+            }
+            (_paths = paths).push.apply(_paths, [].concat(nested));
+        } else if (item.ty === 'sh' && item.ks.a !== 1) {
+            paths.push(item);
+        } else {
+            return undefined;
+        }
+    }
+    return paths;
+}
+/** Embedded glyph paths use 100-unit font coordinates, independent of the exported font size. */ function convertLottieTextGlyphs(layer, fonts, chars) {
+    var _loop = function() {
+        var _step_value = _step.value, lineIndex = _step_value[0], line = _step_value[1];
+        var glyphs = Array.from(line, function(character) {
+            return chars.find(function(glyph) {
+                return glyph.ch === character && glyph.fFamily === font.fFamily && glyph.style === font.fStyle;
+            });
+        });
+        if (glyphs.some(function(glyph) {
+            return glyph == null;
+        })) {
+            return {
+                v: undefined
+            };
+        }
+        // Trailing spaces advance the pen but do not participate in Lottie's alignment width.
+        var trimmedLength = Array.from(line.replace(/ +$/, '')).length;
+        var width = glyphs.slice(0, trimmedLength).reduce(function(sum, glyph) {
+            var _ref;
+            return sum + ((_ref = glyph == null ? void 0 : glyph.w) != null ? _ref : 0) * scale + tracking;
+        }, 0) - (trimmedLength > 0 ? tracking : 0);
+        var x = document['j'] === 1 ? -width : document['j'] === 2 ? -width / 2 : 0;
+        var y = lineIndex * lineHeight + (lineIndex > 0 ? 1 : 0) - baselineShift;
+        for(var _iterator = _create_for_of_iterator_helper_loose(glyphs), _step1; !(_step1 = _iterator()).done;){
+            var glyph = _step1.value;
+            if (glyph == null) {
+                return {
+                    v: undefined
+                };
+            }
+            if ('shapes' in glyph.data) {
+                var _loop = function() {
+                    var shape = _step2.value;
+                    if (shape.primitiveType !== IRShapePrimitiveType.Custom) {
+                        return {
+                            v: undefined
+                        };
+                    }
+                    for(var _iterator = _create_for_of_iterator_helper_loose(shape.customPaths), _step; !(_step = _iterator()).done;){
+                        var path = _step.value;
+                        paths.push({
+                            closed: path.closed,
+                            points: path.points.map(function(point) {
+                                return {
+                                    x: (point.x + shape.position[0]) * scale + x,
+                                    y: (point.y + shape.position[1]) * scale + y
+                                };
+                            }),
+                            inTangents: path.inTangents.map(function(point) {
+                                return {
+                                    x: point.x * scale,
+                                    y: point.y * scale
+                                };
+                            }),
+                            outTangents: path.outTangents.map(function(point) {
+                                return {
+                                    x: point.x * scale,
+                                    y: point.y * scale
+                                };
+                            })
+                        });
+                    }
+                };
+                var outlinePaths = collectOutlinePaths(glyph.data.shapes);
+                if (outlinePaths == null) {
+                    return {
+                        v: undefined
+                    };
+                }
+                var converted = convertLottieShapes([
+                    {
+                        ty: 'gr',
+                        it: outlinePaths
+                    },
+                    {
+                        ty: 'fl',
+                        c: {
+                            a: 0,
+                            k: fillColor
+                        },
+                        o: {
+                            a: 0,
+                            k: 100
+                        },
+                        r: 1
+                    }
+                ]);
+                for(var _iterator1 = _create_for_of_iterator_helper_loose(converted.shapes), _step2; !(_step2 = _iterator1()).done;){
+                    var _ret = _loop();
+                    if (_type_of(_ret) === "object") return {
+                        v: _ret.v
+                    };
+                }
+            } else if (glyph.ch.trim() !== '') {
+                return {
+                    v: undefined
+                };
+            }
+            x += glyph.w * scale + tracking;
+        }
+    };
+    var _color_, _color_1, _color_2;
+    var document = parseLottieTextDocument(layer);
+    var font = fonts.find(function(item) {
+        return item.fName === (document == null ? void 0 : document['f']);
+    });
+    if (document == null || font == null || typeof document['t'] !== 'string' || document['sz'] != null || document['ps'] != null || toFiniteNumber(document['sw'], 0) !== 0) {
         return undefined;
     }
-    var textData = asRecord(layer.t);
-    var documentData = asRecord(textData == null ? void 0 : textData['d']);
-    var keyframes = documentData == null ? void 0 : documentData['k'];
-    return Array.isArray(keyframes) ? asRecord((_asRecord = asRecord(keyframes[0])) == null ? void 0 : _asRecord['s']) : undefined;
+    var color = document['fc'];
+    if (!isFiniteColor(color)) {
+        return undefined;
+    }
+    var fillColor = [
+        (_color_ = color[0]) != null ? _color_ : 0,
+        (_color_1 = color[1]) != null ? _color_1 : 0,
+        (_color_2 = color[2]) != null ? _color_2 : 0,
+        1
+    ];
+    var fontSize = toFiniteNumber(document['s'], 16);
+    var scale = fontSize / 100;
+    var tracking = toFiniteNumber(document['tr'], 0) * fontSize / 1000;
+    var lineHeight = toFiniteNumber(document['lh'], fontSize);
+    var baselineShift = toFiniteNumber(document['ls'], 0);
+    var paths = [];
+    var lines = document['t'].replace(/\r\n?/g, '\n').split('\n');
+    for(var _iterator = _create_for_of_iterator_helper_loose(lines.entries()), _step; !(_step = _iterator()).done;){
+        var _ret = _loop();
+        if (_type_of(_ret) === "object") return _ret.v;
+    }
+    return paths.length === 0 ? [] : [
+        {
+            primitiveType: IRShapePrimitiveType.Custom,
+            customPaths: paths,
+            position: [
+                0,
+                0
+            ],
+            fills: [
+                {
+                    type: IRPaintType.Solid,
+                    color: fillColor
+                }
+            ],
+            strokes: []
+        }
+    ];
 }
 
 var textWeightType = {
@@ -1511,230 +1916,25 @@ function readNamedFontWeight(value) {
     return undefined;
 }
 
-function hasAnimatedAnchor(layer) {
-    var property = getPropertyRecord(layer, 'a');
-    return property != null && isKeyframedProperty(property);
-}
-function toStaticAnchor(layer) {
-    var _ref;
-    var _property_keyframes_;
-    var property = toAnimatedProperty(getPropertyRecord(layer, 'a'), readVector3);
-    if (property == null || property.type === 'static') {
-        return property;
-    }
-    return {
-        type: 'static',
-        value: (_ref = (_property_keyframes_ = property.keyframes[0]) == null ? void 0 : _property_keyframes_.value) != null ? _ref : [
-            0,
-            0,
-            0
-        ]
-    };
-}
-function readVector3(value) {
-    var _values_, _values_1, _values_2;
-    var values = toFiniteNumberArray(value);
-    if (values == null) {
-        return undefined;
-    }
-    return [
-        (_values_ = values[0]) != null ? _values_ : 0,
-        (_values_1 = values[1]) != null ? _values_1 : 0,
-        (_values_2 = values[2]) != null ? _values_2 : 0
-    ];
-}
-function readSpatialTangent(value) {
-    var values = toFiniteNumberArray(value);
-    if ((values == null ? void 0 : values.length) === 2) {
-        return [
-            values[0],
-            values[1]
-        ];
-    }
-    if ((values == null ? void 0 : values.length) === 3) {
-        return [
-            values[0],
-            values[1],
-            values[2]
-        ];
-    }
-    return undefined;
-}
-function readScaleVector(value) {
-    var _values_, _values_1, _values_2;
-    var _toFiniteNumberArray;
-    var values = (_toFiniteNumberArray = toFiniteNumberArray(value)) == null ? void 0 : _toFiniteNumberArray.map(function(item) {
-        return item / 100;
-    });
-    if (values == null) {
-        return undefined;
-    }
-    return [
-        (_values_ = values[0]) != null ? _values_ : 1,
-        (_values_1 = values[1]) != null ? _values_1 : 1,
-        (_values_2 = values[2]) != null ? _values_2 : 1
-    ];
-}
-function readOpacityNumber(value) {
-    var valueNumber = toFirstNumber(value);
-    return valueNumber != null ? valueNumber / 100 : undefined;
-}
-function getPropertyRecord(layer, key) {
-    var ks = asRecord(layer.ks);
-    var property = asRecord(ks == null ? void 0 : ks[key]);
-    if (property == null || !('k' in property)) {
-        return undefined;
-    }
-    return property;
-}
-function readBezierHandle(value) {
-    var record = asRecord(value);
-    var x = toFirstNumber(record == null ? void 0 : record['x']);
-    var y = toFirstNumber(record == null ? void 0 : record['y']);
-    if (x == null || y == null) {
-        return undefined;
-    }
-    return {
-        x: x,
-        y: y
-    };
-}
-function readKeyframes(property, reader) {
-    var rawKeyframes = property['k'];
-    if (!Array.isArray(rawKeyframes)) {
-        return undefined;
-    }
-    var keyframes = [];
-    var previousEndValue;
-    // Lottie stores segment tangents on the start keyframe; IR assigns them to their endpoints.
-    var pendingInTangent;
-    var pendingSpatialIn;
-    for(var _iterator = _create_for_of_iterator_helper_loose(rawKeyframes), _step; !(_step = _iterator()).done;){
-        var rawKeyframe = _step.value;
-        var keyframeRecord = asRecord(rawKeyframe);
-        var t = keyframeRecord == null ? void 0 : keyframeRecord['t'];
-        if (!isFiniteNumber(t)) {
-            continue;
-        }
-        // Terminal keyframes inherit the preceding `e` value.
-        var value = reader(keyframeRecord == null ? void 0 : keyframeRecord['s']);
-        if (value == null) {
-            if (previousEndValue != null) {
-                value = previousEndValue;
-            } else {
-                continue;
-            }
-        }
-        var endValue = reader(keyframeRecord == null ? void 0 : keyframeRecord['e']);
-        previousEndValue = endValue != null ? endValue : value;
-        var recordInTangent = readBezierHandle(keyframeRecord == null ? void 0 : keyframeRecord['i']);
-        var outTangent = readBezierHandle(keyframeRecord == null ? void 0 : keyframeRecord['o']);
-        var spatialOut = readSpatialTangent(keyframeRecord == null ? void 0 : keyframeRecord['to']);
-        var recordSpatialIn = readSpatialTangent(keyframeRecord == null ? void 0 : keyframeRecord['ti']);
-        var inTangent = pendingInTangent;
-        var spatialIn = pendingSpatialIn;
-        keyframes.push(_extends({
-            frame: t,
-            value: value
-        }, endValue != null && {
-            endValue: endValue
-        }, (keyframeRecord == null ? void 0 : keyframeRecord['h']) === 1 && {
-            hold: true
-        }, inTangent != null && {
-            inTangent: inTangent
-        }, outTangent != null && {
-            outTangent: outTangent
-        }, spatialOut != null && {
-            spatialOut: spatialOut
-        }, spatialIn != null && {
-            spatialIn: spatialIn
-        }));
-        // Incoming tangents belong to the next IR keyframe.
-        pendingInTangent = recordInTangent;
-        pendingSpatialIn = recordSpatialIn;
-    }
-    return keyframes.length > 0 ? keyframes : undefined;
-}
-function toAnimatedProperty(property, reader) {
-    if (property == null) {
-        return undefined;
-    }
-    if (isKeyframedProperty(property)) {
-        var _ref;
-        var _keyframes_;
-        var keyframes = readKeyframes(property, reader);
-        if (keyframes != null && keyframes.length >= 2) {
-            return {
-                type: 'keyframed',
-                keyframes: keyframes
-            };
-        }
-        var staticValue = (_ref = keyframes == null ? void 0 : (_keyframes_ = keyframes[0]) == null ? void 0 : _keyframes_.value) != null ? _ref : reader(property['k']);
-        return staticValue != null ? {
-            type: 'static',
-            value: staticValue
-        } : undefined;
-    }
-    var value = reader(property['k']);
-    return value != null ? {
-        type: 'static',
-        value: value
-    } : undefined;
-}
-/**
- * Converts Lottie transform properties and keyframes to IR units and tangent ownership.
- *
- * Scale and opacity percentages become normalized factors. Animated anchors use their first keyframe because IR anchors
- * are static.
- */ function convertLottieTransform(layer) {
-    var _getPropertyRecord;
-    var transform = {};
-    var anchor = toStaticAnchor(layer);
-    var positionProperty = getPropertyRecord(layer, 'p');
-    var position = toAnimatedProperty(positionProperty, readVector3);
-    var scale = toAnimatedProperty(getPropertyRecord(layer, 's'), readScaleVector);
-    var rotationZ = toAnimatedProperty((_getPropertyRecord = getPropertyRecord(layer, 'rz')) != null ? _getPropertyRecord : getPropertyRecord(layer, 'r'), toFirstNumber);
-    var rotationX = toAnimatedProperty(getPropertyRecord(layer, 'rx'), toFirstNumber);
-    var rotationY = toAnimatedProperty(getPropertyRecord(layer, 'ry'), toFirstNumber);
-    var opacity = toAnimatedProperty(getPropertyRecord(layer, 'o'), readOpacityNumber);
-    if (anchor != null) {
-        transform.anchor = anchor;
-    }
-    if (position != null) {
-        transform.position = position;
-    }
-    if (scale != null) {
-        transform.scale = scale;
-    }
-    if (rotationX != null || rotationY != null || rotationZ != null) {
-        var rotation = {};
-        if (rotationX != null) {
-            rotation.x = rotationX;
-        }
-        if (rotationY != null) {
-            rotation.y = rotationY;
-        }
-        if (rotationZ != null) {
-            rotation.z = rotationZ;
-        }
-        transform.rotation = rotation;
-    }
-    if (opacity != null) {
-        transform.opacity = opacity;
-    }
-    return transform;
-}
-
 /**
  * Lowers one supported Lottie Layer after its parent, matte, and precomposition references have been resolved.
  *
  * Fidelity limitations are returned with the converted Layer for Scene-level diagnostic assembly.
  */ function convertLottieLayer(options) {
-    var _ref;
+    var _options_chars, _ref;
     var layer = options.layer, asset = options.asset, id = options.id;
     var layerRecord = layer;
-    var type = mapLottieLayerTypeToIR(layer);
+    var hasGlyphs = layer.ty === 5 && options.chars != null && options.chars.length > 0;
+    var glyphShapes = hasGlyphs ? convertLottieTextGlyphs(layer, options.fonts, (_options_chars = options.chars) != null ? _options_chars : []) : undefined;
+    var type = glyphShapes != null ? 'shape' : mapLottieLayerTypeToIR(layer);
     var diagnostics = [];
+    if (hasGlyphs && glyphShapes == null) {
+        diagnostics.push(createLottieDiagnostic({
+            code: 'unsupported-text-glyphs',
+            message: "Text layer '" + layer.nm + "' has missing or unsupported glyph outlines; using font-based text instead.",
+            layerInd: layer.ind
+        }));
+    }
     var solidLayerColor = type === 'solid' ? convertSolidColor(layer) : undefined;
     var parentLayerId = options.parentLayerId;
     var shapeLayer = layer.ty === 4 ? layer : undefined;
@@ -1817,7 +2017,7 @@ function toAnimatedProperty(property, reader) {
         content: textConversion.content
     }, type === 'shape' && {
         content: {
-            shapes: (_ref = shapeConversion == null ? void 0 : shapeConversion.shapes) != null ? _ref : []
+            shapes: (_ref = glyphShapes != null ? glyphShapes : shapeConversion == null ? void 0 : shapeConversion.shapes) != null ? _ref : []
         }
     }, type === 'precomp' && options.precompCompositionId != null && {
         content: {
@@ -1827,8 +2027,9 @@ function toAnimatedProperty(property, reader) {
         }
     }, {
         transform: transform,
-        blendMode: mapLottieBlendMode(layerRecord['bm']),
-        mask: maskConversion.mask
+        blendMode: mapLottieBlendMode(layerRecord['bm'])
+    }, maskConversion.masks.length > 0 && {
+        masks: maskConversion.masks
     });
     var localBounds = computeLottieLocalBounds(convertedLayer, layer, asset, textConversion == null ? void 0 : textConversion.localBounds);
     if (localBounds != null) {
@@ -1937,9 +2138,10 @@ function convertSolidColor(layer) {
 /** Analyzes authored masks; precomposition clipping remains in `content.clipToBounds`. */ function convertLayerMask(layer) {
     var layerRecord = layer;
     if (layerRecord['hasMask'] === true && layerRecord['masksProperties'] != null) {
-        return convertLottieMask(layerRecord['masksProperties']);
+        return convertLottieMasks(layerRecord['masksProperties']);
     }
     return {
+        masks: [],
         unsupportedFeatures: []
     };
 }
@@ -2151,8 +2353,25 @@ function resolveLayerMattes(layers, contextByLayerIndex, diagnostics) {
                 sourceLayer: layerForTransform
             });
         }
+    }, _loop1 = function() {
+        var context = _step2.value;
+        var _collectParents = collectParents(context, new Set()), parents = _collectParents.parents, ambiguous = _collectParents.ambiguous;
+        var childIn = Math.max(inPoint, toFiniteNumber(context.sourceLayer.ip, 0));
+        var childOut = Math.min(outPoint, toFiniteNumber(context.sourceLayer.op, 0));
+        // Lottie evaluates ancestor transforms even when their own content is inactive.
+        var needsIndependentLifetime = childOut > childIn && parents.some(function(parent) {
+            return childIn < toFiniteNumber(parent.sourceLayer.ip, 0) || childOut > toFiniteNumber(parent.sourceLayer.op, 0);
+        });
+        if (ambiguous || needsIndependentLifetime) {
+            context.parentTransformLayers = parents.map(function(parent) {
+                return parent.sourceLayer;
+            });
+        } else {
+            var _parents_;
+            context.parentLayerId = (_parents_ = parents[0]) == null ? void 0 : _parents_.layerId;
+        }
     };
-    var layers = param.layers, assetById = param.assetById, fonts = param.fonts;
+    var layers = param.layers, assetById = param.assetById, fonts = param.fonts, inPoint = param.inPoint, outPoint = param.outPoint;
     var contexts = [];
     var contextByLayerIndex = new Map();
     var diagnostics = [];
@@ -2167,16 +2386,53 @@ function resolveLayerMattes(layers, contextByLayerIndex, diagnostics) {
     };
     // Lottie lists topmost layers first; IR uses back-to-front painter order.
     for(var layerIndex = layers.length - 1; layerIndex >= 0; layerIndex--)_loop(layerIndex);
-    for(var _iterator = _create_for_of_iterator_helper_loose(contexts), _step; !(_step = _iterator()).done;){
+    var contextsByIndex = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(contexts.toReversed()), _step; !(_step = _iterator()).done;){
         var context = _step.value;
-        var parentInd = context.sourceLayer['parent'];
-        if (typeof parentInd === 'number') {
-            var parentContext = contextByLayerIndex.get(parentInd);
-            if (parentContext != null) {
-                context.parentLayerId = parentContext.layerId;
-            }
+        var index = context.sourceLayer.ind;
+        if (typeof index === 'number') {
+            var _contextsByIndex_get;
+            var matches = (_contextsByIndex_get = contextsByIndex.get(index)) != null ? _contextsByIndex_get : [];
+            matches.push(context);
+            contextsByIndex.set(index, matches);
+        }
+    }
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(contextsByIndex), _step1; !(_step1 = _iterator1()).done;){
+        var _step_value = _step1.value, index1 = _step_value[0], matches1 = _step_value[1];
+        if (matches1.length > 1) {
+            diagnostics.push(createLottieDiagnostic({
+                code: 'duplicate-layer-index',
+                message: "Layer index " + index1 + " is duplicated; parent transforms follow lottie-web's source-order hierarchy.",
+                layerInd: index1
+            }));
         }
     }
+    var collectParents = function collectParents1(context, ancestors) {
+        var _contextsByIndex_get;
+        if (ancestors.has(context)) {
+            throw new TypeError('Cyclic Lottie parent references cannot be converted.');
+        }
+        var parentIndex = context.sourceLayer.parent;
+        var matches = typeof parentIndex === 'number' ? (_contextsByIndex_get = contextsByIndex.get(parentIndex)) != null ? _contextsByIndex_get : [] : [];
+        var parents = [];
+        var ambiguous = matches.length > 1;
+        ancestors.add(context);
+        for(var _iterator = _create_for_of_iterator_helper_loose(matches), _step; !(_step = _iterator()).done;){
+            var parent = _step.value;
+            var _parents;
+            var inherited = collectParents(parent, ancestors);
+            (_parents = parents).push.apply(_parents, [].concat([
+                parent
+            ], inherited.parents));
+            ambiguous || (ambiguous = inherited.ambiguous);
+        }
+        ancestors.delete(context);
+        return {
+            parents: parents,
+            ambiguous: ambiguous
+        };
+    };
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(contexts), _step2; !(_step2 = _iterator2()).done;)_loop1();
     resolveLayerMattes(layers, contextByLayerIndex, diagnostics);
     return {
         contexts: contexts,
@@ -2243,27 +2499,55 @@ function buildIRCompositionFromIRLayers(layers, options) {
         var parsed = parseLottieLayerStack({
             layers: compositionLayers,
             assetById: assetById,
-            fonts: fonts
+            fonts: fonts,
+            inPoint: compositionInPoint,
+            outPoint: compositionOutPoint
         });
         var convertedLayers = [];
         (_diagnostics = diagnostics).push.apply(_diagnostics, [].concat(parsed.diagnostics));
         for(var _iterator = _create_for_of_iterator_helper_loose(parsed.contexts), _step; !(_step = _iterator()).done;){
             var context = _step.value;
             var _diagnostics1;
+            var _ref;
+            var _context_parentTransformLayers;
             var refId = 'refId' in context.sourceLayer ? context.sourceLayer.refId : undefined;
             var precompCompositionId = refId != null ? compositionIdByAssetId.get(String(refId)) : undefined;
+            var parentLayerId = context.parentLayerId;
+            // Private null layers retain ancestor transforms independently of visible
+            // content lifetimes and preserve source-order multiplication for duplicate indices.
+            for(var _iterator1 = _create_for_of_iterator_helper_loose((_ref = (_context_parentTransformLayers = context.parentTransformLayers) == null ? void 0 : _context_parentTransformLayers.toReversed()) != null ? _ref : []), _step1; !(_step1 = _iterator1()).done;){
+                var parent = _step1.value;
+                var transform = convertLottieTransform(parent);
+                var id = createId();
+                delete transform.opacity;
+                convertedLayers.push(_extends({
+                    id: id,
+                    type: 'null',
+                    time: {
+                        inFrame: compositionInPoint,
+                        outFrame: compositionOutPoint
+                    },
+                    visible: true,
+                    transform: transform
+                }, parentLayerId != null && {
+                    parentId: parentLayerId
+                }));
+                parentLayerId = id;
+            }
             var converted = convertLottieLayer({
                 layer: context.sourceLayer,
                 asset: context.asset,
                 id: context.layerId,
-                parentLayerId: context.parentLayerId,
+                parentLayerId: parentLayerId,
                 matte: context.matte,
                 compositionRange: {
                     inPoint: compositionInPoint,
                     outPoint: compositionOutPoint
                 },
                 precompCompositionId: precompCompositionId,
-                fontAssetIdByName: fontRegistry.assetIdByFontName
+                fontAssetIdByName: fontRegistry.assetIdByFontName,
+                fonts: fonts,
+                chars: json.chars
             });
             (_diagnostics1 = diagnostics).push.apply(_diagnostics1, [].concat(converted.diagnostics));
             convertedLayers.push(converted.layer);
@@ -11271,7 +11555,7 @@ Object.defineProperties(JSZip, staticAccessors);
  * @throws `LottieConverterError` when the archive is invalid or contains no JSON file.
  */ function extractLottieFromZip(zipData) {
     return _async_to_generator(function() {
-        var zip, error, resourcePaths, jsonPath, file, mimeType, json, dirPath, resources;
+        var zip, error, resourceEntries, jsonEntry, file, mimeType, json, dirPath, resources;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -11297,34 +11581,34 @@ Object.defineProperties(JSZip, staticAccessors);
                         cause: _instanceof(error, Error) ? error.message : String(error)
                     });
                 case 3:
-                    resourcePaths = [];
+                    resourceEntries = [];
                     for(var relativePath in zip.files){
                         file = zip.files[relativePath];
                         mimeType = resolveZipResourceMimeType(relativePath);
                         if (!file.dir && mimeType != null && !relativePath.includes('_MACOSX')) {
-                            resourcePaths.push({
+                            resourceEntries.push({
                                 file: file,
                                 mimeType: mimeType
                             });
                         }
                         if (!file.dir && /\.json$/i.test(relativePath) && !relativePath.includes('_MACOSX')) {
-                            jsonPath = file;
+                            jsonEntry = file;
                         }
                     }
-                    if (jsonPath == null) {
+                    if (jsonEntry == null) {
                         throw new LottieConverterError(LOTTIE_CONVERTER_ERROR_CODES.ZIP_JSON_NOT_FOUND, 'No JSON file was found in the ZIP archive.');
                     }
                     return [
                         4,
-                        jsonPath.async('string')
+                        jsonEntry.async('string')
                     ];
                 case 4:
                     json = _state.sent();
-                    dirPath = jsonPath.name.split('/').slice(0, -1).join('/');
+                    dirPath = jsonEntry.name.split('/').slice(0, -1).join('/');
                     resources = {};
                     return [
                         4,
-                        Promise.all(resourcePaths.map(function(param) {
+                        Promise.all(resourceEntries.map(function(param) {
                             var file = param.file, mimeType = param.mimeType;
                             return _async_to_generator(function() {
                                 var buffer, uint8Array, binary, i, base64;