lofter-lottie-opt 1.0.1

package/dist/esm/index.mjs

@@ -0,0 +1,2048 @@
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+import chalk from "chalk";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import node_fetch from "node-fetch";
+import node_os from "node:os";
+import nconf from "nconf";
+var __webpack_modules__ = {
+    sharp: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("sharp");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+function createLogger(verbose = false) {
+    return {
+        debug: (message)=>{
+            if (verbose) console.log(chalk.gray(`[DEBUG] ${message}`));
+        },
+        info: (message)=>{
+            console.log(chalk.blue(`[INFO] ${message}`));
+        },
+        warn: (message)=>{
+            console.log(chalk.yellow(`[WARN] ${message}`));
+        },
+        error: (message)=>{
+            console.log(chalk.red(`[ERROR] ${message}`));
+        }
+    };
+}
+function createSilentLogger() {
+    return {
+        debug: ()=>{},
+        info: ()=>{},
+        warn: ()=>{},
+        error: ()=>{}
+    };
+}
+function calculateSize(data) {
+    return Buffer.byteLength(JSON.stringify(data), 'utf8');
+}
+function formatSize(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+function calculateCompressionRatio(originalSize, optimizedSize) {
+    return (originalSize - optimizedSize) / originalSize * 100;
+}
+function computeReferencedAssetIds(json, opts) {
+    const assets = Array.isArray(json.assets) ? json.assets : [];
+    const rootLayers = Array.isArray(json.layers) ? json.layers : [];
+    const byId = new Map();
+    for (const a of assets)if (a && "string" == typeof a.id) byId.set(a.id, a);
+    const used = new Set();
+    const visitedPrecompIds = new Set();
+    const unknownRefs = new Set();
+    const queue = [
+        ...rootLayers
+    ];
+    while(queue.length > 0){
+        const layer = queue.shift();
+        const ty = layer.ty;
+        const refId = layer.refId;
+        if ((0 === ty || 2 === ty) && "string" == typeof refId && refId) if (byId.has(refId)) {
+            used.add(refId);
+            const asset = byId.get(refId);
+            if (Array.isArray(asset.layers) && asset.layers.length > 0) {
+                if (!visitedPrecompIds.has(refId)) {
+                    visitedPrecompIds.add(refId);
+                    for (const sub of asset.layers)queue.push(sub);
+                }
+            }
+        } else unknownRefs.add(refId);
+    }
+    if (opts.preserveAssetIds && opts.preserveAssetIds.length > 0) for (const id of opts.preserveAssetIds)used.add(id);
+    return {
+        used,
+        unknownRefs
+    };
+}
+function removeUnusedAssets(input, options = {}) {
+    const opts = {
+        preserveAssetIds: options.preserveAssetIds ?? [],
+        keepAssetsWithoutId: options.keepAssetsWithoutId ?? true,
+        keepUnreferencedPrecomps: options.keepUnreferencedPrecomps ?? false,
+        onLog: options.onLog ?? (()=>{})
+    };
+    const assets = Array.isArray(input.assets) ? input.assets : [];
+    const originalAssetCount = assets.length;
+    if (0 === originalAssetCount) return {
+        data: input,
+        stats: {
+            originalAssetCount,
+            keptAssetCount: 0,
+            removedAssetCount: 0,
+            unknownRefIds: [],
+            referencedAssetIds: [],
+            removedAssetIds: []
+        }
+    };
+    const { used, unknownRefs } = computeReferencedAssetIds(input, opts);
+    const byId = new Map();
+    for (const a of assets)if (a && "string" == typeof a.id) byId.set(a.id, a);
+    const preservedIdSet = new Set(opts.preserveAssetIds);
+    const kept = [];
+    const removedIds = [];
+    for (const a of assets){
+        const id = a?.id;
+        if ("string" == typeof id && id) {
+            const isPrecomp = Array.isArray(a.layers);
+            const isReferenced = used.has(id) || preservedIdSet.has(id);
+            if (isReferenced) kept.push(a);
+            else if (opts.keepUnreferencedPrecomps && isPrecomp) kept.push(a);
+            else removedIds.push(id);
+        } else if (opts.keepAssetsWithoutId) kept.push(a);
+        else removedIds.push("(no-id)");
+    }
+    const assetsWithIds = kept.filter((asset)=>'string' == typeof asset?.id);
+    const output = {
+        ...input,
+        assets: assetsWithIds
+    };
+    const stats = {
+        originalAssetCount,
+        keptAssetCount: kept.length,
+        removedAssetCount: originalAssetCount - kept.length,
+        unknownRefIds: Array.from(unknownRefs),
+        referencedAssetIds: Array.from(used),
+        removedAssetIds: removedIds
+    };
+    if (stats.unknownRefIds.length > 0) opts.onLog(`[remove-unused-assets] Warning: ${stats.unknownRefIds.length} unknown refId(s) found in layers: ${stats.unknownRefIds.join(", ")}`);
+    opts.onLog(`[remove-unused-assets] assets: ${originalAssetCount} \u{2192} ${kept.length} (removed ${stats.removedAssetCount})`);
+    return {
+        data: output,
+        stats
+    };
+}
+const removeUnusedAssetsPlugin = {
+    name: 'remove-unused-assets',
+    description: 'Remove assets that are not (transitively) referenced by any layers using BFS traversal',
+    version: '2.0.0',
+    defaultOptions: {
+        preserveAssetIds: [],
+        keepAssetsWithoutId: true,
+        keepUnreferencedPrecomps: false
+    },
+    async apply (data, options, context) {
+        const sizeBefore = calculateSize(data);
+        const pluginOptions = {
+            ...options,
+            onLog: context.logger?.info || (()=>{})
+        };
+        const result = removeUnusedAssets(data, pluginOptions);
+        const sizeAfter = calculateSize(result.data);
+        return {
+            data: result.data,
+            changed: result.stats.removedAssetCount > 0,
+            stats: {
+                itemsProcessed: result.stats.originalAssetCount,
+                itemsRemoved: result.stats.removedAssetCount,
+                sizeBefore,
+                sizeAfter
+            }
+        };
+    }
+};
+function add(a, b) {
+    return [
+        a[0] + b[0],
+        a[1] + b[1]
+    ];
+}
+function algorithm_sub(a, b) {
+    return [
+        a[0] - b[0],
+        a[1] - b[1]
+    ];
+}
+function mul(a, s) {
+    return [
+        a[0] * s,
+        a[1] * s
+    ];
+}
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1];
+}
+function len(a) {
+    return Math.hypot(a[0], a[1]);
+}
+function dist(a, b) {
+    return len(algorithm_sub(a, b));
+}
+function clamp01(x) {
+    return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function cubicBezier(p0, p1, p2, p3, t) {
+    const u = 1 - t;
+    const tt = t * t;
+    const uu = u * u;
+    const uuu = uu * u;
+    const ttt = tt * t;
+    const a = mul(p0, uuu);
+    const b = mul(p1, 3 * uu * t);
+    const c = mul(p2, 3 * u * tt);
+    const d = mul(p3, ttt);
+    return add(add(a, b), add(c, d));
+}
+function bboxOfVertices(vs) {
+    let minx = 1 / 0, miny = 1 / 0, maxx = -1 / 0, maxy = -1 / 0;
+    for (const [x, y] of vs){
+        if (x < minx) minx = x;
+        if (y < miny) miny = y;
+        if (x > maxx) maxx = x;
+        if (y > maxy) maxy = y;
+    }
+    const diag = Math.hypot(maxx - minx, maxy - miny) || 1;
+    return {
+        min: [
+            minx,
+            miny
+        ],
+        max: [
+            maxx,
+            maxy
+        ],
+        diag
+    };
+}
+function angleDeg(a, b, c) {
+    const v1 = algorithm_sub(a, b);
+    const v2 = algorithm_sub(c, b);
+    const l1 = len(v1) || 1;
+    const l2 = len(v2) || 1;
+    let cos = 2 * clamp01((dot(v1, v2) / (l1 * l2) + 1) / 2) - 1;
+    const ang = Math.acos(Math.max(-1, Math.min(1, cos)));
+    return 180 * ang / Math.PI;
+}
+function modWrap(i, n) {
+    return (i % n + n) % n;
+}
+function catmullRomHandles(v, closed, tension = 1.0) {
+    const n = v.length;
+    const Ii = new Array(n);
+    const Oo = new Array(n);
+    const get = (idx)=>{
+        if (closed) return v[modWrap(idx, n)];
+        if (idx < 0) return v[0];
+        if (idx >= n) return v[n - 1];
+        return v[idx];
+    };
+    for(let k = 0; k < n; k++){
+        const p0 = get(k - 1);
+        const p1 = get(k);
+        const p2 = get(k + 1);
+        const p3 = get(k + 2);
+        const b1 = add(p1, mul(algorithm_sub(p2, p0), tension / 6));
+        const b2 = algorithm_sub(p2, mul(algorithm_sub(p3, p1), tension / 6));
+        Oo[k] = algorithm_sub(b1, p1);
+        Ii[modWrap(k + 1, n)] = algorithm_sub(b2, p2);
+    }
+    if (!closed) {
+        if (!Ii[0]) Ii[0] = [
+            0,
+            0
+        ];
+        if (!Oo[n - 1]) Oo[n - 1] = [
+            0,
+            0
+        ];
+    }
+    for(let k = 0; k < n; k++){
+        if (!Ii[k]) Ii[k] = [
+            0,
+            0
+        ];
+        if (!Oo[k]) Oo[k] = [
+            0,
+            0
+        ];
+    }
+    return {
+        i: Ii,
+        o: Oo
+    };
+}
+function perpendicularDistance(p, a, b) {
+    const ab = algorithm_sub(b, a);
+    const t = Math.max(0, Math.min(1, dot(algorithm_sub(p, a), ab) / (dot(ab, ab) || 1)));
+    const proj = add(a, mul(ab, t));
+    return dist(p, proj);
+}
+function rdpIndices(points, epsilon) {
+    if (points.length <= 2) return points.map((_, idx)=>idx);
+    const keep = new Array(points.length).fill(false);
+    keep[0] = true;
+    keep[points.length - 1] = true;
+    function recurse(start, end) {
+        let maxDist = -1;
+        let index = -1;
+        const a = points[start];
+        const b = points[end];
+        for(let i = start + 1; i < end; i++){
+            const d = perpendicularDistance(points[i], a, b);
+            if (d > maxDist) {
+                maxDist = d;
+                index = i;
+            }
+        }
+        if (maxDist > epsilon && index >= 0) {
+            keep[index] = true;
+            recurse(start, index);
+            recurse(index, end);
+        }
+    }
+    recurse(0, points.length - 1);
+    const out = [];
+    for(let i = 0; i < keep.length; i++)if (keep[i]) out.push(i);
+    return out;
+}
+function rdpClosed(points, epsilon, mustKeep) {
+    if (points.length <= 2) return points.map((_, idx)=>idx);
+    const pts = points.slice();
+    pts.push(points[0]);
+    let kept = new Set(rdpIndices(pts, epsilon));
+    if (kept.has(pts.length - 1)) kept.delete(pts.length - 1);
+    if (mustKeep && mustKeep.size) for (const i of mustKeep)kept.add(i);
+    return Array.from(kept).sort((a, b)=>a - b);
+}
+function sampleShape(path, samplesPerSeg = 10) {
+    const { v, i, o, c } = path;
+    const n = v.length;
+    if (0 === n) return [];
+    const pts = [];
+    const segs = c ? n : n - 1;
+    for(let k = 0; k < segs; k++){
+        const a = v[k];
+        const b = v[modWrap(k + 1, n)];
+        const cp1 = add(v[k], o[k] || [
+            0,
+            0
+        ]);
+        const cp2 = add(v[modWrap(k + 1, n)], i[modWrap(k + 1, n)] || [
+            0,
+            0
+        ]);
+        const steps = Math.max(2, samplesPerSeg);
+        for(let s = 0; s <= steps; s++){
+            const t = s / steps;
+            pts.push(cubicBezier(a, cp1, cp2, b, t));
+        }
+    }
+    return pts;
+}
+function maxHausdorffLikeError(a, b, samplesPerSeg) {
+    const sa = sampleShape(a, samplesPerSeg);
+    const sb = sampleShape(b, samplesPerSeg);
+    const m = Math.max(sa.length, sb.length);
+    let maxErr = 0;
+    for(let i = 0; i < m; i++){
+        const pa = sa[i % sa.length];
+        const pb = sb[i % sb.length];
+        const d = dist(pa, pb);
+        if (d > maxErr) maxErr = d;
+    }
+    return maxErr;
+}
+function computeCornerSet(v, closed, angleDegThreshold) {
+    const n = v.length;
+    const keep = new Set();
+    for(let k = 0; k < n; k++){
+        const a = v[modWrap(k - 1, n)];
+        const b = v[k];
+        const c = v[modWrap(k + 1, n)];
+        let ang = angleDeg(a, b, c);
+        if (!closed && (0 === k || k === n - 1)) {
+            keep.add(k);
+            continue;
+        }
+        if (ang < angleDegThreshold) keep.add(k);
+    }
+    return keep;
+}
+function simplifyStaticPath(inPath, opts) {
+    const { v, c } = inPath;
+    if (!v || v.length < opts.minPoints) return inPath;
+    const { diag } = bboxOfVertices(v);
+    const tolAbs = opts.relativeTolerance ? opts.tolerance * diag : opts.tolerance;
+    const cornerSet = opts.preserveCorners ? computeCornerSet(v, c, opts.cornerAngleDeg) : new Set();
+    const mustKeep = new Set(cornerSet);
+    if (!c) {
+        mustKeep.add(0);
+        mustKeep.add(v.length - 1);
+    }
+    const keptIdx = c ? rdpClosed(v, tolAbs, mustKeep) : Array.from(new Set([
+        ...rdpIndices(v, tolAbs),
+        ...mustKeep
+    ])).sort((a, b)=>a - b);
+    if (keptIdx.length < opts.minPoints) return inPath;
+    const v2 = keptIdx.map((i)=>inPath.v[i]);
+    const { i: i2, o: o2 } = catmullRomHandles(v2, c, opts.tension);
+    const out = {
+        v: v2,
+        i: i2,
+        o: o2,
+        c
+    };
+    const err = maxHausdorffLikeError(inPath, out, opts.samplesPerSegment);
+    if (err > tolAbs) return inPath;
+    return out;
+}
+function tryRemoveIndexAcrossFrames(frames, j, minPoints, tolAbsPerFrame, samplesPerSeg, tension) {
+    const n = frames[0].v.length;
+    if (n <= minPoints) return {
+        ok: false
+    };
+    const outFrames = [];
+    for (const f of frames){
+        const { v, c } = f;
+        const nNow = v.length;
+        if (nNow !== n) return {
+            ok: false
+        };
+        if (nNow - 1 < minPoints) return {
+            ok: false
+        };
+        const keptIdx = [];
+        for(let k = 0; k < nNow; k++)if (k !== j) keptIdx.push(k);
+        const v2 = keptIdx.map((i)=>f.v[i]);
+        const { i: i2, o: o2 } = catmullRomHandles(v2, c, tension);
+        const candidate = {
+            v: v2,
+            i: i2,
+            o: o2,
+            c
+        };
+        const err = maxHausdorffLikeError(f, candidate, samplesPerSeg);
+        if (err > tolAbsPerFrame) return {
+            ok: false
+        };
+        outFrames.push(candidate);
+    }
+    return {
+        ok: true,
+        framesOut: outFrames
+    };
+}
+function simplifyAnimatedConsistent(keyframes, opts) {
+    const frames = keyframes.map((kf)=>kf.s && kf.s[0] ? kf.s[0] : null).filter(Boolean);
+    if (0 === frames.length) return keyframes;
+    const n0 = frames[0].v.length;
+    const closed0 = frames[0].c;
+    for (const f of frames)if (f.v.length !== n0 || f.c !== closed0) return keyframes;
+    if (n0 < opts.minPoints) return keyframes;
+    const tolAbsPerFrame = frames.map((f)=>{
+        const { diag } = bboxOfVertices(f.v);
+        return opts.relativeTolerance ? opts.tolerance * diag : opts.tolerance;
+    });
+    const cornerUnion = new Set();
+    if (opts.preserveCorners) for (const f of frames){
+        const cs = computeCornerSet(f.v, f.c, opts.cornerAngleDeg);
+        cs.forEach((i)=>cornerUnion.add(i));
+    }
+    if (!closed0) {
+        cornerUnion.add(0);
+        cornerUnion.add(n0 - 1);
+    }
+    function importanceAt(j) {
+        let sum = 0;
+        for(let idx = 0; idx < frames.length; idx++){
+            const f = frames[idx];
+            const n = f.v.length;
+            const a = f.v[modWrap(j - 1, n)];
+            const b = f.v[modWrap(j, n)];
+            const c = f.v[modWrap(j + 1, n)];
+            sum += perpendicularDistance(b, a, c);
+        }
+        return sum / frames.length;
+    }
+    let removable = [];
+    for(let j = 0; j < n0; j++)if (!cornerUnion.has(j)) removable.push(j);
+    removable.sort((a, b)=>importanceAt(a) - importanceAt(b));
+    let currentFrames = frames.map((f)=>({
+            v: f.v.slice(),
+            i: f.i.slice(),
+            o: f.o.slice(),
+            c: f.c
+        }));
+    for (const j0 of removable){
+        const nNow = currentFrames[0].v.length;
+        if (nNow <= opts.minPoints) break;
+        const targetPos = frames[0].v[j0];
+        let jCurr = -1;
+        let best = 1 / 0;
+        for(let j = 0; j < currentFrames[0].v.length; j++){
+            const d = dist(currentFrames[0].v[j], targetPos);
+            if (d < best) {
+                best = d;
+                jCurr = j;
+            }
+        }
+        if (jCurr < 0 || 0 === jCurr || jCurr === currentFrames[0].v.length - 1 && !closed0) continue;
+        const trial = tryRemoveIndexAcrossFrames(currentFrames, jCurr, opts.minPoints, Math.max(...tolAbsPerFrame), opts.samplesPerSegment, opts.tension);
+        if (trial.ok && trial.framesOut) currentFrames = trial.framesOut;
+    }
+    let idx = 0;
+    for (const kf of keyframes)if (kf.s && kf.s[0]) {
+        const f = currentFrames[idx++];
+        kf.s = [
+            f
+        ];
+        if (kf.e && kf.e[0]) kf.e = [
+            f
+        ];
+    }
+    return keyframes;
+}
+function traverseShapes(items, fn, path = []) {
+    if (!items) return;
+    items.forEach((it, idx)=>{
+        const p = path.concat(idx);
+        if (it && "gr" === it.ty) traverseShapes(it.it, fn, p);
+        else if (it && "sh" === it.ty && it.ks) fn(it, p);
+    });
+}
+function simplifyPaths(input, options = {}) {
+    const opts = {
+        mode: options.mode ?? "static-only",
+        tolerance: options.tolerance ?? 1.0,
+        relativeTolerance: options.relativeTolerance ?? false,
+        minPoints: options.minPoints ?? 6,
+        preserveCorners: options.preserveCorners ?? true,
+        cornerAngleDeg: options.cornerAngleDeg ?? 150,
+        algorithm: "rdp",
+        samplesPerSegment: options.samplesPerSegment ?? 10,
+        tension: options.tension ?? 1.0,
+        onLog: options.onLog ?? (()=>{})
+    };
+    const out = {
+        ...input,
+        layers: input.layers ? JSON.parse(JSON.stringify(input.layers)) : []
+    };
+    let totalPaths = 0;
+    let simplifiedPaths = 0;
+    let staticSimplified = 0;
+    let animatedSimplified = 0;
+    let totalBefore = 0;
+    let totalAfter = 0;
+    const warnings = [];
+    for (const layer of out.layers || [])if (4 === layer.ty) traverseShapes(layer.shapes, (node)=>{
+        const ks = node.ks;
+        if (!ks || !ks.k) return;
+        if (("static-only" === opts.mode || "all" === opts.mode) && 0 === ks.a) {
+            const path = ks.k;
+            totalPaths++;
+            totalBefore += path.v.length;
+            const newPath = simplifyStaticPath(path, opts);
+            node.ks.k = newPath;
+            totalAfter += newPath.v.length;
+            if (newPath !== path) {
+                simplifiedPaths++;
+                staticSimplified++;
+            }
+        }
+        if (("animated-consistent" === opts.mode || "all" === opts.mode) && 1 === ks.a) {
+            const arr = ks.k;
+            if (!Array.isArray(arr) || arr.length < 2) return;
+            if (arr.some((kf)=>!kf.s || !kf.s[0])) return void warnings.push("animated path with missing s[0] skipped");
+            totalPaths++;
+            const beforeN = arr[0].s[0].v.length;
+            totalBefore += beforeN;
+            const newArr = simplifyAnimatedConsistent(arr, opts);
+            node.ks.k = newArr;
+            const afterN = newArr[0].s[0].v.length;
+            totalAfter += afterN;
+            if (afterN < beforeN) {
+                simplifiedPaths++;
+                animatedSimplified++;
+            }
+        }
+    });
+    const avgReduction = totalBefore > 0 ? (totalBefore - totalAfter) / totalBefore * 100 : 0;
+    if (warnings.length) warnings.forEach((w)=>opts.onLog(`[simplify-paths] ${w}`));
+    opts.onLog(`[simplify-paths] paths: ${totalPaths}, simplified: ${simplifiedPaths} (static ${staticSimplified}, animated ${animatedSimplified}), avg vertex reduction: ${avgReduction.toFixed(2)}%`);
+    return {
+        data: out,
+        stats: {
+            totalPaths,
+            simplifiedPaths,
+            staticSimplified,
+            animatedSimplified,
+            avgVertexReduction: Number(avgReduction.toFixed(2)),
+            warnings
+        }
+    };
+}
+const simplifyPathsPlugin = {
+    name: 'simplify-paths',
+    description: 'Simplify Lottie path data using RDP algorithm with Catmull-Rom handle regeneration',
+    version: '1.0.0',
+    defaultOptions: {
+        mode: 'static-only',
+        tolerance: 1.0,
+        relativeTolerance: false,
+        minPoints: 6,
+        preserveCorners: true,
+        cornerAngleDeg: 150,
+        algorithm: 'rdp',
+        samplesPerSegment: 10,
+        tension: 1.0
+    },
+    async apply (data, options, context) {
+        const sizeBefore = calculateSize(data);
+        let logMessages = [];
+        const onLog = (msg)=>{
+            if (context.logger) context.logger.debug(msg);
+            logMessages.push(msg);
+        };
+        const mergedOptions = {
+            ...options,
+            onLog
+        };
+        const result = simplifyPaths(data, mergedOptions);
+        const sizeAfter = calculateSize(result.data);
+        return {
+            data: result.data,
+            changed: result.stats.simplifiedPaths > 0,
+            stats: {
+                itemsProcessed: result.stats.totalPaths,
+                itemsRemoved: result.stats.totalPaths - result.stats.simplifiedPaths,
+                sizeBefore,
+                sizeAfter
+            }
+        };
+    }
+};
+let lastRequestTime = 0;
+const MIN_REQUEST_INTERVAL = 2000;
+let isServiceUnavailable = false;
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+function getRandomIP() {
+    return Array.from(Array(4)).map(()=>Math.floor(255 * Math.random()).toString()).join('.');
+}
+async function downloadImg(url) {
+    const response = await node_fetch(url);
+    if (!response.ok) throw new Error(`Failed to download image: ${response.status} ${response.statusText}`);
+    const buffer = await response.arrayBuffer();
+    return Buffer.from(buffer);
+}
+async function compress(file) {
+    if (isServiceUnavailable) throw new Error('TinyPNG service is temporarily unavailable (marked as failed)');
+    async function attemptRequest() {
+        const now = Date.now();
+        const timeSinceLastRequest = now - lastRequestTime;
+        if (timeSinceLastRequest < MIN_REQUEST_INTERVAL) {
+            const waitTime = MIN_REQUEST_INTERVAL - timeSinceLastRequest;
+            await sleep(waitTime);
+        }
+        lastRequestTime = Date.now();
+        const response = await node_fetch('https://tinify.cn/backend/opt/shrink', {
+            method: 'POST',
+            headers: {
+                'Cache-Control': 'no-cache',
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'X-Forwarded-For': getRandomIP(),
+                'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36',
+                Referer: 'https://tinify.cn',
+                Origin: 'https://tinify.cn'
+            },
+            body: file
+        });
+        if (429 === response.status) throw new Error(`Rate limited (429): ${response.statusText}`);
+        if (!response.ok) throw new Error(`TinyPNG compression failed: ${response.status} ${response.statusText}`);
+        const result = await response.json();
+        if (!result?.output?.url) throw new Error('TinyPNG response missing download URL');
+        const compressedBuffer = await downloadImg(result.output.url);
+        return [
+            compressedBuffer,
+            'png'
+        ];
+    }
+    try {
+        return await attemptRequest();
+    } catch (error) {
+        const errorMessage = error.message;
+        if (errorMessage.includes('Rate limited (429)')) {
+            console.log('TinyPNG rate limited, waiting 5s before retry...');
+            await sleep(5000);
+            try {
+                return await attemptRequest();
+            } catch (retryError) {
+                isServiceUnavailable = true;
+                console.log('TinyPNG service marked as unavailable after retry failure');
+                throw new Error(`TinyPNG failed after retry: ${retryError.message}`);
+            }
+        }
+        throw error;
+    }
+}
+let NosClient = null;
+async function loadNosClient() {
+    if (NosClient) return NosClient;
+    try {
+        const sdk = await import("@nos-sdk/nos-node-sdk");
+        NosClient = sdk.NosClient;
+        return NosClient;
+    } catch (error) {
+        throw new Error("NOS SDK \u672A\u5B89\u88C5\uFF0C\u8BF7\u5148\u5B89\u88C5 @nos-sdk/nos-node-sdk");
+    }
+}
+const NOS_CONF_PATH = node_path.resolve(node_os.homedir(), ".nos-conf", "config.json");
+class NOSConf {
+    constructor(){
+        this.nconf = nconf;
+        this.nconf.env().file({
+            file: NOS_CONF_PATH
+        });
+        NOSConf.init();
+    }
+    static init() {
+        const dirPath = node_path.dirname(NOS_CONF_PATH);
+        node_fs.mkdirSync(dirPath, {
+            recursive: true
+        });
+    }
+    getConfig() {
+        return {
+            accessKey: this.nconf.get("accessKey"),
+            accessSecret: this.nconf.get("accessSecret"),
+            endpoint: this.nconf.get("endpoint"),
+            defaultBucket: this.nconf.get("defaultBucket"),
+            host: this.nconf.get("host"),
+            protocol: this.nconf.get("protocol")
+        };
+    }
+    setConfig(config) {
+        if (config.accessKey) this.nconf.set("accessKey", config.accessKey);
+        if (config.accessSecret) this.nconf.set("accessSecret", config.accessSecret);
+        if (config.endpoint) this.nconf.set("endpoint", config.endpoint);
+        if (config.defaultBucket) this.nconf.set("defaultBucket", config.defaultBucket);
+        if (config.host) this.nconf.set("host", config.host);
+        if (config.protocol) this.nconf.set("protocol", config.protocol);
+        this.nconf.save(void 0);
+    }
+    reset() {
+        this.nconf.reset();
+        this.nconf.save(void 0);
+    }
+}
+const nosConf = new NOSConf();
+let client = null;
+const upload = async (file)=>{
+    if (!client) {
+        const NosClientClass = await loadNosClient();
+        client = new NosClientClass(nosConf.getConfig());
+    }
+    await client.putObject({
+        objectKey: file.name,
+        body: file.data
+    });
+    const fileUrl = `${nosConf.getConfig().endpoint}/${file.name}`;
+    return fileUrl;
+};
+async function uploadToCDN(buffer, fileName, config, assetId) {
+    if (!config.enabled) throw new Error("CDN \u4E0A\u4F20\u672A\u542F\u7528");
+    const timestamp = new Date().getTime();
+    const finalFileName = config.generateFileName ? config.generateFileName(fileName, assetId, timestamp) : `${config.prefix || "lottie-assets"}/${timestamp}/${fileName}`;
+    return await upload({
+        data: buffer,
+        name: finalFileName
+    });
+}
+var external_sharp_ = __webpack_require__("sharp");
+var external_sharp_default = /*#__PURE__*/ __webpack_require__.n(external_sharp_);
+const external_ssim_js_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("ssim.js");
+var external_ssim_js_default = /*#__PURE__*/ __webpack_require__.n(external_ssim_js_namespaceObject);
+const DEFAULT_LEVEL = "standard";
+const LEVEL_THRESHOLDS = {
+    mild: 0.995,
+    standard: 0.990,
+    aggressive: 0.975
+};
+const PRESETS = {
+    mild: {
+        webpQ: 90,
+        webpNearQ: 85,
+        alphaQ: 90,
+        pngQ: 100,
+        jpegQ: 86
+    },
+    standard: {
+        webpQ: 85,
+        webpNearQ: 72,
+        alphaQ: 85,
+        pngQ: 100,
+        jpegQ: 82
+    },
+    aggressive: {
+        webpQ: 70,
+        webpNearQ: 68,
+        alphaQ: 80,
+        pngQ: 100,
+        jpegQ: 78
+    }
+};
+async function compressImage(input, options = {}) {
+    const level = options.level ?? DEFAULT_LEVEL;
+    const threshold = options.ssimThreshold ?? LEVEL_THRESHOLDS[level];
+    const allow = new Set(options.allowFormats ?? [
+        "png",
+        "webp-lossy",
+        "webp-near",
+        "jpeg"
+    ]);
+    const forceEffort = options.forceEffort;
+    const base = external_sharp_default()(input, {
+        limitInputPixels: false
+    });
+    const meta = await base.metadata();
+    const hasAlpha = Boolean(meta.hasAlpha || meta.channels && meta.channels >= 4);
+    const candidates = await buildCandidates(base, hasAlpha, level, allow, forceEffort);
+    const tried = [];
+    for (const c of candidates){
+        const buf = await c.encode();
+        const s = await calcSSIM(input, buf);
+        tried.push({
+            format: c.outFormat,
+            variant: c.variant,
+            label: c.label,
+            bytes: buf.byteLength,
+            ssim: s,
+            buffer: buf
+        });
+    }
+    const pick = tried.sort((a, b)=>a.bytes - b.bytes)[0];
+    return {
+        ...pick,
+        level,
+        threshold,
+        hasAlpha,
+        tried
+    };
+}
+async function buildCandidates(base, hasAlpha, level, allow, forceEffort) {
+    const list = [];
+    const p = PRESETS[level];
+    const pngEffort = forceEffort ?? 10;
+    const webpEffort = forceEffort ?? 6;
+    if (allow.has("png")) list.push({
+        variant: "png8",
+        outFormat: "png",
+        label: `png8 q${p.pngQ} e${pngEffort}`,
+        encode: ()=>base.clone().png({
+                palette: true,
+                quality: p.pngQ,
+                compressionLevel: 9,
+                effort: pngEffort,
+                progressive: false
+            }).toBuffer()
+    });
+    if (allow.has("webp-lossy")) list.push({
+        variant: "webp-lossy",
+        outFormat: "webp",
+        label: `webp-lossy q${p.webpQ}${hasAlpha ? ` aq${p.alphaQ}` : ""} e${webpEffort}`,
+        encode: ()=>base.clone().webp({
+                quality: p.webpQ,
+                alphaQuality: hasAlpha ? p.alphaQ : void 0,
+                effort: webpEffort,
+                smartSubsample: true
+            }).toBuffer()
+    });
+    if (allow.has("webp-near")) list.push({
+        variant: "webp-near",
+        outFormat: "webp",
+        label: `webp-nearLossless q${p.webpNearQ} e${webpEffort}`,
+        encode: ()=>base.clone().webp({
+                nearLossless: true,
+                quality: p.webpNearQ,
+                effort: webpEffort
+            }).toBuffer()
+    });
+    if (!hasAlpha && allow.has("jpeg")) list.push({
+        variant: "jpeg",
+        outFormat: "jpeg",
+        label: `jpeg q${p.jpegQ} mozjpeg`,
+        encode: ()=>base.clone().jpeg({
+                quality: p.jpegQ,
+                mozjpeg: true,
+                progressive: true
+            }).toBuffer()
+    });
+    return list;
+}
+async function calcSSIM(orig, cand) {
+    const origSharp = external_sharp_default()(orig);
+    const candSharp = external_sharp_default()(cand);
+    const origMeta = await origSharp.metadata();
+    const { width, height } = origMeta;
+    if (!width || !height) throw new Error("Unable to get image dimensions");
+    const origRawData = await origSharp.resize(width, height).ensureAlpha().raw().toBuffer();
+    const candRawData = await candSharp.resize(width, height).ensureAlpha().raw().toBuffer();
+    const origImageData = {
+        data: new Uint8ClampedArray(origRawData),
+        width,
+        height
+    };
+    const candImageData = {
+        data: new Uint8ClampedArray(candRawData),
+        width,
+        height
+    };
+    const { mssim } = external_ssim_js_default()(origImageData, candImageData, {
+        ssim: "original",
+        downsample: "original",
+        windowSize: 11,
+        bitDepth: 8
+    });
+    return "number" == typeof mssim ? mssim : 0;
+}
+function isDataURL(s) {
+    return !!s && /^data:image\/[^;]+;base64,/.test(s);
+}
+function parseDataURL(s) {
+    const [h, b] = s.split(",", 2);
+    const mime = h.slice(5, h.indexOf(";"));
+    return {
+        mime,
+        buf: Buffer.from(b, "base64")
+    };
+}
+function mimeFromExt(ext) {
+    ext = ext.toLowerCase();
+    if ("png" === ext) return "image/png";
+    if ("jpg" === ext || "jpeg" === ext) return "image/jpeg";
+    if ("webp" === ext) return "image/webp";
+    if ("avif" === ext) return "image/avif";
+    if ("gif" === ext) return "image/gif";
+    if ("svg" === ext) return "image/svg+xml";
+    return "application/octet-stream";
+}
+function extFromMime(m) {
+    m = m.toLowerCase();
+    if (m.includes("png")) return "png";
+    if (m.includes("jpeg")) return "jpg";
+    if (m.includes("webp")) return "webp";
+    if (m.includes("avif")) return "avif";
+    if (m.includes("gif")) return "gif";
+    if (m.includes("svg")) return "svg";
+    return "bin";
+}
+function toDataURL(mime, buf) {
+    return `data:${mime};base64,` + buf.toString("base64");
+}
+function hash(buf) {
+    let h = 2166136261;
+    for(let i = 0; i < buf.length; i++){
+        h ^= buf[i];
+        h = Math.imul(h, 16777619);
+    }
+    return (h >>> 0).toString(16);
+}
+async function loadSharp() {
+    try {
+        return __webpack_require__("sharp");
+    } catch  {
+        return null;
+    }
+}
+function estimateMaxScale(json) {
+    const m = new Map();
+    for (const ly of json.layers || []){
+        if (ly?.ty !== 2) continue;
+        const id = ly.refId;
+        if (!id) continue;
+        let mx = 100;
+        const s = ly.ks?.s;
+        if (s?.a === 0 && Array.isArray(s.k)) mx = Math.max(mx, s.k[0] ?? 100, s.k[1] ?? 100);
+        else if (s?.a === 1 && Array.isArray(s.k)) for (const kf of s.k){
+            const arr = kf?.s ?? kf?.e;
+            if (Array.isArray(arr)) mx = Math.max(mx, arr[0] ?? 100, arr[1] ?? 100);
+        }
+        m.set(id, Math.max(m.get(id) ?? 100, mx));
+    }
+    return m;
+}
+async function compressImages(input, opt = {}) {
+    const log = opt.onLog ?? (()=>{});
+    const safeOpt = {
+        ...opt
+    };
+    delete safeOpt.onLog;
+    log('Plugin configuration: ' + JSON.stringify(safeOpt, null, 2));
+    const sharp = await loadSharp();
+    log('Sharp library loaded: ' + !!sharp);
+    if (!sharp) {
+        const warn = "[compress-images] \u672A\u5B89\u88C5 sharp\uFF0C\u8DF3\u8FC7\u538B\u7F29";
+        log(warn);
+        return {
+            data: input,
+            stats: {
+                total: 0,
+                optimized: 0,
+                before: 0,
+                after: 0,
+                saved: 0,
+                savedPct: 0,
+                perAsset: [],
+                warnings: [
+                    warn
+                ]
+            }
+        };
+    }
+    const cfg = {
+        enableWebp: opt.enableWebp ?? true,
+        enableAvif: opt.enableAvif ?? false,
+        quality: opt.quality ?? "balanced",
+        longEdge: opt.longEdge ?? 0,
+        embed: opt.embed ?? true,
+        baseDir: opt.baseDir ?? process.cwd(),
+        outDir: opt.outDir ?? node_path.join(process.cwd(), "lottie-assets"),
+        useTinyPNG: opt.useTinyPNG ?? false,
+        ssimOptions: opt.ssimOptions ?? {
+            level: "standard"
+        }
+    };
+    if (!cfg.embed && !node_fs.existsSync(cfg.outDir)) node_fs.mkdirSync(cfg.outDir, {
+        recursive: true
+    });
+    const out = JSON.parse(JSON.stringify(input));
+    const stats = {
+        total: 0,
+        optimized: 0,
+        before: 0,
+        after: 0,
+        saved: 0,
+        savedPct: 0,
+        perAsset: [],
+        warnings: []
+    };
+    const maxScale = estimateMaxScale(input);
+    if (!Array.isArray(out.assets)) return {
+        data: out,
+        stats
+    };
+    for (const a of out.assets){
+        const src = a?.p;
+        if (!src) continue;
+        let buf, mime = "", ext = "";
+        try {
+            if (isDataURL(src)) {
+                const p = parseDataURL(src);
+                buf = p.buf;
+                mime = p.mime;
+                ext = extFromMime(mime);
+            } else {
+                const full = node_path.join(cfg.baseDir, a.u ?? "", src);
+                if (!node_fs.existsSync(full)) continue;
+                buf = node_fs.readFileSync(full);
+                ext = node_path.extname(src).slice(1).toLowerCase();
+                mime = mimeFromExt(ext);
+            }
+        } catch (e) {
+            stats.warnings.push(`[compress-images] \u{8BFB}\u{53D6}\u{5931}\u{8D25} ${a.id ?? ""}: ${e.message}`);
+            continue;
+        }
+        if (!buf || /svg|gif/.test(ext) || /svg|gif/.test(mime)) {
+            log(`Skipping asset ${a.id}: unsupported format (${ext}/${mime})`);
+            continue;
+        }
+        if (buf.byteLength < 4096) {
+            log(`Skipping asset ${a.id}: file too small (${buf.byteLength} bytes < 4096 bytes threshold)`);
+            continue;
+        }
+        stats.total++;
+        stats.before += buf.byteLength;
+        let originalBuf = buf;
+        let originalExt = ext;
+        let originalMime = mime;
+        try {
+            if (cfg.useTinyPNG) {
+                const fileSizeKB = buf.byteLength / 1024;
+                try {
+                    log(`Using TinyPNG for asset ${a.id} (${Math.round(fileSizeKB)}KB)`);
+                    const [tinyPngBuf, tinyPngExt] = await compress(buf);
+                    log(`TinyPNG compressed: ${Math.round(buf.byteLength / 1024)}KB -> ${Math.round(tinyPngBuf.byteLength / 1024)}KB`);
+                    buf = tinyPngBuf;
+                    ext = tinyPngExt;
+                    mime = mimeFromExt(ext);
+                    originalBuf = buf;
+                    originalExt = ext;
+                    originalMime = mime;
+                } catch (tinyError) {
+                    log(`TinyPNG failed for asset ${a.id}: ${tinyError.message}, falling back to original`);
+                    stats.warnings.push(`[compress-images] TinyPNG \u{5931}\u{8D25} ${a.id ?? ""}: ${tinyError.message}, \u{4F7F}\u{7528}\u{539F}\u{59CB}\u{56FE}\u{7247}`);
+                }
+            }
+            const meta = await sharp(buf).metadata();
+            const hasAlpha = !!meta.hasAlpha;
+            let W = meta.width || 0, H = meta.height || 0;
+            if (cfg.longEdge && Math.max(W, H) > cfg.longEdge) {
+                const s = cfg.longEdge / Math.max(W, H);
+                W = Math.round(W * s);
+                H = Math.round(H * s);
+            }
+            const ms = maxScale.get(a.id || "") ?? 100;
+            if (ms > 100 && meta.width && meta.height) {
+                const minW = Math.round(meta.width * ms / 100), minH = Math.round(meta.height * ms / 100);
+                W = Math.max(W, Math.min(minW, meta.width));
+                H = Math.max(H, Math.min(minH, meta.height));
+            }
+            log(`Using SSIM compression algorithm for asset ${a.id} (level: ${cfg.ssimOptions.level})`);
+            const ssimOptions = {
+                level: cfg.ssimOptions.level,
+                ssimThreshold: cfg.ssimOptions.ssimThreshold,
+                allowFormats: [],
+                fallbackToBestSSIM: cfg.ssimOptions.fallbackToBestSSIM,
+                forceEffort: cfg.ssimOptions.forceEffort
+            };
+            if (cfg.enableWebp) ssimOptions.allowFormats.push("webp-lossy", "webp-near");
+            if (!hasAlpha) ssimOptions.allowFormats.push("jpeg");
+            ssimOptions.allowFormats.push("png");
+            let resizedBuf = buf;
+            if (W && H && (W < (meta.width || 0) || H < (meta.height || 0))) {
+                resizedBuf = await sharp(buf).rotate().withMetadata({
+                    exif: void 0,
+                    icc: void 0
+                }).resize(W, H, {
+                    fit: "inside",
+                    withoutEnlargement: true
+                }).png().toBuffer();
+                log(`Resized image from ${meta.width}x${meta.height} to ${W}x${H}`);
+            }
+            const ssimResult = await compressImage(resizedBuf, ssimOptions);
+            const useOriginal = ssimResult.bytes >= originalBuf.byteLength;
+            let finalBuf, finalExt, finalMime, finalBytes;
+            let finalSSIM;
+            let resized = !!(W && H && (W < (meta.width || 0) || H < (meta.height || 0)));
+            if (useOriginal) {
+                log(`SSIM compressed result (${Math.round(ssimResult.bytes / 1024)}KB, SSIM: ${ssimResult.ssim.toFixed(3)}) is not better than original (${Math.round(originalBuf.byteLength / 1024)}KB), using original`);
+                finalBuf = originalBuf;
+                finalExt = originalExt;
+                finalMime = originalMime;
+                finalBytes = originalBuf.byteLength;
+                finalSSIM = 1.0;
+                resized = false;
+            } else {
+                log(`SSIM result: ${ssimResult.label} - ${Math.round(ssimResult.bytes / 1024)}KB (SSIM: ${ssimResult.ssim.toFixed(3)}, threshold: ${ssimResult.threshold})`);
+                finalBuf = ssimResult.buffer;
+                finalExt = "jpeg" === ssimResult.format ? "jpg" : ssimResult.format;
+                finalMime = mimeFromExt(finalExt);
+                finalBytes = ssimResult.bytes;
+                finalSSIM = ssimResult.ssim;
+            }
+            if (cfg.embed) {
+                a.u = "";
+                a.p = toDataURL(finalMime, finalBuf);
+                a.e = 1;
+                if (useOriginal) {
+                    a.w = a.w;
+                    a.h = a.h;
+                } else {
+                    a.w = W || meta.width || a.w;
+                    a.h = H || meta.height || a.h;
+                }
+            } else {
+                const baseName = a.id ? `${a.id}.${finalExt}` : `${hash(finalBuf)}.${finalExt}`;
+                if (opt.cdn?.enabled) try {
+                    log(`Uploading asset ${a.id} to CDN...`);
+                    const cdnUrl = await uploadToCDN(finalBuf, baseName, opt.cdn, a.id);
+                    log(`Asset ${a.id} uploaded to CDN: ${cdnUrl}`);
+                    a.u = "";
+                    a.p = cdnUrl;
+                    a.e = 0;
+                } catch (cdnError) {
+                    log(`CDN upload failed for asset ${a.id}: ${cdnError.message}, falling back to local file`);
+                    stats.warnings.push(`[compress-images] CDN \u{4E0A}\u{4F20}\u{5931}\u{8D25} ${a.id ?? ""}: ${cdnError.message}, \u{4F7F}\u{7528}\u{672C}\u{5730}\u{6587}\u{4EF6}`);
+                    const outPath = node_path.join(cfg.outDir, baseName);
+                    node_fs.writeFileSync(outPath, finalBuf);
+                    a.u = node_path.relative(cfg.baseDir, cfg.outDir).replace(/\\/g, "/") + "/";
+                    a.p = baseName;
+                    a.e = 0;
+                }
+                else {
+                    const outPath = node_path.join(cfg.outDir, baseName);
+                    node_fs.writeFileSync(outPath, finalBuf);
+                    a.u = node_path.relative(cfg.baseDir, cfg.outDir).replace(/\\/g, "/") + "/";
+                    a.p = baseName;
+                    a.e = 0;
+                }
+                if (useOriginal) {
+                    a.w = a.w;
+                    a.h = a.h;
+                } else {
+                    a.w = W || meta.width || a.w;
+                    a.h = H || meta.height || a.h;
+                }
+            }
+            stats.optimized++;
+            stats.after += finalBytes;
+            stats.perAsset.push({
+                id: a.id,
+                from: useOriginal ? originalExt : extFromMime(mime),
+                to: finalExt,
+                orig: originalBuf.byteLength,
+                out: finalBytes,
+                ssim: finalSSIM,
+                resized: useOriginal ? false : resized
+            });
+        } catch (e) {
+            stats.after += buf.byteLength;
+            stats.perAsset.push({
+                id: a.id,
+                from: extFromMime(mime),
+                to: extFromMime(mime),
+                orig: buf.byteLength,
+                out: buf.byteLength
+            });
+            stats.warnings.push(`[compress-images] \u{5904}\u{7406}\u{5931}\u{8D25} ${a.id ?? ""}: ${e.message}`);
+        }
+    }
+    stats.saved = Math.max(0, stats.before - stats.after);
+    stats.savedPct = stats.before ? +(stats.saved / stats.before * 100).toFixed(2) : 0;
+    return {
+        data: out,
+        stats
+    };
+}
+const compressImagesPlugin = {
+    name: 'compress-images',
+    description: 'Optimize Lottie image assets with simplified options: WebP/AVIF toggle, quality presets, and smart resizing',
+    version: '2.0.0',
+    defaultOptions: {
+        enableWebp: true,
+        enableAvif: false,
+        quality: 'balanced',
+        longEdge: 0,
+        embed: true,
+        baseDir: process.cwd(),
+        outDir: 'lottie-assets',
+        useTinyPNG: false,
+        cdn: {
+            enabled: false,
+            prefix: 'lottie-assets'
+        },
+        ssimOptions: {
+            level: 'standard'
+        }
+    },
+    async apply (data, options, context) {
+        const sizeBefore = calculateSize(data);
+        const pluginOptions = {
+            ...options,
+            onLog: (msg)=>{
+                if (context.logger) context.logger.info(`[compress-images] ${msg}`);
+            }
+        };
+        const result = await compressImages(data, pluginOptions);
+        const sizeAfter = calculateSize(result.data);
+        return {
+            data: result.data,
+            changed: result.stats.optimized > 0,
+            stats: {
+                itemsProcessed: result.stats.total,
+                itemsRemoved: 0,
+                sizeBefore,
+                sizeAfter
+            },
+            warnings: result.stats.warnings
+        };
+    }
+};
+const DEFAULT_OPTIONS = {
+    keepMatchName: true,
+    keepIds: false,
+    mergeNearbyNumbers: false,
+    markTiny: false,
+    precisionTargetKeys: [
+        't',
+        'sr',
+        'to',
+        'ti',
+        'color',
+        'ip',
+        'op',
+        'st',
+        's',
+        'e'
+    ],
+    frameKeyDigits: 0,
+    normalKeyDigits: 3,
+    mergeStep: 0.001,
+    colorQuantizePrecision: 255,
+    roundThreshold: 0.01,
+    removeMetadataKeys: true,
+    enableGlobalPrecision: true,
+    globalMaxDecimals: 3,
+    compressNames: true,
+    removeDefaultValues: true,
+    customMetadataKeys: [],
+    customDefaultValues: {},
+    onLog: ()=>{}
+};
+function deepClone(x) {
+    return JSON.parse(JSON.stringify(x));
+}
+function toBase36(n) {
+    const chars = '0123456789abcdefghijklmnopqrstuvwxyz';
+    if (0 === n) return '0';
+    let q = Math.floor(Math.abs(n));
+    let out = '';
+    while(q > 0){
+        const m = q % 36;
+        out = chars[m] + out;
+        q = (q - m) / 36;
+    }
+    return out;
+}
+function walk(obj, visit) {
+    const go = (node, key, parent)=>{
+        visit(node, key, parent);
+        if (!node || 'object' != typeof node) return;
+        if (Array.isArray(node)) {
+            for(let i = 0; i < node.length; i++)go(node[i], String(i), node);
+            return;
+        }
+        for (const k of Object.keys(node))go(node[k], k, node);
+    };
+    go(obj, null, null);
+}
+function roundNearInteger(v, eps = 0.01) {
+    const r = Math.round(v);
+    return Math.abs(v - r) <= eps ? r : v;
+}
+function roundTo(num, digits) {
+    const f = Math.pow(10, digits);
+    return Math.round(num * f) / f;
+}
+function quantize255(x, precision = 255) {
+    const snapped = Math.round(x * precision) / precision;
+    return roundTo(snapped, 3);
+}
+function applyMarkAndRound(json, mark, roundThreshold) {
+    let marked = false;
+    let rounded = 0;
+    if (void 0 !== mark) {
+        json.tiny = 'number' == typeof mark ? mark : 1;
+        marked = true;
+    }
+    if ('number' == typeof json.fr) {
+        const oldFr = json.fr;
+        json.fr = roundNearInteger(json.fr, roundThreshold);
+        if (oldFr !== json.fr) rounded++;
+    }
+    if ('number' == typeof json.op) {
+        const oldOp = json.op;
+        json.op = roundNearInteger(json.op, roundThreshold);
+        if (oldOp !== json.op) rounded++;
+    }
+    return {
+        marked,
+        rounded
+    };
+}
+function shortenIdRef(json) {
+    const ids = [];
+    walk(json, (node, key)=>{
+        if (!key || 'object' != typeof node) return;
+        const v = node.id;
+        if ('string' == typeof v) ids.push(v);
+    });
+    const uniq = Array.from(new Set(ids));
+    const map = {};
+    uniq.forEach((v, i)=>map[v] = toBase36(i));
+    let shortened = 0;
+    walk(json, (node, key)=>{
+        if (!key || 'object' != typeof node) return;
+        const o = node;
+        if ('string' == typeof o.id && map[o.id]) {
+            o.id = map[o.id];
+            shortened++;
+        }
+        if ('string' == typeof o.refId && map[o.refId]) {
+            o.refId = map[o.refId];
+            shortened++;
+        }
+    });
+    return shortened;
+}
+function applyNumericPrecision(json, targetKeys, frameKeyDigits, normalKeyDigits, colorPrecision) {
+    const TARGET_KEYS = new Set(targetKeys);
+    let processed = 0;
+    const walkWithParentKey = (obj, parentKey)=>{
+        if (!obj || 'object' != typeof obj) return;
+        if (Array.isArray(obj)) {
+            for(let i = 0; i < obj.length; i++)walkWithParentKey(obj[i], null);
+            return;
+        }
+        for (const k of Object.keys(obj)){
+            const val = obj[k];
+            if ('k' === k && ('c' === parentKey || 'v' === parentKey) && Array.isArray(val)) {
+                for(let i = 0; i < val.length; i++)if ('number' == typeof val[i]) {
+                    val[i] = quantize255(val[i], colorPrecision);
+                    processed++;
+                }
+            }
+            if (TARGET_KEYS.has(k)) {
+                if ('number' == typeof val) {
+                    const digits = 'ip' === k || 'op' === k ? frameKeyDigits : normalKeyDigits;
+                    obj[k] = roundTo(val, digits);
+                    processed++;
+                } else if (Array.isArray(val)) {
+                    const digits = 'ip' === k || 'op' === k ? frameKeyDigits : normalKeyDigits;
+                    obj[k] = val.map((x)=>{
+                        if ('number' == typeof x) {
+                            processed++;
+                            return roundTo(x, digits);
+                        }
+                        return x;
+                    });
+                }
+            }
+            walkWithParentKey(val, k);
+        }
+    };
+    walkWithParentKey(json, null);
+    return processed;
+}
+function applyGlobalPrecision(json, enabled, maxDecimals) {
+    if (!enabled) return 0;
+    let processed = 0;
+    walk(json, (node, key, parent)=>{
+        if (!key || !parent || 'object' != typeof parent) return;
+        const val = parent[key];
+        if ('number' == typeof val && !Number.isInteger(val)) {
+            const str = val.toString();
+            const decimalIndex = str.indexOf('.');
+            if (-1 !== decimalIndex && str.length - decimalIndex - 1 > maxDecimals) {
+                parent[key] = roundTo(val, maxDecimals);
+                processed++;
+            }
+        }
+    });
+    return processed;
+}
+function removeMetadataKeys(json, shouldRemove, keepMatchName, customKeys = []) {
+    const baseKeys = [
+        'n'
+    ];
+    if (!keepMatchName) baseKeys.push('mn');
+    const metadataKeys = shouldRemove ? [
+        'ix',
+        'bm',
+        'ddd',
+        'np',
+        'cix'
+    ] : [];
+    const DELETE_KEYS = new Set([
+        ...baseKeys,
+        ...metadataKeys,
+        ...customKeys
+    ]);
+    let deleted = 0;
+    walk(json, (node, key, parent)=>{
+        if (!key || !parent || 'object' != typeof parent) return;
+        if (DELETE_KEYS.has(key)) {
+            delete parent[key];
+            deleted++;
+        }
+    });
+    return deleted;
+}
+function removeDefaultValues(json, shouldRemove, customDefaults = {}) {
+    if (!shouldRemove) return {
+        defaultValuesRemoved: 0,
+        hiddenFalseRemoved: 0
+    };
+    const defaultValueMap = {
+        bm: 0,
+        ddd: 0,
+        ao: 0,
+        sr: 1,
+        ks: null,
+        ...customDefaults
+    };
+    let defaultValuesRemoved = 0;
+    let hiddenFalseRemoved = 0;
+    walk(json, (node, key, parent)=>{
+        if (!key || !parent || 'object' != typeof parent) return;
+        const val = parent[key];
+        if (key in defaultValueMap && val === defaultValueMap[key]) {
+            delete parent[key];
+            defaultValuesRemoved++;
+        }
+        if ('hd' === key && false === val) {
+            delete parent[key];
+            hiddenFalseRemoved++;
+        }
+    });
+    return {
+        defaultValuesRemoved,
+        hiddenFalseRemoved
+    };
+}
+function compressNames(json, shouldCompress) {
+    if (!shouldCompress) return 0;
+    const names = [];
+    walk(json, (node, key)=>{
+        if ('nm' === key && 'string' == typeof node && node.length > 1) names.push(node);
+    });
+    const uniqueNames = Array.from(new Set(names));
+    const compressChars = "\u4FEE\u63CF\u586B\u53D8\u5F62\u72B6\u52A8\u753B\u56FE\u5C42\u6548\u679C\u906E\u7F69\u8DEF\u5F84\u6587\u5B57\u989C\u8272\u9634\u5F71\u53D1\u5149\u5916\u8FB9\u5185\u8FB9\u9AD8\u4EAE\u4E2D";
+    const nameMap = {};
+    uniqueNames.forEach((name, index)=>{
+        if (index < compressChars.length) nameMap[name] = compressChars[index];
+        else nameMap[name] = String(index - compressChars.length);
+    });
+    let compressed = 0;
+    walk(json, (node, key, parent)=>{
+        if (!key || !parent || 'object' != typeof parent) return;
+        if ('nm' === key && 'string' == typeof node && nameMap[node]) {
+            parent[key] = nameMap[node];
+            compressed++;
+        }
+    });
+    return compressed;
+}
+function mergeNearbyNumbers(json, step) {
+    const nums = [];
+    walk(json, (node)=>{
+        if ('number' == typeof node) nums.push(node);
+    });
+    const uniq = Array.from(new Set(nums)).sort((a, b)=>a - b);
+    const groups = [];
+    let g = [];
+    const isStep = (a, b)=>Number((b - a).toFixed(10)) === Number(step.toFixed(10));
+    for(let i = 0; i < uniq.length; i++){
+        const cur = uniq[i];
+        const nxt = uniq[i + 1];
+        if (void 0 !== nxt && isStep(cur, nxt)) {
+            if (0 === g.length) g.push(cur);
+            g.push(nxt);
+        } else if (g.length > 0) {
+            groups.push(g.slice());
+            g = [];
+        }
+    }
+    const replace = new Map();
+    for (const arr of groups)for(let i = 1; i < arr.length; i += 2){
+        const a = arr[i - 1], b = arr[i];
+        const sa = String(a), sb = String(b);
+        if (sa.length <= sb.length) replace.set(b, a);
+        else replace.set(a, b);
+    }
+    if (0 === replace.size) return 0;
+    let merged = 0;
+    walk(json, (node, key, parent)=>{
+        if (!key || !parent) return;
+        const v = parent[key];
+        if ('number' == typeof v && replace.has(v)) {
+            parent[key] = replace.get(v);
+            merged++;
+        }
+    });
+    return merged;
+}
+function fixMissingInd(json) {
+    let fixed = 0;
+    const patch = (layers)=>{
+        if (!Array.isArray(layers)) return;
+        for(let i = 0; i < layers.length; i++){
+            const lyr = layers[i];
+            if (lyr && (void 0 === lyr.ind || null === lyr.ind)) {
+                lyr.ind = i + 1;
+                fixed++;
+            }
+        }
+    };
+    patch(json.layers);
+    if (Array.isArray(json.assets)) for (const a of json.assets)patch(a.layers);
+    return fixed;
+}
+function countLayersAndAssets(json) {
+    let layers = 0;
+    let assets = 0;
+    if (Array.isArray(json.layers)) layers += json.layers.length;
+    if (Array.isArray(json.assets)) {
+        assets += json.assets.length;
+        for (const asset of json.assets)if (Array.isArray(asset.layers)) layers += asset.layers.length;
+    }
+    return {
+        layers,
+        assets
+    };
+}
+function minifyLottieJson(input, options = {}) {
+    const opts = {
+        ...DEFAULT_OPTIONS,
+        ...options
+    };
+    const { onLog } = opts;
+    const json = deepClone(input);
+    const originalSize = JSON.stringify(json).length;
+    const { layers: layersCount, assets: assetsCount } = countLayersAndAssets(json);
+    let idsShortened = 0;
+    let numbersPrecisionReduced = 0;
+    let nearbyNumbersMerged = 0;
+    let missingIndicesFixed = 0;
+    let metadataKeysRemoved = 0;
+    let globalPrecisionProcessed = 0;
+    let namesCompressed = 0;
+    let defaultValuesRemoved = 0;
+    let hiddenFalseRemoved = 0;
+    applyMarkAndRound(json, opts.markTiny, opts.roundThreshold);
+    if (!opts.keepIds) idsShortened = shortenIdRef(json);
+    numbersPrecisionReduced = applyNumericPrecision(json, opts.precisionTargetKeys, opts.frameKeyDigits, opts.normalKeyDigits, opts.colorQuantizePrecision);
+    globalPrecisionProcessed = applyGlobalPrecision(json, opts.enableGlobalPrecision, opts.globalMaxDecimals);
+    metadataKeysRemoved = removeMetadataKeys(json, opts.removeMetadataKeys, opts.keepMatchName, opts.customMetadataKeys);
+    const defaultResult = removeDefaultValues(json, opts.removeDefaultValues, opts.customDefaultValues);
+    defaultValuesRemoved = defaultResult.defaultValuesRemoved;
+    hiddenFalseRemoved = defaultResult.hiddenFalseRemoved;
+    if (opts.compressNames) namesCompressed = compressNames(json, opts.compressNames);
+    if (opts.mergeNearbyNumbers) nearbyNumbersMerged = mergeNearbyNumbers(json, opts.mergeStep);
+    missingIndicesFixed = fixMissingInd(json);
+    const minifiedSize = JSON.stringify(json).length;
+    const savedBytes = originalSize - minifiedSize;
+    const compressionRatio = originalSize > 0 ? 1 - minifiedSize / originalSize : 0;
+    const stats = {
+        totalItems: layersCount + assetsCount,
+        processedItems: layersCount + assetsCount,
+        warnings: [],
+        originalSize,
+        minifiedSize,
+        compressionRatio,
+        savedBytes,
+        layersProcessed: layersCount,
+        assetsProcessed: assetsCount,
+        idsShortened,
+        numbersPrecisionReduced,
+        attributesRemoved: metadataKeysRemoved,
+        nearbyNumbersMerged,
+        missingIndicesFixed,
+        metadataKeysRemoved,
+        globalPrecisionProcessed,
+        namesCompressed,
+        defaultValuesRemoved,
+        hiddenFalseRemoved
+    };
+    return {
+        data: json,
+        stats
+    };
+}
+const minifyJsonPlugin = {
+    name: 'minify-json',
+    description: 'Optimize Lottie JSON structure: round frame rates, quantize colors, reduce precision, shorten IDs, remove redundant fields',
+    version: '1.0.0',
+    defaultOptions: {
+        keepMatchName: true,
+        keepIds: false,
+        mergeNearbyNumbers: false,
+        markTiny: false,
+        precisionTargetKeys: [
+            't',
+            'sr',
+            'to',
+            'ti',
+            'color',
+            'ip',
+            'op',
+            'st',
+            's',
+            'e'
+        ],
+        frameKeyDigits: 0,
+        normalKeyDigits: 3,
+        mergeStep: 0.001,
+        colorQuantizePrecision: 255,
+        roundThreshold: 0.01,
+        removeMetadataKeys: true,
+        enableGlobalPrecision: true,
+        globalMaxDecimals: 3,
+        compressNames: true,
+        removeDefaultValues: true,
+        customMetadataKeys: [],
+        customDefaultValues: {}
+    },
+    async apply (data, options, context) {
+        const sizeBefore = calculateSize(data);
+        const pluginOptions = {
+            ...options,
+            onLog: (msg)=>{
+                if (context.logger) context.logger.info(`[minify-json] ${msg}`);
+            }
+        };
+        const result = minifyLottieJson(data, pluginOptions);
+        const sizeAfter = calculateSize(result.data);
+        const warnings = [];
+        if (pluginOptions.mergeNearbyNumbers && result.stats.nearbyNumbersMerged > 0) warnings.push(`\u{6FC0}\u{8FDB}\u{4F18}\u{5316}\u{FF1A}\u{5408}\u{5E76}\u{4E86} ${result.stats.nearbyNumbersMerged} \u{4E2A}\u{76F8}\u{90BB}\u{6570}\u{503C}\u{FF0C}\u{53EF}\u{80FD}\u{5F15}\u{5165}\u{8F7B}\u{5FAE}\u{6570}\u{503C}\u{6270}\u{52A8}`);
+        if (!pluginOptions.keepMatchName && result.stats.attributesRemoved > 0) warnings.push("\u5DF2\u5220\u9664 matchName \u5C5E\u6027\uFF0C\u67D0\u4E9B\u5DE5\u5177\u53EF\u80FD\u65E0\u6CD5\u6B63\u786E\u89E3\u6790");
+        if (!pluginOptions.keepIds && result.stats.idsShortened > 0) warnings.push(`\u{5DF2}\u{77ED}\u{540D}\u{5316} ${result.stats.idsShortened} \u{4E2A} ID\u{FF0C}\u{786E}\u{4FDD}\u{4E0D}\u{4F9D}\u{8D56}\u{539F}\u{59CB} ID \u{503C}`);
+        return {
+            data: result.data,
+            changed: result.stats.savedBytes > 0,
+            stats: {
+                itemsProcessed: result.stats.totalItems,
+                itemsRemoved: result.stats.attributesRemoved,
+                sizeBefore,
+                sizeAfter
+            },
+            warnings
+        };
+    }
+};
+const plugins_plugins = [
+    removeUnusedAssetsPlugin,
+    simplifyPathsPlugin,
+    compressImagesPlugin,
+    minifyJsonPlugin
+];
+function getAvailablePlugins() {
+    return [
+        ...plugins_plugins
+    ];
+}
+function getPluginByName(name) {
+    return plugins_plugins.find((plugin)=>plugin.name === name);
+}
+function getPluginsByCategory(_category) {
+    console.warn('getPluginsByCategory is deprecated. Use plugin groups from presets/plugin-groups.ts instead');
+    return [];
+}
+function validateQualityLevel(value, fieldName) {
+    const errors = [];
+    if (void 0 !== value) {
+        const validLevels = [
+            'lossless',
+            'balanced',
+            'smallest'
+        ];
+        if (!validLevels.includes(value)) errors.push(`${fieldName} must be one of: ${validLevels.join(', ')}, got: ${value}`);
+    }
+    return errors;
+}
+function validateNumberRange(value, fieldName, min, max) {
+    const errors = [];
+    if (void 0 !== value) if ('number' != typeof value) errors.push(`${fieldName} must be a number, got: ${typeof value}`);
+    else {
+        if (void 0 !== min && value < min) errors.push(`${fieldName} must be >= ${min}, got: ${value}`);
+        if (void 0 !== max && value > max) errors.push(`${fieldName} must be <= ${max}, got: ${value}`);
+    }
+    return errors;
+}
+function validateBoolean(value, fieldName) {
+    const errors = [];
+    if (void 0 !== value && 'boolean' != typeof value) errors.push(`${fieldName} must be a boolean, got: ${typeof value}`);
+    return errors;
+}
+function validateCompressImagesOptions(options) {
+    const errors = [];
+    const warnings = [];
+    const suggestions = [];
+    errors.push(...validateBoolean(options.enableWebp, 'enableWebp'));
+    errors.push(...validateBoolean(options.enableAvif, 'enableAvif'));
+    errors.push(...validateBoolean(options.embed, 'embed'));
+    errors.push(...validateQualityLevel(options.quality, 'quality'));
+    errors.push(...validateNumberRange(options.longEdge, 'longEdge', 0));
+    if (false === options.enableWebp && false === options.enableAvif && 'smallest' === options.quality) {
+        warnings.push("\u8D28\u91CF\u8BBE\u7F6E\u4E3A smallest \u4F46\u7981\u7528\u4E86 WebP \u548C AVIF\uFF0C\u53EF\u80FD\u65E0\u6CD5\u8FBE\u5230\u6700\u4F73\u538B\u7F29\u6548\u679C");
+        suggestions.push("\u5EFA\u8BAE\u542F\u7528 WebP \u6216 AVIF \u4EE5\u83B7\u5F97\u66F4\u597D\u7684\u538B\u7F29\u6548\u679C");
+    }
+    if ('lossless' === options.quality && (options.enableWebp || options.enableAvif)) suggestions.push("\u4F7F\u7528\u65E0\u635F\u8D28\u91CF\u65F6\uFF0C\u73B0\u4EE3\u683C\u5F0F (WebP/AVIF) \u7684\u4F18\u52BF\u8F83\u5C0F\uFF0C\u8003\u8651\u4F7F\u7528 balanced \u8D28\u91CF");
+    if (options.longEdge && options.longEdge < 256) warnings.push(`longEdge \u{8BBE}\u{7F6E}\u{8FC7}\u{5C0F} (${options.longEdge}px)\u{FF0C}\u{53EF}\u{80FD}\u{5BFC}\u{81F4}\u{56FE}\u{50CF}\u{8D28}\u{91CF}\u{4E25}\u{91CD}\u{4E0B}\u{964D}`);
+    return {
+        valid: 0 === errors.length,
+        errors,
+        warnings,
+        suggestions
+    };
+}
+function validateSimplifyPathsOptions(options) {
+    const errors = [];
+    const warnings = [];
+    const suggestions = [];
+    errors.push(...validateNumberRange(options.tolerance, 'tolerance', 0));
+    errors.push(...validateNumberRange(options.minPoints, 'minPoints', 3));
+    errors.push(...validateNumberRange(options.cornerAngleDeg, 'cornerAngleDeg', 0, 180));
+    errors.push(...validateNumberRange(options.samplesPerSegment, 'samplesPerSegment', 1));
+    errors.push(...validateNumberRange(options.tension, 'tension', 0, 2));
+    errors.push(...validateBoolean(options.relativeTolerance, 'relativeTolerance'));
+    errors.push(...validateBoolean(options.preserveCorners, 'preserveCorners'));
+    if (void 0 !== options.mode) {
+        const validModes = [
+            'static-only',
+            'animated-consistent',
+            'all'
+        ];
+        if (!validModes.includes(options.mode)) errors.push(`mode must be one of: ${validModes.join(', ')}, got: ${options.mode}`);
+    }
+    if (void 0 !== options.algorithm && 'rdp' !== options.algorithm) errors.push(`algorithm must be 'rdp', got: ${options.algorithm}`);
+    if (options.tolerance && options.tolerance > 10) warnings.push(`tolerance \u{503C}\u{8F83}\u{5927} (${options.tolerance})\u{FF0C}\u{53EF}\u{80FD}\u{5BFC}\u{81F4}\u{8DEF}\u{5F84}\u{8FC7}\u{5EA6}\u{7B80}\u{5316}`);
+    if (options.minPoints && options.minPoints < 3) errors.push("minPoints \u5FC5\u987B\u81F3\u5C11\u4E3A 3 \u624D\u80FD\u5F62\u6210\u6709\u6548\u8DEF\u5F84");
+    return {
+        valid: 0 === errors.length,
+        errors,
+        warnings,
+        suggestions
+    };
+}
+function validateRemoveUnusedAssetsOptions(options) {
+    const errors = [];
+    const warnings = [];
+    const suggestions = [];
+    errors.push(...validateBoolean(options.keepAssetsWithoutId, 'keepAssetsWithoutId'));
+    errors.push(...validateBoolean(options.keepUnreferencedPrecomps, 'keepUnreferencedPrecomps'));
+    if (void 0 !== options.preserveAssetIds) if (Array.isArray(options.preserveAssetIds)) {
+        for (const id of options.preserveAssetIds)if ('string' != typeof id) {
+            errors.push('All items in preserveAssetIds must be strings');
+            break;
+        }
+    } else errors.push('preserveAssetIds must be an array');
+    return {
+        valid: 0 === errors.length,
+        errors,
+        warnings,
+        suggestions
+    };
+}
+const pluginValidators = {
+    'compress-images': validateCompressImagesOptions,
+    'simplify-paths': validateSimplifyPathsOptions,
+    'remove-unused-assets': validateRemoveUnusedAssetsOptions
+};
+function validatePluginConfig(pluginName, options) {
+    const validator = pluginValidators[pluginName];
+    if (!validator) return {
+        valid: true,
+        errors: [],
+        warnings: [
+            `No validator found for plugin: ${pluginName}`
+        ],
+        suggestions: []
+    };
+    return validator(options);
+}
+function validateAllPluginConfigs(plugins, pluginOptions) {
+    const results = {};
+    for (const plugin of plugins){
+        const options = {
+            ...plugin.defaultOptions || {},
+            ...pluginOptions[plugin.name] || {}
+        };
+        results[plugin.name] = validatePluginConfig(plugin.name, options);
+    }
+    return results;
+}
+function detectConfigConflicts(plugins, pluginOptions) {
+    const conflicts = [];
+    const compressImagesOptions = pluginOptions['compress-images'];
+    const simplifyPathsOptions = pluginOptions['simplify-paths'];
+    if (compressImagesOptions?.quality === 'lossless' && simplifyPathsOptions?.tolerance && simplifyPathsOptions.tolerance > 1) conflicts.push("配置冲突：compress-images 使用无损质量，但 simplify-paths 的容差较大，可能导致视觉质量不一致");
+    if (compressImagesOptions?.enableAvif === true && compressImagesOptions?.longEdge === 0) conflicts.push("\u6027\u80FD\u8B66\u544A\uFF1A\u542F\u7528\u4E86 AVIF \u4E14\u672A\u9650\u5236\u56FE\u50CF\u5C3A\u5BF8\uFF0C\u53EF\u80FD\u5BFC\u81F4\u5904\u7406\u65F6\u95F4\u8FC7\u957F");
+    return conflicts;
+}
+class LottieOptimizer {
+    constructor(logger){
+        this.plugins = new Map();
+        this.logger = logger || createLogger();
+        this.loadPlugins();
+    }
+    loadPlugins() {
+        const availablePlugins = getAvailablePlugins();
+        for (const plugin of availablePlugins)this.plugins.set(plugin.name, plugin);
+    }
+    async optimize(data, options = {}, inputFileSize) {
+        const startTime = Date.now();
+        const originalSize = inputFileSize || calculateSize(data);
+        this.logger.info(`Starting optimization of ${originalSize} bytes Lottie`);
+        const effectiveOptions = options;
+        const pluginsToApply = await this.resolvePlugins(effectiveOptions);
+        if (effectiveOptions.debug?.showConfigSources) {
+            const validationResults = validateAllPluginConfigs(pluginsToApply, effectiveOptions.pluginOptions || {});
+            const conflicts = detectConfigConflicts(pluginsToApply, effectiveOptions.pluginOptions || {});
+            for (const [pluginName, result] of Object.entries(validationResults)){
+                if (!result.valid) this.logger.warn(`[${pluginName}] Configuration errors: ${result.errors.join(', ')}`);
+                if (result.warnings.length > 0) this.logger.warn(`[${pluginName}] Warnings: ${result.warnings.join(', ')}`);
+                if (result.suggestions.length > 0) this.logger.info(`[${pluginName}] Suggestions: ${result.suggestions.join(', ')}`);
+            }
+            if (conflicts.length > 0) {
+                this.logger.warn('Configuration conflicts detected:');
+                conflicts.forEach((conflict)=>this.logger.warn(`  - ${conflict}`));
+            }
+        }
+        const stats = {
+            originalSize,
+            optimizedSize: originalSize,
+            compressionRatio: 0,
+            pluginsApplied: [],
+            processingTime: 0
+        };
+        let currentData = JSON.parse(JSON.stringify(data));
+        const pluginReports = [];
+        const warnings = [];
+        const errors = [];
+        for(let i = 0; i < pluginsToApply.length; i++){
+            const plugin = pluginsToApply[i];
+            try {
+                this.logger.info(`Applying plugin: ${plugin.name}`);
+                const pluginStartTime = Date.now();
+                const sizeBefore = calculateSize(currentData);
+                const context = {
+                    originalData: data,
+                    currentData,
+                    stats,
+                    logger: this.logger
+                };
+                const defaultOptions = plugin.defaultOptions || {};
+                const presetOptions = effectiveOptions.pluginOptions?.[plugin.name] || {};
+                const pluginOptions = {
+                    ...defaultOptions,
+                    ...presetOptions
+                };
+                if (effectiveOptions.debug?.showEffectiveConfig) {
+                    this.logger.info(`[${plugin.name}] Effective configuration:`);
+                    this.logger.info(JSON.stringify(pluginOptions, null, 2));
+                }
+                if (effectiveOptions.debug?.showConfigSources) {
+                    this.logger.info(`[${plugin.name}] Configuration sources:`);
+                    this.logger.info(`  Default options: ${JSON.stringify(defaultOptions, null, 2)}`);
+                    this.logger.info(`  Preset/User options: ${JSON.stringify(presetOptions, null, 2)}`);
+                }
+                const result = await plugin.apply(currentData, pluginOptions, context);
+                if (result.changed) {
+                    currentData = result.data;
+                    stats.pluginsApplied.push(plugin.name);
+                }
+                if (plugin.validate) {
+                    const isValid = await plugin.validate(result);
+                    if (!isValid) {
+                        this.logger.warn(`Plugin ${plugin.name} validation failed`);
+                        warnings.push(`Plugin ${plugin.name} validation failed`);
+                    }
+                }
+                const sizeAfter = calculateSize(currentData);
+                const processingTime = Date.now() - pluginStartTime;
+                pluginReports.push({
+                    pluginName: plugin.name,
+                    sizeBefore: result.stats.sizeBefore || sizeBefore,
+                    sizeAfter: result.stats.sizeAfter || sizeAfter,
+                    itemsProcessed: result.stats.itemsProcessed,
+                    itemsRemoved: result.stats.itemsRemoved,
+                    processingTime
+                });
+                if (result.warnings) warnings.push(...result.warnings);
+                if (result.errors) errors.push(...result.errors);
+                const reportedSizeBefore = result.stats.sizeBefore || sizeBefore;
+                const reportedSizeAfter = result.stats.sizeAfter || sizeAfter;
+                this.logger.debug(`Plugin ${plugin.name} completed: ${reportedSizeBefore} -> ${reportedSizeAfter} bytes`);
+            } catch (error) {
+                const errorMsg = `Plugin ${plugin.name} failed: ${error}`;
+                this.logger.error(errorMsg);
+                errors.push(errorMsg);
+            }
+        }
+        const finalSize = calculateSize(currentData);
+        stats.optimizedSize = finalSize;
+        stats.compressionRatio = (originalSize - finalSize) / originalSize * 100;
+        stats.processingTime = Date.now() - startTime;
+        const summary = this.generateSummary(stats);
+        this.logger.info(`Optimization complete: ${originalSize} -> ${finalSize} bytes (${stats.compressionRatio.toFixed(1)}% reduction)`);
+        return {
+            data: currentData,
+            stats,
+            report: {
+                summary,
+                details: pluginReports,
+                warnings,
+                errors
+            }
+        };
+    }
+    async resolvePlugins(effectiveOptions) {
+        let pluginNames = [];
+        if (effectiveOptions.plugins) if ('string' != typeof effectiveOptions.plugins[0]) return effectiveOptions.plugins;
+        else pluginNames = effectiveOptions.plugins;
+        else pluginNames = Array.from(this.plugins.keys());
+        if (effectiveOptions.disable) {
+            const disabled = Array.isArray(effectiveOptions.disable) ? effectiveOptions.disable : [
+                effectiveOptions.disable
+            ];
+            pluginNames = pluginNames.filter((name)=>!disabled.includes(name));
+        }
+        const resolvedPlugins = [];
+        for (const name of pluginNames){
+            const plugin = this.plugins.get(name);
+            if (plugin) resolvedPlugins.push(plugin);
+            else this.logger.warn(`Plugin "${name}" not found`);
+        }
+        return resolvedPlugins;
+    }
+    generateSummary(stats) {
+        const reduction = stats.compressionRatio.toFixed(1);
+        const time = (stats.processingTime / 1000).toFixed(2);
+        return `Optimized ${stats.originalSize} -> ${stats.optimizedSize} bytes (${reduction}% reduction) in ${time}s using ${stats.pluginsApplied.length} plugins`;
+    }
+    getAvailablePlugins() {
+        return Array.from(this.plugins.keys());
+    }
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+}
+async function optimize(data, options = {}, inputFileSize) {
+    const optimizer = new LottieOptimizer();
+    return optimizer.optimize(data, options, inputFileSize);
+}
+export { LottieOptimizer, calculateCompressionRatio, calculateSize, createLogger, createSilentLogger, formatSize, getAvailablePlugins, getPluginByName, getPluginsByCategory, optimize };