lofter-lottie-opt 1.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,3162 @@
+#!/usr/bin/env node
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+import { Command } from "commander";
+import { existsSync, promises, readFileSync, writeFileSync } from "fs";
+import { basename, dirname, join, resolve as external_path_resolve } from "path";
+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 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 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 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);
+    }
+}
+class LottieValidator {
+    async validate(data) {
+        const errors = [];
+        const warnings = [];
+        this.validateBasicStructure(data, errors, warnings);
+        this.validateLayers(data, errors, warnings);
+        this.validateAssets(data, errors, warnings);
+        this.validateAnimation(data, errors, warnings);
+        const metrics = this.calculateQualityMetrics(data);
+        return {
+            isValid: 0 === errors.length,
+            errors,
+            warnings,
+            metrics
+        };
+    }
+    async compare(original, optimized) {
+        const originalSize = JSON.stringify(original).length;
+        const optimizedSize = JSON.stringify(optimized).length;
+        const compressionRatio = (originalSize - optimizedSize) / originalSize;
+        const sizeReduction = originalSize - optimizedSize;
+        const originalResult = await this.validate(original);
+        const optimizedResult = await this.validate(optimized);
+        const qualityLoss = this.calculateQualityLoss(originalResult.metrics, optimizedResult.metrics);
+        const timingDiff = this.calculateTimingDifference(original, optimized);
+        const pathDiff = this.calculatePathDifference(original, optimized);
+        const colorDiff = this.calculateColorDifference(original, optimized);
+        const compatibilityScore = optimizedResult.isValid ? 1.0 : 0.5;
+        return {
+            compressionRatio,
+            sizeReduction,
+            qualityLoss,
+            timingDifference: timingDiff,
+            pathDifference: pathDiff,
+            colorDifference: colorDiff,
+            compatibilityScore
+        };
+    }
+    validateBasicStructure(data, errors, warnings) {
+        if (!data.v) errors.push({
+            code: 'MISSING_VERSION',
+            message: 'Missing version field',
+            severity: 'critical'
+        });
+        if (!data.fr || data.fr <= 0) errors.push({
+            code: 'INVALID_FRAMERATE',
+            message: 'Invalid or missing frame rate',
+            severity: 'high'
+        });
+        if (void 0 === data.ip || void 0 === data.op || data.op <= data.ip) errors.push({
+            code: 'INVALID_DURATION',
+            message: 'Invalid animation duration',
+            severity: 'high'
+        });
+        if (!data.w || !data.h || data.w <= 0 || data.h <= 0) errors.push({
+            code: 'INVALID_DIMENSIONS',
+            message: 'Invalid canvas dimensions',
+            severity: 'medium'
+        });
+    }
+    validateLayers(data, errors, warnings) {
+        if (!data.layers || !Array.isArray(data.layers)) return void errors.push({
+            code: 'MISSING_LAYERS',
+            message: 'No layers found',
+            severity: 'critical'
+        });
+        data.layers.forEach((layer, index)=>{
+            const layerPath = `layers[${index}]`;
+            if (void 0 === layer.ty) errors.push({
+                code: 'MISSING_LAYER_TYPE',
+                message: 'Layer missing type',
+                severity: 'high',
+                path: layerPath
+            });
+            if (void 0 !== layer.ip && void 0 !== layer.op && layer.op <= layer.ip) warnings.push({
+                code: 'INVALID_LAYER_DURATION',
+                message: 'Layer has invalid duration',
+                path: layerPath
+            });
+            if (2 === layer.ty && layer.refId) {
+                const asset = data.assets?.find((a)=>a.id === layer.refId);
+                if (!asset) errors.push({
+                    code: 'MISSING_ASSET_REFERENCE',
+                    message: `Layer references missing asset: ${layer.refId}`,
+                    severity: 'high',
+                    path: layerPath
+                });
+            }
+        });
+    }
+    validateAssets(data, errors, warnings) {
+        if (!data.assets) return;
+        data.assets.forEach((asset, index)=>{
+            const assetPath = `assets[${index}]`;
+            if (!asset.id) errors.push({
+                code: 'MISSING_ASSET_ID',
+                message: 'Asset missing ID',
+                severity: 'high',
+                path: assetPath
+            });
+            if (asset.p) {
+                if (1 === asset.e) {
+                    if (!asset.p.startsWith('data:')) warnings.push({
+                        code: 'INVALID_EMBEDDED_DATA',
+                        message: 'Embedded asset has invalid data format',
+                        path: assetPath
+                    });
+                }
+            }
+        });
+    }
+    validateAnimation(data, errors, warnings) {
+        const duration = data.op - data.ip;
+        if (duration <= 0) errors.push({
+            code: 'ZERO_DURATION',
+            message: 'Animation has zero or negative duration',
+            severity: 'high'
+        });
+        if (data.fr && (data.fr < 12 || data.fr > 120)) warnings.push({
+            code: 'UNUSUAL_FRAMERATE',
+            message: `Unusual frame rate: ${data.fr}fps`
+        });
+    }
+    calculateQualityMetrics(data) {
+        const structuralIntegrity = this.calculateStructuralIntegrity(data);
+        const animationContinuity = this.calculateAnimationContinuity(data);
+        const dataConsistency = this.calculateDataConsistency(data);
+        const performanceScore = this.calculatePerformanceScore(data);
+        return {
+            structuralIntegrity,
+            animationContinuity,
+            dataConsistency,
+            performanceScore,
+            frameCount: data.op - data.ip,
+            layerCount: data.layers?.length || 0,
+            assetCount: data.assets?.length || 0,
+            totalKeyframes: this.countTotalKeyframes(data),
+            averageComplexity: this.calculateAverageComplexity(data)
+        };
+    }
+    calculateStructuralIntegrity(data) {
+        let score = 1.0;
+        if (!data.layers || 0 === data.layers.length) score -= 0.5;
+        if (!data.fr || data.fr <= 0) score -= 0.3;
+        if (!data.v) score -= 0.2;
+        return Math.max(0, score);
+    }
+    calculateAnimationContinuity(data) {
+        let continuityScore = 1.0;
+        if (data.layers) {
+            for (const layer of data.layers)if (layer.ks) continuityScore *= this.checkTransformContinuity(layer.ks);
+        }
+        return continuityScore;
+    }
+    calculateDataConsistency(data) {
+        let consistencyScore = 1.0;
+        if (data.layers && data.assets) {
+            for (const layer of data.layers)if (layer.refId) {
+                const asset = data.assets.find((a)=>a.id === layer.refId);
+                if (!asset) consistencyScore -= 0.1;
+            }
+        }
+        return Math.max(0, consistencyScore);
+    }
+    calculatePerformanceScore(data) {
+        let score = 1.0;
+        const layerCount = data.layers?.length || 0;
+        const assetCount = data.assets?.length || 0;
+        const totalKeyframes = this.countTotalKeyframes(data);
+        if (layerCount > 50) score -= 0.2;
+        if (assetCount > 20) score -= 0.2;
+        if (totalKeyframes > 1000) score -= 0.3;
+        return Math.max(0, score);
+    }
+    countTotalKeyframes(data) {
+        let total = 0;
+        if (data.layers) for (const layer of data.layers)total += this.countLayerKeyframes(layer);
+        return total;
+    }
+    countLayerKeyframes(layer) {
+        let count = 0;
+        if (layer.ks) [
+            'p',
+            's',
+            'r',
+            'a',
+            'o'
+        ].forEach((prop)=>{
+            if (layer.ks[prop] && 1 === layer.ks[prop].a && Array.isArray(layer.ks[prop].k)) count += layer.ks[prop].k.length;
+        });
+        return count;
+    }
+    calculateAverageComplexity(data) {
+        const layerCount = data.layers?.length || 1;
+        const totalKeyframes = this.countTotalKeyframes(data);
+        return totalKeyframes / layerCount;
+    }
+    checkTransformContinuity(transform) {
+        return 1.0;
+    }
+    calculateQualityLoss(originalMetrics, optimizedMetrics) {
+        const structuralLoss = Math.max(0, originalMetrics.structuralIntegrity - optimizedMetrics.structuralIntegrity);
+        const animationLoss = Math.max(0, originalMetrics.animationContinuity - optimizedMetrics.animationContinuity);
+        const dataLoss = Math.max(0, originalMetrics.dataConsistency - optimizedMetrics.dataConsistency);
+        const performanceLoss = Math.max(0, originalMetrics.performanceScore - optimizedMetrics.performanceScore);
+        return 0.3 * structuralLoss + 0.4 * animationLoss + 0.2 * dataLoss + 0.1 * performanceLoss;
+    }
+    calculateTimingDifference(original, optimized) {
+        const originalDuration = original.op - original.ip;
+        const optimizedDuration = optimized.op - optimized.ip;
+        return Math.abs(originalDuration - optimizedDuration) / originalDuration;
+    }
+    calculatePathDifference(original, optimized) {
+        return 0.0;
+    }
+    calculateColorDifference(original, optimized) {
+        return 0.0;
+    }
+}
+const validation_validator = new LottieValidator();
+class VisualValidator {
+    async validatePlayback(data) {
+        const errors = [];
+        const startTime = Date.now();
+        try {
+            const canRender = await this.simulateRendering(data, errors);
+            const performanceMetrics = this.calculateRenderingMetrics(data, Date.now() - startTime);
+            return {
+                canRender,
+                renderingErrors: errors,
+                performanceMetrics,
+                visualDifference: 0
+            };
+        } catch (error) {
+            errors.push({
+                code: 'VALIDATION_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+                timestamp: Date.now()
+            });
+            return {
+                canRender: false,
+                renderingErrors: errors,
+                performanceMetrics: this.getDefaultMetrics(),
+                visualDifference: 1.0
+            };
+        }
+    }
+    async compareVisual(original, optimized) {
+        const originalResult = await this.validatePlayback(original);
+        const optimizedResult = await this.validatePlayback(optimized);
+        const visualDifference = this.calculateVisualDifference(original, optimized);
+        return {
+            canRender: optimizedResult.canRender,
+            renderingErrors: [
+                ...originalResult.renderingErrors,
+                ...optimizedResult.renderingErrors
+            ],
+            performanceMetrics: optimizedResult.performanceMetrics,
+            visualDifference
+        };
+    }
+    async performPlaybackTest(data, options = {}) {
+        const errors = [];
+        const startTime = Date.now();
+        try {
+            const testDuration = options.duration || (data.op - data.ip) / data.fr * 1000;
+            const targetFPS = options.framerate || data.fr;
+            const success = await this.simulatePlayback(data, testDuration, targetFPS, errors);
+            const actualDuration = Date.now() - startTime;
+            const metrics = this.calculateRenderingMetrics(data, actualDuration);
+            return {
+                duration: actualDuration,
+                success,
+                errors,
+                metrics
+            };
+        } catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+            return {
+                duration: Date.now() - startTime,
+                success: false,
+                errors,
+                metrics: this.getDefaultMetrics()
+            };
+        }
+    }
+    async simulateRendering(data, errors) {
+        if (!this.checkBasicRenderRequirements(data, errors)) return false;
+        if (!this.checkLayerRendering(data, errors)) return false;
+        if (!this.checkAssetAvailability(data, errors)) return false;
+        if (!this.checkAnimationTiming(data, errors)) return false;
+        return true;
+    }
+    checkBasicRenderRequirements(data, errors) {
+        let canRender = true;
+        if (!data.w || !data.h || data.w <= 0 || data.h <= 0) {
+            errors.push({
+                code: 'INVALID_CANVAS_SIZE',
+                message: 'Invalid canvas dimensions for rendering',
+                timestamp: Date.now()
+            });
+            canRender = false;
+        }
+        if (!data.fr || data.fr <= 0) {
+            errors.push({
+                code: 'INVALID_FRAMERATE',
+                message: 'Invalid frame rate for rendering',
+                timestamp: Date.now()
+            });
+            canRender = false;
+        }
+        if (data.op <= data.ip) {
+            errors.push({
+                code: 'INVALID_ANIMATION_RANGE',
+                message: 'Invalid animation time range',
+                timestamp: Date.now()
+            });
+            canRender = false;
+        }
+        return canRender;
+    }
+    checkLayerRendering(data, errors) {
+        if (!data.layers || 0 === data.layers.length) {
+            errors.push({
+                code: 'NO_RENDERABLE_LAYERS',
+                message: 'No layers available for rendering',
+                timestamp: Date.now()
+            });
+            return false;
+        }
+        let hasRenderableLayer = false;
+        for(let i = 0; i < data.layers.length; i++){
+            const layer = data.layers[i];
+            if (this.isSupportedLayerType(layer.ty)) hasRenderableLayer = true;
+            else errors.push({
+                code: 'UNSUPPORTED_LAYER_TYPE',
+                message: `Unsupported layer type: ${layer.ty}`,
+                timestamp: Date.now()
+            });
+            if (void 0 !== layer.ip && void 0 !== layer.op && layer.op <= layer.ip) errors.push({
+                code: 'INVALID_LAYER_TIME_RANGE',
+                message: `Layer ${i} has invalid time range`,
+                timestamp: Date.now()
+            });
+        }
+        return hasRenderableLayer;
+    }
+    isSupportedLayerType(type) {
+        const supportedTypes = [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5
+        ];
+        return supportedTypes.includes(type);
+    }
+    checkAssetAvailability(data, errors) {
+        if (!data.assets) return true;
+        let allAssetsAvailable = true;
+        for(let i = 0; i < data.assets.length; i++){
+            const asset = data.assets[i];
+            if (asset.p) {
+                if (1 === asset.e) {
+                    if (!asset.p.startsWith('data:')) {
+                        errors.push({
+                            code: 'INVALID_EMBEDDED_ASSET',
+                            message: `Invalid embedded asset data: ${asset.id}`,
+                            timestamp: Date.now()
+                        });
+                        allAssetsAvailable = false;
+                    }
+                }
+            }
+        }
+        return allAssetsAvailable;
+    }
+    checkAnimationTiming(data, errors) {
+        const duration = (data.op - data.ip) / data.fr;
+        if (duration <= 0) {
+            errors.push({
+                code: 'ZERO_ANIMATION_DURATION',
+                message: 'Animation has zero duration',
+                timestamp: Date.now()
+            });
+            return false;
+        }
+        if (duration > 300) errors.push({
+            code: 'EXCESSIVE_DURATION',
+            message: `Animation duration too long: ${duration}s`,
+            timestamp: Date.now()
+        });
+        return true;
+    }
+    async simulatePlayback(data, duration, targetFPS, errors) {
+        const totalFrames = Math.ceil(duration * targetFPS / 1000);
+        const frameInterval = 1000 / targetFPS;
+        try {
+            for(let frame = 0; frame < totalFrames; frame++){
+                const currentTime = data.ip + frame / targetFPS * data.fr;
+                if (!this.canRenderFrame(data, currentTime)) errors.push(`Frame ${frame} cannot be rendered`);
+                await this.simulateFrameDelay(frameInterval);
+            }
+            return 0 === errors.length;
+        } catch (error) {
+            errors.push(`Playback simulation failed: ${error}`);
+            return false;
+        }
+    }
+    canRenderFrame(data, time) {
+        if (!data.layers) return false;
+        for (const layer of data.layers){
+            const layerStart = layer.ip || data.ip;
+            const layerEnd = layer.op || data.op;
+            if (time >= layerStart && time <= layerEnd) return true;
+        }
+        return false;
+    }
+    async simulateFrameDelay(interval) {
+        const renderTime = Math.random() * interval * 0.1;
+        await new Promise((resolve)=>setTimeout(resolve, renderTime));
+    }
+    calculateRenderingMetrics(data, actualDuration) {
+        const totalFrames = data.op - data.ip;
+        const expectedDuration = totalFrames / data.fr * 1000;
+        const averageFPS = totalFrames / (actualDuration / 1000);
+        const layerCount = data.layers?.length || 0;
+        const assetCount = data.assets?.length || 0;
+        const memoryUsage = (0.5 * layerCount + 2 * assetCount) * (data.w * data.h) / 1048576;
+        const droppedFrames = Math.max(0, Math.floor((actualDuration - expectedDuration) / (1000 / data.fr)));
+        return {
+            averageFPS,
+            memoryUsage,
+            renderTime: actualDuration,
+            droppedFrames,
+            totalFrames
+        };
+    }
+    getDefaultMetrics() {
+        return {
+            averageFPS: 0,
+            memoryUsage: 0,
+            renderTime: 0,
+            droppedFrames: 0,
+            totalFrames: 0
+        };
+    }
+    calculateVisualDifference(original, optimized) {
+        let difference = 0;
+        if (original.w !== optimized.w || original.h !== optimized.h) difference += 0.1;
+        if (Math.abs(original.fr - optimized.fr) > 0.1) difference += 0.1;
+        const originalLayers = original.layers?.length || 0;
+        const optimizedLayers = optimized.layers?.length || 0;
+        const layerDifference = Math.abs(originalLayers - optimizedLayers) / Math.max(originalLayers, 1);
+        difference += 0.3 * layerDifference;
+        const originalAssets = original.assets?.length || 0;
+        const optimizedAssets = optimized.assets?.length || 0;
+        const assetDifference = Math.abs(originalAssets - optimizedAssets) / Math.max(originalAssets, 1);
+        difference += 0.2 * assetDifference;
+        const originalDuration = original.op - original.ip;
+        const optimizedDuration = optimized.op - optimized.ip;
+        const durationDifference = Math.abs(originalDuration - optimizedDuration) / originalDuration;
+        difference += 0.3 * durationDifference;
+        return Math.min(1.0, difference);
+    }
+}
+const visualValidator = new VisualValidator();
+async function optimize(data, options = {}, inputFileSize) {
+    const optimizer = new LottieOptimizer();
+    return optimizer.optimize(data, options, inputFileSize);
+}
+class ComparisonTool {
+    async runComparisonTest(lottieData, configurations = [
+        {
+            name: 'basic',
+            options: {
+                plugins: [
+                    'remove-unused-assets'
+                ]
+            }
+        },
+        {
+            name: 'balanced',
+            options: {
+                plugins: [
+                    'remove-unused-assets',
+                    'simplify-paths'
+                ]
+            }
+        },
+        {
+            name: 'complete',
+            options: {}
+        }
+    ]) {
+        const results = [];
+        const originalValidation = await validation_validator.validate(lottieData);
+        const originalVisual = await visualValidator.validatePlayback(lottieData);
+        const originalSize = JSON.stringify(lottieData).length;
+        for (const config of configurations)try {
+            console.log(`\u{1F9EA} Testing configuration: ${config.name}`);
+            const optimizeResult = await optimize(lottieData, config.options);
+            const optimizedValidation = await validation_validator.validate(optimizeResult.data);
+            const optimizedVisual = await visualValidator.validatePlayback(optimizeResult.data);
+            const optimizedSize = JSON.stringify(optimizeResult.data).length;
+            const comparison = await validation_validator.compare(lottieData, optimizeResult.data);
+            const recommendation = this.calculateRecommendation(comparison, originalValidation, optimizedValidation);
+            const summary = this.generateSummary(config.name, comparison, recommendation);
+            results.push({
+                preset: config.name,
+                original: {
+                    size: originalSize,
+                    validationResult: originalValidation,
+                    visualResult: originalVisual
+                },
+                optimized: {
+                    size: optimizedSize,
+                    validationResult: optimizedValidation,
+                    visualResult: optimizedVisual
+                },
+                comparison,
+                recommendation,
+                summary
+            });
+        } catch (error) {
+            console.error(`\u{274C} Failed to test configuration ${config.name}:`, error);
+            results.push({
+                preset: config.name,
+                original: {
+                    size: originalSize,
+                    validationResult: originalValidation,
+                    visualResult: originalVisual
+                },
+                optimized: {
+                    size: originalSize,
+                    validationResult: {
+                        isValid: false,
+                        errors: [],
+                        warnings: [],
+                        metrics: {}
+                    },
+                    visualResult: {
+                        canRender: false,
+                        renderingErrors: [],
+                        performanceMetrics: {},
+                        visualDifference: 1
+                    }
+                },
+                comparison: {
+                    compressionRatio: 0,
+                    sizeReduction: 0,
+                    qualityLoss: 1,
+                    timingDifference: 1,
+                    pathDifference: 1,
+                    colorDifference: 1,
+                    compatibilityScore: 0
+                },
+                recommendation: 'failed',
+                summary: `Optimization failed: ${error}`
+            });
+        }
+        return results;
+    }
+    async runTestSuite(suite) {
+        console.log(`
+\u{1F3AF} Running test suite: ${suite.name}`);
+        console.log(`\u{1F4DD} ${suite.description}\n`);
+        const results = new Map();
+        for (const testCase of suite.testCases){
+            console.log(`
+\u{1F4CB} Test Case: ${testCase.name}`);
+            try {
+                const testResults = await this.runComparisonTest(testCase.lottieData);
+                results.set(testCase.name, testResults);
+                if (testCase.expectedResults) this.validateExpectedResults(testResults, testCase.expectedResults);
+            } catch (error) {
+                console.error(`\u{274C} Test case ${testCase.name} failed:`, error);
+            }
+        }
+        return results;
+    }
+    generateReport(results) {
+        const report = [];
+        report.push('# Lottie Optimization Comparison Report\n');
+        report.push(`Generated: ${new Date().toISOString()}\n`);
+        report.push('## Summary\n');
+        report.push('| Preset | Compression | Quality Loss | Recommendation | Status |');
+        report.push('|--------|-------------|--------------|----------------|---------|');
+        for (const result of results){
+            const compression = `${(100 * result.comparison.compressionRatio).toFixed(1)}%`;
+            const qualityLoss = `${(100 * result.comparison.qualityLoss).toFixed(1)}%`;
+            const status = result.optimized.validationResult.isValid ? "\u2705" : "\u274C";
+            report.push(`| ${result.preset} | ${compression} | ${qualityLoss} | ${result.recommendation} | ${status} |`);
+        }
+        report.push('\n');
+        report.push('## Detailed Results\n');
+        for (const result of results){
+            report.push(`### ${result.preset.toUpperCase()} Preset\n`);
+            report.push(`**Summary**: ${result.summary}\n`);
+            report.push('**Metrics**:');
+            report.push(`- Original Size: ${result.original.size.toLocaleString()} bytes`);
+            report.push(`- Optimized Size: ${result.optimized.size.toLocaleString()} bytes`);
+            report.push(`- Size Reduction: ${result.comparison.sizeReduction.toLocaleString()} bytes (${(100 * result.comparison.compressionRatio).toFixed(1)}%)`);
+            report.push(`- Quality Loss: ${(100 * result.comparison.qualityLoss).toFixed(1)}%`);
+            report.push(`- Compatibility Score: ${(100 * result.comparison.compatibilityScore).toFixed(1)}%`);
+            report.push('\n**Validation Results**:');
+            report.push(`- Original: ${result.original.validationResult.isValid ? 'Valid' : 'Invalid'} (${result.original.validationResult.errors.length} errors, ${result.original.validationResult.warnings.length} warnings)`);
+            report.push(`- Optimized: ${result.optimized.validationResult.isValid ? 'Valid' : 'Invalid'} (${result.optimized.validationResult.errors.length} errors, ${result.optimized.validationResult.warnings.length} warnings)`);
+            report.push('\n**Playback Test**:');
+            report.push(`- Original: ${result.original.visualResult.canRender ? 'Can render' : 'Cannot render'}`);
+            report.push(`- Optimized: ${result.optimized.visualResult.canRender ? 'Can render' : 'Cannot render'}`);
+            report.push(`- Visual Difference: ${(100 * result.optimized.visualResult.visualDifference).toFixed(1)}%`);
+            report.push('\n---\n');
+        }
+        report.push('## Recommendations\n');
+        const bestResult = this.findBestResult(results);
+        if (bestResult) {
+            report.push(`\u{1F3C6} **Best Overall**: ${bestResult.preset} preset`);
+            report.push(`- Compression: ${(100 * bestResult.comparison.compressionRatio).toFixed(1)}%`);
+            report.push(`- Quality preserved: ${(100 - 100 * bestResult.comparison.qualityLoss).toFixed(1)}%`);
+            report.push(`- ${bestResult.summary}`);
+        }
+        return report.join('\n');
+    }
+    calculateRecommendation(comparison, originalValidation, optimizedValidation) {
+        if (!optimizedValidation.isValid) return 'failed';
+        let score = 0;
+        const compressionScore = Math.min(40, 100 * comparison.compressionRatio);
+        score += compressionScore;
+        const qualityScore = Math.max(0, 40 - 40 * comparison.qualityLoss);
+        score += qualityScore;
+        const compatibilityScore = 20 * comparison.compatibilityScore;
+        score += compatibilityScore;
+        if (score >= 80) return 'excellent';
+        if (score >= 65) return 'good';
+        if (score >= 50) return 'acceptable';
+        if (score >= 30) return 'poor';
+        return 'failed';
+    }
+    generateSummary(preset, comparison, recommendation) {
+        const compression = (100 * comparison.compressionRatio).toFixed(1);
+        const qualityLoss = (100 * comparison.qualityLoss).toFixed(1);
+        switch(recommendation){
+            case 'excellent':
+                return `Excellent optimization: ${compression}% compression with only ${qualityLoss}% quality loss. Highly recommended.`;
+            case 'good':
+                return `Good optimization: ${compression}% compression with ${qualityLoss}% quality loss. Recommended for most use cases.`;
+            case 'acceptable':
+                return `Acceptable optimization: ${compression}% compression with ${qualityLoss}% quality loss. Consider if file size is critical.`;
+            case 'poor':
+                return `Poor optimization: Only ${compression}% compression with ${qualityLoss}% quality loss. Not recommended.`;
+            case 'failed':
+                return "Optimization failed or resulted in invalid file. Use with caution or try a different preset.";
+        }
+    }
+    validateExpectedResults(results, expected) {
+        for (const result of results){
+            if (expected.minCompressionRatio && result.comparison.compressionRatio < expected.minCompressionRatio) console.warn(`\u{26A0}\u{FE0F}  ${result.preset}: Compression ratio ${(100 * result.comparison.compressionRatio).toFixed(1)}% below expected ${(100 * expected.minCompressionRatio).toFixed(1)}%`);
+            if (expected.maxQualityLoss && result.comparison.qualityLoss > expected.maxQualityLoss) console.warn(`\u{26A0}\u{FE0F}  ${result.preset}: Quality loss ${(100 * result.comparison.qualityLoss).toFixed(1)}% exceeds maximum ${(100 * expected.maxQualityLoss).toFixed(1)}%`);
+            if (expected.mustPlayback && !result.optimized.visualResult.canRender) console.error(`\u{274C} ${result.preset}: File cannot playback but playback is required`);
+        }
+    }
+    findBestResult(results) {
+        if (0 === results.length) return null;
+        const validResults = results.filter((r)=>r.optimized.validationResult.isValid);
+        if (0 === validResults.length) return null;
+        const recommendationOrder = [
+            'excellent',
+            'good',
+            'acceptable',
+            'poor',
+            'failed'
+        ];
+        for (const level of recommendationOrder){
+            const candidates = validResults.filter((r)=>r.recommendation === level);
+            if (candidates.length > 0) return candidates.reduce((best, current)=>current.comparison.compressionRatio > best.comparison.compressionRatio ? current : best);
+        }
+        return validResults[0];
+    }
+}
+const comparisonTool = new ComparisonTool();
+function createValidateCommand() {
+    const validateCmd = new Command('validate');
+    validateCmd.description('Validate and compare Lottie files').argument('<input>', 'Input Lottie file path').option('-o, --output <path>', 'Output directory for reports').option('-c, --configurations <configs...>', 'Plugin configurations to test', [
+        'basic',
+        'balanced',
+        'complete'
+    ]).option('-r, --report', 'Generate detailed report', false).option('--visual', 'Include visual validation', false).option('--playback', 'Test playback capability', false).action(async (input, options)=>{
+        try {
+            console.log(chalk.blue("\uD83D\uDD0D Lottie Quality Validation\n"));
+            const inputPath = external_path_resolve(input);
+            const fileContent = await promises.readFile(inputPath, 'utf-8');
+            const lottieData = JSON.parse(fileContent);
+            const originalSize = fileContent.length;
+            console.log(`\u{1F4C1} Input file: ${chalk.cyan(inputPath)}`);
+            console.log(`\u{1F4CA} Original size: ${chalk.yellow(originalSize.toLocaleString())} bytes\n`);
+            console.log(chalk.blue("\uD83D\uDCCB Basic Validation:"));
+            const validationResult = await validation_validator.validate(lottieData);
+            if (validationResult.isValid) console.log(chalk.green("\u2705 File structure is valid"));
+            else {
+                console.log(chalk.red("\u274C File structure has issues:"));
+                validationResult.errors.forEach((error)=>{
+                    console.log(`   ${chalk.red("\u2022")} ${error.message} (${error.severity})`);
+                });
+            }
+            if (validationResult.warnings.length > 0) {
+                console.log(chalk.yellow("\n\u26A0\uFE0F  Warnings:"));
+                validationResult.warnings.forEach((warning)=>{
+                    console.log(`   ${chalk.yellow("\u2022")} ${warning.message}`);
+                });
+            }
+            console.log(chalk.blue("\n\uD83D\uDCC8 Quality Metrics:"));
+            const metrics = validationResult.metrics;
+            console.log(`   Structural Integrity: ${chalk.cyan((100 * metrics.structuralIntegrity).toFixed(1))}%`);
+            console.log(`   Animation Continuity: ${chalk.cyan((100 * metrics.animationContinuity).toFixed(1))}%`);
+            console.log(`   Data Consistency: ${chalk.cyan((100 * metrics.dataConsistency).toFixed(1))}%`);
+            console.log(`   Performance Score: ${chalk.cyan((100 * metrics.performanceScore).toFixed(1))}%`);
+            console.log(`   Layers: ${chalk.cyan(metrics.layerCount)}, Assets: ${chalk.cyan(metrics.assetCount)}, Keyframes: ${chalk.cyan(metrics.totalKeyframes)}`);
+            if (options.visual || options.playback) {
+                console.log(chalk.blue("\n\uD83C\uDFAC Visual Validation:"));
+                const visualResult = await visualValidator.validatePlayback(lottieData);
+                if (visualResult.canRender) console.log(chalk.green("\u2705 Animation can render"));
+                else {
+                    console.log(chalk.red("\u274C Animation cannot render:"));
+                    visualResult.renderingErrors.forEach((error)=>{
+                        console.log(`   ${chalk.red("\u2022")} ${error.message}`);
+                    });
+                }
+                const perfMetrics = visualResult.performanceMetrics;
+                console.log(`   Estimated FPS: ${chalk.cyan(perfMetrics.averageFPS.toFixed(1))}`);
+                console.log(`   Memory Usage: ${chalk.cyan(perfMetrics.memoryUsage.toFixed(1))} MB`);
+                console.log(`   Render Time: ${chalk.cyan(perfMetrics.renderTime)} ms`);
+            }
+            if (options.configurations.length > 0) {
+                console.log(chalk.blue("\n\uD83E\uDDEA Compression Comparison:"));
+                const configMap = {
+                    basic: {
+                        plugins: [
+                            'remove-unused-assets'
+                        ]
+                    },
+                    balanced: {
+                        plugins: [
+                            'remove-unused-assets',
+                            'simplify-paths'
+                        ]
+                    },
+                    complete: {}
+                };
+                const testConfigs = options.configurations.map((name)=>({
+                        name,
+                        options: configMap[name] || {}
+                    }));
+                const comparisonResults = await comparisonTool.runComparisonTest(lottieData, testConfigs);
+                console.log('\n' + chalk.bold('Configuration Comparison Results:'));
+                console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+                console.log("\u2502 Config      \u2502 Compression \u2502 Quality     \u2502 Playback     \u2502 Rating     \u2502");
+                console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+                for (const result of comparisonResults){
+                    const config = result.preset.padEnd(11);
+                    const compression = `${(100 * result.comparison.compressionRatio).toFixed(1)}%`.padStart(11);
+                    const quality = `${(100 - 100 * result.comparison.qualityLoss).toFixed(1)}%`.padStart(11);
+                    const playback = result.optimized.visualResult.canRender ? 'Yes'.padStart(12) : 'No'.padStart(12);
+                    let rating = '';
+                    let ratingColor = chalk.gray;
+                    switch(result.recommendation){
+                        case 'excellent':
+                            rating = 'Excellent';
+                            ratingColor = chalk.green;
+                            break;
+                        case 'good':
+                            rating = 'Good';
+                            ratingColor = chalk.cyan;
+                            break;
+                        case 'acceptable':
+                            rating = 'Acceptable';
+                            ratingColor = chalk.yellow;
+                            break;
+                        case 'poor':
+                            rating = 'Poor';
+                            ratingColor = chalk.red;
+                            break;
+                        case 'failed':
+                            rating = 'Failed';
+                            ratingColor = chalk.red;
+                            break;
+                    }
+                    console.log(`\u{2502} ${config} \u{2502} ${compression} \u{2502} ${quality} \u{2502} ${playback} \u{2502} ${ratingColor(rating.padEnd(10))} \u{2502}`);
+                }
+                console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+                const validResults = comparisonResults.filter((r)=>r.optimized.validationResult.isValid);
+                if (validResults.length > 0) {
+                    const bestResult = validResults.reduce((best, current)=>{
+                        const bestScore = 0.6 * best.comparison.compressionRatio + (1 - best.comparison.qualityLoss) * 0.4;
+                        const currentScore = 0.6 * current.comparison.compressionRatio + (1 - current.comparison.qualityLoss) * 0.4;
+                        return currentScore > bestScore ? current : best;
+                    });
+                    console.log(chalk.green(`
+\u{1F3C6} Recommended: ${bestResult.preset.toUpperCase()} configuration`));
+                    console.log(`   ${bestResult.summary}`);
+                }
+            }
+            const shouldGenerateReport = options.report || process.argv.includes('--report') || process.argv.includes('-r');
+            if (shouldGenerateReport) {
+                const outputDir = options.output || dirname(inputPath);
+                const reportPath = join(outputDir, `${basename(inputPath, '.json')}-validation-report.html`);
+                let comparisonResults = [];
+                if (options.configurations.length > 0) {
+                    console.log(chalk.blue("\n\uD83D\uDCCA Generating detailed report..."));
+                    const configMap = {
+                        basic: {
+                            plugins: [
+                                'remove-unused-assets'
+                            ]
+                        },
+                        balanced: {
+                            plugins: [
+                                'remove-unused-assets',
+                                'simplify-paths'
+                            ]
+                        },
+                        complete: {}
+                    };
+                    const testConfigs = options.configurations.map((name)=>({
+                            name,
+                            options: configMap[name] || {}
+                        }));
+                    comparisonResults = await comparisonTool.runComparisonTest(lottieData, testConfigs);
+                }
+                const htmlReport = await generateHTMLReport(lottieData, validationResult, comparisonResults);
+                await promises.writeFile(reportPath, htmlReport);
+                console.log(chalk.green(`
+\u{1F4BE} Detailed HTML report saved: ${reportPath}`));
+            }
+            if (!validationResult.isValid) process.exit(1);
+            console.log(chalk.green("\n\u2705 Validation completed successfully!"));
+        } catch (error) {
+            console.error(chalk.red("\u274C Validation failed:"), error);
+            process.exit(1);
+        }
+    });
+    return validateCmd;
+}
+async function generateHTMLReport(lottieData, validationResult, comparisonResults) {
+    const timestamp = new Date().toISOString();
+    const html = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Lottie Validation Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }
+        .container { max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+        h1 { color: #333; border-bottom: 3px solid #007acc; padding-bottom: 10px; }
+        h2 { color: #555; margin-top: 30px; }
+        .metric-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 20px 0; }
+        .metric-card { background: #f8f9fa; padding: 15px; border-radius: 8px; border-left: 4px solid #007acc; }
+        .metric-label { font-weight: bold; color: #666; font-size: 0.9em; }
+        .metric-value { font-size: 1.4em; color: #333; margin-top: 5px; }
+        .status-good { color: #28a745; }
+        .status-warning { color: #ffc107; }
+        .status-error { color: #dc3545; }
+        table { width: 100%; border-collapse: collapse; margin: 20px 0; }
+        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }
+        th { background-color: #f8f9fa; font-weight: bold; }
+        .recommendation { padding: 15px; border-radius: 8px; margin: 10px 0; }
+        .rec-excellent { background: #d4edda; border-left: 4px solid #28a745; }
+        .rec-good { background: #d1ecf1; border-left: 4px solid #17a2b8; }
+        .rec-acceptable { background: #fff3cd; border-left: 4px solid #ffc107; }
+        .rec-poor { background: #f8d7da; border-left: 4px solid #dc3545; }
+        .timestamp { color: #666; font-size: 0.9em; margin-bottom: 20px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>\u{1F50D} Lottie Validation Report</h1>
+        <div class="timestamp">Generated: ${timestamp}</div>
+        
+        <h2>\u{1F4CA} Basic Information</h2>
+        <div class="metric-grid">
+            <div class="metric-card">
+                <div class="metric-label">File Size</div>
+                <div class="metric-value">${JSON.stringify(lottieData).length.toLocaleString()} bytes</div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-label">Layers</div>
+                <div class="metric-value">${validationResult.metrics.layerCount}</div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-label">Assets</div>
+                <div class="metric-value">${validationResult.metrics.assetCount}</div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-label">Keyframes</div>
+                <div class="metric-value">${validationResult.metrics.totalKeyframes}</div>
+            </div>
+        </div>
+        
+        <h2>\u{2705} Validation Status</h2>
+        <div class="metric-card">
+            <div class="metric-label">Overall Status</div>
+            <div class="metric-value ${validationResult.isValid ? 'status-good' : 'status-error'}">
+                ${validationResult.isValid ? "\u2705 Valid" : "\u274C Invalid"}
+            </div>
+        </div>
+        
+        ${validationResult.errors.length > 0 ? `
+        <h3>\u{274C} Errors</h3>
+        <ul>
+            ${validationResult.errors.map((error)=>`<li class="status-error">${error.message} (${error.severity})</li>`).join('')}
+        </ul>
+        ` : ''}
+        
+        ${validationResult.warnings.length > 0 ? `
+        <h3>\u{26A0}\u{FE0F} Warnings</h3>
+        <ul>
+            ${validationResult.warnings.map((warning)=>`<li class="status-warning">${warning.message}</li>`).join('')}
+        </ul>
+        ` : ''}
+        
+        <h2>\u{1F4C8} Quality Metrics</h2>
+        <div class="metric-grid">
+            <div class="metric-card">
+                <div class="metric-label">Structural Integrity</div>
+                <div class="metric-value">${(100 * validationResult.metrics.structuralIntegrity).toFixed(1)}%</div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-label">Animation Continuity</div>
+                <div class="metric-value">${(100 * validationResult.metrics.animationContinuity).toFixed(1)}%</div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-label">Data Consistency</div>
+                <div class="metric-value">${(100 * validationResult.metrics.dataConsistency).toFixed(1)}%</div>
+            </div>
+            <div class="metric-card">
+                <div class="metric-label">Performance Score</div>
+                <div class="metric-value">${(100 * validationResult.metrics.performanceScore).toFixed(1)}%</div>
+            </div>
+        </div>
+        
+        ${comparisonResults.length > 0 ? `
+        <h2>\u{1F9EA} Compression Comparison</h2>
+        <table>
+            <thead>
+                <tr>
+                    <th>Configuration</th>
+                    <th>Compression</th>
+                    <th>Quality Preserved</th>
+                    <th>Recommendation</th>
+                    <th>Summary</th>
+                </tr>
+            </thead>
+            <tbody>
+                ${comparisonResults.map((result)=>`
+                <tr>
+                    <td><strong>${result.preset}</strong></td>
+                    <td>${(100 * result.comparison.compressionRatio).toFixed(1)}%</td>
+                    <td>${(100 - 100 * result.comparison.qualityLoss).toFixed(1)}%</td>
+                    <td class="rec-${result.recommendation}">${result.recommendation}</td>
+                    <td>${result.summary}</td>
+                </tr>
+                `).join('')}
+            </tbody>
+        </table>
+        ` : ''}
+        
+        <h2>\u{1F3C6} Recommendations</h2>
+        ${comparisonResults.length > 0 ? (()=>{
+        const validResults = comparisonResults.filter((r)=>r.optimized.validationResult.isValid);
+        if (validResults.length > 0) {
+            const bestResult = validResults.reduce((best, current)=>{
+                const bestScore = 0.6 * best.comparison.compressionRatio + (1 - best.comparison.qualityLoss) * 0.4;
+                const currentScore = 0.6 * current.comparison.compressionRatio + (1 - current.comparison.qualityLoss) * 0.4;
+                return currentScore > bestScore ? current : best;
+            });
+            return `
+            <div class="recommendation rec-${bestResult.recommendation}">
+                <strong>Best Overall: ${bestResult.preset.toUpperCase()} configuration</strong><br>
+                ${bestResult.summary}
+            </div>
+            `;
+        }
+        return '<div class="recommendation rec-poor">No valid optimization results found.</div>';
+    })() : '<div class="recommendation">No compression comparison performed.</div>'}
+    </div>
+</body>
+</html>
+  `.trim();
+    return html;
+}
+const program = new Command();
+function parseNestedOption(target, path, value) {
+    const keys = path.split('.');
+    let current = target;
+    for(let i = 0; i < keys.length - 1; i++){
+        const key = keys[i];
+        if (!(key in current)) current[key] = {};
+        current = current[key];
+    }
+    const finalKey = keys[keys.length - 1];
+    current[finalKey] = convertValue(value);
+}
+function convertValue(value) {
+    if ('true' === value.toLowerCase()) return true;
+    if ('false' === value.toLowerCase()) return false;
+    if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+    if (/^-?\d*\.\d+$/.test(value)) return parseFloat(value);
+    return value;
+}
+program.name('lottie-opt').description('A plugin-based Lottie JSON optimizer').version('1.0.0');
+program.addCommand(createValidateCommand());
+program.argument('[input]', 'Input Lottie JSON file').argument('[output]', 'Output file (defaults to input file with .opt.json suffix)').option('--plugins <plugins>', 'Comma-separated list of plugins to use').option('--disable <plugins>', 'Comma-separated list of plugins to disable').option('--plugin-config <config>', 'Plugin configuration in format plugin.option=value,plugin2.option=value').option('-c, --config <path>', 'Path to configuration file').option('-v, --verbose', 'Enable verbose logging').option('-r, --report', 'Generate detailed optimization report').option('--dry-run', 'Analyze without saving output').option('--show-config', 'Show effective plugin configurations').option('--show-config-sources', 'Show configuration sources (default vs preset/user)').option('--list-plugins', 'List available plugins').action(async (input, output, options)=>{
+    try {
+        if (options.listPlugins) return void await listPlugins();
+        if (!input) {
+            console.error(chalk.red('Error: Input file is required when not using --list options'));
+            process.exit(1);
+        }
+        if (!existsSync(input)) {
+            console.error(chalk.red(`Error: Input file "${input}" not found`));
+            process.exit(1);
+        }
+        if (!output) {
+            const ext = input.endsWith('.json') ? '.opt.json' : '.opt.json';
+            output = input.replace(/\.[^/.]+$/, '') + ext;
+        }
+        const logger = createLogger(options.verbose);
+        const optimizer = new LottieOptimizer(logger);
+        console.log('Loading Lottie file...');
+        let lottieData;
+        let originalFileSize;
+        try {
+            const fileContent = readFileSync(external_path_resolve(input), 'utf-8');
+            originalFileSize = Buffer.byteLength(fileContent, 'utf8');
+            lottieData = JSON.parse(fileContent);
+            console.log(`Loaded ${formatSize(originalFileSize)}`);
+        } catch (error) {
+            console.error(`Failed to load file: ${error}`);
+            process.exit(1);
+        }
+        const optimizeOptions = await buildOptimizeOptions(options, input);
+        console.log('Starting optimization...');
+        const result = await optimizer.optimize(lottieData, optimizeOptions, originalFileSize);
+        console.log('Optimization complete!');
+        let finalSize;
+        if (options.dryRun) finalSize = Buffer.byteLength(JSON.stringify(result.data), 'utf8');
+        else {
+            const outputData = JSON.stringify(result.data);
+            finalSize = Buffer.byteLength(outputData, 'utf8');
+            writeFileSync(external_path_resolve(output), outputData);
+            console.log(chalk.green(`\u{2713} Saved to ${output}`));
+        }
+        displayResults(result, options, originalFileSize, finalSize);
+    } catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+        process.exit(1);
+    }
+});
+async function buildOptimizeOptions(options, inputPath) {
+    let optimizeOptions = {};
+    if (options.config) {
+        if (!existsSync(options.config)) throw new Error(`Config file not found: ${options.config}`);
+        const configContent = readFileSync(options.config, 'utf-8');
+        optimizeOptions = JSON.parse(configContent);
+    }
+    if (options.plugins) optimizeOptions.plugins = options.plugins.split(',').map((p)=>p.trim());
+    if (options.disable) optimizeOptions.disable = options.disable.split(',').map((p)=>p.trim());
+    if (options.pluginConfig) {
+        optimizeOptions.pluginOptions = optimizeOptions.pluginOptions || {};
+        const configs = options.pluginConfig.split(',');
+        for (const config of configs){
+            const [pluginOption, value] = config.split('=');
+            if (pluginOption && void 0 !== value) parseNestedOption(optimizeOptions.pluginOptions, pluginOption.trim(), value.trim());
+        }
+    }
+    if (options.showConfig || options.showConfigSources) optimizeOptions.debug = {
+        showEffectiveConfig: options.showConfig || false,
+        showConfigSources: options.showConfigSources || false
+    };
+    return optimizeOptions;
+}
+function displayResults(result, options, actualOriginalSize, actualFinalSize) {
+    const { stats, report } = result;
+    const originalSize = actualOriginalSize || stats.originalSize;
+    const finalSize = actualFinalSize || stats.optimizedSize;
+    const actualReduction = (originalSize - finalSize) / originalSize * 100;
+    console.log('\n' + chalk.bold('Optimization Results:'));
+    console.log(`  Original size: ${chalk.cyan(formatSize(originalSize))}`);
+    console.log(`  Optimized size: ${chalk.green(formatSize(finalSize))}`);
+    console.log(`  Reduction: ${chalk.yellow(actualReduction.toFixed(1) + '%')}`);
+    console.log(`  Processing time: ${chalk.gray(stats.processingTime + 'ms')}`);
+    console.log(`  Plugins applied: ${chalk.blue(stats.pluginsApplied.length)}`);
+    if (options.report) {
+        console.log('\n' + chalk.bold('Plugin Details:'));
+        for (const detail of report.details){
+            const reduction = detail.sizeBefore > 0 ? ((detail.sizeBefore - detail.sizeAfter) / detail.sizeBefore * 100).toFixed(1) : '0.0';
+            console.log(`  ${detail.pluginName}: ${formatSize(detail.sizeBefore)} \u{2192} ${formatSize(detail.sizeAfter)} (${reduction}%)`);
+        }
+    }
+    if (report.warnings.length > 0) {
+        console.log('\n' + chalk.yellow('Warnings:'));
+        report.warnings.forEach((warning)=>{
+            console.log(`  \u{26A0} ${warning}`);
+        });
+    }
+    if (report.errors.length > 0) {
+        console.log('\n' + chalk.red('Errors:'));
+        report.errors.forEach((error)=>{
+            console.log(`  \u{2717} ${error}`);
+        });
+    }
+}
+async function listPlugins() {
+    const optimizer = new LottieOptimizer();
+    const plugins = optimizer.getAvailablePlugins();
+    console.log(chalk.bold('\nAvailable Plugins:'));
+    for (const name of plugins){
+        const plugin = optimizer.getPlugin(name);
+        if (plugin) console.log(`  ${chalk.green(name)} - ${plugin.description}`);
+    }
+}
+process.on('uncaughtException', (error)=>{
+    console.error(chalk.red(`Uncaught error: ${error.message}`));
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason)=>{
+    console.error(chalk.red(`Unhandled rejection: ${reason}`));
+    process.exit(1);
+});
+program.parse();