@e-mc/types 0.13.7 → 0.13.9

package/README.md

@@ -1,6 +1,6 @@
 # @e-mc/types
 
-* NodeJS 18.20.5 LTS
+* NodeJS 18.20 LTS
 * ES2022
 
 ## General Usage
@@ -9,7 +9,7 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.13.7/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.13.9/index.d.ts)
 
 ```typescript
 import type { LogArguments } from "./lib/logger";
@@ -81,6 +81,7 @@ function supported(major: number, minor: number, lts: boolean): boolean;
 function supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
 function importESM(name: string | URL, isDefault: boolean, fromPath?: boolean): Promise<unknown>;
 function importESM(name: string | URL, options?: ImportAttributes, fromPath?: boolean): Promise<unknown>;
+function requireESM(name: string, url?: string | URL, expect?: string): unknown;
 function purgeMemory(percent?: number): number;
 
 interface LOG_TYPE {
@@ -208,10 +209,10 @@ const IMPORT_MAP: Record<string, string | undefined>;
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.13.7/index.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.7/lib/logger.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.7/lib/module.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.7/lib/node.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.9/index.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.9/lib/logger.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.9/lib/module.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.9/lib/node.d.ts
 
 * https://developer.mozilla.org/en-US/docs/Web/API/DOMException
 * https://www.npmjs.com/package/@types/bytes

package/constant.d.ts

@@ -1,5 +1,5 @@
 export const enum INTERNAL {
-    VERSION = '0.13.7',
+    VERSION = '0.13.9',
     TEMP_DIR = 'tmp',
     CJS = '__cjs__'
 }

package/index.d.ts

@@ -344,12 +344,15 @@ declare namespace types {
     function sanitizeCmd(value: string, ...args: unknown[]): string;
     function sanitizeArgs(value: string, doubleQuote?: boolean): string;
     function sanitizeArgs(values: string[], doubleQuote?: boolean): string[];
-    function errorValue(value: string, hint?: string): Error;
-    function errorMessage(title: number | string, value: string, hint?: string): Error;
+    function errorValue(value: string, cause: unknown): Error;
+    function errorValue(value: string, hint?: string, cause?: unknown): Error;
+    function errorMessage(title: number | string, value: string, cause: unknown): Error;
+    function errorMessage(title: number | string, value: string, hint?: string, cause?: unknown): Error;
     function supported(major: number, minor: number, lts: boolean): boolean;
     function supported(major: number, minor?: number, patch?: number, lts?: boolean): boolean;
     function importESM<T = unknown>(name: string | URL, isDefault: boolean, fromPath?: boolean): Promise<T>;
     function importESM<T = unknown>(name: string | URL, options?: ImportAttributes, fromPath?: boolean): Promise<T>;
+    function requireESM<T = unknown>(name: string, url?: string | URL, expect?: string): T;
     function purgeMemory(percent?: number): number;
 }
 

package/index.js

@@ -48,15 +48,18 @@ exports.incrementUUID = incrementUUID;
 exports.hashKey = hashKey;
 exports.supported = supported;
 exports.importESM = importESM;
+exports.requireESM = requireESM;
 const path = require("node:path");
 const fs = require("node:fs");
 const crypto = require("node:crypto");
 const bytes = require("bytes");
+const node_module_1 = require("node:module");
 const node_os_1 = require("node:os");
 const node_url_1 = require("node:url");
 const PATTERN_CHARS = {
     '&': '\\x26',
     '!': '\\x21',
+    '"': '\\x22',
     '#': '\\x23',
     '%': '\\x25',
     ',': '\\x2c',
@@ -102,6 +105,8 @@ let CACHE_COERCED = new WeakSet();
 let LOG_CURRENT = null;
 let SUPPORTED_HASHSINGLE = false;
 let SUPPORTED_IMPORTATTRIBUTES = false;
+let SUPPORTED_REGEXPESCAPE = false;
+let SUPPORTED_FLOAT16ARRAY = false;
 let TEMP_DIR = path.join(process.cwd(), "tmp");
 let INCREMENT_COUNT = 65536;
 let INCREMENT_PREFIX = '';
@@ -144,6 +149,9 @@ function fromObject(value, typedArray, structured, shared) {
             if (value instanceof BigUint64Array) {
                 return BigUint64Array.from(value);
             }
+            if (SUPPORTED_FLOAT16ARRAY && value instanceof Float16Array) {
+                return Float16Array.from(value);
+            }
         }
         if (structured) {
             try {
@@ -176,7 +184,7 @@ function fromObject(value, typedArray, structured, shared) {
 function trimQuote(value) {
     value = value.trim();
     const first = value[0];
-    return first === value.at(-1) && (first === '"' || first === "'" || first === "`") ? value.substring(1, value.length - 1) : value;
+    return first === value.at(-1) && (first === '"' || first === "'" || first === "`") ? value.slice(1, -1) : value;
 }
 function checkCipherType(value) {
     switch (value) {
@@ -761,6 +769,9 @@ function hasGlob(value) {
 function escapePattern(value, symbols) {
     switch (typeof value) {
         case 'string': {
+            if (symbols && SUPPORTED_REGEXPESCAPE) {
+                return RegExp.escape(value);
+            }
             let result = '', j = 0;
             for (let i = 0, length = value.length, ch; i < length; ++i) {
                 switch (ch = value[i]) {
@@ -1102,7 +1113,7 @@ function randomString(format, dictionary) {
                 let length = 0, available;
                 if (b.startsWith('[') && b.endsWith(']')) {
                     length = 1;
-                    available = b.substring(1, b.length - 1);
+                    available = b.slice(1, -1);
                 }
                 else {
                     if (isNaN(length = +b)) {
@@ -1191,11 +1202,19 @@ function sanitizeArgs(values, doubleQuote) {
     }
     return (typeof values === 'string' ? result[0] : result);
 }
-function errorValue(value, hint) {
-    return new Error(value + (hint ? ` (${hint})` : ''));
+function errorValue(value, hint, cause) {
+    if (!cause && isObject(hint)) {
+        cause = hint;
+        hint = undefined;
+    }
+    return new Error(value + (hint ? ` (${hint})` : ''), cause ? { cause } : undefined);
 }
-function errorMessage(title, value, hint) {
-    return new Error((isString(title) || typeof title === 'number' ? title + ': ' : '') + value + (hint ? ` (${hint})` : ''));
+function errorMessage(title, value, hint, cause) {
+    if (!cause && isObject(hint)) {
+        cause = hint;
+        hint = undefined;
+    }
+    return new Error((isString(title) || typeof title === 'number' ? title + ': ' : '') + value + (hint ? ` (${hint})` : ''), cause ? { cause } : undefined);
 }
 function purgeMemory(percent) {
     CACHE_COERCED = new WeakSet();
@@ -1260,5 +1279,10 @@ async function importESM(name, isDefault, fromPath) {
     }
     return result;
 }
+function requireESM(name, url, expect) {
+    const result = url ? (0, node_module_1.createRequire)(url)(name) : require(name);
+    return process.features.require_module && isObject(result) && result.__esModule && 'default' in result && (!expect || typeof result.default === expect) ? result.default : result;
+}
 SUPPORTED_HASHSINGLE = supported(20, 12, true) || supported(21, 7);
-SUPPORTED_IMPORTATTRIBUTES = supported(18, 20, 5, true) || supported(20, 18, 3, true) || supported(22, 12, true) || supported(23, 1);
+SUPPORTED_IMPORTATTRIBUTES = supported(18, 20, true) || supported(20, 10);
+SUPPORTED_REGEXPESCAPE = SUPPORTED_FLOAT16ARRAY = supported(24);

package/lib/asset.d.ts

@@ -36,6 +36,7 @@ export interface IFileThread<T extends ExternalAsset = ExternalAsset> extends IA
     getObject<U extends FileCommand<T>>(data?: PlainObject): U;
     get host(): IFileManager<T>;
     get queuedTasks(): FunctionType<void>[];
+    get localUri(): string | undefined;
 }
 
 export interface FileThreadConstructor<T extends ExternalAsset = ExternalAsset> {

package/lib/compat-v4.d.ts

@@ -0,0 +1,121 @@
+import type { CloudConstructor, FileManagerConstructor, ICloud, IFileManager, IHost, IModule, ModuleConstructor, WatchConstructor } from './index';
+
+import type { CloneObjectOptions } from '../index.d';
+import type { ExternalAsset } from './asset';
+import type { CacheOptions } from './core';
+import type { QueryResult } from './db';
+import type { ITransformSeries, OutV3, TransformSeriesConstructor } from './document';
+import type { IHttpMemoryCache } from './filemanager';
+import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from './http';
+import type { ParseFunctionOptions } from './module';
+import type { LogFailOptions, LogType, LogValue } from './logger';
+import type { HostConfig, OpenOptions, ProxySettings } from './request';
+import type { DbCoerceSettings, DnsLookupSettings, HttpMemorySettings, HttpSettings } from './settings';
+
+import type { OutgoingHttpHeaders } from 'http';
+import type { LookupFunction } from 'net';
+import type { Readable, Writable } from 'stream';
+
+type CpuUsage = NodeJS.CpuUsage;
+
+export interface GetFunctionsOptions extends ParseFunctionOptions {
+    outFailed?: string[];
+}
+
+export interface IModuleLibV4 {
+    isString(value: unknown): value is string;
+    isObject<T = object>(value: unknown): value is T;
+    isPlainObject<T = PlainObject>(value: unknown): value is T;
+    escapePattern(value: unknown, lookBehind?: boolean): string;
+    generateUUID(format?: string, dictionary?: string): string;
+    validateUUID(value: unknown): boolean;
+    cloneObject<T, U = unknown>(data: T, options?: boolean | WeakSet<object> | CloneObjectOptions<U>): T;
+    coerceObject<T = unknown>(data: T, parseString?: FunctionType<unknown, string> | boolean, cache?: boolean): T;
+    asFunction<T = unknown, U = FunctionType<Promise<T> | T>>(value: unknown, sync?: boolean): Null<U>;
+    isFileHTTP(value: string | URL): boolean;
+    isFileUNC(value: string | URL): boolean;
+    isPathUNC(value: string | URL): boolean;
+    toTimeMs(hrtime: HighResolutionTime, format?: boolean): number | string;
+    renameExt(value: string, ext: string, when?: string): string;
+    existsSafe(value: string, isFile?: boolean): boolean;
+    readFileSafe(value: string, encoding: BufferEncoding | "buffer", cache?: boolean): Null<Bufferable>;
+    getFunctions<T extends FunctionType>(values: unknown[], absolute?: boolean | GetFunctionsOptions, sync?: boolean, outFailed?: string[]): T[];
+    formatSize(value: number | string, options?: PlainObject): number | string;
+    hasSameStat(src: string, dest: string, keepEmpty?: boolean): boolean;
+    hasSize(value: string, keepEmpty?: boolean): boolean;
+    getSize(value: string, diskUsed?: boolean): number;
+    byteLength(value: Bufferable, encoding?: BufferEncoding): number;
+    cleanupStream(target: Readable | Writable, pathname?: string): void;
+    allSettled<U>(values: readonly (U | PromiseLike<U>)[], rejected?: LogValue, options?: LogFailOptions | LogType): Promise<PromiseSettledResult<U>[]>;
+}
+
+export interface IModuleCompatV4<T extends IHost = IHost> extends IModule<T> {
+    set startCPU(value);
+    get startCPU(): Null<CpuUsage>;
+}
+
+export interface ModuleCompatV4Constructor extends ModuleConstructor, IModuleLibV4 {
+    readonly prototype: IModuleCompatV4;
+    new(...args: unknown[]): IModuleCompatV4;
+}
+
+export interface IFileManagerCompatV4<T extends ExternalAsset = ExternalAsset> extends IFileManager<T> {
+    archiving: boolean;
+    cacheHttpRequest: boolean | FirstOf<string>;
+    cacheHttpRequestBuffer: IHttpMemoryCache<T>;
+    fetchTimeout: number;
+    httpProxy: Null<ProxySettings>;
+    acceptEncoding: boolean;
+    keepAliveTimeout: number;
+    addDns(hostname: string, address: string, family?: number | string): void;
+    lookupDns(hostname: string): LookupFunction;
+    getHttpProxy(uri: string, localhost?: boolean): Null<ProxySettings>;
+    getHttpHeaders(uri: string): Undef<OutgoingHttpHeaders>;
+    createHttpRequest(uri: string | URL, options?: OpenOptions): HostConfig;
+    getHttpClient(uri: string | URL, options: OpenOptions): HttpRequestClient;
+    set httpVersion(value);
+    get httpVersion(): Null<HttpProtocolVersion>;
+    set ipVersion(value);
+    get ipVersion(): InternetProtocolVersion;
+}
+
+export interface FileManagerCompatV4Constructor<T extends ExternalAsset = ExternalAsset> extends FileManagerConstructor<T> {
+    fromHttpStatusCode(value: number | string): string;
+    resetHttpHost(version?: HttpProtocolVersion): void;
+    defineHttpBuffer(options: HttpMemorySettings): void;
+    defineHttpSettings(options: HttpSettings): void;
+    defineHttpAgent(options: HttpAgentSettings): void;
+    defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
+    clearDnsLookup(): void;
+    getAria2Path(): string;
+    clearHttpBuffer(percent?: number, limit?: number): void;
+    readonly prototype: IFileManagerCompatV4<T>;
+    new(...args: unknown[]): IFileManagerCompatV4<T>;
+}
+
+export interface ICloudCompatV4<T extends IHost = IHost> extends ICloud<T> {
+    getDatabaseResult(service: string, credential: unknown, queryString: string, options?: CacheOptions | boolean | string): Undef<QueryResult>;
+    setDatabaseResult(service: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions | string): QueryResult;
+    hasDatabaseCache(service: string, sessionKey?: string): boolean;
+    hasDatabaseCoerce(service: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
+}
+
+export interface CloudCompatV4Constructor extends CloudConstructor {
+    readonly prototype: ICloudCompatV4;
+    new(...args: unknown[]): ICloudCompatV4;
+}
+
+export interface WatchCompatV4Constructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset> extends WatchConstructor<T, U> {
+    readCACert(value: string, cache?: boolean): string;
+    readTLSKey(value: string, cache?: boolean): string;
+    readTLSCert(value: string, cache?: boolean): string;
+    isCert(value: string): boolean;
+    parseExpires(value: number | string, start?: number): number;
+}
+
+export interface ITransformSeriesCompatV4<T = AnyObject, U = T> extends ITransformSeries<T, U>, PropertyAction<OutV3, "out"> {}
+
+export interface TransformSeriesCompatV4Constructor extends TransformSeriesConstructor {
+    readonly prototype: ITransformSeriesCompatV4;
+    new(...args: unknown[]): ITransformSeriesCompatV4;
+}

package/lib/core.d.ts

@@ -87,7 +87,7 @@ export interface ClientDbConstructor<T extends IHost = IHost, U extends ClientMo
 }
 
 export interface IWorkerGroup extends WorkerBase {
-    [Symbol.iterator](): IteratorObject<IWorkerChannel, BuiltinIteratorReturn>;
+    [Symbol.iterator](): IterableIterator<IWorkerChannel>;
     add(name: string, item: IWorkerChannel, priority?: number): this;
     get(name: string, force?: boolean | number): IWorkerChannel | undefined;
     delete(name: string | IWorkerChannel): boolean;
@@ -111,7 +111,7 @@ export interface WorkerGroupConstructor {
 }
 
 export interface IWorkerChannel<T = unknown> extends EventEmitter, Iterable<Worker>, WorkerInfo {
-    [Symbol.iterator](): IteratorObject<Worker, BuiltinIteratorReturn>;
+    [Symbol.iterator](): IterableIterator<Worker>;
     sendObject(data: unknown, transferList?: Transferable[], callback?: WorkerChannelResponse<T>, ...returnArgs: unknown[]): Worker;
     sendBuffer(data: Buffer | SharedArrayBuffer, callback: WorkerChannelResponse<T>, ...returnArgs: unknown[]): Worker | null;
     sendBuffer(data: Buffer | SharedArrayBuffer, shared?: boolean, callback?: WorkerChannelResponse<T>, ...returnArgs: unknown[]): Worker | null;

package/lib/index.d.ts

@@ -5,7 +5,7 @@ import type { ChecksumValue, DataSource, DbDataSource, IncrementalMatch, LogStat
 import type { ExternalAsset, FileCommand, FileData, IFileThread, OutputFinalize } from './asset';
 import type { BucketWebsiteOptions, CloudDatabase, CloudFeatures, CloudFunctions, CloudLogMessageType, CloudService, CloudStorage, CloudStorageDownload, CloudStorageUpload, CopyObjectOptions, DeleteObjectsOptions, UploadAssetOptions } from './cloud';
 import type { BrotliCompressLevel, BufferResult, CompressFormat, CompressLevel, ReadableOptions, TryFileCompressor } from './compress';
-import type { ClientDbConstructor, HostInitConfig, IAbortComponent, IClient, IClientDb, IPermission, JoinQueueOptions, PermissionReadWrite, ResumeThreadOptions, ThreadCountStat } from './core';
+import type { ClientConstructor, ClientDbConstructor, HostInitConfig, IAbortComponent, IClient, IClientDb, IPermission, JoinQueueOptions, PermissionReadWrite, ResumeThreadOptions, ThreadCountStat } from './core';
 import type { BatchQueryResult, DB_TYPE, ErrorQueryCallback, ExecuteBatchQueryOptions, ExecuteQueryOptions, HandleFailOptions, ProcessRowsOptions, QueryResult, SQL_COMMAND } from './db';
 import type { AsSourceFileOptions, ConfigOrTransformer, CustomizeOptions as CustomizeDocument, GenerateLintTableOptions, LintMessage, PluginConfig, SourceCode, SourceInput, SourceMap, SourceMapOptions, TransformAction, TransformCallback, TransformOutput, TransformResult, UpdateGradleOptions } from './document';
 import type { AssetContentOptions, CheckHashOptions, ChecksumOptions, DeleteFileAddendum, FileOutput, FinalizeResult, FindAssetOptions, IHttpDiskCache, IHttpMemoryCache, ImageMimeMap, InstallData, PostFinalizeCallback, ReplaceOptions } from './filemanager';
@@ -14,7 +14,7 @@ import type { CommandData, CropData, QualityData, ResizeData, RotateData, Transf
 import type { ExecCommand, LOG_TYPE, LogArguments, LogComponent, LogDate, LogFailOptions, LogMessageOptions, LogOptions, LogProcessOptions, LogState, LogTime, LogType, LogValue, STATUS_TYPE, StatusType } from './logger';
 import type { AsHashOptions, CheckSemVerOptions, CopyDirOptions, CopyDirResult, CopyFileOptions, CreateDirOptions, DeleteFileOptions, DirectoryActionType, FileActionType, FileTypeFormat, GlobDirOptions, MoveFileOptions, PackageVersionOptions, ParseFunctionOptions, PermissionOptions, PermissionType, ProtocolType, ReadBufferOptions, ReadFileCallback, ReadFileOptions, ReadHashOptions, ReadTextOptions, RemoveDirOptions, TempDirOptions, WriteFileOptions } from './module';
 import type { ErrorCode, HighResolutionTime, RequestData, Settings } from './node';
-import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, FormDataPart, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostOptions, ProxySettings, PutOptions, RcloneOptions, ReadExpectType, RequestInit, StatusOnCallback } from './request';
+import type { ApplyOptions, Aria2Options, BufferFormat, DataEncodedResult, DataObjectResult, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostFileParts as PostFileParts, PostOptions, ProxySettings, PutOptions, RcloneOptions, ReadExpectType, RequestInit, StatusOnCallback } from './request';
 import type { ClientModule, CloudAuthSettings, CloudModule, CloudServiceOptions, CompressModule, CompressSettings, DbCoerceSettings, DbModule, DbSourceOptions, DnsLookupSettings, DocumentComponent, DocumentComponentOption, DocumentModule, HandlerSettings, HttpConnectSettings, HttpMemorySettings, ImageModule, LoggerFormat, LoggerFormatSettings, PoolConfig, RequestModule, RequestSettings, TaskModule, WatchModule } from './settings';
 import type { Command, SpawnResult } from './task';
 import type { IFileGroup, ModifiedPostFinalizeListener, SecureOptions, WatchInitResult } from './watch';
@@ -92,7 +92,7 @@ declare namespace functions {
         new(module?: U): ICompress<T, U>;
     }
 
-    interface IImage<T extends IHost = IHost, U extends ImageModule = ImageModule> extends IClient<T, U> {
+    interface IImage<T extends IHost = IHost, U extends ImageModule = ImageModule, V extends ExternalAsset = ExternalAsset> extends IClient<T, U> {
         resizeData?: ResizeData | null;
         cropData?: CropData | null;
         rotateData?: RotateData | null;
@@ -110,13 +110,13 @@ declare namespace functions {
         parseQuality(value: string): QualityData | null;
         parseOpacity(value: string): number;
         parseWorker(command: string | CommandData, outputType?: string): CommandData | null;
-        using?<V extends ExternalAsset>(data: IFileThread<V>, command: string): Promise<unknown>;
+        using?(data: IFileThread<V>, command: string): Promise<unknown>;
         get outputAs(): string;
         set host(value);
         get host(): T | null;
     }
 
-    interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ModuleConstructor, IWorkerConstructor {
+    interface ImageConstructor<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ClientConstructor, IWorkerConstructor {
         readonly MIME_JPEG: string;
         readonly MIME_PNG: string;
         readonly MIME_WEBP: string;
@@ -132,19 +132,19 @@ declare namespace functions {
         new(module?: U, ...args: unknown[]): IImage<T, U>;
     }
 
-    interface ITask<T extends IHost = IHost, U extends TaskModule = TaskModule> extends IClient<T, U> {
-        using?<V extends ExternalAsset>(data: IFileThread<V>): Promise<unknown>;
+    interface ITask<T extends IHost = IHost, U extends TaskModule = TaskModule, V extends ExternalAsset = ExternalAsset> extends IClient<T, U> {
+        using?(data: IFileThread<V>): Promise<unknown>;
         collect?(items: unknown[], preceding?: boolean): Promise<SpawnResult>[];
         map?(tasks: Command[]): Promise<SpawnResult | void>[];
         series?(tasks: Command[]): Promise<unknown>;
         parallel?(tasks: Command[]): Promise<unknown>;
         spawn?(task: PlainObject, callback: (result?: SpawnResult) => void): void;
-        execute?<V extends IFileManager<W>, W extends ExternalAsset>(manager: V, task: PlainObject, callback: (value?: unknown) => void): void;
+        execute?<W extends IFileManager<X>, X extends ExternalAsset>(manager: W, task: PlainObject, callback: (value?: unknown) => void): void;
         set host(value);
         get host(): T | null;
     }
 
-    interface TaskConstructor<T extends IHost = IHost, U extends TaskModule = TaskModule> extends ModuleConstructor {
+    interface TaskConstructor<T extends IHost = IHost, U extends TaskModule = TaskModule> extends ClientConstructor {
         finalize<V extends ExternalAsset>(this: T, instance: ITask<T, U>, assets: V[]): Promise<unknown>;
         readonly prototype: ITask<T, U>;
         new(module?: U, ...args: unknown[]): ITask<T, U>;
@@ -159,8 +159,8 @@ declare namespace functions {
         executeQuery(item: V, sessionKey: string): Promise<QueryResult>;
         executeQuery(item: V, options?: ExecuteQueryOptions | string): Promise<QueryResult>;
         executeBatchQuery(batch: V[], callback: ErrorQueryCallback, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
-        executeBatchQuery(batch: V[], sessionKey: string, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
-        executeBatchQuery(batch: V[], options?: ExecuteBatchQueryOptions | string, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
+        executeBatchQuery(batch: V[], sessionKey: string | undefined, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
+        executeBatchQuery(batch: V[], options?: ExecuteBatchQueryOptions, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
         processRows(batch: V[], tasks: Promise<QueryResult | null>[], parallel: boolean): Promise<BatchQueryResult>;
         processRows(batch: V[], tasks: Promise<QueryResult | null>[], options?: ProcessRowsOptions | boolean, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
         handleFail(err: unknown, item: V, options?: HandleFailOptions): boolean;
@@ -327,12 +327,14 @@ declare namespace functions {
         get host(): T | null;
     }
 
-    interface DocumentConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends ModuleConstructor {
+    interface DocumentConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ClientModule = DocumentModule, W extends DocumentComponent = DocumentComponent, X extends DocumentComponentOption = DocumentComponentOption, Y extends ICloud = ICloud<T>> extends ClientConstructor {
         finalize(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
         createSourceMap(code: string, remove: boolean): SourceMap;
         createSourceMap(code: string, uri?: string, remove?: boolean): SourceMap;
         writeSourceMap(uri: string, data: SourceCode, options?: SourceMapOptions): string | undefined;
+        /** @deprecated */
         updateGradle(source: string, namespaces: string[], value: string, upgrade: boolean): string;
+        /** @deprecated */
         updateGradle(source: string, namespaces: string[], value: string, options?: UpdateGradleOptions): string;
         generateLintTable(messages: LintMessage[], options: GenerateLintTableOptions): LogComponent[];
         cleanup?(this: T, instance: IDocument<T, U, V, W, X, Y>): Promise<unknown>;
@@ -366,7 +368,7 @@ declare namespace functions {
         get host(): T | null;
     }
 
-    interface WatchConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionType<unknown, any> = ModifiedPostFinalizeListener<U>> extends ModuleConstructor {
+    interface WatchConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends WatchModule = WatchModule, W extends FunctionType<unknown, any> = ModifiedPostFinalizeListener<U>> extends ClientConstructor {
         createServer(port: number, active: boolean): ws.Server | null;
         createServer(port: number, secure?: SecureOptions | null, active?: boolean): ws.Server | null;
         shutdown(): void;
@@ -401,6 +403,7 @@ declare namespace functions {
         rclone(uri: string | URL, pathname: string | URL): Promise<string[]>;
         rclone(uri: string | URL, options?: RcloneOptions): Promise<string[]>;
         json(uri: string | URL, options?: OpenOptions): Promise<object | null>;
+        blob(uri: string | URL, options?: OpenOptions): Promise<Blob | null>;
         pipe(uri: string | URL, to: Writable, options?: OpenOptions): Promise<null>;
         opts<V extends OpenOptions>(url: string | URL, options?: V): HostConfig & V;
         open(uri: string | URL, options: OpenOptions): HttpRequestClient;
@@ -409,10 +412,10 @@ declare namespace functions {
         put<V extends PutOptions>(uri: string | URL, data: unknown, options: V): Promise<DataObjectResult<V>>;
         put<V extends PutOptions>(uri: string | URL, data: unknown, contentType?: string | V, options?: V): Promise<DataObjectResult<V>>;
         post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, data: unknown, contentType: string): Promise<DataObjectResult<V>>;
-        post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, parts: FormDataPart[]): Promise<DataObjectResult<V>>;
-        post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, form: AnyObject, parts: FormDataPart[]): Promise<DataObjectResult<V>>;
+        post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, parts: PostFileParts): Promise<DataObjectResult<V>>;
+        post<V extends { format: undefined; encoding: undefined }>(uri: string | URL, form: AnyObject, parts: PostFileParts): Promise<DataObjectResult<V>>;
         post<V extends PostOptions>(uri: string | URL, data: unknown, options: V): Promise<DataObjectResult<V>>;
-        post<V extends PostOptions>(uri: string | URL, data: unknown, contentType?: string | FormDataPart[] | V, options?: V): Promise<DataObjectResult<V>>;
+        post<V extends PostOptions>(uri: string | URL, data: unknown, contentType?: string | PostFileParts | V, options?: V): Promise<DataObjectResult<V>>;
         get<V extends OpenOptions & { encoding: BufferEncoding }>(uri: string | URL, options: V): Promise<string>;
         get<V extends BufferFormat>(uri: string | URL, format: V): Promise<object | null>;
         get<V extends OpenOptions, W extends V | BufferFormat>(uri: string | URL, options?: W): Promise<W extends BufferFormat ? object | null : DataEncodedResult<V>>;
@@ -445,7 +448,7 @@ declare namespace functions {
     interface IFileManager<T extends ExternalAsset = ExternalAsset> extends IHost, Set<string> {
         processTimeout: number;
         Request: IRequest;
-        Document: InstallData<IDocument<IFileManager<T>, T>, DocumentConstructor<IFileManager<T>, T>>[];
+        Document: InstallData<IDocument<this, T>, DocumentConstructor<this, T>>[];
         Task: InstallData<ITask, TaskConstructor>[];
         Image: ImageMimeMap | null;
         Cloud: ICloud | null;
@@ -466,8 +469,8 @@ declare namespace functions {
         readonly emptyDir: Set<string>;
         readonly cacheToDisk: IHttpDiskCache<T>;
         readonly cacheToMemory: IHttpMemoryCache<T>;
-        install(name: "document", handler: string, module?: DocumentModule, ...args: unknown[]): IDocument<IFileManager<T>, T> | undefined;
-        install(name: "document", target: DocumentConstructor<IFileManager<T>, T>, module?: DocumentModule, ...args: unknown[]): IDocument<IFileManager<T>, T> | undefined;
+        install(name: "document", handler: string, module?: DocumentModule, ...args: unknown[]): IDocument<this, T> | undefined;
+        install(name: "document", target: DocumentConstructor<this, T>, module?: DocumentModule, ...args: unknown[]): IDocument<this, T> | undefined;
         install(name: "task", handler: string, module?: TaskModule, ...args: unknown[]): ITask | undefined;
         install(name: "task", target: TaskConstructor, module?: TaskModule, ...args: unknown[]): ITask | undefined;
         install(name: "cloud", handler: string, module?: CloudModule, ...args: unknown[]): ICloud | undefined;
@@ -476,7 +479,7 @@ declare namespace functions {
         install(name: "image", target: ImageConstructor, module?: ImageModule, ...args: unknown[]): IImage | undefined;
         install(name: "image", targets: Map<string, ImageConstructor>, module?: ImageModule): void;
         install(name: "watch", handler: string, module?: WatchModule, ...args: unknown[]): WatchInstance<T> | undefined;
-        install(name: "watch", target: WatchConstructor<IFileManager<T>, T>, module?: WatchModule, ...args: unknown[]): WatchInstance<T> | undefined;
+        install(name: "watch", target: WatchConstructor<this, T>, module?: WatchModule, ...args: unknown[]): WatchInstance<T> | undefined;
         install(name: "watch", module: WatchModule): WatchInstance<T> | undefined;
         install(name: "compress", module?: CompressModule): ICompress | undefined;
         install<U extends IModule>(name: string, ...args: unknown[]): U | undefined;
@@ -512,7 +515,7 @@ declare namespace functions {
         addDownload(value: number | Bufferable, type?: number | BufferEncoding, encoding?: BufferEncoding): number;
         getDownload(type?: number): [number, number];
         checkHash(checksum: ChecksumValue, options: CheckHashOptions): boolean;
-        checkHash(checksum: ChecksumValue, data: Bufferable | null, uri: string | URL | undefined): boolean;
+        checkHash(checksum: ChecksumValue, data: Optional<Bufferable>, uri: string | URL | undefined): boolean;
         checkHash(checksum: ChecksumValue, data: Bufferable, options?: CheckHashOptions): boolean;
         transformAsset(data: IFileThread<T>, parent?: T, override?: boolean): Promise<boolean>;
         addCopy(data: FileCommand<T>, saveAs?: string, replace?: boolean): string | undefined;
@@ -884,11 +887,17 @@ declare namespace functions {
         readBuffer(value: string | URL, cache?: boolean | ReadBufferOptions): Buffer | null;
         resolveMime(data: FileTypeFormat): Promise<FileTypeResult | undefined>;
         lookupMime(value: string, extension?: boolean): string;
-        initCpuUsage(instance?: IModule): CpuUsage;
-        getCpuUsage(start: CpuUsage, format: true): string;
-        getCpuUsage(start: CpuUsage, format?: boolean): number;
+        /** @deprecated class */
+        initCpuUsage(instance?: IModule, thread?: boolean): CpuUsage;
+        /** @deprecated private */
+        getCpuUsage(start: CpuUsage, format: true, thread?: boolean): string;
+        /** @deprecated private */
+        getCpuUsage(start: CpuUsage, format?: boolean, thread?: boolean): number;
+        /** @deprecated private */
         getMemUsage(format: true | "%" | Unit, free?: boolean): string;
+        /** @deprecated private */
         getMemUsage(format?: boolean, free?: boolean): number;
+        /** @deprecated private */
         formatCpuMem(start: CpuUsage, all?: boolean): string;
         getPackageVersion(name: string | [string, string], options?: PackageVersionOptions): string;
         checkSemVer(name: string | [string, string], options: CheckSemVerOptions): boolean;
@@ -910,4 +919,4 @@ declare namespace functions {
     }
 }
 
-export = functions;
+export = functions;

package/lib/module.d.ts

@@ -57,6 +57,7 @@ export interface CopyFileOptions extends FileSystemOptions {
     overwrite?: boolean;
     createDir?: boolean;
     outSrc?: string;
+    mode?: number;
 }
 
 export interface RemoveDirOptions extends FileSystemOptions {

package/lib/object.d.ts

@@ -34,4 +34,8 @@ interface MinMax<T = number> {
 }
 
 /** @deprecated lib/node **/
-type HighResolutionTime = bigint | [number, number];
+type HighResolutionTime = bigint | [number, number];
+
+interface RegExpConstructor {
+    escape(value: string): string;
+}

package/lib/request.d.ts

@@ -166,6 +166,7 @@ export interface OpenOptions extends KeepAliveAction, SilentAction, EncodingActi
     expectContinue?: boolean;
     expectTimeout?: number;
     maxBufferSize?: number | string;
+    maxConcurrentStreams?: number;
     format?: BufferFormat | { out?: BufferFormat; parser?: PlainObject };
     headers?: OutgoingHttpHeaders | Headers;
     signal?: AbortSignal;
@@ -178,6 +179,7 @@ export interface OpenOptions extends KeepAliveAction, SilentAction, EncodingActi
     progressId?: number | string;
     outFormat?: { out: BufferFormat; parser?: PlainObject };
     outFilename?: string | null;
+    outContentType?: string;
     outHeaders?: IncomingHttpHeaders | null;
     outStream?: Writable | null;
     outAbort?: AbortController | null;
@@ -189,7 +191,7 @@ export interface PutOptions extends OpenOptions {
 }
 
 export interface PostOptions extends PutOptions {
-    formData?: FormDataPart | FormDataPart[];
+    formData?: FormDataPart | File | PostFileParts;
 }
 
 export interface FormDataPart {
@@ -271,6 +273,7 @@ export interface AltSvcData {
 export type HttpMethod = "GET" | "POST" | "PUT" | "HEAD" | "DELETE";
 export type BufferFormat = "json" | "yaml" | "json5" | "xml" | "toml";
 export type ReadExpectType = "always" | "string" | "none";
+export type PostFileParts = (File | FormDataPart)[];
 export type DataEncodedResult<T extends { encoding?: BufferEncoding }> = T extends { encoding: BufferEncoding } ? string : Bufferable | null;
 export type DataObjectResult<T extends { format?: unknown; encoding?: BufferEncoding }> = T extends { format: string | PlainObject } ? object | null : DataEncodedResult<T>;
 export type StatusOnCallback = (code: number, headers: IncomingHttpHeaders, url?: URL) => boolean | void;

package/lib/settings.d.ts

@@ -311,6 +311,7 @@ export interface ImageSettings extends PlainObject {
 export interface RequestModule<T = RequestSettings> extends HandlerSettings<T>, HttpHostSettings {
     timeout?: number | string;
     read_timeout?: number | string;
+    max_concurrent_streams?: number | string;
     agent?: {
         keep_alive?: boolean;
         keep_alive_interval?: number | string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/types",
-  "version": "0.13.7",
+  "version": "0.13.9",
   "description": "Type definitions for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",