https://x9768-wisdom-of-the-rishis.hf.space/assets/svelte/svelte_easing.js

1/*
2Adapted from https://github.com/mattdesl
3Distributed under MIT License https://github.com/mattdesl/eases/blob/master/LICENSE.md
4*/
5
6/**
7 * @param {number} t
8 * @returns {number}
9 */
10function linear(t) {
11	return t;
12}
13
14/**
15 * @param {number} t
16 * @returns {number}
17 */
18function backInOut(t) {
19	const s = 1.70158 * 1.525;
20	if ((t *= 2) < 1) return 0.5 * (t * t * ((s + 1) * t - s));
21	return 0.5 * ((t -= 2) * t * ((s + 1) * t + s) + 2);
22}
23
24/**
25 * @param {number} t
26 * @returns {number}
27 */
28function backIn(t) {
29	const s = 1.70158;
30	return t * t * ((s + 1) * t - s);
31}
32
33/**
34 * @param {number} t
35 * @returns {number}
36 */
37function backOut(t) {
38	const s = 1.70158;
39	return --t * t * ((s + 1) * t + s) + 1;
40}
41
42/**
43 * @param {number} t
44 * @returns {number}
45 */
46function bounceOut(t) {
47	const a = 4.0 / 11.0;
48	const b = 8.0 / 11.0;
49	const c = 9.0 / 10.0;
50	const ca = 4356.0 / 361.0;
51	const cb = 35442.0 / 1805.0;
52	const cc = 16061.0 / 1805.0;
53	const t2 = t * t;
54	return t < a
55		? 7.5625 * t2
56		: t < b
57			? 9.075 * t2 - 9.9 * t + 3.4
58			: t < c
59				? ca * t2 - cb * t + cc
60				: 10.8 * t * t - 20.52 * t + 10.72;
61}
62
63/**
64 * @param {number} t
65 * @returns {number}
66 */
67function bounceInOut(t) {
68	return t < 0.5 ? 0.5 * (1.0 - bounceOut(1.0 - t * 2.0)) : 0.5 * bounceOut(t * 2.0 - 1.0) + 0.5;
69}
70
71/**
72 * @param {number} t
73 * @returns {number}
74 */
75function bounceIn(t) {
76	return 1.0 - bounceOut(1.0 - t);
77}
78
79/**
80 * @param {number} t
81 * @returns {number}
82 */
83function circInOut(t) {
84	if ((t *= 2) < 1) return -0.5 * (Math.sqrt(1 - t * t) - 1);
85	return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
86}
87
88/**
89 * @param {number} t
90 * @returns {number}
91 */
92function circIn(t) {
93	return 1.0 - Math.sqrt(1.0 - t * t);
94}
95
96/**
97 * @param {number} t
98 * @returns {number}
99 */
100function circOut(t) {
101	return Math.sqrt(1 - --t * t);
102}
103
104/**
105 * @param {number} t
106 * @returns {number}
107 */
108function cubicInOut(t) {
109	return t < 0.5 ? 4.0 * t * t * t : 0.5 * Math.pow(2.0 * t - 2.0, 3.0) + 1.0;
110}
111
112/**
113 * @param {number} t
114 * @returns {number}
115 */
116function cubicIn(t) {
117	return t * t * t;
118}
119
120/**
121 * @param {number} t
122 * @returns {number}
123 */
124function cubicOut(t) {
125	const f = t - 1.0;
126	return f * f * f + 1.0;
127}
128
129/**
130 * @param {number} t
131 * @returns {number}
132 */
133function elasticInOut(t) {
134	return t < 0.5
135		? 0.5 * Math.sin(((13 * Math.PI) / 2) * 2.0 * t) * Math.pow(2.0, 10.0 * (2.0 * t - 1.0))
136		: 0.5 *
137				Math.sin(((-13 * Math.PI) / 2) * (2.0 * t - 1.0 + 1.0)) *
138				Math.pow(2.0, -10 * (2.0 * t - 1.0)) +
139				1.0;
140}
141
142/**
143 * @param {number} t
144 * @returns {number}
145 */
146function elasticIn(t) {
147	return Math.sin((13.0 * t * Math.PI) / 2) * Math.pow(2.0, 10.0 * (t - 1.0));
148}
149
150/**
151 * @param {number} t
152 * @returns {number}
153 */
154function elasticOut(t) {
155	return Math.sin((-13 * (t + 1.0) * Math.PI) / 2) * Math.pow(2.0, -10 * t) + 1.0;
156}
157
158/**
159 * @param {number} t
160 * @returns {number}
161 */
162function expoInOut(t) {
163	return t === 0.0 || t === 1.0
164		? t
165		: t < 0.5
166			? 0.5 * Math.pow(2.0, 20.0 * t - 10.0)
167			: -0.5 * Math.pow(2.0, 10.0 - t * 20.0) + 1.0;
168}
169
170/**
171 * @param {number} t
172 * @returns {number}
173 */
174function expoIn(t) {
175	return t === 0.0 ? t : Math.pow(2.0, 10.0 * (t - 1.0));
176}
177
178/**
179 * @param {number} t
180 * @returns {number}
181 */
182function expoOut(t) {
183	return t === 1.0 ? t : 1.0 - Math.pow(2.0, -10 * t);
184}
185
186/**
187 * @param {number} t
188 * @returns {number}
189 */
190function quadInOut(t) {
191	t /= 0.5;
192	if (t < 1) return 0.5 * t * t;
193	t--;
194	return -0.5 * (t * (t - 2) - 1);
195}
196
197/**
198 * @param {number} t
199 * @returns {number}
200 */
201function quadIn(t) {
202	return t * t;
203}
204
205/**
206 * @param {number} t
207 * @returns {number}
208 */
209function quadOut(t) {
210	return -t * (t - 2.0);
211}
212
213/**
214 * @param {number} t
215 * @returns {number}
216 */
217function quartInOut(t) {
218	return t < 0.5 ? 8 * Math.pow(t, 4.0) : -8 * Math.pow(t - 1.0, 4.0) + 1.0;
219}
220
221/**
222 * @param {number} t
223 * @returns {number}
224 */
225function quartIn(t) {
226	return Math.pow(t, 4.0);
227}
228
229/**
230 * @param {number} t
231 * @returns {number}
232 */
233function quartOut(t) {
234	return Math.pow(t - 1.0, 3.0) * (1.0 - t) + 1.0;
235}
236
237/**
238 * @param {number} t
239 * @returns {number}
240 */
241function quintInOut(t) {
242	if ((t *= 2) < 1) return 0.5 * t * t * t * t * t;
243	return 0.5 * ((t -= 2) * t * t * t * t + 2);
244}
245
246/**
247 * @param {number} t
248 * @returns {number}
249 */
250function quintIn(t) {
251	return t * t * t * t * t;
252}
253
254/**
255 * @param {number} t
256 * @returns {number}
257 */
258function quintOut(t) {
259	return --t * t * t * t * t + 1;
260}
261
262/**
263 * @param {number} t
264 * @returns {number}
265 */
266function sineInOut(t) {
267	return -0.5 * (Math.cos(Math.PI * t) - 1);
268}
269
270/**
271 * @param {number} t
272 * @returns {number}
273 */
274function sineIn(t) {

275	const v = Math.cos(t * Math.PI * 0.5);
276	if (Math.abs(v) < 1e-14) return 1;
277	else return 1 - v;
278}
279
280/**
281 * @param {number} t
282 * @returns {number}
283 */
284function sineOut(t) {
285	return Math.sin((t * Math.PI) / 2);
286}
287
288export { backIn, backInOut, backOut, bounceIn, bounceInOut, bounceOut, circIn, circInOut, circOut, cubicIn, cubicInOut, cubicOut, elasticIn, elasticInOut, elasticOut, expoIn, expoInOut, expoOut, linear, quadIn, quadInOut, quadOut, quartIn, quartInOut, quartOut, quintIn, quintInOut, quintOut, sineIn, sineInOut, sineOut };