@vvfx/svg2ir 0.0.1-beta.0 → 0.0.1-beta.11

package/dist/node.mjs

@@ -3,7 +3,7 @@
  * Description: SVG to Animation IR and Galacean Effects conversion engine
  * Author: Ant Group CO., Ltd.
  * Contributors: 鳞息
- * Version: v0.0.1-beta.0
+ * Version: v0.0.1-beta.11
  */
 
 import { createSVGWindow } from 'svgdom';
@@ -79,11 +79,10 @@ function readInlineStyleProperty(style, propertyName) {
 
 var ParseableSVG = /*#__PURE__*/ function() {
     function ParseableSVG(svgStr, _options) {
-        var _ref, _SVG;
-        var _svgStr_match;
-        // 从字符串里抠出首个 <svg>...</svg> 再交给 svg.js(兼容前导注释/doctype)。
+        var _SVG;
+        // svg.js parses a fragment; remove only the prolog and let the DOM handle nested markup.
+        var content = svgStr.replace(/^\uFEFF/, '').replace(/^(?:\s|<\?xml\b[\s\S]*?\?>|<!DOCTYPE\b[^>]*>|<!--[\s\S]*?-->)+/i, '');
         // svg.js SVG(string) 的 d.ts 标为 Element,但对完整 <svg> 文档运行时返回根 SVG 文档实例。
-        var content = typeof svgStr === 'string' ? (_ref = (_svgStr_match = svgStr.match(RegExp("<svg\\s+.*?>.*?<\\/svg>", "s"))) == null ? void 0 : _svgStr_match[0]) != null ? _ref : svgStr : svgStr;
         // svg.js 对非 SVG 字符串(如 'not svg')解析返 null。兜底空 svg:让 svg2ir 上层
         // hasSVGRootElement 检查(非 svg 抛 INVALID_SVG)生效,而非在构造期抛错。
         this.svg = (_SVG = SVG(content)) != null ? _SVG : SVG('<svg xmlns="http://www.w3.org/2000/svg"/>');
@@ -225,10 +224,10 @@ var editableSVGModule = /*#__PURE__*/Object.freeze({
     default: ParseableSVG
 });
 
-var window = createSVGWindow();
+var window$1 = createSVGWindow();
 // svgdom 的 window 是最小 DOM stub(非完整 Window),运行时被 svg.js registerWindow 接受;
 // d.ts 标 Window 类型过严,svgdom 的 window 是最小 DOM stub,这里断言对齐运行时用法。
-registerWindow(window, window.document);
+registerWindow(window$1, window$1.document);
 
 var editableSVGNodeModule = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1725,7 +1724,7 @@ function parseHexColor(raw) {
         return null;
     }
     var hex = match[1];
-    var expanded = hex.length <= 4 ? [].concat(hex).map(function(char) {
+    var expanded = hex.length <= 4 ? Array.from(hex).map(function(char) {
         return "" + char + char;
     }).join('') : hex;
     var r = parseInt(expanded.slice(0, 2), 16) / 255;
@@ -2826,7 +2825,24 @@ function parseSMILTag(tag, root, beginCache, comparisonDuration, valueParser, un
     return maxEnd;
 }
 
-/** SVG 转换诊断码。不支持的特性按降级和 warning 处理。 */ var SVG2IR_WARNING_CODES = {
+/** Structural source identity, independent of optional or duplicate SVG IDs. */ function buildElementTreePath(element) {
+    var indices = [];
+    var current = element;
+    while(isElementNode(current.parentNode)){
+        var parent = current.parentNode;
+        indices.unshift(Array.from(parent.children).indexOf(current));
+        current = parent;
+    }
+    return indices.join('/');
+}
+function isElementNode(node) {
+    return (node == null ? void 0 : node.nodeType) === 1;
+}
+
+/** SVG 转换诊断码；用于报告烘焙、降级和不支持的特性。 */ var SVG2IR_WARNING_CODES = {
+    /** 图形或图形组已栅格化，矢量编辑能力变化通过 warning 报告。 */ LAYERS_GRAPHIC_BAKED: 'svg2ge_layers_graphic_baked',
+    LAYERS_BLEND_MODE_DOWNGRADED: 'svg2ge_layers_blend_mode_downgraded',
+    LAYERS_ANIMATION_STRIPPED: 'svg2ge_layers_animation_stripped',
     LAYERS_UNSUPPORTED_TYPE: 'svg2ge_layers_unsupported_type',
     LAYERS_UNSUPPORTED_FEATURE: 'svg2ge_layers_unsupported_feature',
     LAYERS_INVALID_DATA: 'svg2ge_layers_invalid_data',
@@ -6316,8 +6332,9 @@ function readVec3(channel) {
         node
     ], Array.from(node.querySelectorAll('*')));
     var hasUnsupportedRule = ruleNodes.some(function(candidate) {
+        var _ref, _ref1;
         var _candidate_getAttribute, _candidate_getAttribute1;
-        return ((_candidate_getAttribute = candidate.getAttribute('clip-rule')) == null ? void 0 : _candidate_getAttribute.trim()) !== '' || ((_candidate_getAttribute1 = candidate.getAttribute('fill-rule')) == null ? void 0 : _candidate_getAttribute1.trim()) !== '';
+        return ((_ref = (_candidate_getAttribute = candidate.getAttribute('clip-rule')) == null ? void 0 : _candidate_getAttribute.trim()) != null ? _ref : '') !== '' || ((_ref1 = (_candidate_getAttribute1 = candidate.getAttribute('fill-rule')) == null ? void 0 : _candidate_getAttribute1.trim()) != null ? _ref1 : '') !== '';
     });
     if (hasUnsupportedRule) {
         warn(SVG2IR_WARNING_CODES.CLIP_RULE_DROPPED, "" + tag + " 内显式 clip-rule/fill-rule 未映射，IR 只保留 mask 几何，不保留该规则。");
@@ -7158,8 +7175,10 @@ function createSVGConversionSession(es, options) {
     };
     var appendLayer = function appendLayer(layer, element, applyElementClip) {
         if (applyElementClip === void 0) applyElementClip = true;
+        var _options_layerSourceCollector;
         var clippedLayer = applyElementClip ? applyClipMask(es, element, layer, clipMasks) : layer;
         layers.push(withGroupParent(clippedLayer, element));
+        (_options_layerSourceCollector = options.layerSourceCollector) == null ? void 0 : _options_layerSourceCollector.set(layer.id, buildElementTreePath(element.node));
     };
     var appendAsset = function appendAsset(asset) {
         if (registeredAssetIds.has(asset.id)) {
@@ -10567,7 +10586,7 @@ function mapFontWeight(raw, fontFamily) {
             seen.set(Math.round(w * 100), ch);
         }
     }
-    return [].concat(seen.entries()).map(function(param) {
+    return Array.from(seen.entries()).map(function(param) {
         var k = param[0], ch = param[1];
         return {
             ch: ch,
@@ -10617,6 +10636,9 @@ function mapFontWeight(raw, fontFamily) {
     // latin / digit / 标点:典型比例字体 sans-serif 大写字母约 0.65em,数字稍窄。
     return /[0-9]/.test(ch) ? 0.55 : 0.62;
 }
+/** 去除单个字体族名的 CSS 字符串引号。 */ function normalizeFontFamilyName(fontFamily) {
+    return fontFamily.trim().replace(/^(['"])(.*)\1$/, '$2');
+}
 /** 构造与 Effects Runtime getFontDesc 一致的 CSS font 简写字符串,用于 Canvas measureText。 */ function buildCanvasFontDesc(fontSize, fontFamily, fontWeight, fontStyle) {
     var weightStr = String(fontWeight);
     var genericFamilies = [
@@ -10625,7 +10647,8 @@ function mapFontWeight(raw, fontFamily) {
         'monospace',
         'courier'
     ];
-    var familyName = genericFamilies.includes(fontFamily) ? fontFamily : '"' + fontFamily + '"';
+    var family = normalizeFontFamilyName(fontFamily);
+    var familyName = genericFamilies.includes(family) ? family : '"' + family + '"';
     var desc = fontSize + "px " + familyName;
     if (weightStr !== 'normal' && weightStr !== '') {
         desc = weightStr + " " + desc;
@@ -10636,13 +10659,13 @@ function mapFontWeight(raw, fontFamily) {
     return desc;
 }
 /** 文本宽度估算。优先使用调用方提供的 Canvas measureText，否则使用字符级启发式系数。 */ function estimateTextWidth(content, fontSize, letterSpacing, measureText, fontFamily, fontWeight, fontStyle) {
-    var len = [].concat(content).length;
+    var chars = Array.from(content);
+    var len = chars.length;
     if (measureText != null && fontFamily !== '') {
         var fontDesc = buildCanvasFontDesc(fontSize, fontFamily, fontWeight, fontStyle);
         var width = measureText(fontDesc, content).width;
         return width + letterSpacing * Math.max(len - 1, 0);
     }
-    var chars = [].concat(content);
     var width1 = chars.reduce(function(s, ch) {
         return s + charWidthCoef(ch) * fontSize;
     }, 0);
@@ -12239,7 +12262,16 @@ function createSVGElementConverterRegistry(session) {
 }
 
 function buildSVGLayers(es, options) {
-    var session = createSVGConversionSession(es, options);
+    var currentPath;
+    var warningSourceCollector = options.warningSourceCollector;
+    var session = createSVGConversionSession(es, warningSourceCollector == null ? options : _extends({}, options, {
+        emit: function emit(warning) {
+            if (currentPath != null) {
+                warningSourceCollector.set(warning, currentPath);
+            }
+            options.emit(warning);
+        }
+    }));
     var converters = createSVGElementConverterRegistry(session);
     for(var _iterator = _create_for_of_iterator_helper_loose(session.all), _step; !(_step = _iterator()).done;){
         var element = _step.value;
@@ -12247,6 +12279,9 @@ function buildSVGLayers(es, options) {
         var _element_node_tagName, _element_node;
         var tag = (_ref = (_element_node = element.node) == null ? void 0 : (_element_node_tagName = _element_node.tagName) == null ? void 0 : _element_node_tagName.toLowerCase()) != null ? _ref : '';
         var selector = describeElement(element);
+        if (warningSourceCollector != null) {
+            currentPath = buildElementTreePath(element.node);
+        }
         if (isInInactiveSwitchBranch(element)) {
             continue;
         }
@@ -12312,6 +12347,8 @@ function parseSVGToIRScene(svgString, options) {
         value: scannedSmilDuration
     };
     var layerBuildOptions = {
+        layerSourceCollector: options == null ? void 0 : options.layerSourceCollector,
+        warningSourceCollector: options == null ? void 0 : options.warningSourceCollector,
         frameRate: frameRate,
         durationSeconds: effectiveDuration,
         emit: emit,
@@ -12491,6 +12528,8 @@ function parseSVGToIRWithPreservedData(source, options, collectors) {
     var svgString = readSVGString(source);
     var irScene = parseSVGToIRScene(svgString, _extends({}, options, {
         onWarning: emitWarning,
+        layerSourceCollector: collectors == null ? void 0 : collectors.layerSourceCollector,
+        warningSourceCollector: collectors == null ? void 0 : collectors.warningSourceCollector,
         textDataCollector: collectors == null ? void 0 : collectors.textDataByLayerId,
         paintAnimationsCollector: collectors == null ? void 0 : collectors.paintAnimationsByLayerId,
         shapeAnimationCollector: collectors == null ? void 0 : collectors.shapeAnimationsByLayerId
@@ -12666,7 +12705,8 @@ function collectLayerWarning(warnings, options, code, message, selector) {
     });
     warnings.push(warning);
     options.onWarning == null ? void 0 : options.onWarning.call(options, warning);
-    if (options.strict === true && code !== SVG2IR_WARNING_CODES.LAYERS_TEXT_BOUNDS_ESTIMATED) {
+    var advisory = code === SVG2IR_WARNING_CODES.LAYERS_TEXT_BOUNDS_ESTIMATED || code === SVG2IR_WARNING_CODES.LAYERS_GRAPHIC_BAKED;
+    if (options.strict === true && !advisory) {
         throw new SVGConverterError(SVG_CONVERTER_ERROR_CODES.LAYERS_CONVERSION_FAILED, warning.message, {
             stage: 'layers',
             sourceId: selector,
@@ -12991,9 +13031,12 @@ function buildTextRunLayout(runs, family, spacing, content, size, conversionOpti
             // 分段文字使用统一参考字号度量字宽和字体边界，再按片段字号缩放。
             var measurementSize = segmented ? 10 : run.fontSize;
             var scale = run.fontSize / measurementSize;
-            var font = (run.italic ? 'italic' : 'normal') + " " + (run.bold ? 'bold' : 'normal') + " " + measurementSize + "px" + (' "' + family + '"');
+            var weight = run.bold ? 'bold' : 'normal';
+            var style = run.italic ? 'italic' : 'normal';
+            var font = buildCanvasFontDesc(measurementSize, family, weight, style);
             var metrics = conversionOptions.measureText == null ? void 0 : conversionOptions.measureText.call(conversionOptions, font, segmented ? 'x' : run.text);
-            var chunks = segmented ? run.text.split('') : [
+            var characters = Array.from(run.text);
+            var chunks = segmented ? characters : [
                 run.text
             ];
             var advance = 0;
@@ -13002,12 +13045,13 @@ function buildTextRunLayout(runs, family, spacing, content, size, conversionOpti
                 var width = segmented ? conversionOptions.measureText == null ? void 0 : conversionOptions.measureText.call(conversionOptions, font, chunk).width : metrics == null ? void 0 : metrics.width;
                 var valid = width != null && Number.isFinite(width) && width >= 0;
                 estimated || (estimated = !valid);
-                advance += valid ? width : Array.from(chunk).length * measurementSize * 0.6;
+                advance += valid ? width : estimateTextWidth(chunk, measurementSize, 0, undefined, family, weight, style);
             }
-            var characterCount = segmented ? run.text.length : Array.from(run.text).length;
+            var characterCount = characters.length;
             var width1 = advance * scale + Math.max(0, characterCount - 1) * spacing;
-            var ascent = (metrics == null ? void 0 : metrics.fontBoundingBoxAscent) == null ? run.fontSize * 0.8 : metrics.fontBoundingBoxAscent * scale;
-            var descent = (metrics == null ? void 0 : metrics.fontBoundingBoxDescent) == null ? run.fontSize * 0.2 : metrics.fontBoundingBoxDescent * scale;
+            var fallback = resolveFontMetrics(undefined, family, weight, style, run.fontSize);
+            var ascent = (metrics == null ? void 0 : metrics.fontBoundingBoxAscent) == null ? fallback.asc : metrics.fontBoundingBoxAscent * scale;
+            var descent = (metrics == null ? void 0 : metrics.fontBoundingBoxDescent) == null ? fallback.desc : metrics.fontBoundingBoxDescent * scale;
             estimated || (estimated = (metrics == null ? void 0 : metrics.fontBoundingBoxAscent) == null || metrics.fontBoundingBoxDescent == null);
             if (!Number.isFinite(width1) || width1 < 0 || !Number.isFinite(ascent) || !Number.isFinite(descent)) {
                 throwInvalidLayerData('Text measurement returned invalid metrics.');
@@ -13154,6 +13198,7 @@ function convertIRTextLayer(layer, state, session, id) {
             content: part.run.text,
             bbox: mapPointsToBBox(polygon),
             polygon: polygon,
+            // Keep the authored font-family string, quotes included; consumers resolve families themselves.
             font_family: font.family,
             font_size: roundPixel(part.run.fontSize * scaleY),
             color: part.run.color,
@@ -13198,6 +13243,41 @@ function createLayerConverterRegistry(session) {
     ]);
 }
 
+/** 完全覆盖图片的直边矩形 mask 不改变可见内容。 */ function maskCoversImage(mask, bounds) {
+    var _Math, _Math1, _Math2, _Math3;
+    var path = mask.path;
+    var epsilon = 1e-6;
+    if (mask.mode === 'subtract' || mask.inverted === true || !path.closed || path.points.length !== 4) {
+        return false;
+    }
+    if (path.inTangents.length !== 4 || path.outTangents.length !== 4 || [].concat(path.inTangents, path.outTangents).some(function(tangent) {
+        return tangent.x !== 0 || tangent.y !== 0;
+    })) {
+        return false;
+    }
+    var straightEdges = path.points.every(function(point, index) {
+        var next = path.points[(index + 1) % 4];
+        var opposite = path.points[(index + 2) % 4];
+        var dx = Math.abs(next.x - point.x);
+        var dy = Math.abs(next.y - point.y);
+        return Number.isFinite(point.x) && Number.isFinite(point.y) && Math.abs(opposite.x - point.x) > epsilon && Math.abs(opposite.y - point.y) > epsilon && (dx <= epsilon && dy > epsilon || dy <= epsilon && dx > epsilon);
+    });
+    if (!straightEdges) {
+        return false;
+    }
+    var xs = path.points.map(function(point) {
+        return point.x;
+    });
+    var ys = path.points.map(function(point) {
+        return point.y;
+    });
+    var left = (_Math = Math).min.apply(_Math, [].concat(xs));
+    var right = (_Math1 = Math).max.apply(_Math1, [].concat(xs));
+    var top = (_Math2 = Math).min.apply(_Math2, [].concat(ys));
+    var bottom = (_Math3 = Math).max.apply(_Math3, [].concat(ys));
+    return bounds.width > 0 && bounds.height > 0 && left <= bounds.x + epsilon && right >= bounds.x + bounds.width - epsilon && top <= bounds.y + epsilon && bottom >= bounds.y + bounds.height - epsilon;
+}
+
 function resolveIRVisualState(layer, session) {
     if (!layer.visible) {
         return undefined;
@@ -13206,19 +13286,20 @@ function resolveIRVisualState(layer, session) {
     if (!state.visible || state.opacity <= 0) {
         return undefined;
     }
-    if (layer.mask != null || layer.matte != null) {
+    var unsupportedMask = layer.mask != null && (layer.type !== 'image' || !maskCoversImage(layer.mask, layer.localBounds));
+    if (unsupportedMask || layer.matte != null) {
         throwUnsupportedLayerFeature('Mask or clipping is not supported by the flat layer protocol.');
     }
     if (Math.abs(state.opacity - 1) > 1e-6) {
         throwUnsupportedLayerFeature('Layer opacity cannot be expressed by the target protocol.');
     }
     if (layer.blendMode != null && layer.blendMode !== IRBlendMode.Normal) {
-        throwUnsupportedLayerFeature('Non-default blending cannot be expressed by the target protocol.');
+        collectLayerWarning(session.warnings, session.options, SVG2IR_WARNING_CODES.LAYERS_BLEND_MODE_DOWNGRADED, 'Blend mode "' + String(layer.blendMode) + '" was downgraded to "normal"; the layer is retained.', layer.id);
     }
     return state;
 }
 
-function buildIRStaticLayers(session) {
+function buildIRStaticLayers(session, sourceIds) {
     var composition = session.composition, maskSourceIds = session.maskSourceIds, options = session.options, warnings = session.warnings;
     var registry = createLayerConverterRegistry(session);
     var result = [];
@@ -13243,6 +13324,7 @@ function buildIRStaticLayers(session) {
             var converted = converter.convert(layer, state, converter.layerType + "_" + String(index).padStart(4, '0'));
             if (converted != null) {
                 result.push(converted);
+                sourceIds == null ? void 0 : sourceIds.set(converted, layer.id);
                 layerCounts.set(converter.layerType, index);
             }
         } catch (error) {
@@ -13255,9 +13337,9 @@ function buildIRStaticLayers(session) {
     return result;
 }
 
-function assembleSVGStaticLayers(scene, options, warnings, preservedData) {
+function assembleSVGStaticLayers(scene, options, warnings, preservedData, sourceIds) {
     var session = buildLayerConversionSession(scene, options, warnings, preservedData);
-    var data = buildIRStaticLayers(session);
+    var data = buildIRStaticLayers(session, sourceIds);
     var composition = session.composition;
     if (composition.backgroundColor != null) {
         collectLayerWarning(warnings, options, SVG2IR_WARNING_CODES.LAYERS_UNSUPPORTED_TYPE, 'Composition background color is not an image or text layer.');
@@ -13270,6 +13352,1034 @@ function assembleSVGStaticLayers(scene, options, warnings, preservedData) {
         data: data
     };
 }
+/** Replace baked sources, combine native and raster layers in painter order, then report final diagnostics. */ function assembleSVGLayers(input) {
+    var _warnings, _ordered;
+    var scene = input.scene, options = input.options, preservedData = input.preservedData, layerSources = input.layerSources, warningSources = input.warningSources, baking = input.baking;
+    var warnings = input.warnings.filter(function(warning) {
+        return !baking.resolvesWarning(warning, warningSources.get(warning));
+    });
+    var composition = getIRSceneEntryComposition(scene);
+    var nativeScene = _extends({}, scene, {
+        compositions: scene.compositions.map(function(candidate) {
+            return candidate === composition ? _extends({}, candidate, {
+                layers: candidate.layers.filter(function(layer) {
+                    return !baking.replacesSource(layerSources.get(layer.id));
+                })
+            }) : candidate;
+        })
+    });
+    var sourceIds = new Map();
+    (_warnings = warnings).push.apply(_warnings, [].concat(baking.warnings));
+    var native = assembleSVGStaticLayers(nativeScene, _extends({}, options, {
+        strict: false,
+        onWarning: undefined
+    }), warnings, preservedData, sourceIds);
+    var ordered = native.data.map(function(layer) {
+        var _layerSources_get, _sourceIds_get;
+        return {
+            path: (_layerSources_get = layerSources.get((_sourceIds_get = sourceIds.get(layer)) != null ? _sourceIds_get : '')) != null ? _layerSources_get : '',
+            layer: layer
+        };
+    });
+    (_ordered = ordered).push.apply(_ordered, [].concat(baking.layers));
+    ordered.sort(function(left, right) {
+        return comparePaths(left.path, right.path);
+    });
+    var counts = {
+        image: 0,
+        text: 0
+    };
+    var data = ordered.map(function(param) {
+        var layer = param.layer;
+        return _extends({}, layer, {
+            id: layer.type + "_" + String(++counts[layer.type]).padStart(4, '0')
+        });
+    });
+    for(var _iterator = _create_for_of_iterator_helper_loose(warnings), _step; !(_step = _iterator()).done;){
+        var warning = _step.value;
+        options.onWarning == null ? void 0 : options.onWarning.call(options, warning);
+        if (options.strict === true) {
+            var message = warning.message.replace(/^\[svg2ge:layers\] /, '');
+            collectLayerWarning([], _extends({}, options, {
+                onWarning: undefined
+            }), warning.code, message, warning.elementSelector);
+        }
+    }
+    return {
+        size: native.size,
+        data: data,
+        warnings: warnings
+    };
+}
+function comparePaths(left, right) {
+    var a = left.split('/').map(Number);
+    var b = right.split('/').map(Number);
+    for(var index = 0; index < Math.min(a.length, b.length); index++){
+        if (a[index] !== b[index]) {
+            return a[index] - b[index];
+        }
+    }
+    return a.length - b.length;
+}
+
+var animatedElements = new Set([
+    'animate',
+    'animatetransform',
+    'animatemotion',
+    'set'
+]);
+var declarations$1 = new Set([
+    'defs',
+    'style',
+    'title',
+    'desc',
+    'metadata',
+    'symbol',
+    'clippath',
+    'mask',
+    'filter',
+    'lineargradient',
+    'radialgradient',
+    'pattern',
+    'marker'
+]);
+/** Preserve selector context until styles are frozen, then isolate the requested paint subtree. */ function prepareSVGSnapshot(source, path, size, inspect) {
+    var parsed = new DOMParser().parseFromString(source, 'image/svg+xml');
+    if (parsed.querySelector('parsererror') != null) {
+        throw new Error('Invalid SVG document.');
+    }
+    var root = parsed.documentElement;
+    var elements = [].concat([
+        root
+    ], Array.from(root.querySelectorAll('*')));
+    var selected = elements.find(function(element) {
+        return buildElementTreePath(element) === path;
+    });
+    if (selected == null) {
+        throw new Error('The graphic source element could not be located.');
+    }
+    if (root.querySelector('script, foreignObject') != null) {
+        throw new Error('Scripts and foreignObject are outside static graphic baking support.');
+    }
+    if (Array.from(root.querySelectorAll('style')).some(function(element) {
+        var _element_textContent;
+        return /@import|@font-face/i.test((_element_textContent = element.textContent) != null ? _element_textContent : '');
+    })) {
+        throw new Error('External stylesheets and fonts require explicit resource preparation.');
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(elements), _step; !(_step = _iterator()).done;){
+        var element = _step.value;
+        for(var _iterator1 = _create_for_of_iterator_helper_loose(Array.from(element.attributes)), _step1; !(_step1 = _iterator1()).done;){
+            var attribute = _step1.value;
+            if (/^on/i.test(attribute.name)) {
+                element.removeAttributeNode(attribute);
+            }
+        }
+    }
+    var frame = document.createElement('iframe');
+    frame.setAttribute('sandbox', 'allow-same-origin');
+    frame.style.cssText = "position:fixed;left:-100000px;top:0;width:" + size[0] + "px;height:" + size[1] + "px;border:0;";
+    document.body.appendChild(frame);
+    try {
+        var _loop = function() {
+            var element = _step3.value;
+            var _element_getAttribute;
+            var computed = frameWindow.getComputedStyle(element);
+            var inside = target.contains(element);
+            var ancestor = element !== target && element.contains(target);
+            if ((inside || ancestor) && (computed.animationName !== 'none' || hasAnimationChildren(element))) {
+                throw new Error('Animated graphics require an explicit sampling policy.');
+            }
+            // Freezing inherited defaults on a definition changes <use> instance inheritance.
+            // Freeze only authored declarations, after matching selectors in the intact source tree.
+            var authored = frameDocument.createElement('div').style;
+            authored.cssText = (_element_getAttribute = element.getAttribute('style')) != null ? _element_getAttribute : '';
+            var names = new Set(Array.from(authored));
+            for(var _iterator = _create_for_of_iterator_helper_loose(styleRules), _step; !(_step = _iterator()).done;){
+                var rule = _step.value;
+                if (element.matches(rule.selectorText)) {
+                    for(var _iterator1 = _create_for_of_iterator_helper_loose(Array.from(rule.style)), _step1; !(_step1 = _iterator1()).done;){
+                        var name = _step1.value;
+                        names.add(name);
+                    }
+                }
+            }
+            var properties = Array.from(names, function(name) {
+                var value = computed.getPropertyValue(name);
+                value = value.replace(/url\(["']?([^)'"\s]+)["']?\)/g, function(_match, url) {
+                    return 'url("' + normalizeReference(url) + '")';
+                });
+                return name + ":" + value + " !important;";
+            });
+            var isTemplate = templateRoots.some(function(template) {
+                return template.contains(element);
+            });
+            frozenStyles.push(isTemplate ? null : properties.join(''));
+        };
+        var frameDocument = frame.contentDocument;
+        var frameWindow = frame.contentWindow;
+        if (frameDocument == null || frameWindow == null) {
+            throw new Error('Unable to create isolated SVG context.');
+        }
+        frameDocument.body.style.cssText = 'margin:0;';
+        var mounted = frameDocument.importNode(root, true);
+        mounted.setAttribute('width', String(size[0]));
+        mounted.setAttribute('height', String(size[1]));
+        frameDocument.body.appendChild(mounted);
+        var mountedElements = [].concat([
+            mounted
+        ], Array.from(mounted.querySelectorAll('*')));
+        var selectedIndex = elements.indexOf(selected);
+        var target = mountedElements[selectedIndex];
+        var normalizeReference = function normalizeReference(url) {
+            if (url.startsWith('#')) {
+                return url;
+            }
+            var hash = url.indexOf('#');
+            if (hash >= 0 && url.slice(0, hash) === frameDocument.baseURI.split('#')[0]) {
+                return url.slice(hash);
+            }
+            throw new Error('External paint resources require explicit resource preparation.');
+        };
+        var frozenStyles = [];
+        var templateRoots = Array.from(mounted.querySelectorAll('use')).flatMap(function(element) {
+            var _ref, _element_getAttribute;
+            var href = (_ref = (_element_getAttribute = element.getAttribute('href')) != null ? _element_getAttribute : element.getAttribute('xlink:href')) != null ? _ref : '';
+            var template = href.startsWith('#') ? mountedElements.find(function(candidate) {
+                return candidate.id === href.slice(1);
+            }) : null;
+            return template == null ? [] : [
+                template
+            ];
+        });
+        var styleRules = [];
+        var collectRules = function collectRules1(rules) {
+            for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(rules)), _step; !(_step = _iterator()).done;){
+                var rule = _step.value;
+                if (isStyleRule$2(rule)) {
+                    styleRules.push(rule);
+                } else if (hasNestedRules$1(rule)) {
+                    if (isMediaRule(rule) && !frameWindow.matchMedia(rule.conditionText).matches) {
+                        continue;
+                    }
+                    collectRules(rule.cssRules);
+                }
+            }
+        };
+        for(var _iterator2 = _create_for_of_iterator_helper_loose(Array.from(frameDocument.styleSheets)), _step2; !(_step2 = _iterator2()).done;){
+            var sheet = _step2.value;
+            collectRules(sheet.cssRules);
+        }
+        for(var _iterator3 = _create_for_of_iterator_helper_loose(mountedElements), _step3; !(_step3 = _iterator3()).done;)_loop();
+        for(var index = 0; index < mountedElements.length; index++){
+            var style = frozenStyles[index];
+            if (style != null) {
+                mountedElements[index].setAttribute('style', style);
+            }
+        }
+        var byId = new Map(mountedElements.filter(function(element) {
+            return element.id !== '';
+        }).map(function(element) {
+            return [
+                element.id,
+                element
+            ];
+        }));
+        var seen = new Set();
+        var checkDependencies = function checkDependencies1(element) {
+            if (seen.has(element)) {
+                return;
+            }
+            seen.add(element);
+            for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(element.attributes)), _step; !(_step = _iterator()).done;){
+                var attribute = _step.value;
+                if (attribute.localName === 'href' && element.tagName.toLowerCase() === 'a') {
+                    continue;
+                }
+                if (attribute.localName === 'href' && !attribute.value.startsWith('#') && !([
+                    'image',
+                    'feimage'
+                ].includes(element.tagName.toLowerCase()) && /^data:image\//i.test(attribute.value))) {
+                    throw new Error('External SVG references require explicit resource preparation.');
+                }
+                var normalized = attribute.value.replace(/url\(\s*["']?([^)'"\s]+)["']?\s*\)/g, function(_match, url) {
+                    return 'url("' + normalizeReference(url) + '")';
+                });
+                var ids = Array.from(normalized.matchAll(/url\(["']?#([^)'"\s]+)["']?\)/g), function(match) {
+                    return match[1];
+                });
+                if (normalized !== attribute.value) {
+                    element.setAttribute(attribute.name, normalized);
+                }
+                if (attribute.localName === 'href' && attribute.value.startsWith('#')) {
+                    ids.push(attribute.value.slice(1));
+                }
+                for(var _iterator1 = _create_for_of_iterator_helper_loose(ids), _step1; !(_step1 = _iterator1()).done;){
+                    var id = _step1.value;
+                    var dependency = byId.get(id);
+                    if (dependency == null) {
+                        throw new Error("Missing SVG reference: #" + id + ".");
+                    }
+                    checkDependencies(dependency);
+                }
+            }
+            for(var _iterator2 = _create_for_of_iterator_helper_loose(Array.from(element.children)), _step2; !(_step2 = _iterator2()).done;){
+                var child = _step2.value;
+                if (!declarations$1.has(child.tagName.toLowerCase())) {
+                    checkDependencies(child);
+                }
+            }
+        };
+        checkDependencies(target);
+        for(var _iterator4 = _create_for_of_iterator_helper_loose(seen), _step4; !(_step4 = _iterator4()).done;){
+            var dependency = _step4.value;
+            if (frameWindow.getComputedStyle(dependency).animationName !== 'none' || hasAnimationChildren(dependency)) {
+                throw new Error('Animated graphics require an explicit sampling policy.');
+            }
+        }
+        inspect == null ? void 0 : inspect({
+            root: mounted,
+            target: target,
+            elements: mountedElements,
+            dependencies: seen,
+            readStyle: function readStyle(element) {
+                return frameWindow.getComputedStyle(element);
+            }
+        });
+        var isolate = function isolate1(element) {
+            for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(element.children)), _step; !(_step = _iterator()).done;){
+                var child = _step.value;
+                var tag = child.tagName.toLowerCase();
+                if (declarations$1.has(tag) || child === target || target.contains(child)) {
+                    continue;
+                }
+                if (child.contains(target)) {
+                    isolate(child);
+                } else {
+                    var definitions = frameDocument.createElementNS('http://www.w3.org/2000/svg', 'defs');
+                    child.replaceWith(definitions);
+                    definitions.appendChild(child);
+                }
+            }
+        };
+        if (target !== mounted) {
+            isolate(mounted);
+        }
+        return new XMLSerializer().serializeToString(mounted);
+    } finally{
+        frame.remove();
+    }
+}
+/** Only animations attached to this element reject its own bake scope, not unrelated subtrees. */ function hasAnimationChildren(element) {
+    return Array.from(element.children).some(function(child) {
+        return animatedElements.has(child.tagName.toLowerCase());
+    });
+}
+function isStyleRule$2(rule) {
+    return rule.type === 1;
+}
+function hasNestedRules$1(rule) {
+    return 'cssRules' in rule;
+}
+function isMediaRule(rule) {
+    return rule.type === 4;
+}
+
+/** Render an SVG subtree as a cropped PNG, or return null if it has no visible pixels. */ function rasterizeSVG(source, path, size, scale, inspect) {
+    if (scale === void 0) scale = 2;
+    return _async_to_generator(function() {
+        var snapshot, canvas;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!Number.isFinite(scale) || scale <= 0) {
+                        throw new RangeError('rasterScale must be finite and positive.');
+                    }
+                    if (Math.ceil(size[0] * scale) * Math.ceil(size[1] * scale) > 16777216) {
+                        throw new RangeError('SVG rasterization exceeds the 16 megapixel working limit; reduce rasterScale.');
+                    }
+                    snapshot = prepareSVGSnapshot(source, path, size, inspect);
+                    return [
+                        4,
+                        renderSVG(snapshot, size, scale)
+                    ];
+                case 1:
+                    canvas = _state.sent();
+                    return [
+                        2,
+                        cropRasterImage(canvas, scale)
+                    ];
+            }
+        });
+    })();
+}
+/** No DOM access at module initialization: the Node entry also imports this module. */ function canRasterizeSVG() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined' && typeof window.HTMLCanvasElement === 'function' && typeof window.Image === 'function' && typeof window.getComputedStyle === 'function';
+}
+function renderSVG(svg, size, scale) {
+    return _async_to_generator(function() {
+        var canvas, context, image, url;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    canvas = document.createElement('canvas');
+                    canvas.width = Math.ceil(size[0] * scale);
+                    canvas.height = Math.ceil(size[1] * scale);
+                    context = canvas.getContext('2d');
+                    if (context == null) {
+                        throw new Error('A 2D canvas context is required for SVG rasterization.');
+                    }
+                    image = new Image();
+                    url = URL.createObjectURL(new Blob([
+                        svg
+                    ], {
+                        type: 'image/svg+xml'
+                    }));
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        ,
+                        3,
+                        4
+                    ]);
+                    return [
+                        4,
+                        new Promise(function(resolve, reject) {
+                            image.onload = function() {
+                                return resolve();
+                            };
+                            image.onerror = function() {
+                                return reject(new Error('The prepared SVG could not be decoded.'));
+                            };
+                            image.src = url;
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    context.drawImage(image, 0, 0, canvas.width, canvas.height);
+                    return [
+                        2,
+                        canvas
+                    ];
+                case 3:
+                    URL.revokeObjectURL(url);
+                    return [
+                        7
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+/** Trim transparent pixels after rendering, retaining strokes, blur and filter extents. */ function cropRasterImage(canvas, scale) {
+    var context = canvas.getContext('2d');
+    if (context == null) {
+        throw new Error('A 2D canvas context is required for SVG rasterization.');
+    }
+    var data = context.getImageData(0, 0, canvas.width, canvas.height).data;
+    var left = canvas.width;
+    var top = canvas.height;
+    var right = 0;
+    var bottom = 0;
+    for(var y = 0; y < canvas.height; y++){
+        for(var x = 0; x < canvas.width; x++){
+            if (data[(y * canvas.width + x) * 4 + 3] === 0) {
+                continue;
+            }
+            left = Math.min(left, x);
+            top = Math.min(top, y);
+            right = Math.max(right, x + 1);
+            bottom = Math.max(bottom, y + 1);
+        }
+    }
+    if (right <= left || bottom <= top) {
+        return null;
+    }
+    var cropped = document.createElement('canvas');
+    cropped.width = right - left;
+    cropped.height = bottom - top;
+    var croppedContext = cropped.getContext('2d');
+    if (croppedContext == null) {
+        throw new Error('A 2D canvas context is required for SVG rasterization.');
+    }
+    croppedContext.drawImage(canvas, left, top, cropped.width, cropped.height, 0, 0, cropped.width, cropped.height);
+    return {
+        url: cropped.toDataURL('image/png'),
+        bbox: [
+            left / scale,
+            top / scale,
+            right / scale,
+            bottom / scale
+        ]
+    };
+}
+
+var normalValues = new Set([
+    'normal',
+    'initial',
+    'inherit',
+    'unset',
+    'revert',
+    'revert-layer'
+]);
+/** Replace non-normal mix-blend-mode declarations with normal and report each downgrade. */ function normalizeLayerBlending(source) {
+    var _loop = function() {
+        var element = _step.value;
+        var _element_getAttribute;
+        var _readPresentationAttribute;
+        var tag = element.tagName.toLowerCase();
+        var id = (_element_getAttribute = element.getAttribute('id')) != null ? _element_getAttribute : '';
+        var selector = id === '' ? tag : tag + "#" + id;
+        var mode = (_readPresentationAttribute = readPresentationAttribute(element, 'mix-blend-mode')) == null ? void 0 : _readPresentationAttribute.replace(/\/\*[\s\S]*?\*\//g, '').trim();
+        if (mode != null && !normalValues.has(mode.toLowerCase())) {
+            downgrades.push({
+                mode: mode,
+                selector: selector
+            });
+        }
+        var style = element.getAttribute('style');
+        if (style != null) {
+            var normalized = normalizeBlendDeclarations(style);
+            if (normalized !== style) {
+                element.setAttribute('style', normalized);
+                changed = true;
+            }
+        }
+        var attribute = element.getAttribute('mix-blend-mode');
+        if (attribute != null && !normalValues.has(attribute.trim().toLowerCase())) {
+            element.setAttribute('mix-blend-mode', 'normal');
+            changed = true;
+        }
+        if (tag === 'style') {
+            var _element_textContent;
+            var text = (_element_textContent = element.textContent) != null ? _element_textContent : '';
+            var normalized1 = normalizeBlendDeclarations(text, function(value) {
+                return downgrades.push({
+                    mode: value,
+                    selector: selector
+                });
+            });
+            if (normalized1 !== text) {
+                element.textContent = normalized1;
+                changed = true;
+            }
+        }
+    };
+    var svg = SVG(source);
+    var downgrades = [];
+    var changed = false;
+    for(var _iterator = _create_for_of_iterator_helper_loose([].concat([
+        svg.node
+    ], Array.from(svg.node.querySelectorAll('*')))), _step; !(_step = _iterator()).done;)_loop();
+    return {
+        source: changed ? svg.svg() : source,
+        downgrades: downgrades
+    };
+}
+/** Match declaration boundaries without changing strings, comments or function arguments. */ function normalizeBlendDeclarations(source, onDowngrade) {
+    var replacements = [];
+    var start = 0;
+    var colon = -1;
+    var parentheses = 0;
+    var quote;
+    var comment = false;
+    var finish = function finish(end) {
+        if (colon < start) {
+            return;
+        }
+        var name = source.slice(start, colon).replace(/\/\*[\s\S]*?\*\//g, '').trim().toLowerCase();
+        if (name !== 'mix-blend-mode') {
+            return;
+        }
+        var value = source.slice(colon + 1, end).replace(/\/\*[\s\S]*?\*\//g, '').trim();
+        var mode = value.replace(/\s*!important\s*$/i, '').trim();
+        if (mode === '' || normalValues.has(mode.toLowerCase())) {
+            return;
+        }
+        onDowngrade == null ? void 0 : onDowngrade(mode);
+        replacements.push({
+            start: colon + 1,
+            end: end,
+            value: /!important\s*$/i.test(value) ? ' normal !important' : ' normal'
+        });
+    };
+    for(var index = 0; index < source.length; index++){
+        var character = source[index];
+        var next = source[index + 1];
+        if (comment) {
+            if (character === '*' && next === '/') {
+                comment = false;
+                index++;
+            }
+            continue;
+        }
+        if (quote != null) {
+            if (character === '\\') {
+                index++;
+            } else if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === '/' && next === '*') {
+            comment = true;
+            index++;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === '(') {
+            parentheses++;
+            continue;
+        }
+        if (character === ')') {
+            parentheses = Math.max(0, parentheses - 1);
+            continue;
+        }
+        if (parentheses > 0) {
+            continue;
+        }
+        if (character === ':' && colon < start) {
+            colon = index;
+        }
+        if (character === ';' || character === '}' || character === '{') {
+            if (character !== '{') {
+                finish(index);
+            }
+            start = index + 1;
+            colon = -1;
+        }
+    }
+    finish(source.length);
+    var result = '';
+    var cursor = 0;
+    for(var _iterator = _create_for_of_iterator_helper_loose(replacements), _step; !(_step = _iterator()).done;){
+        var replacement = _step.value;
+        result += source.slice(cursor, replacement.start) + replacement.value;
+        cursor = replacement.end;
+    }
+    return result + source.slice(cursor);
+}
+
+var declarations = new Set([
+    'defs',
+    'style',
+    'title',
+    'desc',
+    'metadata',
+    'symbol',
+    'clippath',
+    'mask',
+    'filter',
+    'lineargradient',
+    'radialgradient',
+    'pattern',
+    'marker'
+]);
+var graphics = new Set([
+    'path',
+    'rect',
+    'circle',
+    'ellipse',
+    'line',
+    'polyline',
+    'polygon',
+    'use'
+]);
+var containers = new Set([
+    'svg',
+    'g',
+    'a',
+    'switch'
+]);
+var groupEffects = [
+    'opacity',
+    'filter',
+    'mask',
+    'clip-path'
+];
+var native = new Set([
+    'text',
+    'image',
+    'foreignobject'
+]);
+/** Select graphic-only subtrees; keep native text and images as separate layers. */ function planGraphicBaking(source) {
+    var root = SVG(source).node;
+    var scopes = [];
+    var warnings = [];
+    var effectRules = collectGroupEffectRules(root);
+    var byId = new Map(Array.from(root.querySelectorAll('[id]')).map(function(element) {
+        var _element_getAttribute;
+        return [
+            (_element_getAttribute = element.getAttribute('id')) != null ? _element_getAttribute : '',
+            element
+        ];
+    }));
+    var tagOf = function tagOf(element) {
+        return element.tagName.toLowerCase();
+    };
+    var selectorOf = function selectorOf(element) {
+        var _element_getAttribute;
+        var id = (_element_getAttribute = element.getAttribute('id')) != null ? _element_getAttribute : '';
+        return "" + tagOf(element) + (id === '' ? '' : "#" + id);
+    };
+    var references = function references(element) {
+        var ids = Array.from(element.attributes).flatMap(function(attribute) {
+            var values = Array.from(attribute.value.matchAll(/url\(\s*['"]?#([^)'"\s]+)['"]?\s*\)/g), function(match) {
+                return match[1];
+            });
+            if (attribute.localName === 'href' && attribute.value.startsWith('#')) {
+                values.push(attribute.value.slice(1));
+            }
+            return values;
+        });
+        return ids.flatMap(function(id) {
+            var target = byId.get(id);
+            return target == null ? [] : [
+                target
+            ];
+        });
+    };
+    var containsNative = function containsNative1(element, seen) {
+        if (seen === void 0) seen = new Set();
+        if (seen.has(element)) {
+            return false;
+        }
+        seen.add(element);
+        if (native.has(tagOf(element))) {
+            return true;
+        }
+        return Array.from(element.children).some(function(child) {
+            return !declarations.has(tagOf(child)) && containsNative(child, seen);
+        }) || references(element).some(function(target) {
+            return containsNative(target, seen);
+        });
+    };
+    var hasGraphics = function hasGraphics1(element) {
+        return graphics.has(tagOf(element)) || Array.from(element.children).some(function(child) {
+            return !declarations.has(tagOf(child)) && hasGraphics(child);
+        });
+    };
+    var hasGroupEffect = function hasGroupEffect(element) {
+        var _element_getAttribute;
+        var style = (_element_getAttribute = element.getAttribute('style')) != null ? _element_getAttribute : '';
+        return effectRules.some(function(rule) {
+            return element.matches(rule.selectorText);
+        }) || hasGraphicGroupEffect(function(name) {
+            var _element_getAttribute;
+            var _exec_, _exec;
+            return (_element_getAttribute = element.getAttribute(name)) != null ? _element_getAttribute : (_exec = new RegExp("(?:^|;)\\s*" + name + "\\s*:\\s*([^;]+)").exec(style)) == null ? void 0 : (_exec_ = _exec[1]) == null ? void 0 : _exec_.trim();
+        });
+    };
+    var visit = function visit1(element) {
+        var _element_getAttribute, _ref;
+        var _exec_, _exec;
+        var tag = tagOf(element);
+        var style = (_element_getAttribute = element.getAttribute('style')) != null ? _element_getAttribute : '';
+        var display = (_ref = (_exec = /(?:^|;)\s*display\s*:\s*([^;]+)/.exec(style)) == null ? void 0 : (_exec_ = _exec[1]) == null ? void 0 : _exec_.trim()) != null ? _ref : element.getAttribute('display');
+        if (display === 'none') {
+            return;
+        }
+        if (declarations.has(tag) || native.has(tag)) {
+            return;
+        }
+        if (!containers.has(tag) && !graphics.has(tag)) {
+            return;
+        }
+        if (!hasGraphics(element)) {
+            return;
+        }
+        if ((graphics.has(tag) || tag === 'switch') && !containsNative(element)) {
+            scopes.push({
+                path: buildElementTreePath(element),
+                selector: selectorOf(element),
+                isGroup: containers.has(tag)
+            });
+            return;
+        }
+        if (hasGroupEffect(element) && !containsNative(element)) {
+            scopes.push({
+                path: buildElementTreePath(element),
+                selector: selectorOf(element),
+                isGroup: containers.has(tag)
+            });
+            return;
+        }
+        if (hasGroupEffect(element)) {
+            warnings.push({
+                message: 'A compositing group contains native text or images; its graphics cannot be baked separately.',
+                selector: selectorOf(element)
+            });
+            return;
+        }
+        for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(element.children)), _step; !(_step = _iterator()).done;){
+            var child = _step.value;
+            visit(child);
+        }
+    };
+    visit(root);
+    return {
+        scopes: scopes,
+        warnings: warnings
+    };
+}
+function collectGroupEffectRules(root) {
+    var result = [];
+    if (typeof CSSStyleSheet !== 'function') {
+        return result;
+    }
+    var visit = function visit1(rules) {
+        var _loop = function() {
+            var rule = _step.value;
+            if (isStyleRule$1(rule)) {
+                var affectsGroup = hasGraphicGroupEffect(function(name) {
+                    var value = rule.style.getPropertyValue(name).trim();
+                    return value === '' || value === 'initial' || value === 'unset' ? undefined : value;
+                });
+                if (affectsGroup) {
+                    result.push(rule);
+                }
+            } else if (hasNestedRules(rule)) {
+                visit(rule.cssRules);
+            }
+        };
+        for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(rules)), _step; !(_step = _iterator()).done;)_loop();
+    };
+    for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(root.querySelectorAll('style'))), _step; !(_step = _iterator()).done;){
+        var style = _step.value;
+        var _style_textContent;
+        var sheet = new CSSStyleSheet();
+        sheet.replaceSync((_style_textContent = style.textContent) != null ? _style_textContent : '');
+        visit(sheet.cssRules);
+    }
+    return result;
+}
+/** Reject text/image dependencies and effects that cannot be rendered independently. */ function validateGraphicSnapshot(context) {
+    var _loop = function() {
+        var element = _step1.value;
+        var computed = readStyle(element);
+        var ancestor = element !== target && element.contains(target);
+        var groupEffect = ancestor && hasGraphicGroupEffect(function(name) {
+            return name === 'mask' ? computed.maskImage : computed.getPropertyValue(name);
+        });
+        if (ancestor && (groupEffect || computed.mixBlendMode !== 'normal')) {
+            throw new Error('A mixed group effect cannot be applied independently to its graphics.');
+        }
+        if (target.contains(element) && target !== root && computed.mixBlendMode !== 'normal') {
+            throw new Error('Blend modes that depend on an external backdrop cannot be baked independently.');
+        }
+    };
+    var root = context.root, target = context.target, elements = context.elements, dependencies = context.dependencies, readStyle = context.readStyle;
+    for(var _iterator = _create_for_of_iterator_helper_loose(dependencies), _step; !(_step = _iterator()).done;){
+        var element = _step.value;
+        if ([
+            'text',
+            'image',
+            'foreignobject'
+        ].includes(element.tagName.toLowerCase())) {
+            throw new Error('Graphic dependencies contain native text or images; they must remain editable.');
+        }
+    }
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(elements), _step1; !(_step1 = _iterator1()).done;)_loop();
+}
+function isStyleRule$1(rule) {
+    return rule.type === 1;
+}
+function hasNestedRules(rule) {
+    return 'cssRules' in rule;
+}
+function hasGraphicGroupEffect(readValue) {
+    return groupEffects.some(function(name) {
+        var value = readValue(name);
+        return value != null && value !== 'none' && value !== 'normal' && value !== '1';
+    });
+}
+
+/** Mask and clipPath definitions do not produce visible layers. */ function collectNonRenderingDeclarationPaths(source) {
+    var root = SVG(source).node;
+    var elements = Array.from(root.querySelectorAll('*')).filter(function(element) {
+        var tag = element.tagName.toLowerCase();
+        return tag === 'mask' || tag === 'clippath';
+    });
+    return new Set(elements.map(buildElementTreePath));
+}
+/** A stylesheet diagnostic is resolved only when every element it can affect was baked. */ function collectBakedStylesheetPaths(source, isBaked) {
+    var resolved = new Set();
+    if (typeof DOMParser === 'undefined' || typeof CSSStyleSheet !== 'function') {
+        return resolved;
+    }
+    var root = new DOMParser().parseFromString(source, 'image/svg+xml').documentElement;
+    var allUsesBaked = Array.from(root.querySelectorAll('use')).every(function(element) {
+        return isBaked(buildElementTreePath(element));
+    });
+    var isHandled = function isHandled(element) {
+        if (isBaked(buildElementTreePath(element))) {
+            return true;
+        }
+        if (element.closest('defs, symbol, marker, pattern, clipPath, mask, filter') != null) {
+            return allUsesBaked;
+        }
+        return false;
+    };
+    for(var _iterator = _create_for_of_iterator_helper_loose(Array.from(root.querySelectorAll('style'))), _step; !(_step = _iterator()).done;){
+        var style = _step.value;
+        var _style_textContent;
+        var sheet = new CSSStyleSheet();
+        sheet.replaceSync((_style_textContent = style.textContent) != null ? _style_textContent : '');
+        var rules = Array.from(sheet.cssRules);
+        var handled = rules.every(function(rule) {
+            if (!isStyleRule(rule)) {
+                return false;
+            }
+            if (Array.from(rule.style).every(function(name) {
+                return name === 'mix-blend-mode';
+            })) {
+                return true;
+            }
+            var matched = [].concat([
+                root
+            ], Array.from(root.querySelectorAll('*'))).filter(function(element) {
+                return element.matches(rule.selectorText);
+            });
+            return matched.every(isHandled);
+        });
+        if (handled) {
+            resolved.add(buildElementTreePath(style));
+        }
+    }
+    return resolved;
+}
+function isStyleRule(rule) {
+    return rule.type === 1;
+}
+
+/** Rasterize graphics and track the source layers and warnings they replace. */ function buildBakedLayers(source, size, options, rasterScale) {
+    return _async_to_generator(function() {
+        var deferredOptions, bakedPaths, baked, bakingWarnings, blending, plan, _iterator, _step, downgrade, _iterator1, _step1, warning, _iterator2, _step2, scope, image, message, _image_bbox, left, top, right, bottom, width, height, error, reason, replacesSource, handledStyles, declarations;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    deferredOptions = _extends({}, options, {
+                        strict: false,
+                        onWarning: undefined
+                    });
+                    bakedPaths = [];
+                    baked = [];
+                    bakingWarnings = [];
+                    blending = normalizeLayerBlending(source);
+                    plan = planGraphicBaking(blending.source);
+                    for(_iterator = _create_for_of_iterator_helper_loose(blending.downgrades); !(_step = _iterator()).done;){
+                        downgrade = _step.value;
+                        collectLayerWarning(bakingWarnings, deferredOptions, SVG2IR_WARNING_CODES.LAYERS_BLEND_MODE_DOWNGRADED, 'mix-blend-mode "' + downgrade.mode + '" was downgraded to "normal"; the layer is retained.', downgrade.selector);
+                    }
+                    for(_iterator1 = _create_for_of_iterator_helper_loose(plan.warnings); !(_step1 = _iterator1()).done;){
+                        warning = _step1.value;
+                        collectLayerWarning(bakingWarnings, deferredOptions, SVG2IR_WARNING_CODES.LAYERS_UNSUPPORTED_FEATURE, warning.message, warning.selector);
+                    }
+                    _iterator2 = _create_for_of_iterator_helper_loose(plan.scopes);
+                    _state.label = 1;
+                case 1:
+                    if (!!(_step2 = _iterator2()).done) return [
+                        3,
+                        6
+                    ];
+                    scope = _step2.value;
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    if (!canRasterizeSVG()) {
+                        throw new Error('Graphic baking requires a browser with SVG and Canvas support.');
+                    }
+                    return [
+                        4,
+                        rasterizeSVG(blending.source, scope.path, size, rasterScale, validateGraphicSnapshot)
+                    ];
+                case 3:
+                    image = _state.sent();
+                    bakedPaths.push(scope.path);
+                    message = image == null ? 'Graphic rasterization produced no visible pixels; no image layer was emitted.' : scope.isGroup ? 'Graphic group baked into a single PNG; child graphics and paint/effect parameters are no longer editable.' : 'Graphic baked into a PNG; vector geometry and paint/effect parameters are no longer editable.';
+                    collectLayerWarning(bakingWarnings, deferredOptions, SVG2IR_WARNING_CODES.LAYERS_GRAPHIC_BAKED, message, scope.selector);
+                    if (image == null) {
+                        return [
+                            3,
+                            5
+                        ];
+                    }
+                    _image_bbox = image.bbox, left = _image_bbox[0], top = _image_bbox[1], right = _image_bbox[2], bottom = _image_bbox[3];
+                    width = right - left;
+                    height = bottom - top;
+                    baked.push({
+                        path: scope.path,
+                        layer: {
+                            id: '',
+                            type: 'image',
+                            role: 'content',
+                            bbox: image.bbox,
+                            size: [
+                                width,
+                                height
+                            ],
+                            rotation: [
+                                0,
+                                0,
+                                0
+                            ],
+                            url: image.url,
+                            width: width,
+                            height: height
+                        }
+                    });
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    error = _state.sent();
+                    reason = _instanceof(error, Error) ? error.message : String(error);
+                    collectLayerWarning(bakingWarnings, deferredOptions, SVG2IR_WARNING_CODES.LAYERS_UNSUPPORTED_FEATURE, "Graphic baking failed: " + reason, scope.selector);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        3,
+                        1
+                    ];
+                case 6:
+                    replacesSource = function replacesSource(path) {
+                        return path != null && bakedPaths.some(function(scope) {
+                            return scope === '' || path === scope || path.startsWith("" + scope + "/");
+                        });
+                    };
+                    handledStyles = collectBakedStylesheetPaths(blending.source, replacesSource);
+                    declarations = collectNonRenderingDeclarationPaths(source);
+                    return [
+                        2,
+                        {
+                            layers: baked,
+                            warnings: bakingWarnings,
+                            replacesSource: replacesSource,
+                            resolvesWarning: function resolvesWarning(warning, path) {
+                                return replacesSource(path) || warning.code === SVG2IR_WARNING_CODES.ELEMENT_DROPPED && path != null && (handledStyles.has(path) || declarations.has(path));
+                            }
+                        }
+                    ];
+            }
+        });
+    })();
+}
 
 function encodeBase64(data) {
     var chunks = [];
@@ -13458,26 +14568,103 @@ function fetchImageResource(url) {
     }).apply(this, arguments);
 }
 
-function convertSVGToLayers(source, options, loadImage, preservedData) {
+var animatedTags = new Set([
+    'animate',
+    'animatetransform',
+    'animatemotion',
+    'set'
+]);
+/** Static layers cannot sample animation; drop SMIL nodes so elements keep their authored state. */ function stripLayerAnimation(source) {
+    var svg = SVG(source);
+    if ((svg == null ? void 0 : svg.node) == null) {
+        return {
+            source: source,
+            removed: 0
+        };
+    }
+    var elements = Array.from(svg.node.querySelectorAll('*')).filter(function(element) {
+        return animatedTags.has(element.tagName.toLowerCase());
+    });
+    if (elements.length === 0) {
+        return {
+            source: source,
+            removed: 0
+        };
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(elements), _step; !(_step = _iterator()).done;){
+        var element = _step.value;
+        element.remove();
+    }
+    return {
+        source: svg.svg(),
+        removed: elements.length
+    };
+}
+
+function convertSVGToLayers(source, options, loadImage, preservedData, rasterScale) {
+    if (rasterScale === void 0) rasterScale = 2;
     return _async_to_generator(function() {
-        var splitResult, parsed, _assembleSVGStaticLayers, size, data, _tmp;
+        var layerSources, warningSources, collected, stripped, staticSource, parsed, composition, baking, assembled, _tmp, _tmp1;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    splitResult = preservedData == null ? splitSVG(source, options) : undefined;
-                    parsed = splitResult != null ? splitResult : parseSVGToIRWithPreservedData(source, options);
-                    _assembleSVGStaticLayers = assembleSVGStaticLayers(parsed.ir, options, parsed.warnings, preservedData != null ? preservedData : splitResult == null ? void 0 : splitResult.preservedData), size = _assembleSVGStaticLayers.size, data = _assembleSVGStaticLayers.data;
-                    _tmp = {
-                        size: size
+                    layerSources = new Map();
+                    warningSources = new Map();
+                    collected = {
+                        textDataByLayerId: new Map(),
+                        paintAnimationsByLayerId: new Map(),
+                        shapeAnimationsByLayerId: new Map()
                     };
+                    stripped = stripLayerAnimation(source);
+                    staticSource = stripped.source;
+                    // Preserve original layer IDs while gathering the source identities required by baking and assembly.
+                    parsed = parseSVGToIRWithPreservedData(staticSource, _extends({}, options, {
+                        strict: false,
+                        onWarning: undefined
+                    }), _extends({}, collected, {
+                        layerSourceCollector: layerSources,
+                        warningSourceCollector: warningSources
+                    }));
+                    if (stripped.removed > 0) {
+                        collectLayerWarning(parsed.warnings, _extends({}, options, {
+                            strict: false,
+                            onWarning: undefined
+                        }), SVG2IR_WARNING_CODES.LAYERS_ANIMATION_STRIPPED, "" + stripped.removed + " animated element(s) were removed; static layers output does not sample animation.");
+                    }
+                    composition = parsed.ir.compositions[0];
                     return [
                         4,
-                        inlineImageResources(data, loadImage)
+                        buildBakedLayers(staticSource, [
+                            composition.width,
+                            composition.height
+                        ], options, rasterScale)
                     ];
                 case 1:
+                    baking = _state.sent();
+                    assembled = assembleSVGLayers({
+                        scene: parsed.ir,
+                        options: options,
+                        warnings: parsed.warnings,
+                        preservedData: preservedData != null ? preservedData : collected,
+                        layerSources: layerSources,
+                        warningSources: warningSources,
+                        baking: baking
+                    });
+                    _tmp = [
+                        {},
+                        assembled
+                    ];
+                    _tmp1 = {};
+                    return [
+                        4,
+                        inlineImageResources(assembled.data, loadImage)
+                    ];
+                case 2:
                     return [
                         2,
-                        (_tmp.data = _state.sent(), _tmp.warnings = parsed.warnings, _tmp)
+                        _extends.apply(void 0, _tmp.concat([
+                            (_tmp1.data = _state.sent(), _tmp1)
+                        ]))
                     ];
             }
         });
@@ -16007,11 +17194,12 @@ function convertSVG(source, options, preservedData) {
         throw new TypeError('[svg2ir] outputFormat must be ge or layers.');
     }
     if ((options == null ? void 0 : options.outputFormat) === 'layers') {
-        options.outputFormat; var loadImage = options.loadImage, parserOptions = _object_without_properties_loose(options, [
+        options.outputFormat; var loadImage = options.loadImage, rasterScale = options.rasterScale, parserOptions = _object_without_properties_loose(options, [
             "outputFormat",
-            "loadImage"
+            "loadImage",
+            "rasterScale"
         ]);
-        return convertSVGToLayers(source, parserOptions, loadImage, preservedData);
+        return convertSVGToLayers(source, parserOptions, loadImage, preservedData, rasterScale);
     }
     var _ref1 = options != null ? options : {}; _ref1.outputFormat; var geOptions = _object_without_properties_loose(_ref1, [
         "outputFormat"
@@ -16021,5 +17209,5 @@ function convertSVG(source, options, preservedData) {
 
 setEditableSVGConstructor(resolveEditableSVGConstructor(editableSVGNodeModule));
 
-export { convertSVG, convertSVGToGE, convertSVGToIR, splitSVG };
+export { convertSVG, convertSVGToGE, convertSVGToIR, inferNumericWeightFromFamily, splitSVG };
 //# sourceMappingURL=node.mjs.map