@depup/lottie-react 2.4.1-depup.0 → 3.0.0-depup.0

package/build/animation/LottieSvg.d.cts

@@ -0,0 +1,24 @@
+import { AnyTag, LottieRenderer, RendererInSvg } from "./types.cjs";
+import { LottieComponent, LottieComponentProps } from "./createLottieComponent.cjs";
+import { ReactNode } from "react";
+//#region src/animation/LottieSvg.d.ts
+/**
+ * What {@link LottieSvg} accepts. Identical to `LottieProps` except that
+ * `renderer` admits only what the svg build contains.
+ */
+type LottieSvgProps<As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends RendererInSvg = typeof LottieRenderer.svg> = LottieComponentProps<As, Children, Renderer>;
+/**
+ * Renders an animation using the svg build of the engine.
+ *
+ * Identical to {@link Lottie} except that `svg` is the only renderer, which the
+ * type enforces: the svg build does not contain the other two, and asking it
+ * for one throws at runtime while its own declarations claim otherwise.
+ *
+ * It sits between the other two builds: smaller than the full one because it
+ * carries a single renderer, and unlike {@link LottieLight} it keeps the
+ * expression engine, so an animation whose properties are driven by
+ * expressions plays as designed.
+ */
+declare const LottieSvg: LottieComponent<"svg">;
+//#endregion
+export { LottieSvg, LottieSvgProps };

package/build/animation/LottieSvg.d.ts

@@ -0,0 +1,24 @@
+import { AnyTag, LottieRenderer, RendererInSvg } from "./types.js";
+import { LottieComponent, LottieComponentProps } from "./createLottieComponent.js";
+import { ReactNode } from "react";
+//#region src/animation/LottieSvg.d.ts
+/**
+ * What {@link LottieSvg} accepts. Identical to `LottieProps` except that
+ * `renderer` admits only what the svg build contains.
+ */
+type LottieSvgProps<As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends RendererInSvg = typeof LottieRenderer.svg> = LottieComponentProps<As, Children, Renderer>;
+/**
+ * Renders an animation using the svg build of the engine.
+ *
+ * Identical to {@link Lottie} except that `svg` is the only renderer, which the
+ * type enforces: the svg build does not contain the other two, and asking it
+ * for one throws at runtime while its own declarations claim otherwise.
+ *
+ * It sits between the other two builds: smaller than the full one because it
+ * carries a single renderer, and unlike {@link LottieLight} it keeps the
+ * expression engine, so an animation whose properties are driven by
+ * expressions plays as designed.
+ */
+declare const LottieSvg: LottieComponent<"svg">;
+//#endregion
+export { LottieSvg, LottieSvgProps };

package/build/animation/LottieSvg.js

@@ -0,0 +1,18 @@
+import { createLottieComponent } from "./createLottieComponent.js";
+import lottieSvg from "lottie-web/build/player/lottie_svg.js";
+//#region src/animation/LottieSvg.tsx
+/**
+* Renders an animation using the svg build of the engine.
+*
+* Identical to {@link Lottie} except that `svg` is the only renderer, which the
+* type enforces: the svg build does not contain the other two, and asking it
+* for one throws at runtime while its own declarations claim otherwise.
+*
+* It sits between the other two builds: smaller than the full one because it
+* carries a single renderer, and unlike {@link LottieLight} it keeps the
+* expression engine, so an animation whose properties are driven by
+* expressions plays as designed.
+*/
+const LottieSvg = createLottieComponent(lottieSvg);
+//#endregion
+export { LottieSvg };

package/build/animation/collectMarkerCrossings.cjs

@@ -0,0 +1,38 @@
+//#region src/animation/collectMarkerCrossings.ts
+/**
+* The markers a playhead movement passed, in the order it passed them.
+*
+* Positions are compared in the playable range's own coordinates: a marker sits
+* at `time - firstFrame`, which follows a segment the way the playhead does.
+* Moving forward passes a marker when the playhead goes from before it to on or
+* beyond it, so landing exactly on one announces it and the next movement away
+* does not repeat it; moving backward mirrors that. A loop's wrap is not a
+* movement this understands: the caller splits it into the two straight runs it
+* really is and calls twice.
+*
+* The markers must be sorted ascending by `time`, which is what lets a scan
+* stop at the first one past the movement. Returns `null` rather than an empty
+* list when nothing was passed, so the per-frame path allocates nothing.
+*/
+function collectMarkerCrossings(markers, firstFrame, previous, current) {
+	if (markers.length === 0 || previous === current) return null;
+	let crossed = null;
+	if (current > previous) for (const marker of markers) {
+		const frame = marker.time - firstFrame;
+		if (frame <= previous) continue;
+		if (frame > current) break;
+		if (crossed === null) crossed = [];
+		crossed.push(marker.payload.name);
+	}
+	else for (let index = markers.length - 1; index >= 0; index -= 1) {
+		const marker = markers[index];
+		const frame = marker.time - firstFrame;
+		if (frame >= previous) continue;
+		if (frame < current) break;
+		if (crossed === null) crossed = [];
+		crossed.push(marker.payload.name);
+	}
+	return crossed;
+}
+//#endregion
+exports.collectMarkerCrossings = collectMarkerCrossings;

package/build/animation/collectMarkerCrossings.js

@@ -0,0 +1,38 @@
+//#region src/animation/collectMarkerCrossings.ts
+/**
+* The markers a playhead movement passed, in the order it passed them.
+*
+* Positions are compared in the playable range's own coordinates: a marker sits
+* at `time - firstFrame`, which follows a segment the way the playhead does.
+* Moving forward passes a marker when the playhead goes from before it to on or
+* beyond it, so landing exactly on one announces it and the next movement away
+* does not repeat it; moving backward mirrors that. A loop's wrap is not a
+* movement this understands: the caller splits it into the two straight runs it
+* really is and calls twice.
+*
+* The markers must be sorted ascending by `time`, which is what lets a scan
+* stop at the first one past the movement. Returns `null` rather than an empty
+* list when nothing was passed, so the per-frame path allocates nothing.
+*/
+function collectMarkerCrossings(markers, firstFrame, previous, current) {
+	if (markers.length === 0 || previous === current) return null;
+	let crossed = null;
+	if (current > previous) for (const marker of markers) {
+		const frame = marker.time - firstFrame;
+		if (frame <= previous) continue;
+		if (frame > current) break;
+		if (crossed === null) crossed = [];
+		crossed.push(marker.payload.name);
+	}
+	else for (let index = markers.length - 1; index >= 0; index -= 1) {
+		const marker = markers[index];
+		const frame = marker.time - firstFrame;
+		if (frame >= previous) continue;
+		if (frame < current) break;
+		if (crossed === null) crossed = [];
+		crossed.push(marker.payload.name);
+	}
+	return crossed;
+}
+//#endregion
+export { collectMarkerCrossings };

package/build/animation/createLottieComponent.cjs

@@ -0,0 +1,131 @@
+const require_mergeRefs = require("../utils/mergeRefs.cjs");
+const require_polymorphicForwardRef = require("./polymorphicForwardRef.cjs");
+const require_renderStyledElement = require("./renderStyledElement.cjs");
+const require_LottieInstanceContext = require("./LottieInstanceContext.cjs");
+const require_LottieDisplay = require("./LottieDisplay.cjs");
+const require_useLottieAnimation = require("./useLottieAnimation.cjs");
+let react = require("react");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/animation/createLottieComponent.tsx
+/**
+* The class the element around the animation carries when you place the
+* animation yourself, and the name React deduplicates its stylesheet by.
+*/
+const lottieRootClass = "lottie-root";
+/**
+* The rules that element carries, at zero specificity and inside the library's
+* cascade layer, so any rule the consumer writes beats them per property.
+*
+* The column is what puts the controls below the animation, and `position` is
+* what the overlays anchor to. The second rule is what lets the animation take
+* the space the controls leave, since the display's own default height is a
+* full 100% that would otherwise push them out of the box.
+*
+* The descendant rule is written as two separate `:where()` selectors rather
+* than one wrapping the combinator. The two are identical CSS at identical zero
+* specificity, so the split form costs nothing and reads as two independent
+* claims about specificity.
+*
+* The third rule is what this element looks like once it fills the screen. A
+* browser paints a black backdrop behind whatever goes fullscreen and leaves
+* the element itself transparent, so without a surface of its own the animation
+* sits on black and the control bar, whose colours are all inherited, keeps the
+* page's dark text and becomes close to unreadable. Measured in Chromium
+* against the real bar. `Canvas` and `CanvasText` are the system page colours
+* and are taken as a pair, so the two can never contradict each other the way a
+* background without a matching foreground can; they follow the consumer's
+* declared colour scheme rather than a colour this library picked, and the rule
+* is zero-specificity like every other, so one line of their own CSS replaces
+* either. It cannot be verified here, since this environment has no Fullscreen
+* API at all.
+*/
+const lottieRootStyles = `:where(.${lottieRootClass}){position:relative;display:flex;flex-direction:column}:where(.${lottieRootClass}) > :where(.${require_LottieDisplay.lottieDisplayClass}){flex:1;height:auto}:where(.${lottieRootClass}:fullscreen){background:Canvas;color:CanvasText}`;
+/**
+* Builds the component all three public ones are: the full, svg and light
+* builds differ in the engine they load and in the renderers they admit, and in
+* nothing else.
+*
+* `Renderers` is what narrows a smaller build to the renderers it actually
+* contains, so asking it for one it does not have is a compile error rather
+* than a blank animation and a runtime throw.
+*/
+function createLottieComponent(engine) {
+	return require_polymorphicForwardRef.polymorphicForwardRef(function Lottie({ as, children, className, lottieRef, src, renderer, rendererSettings, loop, speed, direction, autoplay, segment, assetsPath, debug, subscriptions, ...rest }, ref) {
+		const instance = require_useLottieAnimation.useLottieAnimation(engine, {
+			src,
+			renderer,
+			rendererSettings,
+			loop,
+			speed,
+			direction,
+			autoplay,
+			segment,
+			assetsPath,
+			debug,
+			subscriptions
+		});
+		const { setDisplayRef, setRootRef } = instance;
+		(0, react.useImperativeHandle)(lottieRef, () => ({
+			reload: instance.reload,
+			play: instance.play,
+			pause: instance.pause,
+			stop: instance.stop,
+			seek: instance.seek,
+			scrubStart: instance.scrubStart,
+			scrubTo: instance.scrubTo,
+			scrubEnd: instance.scrubEnd,
+			playSegments: instance.playSegments,
+			resetSegments: instance.resetSegments,
+			setSpeed: instance.setSpeed,
+			setDirection: instance.setDirection,
+			setLoop: instance.setLoop,
+			animationItem: instance.animationItem
+		}));
+		const attached = (0, react.useRef)(0);
+		const countDisplay = (0, react.useCallback)((node) => {
+			attached.current += node === null ? -1 : 1;
+			setDisplayRef(node);
+		}, [setDisplayRef]);
+		const published = (0, react.useMemo)(() => ({
+			...instance,
+			setDisplayRef: countDisplay
+		}), [instance, countDisplay]);
+		const hasChildren = children !== void 0;
+		(0, react.useEffect)(() => {
+			if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+				if (!hasChildren || attached.current === 1) return;
+				if (attached.current === 0) console.warn("[lottie-react] <Lottie> was given children and none of them is a <LottieDisplay>, so the animation has nowhere to be drawn. Add one where the animation should go. A display rendered conditionally has not appeared yet on this pass, which is the one case where this warning is expected.");
+				else console.warn(`[lottie-react] <Lottie> was given ${attached.current} <LottieDisplay> children and an animation can only be drawn in one of them, so the last to attach is the one that gets it. Render one display per animation.`);
+			}
+		}, [hasChildren]);
+		const attachDisplay = (0, react.useMemo)(() => require_mergeRefs.mergeRefs(ref, countDisplay, setRootRef), [
+			ref,
+			countDisplay,
+			setRootRef
+		]);
+		const attachWrapper = (0, react.useMemo)(() => require_mergeRefs.mergeRefs(ref, setRootRef), [ref, setRootRef]);
+		const tag = typeof as === "string" ? as : "div";
+		if (!hasChildren) return require_renderStyledElement.renderStyledElement({
+			tag,
+			styleClass: require_LottieDisplay.lottieDisplayClass,
+			styles: require_LottieDisplay.lottieDisplayStyles,
+			className,
+			attributes: rest,
+			ref: attachDisplay
+		});
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_LottieInstanceContext.LottieInstanceContext.Provider, {
+			value: published,
+			children: require_renderStyledElement.renderStyledElement({
+				tag,
+				styleClass: lottieRootClass,
+				styles: lottieRootStyles,
+				className,
+				attributes: rest,
+				ref: attachWrapper,
+				children
+			})
+		});
+	});
+}
+//#endregion
+exports.createLottieComponent = createLottieComponent;

package/build/animation/createLottieComponent.d.cts

@@ -0,0 +1,45 @@
+import { AnyTag, ElementProps, LottieHandle, LottieRenderer } from "./types.cjs";
+import { UseLottieOptions } from "./useLottieAnimation.cjs";
+import "lottie-web";
+import { ReactNode, Ref } from "react";
+//#region src/animation/createLottieComponent.d.ts
+/**
+ * What a Lottie component owns, on top of everything the animation takes.
+ *
+ * Every name here is checked against the attributes of the elements `as`
+ * permits, so none of them can quietly take an attribute away from a consumer.
+ */
+interface LottieOwnProps<Children extends ReactNode, Renderer extends LottieRenderer> extends UseLottieOptions<Renderer> {
+  /** Which element to render. A `div` unless you say otherwise. */
+  as?: unknown;
+  /**
+   * Anything at all. Passing children means you place the animation yourself
+   * with `<LottieDisplay>`, and this component renders only the box around it.
+   */
+  children?: Children;
+  /** Added to the library's class rather than replacing it. */
+  className?: string;
+  /**
+   * Where to put the imperative handle: the commands, without the values.
+   *
+   * `ref` names the element, because this component accepts that element's
+   * whole attribute set, so the handle needs somewhere of its own to go. Write
+   * `useRef<LottieHandle>(null)`; no ref type is exported.
+   */
+  lottieRef?: Ref<LottieHandle>;
+}
+/** What a Lottie component accepts for a given element. */
+type LottieComponentProps<As extends AnyTag, Children extends ReactNode, Renderer extends LottieRenderer> = ElementProps<LottieOwnProps<Children, Renderer>, As, Children, Renderer>;
+/**
+ * A component that renders an animation, still generic in its element, its
+ * children and its renderer once the engine has been chosen.
+ *
+ * Written out as a call signature rather than inferred, because a function that
+ * returns a component would otherwise settle those parameters at the moment the
+ * component is created and hand back something that is no longer polymorphic.
+ */
+type LottieComponent<Renderers extends LottieRenderer> = <As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends Renderers = Extract<Renderers, typeof LottieRenderer.svg>>(props: LottieComponentProps<As, Children, Renderer> & {
+  ref?: Ref<HTMLElement>;
+}) => ReactNode;
+//#endregion
+export { LottieComponent, LottieComponentProps, LottieOwnProps };

package/build/animation/createLottieComponent.d.ts

@@ -0,0 +1,45 @@
+import { AnyTag, ElementProps, LottieHandle, LottieRenderer } from "./types.js";
+import { UseLottieOptions } from "./useLottieAnimation.js";
+import "lottie-web";
+import { ReactNode, Ref } from "react";
+//#region src/animation/createLottieComponent.d.ts
+/**
+ * What a Lottie component owns, on top of everything the animation takes.
+ *
+ * Every name here is checked against the attributes of the elements `as`
+ * permits, so none of them can quietly take an attribute away from a consumer.
+ */
+interface LottieOwnProps<Children extends ReactNode, Renderer extends LottieRenderer> extends UseLottieOptions<Renderer> {
+  /** Which element to render. A `div` unless you say otherwise. */
+  as?: unknown;
+  /**
+   * Anything at all. Passing children means you place the animation yourself
+   * with `<LottieDisplay>`, and this component renders only the box around it.
+   */
+  children?: Children;
+  /** Added to the library's class rather than replacing it. */
+  className?: string;
+  /**
+   * Where to put the imperative handle: the commands, without the values.
+   *
+   * `ref` names the element, because this component accepts that element's
+   * whole attribute set, so the handle needs somewhere of its own to go. Write
+   * `useRef<LottieHandle>(null)`; no ref type is exported.
+   */
+  lottieRef?: Ref<LottieHandle>;
+}
+/** What a Lottie component accepts for a given element. */
+type LottieComponentProps<As extends AnyTag, Children extends ReactNode, Renderer extends LottieRenderer> = ElementProps<LottieOwnProps<Children, Renderer>, As, Children, Renderer>;
+/**
+ * A component that renders an animation, still generic in its element, its
+ * children and its renderer once the engine has been chosen.
+ *
+ * Written out as a call signature rather than inferred, because a function that
+ * returns a component would otherwise settle those parameters at the moment the
+ * component is created and hand back something that is no longer polymorphic.
+ */
+type LottieComponent<Renderers extends LottieRenderer> = <As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends Renderers = Extract<Renderers, typeof LottieRenderer.svg>>(props: LottieComponentProps<As, Children, Renderer> & {
+  ref?: Ref<HTMLElement>;
+}) => ReactNode;
+//#endregion
+export { LottieComponent, LottieComponentProps, LottieOwnProps };

package/build/animation/createLottieComponent.js

@@ -0,0 +1,131 @@
+import { mergeRefs } from "../utils/mergeRefs.js";
+import { polymorphicForwardRef } from "./polymorphicForwardRef.js";
+import { renderStyledElement } from "./renderStyledElement.js";
+import { LottieInstanceContext } from "./LottieInstanceContext.js";
+import { lottieDisplayClass, lottieDisplayStyles } from "./LottieDisplay.js";
+import { useLottieAnimation } from "./useLottieAnimation.js";
+import { useCallback, useEffect, useImperativeHandle, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/animation/createLottieComponent.tsx
+/**
+* The class the element around the animation carries when you place the
+* animation yourself, and the name React deduplicates its stylesheet by.
+*/
+const lottieRootClass = "lottie-root";
+/**
+* The rules that element carries, at zero specificity and inside the library's
+* cascade layer, so any rule the consumer writes beats them per property.
+*
+* The column is what puts the controls below the animation, and `position` is
+* what the overlays anchor to. The second rule is what lets the animation take
+* the space the controls leave, since the display's own default height is a
+* full 100% that would otherwise push them out of the box.
+*
+* The descendant rule is written as two separate `:where()` selectors rather
+* than one wrapping the combinator. The two are identical CSS at identical zero
+* specificity, so the split form costs nothing and reads as two independent
+* claims about specificity.
+*
+* The third rule is what this element looks like once it fills the screen. A
+* browser paints a black backdrop behind whatever goes fullscreen and leaves
+* the element itself transparent, so without a surface of its own the animation
+* sits on black and the control bar, whose colours are all inherited, keeps the
+* page's dark text and becomes close to unreadable. Measured in Chromium
+* against the real bar. `Canvas` and `CanvasText` are the system page colours
+* and are taken as a pair, so the two can never contradict each other the way a
+* background without a matching foreground can; they follow the consumer's
+* declared colour scheme rather than a colour this library picked, and the rule
+* is zero-specificity like every other, so one line of their own CSS replaces
+* either. It cannot be verified here, since this environment has no Fullscreen
+* API at all.
+*/
+const lottieRootStyles = `:where(.${lottieRootClass}){position:relative;display:flex;flex-direction:column}:where(.${lottieRootClass}) > :where(.${lottieDisplayClass}){flex:1;height:auto}:where(.${lottieRootClass}:fullscreen){background:Canvas;color:CanvasText}`;
+/**
+* Builds the component all three public ones are: the full, svg and light
+* builds differ in the engine they load and in the renderers they admit, and in
+* nothing else.
+*
+* `Renderers` is what narrows a smaller build to the renderers it actually
+* contains, so asking it for one it does not have is a compile error rather
+* than a blank animation and a runtime throw.
+*/
+function createLottieComponent(engine) {
+	return polymorphicForwardRef(function Lottie({ as, children, className, lottieRef, src, renderer, rendererSettings, loop, speed, direction, autoplay, segment, assetsPath, debug, subscriptions, ...rest }, ref) {
+		const instance = useLottieAnimation(engine, {
+			src,
+			renderer,
+			rendererSettings,
+			loop,
+			speed,
+			direction,
+			autoplay,
+			segment,
+			assetsPath,
+			debug,
+			subscriptions
+		});
+		const { setDisplayRef, setRootRef } = instance;
+		useImperativeHandle(lottieRef, () => ({
+			reload: instance.reload,
+			play: instance.play,
+			pause: instance.pause,
+			stop: instance.stop,
+			seek: instance.seek,
+			scrubStart: instance.scrubStart,
+			scrubTo: instance.scrubTo,
+			scrubEnd: instance.scrubEnd,
+			playSegments: instance.playSegments,
+			resetSegments: instance.resetSegments,
+			setSpeed: instance.setSpeed,
+			setDirection: instance.setDirection,
+			setLoop: instance.setLoop,
+			animationItem: instance.animationItem
+		}));
+		const attached = useRef(0);
+		const countDisplay = useCallback((node) => {
+			attached.current += node === null ? -1 : 1;
+			setDisplayRef(node);
+		}, [setDisplayRef]);
+		const published = useMemo(() => ({
+			...instance,
+			setDisplayRef: countDisplay
+		}), [instance, countDisplay]);
+		const hasChildren = children !== void 0;
+		useEffect(() => {
+			if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+				if (!hasChildren || attached.current === 1) return;
+				if (attached.current === 0) console.warn("[lottie-react] <Lottie> was given children and none of them is a <LottieDisplay>, so the animation has nowhere to be drawn. Add one where the animation should go. A display rendered conditionally has not appeared yet on this pass, which is the one case where this warning is expected.");
+				else console.warn(`[lottie-react] <Lottie> was given ${attached.current} <LottieDisplay> children and an animation can only be drawn in one of them, so the last to attach is the one that gets it. Render one display per animation.`);
+			}
+		}, [hasChildren]);
+		const attachDisplay = useMemo(() => mergeRefs(ref, countDisplay, setRootRef), [
+			ref,
+			countDisplay,
+			setRootRef
+		]);
+		const attachWrapper = useMemo(() => mergeRefs(ref, setRootRef), [ref, setRootRef]);
+		const tag = typeof as === "string" ? as : "div";
+		if (!hasChildren) return renderStyledElement({
+			tag,
+			styleClass: lottieDisplayClass,
+			styles: lottieDisplayStyles,
+			className,
+			attributes: rest,
+			ref: attachDisplay
+		});
+		return /* @__PURE__ */ jsx(LottieInstanceContext.Provider, {
+			value: published,
+			children: renderStyledElement({
+				tag,
+				styleClass: lottieRootClass,
+				styles: lottieRootStyles,
+				className,
+				attributes: rest,
+				ref: attachWrapper,
+				children
+			})
+		});
+	});
+}
+//#endregion
+export { createLottieComponent };

package/build/animation/hasExpressions.cjs

@@ -0,0 +1,25 @@
+//#region src/animation/hasExpressions.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Whether a parsed animation carries an expression anywhere in it.
+*
+* An expression is a non-empty string under the key `x` on an animatable
+* property, which is also how the engine finds them. The type of the value is
+* what decides, not the key: inside keyframes `x` names the numeric easing
+* handles, and on a mask it names the expansion property, an object which may
+* itself carry an expression one level down. The walk covers objects and
+* arrays across the whole document rather than `layers` alone, because a
+* precomp's layers live under `assets`, and it stops at the first find. It
+* assumes the tree shape parsed JSON always has: an object that referenced
+* itself would recurse without end.
+*/
+function hasExpressions(value) {
+	if (Array.isArray(value)) return value.some(hasExpressions);
+	if (!isRecord(value)) return false;
+	if (typeof value.x === "string" && value.x !== "") return true;
+	return Object.values(value).some(hasExpressions);
+}
+//#endregion
+exports.hasExpressions = hasExpressions;

package/build/animation/hasExpressions.js

@@ -0,0 +1,25 @@
+//#region src/animation/hasExpressions.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Whether a parsed animation carries an expression anywhere in it.
+*
+* An expression is a non-empty string under the key `x` on an animatable
+* property, which is also how the engine finds them. The type of the value is
+* what decides, not the key: inside keyframes `x` names the numeric easing
+* handles, and on a mask it names the expansion property, an object which may
+* itself carry an expression one level down. The walk covers objects and
+* arrays across the whole document rather than `layers` alone, because a
+* precomp's layers live under `assets`, and it stops at the first find. It
+* assumes the tree shape parsed JSON always has: an object that referenced
+* itself would recurse without end.
+*/
+function hasExpressions(value) {
+	if (Array.isArray(value)) return value.some(hasExpressions);
+	if (!isRecord(value)) return false;
+	if (typeof value.x === "string" && value.x !== "") return true;
+	return Object.values(value).some(hasExpressions);
+}
+//#endregion
+export { hasExpressions };

package/build/animation/normalizeAnimationSource.cjs

@@ -0,0 +1,38 @@
+//#region src/animation/normalizeAnimationSource.ts
+/**
+* Turns the `src` prop into the pair of fields lottie-web understands, or
+* `null` when it is not something an animation could be loaded from.
+*
+* A non-empty string is a URL or path that the engine fetches and parses as
+* JSON. A `.lottie` archive is **not** supported: it is a zip, and nothing here
+* or in lottie-web unpacks one.
+*
+* An object is the parsed animation itself, and it is **always** shallow-copied
+* before the engine sees it. lottie-web writes `__complete` onto whatever it is
+* handed, so a frozen object throws `TypeError: Cannot add property __complete`
+* and takes the whole load down with it. That happens with `import * as data
+* from "./animation.json"` under Node's own JSON modules, whose namespace is
+* not extensible.
+*
+* The copy is unconditional rather than guarded by `Object.isExtensible`,
+* because the shape of that namespace object differs by toolchain: Node's is
+* not extensible while a bundler's usually is. A guard would therefore behave
+* differently depending on who built the consumer's application, and a copy
+* behaves the same everywhere. It costs about 70 nanoseconds and does not grow
+* with the animation, since only the top level is copied.
+*
+* The copy does not protect the objects inside `layers`, which the engine
+* annotates in place. That is harmless, because those writes are idempotent
+* flags, and avoiding it would mean deep-copying the entire animation on every
+* load.
+*/
+function normalizeAnimationSource(source) {
+	if (typeof source === "string") {
+		const path = source.trim();
+		return path.length > 0 ? { path } : null;
+	}
+	if (typeof source === "object" && source !== null && !Array.isArray(source)) return { animationData: { ...source } };
+	return null;
+}
+//#endregion
+exports.normalizeAnimationSource = normalizeAnimationSource;

package/build/animation/normalizeAnimationSource.js

@@ -0,0 +1,38 @@
+//#region src/animation/normalizeAnimationSource.ts
+/**
+* Turns the `src` prop into the pair of fields lottie-web understands, or
+* `null` when it is not something an animation could be loaded from.
+*
+* A non-empty string is a URL or path that the engine fetches and parses as
+* JSON. A `.lottie` archive is **not** supported: it is a zip, and nothing here
+* or in lottie-web unpacks one.
+*
+* An object is the parsed animation itself, and it is **always** shallow-copied
+* before the engine sees it. lottie-web writes `__complete` onto whatever it is
+* handed, so a frozen object throws `TypeError: Cannot add property __complete`
+* and takes the whole load down with it. That happens with `import * as data
+* from "./animation.json"` under Node's own JSON modules, whose namespace is
+* not extensible.
+*
+* The copy is unconditional rather than guarded by `Object.isExtensible`,
+* because the shape of that namespace object differs by toolchain: Node's is
+* not extensible while a bundler's usually is. A guard would therefore behave
+* differently depending on who built the consumer's application, and a copy
+* behaves the same everywhere. It costs about 70 nanoseconds and does not grow
+* with the animation, since only the top level is copied.
+*
+* The copy does not protect the objects inside `layers`, which the engine
+* annotates in place. That is harmless, because those writes are idempotent
+* flags, and avoiding it would mean deep-copying the entire animation on every
+* load.
+*/
+function normalizeAnimationSource(source) {
+	if (typeof source === "string") {
+		const path = source.trim();
+		return path.length > 0 ? { path } : null;
+	}
+	if (typeof source === "object" && source !== null && !Array.isArray(source)) return { animationData: { ...source } };
+	return null;
+}
+//#endregion
+export { normalizeAnimationSource };

package/build/animation/polymorphicForwardRef.cjs

@@ -0,0 +1,18 @@
+//#region src/animation/polymorphicForwardRef.ts
+/**
+* `forwardRef`, with the render function's own type parameters kept.
+*
+* A component that chooses its element through `as` is generic in that tag, and
+* React's `forwardRef` is not: its signature settles the props at one type, so
+* the tag is lost and `as="button" type="button"` stops typechecking while
+* invented props start passing. Handing the same runtime function a signature
+* that carries the parameters through is what restores per-element props.
+*
+* The assertion lives here, alone, so that there is one of it and so that what
+* removes it is written beside it. React 18 is the whole reason it exists,
+* because a function component receives a `ref` only through `forwardRef`
+* there.
+*/
+const polymorphicForwardRef = require("react").forwardRef;
+//#endregion
+exports.polymorphicForwardRef = polymorphicForwardRef;