whet 0.0.1

package/bin/haxe/ds/ObjectMap.js

@@ -0,0 +1,25 @@
+import {IMap} from "../Constraints.js"
+import {EsMap} from "../../genes/util/EsMap.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const ObjectMap = Register.global("$hxClasses")["haxe.ds.ObjectMap"] = 
+class ObjectMap extends Register.inherits(EsMap) {
+	new() {
+		super.new();
+	}
+	static get __name__() {
+		return "haxe.ds.ObjectMap"
+	}
+	static get __interfaces__() {
+		return [IMap]
+	}
+	static get __super__() {
+		return EsMap
+	}
+	get __class__() {
+		return ObjectMap
+	}
+}
+

package/bin/haxe/ds/StringMap.d.ts

@@ -0,0 +1,6 @@
+import {IMap} from "../Constraints"
+import {EsMap} from "../../genes/util/EsMap"
+
+export declare class StringMap<T> extends EsMap<string, T> implements IMap<string, T> {
+	constructor()
+}

package/bin/haxe/ds/StringMap.js

@@ -0,0 +1,25 @@
+import {IMap} from "../Constraints.js"
+import {EsMap} from "../../genes/util/EsMap.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const StringMap = Register.global("$hxClasses")["haxe.ds.StringMap"] = 
+class StringMap extends Register.inherits(EsMap) {
+	new() {
+		super.new();
+	}
+	static get __name__() {
+		return "haxe.ds.StringMap"
+	}
+	static get __interfaces__() {
+		return [IMap]
+	}
+	static get __super__() {
+		return EsMap
+	}
+	get __class__() {
+		return StringMap
+	}
+}
+

package/bin/haxe/exceptions/NotImplementedException.d.ts

@@ -0,0 +1,10 @@
+import {PosException} from "./PosException"
+import {PosInfos} from "../PosInfos"
+import {Exception} from "../Exception"
+
+/**
+An exception that is thrown when requested function or operation does not have an implementation.
+*/
+export declare class NotImplementedException extends PosException {
+	constructor(message?: string, previous?: null | Exception, pos?: null | PosInfos)
+}

package/bin/haxe/exceptions/NotImplementedException.js

@@ -0,0 +1,27 @@
+import {PosException} from "./PosException.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+An exception that is thrown when requested function or operation does not have an implementation.
+*/
+export const NotImplementedException = Register.global("$hxClasses")["haxe.exceptions.NotImplementedException"] = 
+class NotImplementedException extends Register.inherits(PosException) {
+	new(message, previous, pos) {
+		if (message == null) {
+			message = "Not implemented";
+		};
+		super.new(message, previous, pos);
+	}
+	static get __name__() {
+		return "haxe.exceptions.NotImplementedException"
+	}
+	static get __super__() {
+		return PosException
+	}
+	get __class__() {
+		return NotImplementedException
+	}
+}
+

package/bin/haxe/exceptions/PosException.d.ts

@@ -0,0 +1,19 @@
+import {PosInfos} from "../PosInfos"
+import {Exception} from "../Exception"
+
+/**
+An exception that carry position information of a place where it was created.
+*/
+export declare class PosException extends Exception {
+	constructor(message: string, previous?: null | Exception, pos?: null | PosInfos)
+	
+	/**
+	Position where this exception was created.
+	*/
+	posInfos: PosInfos
+	
+	/**
+	Returns exception message.
+	*/
+	toString(): string
+}

package/bin/haxe/exceptions/PosException.js

@@ -0,0 +1,36 @@
+import {Exception} from "../Exception.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+An exception that carry position information of a place where it was created.
+*/
+export const PosException = Register.global("$hxClasses")["haxe.exceptions.PosException"] = 
+class PosException extends Register.inherits(Exception) {
+	new(message, previous, pos) {
+		super.new(message, previous);
+		if (pos == null) {
+			this.posInfos = {"fileName": "(unknown)", "lineNumber": 0, "className": "(unknown)", "methodName": "(unknown)"};
+		} else {
+			this.posInfos = pos;
+		};
+	}
+	
+	/**
+	Returns exception message.
+	*/
+	toString() {
+		return "" + super.toString() + " in " + this.posInfos.className + "." + this.posInfos.methodName + " at " + this.posInfos.fileName + ":" + this.posInfos.lineNumber;
+	}
+	static get __name__() {
+		return "haxe.exceptions.PosException"
+	}
+	static get __super__() {
+		return Exception
+	}
+	get __class__() {
+		return PosException
+	}
+}
+

package/bin/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/bin/haxe/io/ArrayBufferView.d.ts

@@ -0,0 +1,2 @@
+
+export type ArrayBufferViewData = ArrayBufferView

package/bin/haxe/io/Bytes.d.ts

@@ -0,0 +1,19 @@
+import {Encoding} from "./Encoding"
+
+export declare class Bytes {
+	protected constructor(data: ArrayBuffer)
+	length: number
+	protected b: Uint8Array
+	
+	/**
+	Returns a new `Bytes` instance that contains a copy of `len` bytes of
+	`this` instance, starting at index `pos`.
+	*/
+	sub(pos: number, len: number): Bytes
+	
+	/**
+	Returns the `Bytes` representation of the given `String`, using the
+	specified encoding (UTF-8 by default).
+	*/
+	static ofString(s: string, encoding?: null | Encoding): Bytes
+}

package/bin/haxe/io/Bytes.js

@@ -0,0 +1,78 @@
+import {Error as Error__1} from "./Error.js"
+import {Encoding} from "./Encoding.js"
+import {Exception} from "../Exception.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const Bytes = Register.global("$hxClasses")["haxe.io.Bytes"] = 
+class Bytes extends Register.inherits() {
+	new(data) {
+		this.length = data.byteLength;
+		this.b = new Uint8Array(data);
+		this.b.bufferValue = data;
+		data.hxBytes = this;
+		data.bytes = this.b;
+	}
+	
+	/**
+	Returns a new `Bytes` instance that contains a copy of `len` bytes of
+	`this` instance, starting at index `pos`.
+	*/
+	sub(pos, len) {
+		if (pos < 0 || len < 0 || pos + len > this.length) {
+			throw Exception.thrown(Error__1.OutsideBounds);
+		};
+		return new Bytes(this.b.buffer.slice(pos + this.b.byteOffset, pos + this.b.byteOffset + len));
+	}
+	
+	/**
+	Returns the `Bytes` representation of the given `String`, using the
+	specified encoding (UTF-8 by default).
+	*/
+	static ofString(s, encoding) {
+		if (encoding == Encoding.RawNative) {
+			var buf = new Uint8Array(s.length << 1);
+			var _g = 0;
+			var _g1 = s.length;
+			while (_g < _g1) {
+				var i = _g++;
+				var c = s.charCodeAt(i);
+				buf[i << 1] = c & 255;
+				buf[i << 1 | 1] = c >> 8;
+			};
+			return new Bytes(buf.buffer);
+		};
+		var a = new Array();
+		var i = 0;
+		while (i < s.length) {
+			var c = s.charCodeAt(i++);
+			if (55296 <= c && c <= 56319) {
+				c = c - 55232 << 10 | s.charCodeAt(i++) & 1023;
+			};
+			if (c <= 127) {
+				a.push(c);
+			} else if (c <= 2047) {
+				a.push(192 | c >> 6);
+				a.push(128 | c & 63);
+			} else if (c <= 65535) {
+				a.push(224 | c >> 12);
+				a.push(128 | c >> 6 & 63);
+				a.push(128 | c & 63);
+			} else {
+				a.push(240 | c >> 18);
+				a.push(128 | c >> 12 & 63);
+				a.push(128 | c >> 6 & 63);
+				a.push(128 | c & 63);
+			};
+		};
+		return new Bytes(new Uint8Array(a).buffer);
+	}
+	static get __name__() {
+		return "haxe.io.Bytes"
+	}
+	get __class__() {
+		return Bytes
+	}
+}
+

package/bin/haxe/io/BytesBuffer.d.ts

@@ -0,0 +1,19 @@
+import {Bytes} from "./Bytes"
+
+export declare class BytesBuffer {
+	constructor()
+	protected buffer: ArrayBuffer
+	protected view: DataView
+	protected u8: Uint8Array
+	protected pos: number
+	protected size: number
+	addByte($byte: number): void
+	addBytes(src: Bytes, pos: number, len: number): void
+	protected grow(delta: number): void
+	
+	/**
+	Returns either a copy or a reference of the current bytes.
+	Once called, the buffer should no longer be used.
+	*/
+	getBytes(): Bytes
+}

package/bin/haxe/io/BytesBuffer.js

@@ -0,0 +1,67 @@
+import {Error as Error__1} from "./Error.js"
+import {Bytes} from "./Bytes.js"
+import {Exception} from "../Exception.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const BytesBuffer = Register.global("$hxClasses")["haxe.io.BytesBuffer"] = 
+class BytesBuffer extends Register.inherits() {
+	new() {
+		this.pos = 0;
+		this.size = 0;
+	}
+	addByte($byte) {
+		if (this.pos == this.size) {
+			this.grow(1);
+		};
+		this.view.setUint8(this.pos++, $byte);
+	}
+	addBytes(src, pos, len) {
+		if (pos < 0 || len < 0 || pos + len > src.length) {
+			throw Exception.thrown(Error__1.OutsideBounds);
+		};
+		if (this.pos + len > this.size) {
+			this.grow(len);
+		};
+		if (this.size == 0) {
+			return;
+		};
+		this.u8.set(new Uint8Array(src.b.buffer, src.b.byteOffset + pos, len), this.pos);
+		this.pos += len;
+	}
+	grow(delta) {
+		var req = this.pos + delta;
+		var nsize = (this.size == 0) ? 16 : this.size;
+		while (nsize < req) nsize = nsize * 3 >> 1;
+		var nbuf = new ArrayBuffer(nsize);
+		var nu8 = new Uint8Array(nbuf);
+		if (this.size > 0) {
+			nu8.set(this.u8);
+		};
+		this.size = nsize;
+		this.buffer = nbuf;
+		this.u8 = nu8;
+		this.view = new DataView(this.buffer);
+	}
+	
+	/**
+	Returns either a copy or a reference of the current bytes.
+	Once called, the buffer should no longer be used.
+	*/
+	getBytes() {
+		if (this.size == 0) {
+			return new Bytes(new ArrayBuffer(0));
+		};
+		var b = new Bytes(this.buffer);
+		b.length = this.pos;
+		return b;
+	}
+	static get __name__() {
+		return "haxe.io.BytesBuffer"
+	}
+	get __class__() {
+		return BytesBuffer
+	}
+}
+

package/bin/haxe/io/BytesData.d.ts

@@ -0,0 +1,2 @@
+
+export type BytesData = ArrayBuffer

package/bin/haxe/io/BytesOutput.d.ts

@@ -0,0 +1,18 @@
+import {Output} from "./Output"
+import {BytesBuffer} from "./BytesBuffer"
+import {Bytes} from "./Bytes"
+
+export declare class BytesOutput extends Output {
+	constructor()
+	protected b: BytesBuffer
+	writeByte(c: number): void
+	writeBytes(buf: Bytes, pos: number, len: number): number
+	
+	/**
+	Returns the `Bytes` of this output.
+	
+	This function should not be called more than once on a given
+	`BytesOutput` instance.
+	*/
+	getBytes(): Bytes
+}

package/bin/haxe/io/BytesOutput.js

@@ -0,0 +1,39 @@
+import {Output} from "./Output.js"
+import {BytesBuffer} from "./BytesBuffer.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const BytesOutput = Register.global("$hxClasses")["haxe.io.BytesOutput"] = 
+class BytesOutput extends Register.inherits(Output) {
+	new() {
+		this.b = new BytesBuffer();
+	}
+	writeByte(c) {
+		this.b.addByte(c);
+	}
+	writeBytes(buf, pos, len) {
+		this.b.addBytes(buf, pos, len);
+		return len;
+	}
+	
+	/**
+	Returns the `Bytes` of this output.
+	
+	This function should not be called more than once on a given
+	`BytesOutput` instance.
+	*/
+	getBytes() {
+		return this.b.getBytes();
+	}
+	static get __name__() {
+		return "haxe.io.BytesOutput"
+	}
+	static get __super__() {
+		return Output
+	}
+	get __class__() {
+		return BytesOutput
+	}
+}
+

package/bin/haxe/io/Encoding.d.ts

@@ -0,0 +1,20 @@
+
+/**
+String binary encoding supported by Haxe I/O
+*/
+export declare namespace Encoding {
+	export type UTF8 = {_hx_index: 0, __enum__: "haxe.io.Encoding"}
+	export const UTF8: UTF8
+	export type RawNative = {_hx_index: 1, __enum__: "haxe.io.Encoding"}
+	export const RawNative: RawNative
+}
+
+/**
+String binary encoding supported by Haxe I/O
+*/
+export declare type Encoding = 
+	| Encoding.UTF8
+	/**
+	Output the string the way the platform represent it in memory. This is the most efficient but is platform-specific
+	*/
+	| Encoding.RawNative

package/bin/haxe/io/Encoding.js

@@ -0,0 +1,20 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+String binary encoding supported by Haxe I/O
+*/
+export const Encoding = 
+Register.global("$hxEnums")["haxe.io.Encoding"] = 
+{
+	__ename__: "haxe.io.Encoding",
+	
+	UTF8: {_hx_name: "UTF8", _hx_index: 0, __enum__: "haxe.io.Encoding"},
+	/**
+	Output the string the way the platform represent it in memory. This is the most efficient but is platform-specific
+	*/
+	RawNative: {_hx_name: "RawNative", _hx_index: 1, __enum__: "haxe.io.Encoding"}
+}
+Encoding.__constructs__ = [Encoding.UTF8, Encoding.RawNative]
+Encoding.__empty_constructs__ = [Encoding.UTF8, Encoding.RawNative]

package/bin/haxe/io/Error.d.ts

@@ -0,0 +1,35 @@
+
+/**
+The possible IO errors that can occur
+*/
+export declare namespace Error {
+	export type Overflow = {_hx_index: 1, __enum__: "haxe.io.Error"}
+	export const Overflow: Overflow
+	export type OutsideBounds = {_hx_index: 2, __enum__: "haxe.io.Error"}
+	export const OutsideBounds: OutsideBounds
+	export type Custom = {_hx_index: 3, e: any, __enum__: "haxe.io.Error"}
+	export const Custom: (e: any) => Error
+	export type Blocked = {_hx_index: 0, __enum__: "haxe.io.Error"}
+	export const Blocked: Blocked
+}
+
+/**
+The possible IO errors that can occur
+*/
+export declare type Error = 
+	/**
+	An integer value is outside its allowed range
+	*/
+	| Error.Overflow
+	/**
+	An operation on Bytes is outside of its valid range
+	*/
+	| Error.OutsideBounds
+	/**
+	Other errors
+	*/
+	| Error.Custom
+	/**
+	The IO is set into nonblocking mode and some data cannot be read or written
+	*/
+	| Error.Blocked

package/bin/haxe/io/Error.js

@@ -0,0 +1,31 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+The possible IO errors that can occur
+*/
+export const Error = 
+Register.global("$hxEnums")["haxe.io.Error"] = 
+{
+	__ename__: "haxe.io.Error",
+	
+	/**
+	The IO is set into nonblocking mode and some data cannot be read or written
+	*/
+	Blocked: {_hx_name: "Blocked", _hx_index: 0, __enum__: "haxe.io.Error"},
+	/**
+	An integer value is outside its allowed range
+	*/
+	Overflow: {_hx_name: "Overflow", _hx_index: 1, __enum__: "haxe.io.Error"},
+	/**
+	An operation on Bytes is outside of its valid range
+	*/
+	OutsideBounds: {_hx_name: "OutsideBounds", _hx_index: 2, __enum__: "haxe.io.Error"},
+	/**
+	Other errors
+	*/
+	Custom: Object.assign((e) => ({_hx_index: 3, __enum__: "haxe.io.Error", "e": e}), {_hx_name: "Custom", __params__: ["e"]})
+}
+Error.__constructs__ = [Error.Blocked, Error.Overflow, Error.OutsideBounds, Error.Custom]
+Error.__empty_constructs__ = [Error.Blocked, Error.Overflow, Error.OutsideBounds]

package/bin/haxe/io/Output.d.ts

@@ -0,0 +1,63 @@
+import {Encoding} from "./Encoding"
+import {Bytes} from "./Bytes"
+
+/**
+An Output is an abstract write. A specific output implementation will only
+have to override the `writeByte` and maybe the `write`, `flush` and `close`
+methods. See `File.write` and `String.write` for two ways of creating an
+Output.
+*/
+export declare class Output {
+	
+	/**
+	Endianness (word byte order) used when writing numbers.
+	
+	If `true`, big-endian is used, otherwise `little-endian` is used.
+	*/
+	bigEndian: boolean
+	
+	/**
+	Write one byte.
+	*/
+	writeByte(c: number): void
+	
+	/**
+	Write `len` bytes from `s` starting by position specified by `pos`.
+	
+	Returns the actual length of written data that can differ from `len`.
+	
+	See `writeFullBytes` that tries to write the exact amount of specified bytes.
+	*/
+	writeBytes(s: Bytes, pos: number, len: number): number
+	
+	/**
+	Write all bytes stored in `s`.
+	*/
+	write(s: Bytes): void
+	
+	/**
+	Write `len` bytes from `s` starting by position specified by `pos`.
+	
+	Unlike `writeBytes`, this method tries to write the exact `len` amount of bytes.
+	*/
+	writeFullBytes(s: Bytes, pos: number, len: number): void
+	
+	/**
+	Write `x` as 16-bit unsigned integer.
+	
+	Endianness is specified by the `bigEndian` property.
+	*/
+	writeUInt16(x: number): void
+	
+	/**
+	Write `x` as 32-bit signed integer.
+	
+	Endianness is specified by the `bigEndian` property.
+	*/
+	writeInt32(x: number): void
+	
+	/**
+	Write `s` string.
+	*/
+	writeString(s: string, encoding?: null | Encoding): void
+}