@rspack/core 2.0.1 → 2.0.2

package/compiled/watchpack/package.json

@@ -1 +1,8 @@
-{"name":"watchpack","author":"Tobias Koppers @sokra","version":"2.4.4","license":"MIT","types":"index.d.ts","type":"commonjs"}
+{
+  "name": "watchpack",
+  "author": "Tobias Koppers @sokra",
+  "version": "2.5.1",
+  "license": "MIT",
+  "types": "index.d.ts",
+  "type": "commonjs"
+}

package/compiled/watchpack/types/DirectoryWatcher.d.ts

@@ -0,0 +1,333 @@
+export = DirectoryWatcher;
+/** @typedef {Set<string>} InitialScanRemoved */
+/**
+ * @typedef {object} WatchpackEvents
+ * @property {(target: string, mtime: string, type: EventType, initial: boolean) => void} change change event
+ * @property {() => void} closed closed event
+ */
+/**
+ * @typedef {object} DirectoryWatcherOptions
+ * @property {boolean=} followSymlinks true when need to resolve symlinks and watch symlink and real file, otherwise false
+ * @property {IgnoredFunction=} ignored ignore some files from watching (glob pattern or regexp)
+ * @property {number | boolean=} poll true when need to enable polling mode for watching, otherwise false
+ */
+/**
+ * @extends {EventEmitter<{ [K in keyof WatchpackEvents]: Parameters<WatchpackEvents[K]> }>}
+ */
+declare class DirectoryWatcher extends EventEmitter<{
+	/**
+	 * change event
+	 */
+	change: [
+		target: string,
+		mtime: string,
+		type: import("./index").EventType,
+		initial: boolean,
+	];
+	/**
+	 * closed event
+	 */
+	closed: [];
+}> {
+	/**
+	 * @param {WatcherManager} watcherManager a watcher manager
+	 * @param {string} directoryPath directory path
+	 * @param {DirectoryWatcherOptions=} options options
+	 */
+	constructor(
+		watcherManager: WatcherManager,
+		directoryPath: string,
+		options?: DirectoryWatcherOptions | undefined,
+	);
+	watcherManager: import("./getWatcherManager").WatcherManager;
+	options: DirectoryWatcherOptions;
+	path: string;
+	/** @type {Map<string, Entry>} */
+	files: Map<string, Entry>;
+	/** @type {Map<string, number>} */
+	filesWithoutCase: Map<string, number>;
+	/** @type {Map<string, Watcher<DirectoryWatcherEvents> | boolean>} */
+	directories: Map<string, Watcher<DirectoryWatcherEvents> | boolean>;
+	lastWatchEvent: number;
+	initialScan: boolean;
+	ignored: import("./index").IgnoredFunction;
+	nestedWatching: boolean;
+	/** @type {number | false} */
+	polledWatching: number | false;
+	/** @type {undefined | NodeJS.Timeout} */
+	timeout: undefined | NodeJS.Timeout;
+	/** @type {null | InitialScanRemoved} */
+	initialScanRemoved: null | InitialScanRemoved;
+	/** @type {undefined | number} */
+	initialScanFinished: undefined | number;
+	/** @type {Map<string, Set<Watcher<DirectoryWatcherEvents> | Watcher<FileWatcherEvents>>>} */
+	watchers: Map<
+		string,
+		Set<Watcher<DirectoryWatcherEvents> | Watcher<FileWatcherEvents>>
+	>;
+	/** @type {Watcher<FileWatcherEvents> | null} */
+	parentWatcher: Watcher<FileWatcherEvents> | null;
+	refs: number;
+	/** @type {Map<string, boolean>} */
+	_activeEvents: Map<string, boolean>;
+	closed: boolean;
+	scanning: boolean;
+	scanAgain: boolean;
+	scanAgainInitial: boolean;
+	createWatcher(): void;
+	watcher: watchEventSource.Watcher | null | undefined;
+	/**
+	 * @template {(watcher: Watcher<EventMap>) => void} T
+	 * @param {string} path path
+	 * @param {T} fn function
+	 */
+	forEachWatcher<T extends (watcher: Watcher<EventMap>) => void>(
+		path: string,
+		fn: T,
+	): void;
+	/**
+	 * @param {string} itemPath an item path
+	 * @param {boolean} initial true when initial, otherwise false
+	 * @param {EventType} type even type
+	 */
+	setMissing(itemPath: string, initial: boolean, type: EventType): void;
+	/**
+	 * @param {string} target a target to set file time
+	 * @param {number} mtime mtime
+	 * @param {boolean} initial true when initial, otherwise false
+	 * @param {boolean} ignoreWhenEqual true to ignore when equal, otherwise false
+	 * @param {EventType} type type
+	 */
+	setFileTime(
+		target: string,
+		mtime: number,
+		initial: boolean,
+		ignoreWhenEqual: boolean,
+		type: EventType,
+	): void;
+	/**
+	 * @param {string} directoryPath directory path
+	 * @param {number} birthtime birthtime
+	 * @param {boolean} initial true when initial, otherwise false
+	 * @param {EventType} type even type
+	 */
+	setDirectory(
+		directoryPath: string,
+		birthtime: number,
+		initial: boolean,
+		type: EventType,
+	): void;
+	/**
+	 * @param {string} directoryPath directory path
+	 */
+	createNestedWatcher(directoryPath: string): void;
+	/**
+	 * @param {boolean} flag true when nested, otherwise false
+	 */
+	setNestedWatching(flag: boolean): void;
+	/**
+	 * @param {string} target a target to watch
+	 * @param {number=} startTime start time
+	 * @returns {Watcher<DirectoryWatcherEvents> | Watcher<FileWatcherEvents>} watcher
+	 */
+	watch(
+		target: string,
+		startTime?: number | undefined,
+	): Watcher<DirectoryWatcherEvents> | Watcher<FileWatcherEvents>;
+	/**
+	 * @param {EventType} eventType event type
+	 * @param {string=} filename filename
+	 */
+	onWatchEvent(eventType: EventType, filename?: string | undefined): void;
+	/**
+	 * @param {unknown=} err error
+	 */
+	onWatcherError(err?: unknown | undefined): void;
+	/**
+	 * @param {Error | NodeJS.ErrnoException=} err error
+	 */
+	onStatsError(err?: (Error | NodeJS.ErrnoException) | undefined): void;
+	/**
+	 * @param {Error | NodeJS.ErrnoException=} err error
+	 */
+	onScanError(err?: (Error | NodeJS.ErrnoException) | undefined): void;
+	onScanFinished(): void;
+	/**
+	 * @param {string} reason a reason
+	 */
+	onDirectoryRemoved(reason: string): void;
+	watchInParentDirectory(): void;
+	/**
+	 * @param {boolean} initial true when initial, otherwise false
+	 */
+	doScan(initial: boolean): void;
+	/**
+	 * @returns {Record<string, number>} times
+	 */
+	getTimes(): Record<string, number>;
+	/**
+	 * @param {TimeInfoEntries} fileTimestamps file timestamps
+	 * @param {TimeInfoEntries} directoryTimestamps directory timestamps
+	 * @returns {number} safe time
+	 */
+	collectTimeInfoEntries(
+		fileTimestamps: TimeInfoEntries,
+		directoryTimestamps: TimeInfoEntries,
+	): number;
+	close(): void;
+}
+declare namespace DirectoryWatcher {
+	export {
+		EXISTANCE_ONLY_TIME_ENTRY,
+		Watcher,
+		IgnoredFunction,
+		EventType,
+		TimeInfoEntries,
+		Entry,
+		ExistenceOnlyTimeEntry,
+		OnlySafeTimeEntry,
+		EventMap,
+		WatcherManager,
+		EventSourceWatcher,
+		FileWatcherEvents,
+		DirectoryWatcherEvents,
+		InitialScanRemoved,
+		WatchpackEvents,
+		DirectoryWatcherOptions,
+	};
+}
+import { EventEmitter } from "events";
+/**
+ * @typedef {object} FileWatcherEvents
+ * @property {(type: EventType) => void} initial-missing initial missing event
+ * @property {(mtime: number, type: EventType, initial: boolean) => void} change change event
+ * @property {(type: EventType) => void} remove remove event
+ * @property {() => void} closed closed event
+ */
+/**
+ * @typedef {object} DirectoryWatcherEvents
+ * @property {(type: EventType) => void} initial-missing initial missing event
+ * @property {((file: string, mtime: number, type: EventType, initial: boolean) => void)} change change event
+ * @property {(type: EventType) => void} remove remove event
+ * @property {() => void} closed closed event
+ */
+/**
+ * @template {EventMap} T
+ * @extends {EventEmitter<{ [K in keyof T]: Parameters<T[K]> }>}
+ */
+declare class Watcher<T extends EventMap> extends EventEmitter<{
+	[K in keyof T]: Parameters<T[K]>;
+}> {
+	/**
+	 * @param {DirectoryWatcher} directoryWatcher a directory watcher
+	 * @param {string} target a target to watch
+	 * @param {number=} startTime start time
+	 */
+	constructor(
+		directoryWatcher: DirectoryWatcher,
+		target: string,
+		startTime?: number | undefined,
+	);
+	directoryWatcher: DirectoryWatcher;
+	path: string;
+	startTime: number | undefined;
+	/**
+	 * @param {number} mtime mtime
+	 * @param {boolean} initial true when initial, otherwise false
+	 * @returns {boolean} true of start time less than mtile, otherwise false
+	 */
+	checkStartTime(mtime: number, initial: boolean): boolean;
+	close(): void;
+}
+import watchEventSource = require("./watchEventSource");
+/** @typedef {import("./index").IgnoredFunction} IgnoredFunction */
+/** @typedef {import("./index").EventType} EventType */
+/** @typedef {import("./index").TimeInfoEntries} TimeInfoEntries */
+/** @typedef {import("./index").Entry} Entry */
+/** @typedef {import("./index").ExistenceOnlyTimeEntry} ExistenceOnlyTimeEntry */
+/** @typedef {import("./index").OnlySafeTimeEntry} OnlySafeTimeEntry */
+/** @typedef {import("./index").EventMap} EventMap */
+/** @typedef {import("./getWatcherManager").WatcherManager} WatcherManager */
+/** @typedef {import("./watchEventSource").Watcher} EventSourceWatcher */
+/** @type {ExistenceOnlyTimeEntry} */
+declare const EXISTANCE_ONLY_TIME_ENTRY: ExistenceOnlyTimeEntry;
+type IgnoredFunction = import("./index").IgnoredFunction;
+type EventType = import("./index").EventType;
+type TimeInfoEntries = import("./index").TimeInfoEntries;
+type Entry = import("./index").Entry;
+type ExistenceOnlyTimeEntry = import("./index").ExistenceOnlyTimeEntry;
+type OnlySafeTimeEntry = import("./index").OnlySafeTimeEntry;
+type EventMap = import("./index").EventMap;
+type WatcherManager = import("./getWatcherManager").WatcherManager;
+type EventSourceWatcher = import("./watchEventSource").Watcher;
+type FileWatcherEvents = {
+	/**
+	 * initial missing event
+	 */
+	"initial-missing": (type: EventType) => void;
+	/**
+	 * change event
+	 */
+	change: (mtime: number, type: EventType, initial: boolean) => void;
+	/**
+	 * remove event
+	 */
+	remove: (type: EventType) => void;
+	/**
+	 * closed event
+	 */
+	closed: () => void;
+};
+type DirectoryWatcherEvents = {
+	/**
+	 * initial missing event
+	 */
+	"initial-missing": (type: EventType) => void;
+	/**
+	 * change event
+	 */
+	change: (
+		file: string,
+		mtime: number,
+		type: EventType,
+		initial: boolean,
+	) => void;
+	/**
+	 * remove event
+	 */
+	remove: (type: EventType) => void;
+	/**
+	 * closed event
+	 */
+	closed: () => void;
+};
+type InitialScanRemoved = Set<string>;
+type WatchpackEvents = {
+	/**
+	 * change event
+	 */
+	change: (
+		target: string,
+		mtime: string,
+		type: EventType,
+		initial: boolean,
+	) => void;
+	/**
+	 * closed event
+	 */
+	closed: () => void;
+};
+type DirectoryWatcherOptions = {
+	/**
+	 * true when need to resolve symlinks and watch symlink and real file, otherwise false
+	 */
+	followSymlinks?: boolean | undefined;
+	/**
+	 * ignore some files from watching (glob pattern or regexp)
+	 */
+	ignored?: IgnoredFunction | undefined;
+	/**
+	 * true when need to enable polling mode for watching, otherwise false
+	 */
+	poll?: (number | boolean) | undefined;
+};

package/compiled/watchpack/types/LinkResolver.d.ts

@@ -0,0 +1,10 @@
+export = LinkResolver;
+declare class LinkResolver {
+	/** @type {Map<string, readonly string[]>} */
+	cache: Map<string, readonly string[]>;
+	/**
+	 * @param {string} file path to file or directory
+	 * @returns {readonly string[]} array of file and all symlinks contributed in the resolving process (first item is the resolved file)
+	 */
+	resolve(file: string): readonly string[];
+}

package/compiled/watchpack/types/getWatcherManager.d.ts

@@ -0,0 +1,62 @@
+declare namespace _exports {
+	export {
+		EventMap,
+		DirectoryWatcherOptions,
+		DirectoryWatcherEvents,
+		FileWatcherEvents,
+		Watcher,
+	};
+}
+declare function _exports(options: DirectoryWatcherOptions): WatcherManager;
+declare namespace _exports {
+	export { WatcherManager };
+}
+export = _exports;
+type EventMap = import("./index").EventMap;
+type DirectoryWatcherOptions =
+	import("./DirectoryWatcher").DirectoryWatcherOptions;
+type DirectoryWatcherEvents =
+	import("./DirectoryWatcher").DirectoryWatcherEvents;
+type FileWatcherEvents = import("./DirectoryWatcher").FileWatcherEvents;
+type Watcher<T extends EventMap> = import("./DirectoryWatcher").Watcher<T>;
+/** @typedef {import("./index").EventMap} EventMap */
+/** @typedef {import("./DirectoryWatcher").DirectoryWatcherOptions} DirectoryWatcherOptions */
+/** @typedef {import("./DirectoryWatcher").DirectoryWatcherEvents} DirectoryWatcherEvents */
+/** @typedef {import("./DirectoryWatcher").FileWatcherEvents} FileWatcherEvents */
+/**
+ * @template {EventMap} T
+ * @typedef {import("./DirectoryWatcher").Watcher<T>} Watcher
+ */
+declare class WatcherManager {
+	/**
+	 * @param {DirectoryWatcherOptions=} options options
+	 */
+	constructor(options?: DirectoryWatcherOptions | undefined);
+	options: DirectoryWatcher.DirectoryWatcherOptions;
+	/** @type {Map<string, DirectoryWatcher>} */
+	directoryWatchers: Map<string, DirectoryWatcher>;
+	/**
+	 * @param {string} directory a directory
+	 * @returns {DirectoryWatcher} a directory watcher
+	 */
+	getDirectoryWatcher(directory: string): DirectoryWatcher;
+	/**
+	 * @param {string} file file
+	 * @param {number=} startTime start time
+	 * @returns {Watcher<FileWatcherEvents> | null} watcher or null if file has no directory
+	 */
+	watchFile(
+		file: string,
+		startTime?: number | undefined,
+	): Watcher<FileWatcherEvents> | null;
+	/**
+	 * @param {string} directory directory
+	 * @param {number=} startTime start time
+	 * @returns {Watcher<DirectoryWatcherEvents>} watcher
+	 */
+	watchDirectory(
+		directory: string,
+		startTime?: number | undefined,
+	): Watcher<DirectoryWatcherEvents>;
+}
+import DirectoryWatcher = require("./DirectoryWatcher");

package/compiled/watchpack/types/index.d.ts

@@ -0,0 +1,261 @@
+export = Watchpack;
+/**
+ * @typedef {object} WatchpackEvents
+ * @property {(file: string, mtime: number, type: EventType) => void} change change event
+ * @property {(file: string, type: EventType) => void} remove remove event
+ * @property {(changes: Changes, removals: Removals) => void} aggregated aggregated event
+ */
+/**
+ * @extends {EventEmitter<{ [K in keyof WatchpackEvents]: Parameters<WatchpackEvents[K]> }>}
+ */
+declare class Watchpack extends EventEmitter<{
+	/**
+	 * change event
+	 */
+	change: [file: string, mtime: number, type: EventType];
+	/**
+	 * remove event
+	 */
+	remove: [file: string, type: EventType];
+	/**
+	 * aggregated event
+	 */
+	aggregated: [changes: Changes, removals: Removals];
+}> {
+	/**
+	 * @param {WatchOptions=} options options
+	 */
+	constructor(options?: WatchOptions | undefined);
+	/** @type {WatchOptions} */
+	options: WatchOptions;
+	aggregateTimeout: number;
+	/** @type {NormalizedWatchOptions} */
+	watcherOptions: NormalizedWatchOptions;
+	/** @type {WatcherManager} */
+	watcherManager: WatcherManager;
+	/** @type {Map<string, WatchpackFileWatcher>} */
+	fileWatchers: Map<string, WatchpackFileWatcher>;
+	/** @type {Map<string, WatchpackDirectoryWatcher>} */
+	directoryWatchers: Map<string, WatchpackDirectoryWatcher>;
+	/** @type {Set<string>} */
+	_missing: Set<string>;
+	startTime: number | undefined;
+	paused: boolean;
+	/** @type {Changes} */
+	aggregatedChanges: Changes;
+	/** @type {Removals} */
+	aggregatedRemovals: Removals;
+	/** @type {undefined | NodeJS.Timeout} */
+	aggregateTimer: undefined | NodeJS.Timeout;
+	_onTimeout(): void;
+	/**
+	 * @overload
+	 * @param {Iterable<string>} arg1 files
+	 * @param {Iterable<string>} arg2 directories
+	 * @param {number=} arg3 startTime
+	 * @returns {void}
+	 */
+	watch(
+		arg1: Iterable<string>,
+		arg2: Iterable<string>,
+		arg3?: number | undefined,
+	): void;
+	/**
+	 * @overload
+	 * @param {WatchMethodOptions} arg1 watch options
+	 * @returns {void}
+	 */
+	watch(arg1: WatchMethodOptions): void;
+	close(): void;
+	pause(): void;
+	/**
+	 * @returns {Record<string, number>} times
+	 */
+	getTimes(): Record<string, number>;
+	/**
+	 * @returns {TimeInfoEntries} time info entries
+	 */
+	getTimeInfoEntries(): TimeInfoEntries;
+	/**
+	 * @param {TimeInfoEntries} fileTimestamps file timestamps
+	 * @param {TimeInfoEntries} directoryTimestamps directory timestamps
+	 */
+	collectTimeInfoEntries(
+		fileTimestamps: TimeInfoEntries,
+		directoryTimestamps: TimeInfoEntries,
+	): void;
+	/**
+	 * @returns {Aggregated} aggregated info
+	 */
+	getAggregated(): Aggregated;
+	/**
+	 * @param {string} item item
+	 * @param {number} mtime mtime
+	 * @param {string} file file
+	 * @param {EventType} type type
+	 */
+	_onChange(item: string, mtime: number, file: string, type: EventType): void;
+	/**
+	 * @param {string} item item
+	 * @param {string} file file
+	 * @param {EventType} type type
+	 */
+	_onRemove(item: string, file: string, type: EventType): void;
+}
+declare namespace Watchpack {
+	export {
+		WatcherManager,
+		DirectoryWatcher,
+		DirectoryWatcherEvents,
+		FileWatcherEvents,
+		EventMap,
+		Watcher,
+		IgnoredFunction,
+		Ignored,
+		WatcherOptions,
+		WatchOptions,
+		NormalizedWatchOptions,
+		EventType,
+		Entry,
+		OnlySafeTimeEntry,
+		ExistenceOnlyTimeEntry,
+		TimeInfoEntries,
+		Changes,
+		Removals,
+		Aggregated,
+		WatchMethodOptions,
+		Times,
+		WatchpackEvents,
+	};
+}
+import { EventEmitter } from "events";
+declare class WatchpackFileWatcher {
+	/**
+	 * @param {Watchpack} watchpack watchpack
+	 * @param {Watcher<FileWatcherEvents>} watcher watcher
+	 * @param {string | string[]} files files
+	 */
+	constructor(
+		watchpack: Watchpack,
+		watcher: Watcher<FileWatcherEvents>,
+		files: string | string[],
+	);
+	/** @type {string[]} */
+	files: string[];
+	watcher: import("./DirectoryWatcher").Watcher<
+		import("./DirectoryWatcher").FileWatcherEvents
+	>;
+	/**
+	 * @param {string | string[]} files files
+	 */
+	update(files: string | string[]): void;
+	close(): void;
+}
+declare class WatchpackDirectoryWatcher {
+	/**
+	 * @param {Watchpack} watchpack watchpack
+	 * @param {Watcher<DirectoryWatcherEvents>} watcher watcher
+	 * @param {string} directories directories
+	 */
+	constructor(
+		watchpack: Watchpack,
+		watcher: Watcher<DirectoryWatcherEvents>,
+		directories: string,
+	);
+	/** @type {string[]} */
+	directories: string[];
+	watcher: import("./DirectoryWatcher").Watcher<
+		import("./DirectoryWatcher").DirectoryWatcherEvents
+	>;
+	/**
+	 * @param {string | string[]} directories directories
+	 */
+	update(directories: string | string[]): void;
+	close(): void;
+}
+type WatcherManager = import("./getWatcherManager").WatcherManager;
+type DirectoryWatcher = import("./DirectoryWatcher");
+type DirectoryWatcherEvents =
+	import("./DirectoryWatcher").DirectoryWatcherEvents;
+type FileWatcherEvents = import("./DirectoryWatcher").FileWatcherEvents;
+type EventMap = Record<string, (...args: any[]) => any>;
+type Watcher<T extends EventMap> = import("./DirectoryWatcher").Watcher<T>;
+type IgnoredFunction = (item: string) => boolean;
+type Ignored = string[] | RegExp | string | IgnoredFunction;
+type WatcherOptions = {
+	/**
+	 * true when need to resolve symlinks and watch symlink and real file, otherwise false
+	 */
+	followSymlinks?: boolean | undefined;
+	/**
+	 * ignore some files from watching (glob pattern or regexp)
+	 */
+	ignored?: Ignored | undefined;
+	/**
+	 * true when need to enable polling mode for watching, otherwise false
+	 */
+	poll?: (number | boolean) | undefined;
+};
+type WatchOptions = WatcherOptions & {
+	aggregateTimeout?: number;
+};
+type NormalizedWatchOptions = {
+	/**
+	 * true when need to resolve symlinks and watch symlink and real file, otherwise false
+	 */
+	followSymlinks: boolean;
+	/**
+	 * ignore some files from watching (glob pattern or regexp)
+	 */
+	ignored: IgnoredFunction;
+	/**
+	 * true when need to enable polling mode for watching, otherwise false
+	 */
+	poll?: (number | boolean) | undefined;
+};
+type EventType =
+	| `scan (${string})`
+	| "change"
+	| "rename"
+	| `watch ${string}`
+	| `directory-removed ${string}`;
+type Entry = {
+	safeTime: number;
+	timestamp: number;
+	accuracy: number;
+};
+type OnlySafeTimeEntry = {
+	safeTime: number;
+};
+type ExistenceOnlyTimeEntry = {};
+type TimeInfoEntries = Map<
+	string,
+	Entry | OnlySafeTimeEntry | ExistenceOnlyTimeEntry | null
+>;
+type Changes = Set<string>;
+type Removals = Set<string>;
+type Aggregated = {
+	changes: Changes;
+	removals: Removals;
+};
+type WatchMethodOptions = {
+	files?: Iterable<string>;
+	directories?: Iterable<string>;
+	missing?: Iterable<string>;
+	startTime?: number;
+};
+type Times = Record<string, number>;
+type WatchpackEvents = {
+	/**
+	 * change event
+	 */
+	change: (file: string, mtime: number, type: EventType) => void;
+	/**
+	 * remove event
+	 */
+	remove: (file: string, type: EventType) => void;
+	/**
+	 * aggregated event
+	 */
+	aggregated: (changes: Changes, removals: Removals) => void;
+};

package/compiled/watchpack/types/reducePlan.d.ts

@@ -0,0 +1,34 @@
+declare namespace _exports {
+	export { TreeNode };
+}
+declare function _exports<T>(
+	plan: Map<string, T[] | T>,
+	limit: number,
+): Map<string, Map<T, string>>;
+export = _exports;
+type TreeNode<T> = {
+	/**
+	 * target
+	 */
+	target: string;
+	/**
+	 * parent
+	 */
+	parent: TreeNode<T>;
+	/**
+	 * children
+	 */
+	children: TreeNode<T>[];
+	/**
+	 * number of entries
+	 */
+	entries: number;
+	/**
+	 * true when active, otherwise false
+	 */
+	active: boolean;
+	/**
+	 * value
+	 */
+	value: T[] | T | undefined;
+};