@glissade/lottie 0.4.0

package/dist/index.js

@@ -0,0 +1,1175 @@
+import { Group, ImageNode, Path, Rect, createScene } from "@glissade/scene";
+import { cubicBezier, formatColor, sampleTrack, track } from "@glissade/core";
+//#region src/spec.ts
+var LottieImportError = class extends Error {
+	problems;
+	constructor(problems) {
+		super(`Lottie import rejected ${problems.length} unsupported feature(s):\n` + problems.map((p) => `  - ${p}`).join("\n"));
+		this.name = "LottieImportError";
+		this.problems = problems;
+	}
+};
+//#endregion
+//#region src/keyframes.ts
+/**
+* Lottie property → glissade Key[] conversion: s/e keyframe normalization,
+* the ease shift (Lottie eases live on the DEPARTING key; glissade EaseSpec
+* lives on the ARRIVING key), hold keys, frame→seconds, and the 1 ms nudge
+* for same-frame double keys.
+*/
+const toSeconds = (tm, tFrames) => (tFrames + tm.st) / tm.fr + tm.offset;
+const isKeyframed = (prop) => prop !== void 0 && Array.isArray(prop.k) && prop.k.length > 0 && typeof prop.k[0] === "object" && prop.k[0] !== null && !Array.isArray(prop.k[0]) && "t" in prop.k[0];
+/** Resolve old-format s/e pairs (value at key j = s_j, falling back to e_{j-1}). */
+function normalizeKeys(raw) {
+	const out = [];
+	for (let j = 0; j < raw.length; j++) {
+		const k = raw[j];
+		const prev = raw[j - 1];
+		const value = k.s ?? prev?.e ?? prev?.s;
+		out.push({
+			t: k.t,
+			value,
+			o: k.o ?? void 0,
+			i: k.i ?? void 0,
+			hold: k.h === 1,
+			to: k.to ?? void 0,
+			ti: k.ti ?? void 0
+		});
+	}
+	return out;
+}
+const handleAt = (h, dim, fallback) => {
+	if (h === void 0) return fallback;
+	if (Array.isArray(h)) return h[Math.min(dim, h.length - 1)] ?? fallback;
+	return h;
+};
+const clamp01 = (v) => Math.min(1, Math.max(0, v));
+/**
+* EaseSpec of the segment DEPARTING `from` (lands on the glissade arrival
+* key). x handles are clamped to [0,1] (the time axis); y stays unclamped
+* (overshoot is lossless). x≈y on both handles is the identity curve →
+* undefined (linear).
+*/
+function departingEase(from, dim = 0) {
+	if (!from.o || !from.i) return void 0;
+	const x1 = clamp01(handleAt(from.o.x, dim, 0));
+	const y1 = handleAt(from.o.y, dim, 0);
+	const x2 = clamp01(handleAt(from.i.x, dim, 1));
+	const y2 = handleAt(from.i.y, dim, 1);
+	if (Math.abs(x1 - y1) < 1e-9 && Math.abs(x2 - y2) < 1e-9) return void 0;
+	return {
+		kind: "cubicBezier",
+		pts: [
+			x1,
+			y1,
+			x2,
+			y2
+		]
+	};
+}
+/** Per-dimension eases differ → vec2 tracks must split to component tracks. */
+function easesDifferPerDim(norm, dims) {
+	for (const k of norm) for (const h of [k.o, k.i]) {
+		if (!h) continue;
+		for (const axis of [h.x, h.y]) {
+			if (!Array.isArray(axis) || axis.length < 2) continue;
+			const first = axis[0];
+			for (let d = 1; d < Math.min(dims, axis.length); d++) if (Math.abs(axis[d] - first) > 1e-9) return true;
+		}
+	}
+	return false;
+}
+/**
+* Same-frame double keys (and any non-increasing t after rounding): nudge the
+* later key 1 ms forward and make it a hold arrival, so the jump is preserved
+* without violating validateTrack's strict ordering.
+*/
+function enforceMonotonic(keys) {
+	for (let j = 1; j < keys.length; j++) {
+		const prev = keys[j - 1];
+		const cur = keys[j];
+		if (cur.t <= prev.t) {
+			cur.t = prev.t + .001;
+			cur.interp = "hold";
+			delete cur.ease;
+		}
+	}
+	return keys;
+}
+/**
+* Generic ease-shifted conversion: glissade key j carries the ease/hold of
+* Lottie key j−1's departing segment.
+*/
+function convertKeys(norm, tm, map, dim = 0) {
+	const out = [];
+	for (let j = 0; j < norm.length; j++) {
+		const n = norm[j];
+		const k = {
+			t: toSeconds(tm, n.t),
+			value: map(n.value, n)
+		};
+		if (j > 0) {
+			const from = norm[j - 1];
+			if (from.hold) k.interp = "hold";
+			else {
+				const ease = departingEase(from, dim);
+				if (ease !== void 0) k.ease = ease;
+			}
+		}
+		out.push(k);
+	}
+	return enforceMonotonic(out);
+}
+const scalarOf = (v) => {
+	if (typeof v === "number") return v;
+	if (Array.isArray(v) && typeof v[0] === "number") return v[0];
+	throw new TypeError(`expected a Lottie scalar, got ${JSON.stringify(v)}`);
+};
+const vec2Of = (v) => {
+	if (Array.isArray(v) && typeof v[0] === "number" && typeof v[1] === "number") return [v[0], v[1]];
+	throw new TypeError(`expected a Lottie vector, got ${JSON.stringify(v)}`);
+};
+const SPATIAL_EPS = 1e-9;
+const hasSpatialTangent = (k) => {
+	for (const t of [k.to, k.ti]) if (t && (Math.abs(t[0] ?? 0) > SPATIAL_EPS || Math.abs(t[1] ?? 0) > SPATIAL_EPS)) return true;
+	return false;
+};
+const cubicPoint = (p0, p1, p2, p3, u) => {
+	const w = 1 - u;
+	const a = w * w * w;
+	const b = 3 * w * w * u;
+	const c = 3 * w * u * u;
+	const d = u * u * u;
+	return [a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]];
+};
+function arcLengthTable(p0, p1, p2, p3, samples = 128) {
+	const us = [0];
+	const lens = [0];
+	let prev = p0;
+	let acc = 0;
+	for (let s = 1; s <= samples; s++) {
+		const u = s / samples;
+		const pt = cubicPoint(p0, p1, p2, p3, u);
+		acc += Math.hypot(pt[0] - prev[0], pt[1] - prev[1]);
+		us.push(u);
+		lens.push(acc);
+		prev = pt;
+	}
+	return {
+		us,
+		lens,
+		total: acc
+	};
+}
+function uAtLength(table, target) {
+	const { us, lens } = table;
+	if (target <= 0) return 0;
+	if (target >= table.total) return 1;
+	let lo = 0;
+	let hi = lens.length - 1;
+	while (lo + 1 < hi) {
+		const mid = lo + hi >> 1;
+		if (lens[mid] <= target) lo = mid;
+		else hi = mid;
+	}
+	const span = lens[hi] - lens[lo];
+	const f = span > 0 ? (target - lens[lo]) / span : 0;
+	return us[lo] + f * (us[hi] - us[lo]);
+}
+/**
+* Position keys with spatial ti/to: segments with tangents are BAKED to dense
+* keys at the document fps by arc-length parameterization — Lottie maps the
+* temporal ease onto distance along the curve, not the bezier parameter, so
+* a parameter-space lerp would diverge mid-segment. Plain segments convert
+* directly with their cubicBezier eases.
+*/
+function convertPositionKeys(norm, tm, docFr) {
+	const out = [];
+	for (let j = 0; j < norm.length; j++) {
+		const n = norm[j];
+		const value = vec2Of(n.value);
+		const t = toSeconds(tm, n.t);
+		const from = norm[j - 1];
+		if (j === 0 || from.hold || !hasSpatialTangent(from)) {
+			const k = {
+				t,
+				value
+			};
+			if (j > 0) if (from.hold) k.interp = "hold";
+			else {
+				const ease = departingEase(from, 0);
+				if (ease !== void 0) k.ease = ease;
+			}
+			out.push(k);
+			continue;
+		}
+		const p0 = vec2Of(from.value);
+		const p3 = value;
+		const p1 = [p0[0] + (from.to?.[0] ?? 0), p0[1] + (from.to?.[1] ?? 0)];
+		const p2 = [p3[0] + (from.ti?.[0] ?? 0), p3[1] + (from.ti?.[1] ?? 0)];
+		const table = arcLengthTable(p0, p1, p2, p3);
+		const easeSpec = departingEase(from, 0);
+		const easeFn = easeSpec !== void 0 && typeof easeSpec === "object" && easeSpec.kind === "cubicBezier" ? cubicBezier(...easeSpec.pts) : (u) => u;
+		const t0 = out[out.length - 1].t;
+		const step = 1 / docFr;
+		for (let s = 1; t0 + s * step < t - step / 2; s++) {
+			const bt = t0 + s * step;
+			const u = uAtLength(table, easeFn((bt - t0) / (t - t0)) * table.total);
+			out.push({
+				t: bt,
+				value: cubicPoint(p0, p1, p2, p3, u)
+			});
+		}
+		out.push({
+			t,
+			value
+		});
+	}
+	return enforceMonotonic(out);
+}
+//#endregion
+//#region src/audit.ts
+/**
+* Fail-fast feature audit (lottie-import.md §1): ONE pass over the document
+* collecting EVERY unsupported feature, so users see all rejections at once.
+* `allowDegraded` downgrades the defined degradable subset (expressions,
+* merge-paths modes ≠ 1) to warnings; degradations are never silent.
+*/
+const LAYER_TYPE_NAMES = {
+	0: "precomp",
+	5: "text",
+	6: "audio",
+	7: "pholderVideo",
+	8: "imageSeq",
+	9: "video",
+	10: "pholderStill",
+	13: "camera"
+};
+const SUPPORTED_LAYER_TYPES = new Set([
+	1,
+	2,
+	3,
+	4
+]);
+function reject(ctx, errorClass, detail) {
+	ctx.problems.push(`[${errorClass}] ${detail}`);
+}
+function degrade(ctx, errorClass, detail) {
+	if (ctx.allowDegraded) ctx.warnings.push(`[${errorClass}] ${detail} — skipped (degraded)`);
+	else ctx.problems.push(`[${errorClass}] ${detail} (degradable: re-run with allowDegraded to warn and skip)`);
+}
+const isProp = (v) => typeof v === "object" && v !== null && ("k" in v || "a" in v || "x" in v);
+function checkExpression(ctx, prop, where) {
+	if (isProp(prop) && typeof prop.x === "string" && prop.x.length > 0) degrade(ctx, "unsupported-expression", `expression on ${where}`);
+}
+/** Non-zero (or animated) skew is unrepresentable in fromTRS. */
+function checkSkew(ctx, tr, where) {
+	for (const [name, prop] of [["sk", tr.sk], ["sa", tr.sa]]) {
+		if (prop === void 0) continue;
+		if (isKeyframed(prop)) {
+			if (normalizeKeys(prop.k).map((k) => scalarOf(k.value)).some((v) => Math.abs(v) > 1e-9)) reject(ctx, "unsupported-transform", `animated skew (${name}) on ${where}`);
+		} else if (prop.k !== void 0 && Math.abs(scalarOf(prop.k)) > 1e-9) reject(ctx, "unsupported-transform", `skew (${name}) on ${where}`);
+	}
+}
+function checkTransformExpressions(ctx, tr, where) {
+	const p = tr.p;
+	if (p && p.s === true) {
+		checkExpression(ctx, p.x, `${where}.p.x`);
+		checkExpression(ctx, p.y, `${where}.p.y`);
+	} else checkExpression(ctx, p, `${where}.p`);
+	checkExpression(ctx, tr.a, `${where}.a`);
+	checkExpression(ctx, tr.s, `${where}.s`);
+	checkExpression(ctx, tr.r, `${where}.r`);
+	checkExpression(ctx, tr.o, `${where}.o`);
+}
+const UNSUPPORTED_SHAPE_ITEMS = {
+	tm: "trim paths",
+	rp: "repeater",
+	rd: "round corners",
+	sr: "polystar",
+	gf: "gradient fill",
+	gs: "gradient stroke",
+	zz: "zig-zag",
+	op: "offset path",
+	pb: "pucker & bloat",
+	tw: "twist"
+};
+function auditShapeItems(ctx, items, where) {
+	let sawGroup = false;
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		if (item.hd === true) continue;
+		const here = `${where}/${item.nm ?? `${item.ty}[${i}]`}`;
+		if (item.ty === "st" && item.d !== void 0) reject(ctx, "unsupported-feature", `stroke dashes at ${here}`);
+		const unsupported = UNSUPPORTED_SHAPE_ITEMS[item.ty];
+		if (unsupported) {
+			reject(ctx, "unsupported-shape-item", `${unsupported} at ${here}`);
+			continue;
+		}
+		switch (item.ty) {
+			case "gr": {
+				sawGroup = true;
+				const inner = item.it ?? [];
+				const tr = inner.find((it) => it.ty === "tr");
+				if (tr) {
+					checkSkew(ctx, tr, here);
+					checkTransformExpressions(ctx, tr, here);
+				}
+				auditShapeItems(ctx, inner.filter((it) => it.ty !== "tr"), here);
+				break;
+			}
+			case "sh":
+				checkExpression(ctx, item.ks, here);
+				break;
+			case "el":
+			case "rc":
+				checkExpression(ctx, item.p, `${here}.p`);
+				checkExpression(ctx, item.s, `${here}.s`);
+				checkExpression(ctx, item.r, `${here}.r`);
+				break;
+			case "fl":
+			case "st":
+				if (item.ty === "fl" && typeof item.r === "number" && item.r === 2) reject(ctx, "unsupported-fill-rule", `even-odd fill at ${here}`);
+				if (sawGroup) reject(ctx, "unsupported-shape-structure", `style inheriting into a preceding group at ${here}`);
+				checkExpression(ctx, item.c, `${here}.c`);
+				checkExpression(ctx, item.o, `${here}.o`);
+				checkExpression(ctx, item.w, `${here}.w`);
+				break;
+			case "mm": {
+				const mode = item.mm ?? 1;
+				if (mode !== 1) degrade(ctx, "unsupported-shape-modifier", `merge paths mode ${mode} at ${here}`);
+				break;
+			}
+			default: break;
+		}
+	}
+}
+function auditLayer(ctx, layer, index, doc) {
+	if (layer.hd === true) return;
+	const where = `layer ${layer.ind ?? index} '${layer.nm ?? "?"}'`;
+	if (!SUPPORTED_LAYER_TYPES.has(layer.ty)) {
+		reject(ctx, "unsupported-layer-type", `${LAYER_TYPE_NAMES[layer.ty] ?? `ty:${layer.ty}`} ${where}`);
+		return;
+	}
+	if (layer.ddd === 1) reject(ctx, "unsupported-feature", `3D layer ${where}`);
+	if ((layer.masksProperties?.length ?? 0) > 0 || layer.hasMask === true) reject(ctx, "unsupported-masking", `masks on ${where}`);
+	if (layer.tt !== void 0 && layer.tt !== 0) reject(ctx, "unsupported-masking", `track matte (tt:${layer.tt}) on ${where}`);
+	if (layer.td !== void 0 && layer.td !== 0) reject(ctx, "unsupported-masking", `matte source (td:${layer.td}) ${where}`);
+	if (layer.tm !== void 0) reject(ctx, "unsupported-time-remap", `time remap on ${where}`);
+	if ((layer.ef?.length ?? 0) > 0) reject(ctx, "unsupported-feature", `effects on ${where}`);
+	if ((layer.sy?.length ?? 0) > 0) reject(ctx, "unsupported-feature", `layer styles on ${where}`);
+	if (layer.sr !== void 0 && layer.sr !== 1) reject(ctx, "unsupported-time-remap", `layer time stretch (sr:${layer.sr}) on ${where}`);
+	if (layer.ao === 1) reject(ctx, "unsupported-transform", `auto-orient on ${where}`);
+	if (layer.ks) {
+		checkSkew(ctx, layer.ks, where);
+		checkTransformExpressions(ctx, layer.ks, where);
+	}
+	if (layer.ty === 2) {
+		const asset = (doc.assets ?? []).find((a) => a.id === layer.refId);
+		if (!asset || typeof asset.p !== "string") reject(ctx, "invalid-asset", `image ${where} references missing asset '${layer.refId ?? ""}'`);
+	}
+	if (layer.shapes) auditShapeItems(ctx, layer.shapes, where);
+}
+/** Throws LottieImportError listing EVERY rejection; returns collected warnings. */
+function auditDocument(doc, allowDegraded) {
+	const ctx = {
+		problems: [],
+		warnings: [],
+		allowDegraded
+	};
+	if (doc.ddd === 1) reject(ctx, "unsupported-feature", "3D document");
+	doc.layers.forEach((layer, i) => auditLayer(ctx, layer, i, doc));
+	if (ctx.problems.length > 0) throw new LottieImportError(ctx.problems);
+	return { warnings: ctx.warnings };
+}
+//#endregion
+//#region src/build.ts
+/**
+* Spec tree → real @glissade/scene nodes. Kept separate from conversion so
+* importLottie's data output stays plain JSON-able.
+*/
+function buildNode(spec) {
+	const base = {
+		id: spec.id,
+		...spec.position !== void 0 ? { position: spec.position } : {},
+		...spec.rotation !== void 0 ? { rotation: spec.rotation } : {},
+		...spec.scale !== void 0 ? { scale: spec.scale } : {},
+		...spec.opacity !== void 0 ? { opacity: spec.opacity } : {},
+		...spec.zIndex !== void 0 ? { zIndex: spec.zIndex } : {}
+	};
+	switch (spec.kind) {
+		case "group": return new Group({
+			...base,
+			children: spec.children.map(buildNode)
+		});
+		case "path": return new Path({
+			...base,
+			data: spec.data,
+			...spec.fill !== void 0 ? { fill: spec.fill } : {},
+			...spec.stroke !== void 0 ? { stroke: spec.stroke } : {},
+			...spec.strokeWidth !== void 0 ? { strokeWidth: spec.strokeWidth } : {}
+		});
+		case "rect": return new Rect({
+			...base,
+			width: spec.width,
+			height: spec.height,
+			...spec.fill !== void 0 ? { fill: spec.fill } : {}
+		});
+		case "image": return new ImageNode({
+			...base,
+			assetId: spec.assetId,
+			width: spec.width,
+			height: spec.height
+		});
+	}
+}
+function buildNodes(specs) {
+	return specs.map(buildNode);
+}
+//#endregion
+//#region src/pathvalue.ts
+const v2 = (p) => [p?.[0] ?? 0, p?.[1] ?? 0];
+/** sh data → one contour. `closedFallback` covers the old top-level `closed` flag. */
+function shToContour(data, closedFallback) {
+	return {
+		closed: data.c ?? closedFallback ?? false,
+		v: data.v.map(v2),
+		in: data.i.map(v2),
+		out: data.o.map(v2)
+	};
+}
+/**
+* Bezier circle constant used by AE/lottie-web for ellipses and round rect
+* corners. The resulting control points are LINEAR in the radius, so lerping
+* converted contours equals converting lerped sizes (exact per-key import).
+*/
+const KAPPA = .5519;
+/** el (ellipse): center p, size s → 4-vertex kappa-form contour. */
+function ellipseContour(center, size) {
+	const rx = size[0] / 2;
+	const ry = size[1] / 2;
+	const [cx, cy] = center;
+	const kx = KAPPA * rx;
+	const ky = KAPPA * ry;
+	return {
+		closed: true,
+		v: [
+			[cx, cy - ry],
+			[cx + rx, cy],
+			[cx, cy + ry],
+			[cx - rx, cy]
+		],
+		in: [
+			[-kx, 0],
+			[0, -ky],
+			[kx, 0],
+			[0, ky]
+		],
+		out: [
+			[kx, 0],
+			[0, ky],
+			[-kx, 0],
+			[0, -ky]
+		]
+	};
+}
+/** rc (rectangle): center p, size s, corner radius r → contour (kappa corners). */
+function rectContour(center, size, radius) {
+	const w = size[0] / 2;
+	const h = size[1] / 2;
+	const [cx, cy] = center;
+	const r = Math.min(Math.max(0, radius), w, h);
+	if (r <= 0) {
+		const z = [0, 0];
+		return {
+			closed: true,
+			v: [
+				[cx + w, cy - h],
+				[cx + w, cy + h],
+				[cx - w, cy + h],
+				[cx - w, cy - h]
+			],
+			in: [
+				z,
+				z,
+				z,
+				z
+			],
+			out: [
+				z,
+				z,
+				z,
+				z
+			]
+		};
+	}
+	const k = KAPPA * r;
+	const z = [0, 0];
+	return {
+		closed: true,
+		v: [
+			[cx + w - r, cy - h],
+			[cx + w, cy - h + r],
+			[cx + w, cy + h - r],
+			[cx + w - r, cy + h],
+			[cx - w + r, cy + h],
+			[cx - w, cy + h - r],
+			[cx - w, cy - h + r],
+			[cx - w + r, cy - h]
+		],
+		in: [
+			z,
+			[0, -k],
+			z,
+			[k, 0],
+			z,
+			[0, k],
+			z,
+			[-k, 0]
+		],
+		out: [
+			[k, 0],
+			z,
+			[0, k],
+			z,
+			[-k, 0],
+			z,
+			[0, -k],
+			z
+		]
+	};
+}
+/**
+* Reverse a contour's winding (Lottie shape direction d:3): reversed vertex
+* order with in/out tangents exchanged. Winding decides nonzero-merge holes.
+*/
+function reverseContour(c) {
+	const idx = c.v.map((_, i) => i).reverse();
+	return {
+		closed: c.closed,
+		v: idx.map((i) => c.v[i]),
+		in: idx.map((i) => c.out[i]),
+		out: idx.map((i) => c.in[i])
+	};
+}
+/** mm mode 1 (merge): plain contour concatenation into one multi-contour value. */
+function mergeContours(values) {
+	return values.flatMap((v) => v);
+}
+//#endregion
+//#region src/convert.ts
+/**
+* Document conversion (lottie-import.md §3 Stage 1): layers → constructor
+* specs + Timeline tracks. Structural rules: the anchor sandwich (outer node
+* carries p/r/s, inner child offset by −a), parent chains nest into the
+* parent's anchor group, layer opacity lives on a CONTENT sibling (Lottie
+* parenting never inherits opacity), ip/op become hold-key opacity wrappers,
+* and Lottie's top-layer-first stacking maps to zIndex = −ind.
+*/
+function uid(ctx, base) {
+	const clean = base.replace(/[^A-Za-z0-9_]/g, "_") || "node";
+	let id = clean;
+	for (let n = 2; ctx.ids.has(id); n++) id = `${clean}_${n}`;
+	ctx.ids.add(id);
+	return id;
+}
+const norms = (prop) => isKeyframed(prop) ? normalizeKeys(prop.k) : void 0;
+/**
+* Lottie color array → hex. The byte-vs-float format is a property of the
+* EXPORTER (whole prop), never of one key: a [1,1,1] key inside a byte-format
+* track is rgb(1,1,1) near-black, not white — so callers classify once over
+* every value of the prop and pass `bytes` in.
+*/
+function lottieColor(value, bytes) {
+	const arr = value;
+	const ch = (i) => bytes ? arr[i] ?? 0 : (arr[i] ?? 0) * 255;
+	const a = arr.length > 3 ? bytes ? (arr[3] ?? 255) / 255 : arr[3] ?? 1 : 1;
+	return formatColor({
+		r: ch(0),
+		g: ch(1),
+		b: ch(2),
+		a
+	});
+}
+/** True when ANY component across the prop's values exceeds 1 (old byte exports). */
+function colorPropIsBytes(values) {
+	return values.some((v) => Array.isArray(v) && v.some((c) => c > 1));
+}
+function pushTrack(ctx, target, type, keys) {
+	if (keys.length === 0) return;
+	ctx.tracks.push(track(target, type, keys));
+}
+const isSplitPosition = (p) => p !== void 0 && p.s === true;
+function applyScalarProp(ctx, spec, prop, targetPath, map, assign, tm) {
+	if (prop === void 0) return;
+	const n = norms(prop);
+	if (n) {
+		const keys = convertKeys(n, tm, (v) => map(scalarOf(v)));
+		assign(keys[0].value);
+		pushTrack(ctx, `${spec.id}/${targetPath}`, "number", keys);
+	} else if (prop.k !== void 0) assign(map(scalarOf(prop.k)));
+}
+function applyVecProp(ctx, spec, prop, targetPath, map, assign, tm) {
+	if (prop === void 0) return;
+	const n = norms(prop);
+	if (n) if (easesDifferPerDim(n, 2)) {
+		for (const dim of [0, 1]) {
+			const keys = convertKeys(n, tm, (v) => map(vec2Of(v))[dim], dim);
+			pushTrack(ctx, `${spec.id}/${targetPath}.${dim === 0 ? "x" : "y"}`, "number", keys);
+		}
+		assign(map(vec2Of(n[0].value)));
+	} else {
+		const keys = convertKeys(n, tm, (v) => map(vec2Of(v)));
+		assign(keys[0].value);
+		pushTrack(ctx, `${spec.id}/${targetPath}`, "vec2", keys);
+	}
+	else if (prop.k !== void 0) assign(map(vec2Of(prop.k)));
+}
+function applyPosition(ctx, spec, p, tm) {
+	if (p === void 0) return;
+	if (isSplitPosition(p)) {
+		const pos = [0, 0];
+		for (const [dim, axis, prop] of [[
+			0,
+			"x",
+			p.x
+		], [
+			1,
+			"y",
+			p.y
+		]]) {
+			const n = norms(prop);
+			if (n) {
+				const keys = convertKeys(n, tm, (v) => scalarOf(v));
+				pos[dim] = keys[0].value;
+				pushTrack(ctx, `${spec.id}/position.${axis}`, "number", keys);
+			} else if (prop.k !== void 0) pos[dim] = scalarOf(prop.k);
+		}
+		spec.position = pos;
+		return;
+	}
+	const n = norms(p);
+	if (n) if (!n.some((k) => [k.to, k.ti].some((t) => t && (Math.abs(t[0] ?? 0) > 1e-9 || Math.abs(t[1] ?? 0) > 1e-9))) && easesDifferPerDim(n, 2)) {
+		for (const [dim, axis] of [[0, "x"], [1, "y"]]) {
+			const keys = convertKeys(n, tm, (v) => vec2Of(v)[dim], dim);
+			pushTrack(ctx, `${spec.id}/position.${axis}`, "number", keys);
+		}
+		spec.position = vec2Of(n[0].value);
+	} else {
+		const keys = convertPositionKeys(n, tm, ctx.doc.fr);
+		spec.position = keys[0].value;
+		pushTrack(ctx, `${spec.id}/position`, "vec2", keys);
+	}
+	else if (p.k !== void 0) spec.position = vec2Of(p.k);
+}
+/**
+* Anchor sandwich: returns the inner group (offset by −a) when the anchor is
+* non-zero or animated; otherwise content attaches to the outer group
+* directly. Negation commutes with lerp, so animated anchors stay exact.
+*/
+function applyAnchor(ctx, outer, a, tm) {
+	const makeInner = () => {
+		const inner = {
+			kind: "group",
+			id: uid(ctx, `${outer.id}__a`),
+			children: []
+		};
+		outer.children.push(inner);
+		return inner;
+	};
+	const n = norms(a);
+	if (n) {
+		const negated = n.map((k) => ({
+			...k,
+			value: k.value.map((c) => -c),
+			to: k.to?.map((c) => -c),
+			ti: k.ti?.map((c) => -c)
+		}));
+		const inner = makeInner();
+		const keys = convertPositionKeys(negated, tm, ctx.doc.fr);
+		inner.position = keys[0].value;
+		pushTrack(ctx, `${inner.id}/position`, "vec2", keys);
+		return inner;
+	}
+	if (a?.k !== void 0) {
+		const [ax, ay] = vec2Of(a.k);
+		if (ax !== 0 || ay !== 0) {
+			const inner = makeInner();
+			inner.position = [-ax, -ay];
+			return inner;
+		}
+	}
+	return outer;
+}
+/** p/r/s onto `spec`; returns the attach point (anchor inner group or spec). */
+function applyPRS(ctx, spec, ks, tm) {
+	applyPosition(ctx, spec, ks.p, tm);
+	applyScalarProp(ctx, spec, ks.r, "rotation", (v) => v, (v) => spec.rotation = v, tm);
+	applyVecProp(ctx, spec, ks.s, "scale", (v) => [v[0] / 100, v[1] / 100], (v) => spec.scale = v, tm);
+	return applyAnchor(ctx, spec, ks.a, tm);
+}
+function applyOpacity(ctx, spec, o, tm) {
+	applyScalarProp(ctx, spec, o, "opacity", (v) => v / 100, (v) => spec.opacity = v, tm);
+}
+const aligned = (a, b) => a.length === b.length && a.every((k, j) => k.t === b[j].t);
+/** el/rc: animated parameters convert per-key (exact when key grids align). */
+function combineParametric(ctx, props, build, tm, where) {
+	const animated = props.filter((p) => p.norm !== void 0);
+	const valuesAt = (pick) => props.map(pick);
+	if (animated.length === 0) return {
+		kind: "static",
+		value: build(valuesAt((p) => p.map(p.staticVal)))
+	};
+	const first = animated[0].norm;
+	if (animated.every((p) => aligned(p.norm, first))) {
+		if (!animated.every((p) => p.norm.every((k, j) => k.hold === first[j].hold && JSON.stringify(k.o ?? null) === JSON.stringify(first[j].o ?? null) && JSON.stringify(k.i ?? null) === JSON.stringify(first[j].i ?? null)))) ctx.warnings.push(`[approximation] ${where}: co-keyed parameters with differing eases use the first parameter's ease (endpoints exact, mid-segment may differ)`);
+		const keys = convertKeys(first, tm, (_v, _n) => []);
+		for (let j = 0; j < keys.length; j++) keys[j].value = build(valuesAt((p) => p.map(p.norm !== void 0 ? p.norm[j].value : p.staticVal)));
+		return {
+			kind: "animated",
+			keys
+		};
+	}
+	ctx.warnings.push(`[approximation] ${where}: independently-keyed parameters baked densely at ${ctx.doc.fr} fps`);
+	const samplers = props.map((p) => {
+		if (p.norm === void 0) return () => p.map(p.staticVal);
+		const keys = p.type === "vec2" ? convertKeys(p.norm, tm, (v) => vec2Of(v)) : convertKeys(p.norm, tm, (v) => scalarOf(v));
+		const tr = track(`__bake/${p.type}`, p.type, keys);
+		return (t) => p.map(sampleTrack(tr, t));
+	});
+	const times = animated.flatMap((p) => p.norm.map((k) => toSeconds(tm, k.t)));
+	const t0 = Math.min(...times);
+	const t1 = Math.max(...times);
+	const step = 1 / ctx.doc.fr;
+	const keys = [];
+	for (let t = t0; t < t1 + step / 2; t += step) keys.push({
+		t: Math.min(t, t1),
+		value: build(samplers.map((s) => s(Math.min(t, t1))))
+	});
+	return {
+		kind: "animated",
+		keys: enforceMonotonic(keys)
+	};
+}
+function geometrySource(ctx, item, tm, where) {
+	switch (item.ty) {
+		case "sh": {
+			const toValue = (v) => (Array.isArray(v) ? v : [v]).map((d) => shToContour(d, item.closed));
+			const n = norms(item.ks);
+			if (n) return {
+				kind: "animated",
+				keys: convertKeys(n, tm, toValue)
+			};
+			const k = item.ks?.k;
+			if (k === void 0) return null;
+			return {
+				kind: "static",
+				value: toValue(k)
+			};
+		}
+		case "el": {
+			const p = {
+				norm: norms(item.p),
+				staticVal: item.p?.k ?? [0, 0],
+				type: "vec2",
+				map: (v) => vec2Of(v)
+			};
+			const s = {
+				norm: norms(item.s),
+				staticVal: item.s?.k ?? [0, 0],
+				type: "vec2",
+				map: (v) => vec2Of(v)
+			};
+			const reversed = item.d === 3;
+			return combineParametric(ctx, [p, s], (vals) => {
+				const c = ellipseContour(vals[0], vals[1]);
+				return [reversed ? reverseContour(c) : c];
+			}, tm, where);
+		}
+		case "rc": {
+			const rProp = typeof item.r === "number" ? { k: item.r } : item.r;
+			const p = {
+				norm: norms(item.p),
+				staticVal: item.p?.k ?? [0, 0],
+				type: "vec2",
+				map: (v) => vec2Of(v)
+			};
+			const s = {
+				norm: norms(item.s),
+				staticVal: item.s?.k ?? [0, 0],
+				type: "vec2",
+				map: (v) => vec2Of(v)
+			};
+			const r = {
+				norm: norms(rProp),
+				staticVal: rProp?.k ?? 0,
+				type: "number",
+				map: (v) => scalarOf(v)
+			};
+			const reversed = item.d === 3;
+			return combineParametric(ctx, [
+				p,
+				s,
+				r
+			], (vals) => {
+				const c = rectContour(vals[0], vals[1], vals[2]);
+				return [reversed ? reverseContour(c) : c];
+			}, tm, where);
+		}
+		default: return null;
+	}
+}
+/** mm mode 1: concatenate contours into one multi-contour source. */
+function mergeGeomSources(ctx, sources, tm, where) {
+	if (sources.length === 1) return sources[0];
+	const animated = sources.filter((s) => s.kind === "animated");
+	if (animated.length === 0) return {
+		kind: "static",
+		value: mergeContours(sources.map((s) => s.value))
+	};
+	const first = animated[0].keys;
+	if (animated.every((s) => s.keys.length === first.length && s.keys.every((k, j) => k.t === first[j].t))) return {
+		kind: "animated",
+		keys: first.map((k, j) => ({
+			...k,
+			value: mergeContours(sources.map((s) => s.kind === "static" ? s.value : s.keys[j].value))
+		}))
+	};
+	ctx.warnings.push(`[approximation] ${where}: merge-paths members with misaligned keys baked densely at ${ctx.doc.fr} fps`);
+	const trackOf = (s) => track("__bake/d", "path", s.keys);
+	const samplers = sources.map((s) => s.kind === "static" ? () => s.value : ((tr) => (t) => sampleTrack(tr, t))(trackOf(s)));
+	const times = animated.flatMap((s) => s.keys.map((k) => k.t));
+	const t0 = Math.min(...times);
+	const t1 = Math.max(...times);
+	const step = 1 / ctx.doc.fr;
+	const keys = [];
+	for (let t = t0; t < t1 + step / 2; t += step) {
+		const at = Math.min(t, t1);
+		keys.push({
+			t: at,
+			value: mergeContours(samplers.map((s) => s(at)))
+		});
+	}
+	return {
+		kind: "animated",
+		keys: enforceMonotonic(keys)
+	};
+}
+function pathSpecFor(ctx, style, geom, idBase, tm) {
+	const spec = {
+		kind: "path",
+		id: uid(ctx, idBase),
+		data: geom.kind === "static" ? geom.value : geom.keys[0].value
+	};
+	if (geom.kind === "animated") pushTrack(ctx, `${spec.id}/d`, "path", geom.keys.map((k) => ({ ...k })));
+	const colorTarget = style.ty === "fl" ? "fill" : "stroke";
+	const cNorm = norms(style.c);
+	if (cNorm) {
+		const bytes = colorPropIsBytes(cNorm.map((k) => k.value));
+		const keys = convertKeys(cNorm, tm, (v) => lottieColor(v, bytes));
+		spec[colorTarget] = keys[0].value;
+		pushTrack(ctx, `${spec.id}/${colorTarget}`, "color", keys);
+	} else if (style.c?.k !== void 0) spec[colorTarget] = lottieColor(style.c.k, colorPropIsBytes([style.c.k]));
+	applyOpacity(ctx, spec, style.o, tm);
+	if (style.ty === "st") {
+		applyScalarProp(ctx, spec, style.w, "strokeWidth", (v) => v, (v) => spec.strokeWidth = v, tm);
+		spec.strokeWidth ??= 1;
+	}
+	return spec;
+}
+/**
+* One items list → children, bottom-to-top (Lottie paints array-first on TOP,
+* glissade Groups paint array-last on top, so emission walks in reverse).
+* Each fill/stroke becomes one Path node per preceding geometry; an mm mode-1
+* merges the list's geometries into a single multi-contour source first.
+*/
+function denormItems(ctx, items, idBase, tm, where) {
+	const visible = items.filter((it) => it.hd !== true);
+	const hasMerge = visible.some((it) => it.ty === "mm" && (it.mm ?? 1) === 1);
+	const slots = [];
+	const geoms = [];
+	let geomCounter = 0;
+	for (let i = 0; i < visible.length; i++) {
+		const item = visible[i];
+		const here = `${where}/${item.nm ?? item.ty}`;
+		if (item.ty === "gr") {
+			const inner = item.it?.filter((it) => it.hd !== true) ?? [];
+			const tr = inner.find((it) => it.ty === "tr");
+			const grSpec = {
+				kind: "group",
+				id: uid(ctx, `${idBase}_${item.nm ?? `g${i}`}`),
+				children: []
+			};
+			let attach = grSpec;
+			if (tr) {
+				attach = applyPRS(ctx, grSpec, tr, tm);
+				applyOpacity(ctx, grSpec, tr.o, tm);
+				const oStatic = typeof tr.o?.k === "number" ? tr.o.k : void 0;
+				if (tr.o !== void 0 && oStatic !== 100) ctx.warnings.push(`[approximation] ${here}: shape-group opacity composites the subtree as a unit; Lottie multiplies per shape — overlapping translucent siblings may differ`);
+			}
+			attach.children.push(...denormItems(ctx, inner.filter((it) => it.ty !== "tr"), grSpec.id, tm, here));
+			slots.push({
+				index: i,
+				node: grSpec
+			});
+		} else if (item.ty === "sh" || item.ty === "el" || item.ty === "rc") {
+			const source = geometrySource(ctx, item, tm, here);
+			if (source) geoms.push({
+				index: i,
+				source,
+				name: item.nm ?? `geo${geomCounter++}`
+			});
+		} else if (item.ty === "fl" || item.ty === "st") {
+			const preceding = geoms.filter((g) => g.index < i);
+			if (preceding.length === 0) continue;
+			const styleNodes = (hasMerge ? [{
+				source: mergeGeomSources(ctx, preceding.map((g) => g.source), tm, here),
+				name: "merged"
+			}] : preceding).map((g) => pathSpecFor(ctx, item, g.source, `${idBase}_${item.nm ?? item.ty}_${g.name}`, tm));
+			slots.push({
+				index: i,
+				styleNodes
+			});
+		}
+	}
+	const out = [];
+	for (let s = slots.length - 1; s >= 0; s--) {
+		const slot = slots[s];
+		if (slot.node) out.push(slot.node);
+		if (slot.styleNodes) out.push(...slot.styleNodes);
+	}
+	return out;
+}
+function visibilityWrapper(ctx, base, layer, content, ind) {
+	const { doc } = ctx;
+	const docDur = (doc.op - doc.ip) / doc.fr;
+	const ipS = layer.ip / doc.fr + ctx.offset;
+	const opS = layer.op / doc.fr + ctx.offset;
+	if (ipS <= 0 && opS >= docDur) return content;
+	const vis = {
+		kind: "group",
+		id: uid(ctx, `${base}__v`),
+		children: [content],
+		zIndex: -ind
+	};
+	if (opS <= 0) {
+		vis.opacity = 0;
+		return vis;
+	}
+	const keys = [];
+	if (ipS > 0) {
+		keys.push({
+			t: 0,
+			value: 0
+		}, {
+			t: ipS,
+			value: 1,
+			interp: "hold"
+		});
+		vis.opacity = 0;
+	} else keys.push({
+		t: 0,
+		value: 1
+	});
+	if (opS < docDur) keys.push({
+		t: opS,
+		value: 0,
+		interp: "hold"
+	});
+	pushTrack(ctx, `${vis.id}/opacity`, "number", enforceMonotonic(keys));
+	return vis;
+}
+function convertLayer(ctx, layer, index) {
+	const ind = layer.ind ?? index;
+	const base = uid(ctx, layer.nm ?? `layer${ind}`);
+	const tm = {
+		fr: ctx.doc.fr,
+		st: layer.st ?? 0,
+		offset: ctx.offset
+	};
+	const outer = {
+		kind: "group",
+		id: base,
+		children: [],
+		zIndex: -ind
+	};
+	const attach = layer.ks ? applyPRS(ctx, outer, layer.ks, tm) : outer;
+	const contentChildren = [];
+	if (layer.ty === 4 && layer.shapes) contentChildren.push(...denormItems(ctx, layer.shapes, base, tm, `layer '${layer.nm ?? ind}'`));
+	else if (layer.ty === 1) {
+		const w = layer.sw ?? 0;
+		const h = layer.sh ?? 0;
+		const solid = {
+			kind: "rect",
+			id: uid(ctx, `${base}__solid`),
+			width: w,
+			height: h,
+			position: [w / 2, h / 2]
+		};
+		if (layer.sc !== void 0) solid.fill = layer.sc;
+		contentChildren.push(solid);
+	} else if (layer.ty === 2) {
+		const asset = (ctx.doc.assets ?? []).find((a) => a.id === layer.refId);
+		ctx.assets[asset.id] = {
+			kind: "image",
+			url: `${asset.u ?? ""}${asset.p ?? ""}`
+		};
+		const w = asset.w ?? 0;
+		const h = asset.h ?? 0;
+		const image = {
+			kind: "image",
+			id: uid(ctx, `${base}__img`),
+			assetId: asset.id,
+			width: w,
+			height: h,
+			position: [w / 2, h / 2]
+		};
+		contentChildren.push(image);
+	}
+	if (layer.ty !== 3 && layer.hd !== true) {
+		const content = {
+			kind: "group",
+			id: uid(ctx, `${base}__c`),
+			children: contentChildren,
+			zIndex: -ind
+		};
+		applyOpacity(ctx, content, layer.ks?.o, tm);
+		attach.children.push(visibilityWrapper(ctx, base, layer, content, ind));
+	}
+	return {
+		layer,
+		outer,
+		attach
+	};
+}
+function convertDocument(doc, warnings) {
+	const ctx = {
+		doc,
+		tracks: [],
+		warnings,
+		assets: {},
+		ids: /* @__PURE__ */ new Set(),
+		offset: -doc.ip / doc.fr
+	};
+	const records = doc.layers.map((layer, i) => convertLayer(ctx, layer, i));
+	const byInd = /* @__PURE__ */ new Map();
+	records.forEach((r, i) => byInd.set(r.layer.ind ?? i, r));
+	const roots = [];
+	for (const r of records) {
+		const parent = r.layer.parent !== void 0 ? byInd.get(r.layer.parent) : void 0;
+		if (parent && parent !== r) parent.attach.children.push(r.outer);
+		else roots.push(r.outer);
+	}
+	const timeline = {
+		version: 1,
+		duration: (doc.op - doc.ip) / doc.fr,
+		fps: doc.fr,
+		tracks: ctx.tracks,
+		...Object.keys(ctx.assets).length > 0 ? { assets: ctx.assets } : {}
+	};
+	return {
+		size: {
+			w: doc.w,
+			h: doc.h
+		},
+		nodes: roots,
+		timeline,
+		warnings: ctx.warnings
+	};
+}
+//#endregion
+//#region src/codegen.ts
+const CTOR = {
+	group: "Group",
+	path: "Path",
+	rect: "Rect",
+	image: "ImageNode"
+};
+function lit(value, indent) {
+	return JSON.stringify(value, null, 2).split("\n").join(`\n${indent}`);
+}
+function emitNode(spec, indent) {
+	const inner = `${indent}  `;
+	const props = [`id: ${JSON.stringify(spec.id)}`];
+	if (spec.position) props.push(`position: ${JSON.stringify(spec.position)}`);
+	if (spec.rotation !== void 0) props.push(`rotation: ${spec.rotation}`);
+	if (spec.scale) props.push(`scale: ${JSON.stringify(spec.scale)}`);
+	if (spec.opacity !== void 0) props.push(`opacity: ${spec.opacity}`);
+	if (spec.zIndex !== void 0) props.push(`zIndex: ${spec.zIndex}`);
+	switch (spec.kind) {
+		case "group":
+			if (spec.children.length > 0) {
+				const children = spec.children.map((c) => `${inner}  ${emitNode(c, `${inner}  `)},`).join("\n");
+				props.push(`children: [\n${children}\n${inner}]`);
+			}
+			break;
+		case "path":
+			props.push(`data: ${lit(spec.data, inner)} as PathValue`);
+			if (spec.fill !== void 0) props.push(`fill: ${JSON.stringify(spec.fill)}`);
+			if (spec.stroke !== void 0) props.push(`stroke: ${JSON.stringify(spec.stroke)}`);
+			if (spec.strokeWidth !== void 0) props.push(`strokeWidth: ${spec.strokeWidth}`);
+			break;
+		case "rect":
+			props.push(`width: ${spec.width}`, `height: ${spec.height}`);
+			if (spec.fill !== void 0) props.push(`fill: ${JSON.stringify(spec.fill)}`);
+			break;
+		case "image":
+			props.push(`assetId: ${JSON.stringify(spec.assetId)}`, `width: ${spec.width}`, `height: ${spec.height}`);
+			break;
+	}
+	return `new ${CTOR[spec.kind]}({\n${props.map((p) => `${inner}${p},`).join("\n")}\n${indent}})`;
+}
+function generateSceneModule(result, opts = {}) {
+	const usedKinds = /* @__PURE__ */ new Set();
+	const visit = (s) => {
+		usedKinds.add(s.kind);
+		if (s.kind === "group") s.children.forEach(visit);
+	};
+	result.nodes.forEach(visit);
+	const ctors = [...usedKinds].map((k) => CTOR[k]).sort();
+	const usesPath = usedKinds.has("path");
+	const children = result.nodes.map((n) => `      ${emitNode(n, "      ")},`).join("\n");
+	return `${`// Generated by gs import${opts.source ? ` from ${opts.source}` : ""} (@glissade/lottie).`}${result.warnings.length ? `\n// Import warnings:\n${result.warnings.map((w) => `//   ${w}`).join("\n")}` : ""}
+import { ${ctors.join(", ")}, createScene, type SceneModule } from '@glissade/scene';
+import type { ${usesPath ? "PathValue, " : ""}Timeline } from '@glissade/core';
+
+export const timeline = ${lit(result.timeline, "")} as unknown as Timeline;
+
+export default {
+  createScene: () =>
+    createScene({
+      size: ${JSON.stringify(result.size)},
+      children: [
+${children}
+      ],
+    }),
+  timeline,
+} satisfies SceneModule;
+`;
+}
+//#endregion
+//#region src/index.ts
+function assertDocument(json) {
+	const doc = json;
+	if (doc === null || typeof doc !== "object" || typeof doc.fr !== "number" || doc.fr <= 0 || typeof doc.ip !== "number" || typeof doc.op !== "number" || typeof doc.w !== "number" || typeof doc.h !== "number" || !Array.isArray(doc.layers)) throw new LottieImportError(["[invalid-document] not a Lottie document (missing fr/ip/op/w/h/layers)"]);
+	return doc;
+}
+function importLottie(json, opts = {}) {
+	const doc = assertDocument(json);
+	const { warnings } = auditDocument(doc, opts.allowDegraded === true);
+	const out = convertDocument(doc, warnings);
+	return {
+		...out,
+		toSceneModule() {
+			return {
+				createScene: () => createScene({
+					size: out.size,
+					children: buildNodes(out.nodes)
+				}),
+				timeline: out.timeline
+			};
+		}
+	};
+}
+//#endregion
+export { KAPPA, LottieImportError, buildNode, buildNodes, colorPropIsBytes, ellipseContour, generateSceneModule, importLottie, lottieColor, mergeContours, rectContour, reverseContour, shToContour };