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

package/types/helpers/streamChunks.d.ts

@@ -0,0 +1,56 @@
+declare namespace _exports {
+	export {
+		Source,
+		GeneratedSourceInfo,
+		OnChunk,
+		ScopeBindings,
+		OnSource,
+		OnName,
+		Options,
+		StreamChunksFunction,
+		SourceMaybeWithStreamChunksFunction,
+	};
+}
+declare function _exports(
+	source: SourceMaybeWithStreamChunksFunction,
+	options: Options,
+	onChunk: OnChunk,
+	onSource: OnSource,
+	onName: OnName,
+): GeneratedSourceInfo;
+export = _exports;
+type Source = import("../Source");
+type GeneratedSourceInfo =
+	import("./getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = (
+	chunk: string | undefined,
+	generatedLine: number,
+	generatedColumn: number,
+	sourceIndex: number,
+	originalLine: number,
+	originalColumn: number,
+	nameIndex: number,
+) => void;
+type ScopeBindings = Map<string, string>;
+type OnSource = (
+	sourceIndex: number,
+	source: string | null,
+	sourceContent: string | undefined,
+	scopeBindings?: ScopeBindings,
+) => void;
+type OnName = (nameIndex: number, name: string) => void;
+type Options = {
+	source?: boolean;
+	finalSource?: boolean;
+	columns?: boolean;
+	scopes?: boolean;
+};
+type StreamChunksFunction = (
+	options: Options,
+	onChunk: OnChunk,
+	onSource: OnSource,
+	onName: OnName,
+) => any;
+type SourceMaybeWithStreamChunksFunction = Source & {
+	streamChunks?: StreamChunksFunction;
+};

package/types/helpers/streamChunksOfCombinedSourceMap.d.ts

@@ -0,0 +1,42 @@
+export = streamChunksOfCombinedSourceMap;
+/** @typedef {import("../Source").RawSourceMap} RawSourceMap */
+/** @typedef {import("./getGeneratedSourceInfo").GeneratedSourceInfo} GeneratedSourceInfo */
+/** @typedef {import("./streamChunks").OnChunk} onChunk */
+/** @typedef {import("./streamChunks").OnName} OnName */
+/** @typedef {import("./streamChunks").OnSource} OnSource */
+/**
+ * @param {string} source source
+ * @param {RawSourceMap} sourceMap source map
+ * @param {string} innerSourceName inner source name
+ * @param {string} innerSource inner source
+ * @param {RawSourceMap} innerSourceMap inner source map
+ * @param {boolean | undefined} removeInnerSource do remove inner source
+ * @param {onChunk} onChunk on chunk
+ * @param {OnSource} onSource on source
+ * @param {OnName} onName on name
+ * @param {boolean} finalSource finalSource
+ * @param {boolean} columns columns
+ * @returns {GeneratedSourceInfo} generated source info
+ */
+declare function streamChunksOfCombinedSourceMap(
+	source: string,
+	sourceMap: RawSourceMap,
+	innerSourceName: string,
+	innerSource: string,
+	innerSourceMap: RawSourceMap,
+	removeInnerSource: boolean | undefined,
+	onChunk: onChunk,
+	onSource: OnSource,
+	onName: OnName,
+	finalSource: boolean,
+	columns: boolean,
+): GeneratedSourceInfo;
+declare namespace streamChunksOfCombinedSourceMap {
+	export { RawSourceMap, GeneratedSourceInfo, onChunk, OnName, OnSource };
+}
+type RawSourceMap = import("../Source").RawSourceMap;
+type GeneratedSourceInfo =
+	import("./getGeneratedSourceInfo").GeneratedSourceInfo;
+type onChunk = import("./streamChunks").OnChunk;
+type OnName = import("./streamChunks").OnName;
+type OnSource = import("./streamChunks").OnSource;

package/types/helpers/streamChunksOfRawSource.d.ts

@@ -0,0 +1,16 @@
+declare namespace _exports {
+	export { GeneratedSourceInfo, OnChunk, OnName, OnSource };
+}
+declare function _exports(
+	source: string,
+	onChunk: OnChunk,
+	onSource: OnSource,
+	onName: OnName,
+	finalSource: boolean,
+): GeneratedSourceInfo;
+export = _exports;
+type GeneratedSourceInfo =
+	import("./getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./streamChunks").OnChunk;
+type OnName = import("./streamChunks").OnName;
+type OnSource = import("./streamChunks").OnSource;

package/types/helpers/streamChunksOfSourceMap.d.ts

@@ -0,0 +1,19 @@
+declare namespace _exports {
+	export { RawSourceMap, GeneratedSourceInfo, OnChunk, OnName, OnSource };
+}
+declare function _exports(
+	source: string,
+	sourceMap: RawSourceMap,
+	onChunk: OnChunk,
+	onSource: OnSource,
+	onName: OnName,
+	finalSource: boolean,
+	columns: boolean,
+): GeneratedSourceInfo;
+export = _exports;
+type RawSourceMap = import("../Source").RawSourceMap;
+type GeneratedSourceInfo =
+	import("./getGeneratedSourceInfo").GeneratedSourceInfo;
+type OnChunk = import("./streamChunks").OnChunk;
+type OnName = import("./streamChunks").OnName;
+type OnSource = import("./streamChunks").OnSource;

package/types/helpers/stringBufferUtils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Disables the optimization to save both string and buffer in memory. This
+ * may increase performance but should reduce memory usage in the Webpack
+ * compiler.
+ * @returns {void}
+ */
+export function disableDualStringBufferCaching(): void;
+/**
+ * Enables an optimization to save both string and buffer in memory to avoid
+ * repeat conversions between the two formats when they are requested. This
+ * is enabled by default. This option can improve performance but can consume
+ * additional memory since values are stored twice.
+ * @returns {void}
+ */
+export function enableDualStringBufferCaching(): void;
+/**
+ * Starts a memory optimization to avoid repeat copies of the same string in
+ * memory by caching a single reference to the string. This can reduce memory
+ * usage if the same string is repeated many times in the compiler, such as
+ * when Webpack layers are used with the same files.
+ *
+ * {@link exitStringInterningRange} should be called when string interning is
+ * no longer necessary to free up the memory used by the interned strings. If
+ * {@link enterStringInterningRange} has been called multiple times, then
+ * this method may not immediately free all the memory until
+ * {@link exitStringInterningRange} has been called to end all string
+ * interning ranges.
+ * @returns {void}
+ */
+export function enterStringInterningRange(): void;
+/**
+ * Stops the current string interning range. Once all string interning ranges
+ * have been exited, this method will free all the memory used by the interned
+ * strings. This method should be called once for each time that
+ * {@link enterStringInterningRange} was called.
+ * @returns {void}
+ */
+export function exitStringInterningRange(): void;
+/**
+ * Saves the string in a map to ensure that only one copy of the string exists
+ * in memory at a given time. This is controlled by {@link enableStringInterning}
+ * and {@link disableStringInterning}. Callers are expect to manage the memory
+ * of the interned strings by calling {@link disableStringInterning} after the
+ * compiler no longer needs to save the interned memory.
+ * @param {string} str A string to be interned.
+ * @returns {string} The original string or a reference to an existing string of the same value if it has already been interned.
+ */
+export function internString(str: string): string;
+/**
+ * @returns {boolean} Whether the optimization to cache copies of both the
+ * string and buffer version of source content is enabled. This is enabled by
+ * default to improve performance but can consume more memory since values are
+ * stored twice.
+ */
+export function isDualStringBufferCachingEnabled(): boolean;

package/types/index.d.ts

@@ -0,0 +1,50 @@
+declare namespace _exports {
+	export {
+		CachedData,
+		SourceLike,
+		ConcatSourceChild,
+		Replacement,
+		HashLike,
+		MapOptions,
+		RawSourceMap,
+		SourceAndMap,
+		SourceValue,
+		GeneratedSourceInfo,
+		OnChunk,
+		OnName,
+		OnSource,
+		StreamChunksOptions,
+	};
+}
+declare namespace _exports {
+	const Source: typeof import("./Source");
+	const RawSource: typeof import("./RawSource");
+	const OriginalSource: typeof import("./OriginalSource");
+	const SourceMapSource: typeof import("./SourceMapSource");
+	const CachedSource: typeof import("./CachedSource");
+	const ConcatSource: typeof import("./ConcatSource");
+	const ReplaceSource: typeof import("./ReplaceSource");
+	const PrefixSource: typeof import("./PrefixSource");
+	const SizeOnlySource: typeof import("./SizeOnlySource");
+	const CompatSource: typeof import("./CompatSource");
+	namespace util {
+		const scopes: typeof import("./helpers/scopes");
+		const stringBufferUtils: typeof import("./helpers/stringBufferUtils");
+	}
+}
+export = _exports;
+type CachedData = import("./CachedSource").CachedData;
+type SourceLike = import("./CompatSource").SourceLike;
+type ConcatSourceChild = import("./ConcatSource").Child;
+type Replacement = import("./ReplaceSource").Replacement;
+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 StreamChunksOptions = import("./helpers/streamChunks").Options;