shaders 3.0.453 → 3.1.455

package/dist/core/fields-CC0756V2.js

@@ -0,0 +1,1311 @@
+import { Bt as sin, Dt as floor, Gt as data_exports, St as cos, Tt as exp, at as std_exports, dn as i32, gt as select, on as vec3f, pn as __export, rn as vec2f, rt as src_default, un as f32 } from "./edges-CD7gCAto.js";
+import { n as GOLDEN } from "./constants-DoOzbl5b.js";
+import { t as aspectOf } from "./geom-90G-d_hc.js";
+var fields_exports = /* @__PURE__ */ __export({
+	aspectScaledDomain: () => aspectScaledDomain,
+	domainWarp2: () => domainWarp2,
+	fbmGated: () => fbmGated,
+	pixelGridDomain: () => pixelGridDomain,
+	timeAxisDomain: () => timeAxisDomain
+});
+const aspectScaledDomain = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	return vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					"aspectOf",
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"aspectUV",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					], [
+						7,
+						"uv",
+						"y"
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					[
+						6,
+						[
+							7,
+							"aspectUV",
+							"mul"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"exp"
+							],
+							["scale"]
+						]]
+					],
+					"add"
+				],
+				["seed"]
+			]]
+		]],
+		"externalNames": [
+			"aspectOf",
+			"d",
+			"std"
+		]
+	},
+	externals: () => ({
+		aspectOf,
+		d: data_exports,
+		std: std_exports
+	})
+}) && $.f)({}));
+const pixelGridDomain = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, grain, seed) => {
+	"use gpu";
+	return floor(uv.mul(viewport).div(grain)).add(seed);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "grain"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"uv",
+									"mul"
+								],
+								["viewport"]
+							],
+							"div"
+						],
+						["grain"]
+					]]
+				],
+				"add"
+			],
+			["seed"]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const timeAxisDomain = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, t, rate) => {
+	"use gpu";
+	return vec3f(pos.x, pos.y, __tsover_mul(t, rate));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "pos"
+			},
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "rate"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec3f"
+			],
+			[
+				[
+					7,
+					"pos",
+					"x"
+				],
+				[
+					7,
+					"pos",
+					"y"
+				],
+				[
+					1,
+					"t",
+					"*",
+					"rate"
+				]
+			]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d: data_exports })
+}) && $.f)({}));
+var fieldFnIds = /* @__PURE__ */ new WeakMap();
+var nextFieldFnId = 0;
+function fieldFnId(fieldFn) {
+	const keyable = fieldFn;
+	const existing = fieldFnIds.get(keyable);
+	if (existing !== void 0) return existing;
+	const assigned = nextFieldFnId++;
+	fieldFnIds.set(keyable, assigned);
+	return assigned;
+}
+function fbmGated(fieldFn, options) {
+	const { maxOctaves, drift, stride = [17, 31], name = "fbmGated" } = options;
+	const key = `${fieldFnId(fieldFn)}|${name}|${maxOctaves}|${drift}|${stride[0]},${stride[1]}`;
+	const cached = fbmCache.get(key);
+	if (cached) return cached;
+	const N = maxOctaves;
+	const TIME_STRIDE = stride[0];
+	const SEED_STRIDE = stride[1];
+	const suffix = `${drift === "goldenAngle" ? "Golden" : "TimeSeed"}${N}`;
+	let built;
+	if (drift === "goldenAngle") {
+		const octaveField = fieldFn;
+		built = src_default.fn([
+			vec2f,
+			f32,
+			f32,
+			f32,
+			f32,
+			vec2f,
+			f32
+		], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, baseFreq, lacunarity, persistence, animTime, seedOffset, octaveCount) => {
+			"use gpu";
+			const n = i32(octaveCount);
+			let freq = baseFreq;
+			let weight = f32(1);
+			let accumulated = f32(0);
+			let totalWeight = f32(0);
+			for (let i = 0; i < N; i++) {
+				const fi = f32(i);
+				const dirX = cos(__tsover_mul(fi, 2.3999632297286535));
+				const dirY = sin(__tsover_mul(fi, 2.3999632297286535));
+				const coord = vec2f(__tsover_add(__tsover_add(__tsover_mul(base.x, freq), __tsover_mul(animTime, dirX)), seedOffset.x), __tsover_add(__tsover_add(__tsover_mul(base.y, freq), __tsover_mul(animTime, dirY)), seedOffset.y));
+				const active = select(f32(0), f32(1), i < n);
+				accumulated = __tsover_add(accumulated, __tsover_mul(__tsover_mul(octaveField(coord), weight), active));
+				totalWeight = __tsover_add(totalWeight, __tsover_mul(weight, active));
+				freq = __tsover_mul(freq, lacunarity);
+				weight = __tsover_mul(weight, persistence);
+			}
+			return vec2f(accumulated, totalWeight);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [
+					{
+						"type": "i",
+						"name": "base"
+					},
+					{
+						"type": "i",
+						"name": "baseFreq"
+					},
+					{
+						"type": "i",
+						"name": "lacunarity"
+					},
+					{
+						"type": "i",
+						"name": "persistence"
+					},
+					{
+						"type": "i",
+						"name": "animTime"
+					},
+					{
+						"type": "i",
+						"name": "seedOffset"
+					},
+					{
+						"type": "i",
+						"name": "octaveCount"
+					}
+				],
+				"body": [0, [
+					[
+						13,
+						"n",
+						[
+							6,
+							[
+								7,
+								"d",
+								"i32"
+							],
+							["octaveCount"]
+						]
+					],
+					[
+						12,
+						"freq",
+						"baseFreq"
+					],
+					[
+						12,
+						"weight",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					],
+					[
+						12,
+						"accumulated",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]
+					],
+					[
+						12,
+						"totalWeight",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"i",
+							[5, "0"]
+						],
+						[
+							1,
+							"i",
+							"<",
+							"N"
+						],
+						[
+							102,
+							"++",
+							"i"
+						],
+						[0, [
+							[
+								13,
+								"fi",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["i"]
+								]
+							],
+							[
+								13,
+								"dirX",
+								[
+									6,
+									[
+										7,
+										"std",
+										"cos"
+									],
+									[[
+										1,
+										"fi",
+										"*",
+										"GOLDEN"
+									]]
+								]
+							],
+							[
+								13,
+								"dirY",
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										"fi",
+										"*",
+										"GOLDEN"
+									]]
+								]
+							],
+							[
+								13,
+								"coord",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										1,
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"base",
+													"x"
+												],
+												"*",
+												"freq"
+											],
+											"+",
+											[
+												1,
+												"animTime",
+												"*",
+												"dirX"
+											]
+										],
+										"+",
+										[
+											7,
+											"seedOffset",
+											"x"
+										]
+									], [
+										1,
+										[
+											1,
+											[
+												1,
+												[
+													7,
+													"base",
+													"y"
+												],
+												"*",
+												"freq"
+											],
+											"+",
+											[
+												1,
+												"animTime",
+												"*",
+												"dirY"
+											]
+										],
+										"+",
+										[
+											7,
+											"seedOffset",
+											"y"
+										]
+									]]
+								]
+							],
+							[
+								13,
+								"active",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "0"]]
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "1"]]
+										],
+										[
+											1,
+											"i",
+											"<",
+											"n"
+										]
+									]
+								]
+							],
+							[
+								2,
+								"accumulated",
+								"=",
+								[
+									1,
+									"accumulated",
+									"+",
+									[
+										1,
+										[
+											1,
+											[
+												6,
+												"octaveField",
+												["coord"]
+											],
+											"*",
+											"weight"
+										],
+										"*",
+										"active"
+									]
+								]
+							],
+							[
+								2,
+								"totalWeight",
+								"=",
+								[
+									1,
+									"totalWeight",
+									"+",
+									[
+										1,
+										"weight",
+										"*",
+										"active"
+									]
+								]
+							],
+							[
+								2,
+								"freq",
+								"=",
+								[
+									1,
+									"freq",
+									"*",
+									"lacunarity"
+								]
+							],
+							[
+								2,
+								"weight",
+								"=",
+								[
+									1,
+									"weight",
+									"*",
+									"persistence"
+								]
+							]
+						]]
+					],
+					[10, [
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						["accumulated", "totalWeight"]
+					]]
+				]],
+				"externalNames": [
+					"d",
+					"N",
+					"std",
+					"GOLDEN",
+					"octaveField"
+				]
+			},
+			externals: () => ({
+				d: data_exports,
+				N,
+				std: std_exports,
+				GOLDEN: 2.3999632297286535,
+				octaveField
+			})
+		}) && $.f)({})).$name(`${name}${suffix}`);
+	} else {
+		const octaveField = fieldFn;
+		built = src_default.fn([
+			vec2f,
+			f32,
+			f32,
+			f32,
+			f32,
+			f32,
+			vec3f,
+			f32
+		], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, baseFreq, lacunarity, persistence, animTime, seed, extra, octaveCount) => {
+			"use gpu";
+			let freq = baseFreq;
+			let amp = f32(1);
+			let accumulated = f32(0);
+			let totalWeight = f32(0);
+			for (let o = 0; o < N; o++) {
+				const fo = f32(o);
+				const active = select(f32(0), f32(1), fo < octaveCount);
+				const raw = octaveField(vec2f(__tsover_mul(base.x, freq), __tsover_mul(base.y, freq)), __tsover_add(animTime, __tsover_mul(fo, TIME_STRIDE)), __tsover_add(seed, __tsover_mul(fo, SEED_STRIDE)), extra.x, extra.y, extra.z);
+				accumulated = __tsover_add(accumulated, __tsover_mul(__tsover_mul(raw, amp), active));
+				totalWeight = __tsover_add(totalWeight, __tsover_mul(amp, active));
+				amp = __tsover_mul(amp, persistence);
+				freq = __tsover_mul(freq, lacunarity);
+			}
+			return vec2f(accumulated, totalWeight);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [
+					{
+						"type": "i",
+						"name": "base"
+					},
+					{
+						"type": "i",
+						"name": "baseFreq"
+					},
+					{
+						"type": "i",
+						"name": "lacunarity"
+					},
+					{
+						"type": "i",
+						"name": "persistence"
+					},
+					{
+						"type": "i",
+						"name": "animTime"
+					},
+					{
+						"type": "i",
+						"name": "seed"
+					},
+					{
+						"type": "i",
+						"name": "extra"
+					},
+					{
+						"type": "i",
+						"name": "octaveCount"
+					}
+				],
+				"body": [0, [
+					[
+						12,
+						"freq",
+						"baseFreq"
+					],
+					[
+						12,
+						"amp",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						]
+					],
+					[
+						12,
+						"accumulated",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]
+					],
+					[
+						12,
+						"totalWeight",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]
+					],
+					[
+						14,
+						[
+							12,
+							"o",
+							[5, "0"]
+						],
+						[
+							1,
+							"o",
+							"<",
+							"N"
+						],
+						[
+							102,
+							"++",
+							"o"
+						],
+						[0, [
+							[
+								13,
+								"fo",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["o"]
+								]
+							],
+							[
+								13,
+								"active",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "0"]]
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "1"]]
+										],
+										[
+											1,
+											"fo",
+											"<",
+											"octaveCount"
+										]
+									]
+								]
+							],
+							[
+								13,
+								"oUV",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										1,
+										[
+											7,
+											"base",
+											"x"
+										],
+										"*",
+										"freq"
+									], [
+										1,
+										[
+											7,
+											"base",
+											"y"
+										],
+										"*",
+										"freq"
+									]]
+								]
+							],
+							[
+								13,
+								"animT",
+								[
+									1,
+									"animTime",
+									"+",
+									[
+										1,
+										"fo",
+										"*",
+										"TIME_STRIDE"
+									]
+								]
+							],
+							[
+								13,
+								"seedOff",
+								[
+									1,
+									"seed",
+									"+",
+									[
+										1,
+										"fo",
+										"*",
+										"SEED_STRIDE"
+									]
+								]
+							],
+							[
+								13,
+								"raw",
+								[
+									6,
+									"octaveField",
+									[
+										"oUV",
+										"animT",
+										"seedOff",
+										[
+											7,
+											"extra",
+											"x"
+										],
+										[
+											7,
+											"extra",
+											"y"
+										],
+										[
+											7,
+											"extra",
+											"z"
+										]
+									]
+								]
+							],
+							[
+								2,
+								"accumulated",
+								"=",
+								[
+									1,
+									"accumulated",
+									"+",
+									[
+										1,
+										[
+											1,
+											"raw",
+											"*",
+											"amp"
+										],
+										"*",
+										"active"
+									]
+								]
+							],
+							[
+								2,
+								"totalWeight",
+								"=",
+								[
+									1,
+									"totalWeight",
+									"+",
+									[
+										1,
+										"amp",
+										"*",
+										"active"
+									]
+								]
+							],
+							[
+								2,
+								"amp",
+								"=",
+								[
+									1,
+									"amp",
+									"*",
+									"persistence"
+								]
+							],
+							[
+								2,
+								"freq",
+								"=",
+								[
+									1,
+									"freq",
+									"*",
+									"lacunarity"
+								]
+							]
+						]]
+					],
+					[10, [
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						["accumulated", "totalWeight"]
+					]]
+				]],
+				"externalNames": [
+					"d",
+					"N",
+					"std",
+					"TIME_STRIDE",
+					"SEED_STRIDE",
+					"octaveField"
+				]
+			},
+			externals: () => ({
+				d: data_exports,
+				N,
+				std: std_exports,
+				TIME_STRIDE,
+				SEED_STRIDE,
+				octaveField
+			})
+		}) && $.f)({})).$name(`${name}${suffix}`);
+	}
+	fbmCache.set(key, built);
+	return built;
+}
+var fbmCache = /* @__PURE__ */ new Map();
+var IQ_WARP_OFFSETS = {
+	q: [[
+		.3,
+		-.2,
+		0
+	], [
+		5.2,
+		1.3,
+		.25
+	]],
+	r: [[
+		1.7,
+		9.2,
+		.15
+	], [
+		8.3,
+		2.8,
+		.13
+	]]
+};
+function domainWarp2(fieldFn, options = {}) {
+	const { offsets = IQ_WARP_OFFSETS, name = "domainWarp2" } = options;
+	const key = `${fieldFnId(fieldFn)}|${name}|${JSON.stringify(offsets)}`;
+	const cached = warpCache.get(key);
+	if (cached) return cached;
+	const warpField = fieldFn;
+	const [QX, QY, QZ] = offsets.q[0];
+	const [Q2X, Q2Y, Q2Z] = offsets.q[1];
+	const [RX, RY, RZ] = offsets.r[0];
+	const [R2X, R2Y, R2Z] = offsets.r[1];
+	const built = src_default.fn([
+		vec3f,
+		f32,
+		f32
+	], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, t, warpAmount) => {
+		"use gpu";
+		const qx = warpField(pos.add(vec3f(__tsover_mul(t, QX), __tsover_mul(t, QY), QZ)));
+		const qy = warpField(pos.add(vec3f(Q2X, Q2Y, __tsover_mul(t, Q2Z))));
+		const warped1 = pos.add(vec3f(qx, qy, 0).mul(warpAmount));
+		const rx = warpField(warped1.add(vec3f(RX, RY, __tsover_mul(t, RZ))));
+		const ry = warpField(warped1.add(vec3f(R2X, R2Y, __tsover_mul(t, R2Z))));
+		return pos.add(vec3f(rx, ry, 0).mul(warpAmount));
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "pos"
+				},
+				{
+					"type": "i",
+					"name": "t"
+				},
+				{
+					"type": "i",
+					"name": "warpAmount"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"qx",
+					[
+						6,
+						"warpField",
+						[[
+							6,
+							[
+								7,
+								"pos",
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										1,
+										"t",
+										"*",
+										"QX"
+									],
+									[
+										1,
+										"t",
+										"*",
+										"QY"
+									],
+									"QZ"
+								]
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"qy",
+					[
+						6,
+						"warpField",
+						[[
+							6,
+							[
+								7,
+								"pos",
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									"Q2X",
+									"Q2Y",
+									[
+										1,
+										"t",
+										"*",
+										"Q2Z"
+									]
+								]
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"warped1",
+					[
+						6,
+						[
+							7,
+							"pos",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									[
+										"qx",
+										"qy",
+										[5, "0"]
+									]
+								],
+								"mul"
+							],
+							["warpAmount"]
+						]]
+					]
+				],
+				[
+					13,
+					"rx",
+					[
+						6,
+						"warpField",
+						[[
+							6,
+							[
+								7,
+								"warped1",
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									"RX",
+									"RY",
+									[
+										1,
+										"t",
+										"*",
+										"RZ"
+									]
+								]
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"ry",
+					[
+						6,
+						"warpField",
+						[[
+							6,
+							[
+								7,
+								"warped1",
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									"R2X",
+									"R2Y",
+									[
+										1,
+										"t",
+										"*",
+										"R2Z"
+									]
+								]
+							]]
+						]]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"pos",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									"rx",
+									"ry",
+									[5, "0"]
+								]
+							],
+							"mul"
+						],
+						["warpAmount"]
+					]]
+				]]
+			]],
+			"externalNames": [
+				"warpField",
+				"d",
+				"QX",
+				"QY",
+				"QZ",
+				"Q2X",
+				"Q2Y",
+				"Q2Z",
+				"RX",
+				"RY",
+				"RZ",
+				"R2X",
+				"R2Y",
+				"R2Z"
+			]
+		},
+		externals: () => ({
+			warpField,
+			d: data_exports,
+			QX,
+			QY,
+			QZ,
+			Q2X,
+			Q2Y,
+			Q2Z,
+			RX,
+			RY,
+			RZ,
+			R2X,
+			R2Y,
+			R2Z
+		})
+	}) && $.f)({})).$name(name);
+	warpCache.set(key, built);
+	return built;
+}
+var warpCache = /* @__PURE__ */ new Map();
+export { pixelGridDomain as a, fields_exports as i, domainWarp2 as n, timeAxisDomain as o, fbmGated as r, aspectScaledDomain as t };