whet 0.0.1

package/bin/haxe/zip/Writer.d.ts

@@ -0,0 +1,22 @@
+import {Entry} from "./Entry"
+import {Output} from "../io/Output"
+import {Bytes} from "../io/Bytes"
+import {List} from "../ds/List"
+
+export declare class Writer {
+	constructor(o: Output)
+	protected o: Output
+	protected files: List<{
+		clen: number, 
+		compressed: boolean, 
+		crc: number, 
+		date: Date, 
+		fields: Bytes, 
+		name: string, 
+		size: number
+	}>
+	protected writeZipDate(date: Date): void
+	writeEntryHeader(f: Entry): void
+	write(files: List<Entry>): void
+	writeCDR(): void
+}

package/bin/haxe/zip/Writer.js

@@ -0,0 +1,149 @@
+import {BytesOutput} from "../io/BytesOutput.js"
+import {Bytes} from "../io/Bytes.js"
+import {List} from "../ds/List.js"
+import {Crc32} from "../crypto/Crc32.js"
+import {Exception} from "../Exception.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const Writer = Register.global("$hxClasses")["haxe.zip.Writer"] = 
+class Writer extends Register.inherits() {
+	new(o) {
+		this.o = o;
+		this.files = new List();
+	}
+	writeZipDate(date) {
+		this.o.writeUInt16(date.getHours() << 11 | date.getMinutes() << 5 | date.getSeconds() >> 1);
+		this.o.writeUInt16(date.getFullYear() - 1980 << 9 | date.getMonth() + 1 << 5 | date.getDate());
+	}
+	writeEntryHeader(f) {
+		var o = this.o;
+		var flags = 0;
+		if (f.extraFields != null) {
+			var _g_head = f.extraFields.h;
+			while (_g_head != null) {
+				var val = _g_head.item;
+				_g_head = _g_head.next;
+				if (val._hx_index == 2) {
+					flags |= 2048;
+				};
+			};
+		};
+		o.writeInt32(67324752);
+		o.writeUInt16(20);
+		o.writeUInt16(flags);
+		if (f.data == null) {
+			f.fileSize = 0;
+			f.dataSize = 0;
+			f.crc32 = 0;
+			f.compressed = false;
+			f.data = new Bytes(new ArrayBuffer(0));
+		} else {
+			if (f.crc32 == null) {
+				if (f.compressed) {
+					throw Exception.thrown("CRC32 must be processed before compression");
+				};
+				f.crc32 = Crc32.make(f.data);
+			};
+			if (!f.compressed) {
+				f.fileSize = f.data.length;
+			};
+			f.dataSize = f.data.length;
+		};
+		o.writeUInt16((f.compressed) ? 8 : 0);
+		this.writeZipDate(f.fileTime);
+		o.writeInt32(f.crc32);
+		o.writeInt32(f.dataSize);
+		o.writeInt32(f.fileSize);
+		o.writeUInt16(f.fileName.length);
+		var e = new BytesOutput();
+		if (f.extraFields != null) {
+			var _g_head = f.extraFields.h;
+			while (_g_head != null) {
+				var val = _g_head.item;
+				_g_head = _g_head.next;
+				switch (val._hx_index) {
+					case 0:
+						var _g = val.bytes;
+						e.writeUInt16(val.tag);
+						e.writeUInt16(_g.length);
+						e.write(_g);
+						break
+					case 1:
+						var namebytes = Bytes.ofString(val.name);
+						e.writeUInt16(28789);
+						e.writeUInt16(namebytes.length + 5);
+						e.writeByte(1);
+						e.writeInt32(val.crc);
+						e.write(namebytes);
+						break
+					case 2:
+						break
+					
+				};
+			};
+		};
+		var ebytes = e.getBytes();
+		o.writeUInt16(ebytes.length);
+		o.writeString(f.fileName);
+		o.write(ebytes);
+		this.files.add({"name": f.fileName, "compressed": f.compressed, "clen": f.data.length, "size": f.fileSize, "crc": f.crc32, "date": f.fileTime, "fields": ebytes});
+	}
+	write(files) {
+		var _g_head = files.h;
+		while (_g_head != null) {
+			var val = _g_head.item;
+			_g_head = _g_head.next;
+			this.writeEntryHeader(val);
+			this.o.writeFullBytes(val.data, 0, val.data.length);
+		};
+		this.writeCDR();
+	}
+	writeCDR() {
+		var cdr_size = 0;
+		var cdr_offset = 0;
+		var _g_head = this.files.h;
+		while (_g_head != null) {
+			var val = _g_head.item;
+			_g_head = _g_head.next;
+			var namelen = val.name.length;
+			var extraFieldsLength = val.fields.length;
+			this.o.writeInt32(33639248);
+			this.o.writeUInt16(20);
+			this.o.writeUInt16(20);
+			this.o.writeUInt16(0);
+			this.o.writeUInt16((val.compressed) ? 8 : 0);
+			this.writeZipDate(val.date);
+			this.o.writeInt32(val.crc);
+			this.o.writeInt32(val.clen);
+			this.o.writeInt32(val.size);
+			this.o.writeUInt16(namelen);
+			this.o.writeUInt16(extraFieldsLength);
+			this.o.writeUInt16(0);
+			this.o.writeUInt16(0);
+			this.o.writeUInt16(0);
+			this.o.writeInt32(0);
+			this.o.writeInt32(cdr_offset);
+			this.o.writeString(val.name);
+			this.o.write(val.fields);
+			cdr_size += 46 + namelen + extraFieldsLength;
+			cdr_offset += 30 + namelen + extraFieldsLength + val.clen;
+		};
+		this.o.writeInt32(101010256);
+		this.o.writeUInt16(0);
+		this.o.writeUInt16(0);
+		this.o.writeUInt16(this.files.length);
+		this.o.writeUInt16(this.files.length);
+		this.o.writeInt32(cdr_size);
+		this.o.writeInt32(cdr_offset);
+		this.o.writeUInt16(0);
+	}
+	static get __name__() {
+		return "haxe.zip.Writer"
+	}
+	get __class__() {
+		return Writer
+	}
+}
+

package/bin/js/Boot.d.ts

@@ -0,0 +1,18 @@
+
+export declare class Boot {
+	protected static getClass(o: null | any): null | any
+	protected static __string_rec(o: {
+		__enum__: boolean, 
+		_hx_index: number, 
+		hasOwnProperty: (arg0: string) => boolean, 
+		length: number, 
+		toString: () => string
+	}, s: string): string
+	protected static __interfLoop(cc: any, cl: any): boolean
+	protected static __instanceof(o: any, cl: any): boolean
+	protected static __downcastCheck(o: any, cl: any): boolean
+	protected static __toStr: Function
+	protected static __nativeClassName(o: any): string
+	protected static __isNativeObj(o: any): boolean
+	protected static __resolveNativeClass(name: string): null | any
+}

package/bin/js/Boot.js

@@ -0,0 +1,225 @@
+import {Register} from "../genes/Register.js"
+
+const $global = Register.$global
+
+export const Boot = Register.global("$hxClasses")["js.Boot"] = 
+class Boot {
+	static getClass(o) {
+		if (o == null) {
+			return null;
+		} else if (((o) instanceof Array)) {
+			return Array;
+		} else {
+			var cl = o.__class__;
+			if (cl != null) {
+				return cl;
+			};
+			var name = Boot.__nativeClassName(o);
+			if (name != null) {
+				return Boot.__resolveNativeClass(name);
+			};
+			return null;
+		};
+	}
+	static __string_rec(o, s) {
+		if (o == null) {
+			return "null";
+		};
+		if (s.length >= 5) {
+			return "<...>";
+		};
+		var t = typeof(o);
+		if (t == "function" && (o.__name__ || o.__ename__)) {
+			t = "object";
+		};
+		switch (t) {
+			case "function":
+				return "<function>";
+				break
+			case "object":
+				if (o.__enum__) {
+					var e = Register.global("$hxEnums")[o.__enum__];
+					var con = e.__constructs__[o._hx_index];
+					var n = con._hx_name;
+					if (con.__params__) {
+						s = s + "\t";
+						return n + "(" + ((function($this) {var $r0
+							var _g = [];
+							{
+								var _g1 = 0;
+								var _g2 = con.__params__;
+								while (true) {
+									if (!(_g1 < _g2.length)) {
+										break;
+									};
+									var p = _g2[_g1];
+									_g1 = _g1 + 1;
+									_g.push(Boot.__string_rec(o[p], s));
+								};
+							};
+							
+							$r0 = _g
+							return $r0})(this)).join(",") + ")";
+					} else {
+						return n;
+					};
+				};
+				if (((o) instanceof Array)) {
+					var str = "[";
+					s += "\t";
+					var _g = 0;
+					var _g1 = o.length;
+					while (_g < _g1) {
+						var i = _g++;
+						str += ((i > 0) ? "," : "") + Boot.__string_rec(o[i], s);
+					};
+					str += "]";
+					return str;
+				};
+				var tostr;
+				try {
+					tostr = o.toString;
+				}catch (_g) {
+					return "???";
+				};
+				if (tostr != null && tostr != Object.toString && typeof(tostr) == "function") {
+					var s2 = o.toString();
+					if (s2 != "[object Object]") {
+						return s2;
+					};
+				};
+				var str = "{\n";
+				s += "\t";
+				var hasp = o.hasOwnProperty != null;
+				var k = null;
+				for( k in o ) {;
+				if (hasp && !o.hasOwnProperty(k)) {
+					continue;
+				};
+				if (k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__") {
+					continue;
+				};
+				if (str.length != 2) {
+					str += ", \n";
+				};
+				str += s + k + " : " + Boot.__string_rec(o[k], s);
+				};
+				s = s.substring(1);
+				str += "\n" + s + "}";
+				return str;
+				break
+			case "string":
+				return o;
+				break
+			default:
+			return String(o);
+			
+		};
+	}
+	static __interfLoop(cc, cl) {
+		while (true) {
+			if (cc == null) {
+				return false;
+			};
+			if (cc == cl) {
+				return true;
+			};
+			var intf = cc.__interfaces__;
+			if (intf != null) {
+				var _g = 0;
+				var _g1 = intf.length;
+				while (_g < _g1) {
+					var i = intf[_g++];
+					if (i == cl || Boot.__interfLoop(i, cl)) {
+						return true;
+					};
+				};
+			};
+			cc = cc.__super__;
+		};
+	}
+	static __instanceof(o, cl) {
+		if (cl == null) {
+			return false;
+		};
+		switch (cl) {
+			case Array:
+				return ((o) instanceof Array);
+				break
+			case "$hxCoreType__Bool":
+				return typeof(o) == "boolean";
+				break
+			case "$hxCoreType__Dynamic":
+				return o != null;
+				break
+			case "$hxCoreType__Float":
+				return typeof(o) == "number";
+				break
+			case "$hxCoreType__Int":
+				if (typeof(o) == "number") {
+					return ((o | 0) === (o));
+				} else {
+					return false;
+				};
+				break
+			case String:
+				return typeof(o) == "string";
+				break
+			default:
+			if (o != null) {
+				if (typeof(cl) == "function") {
+					if (Boot.__downcastCheck(o, cl)) {
+						return true;
+					};
+				} else if (typeof(cl) == "object" && Boot.__isNativeObj(cl)) {
+					if (((o) instanceof cl)) {
+						return true;
+					};
+				};
+			} else {
+				return false;
+			};
+			if ((cl == "$hxCoreType__Class") ? o.__name__ != null : false) {
+				return true;
+			};
+			if ((cl == "$hxCoreType__Enum") ? o.__ename__ != null : false) {
+				return true;
+			};
+			return (o.__enum__ != null) ? Register.global("$hxEnums")[o.__enum__] == cl : false;
+			
+		};
+	}
+	static __downcastCheck(o, cl) {
+		if (!((o) instanceof cl)) {
+			if (cl.__isInterface__) {
+				return Boot.__interfLoop(Boot.getClass(o), cl);
+			} else {
+				return false;
+			};
+		} else {
+			return true;
+		};
+	}
+	static __nativeClassName(o) {
+		var name = Boot.__toStr.call(o).slice(8, -1);
+		if (name == "Object" || name == "Function" || name == "Math" || name == "JSON") {
+			return null;
+		};
+		return name;
+	}
+	static __isNativeObj(o) {
+		return Boot.__nativeClassName(o) != null;
+	}
+	static __resolveNativeClass(name) {
+		return Register.$global[name];
+	}
+	static get __name__() {
+		return "js.Boot"
+	}
+	get __class__() {
+		return Boot
+	}
+}
+
+
+;Boot.__toStr = ({}).toString

package/bin/js/Node.d.ts

@@ -0,0 +1,6 @@
+
+export type TimeoutObject = Timeout
+
+export type IntervalObject = Timeout
+
+export type ImmediateObject = Immediate

package/bin/js/lib/ArrayBuffer.d.ts

@@ -0,0 +1,4 @@
+
+export declare class ArrayBufferCompat {
+	protected static sliceImpl(begin: null | number, end?: null | number): ArrayBuffer
+}

package/bin/js/lib/ArrayBuffer.js

@@ -0,0 +1,24 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const ArrayBufferCompat = Register.global("$hxClasses")["js.lib._ArrayBuffer.ArrayBufferCompat"] = 
+class ArrayBufferCompat {
+	static sliceImpl(begin, end) {
+		var u = new Uint8Array(this, begin, (end == null) ? null : end - begin);
+		var resultArray = new Uint8Array(u.byteLength);
+		resultArray.set(u);
+		return resultArray.buffer;
+	}
+	static get __name__() {
+		return "js.lib._ArrayBuffer.ArrayBufferCompat"
+	}
+	get __class__() {
+		return ArrayBufferCompat
+	}
+}
+
+
+;if (ArrayBuffer.prototype.slice == null) {
+	ArrayBuffer.prototype.slice = ArrayBufferCompat.sliceImpl;
+}

package/bin/js/lib/Iterator.d.ts

@@ -0,0 +1,23 @@
+
+/**
+Native JavaScript iterator structure. To enable haxe for-in iteration, use `js.lib.HaxeIterator`, for example `for (v in new js.lib.HaxeIterator(jsIterator))` or add `using js.lib.HaxeIterator;` to your module
+
+See [Iteration Protocols](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols)
+*/
+export type Iterator<T> = {
+	next: () => IteratorStep<T>
+}
+
+/**
+Native JavaScript async iterator structure.
+
+See [for await...of](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of)
+*/
+export type AsyncIterator<T> = {
+	next: () => Promise<IteratorStep<T>>
+}
+
+export type IteratorStep<T> = {
+	done: boolean, 
+	value?: null | T
+}

package/bin/js/lib/Map.d.ts

@@ -0,0 +1,2 @@
+
+export type MapEntry<K, V> = any[]

package/bin/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/bin/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 = {
+	reason?: null | any, 
+	status: string, 
+	value?: null | any
+}

package/bin/js/lib/intl/NumberFormat.d.ts

@@ -0,0 +1,114 @@
+
+export type NumberFormatOptions = {
+	/**
+	The currency to use in currency formatting. Possible values are the ISO 4217 currency codes,
+	such as "USD" for the US dollar, "EUR" for the euro, or "CNY" for the Chinese RMB — see the
+	[Current currency & funds code list](https://www.currency-iso.org/en/home/tables/table-a1.html).
+	There is no default value; if the style is "currency", the currency property must be provided.
+	*/
+	currency?: null | string, 
+	/**
+	How to display the currency in currency formatting.
+	The default is `Symbol`.
+	*/
+	currencyDisplay?: null | string, 
+	/**
+	The locale matching algorithm to use.
+	The default is `BestFit`.
+	For information about this option, see the [Intl page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation).
+	*/
+	localeMatcher?: null | string, 
+	/**
+	The maximum number of fraction digits to use.
+	Possible values are from 0 to 20; the default for plain number formatting is the larger of
+	minimumFractionDigits and 3; the default for currency formatting is the larger of minimumFractionDigits
+	and the number of minor unit digits provided by the [ISO 4217 currency code list](http://www.currency-iso.org/en/home/tables/table-a1.html)
+	(2 if the list doesn't provide that information); the default for percent formatting is the larger of
+	minimumFractionDigits and 0.
+	*/
+	maximumFractionDigits?: null | number, 
+	/**
+	The maximum number of significant digits to use.
+	Possible values are from 1 to 21; the default is 21.
+	*/
+	maximumSignificantDigits?: null | number, 
+	/**
+	The minimum number of fraction digits to use.
+	Possible values are from 0 to 20; the default for plain number and percent formatting is 0;
+	the default for currency formatting is the number of minor unit digits provided by the
+	[ISO 4217 currency code list](http://www.currency-iso.org/en/home/tables/table-a1.html)
+	(2 if the list doesn't provide that information).
+	*/
+	minimumFractionDigits?: null | number, 
+	/**
+	The minimum number of integer digits to use.
+	Possible values are from 1 to 21; the default is 1.
+	*/
+	minimumIntegerDigits?: null | number, 
+	/**
+	The minimum number of significant digits to use.
+	Possible values are from 1 to 21; the default is 1.
+	*/
+	minimumSignificantDigits?: null | number, 
+	/**
+	The formatting style to use.
+	The default is `Decimal`.
+	*/
+	style?: null | string, 
+	/**
+	Whether to use grouping separators, such as thousands separators or thousand/lakh/crore separators.
+	The default is `true`.
+	*/
+	useGrouping?: null | boolean
+}
+
+export type NumberFormatResolvedOption = {
+	currency: string, 
+	/**
+	The values provided for these properties in the `options` argument or filled in as defaults.
+	These properties are only present if `style` is `"currency"`.
+	*/
+	currencyDisplay: string, 
+	/**
+	The BCP 47 language tag for the locale actually used. If any Unicode extension values were
+	requested in the input BCP 47 language tag that led to this locale, the key-value pairs that
+	were requested and are supported for this locale are included in `locale`.
+	*/
+	locale: string, 
+	/**
+	The values provided for these properties in the `options` argument or filled in as defaults.
+	These properties are present only if neither m`inimumSignificantDigits` nor `maximumSignificantDigits`
+	was provided in the `options` argument.
+	*/
+	maximumFractionDigits: number, 
+	/**
+	The values provided for these properties in the `options` argument or filled in as defaults.
+	These properties are present only if at least one of them was provided in the `options` argument.
+	*/
+	maximumSignificantDigits: number, 
+	minimumFractionDigits: number, 
+	minimumIntegerDigits: number, 
+	minimumSignificantDigits: number, 
+	/**
+	The value requested using the Unicode extension key `"nu"` or filled in as a default.
+	*/
+	numberingSystem: string, 
+	style: string, 
+	/**
+	The values provided for these properties in the `options` argument or filled in as defaults.
+	*/
+	useGrouping: string
+}
+
+export type NumberFormatPart = {
+	type: string, 
+	value: string
+}
+
+export type NumberFormatSupportedLocalesOfOptions = {
+	/**
+	The locale matching algorithm to use.
+	The default is `BestFit`.
+	*/
+	localeMatcher?: null | string
+}

package/bin/js/node/Buffer.d.ts

@@ -0,0 +1,3 @@
+import {Buffer as Buffer__1} from "buffer"
+
+export type Buffer = Buffer__1