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

package/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2022 David Gamote
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -13,16 +13,10 @@ npm install @depup/lottie-react
 
 | Field | Value |
 |-------|-------|
-| Original | [lottie-react](https://www.npmjs.com/package/lottie-react) @ 2.4.1 |
-| Processed | 2026-03-18 |
-| Smoke test | failed |
-| Deps updated | 1 |
-
-## Dependency Changes
-
-| Dependency | From | To |
-|------------|------|-----|
-| lottie-web | ^5.10.2 | ^5.13.0 |
+| Original | [lottie-react](https://www.npmjs.com/package/lottie-react) @ 3.0.0 |
+| Processed | 2026-08-16 |
+| Smoke test | passed |
+| Deps updated | 0 |
 
 ---
 

package/build/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/build/animation/Lottie.cjs

@@ -0,0 +1,39 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_createLottieComponent = require("./createLottieComponent.cjs");
+let lottie_web = require("lottie-web");
+lottie_web = require_runtime.__toESM(lottie_web, 1);
+//#region src/animation/Lottie.tsx
+/**
+* Renders an animation.
+*
+* With no children it is the animation itself: the element it renders is where
+* the animation is drawn, and `className`, `style` and every other attribute
+* land on that element. Give it a size, since an animation fills whatever box
+* it is in and a box of no height shows nothing.
+*
+* ```jsx
+* <Lottie src={animation} className="h-64" autoplay loop />
+* ```
+*
+* With children it steps back and becomes the box around them, and you say
+* where the animation goes with `<LottieDisplay>`. Anything else you render
+* beside it finds the same animation without being handed it.
+*
+* ```jsx
+* <Lottie src={animation}>
+*   <MyCaption />
+*   <LottieDisplay />
+* </Lottie>
+* ```
+*
+* `ref` names the element either way. Commands go through `lottieRef`, and
+* anything the animation reports comes back through `subscriptions`.
+*
+* This is the full build, so every renderer is available. Reach for
+* `LottieSvg` instead when only `svg` is needed, or `LottieLight` when the
+* animation uses no expressions either: each carries a smaller copy of the
+* engine.
+*/
+const Lottie = require_createLottieComponent.createLottieComponent(lottie_web.default);
+//#endregion
+exports.Lottie = Lottie;

package/build/animation/Lottie.d.cts

@@ -0,0 +1,47 @@
+import { AnyTag, LottieRenderer } from "./types.cjs";
+import { LottieComponent, LottieComponentProps } from "./createLottieComponent.cjs";
+import { ReactNode } from "react";
+//#region src/animation/Lottie.d.ts
+/**
+ * What {@link Lottie} accepts: our own props, plus every attribute of the
+ * element it renders.
+ *
+ * Our props all carry a description, so hovering one at the call site tells you
+ * whose it is. Everything else belongs to the element and behaves exactly as it
+ * does anywhere else.
+ */
+type LottieProps<As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends LottieRenderer = typeof LottieRenderer.svg> = LottieComponentProps<As, Children, Renderer>;
+/**
+ * Renders an animation.
+ *
+ * With no children it is the animation itself: the element it renders is where
+ * the animation is drawn, and `className`, `style` and every other attribute
+ * land on that element. Give it a size, since an animation fills whatever box
+ * it is in and a box of no height shows nothing.
+ *
+ * ```jsx
+ * <Lottie src={animation} className="h-64" autoplay loop />
+ * ```
+ *
+ * With children it steps back and becomes the box around them, and you say
+ * where the animation goes with `<LottieDisplay>`. Anything else you render
+ * beside it finds the same animation without being handed it.
+ *
+ * ```jsx
+ * <Lottie src={animation}>
+ *   <MyCaption />
+ *   <LottieDisplay />
+ * </Lottie>
+ * ```
+ *
+ * `ref` names the element either way. Commands go through `lottieRef`, and
+ * anything the animation reports comes back through `subscriptions`.
+ *
+ * This is the full build, so every renderer is available. Reach for
+ * `LottieSvg` instead when only `svg` is needed, or `LottieLight` when the
+ * animation uses no expressions either: each carries a smaller copy of the
+ * engine.
+ */
+declare const Lottie: LottieComponent<LottieRenderer>;
+//#endregion
+export { Lottie, LottieProps };

package/build/animation/Lottie.d.ts

@@ -0,0 +1,47 @@
+import { AnyTag, LottieRenderer } from "./types.js";
+import { LottieComponent, LottieComponentProps } from "./createLottieComponent.js";
+import { ReactNode } from "react";
+//#region src/animation/Lottie.d.ts
+/**
+ * What {@link Lottie} accepts: our own props, plus every attribute of the
+ * element it renders.
+ *
+ * Our props all carry a description, so hovering one at the call site tells you
+ * whose it is. Everything else belongs to the element and behaves exactly as it
+ * does anywhere else.
+ */
+type LottieProps<As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends LottieRenderer = typeof LottieRenderer.svg> = LottieComponentProps<As, Children, Renderer>;
+/**
+ * Renders an animation.
+ *
+ * With no children it is the animation itself: the element it renders is where
+ * the animation is drawn, and `className`, `style` and every other attribute
+ * land on that element. Give it a size, since an animation fills whatever box
+ * it is in and a box of no height shows nothing.
+ *
+ * ```jsx
+ * <Lottie src={animation} className="h-64" autoplay loop />
+ * ```
+ *
+ * With children it steps back and becomes the box around them, and you say
+ * where the animation goes with `<LottieDisplay>`. Anything else you render
+ * beside it finds the same animation without being handed it.
+ *
+ * ```jsx
+ * <Lottie src={animation}>
+ *   <MyCaption />
+ *   <LottieDisplay />
+ * </Lottie>
+ * ```
+ *
+ * `ref` names the element either way. Commands go through `lottieRef`, and
+ * anything the animation reports comes back through `subscriptions`.
+ *
+ * This is the full build, so every renderer is available. Reach for
+ * `LottieSvg` instead when only `svg` is needed, or `LottieLight` when the
+ * animation uses no expressions either: each carries a smaller copy of the
+ * engine.
+ */
+declare const Lottie: LottieComponent<LottieRenderer>;
+//#endregion
+export { Lottie, LottieProps };

package/build/animation/Lottie.js

@@ -0,0 +1,37 @@
+import { createLottieComponent } from "./createLottieComponent.js";
+import lottie from "lottie-web";
+//#region src/animation/Lottie.tsx
+/**
+* Renders an animation.
+*
+* With no children it is the animation itself: the element it renders is where
+* the animation is drawn, and `className`, `style` and every other attribute
+* land on that element. Give it a size, since an animation fills whatever box
+* it is in and a box of no height shows nothing.
+*
+* ```jsx
+* <Lottie src={animation} className="h-64" autoplay loop />
+* ```
+*
+* With children it steps back and becomes the box around them, and you say
+* where the animation goes with `<LottieDisplay>`. Anything else you render
+* beside it finds the same animation without being handed it.
+*
+* ```jsx
+* <Lottie src={animation}>
+*   <MyCaption />
+*   <LottieDisplay />
+* </Lottie>
+* ```
+*
+* `ref` names the element either way. Commands go through `lottieRef`, and
+* anything the animation reports comes back through `subscriptions`.
+*
+* This is the full build, so every renderer is available. Reach for
+* `LottieSvg` instead when only `svg` is needed, or `LottieLight` when the
+* animation uses no expressions either: each carries a smaller copy of the
+* engine.
+*/
+const Lottie = createLottieComponent(lottie);
+//#endregion
+export { Lottie };

package/build/animation/LottieDisplay.cjs

@@ -0,0 +1,55 @@
+const require_mergeRefs = require("../utils/mergeRefs.cjs");
+const require_polymorphicForwardRef = require("./polymorphicForwardRef.cjs");
+const require_renderStyledElement = require("./renderStyledElement.cjs");
+const require_useLottieInstance = require("./useLottieInstance.cjs");
+let react = require("react");
+//#region src/animation/LottieDisplay.tsx
+/**
+* The class the display carries, and the name React deduplicates its stylesheet
+* by. One string does both, so two components can only collide in the document
+* if they already collide in CSS.
+*/
+const lottieDisplayClass = "lottie-display";
+/**
+* The display's own defaults, at zero specificity and inside the library's
+* cascade layer, so that any rule the consumer writes beats them per property.
+*
+* Two of these are required rather than chosen. `position` is what the html
+* renderer needs, because the box it appends is absolutely positioned, and it
+* is what the overlays anchor to. `padding` is a correctness fix: the canvas
+* renderer sizes its bitmap from `offsetWidth`, which includes padding, so a
+* padded display draws at the wrong scale.
+*
+* Every selector stays scoped to the class. An unscoped one would restyle the
+* host page's own elements.
+*/
+const lottieDisplayStyles = `:where(.${lottieDisplayClass}){width:100%;height:100%;position:relative;overflow:hidden;border:0;padding:0;background:none;appearance:none}`;
+/**
+* The element the animation is drawn inside.
+*
+* Render it among the children of a component that publishes an animation to
+* say where the animation goes, or on its own with the result of `useLottie` to
+* place it anywhere at all. It takes every attribute of the element it renders,
+* and `ref` names that same element.
+*
+* ```jsx
+* const lottie = useLottie({ src });
+* <LottieDisplay lottie={lottie} as="section" className="h-64" />
+* ```
+*/
+const LottieDisplay = require_polymorphicForwardRef.polymorphicForwardRef(function LottieDisplay({ lottie, as, className, ...rest }, ref) {
+	const { setDisplayRef } = require_useLottieInstance.useLottieInstance(lottie);
+	const attach = (0, react.useMemo)(() => require_mergeRefs.mergeRefs(ref, setDisplayRef), [ref, setDisplayRef]);
+	return require_renderStyledElement.renderStyledElement({
+		tag: typeof as === "string" ? as : "div",
+		styleClass: lottieDisplayClass,
+		styles: lottieDisplayStyles,
+		className,
+		attributes: rest,
+		ref: attach
+	});
+});
+//#endregion
+exports.LottieDisplay = LottieDisplay;
+exports.lottieDisplayClass = lottieDisplayClass;
+exports.lottieDisplayStyles = lottieDisplayStyles;

package/build/animation/LottieDisplay.d.cts

@@ -0,0 +1,46 @@
+import { AnyTag, ContainerTag, ElementProps, LottieInstance, LottieRenderer } from "./types.cjs";
+//#region src/animation/LottieDisplay.d.ts
+/** What this component owns. Every other prop belongs to the element. */
+interface LottieDisplayOwnProps {
+  /** The animation to draw. Omit it inside a component that publishes one. */
+  lottie?: LottieInstance;
+  /** Which element to render. A `div` unless you say otherwise. */
+  as?: unknown;
+  /**
+   * Never any: lottie-web owns what is inside the display and rebuilds it on
+   * every load, so anything React put there would be wiped without warning.
+   */
+  children?: never;
+  /** Added to the library's class rather than replacing it. */
+  className?: string;
+}
+/**
+ * What {@link LottieDisplay} accepts for a given element.
+ *
+ * `as` is checked against the case every renderer allows, an element that may
+ * hold the `<svg>` or `<canvas>` two of the three append, because the display
+ * takes an animation rather than a source and so cannot see which renderer is
+ * in use. With `renderer="html"` a block element is required and nothing here
+ * can enforce it.
+ */
+type LottieDisplayProps<As extends AnyTag = "div"> = ElementProps<LottieDisplayOwnProps, As, undefined, typeof LottieRenderer.svg>;
+/**
+ * The element the animation is drawn inside.
+ *
+ * Render it among the children of a component that publishes an animation to
+ * say where the animation goes, or on its own with the result of `useLottie` to
+ * place it anywhere at all. It takes every attribute of the element it renders,
+ * and `ref` names that same element.
+ *
+ * ```jsx
+ * const lottie = useLottie({ src });
+ * <LottieDisplay lottie={lottie} as="section" className="h-64" />
+ * ```
+ */
+declare const LottieDisplay: <As extends AnyTag = "div">(props: Omit<LottieDisplayOwnProps, "as"> & {
+  as?: (As extends ContainerTag ? As : {
+    readonly __lottie: "this tag cannot hold an animation";
+  }) | undefined;
+} & Omit<import("react").PropsWithoutRef<import("react").ComponentProps<As>>, keyof LottieDisplayOwnProps> & import("react").RefAttributes<HTMLElement>) => import("react").ReactNode;
+//#endregion
+export { LottieDisplay, LottieDisplayProps };

package/build/animation/LottieDisplay.d.ts

@@ -0,0 +1,46 @@
+import { AnyTag, ContainerTag, ElementProps, LottieInstance, LottieRenderer } from "./types.js";
+//#region src/animation/LottieDisplay.d.ts
+/** What this component owns. Every other prop belongs to the element. */
+interface LottieDisplayOwnProps {
+  /** The animation to draw. Omit it inside a component that publishes one. */
+  lottie?: LottieInstance;
+  /** Which element to render. A `div` unless you say otherwise. */
+  as?: unknown;
+  /**
+   * Never any: lottie-web owns what is inside the display and rebuilds it on
+   * every load, so anything React put there would be wiped without warning.
+   */
+  children?: never;
+  /** Added to the library's class rather than replacing it. */
+  className?: string;
+}
+/**
+ * What {@link LottieDisplay} accepts for a given element.
+ *
+ * `as` is checked against the case every renderer allows, an element that may
+ * hold the `<svg>` or `<canvas>` two of the three append, because the display
+ * takes an animation rather than a source and so cannot see which renderer is
+ * in use. With `renderer="html"` a block element is required and nothing here
+ * can enforce it.
+ */
+type LottieDisplayProps<As extends AnyTag = "div"> = ElementProps<LottieDisplayOwnProps, As, undefined, typeof LottieRenderer.svg>;
+/**
+ * The element the animation is drawn inside.
+ *
+ * Render it among the children of a component that publishes an animation to
+ * say where the animation goes, or on its own with the result of `useLottie` to
+ * place it anywhere at all. It takes every attribute of the element it renders,
+ * and `ref` names that same element.
+ *
+ * ```jsx
+ * const lottie = useLottie({ src });
+ * <LottieDisplay lottie={lottie} as="section" className="h-64" />
+ * ```
+ */
+declare const LottieDisplay: <As extends AnyTag = "div">(props: Omit<LottieDisplayOwnProps, "as"> & {
+  as?: (As extends ContainerTag ? As : {
+    readonly __lottie: "this tag cannot hold an animation";
+  }) | undefined;
+} & Omit<import("react").PropsWithoutRef<import("react").ComponentProps<As>>, keyof LottieDisplayOwnProps> & import("react").RefAttributes<HTMLElement>) => import("react").ReactNode;
+//#endregion
+export { LottieDisplay, LottieDisplayProps };

package/build/animation/LottieDisplay.js

@@ -0,0 +1,53 @@
+import { mergeRefs } from "../utils/mergeRefs.js";
+import { polymorphicForwardRef } from "./polymorphicForwardRef.js";
+import { renderStyledElement } from "./renderStyledElement.js";
+import { useLottieInstance } from "./useLottieInstance.js";
+import { useMemo } from "react";
+//#region src/animation/LottieDisplay.tsx
+/**
+* The class the display carries, and the name React deduplicates its stylesheet
+* by. One string does both, so two components can only collide in the document
+* if they already collide in CSS.
+*/
+const lottieDisplayClass = "lottie-display";
+/**
+* The display's own defaults, at zero specificity and inside the library's
+* cascade layer, so that any rule the consumer writes beats them per property.
+*
+* Two of these are required rather than chosen. `position` is what the html
+* renderer needs, because the box it appends is absolutely positioned, and it
+* is what the overlays anchor to. `padding` is a correctness fix: the canvas
+* renderer sizes its bitmap from `offsetWidth`, which includes padding, so a
+* padded display draws at the wrong scale.
+*
+* Every selector stays scoped to the class. An unscoped one would restyle the
+* host page's own elements.
+*/
+const lottieDisplayStyles = `:where(.${lottieDisplayClass}){width:100%;height:100%;position:relative;overflow:hidden;border:0;padding:0;background:none;appearance:none}`;
+/**
+* The element the animation is drawn inside.
+*
+* Render it among the children of a component that publishes an animation to
+* say where the animation goes, or on its own with the result of `useLottie` to
+* place it anywhere at all. It takes every attribute of the element it renders,
+* and `ref` names that same element.
+*
+* ```jsx
+* const lottie = useLottie({ src });
+* <LottieDisplay lottie={lottie} as="section" className="h-64" />
+* ```
+*/
+const LottieDisplay = polymorphicForwardRef(function LottieDisplay({ lottie, as, className, ...rest }, ref) {
+	const { setDisplayRef } = useLottieInstance(lottie);
+	const attach = useMemo(() => mergeRefs(ref, setDisplayRef), [ref, setDisplayRef]);
+	return renderStyledElement({
+		tag: typeof as === "string" ? as : "div",
+		styleClass: lottieDisplayClass,
+		styles: lottieDisplayStyles,
+		className,
+		attributes: rest,
+		ref: attach
+	});
+});
+//#endregion
+export { LottieDisplay, lottieDisplayClass, lottieDisplayStyles };

package/build/animation/LottieInstanceContext.cjs

@@ -0,0 +1,16 @@
+//#region src/animation/LottieInstanceContext.ts
+/**
+* How a child component reaches the animation it belongs to.
+*
+* Whatever owns the animation publishes it here, and every child prefers its
+* own `lottie` prop and falls back to this, which is what lets one set of
+* children serve both the component path and the hook path. It has to be a
+* context rather than an injected prop: children are wrapped, mapped and
+* conditional in real code, and only a context reaches all three.
+*
+* Read it through `useLottieInstance`, which turns the un-provided case into an
+* error naming both ways to fix it.
+*/
+const LottieInstanceContext = (0, require("react").createContext)(null);
+//#endregion
+exports.LottieInstanceContext = LottieInstanceContext;

package/build/animation/LottieInstanceContext.js

@@ -0,0 +1,17 @@
+import { createContext } from "react";
+//#region src/animation/LottieInstanceContext.ts
+/**
+* How a child component reaches the animation it belongs to.
+*
+* Whatever owns the animation publishes it here, and every child prefers its
+* own `lottie` prop and falls back to this, which is what lets one set of
+* children serve both the component path and the hook path. It has to be a
+* context rather than an injected prop: children are wrapped, mapped and
+* conditional in real code, and only a context reaches all three.
+*
+* Read it through `useLottieInstance`, which turns the un-provided case into an
+* error naming both ways to fix it.
+*/
+const LottieInstanceContext = createContext(null);
+//#endregion
+export { LottieInstanceContext };

package/build/animation/LottieLight.cjs

@@ -0,0 +1,19 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_createLottieComponent = require("./createLottieComponent.cjs");
+let lottie_web_build_player_lottie_light_js = require("lottie-web/build/player/lottie_light.js");
+lottie_web_build_player_lottie_light_js = require_runtime.__toESM(lottie_web_build_player_lottie_light_js, 1);
+//#region src/animation/LottieLight.tsx
+/**
+* Renders an animation using the light build of the engine.
+*
+* Identical to {@link Lottie} except that `svg` is the only renderer, which the
+* type enforces: the light build does not contain the other two, and asking it
+* for one throws at runtime while its own declarations claim otherwise.
+*
+* It also carries no expression engine, so a property an expression drives is
+* drawn at its static value; {@link LottieSvg} is the smaller build that keeps
+* expressions.
+*/
+const LottieLight = require_createLottieComponent.createLottieComponent(lottie_web_build_player_lottie_light_js.default);
+//#endregion
+exports.LottieLight = LottieLight;

package/build/animation/LottieLight.d.cts

@@ -0,0 +1,23 @@
+import { AnyTag, LottieRenderer, RendererInLight } from "./types.cjs";
+import { LottieComponent, LottieComponentProps } from "./createLottieComponent.cjs";
+import { ReactNode } from "react";
+//#region src/animation/LottieLight.d.ts
+/**
+ * What {@link LottieLight} accepts. Identical to `LottieProps` except that
+ * `renderer` admits only what the light build contains.
+ */
+type LottieLightProps<As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends RendererInLight = typeof LottieRenderer.svg> = LottieComponentProps<As, Children, Renderer>;
+/**
+ * Renders an animation using the light build of the engine.
+ *
+ * Identical to {@link Lottie} except that `svg` is the only renderer, which the
+ * type enforces: the light build does not contain the other two, and asking it
+ * for one throws at runtime while its own declarations claim otherwise.
+ *
+ * It also carries no expression engine, so a property an expression drives is
+ * drawn at its static value; {@link LottieSvg} is the smaller build that keeps
+ * expressions.
+ */
+declare const LottieLight: LottieComponent<"svg">;
+//#endregion
+export { LottieLight, LottieLightProps };

package/build/animation/LottieLight.d.ts

@@ -0,0 +1,23 @@
+import { AnyTag, LottieRenderer, RendererInLight } from "./types.js";
+import { LottieComponent, LottieComponentProps } from "./createLottieComponent.js";
+import { ReactNode } from "react";
+//#region src/animation/LottieLight.d.ts
+/**
+ * What {@link LottieLight} accepts. Identical to `LottieProps` except that
+ * `renderer` admits only what the light build contains.
+ */
+type LottieLightProps<As extends AnyTag = "div", Children extends ReactNode = undefined, Renderer extends RendererInLight = typeof LottieRenderer.svg> = LottieComponentProps<As, Children, Renderer>;
+/**
+ * Renders an animation using the light build of the engine.
+ *
+ * Identical to {@link Lottie} except that `svg` is the only renderer, which the
+ * type enforces: the light build does not contain the other two, and asking it
+ * for one throws at runtime while its own declarations claim otherwise.
+ *
+ * It also carries no expression engine, so a property an expression drives is
+ * drawn at its static value; {@link LottieSvg} is the smaller build that keeps
+ * expressions.
+ */
+declare const LottieLight: LottieComponent<"svg">;
+//#endregion
+export { LottieLight, LottieLightProps };

package/build/animation/LottieLight.js

@@ -0,0 +1,17 @@
+import { createLottieComponent } from "./createLottieComponent.js";
+import lottieLight from "lottie-web/build/player/lottie_light.js";
+//#region src/animation/LottieLight.tsx
+/**
+* Renders an animation using the light build of the engine.
+*
+* Identical to {@link Lottie} except that `svg` is the only renderer, which the
+* type enforces: the light build does not contain the other two, and asking it
+* for one throws at runtime while its own declarations claim otherwise.
+*
+* It also carries no expression engine, so a property an expression drives is
+* drawn at its static value; {@link LottieSvg} is the smaller build that keeps
+* expressions.
+*/
+const LottieLight = createLottieComponent(lottieLight);
+//#endregion
+export { LottieLight };

package/build/animation/LottieRegistryContext.cjs

@@ -0,0 +1,36 @@
+let react = require("react");
+//#region src/animation/LottieRegistryContext.ts
+function createLottieRegistry() {
+	const entries = /* @__PURE__ */ new Set();
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		register(box) {
+			entries.add(box);
+			emit();
+			return () => {
+				entries.delete(box);
+				emit();
+			};
+		},
+		bump: emit,
+		boxes: () => [...entries],
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+/**
+* How an animation reaches whatever wrapper surrounds it, and `null` in the
+* common case where nothing does, which costs the animation one context read
+* and two no-op effects.
+*/
+const LottieRegistryContext = (0, react.createContext)(null);
+//#endregion
+exports.LottieRegistryContext = LottieRegistryContext;
+exports.createLottieRegistry = createLottieRegistry;

package/build/animation/LottieRegistryContext.js

@@ -0,0 +1,35 @@
+import { createContext } from "react";
+//#region src/animation/LottieRegistryContext.ts
+function createLottieRegistry() {
+	const entries = /* @__PURE__ */ new Set();
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		register(box) {
+			entries.add(box);
+			emit();
+			return () => {
+				entries.delete(box);
+				emit();
+			};
+		},
+		bump: emit,
+		boxes: () => [...entries],
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+/**
+* How an animation reaches whatever wrapper surrounds it, and `null` in the
+* common case where nothing does, which costs the animation one context read
+* and two no-op effects.
+*/
+const LottieRegistryContext = createContext(null);
+//#endregion
+export { LottieRegistryContext, createLottieRegistry };

package/build/animation/LottieSvg.cjs

@@ -0,0 +1,20 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_createLottieComponent = require("./createLottieComponent.cjs");
+let lottie_web_build_player_lottie_svg_js = require("lottie-web/build/player/lottie_svg.js");
+lottie_web_build_player_lottie_svg_js = require_runtime.__toESM(lottie_web_build_player_lottie_svg_js, 1);
+//#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 = require_createLottieComponent.createLottieComponent(lottie_web_build_player_lottie_svg_js.default);
+//#endregion
+exports.LottieSvg = LottieSvg;