claude-flow-novice 1.5.16 → 1.5.18

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/merge.js

@@ -0,0 +1,304 @@
+import { deepNormalizeScriptCov, normalizeFunctionCov, normalizeProcessCov, normalizeRangeTree, normalizeScriptCov } from "./normalize";
+import { RangeTree } from "./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.
+ */ export 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
+    };
+    normalizeProcessCov(merged);
+    return merged;
+}
+/**
+ * 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 function mergeScriptCovs(scriptCovs) {
+    if (scriptCovs.length === 0) {
+        return undefined;
+    } else if (scriptCovs.length === 1) {
+        const merged = scriptCovs[0];
+        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) {
+                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
+    };
+    normalizeScriptCov(merged);
+    return merged;
+}
+/**
+ * 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.
+ */ export function mergeFunctionCovs(funcCovs) {
+    if (funcCovs.length === 0) {
+        return undefined;
+    } else if (funcCovs.length === 1) {
+        const merged = funcCovs[0];
+        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(RangeTree.fromSortedRanges(funcCov.ranges));
+    }
+    // assert: `trees.length > 0`
+    const mergedTree = mergeRangeTrees(trees);
+    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;
+}
+/**
+ * @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 RangeTree(first.start, first.end, delta, children);
+}
+let RangeTreeWithParent = class RangeTreeWithParent {
+    parentIndex;
+    tree;
+    constructor(parentIndex, tree){
+        this.parentIndex = parentIndex;
+        this.tree = tree;
+    }
+};
+let StartEvent = class StartEvent {
+    offset;
+    trees;
+    constructor(offset, trees){
+        this.offset = offset;
+        this.trees = trees;
+    }
+    static compare(a, b) {
+        return a.offset - b.offset;
+    }
+};
+let StartEventQueue = class StartEventQueue {
+    queue;
+    nextIndex;
+    pendingOffset;
+    pendingTrees;
+    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 RangeTree(openRange.start, openRange.end, 0, nested));
+        }
+    }
+    parentToNested.clear();
+    return mergeRangeTrees(matchingTrees);
+}
+
+//# sourceMappingURL=merge.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/merge.ts"],"names":["deepNormalizeScriptCov","normalizeFunctionCov","normalizeProcessCov","normalizeRangeTree","normalizeScriptCov","RangeTree","mergeProcessCovs","processCovs","length","result","urlToScripts","Map","processCov","scriptCov","scriptCovs","get","url","undefined","set","push","scripts","values","mergeScriptCovs","merged","first","scriptId","rangeToFuncs","funcCov","functions","rootRange","stringifyFunctionRootRange","funcCovs","isBlockCoverage","mergeFunctionCovs","ranges","startOffset","toString","endOffset","functionName","trees","fromSortedRanges","mergedTree","mergeRangeTrees","toRanges","count","delta","tree","children","mergeRangeTreeChildren","start","end","RangeTreeWithParent","parentIndex","StartEvent","offset","compare","a","b","StartEventQueue","queue","nextIndex","pendingOffset","pendingTrees","fromParentTrees","parentTrees","startToTrees","parentTree","entries","child","sort","setPendingOffset","pushPendingTree","next","nextEvent","startEventQueue","parentToNested","openRange","event","nextChild","openRangeEnd","Math","max","insertChild","right","split","nested","matchingTrees","clear"],"mappings":"AAAA,SACEA,sBAAsB,EACtBC,oBAAoB,EACpBC,mBAAmB,EACnBC,kBAAkB,EAClBC,kBAAkB,QACb,cAAc;AACrB,SAASC,SAAS,QAAQ,eAAe;AAGzC;;;;;;;;;;CAUC,GACD,OAAO,SAASC,iBAAiBC,WAAsC;IACrE,IAAIA,YAAYC,MAAM,KAAK,GAAG;QAC5B,OAAO;YAACC,QAAQ,EAAE;QAAA;IACpB;IAEA,MAAMC,eAAyC,IAAIC;IACnD,KAAK,MAAMC,cAAcL,YAAa;QACpC,KAAK,MAAMM,aAAaD,WAAWH,MAAM,CAAE;YACzC,IAAIK,aAAsCJ,aAAaK,GAAG,CAACF,UAAUG,GAAG;YACxE,IAAIF,eAAeG,WAAW;gBAC5BH,aAAa,EAAE;gBACfJ,aAAaQ,GAAG,CAACL,UAAUG,GAAG,EAAEF;YAClC;YACAA,WAAWK,IAAI,CAACN;QAClB;IACF;IAEA,MAAMJ,SAAsB,EAAE;IAC9B,KAAK,MAAMW,WAAWV,aAAaW,MAAM,GAAI;QAC3C,+BAA+B;QAC/BZ,OAAOU,IAAI,CAACG,gBAAgBF;IAC9B;IACA,MAAMG,SAAqB;QAACd;IAAM;IAElCP,oBAAoBqB;IACpB,OAAOA;AACT;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASD,gBAAgBR,UAAoC;IAClE,IAAIA,WAAWN,MAAM,KAAK,GAAG;QAC3B,OAAOS;IACT,OAAO,IAAIH,WAAWN,MAAM,KAAK,GAAG;QAClC,MAAMe,SAAoBT,UAAU,CAAC,EAAE;QACvCd,uBAAuBuB;QACvB,OAAOA;IACT;IAEA,MAAMC,QAAmBV,UAAU,CAAC,EAAE;IACtC,MAAMW,WAAmBD,MAAMC,QAAQ;IACvC,MAAMT,MAAcQ,MAAMR,GAAG;IAE7B,MAAMU,eAA2C,IAAIf;IACrD,KAAK,MAAME,aAAaC,WAAY;QAClC,KAAK,MAAMa,WAAWd,UAAUe,SAAS,CAAE;YACzC,MAAMC,YAAoBC,2BAA2BH;YACrD,IAAII,WAAsCL,aAAaX,GAAG,CAACc;YAE3D,IAAIE,aAAad,aACf,iEAAiE;YACjE,uDAAuD;YACtD,CAACc,QAAQ,CAAC,EAAE,CAACC,eAAe,IAAIL,QAAQK,eAAe,EAAG;gBAC3DD,WAAW,EAAE;gBACbL,aAAaR,GAAG,CAACW,WAAWE;YAC9B,OAAO,IAAIA,QAAQ,CAAC,EAAE,CAACC,eAAe,IAAI,CAACL,QAAQK,eAAe,EAAE;gBAGlE;YACF;YACAD,SAASZ,IAAI,CAACQ;QAChB;IACF;IAEA,MAAMC,YAA2B,EAAE;IACnC,KAAK,MAAMG,YAAYL,aAAaL,MAAM,GAAI;QAC5C,gCAAgC;QAChCO,UAAUT,IAAI,CAACc,kBAAkBF;IACnC;IAEA,MAAMR,SAAoB;QAACE;QAAUT;QAAKY;IAAS;IACnDxB,mBAAmBmB;IACnB,OAAOA;AACT;AAEA;;;;;;;;;;CAUC,GACD,SAASO,2BAA2BH,OAA8B;IAChE,MAAME,YAAsBF,QAAQO,MAAM,CAAC,EAAE;IAC7C,OAAO,GAAGL,UAAUM,WAAW,CAACC,QAAQ,CAAC,IAAI,CAAC,EAAEP,UAAUQ,SAAS,CAACD,QAAQ,CAAC,KAAK;AACpF;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASH,kBAAkBF,QAAoC;IACpE,IAAIA,SAASvB,MAAM,KAAK,GAAG;QACzB,OAAOS;IACT,OAAO,IAAIc,SAASvB,MAAM,KAAK,GAAG;QAChC,MAAMe,SAAsBQ,QAAQ,CAAC,EAAE;QACvC9B,qBAAqBsB;QACrB,OAAOA;IACT;IAEA,MAAMe,eAAuBP,QAAQ,CAAC,EAAE,CAACO,YAAY;IAErD,MAAMC,QAAqB,EAAE;IAC7B,KAAK,MAAMZ,WAAWI,SAAU;QAC9B,iCAAiC;QACjC,gCAAgC;QAChCQ,MAAMpB,IAAI,CAACd,UAAUmC,gBAAgB,CAACb,QAAQO,MAAM;IACtD;IAEA,6BAA6B;IAC7B,MAAMO,aAAwBC,gBAAgBH;IAC9CpC,mBAAmBsC;IACnB,MAAMP,SAAqBO,WAAWE,QAAQ;IAC9C,MAAMX,kBAA2B,CAAEE,CAAAA,OAAO1B,MAAM,KAAK,KAAK0B,MAAM,CAAC,EAAE,CAACU,KAAK,KAAK,CAAA;IAE9E,MAAMrB,SAAsB;QAACe;QAAcJ;QAAQF;IAAe;IAClE,iCAAiC;IACjC,OAAOT;AACT;AAEA;;CAEC,GACD,SAASmB,gBAAgBH,KAA+B;IACtD,IAAIA,MAAM/B,MAAM,IAAI,GAAG;QACrB,OAAO+B,KAAK,CAAC,EAAE;IACjB;IACA,MAAMf,QAAmBe,KAAK,CAAC,EAAE;IACjC,IAAIM,QAAgB;IACpB,KAAK,MAAMC,QAAQP,MAAO;QACxBM,SAASC,KAAKD,KAAK;IACrB;IACA,MAAME,WAAwBC,uBAAuBT;IACrD,OAAO,IAAIlC,UAAUmB,MAAMyB,KAAK,EAAEzB,MAAM0B,GAAG,EAAEL,OAAOE;AACtD;AAEA,IAAA,AAAMI,sBAAN,MAAMA;IACKC,YAAoB;IACpBN,KAAgB;IAEzB,YAAYM,WAAmB,EAAEN,IAAe,CAAE;QAChD,IAAI,CAACM,WAAW,GAAGA;QACnB,IAAI,CAACN,IAAI,GAAGA;IACd;AACF;AAEA,IAAA,AAAMO,aAAN,MAAMA;IACKC,OAAe;IACff,MAA6B;IAEtC,YAAYe,MAAc,EAAEf,KAA4B,CAAE;QACxD,IAAI,CAACe,MAAM,GAAGA;QACd,IAAI,CAACf,KAAK,GAAGA;IACf;IAEA,OAAOgB,QAAQC,CAAa,EAAEC,CAAa,EAAU;QACnD,OAAOD,EAAEF,MAAM,GAAGG,EAAEH,MAAM;IAC5B;AACF;AAEA,IAAA,AAAMI,kBAAN,MAAMA;IACaC,MAAoB;IAC7BC,UAAkB;IAClBC,cAAsB;IACtBC,aAAgD;IAExD,YAAoBH,KAAmB,CAAE;QACvC,IAAI,CAACA,KAAK,GAAGA;QACb,IAAI,CAACC,SAAS,GAAG;QACjB,IAAI,CAACC,aAAa,GAAG;QACrB,IAAI,CAACC,YAAY,GAAG7C;IACtB;IAEA,OAAO8C,gBAAgBC,WAAqC,EAAmB;QAC7E,MAAMC,eAAmD,IAAItD;QAC7D,KAAK,MAAM,CAACyC,aAAac,WAAW,IAAIF,YAAYG,OAAO,GAAI;YAC7D,KAAK,MAAMC,SAASF,WAAWnB,QAAQ,CAAE;gBACvC,IAAIR,QAA2C0B,aAAalD,GAAG,CAACqD,MAAMnB,KAAK;gBAC3E,IAAIV,UAAUtB,WAAW;oBACvBsB,QAAQ,EAAE;oBACV0B,aAAa/C,GAAG,CAACkD,MAAMnB,KAAK,EAAEV;gBAChC;gBACAA,MAAMpB,IAAI,CAAC,IAAIgC,oBAAoBC,aAAagB;YAClD;QACF;QACA,MAAMT,QAAsB,EAAE;QAC9B,KAAK,MAAM,CAACxB,aAAaI,MAAM,IAAI0B,aAAc;YAC/CN,MAAMxC,IAAI,CAAC,IAAIkC,WAAWlB,aAAaI;QACzC;QACAoB,MAAMU,IAAI,CAAChB,WAAWE,OAAO;QAC7B,OAAO,IAAIG,gBAAgBC;IAC7B;IAEAW,iBAAiBhB,MAAc,EAAQ;QACrC,IAAI,CAACO,aAAa,GAAGP;IACvB;IAEAiB,gBAAgBzB,IAAyB,EAAQ;QAC/C,IAAI,IAAI,CAACgB,YAAY,KAAK7C,WAAW;YACnC,IAAI,CAAC6C,YAAY,GAAG,EAAE;QACxB;QACA,IAAI,CAACA,YAAY,CAAC3C,IAAI,CAAC2B;IACzB;IAEA0B,OAA+B;QAC7B,MAAMV,eAAkD,IAAI,CAACA,YAAY;QACzE,MAAMW,YAAoC,IAAI,CAACd,KAAK,CAAC,IAAI,CAACC,SAAS,CAAC;QACpE,IAAIE,iBAAiB7C,WAAW;YAC9B,IAAI,CAAC2C,SAAS;YACd,OAAOa;QACT,OAAO,IAAIA,cAAcxD,WAAW;YAClC,IAAI,CAAC6C,YAAY,GAAG7C;YACpB,OAAO,IAAIoC,WAAW,IAAI,CAACQ,aAAa,EAAEC;QAC5C,OAAO;YACL,IAAI,IAAI,CAACD,aAAa,GAAGY,UAAUnB,MAAM,EAAE;gBACzC,IAAI,CAACQ,YAAY,GAAG7C;gBACpB,OAAO,IAAIoC,WAAW,IAAI,CAACQ,aAAa,EAAEC;YAC5C,OAAO;gBACL,IAAI,IAAI,CAACD,aAAa,KAAKY,UAAUnB,MAAM,EAAE;oBAC3C,IAAI,CAACQ,YAAY,GAAG7C;oBACpB,KAAK,MAAM6B,QAAQgB,aAAc;wBAC/BW,UAAUlC,KAAK,CAACpB,IAAI,CAAC2B;oBACvB;gBACF;gBACA,IAAI,CAACc,SAAS;gBACd,OAAOa;YACT;QACF;IACF;AACF;AAEA,SAASzB,uBAAuBgB,WAAqC;IACnE,MAAMvD,SAAsB,EAAE;IAC9B,MAAMiE,kBAAmChB,gBAAgBK,eAAe,CAACC;IACzE,MAAMW,iBAA2C,IAAIhE;IACrD,IAAIiE;IAEJ,MAAO,KAAM;QACX,MAAMC,QAAgCH,gBAAgBF,IAAI;QAC1D,IAAIK,UAAU5D,WAAW;YACvB;QACF;QAEA,IAAI2D,cAAc3D,aAAa2D,UAAU1B,GAAG,IAAI2B,MAAMvB,MAAM,EAAE;YAC5D7C,OAAOU,IAAI,CAAC2D,UAAUF,WAAWD;YACjCC,YAAY3D;QACd;QAEA,IAAI2D,cAAc3D,WAAW;YAC3B,IAAI8D,eAAuBF,MAAMvB,MAAM,GAAG;YAC1C,KAAK,MAAM,EAACF,WAAW,EAAEN,IAAI,EAAC,IAAI+B,MAAMtC,KAAK,CAAE;gBAC7CwC,eAAeC,KAAKC,GAAG,CAACF,cAAcjC,KAAKI,GAAG;gBAC9CgC,YAAYP,gBAAgBvB,aAAaN;YAC3C;YACA4B,gBAAgBJ,gBAAgB,CAACS;YACjCH,YAAY;gBAAC3B,OAAO4B,MAAMvB,MAAM;gBAAEJ,KAAK6B;YAAY;QACrD,OAAO;YACL,KAAK,MAAM,EAAC3B,WAAW,EAAEN,IAAI,EAAC,IAAI+B,MAAMtC,KAAK,CAAE;gBAC7C,IAAIO,KAAKI,GAAG,GAAG0B,UAAU1B,GAAG,EAAE;oBAC5B,MAAMiC,QAAmBrC,KAAKsC,KAAK,CAACR,UAAU1B,GAAG;oBACjDwB,gBAAgBH,eAAe,CAAC,IAAIpB,oBAAoBC,aAAa+B;gBACvE;gBACAD,YAAYP,gBAAgBvB,aAAaN;YAC3C;QACF;IACF;IACA,IAAI8B,cAAc3D,WAAW;QAC3BR,OAAOU,IAAI,CAAC2D,UAAUF,WAAWD;IACnC;IAEA,OAAOlE;AACT;AAEA,SAASyE,YAAYP,cAAwC,EAAEvB,WAAmB,EAAEN,IAAe;IACjG,IAAIuC,SAAkCV,eAAe5D,GAAG,CAACqC;IACzD,IAAIiC,WAAWpE,WAAW;QACxBoE,SAAS,EAAE;QACXV,eAAezD,GAAG,CAACkC,aAAaiC;IAClC;IACAA,OAAOlE,IAAI,CAAC2B;AACd;AAEA,SAASgC,UAAUF,SAAgB,EAAED,cAAwC;IAC3E,MAAMW,gBAA6B,EAAE;IAErC,KAAK,MAAMD,UAAUV,eAAetD,MAAM,GAAI;QAC5C,IAAIgE,OAAO7E,MAAM,KAAK,KAAK6E,MAAM,CAAC,EAAE,CAACpC,KAAK,KAAK2B,UAAU3B,KAAK,IAAIoC,MAAM,CAAC,EAAE,CAACnC,GAAG,KAAK0B,UAAU1B,GAAG,EAAE;YACjGoC,cAAcnE,IAAI,CAACkE,MAAM,CAAC,EAAE;QAC9B,OAAO;YACLC,cAAcnE,IAAI,CAAC,IAAId,UACrBuE,UAAU3B,KAAK,EACf2B,UAAU1B,GAAG,EACb,GACAmC;QAEJ;IACF;IACAV,eAAeY,KAAK;IACpB,OAAO7C,gBAAgB4C;AACzB"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/normalize.js

@@ -0,0 +1,73 @@
+import { compareFunctionCovs, compareRangeCovs, compareScriptCovs } from "./compare";
+import { RangeTree } from "./range-tree";
+/**
+ * Normalizes a process coverage.
+ *
+ * Sorts the scripts alphabetically by `url`.
+ * Reassigns script ids: the script at index `0` receives `"0"`, the script at
+ * index `1` receives `"1"` etc.
+ * This does not normalize the script coverages.
+ *
+ * @param processCov Process coverage to normalize.
+ */ export function normalizeProcessCov(processCov) {
+    processCov.result.sort(compareScriptCovs);
+    for (const [scriptId, scriptCov] of processCov.result.entries()){
+        scriptCov.scriptId = scriptId.toString(10);
+    }
+}
+/**
+ * Normalizes a process coverage deeply.
+ *
+ * Normalizes the script coverages deeply, then normalizes the process coverage
+ * itself.
+ *
+ * @param processCov Process coverage to normalize.
+ */ export function deepNormalizeProcessCov(processCov) {
+    for (const scriptCov of processCov.result){
+        deepNormalizeScriptCov(scriptCov);
+    }
+    normalizeProcessCov(processCov);
+}
+/**
+ * Normalizes a script coverage.
+ *
+ * Sorts the function by root range (pre-order sort).
+ * This does not normalize the function coverages.
+ *
+ * @param scriptCov Script coverage to normalize.
+ */ export function normalizeScriptCov(scriptCov) {
+    scriptCov.functions.sort(compareFunctionCovs);
+}
+/**
+ * Normalizes a script coverage deeply.
+ *
+ * Normalizes the function coverages deeply, then normalizes the script coverage
+ * itself.
+ *
+ * @param scriptCov Script coverage to normalize.
+ */ export function deepNormalizeScriptCov(scriptCov) {
+    for (const funcCov of scriptCov.functions){
+        normalizeFunctionCov(funcCov);
+    }
+    normalizeScriptCov(scriptCov);
+}
+/**
+ * Normalizes a function coverage.
+ *
+ * Sorts the ranges (pre-order sort).
+ * TODO: Tree-based normalization of the ranges.
+ *
+ * @param funcCov Function coverage to normalize.
+ */ export function normalizeFunctionCov(funcCov) {
+    funcCov.ranges.sort(compareRangeCovs);
+    const tree = RangeTree.fromSortedRanges(funcCov.ranges);
+    normalizeRangeTree(tree);
+    funcCov.ranges = tree.toRanges();
+}
+/**
+ * @internal
+ */ export function normalizeRangeTree(tree) {
+    tree.normalize();
+}
+
+//# sourceMappingURL=normalize.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/normalize.ts"],"names":["compareFunctionCovs","compareRangeCovs","compareScriptCovs","RangeTree","normalizeProcessCov","processCov","result","sort","scriptId","scriptCov","entries","toString","deepNormalizeProcessCov","deepNormalizeScriptCov","normalizeScriptCov","functions","funcCov","normalizeFunctionCov","ranges","tree","fromSortedRanges","normalizeRangeTree","toRanges","normalize"],"mappings":"AAAA,SAASA,mBAAmB,EAAEC,gBAAgB,EAAEC,iBAAiB,QAAQ,YAAY;AACrF,SAASC,SAAS,QAAQ,eAAe;AAGzC;;;;;;;;;CASC,GACD,OAAO,SAASC,oBAAoBC,UAAsB;IACxDA,WAAWC,MAAM,CAACC,IAAI,CAACL;IACvB,KAAK,MAAM,CAACM,UAAUC,UAAU,IAAIJ,WAAWC,MAAM,CAACI,OAAO,GAAI;QAC/DD,UAAUD,QAAQ,GAAGA,SAASG,QAAQ,CAAC;IACzC;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASC,wBAAwBP,UAAsB;IAC5D,KAAK,MAAMI,aAAaJ,WAAWC,MAAM,CAAE;QACzCO,uBAAuBJ;IACzB;IACAL,oBAAoBC;AACtB;AAEA;;;;;;;CAOC,GACD,OAAO,SAASS,mBAAmBL,SAAoB;IACrDA,UAAUM,SAAS,CAACR,IAAI,CAACP;AAC3B;AAEA;;;;;;;CAOC,GACD,OAAO,SAASa,uBAAuBJ,SAAoB;IACzD,KAAK,MAAMO,WAAWP,UAAUM,SAAS,CAAE;QACzCE,qBAAqBD;IACvB;IACAF,mBAAmBL;AACrB;AAEA;;;;;;;CAOC,GACD,OAAO,SAASQ,qBAAqBD,OAAoB;IACvDA,QAAQE,MAAM,CAACX,IAAI,CAACN;IACpB,MAAMkB,OAAkBhB,UAAUiB,gBAAgB,CAACJ,QAAQE,MAAM;IACjEG,mBAAmBF;IACnBH,QAAQE,MAAM,GAAGC,KAAKG,QAAQ;AAChC;AAEA;;CAEC,GACD,OAAO,SAASD,mBAAmBF,IAAe;IAChDA,KAAKI,SAAS;AAChB"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/range-tree.js

@@ -0,0 +1,151 @@
+export class RangeTree {
+    start;
+    end;
+    delta;
+    children;
+    constructor(start, end, delta, children){
+        this.start = start;
+        this.end = end;
+        this.delta = delta;
+        this.children = children;
+    }
+    /**
+   * @precodition `ranges` are well-formed and pre-order sorted
+   */ static fromSortedRanges(ranges) {
+        let root;
+        // Stack of parent trees and parent counts.
+        const stack = [];
+        for (const range of ranges){
+            const node = new RangeTree(range.startOffset, range.endOffset, range.count, []);
+            if (root === undefined) {
+                root = node;
+                stack.push([
+                    node,
+                    range.count
+                ]);
+                continue;
+            }
+            let parent;
+            let parentCount;
+            while(true){
+                [parent, parentCount] = stack[stack.length - 1];
+                // assert: `top !== undefined` (the ranges are sorted)
+                if (range.startOffset < parent.end) {
+                    break;
+                } else {
+                    stack.pop();
+                }
+            }
+            node.delta -= parentCount;
+            parent.children.push(node);
+            stack.push([
+                node,
+                range.count
+            ]);
+        }
+        return root;
+    }
+    normalize() {
+        const children = [];
+        let curEnd;
+        let head;
+        const tail = [];
+        for (const child of this.children){
+            if (head === undefined) {
+                head = child;
+            } else if (child.delta === head.delta && child.start === curEnd) {
+                tail.push(child);
+            } else {
+                endChain();
+                head = child;
+            }
+            curEnd = child.end;
+        }
+        if (head !== undefined) {
+            endChain();
+        }
+        if (children.length === 1) {
+            const child = children[0];
+            if (child.start === this.start && child.end === this.end) {
+                this.delta += child.delta;
+                this.children = child.children;
+                // `.lazyCount` is zero for both (both are after normalization)
+                return;
+            }
+        }
+        this.children = children;
+        function endChain() {
+            if (tail.length !== 0) {
+                head.end = tail[tail.length - 1].end;
+                for (const tailTree of tail){
+                    for (const subChild of tailTree.children){
+                        subChild.delta += tailTree.delta - head.delta;
+                        head.children.push(subChild);
+                    }
+                }
+                tail.length = 0;
+            }
+            head.normalize();
+            children.push(head);
+        }
+    }
+    /**
+   * @precondition `tree.start < value && value < tree.end`
+   * @return RangeTree Right part
+   */ split(value) {
+        let leftChildLen = this.children.length;
+        let mid;
+        // TODO(perf): Binary search (check overhead)
+        for(let i = 0; i < this.children.length; i++){
+            const child = this.children[i];
+            if (child.start < value && value < child.end) {
+                mid = child.split(value);
+                leftChildLen = i + 1;
+                break;
+            } else if (child.start >= value) {
+                leftChildLen = i;
+                break;
+            }
+        }
+        const rightLen = this.children.length - leftChildLen;
+        const rightChildren = this.children.splice(leftChildLen, rightLen);
+        if (mid !== undefined) {
+            rightChildren.unshift(mid);
+        }
+        const result = new RangeTree(value, this.end, this.delta, rightChildren);
+        this.end = value;
+        return result;
+    }
+    /**
+   * Get the range coverages corresponding to the tree.
+   *
+   * The ranges are pre-order sorted.
+   */ toRanges() {
+        const ranges = [];
+        // Stack of parent trees and counts.
+        const stack = [
+            [
+                this,
+                0
+            ]
+        ];
+        while(stack.length > 0){
+            const [cur, parentCount] = stack.pop();
+            const count = parentCount + cur.delta;
+            ranges.push({
+                startOffset: cur.start,
+                endOffset: cur.end,
+                count
+            });
+            for(let i = cur.children.length - 1; i >= 0; i--){
+                stack.push([
+                    cur.children[i],
+                    count
+                ]);
+            }
+        }
+        return ranges;
+    }
+}
+
+//# sourceMappingURL=range-tree.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/range-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/range-tree.ts"],"names":["RangeTree","start","end","delta","children","fromSortedRanges","ranges","root","stack","range","node","startOffset","endOffset","count","undefined","push","parent","parentCount","length","pop","normalize","curEnd","head","tail","child","endChain","tailTree","subChild","split","value","leftChildLen","mid","i","rightLen","rightChildren","splice","unshift","result","toRanges","cur"],"mappings":"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"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../src/web/frontend/node_modules/@bcoe/v8-coverage/src/lib/types.ts"],"names":[],"mappings":"AAqBA,WAIC"}