@depup/webpack-sources 3.3.4-depup.0 → 3.6.0-depup.0

package/types/CachedSource.d.ts

@@ -0,0 +1,192 @@
+export = CachedSource;
+/**
+ * @typedef {object} CachedData
+ * @property {boolean=} source source
+ * @property {Buffer} buffer buffer
+ * @property {number=} size size
+ * @property {BufferedMaps} maps maps
+ * @property {(string | Buffer)[]=} hash hash
+ */
+declare class CachedSource extends Source {
+	/**
+	 * @param {Source | (() => Source)} source source
+	 * @param {CachedData=} cachedData cached data
+	 */
+	constructor(
+		source: Source | (() => Source),
+		cachedData?: CachedData | undefined,
+	);
+	/**
+	 * @type {Source | (() => Source)}
+	 */
+	_source: Source | (() => Source);
+	/**
+	 * @type {undefined | string}
+	 */
+	_cachedSource: undefined | string;
+	/**
+	 * @type {boolean | undefined}
+	 */
+	_cachedSourceType: boolean | undefined;
+	/**
+	 * @type {Buffer | undefined}
+	 */
+	_cachedBuffer: Buffer | undefined;
+	/**
+	 * @type {number | undefined}
+	 */
+	_cachedSize: number | undefined;
+	/**
+	 * @type {BufferedMaps | undefined}
+	 */
+	_cachedMaps: BufferedMaps | undefined;
+	/**
+	 * @type {(string | Buffer)[] | undefined}
+	 */
+	_cachedHashUpdate: (string | Buffer)[] | undefined;
+	/**
+	 * The map cache, created on first use: a source nobody asks a map of holds
+	 * none, since V8 allocates a Map's hash table whether or not it is filled.
+	 * @returns {BufferedMaps} map cache
+	 */
+	_getOrCreateCachedMaps(): BufferedMaps;
+	/**
+	 * @returns {CachedData} cached data
+	 */
+	getCachedData(): CachedData;
+	originalLazy(): Source | (() => Source);
+	original(): Source;
+	/**
+	 * @param {BufferEntry} cacheEntry cache entry
+	 * @returns {null | RawSourceMap} raw source map
+	 */
+	_getMapFromCacheEntry(cacheEntry: BufferEntry): null | RawSourceMap;
+	/**
+	 * @returns {undefined | string} cached source
+	 */
+	_getCachedSource(): undefined | string;
+	_cachedBuffers: Buffer<ArrayBufferLike>[] | undefined;
+	/**
+	 * @param {Options} options options
+	 * @param {OnChunk} onChunk called for each chunk of code
+	 * @param {OnSource} onSource called for each source
+	 * @param {OnName} onName called for each name
+	 * @returns {GeneratedSourceInfo} generated source info
+	 */
+	streamChunks(
+		options: Options,
+		onChunk: OnChunk,
+		onSource: OnSource,
+		onName: OnName,
+	): GeneratedSourceInfo;
+}
+declare namespace CachedSource {
+	export {
+		ClearCacheOptions,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceAndMap,
+		SourceValue,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		Options,
+		ScopeBindings,
+		BufferedMap,
+		ScopesReplay,
+		BufferEntry,
+		BufferedMaps,
+		CachedData,
+	};
+}
+import Source = require("./Source");
+type ClearCacheOptions = import("./Source").ClearCacheOptions;
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceAndMap = import("./Source").SourceAndMap;
+type SourceValue = import("./Source").SourceValue;
+type GeneratedSourceInfo =
+	import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./helpers/streamChunks").OnChunk;
+type OnName = import("./helpers/streamChunks").OnName;
+type OnSource = import("./helpers/streamChunks").OnSource;
+type Options = import("./helpers/streamChunks").Options;
+type ScopeBindings = import("./helpers/streamChunks").ScopeBindings;
+type BufferedMap = {
+	/**
+	 * version
+	 */
+	version: number;
+	/**
+	 * sources
+	 */
+	sources: string[];
+	/**
+	 * name
+	 */
+	names: string[];
+	/**
+	 * source root
+	 */
+	sourceRoot?: string | undefined;
+	/**
+	 * sources content
+	 */
+	sourcesContent?: (Buffer | "")[] | undefined;
+	/**
+	 * mappings
+	 */
+	mappings?: Buffer | undefined;
+	/**
+	 * file
+	 */
+	file: string;
+};
+/**
+ * What replaying an entry streamed for a `scopes` request needs besides its
+ * map. The map only keeps the encoded `scopes` field, so `bindings` holds, by
+ * source index, the bindings each source reported. The field also appended
+ * names to the map, and `names` counts the ones the stream itself reported,
+ * so a replay reports the same names a fresh stream would.
+ */
+type ScopesReplay = {
+	/**
+	 * bindings by source index
+	 */
+	bindings: (ScopeBindings | undefined)[];
+	/**
+	 * number of names the stream reported
+	 */
+	names: number;
+};
+type BufferEntry = {
+	map?: null | RawSourceMap;
+	bufferedMap?: null | BufferedMap;
+	scopes?: ScopesReplay;
+};
+type BufferedMaps = Map<string, BufferEntry>;
+type CachedData = {
+	/**
+	 * source
+	 */
+	source?: boolean | undefined;
+	/**
+	 * buffer
+	 */
+	buffer: Buffer;
+	/**
+	 * size
+	 */
+	size?: number | undefined;
+	/**
+	 * maps
+	 */
+	maps: BufferedMaps;
+	/**
+	 * hash
+	 */
+	hash?: (string | Buffer)[] | undefined;
+};

package/types/CompatSource.d.ts

@@ -0,0 +1,87 @@
+export = CompatSource;
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
+/** @typedef {import("./Source").HashLike} HashLike */
+/** @typedef {import("./Source").MapOptions} MapOptions */
+/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./Source").SourceAndMap} SourceAndMap */
+/** @typedef {import("./Source").SourceValue} SourceValue */
+/**
+ * @typedef {object} SourceLike
+ * @property {() => SourceValue} source source
+ * @property {(() => Buffer)=} buffer buffer
+ * @property {(() => Buffer[])=} buffers buffers
+ * @property {(() => number)=} size size
+ * @property {((options?: MapOptions) => RawSourceMap | null)=} map map
+ * @property {((options?: MapOptions) => SourceAndMap)=} sourceAndMap source and map
+ * @property {((hash: HashLike) => void)=} updateHash hash updater
+ * @property {((options?: ClearCacheOptions, visited?: WeakSet<Source>) => void)=} clearCache clear cache
+ */
+declare class CompatSource extends Source {
+	/**
+	 * @param {SourceLike} sourceLike source like
+	 * @returns {Source} source
+	 */
+	static from(sourceLike: SourceLike): Source;
+	/**
+	 * @param {SourceLike} sourceLike source like
+	 */
+	constructor(sourceLike: SourceLike);
+	/**
+	 * @type {SourceLike}
+	 */
+	_sourceLike: SourceLike;
+}
+declare namespace CompatSource {
+	export {
+		ClearCacheOptions,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceAndMap,
+		SourceValue,
+		SourceLike,
+	};
+}
+import Source = require("./Source");
+type ClearCacheOptions = import("./Source").ClearCacheOptions;
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceAndMap = import("./Source").SourceAndMap;
+type SourceValue = import("./Source").SourceValue;
+type SourceLike = {
+	/**
+	 * source
+	 */
+	source: () => SourceValue;
+	/**
+	 * buffer
+	 */
+	buffer?: (() => Buffer) | undefined;
+	/**
+	 * buffers
+	 */
+	buffers?: (() => Buffer[]) | undefined;
+	/**
+	 * size
+	 */
+	size?: (() => number) | undefined;
+	/**
+	 * map
+	 */
+	map?: ((options?: MapOptions) => RawSourceMap | null) | undefined;
+	/**
+	 * source and map
+	 */
+	sourceAndMap?: ((options?: MapOptions) => SourceAndMap) | undefined;
+	/**
+	 * hash updater
+	 */
+	updateHash?: ((hash: HashLike) => void) | undefined;
+	/**
+	 * clear cache
+	 */
+	clearCache?:
+		| ((options?: ClearCacheOptions, visited?: WeakSet<Source>) => void)
+		| undefined;
+};

package/types/ConcatSource.d.ts

@@ -0,0 +1,75 @@
+export = ConcatSource;
+declare class ConcatSource extends Source {
+	/**
+	 * @param {Child[]} args children
+	 */
+	constructor(...args: Child[]);
+	/**
+	 * @type {Child[]}
+	 */
+	_children: Child[];
+	/**
+	 * @type {boolean}
+	 */
+	_isOptimized: boolean;
+	/**
+	 * @returns {Source[]} children
+	 */
+	getChildren(): Source[];
+	/**
+	 * @param {Child} item item
+	 * @returns {void}
+	 */
+	add(item: Child): void;
+	/**
+	 * @param {Child[]} items items
+	 * @returns {void}
+	 */
+	addAllSkipOptimizing(items: Child[]): void;
+	/**
+	 * @param {Options} options options
+	 * @param {OnChunk} onChunk called for each chunk of code
+	 * @param {OnSource} onSource called for each source
+	 * @param {OnName} onName called for each name
+	 * @returns {GeneratedSourceInfo} generated source info
+	 */
+	streamChunks(
+		options: Options,
+		onChunk: OnChunk,
+		onSource: OnSource,
+		onName: OnName,
+	): GeneratedSourceInfo;
+	_optimize(): void;
+}
+declare namespace ConcatSource {
+	export {
+		SourceLike,
+		ClearCacheOptions,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceAndMap,
+		SourceValue,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		Options,
+		Child,
+	};
+}
+import Source = require("./Source");
+type SourceLike = import("./CompatSource").SourceLike;
+type ClearCacheOptions = import("./Source").ClearCacheOptions;
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceAndMap = import("./Source").SourceAndMap;
+type SourceValue = import("./Source").SourceValue;
+type GeneratedSourceInfo =
+	import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./helpers/streamChunks").OnChunk;
+type OnName = import("./helpers/streamChunks").OnName;
+type OnSource = import("./helpers/streamChunks").OnSource;
+type Options = import("./helpers/streamChunks").Options;
+type Child = string | Source | SourceLike;

package/types/OriginalSource.d.ts

@@ -0,0 +1,87 @@
+export = OriginalSource;
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
+/** @typedef {import("./Source").HashLike} HashLike */
+/** @typedef {import("./Source").MapOptions} MapOptions */
+/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./Source").SourceAndMap} SourceAndMap */
+/** @typedef {import("./Source").SourceValue} SourceValue */
+/** @typedef {import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./helpers/streamChunks").OnChunk} OnChunk */
+/** @typedef {import("./helpers/streamChunks").OnName} OnName */
+/** @typedef {import("./helpers/streamChunks").OnSource} OnSource */
+/** @typedef {import("./helpers/streamChunks").Options} Options */
+/** @typedef {import("./helpers/streamChunks").ScopeBindings} ScopeBindings */
+declare class OriginalSource extends Source {
+	/**
+	 * @param {string | Buffer} value value
+	 * @param {string} name name
+	 * @param {ScopeBindings=} scopeBindings what each name this source declares
+	 * evaluates to in the generated code, for the map's `scopes` field
+	 */
+	constructor(
+		value: string | Buffer,
+		name: string,
+		scopeBindings?: ScopeBindings | undefined,
+	);
+	/**
+	 * @type {undefined | string}
+	 */
+	_value: undefined | string;
+	/**
+	 * @type {undefined | Buffer}
+	 */
+	_valueAsBuffer: undefined | Buffer;
+	/**
+	 * @type {string}
+	 */
+	_name: string;
+	/**
+	 * @type {undefined | ScopeBindings}
+	 */
+	_scopeBindings: undefined | ScopeBindings;
+	getName(): string;
+	_cachedSize: number | undefined;
+	/**
+	 * @param {Options} options options
+	 * @param {OnChunk} onChunk called for each chunk of code
+	 * @param {OnSource} onSource called for each source
+	 * @param {OnName} _onName called for each name
+	 * @returns {GeneratedSourceInfo} generated source info
+	 */
+	streamChunks(
+		options: Options,
+		onChunk: OnChunk,
+		onSource: OnSource,
+		_onName: OnName,
+	): GeneratedSourceInfo;
+}
+declare namespace OriginalSource {
+	export {
+		ClearCacheOptions,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceAndMap,
+		SourceValue,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		Options,
+		ScopeBindings,
+	};
+}
+import Source = require("./Source");
+type ClearCacheOptions = import("./Source").ClearCacheOptions;
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceAndMap = import("./Source").SourceAndMap;
+type SourceValue = import("./Source").SourceValue;
+type GeneratedSourceInfo =
+	import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./helpers/streamChunks").OnChunk;
+type OnName = import("./helpers/streamChunks").OnName;
+type OnSource = import("./helpers/streamChunks").OnSource;
+type Options = import("./helpers/streamChunks").Options;
+type ScopeBindings = import("./helpers/streamChunks").ScopeBindings;

package/types/PrefixSource.d.ts

@@ -0,0 +1,59 @@
+export = PrefixSource;
+declare class PrefixSource extends Source {
+	/**
+	 * @param {string} prefix prefix
+	 * @param {string | Buffer | Source} source source
+	 */
+	constructor(prefix: string, source: string | Buffer | Source);
+	/**
+	 * @type {string}
+	 */
+	_prefix: string;
+	/**
+	 * @type {Source}
+	 */
+	_source: Source;
+	getPrefix(): string;
+	original(): Source;
+	/**
+	 * @param {Options} options options
+	 * @param {OnChunk} onChunk called for each chunk of code
+	 * @param {OnSource} onSource called for each source
+	 * @param {OnName} onName called for each name
+	 * @returns {GeneratedSourceInfo} generated source info
+	 */
+	streamChunks(
+		options: Options,
+		onChunk: OnChunk,
+		onSource: OnSource,
+		onName: OnName,
+	): GeneratedSourceInfo;
+}
+declare namespace PrefixSource {
+	export {
+		ClearCacheOptions,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceAndMap,
+		SourceValue,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		Options,
+	};
+}
+import Source = require("./Source");
+type ClearCacheOptions = import("./Source").ClearCacheOptions;
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceAndMap = import("./Source").SourceAndMap;
+type SourceValue = import("./Source").SourceValue;
+type GeneratedSourceInfo =
+	import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./helpers/streamChunks").OnChunk;
+type OnName = import("./helpers/streamChunks").OnName;
+type OnSource = import("./helpers/streamChunks").OnSource;
+type Options = import("./helpers/streamChunks").Options;

package/types/RawSource.d.ts

@@ -0,0 +1,75 @@
+export = RawSource;
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
+/** @typedef {import("./Source").HashLike} HashLike */
+/** @typedef {import("./Source").MapOptions} MapOptions */
+/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./Source").SourceValue} SourceValue */
+/** @typedef {import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./helpers/streamChunks").OnChunk} OnChunk */
+/** @typedef {import("./helpers/streamChunks").OnName} OnName */
+/** @typedef {import("./helpers/streamChunks").OnSource} OnSource */
+/** @typedef {import("./helpers/streamChunks").Options} Options */
+declare class RawSource extends Source {
+	/**
+	 * @param {string | Buffer} value value
+	 * @param {boolean=} convertToString convert to string
+	 */
+	constructor(value: string | Buffer, convertToString?: boolean | undefined);
+	/**
+	 * @type {boolean}
+	 */
+	_valueIsBuffer: boolean;
+	/**
+	 * @type {undefined | string | Buffer}
+	 */
+	_value: undefined | string | Buffer;
+	/**
+	 * @type {undefined | Buffer}
+	 */
+	_valueAsBuffer: undefined | Buffer;
+	/**
+	 * @type {undefined | string}
+	 */
+	_valueAsString: undefined | string;
+	isBuffer(): boolean;
+	_cachedSize: number | undefined;
+	/**
+	 * @param {Options} options options
+	 * @param {OnChunk} onChunk called for each chunk of code
+	 * @param {OnSource} onSource called for each source
+	 * @param {OnName} onName called for each name
+	 * @returns {GeneratedSourceInfo} generated source info
+	 */
+	streamChunks(
+		options: Options,
+		onChunk: OnChunk,
+		onSource: OnSource,
+		onName: OnName,
+	): GeneratedSourceInfo;
+}
+declare namespace RawSource {
+	export {
+		ClearCacheOptions,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceValue,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		Options,
+	};
+}
+import Source = require("./Source");
+type ClearCacheOptions = import("./Source").ClearCacheOptions;
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceValue = import("./Source").SourceValue;
+type GeneratedSourceInfo =
+	import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./helpers/streamChunks").OnChunk;
+type OnName = import("./helpers/streamChunks").OnName;
+type OnSource = import("./helpers/streamChunks").OnSource;
+type Options = import("./helpers/streamChunks").Options;

package/types/ReplaceSource.d.ts

@@ -0,0 +1,107 @@
+export = ReplaceSource;
+declare class ReplaceSource extends Source {
+	/**
+	 * @param {Source} source source
+	 * @param {string=} name name
+	 */
+	constructor(source: Source, name?: string | undefined);
+	/**
+	 * @type {Source}
+	 */
+	_source: Source;
+	/**
+	 * @type {string | undefined}
+	 */
+	_name: string | undefined;
+	/** @type {Replacement[]} */
+	_replacements: Replacement[];
+	/**
+	 * @type {boolean}
+	 */
+	_isSorted: boolean;
+	getName(): string | undefined;
+	getReplacements(): Replacement[];
+	/**
+	 * @param {number} start start
+	 * @param {number} end end
+	 * @param {string} newValue new value
+	 * @param {string=} name name
+	 * @returns {void}
+	 */
+	replace(
+		start: number,
+		end: number,
+		newValue: string,
+		name?: string | undefined,
+	): void;
+	/**
+	 * @param {number} pos pos
+	 * @param {string} newValue new value
+	 * @param {string=} name name
+	 * @returns {void}
+	 */
+	insert(pos: number, newValue: string, name?: string | undefined): void;
+	original(): Source;
+	_sortReplacements(): void;
+	/**
+	 * @param {Options} options options
+	 * @param {OnChunk} onChunk called for each chunk of code
+	 * @param {OnSource} onSource called for each source
+	 * @param {OnName} onName called for each name
+	 * @returns {GeneratedSourceInfo} generated source info
+	 */
+	streamChunks(
+		options: Options,
+		onChunk: OnChunk,
+		onSource: OnSource,
+		onName: OnName,
+	): GeneratedSourceInfo;
+}
+declare namespace ReplaceSource {
+	export {
+		Replacement,
+		ClearCacheOptions,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceAndMap,
+		SourceValue,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		Options,
+	};
+}
+import Source = require("./Source");
+declare class Replacement {
+	/**
+	 * @param {number} start start
+	 * @param {number} end end
+	 * @param {string} content content
+	 * @param {string=} name name
+	 */
+	constructor(
+		start: number,
+		end: number,
+		content: string,
+		name?: string | undefined,
+	);
+	start: number;
+	end: number;
+	content: string;
+	name: string | undefined;
+	index: number | undefined;
+}
+type ClearCacheOptions = import("./Source").ClearCacheOptions;
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceAndMap = import("./Source").SourceAndMap;
+type SourceValue = import("./Source").SourceValue;
+type GeneratedSourceInfo =
+	import("./helpers/getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./helpers/streamChunks").OnChunk;
+type OnName = import("./helpers/streamChunks").OnName;
+type OnSource = import("./helpers/streamChunks").OnSource;
+type Options = import("./helpers/streamChunks").Options;

package/types/SizeOnlySource.d.ts

@@ -0,0 +1,24 @@
+export = SizeOnlySource;
+/** @typedef {import("./Source").HashLike} HashLike */
+/** @typedef {import("./Source").MapOptions} MapOptions */
+/** @typedef {import("./Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./Source").SourceValue} SourceValue */
+declare class SizeOnlySource extends Source {
+	/**
+	 * @param {number} size size
+	 */
+	constructor(size: number);
+	/**
+	 * @type {number}
+	 */
+	_size: number;
+	_error(): Error;
+}
+declare namespace SizeOnlySource {
+	export { HashLike, MapOptions, RawSourceMap, SourceValue };
+}
+import Source = require("./Source");
+type HashLike = import("./Source").HashLike;
+type MapOptions = import("./Source").MapOptions;
+type RawSourceMap = import("./Source").RawSourceMap;
+type SourceValue = import("./Source").SourceValue;