whet 0.0.1

package/bin/haxe/macro/Type.d.ts

@@ -0,0 +1,609 @@
+import {Position, Binop, Unop, Expr, MetadataEntry} from "./Expr"
+import {Map as Map__1} from "../../Map"
+
+/**
+Represents a reference to internal compiler structure. It exists to avoid
+expensive encoding if it is not required and to ensure that physical
+equality remains intact.
+
+A structure is only encoded when user requests it through `ref.get()`.
+*/
+export type Ref<T> = {
+	get: () => T, 
+	toString: () => string
+}
+
+/**
+Represents information for anonymous structure types.
+*/
+export type AnonType = {
+	/**
+	The class fields of the structure.
+	*/
+	fields: ClassField[], 
+	/**
+	The status/kind of the structure.
+	*/
+	status: AnonStatus
+}
+
+/**
+Represents the declaration of type parameters.
+*/
+export type TypeParameter = {
+	/**
+	The name of the type parameter.
+	*/
+	name: string, 
+	/**
+	The type of the type parameter. It is guaranteed to be a `TInst` with a
+	`KTypeParameter` kind.
+	*/
+	t: Type
+}
+
+/**
+Represents a class field.
+*/
+export type ClassField = {
+	/**
+	The associated documentation of the class field.
+	*/
+	doc: null | string, 
+	/**
+	Returns the typed expression of the class field.
+	*/
+	expr: () => null | TypedExpr, 
+	/**
+	Whether or not the class field is abstract.
+	*/
+	isAbstract: boolean, 
+	/**
+	Whether or not the class field is extern.
+	*/
+	isExtern: boolean, 
+	/**
+	Whether or not the class field is final.
+	*/
+	isFinal: boolean, 
+	/**
+	Whether or not the class field is public.
+	*/
+	isPublic: boolean, 
+	/**
+	The class field kind.
+	*/
+	kind: FieldKind, 
+	/**
+	The metadata of the class field.
+	*/
+	meta: MetaAccess, 
+	/**
+	The name of the class field.
+	*/
+	name: string, 
+	/**
+	The overload fields of the class field.
+	*/
+	overloads: Ref<ClassField[]>, 
+	/**
+	The type parameters of the class field.
+	*/
+	params: TypeParameter[], 
+	/**
+	The position of the class field.
+	*/
+	pos: Position, 
+	/**
+	The type of the class field.
+	*/
+	type: Type
+}
+
+/**
+Represents an enum constructor.
+*/
+export type EnumField = {
+	/**
+	The associated documentation of the enum constructor.
+	*/
+	doc: null | string, 
+	/**
+	The index of the enum constructor, i.e. in which position it appears
+	in the syntax.
+	*/
+	index: number, 
+	/**
+	The metadata of the enum constructor.
+	*/
+	meta: MetaAccess, 
+	/**
+	The name of the enum constructor.
+	*/
+	name: string, 
+	/**
+	The type parameters of the enum constructor.
+	*/
+	params: TypeParameter[], 
+	/**
+	The position of the enum constructor.
+	*/
+	pos: Position, 
+	/**
+	The type of the enum constructor.
+	*/
+	type: Type
+}
+
+/**
+The information that all types (`ClassType`, `EnumType`, `DefType`,
+`AbstractType`) have in common.
+*/
+export type BaseType = {
+	/**
+	The associated documentation of the class field.
+	*/
+	doc: null | string, 
+	/**
+	Allows excluding the type from compilation.
+	*/
+	exclude: () => void, 
+	/**
+	Whether or not the type is extern.
+	*/
+	isExtern: boolean, 
+	/**
+	Whether or not the type is private.
+	*/
+	isPrivate: boolean, 
+	/**
+	The metadata of the type.
+	*/
+	meta: MetaAccess, 
+	/**
+	The module name of the type, which might be different.
+	*/
+	module: string, 
+	/**
+	The name of the type.
+	*/
+	name: string, 
+	/**
+	The package of the type.
+	*/
+	pack: string[], 
+	/**
+	The type parameters of the type.
+	*/
+	params: TypeParameter[], 
+	/**
+	The position of the type.
+	*/
+	pos: Position
+}
+
+/**
+Represents a class type.
+*/
+export type ClassType = {
+	/**
+	The constructor of the class, if available.
+	*/
+	constructor: null | Ref<ClassField>, 
+	/**
+	The associated documentation of the class field.
+	*/
+	doc: null | string, 
+	/**
+	Allows excluding the type from compilation.
+	*/
+	exclude: () => void, 
+	/**
+	The member fields of the class.
+	*/
+	fields: Ref<ClassField[]>, 
+	/**
+	The `__init__` expression of the class, if available.
+	*/
+	init: null | TypedExpr, 
+	/**
+	The implemented interfaces and their type parameters.
+	*/
+	interfaces: {
+		params: Type[], 
+		t: Ref<ClassType>
+	}[], 
+	/**
+	If true the class is abstract and cannot be instantiated directly.
+	*/
+	isAbstract: boolean, 
+	/**
+	Whether or not the type is extern.
+	*/
+	isExtern: boolean, 
+	/**
+	If true the class is final and cannot be extended.
+	*/
+	isFinal: boolean, 
+	/**
+	If true the type is an interface, otherwise it is a class.
+	*/
+	isInterface: boolean, 
+	/**
+	Whether or not the type is private.
+	*/
+	isPrivate: boolean, 
+	/**
+	The kind of the class.
+	*/
+	kind: ClassKind, 
+	/**
+	The metadata of the type.
+	*/
+	meta: MetaAccess, 
+	/**
+	The module name of the type, which might be different.
+	*/
+	module: string, 
+	/**
+	The name of the type.
+	*/
+	name: string, 
+	/**
+	The list of fields that have override status.
+	*/
+	overrides: Ref<ClassField>[], 
+	/**
+	The package of the type.
+	*/
+	pack: string[], 
+	/**
+	The type parameters of the type.
+	*/
+	params: TypeParameter[], 
+	/**
+	The position of the type.
+	*/
+	pos: Position, 
+	/**
+	The static fields of the class.
+	*/
+	statics: Ref<ClassField[]>, 
+	/**
+	The parent class and its type parameters, if available.
+	*/
+	superClass: null | {
+		params: Type[], 
+		t: Ref<ClassType>
+	}
+}
+
+/**
+Represents an enum type.
+*/
+export type EnumType = {
+	/**
+	The available enum constructors.
+	*/
+	constructs: Map__1<string, EnumField>, 
+	/**
+	The associated documentation of the class field.
+	*/
+	doc: null | string, 
+	/**
+	Allows excluding the type from compilation.
+	*/
+	exclude: () => void, 
+	/**
+	Whether or not the type is extern.
+	*/
+	isExtern: boolean, 
+	/**
+	Whether or not the type is private.
+	*/
+	isPrivate: boolean, 
+	/**
+	The metadata of the type.
+	*/
+	meta: MetaAccess, 
+	/**
+	The module name of the type, which might be different.
+	*/
+	module: string, 
+	/**
+	The name of the type.
+	*/
+	name: string, 
+	/**
+	An ordered list of enum constructor names.
+	*/
+	names: string[], 
+	/**
+	The package of the type.
+	*/
+	pack: string[], 
+	/**
+	The type parameters of the type.
+	*/
+	params: TypeParameter[], 
+	/**
+	The position of the type.
+	*/
+	pos: Position
+}
+
+/**
+Represents a typedef.
+*/
+export type DefType = {
+	/**
+	The associated documentation of the class field.
+	*/
+	doc: null | string, 
+	/**
+	Allows excluding the type from compilation.
+	*/
+	exclude: () => void, 
+	/**
+	Whether or not the type is extern.
+	*/
+	isExtern: boolean, 
+	/**
+	Whether or not the type is private.
+	*/
+	isPrivate: boolean, 
+	/**
+	The metadata of the type.
+	*/
+	meta: MetaAccess, 
+	/**
+	The module name of the type, which might be different.
+	*/
+	module: string, 
+	/**
+	The name of the type.
+	*/
+	name: string, 
+	/**
+	The package of the type.
+	*/
+	pack: string[], 
+	/**
+	The type parameters of the type.
+	*/
+	params: TypeParameter[], 
+	/**
+	The position of the type.
+	*/
+	pos: Position, 
+	/**
+	The target type of the typedef.
+	*/
+	type: Type
+}
+
+/**
+Represents an abstract type.
+*/
+export type AbstractType = {
+	/**
+	The defined array-access fields of the abstract.
+	*/
+	array: ClassField[], 
+	/**
+	The defined binary operators of the abstract.
+	*/
+	binops: {
+		field: ClassField, 
+		op: Binop
+	}[], 
+	/**
+	The associated documentation of the class field.
+	*/
+	doc: null | string, 
+	/**
+	Allows excluding the type from compilation.
+	*/
+	exclude: () => void, 
+	/**
+	The available implicit from-casts of the abstract.
+	
+	@see https://haxe.org/manual/types-abstract-implicit-casts.html
+	*/
+	from: {
+		field: null | ClassField, 
+		t: Type
+	}[], 
+	/**
+	The implementation class of the abstract, if available.
+	*/
+	impl: null | Ref<ClassType>, 
+	/**
+	Whether or not the type is extern.
+	*/
+	isExtern: boolean, 
+	/**
+	Whether or not the type is private.
+	*/
+	isPrivate: boolean, 
+	/**
+	The metadata of the type.
+	*/
+	meta: MetaAccess, 
+	/**
+	The module name of the type, which might be different.
+	*/
+	module: string, 
+	/**
+	The name of the type.
+	*/
+	name: string, 
+	/**
+	The package of the type.
+	*/
+	pack: string[], 
+	/**
+	The type parameters of the type.
+	*/
+	params: TypeParameter[], 
+	/**
+	The position of the type.
+	*/
+	pos: Position, 
+	/**
+	The method used for resolving unknown field access, if available.
+	*/
+	resolve: null | ClassField, 
+	/**
+	The method used for resolving unknown field access, if available.
+	*/
+	resolveWrite: null | ClassField, 
+	/**
+	The available implicit to-casts of the abstract.
+	
+	@see https://haxe.org/manual/types-abstract-implicit-casts.html
+	*/
+	to: {
+		field: null | ClassField, 
+		t: Type
+	}[], 
+	/**
+	The underlying type of the abstract.
+	*/
+	type: Type, 
+	/**
+	The defined unary operators of the abstract.
+	*/
+	unops: {
+		field: ClassField, 
+		op: Unop, 
+		postFix: boolean
+	}[]
+}
+
+/**
+MetaAccess is a wrapper for the `Metadata` array. It can be used to add
+metadata to and remove metadata from its origin.
+*/
+export type MetaAccess = {
+	/**
+	Adds the metadata specified by `name`, `params` and `pos` to the origin
+	of `this` MetaAccess.
+	
+	Metadata names are not unique during compilation, so this method never
+	overwrites a previous metadata.
+	
+	If a `Metadata` array is obtained through a call to `get`, a subsequent
+	call to `add` has no effect on that array.
+	
+	If any argument is null, compilation fails with an error.
+	*/
+	add: (name: string, params: Expr[], pos: Position) => void, 
+	/**
+	Extract metadata entries by given `name`.
+	
+	If there's no metadata with such name, empty array `[]` is returned.
+	
+	If `name` is null, compilation fails with an error.
+	*/
+	extract: (name: string) => MetadataEntry[], 
+	/**
+	Return the wrapped `Metadata` array.
+	
+	Modifying this array has no effect on the origin of `this` MetaAccess.
+	The `add` and `remove` methods can be used for that.
+	*/
+	get: () => MetadataEntry[], 
+	/**
+	Tells if the origin of `this` MetaAccess has a `name` metadata entry.
+	
+	If `name` is null, compilation fails with an error.
+	*/
+	has: (name: string) => boolean, 
+	/**
+	Removes all `name` metadata entries from the origin of `this`
+	MetaAccess.
+	
+	This method might clear several metadata entries of the same name.
+	
+	If a `Metadata` array is obtained through a call to `get`, a subsequent
+	call to `remove` has no effect on that array.
+	
+	If `name` is null, compilation fails with an error.
+	*/
+	remove: (name: string) => void
+}
+
+/**
+Represents a variable in the typed AST.
+*/
+export type TVar = {
+	/**
+	Whether or not the variable has been captured by a closure.
+	*/
+	capture: boolean, 
+	/**
+	Special information which is internally used to keep track of closure.
+	information
+	*/
+	extra: null | {
+		expr: null | TypedExpr, 
+		params: TypeParameter[]
+	}, 
+	/**
+	The unique ID of the variable.
+	*/
+	id: number, 
+	/**
+	The metadata of the variable.
+	*/
+	meta: null | MetaAccess, 
+	/**
+	The name of the variable.
+	*/
+	name: string, 
+	/**
+	The type of the variable.
+	*/
+	t: Type
+}
+
+/**
+Represents a function in the typed AST.
+*/
+export type TFunc = {
+	/**
+	A list of function arguments identified by an argument variable `v` and
+	an optional initialization `value`.
+	*/
+	args: {
+		v: TVar, 
+		value: null | TypedExpr
+	}[], 
+	/**
+	The expression of the function body.
+	*/
+	expr: TypedExpr, 
+	/**
+	The return type of the function.
+	*/
+	t: Type
+}
+
+/**
+Represents a typed AST node.
+*/
+export type TypedExpr = {
+	/**
+	The expression kind.
+	*/
+	expr: TypedExprDef, 
+	/**
+	The position of the expression.
+	*/
+	pos: Position, 
+	/**
+	The type of the expression.
+	*/
+	t: Type
+}

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

@@ -0,0 +1,5 @@
+import {Bytes} from "../io/Bytes"
+
+export declare class Compress {
+	static run(s: Bytes, level: number): Bytes
+}

package/bin/haxe/zip/Compress.js

@@ -0,0 +1,21 @@
+import * as Zlib from "zlib"
+import {Helper} from "../../js/node/buffer/Buffer.js"
+import {Register} from "../../genes/Register.js"
+import {Buffer} from "buffer"
+
+const $global = Register.$global
+
+export const Compress = Register.global("$hxClasses")["haxe.zip.Compress"] = 
+class Compress {
+	static run(s, level) {
+		var data = s.b;
+		return Helper.bytesOfBuffer(Zlib.deflateSync(Buffer.from(data.buffer, data.byteOffset, s.length), {"level": level}));
+	}
+	static get __name__() {
+		return "haxe.zip.Compress"
+	}
+	get __class__() {
+		return Compress
+	}
+}
+

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

@@ -0,0 +1,27 @@
+import {Bytes} from "../io/Bytes"
+import {List} from "../ds/List"
+
+export declare namespace ExtraField {
+	export type FUtf8 = {_hx_index: 2, __enum__: "haxe.zip.ExtraField"}
+	export const FUtf8: FUtf8
+	export type FUnknown = {_hx_index: 0, tag: number, bytes: Bytes, __enum__: "haxe.zip.ExtraField"}
+	export const FUnknown: (tag: number, bytes: Bytes) => ExtraField
+	export type FInfoZipUnicodePath = {_hx_index: 1, name: string, crc: number, __enum__: "haxe.zip.ExtraField"}
+	export const FInfoZipUnicodePath: (name: string, crc: number) => ExtraField
+}
+
+export declare type ExtraField = 
+	| ExtraField.FUtf8
+	| ExtraField.FUnknown
+	| ExtraField.FInfoZipUnicodePath
+
+export type Entry = {
+	compressed: boolean, 
+	crc32: null | number, 
+	data: null | Bytes, 
+	dataSize: number, 
+	extraFields?: null | List<ExtraField>, 
+	fileName: string, 
+	fileSize: number, 
+	fileTime: Date
+}

package/bin/haxe/zip/Entry.js

@@ -0,0 +1,15 @@
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const ExtraField = 
+Register.global("$hxEnums")["haxe.zip.ExtraField"] = 
+{
+	__ename__: "haxe.zip.ExtraField",
+	
+	FUnknown: Object.assign((tag, bytes) => ({_hx_index: 0, __enum__: "haxe.zip.ExtraField", "tag": tag, "bytes": bytes}), {_hx_name: "FUnknown", __params__: ["tag", "bytes"]}),
+	FInfoZipUnicodePath: Object.assign((name, crc) => ({_hx_index: 1, __enum__: "haxe.zip.ExtraField", "name": name, "crc": crc}), {_hx_name: "FInfoZipUnicodePath", __params__: ["name", "crc"]}),
+	FUtf8: {_hx_name: "FUtf8", _hx_index: 2, __enum__: "haxe.zip.ExtraField"}
+}
+ExtraField.__constructs__ = [ExtraField.FUnknown, ExtraField.FInfoZipUnicodePath, ExtraField.FUtf8]
+ExtraField.__empty_constructs__ = [ExtraField.FUtf8]

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

@@ -0,0 +1,5 @@
+import {Entry} from "./Entry"
+
+export declare class Tools {
+	static compress(f: Entry, level: number): void
+}

package/bin/haxe/zip/Tools.js

@@ -0,0 +1,24 @@
+import {Compress} from "./Compress.js"
+import {Register} from "../../genes/Register.js"
+
+const $global = Register.$global
+
+export const Tools = Register.global("$hxClasses")["haxe.zip.Tools"] = 
+class Tools {
+	static compress(f, level) {
+		if (f.compressed) {
+			return;
+		};
+		var data = Compress.run(f.data, level);
+		f.compressed = true;
+		f.data = data.sub(2, data.length - 6);
+		f.dataSize = f.data.length;
+	}
+	static get __name__() {
+		return "haxe.zip.Tools"
+	}
+	get __class__() {
+		return Tools
+	}
+}
+