@pixodesk/svg-animator-vue 1.0.16 → 1.0.18

package/dist/index.umd.js

@@ -39,9 +39,9 @@ var PixodeskAnimatorVue = (() => {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       // @__NO_SIDE_EFFECTS__
-      function makeMap(str) {
+      function makeMap(str2) {
         const map = /* @__PURE__ */ Object.create(null);
-        for (const key of str.split(",")) map[key] = 1;
+        for (const key of str2.split(",")) map[key] = 1;
         return (val) => val in map;
       }
       var EMPTY_OBJ = {};
@@ -89,27 +89,27 @@ var PixodeskAnimatorVue = (() => {
       );
       var cacheStringFunction = (fn) => {
         const cache = /* @__PURE__ */ Object.create(null);
-        return ((str) => {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
+        return ((str2) => {
+          const hit = cache[str2];
+          return hit || (cache[str2] = fn(str2));
         });
       };
       var camelizeRE = /-\w/g;
       var camelize = cacheStringFunction(
-        (str) => {
-          return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+        (str2) => {
+          return str2.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
         }
       );
       var hyphenateRE = /\B([A-Z])/g;
       var hyphenate = cacheStringFunction(
-        (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+        (str2) => str2.replace(hyphenateRE, "-$1").toLowerCase()
       );
-      var capitalize = cacheStringFunction((str) => {
-        return str.charAt(0).toUpperCase() + str.slice(1);
+      var capitalize = cacheStringFunction((str2) => {
+        return str2.charAt(0).toUpperCase() + str2.slice(1);
       });
       var toHandlerKey = cacheStringFunction(
-        (str) => {
-          const s = str ? `on${capitalize(str)}` : ``;
+        (str2) => {
+          const s = str2 ? `on${capitalize(str2)}` : ``;
           return s;
         }
       );
@@ -402,17 +402,17 @@ var PixodeskAnimatorVue = (() => {
       }
       var escapeRE = /["'&<>]/;
       function escapeHtml(string) {
-        const str = "" + string;
-        const match = escapeRE.exec(str);
+        const str2 = "" + string;
+        const match = escapeRE.exec(str2);
         if (!match) {
-          return str;
+          return str2;
         }
         let html = "";
         let escaped;
         let index;
         let lastIndex = 0;
-        for (index = match.index; index < str.length; index++) {
-          switch (str.charCodeAt(index)) {
+        for (index = match.index; index < str2.length; index++) {
+          switch (str2.charCodeAt(index)) {
             case 34:
               escaped = "&quot;";
               break;
@@ -432,12 +432,12 @@ var PixodeskAnimatorVue = (() => {
               continue;
           }
           if (lastIndex !== index) {
-            html += str.slice(lastIndex, index);
+            html += str2.slice(lastIndex, index);
           }
           lastIndex = index + 1;
           html += escaped;
         }
-        return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+        return lastIndex !== index ? html + str2.slice(lastIndex, index) : html;
       }
       var commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
       function escapeHtmlComment(src) {
@@ -628,9 +628,9 @@ var PixodeskAnimatorVue = (() => {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       // @__NO_SIDE_EFFECTS__
-      function makeMap(str) {
+      function makeMap(str2) {
         const map = /* @__PURE__ */ Object.create(null);
-        for (const key of str.split(",")) map[key] = 1;
+        for (const key of str2.split(",")) map[key] = 1;
         return (val) => val in map;
       }
       var EMPTY_OBJ = Object.freeze({});
@@ -678,27 +678,27 @@ var PixodeskAnimatorVue = (() => {
       );
       var cacheStringFunction = (fn) => {
         const cache = /* @__PURE__ */ Object.create(null);
-        return ((str) => {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
+        return ((str2) => {
+          const hit = cache[str2];
+          return hit || (cache[str2] = fn(str2));
         });
       };
       var camelizeRE = /-\w/g;
       var camelize = cacheStringFunction(
-        (str) => {
-          return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+        (str2) => {
+          return str2.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
         }
       );
       var hyphenateRE = /\B([A-Z])/g;
       var hyphenate = cacheStringFunction(
-        (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+        (str2) => str2.replace(hyphenateRE, "-$1").toLowerCase()
       );
-      var capitalize = cacheStringFunction((str) => {
-        return str.charAt(0).toUpperCase() + str.slice(1);
+      var capitalize = cacheStringFunction((str2) => {
+        return str2.charAt(0).toUpperCase() + str2.slice(1);
       });
       var toHandlerKey = cacheStringFunction(
-        (str) => {
-          const s = str ? `on${capitalize(str)}` : ``;
+        (str2) => {
+          const s = str2 ? `on${capitalize(str2)}` : ``;
           return s;
         }
       );
@@ -991,17 +991,17 @@ var PixodeskAnimatorVue = (() => {
       }
       var escapeRE = /["'&<>]/;
       function escapeHtml(string) {
-        const str = "" + string;
-        const match = escapeRE.exec(str);
+        const str2 = "" + string;
+        const match = escapeRE.exec(str2);
         if (!match) {
-          return str;
+          return str2;
         }
         let html = "";
         let escaped;
         let index;
         let lastIndex = 0;
-        for (index = match.index; index < str.length; index++) {
-          switch (str.charCodeAt(index)) {
+        for (index = match.index; index < str2.length; index++) {
+          switch (str2.charCodeAt(index)) {
             case 34:
               escaped = "&quot;";
               break;
@@ -1021,12 +1021,12 @@ var PixodeskAnimatorVue = (() => {
               continue;
           }
           if (lastIndex !== index) {
-            html += str.slice(lastIndex, index);
+            html += str2.slice(lastIndex, index);
           }
           lastIndex = index + 1;
           html += escaped;
         }
-        return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
+        return lastIndex !== index ? html + str2.slice(lastIndex, index) : html;
       }
       var commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
       function escapeHtmlComment(src) {
@@ -8120,9 +8120,9 @@ var PixodeskAnimatorVue = (() => {
           });
         }
         finishOp(type, size) {
-          const str = this.input.slice(this.state.pos, this.state.pos + size);
+          const str2 = this.input.slice(this.state.pos, this.state.pos + size);
           this.state.pos += size;
-          this.finishToken(type, str);
+          this.finishToken(type, str2);
         }
         readRegexp() {
           const startLoc = this.state.startLoc;
@@ -8216,8 +8216,8 @@ var PixodeskAnimatorVue = (() => {
             throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
           }
           if (isBigInt) {
-            const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
-            this.finishToken(136, str);
+            const str2 = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
+            this.finishToken(136, str2);
             return;
           }
           this.finishToken(135, val);
@@ -8281,16 +8281,16 @@ var PixodeskAnimatorVue = (() => {
           if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
             throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
           }
-          const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
+          const str2 = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
           if (isBigInt) {
-            this.finishToken(136, str);
+            this.finishToken(136, str2);
             return;
           }
           if (isDecimal) {
-            this.finishToken(137, str);
+            this.finishToken(137, str2);
             return;
           }
-          const val = isOctal ? parseInt(str, 8) : parseFloat(str);
+          const val = isOctal ? parseInt(str2, 8) : parseFloat(str2);
           this.finishToken(135, val);
         }
         readCodePoint(throwOnInvalid) {
@@ -8303,7 +8303,7 @@ var PixodeskAnimatorVue = (() => {
         }
         readString(quote) {
           const {
-            str,
+            str: str2,
             pos,
             curLine,
             lineStart
@@ -8311,7 +8311,7 @@ var PixodeskAnimatorVue = (() => {
           this.state.pos = pos + 1;
           this.state.lineStart = lineStart;
           this.state.curLine = curLine;
-          this.finishToken(134, str);
+          this.finishToken(134, str2);
         }
         readTemplateContinuation() {
           if (!this.match(8)) {
@@ -8323,7 +8323,7 @@ var PixodeskAnimatorVue = (() => {
         readTemplateToken() {
           const opening = this.input[this.state.pos];
           const {
-            str,
+            str: str2,
             firstInvalidLoc,
             pos,
             curLine,
@@ -8336,10 +8336,10 @@ var PixodeskAnimatorVue = (() => {
             this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, this.sourceToOffsetPos(firstInvalidLoc.pos));
           }
           if (this.input.codePointAt(pos) === 96) {
-            this.finishToken(24, firstInvalidLoc ? null : opening + str + "`");
+            this.finishToken(24, firstInvalidLoc ? null : opening + str2 + "`");
           } else {
             this.state.pos++;
-            this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
+            this.finishToken(25, firstInvalidLoc ? null : opening + str2 + "${");
           }
         }
         recordStrictModeErrors(toParseError, at) {
@@ -17045,8 +17045,8 @@ var PixodeskAnimatorVue = (() => {
         return strcmp(mappingA.name, mappingB.name);
       }
       exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
-      function parseSourceMapInput(str) {
-        return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+      function parseSourceMapInput(str2) {
+        return JSON.parse(str2.replace(/^\)]}'[^\n]*\n/, ""));
       }
       exports.parseSourceMapInput = parseSourceMapInput;
       function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
@@ -17865,7 +17865,7 @@ var PixodeskAnimatorVue = (() => {
         var temp = {};
         var originalMappings = [];
         var generatedMappings = [];
-        var mapping, str, segment, end, value;
+        var mapping, str2, segment, end, value;
         let subarrayStart = 0;
         while (index < length) {
           if (aStr.charAt(index) === ";") {
@@ -17884,7 +17884,7 @@ var PixodeskAnimatorVue = (() => {
                 break;
               }
             }
-            str = aStr.slice(index, end);
+            str2 = aStr.slice(index, end);
             segment = [];
             while (index < end) {
               base64VLQ.decode(aStr, index, temp);
@@ -18417,11 +18417,11 @@ var PixodeskAnimatorVue = (() => {
         }
       };
       SourceNode.prototype.toString = function SourceNode_toString() {
-        var str = "";
+        var str2 = "";
         this.walk(function(chunk) {
-          str += chunk;
+          str2 += chunk;
         });
-        return str;
+        return str2;
       };
       SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
         var generated = {
@@ -18928,10 +18928,10 @@ var PixodeskAnimatorVue = (() => {
       function isEndOfTagSection(c) {
         return c === 47 || c === 62 || isWhitespace(c);
       }
-      function toCharCodes(str) {
-        const ret = new Uint8Array(str.length);
-        for (let i = 0; i < str.length; i++) {
-          ret[i] = str.charCodeAt(i);
+      function toCharCodes(str2) {
+        const ret = new Uint8Array(str2.length);
+        for (let i = 0; i < str2.length; i++) {
+          ret[i] = str2.charCodeAt(i);
         }
         return ret;
       }
@@ -20770,9 +20770,9 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         }
       }
       var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
-      function isAllWhitespace(str) {
-        for (let i = 0; i < str.length; i++) {
-          if (!isWhitespace(str.charCodeAt(i))) {
+      function isAllWhitespace(str2) {
+        for (let i = 0; i < str2.length; i++) {
+          if (!isWhitespace(str2.charCodeAt(i))) {
             return false;
           }
         }
@@ -21375,26 +21375,26 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         }
         return removedWhitespace ? nodes.filter(Boolean) : nodes;
       }
-      function hasNewlineChar(str) {
-        for (let i = 0; i < str.length; i++) {
-          const c = str.charCodeAt(i);
+      function hasNewlineChar(str2) {
+        for (let i = 0; i < str2.length; i++) {
+          const c = str2.charCodeAt(i);
           if (c === 10 || c === 13) {
             return true;
           }
         }
         return false;
       }
-      function condense(str) {
+      function condense(str2) {
         let ret = "";
         let prevCharIsWhitespace = false;
-        for (let i = 0; i < str.length; i++) {
-          if (isWhitespace(str.charCodeAt(i))) {
+        for (let i = 0; i < str2.length; i++) {
+          if (isWhitespace(str2.charCodeAt(i))) {
             if (!prevCharIsWhitespace) {
               ret += " ";
               prevCharIsWhitespace = true;
             }
           } else {
-            ret += str[i];
+            ret += str2[i];
             prevCharIsWhitespace = false;
           }
         }
@@ -25695,10 +25695,10 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
       function isEndOfTagSection(c) {
         return c === 47 || c === 62 || isWhitespace(c);
       }
-      function toCharCodes(str) {
-        const ret = new Uint8Array(str.length);
-        for (let i = 0; i < str.length; i++) {
-          ret[i] = str.charCodeAt(i);
+      function toCharCodes(str2) {
+        const ret = new Uint8Array(str2.length);
+        for (let i = 0; i < str2.length; i++) {
+          ret[i] = str2.charCodeAt(i);
         }
         return ret;
       }
@@ -27541,9 +27541,9 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         }
       }
       var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
-      function isAllWhitespace(str) {
-        for (let i = 0; i < str.length; i++) {
-          if (!isWhitespace(str.charCodeAt(i))) {
+      function isAllWhitespace(str2) {
+        for (let i = 0; i < str2.length; i++) {
+          if (!isWhitespace(str2.charCodeAt(i))) {
             return false;
           }
         }
@@ -28176,26 +28176,26 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         }
         return removedWhitespace ? nodes.filter(Boolean) : nodes;
       }
-      function hasNewlineChar(str) {
-        for (let i = 0; i < str.length; i++) {
-          const c = str.charCodeAt(i);
+      function hasNewlineChar(str2) {
+        for (let i = 0; i < str2.length; i++) {
+          const c = str2.charCodeAt(i);
           if (c === 10 || c === 13) {
             return true;
           }
         }
         return false;
       }
-      function condense(str) {
+      function condense(str2) {
         let ret = "";
         let prevCharIsWhitespace = false;
-        for (let i = 0; i < str.length; i++) {
-          if (isWhitespace(str.charCodeAt(i))) {
+        for (let i = 0; i < str2.length; i++) {
+          if (isWhitespace(str2.charCodeAt(i))) {
             if (!prevCharIsWhitespace) {
               ret += " ";
               prevCharIsWhitespace = true;
             }
           } else {
-            ret += str[i];
+            ret += str2[i];
             prevCharIsWhitespace = false;
           }
         }
@@ -34456,10 +34456,10 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           });
         },
         every(fn, thisArg) {
-          return apply(this, "every", fn, thisArg, void 0, arguments);
+          return apply2(this, "every", fn, thisArg, void 0, arguments);
         },
         filter(fn, thisArg) {
-          return apply(
+          return apply2(
             this,
             "filter",
             fn,
@@ -34469,7 +34469,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           );
         },
         find(fn, thisArg) {
-          return apply(
+          return apply2(
             this,
             "find",
             fn,
@@ -34479,10 +34479,10 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           );
         },
         findIndex(fn, thisArg) {
-          return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+          return apply2(this, "findIndex", fn, thisArg, void 0, arguments);
         },
         findLast(fn, thisArg) {
-          return apply(
+          return apply2(
             this,
             "findLast",
             fn,
@@ -34492,11 +34492,11 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           );
         },
         findLastIndex(fn, thisArg) {
-          return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+          return apply2(this, "findLastIndex", fn, thisArg, void 0, arguments);
         },
         // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
         forEach(fn, thisArg) {
-          return apply(this, "forEach", fn, thisArg, void 0, arguments);
+          return apply2(this, "forEach", fn, thisArg, void 0, arguments);
         },
         includes(...args) {
           return searchProxy(this, "includes", args);
@@ -34512,7 +34512,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           return searchProxy(this, "lastIndexOf", args);
         },
         map(fn, thisArg) {
-          return apply(this, "map", fn, thisArg, void 0, arguments);
+          return apply2(this, "map", fn, thisArg, void 0, arguments);
         },
         pop() {
           return noTracking(this, "pop");
@@ -34531,7 +34531,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
         },
         // slice could use ARRAY_ITERATE but also seems to beg for range tracking
         some(fn, thisArg) {
-          return apply(this, "some", fn, thisArg, void 0, arguments);
+          return apply2(this, "some", fn, thisArg, void 0, arguments);
         },
         splice(...args) {
           return noTracking(this, "splice", args);
@@ -34568,7 +34568,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
         return iter;
       }
       var arrayProto = Array.prototype;
-      function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
+      function apply2(self2, method, fn, thisArg, wrappedRetFn, args) {
         const arr = shallowReadArray(self2);
         const needsWrap = arr !== self2 && !/* @__PURE__ */ isShallow(self2);
         const methodFn = arr[method];
@@ -36306,10 +36306,10 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           });
         },
         every(fn, thisArg) {
-          return apply(this, "every", fn, thisArg, void 0, arguments);
+          return apply2(this, "every", fn, thisArg, void 0, arguments);
         },
         filter(fn, thisArg) {
-          return apply(
+          return apply2(
             this,
             "filter",
             fn,
@@ -36319,7 +36319,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           );
         },
         find(fn, thisArg) {
-          return apply(
+          return apply2(
             this,
             "find",
             fn,
@@ -36329,10 +36329,10 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           );
         },
         findIndex(fn, thisArg) {
-          return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+          return apply2(this, "findIndex", fn, thisArg, void 0, arguments);
         },
         findLast(fn, thisArg) {
-          return apply(
+          return apply2(
             this,
             "findLast",
             fn,
@@ -36342,11 +36342,11 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           );
         },
         findLastIndex(fn, thisArg) {
-          return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+          return apply2(this, "findLastIndex", fn, thisArg, void 0, arguments);
         },
         // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
         forEach(fn, thisArg) {
-          return apply(this, "forEach", fn, thisArg, void 0, arguments);
+          return apply2(this, "forEach", fn, thisArg, void 0, arguments);
         },
         includes(...args) {
           return searchProxy(this, "includes", args);
@@ -36362,7 +36362,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
           return searchProxy(this, "lastIndexOf", args);
         },
         map(fn, thisArg) {
-          return apply(this, "map", fn, thisArg, void 0, arguments);
+          return apply2(this, "map", fn, thisArg, void 0, arguments);
         },
         pop() {
           return noTracking(this, "pop");
@@ -36381,7 +36381,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
         },
         // slice could use ARRAY_ITERATE but also seems to beg for range tracking
         some(fn, thisArg) {
-          return apply(this, "some", fn, thisArg, void 0, arguments);
+          return apply2(this, "some", fn, thisArg, void 0, arguments);
         },
         splice(...args) {
           return noTracking(this, "splice", args);
@@ -36418,7 +36418,7 @@ const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(",
         return iter;
       }
       var arrayProto = Array.prototype;
-      function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
+      function apply2(self2, method, fn, thisArg, wrappedRetFn, args) {
         const arr = shallowReadArray(self2);
         const needsWrap = arr !== self2 && !/* @__PURE__ */ isShallow(self2);
         const methodFn = arr[method];
@@ -46766,8 +46766,8 @@ Server rendered element contains fewer child nodes than client vdom.`
         }
         return false;
       }
-      function toClassSet(str) {
-        return new Set(str.trim().split(/\s+/));
+      function toClassSet(str2) {
+        return new Set(str2.trim().split(/\s+/));
       }
       function isSetEqual(a, b) {
         if (a.size !== b.size) {
@@ -46780,9 +46780,9 @@ Server rendered element contains fewer child nodes than client vdom.`
         }
         return true;
       }
-      function toStyleMap(str) {
+      function toStyleMap(str2) {
         const styleMap = /* @__PURE__ */ new Map();
-        for (const item of str.split(";")) {
+        for (const item of str2.split(";")) {
           let [key, value] = item.split(":");
           key = key.trim();
           value = value && value.trim();
@@ -52550,7 +52550,7 @@ Component that was made reactive: `,
         }
       }
       var classifyRE = /(?:^|[-_])\w/g;
-      var classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+      var classify = (str2) => str2.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
       function getComponentName(Component, includeInferred = true) {
         return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
       }
@@ -56768,6 +56768,7 @@ ${codeFrame}` : message);
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp2 = Object.prototype.hasOwnProperty;
   var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __pow = Math.pow;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __spreadValues = (a, b) => {
     for (var prop in b || (b = {}))
@@ -56810,7 +56811,7 @@ ${codeFrame}` : message);
     if (typeof raw === "object") {
       const obj = raw;
       if (obj.keyframes) {
-        return { kind: "animated", keyframes: obj.keyframes, autoOrient: obj.autoOrient };
+        return { kind: "animated", keyframes: obj.keyframes, autoOrient: obj.autoOrient, loop: obj.loop };
       }
       if (obj.value !== void 0) return { kind: "static", value: obj.value };
     }
@@ -56898,6 +56899,7 @@ ${codeFrame}` : message);
     if (v.kind === "animated") {
       const animTr = { keyframes: v.keyframes.map((kf) => keyframeWith(kf, partsRecord(part, kf.value, void 0))) };
       if (v.autoOrient) animTr.autoOrient = true;
+      if (v.loop !== void 0) animTr.loop = v.loop;
       return {
         type: "g",
         animate: { transform: animTr },
@@ -56916,9 +56918,11 @@ ${codeFrame}` : message);
       return { type: "g", transform: { value: { translate: sign(v.value) } }, children: [inner] };
     }
     if (v.kind === "animated") {
+      const animTr = { keyframes: v.keyframes.map((kf) => keyframeWith(kf, { translate: sign(kf.value) })) };
+      if (v.loop !== void 0) animTr.loop = v.loop;
       return {
         type: "g",
-        animate: { transform: { keyframes: v.keyframes.map((kf) => keyframeWith(kf, { translate: sign(kf.value) })) } },
+        animate: { transform: animTr },
         children: [inner]
       };
     }
@@ -56926,8 +56930,8 @@ ${codeFrame}` : message);
   }
   function identifyContentRefTargets(node, ctx, allocator) {
     var _a, _b, _c;
-    if (node.type === "use" && ((_b = (_a = node.effects) == null ? void 0 : _a.ref) == null ? void 0 : _b.type) === "content") {
-      const baseId = node.effects.ref.baseId;
+    if (node.type === "use" && ((_b = (_a = node.effects) == null ? void 0 : _a.clone) == null ? void 0 : _b.type) === "content") {
+      const baseId = node.effects.clone.baseId;
       if (typeof baseId === "string" && baseId && !ctx.contentRefInnerIds.has(baseId)) {
         ctx.contentRefInnerIds.set(baseId, allocator(baseId));
       }
@@ -56975,6 +56979,8 @@ ${codeFrame}` : message);
         });
         const outerAnimTr = { keyframes: outerKfs };
         if (animTr.autoOrient) outerAnimTr.autoOrient = true;
+        const srcLoop = animTr.loop;
+        if (srcLoop !== void 0) outerAnimTr.loop = srcLoop;
         out.animate = { transform: outerAnimTr };
         const innerHasPivotedPart = kfs.some((kf) => {
           const v = kf.value || {};
@@ -56996,7 +57002,9 @@ ${codeFrame}` : message);
           delete node.animate.transform;
           if (node.animate && Object.keys(node.animate).length === 0) delete node.animate;
         } else {
-          node.animate.transform = { keyframes: innerKfs };
+          const innerAnimTr = { keyframes: innerKfs };
+          if (srcLoop !== void 0) innerAnimTr.loop = srcLoop;
+          node.animate.transform = innerAnimTr;
         }
         didLiftAnimate = true;
       }
@@ -57641,10 +57649,22 @@ ${codeFrame}` : message);
     outAction: px.enum(["continue", "pause", "reset", "reverse"]).optional(),
     scrollIntoViewThreshold: px.number().optional()
   }));
+  var PxGlyphSchema = implementsInterface()(px.object({
+    width: px.number(),
+    d: px.string()
+  }));
+  var PxGlyphFontSchema = implementsInterface()(px.object({
+    fFamily: px.string(),
+    style: px.string(),
+    ascent: px.number(),
+    unitsPerEm: px.number(),
+    glyphs: px.record(PxGlyphSchema)
+  }));
   var PxDefsSchema = implementsInterface()(px.object({
     easings: px.record(px.tuple([px.number(), px.number(), px.number(), px.number()])).optional(),
     animations: px.record(PxAnimationDefinitionSchema).optional(),
-    styles: px.record(px.any()).optional()
+    styles: px.record(px.any()).optional(),
+    glyphs: px.record(PxGlyphFontSchema).optional()
   }));
   var PxAnimatorConfigSchema = implementsInterface()(px.object({
     mode: px.enum([PxAnimatorMode.auto, PxAnimatorMode.webapi, PxAnimatorMode.frames]).optional(),
@@ -57717,9 +57737,10 @@ ${codeFrame}` : message);
     stretch: px.number().optional(),
     timeCrop: px.tuple([px.number(), px.number()]).optional()
   }));
-  var PxRefEffectSchema = implementsInterface()(px.object({
+  var PxCloneEffectSchema = implementsInterface()(px.object({
+    type: px.string().optional(),
     baseId: px.string().optional(),
-    type: px.string().optional()
+    retime: PxRetimeEffectSchema.optional()
   }));
   var PxGradientType = {
     linear: "linear",
@@ -57755,17 +57776,20 @@ ${codeFrame}` : message);
     startOffset: PxAnimatableNumberSchema.optional(),
     textLength: PxAnimatableNumberSchema.optional()
   }));
+  var PxTextEffectSchema = implementsInterface()(px.object({
+    useGlyphs: px.boolean().optional()
+  }));
   var PxEffectsSchema = implementsInterface()(px.object({
     transformation: PxTransformationEffectSchema.optional(),
     repeater: PxRepeaterEffectSchema.optional(),
     maskedBy: PxMaskedByEffectSchema.optional(),
     trimPath: PxTrimPathEffectSchema.optional(),
-    retime: PxRetimeEffectSchema.optional(),
+    clone: PxCloneEffectSchema.optional(),
     isCombinedShape: px.boolean().optional(),
-    ref: PxRefEffectSchema.optional(),
     fillGradient: PxFillGradientEffectSchema.optional(),
     strokeGradient: PxStrokeGradientEffectSchema.optional(),
-    textAlongPath: PxTextAlongPathEffectSchema.optional()
+    textAlongPath: PxTextAlongPathEffectSchema.optional(),
+    text: PxTextEffectSchema.optional()
   }));
   function validateNodeEffects(root, opts) {
     const warnings = [];
@@ -57977,6 +58001,7 @@ ${codeFrame}` : message);
     const animBlock = stops;
     const kfs = animBlock.keyframes;
     if (!Array.isArray(kfs) || !kfs.length) return [];
+    const loopFromSource = animBlock.loop;
     let stopCount = 0;
     for (const kf of kfs) {
       const v = (_a = kf.value) != null ? _a : kf.v;
@@ -57989,7 +58014,7 @@ ${codeFrame}` : message);
       const s = (_d = (_c = firstKfValue == null ? void 0 : firstKfValue[i]) != null ? _c : prevDefinedStop(kfs, 0, i)) != null ? _d : { offset: i / Math.max(1, stopCount - 1), color: "#000000" };
       baselineStops.push({ offset: s.offset, color: s.color });
     }
-    return baselineStops.map((bs, i) => animatedStopNode(bs, kfs, i, ctx));
+    return baselineStops.map((bs, i) => animatedStopNode(bs, kfs, i, ctx, loopFromSource));
   }
   function staticStopNode(s) {
     return {
@@ -57998,7 +58023,7 @@ ${codeFrame}` : message);
       stopColor: s.color
     };
   }
-  function animatedStopNode(baseline, kfs, stopIdx, _ctx) {
+  function animatedStopNode(baseline, kfs, stopIdx, _ctx, loop) {
     var _a, _b, _c, _d, _e;
     const colorKfs = [];
     const offsetKfs = [];
@@ -58023,8 +58048,14 @@ ${codeFrame}` : message);
       stopColor: baseline.color
     };
     const animate = {};
-    if (colorKfs.length) animate.stopColor = { keyframes: colorKfs };
-    if (offsetVaries && offsetKfs.length) animate.offset = { keyframes: offsetKfs };
+    if (colorKfs.length) {
+      animate.stopColor = { keyframes: colorKfs };
+      if (loop !== void 0) animate.stopColor.loop = loop;
+    }
+    if (offsetVaries && offsetKfs.length) {
+      animate.offset = { keyframes: offsetKfs };
+      if (loop !== void 0) animate.offset.loop = loop;
+    }
     if (Object.keys(animate).length) stop.animate = animate;
     return stop;
   }
@@ -58087,9 +58118,11 @@ ${codeFrame}` : message);
       return { type: "g", transform: { value: partsRecord(part, invertPartValue(part, v.value), origin) }, children: [inner] };
     }
     if (v.kind === "animated") {
+      const animTr = { keyframes: v.keyframes.map((kf) => keyframeWith(kf, partsRecord(part, invertPartValue(part, kf.value), origin))) };
+      if (v.loop !== void 0) animTr.loop = v.loop;
       return {
         type: "g",
-        animate: { transform: { keyframes: v.keyframes.map((kf) => keyframeWith(kf, partsRecord(part, invertPartValue(part, kf.value), origin))) } },
+        animate: { transform: animTr },
         children: [inner]
       };
     }
@@ -58126,10 +58159,16 @@ ${codeFrame}` : message);
         scaleKfs.push(__spreadProps(__spreadValues({}, baseKf), { value: rec }));
       }
     }
+    const srcLoop = animTr == null ? void 0 : animTr.loop;
+    const withLoop = (kfs2) => {
+      const block = { keyframes: kfs2 };
+      if (srcLoop !== void 0) block.loop = srcLoop;
+      return block;
+    };
     let n = inner;
-    if (translateKfs.length) n = { type: "g", animate: { transform: { keyframes: translateKfs } }, children: [n] };
-    if (rotateKfs.length) n = { type: "g", animate: { transform: { keyframes: rotateKfs } }, children: [n] };
-    if (scaleKfs.length) n = { type: "g", animate: { transform: { keyframes: scaleKfs } }, children: [n] };
+    if (translateKfs.length) n = { type: "g", animate: { transform: withLoop(translateKfs) }, children: [n] };
+    if (rotateKfs.length) n = { type: "g", animate: { transform: withLoop(rotateKfs) }, children: [n] };
+    if (scaleKfs.length) n = { type: "g", animate: { transform: withLoop(scaleKfs) }, children: [n] };
     return n;
   }
   function nodeHasBodyTransform(node) {
@@ -58361,16 +58400,18 @@ ${codeFrame}` : message);
     return seen ? [x, y] : void 0;
   }
   var CONTENT_SUBREF = "content";
-  function applyRefAndTransformationEffect(node, ref3, transformation, ctx) {
-    if (ref3) {
-      const baseId = ref3.baseId;
-      if (!baseId) {
-        ctx.errors.push("ref: missing baseId");
-      } else {
-        const targetId = ref3.type === CONTENT_SUBREF ? ctx.contentRefInnerIds.get(baseId) || baseId : baseId;
-        node.href = "#" + targetId;
-      }
+  function applyRefHref(node, clone2, ctx) {
+    if (!clone2) return;
+    const baseId = clone2.baseId;
+    if (!baseId) {
+      if (clone2.type === CONTENT_SUBREF) ctx.errors.push("clone: content ref missing baseId");
+      return;
     }
+    const targetId = clone2.type === CONTENT_SUBREF ? ctx.contentRefInnerIds.get(baseId) || baseId : baseId;
+    node.href = "#" + targetId;
+  }
+  function applyRefAndTransformationEffect(node, clone2, transformation, ctx) {
+    applyRefHref(node, clone2, ctx);
     return applyTransformationEffect(node, transformation, ctx);
   }
   function applyRepeaterEffect(node, fx, ctx) {
@@ -58477,22 +58518,32 @@ ${codeFrame}` : message);
       stretch: parent.stretch * child.stretch
     };
   }
-  function applyAllRetimeEffects(root, ctx) {
+  function readCloneRetime(n) {
+    var _a, _b;
+    return (_b = (_a = n.effects) == null ? void 0 : _a.clone) == null ? void 0 : _b.retime;
+  }
+  function clearCloneRetime(n) {
     var _a;
+    const clone2 = (_a = n.effects) == null ? void 0 : _a.clone;
+    if (!clone2) return;
+    delete clone2.retime;
+    if (Object.keys(clone2).length === 0) delete n.effects.clone;
+    if (n.effects && Object.keys(n.effects).length === 0) delete n.effects;
+  }
+  function applyAllRetimeEffects(root, ctx) {
     ctx.idMap.clear();
     indexById(root, ctx.idMap);
     const sites = [];
     const collect = (n) => {
-      var _a2, _b;
-      if ((_a2 = n.effects) == null ? void 0 : _a2.retime) sites.push(n);
-      (_b = n.children) == null ? void 0 : _b.forEach(collect);
+      var _a;
+      if (readCloneRetime(n)) sites.push(n);
+      (_a = n.children) == null ? void 0 : _a.forEach(collect);
     };
     collect(root);
     for (const useNode of sites) {
-      const retime = (_a = useNode.effects) == null ? void 0 : _a.retime;
+      const retime = readCloneRetime(useNode);
       if (!retime) continue;
-      delete useNode.effects.retime;
-      if (Object.keys(useNode.effects).length === 0) delete useNode.effects;
+      clearCloneRetime(useNode);
       materialiseRetime(useNode, asRetime(retime), ctx);
     }
   }
@@ -58516,7 +58567,6 @@ ${codeFrame}` : message);
     }
   }
   function buildChainClone(targetId, accum, ctx, chain) {
-    var _a, _b;
     if (chain.has(targetId)) {
       ctx.errors.push('retime: loop via "' + targetId + '"');
       return void 0;
@@ -58533,25 +58583,43 @@ ${codeFrame}` : message);
     } else {
       remapKeyframeTimes(cloneNode, accum.start, accum.stretch);
     }
-    if ((_a = cloneNode.effects) == null ? void 0 : _a.retime) {
-      delete cloneNode.effects.retime;
-      if (Object.keys(cloneNode.effects).length === 0) delete cloneNode.effects;
-    }
+    clearCloneRetime(cloneNode);
     if (target.type === "use" && target.href) {
       const subId = stripHash(target.href);
       if (subId) {
-        const innerRetime = (_b = target.effects) == null ? void 0 : _b.retime;
+        const innerRetime = readCloneRetime(target);
         const subAccum = innerRetime ? concatRetime(asRetime(innerRetime), accum) : accum;
         const subChain = new Set(chain);
         subChain.add(targetId);
         const subId2 = buildChainClone(subId, subAccum, ctx, subChain);
         if (subId2) cloneNode.href = "#" + subId2;
       }
+    } else {
+      materialiseNestedRetimeUses(cloneNode, accum, ctx, chain, targetId);
     }
     ctx.defs.push(cloneNode);
     if (typeof cloneNode.id === "string") ctx.idMap.set(cloneNode.id, cloneNode);
     return typeof cloneNode.id === "string" ? cloneNode.id : void 0;
   }
+  function materialiseNestedRetimeUses(node, accum, ctx, chain, parentTargetId) {
+    const visit = (n) => {
+      var _a;
+      const retime = readCloneRetime(n);
+      if (n.type === "use" && retime && n.href) {
+        const subId = stripHash(n.href);
+        if (subId) {
+          const subAccum = concatRetime(asRetime(retime), accum);
+          const subChain = new Set(chain);
+          subChain.add(parentTargetId);
+          const subId2 = buildChainClone(subId, subAccum, ctx, subChain);
+          if (subId2) n.href = "#" + subId2;
+        }
+        clearCloneRetime(n);
+      }
+      (_a = n.children) == null ? void 0 : _a.forEach(visit);
+    };
+    visit(node);
+  }
   function remapKeyframeTimes(node, start, stretch) {
     var _a;
     remapKeyframeTimesOnly(node, start, stretch);
@@ -58594,12 +58662,14 @@ ${codeFrame}` : message);
       node[attrName] = String(raw);
       return;
     }
-    if (typeof raw === "object") {
+    if (typeof raw === "object" && raw !== null) {
       const obj = raw;
       if (Array.isArray(obj.keyframes)) {
         const prevAnimate = node.animate && typeof node.animate === "object" && !Array.isArray(node.animate) ? node.animate : void 0;
         const animate = __spreadValues({}, prevAnimate || {});
-        animate[attrName] = { keyframes: obj.keyframes };
+        const block = { keyframes: obj.keyframes };
+        if (obj.loop !== void 0) block.loop = obj.loop;
+        animate[attrName] = block;
         node.animate = animate;
         return;
       }
@@ -58609,6 +58679,57 @@ ${codeFrame}` : message);
       }
     }
   }
+  var jsonElementFactory = (type, props, children) => {
+    const node = { type };
+    for (const k in props) if (props[k] !== void 0) node[k] = props[k];
+    const arr = Array.isArray(children) ? children.filter((c) => c != null) : children != null ? [children] : [];
+    if (arr.length) node.children = arr;
+    return node;
+  };
+  function fmt(v, decimals) {
+    return Math.round(v) === v ? "" + Math.round(v) : v.toFixed(decimals);
+  }
+  function pack(nums, decimals) {
+    let s = "";
+    for (let i = 0; i < nums.length; i++) {
+      const str2 = fmt(nums[i], decimals);
+      if (i > 0 && str2.charCodeAt(0) !== 45) s += " ";
+      s += str2;
+    }
+    return s;
+  }
+  function apply(m, x, y) {
+    return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+  }
+  var TOKEN_RE = /([MLCQZ])|(-?\d*\.?\d+(?:e[-+]?\d+)?)/gi;
+  function transformPathData(d, m, decimals = 2) {
+    const tokens = [];
+    let match;
+    TOKEN_RE.lastIndex = 0;
+    while ((match = TOKEN_RE.exec(d)) !== null) tokens.push(match[0]);
+    let out = "";
+    let i = 0;
+    const num2 = () => parseFloat(tokens[i++]);
+    while (i < tokens.length) {
+      const cmd = tokens[i++];
+      if (cmd === "M" || cmd === "L") {
+        const [x, y] = apply(m, num2(), num2());
+        out += cmd + pack([x, y], decimals);
+      } else if (cmd === "C") {
+        const [x1, y1] = apply(m, num2(), num2());
+        const [x2, y2] = apply(m, num2(), num2());
+        const [x, y] = apply(m, num2(), num2());
+        out += "C" + pack([x1, y1, x2, y2, x, y], decimals);
+      } else if (cmd === "Q") {
+        const [x1, y1] = apply(m, num2(), num2());
+        const [x, y] = apply(m, num2(), num2());
+        out += "Q" + pack([x1, y1, x, y], decimals);
+      } else if (cmd === "Z" || cmd === "z") {
+        out += "Z";
+      }
+    }
+    return out;
+  }
   function bezierToSvgPath(path) {
     var _a, _b, _c, _d;
     const v = path.v;
@@ -58980,6 +59101,24 @@ ${codeFrame}` : message);
     }
     return { ts, ds };
   }
+  function bezier2D_tForDistance(lut, distance) {
+    const { ts, ds } = lut;
+    const last = ds.length - 1;
+    if (distance <= 0) return ts[0];
+    if (distance >= ds[last]) return ts[last];
+    let lo = 1;
+    let hi = last;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (ds[mid] < distance) lo = mid + 1;
+      else hi = mid;
+    }
+    const dPrev = ds[hi - 1];
+    const dCur = ds[hi];
+    const span = dCur - dPrev;
+    const frac = span > 0 ? (distance - dPrev) / span : 0;
+    return ts[hi - 1] + frac * (ts[hi] - ts[hi - 1]);
+  }
   function bezier2D_arcAtT(lut, t) {
     const { ts, ds } = lut;
     const last = ts.length - 1;
@@ -59001,6 +59140,435 @@ ${codeFrame}` : message);
     const flipped = [easing[1], easing[0], easing[3], easing[2]];
     return cubicBezier(flipped);
   }
+  var LUT_STEPS = 48;
+  var CMD_RE = /[MmLlHhVvCcSsQqTtAaZz]/;
+  function tokenize(d) {
+    const tokens = [];
+    const re = /([MmLlHhVvCcSsQqTtAaZz])|(-?\d*\.?\d+(?:[eE][-+]?\d+)?)/g;
+    let m;
+    while ((m = re.exec(d)) !== null) tokens.push(m[0]);
+    return tokens;
+  }
+  function quadToCubic(P0, Qc, P3) {
+    return {
+      P1: [P0[0] + 2 / 3 * (Qc[0] - P0[0]), P0[1] + 2 / 3 * (Qc[1] - P0[1])],
+      P2: [P3[0] + 2 / 3 * (Qc[0] - P3[0]), P3[1] + 2 / 3 * (Qc[1] - P3[1])]
+    };
+  }
+  function parseCubics(d) {
+    const tokens = tokenize(d);
+    const segs = [];
+    let i = 0;
+    let cx = 0, cy = 0;
+    let sx = 0, sy = 0;
+    let pcx = 0, pcy = 0;
+    let pqx = 0, pqy = 0;
+    let prevCmd = "";
+    const num2 = () => parseFloat(tokens[i++]);
+    const push = (P1, P2, P3) => {
+      const P0 = [cx, cy];
+      const lut = bezier2D_arcLengthLUT(P0, P1, P2, P3, LUT_STEPS);
+      segs.push({ P0, P1, P2, P3, lut, len: lut.ds[lut.ds.length - 1] });
+      cx = P3[0];
+      cy = P3[1];
+    };
+    const pushLine = (x, y) => {
+      push(
+        [cx + (x - cx) / 3, cy + (y - cy) / 3],
+        [cx + 2 * (x - cx) / 3, cy + 2 * (y - cy) / 3],
+        [x, y]
+      );
+    };
+    while (i < tokens.length) {
+      let cmd = tokens[i];
+      if (CMD_RE.test(cmd)) i++;
+      else cmd = prevCmd === "M" ? "L" : prevCmd === "m" ? "l" : prevCmd;
+      const rel = cmd >= "a";
+      const U = cmd.toUpperCase();
+      if (U === "Z") {
+        pushLine(sx, sy);
+        cx = sx;
+        cy = sy;
+        prevCmd = cmd;
+        continue;
+      }
+      if (U === "M") {
+        const x = num2() + (rel ? cx : 0), y = num2() + (rel ? cy : 0);
+        cx = x;
+        cy = y;
+        sx = x;
+        sy = y;
+        prevCmd = cmd;
+        continue;
+      }
+      if (U === "L") {
+        pushLine(num2() + (rel ? cx : 0), num2() + (rel ? cy : 0));
+      } else if (U === "H") {
+        pushLine(num2() + (rel ? cx : 0), cy);
+      } else if (U === "V") {
+        pushLine(cx, num2() + (rel ? cy : 0));
+      } else if (U === "C") {
+        const p1 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        const p2 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        const p3 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        pcx = p2[0];
+        pcy = p2[1];
+        push(p1, p2, p3);
+      } else if (U === "S") {
+        const smooth = prevCmd.toUpperCase() === "C" || prevCmd.toUpperCase() === "S";
+        const p1 = smooth ? [2 * cx - pcx, 2 * cy - pcy] : [cx, cy];
+        const p2 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        const p3 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        pcx = p2[0];
+        pcy = p2[1];
+        push(p1, p2, p3);
+      } else if (U === "Q") {
+        const qc = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        const p3 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        pqx = qc[0];
+        pqy = qc[1];
+        const { P1, P2 } = quadToCubic([cx, cy], qc, p3);
+        push(P1, P2, p3);
+      } else if (U === "T") {
+        const smooth = prevCmd.toUpperCase() === "Q" || prevCmd.toUpperCase() === "T";
+        const qc = smooth ? [2 * cx - pqx, 2 * cy - pqy] : [cx, cy];
+        const p3 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+        pqx = qc[0];
+        pqy = qc[1];
+        const { P1, P2 } = quadToCubic([cx, cy], qc, p3);
+        push(P1, P2, p3);
+      } else if (U === "A") {
+        i += 5;
+        pushLine(num2() + (rel ? cx : 0), num2() + (rel ? cy : 0));
+      } else {
+        i++;
+        continue;
+      }
+      prevCmd = cmd;
+    }
+    return segs.length ? segs : null;
+  }
+  function clamp2(v, lo, hi) {
+    return v < lo ? lo : v > hi ? hi : v;
+  }
+  function createPathSampler(d) {
+    const segs = parseCubics(d);
+    if (!segs) return null;
+    const cum = new Float64Array(segs.length + 1);
+    for (let k = 0; k < segs.length; k++) cum[k + 1] = cum[k] + segs[k].len;
+    const totalLength = cum[segs.length];
+    const start = segs[0].P0, end = segs[segs.length - 1].P3;
+    const closed = Math.hypot(end[0] - start[0], end[1] - start[1]) < 1e-3;
+    const sampleOn = (dist) => {
+      let k = 0;
+      while (k < segs.length - 1 && dist > cum[k + 1]) k++;
+      const seg = segs[k];
+      const local = dist - cum[k];
+      const t = seg.len > 0 ? bezier2D_tForDistance(seg.lut, local) : 0;
+      const [x, y] = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+      const [dx, dy] = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+      return { x, y, angle: Math.atan2(dy, dx) };
+    };
+    return {
+      totalLength,
+      sampleAtDistance(dist) {
+        if (!closed && (dist < 0 || dist > totalLength)) {
+          const edge = dist < 0 ? 0 : totalLength;
+          const p = sampleOn(edge);
+          const over = dist - edge;
+          return { x: p.x + Math.cos(p.angle) * over, y: p.y + Math.sin(p.angle) * over, angle: p.angle };
+        }
+        return sampleOn(clamp2(dist, 0, totalLength));
+      }
+    };
+  }
+  var DEFAULT_FONT_SIZE = 16;
+  var TEXT_ATTR_KEYS = [
+    "fontFamily",
+    "fontSize",
+    "fontWeight",
+    "fontStyle",
+    "textAnchor",
+    "letterSpacing",
+    "wordSpacing",
+    "textDecoration",
+    "textTransform",
+    "whiteSpace",
+    "x",
+    "y",
+    "dx",
+    "dy",
+    "lengthAdjust",
+    "fill",
+    "stroke",
+    "strokeWidth",
+    "effects",
+    TEXT_ATTR,
+    TEXT_CONTENT_ATTR,
+    "xml:space"
+  ];
+  function parseLen(v) {
+    if (typeof v === "number") return v;
+    if (typeof v === "string") {
+      const n = parseFloat(v);
+      return isNaN(n) ? void 0 : n;
+    }
+    return void 0;
+  }
+  function str(v) {
+    return typeof v === "string" ? v : void 0;
+  }
+  function resolveStyle(node, parent) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return {
+      fontFamily: (_a = str(node.fontFamily)) != null ? _a : parent.fontFamily,
+      fontSize: (_b = parseLen(node.fontSize)) != null ? _b : parent.fontSize,
+      fill: (_c = node.fill) != null ? _c : parent.fill,
+      stroke: (_d = node.stroke) != null ? _d : parent.stroke,
+      strokeWidth: (_e = node.strokeWidth) != null ? _e : parent.strokeWidth,
+      letterSpacing: (_f = parseLen(node.letterSpacing)) != null ? _f : parent.letterSpacing,
+      wordSpacing: (_g = parseLen(node.wordSpacing)) != null ? _g : parent.wordSpacing
+    };
+  }
+  function rootStyleOf(node) {
+    var _a, _b, _c;
+    return {
+      fontFamily: str(node.fontFamily),
+      fontSize: (_a = parseLen(node.fontSize)) != null ? _a : DEFAULT_FONT_SIZE,
+      fill: node.fill,
+      stroke: node.stroke,
+      strokeWidth: node.strokeWidth,
+      letterSpacing: (_b = parseLen(node.letterSpacing)) != null ? _b : 0,
+      wordSpacing: (_c = parseLen(node.wordSpacing)) != null ? _c : 0
+    };
+  }
+  function paintOf(s) {
+    const p = {};
+    if (s.fill !== void 0) p.fill = s.fill;
+    if (s.stroke !== void 0) p.stroke = s.stroke;
+    if (s.strokeWidth !== void 0) p.strokeWidth = s.strokeWidth;
+    return p;
+  }
+  function glyphFontFor(s, glyphs, soleFont, warnings) {
+    var _a;
+    const gf = s.fontFamily ? glyphs[s.fontFamily] : soleFont;
+    if (!gf) warnings == null ? void 0 : warnings.push('textGlyphs: no glyphs for font "' + ((_a = s.fontFamily) != null ? _a : "") + '"');
+    return gf;
+  }
+  function soleFontOf(glyphs) {
+    const names = Object.keys(glyphs);
+    return names.length === 1 ? glyphs[names[0]] : void 0;
+  }
+  function materialiseGlyphTextHorizontal(node, opts) {
+    var _a, _b, _c, _d;
+    const { glyphs, create = jsonElementFactory, warnings } = opts;
+    const soleFont = soleFontOf(glyphs);
+    const pen = { x: (_a = parseLen(node.x)) != null ? _a : 0, y: (_b = parseLen(node.y)) != null ? _b : 0 };
+    const placements = [];
+    const lines = [{ start: pen.x, end: pen.x }];
+    let line = 0;
+    const renderChars = (content, s) => {
+      const gf = glyphFontFor(s, glyphs, soleFont, warnings);
+      if (!gf) return;
+      const scale = s.fontSize / gf.unitsPerEm;
+      const paint = paintOf(s);
+      for (let i = 0; i < content.length; i++) {
+        const ch = content.charAt(i);
+        const g = gf.glyphs[ch];
+        if (g && g.d) placements.push({ glyphD: g.d, m: [scale, 0, 0, scale, pen.x, pen.y], paint, line, x: pen.x, y: pen.y, scale });
+        pen.x += (g ? g.width : 0) * scale + s.letterSpacing + (ch === " " ? s.wordSpacing : 0);
+        lines[line].end = pen.x;
+      }
+    };
+    const walk = (el, parentStyle) => {
+      var _a2, _b2, _c2, _d2;
+      const s = resolveStyle(el, parentStyle);
+      const x = parseLen(el.x);
+      const y = parseLen(el.y);
+      if (x !== void 0) {
+        pen.x = x;
+        line = lines.length;
+        lines.push({ start: pen.x, end: pen.x });
+      }
+      if (y !== void 0) pen.y = y;
+      pen.x += (_a2 = parseLen(el.dx)) != null ? _a2 : 0;
+      pen.y += (_b2 = parseLen(el.dy)) != null ? _b2 : 0;
+      const content = (_c2 = str(el[TEXT_ATTR])) != null ? _c2 : str(el[TEXT_CONTENT_ATTR]);
+      if (content && !((_d2 = el.children) == null ? void 0 : _d2.length)) renderChars(content, s);
+      if (el.children) for (const ch of el.children) walk(ch, s);
+    };
+    const rootStyle = rootStyleOf(node);
+    if (node.children) for (const ch of node.children) walk(ch, rootStyle);
+    const rootContent = (_c = str(node[TEXT_ATTR])) != null ? _c : str(node[TEXT_CONTENT_ATTR]);
+    if (rootContent && !((_d = node.children) == null ? void 0 : _d.length)) renderChars(rootContent, rootStyle);
+    const anchor = str(node.textAnchor);
+    if (anchor === "middle" || anchor === "end") {
+      for (const p of placements) {
+        const w = lines[p.line].end - lines[p.line].start;
+        const shift = anchor === "middle" ? -w / 2 : -w;
+        p.m = [p.scale, 0, 0, p.scale, p.x + shift, p.y];
+      }
+    }
+    return toGroup(node, buildPaths(placements, create, warnings), create);
+  }
+  function collectAlongPathCells(node, glyphs, soleFont, warnings) {
+    const cells = [];
+    let adv = 0;
+    const walk = (el, parentStyle) => {
+      var _a, _b;
+      const s = resolveStyle(el, parentStyle);
+      const content = (_a = str(el[TEXT_ATTR])) != null ? _a : str(el[TEXT_CONTENT_ATTR]);
+      if (content && !((_b = el.children) == null ? void 0 : _b.length)) {
+        const gf = glyphFontFor(s, glyphs, soleFont, warnings);
+        if (gf) {
+          const scale = s.fontSize / gf.unitsPerEm;
+          const paint = paintOf(s);
+          for (let i = 0; i < content.length; i++) {
+            const ch = content.charAt(i);
+            const g = gf.glyphs[ch];
+            const glyphAdv = (g ? g.width : 0) * scale;
+            if (g && g.d) cells.push({ glyphD: g.d, widthEm: g.width, scale, paint, midBase: adv + glyphAdv / 2 });
+            adv += glyphAdv + s.letterSpacing + (ch === " " ? s.wordSpacing : 0);
+          }
+        }
+      }
+      if (el.children) for (const ch of el.children) walk(ch, s);
+    };
+    walk(node, rootStyleOf(node));
+    return { cells, width: adv };
+  }
+  function alongAffine(sampler, dist, scale, widthEm) {
+    const { x, y, angle } = sampler.sampleAtDistance(dist);
+    const cos = Math.cos(angle), sin = Math.sin(angle), hw = widthEm / 2;
+    return [scale * cos, scale * sin, -scale * sin, scale * cos, x - scale * cos * hw, y - scale * sin * hw];
+  }
+  function materialiseGlyphTextAlongPath(node, pathD, startOffset, opts, textLength) {
+    var _a;
+    const { glyphs, create = jsonElementFactory, warnings } = opts;
+    const sampler = pathD ? createPathSampler(pathD) : null;
+    if (!sampler) {
+      warnings == null ? void 0 : warnings.push("textGlyphs: unparsable along-path geometry");
+      return null;
+    }
+    const soleFont = soleFontOf(glyphs);
+    const { cells, width } = collectAlongPathCells(node, glyphs, soleFont, warnings);
+    if (!cells.length) return toGroup(node, [], create);
+    if (textLength && textLength > 0 && width > 0) {
+      const k = textLength / width;
+      for (const c of cells) c.midBase *= k;
+    }
+    const so = readAnimatable(startOffset);
+    if (so.kind === "animated" && so.keyframes.length >= 2) {
+      return toGroup(node, buildAnimatedAlongPath(cells, sampler, so.keyframes, so.loop, create), create);
+    }
+    const base = so.kind === "animated" ? Number((_a = so.keyframes[0]) == null ? void 0 : _a.value) || 0 : so.kind === "static" ? Number(so.value) || 0 : 0;
+    const placements = cells.map((c) => ({
+      glyphD: c.glyphD,
+      paint: c.paint,
+      m: alongAffine(sampler, base + c.midBase, c.scale, c.widthEm)
+    }));
+    return toGroup(node, buildPaths(placements, create, warnings), create);
+  }
+  var ALONG_PATH_MAX_STEPS = 48;
+  var ALONG_PATH_MAX_STEPS_PER_SEGMENT = 64;
+  function roundN(v, n) {
+    const f = __pow(10, n);
+    return Math.round(v * f) / f;
+  }
+  function buildAnimatedAlongPath(cells, sampler, sokfs, loop, create) {
+    const step = Math.max(sampler.totalLength / ALONG_PATH_MAX_STEPS, 0.5);
+    const timeOf = (kf) => Number(kf.time) || 0;
+    const offOf = (kf) => Number(kf.value) || 0;
+    const out = [];
+    for (const c of cells) {
+      const centred = [c.scale, 0, 0, c.scale, -c.scale * (c.widthEm / 2), 0];
+      const d = transformPathData(c.glyphD, centred);
+      const sampleKf = (dist, time) => {
+        const { x, y, angle } = sampler.sampleAtDistance(dist);
+        return {
+          time,
+          value: {
+            [
+              "translate"
+              /* Translate */
+            ]: [roundN(x, 3), roundN(y, 3)],
+            [
+              "rotate"
+              /* Rotate */
+            ]: roundN(angle * 180 / Math.PI, 3)
+          }
+        };
+      };
+      const kfs = [sampleKf(offOf(sokfs[0]) + c.midBase, timeOf(sokfs[0]))];
+      for (let k = 1; k < sokfs.length; k++) {
+        const t0 = timeOf(sokfs[k - 1]), t1 = timeOf(sokfs[k]);
+        const o0 = offOf(sokfs[k - 1]), o1 = offOf(sokfs[k]);
+        const n = Math.min(ALONG_PATH_MAX_STEPS_PER_SEGMENT, Math.max(1, Math.ceil(Math.abs(o1 - o0) / step)));
+        for (let s = 1; s <= n; s++) {
+          const f = s / n;
+          kfs.push(sampleKf(o0 + f * (o1 - o0) + c.midBase, t0 + f * (t1 - t0)));
+        }
+      }
+      const transform = { keyframes: kfs };
+      if (loop !== void 0) transform.loop = loop;
+      out.push(create("path", __spreadProps(__spreadValues({ d }, paintProps(c.paint)), { animate: { transform } }), []));
+    }
+    return out;
+  }
+  function paintProps(paint) {
+    const p = {};
+    if (paint.fill !== void 0) p.fill = paint.fill;
+    if (paint.stroke !== void 0) p.stroke = paint.stroke;
+    if (paint.strokeWidth !== void 0) p.strokeWidth = paint.strokeWidth;
+    return p;
+  }
+  function buildPaths(placements, create, warnings) {
+    var _a, _b, _c;
+    if (!placements.length) {
+      warnings == null ? void 0 : warnings.push("textGlyphs: nothing to render");
+      return [];
+    }
+    const byPaint = /* @__PURE__ */ new Map();
+    for (const p of placements) {
+      const key = JSON.stringify([(_a = p.paint.fill) != null ? _a : null, (_b = p.paint.stroke) != null ? _b : null, (_c = p.paint.strokeWidth) != null ? _c : null]);
+      const baked = transformPathData(p.glyphD, p.m);
+      const entry = byPaint.get(key);
+      if (entry) entry.d += baked;
+      else byPaint.set(key, { paint: p.paint, d: baked });
+    }
+    const out = [];
+    for (const { paint, d } of byPaint.values()) out.push(create("path", __spreadValues({ d }, paintProps(paint)), []));
+    return out;
+  }
+  function toGroup(node, children, create) {
+    const gProps = {};
+    for (const k of Object.keys(node)) {
+      if (k === "type" || k === "children" || TEXT_ATTR_KEYS.indexOf(k) !== -1) continue;
+      gProps[k] = node[k];
+    }
+    if (gProps.style && typeof gProps.style === "object") {
+      const style = __spreadValues({}, gProps.style);
+      delete style["white-space"];
+      if (Object.keys(style).length) gProps.style = style;
+      else delete gProps.style;
+    }
+    return create("g", gProps, children);
+  }
+  function applyTextGlyphsEffect(node, fx, ctx) {
+    if (!(fx == null ? void 0 : fx.useGlyphs)) return node;
+    if (!ctx.glyphs) {
+      ctx.warnings.push("textGlyphs: no definitions.glyphs \u2014 left as native <text>");
+      return node;
+    }
+    return materialiseGlyphTextHorizontal(node, { glyphs: ctx.glyphs, warnings: ctx.warnings });
+  }
+  function applyTextGlyphsAlongPath(node, ctx, pathD, startOffset, textLength) {
+    if (!ctx.glyphs) {
+      ctx.warnings.push("textGlyphs: no definitions.glyphs");
+      return null;
+    }
+    return materialiseGlyphTextAlongPath(node, pathD, startOffset, { glyphs: ctx.glyphs, warnings: ctx.warnings }, textLength);
+  }
   function getKfTranslate(kf) {
     var _a;
     const v = (_a = kf.value) != null ? _a : kf.v;
@@ -59441,12 +60009,12 @@ ${codeFrame}` : message);
     }
     return res;
   }
-  function extractPathData(str) {
-    if (str.startsWith("path(") && str.endsWith(")")) {
-      return str.slice(5, -1);
+  function extractPathData(str2) {
+    if (str2.startsWith("path(") && str2.endsWith(")")) {
+      return str2.slice(5, -1);
     }
-    if (/^[MmZzLlHhVvCcSsQqTtAa]/.test(str)) {
-      return str;
+    if (/^[MmZzLlHhVvCcSsQqTtAa]/.test(str2)) {
+      return str2;
     }
     return void 0;
   }
@@ -59656,16 +60224,67 @@ ${codeFrame}` : message);
         looped.push(pushed);
       }
     }
-    for (let rep = 0; rep < fullReps; rep++) {
-      const distFromBoundary = loop.before ? fullReps - 1 - rep : rep;
-      const isReversed = !!loop.alternate && distFromBoundary % 2 === 0;
-      const repStart = fillStart + rep * segDuration;
-      appendRep(repStart, isReversed);
+    function appendRepTail(repStart, isReversed, tailFraction) {
+      let entries;
+      if (isReversed) {
+        entries = [];
+        for (let i = template.length - 1; i >= 0; i--) {
+          entries.push({
+            relT: 1 - template[i].relT,
+            v: template[i].v,
+            e: i > 0 ? reverseEasing(template[i - 1].e) : void 0,
+            tangentIn: template[i].tangentOut,
+            tangentOut: template[i].tangentIn
+          });
+        }
+      } else {
+        entries = template;
+      }
+      const startRelT = 1 - tailFraction;
+      for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.relT < startRelT - 1e-9) continue;
+        const prev = entries[i - 1];
+        if (prev && prev.relT < startRelT - 1e-9 && entry.relT > startRelT + 1e-9) {
+          const intervalSpan = entry.relT - prev.relT;
+          const localFrac = (startRelT - prev.relT) / intervalSpan;
+          const easedFrac = prev.e ? cubicBezier(prev.e)(localFrac) : localFrac;
+          const startValue = interpolateValue(propName, prev.v, entry.v, easedFrac);
+          const { right: rightEasing } = splitEasing(prev.e, localFrac);
+          looped.push({ t: repStart, v: startValue, e: rightEasing });
+        }
+        const pushed = {
+          t: repStart + (entry.relT - startRelT) * segDuration,
+          v: entry.v,
+          e: i < entries.length - 1 ? entry.e : void 0
+        };
+        if (entry.tangentIn) pushed.tangentIn = entry.tangentIn;
+        if (entry.tangentOut) pushed.tangentOut = entry.tangentOut;
+        looped.push(pushed);
+      }
     }
-    if (partialFraction > 1e-9) {
-      const isReversed = !!loop.alternate && fullReps % 2 === 0;
-      const repStart = fillStart + fullReps * segDuration;
-      appendRep(repStart, isReversed, partialFraction);
+    if (loop.before) {
+      if (partialFraction > 1e-9) {
+        const isReversed = !!loop.alternate && fullReps % 2 === 0;
+        appendRepTail(fillStart, isReversed, partialFraction);
+      }
+      for (let rep = 0; rep < fullReps; rep++) {
+        const distFromBoundary = fullReps - 1 - rep;
+        const isReversed = !!loop.alternate && distFromBoundary % 2 === 0;
+        const repStart = fillStart + remainder + rep * segDuration;
+        appendRep(repStart, isReversed);
+      }
+    } else {
+      for (let rep = 0; rep < fullReps; rep++) {
+        const isReversed = !!loop.alternate && rep % 2 === 0;
+        const repStart = fillStart + rep * segDuration;
+        appendRep(repStart, isReversed);
+      }
+      if (partialFraction > 1e-9) {
+        const isReversed = !!loop.alternate && fullReps % 2 === 0;
+        const repStart = fillStart + fullReps * segDuration;
+        appendRep(repStart, isReversed, partialFraction);
+      }
     }
     if (loop.before) {
       return [...looped, ...keyframes];
@@ -59982,7 +60601,6 @@ ${codeFrame}` : message);
     if (!trimPath) return node;
     const trimAllAsOne = !!trimPath.trimAllAsOne;
     const leafEntries = [];
-    let acc = 0;
     const measure = (n) => {
       if (Array.isArray(n.children) && n.children.length > 0) {
         for (const ch of n.children) measure(ch);
@@ -59994,15 +60612,22 @@ ${codeFrame}` : message);
       if (!subpaths.length) return;
       const entry = { leaf: n, subpaths: [] };
       for (const sp of subpaths) {
-        if (!trimAllAsOne) acc = 0;
         const lengthPx = pxBezierPathLength(sp);
-        entry.subpaths.push({ subpath: sp, lengthPx, startOffsetPx: acc });
-        acc += lengthPx;
+        entry.subpaths.push({ subpath: sp, lengthPx, startOffsetPx: 0 });
       }
       leafEntries.push(entry);
     };
     measure(node);
     if (!leafEntries.length) return node;
+    let acc = 0;
+    const iterOrder = trimAllAsOne ? [...leafEntries].reverse() : leafEntries;
+    for (const entry of iterOrder) {
+      for (const sp of entry.subpaths) {
+        if (!trimAllAsOne) acc = 0;
+        sp.startOffsetPx = acc;
+        acc += sp.lengthPx;
+      }
+    }
     const chainLengthPx = acc;
     if (trimAllAsOne && chainLengthPx < 1e-3) return node;
     const offsetReadRaw = readAnimatable(trimPath.offset);
@@ -60129,10 +60754,12 @@ ${codeFrame}` : message);
           value: map((_c = kf.value) != null ? _c : kf.v),
           easing: (_d = kf.easing) != null ? _d : kf.e
         };
-      })
+      }),
+      loop: read.loop
     };
   }
   function applyAttr(node, attrName, attr) {
+    var _a, _b;
     if (!attr) return;
     if (attr.kind === "static") {
       node[attrName] = attr.value;
@@ -60140,9 +60767,16 @@ ${codeFrame}` : message);
     }
     const prevAnimate = node.animate && typeof node.animate === "object" && !Array.isArray(node.animate) ? node.animate : void 0;
     const animate = __spreadValues({}, prevAnimate || {});
-    animate[attrName] = { keyframes: attr.keyframes };
+    const block = { keyframes: attr.keyframes };
+    if (attr.loop !== void 0) block.loop = attr.loop;
+    animate[attrName] = block;
     node.animate = animate;
+    const firstKf = attr.keyframes[0];
+    if (firstKf && ((_a = firstKf.value) != null ? _a : firstKf.v) !== void 0) {
+      node[attrName] = (_b = firstKf.value) != null ? _b : firstKf.v;
+    }
   }
+  var OPACITY_STEP_MS = 10;
   function computeOpacityFromRange(rangeRead) {
     var _a, _b, _c, _d, _e, _f;
     const hide = (v) => v[0] === v[1];
@@ -60168,9 +60802,9 @@ ${codeFrame}` : message);
       const nextHide = nextKf ? thisHide && hide((_f = nextKf.value) != null ? _f : nextKf.v) : thisHide;
       if (prevHide && !nextHide) {
         out.push({ time: t, value: 0 });
-        out.push({ time: t + 1, value: 1 });
+        out.push({ time: t + OPACITY_STEP_MS, value: 1 });
       } else if (!prevHide && nextHide) {
-        out.push({ time: t - 1, value: 1 });
+        out.push({ time: t - OPACITY_STEP_MS, value: 1 });
         out.push({ time: t, value: 0 });
       }
     }
@@ -60301,6 +60935,7 @@ ${codeFrame}` : message);
     return "M" + (x + w) + "," + y + "L" + (x + w) + "," + (y + h3) + "L" + x + "," + (y + h3) + "L" + x + "," + y + "L" + (x + w) + "," + y + "z";
   }
   function applyPlayerEffects(root) {
+    var _a, _b;
     const ctx = {
       defs: [],
       warnings: [],
@@ -60308,7 +60943,11 @@ ${codeFrame}` : message);
       idMap: /* @__PURE__ */ new Map(),
       nextId: 0,
       contentRefInnerIds: /* @__PURE__ */ new Map(),
-      maskAncestorChains: /* @__PURE__ */ new Map()
+      maskAncestorChains: /* @__PURE__ */ new Map(),
+      // Resolved engine: `frames` ONLY when explicitly set; auto/webapi/unset →
+      // webapi (we're not 100% sure it's frames, and CSS/WAAPI need the inline form).
+      engine: ((_a = getAnimatorConfig(root)) == null ? void 0 : _a.mode) === PxAnimatorMode.frames ? PxAnimatorEngine.frames : PxAnimatorEngine.webapi,
+      glyphs: (_b = getDefs(root)) == null ? void 0 : _b.glyphs
     };
     const working = clone(root);
     indexById(working, ctx.idMap);
@@ -60320,27 +60959,46 @@ ${codeFrame}` : message);
     return { root: out, defs: ctx.defs, warnings: ctx.warnings, errors: ctx.errors };
   }
   function applyPlayerEffects_exceptRetime(node, ctx) {
+    var _a;
     if (node.children) node.children = node.children.map((child) => applyPlayerEffects_exceptRetime(child, ctx));
     const fx = node.effects;
     const originalId = typeof node.id === "string" ? node.id : void 0;
     const innerIdForContentRef = originalId ? ctx.contentRefInnerIds.get(originalId) : void 0;
     if (!fx && !innerIdForContentRef) return node;
-    const { transformation, repeater, maskedBy, trimPath, retime, ref: ref3, fillGradient, strokeGradient, textAlongPath } = fx != null ? fx : {};
+    const { transformation, repeater, maskedBy, trimPath, clone: cloneFx, fillGradient, strokeGradient, textAlongPath, text } = fx != null ? fx : {};
     const isCombinedShape = fx == null ? void 0 : fx.isCombinedShape;
     if (fx) delete node.effects;
     let n = node;
-    n = applyTextAlongPathEffect(n, textAlongPath, ctx);
+    let consumedByGlyphs = false;
+    if (text == null ? void 0 : text.useGlyphs) {
+      if (textAlongPath) {
+        const pathNode = typeof textAlongPath.href === "string" ? ctx.idMap.get(textAlongPath.href) : void 0;
+        const pathD = pathNode && typeof pathNode.d === "string" ? pathNode.d : void 0;
+        const rawTL = textAlongPath.textLength;
+        const textLength = typeof rawTL === "number" ? rawTL : rawTL && typeof rawTL === "object" ? typeof rawTL.value === "number" ? rawTL.value : Array.isArray(rawTL.keyframes) && rawTL.keyframes.length ? Number((_a = rawTL.keyframes[0]) == null ? void 0 : _a.value) : void 0 : void 0;
+        const glyphed = applyTextGlyphsAlongPath(n, ctx, pathD, textAlongPath.startOffset, textLength);
+        if (glyphed) {
+          n = glyphed;
+          consumedByGlyphs = true;
+        }
+      } else {
+        n = applyTextGlyphsEffect(n, text, ctx);
+        consumedByGlyphs = true;
+      }
+    }
+    if (!consumedByGlyphs) n = applyTextAlongPathEffect(n, textAlongPath, ctx);
     n = applyFillGradientEffect(n, fillGradient, ctx);
     n = applyStrokeGradientEffect(n, strokeGradient, ctx);
     n = applyTrimPathEffect(n, trimPath, isCombinedShape, ctx);
     n = applyRepeaterEffect(n, repeater, ctx);
     n = applyMaskedByEffect(n, maskedBy, transformation, ctx);
     if (innerIdForContentRef) {
+      applyRefHref(n, cloneFx, ctx);
       n = splitForContentRef(n, transformation, originalId, innerIdForContentRef, ctx);
     } else {
-      n = applyRefAndTransformationEffect(n, ref3, transformation, ctx);
+      n = applyRefAndTransformationEffect(n, cloneFx, transformation, ctx);
     }
-    if (retime) node.effects = { retime };
+    if (cloneFx == null ? void 0 : cloneFx.retime) node.effects = { clone: { retime: cloneFx.retime } };
     if (originalId) ctx.idMap.set(originalId, n);
     return n;
   }
@@ -60355,13 +61013,30 @@ ${codeFrame}` : message);
     if (animatedIds.size === 0) return root;
     let idCounter = 0;
     const genId3 = () => "_lw_use_mat_" + ++idCounter;
+    const rootViewport = readRootViewport(root);
     const defsCollector = [];
-    const walked = walkAndMaterialise2(root, idMap, animatedIds, genId3, defsCollector);
+    const walked = walkAndMaterialise2(root, idMap, animatedIds, genId3, defsCollector, rootViewport);
     if (defsCollector.length === 0) return walked;
     const defsNode = { type: "defs", children: defsCollector };
     const newChildren = [...(_a = walked.children) != null ? _a : [], defsNode];
     return __spreadProps(__spreadValues({}, walked), { children: newChildren });
   }
+  function readRootViewport(root) {
+    const vb = parseViewBox(root.viewBox);
+    if (vb) return [vb[2], vb[3]];
+    const w = numericAttr(root.width);
+    const h3 = numericAttr(root.height);
+    if (w !== void 0 && h3 !== void 0) return [w, h3];
+    return [1, 1];
+  }
+  function numericAttr(v) {
+    if (typeof v === "number") return v;
+    if (typeof v === "string") {
+      const n = parseFloat(v);
+      return Number.isFinite(n) ? n : void 0;
+    }
+    return void 0;
+  }
   function buildIdMap(root) {
     const map = /* @__PURE__ */ new Map();
     const visit = (n) => {
@@ -60413,16 +61088,22 @@ ${codeFrame}` : message);
     if (typeof href !== "string") return void 0;
     return href.startsWith("#") ? href.slice(1) : href;
   }
-  function materialiseOneUse(useNode, target, idMap, animatedIds, genId3, defsCollector) {
+  function materialiseOneUse(useNode, target, idMap, animatedIds, genId3, defsCollector, rootViewport) {
+    var _a, _b, _c, _d;
     const clone2 = deepClonePxNode(target);
     regenerateIdsAndRewriteRefs(clone2, genId3);
-    const rewrittenClone = clone2.type === "symbol" ? rewriteSymbolRootToGroup(clone2, genId3, defsCollector) : clone2;
-    const materialisedClone = walkAndMaterialise2(rewrittenClone, idMap, animatedIds, genId3, defsCollector);
+    const symbolViewBox = clone2.type === "symbol" ? parseViewBox(clone2.viewBox) : void 0;
+    const useW = (_b = (_a = numericAttr(useNode.width)) != null ? _a : symbolViewBox == null ? void 0 : symbolViewBox[2]) != null ? _b : rootViewport[0];
+    const useH = (_d = (_c = numericAttr(useNode.height)) != null ? _c : symbolViewBox == null ? void 0 : symbolViewBox[3]) != null ? _d : rootViewport[1];
+    const rewrittenClone = clone2.type === "symbol" ? rewriteSymbolRootToGroup(clone2, genId3, defsCollector, useW, useH) : clone2;
+    const materialisedClone = walkAndMaterialise2(rewrittenClone, idMap, animatedIds, genId3, defsCollector, rootViewport);
     const newNode = __spreadProps(__spreadValues({}, useNode), { type: "g", children: [materialisedClone] });
     delete newNode.href;
+    delete newNode.width;
+    delete newNode.height;
     return applyUseOffsetToG(newNode);
   }
-  function rewriteSymbolRootToGroup(symbolNode, genId3, defsCollector) {
+  function rewriteSymbolRootToGroup(symbolNode, genId3, defsCollector, useW, useH) {
     const viewBox = parseViewBox(symbolNode.viewBox);
     const g = __spreadProps(__spreadValues({}, symbolNode), { type: "g" });
     delete g.viewBox;
@@ -60431,9 +61112,14 @@ ${codeFrame}` : message);
     delete g.height;
     if (!viewBox) return g;
     const [vbX, vbY, vbW, vbH] = viewBox;
-    if (vbX !== 0 || vbY !== 0) {
-      g.transform = "translate(" + -vbX + "," + -vbY + ")";
-    }
+    const scale = vbW > 0 && vbH > 0 ? Math.min(useW / vbW, useH / vbH) : 1;
+    const xOff = (useW - vbW * scale) / 2;
+    const yOff = (useH - vbH * scale) / 2;
+    const parts = [];
+    if (xOff !== 0 || yOff !== 0) parts.push("translate(" + xOff + "," + yOff + ")");
+    if (scale !== 1) parts.push("scale(" + scale + ")");
+    if (vbX !== 0 || vbY !== 0) parts.push("translate(" + -vbX + "," + -vbY + ")");
+    if (parts.length) g.transform = parts.join("");
     const clipId = genId3();
     defsCollector.push({
       type: "clipPath",
@@ -60449,18 +61135,18 @@ ${codeFrame}` : message);
     if (parts.length < 4 || parts.some((n) => !Number.isFinite(n))) return void 0;
     return [parts[0], parts[1], parts[2], parts[3]];
   }
-  function walkAndMaterialise2(node, idMap, animatedIds, genId3, defsCollector) {
+  function walkAndMaterialise2(node, idMap, animatedIds, genId3, defsCollector, rootViewport) {
     if (node.type === "use" && typeof node.href === "string") {
       const targetId = stripHash2(node.href);
       if (targetId && animatedIds.has(targetId)) {
         const target = idMap.get(targetId);
-        if (target) return materialiseOneUse(node, target, idMap, animatedIds, genId3, defsCollector);
+        if (target) return materialiseOneUse(node, target, idMap, animatedIds, genId3, defsCollector, rootViewport);
       }
     }
     if (!node.children) return node;
     let changed = false;
     const newChildren = node.children.map((ch) => {
-      const m = walkAndMaterialise2(ch, idMap, animatedIds, genId3, defsCollector);
+      const m = walkAndMaterialise2(ch, idMap, animatedIds, genId3, defsCollector, rootViewport);
       if (m !== ch) changed = true;
       return m;
     });
@@ -60474,6 +61160,36 @@ ${codeFrame}` : message);
     if (engine === PxAnimatorEngine.webapi) {
       root = materialiseMotionPathsInTree(root, opts == null ? void 0 : opts.motionPath);
       root = materialiseAnimatedUseInstances(root);
+      root = pruneUnreferencedDefs(root);
+    }
+    return root;
+  }
+  function pruneUnreferencedDefs(root) {
+    const stripHash3 = (h3) => h3.startsWith("#") ? h3.slice(1) : h3;
+    const walk = (n, fn) => {
+      var _a;
+      fn(n);
+      (_a = n.children) == null ? void 0 : _a.forEach((c) => walk(c, fn));
+    };
+    let changed = true;
+    while (changed) {
+      changed = false;
+      const referenced = /* @__PURE__ */ new Set();
+      walk(root, (n) => {
+        if (n.type === "use" && typeof n.href === "string") referenced.add(stripHash3(n.href));
+      });
+      walk(root, (n) => {
+        if (!n.children) return;
+        let kept = n.children;
+        if (n.type === "defs") {
+          kept = kept.filter((c) => !((c.type === "g" || c.type === "symbol") && typeof c.id === "string" && !referenced.has(c.id)));
+        }
+        kept = kept.filter((c) => !(c.type === "defs" && (!c.children || c.children.length === 0)));
+        if (kept.length !== n.children.length) {
+          n.children = kept;
+          changed = true;
+        }
+      });
     }
     return root;
   }
@@ -60504,6 +61220,13 @@ ${codeFrame}` : message);
   ]);
   var IMAGE_REF_ATTRS_LOWER = /* @__PURE__ */ new Set(["href", "xlink:href", "src"]);
   var DATA_RASTER_IMAGE_RE = /^data:image\/(?:png|jpe?g|gif|webp|bmp);base64,/i;
+  var DATA_SVG_IMAGE_RE = /^data:image\/svg\+xml(?:;[^,]*)?,/i;
+  var DATA_IMAGE_BASE64_PAYLOAD_RE = /^data:image\/[^;,]*;base64,([A-Za-z0-9+/]{8})/i;
+  var BASE64_RASTER_MAGICS = ["iVBORw0K", "/9j/", "R0lGOD", "UklGR", "Qk"];
+  function isContentSniffedRasterImage(str2) {
+    const m = DATA_IMAGE_BASE64_PAYLOAD_RE.exec(str2);
+    return !!m && BASE64_RASTER_MAGICS.some((magic) => m[1].startsWith(magic));
+  }
   function isDangerousAttrName(nameLower) {
     if (nameLower.startsWith("on")) return true;
     return false;
@@ -60515,19 +61238,19 @@ ${codeFrame}` : message);
       return void 0;
     }
     if (nameLower === "fill" || nameLower === "stroke" || nameLower === "stopcolor") {
-      const str = String(value);
-      if (str.includes("url(") && !/^url\(#[^)]+\)$/.test(str)) {
+      const str2 = String(value);
+      if (str2.includes("url(") && !/^url\(#[^)]+\)$/.test(str2)) {
         console.warn('Attribute "' + nameLower + '" blocked: url() must be internal url(#id), got:', value);
         return void 0;
       }
       return value;
     }
     if (URL_VALUE_ATTRS_LOWER.has(nameLower)) {
-      const str = String(value);
-      if (str.startsWith("#")) return value;
-      if (/^url\(#[^)]+\)$/.test(str)) return value;
-      if (IMAGE_REF_ATTRS_LOWER.has(nameLower) && DATA_RASTER_IMAGE_RE.test(str)) return value;
-      console.warn('Attribute "' + nameLower + '" blocked: must be #id, url(#id), or base64 raster data: URI, got:', value);
+      const str2 = String(value);
+      if (str2.startsWith("#")) return value;
+      if (/^url\(#[^)]+\)$/.test(str2)) return value;
+      if (IMAGE_REF_ATTRS_LOWER.has(nameLower) && (DATA_RASTER_IMAGE_RE.test(str2) || DATA_SVG_IMAGE_RE.test(str2) || isContentSniffedRasterImage(str2))) return value;
+      console.warn('Attribute "' + nameLower + '" blocked: must be #id, url(#id), or data:image/\u2026 URI, got:', value);
       return void 0;
     }
     return value;
@@ -60556,7 +61279,7 @@ ${codeFrame}` : message);
     if (textContent) element.textContent = textContent;
     return element;
   }
-  function resolveStyle(style, defs) {
+  function resolveStyle2(style, defs) {
     var _a;
     if (!style) return void 0;
     if (typeof style === "string") {
@@ -60592,7 +61315,7 @@ ${codeFrame}` : message);
     if (!node) return null;
     const _a = node, { type, children, style } = _a, props = __objRest(_a, ["type", "children", "style"]);
     const nodeDefs = getDefs(node) || defs;
-    const resolvedStyle = resolveStyle(style, nodeDefs);
+    const resolvedStyle = resolveStyle2(style, nodeDefs);
     let childElements;
     if (children) {
       for (const ch of children) {