@godot-scene-web/effects 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tomás Fox
+
+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/dist/easing/index.d.ts

@@ -0,0 +1,2 @@
+import { n as godotEaseSample, t as createEaseSampler } from "../index-CeKMJryT.js";
+export { createEaseSampler, godotEaseSample };

package/dist/easing/index.js

@@ -0,0 +1,2 @@
+import { n as godotEaseSample, t as createEaseSampler } from "../easing-BH-VRsXl.js";
+export { createEaseSampler, godotEaseSample };

package/dist/easing-BH-VRsXl.js

@@ -0,0 +1,237 @@
+//#region src/easing/numeric.ts
+const NORMALIZED_NAME_CACHE_LIMIT = 64;
+const normalizedNames = /* @__PURE__ */ new Map();
+function outInOf(halves) {
+	return (t) => t < .5 ? .5 * halves.out(t * 2) : .5 + .5 * halves.in(t * 2 - 1);
+}
+function inOutOf(halves) {
+	return (t) => t < .5 ? .5 * halves.in(t * 2) : .5 + .5 * halves.out(t * 2 - 1);
+}
+function family(f) {
+	return {
+		in: f.in,
+		out: f.out,
+		inOut: f.inOut,
+		outIn: outInOf(f)
+	};
+}
+const LINEAR = (() => {
+	const identity = (t) => t;
+	return {
+		in: identity,
+		out: identity,
+		inOut: identity,
+		outIn: identity
+	};
+})();
+const HALF_PI = Math.PI / 2;
+const SINE = family({
+	in: (t) => 1 - Math.cos(t * HALF_PI),
+	out: (t) => Math.sin(t * HALF_PI),
+	inOut: (t) => -.5 * (Math.cos(Math.PI * t) - 1)
+});
+const QUINT = family({
+	in: (t) => t ** 5,
+	out: (t) => (t - 1) ** 5 + 1,
+	inOut: (t) => {
+		const u = t * 2;
+		return u < 1 ? .5 * u ** 5 : .5 * ((u - 2) ** 5 + 2);
+	}
+});
+const QUART = family({
+	in: (t) => t ** 4,
+	out: (t) => -((t - 1) ** 4 - 1),
+	inOut: (t) => {
+		const u = t * 2;
+		return u < 1 ? .5 * u ** 4 : -.5 * ((u - 2) ** 4 - 2);
+	}
+});
+const QUAD = family({
+	in: (t) => t ** 2,
+	out: (t) => -t * (t - 2),
+	inOut: (t) => {
+		const u = t * 2;
+		return u < 1 ? .5 * u ** 2 : -.5 * ((u - 1) * (u - 3) - 1);
+	}
+});
+const EXPO = family({
+	in: (t) => t === 0 ? 0 : 2 ** (10 * (t - 1)) - .001,
+	out: (t) => t === 1 ? 1 : 1.001 * (1 - 2 ** (-10 * t)),
+	inOut: (t) => {
+		if (t === 0) return 0;
+		if (t === 1) return 1;
+		const u = t * 2;
+		return u < 1 ? .5 * 2 ** (10 * (u - 1)) - 5e-4 : .5 * 1.0005 * (2 - 2 ** (-10 * (u - 1)));
+	}
+});
+const ELASTIC_PERIOD = .3;
+const ELASTIC_SHIFT = ELASTIC_PERIOD / 4;
+const ELASTIC_INOUT_PERIOD = .3 * 1.5;
+const ELASTIC_INOUT_SHIFT = ELASTIC_INOUT_PERIOD / 4;
+const ELASTIC = family({
+	in: (t) => {
+		if (t === 0) return 0;
+		if (t === 1) return 1;
+		const u = t - 1;
+		return -(2 ** (10 * u) * Math.sin((u - ELASTIC_SHIFT) * (2 * Math.PI) / ELASTIC_PERIOD));
+	},
+	out: (t) => {
+		if (t === 0) return 0;
+		if (t === 1) return 1;
+		return 2 ** (-10 * t) * Math.sin((t - ELASTIC_SHIFT) * (2 * Math.PI) / ELASTIC_PERIOD) + 1;
+	},
+	inOut: (t) => {
+		if (t === 0) return 0;
+		const u = t * 2;
+		if (u === 2) return 1;
+		const v = u - 1;
+		const phase = Math.sin((v - ELASTIC_INOUT_SHIFT) * (2 * Math.PI) / ELASTIC_INOUT_PERIOD);
+		return u < 1 ? -.5 * (2 ** (10 * v) * phase) : 2 ** (-10 * v) * phase * .5 + 1;
+	}
+});
+const CUBIC = family({
+	in: (t) => t * t * t,
+	out: (t) => {
+		const u = t - 1;
+		return u * u * u + 1;
+	},
+	inOut: (t) => {
+		const u = t * 2;
+		if (u < 1) return .5 * u * u * u;
+		const v = u - 2;
+		return .5 * (v * v * v + 2);
+	}
+});
+const CIRC = family({
+	in: (t) => -(Math.sqrt(1 - t * t) - 1),
+	out: (t) => {
+		const u = t - 1;
+		return Math.sqrt(1 - u * u);
+	},
+	inOut: (t) => {
+		const u = t * 2;
+		if (u < 1) return -.5 * (Math.sqrt(1 - u * u) - 1);
+		const v = u - 2;
+		return .5 * (Math.sqrt(1 - v * v) + 1);
+	}
+});
+const BOUNCE_OUT = (t) => {
+	if (t < 1 / 2.75) return 7.5625 * t * t;
+	if (t < 2 / 2.75) {
+		const u = t - 1.5 / 2.75;
+		return 7.5625 * u * u + .75;
+	}
+	if (t < 2.5 / 2.75) {
+		const u = t - 2.25 / 2.75;
+		return 7.5625 * u * u + .9375;
+	}
+	const u = t - 2.625 / 2.75;
+	return 7.5625 * u * u + .984375;
+};
+const BOUNCE_HALVES = {
+	in: (t) => 1 - BOUNCE_OUT(1 - t),
+	out: BOUNCE_OUT
+};
+const BOUNCE = {
+	...BOUNCE_HALVES,
+	inOut: inOutOf(BOUNCE_HALVES),
+	outIn: outInOf(BOUNCE_HALVES)
+};
+const BACK_OVERSHOOT = 1.70158;
+const BACK_INOUT_OVERSHOOT = 1.70158 * 1.525;
+const BACK = family({
+	in: (t) => t * t * (2.70158 * t - BACK_OVERSHOOT),
+	out: (t) => {
+		const u = t - 1;
+		return u * u * (2.70158 * u + BACK_OVERSHOOT) + 1;
+	},
+	inOut: (t) => {
+		const s = BACK_INOUT_OVERSHOOT;
+		const u = t * 2;
+		if (u < 1) return .5 * (u * u * (3.5949095 * u - s));
+		const v = u - 2;
+		return .5 * (v * v * (3.5949095 * v + s) + 2);
+	}
+});
+const SPRING_OUT = (t) => {
+	const s = 1 - t;
+	return (Math.sin(t * Math.PI * (.2 + 2.5 * t * t * t)) * s ** 2.2 + t) * (1 + 1.2 * s);
+};
+const SPRING_HALVES = {
+	in: (t) => 1 - SPRING_OUT(1 - t),
+	out: SPRING_OUT
+};
+const SPRING = {
+	...SPRING_HALVES,
+	inOut: inOutOf(SPRING_HALVES),
+	outIn: outInOf(SPRING_HALVES)
+};
+const FAMILIES = new Map([
+	["linear", LINEAR],
+	["sine", SINE],
+	["quint", QUINT],
+	["quart", QUART],
+	["quad", QUAD],
+	["expo", EXPO],
+	["elastic", ELASTIC],
+	["cubic", CUBIC],
+	["circ", CIRC],
+	["bounce", BOUNCE],
+	["back", BACK],
+	["spring", SPRING]
+]);
+function normalizeName(name) {
+	if (typeof name !== "string") return "";
+	const cached = normalizedNames.get(name);
+	if (cached !== void 0) return cached;
+	const normalized = name.toLowerCase().replace(/[^a-z]/g, "");
+	if (normalizedNames.size < NORMALIZED_NAME_CACHE_LIMIT) normalizedNames.set(name, normalized);
+	return normalized;
+}
+/** Select Godot's family/mode column, with the engine's missing/unknown-name defaults. */
+function resolveEaseSampler(ease, trans) {
+	const family = FAMILIES.get(normalizeName(trans)) ?? LINEAR;
+	const mode = normalizeName(ease);
+	return mode === "in" ? family.in : mode === "out" ? family.out : mode === "outin" ? family.outIn : family.inOut;
+}
+function sampleResolvedEase(sample, t) {
+	if (!(t > 0)) return 0;
+	if (t >= 1) return 1;
+	return sample(t);
+}
+/**
+* Resolve a Godot easing family and mode once, returning a sampler for normalized time `t`.
+*
+* The returned function has the same endpoint behavior as `godotEaseSample`: values at or below
+* zero (including NaN) are zero and values at or above one are one. Missing and unknown names use
+* Godot's defaults (linear transition and in-out ease mode).
+*/
+function createEaseSampler(ease, trans) {
+	const sample = resolveEaseSampler(ease, trans);
+	return (t) => sampleResolvedEase(sample, t);
+}
+/**
+* Sample Godot's easing curve at normalized time `t`, returning the normalized progress (0 at the start, 1 at the
+* end, and freely outside that range in between for the overshooting families).
+*
+* `ease` and `trans` are the RAW Godot enum names as they arrive over a live wire, exactly like
+* `godotEasingToCss`: `ease` is "In"/"Out"/"InOut"/"OutIn" and `trans` is "Linear"/"Sine"/"Quint"/"Quart"/"Quad"/
+* "Expo"/"Elastic"/"Cubic"/"Circ"/"Bounce"/"Back"/"Spring". Both are case-insensitive and tolerate separators
+* ("in_out" reads as "InOut"). Unlike the CSS mapping — which has to collapse "OutIn" into the in-out column
+* because CSS cannot express it — every one of Godot's four ease modes is available here.
+*
+* Defaults match Godot's `Tween`: a missing `trans` is TRANS_LINEAR and a missing `ease` is EASE_IN_OUT
+* (`scene/animation/tween.h`). An UNRECOGNISED family also falls back to linear, so an unknown name degrades to
+* "plays at the right speed on average" rather than to a guess with the wrong shape.
+*
+* `t` is clamped to [0, 1] (NaN reads as 0). Returning exactly 1 at t >= 1 is what the engine does, not a
+* convenience: `PropertyTweener::step` assigns `final_val` outright once the elapsed time reaches the duration and
+* never evaluates the equation there (`tween.cpp`). It matters for Expo, whose raw equation would end at 0.999.
+*/
+function godotEaseSample(ease, trans, t) {
+	return sampleResolvedEase(resolveEaseSampler(ease, trans), t);
+}
+//#endregion
+export { godotEaseSample as n, createEaseSampler as t };
+
+//# sourceMappingURL=easing-BH-VRsXl.js.map

package/dist/easing-BH-VRsXl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"easing-BH-VRsXl.js","names":[],"sources":["../src/easing/numeric.ts"],"sourcesContent":["// Godot Tween easing → an EXACT numeric sample. The companion to `easing.ts`: that module maps a Godot\n// TransitionType×EaseType onto a CSS timing-function (a fit, and for some families only a fallback), which is what a\n// consumer wants when the browser animates the property itself. This module is for the other half of the problem —\n// when the consumer has to compute the value at time `t` itself (a canvas/WebGL frame, a sampled bake, a parity\n// check against the game) and an approximation is not good enough.\n//\n// The equations are ported 1:1 from the Godot Engine 4.5.1 source file `scene/animation/easing_equations.h`\n// (MIT-licensed; Copyright (c) 2014-present Godot Engine contributors, Copyright (c) 2007-2014 Juan Linietsky,\n// Ariel Manzur — itself derived from Robert Penner's easing equations, Copyright (c) 2001 Robert Penner).\n// `scene/animation/tween.cpp` supplies the dispatch: `Tween::interpolaters[TRANS][EASE]` picks the family/mode\n// function and `run_equation()` calls it as `func(time, 0.0, 1.0, duration)`, i.e. b=0, c=1 — so normalizing to\n// b=0, c=1, d=1 (what this module does) loses nothing: every equation is affine in b and c.\n\n/** One `t → value` curve, normalized to b=0, c=1, d=1. */\ntype EaseSampler = (t: number) => number;\n\n// Live effect renderers sample an easing once for every animated channel on every frame. Raw names\n// come from the wire and are often repeated verbatim, so retain their normalized forms. This is\n// deliberately a simple bounded memo rather than an LRU: names beyond the cap still compute\n// correctly, they simply do not turn untrusted input into unbounded retained memory.\nconst NORMALIZED_NAME_CACHE_LIMIT = 64;\nconst normalizedNames = new Map<string, string>();\n\n/** The four Godot EaseType columns for one TransitionType. */\ninterface EaseFamily {\n  in: EaseSampler;\n  out: EaseSampler;\n  inOut: EaseSampler;\n  outIn: EaseSampler;\n}\n\n// Godot's `out_in` is not an equation of its own: it runs `out` over the first half and `in` over the second, each\n// with c/2 (`easing_equations.h`, every family's `out_in`).\nfunction outInOf(halves: { in: EaseSampler; out: EaseSampler }): EaseSampler {\n  return (t) =>\n    t < 0.5 ? 0.5 * halves.out(t * 2) : 0.5 + 0.5 * halves.in(t * 2 - 1);\n}\n\n// The mirror of the above, used by Bounce and Spring, whose `in_out` is `in` then `out` over the halves rather than\n// a dedicated equation.\nfunction inOutOf(halves: { in: EaseSampler; out: EaseSampler }): EaseSampler {\n  return (t) =>\n    t < 0.5 ? 0.5 * halves.in(t * 2) : 0.5 + 0.5 * halves.out(t * 2 - 1);\n}\n\nfunction family(f: {\n  in: EaseSampler;\n  out: EaseSampler;\n  inOut: EaseSampler;\n}): EaseFamily {\n  return { in: f.in, out: f.out, inOut: f.inOut, outIn: outInOf(f) };\n}\n\n// Linear::in is bound to all four ease columns (\"Linear is the same for each easing\", tween.cpp).\nconst LINEAR: EaseFamily = (() => {\n  const identity: EaseSampler = (t) => t;\n  return { in: identity, out: identity, inOut: identity, outIn: identity };\n})();\n\nconst HALF_PI = Math.PI / 2;\n\nconst SINE = family({\n  in: (t) => 1 - Math.cos(t * HALF_PI),\n  out: (t) => Math.sin(t * HALF_PI),\n  inOut: (t) => -0.5 * (Math.cos(Math.PI * t) - 1),\n});\n\nconst QUINT = family({\n  in: (t) => t ** 5,\n  out: (t) => (t - 1) ** 5 + 1,\n  inOut: (t) => {\n    const u = t * 2;\n    return u < 1 ? 0.5 * u ** 5 : 0.5 * ((u - 2) ** 5 + 2);\n  },\n});\n\nconst QUART = family({\n  in: (t) => t ** 4,\n  out: (t) => -((t - 1) ** 4 - 1),\n  inOut: (t) => {\n    const u = t * 2;\n    return u < 1 ? 0.5 * u ** 4 : -0.5 * ((u - 2) ** 4 - 2);\n  },\n});\n\nconst QUAD = family({\n  in: (t) => t ** 2,\n  out: (t) => -t * (t - 2),\n  inOut: (t) => {\n    const u = t * 2;\n    return u < 1 ? 0.5 * u ** 2 : -0.5 * ((u - 1) * (u - 3) - 1);\n  },\n});\n\n// Expo carries Godot's (Penner's) small corrections — `- c * 0.001` on the way in, `* 1.001` on the way out — which\n// exist to pull the curve's start/end onto the endpoints. They are kept EXACTLY: `godotEaseSample` is meant to\n// reproduce the game's numbers, including that `Expo::in` really does reach only 0.999 as t approaches d.\nconst EXPO = family({\n  in: (t) => (t === 0 ? 0 : 2 ** (10 * (t - 1)) - 0.001),\n  out: (t) => (t === 1 ? 1 : 1.001 * (1 - 2 ** (-10 * t))),\n  inOut: (t) => {\n    if (t === 0) return 0;\n    if (t === 1) return 1;\n    const u = t * 2;\n    return u < 1\n      ? 0.5 * 2 ** (10 * (u - 1)) - 0.0005\n      : 0.5 * 1.0005 * (2 - 2 ** (-10 * (u - 1)));\n  },\n});\n\n// Elastic with d=1: p = 0.3 (period), s = p/4 = 0.075 (phase shift); the in-out variant stretches the period to\n// 0.3*1.5 = 0.45, so s = 0.1125.\nconst ELASTIC_PERIOD = 0.3;\nconst ELASTIC_SHIFT = ELASTIC_PERIOD / 4;\nconst ELASTIC_INOUT_PERIOD = 0.3 * 1.5;\nconst ELASTIC_INOUT_SHIFT = ELASTIC_INOUT_PERIOD / 4;\n\nconst ELASTIC = family({\n  in: (t) => {\n    if (t === 0) return 0;\n    if (t === 1) return 1;\n    const u = t - 1;\n    const a = 2 ** (10 * u);\n    return -(\n      a * Math.sin(((u - ELASTIC_SHIFT) * (2 * Math.PI)) / ELASTIC_PERIOD)\n    );\n  },\n  out: (t) => {\n    if (t === 0) return 0;\n    if (t === 1) return 1;\n    return (\n      2 ** (-10 * t) *\n        Math.sin(((t - ELASTIC_SHIFT) * (2 * Math.PI)) / ELASTIC_PERIOD) +\n      1\n    );\n  },\n  inOut: (t) => {\n    if (t === 0) return 0;\n    const u = t * 2;\n    if (u === 2) return 1;\n    const v = u - 1;\n    const phase = Math.sin(\n      ((v - ELASTIC_INOUT_SHIFT) * (2 * Math.PI)) / ELASTIC_INOUT_PERIOD,\n    );\n    return u < 1\n      ? -0.5 * (2 ** (10 * v) * phase)\n      : 2 ** (-10 * v) * phase * 0.5 + 1;\n  },\n});\n\nconst CUBIC = family({\n  in: (t) => t * t * t,\n  out: (t) => {\n    const u = t - 1;\n    return u * u * u + 1;\n  },\n  inOut: (t) => {\n    const u = t * 2;\n    if (u < 1) return 0.5 * u * u * u;\n    const v = u - 2;\n    return 0.5 * (v * v * v + 2);\n  },\n});\n\nconst CIRC = family({\n  in: (t) => -(Math.sqrt(1 - t * t) - 1),\n  out: (t) => {\n    const u = t - 1;\n    return Math.sqrt(1 - u * u);\n  },\n  inOut: (t) => {\n    const u = t * 2;\n    if (u < 1) return -0.5 * (Math.sqrt(1 - u * u) - 1);\n    const v = u - 2;\n    return 0.5 * (Math.sqrt(1 - v * v) + 1);\n  },\n});\n\nconst BOUNCE_OUT: EaseSampler = (t) => {\n  if (t < 1 / 2.75) return 7.5625 * t * t;\n  if (t < 2 / 2.75) {\n    const u = t - 1.5 / 2.75;\n    return 7.5625 * u * u + 0.75;\n  }\n  if (t < 2.5 / 2.75) {\n    const u = t - 2.25 / 2.75;\n    return 7.5625 * u * u + 0.9375;\n  }\n  const u = t - 2.625 / 2.75;\n  return 7.5625 * u * u + 0.984375;\n};\n\n// Bounce::in is defined as `c - out(d - t)`, and Bounce::in_out as in-then-out over the halves (NOT the usual\n// dedicated equation) — same for Spring.\nconst BOUNCE_HALVES = {\n  in: (t: number) => 1 - BOUNCE_OUT(1 - t),\n  out: BOUNCE_OUT,\n};\nconst BOUNCE: EaseFamily = {\n  ...BOUNCE_HALVES,\n  inOut: inOutOf(BOUNCE_HALVES),\n  outIn: outInOf(BOUNCE_HALVES),\n};\n\nconst BACK_OVERSHOOT = 1.70158;\nconst BACK_INOUT_OVERSHOOT = 1.70158 * 1.525;\n\nconst BACK = family({\n  in: (t) => t * t * ((BACK_OVERSHOOT + 1) * t - BACK_OVERSHOOT),\n  out: (t) => {\n    const u = t - 1;\n    return u * u * ((BACK_OVERSHOOT + 1) * u + BACK_OVERSHOOT) + 1;\n  },\n  inOut: (t) => {\n    const s = BACK_INOUT_OVERSHOOT;\n    const u = t * 2;\n    if (u < 1) return 0.5 * (u * u * ((s + 1) * u - s));\n    const v = u - 2;\n    return 0.5 * (v * v * ((s + 1) * v + s) + 2);\n  },\n});\n\nconst SPRING_OUT: EaseSampler = (t) => {\n  const s = 1 - t;\n  return (\n    (Math.sin(t * Math.PI * (0.2 + 2.5 * t * t * t)) * s ** 2.2 + t) *\n    (1 + 1.2 * s)\n  );\n};\n\nconst SPRING_HALVES = {\n  in: (t: number) => 1 - SPRING_OUT(1 - t),\n  out: SPRING_OUT,\n};\nconst SPRING: EaseFamily = {\n  ...SPRING_HALVES,\n  inOut: inOutOf(SPRING_HALVES),\n  outIn: outInOf(SPRING_HALVES),\n};\n\n// Keyed by the lowercased Godot TransitionType name, in the enum's own order (tween.cpp `interpolaters`).\nconst FAMILIES = new Map<string, EaseFamily>([\n  [\"linear\", LINEAR],\n  [\"sine\", SINE],\n  [\"quint\", QUINT],\n  [\"quart\", QUART],\n  [\"quad\", QUAD],\n  [\"expo\", EXPO],\n  [\"elastic\", ELASTIC],\n  [\"cubic\", CUBIC],\n  [\"circ\", CIRC],\n  [\"bounce\", BOUNCE],\n  [\"back\", BACK],\n  [\"spring\", SPRING],\n]);\n\nfunction normalizeName(name: string | undefined): string {\n  if (typeof name !== \"string\") return \"\";\n  const cached = normalizedNames.get(name);\n  if (cached !== undefined) return cached;\n  const normalized = name.toLowerCase().replace(/[^a-z]/g, \"\");\n  if (normalizedNames.size < NORMALIZED_NAME_CACHE_LIMIT)\n    normalizedNames.set(name, normalized);\n  return normalized;\n}\n\n/** Select Godot's family/mode column, with the engine's missing/unknown-name defaults. */\nfunction resolveEaseSampler(\n  ease: string | undefined,\n  trans: string | undefined,\n): EaseSampler {\n  const family = FAMILIES.get(normalizeName(trans)) ?? LINEAR;\n  const mode = normalizeName(ease);\n  return mode === \"in\"\n    ? family.in\n    : mode === \"out\"\n      ? family.out\n      : mode === \"outin\"\n        ? family.outIn\n        : family.inOut;\n}\n\nfunction sampleResolvedEase(sample: EaseSampler, t: number): number {\n  if (!(t > 0)) return 0;\n  if (t >= 1) return 1;\n  return sample(t);\n}\n\n/**\n * Resolve a Godot easing family and mode once, returning a sampler for normalized time `t`.\n *\n * The returned function has the same endpoint behavior as `godotEaseSample`: values at or below\n * zero (including NaN) are zero and values at or above one are one. Missing and unknown names use\n * Godot's defaults (linear transition and in-out ease mode).\n */\nexport function createEaseSampler(\n  ease: string | undefined,\n  trans: string | undefined,\n): (t: number) => number {\n  const sample = resolveEaseSampler(ease, trans);\n  return (t) => sampleResolvedEase(sample, t);\n}\n\n/**\n * Sample Godot's easing curve at normalized time `t`, returning the normalized progress (0 at the start, 1 at the\n * end, and freely outside that range in between for the overshooting families).\n *\n * `ease` and `trans` are the RAW Godot enum names as they arrive over a live wire, exactly like\n * `godotEasingToCss`: `ease` is \"In\"/\"Out\"/\"InOut\"/\"OutIn\" and `trans` is \"Linear\"/\"Sine\"/\"Quint\"/\"Quart\"/\"Quad\"/\n * \"Expo\"/\"Elastic\"/\"Cubic\"/\"Circ\"/\"Bounce\"/\"Back\"/\"Spring\". Both are case-insensitive and tolerate separators\n * (\"in_out\" reads as \"InOut\"). Unlike the CSS mapping — which has to collapse \"OutIn\" into the in-out column\n * because CSS cannot express it — every one of Godot's four ease modes is available here.\n *\n * Defaults match Godot's `Tween`: a missing `trans` is TRANS_LINEAR and a missing `ease` is EASE_IN_OUT\n * (`scene/animation/tween.h`). An UNRECOGNISED family also falls back to linear, so an unknown name degrades to\n * \"plays at the right speed on average\" rather than to a guess with the wrong shape.\n *\n * `t` is clamped to [0, 1] (NaN reads as 0). Returning exactly 1 at t >= 1 is what the engine does, not a\n * convenience: `PropertyTweener::step` assigns `final_val` outright once the elapsed time reaches the duration and\n * never evaluates the equation there (`tween.cpp`). It matters for Expo, whose raw equation would end at 0.999.\n */\nexport function godotEaseSample(\n  ease: string | undefined,\n  trans: string | undefined,\n  t: number,\n): number {\n  return sampleResolvedEase(resolveEaseSampler(ease, trans), t);\n}\n"],"mappings":"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"}

package/dist/index-CeKMJryT.d.ts

@@ -0,0 +1,31 @@
+//#region src/easing/numeric.d.ts
+/**
+ * Resolve a Godot easing family and mode once, returning a sampler for normalized time `t`.
+ *
+ * The returned function has the same endpoint behavior as `godotEaseSample`: values at or below
+ * zero (including NaN) are zero and values at or above one are one. Missing and unknown names use
+ * Godot's defaults (linear transition and in-out ease mode).
+ */
+declare function createEaseSampler(ease: string | undefined, trans: string | undefined): (t: number) => number;
+/**
+ * Sample Godot's easing curve at normalized time `t`, returning the normalized progress (0 at the start, 1 at the
+ * end, and freely outside that range in between for the overshooting families).
+ *
+ * `ease` and `trans` are the RAW Godot enum names as they arrive over a live wire, exactly like
+ * `godotEasingToCss`: `ease` is "In"/"Out"/"InOut"/"OutIn" and `trans` is "Linear"/"Sine"/"Quint"/"Quart"/"Quad"/
+ * "Expo"/"Elastic"/"Cubic"/"Circ"/"Bounce"/"Back"/"Spring". Both are case-insensitive and tolerate separators
+ * ("in_out" reads as "InOut"). Unlike the CSS mapping — which has to collapse "OutIn" into the in-out column
+ * because CSS cannot express it — every one of Godot's four ease modes is available here.
+ *
+ * Defaults match Godot's `Tween`: a missing `trans` is TRANS_LINEAR and a missing `ease` is EASE_IN_OUT
+ * (`scene/animation/tween.h`). An UNRECOGNISED family also falls back to linear, so an unknown name degrades to
+ * "plays at the right speed on average" rather than to a guess with the wrong shape.
+ *
+ * `t` is clamped to [0, 1] (NaN reads as 0). Returning exactly 1 at t >= 1 is what the engine does, not a
+ * convenience: `PropertyTweener::step` assigns `final_val` outright once the elapsed time reaches the duration and
+ * never evaluates the equation there (`tween.cpp`). It matters for Expo, whose raw equation would end at 0.999.
+ */
+declare function godotEaseSample(ease: string | undefined, trans: string | undefined, t: number): number;
+//#endregion
+export { godotEaseSample as n, createEaseSampler as t };
+//# sourceMappingURL=index-CeKMJryT.d.ts.map

package/dist/index-CeKMJryT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CeKMJryT.d.ts","names":[],"sources":["../src/easing/numeric.ts"],"mappings":";;AAuSA;;;;;;iBAAgB,iBAAA,CACd,IAAA,sBACA,KAAA,wBACE,CAAA;;AAAS;AAuBb;;;;;;;;AAGW;;;;;;;;iBAHK,eAAA,CACd,IAAA,sBACA,KAAA,sBACA,CAAA"}