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

package/types/Source.d.ts

@@ -0,0 +1,189 @@
+export = Source;
+/**
+ * @typedef {object} MapOptions
+ * @property {boolean=} columns need columns?
+ * @property {boolean=} module is module
+ * @property {boolean=} scopes emit the `scopes` field from the bindings the sources declare
+ */
+/**
+ * @typedef {object} RawSourceMap
+ * @property {number} version version
+ * @property {string[]} sources sources
+ * @property {string[]} names names
+ * @property {string=} sourceRoot source root
+ * @property {string[]=} sourcesContent sources content
+ * @property {string} mappings mappings
+ * @property {string} file file
+ * @property {string=} debugId debug id
+ * @property {number[]=} ignoreList ignore list
+ * @property {string=} scopes encoded `scopes` field of the "Scopes" proposal
+ */
+/** @typedef {string | Buffer} SourceValue */
+/**
+ * @typedef {object} SourceAndMap
+ * @property {SourceValue} source source
+ * @property {RawSourceMap | null} map map
+ */
+/**
+ * @typedef {object} HashLike
+ * @property {(data: string | Buffer, inputEncoding?: string) => HashLike} update make hash update
+ * @property {(encoding?: string) => string | Buffer} digest get hash digest
+ */
+/**
+ * @typedef {object} ClearCacheOptions
+ * @property {boolean=} maps drop cached source maps (default `true`)
+ * @property {boolean=} source drop cached source/buffer copies (default `true`)
+ * @property {boolean=} parsedMap drop the parsed object form of cached source maps on `SourceMapSource` instances (default `false` — re-parsing JSON is significantly more expensive than `toString`). Only takes effect when a serialized form (buffer or string) is also retained, so the data remains recoverable.
+ */
+declare class Source {
+	/**
+	 * @returns {SourceValue} source
+	 */
+	source(): SourceValue;
+	/**
+	 * @returns {Buffer} buffer
+	 */
+	buffer(): Buffer;
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers(): Buffer[];
+	/**
+	 * @returns {number} size
+	 */
+	size(): number;
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {RawSourceMap | null} map
+	 */
+	map(options?: MapOptions | undefined): RawSourceMap | null;
+	/**
+	 * @param {MapOptions=} options map options
+	 * @returns {SourceAndMap} source and map
+	 */
+	sourceAndMap(options?: MapOptions | undefined): SourceAndMap;
+	/**
+	 * @param {HashLike} hash hash
+	 * @returns {void}
+	 */
+	updateHash(hash: HashLike): void;
+	/**
+	 * Release cached data held by this source. clearCache is a memory
+	 * hint: it never affects correctness or output, only how expensive
+	 * the next read is. Subclasses override; the base is a no-op so
+	 * every Source supports the call. Composite sources always recurse
+	 * into wrapped sources. When the same child is reachable via several
+	 * parents (e.g. modules shared across webpack chunks), pass a shared
+	 * `visited` WeakSet so each subtree is walked at most once.
+	 * Not safe to call concurrently with source/map/sourceAndMap/
+	 * streamChunks/updateHash on the same instance.
+	 * @param {ClearCacheOptions=} options selectors
+	 * @param {WeakSet<Source>=} visited de-duplication set shared across calls
+	 * @returns {void}
+	 */
+	clearCache(
+		options?: ClearCacheOptions | undefined,
+		visited?: WeakSet<Source> | undefined,
+	): void;
+}
+declare namespace Source {
+	export {
+		MapOptions,
+		RawSourceMap,
+		SourceValue,
+		SourceAndMap,
+		HashLike,
+		ClearCacheOptions,
+	};
+}
+type MapOptions = {
+	/**
+	 * need columns?
+	 */
+	columns?: boolean | undefined;
+	/**
+	 * is module
+	 */
+	module?: boolean | undefined;
+	/**
+	 * emit the `scopes` field from the bindings the sources declare
+	 */
+	scopes?: boolean | undefined;
+};
+type RawSourceMap = {
+	/**
+	 * version
+	 */
+	version: number;
+	/**
+	 * sources
+	 */
+	sources: string[];
+	/**
+	 * names
+	 */
+	names: string[];
+	/**
+	 * source root
+	 */
+	sourceRoot?: string | undefined;
+	/**
+	 * sources content
+	 */
+	sourcesContent?: string[] | undefined;
+	/**
+	 * mappings
+	 */
+	mappings: string;
+	/**
+	 * file
+	 */
+	file: string;
+	/**
+	 * debug id
+	 */
+	debugId?: string | undefined;
+	/**
+	 * ignore list
+	 */
+	ignoreList?: number[] | undefined;
+	/**
+	 * encoded `scopes` field of the "Scopes" proposal
+	 */
+	scopes?: string | undefined;
+};
+type SourceValue = string | Buffer;
+type SourceAndMap = {
+	/**
+	 * source
+	 */
+	source: SourceValue;
+	/**
+	 * map
+	 */
+	map: RawSourceMap | null;
+};
+type HashLike = {
+	/**
+	 * make hash update
+	 */
+	update: (data: string | Buffer, inputEncoding?: string) => HashLike;
+	/**
+	 * get hash digest
+	 */
+	digest: (encoding?: string) => string | Buffer;
+};
+type ClearCacheOptions = {
+	/**
+	 * drop cached source maps (default `true`)
+	 */
+	maps?: boolean | undefined;
+	/**
+	 * drop cached source/buffer copies (default `true`)
+	 */
+	source?: boolean | undefined;
+	/**
+	 * drop the parsed object form of cached source maps on `SourceMapSource` instances (default `false` — re-parsing JSON is significantly more expensive than `toString`). Only takes effect when a serialized form (buffer or string) is also retained, so the data remains recoverable.
+	 */
+	parsedMap?: boolean | undefined;
+};

package/types/SourceMapSource.d.ts

@@ -0,0 +1,136 @@
+export = SourceMapSource;
+/** @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 */
+declare class SourceMapSource extends Source {
+	/**
+	 * @param {string | Buffer} value value
+	 * @param {string} name name
+	 * @param {string | Buffer | RawSourceMap=} sourceMap source map
+	 * @param {SourceValue=} originalSource original source
+	 * @param {(null | string | Buffer | RawSourceMap)=} innerSourceMap inner source map
+	 * @param {boolean=} removeOriginalSource do remove original source
+	 */
+	constructor(
+		value: string | Buffer,
+		name: string,
+		sourceMap?: (string | Buffer | RawSourceMap) | undefined,
+		originalSource?: SourceValue | undefined,
+		innerSourceMap?: (null | string | Buffer | RawSourceMap) | undefined,
+		removeOriginalSource?: boolean | undefined,
+	);
+	/**
+	 * @type {undefined | string}
+	 */
+	_valueAsString: undefined | string;
+	/**
+	 * @type {undefined | Buffer}
+	 */
+	_valueAsBuffer: undefined | Buffer;
+	_name: string;
+	_hasSourceMap: boolean;
+	/**
+	 * @type {undefined | RawSourceMap}
+	 */
+	_sourceMapAsObject: undefined | RawSourceMap;
+	/**
+	 * @type {undefined | string}
+	 */
+	_sourceMapAsString: undefined | string;
+	/**
+	 * @type {undefined | Buffer}
+	 */
+	_sourceMapAsBuffer: undefined | Buffer;
+	_hasOriginalSource: boolean;
+	_originalSourceAsString: string | undefined;
+	_originalSourceAsBuffer: Buffer<ArrayBufferLike> | undefined;
+	_hasInnerSourceMap: boolean;
+	/**
+	 * @type {undefined | RawSourceMap}
+	 */
+	_innerSourceMapAsObject: undefined | RawSourceMap;
+	/**
+	 * @type {undefined | string}
+	 */
+	_innerSourceMapAsString: undefined | string;
+	/**
+	 * @type {undefined | Buffer}
+	 */
+	_innerSourceMapAsBuffer: undefined | Buffer;
+	_removeOriginalSource: boolean | undefined;
+	/**
+	 * @returns {[Buffer, string, Buffer, Buffer | undefined, Buffer | undefined, boolean | undefined]} args
+	 */
+	getArgsAsBuffers(): [
+		Buffer,
+		string,
+		Buffer,
+		Buffer | undefined,
+		Buffer | undefined,
+		boolean | undefined,
+	];
+	_cachedSize: number | undefined;
+	/**
+	 * @returns {undefined | Buffer} buffer
+	 */
+	_originalSourceBuffer(): undefined | Buffer;
+	_originalSourceString(): string | undefined;
+	_innerSourceMapObject(): any;
+	_innerSourceMapBuffer(): Buffer<ArrayBufferLike> | undefined;
+	/**
+	 * @returns {string} result
+	 */
+	_innerSourceMapString(): string;
+	_sourceMapObject(): any;
+	_sourceMapBuffer(): Buffer<ArrayBufferLike>;
+	_sourceMapString(): string;
+	/**
+	 * @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 SourceMapSource {
+	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/helpers/createMappingsSerializer.d.ts

@@ -0,0 +1,60 @@
+export = createMappingsSerializer;
+/**
+ * @param {{ columns?: boolean }=} options options
+ * @returns {MappingsSerializer} mappings serializer
+ */
+declare function createMappingsSerializer(
+	options?:
+		| {
+				columns?: boolean;
+		  }
+		| undefined,
+): MappingsSerializer;
+declare namespace createMappingsSerializer {
+	export { createMappingsWriter, MappingsSerializer, MappingsWriter };
+}
+/**
+ * @param {{ columns?: boolean }=} options options
+ * @returns {MappingsWriter} push-based mappings writer
+ */
+declare function createMappingsWriter(
+	options?:
+		| {
+				columns?: boolean;
+		  }
+		| undefined,
+): MappingsWriter;
+type MappingsSerializer = (
+	generatedLine: number,
+	generatedColumn: number,
+	sourceIndex: number,
+	originalLine: number,
+	originalColumn: number,
+	nameIndex: number,
+) => string;
+/**
+ * A push-based serializer: `add()` appends one mapping to an internal
+ * byte buffer, `finish()` materialises the whole `mappings` string in a
+ * single allocation. Compared to the string-returning
+ * {@link MappingsSerializer} this avoids every per-mapping intermediate
+ * string (each VLQ digit concatenation) plus the caller-side
+ * `mappings += str` cons chain — together the dominant allocation site
+ * of `map()` / `sourceAndMap()`.
+ */
+type MappingsWriter = {
+	/**
+	 * append one mapping
+	 */
+	add: (
+		generatedLine: number,
+		generatedColumn: number,
+		sourceIndex: number,
+		originalLine: number,
+		originalColumn: number,
+		nameIndex: number,
+	) => void;
+	/**
+	 * materialise the mappings string
+	 */
+	finish: () => string;
+};

package/types/helpers/getFromStreamChunks.d.ts

@@ -0,0 +1,16 @@
+export function getMap(
+	source: SourceLikeWithStreamChunks,
+	options?: Options | undefined,
+): RawSourceMap | null;
+export function getSourceAndMap(
+	inputSource: SourceLikeWithStreamChunks,
+	options?: Options | undefined,
+): SourceAndMap;
+export type RawSourceMap = import("../Source").RawSourceMap;
+export type SourceAndMap = import("../Source").SourceAndMap;
+export type Options = import("./streamChunks").Options;
+export type StreamChunksFunction =
+	import("./streamChunks").StreamChunksFunction;
+export type SourceLikeWithStreamChunks = {
+	streamChunks: StreamChunksFunction;
+};

package/types/helpers/getGeneratedSourceInfo.d.ts

@@ -0,0 +1,31 @@
+export = getGeneratedSourceInfo;
+/**
+ * @typedef {object} GeneratedSourceInfo
+ * @property {number=} generatedLine generated line
+ * @property {number=} generatedColumn generated column
+ * @property {string=} source source
+ */
+/**
+ * @param {string | undefined} source source
+ * @returns {GeneratedSourceInfo} source info
+ */
+declare function getGeneratedSourceInfo(
+	source: string | undefined,
+): GeneratedSourceInfo;
+declare namespace getGeneratedSourceInfo {
+	export { GeneratedSourceInfo };
+}
+type GeneratedSourceInfo = {
+	/**
+	 * generated line
+	 */
+	generatedLine?: number | undefined;
+	/**
+	 * generated column
+	 */
+	generatedColumn?: number | undefined;
+	/**
+	 * source
+	 */
+	source?: string | undefined;
+};

package/types/helpers/getName.d.ts

@@ -0,0 +1,15 @@
+export = getName;
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/**
+ * @param {RawSourceMap} sourceMap source map
+ * @param {number} index index
+ * @returns {string | undefined | null} name
+ */
+declare function getName(
+	sourceMap: RawSourceMap,
+	index: number,
+): string | undefined | null;
+declare namespace getName {
+	export { RawSourceMap };
+}
+type RawSourceMap = import("../Source").RawSourceMap;

package/types/helpers/getSource.d.ts

@@ -0,0 +1,15 @@
+export = getSource;
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/**
+ * @param {RawSourceMap} sourceMap source map
+ * @param {number} index index
+ * @returns {string | null} name
+ */
+declare function getSource(
+	sourceMap: RawSourceMap,
+	index: number,
+): string | null;
+declare namespace getSource {
+	export { RawSourceMap };
+}
+type RawSourceMap = import("../Source").RawSourceMap;

package/types/helpers/readMappings.d.ts

@@ -0,0 +1,19 @@
+export = readMappings;
+/** @typedef {(generatedLine: number, generatedColumn: number, sourceIndex: number, originalLine: number, originalColumn: number, nameIndex: number) => void} OnMapping */
+/**
+ * @param {string} mappings the mappings string
+ * @param {OnMapping} onMapping called for each mapping
+ * @returns {void}
+ */
+declare function readMappings(mappings: string, onMapping: OnMapping): void;
+declare namespace readMappings {
+	export { OnMapping };
+}
+type OnMapping = (
+	generatedLine: number,
+	generatedColumn: number,
+	sourceIndex: number,
+	originalLine: number,
+	originalColumn: number,
+	nameIndex: number,
+) => void;

package/types/helpers/scopes.d.ts

@@ -0,0 +1,119 @@
+export type RawSourceMap = import("../Source").RawSourceMap;
+export type ScopeBindings = import("./streamChunks").ScopeBindings;
+/**
+ * A generated or original position, both counted from zero.
+ */
+export type ScopePosition = {
+	/**
+	 * line
+	 */
+	line: number;
+	/**
+	 * column
+	 */
+	column: number;
+};
+/**
+ * One source's scope, and the span of generated code it explains.
+ */
+export type SourceScope = {
+	/**
+	 * index into the map's `sources`
+	 */
+	sourceIndex: number;
+	/**
+	 * the names the source declares
+	 */
+	variables: string[];
+	/**
+	 * the generated expression each name evaluates to
+	 */
+	values: string[];
+	/**
+	 * end of the original scope, exclusive
+	 */
+	originalEnd: ScopePosition;
+	/**
+	 * start of each generated range, inclusive
+	 */
+	rangeStarts: ScopePosition[];
+	/**
+	 * end of each generated range, exclusive
+	 */
+	rangeEnds: ScopePosition[];
+};
+/**
+ * Adds the `scopes` field of the "Scopes" proposal to a source map, naming for
+ * each source the bindings a debugger cannot resolve on its own and the
+ * generated expression each one evaluates to. Does nothing when no source
+ * contributes a binding.
+ * @param {RawSourceMap} sourceMap the map to extend in place
+ * @param {(sourceIndex: number) => Map<string, string> | undefined} getBindings binding expressions per source
+ * @returns {void}
+ */
+export function addScopesToSourceMap(
+	sourceMap: RawSourceMap,
+	getBindings: (sourceIndex: number) => Map<string, string> | undefined,
+): void;
+/**
+ * Groups a finished map's segments into one entry per source. Prefer the
+ * collector when the segments are still being written, which saves decoding
+ * back what was just encoded.
+ * @param {string} mappings the map's `mappings` field
+ * @param {number} sourceCount number of entries in the map's `sources`
+ * @returns {SourceScope[]} one entry per source that the mappings reach, in source order
+ */
+export function collectSourceScopes(
+	mappings: string,
+	sourceCount: number,
+): SourceScope[];
+/**
+ * Collects, segment by segment, the generated runs each source explains and how
+ * far into it the map reaches. Both lines are counted from zero, so a caller
+ * whose lines start at one subtracts before feeding a segment in.
+ * @param {number=} sourceCount number of entries in the map's `sources`, when known
+ * @returns {{ add: (generatedLine: number, generatedColumn: number, sourceIndex: number, originalLine: number) => void, finish: (lastLine: number, lastColumn?: number) => SourceScope[] }} collector
+ */
+export function createScopeCollector(sourceCount?: number | undefined): {
+	add: (
+		generatedLine: number,
+		generatedColumn: number,
+		sourceIndex: number,
+		originalLine: number,
+	) => void;
+	finish: (lastLine: number, lastColumn?: number) => SourceScope[];
+};
+/**
+ * Builds the `scopes` field while a map is being written, so the segments are
+ * read as they are produced rather than decoded back out of `mappings`. Lines
+ * are the one-based ones the chunk stream reports; `finish` takes the position
+ * the generated code ends at, where the last range closes.
+ * @returns {{ add: (generatedLine: number, generatedColumn: number, sourceIndex: number, originalLine: number) => void, addSource: (sourceIndex: number, scopeBindings?: ScopeBindings) => void, finish: (map: RawSourceMap, generatedLine: number, generatedColumn?: number) => void }} writer
+ */
+export function createScopesWriter(): {
+	add: (
+		generatedLine: number,
+		generatedColumn: number,
+		sourceIndex: number,
+		originalLine: number,
+	) => void;
+	addSource: (sourceIndex: number, scopeBindings?: ScopeBindings) => void;
+	finish: (
+		map: RawSourceMap,
+		generatedLine: number,
+		generatedColumn?: number,
+	) => void;
+};
+/**
+ * Encodes the scope tree into the `scopes` field of the proposal, appending any
+ * name it needs to the map's `names`.
+ * @param {SourceScope[]} scopes the scopes to encode, in source order
+ * @param {number} sourceCount number of entries in the map's `sources`
+ * @param {string[]} names the map's `names`, extended in place
+ * @returns {string} the encoded `scopes` field
+ */
+export function encodeScopes(
+	scopes: SourceScope[],
+	sourceCount: number,
+	names: string[],
+): string;

package/types/helpers/splitIntoLines.d.ts

@@ -0,0 +1,6 @@
+export = splitIntoLines;
+/**
+ * @param {string} str string
+ * @returns {string[]} array of string separated by lines
+ */
+declare function splitIntoLines(str: string): string[];

package/types/helpers/splitIntoPotentialTokens.d.ts

@@ -0,0 +1,37 @@
+export = splitIntoPotentialTokens;
+/**
+ * Array-returning variant. Kept as a standalone loop rather than wrapping
+ * `eachPotentialToken` with a per-token callback: the callback indirection
+ * measurably slows this hot scan (V8 can no longer inline the slice/push),
+ * and the two only share the same small, well-tested classification table.
+ * @param {string} str string
+ * @returns {string[] | null} array of string separated by potential tokens
+ */
+declare function splitIntoPotentialTokens(str: string): string[] | null;
+declare namespace splitIntoPotentialTokens {
+	export { eachPotentialToken, OnPotentialToken };
+}
+/**
+ * @callback OnPotentialToken
+ * @param {number} start start offset (inclusive)
+ * @param {number} end end offset (exclusive)
+ * @param {boolean} newline whether the token ends with a `\n`
+ * @returns {void}
+ */
+/**
+ * Streaming core: report each potential token by its `[start, end)` bounds
+ * instead of materialising substrings. The single real consumer
+ * (`OriginalSource.streamChunks`) slices on demand — and skips slicing
+ * entirely when emitting the final source (the `map()` / `sourceAndMap()`
+ * paths, which discard the chunk text) — so this avoids both the
+ * intermediate results array and every per-token `String.slice` allocation
+ * in the dominant case.
+ * @param {string} str string
+ * @param {OnPotentialToken} onToken called for each token
+ * @returns {void}
+ */
+declare function eachPotentialToken(
+	str: string,
+	onToken: OnPotentialToken,
+): void;
+type OnPotentialToken = (start: number, end: number, newline: boolean) => void;

package/types/helpers/streamAndGetSourceAndMap.d.ts

@@ -0,0 +1,39 @@
+export = streamAndGetSourceAndMap;
+/**
+ * @param {SourceMaybeWithStreamChunksFunction} inputSource input source
+ * @param {Options} options options
+ * @param {OnChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @returns {{ result: GeneratedSourceInfo, source: string, map: RawSourceMap | null }} result
+ */
+declare function streamAndGetSourceAndMap(
+	inputSource: SourceMaybeWithStreamChunksFunction,
+	options: Options,
+	onChunk: OnChunk,
+	onSource: OnSource,
+	onName: OnName,
+): {
+	result: GeneratedSourceInfo;
+	source: string;
+	map: RawSourceMap | null;
+};
+declare namespace streamAndGetSourceAndMap {
+	export {
+		RawSourceMap,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		Options,
+		SourceMaybeWithStreamChunksFunction,
+	};
+}
+type RawSourceMap = import("../Source").RawSourceMap;
+type GeneratedSourceInfo = import("./streamChunks").GeneratedSourceInfo;
+type OnChunk = import("./streamChunks").OnChunk;
+type OnName = import("./streamChunks").OnName;
+type OnSource = import("./streamChunks").OnSource;
+type Options = import("./streamChunks").Options;
+type SourceMaybeWithStreamChunksFunction =
+	import("./streamChunks").SourceMaybeWithStreamChunksFunction;