shaders 3.0.453 → 3.1.455

package/dist/core/lighting-D3jc6qOc.js

@@ -0,0 +1,1270 @@
+import { At as max, Gt as data_exports, Ht as sqrt, Nt as normalize, St as cos, Tt as exp, _t as abs, at as std_exports, cn as vec4f, en as struct, gt as select, jt as min, kt as length, ln as bool, on as vec3f, pn as __export, rn as vec2f, rt as src_default, un as f32, wt as dot, xt as clamp } from "./edges-CD7gCAto.js";
+import { s as TWO_PI } from "./constants-DoOzbl5b.js";
+var lighting_exports = /* @__PURE__ */ __export({
+	TangentFrame: () => TangentFrame,
+	WardSpecularInput: () => WardSpecularInput,
+	bevelledFlatNormal: () => bevelledFlatNormal,
+	cosinePalette: () => cosinePalette,
+	fieldGradient: () => fieldGradient,
+	insideMask: () => insideMask,
+	orthonormalTangentFrame: () => orthonormalTangentFrame,
+	outsideShape: () => outsideShape,
+	patternCoords: () => patternCoords,
+	perspectiveViewRay: () => perspectiveViewRay,
+	volumetricNormal: () => volumetricNormal,
+	wardAnisotropicSpecular: () => wardAnisotropicSpecular
+});
+const fieldGradient = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, eps) => {
+	"use gpu";
+	return vec2f(__tsover_div(__tsover_sub(surfX.x, surf0.x), eps), __tsover_div(__tsover_sub(surfY.x, surf0.x), eps));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "surf0"
+			},
+			{
+				"type": "i",
+				"name": "surfX"
+			},
+			{
+				"type": "i",
+				"name": "surfY"
+			},
+			{
+				"type": "i",
+				"name": "eps"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					1,
+					[
+						7,
+						"surfX",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"surf0",
+						"x"
+					]
+				],
+				"/",
+				"eps"
+			], [
+				1,
+				[
+					1,
+					[
+						7,
+						"surfY",
+						"x"
+					],
+					"-",
+					[
+						7,
+						"surf0",
+						"x"
+					]
+				],
+				"/",
+				"eps"
+			]]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d: data_exports })
+}) && $.f)({}));
+const volumetricNormal = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, eps, gradClamp) => {
+	"use gpu";
+	return normalize(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), eps), __tsover_mul(gradClamp, -1), gradClamp), clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), eps), __tsover_mul(gradClamp, -1), gradClamp), -1));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "surf0"
+			},
+			{
+				"type": "i",
+				"name": "surfX"
+			},
+			{
+				"type": "i",
+				"name": "surfY"
+			},
+			{
+				"type": "i",
+				"name": "eps"
+			},
+			{
+				"type": "i",
+				"name": "gradClamp"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ddx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfX",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"eps"
+						],
+						[
+							1,
+							"gradClamp",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gradClamp"
+					]
+				]
+			],
+			[
+				13,
+				"ddy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfY",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"eps"
+						],
+						[
+							1,
+							"gradClamp",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gradClamp"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"normalize"
+				],
+				[[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						"ddx",
+						"ddy",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const bevelledFlatNormal = src_default.fn([vec2f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((grad, sinTilt) => {
+	"use gpu";
+	const glen = max(length(grad), 1e-4);
+	const sB = min(sinTilt, .9995);
+	return vec3f(__tsover_mul(__tsover_div(grad.x, glen), sB), __tsover_mul(__tsover_div(grad.y, glen), sB), __tsover_mul(sqrt(__tsover_sub(1, __tsover_mul(sB, sB))), -1));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "grad"
+		}, {
+			"type": "i",
+			"name": "sinTilt"
+		}],
+		"body": [0, [
+			[
+				13,
+				"glen",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"length"
+						],
+						["grad"]
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"sB",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					["sinTilt", [5, "0.9995"]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"grad",
+								"x"
+							],
+							"/",
+							"glen"
+						],
+						"*",
+						"sB"
+					],
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"grad",
+								"y"
+							],
+							"/",
+							"glen"
+						],
+						"*",
+						"sB"
+					],
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"sqrt"
+							],
+							[[
+								1,
+								[5, "1"],
+								"-",
+								[
+									1,
+									"sB",
+									"*",
+									"sB"
+								]
+							]]
+						],
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					]
+				]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const patternCoords = src_default.fn([
+	vec2f,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfUV, surf0, volumetric) => {
+	"use gpu";
+	return vec2f(select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5), select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdfUV"
+			},
+			{
+				"type": "i",
+				"name": "surf0"
+			},
+			{
+				"type": "i",
+				"name": "volumetric"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					[
+						1,
+						[
+							7,
+							"sdfUV",
+							"x"
+						],
+						"-",
+						[5, "0.5"]
+					],
+					[
+						7,
+						"surf0",
+						"y"
+					],
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			], [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					[
+						1,
+						[
+							7,
+							"sdfUV",
+							"y"
+						],
+						"-",
+						[5, "0.5"]
+					],
+					[
+						7,
+						"surf0",
+						"z"
+					],
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			]]
+		]]]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d: data_exports,
+		std: std_exports
+	})
+}) && $.f)({}));
+const outsideShape = src_default.fn([f32, f32], bool)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, pxH) => {
+	"use gpu";
+	return sdf > __tsover_mul(pxH, 2);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "sdf"
+		}, {
+			"type": "i",
+			"name": "pxH"
+		}],
+		"body": [0, [[10, [
+			1,
+			"sdf",
+			">",
+			[
+				1,
+				"pxH",
+				"*",
+				[5, "2"]
+			]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const insideMask = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, sharpEdge, pxH, minPixels) => {
+	"use gpu";
+	const w = max(__tsover_mul(sharpEdge, .03125), __tsover_mul(pxH, minPixels));
+	return clamp(__tsover_div(__tsover_mul(sdf, -1), w), 0, 1);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdf"
+			},
+			{
+				"type": "i",
+				"name": "sharpEdge"
+			},
+			{
+				"type": "i",
+				"name": "pxH"
+			},
+			{
+				"type": "i",
+				"name": "minPixels"
+			}
+		],
+		"body": [0, [[
+			13,
+			"w",
+			[
+				6,
+				[
+					7,
+					"std",
+					"max"
+				],
+				[[
+					1,
+					"sharpEdge",
+					"*",
+					[5, "0.03125"]
+				], [
+					1,
+					"pxH",
+					"*",
+					"minPixels"
+				]]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"std",
+				"clamp"
+			],
+			[
+				[
+					1,
+					[
+						1,
+						"sdf",
+						"*",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					"/",
+					"w"
+				],
+				[5, "0"],
+				[5, "1"]
+			]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const perspectiveViewRay = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, fov) => {
+	"use gpu";
+	return normalize(vec3f(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), aspect), fov), __tsover_mul(__tsover_sub(uv.y, .5), fov), 1));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			},
+			{
+				"type": "i",
+				"name": "fov"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"normalize"
+			],
+			[[
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"-",
+								[5, "0.5"]
+							],
+							"*",
+							"aspect"
+						],
+						"*",
+						"fov"
+					],
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"uv",
+								"y"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						"fov"
+					],
+					[5, "1"]
+				]
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const TangentFrame = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	tangent: vec3f,
+	bitangent: vec3f
+}), "TangentFrame");
+const orthonormalTangentFrame = src_default.fn([vec3f, vec3f], TangentFrame)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((normal, dir) => {
+	"use gpu";
+	const T3 = normalize(dir.sub(normal.mul(dot(normal, dir))));
+	return TangentFrame({
+		tangent: T3,
+		bitangent: vec3f(__tsover_sub(__tsover_mul(normal.y, T3.z), __tsover_mul(normal.z, T3.y)), __tsover_sub(__tsover_mul(normal.z, T3.x), __tsover_mul(normal.x, T3.z)), __tsover_sub(__tsover_mul(normal.x, T3.y), __tsover_mul(normal.y, T3.x)))
+	});
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "normal"
+		}, {
+			"type": "i",
+			"name": "dir"
+		}],
+		"body": [0, [
+			[
+				13,
+				"T3",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"dir",
+							"sub"
+						],
+						[[
+							6,
+							[
+								7,
+								"normal",
+								"mul"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								["normal", "dir"]
+							]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"B3",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"normal",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"z"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"normal",
+									"z"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"y"
+								]
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"normal",
+									"z"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"x"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"normal",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"z"
+								]
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"normal",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"y"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"normal",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"x"
+								]
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"TangentFrame",
+				[[104, {
+					"tangent": "T3",
+					"bitangent": "B3"
+				}]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"TangentFrame"
+		]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports,
+		TangentFrame
+	})
+}) && $.f)({}));
+const WardSpecularInput = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	normal: vec3f,
+	tangent: vec3f,
+	light: vec3f,
+	view: vec3f,
+	alphaAlong: f32,
+	alphaAcross: f32
+}), "WardSpecularInput");
+const wardAnisotropicSpecular = src_default.fn([WardSpecularInput], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	const frame = orthonormalTangentFrame(p.normal, p.tangent);
+	const H = normalize(p.light.sub(p.view));
+	const hT = dot(H, frame.tangent);
+	const hB = dot(H, frame.bitangent);
+	const hN = clamp(abs(dot(H, p.normal)), 1e-4, 1);
+	const aT = max(p.alphaAlong, 1e-4);
+	const aB = max(p.alphaAcross, 1e-4);
+	const expo = __tsover_div(__tsover_add(__tsover_mul(__tsover_div(hT, aT), __tsover_div(hT, aT)), __tsover_mul(__tsover_div(hB, aB), __tsover_div(hB, aB))), __tsover_mul(__tsover_add(hN, 1), .5));
+	return exp(__tsover_mul(expo, -1));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [
+			[
+				13,
+				"frame",
+				[
+					6,
+					"orthonormalTangentFrame",
+					[[
+						7,
+						"p",
+						"normal"
+					], [
+						7,
+						"p",
+						"tangent"
+					]]
+				]
+			],
+			[
+				13,
+				"H",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"p",
+								"light"
+							],
+							"sub"
+						],
+						[[
+							7,
+							"p",
+							"view"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"hT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["H", [
+						7,
+						"frame",
+						"tangent"
+					]]
+				]
+			],
+			[
+				13,
+				"hB",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["H", [
+						7,
+						"frame",
+						"bitangent"
+					]]
+				]
+			],
+			[
+				13,
+				"hN",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								["H", [
+									7,
+									"p",
+									"normal"
+								]]
+							]]
+						],
+						[5, "0.0001"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"aT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"p",
+						"alphaAlong"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"aB",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"p",
+						"alphaAcross"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"expo",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"hT",
+								"/",
+								"aT"
+							],
+							"*",
+							[
+								1,
+								"hT",
+								"/",
+								"aT"
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								"hB",
+								"/",
+								"aB"
+							],
+							"*",
+							[
+								1,
+								"hB",
+								"/",
+								"aB"
+							]
+						]
+					],
+					"/",
+					[
+						1,
+						[
+							1,
+							"hN",
+							"+",
+							[5, "1"]
+						],
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"exp"
+				],
+				[[
+					1,
+					"expo",
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]]
+			]]
+		]],
+		"externalNames": ["orthonormalTangentFrame", "std"]
+	},
+	externals: () => ({
+		orthonormalTangentFrame,
+		std: std_exports
+	})
+}) && $.f)({}));
+const cosinePalette = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, phaseR, phaseG, phaseB) => {
+	"use gpu";
+	return vec3f(__tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, phaseR), TWO_PI)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, phaseG), TWO_PI)), .5), .5), __tsover_add(__tsover_mul(cos(__tsover_mul(__tsover_add(t, phaseB), TWO_PI)), .5), .5));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "phaseR"
+			},
+			{
+				"type": "i",
+				"name": "phaseG"
+			},
+			{
+				"type": "i",
+				"name": "phaseB"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec3f"
+			],
+			[
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"phaseR"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				],
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"phaseG"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				],
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"phaseB"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			]
+		]]]],
+		"externalNames": [
+			"d",
+			"std",
+			"TWO_PI"
+		]
+	},
+	externals: () => ({
+		d: data_exports,
+		std: std_exports,
+		TWO_PI
+	})
+}) && $.f)({}));
+export { lighting_exports as n, cosinePalette as t };