@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/requests/ValidationRequest.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createValidationRequest;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const AtlaspackConfig_1 = require("../AtlaspackConfig");
+const ReporterRunner_1 = require("../ReporterRunner");
+const Validation_1 = __importDefault(require("../Validation"));
+const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
+const RequestTracker_1 = require("../RequestTracker");
+function createValidationRequest(input) {
+    return {
+        id: 'validation',
+        type: RequestTracker_1.requestTypes.validation_request,
+        run: async ({ input: { assetRequests, optionsRef }, api, options, farm }) => {
+            let { config: processedConfig, cachePath } = (0, nullthrows_1.default)(await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+            let config = new AtlaspackConfig_1.AtlaspackConfig(processedConfig, options);
+            let trackedRequestsDesc = assetRequests.filter((request) => {
+                // @ts-expect-error TS2345
+                return config.getValidatorNames(request.filePath).length > 0;
+            });
+            // Schedule validations on workers for all plugins that implement the one-asset-at-a-time "validate" method.
+            let promises = trackedRequestsDesc.map(async (request) => (await farm.createHandle('runValidate'))({
+                requests: [request],
+                optionsRef: optionsRef,
+                configCachePath: cachePath,
+            }));
+            // Skip sending validation requests if no validators were configured
+            if (trackedRequestsDesc.length === 0) {
+                return;
+            }
+            // Schedule validations on the main thread for all validation plugins that implement "validateAll".
+            promises.push(
+            // @ts-expect-error TS2345
+            new Validation_1.default({
+                requests: trackedRequestsDesc,
+                options,
+                config,
+                // @ts-expect-error TS2322
+                report: ReporterRunner_1.report,
+                dedicatedThread: true,
+            }).run());
+            await Promise.all(promises);
+        },
+        input,
+    };
+}

package/dist/requests/WriteBundleRequest.js

@@ -0,0 +1,522 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMapHashRefRewriteStream = void 0;
+exports.default = createWriteBundleRequest;
+exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.applyReplacementsToVLQMappings = applyReplacementsToVLQMappings;
+exports.computeSourceMapRoot = computeSourceMapRoot;
+const constants_1 = require("../constants");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+const Bundle_1 = require("../public/Bundle");
+const utils_1 = require("@atlaspack/utils");
+const stream_1 = require("stream");
+const projectPath_1 = require("../projectPath");
+const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
+const PluginOptions_1 = __importDefault(require("../public/PluginOptions"));
+const logger_1 = require("@atlaspack/logger");
+const DevDepRequest_1 = require("./DevDepRequest");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const profiler_1 = require("@atlaspack/profiler");
+const RequestTracker_1 = require("../RequestTracker");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const source_map_1 = require("@atlaspack/source-map");
+const HASH_REF_PREFIX_LEN = constants_1.HASH_REF_PREFIX.length;
+const BOUNDARY_LENGTH = constants_1.HASH_REF_PREFIX.length + 32 - 1;
+const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN;
+// The JSON key prefix we scan for in the source map stream.
+const MAPPINGS_KEY_BUF = Buffer.from('"mappings":"');
+/**
+ * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
+ */
+function createWriteBundleRequest(input) {
+    let name = (0, nullthrows_1.default)(input.bundle.name);
+    let nameHash = (0, nullthrows_1.default)(input.hashRefToNameHash.get(input.bundle.hashReference));
+    return {
+        id: `${input.bundle.id}:${input.info.hash}:${nameHash}:${name}`,
+        type: RequestTracker_1.requestTypes.write_bundle_request,
+        run,
+        input,
+    };
+}
+// @ts-expect-error TS7031
+async function run({ input, options, api }) {
+    let { bundleGraph, bundle, info, hashRefToNameHash } = input;
+    let { inputFS, outputFS } = options;
+    let name = (0, nullthrows_1.default)(bundle.name);
+    let thisHashReference = bundle.hashReference;
+    if (info.type !== bundle.type) {
+        name = name.slice(0, -path_1.default.extname(name).length) + '.' + info.type;
+    }
+    if (name.includes(thisHashReference)) {
+        let thisNameHash = (0, nullthrows_1.default)(hashRefToNameHash.get(thisHashReference));
+        name = name.replace(thisHashReference, thisNameHash);
+    }
+    let filePath = (0, projectPath_1.joinProjectPath)(bundle.target.distDir, name);
+    // Watch the bundle and source map for deletion.
+    // Also watch the dist dir because invalidateOnFileDelete does not currently
+    // invalidate when a parent directory is deleted.
+    // TODO: do we want to also watch for file edits?
+    api.invalidateOnFileDelete(bundle.target.distDir);
+    api.invalidateOnFileDelete(filePath);
+    let cacheKeys = info.cacheKeys;
+    let mapKey = cacheKeys.map;
+    let fullPath = (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath);
+    const env = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env);
+    if (mapKey && env.sourceMap && !env.sourceMap.inline) {
+        api.invalidateOnFileDelete((0, projectPath_1.toProjectPath)(options.projectRoot, fullPath + '.map'));
+    }
+    let dir = path_1.default.dirname(fullPath);
+    await outputFS.mkdirp(dir); // ? Got rid of dist exists, is this an expensive operation
+    // Use the file mode from the entry asset as the file mode for the bundle.
+    // Don't do this for browser builds, as the executable bit in particular is unnecessary.
+    let publicBundle = Bundle_1.NamedBundle.get(bundle, bundleGraph, options);
+    let mainEntry = publicBundle.getMainEntry();
+    let writeOptions = publicBundle.env.isBrowser() || !mainEntry
+        ? undefined
+        : {
+            mode: (await inputFS.stat(mainEntry.filePath)).mode,
+        };
+    let contentStream;
+    if (info.isLargeBlob) {
+        contentStream = options.cache.getStream(cacheKeys.content);
+    }
+    else {
+        contentStream = (0, utils_1.blobToStream)(await options.cache.getBlob(cacheKeys.content));
+    }
+    let size = 0;
+    contentStream = contentStream.pipe(
+    // @ts-expect-error TS2554
+    new utils_1.TapStream((buf) => {
+        size += buf.length;
+    }));
+    let configResult = (0, nullthrows_1.default)(
+    // @ts-expect-error TS2347
+    await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let config = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, options);
+    let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(api);
+    (0, DevDepRequest_1.invalidateDevDeps)(invalidDevDeps, options, config);
+    const bundleReplacements = (0, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs')
+        ? []
+        : undefined;
+    await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
+    const hasSourceMap = await options.cache.has(mapKey);
+    if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+        const mapEntry = await options.cache.getBlob(mapKey);
+        let mapStream;
+        if ((0, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs') &&
+            bundleReplacements &&
+            bundleReplacements.length > 0) {
+            mapStream = (0, utils_1.blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
+        }
+        else {
+            mapStream = (0, utils_1.blobToStream)(mapEntry);
+        }
+        await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, projectPath_1.toProjectPathUnsafe)((0, projectPath_1.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+    }
+    let res = {
+        filePath,
+        bundleId: bundle.id,
+        type: info.type,
+        stats: {
+            size,
+            time: info.time ?? 0,
+        },
+    };
+    api.storeResult(res);
+    return res;
+}
+function applyReplacementsToSourceMap(sourceMap, replacements) {
+    if (replacements.length === 0)
+        return;
+    const sorted = [...replacements].sort((a, b) => a.line - b.line || a.column - b.column);
+    for (const r of sorted) {
+        const delta = r.newLength - r.originalLength;
+        if (delta !== 0) {
+            // r.column is in post-replacement coordinates (matching the already-shifted
+            // source map state after previous offsetColumns calls). The end of the
+            // placeholder in these coordinates is simply r.column + r.originalLength.
+            const offsetStartColumn = r.column + r.originalLength;
+            const line1Based = r.line + 1;
+            if (line1Based >= 1 && offsetStartColumn + delta >= 0) {
+                sourceMap.offsetColumns(line1Based, offsetStartColumn, delta);
+            }
+        }
+    }
+}
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+function applyReplacementsToVLQMappings(mappings, replacements) {
+    if (replacements.length === 0)
+        return mappings;
+    // Group replacements by line (0-indexed), sorted by column ascending.
+    const byLine = new Map();
+    for (const r of replacements) {
+        let arr = byLine.get(r.line);
+        if (!arr) {
+            arr = [];
+            byLine.set(r.line, arr);
+        }
+        arr.push(r);
+    }
+    for (const arr of byLine.values()) {
+        arr.sort((a, b) => a.column - b.column);
+    }
+    const lines = mappings.split(';');
+    const resultLines = [];
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const lineReps = byLine.get(lineIdx);
+        if (!lineReps || lineReps.length === 0) {
+            resultLines.push(lines[lineIdx]);
+            continue;
+        }
+        const line = lines[lineIdx];
+        if (!line) {
+            resultLines.push('');
+            continue;
+        }
+        // Decode segment column deltas to absolute columns.
+        const segments = line.split(',');
+        const colVlqEnds = [];
+        const absCols = [];
+        let absCol = 0;
+        for (const seg of segments) {
+            const { value: colDelta, nextPos } = (0, source_map_1.decodeVLQ)(seg, 0);
+            absCol += colDelta;
+            colVlqEnds.push(nextPos);
+            absCols.push(absCol);
+        }
+        // Apply each replacement's column shift sequentially against the
+        // current absCol values (which have already been adjusted by previous
+        // replacements on this line), mirroring the sequential offsetColumns calls.
+        for (const r of lineReps) {
+            const delta = r.newLength - r.originalLength;
+            if (delta === 0)
+                continue;
+            const threshold = r.column + r.originalLength;
+            for (let i = 0; i < absCols.length; i++) {
+                if (absCols[i] >= threshold) {
+                    absCols[i] += delta;
+                }
+            }
+        }
+        // Re-encode with updated absolute columns; only the leading column VLQ
+        // field of each segment changes – the tail bytes are sliced unchanged.
+        const resultSegments = [];
+        let prevAbsCol = 0;
+        for (let i = 0; i < segments.length; i++) {
+            const newDelta = absCols[i] - prevAbsCol;
+            prevAbsCol = absCols[i];
+            resultSegments.push((0, source_map_1.encodeVLQ)(newDelta) + segments[i].slice(colVlqEnds[i]));
+        }
+        resultLines.push(resultSegments.join(','));
+    }
+    return resultLines.join(';');
+}
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+class SourceMapHashRefRewriteStream extends stream_1.Transform {
+    constructor(replacements) {
+        super();
+        this.replacements = replacements;
+        this.state = 'scanning';
+        this.scanBuf = Buffer.alloc(0);
+        this.mappingsBufs = [];
+    }
+    // @ts-expect-error TS7006
+    _transform(chunk, _encoding, cb) {
+        if (this.state === 'passthrough') {
+            this.push(chunk);
+            cb();
+            return;
+        }
+        if (this.state === 'scanning') {
+            const combined = Buffer.concat([this.scanBuf, chunk]);
+            const idx = combined.indexOf(MAPPINGS_KEY_BUF);
+            if (idx === -1) {
+                // Key not yet found – hold back enough bytes to handle a split key.
+                const keepLen = Math.min(combined.length, MAPPINGS_KEY_BUF.length - 1);
+                if (combined.length > keepLen) {
+                    this.push(combined.slice(0, combined.length - keepLen));
+                }
+                this.scanBuf = combined.slice(combined.length - keepLen);
+                cb();
+                return;
+            }
+            // Emit everything up to and including the key.
+            const keyEnd = idx + MAPPINGS_KEY_BUF.length;
+            this.push(combined.slice(0, keyEnd));
+            this.scanBuf = Buffer.alloc(0);
+            this.state = 'buffering';
+            this._bufferingTransform(combined.slice(keyEnd), cb);
+            return;
+        }
+        // state === 'buffering'
+        this._bufferingTransform(chunk, cb);
+    }
+    // @ts-expect-error TS7006
+    _bufferingTransform(chunk, cb) {
+        // Mappings values contain only base64 chars, ';', and ',' – no escaping –
+        // so scanning for the closing '"' (0x22) is safe.
+        const closeIdx = chunk.indexOf(0x22);
+        if (closeIdx === -1) {
+            this.mappingsBufs.push(chunk);
+            cb();
+            return;
+        }
+        this.mappingsBufs.push(chunk.slice(0, closeIdx));
+        // VLQ chars are all ASCII (<128), so latin1 round-trips without loss.
+        const mappingsStr = Buffer.concat(this.mappingsBufs).toString('latin1');
+        const rewritten = applyReplacementsToVLQMappings(mappingsStr, this.replacements);
+        this.push(Buffer.from(rewritten, 'latin1'));
+        // Emit the closing '"' and everything remaining in one push.
+        this.push(chunk.slice(closeIdx));
+        this.state = 'passthrough';
+        this.mappingsBufs = [];
+        cb();
+    }
+    // @ts-expect-error TS7006
+    _flush(cb) {
+        if (this.state === 'scanning' && this.scanBuf.length > 0) {
+            this.push(this.scanBuf);
+        }
+        else if (this.state === 'buffering') {
+            // Malformed JSON – flush whatever we buffered as-is.
+            this.push(Buffer.concat(this.mappingsBufs));
+        }
+        cb();
+    }
+}
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
+/**
+ * Computes the sourceRoot for a source map file. This is the relative path from
+ * the output directory back to the project root, so that source paths (stored
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+function computeSourceMapRoot(bundle, options) {
+    let name = (0, nullthrows_1.default)(bundle.name);
+    let filePath = (0, projectPath_1.joinProjectPath)(bundle.target.distDir, name);
+    let fullPath = (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath);
+    let sourceRoot = path_1.default.relative(path_1.default.dirname(fullPath), options.projectRoot);
+    let inlineSources = false;
+    const bundleEnv = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env);
+    if (bundle.target) {
+        const bundleTargetEnv = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.target.env);
+        if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+            sourceRoot = bundleEnv.sourceMap.sourceRoot;
+        }
+        else if (options.serveOptions && bundleTargetEnv.context === 'browser') {
+            sourceRoot = '/__parcel_source_root';
+        }
+        if (bundleEnv.sourceMap &&
+            bundleEnv.sourceMap.inlineSources !== undefined) {
+            inlineSources = bundleEnv.sourceMap.inlineSources;
+        }
+        else if (bundleTargetEnv.context !== 'node') {
+            inlineSources = options.mode === 'production';
+        }
+    }
+    let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
+    if ((0, feature_flags_1.getFeatureFlag)('omitSourcesContentInMemory') && !isInlineMap) {
+        if (!(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)) {
+            inlineSources = true;
+        }
+    }
+    if (inlineSources) {
+        return undefined;
+    }
+    return url_1.default.format(url_1.default.parse(sourceRoot + '/'));
+}
+async function writeFiles(
+// @ts-expect-error TS2503
+inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements) {
+    let compressors = await config.getCompressors((0, projectPath_1.fromProjectPathRelative)(filePath));
+    let fullPath = (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath);
+    let stream = info.hashReferences.length
+        ? inputStream.pipe(replaceStream(hashRefToNameHash, bundleReplacements))
+        : inputStream;
+    let promises = [];
+    for (let compressor of compressors) {
+        promises.push(
+        // @ts-expect-error TS2345
+        runCompressor(compressor, cloneStream(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
+    }
+    await Promise.all(promises);
+}
+async function runCompressor(compressor, 
+// @ts-expect-error TS2503
+stream, options, outputFS, filePath, writeOptions, devDeps, api) {
+    let measurement;
+    try {
+        measurement = profiler_1.tracer.createMeasurement(compressor.name, 'compress', path_1.default.relative(options.projectRoot, filePath));
+        let res = await compressor.plugin.compress({
+            stream,
+            options: new PluginOptions_1.default(options),
+            logger: new logger_1.PluginLogger({ origin: compressor.name }),
+            tracer: new profiler_1.PluginTracer({ origin: compressor.name, category: 'compress' }),
+        });
+        if (res != null) {
+            await new Promise((resolve, reject) => (0, stream_1.pipeline)(res.stream, outputFS.createWriteStream(filePath + (res.type != null ? '.' + res.type : ''), writeOptions), (err) => {
+                if (err)
+                    reject(err);
+                // @ts-expect-error TS2794
+                else
+                    resolve();
+            }));
+        }
+    }
+    catch (err) {
+        throw new diagnostic_1.default({
+            diagnostic: (0, diagnostic_1.errorToDiagnostic)(err, {
+                origin: compressor.name,
+            }),
+        });
+    }
+    finally {
+        measurement && measurement.end();
+        // Add dev deps for compressor plugins AFTER running them, to account for lazy require().
+        let devDepRequest = await (0, DevDepRequest_1.createDevDependency)({
+            specifier: compressor.name,
+            resolveFrom: compressor.resolveFrom,
+        }, devDeps, options);
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+}
+function advanceLineColumn(line, column, buf) {
+    for (let i = 0; i < buf.length; i++) {
+        if (buf[i] === 0x0a) {
+            line++;
+            column = 0;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column };
+}
+function replaceStream(hashRefToNameHash, replacements) {
+    let boundaryStr = Buffer.alloc(0);
+    let replaced = Buffer.alloc(0);
+    let outputLine = 0;
+    let outputColumn = 0;
+    return new stream_1.Transform({
+        transform(chunk, encoding, cb) {
+            let str = Buffer.concat([boundaryStr, Buffer.from(chunk)]);
+            let lastMatchI = 0;
+            if (replaced.length < str.byteLength) {
+                replaced = Buffer.alloc(str.byteLength);
+            }
+            let replacedLength = 0;
+            while (lastMatchI < str.byteLength) {
+                let matchI = str.indexOf(constants_1.HASH_REF_PREFIX, lastMatchI);
+                if (matchI === -1) {
+                    replaced.set(str.subarray(lastMatchI, str.byteLength), replacedLength);
+                    replacedLength += str.byteLength - lastMatchI;
+                    break;
+                }
+                else {
+                    let match = str
+                        .subarray(matchI, matchI + HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN)
+                        .toString();
+                    let replacement = Buffer.from(hashRefToNameHash.get(match) ?? match);
+                    // Copy pre-match content FIRST so position calculation includes it
+                    replaced.set(str.subarray(lastMatchI, matchI), replacedLength);
+                    replacedLength += matchI - lastMatchI;
+                    if (replacements) {
+                        const pos = advanceLineColumn(outputLine, outputColumn, replaced.subarray(0, replacedLength));
+                        replacements.push({
+                            line: pos.line,
+                            column: pos.column,
+                            originalLength: HASH_REF_PLACEHOLDER_LEN,
+                            newLength: replacement.byteLength,
+                        });
+                    }
+                    replaced.set(replacement, replacedLength);
+                    replacedLength += replacement.byteLength;
+                    lastMatchI = matchI + HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN;
+                }
+            }
+            const pushLen = replacedLength - BOUNDARY_LENGTH;
+            const pushed = advanceLineColumn(outputLine, outputColumn, replaced.subarray(0, pushLen));
+            outputLine = pushed.line;
+            outputColumn = pushed.column;
+            boundaryStr = replaced.subarray(replacedLength - BOUNDARY_LENGTH, replacedLength);
+            let strUpToBoundary = replaced.subarray(0, pushLen);
+            cb(null, strUpToBoundary);
+        },
+        flush(cb) {
+            cb(null, boundaryStr);
+        },
+    });
+}
+// @ts-expect-error TS2503
+function cloneStream(readable) {
+    let res = new stream_1.Readable();
+    res._read = () => { };
+    // @ts-expect-error TS7006
+    readable.on('data', (chunk) => res.push(chunk));
+    readable.on('end', () => res.push(null));
+    // @ts-expect-error TS7006
+    readable.on('error', (err) => res.emit('error', err));
+    return res;
+}