framefields 2.11.0 → 2.12.0

package/dist/{src-BYp6r-cS.mjs → src-D7M8VTzv.mjs}

@@ -1,12 +1,12 @@
 import { G as ProgrammaticSignal, K as Signal, Mt as frameArraySignal, N as MediaSignalRecorder, St as createVirtualMedia, pt as appendOperation, rn as mediaSourceTime, tn as mediaSourceRange, y as Effect$1, yn as resolveFrameRequest } from "./dist-Bf2_efYP.mjs";
-import { F as getPrimitiveGeometry, K as mediaDecoderCache, N as generateExtrudedTextGeometry, Z as parseSvgPathToSegments, _ as buildShapeSvgPath, _t as Path3D, p as SlugFontCache, q as parseColor$1, z as inputStore } from "./dist-CWLLnigL.mjs";
-import { a as preflightMediaTime, n as decodeAudioSource } from "./dist-EQX3TUUl.mjs";
-import { t as FontManager } from "./fonts-gPbGbShD.mjs";
+import { F as getPrimitiveGeometry, K as mediaDecoderCache, N as generateExtrudedTextGeometry, Z as parseSvgPathToSegments, _ as buildShapeSvgPath, p as SlugFontCache, q as parseColor$1, vt as Path3D, z as inputStore } from "./dist-B-OPY7Cs.mjs";
+import { a as preflightMediaTime, n as decodeAudioSource } from "./dist-BSqeChht.mjs";
+import { t as FontManager } from "./fonts-BQrDjnpV.mjs";
 import { s as TensorPipeline } from "./dist-BIE8fvlv.mjs";
-import { E as pinNodeToObject, S as maskObject, T as pinNodeToLandmark, d as VisionNode, f as VisionRunner, i as COCO17_KEYPOINT_NAMES, l as VisionBundle, p as analyzeSequence, t as CLIP_SUBJECT, w as mergeSubjectMask } from "./src-Bnr8DUC--BRDqRF6I.mjs";
-import { G as mediaSignalSampler, K as mergeAnimationTracks, N as collectNodeOps, P as compositorToProgram, W as lintComposition, f as LayerAnimation, q as sampleMediaTimeSignal } from "./program-Bc860ko5.mjs";
-import { C as effectFactories, H as Dither, I as ColorBalance, K as Iridescence, L as ColorKey, M as CRT, R as Contour, S as Vision, T as Ascii, Y as LayerStyle, _ as SelectiveColor, a as CustomEffect, at as Posterize, b as TileOffset, c as GradientMap, d as Levels, et as OpArt, f as Modulate, g as SSAO, h as Relight3D, ht as Vignette, i as Curves, it as Pixelate, l as HalftoneScreen, m as PBRGlass, nt as Painterly, o as DepthOfField, ot as ProceduralVFX, p as MotionBlur, pt as Toon, q as Kaleidoscope, r as Crop, s as FilmGrain, st as RGBSplit, t as ApplyLUT, u as HighPass, v as ShadowsHighlights, w as Blur, x as UnsharpMask, y as TemporalDeflicker } from "./effects-DKLbLXF7.mjs";
-import { n as renderFrameGrid, s as HeadlessMediaRenderer } from "./renderer-Bbxh4N8Y.mjs";
+import { E as pinNodeToObject, S as maskObject, T as pinNodeToLandmark, d as VisionNode, f as VisionRunner, i as COCO17_KEYPOINT_NAMES, l as VisionBundle, p as analyzeSequence, t as CLIP_SUBJECT, w as mergeSubjectMask } from "./src-BU6vm9sP-DFJ3phW0.mjs";
+import { G as mediaSignalSampler, K as mergeAnimationTracks, N as collectNodeOps, P as compositorToProgram, W as lintComposition, f as LayerAnimation, q as sampleMediaTimeSignal } from "./program-Cvv_nb9T.mjs";
+import { C as effectFactories, H as Dither, I as ColorBalance, K as Iridescence, L as ColorKey, M as CRT, R as Contour, S as Vision, T as Ascii, Y as LayerStyle, _ as SelectiveColor, a as CustomEffect, at as Posterize, b as TileOffset, c as GradientMap, d as Levels, et as OpArt, f as Modulate, g as SSAO, h as Relight3D, ht as Vignette, i as Curves, it as Pixelate, l as HalftoneScreen, m as PBRGlass, nt as Painterly, o as DepthOfField, ot as ProceduralVFX, p as MotionBlur, pt as Toon, q as Kaleidoscope, r as Crop, s as FilmGrain, st as RGBSplit, t as ApplyLUT, u as HighPass, v as ShadowsHighlights, w as Blur, x as UnsharpMask, y as TemporalDeflicker } from "./effects-C8CL9cOq.mjs";
+import { n as renderFrameGrid, s as HeadlessMediaRenderer } from "./renderer-D3YbHjRG.mjs";
 import { z, z as z$2 } from "zod";
 import path from "node:path";
 import fs from "node:fs/promises";
@@ -1337,11 +1337,15 @@ function translatePath(d, dx, dy) {
 /** Frames looked back over to bridge a gap where the person is lost. */
 const HOLD = 24;
 const CACHE_VERSION = 1;
+const DEPTH_CACHE_VERSION = 1;
+const DEPTH_MODEL = "depth-anything-v2-s";
+/** Depth frames held in memory when they also live on disk (each is about 1 MB). */
+const DEPTH_MEMORY = 48;
 let visionSam;
 let clipVisionIds = 0;
 /** SAM ships in its own chunk, loaded only when a clip asks for `sam2` or `sam3`. */
 function loadVisionSam() {
-	visionSam ??= import("./dist-CNGv-JTX.mjs");
+	visionSam ??= import("./dist-BwtxciN4.mjs");
 	return visionSam;
 }
 /**
@@ -1398,6 +1402,13 @@ var ClipVision = class {
 	subjects = /* @__PURE__ */ new Map();
 	wantSubjects = false;
 	subjectsLoaded;
+	/** Depth per source frame; null when the frame did not decode. Bounded when on disk. */
+	depths = /* @__PURE__ */ new Map();
+	/** Source frames whose depth is on disk. */
+	depthsOnDisk = /* @__PURE__ */ new Set();
+	depthDir;
+	/** Set once the depth folder is known: render-time reads are synchronous. */
+	depthDisk;
 	/** @internal Use `comp.vision(source, options)`. */
 	constructor(source, fps, options = {}) {
 		this.source = source;
@@ -1565,7 +1576,40 @@ var ClipVision = class {
 	}
 	/** Whether frames carry keypoints: on by default, opt-in for prompted (SAM) clips. */
 	get tracksPose() {
-		return this.exact ? this.options.pose === true : this.options.pose ?? true;
+		return this.exact ? this.options.pose === true : this.options.pose ?? !this.tracksDepth;
+	}
+	/** Whether frames carry the person's silhouette: on by default, off for depth clips. */
+	get tracksMask() {
+		return this.options.mask ?? !this.tracksDepth;
+	}
+	/** Whether frames carry relative depth. */
+	get tracksDepth() {
+		return this.options.depth === true;
+	}
+	/**
+	* The relative depth (near = 1) of composition frame `frame`, at the depth
+	* model's resolution; undefined until that frame is analysed (`ready`).
+	*/
+	depthMap(frame) {
+		return this.depth(frame, this.compositionFps) ?? void 0;
+	}
+	/**
+	* @internal The relative depth of a source frame of the clip (`frame` at
+	* `fps`) for a render-time depth layer: undefined until analysed, null when
+	* the frame did not decode.
+	*/
+	depth(frame, fps) {
+		const c = this.sourceFrame(frame, fps);
+		if (c === void 0 || !this.tracksDepth) return void 0;
+		const stored = this.storedDepth(c);
+		if (!stored) return stored;
+		const data = new Float32Array(stored.data.length);
+		for (let i = 0; i < data.length; i++) data[i] = stored.data[i] / 65535;
+		return {
+			data,
+			width: stored.width,
+			height: stored.height
+		};
 	}
 	/**
 	* The analysed source frame a render-time read at `frame` (at `fps`) maps to;
@@ -1592,6 +1636,10 @@ var ClipVision = class {
 		return [Math.max(0, a - HOLD - this.smoothing), Math.max(0, b + this.smoothing)];
 	}
 	analysed(c) {
+		return this.analysedSubject(c) && (!this.tracksDepth || this.hasDepth(c));
+	}
+	/** Everything but depth, which is a pass of its own. */
+	analysedSubject(c) {
 		return this.results.has(c) && (!this.wantSubjects || this.subjects.has(c));
 	}
 	/** Loads `@framefields/vision-sam` and validates the prompts once, on first use. */
@@ -1611,8 +1659,9 @@ var ClipVision = class {
 			this.subjectsLoaded ??= this.loadSubjects();
 			await this.subjectsLoaded;
 		}
+		if (this.tracksDepth) await this.computeDepth(from, to);
 		let missing = false;
-		for (let c = from; c <= to; c++) if (!this.analysed(c)) missing = true;
+		for (let c = from; c <= to; c++) if (!this.analysedSubject(c)) missing = true;
 		if (!missing) return;
 		if (this.options.sam2) {
 			await this.computeSam2(to);
@@ -1623,16 +1672,11 @@ var ClipVision = class {
 			return;
 		}
 		const wantPose = this.tracksPose;
-		const wantMask = this.options.mask ?? true;
-		this.runner ??= VisionRunner.create({
-			modelsDir: this.options.modelsDir,
-			baseUrl: this.options.baseUrl,
-			...this.options.confidence !== void 0 && { confidence: this.options.confidence },
-			...this.options.variant !== void 0 && { variant: this.options.variant }
-		});
+		const wantMask = this.tracksMask;
+		const runner = this.visionRunner();
 		const decoder = this.decoder();
 		for (let c = from; c <= to; c++) {
-			if (this.analysed(c)) continue;
+			if (this.analysedSubject(c)) continue;
 			const image = await decodedPixels(await decoder.getFrame(c / this.fps));
 			if (!image) {
 				this.results.set(c, {
@@ -1647,7 +1691,7 @@ var ClipVision = class {
 			let kp = known?.kp ?? null;
 			let mask = known?.mask ?? null;
 			if (wantPose && !known) {
-				const person = (await this.runner.pose(image)).people[0];
+				const person = (await runner.pose(image)).people[0];
 				if (person) {
 					kp = new Float32Array(51);
 					for (const [k, p] of person.keypoints.entries()) kp.set([
@@ -1657,7 +1701,7 @@ var ClipVision = class {
 					], k * 3);
 				}
 			}
-			const seg = wantMask && !known || this.wantSubjects ? await this.runner.segment(image) : void 0;
+			const seg = wantMask && !known || this.wantSubjects ? await runner.segment(image) : void 0;
 			if (seg && this.wantSubjects) {
 				const subject = mergeSubjectMask(seg.masks);
 				this.subjects.set(c, subject ? {
@@ -1685,6 +1729,109 @@ var ClipVision = class {
 		if (this.unsaved > 0) await this.saveCache();
 		if (this.unsavedSubjects > 0) await this.saveSubjects();
 	}
+	visionRunner() {
+		this.runner ??= VisionRunner.create({
+			modelsDir: this.options.modelsDir,
+			baseUrl: this.options.baseUrl,
+			...this.options.confidence !== void 0 && { confidence: this.options.confidence },
+			...this.options.variant !== void 0 && { variant: this.options.variant }
+		});
+		return this.runner;
+	}
+	/** Depth of every source frame in `from…to` not analysed yet, saved one file per frame. */
+	async computeDepth(from, to) {
+		const dir = await this.depthCacheDir();
+		let decoder;
+		for (let c = from; c <= to; c++) {
+			if (this.hasDepth(c)) continue;
+			decoder ??= this.decoder();
+			const image = await decodedPixels(await decoder.getFrame(c / this.fps));
+			if (!image) {
+				this.depths.set(c, null);
+				continue;
+			}
+			if (!this.sourceWidth) this.setSize(image.width, image.height);
+			const map = await this.visionRunner().depth(image);
+			const stored = {
+				width: map.width,
+				height: map.height,
+				data: Uint16Array.from(map.data, (v) => Math.round(v * 65535))
+			};
+			this.keepDepth(c, stored);
+			if (dir) await this.saveDepth(dir, c, stored);
+		}
+	}
+	hasDepth(c) {
+		return this.depths.has(c) || this.depthsOnDisk.has(c);
+	}
+	keepDepth(c, depth) {
+		this.depths.delete(c);
+		this.depths.set(c, depth);
+		if (this.depthsOnDisk.size === 0) return;
+		for (const k of this.depths.keys()) {
+			if (this.depths.size <= DEPTH_MEMORY) break;
+			if (this.depthsOnDisk.has(k)) this.depths.delete(k);
+		}
+	}
+	storedDepth(c) {
+		const held = this.depths.get(c);
+		if (held !== void 0 || !this.depthsOnDisk.has(c)) return held;
+		const disk = this.depthDisk;
+		if (!disk) return void 0;
+		const stored = readDepthFile(disk.fs, disk.path.join(disk.dir, `${c}.bin`));
+		if (stored) this.keepDepth(c, stored);
+		return stored ?? void 0;
+	}
+	/**
+	* Where depth frames persist: a folder of its own, keyed only by the clip
+	* and the model, so other options never invalidate it.
+	*/
+	depthCacheDir() {
+		this.depthDir ??= (async () => {
+			const node = await nodeModules();
+			if (!node || this.options.cacheDir === false) return null;
+			const { fs: fs$1, path: path$1, os, crypto } = node;
+			try {
+				const stat = fs$1.statSync(this.source);
+				const root = this.options.cacheDir ?? process.env.FRAMEFIELDS_VISION_CACHE_DIR ?? path$1.join(os.homedir(), ".cache", "framefields", "vision");
+				const key = JSON.stringify([
+					DEPTH_CACHE_VERSION,
+					path$1.resolve(this.source),
+					stat.size,
+					stat.mtimeMs,
+					this.fps,
+					DEPTH_MODEL
+				]);
+				const hash = crypto.createHash("sha256").update(key).digest("hex").slice(0, 24);
+				const dir = path$1.join(root, `${path$1.basename(this.source)}.${hash}.depth`);
+				fs$1.mkdirSync(dir, { recursive: true });
+				for (const name of fs$1.readdirSync(dir)) {
+					const m = /^(\d+)\.bin$/.exec(name);
+					if (m) this.depthsOnDisk.add(Number(m[1]));
+				}
+				this.depthDisk = {
+					dir,
+					fs: fs$1,
+					path: path$1
+				};
+				return dir;
+			} catch {
+				return null;
+			}
+		})();
+		return this.depthDir;
+	}
+	async saveDepth(dir, c, depth) {
+		const node = await nodeModules();
+		if (!node) return;
+		const header = new Uint32Array([depth.width, depth.height]);
+		const file = node.path.join(dir, `${c}.bin`);
+		const tmp = `${file}.${process.pid}.tmp`;
+		node.fs.writeFileSync(tmp, Buffer.concat([Buffer.from(header.buffer), Buffer.from(depth.data.buffer, depth.data.byteOffset, depth.data.byteLength)]));
+		node.fs.renameSync(tmp, file);
+		this.depthsOnDisk.add(c);
+		this.keepDepth(c, depth);
+	}
 	async computeSam2(to) {
 		const settings = this.options.sam2;
 		if (!settings) return;
@@ -2000,7 +2147,7 @@ var ClipVision = class {
 				stat.mtimeMs,
 				this.fps,
 				this.tracksPose,
-				o.mask ?? true,
+				this.tracksMask,
 				this.cell,
 				o.variant ?? "s",
 				o.confidence ?? null,
@@ -2388,6 +2535,41 @@ function unionMask(objects, image) {
 	for (const { mask } of objects) for (let i = 0; i < union.length; i++) union[i] = Math.max(union[i] ?? 0, mask[i] ?? 0);
 	return union;
 }
+let nodeModulesLoaded;
+/** Node's file modules, or null in a browser. */
+function nodeModules() {
+	nodeModulesLoaded ??= typeof process === "undefined" || !process.versions?.node ? Promise.resolve(null) : Promise.all([
+		import("node:fs"),
+		import("node:path"),
+		import("node:os"),
+		import("node:crypto")
+	]).then(([fs$1, path$1, os, crypto]) => ({
+		fs: fs$1,
+		path: path$1,
+		os,
+		crypto
+	}));
+	return nodeModulesLoaded;
+}
+/** A depth frame written by `saveDepth`; null when the file is missing or damaged. */
+function readDepthFile(fs$1, file) {
+	try {
+		const buf = fs$1.readFileSync(file);
+		if (buf.byteLength < 8) return null;
+		const width = buf.readUInt32LE(0);
+		const height = buf.readUInt32LE(4);
+		if (buf.byteLength !== 8 + width * height * 2) return null;
+		const data = new Uint16Array(width * height);
+		Buffer.from(data.buffer).set(buf.subarray(8));
+		return {
+			width,
+			height,
+			data
+		};
+	} catch {
+		return null;
+	}
+}
 
 //#endregion
 //#region src/media-signals.ts
@@ -8524,6 +8706,7 @@ var Composition = class Composition {
 	_frameHooks = [];
 	_prepareHooks = [];
 	_clipVision = /* @__PURE__ */ new Map();
+	_linking = false;
 	_mediaSignals;
 	_visionConfig;
 	_visionBundle;
@@ -8598,14 +8781,13 @@ var Composition = class Composition {
 		await Promise.all([...this._clipVision.values()].map((clip) => clip.ready(0, frame)));
 	}
 	/**
-	* Points matte-family and skeleton `withVision` layers at the `comp.vision`
-	* clip they show, so the cutout reuses that clip's per-frame subject and the
-	* skeleton draws its matched pose, instead of analysing the frame again
-	* during render. Only layers whose settings would give the same subject are
+	* Points matte-family, skeleton and depth `withVision` layers at the
+	* `comp.vision` clip they show, so the cutout reuses that clip's per-frame
+	* subject, the skeleton draws its matched pose and the depth layer its
+	* frame's depth, instead of analysing the frame again during render. Only layers whose settings would give the same subject are
 	* linked; the rest keep their own pass.
 	*/
 	linkClipLayers() {
-		if (this._clipVision.size === 0) return;
 		let layers;
 		const walk = (node) => {
 			if (!node || typeof node !== "object") return;
@@ -8622,7 +8804,7 @@ var Composition = class Composition {
 					timeRemap: layer?.timeRemap
 				});
 				if (clip) {
-					if (n.vision.mode !== "skeleton") clip.keepSubjects();
+					if (n.vision.mode !== "skeleton" && n.vision.mode !== "depth") clip.keepSubjects();
 					Object.defineProperty(n.vision, CLIP_SUBJECT, {
 						value: clip,
 						enumerable: false,
@@ -8631,12 +8813,15 @@ var Composition = class Composition {
 				}
 			}
 			if (Array.isArray(n.children)) for (const c of n.children) walk(c);
+			walk(n.matte?.node);
+			walk(n.relief?.node);
 		};
 		for (const child of this.children) walk(child);
 	}
 	/** The `comp.vision` clip a matte or skeleton layer of the same source reads instead of analysing. */
 	clipForLayer(source, v, layer) {
 		const mode = v.mode ?? "passthrough";
+		if (mode === "depth") return this.depthClip(source, layer);
 		const skeleton = mode === "skeleton";
 		if (mode !== "matte" && mode !== "mask" && mode !== "crop" && !skeleton) return;
 		if (v.classes !== void 0 || v.enableMatte === true || v.visionBundle !== void 0 || !skeleton && (v.matteSource === "selfie" || v.keyBackground === true || v.enablePose === true || (v.maskThreshold ?? .5) !== .5 || v.featherRadius !== void 0)) return;
@@ -8652,6 +8837,20 @@ var Composition = class Composition {
 		}
 	}
 	/**
+	* The clip a depth layer reads: one of the same source and timing that
+	* tracks depth, or a new depth clip, since depth is never analysed at render
+	* time (it would trail the picture by a frame).
+	*/
+	depthClip(source, layer) {
+		for (const clip of this._clipVision.values()) if (clip.tracksDepth && clip.source === source && clip.startFrame === (layer.startFrame ?? 0) && clip.trimStartSec === (layer.trimStartSec ?? 0) && remapKey(clip.options.timeRemap) === remapKey(layer.timeRemap)) return clip;
+		return this.vision(source, {
+			depth: true,
+			...layer.startFrame !== void 0 && { startFrame: layer.startFrame },
+			...layer.trimStartSec !== void 0 && { trimStartSec: layer.trimStartSec },
+			...layer.timeRemap !== void 0 && { timeRemap: layer.timeRemap }
+		});
+	}
+	/**
 	* One-shot, ffmpeg-free vision analysis of a media source.
 	*
 	* Decodes frames through the same mediabunny pipeline the renderer uses, runs the requested
@@ -8724,6 +8923,7 @@ var Composition = class Composition {
 		for (const hook of this._frameHooks) hook(ctx);
 		const signals = this._mediaSignals;
 		signals?.advance(ctx.frame);
+		this.linkClipLayers();
 		if (this._clipVision.size === 0 && this._prepareHooks.length === 0) {
 			signals?.reach(ctx.frame);
 			return;
@@ -9106,6 +9306,14 @@ var Composition = class Composition {
 	* Compiles the composition into a VirtualMediaData AST ready for WebGPU rendering.
 	*/
 	toVirtualMedia(options = {}) {
+		if (!this._linking) {
+			this._linking = true;
+			try {
+				this.linkClipLayers();
+			} finally {
+				this._linking = false;
+			}
+		}
 		const durationMs = options.durationMs ?? this.durationMs;
 		const signals = options.signals ?? this.signals;
 		return compositorToProgram(this.toSpec(), {
@@ -9257,6 +9465,18 @@ function withAnimation(node) {
 		writable: true,
 		configurable: true
 	});
+	Object.defineProperty(target$1, "withRelief", {
+		value: (relief, options = {}) => {
+			target$1.relief = {
+				node: relief,
+				...options
+			};
+			return target$1;
+		},
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
 	Object.defineProperty(target$1, "withPbrGlass", {
 		value: (options) => {
 			target$1.glass = options ?? {};
@@ -9861,4 +10081,4 @@ const Effect = Object.assign(Effect$1, effectFactories, {
 
 //#endregion
 export { glyphAnimator as $, wordRanges as $t, boilKeys as A, squigglePath as At, defineTheme as B, themes as Bt, audioLevelsSchema as C, span as Cn, scaleFrames as Ct, basePropsSchema as D, FRAMEFIELDS_AI_PROXY_URL as Dn, springKeys as Dt, bandEdges as E, ApiError as En, springAt as Et, constantExpression as F, surfaceFill as Ft, elevationStyle as G, transparent as Gt, drawOnKeys as H, toPathData as Ht, contrastRatio as I, targetPoint as It, evaluateEase as J, windowExpression as Jt, ellipsePath as K, typingFrames as Kt, cover as L, targetSchema as Lt, boxPath as M, staggerRanks as Mt, catmullRom as N, stepExpression as Nt, beats as O, ValidationError as On, springSettleFrames as Ot, chain as P, supersede as Pt, frameSpan as Q, wobblePoints as Qt, defineComponent as R, textLayout as Rt, ascending as S, size as Sn, safeArea as St, bakeSamples as T, sup as Tn, smoothRelease as Tt, ease as U, toSeconds as Ut, dist as V, toFrames as Vt, elevate as W, transformPathData as Wt, exitAnimation as X, withDefaults as Xt, evaluateGlyphExpression as Y, withAlpha as Yt, findRange as Z, within as Zt, after as _, italic as _n, resampleBands as _t, Media as a, PhysicsWorld2D as an, last as at, arcPath as b, parseMarkup as bn, rng as bt, section as c, Layer3D as cn, lineShift as ct, analyzeAudio as d, PersonTrack as dn, offsetCues as dt, Styles as en, hashRng as et, KeyBook as f, DEFAULT_CHART_COLORS as fn, parseColor as ft, UNIT_INDEX as g, color as gn, rendererChars as gt, Track as h, code as hn, rangeRects as ht, Light as i, PhysicsBody2D as in, isLight as it, boundsOf as j, staggerOffsets as jt, bind as k, ai as kn, springTrack as kt, bindComponent as l, Particles as ln, luminance as lt, SAFE_INSETS as m, bold as mn, quantize as mt, Effect as n, PhysicsBody3D as nn, holdFirstKeys as nt, blurRegion as o, Lighting as on, lerp2 as ot, MOTION_PRESETS as p, accent as pn, pulseKeys as pt, enterAnimation as q, valueAt as qt, Layer as r, PhysicsWorld3D as rn, inkOn as rt, editTrackedRegion as s, Transition as sn, linePath as st, Composition as t, Physics as tn, hashString as tt, z$2 as u, ClipVision as un, mix as ut, analyzeChannels as v, mark as vn, resolveMotion as vt, bakeFunction as w, sub as wn, scheduleExpression as wt, arrowPaths as x, rich as xn, round as xt, anchorPoint as y, normalizeTextSpans as yn, resolveTarget as yt, defineMeta as z, themeFrames as zt };
-//# sourceMappingURL=src-BYp6r-cS.mjs.map
+//# sourceMappingURL=src-D7M8VTzv.mjs.map