@dropecho/easings 0.1.0

package/LICENSE.md

@@ -0,0 +1,22 @@
+This code is licensed under the MIT License:
+
+> Copyright (c) 2020: Ben Van Treese 
+> 
+> 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/README.md

@@ -0,0 +1,66 @@
+# dropecho.easings
+
+A small Haxe library of easing functions (linear transformations) and interpolation
+helpers for games and animation. Compiles to JavaScript and C#.
+
+## Install
+
+```bash
+haxelib install dropecho.easings   # Haxe
+npm install @dropecho/easings      # JavaScript
+```
+
+## Usage
+
+Easing functions take a normalized time `t` in `[0, 1]` and return the eased value,
+also in `[0, 1]`.
+
+### Haxe
+
+```haxe
+import dropecho.Easings;
+
+Easings.easeInQuad(0.25);                  // 0.0625
+Easings.easeOutCubic(0.25);                // 0.578125
+Easings.smoothStep(0.5);                   // 0.5
+Easings.mix(0, 100, 0.25);                 // 25   (lerp is an alias)
+Easings.rangeMap(0.25, 0, 1, 0, 255);      // 63.75
+Easings.rangeMapClamped(5, 0, 1, 0, 255);  // 255  (input clamped to the in-range)
+Easings.clamp(value, 0, 1);
+```
+
+### JavaScript
+
+The library is exposed as the `easings` object (CommonJS export, or a global in the browser).
+
+```js
+const { easings } = require("@dropecho/easings");
+
+easings.easeInQuad(0.25); // 0.0625
+easings.smoothStep(0.5);  // 0.5
+```
+
+## API
+
+| Group | Functions |
+|---|---|
+| Range / interpolation | `clamp`, `rangeMap`, `rangeMapClamped`, `mix`, `lerp` |
+| Ease in (accelerate from 0) | `easeInQuad`, `easeInCubic`, `easeInQuart`, `easeInQuint`, `easeInSine` |
+| Ease out (decelerate to 1) | `easeOutQuad`, `easeOutCubic`, `easeOutQuart`, `easeOutQuint` |
+| Composite / misc | `smoothStep`, `scale` |
+
+- **`rangeMap`** extrapolates outside the in-range; **`rangeMapClamped`** pins the result to
+  the out-range and handles inverted in-ranges (`inMin > inMax`).
+- **`scale(t, easing)`** returns `t · easing(t)`, a cheap way to sharpen an ease.
+
+## Development
+
+```bash
+npm run build   # build JS + C#
+npm test        # run the utest suite (via dropecho.testing)
+npm run bench   # run the benchmarks
+```
+
+## License
+
+MIT

package/dist/js/cjs/index.cjs

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.3.4
+(function ($hx_exports, $global) { "use strict";
+class dropecho_Easings {
+	static clamp(value,min,max) {
+		return Math.min(Math.max(value,min),max);
+	}
+	static rangeMap(value,inMin,inMax,outMin,outMax) {
+		return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+	}
+	static rangeMapClamped(value,inMin,inMax,outMin,outMax) {
+		value = inMin > inMax ? Math.min(Math.max(value,inMax),inMin) : Math.min(Math.max(value,inMin),inMax);
+		return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+	}
+	static mix(a,b,amount) {
+		return (1 - amount) * a + amount * b;
+	}
+	static lerp(a,b,amount) {
+		return (1 - amount) * a + amount * b;
+	}
+	static easeInQuad(t) {
+		return t * t;
+	}
+	static easeInCubic(t) {
+		return t * t * t;
+	}
+	static easeInQuart(t) {
+		return t * t * t * t;
+	}
+	static easeInQuint(t) {
+		return t * t * t * t * t;
+	}
+	static easeInSine(t) {
+		return 1 - Math.cos(t * Math.PI / 2);
+	}
+	static easeOutQuad(t) {
+		let __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base;
+	}
+	static easeOutCubic(t) {
+		let __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base * __pow_base;
+	}
+	static easeOutQuart(t) {
+		let __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base * __pow_base * __pow_base;
+	}
+	static easeOutQuint(t) {
+		let __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base * __pow_base * __pow_base * __pow_base;
+	}
+	static smoothStep(t) {
+		let __pow_base = 1 - t;
+		return (1 - t) * (t * t) + t * (1 - __pow_base * __pow_base);
+	}
+	static scale(t,easing) {
+		return t * easing(t);
+	}
+}
+$hx_exports["easings"] = dropecho_Easings;
+class dropecho_macros_MathMacros {
+}
+class haxe_iterators_ArrayIterator {
+	constructor(array) {
+		this.current = 0;
+		this.array = array;
+	}
+	hasNext() {
+		return this.current < this.array.length;
+	}
+	next() {
+		return this.array[this.current++];
+	}
+}
+{
+}
+})(typeof exports != "undefined" ? exports : typeof window != "undefined" ? window : typeof self != "undefined" ? self : this, {});

package/dist/js/esm/Std.d.ts

@@ -0,0 +1,6 @@
+
+/**
+The Std class provides standard methods for manipulating basic types.
+*/
+export declare class Std {
+}

package/dist/js/esm/Std.js

@@ -0,0 +1,18 @@
+import {Register} from "./genes/Register.js"
+
+/**
+The Std class provides standard methods for manipulating basic types.
+*/
+export const Std = Register.global("$hxClasses")["Std"] = 
+class Std {
+	static get __name__() {
+		return "Std"
+	}
+	get __class__() {
+		return Std
+	}
+}
+
+
+;{
+}

package/dist/js/esm/StdTypes.d.ts

@@ -0,0 +1,57 @@
+
+/**
+An `Iterator` is a structure that permits iteration over elements of type `T`.
+
+Any class with matching `hasNext()` and `next()` fields is considered an `Iterator`
+and can then be used e.g. in `for`-loops. This makes it easy to implement
+custom iterators.
+
+@see https://haxe.org/manual/lf-iterators.html
+*/
+export type Iterator<T> = {
+	/**
+	Returns `false` if the iteration is complete, `true` otherwise.
+	
+	Usually iteration is considered to be complete if all elements of the
+	underlying data structure were handled through calls to `next()`. However,
+	in custom iterators any logic may be used to determine the completion
+	state.
+	*/
+	hasNext: () => boolean, 
+	/**
+	Returns the current item of the `Iterator` and advances to the next one.
+	
+	This method is not required to check `hasNext()` first. A call to this
+	method while `hasNext()` is `false` yields unspecified behavior.
+	
+	On the other hand, iterators should not require a call to `hasNext()`
+	before the first call to `next()` if an element is available.
+	*/
+	next: () => T
+}
+
+/**
+An `Iterable` is a data structure which has an `iterator()` method.
+See `Lambda` for generic functions on iterable structures.
+
+@see https://haxe.org/manual/lf-iterators.html
+*/
+export type Iterable<T> = {
+	iterator: () => Iterator<T>
+}
+
+/**
+A `KeyValueIterator` is an `Iterator` that has a key and a value.
+*/
+export type KeyValueIterator<K, V> = Iterator<{
+	key: K, 
+	value: V
+}>
+
+/**
+A `KeyValueIterable` is a data structure which has a `keyValueIterator()`
+method to iterate over key-value-pairs.
+*/
+export type KeyValueIterable<K, V> = {
+	keyValueIterator: () => KeyValueIterator<K, V>
+}

package/dist/js/esm/dropecho/Easings.d.ts

@@ -0,0 +1,165 @@
+
+/**
+A small collection of easing and interpolation helpers.
+
+The easing functions (`easeIn*`, `easeOut*`, `easeInSine`, `smoothStep`) take a
+normalized time `t` in `[0, 1]` and return the eased value, also in `[0, 1]`.
+The range and interpolation helpers (`clamp`, `rangeMap`, `mix`/`lerp`) are
+general-purpose and accept any range.
+
+Exposed to JavaScript as the `easings` object via `@:expose`.
+*/
+export declare class Easings {
+	
+	/**
+	Constrain `value` to the inclusive range `[min, max]`.
+	
+	@param value The value to clamp.
+	@param min The lower bound.
+	@param max The upper bound.
+	@return `value` limited to `[min, max]`.
+	*/
+	static clamp(value: number, min: number, max: number): number
+	
+	/**
+	Linearly remap `value` from `[inMin, inMax]` onto `[outMin, outMax]`.
+	
+	The input is not clamped, so values outside the in-range extrapolate beyond
+	the out-range. Use `rangeMapClamped` to pin the result to the out-range.
+	
+	@param value The value to remap.
+	@param inMin The lower bound of the input range.
+	@param inMax The upper bound of the input range.
+	@param outMin The lower bound of the output range.
+	@param outMax The upper bound of the output range.
+	@return `value` mapped onto `[outMin, outMax]`.
+	*/
+	static rangeMap(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number
+	
+	/**
+	Like `rangeMap`, but `value` is first clamped to the in-range so the result
+	always stays within `[outMin, outMax]`. Inverted in-ranges (`inMin > inMax`)
+	are handled.
+	
+	@param value The value to remap.
+	@param inMin One bound of the input range.
+	@param inMax The other bound of the input range.
+	@param outMin The lower bound of the output range.
+	@param outMax The upper bound of the output range.
+	@return `value` clamped to the in-range and mapped onto `[outMin, outMax]`.
+	*/
+	static rangeMapClamped(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number
+	
+	/**
+	Linearly interpolate from `a` to `b` by `amount`.
+	
+	@param a The start value, returned when `amount` is `0`.
+	@param b The end value, returned when `amount` is `1`.
+	@param amount The interpolation factor, typically in `[0, 1]`.
+	@return The interpolated value between `a` and `b`.
+	*/
+	static mix(a: number, b: number, amount: number): number
+	
+	/**
+	Alias of `mix`.
+	
+	@param a The start value, returned when `amount` is `0`.
+	@param b The end value, returned when `amount` is `1`.
+	@param amount The interpolation factor, typically in `[0, 1]`.
+	@return The interpolated value between `a` and `b`.
+	@see `Easings.mix`
+	*/
+	static lerp(a: number, b: number, amount: number): number
+	
+	/**
+	Quadratic ease-in (`t²`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInQuad(t: number): number
+	
+	/**
+	Cubic ease-in (`t³`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInCubic(t: number): number
+	
+	/**
+	Quartic ease-in (`t⁴`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInQuart(t: number): number
+	
+	/**
+	Quintic ease-in (`t⁵`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInQuint(t: number): number
+	
+	/**
+	Sine ease-in (`1 - cos(t·π/2)`): accelerates gently from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInSine(t: number): number
+	
+	/**
+	Quadratic ease-out (`1 - (1 - t)²`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutQuad(t: number): number
+	
+	/**
+	Cubic ease-out (`1 - (1 - t)³`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutCubic(t: number): number
+	
+	/**
+	Quartic ease-out (`1 - (1 - t)⁴`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutQuart(t: number): number
+	
+	/**
+	Quintic ease-out (`1 - (1 - t)⁵`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutQuint(t: number): number
+	
+	/**
+	Smooth start-and-stop S-curve, blending quadratic ease-in and ease-out.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static smoothStep(t: number): number
+	
+	/**
+	Scale `easing(t)` by the raw time `t`, i.e. `t · easing(t)`.
+	
+	Multiplying by `t` biases the curve toward `0`, a cheap way to sharpen an
+	ease-in (e.g. `scale(t, easeInQuad)` behaves like `easeInCubic`).
+	
+	@param t Normalized time in `[0, 1]`.
+	@param easing The easing function to apply before scaling.
+	@return `t · easing(t)`.
+	*/
+	static scale(t: number, easing: ((arg0: number) => number)): number
+}

package/dist/js/esm/dropecho/Easings.js

@@ -0,0 +1,212 @@
+import {Register} from "../genes/Register.js"
+
+/**
+A small collection of easing and interpolation helpers.
+
+The easing functions (`easeIn*`, `easeOut*`, `easeInSine`, `smoothStep`) take a
+normalized time `t` in `[0, 1]` and return the eased value, also in `[0, 1]`.
+The range and interpolation helpers (`clamp`, `rangeMap`, `mix`/`lerp`) are
+general-purpose and accept any range.
+
+Exposed to JavaScript as the `easings` object via `@:expose`.
+*/
+export const Easings = Register.global("$hxClasses")["dropecho.Easings"] = 
+class Easings {
+	
+	/**
+	Constrain `value` to the inclusive range `[min, max]`.
+	
+	@param value The value to clamp.
+	@param min The lower bound.
+	@param max The upper bound.
+	@return `value` limited to `[min, max]`.
+	*/
+	static clamp(value, min, max) {
+		return Math.min(Math.max(value, min), max);
+	}
+	
+	/**
+	Linearly remap `value` from `[inMin, inMax]` onto `[outMin, outMax]`.
+	
+	The input is not clamped, so values outside the in-range extrapolate beyond
+	the out-range. Use `rangeMapClamped` to pin the result to the out-range.
+	
+	@param value The value to remap.
+	@param inMin The lower bound of the input range.
+	@param inMax The upper bound of the input range.
+	@param outMin The lower bound of the output range.
+	@param outMax The upper bound of the output range.
+	@return `value` mapped onto `[outMin, outMax]`.
+	*/
+	static rangeMap(value, inMin, inMax, outMin, outMax) {
+		return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+	}
+	
+	/**
+	Like `rangeMap`, but `value` is first clamped to the in-range so the result
+	always stays within `[outMin, outMax]`. Inverted in-ranges (`inMin > inMax`)
+	are handled.
+	
+	@param value The value to remap.
+	@param inMin One bound of the input range.
+	@param inMax The other bound of the input range.
+	@param outMin The lower bound of the output range.
+	@param outMax The upper bound of the output range.
+	@return `value` clamped to the in-range and mapped onto `[outMin, outMax]`.
+	*/
+	static rangeMapClamped(value, inMin, inMax, outMin, outMax) {
+		value = (inMin > inMax) ? Math.min(Math.max(value, inMax), inMin) : Math.min(Math.max(value, inMin), inMax);
+		return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+	}
+	
+	/**
+	Linearly interpolate from `a` to `b` by `amount`.
+	
+	@param a The start value, returned when `amount` is `0`.
+	@param b The end value, returned when `amount` is `1`.
+	@param amount The interpolation factor, typically in `[0, 1]`.
+	@return The interpolated value between `a` and `b`.
+	*/
+	static mix(a, b, amount) {
+		return (1 - amount) * a + amount * b;
+	}
+	
+	/**
+	Alias of `mix`.
+	
+	@param a The start value, returned when `amount` is `0`.
+	@param b The end value, returned when `amount` is `1`.
+	@param amount The interpolation factor, typically in `[0, 1]`.
+	@return The interpolated value between `a` and `b`.
+	@see `Easings.mix`
+	*/
+	static lerp(a, b, amount) {
+		return (1 - amount) * a + amount * b;
+	}
+	
+	/**
+	Quadratic ease-in (`t²`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInQuad(t) {
+		return t * t;
+	}
+	
+	/**
+	Cubic ease-in (`t³`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInCubic(t) {
+		return t * t * t;
+	}
+	
+	/**
+	Quartic ease-in (`t⁴`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInQuart(t) {
+		return t * t * t * t;
+	}
+	
+	/**
+	Quintic ease-in (`t⁵`): accelerates from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInQuint(t) {
+		return t * t * t * t * t;
+	}
+	
+	/**
+	Sine ease-in (`1 - cos(t·π/2)`): accelerates gently from `0`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeInSine(t) {
+		return 1 - Math.cos(t * Math.PI / 2);
+	}
+	
+	/**
+	Quadratic ease-out (`1 - (1 - t)²`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutQuad(t) {
+		var __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base;
+	}
+	
+	/**
+	Cubic ease-out (`1 - (1 - t)³`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutCubic(t) {
+		var __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base * __pow_base;
+	}
+	
+	/**
+	Quartic ease-out (`1 - (1 - t)⁴`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutQuart(t) {
+		var __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base * __pow_base * __pow_base;
+	}
+	
+	/**
+	Quintic ease-out (`1 - (1 - t)⁵`): decelerates to `1`.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static easeOutQuint(t) {
+		var __pow_base = 1 - t;
+		return 1 - __pow_base * __pow_base * __pow_base * __pow_base * __pow_base;
+	}
+	
+	/**
+	Smooth start-and-stop S-curve, blending quadratic ease-in and ease-out.
+	
+	@param t Normalized time in `[0, 1]`.
+	@return The eased value in `[0, 1]`.
+	*/
+	static smoothStep(t) {
+		var __pow_base = 1 - t;
+		return (1 - t) * (t * t) + t * (1 - __pow_base * __pow_base);
+	}
+	
+	/**
+	Scale `easing(t)` by the raw time `t`, i.e. `t · easing(t)`.
+	
+	Multiplying by `t` biases the curve toward `0`, a cheap way to sharpen an
+	ease-in (e.g. `scale(t, easeInQuad)` behaves like `easeInCubic`).
+	
+	@param t Normalized time in `[0, 1]`.
+	@param easing The easing function to apply before scaling.
+	@return `t · easing(t)`.
+	*/
+	static scale(t, easing) {
+		return t * easing(t);
+	}
+	static get __name__() {
+		return "dropecho.Easings"
+	}
+	get __class__() {
+		return Easings
+	}
+}
+

package/dist/js/esm/dropecho/macros/MathMacros.d.ts

@@ -0,0 +1,6 @@
+
+/**
+Compile-time math helpers implemented as expression macros.
+*/
+export declare class MathMacros {
+}

package/dist/js/esm/dropecho/macros/MathMacros.js

@@ -0,0 +1,15 @@
+import {Register} from "../../genes/Register.js"
+
+/**
+Compile-time math helpers implemented as expression macros.
+*/
+export const MathMacros = Register.global("$hxClasses")["dropecho.macros.MathMacros"] = 
+class MathMacros {
+	static get __name__() {
+		return "dropecho.macros.MathMacros"
+	}
+	get __class__() {
+		return MathMacros
+	}
+}
+

package/dist/js/esm/genes/Register.d.ts

@@ -0,0 +1,15 @@
+import {Iterator} from "../StdTypes"
+
+export declare class Register {
+	static $global: any
+	protected static globals: {
+	}
+	static global(name: number): any
+	static createStatic<T>(obj: {
+	}, name: string, get: (() => T)): void
+	static iter<T>(a: T[]): Iterator<T>
+	static extend(superClass: any): void
+	static inherits(resolve: any, defer?: boolean): void
+	protected static fid: number
+	static bind(o: any, m: any): null | any
+}

package/dist/js/esm/genes/Register.js

@@ -0,0 +1,107 @@
+
+export class Register {
+	static global(name) {
+		if (Register.globals[name]) {
+			return Register.globals[name];
+		} else {
+			return Register.globals[name] = {};
+		};
+	}
+	static createStatic(obj, name, get) {
+		var value = null;
+		Object.defineProperty(obj, name, {"enumerable": true, "get": function () {
+			if (get != null) {
+				value = get();
+				get = null;
+			};
+			return value;
+		}, "set": function (v) {
+			if (get != null) {
+				value = get();
+				get = null;
+			};
+			value = v;
+		}});
+	}
+	static iter(a) {
+		if (!Array.isArray(a)) {
+			return a.iterator();
+		} else {
+			return {"cur": 0, "arr": a, "hasNext": function () {
+				return this.cur < this.arr.length;
+			}, "next": function () {
+				return this.arr[this.cur++];
+			}};
+		};
+	}
+	static extend(superClass) {
+		
+      function res() {
+        this.new.apply(this, arguments)
+      }
+      Object.setPrototypeOf(res.prototype, superClass.prototype)
+      return res
+    ;
+	}
+	static inherits(resolve, defer) {
+		if (defer == null) {
+			defer = false;
+		};
+		
+      function res() {
+        if (defer && resolve && res.__init__) res.__init__()
+        this.new.apply(this, arguments)
+      }
+      if (!defer) {
+        if (resolve && resolve.__init__) {
+          defer = true
+          res.__init__ = () => {
+            resolve.__init__()
+            Object.setPrototypeOf(res.prototype, resolve.prototype)
+            res.__init__ = undefined
+          } 
+        } else if (resolve) {
+          Object.setPrototypeOf(res.prototype, resolve.prototype)
+        }
+      } else {
+        res.__init__ = () => {
+          const superClass = resolve()
+          if (superClass.__init__) superClass.__init__()
+          Object.setPrototypeOf(res.prototype, superClass.prototype)
+          res.__init__ = undefined
+        } 
+      }
+      return res
+    ;
+	}
+	static bind(o, m) {
+		if (m == null) {
+			return null;
+		};
+		if (m.__id__ == null) {
+			m.__id__ = Register.fid++;
+		};
+		var f = null;
+		if (o.hx__closures__ == null) {
+			o.hx__closures__ = {};
+		} else {
+			f = o.hx__closures__[m.__id__];
+		};
+		if (f == null) {
+			f = m.bind(o);
+			o.hx__closures__[m.__id__] = f;
+		};
+		return f;
+	}
+	static get __name__() {
+		return "genes.Register"
+	}
+	get __class__() {
+		return Register
+	}
+}
+
+
+Register.$global = typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : undefined
+Register.globals = {}
+Register.fid = 0

package/dist/js/esm/haxe/NativeStackTrace.d.ts

@@ -0,0 +1,7 @@
+
+export type V8CallSite = {
+	getColumnNumber: () => number, 
+	getFileName: () => string, 
+	getFunctionName: () => string, 
+	getLineNumber: () => number
+}

package/dist/js/esm/haxe/Rest.d.ts

@@ -0,0 +1,2 @@
+
+export type NativeRest<T> = T[]

package/dist/js/esm/haxe/extern/Rest.d.ts

@@ -0,0 +1,11 @@
+
+/**
+DEPRECATED: use haxe.Rest instead.
+
+A special type that represents "rest" function argument.
+Should be used as a type for the last argument of an extern method,
+representing that arbitrary number of arguments of given type can be
+passed to that method.
+@see <https://haxe.org/manual/lf-externs.html>
+*/
+export type Rest<T> = T[]

package/dist/js/esm/haxe/iterators/ArrayIterator.d.ts

@@ -0,0 +1,19 @@
+
+/**
+This iterator is used only when `Array<T>` is passed to `Iterable<T>`
+*/
+export declare class ArrayIterator<T> {
+	constructor(array: T[])
+	protected array: T[]
+	protected current: number
+	
+	/**
+	See `Iterator.hasNext`
+	*/
+	hasNext(): boolean
+	
+	/**
+	See `Iterator.next`
+	*/
+	next(): T
+}

package/dist/js/esm/haxe/iterators/ArrayIterator.js

@@ -0,0 +1,33 @@
+import {Register} from "../../genes/Register.js"
+
+/**
+This iterator is used only when `Array<T>` is passed to `Iterable<T>`
+*/
+export const ArrayIterator = Register.global("$hxClasses")["haxe.iterators.ArrayIterator"] = 
+class ArrayIterator extends Register.inherits() {
+	new(array) {
+		this.current = 0;
+		this.array = array;
+	}
+	
+	/**
+	See `Iterator.hasNext`
+	*/
+	hasNext() {
+		return this.current < this.array.length;
+	}
+	
+	/**
+	See `Iterator.next`
+	*/
+	next() {
+		return this.array[this.current++];
+	}
+	static get __name__() {
+		return "haxe.iterators.ArrayIterator"
+	}
+	get __class__() {
+		return ArrayIterator
+	}
+}
+

package/dist/js/esm/index.d.ts

@@ -0,0 +1,2 @@
+
+export {Easings} from "./dropecho/Easings"

package/dist/js/esm/index.js

@@ -0,0 +1,3 @@
+import {Register} from "./genes/Register.js"
+
+export {Easings} from "./dropecho/Easings.js"

package/dist/js/esm/js/lib/Object.d.ts

@@ -0,0 +1,82 @@
+
+/**
+Type for
+@see <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object>
+*/
+export type ObjectPrototype = {
+	/**
+	Returns a boolean indicating whether an object contains the specified
+	property as a direct property of that object and not inherited through
+	the prototype chain.
+	*/
+	hasOwnProperty: Function, 
+	/**
+	Returns a boolean indicating whether the object this method is called
+	upon is in the prototype chain of the specified object.
+	*/
+	isPrototypeOf: Function, 
+	/**
+	Returns a boolean indicating if the internal enumerable attribute is set.
+	*/
+	propertyIsEnumerable: Function, 
+	/**
+	Calls `toString()`.
+	*/
+	toLocaleString: Function, 
+	/**
+	Returns a string representation of the object.
+	*/
+	toString: Function, 
+	/**
+	Returns the primitive value of the specified object.
+	*/
+	valueOf: Function
+}
+
+/**
+@see <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty>
+*/
+export type ObjectPropertyDescriptor = {
+	/**
+	`true` if and only if the type of this property descriptor may be
+	changed and if the property may be deleted from the corresponding object.
+	
+	Defaults to `false`.
+	*/
+	configurable?: null | boolean, 
+	/**
+	`true` if and only if this property shows up during enumeration of the
+	properties on the corresponding object.
+	
+	Defaults to `false`.
+	*/
+	enumerable?: null | boolean, 
+	/**
+	A function which serves as a getter for the property, or `undefined` if
+	there is no getter. When the property is accessed, this function is
+	called without arguments and with `this` set to the object through which
+	the property is accessed (this may not be the object on which the
+	property is defined due to inheritance).
+	The return value will be used as the value of the property.
+	*/
+	get?: null | (() => any), 
+	/**
+	A function which serves as a setter for the property, or undefined if
+	there is no setter. When the property is assigned to, this function
+	is called with one argument (the value being assigned to the property)
+	and with `this` set to the object through which the property is assigned.
+	*/
+	set?: null | ((arg0: any) => void), 
+	/**
+	The value associated with the property.
+	Can be any valid JavaScript value (number, object, function, etc).
+	*/
+	value?: null | any, 
+	/**
+	`true` if and only if the value associated with the property may be
+	changed with an assignment operator.
+	
+	Defaults to `false`.
+	*/
+	writable?: null | boolean
+}

package/dist/js/esm/js/lib/Promise.d.ts

@@ -0,0 +1,10 @@
+
+export type ThenableStruct<T> = {
+	then: <TOut>(onFulfilled: null | ((arg0: T) => any), onRejected?: ((arg0: any) => any)) => ThenableStruct<TOut>
+}
+
+export type PromiseSettleOutcome<T> = {
+	reason?: null | any, 
+	status: string, 
+	value?: null | T
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@dropecho/easings",
+  "version": "0.1.0",
+  "description": "A library of easings (linear transformations).",
+  "author": "vantreeseba <vantreeseba@gmail.com>",
+  "repository": "github:dropecho/easings",
+  "type": "module",
+  "main": "./dist/js/cjs/index.cjs",
+  "types": "./dist/js/esm/index.d.ts",
+  "files": [
+    "dist/js/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "prepare": "lix download",
+    "build": "npm run clean && haxe build.hxml",
+    "test": "lix dropecho.testing",
+    "clean": "rm -rf dist artifacts",
+    "bench": "haxe test.hxml --main dropecho.testing.AutoTest -D RUN_BENCHMARKS && node artifacts/js_test.cjs"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/js/cjs/index.cjs",
+      "import": "./dist/js/esm/index.js"
+    }
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.8",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^14.1.1",
+    "lix": "^16.0.2",
+    "semantic-release": "^25.0.5",
+    "semantic-release-haxelib": "^1.1.0"
+  }
+}