@takumi-rs/wasm 1.8.6 → 2.0.0-beta.0

package/bundlers/bun.d.ts

@@ -1 +1 @@
-export * from "../dist/export";
+export * from "../dist/export.mjs";

package/bundlers/node.d.cts

@@ -0,0 +1 @@
+export * from "../dist/export.cjs";

package/bundlers/node.d.ts

@@ -1 +1 @@
-export * from "../dist/export";
+export * from "../dist/export.mjs";

package/dist/export.cjs

@@ -23,13 +23,6 @@ var Renderer$1 = class {
 		wasm.__wbg_renderer_free(ptr, 0);
 	}
 	/**
-	* Clears the renderer's internal image store.
-	*/
-	clearImageStore() {
-		const ret = wasm.renderer_clearImageStore(this.__wbg_ptr);
-		if (ret[1]) throw takeFromExternrefTable0(ret[0]);
-	}
-	/**
 	* Encodes a precomputed frame sequence into an animated image buffer.
 	* @param {AnimationFrameSource[]} frames
 	* @param {EncodeFramesOptions} options
@@ -45,14 +38,6 @@ var Renderer$1 = class {
 		return v2;
 	}
 	/**
-	* Loads a font into the renderer.
-	* @param {Font} font
-	*/
-	loadFont(font) {
-		const ret = wasm.renderer_loadFont(this.__wbg_ptr, font);
-		if (ret[1]) throw takeFromExternrefTable0(ret[0]);
-	}
-	/**
 	* Measures a node tree and returns layout information.
 	* @param {Node} node
 	* @param {RenderOptions | null} [options]
@@ -65,22 +50,23 @@ var Renderer$1 = class {
 	}
 	/**
 	* Creates a new Renderer instance.
-	* @param {ConstructRendererOptions | null} [options]
 	*/
-	constructor(options) {
-		const ret = wasm.renderer_new(isLikeNone(options) ? 0 : addToExternrefTable0(options));
+	constructor() {
+		const ret = wasm.renderer_new();
 		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
 		this.__wbg_ptr = ret[0];
 		RendererFinalization.register(this, this.__wbg_ptr, this);
 		return this;
 	}
 	/**
-	* Puts a persistent image into the renderer's internal store.
-	* @param {ImageSource} data
+	* Registers fonts into the renderer, returning the families each font produced.
+	* @param {Font} font
+	* @returns {RegisteredFamily[]}
 	*/
-	putPersistentImage(data) {
-		const ret = wasm.renderer_putPersistentImage(this.__wbg_ptr, data);
-		if (ret[1]) throw takeFromExternrefTable0(ret[0]);
+	registerFont(font) {
+		const ret = wasm.renderer_registerFont(this.__wbg_ptr, font);
+		if (ret[2]) throw takeFromExternrefTable0(ret[1]);
+		return takeFromExternrefTable0(ret[0]);
 	}
 	/**
 	* Renders a node tree into an image buffer.
@@ -134,6 +120,31 @@ var Renderer$1 = class {
 			wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
 		}
 	}
+	/**
+	* Renders a node tree into an SVG document string.
+	* @param {Node} node
+	* @param {SvgRenderOptions | null} [options]
+	* @returns {string}
+	*/
+	renderSvg(node, options) {
+		let deferred2_0;
+		let deferred2_1;
+		try {
+			const ret = wasm.renderer_renderSvg(this.__wbg_ptr, node, isLikeNone(options) ? 0 : addToExternrefTable0(options));
+			var ptr1 = ret[0];
+			var len1 = ret[1];
+			if (ret[3]) {
+				ptr1 = 0;
+				len1 = 0;
+				throw takeFromExternrefTable0(ret[2]);
+			}
+			deferred2_0 = ptr1;
+			deferred2_1 = len1;
+			return getStringFromWasm0(ptr1, len1);
+		} finally {
+			wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+		}
+	}
 };
 if (Symbol.dispose) Renderer$1.prototype[Symbol.dispose] = Renderer$1.prototype.free;
 function __wbg_get_imports() {
@@ -543,124 +554,114 @@ async function __wbg_init(module_or_path) {
 }
 //#endregion
 //#region src/export.ts
-var Renderer = class extends Renderer$1 {
-	fontsMark = /* @__PURE__ */ new Set();
-	fontBuffersMark = /* @__PURE__ */ new WeakSet();
-	persistentImageSrcMark = /* @__PURE__ */ new Set();
-	pendingPersistentImages = /* @__PURE__ */ new Map();
-	putPersistentImage(data, signal) {
-		if (signal?.aborted) return;
-		if (!this.isNewPersistentImage(data.src)) return this.pendingPersistentImages.get(data.src);
-		const resolved = resolveImageLoader(data);
-		if (isPromise(resolved)) {
-			const pending = resolved.then((value) => {
-				if (signal?.aborted) return;
-				super.putPersistentImage(value);
-				this.persistentImageSrcMark.add(data.src);
-			}).finally(() => {
-				this.pendingPersistentImages.delete(data.src);
-			});
-			this.pendingPersistentImages.set(data.src, pending);
-			return pending;
-		}
-		if (signal?.aborted) return;
-		super.putPersistentImage(resolved);
-		this.persistentImageSrcMark.add(data.src);
-	}
-	clearImageStore() {
-		super.clearImageStore();
-		this.persistentImageSrcMark.clear();
-		this.pendingPersistentImages.clear();
-	}
-	async loadFonts(fonts, signal) {
-		let loaded = 0;
-		for (const font of fonts) if (await this.loadFontInternal(font, signal)) loaded += 1;
-		return loaded;
-	}
-	loadFont(data, signal) {
-		const loaded = this.loadFontInternal(data, signal);
-		if (isPromise(loaded)) return loaded.then(() => void 0);
-	}
-	loadFontInternal(font, signal) {
-		if (signal?.aborted) return false;
-		const resolved = resolveFontLoader(font);
-		if (isPromise(resolved)) return resolved.then((value) => {
-			if (signal?.aborted || !this.checkAndMarkFont(value)) return false;
-			try {
-				super.loadFont(value);
-				return true;
-			} catch (error) {
-				this.unmarkFont(value);
-				throw error;
-			}
+async function resolveImageLoaders(images) {
+	const bySrc = /* @__PURE__ */ new Map();
+	for (const image of images) bySrc.set(image.src, image);
+	return Promise.all([...bySrc.values()].map(async ({ src, data, cache }) => ({
+		src,
+		data: typeof data === "function" ? await data() : data,
+		cache
+	})));
+}
+var Renderer = class {
+	fontMapping = /* @__PURE__ */ new Map();
+	inner = new Renderer$1();
+	async prepareFonts(fonts) {
+		if (!fonts) return;
+		const families = await Promise.all(fonts.map(this.registerFont.bind(this)));
+		return [...new Set(families.flat().map((f) => f.name))];
+	}
+	async render(node, options) {
+		const { fonts, fontFamilies, images, ...rest } = options ?? {};
+		const registeredFamilies = await this.prepareFonts(fonts);
+		const resolvedImages = images ? await resolveImageLoaders(images) : void 0;
+		return this.inner.render(node, {
+			...rest,
+			images: resolvedImages,
+			fontFamilies: fontFamilies ?? registeredFamilies
 		});
-		if (!this.checkAndMarkFont(resolved)) return false;
-		try {
-			super.loadFont(resolved);
-			return true;
-		} catch (error) {
-			this.unmarkFont(resolved);
-			throw error;
-		}
 	}
-	checkAndMarkFont(font) {
-		const key = createFontKey(font);
-		if (isBuffer(key)) {
-			const isNew = !this.fontBuffersMark.has(key);
-			this.fontBuffersMark.add(key);
-			return isNew;
-		}
-		const isNew = !this.fontsMark.has(key);
-		this.fontsMark.add(key);
-		return isNew;
+	async renderAsDataUrl(node, options) {
+		const { fonts, fontFamilies, images, ...rest } = options ?? {};
+		const registeredFamilies = await this.prepareFonts(fonts);
+		const resolvedImages = images ? await resolveImageLoaders(images) : void 0;
+		return this.inner.renderAsDataUrl(node, {
+			...rest,
+			images: resolvedImages,
+			fontFamilies: fontFamilies ?? registeredFamilies
+		});
+	}
+	async renderSvg(node, options) {
+		const { fonts, fontFamilies, images, ...rest } = options ?? {};
+		const registeredFamilies = await this.prepareFonts(fonts);
+		const resolvedImages = images ? await resolveImageLoaders(images) : void 0;
+		return this.inner.renderSvg(node, {
+			...rest,
+			images: resolvedImages,
+			fontFamilies: fontFamilies ?? registeredFamilies
+		});
+	}
+	async measure(node, options) {
+		const { fonts, fontFamilies, images, ...rest } = options ?? {};
+		const registeredFamilies = await this.prepareFonts(fonts);
+		const resolvedImages = images ? await resolveImageLoaders(images) : void 0;
+		return this.inner.measure(node, {
+			...rest,
+			images: resolvedImages,
+			fontFamilies: fontFamilies ?? registeredFamilies
+		});
+	}
+	async renderAnimation(options) {
+		const { fonts, fontFamilies, images, ...rest } = options;
+		const registeredFamilies = await this.prepareFonts(fonts);
+		const resolvedImages = images ? await resolveImageLoaders(images) : void 0;
+		return this.inner.renderAnimation({
+			...rest,
+			images: resolvedImages,
+			fontFamilies: fontFamilies ?? registeredFamilies
+		});
+	}
+	async encodeFrames(frames, options) {
+		const { fonts, fontFamilies, images, ...rest } = options;
+		const registeredFamilies = await this.prepareFonts(fonts);
+		const resolvedImages = images ? await resolveImageLoaders(images) : void 0;
+		return this.inner.encodeFrames(frames, {
+			...rest,
+			images: resolvedImages,
+			fontFamilies: fontFamilies ?? registeredFamilies
+		});
 	}
-	unmarkFont(font) {
+	free() {
+		this.inner.free();
+	}
+	async registerFont(font) {
 		const key = createFontKey(font);
-		if (isBuffer(key)) {
-			this.fontBuffersMark.delete(key);
-			return;
+		const cached = this.fontMapping.get(key);
+		if (cached) return cached;
+		const extracted = extractFontBuffer(font);
+		if (isBuffer(extracted)) {
+			const binded = this.inner.registerFont(extracted);
+			this.fontMapping.set(key, Promise.resolve(binded));
+			return binded;
 		}
-		this.fontsMark.delete(key);
-	}
-	isNewPersistentImage(src) {
-		return !this.persistentImageSrcMark.has(src) && !this.pendingPersistentImages.has(src);
+		const promise = extracted.then(this.inner.registerFont.bind(this.inner)).catch((error) => {
+			this.fontMapping.delete(key);
+			throw error;
+		});
+		this.fontMapping.set(key, promise);
+		return promise;
 	}
 };
-function createFontKey(font) {
-	if ("key" in font && font.key) return font.key;
+function extractFontBuffer(font) {
 	if (isBuffer(font)) return font;
-	return `${font.name ?? ""}-${font.style ?? ""}-${font.weight ?? ""}`;
-}
-function resolveFontLoader(font) {
-	if ("data" in font && typeof font.data === "function") {
-		const resolved = font.data();
-		if (isPromise(resolved)) return resolved.then((data) => ({
-			...font,
-			data
-		}));
-		return {
-			...font,
-			data: resolved
-		};
-	}
-	return font;
-}
-function resolveImageLoader(source) {
-	if (typeof source.data === "function") {
-		const resolved = source.data();
-		if (isPromise(resolved)) return resolved.then((data) => ({
-			...source,
-			data
-		}));
-		return {
-			...source,
-			data: resolved
-		};
-	}
-	return source;
+	if (typeof font.data !== "function") return font.data;
+	return font.data();
 }
-function isPromise(value) {
-	return typeof value === "object" && value !== null && "then" in value;
+function createFontKey(font) {
+	if (isBuffer(font)) return font;
+	if ("key" in font && font.key) return font.key;
+	if (typeof font.data === "function") return `${font.name ?? ""}:${font.weight ?? ""}:${font.style ?? ""}`;
+	return font.data;
 }
 function isBuffer(data) {
 	return data instanceof Uint8Array || data instanceof ArrayBuffer || typeof Buffer !== "undefined" && Buffer.isBuffer(data);

package/dist/export.d.cts

@@ -12,7 +12,7 @@ type KeyframesRuleList = {
   }[];
 }[];
 type Keyframes = KeyframesMap | KeyframesRuleList;
-type RenderOptions = {
+type RenderOptions$1 = {
   /**
    * The width of the image. If not provided, the width will be automatically calculated based on the content.
    */
@@ -31,9 +31,10 @@ type RenderOptions = {
    */
   quality?: number;
   /**
-   * The resources fetched externally. You should collect the fetch tasks first using `extractResourceUrls` and then pass the resources here.
+   * Images keyed by `src`, each carrying raw bytes. Provided up front and used
+   * in place of fetching external `src` URLs during rendering.
    */
-  fetchedResources?: ImageSource[];
+  images?: ImageSource[];
   /**
    * CSS stylesheets to apply before rendering.
    */
@@ -60,8 +61,17 @@ type RenderOptions = {
    * @default "none"
    */
   dithering?: "none" | "ordered-bayer" | "floyd-steinberg";
+  /**
+   * Per-render font stack: ordered family names used as the fallback chain.
+   * Defaults to all registered families in registration order.
+   */
+  fontFamilies?: string[];
 };
-type RenderAnimationOptions = {
+/**
+ * SVG is a vector format, so the raster-only knobs do not apply.
+ */
+type SvgRenderOptions$1 = Omit<RenderOptions$1, "format" | "quality" | "drawDebugBorder" | "devicePixelRatio" | "dithering">;
+type RenderAnimationOptions$1 = {
   scenes: AnimationSceneSource[];
   width: number;
   height: number;
@@ -71,9 +81,10 @@ type RenderAnimationOptions = {
    */
   quality?: number;
   /**
-   * The resources fetched externally. You should collect the fetch tasks first using `extractResourceUrls` and then pass the resources here.
+   * Images keyed by `src`, each carrying raw bytes. Provided up front and used
+   * in place of fetching external `src` URLs during rendering.
    */
-  fetchedResources?: ImageSource[];
+  images?: ImageSource[];
   drawDebugBorder?: boolean;
   /**
    * CSS stylesheets to apply before rendering.
@@ -88,8 +99,13 @@ type RenderAnimationOptions = {
    * Frames per second for timeline sampling.
    */
   fps: number;
+  /**
+   * Per-render font stack: ordered family names used as the fallback chain.
+   * Defaults to all registered families in registration order.
+   */
+  fontFamilies?: string[];
 };
-type EncodeFramesOptions = {
+type EncodeFramesOptions$1 = {
   width: number;
   height: number;
   format?: "webp" | "apng" | "gif";
@@ -98,9 +114,10 @@ type EncodeFramesOptions = {
    */
   quality?: number;
   /**
-   * The resources fetched externally. You should collect the fetch tasks first using `extractResourceUrls` and then pass the resources here.
+   * Images keyed by `src`, each carrying raw bytes. Provided up front and used
+   * in place of fetching external `src` URLs during rendering.
    */
-  fetchedResources?: ImageSource[];
+  images?: ImageSource[];
   drawDebugBorder?: boolean;
   /**
    * CSS stylesheets to apply before rendering.
@@ -111,6 +128,11 @@ type EncodeFramesOptions = {
    * @default 1.0
    */
   devicePixelRatio?: number;
+  /**
+   * Per-render font stack: ordered family names used as the fallback chain.
+   * Defaults to all registered families in registration order.
+   */
+  fontFamilies?: string[];
 };
 type FontDetails = {
   name?: string;
@@ -120,7 +142,8 @@ type FontDetails = {
 };
 type ImageSource = {
   src: string;
-  data: ByteBuf;
+  data: ByteBuf; /** Cache policy for the decoded image. Defaults to `"auto"`. */
+  cache?: "auto" | "none";
 };
 type KeyframeRule = {
   offsets: number[];
@@ -131,20 +154,15 @@ type KeyframesRule = {
   keyframes: KeyframeRule[];
 };
 type Font = FontDetails | ByteBuf;
-type ConstructRendererOptions = {
-  /**
-   * The images that needs to be preloaded into the renderer.
-   */
-  persistentImages?: ImageSource[];
-  /**
-   * The fonts being used.
-   */
-  fonts?: Font[];
-  /**
-   * Whether to load the default fonts.
-   * If `fonts` are provided, this will be `false` by default.
-   */
-  loadDefaultFonts?: boolean;
+type RegisteredFace = {
+  weight: number;
+  style: string;
+  width: number;
+  index: number;
+};
+type RegisteredFamily = {
+  name: string;
+  faces: RegisteredFace[];
 };
 type MeasuredTextRun = {
   text: string;
@@ -168,68 +186,18 @@ type AnimationSceneSource = {
   node: Node$1;
   durationMs: number;
 };
-/**
- * The main renderer for Takumi image rendering engine.
- *
- * State lives behind a lock and every method takes `&self`, mirroring the
- * napi bindings: a panic mid-call can't leave the wasm-bindgen borrow flag
- * permanently set, which would otherwise fail all subsequent calls.
- */
-declare class Renderer$1 {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Clears the renderer's internal image store.
-   */
-  clearImageStore(): void;
-  /**
-   * Encodes a precomputed frame sequence into an animated image buffer.
-   */
-  encodeFrames(frames: AnimationFrameSource[], options: EncodeFramesOptions): Uint8Array;
-  /**
-   * Loads a font into the renderer.
-   */
-  loadFont(font: Font): void;
-  /**
-   * Measures a node tree and returns layout information.
-   */
-  measure(node: Node$1, options?: RenderOptions | null): MeasuredNode;
-  /**
-   * Creates a new Renderer instance.
-   */
-  constructor(options?: ConstructRendererOptions | null);
-  /**
-   * Puts a persistent image into the renderer's internal store.
-   */
-  putPersistentImage(data: ImageSource): void;
-  /**
-   * Renders a node tree into an image buffer.
-   */
-  render(node: Node$1, options?: RenderOptions | null): Uint8Array;
-  /**
-   * Renders a sequential animation timeline into a buffer.
-   */
-  renderAnimation(options: RenderAnimationOptions): Uint8Array;
-  /**
-   * Renders a node tree into a data URL.
-   *
-   * `raw` format is not supported for data URL.
-   */
-  renderAsDataUrl(node: Node$1, options: RenderOptions): string;
-}
 type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_renderer_free: (a: number, b: number) => void;
-  readonly renderer_clearImageStore: (a: number) => [number, number];
   readonly renderer_encodeFrames: (a: number, b: number, c: number, d: any) => [number, number, number, number];
-  readonly renderer_loadFont: (a: number, b: any) => [number, number];
   readonly renderer_measure: (a: number, b: any, c: number) => [number, number, number];
-  readonly renderer_new: (a: number) => [number, number, number];
-  readonly renderer_putPersistentImage: (a: number, b: any) => [number, number];
+  readonly renderer_new: () => [number, number, number];
+  readonly renderer_registerFont: (a: number, b: any) => [number, number, number];
   readonly renderer_render: (a: number, b: any, c: number) => [number, number, number, number];
   readonly renderer_renderAnimation: (a: number, b: any) => [number, number, number, number];
   readonly renderer_renderAsDataUrl: (a: number, b: any, c: any) => [number, number, number, number];
+  readonly renderer_renderSvg: (a: number, b: any, c: number) => [number, number, number, number];
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;
@@ -265,35 +233,73 @@ declare function __wbg_init(module_or_path?: {
 } | InitInput | Promise<InitInput>): Promise<InitOutput>;
 //#endregion
 //#region src/export.d.ts
-type ImageSourceLoader = Omit<ImageSource, "data"> & {
-  data: ImageSource["data"] | (() => Promise<ImageSource["data"]> | ImageSource["data"]);
-};
 type FontLoader = Font | (Omit<FontDetails, "data"> & {
-  key?: string;
-  data: FontDetails["data"] | (() => Promise<FontDetails["data"]> | FontDetails["data"]);
-});
-type ImageSourceLoaderSync = Omit<ImageSource, "data"> & {
-  data: ImageSource["data"] | (() => ImageSource["data"]);
+  data: () => Promise<FontDetails["data"]> | FontDetails["data"];
+} & ({
+  key: string;
+} | {
+  name: string;
+}));
+type ImageLoaderData = ImageSource["data"];
+type ImageLoader = Omit<ImageSource, "data"> & {
+  data: ImageLoaderData | (() => ImageLoaderData | Promise<ImageLoaderData>);
 };
-type FontLoaderSync = Font | (Omit<FontDetails, "data"> & {
-  key?: string;
-  data: FontDetails["data"] | (() => FontDetails["data"]);
-});
-declare class Renderer extends Renderer$1 {
-  private fontsMark;
-  private fontBuffersMark;
-  private persistentImageSrcMark;
-  private pendingPersistentImages;
-  putPersistentImage(data: ImageSourceLoaderSync, signal?: AbortSignal): void;
-  putPersistentImage(data: ImageSourceLoader, signal?: AbortSignal): Promise<void>;
-  clearImageStore(): void;
-  loadFonts(fonts: FontLoader[], signal?: AbortSignal): Promise<number>;
-  loadFont(data: FontLoaderSync, signal?: AbortSignal): void;
-  loadFont(data: FontLoader, signal?: AbortSignal): Promise<void>;
-  private loadFontInternal;
-  private checkAndMarkFont;
-  private unmarkFont;
-  private isNewPersistentImage;
+/**
+ * Output format. Format-specific options live on the variant that supports them,
+ * so `quality` cannot be paired with a lossless format. On wasm, WebP is always
+ * lossless (lossy WebP is native-only).
+ */
+type OutputFormatOptions = {
+  format?: "png";
+} | {
+  format: "jpeg";
+  quality?: number;
+} | {
+  format: "webp";
+} | {
+  format: "ico";
+} | {
+  format: "raw";
+};
+type RenderOptions = Omit<RenderOptions$1, "images" | "format" | "quality"> & OutputFormatOptions & {
+  fonts?: FontLoader[];
+  images?: ImageLoader[];
+};
+/**
+ * Animation output format. On wasm, WebP animation is always lossless (lossy
+ * WebP is native-only).
+ */
+type AnimationOutputFormatOptions = {
+  format?: "webp";
+} | {
+  format: "apng";
+} | {
+  format: "gif";
+};
+type RenderAnimationOptions = Omit<RenderAnimationOptions$1, "images" | "format"> & AnimationOutputFormatOptions & {
+  fonts?: FontLoader[];
+  images?: ImageLoader[];
+};
+type EncodeFramesOptions = Omit<EncodeFramesOptions$1, "images" | "format"> & AnimationOutputFormatOptions & {
+  fonts?: FontLoader[];
+  images?: ImageLoader[];
+};
+type SvgRenderOptions = Omit<SvgRenderOptions$1, "images"> & {
+  fonts?: FontLoader[];
+  images?: ImageLoader[];
+};
+declare class Renderer {
+  private fontMapping;
+  private inner;
+  private prepareFonts;
+  render(node: Node, options?: RenderOptions): Promise<Uint8Array<ArrayBufferLike>>;
+  renderAsDataUrl(node: Node, options?: RenderOptions): Promise<string>;
+  renderSvg(node: Node, options?: SvgRenderOptions): Promise<string>;
+  measure(node: Node, options?: RenderOptions): Promise<MeasuredNode>;
+  renderAnimation(options: RenderAnimationOptions): Promise<Uint8Array<ArrayBufferLike>>;
+  encodeFrames(frames: AnimationFrameSource[], options: EncodeFramesOptions): Promise<Uint8Array<ArrayBufferLike>>;
+  free(): void;
+  registerFont(font: FontLoader): Promise<any>;
 }
 //#endregion
-export { AnimationFrameSource, AnimationSceneSource, ByteBuf, ConstructRendererOptions, ContainerNode, EncodeFramesOptions, Font, FontDetails, FontLoader, FontLoaderSync, ImageNode, ImageSource, ImageSourceLoader, ImageSourceLoaderSync, InitInput, InitOutput, KeyframeRule, Keyframes, KeyframesMap, KeyframesRule, KeyframesRuleList, MeasuredNode, MeasuredTextRun, type Node, NodeMetadata, RenderAnimationOptions, RenderOptions, Renderer, SyncInitInput, TextNode, __wbg_init as default, extractResourceUrls, initSync };
+export { AnimationFrameSource, AnimationOutputFormatOptions, AnimationSceneSource, ByteBuf, ContainerNode, EncodeFramesOptions, Font, FontDetails, FontLoader, ImageLoader, ImageNode, ImageSource, InitInput, InitOutput, KeyframeRule, Keyframes, KeyframesMap, KeyframesRule, KeyframesRuleList, MeasuredNode, MeasuredTextRun, type Node, NodeMetadata, OutputFormatOptions, RegisteredFace, RegisteredFamily, RenderAnimationOptions, RenderOptions, Renderer, SvgRenderOptions, SyncInitInput, TextNode, __wbg_init as default, extractResourceUrls, initSync };