@idlebox/node 1.2.12 → 1.2.14

package/src/error/code.ts

@@ -0,0 +1,124 @@
+export enum ERRNO_LINUX {
+	EPERM = 1 /* Not super-user */,
+	ENOENT = 2 /* No such file or directory */,
+	ESRCH = 3 /* No such process */,
+	EINTR = 4 /* Interrupted system call */,
+	EIO = 5 /* I/O error */,
+	ENXIO = 6 /* No such device or address */,
+	E2BIG = 7 /* Arg list too long */,
+	ENOEXEC = 8 /* Exec format error */,
+	EBADF = 9 /* Bad file number */,
+	ECHILD = 10 /* No children */,
+	EAGAIN = 11 /* No more processes */,
+	ENOMEM = 12 /* Not enough core */,
+	EACCES = 13 /* Permission denied */,
+	EFAULT = 14 /* Bad address */,
+	ENOTBLK = 15 /* Block device required */,
+	EBUSY = 16 /* Mount device busy */,
+	EEXIST = 17 /* File exists */,
+	EXDEV = 18 /* Cross-device link */,
+	ENODEV = 19 /* No such device */,
+	ENOTDIR = 20 /* Not a directory */,
+	EISDIR = 21 /* Is a directory */,
+	EINVAL = 22 /* Invalid argument */,
+	ENFILE = 23 /* Too many open files in system */,
+	EMFILE = 24 /* Too many open files */,
+	ENOTTY = 25 /* Not a typewriter */,
+	ETXTBSY = 26 /* Text file busy */,
+	EFBIG = 27 /* File too large */,
+	ENOSPC = 28 /* No space left on device */,
+	ESPIPE = 29 /* Illegal seek */,
+	EROFS = 30 /* Read only file system */,
+	EMLINK = 31 /* Too many links */,
+	EPIPE = 32 /* Broken pipe */,
+	EDOM = 33 /* Math arg out of domain of func */,
+	ERANGE = 34 /* Math result not representable */,
+	ENOMSG = 35 /* No message of desired type */,
+	EIDRM = 36 /* Identifier removed */,
+	ECHRNG = 37 /* Channel number out of range */,
+	EL2NSYNC = 38 /* Level 2 not synchronized */,
+	EL3HLT = 39 /* Level 3 halted */,
+	EL3RST = 40 /* Level 3 reset */,
+	ELNRNG = 41 /* Link number out of range */,
+	EUNATCH = 42 /* Protocol driver not attached */,
+	ENOCSI = 43 /* No CSI structure available */,
+	EL2HLT = 44 /* Level 2 halted */,
+	EDEADLK = 45 /* Deadlock condition */,
+	ENOLCK = 46 /* No record locks available */,
+	EBADE = 50 /* Invalid exchange */,
+	EBADR = 51 /* Invalid request descriptor */,
+	EXFULL = 52 /* Exchange full */,
+	ENOANO = 53 /* No anode */,
+	EBADRQC = 54 /* Invalid request code */,
+	EBADSLT = 55 /* Invalid slot */,
+	EDEADLOCK = 56 /* File locking deadlock error */,
+	EBFONT = 57 /* Bad font file fmt */,
+	ENOSTR = 60 /* Device not a stream */,
+	ENODATA = 61 /* No data (for no delay io) */,
+	ETIME = 62 /* Timer expired */,
+	ENOSR = 63 /* Out of streams resources */,
+	ENONET = 64 /* Machine is not on the network */,
+	ENOPKG = 65 /* Package not installed */,
+	EREMOTE = 66 /* The object is remote */,
+	ENOLINK = 67 /* The link has been severed */,
+	EADV = 68 /* Advertise error */,
+	ESRMNT = 69 /* Srmount error */,
+	ECOMM = 70 /* Communication error on send */,
+	EPROTO = 71 /* Protocol error */,
+	EMULTIHOP = 74 /* Multihop attempted */,
+	ELBIN = 75 /* Inode is remote (not really error) */,
+	EDOTDOT = 76 /* Cross mount point (not really error) */,
+	EBADMSG = 77 /* Trying to read unreadable message */,
+	EFTYPE = 79 /* Inappropriate file type or format */,
+	ENOTUNIQ = 80 /* Given log. name not unique */,
+	EBADFD = 81 /* f.d. invalid for this operation */,
+	EREMCHG = 82 /* Remote address changed */,
+	ELIBACC = 83 /* Can't access a needed shared lib */,
+	ELIBBAD = 84 /* Accessing a corrupted shared lib */,
+	ELIBSCN = 85 /* .lib section in a.out corrupted */,
+	ELIBMAX = 86 /* Attempting to link in too many libs */,
+	ELIBEXEC = 87 /* Attempting to exec a shared library */,
+	ENOSYS = 88 /* Function not implemented */,
+	ENMFILE = 89 /* No more files */,
+	ENOTEMPTY = 90 /* Directory not empty */,
+	ENAMETOOLONG = 91 /* File or path name too long */,
+	ELOOP = 92 /* Too many symbolic links */,
+	EOPNOTSUPP = 95 /* Operation not supported on transport endpoint */,
+	EPFNOSUPPORT = 96 /* Protocol family not supported */,
+	ECONNRESET = 104 /* Connection reset by peer */,
+	ENOBUFS = 105 /* No buffer space available */,
+	EAFNOSUPPORT = 106 /* Address family not supported by protocol family */,
+	EPROTOTYPE = 107 /* Protocol wrong type for socket */,
+	ENOTSOCK = 108 /* Socket operation on non-socket */,
+	ENOPROTOOPT = 109 /* Protocol not available */,
+	ESHUTDOWN = 110 /* Can't send after socket shutdown */,
+	ECONNREFUSED = 111 /* Connection refused */,
+	EADDRINUSE = 112 /* Address already in use */,
+	ECONNABORTED = 113 /* Connection aborted */,
+	ENETUNREACH = 114 /* Network is unreachable */,
+	ENETDOWN = 115 /* Network interface is not configured */,
+	ETIMEDOUT = 116 /* Connection timed out */,
+	EHOSTDOWN = 117 /* Host is down */,
+	EHOSTUNREACH = 118 /* Host is unreachable */,
+	EINPROGRESS = 119 /* Connection already in progress */,
+	EALREADY = 120 /* Socket already connected */,
+	EDESTADDRREQ = 121 /* Destination address required */,
+	EMSGSIZE = 122 /* Message too long */,
+	EPROTONOSUPPORT = 123 /* Unknown protocol */,
+	ESOCKTNOSUPPORT = 124 /* Socket type not supported */,
+	EADDRNOTAVAIL = 125 /* Address not available */,
+	ENETRESET = 126,
+	EISCONN = 127 /* Socket is already connected */,
+	ENOTCONN = 128 /* Socket is not connected */,
+	ETOOMANYREFS = 129,
+	EPROCLIM = 130,
+	EUSERS = 131,
+	EDQUOT = 132,
+	ESTALE = 133,
+	ENOTSUP = 134 /* Not supported */,
+	ENOMEDIUM = 135 /* No medium (in tape drive) */,
+	ENOSHARE = 136 /* No such host or network path */,
+	ECASECLASH = 137 /* Filename exists with different case */,
+	EILSEQ = 138,
+	EOVERFLOW = 139 /* Value too large for defined data type */,
+}

package/src/error/pretty.ts

@@ -0,0 +1,240 @@
+import { isAbsolute } from '@idlebox/common';
+import { relativePath } from '../path-resolve/resolvePath';
+
+const regNormal = /^\s+at ([^\/\s]+)(?: \[as ([^\]]+)])? \(((?:node|file):\/*)?([^:]+)(:\d+)?(:\d+)\)$/;
+
+const enum regNormalMatch {
+	fn = 1,
+	fnAlias,
+	fileSchema,
+	file,
+	row,
+	column,
+}
+
+const regFunctionOnly = /^\s+at ([^\/\\\s]+(?: \[as ([^\]]+)])?)$/;
+
+const enum regFunctionMatch {
+	fn = 1,
+	fnAlias,
+}
+
+const regFileOnly = /^\s+at ([^:]+)(:\d+)?(:\d+)$/;
+
+const enum regFileOnlyMatch {
+	file = 1,
+	row,
+	column,
+}
+
+const regSimpleFrame = /^\s+at ([^(]+) \(<anonymous>\)$/;
+
+const enum regSimpleFrameMatch {
+	fn = 1,
+}
+
+let root = process.cwd();
+
+export function setErrorLogRoot(_root: string) {
+	root = _root;
+}
+
+interface IInternalData {
+	raw?: string;
+	fn?: string;
+	as?: string;
+	file?: string;
+	fileSchema?: string; // 'node' | 'file';
+	line?: number;
+	col?: number;
+	abs?: boolean;
+}
+
+let notify_printed = false;
+export function prettyPrintError(type: string, e: Error) {
+	if (process.env.DISABLE_PRETTY_ERROR) {
+		console.error('[${type}] %s', e.stack || e.message);
+		return;
+	}
+	console.error(`------------------------------------------
+[${type}] ${prettyFormatError(e)}`);
+
+	if (!notify_printed) {
+		notify_printed = true;
+		console.error('\x1B[2muse env.DISABLE_PRETTY_ERROR=yes to see original error stack\x1B[0m');
+	}
+}
+
+function red(s: string) {
+	return `\x1B[38;5;9m${s}\x1B[0m`;
+}
+
+export function prettyFormatError(e: Error) {
+	if (!e || !e.message) {
+		return red('Unknown Error') + '\n' + new Error().stack?.split('\n').slice(3).join('\n');
+	}
+	if (!e.stack) {
+		return red(e.message + '\nNo stack trace');
+	}
+	const stackStr = e.stack.replace(/file:\/\//, '').split(/\n/g);
+	debugger;
+	let first = stackStr.shift()!;
+	const stack: IInternalData[] = stackStr.map((line) => {
+		if (regNormal.test(line)) {
+			const m = regNormal.exec(line)!;
+			return {
+				fn: m[regNormalMatch.fn],
+				as: m[regNormalMatch.fnAlias],
+				fileSchema: m[regNormalMatch.fileSchema],
+				file: m[regNormalMatch.file],
+				line: parseInt(m[regNormalMatch.row].slice(1)),
+				col: parseInt(m[regNormalMatch.column].slice(1)),
+				abs: isAbsolute(m[regNormalMatch.file]),
+			};
+		} else if (regFunctionOnly.test(line)) {
+			const m = regFunctionOnly.exec(line)!;
+			return {
+				fn: m[regFunctionMatch.fn],
+				as: m[regFunctionMatch.fnAlias],
+				file: undefined,
+				line: undefined,
+				col: undefined,
+				abs: false,
+			};
+		} else if (regFileOnly.test(line)) {
+			const m = regFileOnly.exec(line)!;
+			return {
+				fn: undefined,
+				as: undefined,
+				file: m[regFileOnlyMatch.file],
+				line: parseInt(m[regFileOnlyMatch.row].slice(1)),
+				col: parseInt(m[regFileOnlyMatch.column].slice(1)),
+				abs: isAbsolute(m[regFileOnlyMatch.file]),
+			};
+		} else if (regSimpleFrame.test(line)) {
+			const m = regSimpleFrame.exec(line)!;
+			return {
+				fn: m[regSimpleFrameMatch.fn],
+				as: undefined,
+				file: '<anonymous>',
+				line: undefined,
+				col: undefined,
+				abs: false,
+			};
+		} else {
+			return { raw: line.replace(/^  /, '') };
+		}
+	});
+	const stackOutput = stack
+		.filter(ignoreSomeFiles)
+		.map(translateFunction)
+		.map(({ raw, fn, file, as, abs, line, col, fileSchema }) => {
+			let ret;
+			if (raw) {
+				return raw;
+			}
+
+			if (abs) {
+				const isNodeModule = file?.includes('/node_modules/');
+				const color = fn ? (isNodeModule ? '4' : '14') : '8';
+				ret = `  at \x1b[38;5;${color}m`;
+				if (as && fn && fn.startsWith('Object.')) {
+					ret += as + ' [export]';
+				} else {
+					ret += formatFunctionName(fn, as);
+				}
+				ret += '\x1b[0m';
+				if (file) {
+					ret += ' (';
+					if (!isNodeModule) {
+						ret += '\x1b[38;5;2m';
+					}
+					ret += formatFileLine(fileSchema, file, line, col);
+					ret += '\x1B[0m)';
+				}
+			} else {
+				ret = '\x1B[2m  at ';
+				if (fn) {
+					ret += fn;
+				}
+				if (file) {
+					if (fn) {
+						ret += ' (';
+					}
+					ret += formatFileLine(fileSchema, file, line, col);
+					if (fn) {
+						ret += ')';
+					}
+				}
+				ret += '\x1B[0m';
+			}
+			return ret;
+		});
+
+	if ((e as any).code) {
+		first = first.replace(/^(\S+):/, (_, name) => {
+			return `${name}(code ${(e as any).code}):`;
+		});
+	}
+
+	return first + '\n' + stackOutput.join('\n');
+}
+
+function formatFileLine(schema: string | undefined, file: string, row?: number, col?: number) {
+	let rel = file;
+
+	if (schema !== 'node:') {
+		rel = relativePath(root, file);
+		if (rel.startsWith('..')) {
+			rel = file;
+		} else if (!rel.startsWith('.')) {
+			rel = './' + rel;
+		}
+	}
+
+	return `${schema || ''}${rel}${row ? `:${row}` : ''}${col ? `:${col}` : ''}`;
+}
+
+function formatFunctionName(fn?: string, as?: string) {
+	if (fn) {
+		if (as) {
+			return `${fn} [as ${as}]`;
+		} else {
+			return fn;
+		}
+	} else {
+		return '[anonymous]';
+	}
+}
+
+function translateFunction(data: IInternalData): IInternalData {
+	if (!data.fn) {
+		return data;
+	}
+	if (data.fn === 'Timeout._onTimeout') {
+		data.fn = 'setTimeout';
+	}
+	if (data.fn.startsWith('Timeout.') && data.as === '_onTimeout') {
+		data.fn = 'setTimeout->' + data.fn.slice(8);
+		delete data.as;
+	}
+	return data;
+}
+
+function ignoreSomeFiles({ file }: IInternalData): boolean {
+	if (!file) {
+		return true;
+	}
+	if (file === 'internal/timers.js') {
+		return false;
+	}
+	if (file.startsWith('internal/modules/cjs/loader')) {
+		return false;
+	}
+	if (!file.includes('/')) {
+		if (file.startsWith('_stream_')) {
+			return false;
+		}
+	}
+	return true;
+}

package/src/events/dumpEventEmitter.ts

@@ -0,0 +1,9 @@
+import { EventEmitter } from 'events';
+
+export function dumpEventEmitterEmit(ev: EventEmitter) {
+	const real = ev.emit;
+	ev.emit = (event: string | symbol, ...args: any[]) => {
+		console.log('[%s] emit:', ev.constructor.name, ...args);
+		return real.call(ev, event, ...args);
+	};
+}

package/src/fs/commandExists.ts

@@ -0,0 +1,48 @@
+import { isWindows } from '@idlebox/common';
+import { access, constants, accessSync } from 'fs';
+import { PathEnvironment } from '../environment/pathEnvironment';
+
+const windowsExecExtensions = ['.exe', '.bat', '.cmd', '.com', '.ps1'];
+
+function exts(alterExt?: string[]) {
+	if (alterExt) {
+		const ret = [...alterExt];
+		if (!isWindows) {
+			ret.unshift('');
+		}
+		return ret;
+	}
+	if (isWindows) {
+		return windowsExecExtensions;
+	} else {
+		return [''];
+	}
+}
+
+export async function commandInPath(cmd: string, alterExt?: string[]): Promise<string | undefined> {
+	const pathVar = new PathEnvironment();
+	for (const item of pathVar.join(cmd)) {
+		for (const ext of exts(alterExt)) {
+			const found = await new Promise((resolve) => {
+				access(item + ext, constants.X_OK, (e) => {
+					if (e) resolve(false);
+					else resolve(true);
+				});
+			});
+			if (found) return item + ext;
+		}
+	}
+	return undefined;
+}
+export function commmandInPathSync(cmd: string, alterExt?: string[]): string | undefined {
+	const pathVar = new PathEnvironment();
+	for (const item of pathVar.join(cmd)) {
+		for (const ext of exts(alterExt)) {
+			try {
+				accessSync(item + ext, constants.X_OK);
+				return item + ext;
+			} catch {}
+		}
+	}
+	return undefined;
+}

package/src/fs/exists.ts

@@ -0,0 +1,17 @@
+import { access, accessSync } from 'fs';
+
+export function existsSync(path: string): boolean {
+	try {
+		accessSync(path);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+export function exists(path: string): Promise<boolean> {
+	return new Promise((resolve) => {
+		const wrappedCallback = (err: Error | null) => (err ? resolve(false) : resolve(true));
+		access(path, wrappedCallback);
+	});
+}

package/src/fs/tempFolder.ts

@@ -0,0 +1,54 @@
+import { mkdirSync, readdirSync, rmdirSync, statSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { IDisposable } from '@idlebox/common';
+import { existsSync } from './exists';
+
+let registered = false;
+const tempFolders = new Set<string>();
+
+export function createTempFolder(fullPath: string): IDisposable {
+	if (existsSync(fullPath)) {
+		throw new Error('temp folder already exists: ' + fullPath);
+	}
+	if (!registered) {
+		process.on('beforeExit', onBeforeExit);
+	}
+	tempFolders.add(fullPath);
+	mkdirSync(fullPath);
+
+	return {
+		dispose() {
+			tempFolders.delete(fullPath);
+			rmdirpSync(fullPath);
+		},
+	};
+}
+
+function rmdirpSync(p: string) {
+	try {
+		const stat = statSync(p);
+		if (stat.isSymbolicLink() || stat.isFile()) {
+			unlinkSync(p);
+		} else if (stat.isDirectory()) {
+			let succ = true;
+			for (const item of readdirSync(p)) {
+				if (!rmdirpSync(resolve(p, item))) {
+					succ = false;
+				}
+			}
+			if (succ) {
+				rmdirSync(p);
+			}
+			return succ;
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function onBeforeExit() {
+	for (const path of tempFolders) {
+		rmdirpSync(path);
+	}
+}

package/src/fs/weiteChanged.ts

@@ -0,0 +1,46 @@
+import { readFile as readFileAsync, readFileSync, writeFile as writeFileAsync, writeFileSync } from 'fs';
+import { promisify } from 'util';
+import { exists, existsSync } from './exists';
+
+const readFile = promisify(readFileAsync);
+const writeFile = promisify(writeFileAsync);
+
+export function writeFileIfChangeSync(file: string, data: string | Buffer) {
+	if (existsSync(file)) {
+		if (typeof data === 'string') {
+			if (readFileSync(file, 'utf-8') === data) {
+				return false;
+			}
+		} else {
+			if (Buffer.compare(data, readFileSync(file)) === 0) {
+				return false;
+			}
+		}
+	}
+	if (typeof data === 'string') {
+		writeFileSync(file, data, 'utf-8');
+	} else {
+		writeFileSync(file, data);
+	}
+	return true;
+}
+
+export async function writeFileIfChange(file: string, data: string | Buffer) {
+	if (await exists(file)) {
+		if (typeof data === 'string') {
+			if ((await readFile(file, 'utf-8')) === data) {
+				return false;
+			}
+		} else {
+			if (Buffer.compare(data, await readFile(file)) === 0) {
+				return false;
+			}
+		}
+	}
+	if (typeof data === 'string') {
+		await writeFile(file, data, 'utf-8');
+	} else {
+		await writeFile(file, data);
+	}
+	return true;
+}

package/src/index.generated.ts

@@ -0,0 +1,133 @@
+// DO NOT EDIT THIS FILE
+// @ts-ignore
+/* eslint-disable */
+
+/* preload.ts */
+	// Identifiers
+/* path-resolve/resolvePath.ts */
+	// Identifiers
+		export {ResolvePathFunction} from "./path-resolve/resolvePath";
+		export {JoinPathFunction} from "./path-resolve/resolvePath";
+		export {resolvePath} from "./path-resolve/resolvePath";
+		export {NormalizePathFunction} from "./path-resolve/resolvePath";
+		export {normalizePath} from "./path-resolve/resolvePath";
+		export {osTempDir} from "./path-resolve/resolvePath";
+		export {relativePath} from "./path-resolve/resolvePath";
+/* error/pretty.ts */
+	// Identifiers
+		export {setErrorLogRoot} from "./error/pretty";
+		export {prettyPrintError} from "./error/pretty";
+		export {prettyFormatError} from "./error/pretty";
+/* asyncLoad.ts */
+	// Identifiers
+		export {AsyncMainFunction} from "./asyncLoad";
+		export {ExitError} from "./asyncLoad";
+		export {runMain} from "./asyncLoad";
+/* child_process/error.ts */
+	// Identifiers
+		export {checkChildProcessResult} from "./child_process/error";
+/* child_process/execa.ts */
+	// Identifiers
+		export {Sync} from "./child_process/execa";
+		export {Async} from "./child_process/execa";
+		export {ICommand} from "./child_process/execa";
+		export {spawnWithoutOutput} from "./child_process/execa";
+		export {spawnGetOutput} from "./child_process/execa";
+		export {spawnGetEverything} from "./child_process/execa";
+/* cli-io/output.ts */
+	// Identifiers
+		export {printLine} from "./cli-io/output";
+/* child_process/lateError.ts */
+	// Identifiers
+		export {ISpawnAdditionOptions} from "./child_process/lateError";
+		export {execLazyError} from "./child_process/lateError";
+/* fs/exists.ts */
+	// Identifiers
+		export {existsSync} from "./fs/exists";
+		export {exists} from "./fs/exists";
+/* environment/getEnvironment.ts */
+	// Identifiers
+		export {IEnvironmentResult} from "./environment/getEnvironment";
+		export {getEnvironment} from "./environment/getEnvironment";
+		export {deleteEnvironment} from "./environment/getEnvironment";
+		export {cleanupEnvironment} from "./environment/getEnvironment";
+/* environment/pathEnvironment.ts */
+	// Identifiers
+		export {PATH_SEPARATOR} from "./environment/pathEnvironment";
+		export {PathEnvironment} from "./environment/pathEnvironment";
+/* environment/findBinary.ts */
+	// Identifiers
+		export {findBinary} from "./environment/findBinary";
+/* child_process/respawn.ts */
+	// Identifiers
+		export {spawnRecreateEventHandlers} from "./child_process/respawn";
+		export {trySpawnInScope} from "./child_process/respawn";
+		export {respawnInScope} from "./child_process/respawn";
+/* crypto/md5.ts */
+	// Identifiers
+		export {md5} from "./crypto/md5";
+/* crypto/sha256.ts */
+	// Identifiers
+		export {sha256} from "./crypto/sha256";
+/* environment/npmConfig.ts */
+	// Identifiers
+		export {getNpmConfigValue} from "./environment/npmConfig";
+/* error/code.ts */
+	// Identifiers
+		export {ERRNO_LINUX} from "./error/code";
+/* events/dumpEventEmitter.ts */
+	// Identifiers
+		export {dumpEventEmitterEmit} from "./events/dumpEventEmitter";
+/* fs/commandExists.ts */
+	// Identifiers
+		export {commandInPath} from "./fs/commandExists";
+		export {commmandInPathSync} from "./fs/commandExists";
+/* fs/tempFolder.ts */
+	// Identifiers
+		export {createTempFolder} from "./fs/tempFolder";
+/* fs/weiteChanged.ts */
+	// Identifiers
+		export {writeFileIfChangeSync} from "./fs/weiteChanged";
+		export {writeFileIfChange} from "./fs/weiteChanged";
+/* log/terminal.ts */
+	// Identifiers
+		export {WrappedTerminalConsole} from "./log/terminal";
+/* path-resolve/findUp.ts */
+	// Identifiers
+		export {findUpUntil} from "./path-resolve/findUp";
+		export {findUpUntilSync} from "./path-resolve/findUp";
+/* path-resolve/findPackageRoot.ts */
+	// Identifiers
+		export {findPackageRoot} from "./path-resolve/findPackageRoot";
+/* path-resolve/getAllUp.ts */
+	// Identifiers
+		export {getAllPathUpToRoot} from "./path-resolve/getAllUp";
+/* path-resolve/lrelative.ts */
+	// Identifiers
+		export {lrelative} from "./path-resolve/lrelative";
+/* path-resolve/nodeResolvePathArray.ts */
+	// Identifiers
+		export {nodeResolvePathArray} from "./path-resolve/nodeResolvePathArray";
+/* stream/blackHoleStream.ts */
+	// Identifiers
+		export {BlackHoleStream} from "./stream/blackHoleStream";
+/* stream/streamPromise.ts */
+	// Identifiers
+		export {streamPromise} from "./stream/streamPromise";
+		export {streamHasEnd} from "./stream/streamPromise";
+/* stream/collectingStream.ts */
+	// Identifiers
+		export {streamToBuffer} from "./stream/collectingStream";
+		export {RawCollectingStream} from "./stream/collectingStream";
+		export {CollectingStream} from "./stream/collectingStream";
+/* stream/disposableStream.ts */
+	// Identifiers
+		export {disposableStream} from "./stream/disposableStream";
+/* stream/drainStream.ts */
+	// Identifiers
+		export {drainStream} from "./stream/drainStream";
+/* stream/loggerStream.ts */
+	// Identifiers
+		export {LogFunction} from "./stream/loggerStream";
+		export {LoggerStream} from "./stream/loggerStream";
+		export {HexDumpLoggerStream} from "./stream/loggerStream";