whet 0.0.1

package/bin/commander/AddHelpTextContext.d.ts

@@ -0,0 +1,6 @@
+import {Command} from "commander"
+
+export type AddHelpTextContext = {
+	command: Command, 
+	error: boolean
+}

package/bin/commander/AddHelpTextPosition.d.ts

@@ -0,0 +1,2 @@
+
+export type AddHelpTextPosition = string

package/bin/commander/CommandOptions.d.ts

@@ -0,0 +1,6 @@
+
+export type CommandOptions = {
+	hidden?: null | boolean, 
+	isDefault?: null | boolean, 
+	noHelp?: null | boolean
+}

package/bin/commander/ErrorOptions.d.ts

@@ -0,0 +1,11 @@
+
+export type ErrorOptions = {
+	/**
+	an id string representing the error
+	*/
+	code?: null | string, 
+	/**
+	suggested exit code which could be used with process.exit
+	*/
+	exitCode?: null | number
+}

package/bin/commander/ExecutableCommandOptions.d.ts

@@ -0,0 +1,7 @@
+
+export type ExecutableCommandOptions = {
+	executableFile?: null | string, 
+	hidden?: null | boolean, 
+	isDefault?: null | boolean, 
+	noHelp?: null | boolean
+}

package/bin/commander/HelpContext.d.ts

@@ -0,0 +1,4 @@
+
+export type HelpContext = {
+	error: boolean
+}

package/bin/commander/HookEvent.d.ts

@@ -0,0 +1,2 @@
+
+export type HookEvent = string

package/bin/commander/OptionValueSource.d.ts

@@ -0,0 +1,2 @@
+
+export type OptionValueSource = string

package/bin/commander/OutputConfiguration.d.ts

@@ -0,0 +1,8 @@
+
+export type OutputConfiguration = {
+	getErrHelpWidth?: null | (() => number), 
+	getOutHelpWidth?: null | (() => number), 
+	outputError?: null | ((str: string, write: ((str: string) => void)) => void), 
+	writeErr?: null | ((str: string) => void), 
+	writeOut?: null | ((str: string) => void)
+}

package/bin/commander/ParseOptions.d.ts

@@ -0,0 +1,4 @@
+
+export type ParseOptions = {
+	from: string
+}

package/bin/commander/ParseOptionsResult.d.ts

@@ -0,0 +1,5 @@
+
+export type ParseOptionsResult = {
+	operands: string[], 
+	unknown: string[]
+}

package/bin/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): any
+}

package/bin/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/bin/genes/util/EsMap.d.ts

@@ -0,0 +1,12 @@
+import {Iterator as Iterator__1} from "../../js/lib/Iterator"
+import {Iterator, Iterator as Iterator__2} from "../../StdTypes"
+
+export declare class EsMap<K, V> {
+	constructor()
+	protected inst: Map<K, V>
+	set(key: K, value: V): void
+	get(key: K): null | V
+	exists(key: K): boolean
+	keys(): Iterator<K>
+	protected static adaptIterator<T>(from: Iterator__1<T>): Iterator<T>
+}

package/bin/genes/util/EsMap.js

@@ -0,0 +1,51 @@
+import {Register} from "../Register.js"
+
+const $global = Register.$global
+
+export const EsMap = Register.global("$hxClasses")["genes.util.EsMap"] = 
+class EsMap extends Register.inherits() {
+	new() {
+		this.inst = new Map();
+	}
+	set(key, value) {
+		this.inst.set(key, value);
+	}
+	get(key) {
+		return this.inst.get(key);
+	}
+	exists(key) {
+		return this.inst.has(key);
+	}
+	keys() {
+		return EsMap.adaptIterator(this.inst.keys());
+	}
+	static adaptIterator(from) {
+		var value;
+		var done;
+		var queue = function () {
+			var data = from.next();
+			value = data.value;
+			done = data.done;
+		};
+		return {"hasNext": function () {
+			if (done == null) {
+				queue();
+			};
+			return !done;
+		}, "next": function () {
+			if (done == null) {
+				queue();
+			};
+			var pending = value;
+			queue();
+			return pending;
+		}};
+	}
+	static get __name__() {
+		return "genes.util.EsMap"
+	}
+	get __class__() {
+		return EsMap
+	}
+}
+

package/bin/haxe/Constraints.d.ts

@@ -0,0 +1,8 @@
+import {Iterator} from "../StdTypes"
+
+export declare interface IMap<K, V> {
+	get(k: K): null | V
+	set(k: K, v: V): void
+	exists(k: K): boolean
+	keys(): Iterator<K>
+}

package/bin/haxe/Constraints.js

@@ -0,0 +1,5 @@
+import {Register} from "../genes/Register.js"
+
+const $global = Register.$global
+
+export const IMap = {}

package/bin/haxe/Exception.d.ts

@@ -0,0 +1,66 @@
+
+/**
+Base class for exceptions.
+
+If this class (or derivatives) is used to catch an exception, then
+`haxe.CallStack.exceptionStack()` will not return a stack for the exception
+caught. Use `haxe.Exception.stack` property instead:
+```haxe
+try {
+throwSomething();
+} catch(e:Exception) {
+trace(e.stack);
+}
+```
+
+Custom exceptions should extend this class:
+```haxe
+class MyException extends haxe.Exception {}
+//...
+throw new MyException('terrible exception');
+```
+
+`haxe.Exception` is also a wildcard type to catch any exception:
+```haxe
+try {
+throw 'Catch me!';
+} catch(e:haxe.Exception) {
+trace(e.message); // Output: Catch me!
+}
+```
+
+To rethrow an exception just throw it again.
+Haxe will try to rethrow an original native exception whenever possible.
+```haxe
+try {
+var a:Array<Int> = null;
+a.push(1); // generates target-specific null-pointer exception
+} catch(e:haxe.Exception) {
+throw e; // rethrows native exception instead of haxe.Exception
+}
+```
+*/
+export declare class Exception extends Error {
+	constructor(message: string, previous?: null | Exception, $native?: null | any)
+	
+	/**
+	Exception message.
+	*/
+	message: string
+	
+	/**
+	Native exception, which caused this exception.
+	*/
+	native: any
+	protected __skipStack: number
+	protected __nativeException: any
+	protected __previousException: null | Exception
+	
+	/**
+	Returns exception message.
+	*/
+	toString(): string
+	protected get_message(): string
+	protected get_native(): any
+	protected static thrown(value: any): any
+}

package/bin/haxe/Exception.js

@@ -0,0 +1,88 @@
+import {ValueException} from "./ValueException.js"
+import {Register} from "../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+Base class for exceptions.
+
+If this class (or derivatives) is used to catch an exception, then
+`haxe.CallStack.exceptionStack()` will not return a stack for the exception
+caught. Use `haxe.Exception.stack` property instead:
+```haxe
+try {
+throwSomething();
+} catch(e:Exception) {
+trace(e.stack);
+}
+```
+
+Custom exceptions should extend this class:
+```haxe
+class MyException extends haxe.Exception {}
+//...
+throw new MyException('terrible exception');
+```
+
+`haxe.Exception` is also a wildcard type to catch any exception:
+```haxe
+try {
+throw 'Catch me!';
+} catch(e:haxe.Exception) {
+trace(e.message); // Output: Catch me!
+}
+```
+
+To rethrow an exception just throw it again.
+Haxe will try to rethrow an original native exception whenever possible.
+```haxe
+try {
+var a:Array<Int> = null;
+a.push(1); // generates target-specific null-pointer exception
+} catch(e:haxe.Exception) {
+throw e; // rethrows native exception instead of haxe.Exception
+}
+```
+*/
+export const Exception = Register.global("$hxClasses")["haxe.Exception"] = 
+class Exception extends Register.inherits(() => Error, true) {
+	new(message, previous, $native) {
+		Error.call(this, message);
+		this.message = message;
+		this.__previousException = previous;
+		this.__nativeException = ($native != null) ? $native : this;
+	}
+	
+	/**
+	Returns exception message.
+	*/
+	toString() {
+		return this.get_message();
+	}
+	get_message() {
+		return this.message;
+	}
+	get_native() {
+		return this.__nativeException;
+	}
+	static thrown(value) {
+		if (((value) instanceof Exception)) {
+			return value.get_native();
+		} else if (((value) instanceof Error)) {
+			return value;
+		} else {
+			var e = new ValueException(value);
+			return e;
+		};
+	}
+	static get __name__() {
+		return "haxe.Exception"
+	}
+	static get __super__() {
+		return Error
+	}
+	get __class__() {
+		return Exception
+	}
+}
+

package/bin/haxe/NativeStackTrace.d.ts

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

package/bin/haxe/PosInfos.d.ts

@@ -0,0 +1,19 @@
+
+/**
+`PosInfos` is a magic type which can be used to generate position information
+into the output for debugging use.
+
+If a function has a final optional argument of this type, i.e.
+`(..., ?pos:haxe.PosInfos)`, each call to that function which does not assign
+a value to that argument has its position added as call argument.
+
+This can be used to track positions of calls in e.g. a unit testing
+framework.
+*/
+export type PosInfos = {
+	className: string, 
+	customParams?: null | any[], 
+	fileName: string, 
+	lineNumber: number, 
+	methodName: string
+}

package/bin/haxe/Rest.d.ts

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

package/bin/haxe/ValueException.d.ts

@@ -0,0 +1,24 @@
+import {Exception} from "./Exception"
+
+/**
+An exception containing arbitrary value.
+
+This class is automatically used for throwing values, which don't extend `haxe.Exception`
+or native exception type.
+For example:
+```haxe
+throw "Terrible error";
+```
+will be compiled to
+```haxe
+throw new ValueException("Terrible error");
+```
+*/
+export declare class ValueException extends Exception {
+	constructor(value: any, previous?: null | Exception, $native?: null | any)
+	
+	/**
+	Thrown value.
+	*/
+	value: any
+}

package/bin/haxe/ValueException.js

@@ -0,0 +1,36 @@
+import {Exception} from "./Exception.js"
+import {Register} from "../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+An exception containing arbitrary value.
+
+This class is automatically used for throwing values, which don't extend `haxe.Exception`
+or native exception type.
+For example:
+```haxe
+throw "Terrible error";
+```
+will be compiled to
+```haxe
+throw new ValueException("Terrible error");
+```
+*/
+export const ValueException = Register.global("$hxClasses")["haxe.ValueException"] = 
+class ValueException extends Register.inherits(() => Exception, true) {
+	new(value, previous, $native) {
+		super.new(String(value), previous, $native);
+		this.value = value;
+	}
+	static get __name__() {
+		return "haxe.ValueException"
+	}
+	static get __super__() {
+		return Exception
+	}
+	get __class__() {
+		return ValueException
+	}
+}
+

package/bin/haxe/crypto/Crc32.d.ts

@@ -0,0 +1,12 @@
+import {Bytes} from "../io/Bytes"
+
+/**
+Calculates the Crc32 of the given Bytes.
+*/
+export declare class Crc32 {
+	
+	/**
+	Calculates the CRC32 of the given data bytes
+	*/
+	static make(data: Bytes): number
+}

package/bin/haxe/crypto/Crc32.js

@@ -0,0 +1,40 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+Calculates the Crc32 of the given Bytes.
+*/
+export const Crc32 = Register.global("$hxClasses")["haxe.crypto.Crc32"] = 
+class Crc32 {
+	
+	/**
+	Calculates the CRC32 of the given data bytes
+	*/
+	static make(data) {
+		var c_crc = -1;
+		var len = data.length;
+		var b = data.b.bufferValue;
+		var _g = 0;
+		while (_g < len) {
+			var tmp = (c_crc ^ b.bytes[_g++]) & 255;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			tmp = tmp >>> 1 ^ -(tmp & 1) & -306674912;
+			c_crc = c_crc >>> 8 ^ tmp;
+		};
+		return c_crc ^ -1;
+	}
+	static get __name__() {
+		return "haxe.crypto.Crc32"
+	}
+	get __class__() {
+		return Crc32
+	}
+}
+

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

@@ -0,0 +1,31 @@
+
+/**
+A linked-list of elements. The list is composed of element container objects
+that are chained together. It is optimized so that adding or removing an
+element does not imply copying the whole list content every time.
+
+@see https://haxe.org/manual/std-List.html
+*/
+export declare class List<T> {
+	constructor()
+	protected h: ListNode<T>
+	protected q: ListNode<T>
+	
+	/**
+	The length of `this` List.
+	*/
+	length: number
+	
+	/**
+	Adds element `item` at the end of `this` List.
+	
+	`this.length` increases by 1.
+	*/
+	add(item: T): void
+}
+
+export declare class ListNode<T> {
+	constructor(item: T, next: ListNode<T>)
+	item: T
+	next: ListNode<T>
+}

package/bin/haxe/ds/List.js

@@ -0,0 +1,55 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+/**
+A linked-list of elements. The list is composed of element container objects
+that are chained together. It is optimized so that adding or removing an
+element does not imply copying the whole list content every time.
+
+@see https://haxe.org/manual/std-List.html
+*/
+export const List = Register.global("$hxClasses")["haxe.ds.List"] = 
+class List extends Register.inherits() {
+	new() {
+		this.length = 0;
+	}
+	
+	/**
+	Adds element `item` at the end of `this` List.
+	
+	`this.length` increases by 1.
+	*/
+	add(item) {
+		var x = new ListNode(item, null);
+		if (this.h == null) {
+			this.h = x;
+		} else {
+			this.q.next = x;
+		};
+		this.q = x;
+		this.length++;
+	}
+	static get __name__() {
+		return "haxe.ds.List"
+	}
+	get __class__() {
+		return List
+	}
+}
+
+
+export const ListNode = Register.global("$hxClasses")["haxe.ds._List.ListNode"] = 
+class ListNode extends Register.inherits() {
+	new(item, next) {
+		this.item = item;
+		this.next = next;
+	}
+	static get __name__() {
+		return "haxe.ds._List.ListNode"
+	}
+	get __class__() {
+		return ListNode
+	}
+}
+

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

@@ -0,0 +1,7 @@
+import {IMap} from "../Constraints"
+import {EsMap} from "../../genes/util/EsMap"
+
+export declare class ObjectMap<K extends {
+}, V> extends EsMap<K, V> implements IMap<K, V> {
+	constructor()
+}