claude-autopm 2.12.3 → 3.0.1

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/clone.mjs

@@ -0,0 +1,64 @@
+/**
+ * Creates a deep copy of a process coverage.
+ *
+ * @param processCov Process coverage to clone.
+ * @return Cloned process coverage.
+ */
+export function cloneProcessCov(processCov) {
+    const result = [];
+    for (const scriptCov of processCov.result) {
+        result.push(cloneScriptCov(scriptCov));
+    }
+    return {
+        result,
+    };
+}
+/**
+ * Creates a deep copy of a script coverage.
+ *
+ * @param scriptCov Script coverage to clone.
+ * @return Cloned script coverage.
+ */
+export function cloneScriptCov(scriptCov) {
+    const functions = [];
+    for (const functionCov of scriptCov.functions) {
+        functions.push(cloneFunctionCov(functionCov));
+    }
+    return {
+        scriptId: scriptCov.scriptId,
+        url: scriptCov.url,
+        functions,
+    };
+}
+/**
+ * Creates a deep copy of a function coverage.
+ *
+ * @param functionCov Function coverage to clone.
+ * @return Cloned function coverage.
+ */
+export function cloneFunctionCov(functionCov) {
+    const ranges = [];
+    for (const rangeCov of functionCov.ranges) {
+        ranges.push(cloneRangeCov(rangeCov));
+    }
+    return {
+        functionName: functionCov.functionName,
+        ranges,
+        isBlockCoverage: functionCov.isBlockCoverage,
+    };
+}
+/**
+ * Creates a deep copy of a function coverage.
+ *
+ * @param rangeCov Range coverage to clone.
+ * @return Cloned range coverage.
+ */
+export function cloneRangeCov(rangeCov) {
+    return {
+        startOffset: rangeCov.startOffset,
+        endOffset: rangeCov.endOffset,
+        count: rangeCov.count,
+    };
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/compare.d.ts

@@ -0,0 +1,21 @@
+import { FunctionCov, RangeCov, ScriptCov } from "./types";
+/**
+ * Compares two script coverages.
+ *
+ * The result corresponds to the comparison of their `url` value (alphabetical sort).
+ */
+export declare function compareScriptCovs(a: Readonly<ScriptCov>, b: Readonly<ScriptCov>): number;
+/**
+ * Compares two function coverages.
+ *
+ * The result corresponds to the comparison of the root ranges.
+ */
+export declare function compareFunctionCovs(a: Readonly<FunctionCov>, b: Readonly<FunctionCov>): number;
+/**
+ * Compares two range coverages.
+ *
+ * The ranges are first ordered by ascending `startOffset` and then by
+ * descending `endOffset`.
+ * This corresponds to a pre-order tree traversal.
+ */
+export declare function compareRangeCovs(a: Readonly<RangeCov>, b: Readonly<RangeCov>): number;

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/compare.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Compares two script coverages.
+ *
+ * The result corresponds to the comparison of their `url` value (alphabetical sort).
+ */
+function compareScriptCovs(a, b) {
+    if (a.url === b.url) {
+        return 0;
+    }
+    else if (a.url < b.url) {
+        return -1;
+    }
+    else {
+        return 1;
+    }
+}
+exports.compareScriptCovs = compareScriptCovs;
+/**
+ * Compares two function coverages.
+ *
+ * The result corresponds to the comparison of the root ranges.
+ */
+function compareFunctionCovs(a, b) {
+    return compareRangeCovs(a.ranges[0], b.ranges[0]);
+}
+exports.compareFunctionCovs = compareFunctionCovs;
+/**
+ * Compares two range coverages.
+ *
+ * The ranges are first ordered by ascending `startOffset` and then by
+ * descending `endOffset`.
+ * This corresponds to a pre-order tree traversal.
+ */
+function compareRangeCovs(a, b) {
+    if (a.startOffset !== b.startOffset) {
+        return a.startOffset - b.startOffset;
+    }
+    else {
+        return b.endOffset - a.endOffset;
+    }
+}
+exports.compareRangeCovs = compareRangeCovs;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvY29tcGFyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBOzs7O0dBSUc7QUFDSCxTQUFnQixpQkFBaUIsQ0FBQyxDQUFzQixFQUFFLENBQXNCO0lBQzlFLElBQUksQ0FBQyxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUMsR0FBRyxFQUFFO1FBQ25CLE9BQU8sQ0FBQyxDQUFDO0tBQ1Y7U0FBTSxJQUFJLENBQUMsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRTtRQUN4QixPQUFPLENBQUMsQ0FBQyxDQUFDO0tBQ1g7U0FBTTtRQUNMLE9BQU8sQ0FBQyxDQUFDO0tBQ1Y7QUFDSCxDQUFDO0FBUkQsOENBUUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsbUJBQW1CLENBQUMsQ0FBd0IsRUFBRSxDQUF3QjtJQUNwRixPQUFPLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ3BELENBQUM7QUFGRCxrREFFQztBQUVEOzs7Ozs7R0FNRztBQUNILFNBQWdCLGdCQUFnQixDQUFDLENBQXFCLEVBQUUsQ0FBcUI7SUFDM0UsSUFBSSxDQUFDLENBQUMsV0FBVyxLQUFLLENBQUMsQ0FBQyxXQUFXLEVBQUU7UUFDbkMsT0FBTyxDQUFDLENBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQyxXQUFXLENBQUM7S0FDdEM7U0FBTTtRQUNMLE9BQU8sQ0FBQyxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQUMsU0FBUyxDQUFDO0tBQ2xDO0FBQ0gsQ0FBQztBQU5ELDRDQU1DIiwiZmlsZSI6ImNvbXBhcmUuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGdW5jdGlvbkNvdiwgUmFuZ2VDb3YsIFNjcmlwdENvdiB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbi8qKlxuICogQ29tcGFyZXMgdHdvIHNjcmlwdCBjb3ZlcmFnZXMuXG4gKlxuICogVGhlIHJlc3VsdCBjb3JyZXNwb25kcyB0byB0aGUgY29tcGFyaXNvbiBvZiB0aGVpciBgdXJsYCB2YWx1ZSAoYWxwaGFiZXRpY2FsIHNvcnQpLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY29tcGFyZVNjcmlwdENvdnMoYTogUmVhZG9ubHk8U2NyaXB0Q292PiwgYjogUmVhZG9ubHk8U2NyaXB0Q292Pik6IG51bWJlciB7XG4gIGlmIChhLnVybCA9PT0gYi51cmwpIHtcbiAgICByZXR1cm4gMDtcbiAgfSBlbHNlIGlmIChhLnVybCA8IGIudXJsKSB7XG4gICAgcmV0dXJuIC0xO1xuICB9IGVsc2Uge1xuICAgIHJldHVybiAxO1xuICB9XG59XG5cbi8qKlxuICogQ29tcGFyZXMgdHdvIGZ1bmN0aW9uIGNvdmVyYWdlcy5cbiAqXG4gKiBUaGUgcmVzdWx0IGNvcnJlc3BvbmRzIHRvIHRoZSBjb21wYXJpc29uIG9mIHRoZSByb290IHJhbmdlcy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvbXBhcmVGdW5jdGlvbkNvdnMoYTogUmVhZG9ubHk8RnVuY3Rpb25Db3Y+LCBiOiBSZWFkb25seTxGdW5jdGlvbkNvdj4pOiBudW1iZXIge1xuICByZXR1cm4gY29tcGFyZVJhbmdlQ292cyhhLnJhbmdlc1swXSwgYi5yYW5nZXNbMF0pO1xufVxuXG4vKipcbiAqIENvbXBhcmVzIHR3byByYW5nZSBjb3ZlcmFnZXMuXG4gKlxuICogVGhlIHJhbmdlcyBhcmUgZmlyc3Qgb3JkZXJlZCBieSBhc2NlbmRpbmcgYHN0YXJ0T2Zmc2V0YCBhbmQgdGhlbiBieVxuICogZGVzY2VuZGluZyBgZW5kT2Zmc2V0YC5cbiAqIFRoaXMgY29ycmVzcG9uZHMgdG8gYSBwcmUtb3JkZXIgdHJlZSB0cmF2ZXJzYWwuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjb21wYXJlUmFuZ2VDb3ZzKGE6IFJlYWRvbmx5PFJhbmdlQ292PiwgYjogUmVhZG9ubHk8UmFuZ2VDb3Y+KTogbnVtYmVyIHtcbiAgaWYgKGEuc3RhcnRPZmZzZXQgIT09IGIuc3RhcnRPZmZzZXQpIHtcbiAgICByZXR1cm4gYS5zdGFydE9mZnNldCAtIGIuc3RhcnRPZmZzZXQ7XG4gIH0gZWxzZSB7XG4gICAgcmV0dXJuIGIuZW5kT2Zmc2V0IC0gYS5lbmRPZmZzZXQ7XG4gIH1cbn1cbiJdLCJzb3VyY2VSb290IjoiIn0=

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/compare.mjs

@@ -0,0 +1,41 @@
+/**
+ * Compares two script coverages.
+ *
+ * The result corresponds to the comparison of their `url` value (alphabetical sort).
+ */
+export function compareScriptCovs(a, b) {
+    if (a.url === b.url) {
+        return 0;
+    }
+    else if (a.url < b.url) {
+        return -1;
+    }
+    else {
+        return 1;
+    }
+}
+/**
+ * Compares two function coverages.
+ *
+ * The result corresponds to the comparison of the root ranges.
+ */
+export function compareFunctionCovs(a, b) {
+    return compareRangeCovs(a.ranges[0], b.ranges[0]);
+}
+/**
+ * Compares two range coverages.
+ *
+ * The ranges are first ordered by ascending `startOffset` and then by
+ * descending `endOffset`.
+ * This corresponds to a pre-order tree traversal.
+ */
+export function compareRangeCovs(a, b) {
+    if (a.startOffset !== b.startOffset) {
+        return a.startOffset - b.startOffset;
+    }
+    else {
+        return b.endOffset - a.endOffset;
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { emitForest, emitForestLines, parseFunctionRanges, parseOffsets } from "./ascii";
+export { cloneFunctionCov, cloneProcessCov, cloneScriptCov, cloneRangeCov } from "./clone";
+export { compareScriptCovs, compareFunctionCovs, compareRangeCovs } from "./compare";
+export { mergeFunctionCovs, mergeProcessCovs, mergeScriptCovs } from "./merge";
+export { RangeTree } from "./range-tree";
+export { ProcessCov, ScriptCov, FunctionCov, RangeCov } from "./types";

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ascii_1 = require("./ascii");
+exports.emitForest = ascii_1.emitForest;
+exports.emitForestLines = ascii_1.emitForestLines;
+exports.parseFunctionRanges = ascii_1.parseFunctionRanges;
+exports.parseOffsets = ascii_1.parseOffsets;
+var clone_1 = require("./clone");
+exports.cloneFunctionCov = clone_1.cloneFunctionCov;
+exports.cloneProcessCov = clone_1.cloneProcessCov;
+exports.cloneScriptCov = clone_1.cloneScriptCov;
+exports.cloneRangeCov = clone_1.cloneRangeCov;
+var compare_1 = require("./compare");
+exports.compareScriptCovs = compare_1.compareScriptCovs;
+exports.compareFunctionCovs = compare_1.compareFunctionCovs;
+exports.compareRangeCovs = compare_1.compareRangeCovs;
+var merge_1 = require("./merge");
+exports.mergeFunctionCovs = merge_1.mergeFunctionCovs;
+exports.mergeProcessCovs = merge_1.mergeProcessCovs;
+exports.mergeScriptCovs = merge_1.mergeScriptCovs;
+var range_tree_1 = require("./range-tree");
+exports.RangeTree = range_tree_1.RangeTree;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxpQ0FBeUY7QUFBaEYsNkJBQUEsVUFBVSxDQUFBO0FBQUUsa0NBQUEsZUFBZSxDQUFBO0FBQUUsc0NBQUEsbUJBQW1CLENBQUE7QUFBRSwrQkFBQSxZQUFZLENBQUE7QUFDdkUsaUNBQTJGO0FBQWxGLG1DQUFBLGdCQUFnQixDQUFBO0FBQUUsa0NBQUEsZUFBZSxDQUFBO0FBQUUsaUNBQUEsY0FBYyxDQUFBO0FBQUUsZ0NBQUEsYUFBYSxDQUFBO0FBQ3pFLHFDQUFxRjtBQUE1RSxzQ0FBQSxpQkFBaUIsQ0FBQTtBQUFFLHdDQUFBLG1CQUFtQixDQUFBO0FBQUUscUNBQUEsZ0JBQWdCLENBQUE7QUFDakUsaUNBQStFO0FBQXRFLG9DQUFBLGlCQUFpQixDQUFBO0FBQUUsbUNBQUEsZ0JBQWdCLENBQUE7QUFBRSxrQ0FBQSxlQUFlLENBQUE7QUFDN0QsMkNBQXlDO0FBQWhDLGlDQUFBLFNBQVMsQ0FBQSIsImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGVtaXRGb3Jlc3QsIGVtaXRGb3Jlc3RMaW5lcywgcGFyc2VGdW5jdGlvblJhbmdlcywgcGFyc2VPZmZzZXRzIH0gZnJvbSBcIi4vYXNjaWlcIjtcbmV4cG9ydCB7IGNsb25lRnVuY3Rpb25Db3YsIGNsb25lUHJvY2Vzc0NvdiwgY2xvbmVTY3JpcHRDb3YsIGNsb25lUmFuZ2VDb3YgfSBmcm9tIFwiLi9jbG9uZVwiO1xuZXhwb3J0IHsgY29tcGFyZVNjcmlwdENvdnMsIGNvbXBhcmVGdW5jdGlvbkNvdnMsIGNvbXBhcmVSYW5nZUNvdnMgfSBmcm9tIFwiLi9jb21wYXJlXCI7XG5leHBvcnQgeyBtZXJnZUZ1bmN0aW9uQ292cywgbWVyZ2VQcm9jZXNzQ292cywgbWVyZ2VTY3JpcHRDb3ZzIH0gZnJvbSBcIi4vbWVyZ2VcIjtcbmV4cG9ydCB7IFJhbmdlVHJlZSB9IGZyb20gXCIuL3JhbmdlLXRyZWVcIjtcbmV4cG9ydCB7IFByb2Nlc3NDb3YsIFNjcmlwdENvdiwgRnVuY3Rpb25Db3YsIFJhbmdlQ292IH0gZnJvbSBcIi4vdHlwZXNcIjtcbiJdLCJzb3VyY2VSb290IjoiIn0=

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/index.mjs

@@ -0,0 +1,7 @@
+export { emitForest, emitForestLines, parseFunctionRanges, parseOffsets } from "./ascii";
+export { cloneFunctionCov, cloneProcessCov, cloneScriptCov, cloneRangeCov } from "./clone";
+export { compareScriptCovs, compareFunctionCovs, compareRangeCovs } from "./compare";
+export { mergeFunctionCovs, mergeProcessCovs, mergeScriptCovs } from "./merge";
+export { RangeTree } from "./range-tree";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQUUsWUFBWSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3pGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLGFBQWEsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUMzRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsbUJBQW1CLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDckYsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUMvRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sY0FBYyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZW1pdEZvcmVzdCwgZW1pdEZvcmVzdExpbmVzLCBwYXJzZUZ1bmN0aW9uUmFuZ2VzLCBwYXJzZU9mZnNldHMgfSBmcm9tIFwiLi9hc2NpaVwiO1xuZXhwb3J0IHsgY2xvbmVGdW5jdGlvbkNvdiwgY2xvbmVQcm9jZXNzQ292LCBjbG9uZVNjcmlwdENvdiwgY2xvbmVSYW5nZUNvdiB9IGZyb20gXCIuL2Nsb25lXCI7XG5leHBvcnQgeyBjb21wYXJlU2NyaXB0Q292cywgY29tcGFyZUZ1bmN0aW9uQ292cywgY29tcGFyZVJhbmdlQ292cyB9IGZyb20gXCIuL2NvbXBhcmVcIjtcbmV4cG9ydCB7IG1lcmdlRnVuY3Rpb25Db3ZzLCBtZXJnZVByb2Nlc3NDb3ZzLCBtZXJnZVNjcmlwdENvdnMgfSBmcm9tIFwiLi9tZXJnZVwiO1xuZXhwb3J0IHsgUmFuZ2VUcmVlIH0gZnJvbSBcIi4vcmFuZ2UtdHJlZVwiO1xuZXhwb3J0IHsgUHJvY2Vzc0NvdiwgU2NyaXB0Q292LCBGdW5jdGlvbkNvdiwgUmFuZ2VDb3YgfSBmcm9tIFwiLi90eXBlc1wiO1xuIl0sInNvdXJjZVJvb3QiOiIifQ==

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/merge.d.ts

@@ -0,0 +1,39 @@
+import { FunctionCov, ProcessCov, ScriptCov } from "./types";
+/**
+ * Merges a list of process coverages.
+ *
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param processCovs Process coverages to merge.
+ * @return Merged process coverage.
+ */
+export declare function mergeProcessCovs(processCovs: ReadonlyArray<ProcessCov>): ProcessCov;
+/**
+ * Merges a list of matching script coverages.
+ *
+ * Scripts are matching if they have the same `url`.
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param scriptCovs Process coverages to merge.
+ * @return Merged script coverage, or `undefined` if the input list was empty.
+ */
+export declare function mergeScriptCovs(scriptCovs: ReadonlyArray<ScriptCov>): ScriptCov | undefined;
+/**
+ * Merges a list of matching function coverages.
+ *
+ * Functions are matching if their root ranges have the same span.
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param funcCovs Function coverages to merge.
+ * @return Merged function coverage, or `undefined` if the input list was empty.
+ */
+export declare function mergeFunctionCovs(funcCovs: ReadonlyArray<FunctionCov>): FunctionCov | undefined;

package/packages/plugin-devops/node_modules/@bcoe/v8-coverage/dist/lib/merge.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalize_1 = require("./normalize");
+const range_tree_1 = require("./range-tree");
+/**
+ * Merges a list of process coverages.
+ *
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param processCovs Process coverages to merge.
+ * @return Merged process coverage.
+ */
+function mergeProcessCovs(processCovs) {
+    if (processCovs.length === 0) {
+        return { result: [] };
+    }
+    const urlToScripts = new Map();
+    for (const processCov of processCovs) {
+        for (const scriptCov of processCov.result) {
+            let scriptCovs = urlToScripts.get(scriptCov.url);
+            if (scriptCovs === undefined) {
+                scriptCovs = [];
+                urlToScripts.set(scriptCov.url, scriptCovs);
+            }
+            scriptCovs.push(scriptCov);
+        }
+    }
+    const result = [];
+    for (const scripts of urlToScripts.values()) {
+        // assert: `scripts.length > 0`
+        result.push(mergeScriptCovs(scripts));
+    }
+    const merged = { result };
+    normalize_1.normalizeProcessCov(merged);
+    return merged;
+}
+exports.mergeProcessCovs = mergeProcessCovs;
+/**
+ * Merges a list of matching script coverages.
+ *
+ * Scripts are matching if they have the same `url`.
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param scriptCovs Process coverages to merge.
+ * @return Merged script coverage, or `undefined` if the input list was empty.
+ */
+function mergeScriptCovs(scriptCovs) {
+    if (scriptCovs.length === 0) {
+        return undefined;
+    }
+    else if (scriptCovs.length === 1) {
+        const merged = scriptCovs[0];
+        normalize_1.deepNormalizeScriptCov(merged);
+        return merged;
+    }
+    const first = scriptCovs[0];
+    const scriptId = first.scriptId;
+    const url = first.url;
+    const rangeToFuncs = new Map();
+    for (const scriptCov of scriptCovs) {
+        for (const funcCov of scriptCov.functions) {
+            const rootRange = stringifyFunctionRootRange(funcCov);
+            let funcCovs = rangeToFuncs.get(rootRange);
+            if (funcCovs === undefined ||
+                // if the entry in rangeToFuncs is function-level granularity and
+                // the new coverage is block-level, prefer block-level.
+                (!funcCovs[0].isBlockCoverage && funcCov.isBlockCoverage)) {
+                funcCovs = [];
+                rangeToFuncs.set(rootRange, funcCovs);
+            }
+            else if (funcCovs[0].isBlockCoverage && !funcCov.isBlockCoverage) {
+                // if the entry in rangeToFuncs is block-level granularity, we should
+                // not append function level granularity.
+                continue;
+            }
+            funcCovs.push(funcCov);
+        }
+    }
+    const functions = [];
+    for (const funcCovs of rangeToFuncs.values()) {
+        // assert: `funcCovs.length > 0`
+        functions.push(mergeFunctionCovs(funcCovs));
+    }
+    const merged = { scriptId, url, functions };
+    normalize_1.normalizeScriptCov(merged);
+    return merged;
+}
+exports.mergeScriptCovs = mergeScriptCovs;
+/**
+ * Returns a string representation of the root range of the function.
+ *
+ * This string can be used to match function with same root range.
+ * The string is derived from the start and end offsets of the root range of
+ * the function.
+ * This assumes that `ranges` is non-empty (true for valid function coverages).
+ *
+ * @param funcCov Function coverage with the range to stringify
+ * @internal
+ */
+function stringifyFunctionRootRange(funcCov) {
+    const rootRange = funcCov.ranges[0];
+    return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`;
+}
+/**
+ * Merges a list of matching function coverages.
+ *
+ * Functions are matching if their root ranges have the same span.
+ * The result is normalized.
+ * The input values may be mutated, it is not safe to use them after passing
+ * them to this function.
+ * The computation is synchronous.
+ *
+ * @param funcCovs Function coverages to merge.
+ * @return Merged function coverage, or `undefined` if the input list was empty.
+ */
+function mergeFunctionCovs(funcCovs) {
+    if (funcCovs.length === 0) {
+        return undefined;
+    }
+    else if (funcCovs.length === 1) {
+        const merged = funcCovs[0];
+        normalize_1.normalizeFunctionCov(merged);
+        return merged;
+    }
+    const functionName = funcCovs[0].functionName;
+    const trees = [];
+    for (const funcCov of funcCovs) {
+        // assert: `fn.ranges.length > 0`
+        // assert: `fn.ranges` is sorted
+        trees.push(range_tree_1.RangeTree.fromSortedRanges(funcCov.ranges));
+    }
+    // assert: `trees.length > 0`
+    const mergedTree = mergeRangeTrees(trees);
+    normalize_1.normalizeRangeTree(mergedTree);
+    const ranges = mergedTree.toRanges();
+    const isBlockCoverage = !(ranges.length === 1 && ranges[0].count === 0);
+    const merged = { functionName, ranges, isBlockCoverage };
+    // assert: `merged` is normalized
+    return merged;
+}
+exports.mergeFunctionCovs = mergeFunctionCovs;
+/**
+ * @precondition Same `start` and `end` for all the trees
+ */
+function mergeRangeTrees(trees) {
+    if (trees.length <= 1) {
+        return trees[0];
+    }
+    const first = trees[0];
+    let delta = 0;
+    for (const tree of trees) {
+        delta += tree.delta;
+    }
+    const children = mergeRangeTreeChildren(trees);
+    return new range_tree_1.RangeTree(first.start, first.end, delta, children);
+}
+class RangeTreeWithParent {
+    constructor(parentIndex, tree) {
+        this.parentIndex = parentIndex;
+        this.tree = tree;
+    }
+}
+class StartEvent {
+    constructor(offset, trees) {
+        this.offset = offset;
+        this.trees = trees;
+    }
+    static compare(a, b) {
+        return a.offset - b.offset;
+    }
+}
+class StartEventQueue {
+    constructor(queue) {
+        this.queue = queue;
+        this.nextIndex = 0;
+        this.pendingOffset = 0;
+        this.pendingTrees = undefined;
+    }
+    static fromParentTrees(parentTrees) {
+        const startToTrees = new Map();
+        for (const [parentIndex, parentTree] of parentTrees.entries()) {
+            for (const child of parentTree.children) {
+                let trees = startToTrees.get(child.start);
+                if (trees === undefined) {
+                    trees = [];
+                    startToTrees.set(child.start, trees);
+                }
+                trees.push(new RangeTreeWithParent(parentIndex, child));
+            }
+        }
+        const queue = [];
+        for (const [startOffset, trees] of startToTrees) {
+            queue.push(new StartEvent(startOffset, trees));
+        }
+        queue.sort(StartEvent.compare);
+        return new StartEventQueue(queue);
+    }
+    setPendingOffset(offset) {
+        this.pendingOffset = offset;
+    }
+    pushPendingTree(tree) {
+        if (this.pendingTrees === undefined) {
+            this.pendingTrees = [];
+        }
+        this.pendingTrees.push(tree);
+    }
+    next() {
+        const pendingTrees = this.pendingTrees;
+        const nextEvent = this.queue[this.nextIndex];
+        if (pendingTrees === undefined) {
+            this.nextIndex++;
+            return nextEvent;
+        }
+        else if (nextEvent === undefined) {
+            this.pendingTrees = undefined;
+            return new StartEvent(this.pendingOffset, pendingTrees);
+        }
+        else {
+            if (this.pendingOffset < nextEvent.offset) {
+                this.pendingTrees = undefined;
+                return new StartEvent(this.pendingOffset, pendingTrees);
+            }
+            else {
+                if (this.pendingOffset === nextEvent.offset) {
+                    this.pendingTrees = undefined;
+                    for (const tree of pendingTrees) {
+                        nextEvent.trees.push(tree);
+                    }
+                }
+                this.nextIndex++;
+                return nextEvent;
+            }
+        }
+    }
+}
+function mergeRangeTreeChildren(parentTrees) {
+    const result = [];
+    const startEventQueue = StartEventQueue.fromParentTrees(parentTrees);
+    const parentToNested = new Map();
+    let openRange;
+    while (true) {
+        const event = startEventQueue.next();
+        if (event === undefined) {
+            break;
+        }
+        if (openRange !== undefined && openRange.end <= event.offset) {
+            result.push(nextChild(openRange, parentToNested));
+            openRange = undefined;
+        }
+        if (openRange === undefined) {
+            let openRangeEnd = event.offset + 1;
+            for (const { parentIndex, tree } of event.trees) {
+                openRangeEnd = Math.max(openRangeEnd, tree.end);
+                insertChild(parentToNested, parentIndex, tree);
+            }
+            startEventQueue.setPendingOffset(openRangeEnd);
+            openRange = { start: event.offset, end: openRangeEnd };
+        }
+        else {
+            for (const { parentIndex, tree } of event.trees) {
+                if (tree.end > openRange.end) {
+                    const right = tree.split(openRange.end);
+                    startEventQueue.pushPendingTree(new RangeTreeWithParent(parentIndex, right));
+                }
+                insertChild(parentToNested, parentIndex, tree);
+            }
+        }
+    }
+    if (openRange !== undefined) {
+        result.push(nextChild(openRange, parentToNested));
+    }
+    return result;
+}
+function insertChild(parentToNested, parentIndex, tree) {
+    let nested = parentToNested.get(parentIndex);
+    if (nested === undefined) {
+        nested = [];
+        parentToNested.set(parentIndex, nested);
+    }
+    nested.push(tree);
+}
+function nextChild(openRange, parentToNested) {
+    const matchingTrees = [];
+    for (const nested of parentToNested.values()) {
+        if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) {
+            matchingTrees.push(nested[0]);
+        }
+        else {
+            matchingTrees.push(new range_tree_1.RangeTree(openRange.start, openRange.end, 0, nested));
+        }
+    }
+    parentToNested.clear();
+    return mergeRangeTrees(matchingTrees);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/merge.ts"],"names":[],"mappings":"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","file":"merge.js","sourcesContent":["import {\n  deepNormalizeScriptCov,\n  normalizeFunctionCov,\n  normalizeProcessCov,\n  normalizeRangeTree,\n  normalizeScriptCov,\n} from \"./normalize\";\nimport { RangeTree } from \"./range-tree\";\nimport { FunctionCov, ProcessCov, Range, RangeCov, ScriptCov } from \"./types\";\n\n/**\n * Merges a list of process coverages.\n *\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param processCovs Process coverages to merge.\n * @return Merged process coverage.\n */\nexport function mergeProcessCovs(processCovs: ReadonlyArray<ProcessCov>): ProcessCov {\n  if (processCovs.length === 0) {\n    return {result: []};\n  }\n\n  const urlToScripts: Map<string, ScriptCov[]> = new Map();\n  for (const processCov of processCovs) {\n    for (const scriptCov of processCov.result) {\n      let scriptCovs: ScriptCov[] | undefined = urlToScripts.get(scriptCov.url);\n      if (scriptCovs === undefined) {\n        scriptCovs = [];\n        urlToScripts.set(scriptCov.url, scriptCovs);\n      }\n      scriptCovs.push(scriptCov);\n    }\n  }\n\n  const result: ScriptCov[] = [];\n  for (const scripts of urlToScripts.values()) {\n    // assert: `scripts.length > 0`\n    result.push(mergeScriptCovs(scripts)!);\n  }\n  const merged: ProcessCov = {result};\n\n  normalizeProcessCov(merged);\n  return merged;\n}\n\n/**\n * Merges a list of matching script coverages.\n *\n * Scripts are matching if they have the same `url`.\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param scriptCovs Process coverages to merge.\n * @return Merged script coverage, or `undefined` if the input list was empty.\n */\nexport function mergeScriptCovs(scriptCovs: ReadonlyArray<ScriptCov>): ScriptCov | undefined {\n  if (scriptCovs.length === 0) {\n    return undefined;\n  } else if (scriptCovs.length === 1) {\n    const merged: ScriptCov = scriptCovs[0];\n    deepNormalizeScriptCov(merged);\n    return merged;\n  }\n\n  const first: ScriptCov = scriptCovs[0];\n  const scriptId: string = first.scriptId;\n  const url: string = first.url;\n\n  const rangeToFuncs: Map<string, FunctionCov[]> = new Map();\n  for (const scriptCov of scriptCovs) {\n    for (const funcCov of scriptCov.functions) {\n      const rootRange: string = stringifyFunctionRootRange(funcCov);\n      let funcCovs: FunctionCov[] | undefined = rangeToFuncs.get(rootRange);\n\n      if (funcCovs === undefined ||\n        // if the entry in rangeToFuncs is function-level granularity and\n        // the new coverage is block-level, prefer block-level.\n        (!funcCovs[0].isBlockCoverage && funcCov.isBlockCoverage)) {\n        funcCovs = [];\n        rangeToFuncs.set(rootRange, funcCovs);\n      } else if (funcCovs[0].isBlockCoverage && !funcCov.isBlockCoverage) {\n        // if the entry in rangeToFuncs is block-level granularity, we should\n        // not append function level granularity.\n        continue;\n      }\n      funcCovs.push(funcCov);\n    }\n  }\n\n  const functions: FunctionCov[] = [];\n  for (const funcCovs of rangeToFuncs.values()) {\n    // assert: `funcCovs.length > 0`\n    functions.push(mergeFunctionCovs(funcCovs)!);\n  }\n\n  const merged: ScriptCov = {scriptId, url, functions};\n  normalizeScriptCov(merged);\n  return merged;\n}\n\n/**\n * Returns a string representation of the root range of the function.\n *\n * This string can be used to match function with same root range.\n * The string is derived from the start and end offsets of the root range of\n * the function.\n * This assumes that `ranges` is non-empty (true for valid function coverages).\n *\n * @param funcCov Function coverage with the range to stringify\n * @internal\n */\nfunction stringifyFunctionRootRange(funcCov: Readonly<FunctionCov>): string {\n  const rootRange: RangeCov = funcCov.ranges[0];\n  return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`;\n}\n\n/**\n * Merges a list of matching function coverages.\n *\n * Functions are matching if their root ranges have the same span.\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param funcCovs Function coverages to merge.\n * @return Merged function coverage, or `undefined` if the input list was empty.\n */\nexport function mergeFunctionCovs(funcCovs: ReadonlyArray<FunctionCov>): FunctionCov | undefined {\n  if (funcCovs.length === 0) {\n    return undefined;\n  } else if (funcCovs.length === 1) {\n    const merged: FunctionCov = funcCovs[0];\n    normalizeFunctionCov(merged);\n    return merged;\n  }\n\n  const functionName: string = funcCovs[0].functionName;\n\n  const trees: RangeTree[] = [];\n  for (const funcCov of funcCovs) {\n    // assert: `fn.ranges.length > 0`\n    // assert: `fn.ranges` is sorted\n    trees.push(RangeTree.fromSortedRanges(funcCov.ranges)!);\n  }\n\n  // assert: `trees.length > 0`\n  const mergedTree: RangeTree = mergeRangeTrees(trees)!;\n  normalizeRangeTree(mergedTree);\n  const ranges: RangeCov[] = mergedTree.toRanges();\n  const isBlockCoverage: boolean = !(ranges.length === 1 && ranges[0].count === 0);\n\n  const merged: FunctionCov = {functionName, ranges, isBlockCoverage};\n  // assert: `merged` is normalized\n  return merged;\n}\n\n/**\n * @precondition Same `start` and `end` for all the trees\n */\nfunction mergeRangeTrees(trees: ReadonlyArray<RangeTree>): RangeTree | undefined {\n  if (trees.length <= 1) {\n    return trees[0];\n  }\n  const first: RangeTree = trees[0];\n  let delta: number = 0;\n  for (const tree of trees) {\n    delta += tree.delta;\n  }\n  const children: RangeTree[] = mergeRangeTreeChildren(trees);\n  return new RangeTree(first.start, first.end, delta, children);\n}\n\nclass RangeTreeWithParent {\n  readonly parentIndex: number;\n  readonly tree: RangeTree;\n\n  constructor(parentIndex: number, tree: RangeTree) {\n    this.parentIndex = parentIndex;\n    this.tree = tree;\n  }\n}\n\nclass StartEvent {\n  readonly offset: number;\n  readonly trees: RangeTreeWithParent[];\n\n  constructor(offset: number, trees: RangeTreeWithParent[]) {\n    this.offset = offset;\n    this.trees = trees;\n  }\n\n  static compare(a: StartEvent, b: StartEvent): number {\n    return a.offset - b.offset;\n  }\n}\n\nclass StartEventQueue {\n  private readonly queue: StartEvent[];\n  private nextIndex: number;\n  private pendingOffset: number;\n  private pendingTrees: RangeTreeWithParent[] | undefined;\n\n  private constructor(queue: StartEvent[]) {\n    this.queue = queue;\n    this.nextIndex = 0;\n    this.pendingOffset = 0;\n    this.pendingTrees = undefined;\n  }\n\n  static fromParentTrees(parentTrees: ReadonlyArray<RangeTree>): StartEventQueue {\n    const startToTrees: Map<number, RangeTreeWithParent[]> = new Map();\n    for (const [parentIndex, parentTree] of parentTrees.entries()) {\n      for (const child of parentTree.children) {\n        let trees: RangeTreeWithParent[] | undefined = startToTrees.get(child.start);\n        if (trees === undefined) {\n          trees = [];\n          startToTrees.set(child.start, trees);\n        }\n        trees.push(new RangeTreeWithParent(parentIndex, child));\n      }\n    }\n    const queue: StartEvent[] = [];\n    for (const [startOffset, trees] of startToTrees) {\n      queue.push(new StartEvent(startOffset, trees));\n    }\n    queue.sort(StartEvent.compare);\n    return new StartEventQueue(queue);\n  }\n\n  setPendingOffset(offset: number): void {\n    this.pendingOffset = offset;\n  }\n\n  pushPendingTree(tree: RangeTreeWithParent): void {\n    if (this.pendingTrees === undefined) {\n      this.pendingTrees = [];\n    }\n    this.pendingTrees.push(tree);\n  }\n\n  next(): StartEvent | undefined {\n    const pendingTrees: RangeTreeWithParent[] | undefined = this.pendingTrees;\n    const nextEvent: StartEvent | undefined = this.queue[this.nextIndex];\n    if (pendingTrees === undefined) {\n      this.nextIndex++;\n      return nextEvent;\n    } else if (nextEvent === undefined) {\n      this.pendingTrees = undefined;\n      return new StartEvent(this.pendingOffset, pendingTrees);\n    } else {\n      if (this.pendingOffset < nextEvent.offset) {\n        this.pendingTrees = undefined;\n        return new StartEvent(this.pendingOffset, pendingTrees);\n      } else {\n        if (this.pendingOffset === nextEvent.offset) {\n          this.pendingTrees = undefined;\n          for (const tree of pendingTrees) {\n            nextEvent.trees.push(tree);\n          }\n        }\n        this.nextIndex++;\n        return nextEvent;\n      }\n    }\n  }\n}\n\nfunction mergeRangeTreeChildren(parentTrees: ReadonlyArray<RangeTree>): RangeTree[] {\n  const result: RangeTree[] = [];\n  const startEventQueue: StartEventQueue = StartEventQueue.fromParentTrees(parentTrees);\n  const parentToNested: Map<number, RangeTree[]> = new Map();\n  let openRange: Range | undefined;\n\n  while (true) {\n    const event: StartEvent | undefined = startEventQueue.next();\n    if (event === undefined) {\n      break;\n    }\n\n    if (openRange !== undefined && openRange.end <= event.offset) {\n      result.push(nextChild(openRange, parentToNested));\n      openRange = undefined;\n    }\n\n    if (openRange === undefined) {\n      let openRangeEnd: number = event.offset + 1;\n      for (const {parentIndex, tree} of event.trees) {\n        openRangeEnd = Math.max(openRangeEnd, tree.end);\n        insertChild(parentToNested, parentIndex, tree);\n      }\n      startEventQueue.setPendingOffset(openRangeEnd);\n      openRange = {start: event.offset, end: openRangeEnd};\n    } else {\n      for (const {parentIndex, tree} of event.trees) {\n        if (tree.end > openRange.end) {\n          const right: RangeTree = tree.split(openRange.end);\n          startEventQueue.pushPendingTree(new RangeTreeWithParent(parentIndex, right));\n        }\n        insertChild(parentToNested, parentIndex, tree);\n      }\n    }\n  }\n  if (openRange !== undefined) {\n    result.push(nextChild(openRange, parentToNested));\n  }\n\n  return result;\n}\n\nfunction insertChild(parentToNested: Map<number, RangeTree[]>, parentIndex: number, tree: RangeTree): void {\n  let nested: RangeTree[] | undefined = parentToNested.get(parentIndex);\n  if (nested === undefined) {\n    nested = [];\n    parentToNested.set(parentIndex, nested);\n  }\n  nested.push(tree);\n}\n\nfunction nextChild(openRange: Range, parentToNested: Map<number, RangeTree[]>): RangeTree {\n  const matchingTrees: RangeTree[] = [];\n\n  for (const nested of parentToNested.values()) {\n    if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) {\n      matchingTrees.push(nested[0]);\n    } else {\n      matchingTrees.push(new RangeTree(\n        openRange.start,\n        openRange.end,\n        0,\n        nested,\n      ));\n    }\n  }\n  parentToNested.clear();\n  return mergeRangeTrees(matchingTrees)!;\n}\n"],"sourceRoot":""}